implab/gradle-container-plugin Commit - r11:cf3a5b9d59a9

WIP docker compose support

cin -

r11:cf3a5b9d59a9 default

parent child

Context file:

r11:cf3a5b9d59a9

Collapse all files

container/build.gradle +8 0

             			implementationClass = 'org.implab.gradle.containers.ContainerBasePlugin'
                         tags.set(['containers', 'image', 'docker', 'podman'])
             		}
+                    conmposePlugin {
+            			id = 'org.implab.gradle-container-compose'
+                        displayName = "Provdes tasks to start and stop compose"
+                        description = 'Build and publish container images with docker or podman. Simple wrapper around cli.'
+            			implementationClass = 'org.implab.gradle.containers.ComposePlugin'
+                        tags.set(['containers', 'image', 'docker', 'podman'])
+            		}
             	}
             }

container/src/main/java/org/implab/gradle/containers/ContainerBasePlugin.java +8 -4

             import org.implab.gradle.containers.tasks.SaveImage;
             import org.implab.gradle.containers.tasks.TagImage;
-            public class ContainerBasePlugin implements Plugin<Project>  {
+            public class ContainerBasePlugin implements Plugin<Project> {
                 public static final String CONTAINER_EXTENSION_NAME = "container";
-                ContainerExtension containerExtension;
+                private ContainerExtension containerExtension;
                 ContainerExtension getContainerExtension() {
                     if (containerExtension == null)
                     containerExtension.getImageGroup()
                             .convention(project.provider(() -> (String) project.getProperties().get("imagesGroup")));
+                    containerExtension.getCliCmd()
+                            .convention(project
+                                    .provider(() -> (String) project.getProperties().get("containerCli"))
+                                    .orElse("docker"));
                     project.getExtensions().add(CONTAINER_EXTENSION_NAME, containerExtension);
                     exportClasses(
                             project,
                             BuildImage.class, PushImage.class, SaveImage.class, TagImage.class, RunImage.class);
+                }
             }

container/src/main/java/org/implab/gradle/containers/ContainerExtension.java +13 -20

             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.provider.Property;
             import org.gradle.api.provider.Provider;
             import org.implab.gradle.containers.cli.ImageName;
             import org.implab.gradle.containers.cli.ImageRef;
             import org.implab.gradle.containers.cli.Utils;
-            public abstract class ContainerExtension {
+            public abstract class ContainerExtension implements PropertiesMixin {
                 public abstract Property<String> getCliCmd();
                 public abstract DirectoryProperty getContextDirectory();
-                public abstract RegularFileProperty getImageIdFile();
                 /**
                  * Specifies the name of the registry where the image is located
                  * {@code registry.my-company.org}
                  */
                 public abstract Property<String> getImageGroup();
-                public abstract Property<ImageName> getImageName();
+                public Provider<ImageName> getImageName() {
+                    return provider(this::createImageName);
+                }
                 /**
                  * Specifies local image part like {@code httpd}
                 public ContainerExtension(ProjectLayout layout, Project project) {
                     getContextDirectory().convention(layout.getBuildDirectory().dir("context"));
-                    getImageIdFile().convention(layout.getBuildDirectory().file("iid.json"));
-                    getCliCmd().set("docker");
                     getImageLocalName().convention(project.getName());
-                    getImageTag().set(project
+                    getImageTag().set(provider(() -> Optional.ofNullable(project.getVersion())
-                            .provider(() -> Optional.ofNullable(project.getVersion()).map(v -> v.toString()).orElse("latest")));
+                            .map(Object::toString)
+                            .orElse("latest")));
-                    Provider<String> imageRepository = getImageGroup().map(g -> g + "/" + getImageLocalName().get())
-                            .orElse(getImageLocalName());
-                    getImageName().convention(project.provider(
-                            () -> new ImageName().authority(getImageAuthority().get()).name(imageRepository.get())
-                                    .tag(getImageTag().get())));
                 }
-                public ImageName createImageName() {
+                ImageName createImageName() {
-                    return new ImageName();
+                    return new ImageName(
+                            getImageAuthority().getOrNull(),
+                            getImageGroup().getOrNull(),
+                            getImageLocalName().get(),
+                            getImageTag().getOrNull());
                 }
                 public ImageRef readImageRef(File file) throws FileNotFoundException, IOException {

container/src/main/java/org/implab/gradle/containers/ContainerPlugin.java +3 -5

                 public static final String ARCHIVE_CONFIGURATION = "archive";
-                ContainerExtension containerExtension;
                 public void apply(Project project) {
                     ProjectLayout layout = project.getLayout();
                         t.dependsOn(processResourcesTask);
                         t.getContextDirectory().set(containerExtension.getContextDirectory());
-                        t.getImageIdFile().set(containerExtension.getImageIdFile());
+                        t.getImageIdFile().set(project.getLayout().getBuildDirectory().file("iid.json"));
-                        t.getImageName().set(containerExtension.getImageName());
+                        t.getImageName().set(containerExtension.getImageName().map(ImageName::toString));
                     });
                     project.getTasks().register("clean", Delete.class, t -> {
                     project.getTasks().register("saveImage", SaveImage.class, t -> {
                         t.dependsOn(buildImageTask);
-                        t.getExportImages().add(buildImageTask.flatMap(BuildImage::getImageName).map(ImageName::toString));
+                        t.getExportImages().add(buildImageTask.flatMap(BuildImage::getImageName));
                     });
                     project.getArtifacts().add(Dependency.DEFAULT_CONFIGURATION, buildImageTask);

container/src/main/java/org/implab/gradle/containers/cli/DockerTraits.java 0 -1

             import java.io.File;
             import java.io.IOException;
-            import java.nio.file.Files;
             import java.util.ArrayList;
             import java.util.Arrays;
             import java.util.List;

container/src/main/java/org/implab/gradle/containers/cli/ImageName.java +41 -29

             package org.implab.gradle.containers.cli;
             import java.io.Serializable;
+            import java.util.ArrayList;
             import java.util.Optional;
             import com.fasterxml.jackson.annotation.JsonCreator;
                 final String authority;
-                final String name;
+                final String groupName;
+                final String localName;
                 final String tag;
-                public ImageName() {
+                @JsonCreator(mode = JsonCreator.Mode.PROPERTIES)
-                    name = null;
+                public ImageName(
-                    authority = null;
+                        @JsonProperty("authority") String authority,
-                    tag = null;
+                        @JsonProperty("groupName") String groupName,
+                        @JsonProperty("localName") String localName,
+                        @JsonProperty("tag") String tag) {
+                    if (localName == null || localName.isBlank())
+                        throw new IllegalArgumentException("localName can't be null or blank string");
-                @JsonCreator(mode = JsonCreator.Mode.PROPERTIES)
-                private ImageName(@JsonProperty("authority") String authority, @JsonProperty("name") String name,
-                        @JsonProperty("tag") String tag) {
                     this.authority = authority;
-                    this.name = name;
+                    this.groupName = groupName;
+                    this.localName = localName;
                     this.tag = tag;
                 }
-                public String getAuthority() {
+                public Optional<String> getAuthority() {
-                    return authority;
+                    return Optional.ofNullable(authority);
                 }
-                public ImageName authority(String authority) {
+                public ImageName withAuthority(String authority) {
-                    return new ImageName(authority, name, tag);
+                    return new ImageName(authority, groupName, localName, tag);
                 }
-                public String getName() {
+                public Optional<String> getGroupName() {
-                    return name;
+                    return Optional.ofNullable(groupName);
+                }
+                public ImageName withGroupName(String groupName) {
+                    return new ImageName(authority, groupName, localName, tag);
                 }
-                public ImageName name(String name) {
+                public String getLocalName() {
-                    return new ImageName(authority, name, tag);
+                    return localName;
                 }
-                public String getTag() {
+                public ImageName withLocalName(String localName) {
-                    return tag;
+                    if (localName == null || localName.isBlank())
+                        throw new IllegalArgumentException("localName can't be null or blank string");
+                    return new ImageName(authority, groupName, localName, tag);
                 }
-                public ImageName tag(String tag) {
+                public Optional<String> getTag() {
-                    return new ImageName(authority, name, tag);
+                    return Optional.ofNullable(tag);
                 }
-                public ImageName copy() {
+                public ImageName withTag(String tag) {
-                    return new ImageName(authority, name, tag);
+                    return new ImageName(authority, groupName, localName, tag);
                 }
                 @Override
                 public String toString() {
-                    StringBuilder sb = new StringBuilder();
+                    var path = new ArrayList<String>();
-                    Optional.ofNullable(authority).ifPresent(s -> sb.append(s).append("/"));
+                    getAuthority().ifPresent(path::add);
-                    Optional.ofNullable(name).ifPresent(s -> sb.append(s));
+                    getGroupName().ifPresent(path::add);
-                    Optional.ofNullable(tag).ifPresent(s -> sb.append(":").append(s));
+                    path.add(getLocalName());
-                    return sb.toString();
+                    var repo = String.join("/", path);
+                    return getTag().map(tag -> String.join(":", repo, tag)).orElse(repo);
                 }
             }

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

             import org.gradle.api.tasks.TaskAction;
             import java.io.File;
-            import org.implab.gradle.containers.cli.ImageName;
             import org.implab.gradle.containers.cli.ImageRef;
             import org.implab.gradle.containers.cli.Utils;
             import org.implab.gradle.containers.dsl.MapPropertyEntry;
             import groovy.lang.Closure;
             public abstract class BuildImage extends DockerCliTask implements OptionsMixin {
                 @InputDirectory
                 @SkipWhenEmpty
                 public abstract DirectoryProperty getContextDirectory();
                 public abstract Property<String> getBuildTarget();
                 @Input
-                public abstract Property<ImageName> getImageName();
+                public abstract Property<String> getImageName();
                 @Internal
                 public abstract RegularFileProperty getImageIdFile();
                     // add extra parameters
                     getOptions().get().forEach(args::add);
-                    var imageTag = getImageName().map(ImageName::toString).get();
+                    var imageTag = getImageName().get();
                     // build image
                     docker().buildImage(
                     // read the built image id and store image ref metadata
                     var imageRef = new ImageRef(imageTag, Utils.readAll(iidFile));
-                    Utils.writeJson(getImageIdFileOutput().get(), imageRef);
+                    Utils.writeJson(getImageIdFile().map(RegularFile::getAsFile).get(), imageRef);
                 }
             }

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

             import org.gradle.api.tasks.Input;
             import org.gradle.api.tasks.Optional;
             import org.gradle.api.tasks.TaskAction;
-            import org.implab.gradle.containers.cli.ImageName;
             import org.implab.gradle.containers.dsl.OptionsMixin;
             public abstract class PushImage extends DockerCliTask implements OptionsMixin {
                 @Input
-                public abstract Property<ImageName> getImageName();
+                public abstract Property<String> getImageName();
                 @Input
                 @Optional
                 public void run() throws InterruptedException, IOException {
                     docker().pushImage(
-                            getImageName().get().toString(),
+                            getImageName().get(),
                             getOptions().get());
                 }
             }

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

             import org.gradle.api.provider.Property;
             import org.gradle.api.tasks.Input;
             import org.gradle.api.tasks.Optional;
-            import org.implab.gradle.containers.cli.ImageName;
             import org.implab.gradle.containers.dsl.OptionsMixin;
             import org.implab.gradle.containers.dsl.VolumeSpec;
             public abstract class RunImage extends DockerCliTask implements OptionsMixin {
                 @Input
-                public abstract Property<ImageName> getImageName();
+                public abstract Property<String> getImageName();
                 @Input
                 @Optional
                 public void run() throws InterruptedException, IOException {
                     docker().runImage(
-                            getImageName().get().toString(),
+                            getImageName().get(),
                             getOptions().get(),
                             getCommandLine().get());
                 }

container/src/main/java/org/implab/gradle/containers/tasks/TagImage.java +4 -5

             import org.gradle.api.provider.Property;
             import org.gradle.api.tasks.Input;
             import org.gradle.api.tasks.TaskAction;
-            import org.implab.gradle.containers.cli.ImageName;
             public abstract class TagImage extends DockerCliTask {
                 @Input
-                public abstract Property<ImageName> getSrcImage();
+                public abstract Property<String> getSrcImage();
                 @Input
-                public abstract Property<ImageName> getDestImage();
+                public abstract Property<String> getDestImage();
                 @TaskAction
                 public void run() throws InterruptedException, IOException {
                     docker().tagImage(
-                            getSrcImage().map(ImageName::toString).get(),
+                            getSrcImage().get(),
-                            getDestImage().map(ImageName::toString).get());
+                            getDestImage().get());
                 }
             }

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	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