implab/gradle-container-plugin Commit - r9:04caf9830434

moving docker commands to DockerTraits, refacotring

cin -

r9:04caf9830434 default

parent child

Context file:

r9:04caf9830434

Collapse all files

container/src/main/java/org/implab/gradle/containers/cli/DockerTraits.java created 644 +67 0

@@ -0,0 +1,67
	1	package org.implab.gradle.containers.cli;
	2
	3	import java.io.File;
	4	import java.io.IOException;
	5	import java.nio.file.Files;
	6	import java.util.ArrayList;
	7	import java.util.Arrays;
	8	import java.util.List;
	9	import java.util.Optional;
	10	import org.gradle.api.logging.Logger;
	11
	12	public abstract class DockerTraits {
	13
	14	public abstract Logger getLogger();
	15
	16	public abstract Optional<File> getWorkingDir();
	17
	18	public abstract String getCliCmd();
	19
	20	boolean execute(ProcessBuilder builder, int code) throws IOException, InterruptedException {
	21	var proc = builder.start();
	22	return proc.waitFor() == code;
	23	}
	24
	25	protected ProcessBuilder builder(String... args) {
	26	var command = new ArrayList<String>(args.length + 1);
	27	command.add(getCliCmd());
	28	Arrays.stream(args).forEach(command::add);
	29
	30	var builder = new ProcessBuilder(command);
	31
	32	getWorkingDir().ifPresent(builder::directory);
	33	return builder();
	34	}
	35
	36	protected ProcessBuilder builder(List<String> command) {
	37	var builder = new ProcessBuilder(command);
	38
	39	getWorkingDir().ifPresent(builder::directory);
	40	return builder();
	41	}
	42
	43	public void build(List<String> args) {
	44
	45	}
	46
	47	public boolean imageExists(String imageId) throws InterruptedException, IOException {
	48	getLogger().info("Check image {} exists", imageId);
	49
	50	var builder = builder("image", "inspect", "--format", "image-exists", imageId);
	51
	52	return execute(builder, 0);
	53	}
	54
	55	public boolean imageExists(File imageIdFile) {
	56	if (imageIdFile.exists()) {
	57	try {
	58	var imageId = Files.readString(imageIdFile.toPath());
	59	return imageExists(imageId);
	60	} catch (IOException \| InterruptedException e) {
	61	getLogger().error("Failed to read imageId {}: {}", imageIdFile, e);
	62	return false;
	63	}
	64	}
	65	return false;
	66	}
	67	}

container/src/main/java/org/implab/gradle/containers/cli/Utils.java created 644 +93 0

@@ -0,0 +1,93
	1	package org.implab.gradle.containers.cli;
	2
	3	import java.io.ByteArrayOutputStream;
	4	import java.io.Closeable;
	5	import java.io.File;
	6	import java.io.FileInputStream;
	7	import java.io.FileOutputStream;
	8	import java.io.IOException;
	9	import java.io.InputStream;
	10	import java.io.OutputStream;
	11	import java.nio.file.Files;
	12	import java.util.Scanner;
	13
	14	import org.gradle.api.Action;
	15
	16	import groovy.json.JsonGenerator;
	17	import groovy.json.JsonOutput;
	18	import groovy.json.JsonGenerator.Converter;
	19	import groovy.lang.Closure;
	20
	21	public final class Utils {
	22	public static void redirectIO(final InputStream src, final Action<String> consumer) {
	23	new Thread(() -> {
	24	try (Scanner sc = new Scanner(src)) {
	25	while (sc.hasNextLine()) {
	26	consumer.execute(sc.nextLine());
	27	}
	28	}
	29	}).start();
	30	}
	31
	32	public static void redirectIO(final InputStream src, final File file) {
	33	new Thread(() -> {
	34	try (OutputStream out = new FileOutputStream(file)) {
	35	src.transferTo(out);
	36	} catch (Exception e) {
	37	// silence!
	38	}
	39	}).start();
	40	}
	41
	42	public static void closeSilent(Closeable handle) {
	43	try {
	44	handle.close();
	45	} catch (Exception e) {
	46	// silence!
	47	}
	48	}
	49
	50	public static String readAll(final InputStream src) throws IOException {
	51	ByteArrayOutputStream out = new ByteArrayOutputStream();
	52	src.transferTo(out);
	53	return out.toString();
	54	}
	55
	56	public static String readAll(final InputStream src, String charset) throws IOException {
	57	ByteArrayOutputStream out = new ByteArrayOutputStream();
	58	src.transferTo(out);
	59	return out.toString(charset);
	60	}
	61
	62	public static JsonGenerator createDefaultJsonGenerator() {
	63	return new JsonGenerator.Options()
	64	.excludeNulls()
	65	.addConverter(new Converter() {
	66	public boolean handles(Class<?> type) {
	67	return (File.class == type);
	68	}
	69
	70	public Object convert(Object value, String key) {
	71	return ((File) value).getPath();
	72	}
	73	})
	74	.build();
	75	}
	76
	77	public static String toJsonPretty(Object value) {
	78	return JsonOutput.prettyPrint(createDefaultJsonGenerator().toJson(value));
	79	}
	80
	81	public static boolean isNullOrEmptyString(String value) {
	82	return (value == null \|\| value.length() == 0);
	83	}
	84
	85	public static <T> Action<T> wrapClosure(Closure<?> closure) {
	86	return x -> {
	87	closure.setDelegate(x);
	88	closure.setResolveStrategy(Closure.DELEGATE_FIRST);
	89	closure.call(x);
	90	};
	91	}
	92
	93	} No newline at end of file

container/src/main/java/org/implab/gradle/containers/dsl/MapPropertyEntry.java created 644 +35 0

@@ -0,0 +1,35
	1	package org.implab.gradle.containers.dsl;
	2
	3	import java.util.concurrent.Callable;
	4	import org.gradle.api.provider.MapProperty;
	5	import org.gradle.api.provider.Provider;
	6	import org.gradle.api.provider.ProviderFactory;
	7
	8	public class MapPropertyEntry<K,V> {
	9
	10	private final MapProperty<K,V> map;
	11
	12	private final K key;
	13
	14	private final ProviderFactory providerFactory;
	15
	16	public MapPropertyEntry(MapProperty<K,V> map, K key, ProviderFactory providerFactory) {
	17	this.map = map;
	18	this.key = key;
	19	this.providerFactory = providerFactory;
	20	}
	21
	22	void put(Callable<V> value) {
	23	map.put(key, providerFactory.provider(value));
	24	}
	25
	26	void put(V value) {
	27	map.put(key, value);
	28	}
	29
	30	void put(Provider<V> value) {
	31	map.put(key, value);
	32	}
	33
	34
	35	}

container/src/main/java/org/implab/gradle/containers/ExecuteMixin.java +12 -3

             package org.implab.gradle.containers;
             import java.io.File;
+            import java.io.IOException;
             import java.util.ArrayList;
             import java.util.List;
             import java.util.Optional;
             import org.gradle.api.logging.Logger;
+            import org.gradle.api.tasks.Internal;
+            import org.implab.gradle.containers.cli.Utils;
             public interface ExecuteMixin {
+                @Internal
                 Logger getLogger();
+                @Internal
                 Optional<File> getWorkingDir();
-                default void Execute() throws Exception {
+                default void Execute() throws IOException, InterruptedException {
                     final Logger log = getLogger();
                     List<String> command = new ArrayList<>();
                     preparingCommand(command);
                     ProcessBuilder builder = new ProcessBuilder(command);
                     getWorkingDir().ifPresent(workingDir -> builder.directory(workingDir));
                     log.info("Starting: {}", builder.command());
                     Process p = builder.start();
                     processStarted(p);
                     if (log.isErrorEnabled()) {
                         Utils.redirectIO(p.getErrorStream(), log::error);
                     }
                     int code = p.waitFor();
-                    if (code != 0)
+                    if (code != 0) {
-                        throw new Exception("Process exited with the error: " + code);
+                        log.error("Process: {}", builder.command());
+                        log.error("Process exited with code {}", code);
+                        throw new IOException("Process exited with code: " + code);
+                    }
                 }
                 void preparingCommand(List<String> command);
                 /**
                  * Invoked after the process is started, can be used to handle the process
                  * output.
                  *
                  * Default implementation redirects output to the logger as INFO messages.
                  *
                  * @param p The current process.
                  */
                 default void processStarted(Process p) {
                     final Logger log = getLogger();
                     Utils.redirectIO(p.getInputStream(), log::info);
                 }
             }

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

             package org.implab.gradle.containers.tasks;
+            import java.io.FileInputStream;
+            import java.io.IOException;
+            import java.io.InputStream;
+            import java.nio.file.Files;
             import java.util.ArrayList;
             import java.util.Collection;
             import java.util.Collections;
             import java.util.HashMap;
             import java.util.List;
             import java.util.Map;
             import java.util.Optional;
+            import org.apache.tools.ant.taskdefs.UpToDate;
             import org.gradle.api.Action;
             import org.gradle.api.file.DirectoryProperty;
+            import org.gradle.api.file.RegularFile;
             import org.gradle.api.file.RegularFileProperty;
             import org.gradle.api.provider.ListProperty;
             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.OutputFile;
             import org.gradle.api.tasks.SkipWhenEmpty;
+            import org.gradle.api.tasks.TaskAction;
             import org.implab.gradle.containers.ImageName;
-            import org.implab.gradle.containers.Utils;
+            import org.implab.gradle.containers.cli.Utils;
+            import org.implab.gradle.containers.dsl.MapPropertyEntry;
             import groovy.lang.Closure;
             public abstract class BuildImage extends DockerCliTask {
                 public final String BUILD_COMMAND = "build";
                 @InputDirectory
                 @SkipWhenEmpty
                 public abstract DirectoryProperty getContextDirectory();
                 @Input
                 public abstract MapProperty<String, String> getBuildArgs();
                 @Input
                 public abstract ListProperty<String> getExtraCommandArgs();
                 @Input
+                @org.gradle.api.tasks.Optional
                 public abstract Property<String> getBuildTarget();
                 @Input
                 public abstract Property<ImageName> getImageName();
                 @OutputFile
                 public abstract RegularFileProperty getImageIdFile();
+                protected 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);
                         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<>();
+                    args.addAll(List.of(
+                            "-t", getImageName().get().toString(),
+                            "--iidfile", getImageIdFile().getAsFile().get().toString()));
+                    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
+                    getExtraCommandArgs().getOrElse(Collections.emptyList())
+                            .forEach(args::add);
+                    args.add(getContextDirectory().getAsFile().get().toString());
+                    docker().build(args);
+                }
                 @Override
                 protected Optional<String> getSubCommand() {
                     return Optional.of(BUILD_COMMAND);
                 }
                 @Override
                 protected Collection<String> getSubCommandArguments() {
                     List<String> args = new ArrayList<>();
                     args.addAll(List.of(
                             "-t", getImageName().get().toString(),
                             "--iidfile", getImageIdFile().getAsFile().get().toString()));
-                    if (imageBuildArgs.isPresent()) {
+                    getBuildArgs().get().forEach((k, v) -> {
-                        imageBuildArgs.get().forEach((k, v) -> {
+                        args.add("--build-arg");
-                            args.add("--build-arg");
+                        args.add(String.format("%s=%s", k, v));
-                            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
                     getExtraCommandArgs().getOrElse(Collections.emptyList())
                             .forEach(args::add);
                     args.add(getContextDirectory().getAsFile().get().toString());
                     return args;
                 }
             }

container/src/main/java/org/implab/gradle/containers/tasks/DockerCliTask.java +30 -1

             package org.implab.gradle.containers.tasks;
             import java.io.File;
             import java.util.Collection;
             import java.util.Collections;
             import java.util.List;
             import java.util.Optional;
             import org.gradle.api.DefaultTask;
+            import org.gradle.api.file.Directory;
             import org.gradle.api.file.DirectoryProperty;
+            import org.gradle.api.logging.Logger;
             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.TaskAction;
             import org.implab.gradle.containers.ContainerExtension;
             import org.implab.gradle.containers.ExecuteMixin;
             import org.implab.gradle.containers.PropertiesMixin;
+            import org.implab.gradle.containers.cli.DockerTraits;
             public abstract class DockerCliTask extends DefaultTask implements PropertiesMixin, ExecuteMixin {
                 private final Property<String> cliCmd;
                 private final DirectoryProperty workingDir;
                 public DockerCliTask() {
                     cliCmd = property(String.class)
                             .convention(getContainerExtension().getCliCmd());
                     workingDir = directoryProperty();
                 }
                 @Internal
                 protected Optional<String> getSubCommand() {
                     return Optional.empty();
                 }
                 @Internal
                 protected Collection<String> getSubCommandArguments() {
                     return Collections.emptyList();
                 }
                 @Input
                 public Property<String> getCliCmd() {
                     return cliCmd;
                 }
                 public void setCliCmd(String cliCmd) {
                     this.cliCmd.set(cliCmd);
                 }
                 @Internal
                 protected ContainerExtension getContainerExtension() {
                     return getProject().getExtensions().getByType(ContainerExtension.class);
                 }
                 @TaskAction
                 public void Run() throws Exception {
                     Execute();
                 }
                 public void preparingCommand(List<String> commandLine) {
                     commandLine.add(cliCmd.get());
                     getSubCommand().ifPresent(commandLine::add);
                     getSubCommandArguments().forEach(commandLine::add);
                 }
                 @Override
                 @Internal
                 public Optional<File> getWorkingDir() {
-                    return Optional.ofNullable(workingDir.get().getAsFile());
+                    return workingDir
+                        .map(Directory::getAsFile)
+                        .map(Optional::of)
+                        .getOrElse(Optional.empty());
                 }
                 protected void setWorkingDir(Provider<File> workingDir) {
                     this.workingDir.fileProvider(workingDir);
                 }
                 protected void setWorkingDir(File workingDir) {
                     this.workingDir.set(workingDir);
                 }
+                protected DockerTraits docker() {
+                    return new TaskDockerTraits();
+                }
+                class TaskDockerTraits extends DockerTraits {
+                    @Override
+                    public Logger getLogger() {
+                        return DockerCliTask.this.getLogger();
+                    }
+                    @Override
+                    public Optional<File> getWorkingDir() {
+                        return DockerCliTask.this.getWorkingDir();
+                    }
+                    @Override
+                    public String getCliCmd() {
+                        return cliCmd.get();
+                    }
+                }
             }

container/src/main/java/org/implab/gradle/containers/Utils.java removed 0 -91

NO CONTENT: file was removed

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