implab/gradle-container-plugin Commit - r8:e992157ede55

Bump gradle, tasks refactoring

cin -

r8:e992157ede55 default

parent child

Context file:

r8:e992157ede55

Expand all files

container/src/main/java/org/implab/gradle/containers/ExecuteMixin.java created 644 +57 0

@@ -0,0 +1,57
	1	package org.implab.gradle.containers;
	2
	3	import java.io.File;
	4	import java.util.ArrayList;
	5	import java.util.List;
	6	import java.util.Optional;
	7
	8	import org.gradle.api.logging.Logger;
	9
	10	public interface ExecuteMixin {
	11
	12	Logger getLogger();
	13
	14	Optional<File> getWorkingDir();
	15
	16	default void Execute() throws Exception {
	17	final Logger log = getLogger();
	18
	19	List<String> command = new ArrayList<>();
	20
	21	preparingCommand(command);
	22
	23	ProcessBuilder builder = new ProcessBuilder(command);
	24	getWorkingDir().ifPresent(workingDir -> builder.directory(workingDir));
	25
	26	log.info("Starting: {}", builder.command());
	27
	28	Process p = builder.start();
	29
	30	processStarted(p);
	31
	32	if (log.isErrorEnabled()) {
	33	Utils.redirectIO(p.getErrorStream(), log::error);
	34	}
	35
	36	int code = p.waitFor();
	37	if (code != 0)
	38	throw new Exception("Process exited with the error: " + code);
	39	}
	40
	41	void preparingCommand(List<String> command);
	42
	43
	44	/**
	45	* Invoked after the process is started, can be used to handle the process
	46	* output.
	47	*
	48	* Default implementation redirects output to the logger as INFO messages.
	49	*
	50	* @param p The current process.
	51	*/
	52
	53	default void processStarted(Process p) {
	54	final Logger log = getLogger();
	55	Utils.redirectIO(p.getInputStream(), log::info);
	56	}
	57	}

container/src/main/java/org/implab/gradle/containers/PropertiesMixin.java created 644 +45 0

@@ -0,0 +1,45
	1	package org.implab.gradle.containers;
	2
	3	import java.util.concurrent.Callable;
	4
	5	import javax.inject.Inject;
	6
	7	import org.gradle.api.file.DirectoryProperty;
	8	import org.gradle.api.file.RegularFileProperty;
	9	import org.gradle.api.model.ObjectFactory;
	10	import org.gradle.api.provider.ListProperty;
	11	import org.gradle.api.provider.Property;
	12	import org.gradle.api.provider.Provider;
	13	import org.gradle.api.provider.ProviderFactory;
	14
	15	public interface PropertiesMixin {
	16	@Inject
	17	ObjectFactory getObjectFactory();
	18
	19	@Inject
	20	ProviderFactory getProviders();
	21
	22	default <T> Provider<T> provider(Callable<? extends T> callable) {
	23	return getProviders().provider(callable);
	24	}
	25
	26	default <T> Property<T> property(Class<T> clazz) {
	27	return getObjectFactory().property(clazz);
	28	}
	29
	30	default <T> ListProperty<T> listProperty(Class<T> clazz) {
	31	return getObjectFactory().listProperty(clazz);
	32	}
	33
	34	default RegularFileProperty fileProperty() {
	35	return getObjectFactory().fileProperty();
	36	}
	37
	38	default DirectoryProperty directoryProperty() {
	39	return getObjectFactory().directoryProperty();
	40	}
	41
	42
	43
	44
	45	}

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

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

container/src/main/java/org/implab/gradle/containers/tasks/MountSpec.java created 644 +10 0

@@ -0,0 +1,10
	1	package org.implab.gradle.containers.tasks;
	2
	3	public class MountSpec {
	4
	5	String destination;
	6
	7	String source;
	8
	9	boolean readOnly;
	10	}

container/src/main/java/org/implab/gradle/containers/tasks/RunImage.java created 644 +54 0

@@ -0,0 +1,54
	1	package org.implab.gradle.containers.tasks;
	2
	3	import java.util.ArrayList;
	4	import java.util.Collection;
	5	import java.util.List;
	6
	7	import org.gradle.api.Action;
	8	import org.gradle.api.provider.ListProperty;
	9	import org.gradle.api.provider.Property;
	10	import org.gradle.api.tasks.Input;
	11	import org.gradle.api.tasks.Optional;
	12	import org.implab.gradle.containers.ImageName;
	13
	14	public abstract class RunImage extends DockerCliTask {
	15
	16	public final String RUN_COMMAND = "run";
	17
	18	@Input
	19	@Optional
	20	public abstract ListProperty<String> getOptions();
	21
	22	@Input
	23	public abstract Property<ImageName> getImageName();
	24
	25	@Input
	26	@Optional
	27	public abstract ListProperty<String> getCommandLine();
	28
	29	@Override
	30	protected java.util.Optional<String> getSubCommand() {
	31	return java.util.Optional.of(RUN_COMMAND);
	32	}
	33
	34	@Override
	35	protected Collection<String> getSubCommandArguments() {
	36	List<String> args = new ArrayList<String>();
	37
	38	args.addAll(getOptions().get());
	39	args.add(getImageName().get().toString());
	40	args.addAll(getCommandLine().get());
	41
	42	return args;
	43	}
	44
	45	public void volume(Action<VolumeSpec> configure) {
	46	getOptions().add("-v");
	47	getOptions().add(provider(() -> {
	48	var volumeSpec = getObjectFactory().newInstance(VolumeSpec.class);
	49	configure.execute(volumeSpec);
	50	return volumeSpec.resolveSpec();
	51	}));
	52	}
	53
	54	}

container/src/main/java/org/implab/gradle/containers/tasks/VolumeSpec.java created 644 +34 0

@@ -0,0 +1,34
	1	package org.implab.gradle.containers.tasks;
	2
	3	import java.util.ArrayList;
	4
	5	import org.gradle.api.provider.ListProperty;
	6	import org.gradle.api.provider.Property;
	7
	8	public abstract class VolumeSpec {
	9
	10	public abstract Property<String> getSource();
	11
	12	public abstract Property<String> getTarget();
	13
	14	public abstract ListProperty<String> getOptions();
	15
	16	public void ro() {
	17	getOptions().add("ro");
	18	}
	19
	20	public String resolveSpec() {
	21	var parts = new ArrayList<String>();
	22
	23	if (getSource().isPresent())
	24	parts.add(getSource().get());
	25
	26	parts.add(getTarget().get());
	27
	28	if (getOptions().isPresent())
	29	parts.add(String.join(",", getOptions().get()));
	30
	31	return String.join(":", parts);
	32	}
	33
	34	}

build.gradle +7 0

@@ -0,0 +1,7
	1	subprojects { p ->
	2	plugins.withId('java') {
	3	p.base {
	4	archivesBaseName = "$rootProject.name-$p.name";
	5	}
	6	}
	7	} No newline at end of file

container/build.gradle +18 -5

             plugins {
                 id "java-gradle-plugin"
-                id "com.gradle.plugin-publish" version "0.16.0"
+                id "com.gradle.plugin-publish" version "1.2.1"
+                // Maven Publish Plugin applied by com.gradle.plugin-publish > 1.0
+                id "ivy-publish"
             }
             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'
+                        tags.set(['containers', 'image', 'docker', 'podman'])
             		}
             	}
             }
-            pluginBundle {
-                website = 'https://code.implab.org/implab/gradle-container-plugin'
+            task printVersion {
-                vcsUrl = 'https://code.implab.org/implab/gradle-container-plugin'
+                doLast {
+                    println "${->jar.archiveFileName.get()}"
+                }
+            }
-                tags = ['containers', 'image', 'docker', 'podman']
+            publishing {
+                repositories {
+                    ivy {
+                        url "${System.properties["user.home"]}/ivy-repo"
                     }
+                }
+            }

container/gradle.properties +1 -1

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

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

             package org.implab.gradle.containers;
             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.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.RunImage;
             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;
+                void exportClasses(Project project, Class<?>... classes) {
+                    ExtraPropertiesExtension extras = project.getExtensions().getExtraProperties();
+                    for (var clazz : classes)
+                        extras.set(clazz.getSimpleName(), clazz);
+                }
                 public void apply(Project project) {
                     ObjectFactory factory = project.getObjects();
                     ProjectLayout layout = project.getLayout();
                     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();
+                    exportClasses(
-                    extras.set(BuildImage.class.getSimpleName(), BuildImage.class);
+                            project,
-                    extras.set(PushImage.class.getSimpleName(), PushImage.class);
+                            BuildImage.class, PushImage.class, SaveImage.class, TagImage.class, RunImage.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());
                         t.getImageName().set(containerExtension.getImageName());
                     });
                     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(b -> b.getImageName()));
                     });
                     project.getTasks().register("saveImage", SaveImage.class, t -> {
                         t.dependsOn(buildImageTask);
                         t.getImage().set(buildImageTask.flatMap(b -> b.getImageName()));
                     });
-                    project.getArtifacts().add(Dependency.DEFAULT_CONFIGURATION, buildImageTask.flatMap(x -> x.getImageIdFile()), t -> {
+                    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 +64 -11

@@ -1,43 +1,96
1	package org.implab.gradle.containers.tasks;	1	package org.implab.gradle.containers.tasks;
2		2
		3	import java.util.ArrayList;
		4	import java.util.Collection;
		5	import java.util.Collections;
		6	import java.util.HashMap;
3	import java.util.List;	7	import java.util.List;
		8	import java.util.Map;
		9	import java.util.Optional;
4		10
		11	import org.gradle.api.Action;
5	import org.gradle.api.file.DirectoryProperty;	12	import org.gradle.api.file.DirectoryProperty;
6	import org.gradle.api.file.RegularFileProperty;	13	import org.gradle.api.file.RegularFileProperty;
		14	import org.gradle.api.provider.ListProperty;
		15	import org.gradle.api.provider.MapProperty;
7	import org.gradle.api.provider.Property;	16	import org.gradle.api.provider.Property;
		17	import org.gradle.api.provider.Provider;
8	import org.gradle.api.tasks.Input;	18	import org.gradle.api.tasks.Input;
9	import org.gradle.api.tasks.InputDirectory;	19	import org.gradle.api.tasks.InputDirectory;
10	import org.gradle.api.tasks.OutputFile;	20	import org.gradle.api.tasks.OutputFile;
11	import org.gradle.api.tasks.SkipWhenEmpty;	21	import org.gradle.api.tasks.SkipWhenEmpty;
12	import org.implab.gradle.Utils;
13	import org.implab.gradle.containers.ImageName;	22	import org.implab.gradle.containers.ImageName;
		23	import org.implab.gradle.containers.Utils;
14		24
15	public abstract class BuildImage extends CliTask {	25	import groovy.lang.Closure;
		26
		27	public abstract class BuildImage extends DockerCliTask {
		28
		29	public final String BUILD_COMMAND = "build";
		30
16	@InputDirectory	31	@InputDirectory
17	@SkipWhenEmpty	32	@SkipWhenEmpty
18	public abstract DirectoryProperty getContextDirectory();	33	public abstract DirectoryProperty getContextDirectory();
19		34
20	@Input	35	@Input
		36	public abstract MapProperty<String, String> getBuildArgs();
		37
		38	@Input
		39	public abstract ListProperty<String> getExtraCommandArgs();
		40
		41	@Input
		42	public abstract Property<String> getBuildTarget();
		43
		44	@Input
21	public abstract Property<ImageName> getImageName();	45	public abstract Property<ImageName> getImageName();
22		46
23	@OutputFile	47	@OutputFile
24	public abstract RegularFileProperty getImageIdFile();	48	public abstract RegularFileProperty getImageIdFile();
25		49
26	public BuildImage() {	50	public void buildArgs(Action<Map<String, String>> spec) {
		51	getBuildArgs().putAll(provider(() -> {
		52	Map<String, String> args = new HashMap<>();
		53	spec.execute(args);
		54	return args;
		55	}));
		56	}
27		57
28	setWorkingDir(getContextDirectory().getAsFile());	58	public void buildArgs(Closure<Map<String, String>> spec) {
		59	buildArgs(Utils.wrapClosure(spec));
		60	}
		61
		62	@Override
		63	protected Optional<String> getSubCommand() {
		64	return Optional.of(BUILD_COMMAND);
29	}	65	}
30		66
31	@Override	67	@Override
32	protected void preparingCommand(List<String> commandLine) {	68	protected Collection<String> getSubCommandArguments() {
33	super.preparingCommand(commandLine);	69	List<String> args = new ArrayList<>();
34		70
35	commandLine.addAll(List.of("build", ".", "-q", "-t"));	71	args.addAll(List.of(
36	~~commandLine~~.~~add~~(getImageName().get().toString());	72	"-t", getImageName().get().toString(),
		73	"--iidfile", getImageIdFile().getAsFile().get().toString()));
		74
		75	if (imageBuildArgs.isPresent()) {
		76	imageBuildArgs.get().forEach((k, v) -> {
		77	args.add("--build-arg");
		78	args.add(String.format("%s=%s", k, v));
		79	});
37	}	80	}
38		81
39	@Override	82	// add --target if specified for multi-stage build
40	protected void processStarted(Process p) {	83	if (getBuildTarget().isPresent()) {
41	Utils.redirectIO(p.getInputStream(), getImageIdFile().get().getAsFile());	84	args.add("--target");
		85	args.add(getBuildTarget().get());
		86	}
		87
		88	// add extra parameters
		89	getExtraCommandArgs().getOrElse(Collections.emptyList())
		90	.forEach(args::add);
		91
		92	args.add(getContextDirectory().getAsFile().get().toString());
		93
		94	return args;
42	}	95	}
43	}	96	}

container/src/main/java/org/implab/gradle/containers/tasks/DockerCliTask.java ~~container/src/main/java/org/implab/gradle/containers/tasks/CliTask.java~~ renamed +32 -44

             package org.implab.gradle.containers.tasks;
             import java.io.File;
-            import java.util.ArrayList;
+            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.logging.Logger;
+            import org.gradle.api.file.DirectoryProperty;
             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.Utils;
             import org.implab.gradle.containers.ContainerExtension;
+            import org.implab.gradle.containers.ExecuteMixin;
+            import org.implab.gradle.containers.PropertiesMixin;
-            public abstract class CliTask extends DefaultTask {
+            public abstract class DockerCliTask extends DefaultTask implements PropertiesMixin, ExecuteMixin {
                 private final Property<String> cliCmd;
-                private final Property<File> workingDir;
+                private final DirectoryProperty workingDir;
+                public DockerCliTask() {
+                    cliCmd = property(String.class)
+                            .convention(getContainerExtension().getCliCmd());
+                    workingDir = directoryProperty();
+                }
-                public CliTask() {
+                @Internal
-                    cliCmd = getProject().getObjects().property(String.class);
+                protected Optional<String> getSubCommand() {
-                    cliCmd.convention(getContainerExtension().getCliCmd());
+                    return Optional.empty();
+                }
-                    workingDir = getProject().getObjects().property(File.class);
+                @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 {
-                    final Logger log = getLogger();
+                    Execute();
-                    List<String> args = new ArrayList<>();
-                    preparingCommand(args);
-                    ProcessBuilder builder = new ProcessBuilder(args);
-                    if (workingDir.isPresent())
-                        builder.directory(workingDir.get());
-                    log.info("Starting: {}", builder.command());
-                    Process p = builder.start();
-                    processStarted(p);
-                    if (log.isErrorEnabled()) {
-                        Utils.redirectIO(p.getErrorStream(), log::error);
                 }
-                    int code = p.waitFor();
+                public void preparingCommand(List<String> commandLine) {
-                    if (code != 0)
+                    commandLine.add(cliCmd.get());
-                        throw new Exception("Process exited with the error: " + code);
+                    getSubCommand().ifPresent(commandLine::add);
+                    getSubCommandArguments().forEach(commandLine::add);
                 }
-                protected void preparingCommand(List<String> commandLine) {
+                @Override
-                    commandLine.add(cliCmd.get());
+                @Internal
+                public Optional<File> getWorkingDir() {
+                    return Optional.ofNullable(workingDir.get().getAsFile());
                 }
                 protected void setWorkingDir(Provider<File> workingDir) {
-                    this.workingDir.set(workingDir);
+                    this.workingDir.fileProvider(workingDir);
                 }
                 protected void setWorkingDir(File workingDir) {
                     this.workingDir.set(workingDir);
                 }
-                /** Invoked after the process is started, can be used to handle the process output.
-                 * Default implemetation redirects output to the logger as INFO messages.
-                 * @param p The current process.
-                 */
-                protected void processStarted(Process p) {
-                    final Logger log = getLogger();
-                    Utils.redirectIO(p.getInputStream(), log::info);
             }

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

             package org.implab.gradle.containers.tasks;
+            import java.util.ArrayList;
+            import java.util.Collection;
             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.tasks.Input;
             import org.gradle.api.tasks.Optional;
             import org.implab.gradle.containers.ImageName;
-            public abstract class PushImage extends CliTask {
+            public abstract class PushImage extends DockerCliTask {
+                public final String PUSH_COMMAND = "push";
                 @Input
                 public abstract Property<ImageName> getImageName();
                 @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;
                 }
                 @Override
-                protected void preparingCommand(List<String> commandLine) {
+                protected java.util.Optional<String> getSubCommand() {
-                    super.preparingCommand(commandLine);
+                    return java.util.Optional.of(PUSH_COMMAND);
+                }
-                    commandLine.add("push");
+                @Override
-                    commandLine.addAll(getOptions().get());
+                protected Collection<String> getSubCommandArguments() {
-                    commandLine.add(getImageName().get().toString());
+                    List<String> args = new ArrayList<>();
+                    args.addAll(getOptions().get());
+                    args.add(getImageName().get().toString());
+                    return args;
                 }
             }

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

             package org.implab.gradle.containers.tasks;
             import java.util.ArrayList;
+            import java.util.Collection;
             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.ImageName;
-            public abstract class SaveImage extends CliTask {
+            public abstract class SaveImage extends DockerCliTask {
+                public final String SAVE_COMMAND = "save";
                 @Input
                 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));
+                    getArchiveFileName().convention(provider(this::conventionalArchiveFileName));
-                    getArchiveBaseName().convention(getProject().provider(this::conventionalArchiveBaseName));
+                    getArchiveBaseName().convention(provider(this::conventionalArchiveBaseName));
-                    getArchiveVersion().convention(getProject().provider(() -> getProject().getVersion()).map(x -> x.toString()));
+                    getArchiveVersion().convention(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) {
+                protected Optional<String> getSubCommand() {
-                    super.preparingCommand(commandLine);
+                    return Optional.of(SAVE_COMMAND);
-                    commandLine.add("save");
-                    commandLine.add(getImage().get().toString());
                 }
                 @Override
-                protected void processStarted(Process p) {
+                protected Collection<String> getSubCommandArguments() {
-                    Utils.redirectIO(p.getInputStream(), getArchiveFile().get().getAsFile());
+                    return List.of(
+                        getImage().get().toString(),
+                        getArchiveFile().get().getAsFile().toString()
+                    );
                 }
             }

container/src/main/java/org/implab/gradle/containers/tasks/TagImage.java +16 -7

             package org.implab.gradle.containers.tasks;
+            import java.util.ArrayList;
+            import java.util.Collection;
             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.tasks.Input;
             import org.gradle.api.tasks.Optional;
             import org.implab.gradle.containers.ImageName;
-            public abstract class TagImage extends CliTask {
+            public abstract class TagImage extends DockerCliTask {
+                public final String TAG_COMMAND = "tag";
                 @Input
                 public abstract Property<ImageName> getSrcImage();
                 @Input
                 public abstract Property<ImageName> getDestImage();
                 @Input
                 @Optional
                 public abstract Property<String> getTransport();
                 @Input
                 @Optional
                 public abstract ListProperty<String> getOptions();
                 public TagImage option(Callable<String> provider) {
                     getOptions().add(getProject().provider(provider));
                     return this;
                 }
                 @Override
-                protected void preparingCommand(List<String> commandLine) {
+                protected java.util.Optional<String> getSubCommand() {
-                    super.preparingCommand(commandLine);
+                    return java.util.Optional.of(TAG_COMMAND);
+                }
-                    commandLine.add("tag");
+                @Override
-                    commandLine.addAll(getOptions().get());
+                protected Collection<String> getSubCommandArguments() {
-                    commandLine.add(getSrcImage().get().toString());
+                    List<String> args = new ArrayList<>();
-                    commandLine.add(getDestImage().get().toString());
+                    args.addAll(getOptions().get());
+                    args.add(getSrcImage().get().toString());
+                    args.add(getDestImage().get().toString());
+                    return args;
                 }
             }

gradle/wrapper/gradle-wrapper.jar binary modified 0 0

NO CONTENT: modified file, binary diff hidden

gradle/wrapper/gradle-wrapper.properties +3 -1

             distributionBase=GRADLE_USER_HOME
             distributionPath=wrapper/dists
-            distributionUrl=https\://services.gradle.org/distributions/gradle-6.8.3-bin.zip
+            distributionUrl=https\://services.gradle.org/distributions/gradle-8.4-bin.zip
+            networkTimeout=10000
+            validateDistributionUrl=true
             zipStoreBase=GRADLE_USER_HOME
             zipStorePath=wrapper/dists

gradlew +180 -114

@@ -1,183 +1,249
1	#!/~~usr/~~bin/~~env~~ sh	1	#!/bin/sh
2		2
3	#	3	#
4	# Copyright 2015 the original ~~author or~~ authors.	4	# Copyright © 2015-2021 the original authors.
5	#	5	#
6	# Licensed under the Apache License, Version 2.0 (the "License");	6	# Licensed under the Apache License, Version 2.0 (the "License");
7	# you may not use this file except in compliance with the License.	7	# you may not use this file except in compliance with the License.
8	# You may obtain a copy of the License at	8	# You may obtain a copy of the License at
9	#	9	#
10	# https://www.apache.org/licenses/LICENSE-2.0	10	# https://www.apache.org/licenses/LICENSE-2.0
11	#	11	#
12	# Unless required by applicable law or agreed to in writing, software	12	# Unless required by applicable law or agreed to in writing, software
13	# distributed under the License is distributed on an "AS IS" BASIS,	13	# distributed under the License is distributed on an "AS IS" BASIS,
14	# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.	14	# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15	# See the License for the specific language governing permissions and	15	# See the License for the specific language governing permissions and
16	# limitations under the License.	16	# limitations under the License.
17	#	17	#
18		18
19	##############################################################################	19	##############################################################################
20	##	20	#
21	## Gradle start up script for ~~UN*X~~	21	# Gradle start up script for POSIX generated by Gradle.
22	##	22	#
		23	# Important for running:
		24	#
		25	# (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
		26	# noncompliant, but you have some other compliant shell such as ksh or
		27	# bash, then to run this script, type that shell name before the whole
		28	# command line, like:
		29	#
		30	# ksh Gradle
		31	#
		32	# Busybox and similar reduced shells will NOT work, because this script
		33	# requires all of these POSIX shell features:
		34	# * functions;
		35	# * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
		36	# «${var#prefix}», «${var%suffix}», and «$( cmd )»;
		37	# * compound commands having a testable exit status, especially «case»;
		38	# * various built-in commands including «command», «set», and «ulimit».
		39	#
		40	# Important for patching:
		41	#
		42	# (2) This script targets any POSIX shell, so it avoids extensions provided
		43	# by Bash, Ksh, etc; in particular arrays are avoided.
		44	#
		45	# The "traditional" practice of packing multiple parameters into a
		46	# space-separated string is a well documented source of bugs and security
		47	# problems, so this is (mostly) avoided, by progressively accumulating
		48	# options in "$@", and eventually passing that to Java.
		49	#
		50	# Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
		51	# and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
		52	# see the in-line comments for details.
		53	#
		54	# There are tweaks for specific operating systems such as AIX, CygWin,
		55	# Darwin, MinGW, and NonStop.
		56	#
		57	# (3) This script is generated from the Groovy template
		58	# https://github.com/gradle/gradle/blob/HEAD/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
		59	# within the Gradle project.
		60	#
		61	# You can find Gradle at https://github.com/gradle/gradle/.
		62	#
23	##############################################################################	63	##############################################################################
24		64
25	# Attempt to set APP_HOME	65	# Attempt to set APP_HOME
		66
26	# Resolve links: $0 may be a link	67	# Resolve links: $0 may be a link
27	PRG="$0"	68	app_path=$0
28	# Need this for relative symlinks.	69
29	while [ -h "$PRG" ] ; do	70	# Need this for daisy-chained symlinks.
30	ls=`ls -ld "$PRG"`	71	while
31	link=`expr "$ls" : '.-> $.$$'`	72	APP_HOME=${app_path%"${app_path##*/}"} # leaves a trailing /; empty if no leading path
32	if expr "$link" : '/.*' > /dev/null; then	73	[ -h "$app_path" ]
33	PRG="$link"	74	do
34	else	75	ls=$( ls -ld "$app_path" )
35	PRG=`dirname "$PRG"`"/$link"	76	link=${ls#*' -> '}
36	fi	77	case $link in #(
		78	/*) app_path=$link ;; #(
		79	*) app_path=$APP_HOME$link ;;
		80	esac
37	done	81	done
38	SAVED="`pwd`"
39	cd "`dirname \"$PRG\"`/" >/dev/null
40	APP_HOME="`pwd -P`"
41	cd "$SAVED" >/dev/null
42		82
43	APP_NAME="Gradle"	83	# This is normally unused
44	APP_BASE_NAME=`basename "$0"`	84	# shellcheck disable=SC2034
45		85	APP_BASE_NAME=${0##*/}
46	# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.	86	# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
47	DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'	87	APP_HOME=$( cd "${APP_HOME:-./}" > /dev/null && pwd -P ) \|\| exit
48		88
49	# Use the maximum available, or set MAX_FD != -1 to use that value.	89	# Use the maximum available, or set MAX_FD != -1 to use that value.
50	MAX_FD="maximum"	90	MAX_FD=maximum
51		91
52	warn () {	92	warn () {
53	echo "$*"	93	echo "$*"
54	}	94	} >&2
55		95
56	die () {	96	die () {
57	echo	97	echo
58	echo "$*"	98	echo "$*"
59	echo	99	echo
60	exit 1	100	exit 1
61	}	101	} >&2
62		102
63	# OS specific support (must be 'true' or 'false').	103	# OS specific support (must be 'true' or 'false').
64	cygwin=false	104	cygwin=false
65	msys=false	105	msys=false
66	darwin=false	106	darwin=false
67	nonstop=false	107	nonstop=false
68	case "`uname`" in	108	case "$( uname )" in #(
69	CYGWIN* )	109	CYGWIN* ) cygwin=true ;; #(
70	cygwin=true	110	Darwin* ) darwin=true ;; #(
71	;;	111	MSYS* \| MINGW* ) msys=true ;; #(
72	Darwin* )	112	NONSTOP* ) nonstop=true ;;
73	darwin=true
74	;;
75	MINGW* )
76	msys=true
77	;;
78	NONSTOP* )
79	nonstop=true
80	;;
81	esac	113	esac
82		114
83	CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar	115	CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
84		116
		117
85	# Determine the Java command to use to start the JVM.	118	# Determine the Java command to use to start the JVM.
86	if [ -n "$JAVA_HOME" ] ; then	119	if [ -n "$JAVA_HOME" ] ; then
87	if [ -x "$JAVA_HOME/jre/sh/java" ] ; then	120	if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
88	# IBM's JDK on AIX uses strange locations for the executables	121	# IBM's JDK on AIX uses strange locations for the executables
89	JAVACMD="$JAVA_HOME/jre/sh/java"	122	JAVACMD=$JAVA_HOME/jre/sh/java
90	else	123	else
91	JAVACMD="$JAVA_HOME/bin/java"	124	JAVACMD=$JAVA_HOME/bin/java
92	fi	125	fi
93	if [ ! -x "$JAVACMD" ] ; then	126	if [ ! -x "$JAVACMD" ] ; then
94	die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME	127	die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
95		128
96	Please set the JAVA_HOME variable in your environment to match the	129	Please set the JAVA_HOME variable in your environment to match the
97	location of your Java installation."	130	location of your Java installation."
98	fi	131	fi
99	else	132	else
100	JAVACMD="java"	133	JAVACMD=java
101	which java >/dev/null 2>&1 \|\| die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.	134	if ! command -v java >/dev/null 2>&1
		135	then
		136	die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
102		137
103	Please set the JAVA_HOME variable in your environment to match the	138	Please set the JAVA_HOME variable in your environment to match the
104	location of your Java installation."	139	location of your Java installation."
105	fi	140	fi
106
107	# Increase the maximum file descriptors if we can.
108	if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
109	MAX_FD_LIMIT=`ulimit -H -n`
110	if [ $? -eq 0 ] ; then
111	if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
112	MAX_FD="$MAX_FD_LIMIT"
113	fi
114	ulimit -n $MAX_FD
115	if [ $? -ne 0 ] ; then
116	warn "Could not set maximum file descriptor limit: $MAX_FD"
117	fi
118	else
119	warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
120	fi
121	fi
122
123	# For Darwin, add options to specify how the application appears in the dock
124	if $darwin; then
125	GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
126	fi	141	fi
127		142
128	# For Cygwin or MSYS, switch paths to Windows format before running java	143	# Increase the maximum file descriptors if we can.
129	if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then	144	if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
130	APP_HOME=`cygpath --path --mixed "$APP_HOME"`	145	case $MAX_FD in #(
131	CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`	146	max*)
132	JAVACMD=`cygpath --unix "$JAVACMD"`	147	# In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
133		148	# shellcheck disable=SC2039,SC3045
134	# We build the pattern for arguments to be converted via cygpath	149	MAX_FD=$( ulimit -H -n ) \|\|
135	ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`	150	warn "Could not query maximum file descriptor limit"
136	SEP=""	151	esac
137	for dir in $ROOTDIRSRAW ; do	152	case $MAX_FD in #(
138	ROOTDIRS="$ROOTDIRS$SEP$dir"	153	'' \| soft) :;; #(
139	SEP="\|"	154	*)
140	done	155	# In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
141	OURCYGPATTERN="(^($ROOTDIRS))"	156	# shellcheck disable=SC2039,SC3045
142	# Add a user-defined pattern to the cygpath arguments	157	ulimit -n "$MAX_FD" \|\|
143	if [ "$GRADLE_CYGPATTERN" != "" ] ; then	158	warn "Could not set maximum file descriptor limit to $MAX_FD"
144	OURCYGPATTERN="$OURCYGPATTERN\|($GRADLE_CYGPATTERN)"
145	fi
146	# Now convert the arguments - kludge to limit ourselves to /bin/sh
147	i=0
148	for arg in "$@" ; do
149	CHECK=`echo "$arg"\|egrep -c "$OURCYGPATTERN" -`
150	CHECK2=`echo "$arg"\|egrep -c "^-"` ### Determine if an option
151
152	if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition
153	eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
154	else
155	eval `echo args$i`="\"$arg\""
156	fi
157	i=`expr $i + 1`
158	done
159	case $i in
160	0) set -- ;;
161	1) set -- "$args0" ;;
162	2) set -- "$args0" "$args1" ;;
163	3) set -- "$args0" "$args1" "$args2" ;;
164	4) set -- "$args0" "$args1" "$args2" "$args3" ;;
165	5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
166	6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
167	7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
168	8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
169	9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
170	esac	159	esac
171	fi	160	fi
172		161
173	# Escape application args	162	# Collect all arguments for the java command, stacking in reverse order:
174	save () {	163	# * args from the command line
175	for i do printf %s\\n "$i" \| sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done	164	# * the main class name
176	echo " "	165	# * -classpath
177	}	166	# * -D...appname settings
178	APP_ARGS=`save "$@"`	167	# * --module-path (only if needed)
		168	# * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
		169
		170	# For Cygwin or MSYS, switch paths to Windows format before running java
		171	if "$cygwin" \|\| "$msys" ; then
		172	APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
		173	CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
		174
		175	JAVACMD=$( cygpath --unix "$JAVACMD" )
		176
		177	# Now convert the arguments - kludge to limit ourselves to /bin/sh
		178	for arg do
		179	if
		180	case $arg in #(
		181	-*) false ;; # don't mess with options #(
		182	/?) t=${arg#/} t=/${t%%/} # looks like a POSIX filepath
		183	[ -e "$t" ] ;; #(
		184	*) false ;;
		185	esac
		186	then
		187	arg=$( cygpath --path --ignore --mixed "$arg" )
		188	fi
		189	# Roll the args list around exactly as many times as the number of
		190	# args, so each arg winds up back in the position where it started, but
		191	# possibly modified.
		192	#
		193	# NB: a `for` loop captures its iteration list before it begins, so
		194	# changing the positional parameters here affects neither the number of
		195	# iterations, nor the values presented in `arg`.
		196	shift # remove old arg
		197	set -- "$@" "$arg" # push replacement arg
		198	done
		199	fi
		200
		201
		202	# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
		203	DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
179		204
180	# Collect all arguments for the java command~~, following the shell quoting and substitution rules~~	205	# Collect all arguments for the java command:
181	eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"	206	# * DEFAULT_JVM_OPTS, JAVA_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
		207	# and any embedded shellness will be escaped.
		208	# * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
		209	# treated as '${Hostname}' itself on the command line.
		210
		211	set -- \
		212	"-Dorg.gradle.appname=$APP_BASE_NAME" \
		213	-classpath "$CLASSPATH" \
		214	org.gradle.wrapper.GradleWrapperMain \
		215	"$@"
		216
		217	# Stop when "xargs" is not available.
		218	if ! command -v xargs >/dev/null 2>&1
		219	then
		220	die "xargs is not available"
		221	fi
		222
		223	# Use "xargs" to parse quoted args.
		224	#
		225	# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
		226	#
		227	# In Bash we could simply go:
		228	#
		229	# readarray ARGS < <( xargs -n1 <<<"$var" ) &&
		230	# set -- "${ARGS[@]}" "$@"
		231	#
		232	# but POSIX shell has neither arrays nor command substitution, so instead we
		233	# post-process each arg (as a line of input to sed) to backslash-escape any
		234	# character that might be a shell metacharacter, then use eval to reverse
		235	# that process (while maintaining the separation between arguments), and wrap
		236	# the whole thing up as a single "set" statement.
		237	#
		238	# This will of course break if any of these variables contains a newline or
		239	# an unmatched quote.
		240	#
		241
		242	eval "set -- $(
		243	printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" \|
		244	xargs -n1 \|
		245	sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' \|
		246	tr '\n' ' '
		247	)" '"$@"'
182		248
183	exec "$JAVACMD" "$@"	249	exec "$JAVACMD" "$@"

gradlew.bat +13 -21

             @rem
             @rem Copyright 2015 the original author or authors.
             @rem
             @rem Licensed under the Apache License, Version 2.0 (the "License");
             @rem you may not use this file except in compliance with the License.
             @rem You may obtain a copy of the License at
             @rem
             @rem      https://www.apache.org/licenses/LICENSE-2.0
             @rem
             @rem Unless required by applicable law or agreed to in writing, software
             @rem distributed under the License is distributed on an "AS IS" BASIS,
             @rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
             @rem See the License for the specific language governing permissions and
             @rem limitations under the License.
             @rem
             @if "%DEBUG%"=="" @echo off
             @rem ##########################################################################
             @rem
             @rem  Gradle startup script for Windows
             @rem
             @rem ##########################################################################
             @rem Set local scope for the variables with windows NT shell
             if "%OS%"=="Windows_NT" setlocal
             set DIRNAME=%~dp0
             if "%DIRNAME%"=="" set DIRNAME=.
+            @rem This is normally unused
             set APP_BASE_NAME=%~n0
             set APP_HOME=%DIRNAME%
+            @rem Resolve any "." and ".." in APP_HOME to make it shorter.
+            for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
             @rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
             set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
             @rem Find java.exe
             if defined JAVA_HOME goto findJavaFromJavaHome
             set JAVA_EXE=java.exe
             %JAVA_EXE% -version >NUL 2>&1
-            if "%ERRORLEVEL%" == "0" goto init
+            if %ERRORLEVEL% equ 0 goto execute
             echo.
             echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
             echo.
             echo Please set the JAVA_HOME variable in your environment to match the
             echo location of your Java installation.
             goto fail
             :findJavaFromJavaHome
             set JAVA_HOME=%JAVA_HOME:"=%
             set JAVA_EXE=%JAVA_HOME%/bin/java.exe
-            if exist "%JAVA_EXE%" goto init
+            if exist "%JAVA_EXE%" goto execute
             echo.
             echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
             echo.
             echo Please set the JAVA_HOME variable in your environment to match the
             echo location of your Java installation.
             goto fail
-            :init
-            @rem Get command-line arguments, handling Windows variants
-            if not "%OS%" == "Windows_NT" goto win9xME_args
-            :win9xME_args
-            @rem Slurp the command line arguments.
-            set CMD_LINE_ARGS=
-            set _SKIP=2
-            :win9xME_args_slurp
-            if "x%~1" == "x" goto execute
-            set CMD_LINE_ARGS=%*
             :execute
             @rem Setup the command line
             set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
             @rem Execute Gradle
-            "%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
+            "%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
             :end
             @rem End local scope for the variables with windows NT shell
-            if "%ERRORLEVEL%"=="0" goto mainEnd
+            if %ERRORLEVEL% equ 0 goto mainEnd
             :fail
             rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
             rem the _cmd.exe /c_ return code!
-            if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+            set EXIT_CODE=%ERRORLEVEL%
-            exit /b 1
+            if %EXIT_CODE% equ 0 set EXIT_CODE=1
+            if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
+            exit /b %EXIT_CODE%
             :mainEnd
             if "%OS%"=="Windows_NT" endlocal
             :omega

settings.gradle +1 -1

             /*
              * This settings file was generated by the Gradle 'init' task.
              *
              * The settings file is used to specify which projects to include in your build.
              * In a single project build this file can be empty or even removed.
              *
              * Detailed information about configuring a multi-project build in Gradle can be found
              * in the user guide at https://docs.gradle.org/3.5/userguide/multi_project_builds.html
              */
-            rootProject.name = 'plugins'
+            rootProject.name = 'implab-gradle'
             include 'container'

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

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