implab/gradle-container-plugin Commit - r4:00ef236c472b

Reworked ImageName, added imageName property to the project extension, added TagImage task.

cin -

r4:00ef236c472b v1.1 default

parent child

Context file:

r4:00ef236c472b

Collapse all files

container/src/main/java/org/implab/gradle/containers/ImageName.java created 644 +66 0

@@ -0,0 +1,66
	1	package org.implab.gradle.containers;
	2
	3	import java.io.Serializable;
	4	import java.util.Optional;
	5
	6	public class ImageName implements Serializable {
	7
	8	private static final long serialVersionUID = -1990105923537254552L;
	9
	10	final String authority;
	11
	12	final String name;
	13
	14	final String tag;
	15
	16	public ImageName() {
	17	name = null;
	18	authority = null;
	19	tag = null;
	20	}
	21
	22	private ImageName(String authority, String name, String tag) {
	23	this.authority = authority;
	24	this.name = name;
	25	this.tag = tag;
	26	}
	27
	28	public String getAuthority() {
	29	return authority;
	30	}
	31
	32	public ImageName authority(String authority) {
	33	return new ImageName(authority, name, tag);
	34	}
	35
	36	public String getName() {
	37	return name;
	38	}
	39
	40	public ImageName name(String name) {
	41	return new ImageName(authority, name, tag);
	42	}
	43
	44	public String getTag() {
	45	return tag;
	46	}
	47
	48	public ImageName tag(String tag) {
	49	return new ImageName(authority, name, tag);
	50	}
	51
	52	public ImageName copy() {
	53	return new ImageName(authority, name, tag);
	54	}
	55
	56	@Override
	57	public String toString() {
	58	StringBuilder sb = new StringBuilder();
	59
	60	Optional.ofNullable(authority).ifPresent(s -> sb.append(s).append("/"));
	61	Optional.ofNullable(name).ifPresent(s -> sb.append(s));
	62	Optional.ofNullable(tag).ifPresent(s-> sb.append(":").append(s));
	63
	64	return sb.toString();
	65	}
	66	}

container/src/main/java/org/implab/gradle/containers/tasks/TagImage.java created 644 +42 0

@@ -0,0 +1,42
	1	package org.implab.gradle.containers.tasks;
	2
	3	import java.util.List;
	4	import java.util.concurrent.Callable;
	5
	6	import org.gradle.api.provider.ListProperty;
	7	import org.gradle.api.provider.Property;
	8	import org.gradle.api.tasks.Input;
	9	import org.gradle.api.tasks.Optional;
	10	import org.implab.gradle.containers.ImageName;
	11
	12	public abstract class TagImage extends CliTask {
	13
	14	@Input
	15	public abstract Property<ImageName> getSrcImage();
	16
	17	@Input
	18	public abstract Property<ImageName> getDestImage();
	19
	20	@Input
	21	@Optional
	22	public abstract Property<String> getTransport();
	23
	24	@Input
	25	@Optional
	26	public abstract ListProperty<String> getOptions();
	27
	28	public TagImage option(Callable<String> provider) {
	29	getOptions().add(getProject().provider(provider));
	30	return this;
	31	}
	32
	33	@Override
	34	protected void preparingCommand(List<String> commandLine) {
	35	super.preparingCommand(commandLine);
	36
	37	commandLine.add("tag");
	38	commandLine.addAll(getOptions().get());
	39	commandLine.add(getSrcImage().get().toString());
	40	commandLine.add(getDestImage().get().toString());
	41	}
	42	}

container/build.gradle +3 -10

             plugins {
                 id "java-gradle-plugin"
-                id "com.gradle.plugin-publish" version "0.15.0"
+                id "com.gradle.plugin-publish" version "0.16.0"
             }
             }
             gradlePlugin {
-                website = 'https://code.implab.org/implab/gradle-container-plugin'
-                vcsUrl = 'https://code.implab.org/implab/gradle-container-plugin'
             	plugins {
             		containerPlugin {
             			id = 'org.implab.gradle-container'
+                        displayName = "Container building plugin"
+                        description = 'Build and publish container images with docker or podman. Simple wrapper around cli.'
             			implementationClass = 'org.implab.gradle.containers.ContainerPlugin'
             		}
             	}
                 vcsUrl = 'https://code.implab.org/implab/gradle-container-plugin'
                 tags = ['containers', 'image', 'docker', 'podman']
-                plugins {
-                    containerPlugin {
-            			description = 'Build and publish container images with docker or podman'
             }

container/gradle.properties +1 -1

@@ -1,2 +1,2
1	group=org.implab.gradle	1	group=org.implab.gradle
2	version=1.0 No newline at end of file	2	version=1.1 No newline at end of file

container/src/main/java/org/implab/gradle/containers/ContainerExtension.java +37 -1

             package org.implab.gradle.containers;
+            import java.util.Optional;
+            import org.gradle.api.Project;
             import org.gradle.api.file.DirectoryProperty;
             import org.gradle.api.file.ProjectLayout;
             import org.gradle.api.file.RegularFileProperty;
             import org.gradle.api.model.ObjectFactory;
             import org.gradle.api.provider.Property;
+            import org.gradle.api.provider.Provider;
             public class ContainerExtension {
                 private final Property<String> imageGroup;
+                private final Property<String> imageShortName;
+                private final Property<String> imageTag;
+                private final Property<ImageName> imageName;
                 private final DirectoryProperty contextDir;
                 private final RegularFileProperty imageIdFile;
-                public ContainerExtension(ObjectFactory factory, ProjectLayout layout) {
+                public ContainerExtension(ObjectFactory factory, ProjectLayout layout, Project project) {
                     contextDir = factory.directoryProperty();
                     contextDir.convention(layout.getBuildDirectory().dir("context"));
                     imageAuthority = factory.property(String.class);
                     imageGroup = factory.property(String.class);
+                    imageShortName = factory.property(String.class);
+                    imageShortName.convention(project.getName());
+                    imageTag = factory.property(String.class);
+                    imageTag.set(project
+                            .provider(() -> Optional.ofNullable(project.getVersion()).map(v -> v.toString()).orElse("latest")));
+                    Provider<String> imageRepository = imageGroup.map(g -> g + "/" + imageShortName.get()).orElse(imageShortName);
+                    imageName = factory.property(ImageName.class);
+                    imageName.convention(project.provider(
+                            () -> new ImageName().authority(imageAuthority.get()).name(imageRepository.get()).tag(imageTag.get())));
                 }
                 public Property<String> getCliCmd() {
                 public Property<String> getImageGroup() {
                     return imageGroup;
                 }
+                public Property<ImageName> getImageName() {
+                    return imageName;
+                }
+                public Property<String> getImageShortName() {
+                    return imageShortName;
+                }
+                public ImageName createImageName() {
+                    return new ImageName();
+                }
             }

container/src/main/java/org/implab/gradle/containers/ContainerPlugin.java +6 -13

             package org.implab.gradle.containers;
-            import java.util.Optional;
             import org.gradle.api.Plugin;
             import org.gradle.api.Project;
             import org.gradle.api.artifacts.Dependency;
             import org.gradle.api.file.ProjectLayout;
             import org.gradle.api.model.ObjectFactory;
             import org.gradle.api.plugins.ExtraPropertiesExtension;
-            import org.gradle.api.provider.Provider;
             import org.gradle.api.tasks.Copy;
             import org.gradle.api.tasks.Delete;
             import org.gradle.api.tasks.TaskProvider;
             import org.implab.gradle.containers.tasks.BuildImage;
             import org.implab.gradle.containers.tasks.PushImage;
             import org.implab.gradle.containers.tasks.SaveImage;
+            import org.implab.gradle.containers.tasks.TagImage;
             public class ContainerPlugin implements Plugin<Project> {
                 public void apply(Project project) {
                     ObjectFactory factory = project.getObjects();
                     ProjectLayout layout = project.getLayout();
-                    containerExtension = new ContainerExtension(factory, layout);
+                    containerExtension = new ContainerExtension(factory, layout, project);
                     containerExtension.getImageAuthority()
                             .convention(project.provider(() -> (String) project.getProperties().get("imagesAuthority")));
                     extras.set(BuildImage.class.getSimpleName(), BuildImage.class);
                     extras.set(PushImage.class.getSimpleName(), PushImage.class);
                     extras.set(SaveImage.class.getSimpleName(), SaveImage.class);
+                    extras.set(TagImage.class.getSimpleName(), TagImage.class);
                     project.getConfigurations().create(Dependency.DEFAULT_CONFIGURATION, c -> {
                         c.setCanBeConsumed(true);
                         t.getContextDirectory().set(containerExtension.getContextDirectory());
                         t.getImageIdFile().set(containerExtension.getImageIdFile());
-                        Provider<String> imageName = containerExtension.getImageGroup().map(g -> g + "/" + project.getName())
+                        t.getImageName().set(containerExtension.getImageName());
-                                .orElse(project.getName());
-                        t.getImageAuthority().set(containerExtension.getImageAuthority());
-                        t.getImageQName().convention(imageName);
-                        t.getImageVersion()
-                                .convention(Optional.ofNullable(project.getVersion()).map(v -> v.toString()).orElse("latest"));
                     });
                     project.getTasks().register("clean", Delete.class, t -> {
                     project.getTasks().register("pushImage", PushImage.class, t -> {
                         t.dependsOn(buildImageTask);
-                        t.getSrcImage().set(buildImageTask.flatMap(b -> b.getImageTag()));
+                        t.getImageName().set(buildImageTask.flatMap(b -> b.getImageName()));
                     });
                     project.getTasks().register("saveImage", SaveImage.class, t -> {
                         t.dependsOn(buildImageTask);
-                        t.getImage().set(buildImageTask.flatMap(b -> b.getImageTag()));
+                        t.getImage().set(buildImageTask.flatMap(b -> b.getImageName()));
                     });
                     project.getArtifacts().add(Dependency.DEFAULT_CONFIGURATION, buildImageTask.flatMap(x -> x.getImageIdFile()), t -> {

container/src/main/java/org/implab/gradle/containers/tasks/BuildImage.java +3 -22

             import org.gradle.api.file.DirectoryProperty;
             import org.gradle.api.file.RegularFileProperty;
             import org.gradle.api.provider.Property;
-            import org.gradle.api.provider.Provider;
             import org.gradle.api.tasks.Input;
             import org.gradle.api.tasks.InputDirectory;
-            import org.gradle.api.tasks.Internal;
             import org.gradle.api.tasks.OutputFile;
             import org.gradle.api.tasks.SkipWhenEmpty;
             import org.implab.gradle.Utils;
-            import org.implab.gradle.containers.ImageTag;
+            import org.implab.gradle.containers.ImageName;
             public abstract class BuildImage extends CliTask {
                 @InputDirectory
                 @SkipWhenEmpty
                 public abstract DirectoryProperty getContextDirectory();
-                @Internal
-                public abstract Property<String> getImageQName();
-                @Internal
-                public abstract Property<String> getImageVersion();
-                @Internal
-                public abstract Property<String> getImageAuthority();
                 @Input
-                public Provider<ImageTag> getImageTag() {
+                public abstract Property<ImageName> getImageName();
-                    return getProject().provider(() -> {
-                        ImageTag tag = new ImageTag();
-                        tag.setQName(getImageQName().getOrNull());
-                        tag.setAuthority(getImageAuthority().getOrNull());
-                        tag.setVersion(getImageVersion().getOrNull());
-                        return tag;
-                    });
                 @OutputFile
                 public abstract RegularFileProperty getImageIdFile();
                     super.preparingCommand(commandLine);
                     commandLine.addAll(List.of("build", ".", "-q", "-t"));
-                    commandLine.add(getImageTag().get().toString());
+                    commandLine.add(getImageName().get().toString());
                 }
                 @Override

container/src/main/java/org/implab/gradle/containers/tasks/PushImage.java +3 -16

             import org.gradle.api.provider.ListProperty;
             import org.gradle.api.provider.Property;
-            import org.gradle.api.provider.Provider;
             import org.gradle.api.tasks.Input;
-            import org.gradle.api.tasks.Internal;
             import org.gradle.api.tasks.Optional;
-            import org.implab.gradle.containers.ImageTag;
+            import org.implab.gradle.containers.ImageName;
             public abstract class PushImage extends CliTask {
                 @Input
-                public abstract Property<ImageTag> getSrcImage();
+                public abstract Property<ImageName> getImageName();
-                @Input
-                @Optional
-                public abstract Property<ImageTag> getDestImage();
                 @Input
                 @Optional
                     return this;
                 }
-                @Internal
-                public Provider<String> getDestination() {
-                    return getDestImage().flatMap(tag -> getTransport().orElse("").map(t -> t + tag.toString()));
                 @Override
                 protected void preparingCommand(List<String> commandLine) {
                     super.preparingCommand(commandLine);
                     commandLine.add("push");
                     commandLine.addAll(getOptions().get());
-                    commandLine.add(getSrcImage().get().toString());
+                    commandLine.add(getImageName().get().toString());
-                    if (getDestination().isPresent())
-                        commandLine.add(getDestination().get());
                 }
             }

container/src/main/java/org/implab/gradle/containers/tasks/SaveImage.java +2 -2

             import org.gradle.api.tasks.OutputFile;
             import org.gradle.api.tasks.TaskExecutionException;
             import org.implab.gradle.Utils;
-            import org.implab.gradle.containers.ImageTag;
+            import org.implab.gradle.containers.ImageName;
             public abstract class SaveImage extends CliTask {
                 @Input
-                public abstract Property<ImageTag> getImage();
+                public abstract Property<ImageName> getImage();
                 @OutputFile
                 public Provider<RegularFile> getArchiveFile() {

readme.md +28 -1

@@ -5,7 +5,7
5	```gradle	5	```gradle
6		6
7	plugins {	7	plugins {
8	id 'org.implab.gradle-container' version ~~"1.0"~~	8	id 'org.implab.gradle-container' version '1.1'
9	}	9	}
10		10
11	container {	11	container {
@@ -81,3 +81,30 The task pushes the image to the remote
81		81
82	The copy task, it prepares the build context. Use it to customize	82	The copy task, it prepares the build context. Use it to customize
83	the build context.	83	the build context.
		84
		85	### tagImage
		86
		87	since: 1.1
		88
		89	```gradle
		90	task tagLatest(type: TagImage) {
		91	srcImage = container.imageName
		92	destImage = container.imageName.map { it.tag("latest") }
		93	}
		94
		95	```
		96
		97	## Changes
		98
		99	### 1.1
		100
		101	Warning! This version isn't fully backward compatible with 1.0 version.
		102
		103	* Added `TagImage` task type
		104	* `ImageTag` class is replaced with `ImageName` class
		105	* `BuildImage`, `PushImage` tasks are now accepting only `imageName` property
		106	* Added `imageName`, `imageShortName`, `imageTag` properties to `container` extension
		107
		108	### 1.0
		109
		110	Initial release. Default tasks to build and publish container images.

container/src/main/java/org/implab/gradle/containers/ImageTag.java removed 0 -74

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages