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"
             }
             repositories {
             	mavenCentral()
             }
             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'
             		}
             	}
             }
             pluginBundle {
                 website = 'https://code.implab.org/implab/gradle-container-plugin'
                 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> cliCmd;
                 private final Property<String> imageAuthority;
                 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"));
                     imageIdFile = factory.fileProperty();
                     imageIdFile.convention(layout.getBuildDirectory().file("imageId"));
                     cliCmd = factory.property(String.class);
                     cliCmd.set("docker");
                     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() {
                     return cliCmd;
                 }
                 public void setCliCmd(String cliCmd) {
                     this.cliCmd.set(cliCmd);
                 }
                 public DirectoryProperty getContextDirectory() {
                     return contextDir;
                 }
                 public RegularFileProperty getImageIdFile() {
                     return imageIdFile;
                 }
                 public Property<String> getImageAuthority() {
                     return imageAuthority;
                 }
                 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 static final String BUILD_GROUP = "build";
                 public static final String CONTAINER_EXTENSION_NAME = "container";
                 public static final String ARCHIVE_CONFIGURATION = "archive";
                 private ContainerExtension containerExtension;
                 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")));
                     containerExtension.getImageGroup()
                             .convention(project.provider(() -> (String) project.getProperties().get("imagesGroup")));
                     project.getExtensions().add(CONTAINER_EXTENSION_NAME, containerExtension);
                     ExtraPropertiesExtension extras = project.getExtensions().getExtraProperties();
                     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);
                         c.setCanBeResolved(false);
                     });
                     project.getConfigurations().create(ARCHIVE_CONFIGURATION, c -> {
                         c.setCanBeConsumed(true);
                         c.setCanBeResolved(false);
                     });
                     TaskProvider<Copy> processResourcesTask = project.getTasks().register("processResources", Copy.class, t -> {
                         t.setGroup(BUILD_GROUP);
                         t.from(layout.getProjectDirectory().dir("src/main"));
                         t.into(containerExtension.getContextDirectory());
                     });
                     TaskProvider<BuildImage> buildImageTask = project.getTasks().register("buildImage", BuildImage.class, t -> {
                         t.setGroup(BUILD_GROUP);
                         t.dependsOn(processResourcesTask);
                         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 -> {
                         t.delete(layout.getBuildDirectory());
                     });
                     project.getTasks().register("build", t -> {
                         t.setGroup(BUILD_GROUP);
                         t.dependsOn(buildImageTask);
                     });
                     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 -> {
                         t.builtBy(buildImageTask);
                     });
                 }
             }

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

             package org.implab.gradle.containers.tasks;
             import java.util.List;
             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();
                 public BuildImage() {
                     setWorkingDir(getContextDirectory().getAsFile());
                 }
                 @Override
                 protected void preparingCommand(List<String> commandLine) {
                     super.preparingCommand(commandLine);
                     commandLine.addAll(List.of("build", ".", "-q", "-t"));
-                    commandLine.add(getImageTag().get().toString());
+                    commandLine.add(getImageName().get().toString());
                 }
                 @Override
                 protected void processStarted(Process p) {
                     Utils.redirectIO(p.getInputStream(), getImageIdFile().get().getAsFile());
                 }
             }

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

             package org.implab.gradle.containers.tasks;
             import java.util.List;
             import java.util.concurrent.Callable;
             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
                 public abstract Property<String> getTransport();
                 @Input
                 @Optional
                 public abstract ListProperty<String> getOptions();
                 public PushImage option(Callable<String> provider) {
                     getOptions().add(getProject().provider(provider));
                     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

             package org.implab.gradle.containers.tasks;
             import java.util.ArrayList;
             import java.util.List;
             import java.util.Optional;
             import org.gradle.api.file.DirectoryProperty;
             import org.gradle.api.file.RegularFile;
             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.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() {
                     return getDestinationDirectory().file(getArchiveFileName());
                 }
                 @Internal
                 public abstract DirectoryProperty getDestinationDirectory();
                 @Internal
                 public abstract Property<String> getArchiveFileName();
                 @Internal
                 public abstract Property<String> getArchiveBaseName();
                 @Internal
                 public abstract Property<String> getArchiveVersion();
                 @Internal
                 public abstract Property<String> getArchiveClassifier();
                 @Internal
                 public abstract Property<String> getArchiveExtension();
                 public SaveImage() {
                     getArchiveFileName().convention(getProject().provider(this::conventionalArchiveFileName));
                     getArchiveBaseName().convention(getProject().provider(this::conventionalArchiveBaseName));
                     getArchiveVersion().convention(getProject().provider(() -> getProject().getVersion()).map(x -> x.toString()));
                     getDestinationDirectory().convention(getProject().getLayout().getBuildDirectory());
                     getArchiveExtension().convention("tar");
                 }
                 private String conventionalArchiveBaseName() {
                     ArrayList<String> parts = new ArrayList<>();
                     Optional.of(getProject().getGroup()).map(x -> x.toString()).ifPresent(parts::add);
                     parts.add(getProject().getName());
                     return String.join("-", parts);
                 }
                 private String conventionalArchiveFileName() {
                     ArrayList<String> parts = new ArrayList<>();
                     if (getArchiveBaseName().isPresent())
                         parts.add(getArchiveBaseName().get());
                     if (getArchiveVersion().isPresent())
                         parts.add(getArchiveVersion().get());
                     if (getArchiveClassifier().isPresent())
                         parts.add(getArchiveClassifier().get());
                     if (parts.size() == 0)
                         throw new TaskExecutionException(this, new Exception("The archiveFileName ism't specified"));
                     return String.join("-", parts) + "." + getArchiveExtension().get();
                 }
                 @Override
                 protected void preparingCommand(List<String> commandLine) {
                     super.preparingCommand(commandLine);
                     commandLine.add("save");
                     commandLine.add(getImage().get().toString());
                 }
                 @Override
                 protected void processStarted(Process p) {
                     Utils.redirectIO(p.getInputStream(), getArchiveFile().get().getAsFile());
                 }
             }

readme.md +28 -1

             # Build and publish images with docker/podman
             ## SYNOPSIS
             ```gradle
             plugins {
-                id 'org.implab.gradle-container' version "1.0"
+                id 'org.implab.gradle-container' version '1.1'
             }
             container {
                 // if you want to use podman
                 cliCmd = "podman"
             }
             configurations {
                 app
             }
             dependencies {
                 // the application that needs to be built and packed
                 app project(":server")
             }
             // add custom task to copy application files
             // to the docker build context.
             task copyApp(type: Copy) {
                 processResources.dependsOn it
                 into container.contextDirectory.dir("root/opt/myapp")
                 from configurations.app
             }
             task printVersion {
                 doLast {
                     println "tag: ${buildImage.imageTag.get()}"
                     println "archive: ${saveImage.archiveFileName.get()}"
                 }
             }
             ```
             ## Description
             This plugin is a simple wrapper around docker CLI. All the image
             building process is deligated to the `Dockerfile` which will run
             in the prepeared build context.
             ### Project structure
             * `build/`
                 * `context/` - the build context where `docker build` command will run.
                 * `imageid` - the file storing the id of the image has been built.
                 * `image-name-1.2.3.tgz` - the exported image if `saveImage` has been executed.
             * `src`
                 * `main` - the source files which will be copied to the build context.
             ## Properties
             `imagesAuthority` - the registry where the image should be published.
             for example `docker.io`
             `imagesGroup` - the path to the image in the repository.
             ## Tasks
             ### buildImage
             The task builds the image. Wrapper around the `docker build` command.
             ### saveImage
             The task exports image as the .tar archive.
             ### pushImage
             The task pushes the image to the remote repository.
             ### processResources
             The copy task, it prepares the build context. Use it to customize
             the build context.
+            ### tagImage
+            since: 1.1
+            ```gradle
+            task tagLatest(type: TagImage) {
+                srcImage = container.imageName
+                destImage = container.imageName.map { it.tag("latest") }
+            }
+            ```
+            ## Changes
+            ### 1.1
+            Warning! This version isn't fully backward compatible with 1.0 version.
+            * Added `TagImage` task type
+            * `ImageTag` class is replaced with `ImageName` class
+            * `BuildImage`, `PushImage` tasks are now accepting only `imageName` property
+            * Added `imageName`, `imageShortName`, `imageTag` properties to `container` extension
+            ### 1.0
+            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