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

             plugins {
                 id "java-gradle-plugin"
                 id "com.gradle.plugin-publish" version "1.2.1"
                 // Maven Publish Plugin applied by com.gradle.plugin-publish > 1.0
                 id "ivy-publish"
             }
             dependencies {
                 implementation "com.fasterxml.jackson.core:jackson-core:2.13.5",
                     "com.fasterxml.jackson.datatype:jackson-datatype-jdk8:2.13.5"
             }
             java {
                 targetCompatibility = 11
                 sourceCompatibility = 11
             }
             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 = "Provdes convetional configuration to build a container image"
                         description = 'Build and publish container images with docker or podman. Simple wrapper around cli.'
             			implementationClass = 'org.implab.gradle.containers.ContainerPlugin'
                         tags.set(['containers', 'image', 'docker', 'podman'])
             		}
                     containerBasePlugin {
             			id = 'org.implab.gradle-container-base'
                         displayName = "Provides tasks to build manipulate container images"
                         description = 'Build and publish container images with docker or podman. Simple wrapper around cli.'
             			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'])
+            		}
             	}
             }
             task printVersion {
                 doLast {
                     println "${->jar.archiveFileName.get()}"
                 }
             }
             publishing {
                 repositories {
                     ivy {
                         url "${System.properties["user.home"]}/ivy-repo"
                     }
                 }
             }

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

             package org.implab.gradle.containers;
             import org.gradle.api.Plugin;
             import org.gradle.api.Project;
             import org.gradle.api.plugins.ExtraPropertiesExtension;
             import org.implab.gradle.containers.tasks.BuildImage;
             import org.implab.gradle.containers.tasks.PushImage;
             import org.implab.gradle.containers.tasks.RunImage;
             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)
                         throw new IllegalStateException();
                     return containerExtension;
                 }
                 void exportClasses(Project project, Class<?>... classes) {
                     ExtraPropertiesExtension extras = project.getExtensions().getExtraProperties();
                     for (var clazz : classes)
                         extras.set(clazz.getSimpleName(), clazz);
                 }
                 @Override
                 public void apply(Project project) {
                     containerExtension = project.getObjects().newInstance(ContainerExtension.class);
                     containerExtension.getImageAuthority()
                             .convention(project.provider(() -> (String) project.getProperties().get("imagesAuthority")));
                     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

             package org.implab.gradle.containers;
             import java.io.File;
             import java.io.FileNotFoundException;
             import java.io.IOException;
             import java.util.Optional;
             import javax.inject.Inject;
             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> getImageAuthority();
                 /**
                  * Specified the path of the image like {@code my-company}
                  */
                 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 abstract Property<String> getImageLocalName();
                 /**
                  * This property is deprecated use imageLocalName
                  */
                 @Deprecated
                 public Property<String> getImageShortName() {
                     return getImageLocalName();
                 }
                 public abstract Property<String> getImageTag();
                 @Inject
                 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 {
                     return Utils.readImageRef(file);
                 }
             }

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

             package org.implab.gradle.containers;
             import org.gradle.api.GradleException;
             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.tasks.Copy;
             import org.gradle.api.tasks.Delete;
             import org.gradle.api.tasks.TaskProvider;
             import org.implab.gradle.containers.cli.ImageName;
             import org.implab.gradle.containers.tasks.BuildImage;
             import org.implab.gradle.containers.tasks.PushImage;
             import org.implab.gradle.containers.tasks.SaveImage;
             public class ContainerPlugin implements Plugin<Project> {
                 public static final String BUILD_GROUP = "build";
                 public static final String ARCHIVE_CONFIGURATION = "archive";
-                ContainerExtension containerExtension;
                 public void apply(Project project) {
                     ProjectLayout layout = project.getLayout();
                     project.getPluginManager().apply(ContainerBasePlugin.class);
                     var basePlugin = project.getPlugins().findPlugin(ContainerBasePlugin.class);
                     if (basePlugin == null)
                         throw new GradleException("The container-base plugin fails to be applied");
                     var containerExtension = basePlugin.getContainerExtension();
                     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());
+                        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 -> {
                         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.getImageName().set(buildImageTask.flatMap(BuildImage::getImageName));
                     });
                     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

             package org.implab.gradle.containers.cli;
             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;
             import java.util.Optional;
             import org.gradle.api.logging.Logger;
             public abstract class DockerTraits {
                 public final String BUILD_COMMAND = "build";
                 public final String PUSH_COMMAND = "push";
                 public final String RUN_COMMAND = "run";
                 public final String SAVE_COMMAND = "save";
                 public final String INSPECT_COMMAND = "inspect";
                 public final String IMAGE_COMMAND = "image";
                 public final String TAG_COMMAND = "tag";
                 public abstract Logger getLogger();
                 public abstract Optional<File> getWorkingDir();
                 public abstract String getCliCmd();
                 Process startProcess(ProcessBuilder builder) throws IOException {
                     getLogger().info("Starting: {}", builder.command());
                     return builder.start();
                 }
                 protected boolean checkRetCode(Process proc, int code) throws InterruptedException {
                     if (getLogger().isInfoEnabled()) {
                         Utils.redirectIO(proc.getInputStream(), getLogger()::info);
                         Utils.redirectIO(proc.getErrorStream(), getLogger()::info);
                     }
                     return proc.waitFor() == code;
                 }
                 protected void complete(Process proc) throws InterruptedException, IOException {
                     if (getLogger().isInfoEnabled())
                         Utils.redirectIO(proc.getInputStream(), getLogger()::info);
                     if (getLogger().isErrorEnabled())
                         Utils.redirectIO(proc.getErrorStream(), getLogger()::error);
                     var code = proc.waitFor();
                     if (code != 0) {
                         getLogger().error("The process exited with code {}", code);
                         throw new IOException("The process exited with error code " + code);
                     }
                 }
                 protected ProcessBuilder builder(String... args) {
                     var argsList = new ArrayList<String>(args.length + 1);
                     Arrays.stream(args).forEach(argsList::add);
                     return builder(argsList);
                 }
                 protected ProcessBuilder builder(List<String> args) {
                     var command = new ArrayList<String>(args.size() + 1);
                     command.add(getCliCmd());
                     args.forEach(command::add);
                     var builder = new ProcessBuilder(command);
                     getWorkingDir().ifPresent(builder::directory);
                     return builder;
                 }
                 public void buildImage(String imageName, File contextDirectory, List<String> options)
                         throws IOException, InterruptedException {
                     var args = new ArrayList<String>();
                     args.add(BUILD_COMMAND);
                     args.addAll(options);
                     args.add("-t");
                     args.add(imageName);
                     args.add(contextDirectory.getAbsolutePath());
                     complete(startProcess(builder(args)));
                 }
                 public void pushImage(String image, List<String> options) throws InterruptedException, IOException {
                     var args = new ArrayList<String>();
                     args.add(PUSH_COMMAND);
                     args.addAll(options);
                     args.add(image);
                     complete(startProcess(builder(args)));
                 }
                 public void runImage(String image, List<String> options, List<String> command)
                         throws InterruptedException, IOException {
                     var args = new ArrayList<String>();
                     args.add(RUN_COMMAND);
                     args.addAll(options);
                     args.add(image);
                     args.addAll(command);
                     complete(startProcess(builder(args)));
                 }
                 public void saveImage(List<String> images, File output) throws InterruptedException, IOException {
                     if (output.exists())
                         output.delete();
                     var args = new ArrayList<String>();
                     args.add(SAVE_COMMAND);
                     args.add("-o");
                     args.add(output.getAbsolutePath());
                     images.forEach(args::add);
                     complete(startProcess(builder(args)));
                 }
                 public void tagImage(String source, String target) throws InterruptedException, IOException {
                     complete(startProcess(builder(TAG_COMMAND, source, target)));
                 }
                 public boolean imageExists(String imageId) throws InterruptedException, IOException {
                     getLogger().info("Check image {} exists", imageId);
                     return checkRetCode(
                             startProcess(builder(IMAGE_COMMAND, INSPECT_COMMAND, "--format", "image-exists", imageId)),
 );
                 }
                 public boolean imageExists(File imageIdFile) {
                     if (imageIdFile.exists()) {
                         try {
                             var imageId = Utils.readImageRef(imageIdFile);
                             return imageExists(imageId.getId());
                         } catch (IOException | InterruptedException e) {
                             getLogger().error("Failed to read imageId {}: {}", imageIdFile, e);
                             return false;
                         }
                     }
                     return false;
                 }
             }

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;
             import com.fasterxml.jackson.annotation.JsonProperty;
             public class ImageName implements Serializable {
                 private static final long serialVersionUID = -1990105923537254552L;
                 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

             package org.implab.gradle.containers.tasks;
             import java.util.ArrayList;
             import java.util.HashMap;
             import java.util.List;
             import java.util.Map;
             import org.gradle.api.Action;
             import org.gradle.api.file.Directory;
             import org.gradle.api.file.DirectoryProperty;
             import org.gradle.api.file.RegularFile;
             import org.gradle.api.file.RegularFileProperty;
             import org.gradle.api.provider.MapProperty;
             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.Optional;
             import org.gradle.api.tasks.OutputFile;
             import org.gradle.api.tasks.SkipWhenEmpty;
             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 org.implab.gradle.containers.dsl.OptionsMixin;
             import groovy.lang.Closure;
             public abstract class BuildImage extends DockerCliTask implements OptionsMixin {
                 @InputDirectory
                 @SkipWhenEmpty
                 public abstract DirectoryProperty getContextDirectory();
                 @Input
                 public abstract MapProperty<String, String> getBuildArgs();
                 @Input
                 @Optional
                 public abstract Property<String> getBuildTarget();
                 @Input
-                public abstract Property<ImageName> getImageName();
+                public abstract Property<String> getImageName();
                 @Internal
                 public abstract RegularFileProperty getImageIdFile();
                 @OutputFile
                 public Provider<File> getImageIdFileOutput() {
                     return getImageIdFile().map(RegularFile::getAsFile);
                 }
                 public BuildImage() {
                     getOutputs().upToDateWhen(task -> getImageIdFile()
                             .map(RegularFile::getAsFile)
                             .map(docker()::imageExists)
                             .getOrElse(false));
                 }
                 public void buildArgs(Action<Map<String, String>> spec) {
                     getBuildArgs().putAll(provider(() -> {
                         Map<String, String> args = new HashMap<>();
                         spec.execute(args);
                         getLogger().info("add buildArgs {}", args);
                         return args;
                     }));
                 }
                 public void buildArgs(Closure<Map<String, String>> spec) {
                     buildArgs(Utils.wrapClosure(spec));
                 }
                 public MapPropertyEntry<String, String> buildArg(String key) {
                     return new MapPropertyEntry<String, String>(getBuildArgs(), key, getProviders());
                 }
                 @TaskAction
                 public void run() throws Exception {
                     List<String> args = new ArrayList<>();
                     // create a temp file to store image id
                     var iidFile = new File(this.getTemporaryDir(), "iid");
                     // specify where to write image id
                     args.addAll(List.of("--iidfile", iidFile.getAbsolutePath()));
                     getBuildArgs().get().forEach((k, v) -> {
                         args.add("--build-arg");
                         args.add(String.format("%s=%s", k, v));
                     });
                     // add --target if specified for multi-stage build
                     if (getBuildTarget().isPresent()) {
                         args.add("--target");
                         args.add(getBuildTarget().get());
                     }
                     // add extra parameters
                     getOptions().get().forEach(args::add);
-                    var imageTag = getImageName().map(ImageName::toString).get();
+                    var imageTag = getImageName().get();
                     // build image
                     docker().buildImage(
                             imageTag,
                             getContextDirectory().map(Directory::getAsFile).get(),
                             args);
                     // 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

             package org.implab.gradle.containers.tasks;
             import java.io.IOException;
             import org.gradle.api.provider.ListProperty;
             import org.gradle.api.provider.Property;
             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 abstract Property<String> getTransport();
                 @Input
                 @Optional
                 public abstract ListProperty<String> getOptions();
                 @TaskAction
                 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

             package org.implab.gradle.containers.tasks;
             import java.io.IOException;
             import org.gradle.api.Action;
             import org.gradle.api.provider.ListProperty;
             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 abstract ListProperty<String> getCommandLine();
                 public void volume(Action<VolumeSpec> configure) {
                     getOptions().add("-v");
                     getOptions().add(provider(() -> {
                         var volumeSpec = getObjectFactory().newInstance(VolumeSpec.class);
                         configure.execute(volumeSpec);
                         return volumeSpec.resolveSpec();
                     }));
                 }
                 void commandLine(String ...args) {
                     getCommandLine().addAll(args);
                 }
                 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

             package org.implab.gradle.containers.tasks;
             import java.io.IOException;
             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