##// END OF EJS Templates
implab » gradle-container-plugin
RSS
Bump gradle, tasks refactoring
cin -
r8:e992157ede55 default
parent child
Show More
Show file before | Show file after | Hide comments
@@ -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 }
Show file before | Show file after | Hide comments
@@ -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 }
Show file before | Show file after | Hide comments
@@ -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
Show file before | Show file after | Hide comments
@@ -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 }
Show file before | Show file after | Hide comments
@@ -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 }
Show file before | Show file after | Hide comments
@@ -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 }
Show file before | Show file after | Hide comments
@@ -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
Show file before | Show file after | Hide comments
@@ -1,27 +1,40
1 1 plugins {
2 2 id "java-gradle-plugin"
3 id "com.gradle.plugin-publish" version "0.16.0"
3 id "com.gradle.plugin-publish" version "1.2.1"
4 // Maven Publish Plugin applied by com.gradle.plugin-publish > 1.0
5 id "ivy-publish"
4 6 }
5 7
6 8
7 9 repositories {
8 10 mavenCentral()
9 11 }
10 12
11 13 gradlePlugin {
14 website = 'https://code.implab.org/implab/gradle-container-plugin'
15 vcsUrl = 'https://code.implab.org/implab/gradle-container-plugin'
12 16 plugins {
13 17 containerPlugin {
14 18 id = 'org.implab.gradle-container'
15 19 displayName = "Container building plugin"
16 20 description = 'Build and publish container images with docker or podman. Simple wrapper around cli.'
17 21 implementationClass = 'org.implab.gradle.containers.ContainerPlugin'
22 tags.set(['containers', 'image', 'docker', 'podman'])
18 23 }
19 24 }
20 25 }
21 26
22 pluginBundle {
23 website = 'https://code.implab.org/implab/gradle-container-plugin'
24 vcsUrl = 'https://code.implab.org/implab/gradle-container-plugin'
27
28 task printVersion {
29 doLast {
30 println "${->jar.archiveFileName.get()}"
31 }
32 }
25 33
26 tags = ['containers', 'image', 'docker', 'podman']
34 publishing {
35 repositories {
36 ivy {
37 url "${System.properties["user.home"]}/ivy-repo"
38 }
39 }
27 40 }
Show file before | Show file after | Hide comments
@@ -1,2 +1,2
1 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
Show file before | Show file after | Hide comments
@@ -1,95 +1,101
1 1 package org.implab.gradle.containers;
2 2
3 3 import org.gradle.api.Plugin;
4 4 import org.gradle.api.Project;
5 5 import org.gradle.api.artifacts.Dependency;
6 6 import org.gradle.api.file.ProjectLayout;
7 7 import org.gradle.api.model.ObjectFactory;
8 8 import org.gradle.api.plugins.ExtraPropertiesExtension;
9 9 import org.gradle.api.tasks.Copy;
10 10 import org.gradle.api.tasks.Delete;
11 11 import org.gradle.api.tasks.TaskProvider;
12 12 import org.implab.gradle.containers.tasks.BuildImage;
13 13 import org.implab.gradle.containers.tasks.PushImage;
14 import org.implab.gradle.containers.tasks.RunImage;
14 15 import org.implab.gradle.containers.tasks.SaveImage;
15 16 import org.implab.gradle.containers.tasks.TagImage;
16 17
17 18 public class ContainerPlugin implements Plugin<Project> {
18 19
19 20 public static final String BUILD_GROUP = "build";
20 21
21 22 public static final String CONTAINER_EXTENSION_NAME = "container";
22 23
23 24 public static final String ARCHIVE_CONFIGURATION = "archive";
24 25
25 26 private ContainerExtension containerExtension;
26 27
28 void exportClasses(Project project, Class<?>... classes) {
29 ExtraPropertiesExtension extras = project.getExtensions().getExtraProperties();
30 for (var clazz : classes)
31 extras.set(clazz.getSimpleName(), clazz);
32 }
33
27 34 public void apply(Project project) {
28 35 ObjectFactory factory = project.getObjects();
29 36 ProjectLayout layout = project.getLayout();
30 37 containerExtension = new ContainerExtension(factory, layout, project);
31 38
32 39 containerExtension.getImageAuthority()
33 40 .convention(project.provider(() -> (String) project.getProperties().get("imagesAuthority")));
34 41
35 42 containerExtension.getImageGroup()
36 43 .convention(project.provider(() -> (String) project.getProperties().get("imagesGroup")));
37 44
38 45 project.getExtensions().add(CONTAINER_EXTENSION_NAME, containerExtension);
39 46
40 ExtraPropertiesExtension extras = project.getExtensions().getExtraProperties();
41 extras.set(BuildImage.class.getSimpleName(), BuildImage.class);
42 extras.set(PushImage.class.getSimpleName(), PushImage.class);
43 extras.set(SaveImage.class.getSimpleName(), SaveImage.class);
44 extras.set(TagImage.class.getSimpleName(), TagImage.class);
47 exportClasses(
48 project,
49 BuildImage.class, PushImage.class, SaveImage.class, TagImage.class, RunImage.class);
45 50
46 51 project.getConfigurations().create(Dependency.DEFAULT_CONFIGURATION, c -> {
47 52 c.setCanBeConsumed(true);
48 53 c.setCanBeResolved(false);
49 54 });
50 55
51 56 project.getConfigurations().create(ARCHIVE_CONFIGURATION, c -> {
52 57 c.setCanBeConsumed(true);
53 58 c.setCanBeResolved(false);
54 59 });
55 60
56 61 TaskProvider<Copy> processResourcesTask = project.getTasks().register("processResources", Copy.class, t -> {
57 62 t.setGroup(BUILD_GROUP);
58 63 t.from(layout.getProjectDirectory().dir("src/main"));
59 64 t.into(containerExtension.getContextDirectory());
60 65 });
61 66
62 67 TaskProvider<BuildImage> buildImageTask = project.getTasks().register("buildImage", BuildImage.class, t -> {
63 68 t.setGroup(BUILD_GROUP);
64 69 t.dependsOn(processResourcesTask);
65 70
66 71 t.getContextDirectory().set(containerExtension.getContextDirectory());
67 72 t.getImageIdFile().set(containerExtension.getImageIdFile());
68 73
69 74 t.getImageName().set(containerExtension.getImageName());
70 75 });
71 76
72 77 project.getTasks().register("clean", Delete.class, t -> {
73 78 t.delete(layout.getBuildDirectory());
74 79 });
75 80
76 81 project.getTasks().register("build", t -> {
77 82 t.setGroup(BUILD_GROUP);
78 83 t.dependsOn(buildImageTask);
79 84 });
80 85
81 86 project.getTasks().register("pushImage", PushImage.class, t -> {
82 87 t.dependsOn(buildImageTask);
83 88 t.getImageName().set(buildImageTask.flatMap(b -> b.getImageName()));
84 89 });
85 90
86 91 project.getTasks().register("saveImage", SaveImage.class, t -> {
87 92 t.dependsOn(buildImageTask);
88 93 t.getImage().set(buildImageTask.flatMap(b -> b.getImageName()));
89 94 });
90 95
91 project.getArtifacts().add(Dependency.DEFAULT_CONFIGURATION, buildImageTask.flatMap(x -> x.getImageIdFile()), t -> {
92 t.builtBy(buildImageTask);
93 });
96 project.getArtifacts().add(Dependency.DEFAULT_CONFIGURATION, buildImageTask.flatMap(x -> x.getImageIdFile()),
97 t -> {
98 t.builtBy(buildImageTask);
99 });
94 100 }
95 101 }
Show file before | Show file after | Hide comments
@@ -1,43 +1,96
1 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 7 import java.util.List;
8 import java.util.Map;
9 import java.util.Optional;
4 10
11 import org.gradle.api.Action;
5 12 import org.gradle.api.file.DirectoryProperty;
6 13 import org.gradle.api.file.RegularFileProperty;
14 import org.gradle.api.provider.ListProperty;
15 import org.gradle.api.provider.MapProperty;
7 16 import org.gradle.api.provider.Property;
17 import org.gradle.api.provider.Provider;
8 18 import org.gradle.api.tasks.Input;
9 19 import org.gradle.api.tasks.InputDirectory;
10 20 import org.gradle.api.tasks.OutputFile;
11 21 import org.gradle.api.tasks.SkipWhenEmpty;
12 import org.implab.gradle.Utils;
13 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 31 @InputDirectory
17 32 @SkipWhenEmpty
18 33 public abstract DirectoryProperty getContextDirectory();
19 34
20 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 45 public abstract Property<ImageName> getImageName();
22 46
23 47 @OutputFile
24 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 67 @Override
32 protected void preparingCommand(List<String> commandLine) {
33 super.preparingCommand(commandLine);
68 protected Collection<String> getSubCommandArguments() {
69 List<String> args = new ArrayList<>();
70
71 args.addAll(List.of(
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 });
80 }
34 81
35 commandLine.addAll(List.of("build", ".", "-q", "-t"));
36 commandLine.add(getImageName().get().toString());
37 }
82 // add --target if specified for multi-stage build
83 if (getBuildTarget().isPresent()) {
84 args.add("--target");
85 args.add(getBuildTarget().get());
86 }
38 87
39 @Override
40 protected void processStarted(Process p) {
41 Utils.redirectIO(p.getInputStream(), getImageIdFile().get().getAsFile());
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 }
Show file before | Show file after | Hide comments
@@ -1,93 +1,81
1 1 package org.implab.gradle.containers.tasks;
2 2
3 3 import java.io.File;
4 import java.util.ArrayList;
4 import java.util.Collection;
5 import java.util.Collections;
5 6 import java.util.List;
7 import java.util.Optional;
6 8
7 9 import org.gradle.api.DefaultTask;
8 import org.gradle.api.logging.Logger;
10 import org.gradle.api.file.DirectoryProperty;
9 11 import org.gradle.api.provider.Property;
10 12 import org.gradle.api.provider.Provider;
11 13 import org.gradle.api.tasks.Input;
12 14 import org.gradle.api.tasks.Internal;
13 15 import org.gradle.api.tasks.TaskAction;
14 import org.implab.gradle.Utils;
15 16 import org.implab.gradle.containers.ContainerExtension;
17 import org.implab.gradle.containers.ExecuteMixin;
18 import org.implab.gradle.containers.PropertiesMixin;
16 19
17 public abstract class CliTask extends DefaultTask {
20 public abstract class DockerCliTask extends DefaultTask implements PropertiesMixin, ExecuteMixin {
18 21
19 22 private final Property<String> cliCmd;
20 23
21 private final Property<File> workingDir;
24 private final DirectoryProperty workingDir;
25
26 public DockerCliTask() {
27 cliCmd = property(String.class)
28 .convention(getContainerExtension().getCliCmd());
29
30 workingDir = directoryProperty();
31 }
22 32
23 public CliTask() {
24 cliCmd = getProject().getObjects().property(String.class);
25 cliCmd.convention(getContainerExtension().getCliCmd());
33 @Internal
34 protected Optional<String> getSubCommand() {
35 return Optional.empty();
36 }
26 37
27 workingDir = getProject().getObjects().property(File.class);
38 @Internal
39 protected Collection<String> getSubCommandArguments() {
40 return Collections.emptyList();
28 41 }
29 42
30 43 @Input
31 44 public Property<String> getCliCmd() {
32 45 return cliCmd;
33 46 }
34 47
35 48 public void setCliCmd(String cliCmd) {
36 49 this.cliCmd.set(cliCmd);
37 50 }
38 51
39 52 @Internal
40 53 protected ContainerExtension getContainerExtension() {
41 54 return getProject().getExtensions().getByType(ContainerExtension.class);
42 55 }
43 56
44 57 @TaskAction
45 58 public void Run() throws Exception {
46 final Logger log = getLogger();
47
48 List<String> args = new ArrayList<>();
49 preparingCommand(args);
50
51 ProcessBuilder builder = new ProcessBuilder(args);
52 if (workingDir.isPresent())
53 builder.directory(workingDir.get());
54
55 log.info("Starting: {}", builder.command());
56
57 Process p = builder.start();
58
59 processStarted(p);
60
61 if (log.isErrorEnabled()) {
62 Utils.redirectIO(p.getErrorStream(), log::error);
63 }
64
65 int code = p.waitFor();
66 if (code != 0)
67 throw new Exception("Process exited with the error: " + code);
59 Execute();
68 60 }
69 61
70 protected void preparingCommand(List<String> commandLine) {
62 public void preparingCommand(List<String> commandLine) {
71 63 commandLine.add(cliCmd.get());
64 getSubCommand().ifPresent(commandLine::add);
65 getSubCommandArguments().forEach(commandLine::add);
66 }
67
68 @Override
69 @Internal
70 public Optional<File> getWorkingDir() {
71 return Optional.ofNullable(workingDir.get().getAsFile());
72 72 }
73 73
74 74 protected void setWorkingDir(Provider<File> workingDir) {
75 this.workingDir.set(workingDir);
75 this.workingDir.fileProvider(workingDir);
76 76 }
77 77
78 78 protected void setWorkingDir(File workingDir) {
79 79 this.workingDir.set(workingDir);
80 80 }
81
82
83 /** Invoked after the process is started, can be used to handle the process output.
84 *
85 * Default implemetation redirects output to the logger as INFO messages.
86 *
87 * @param p The current process.
88 */
89 protected void processStarted(Process p) {
90 final Logger log = getLogger();
91 Utils.redirectIO(p.getInputStream(), log::info);
92 }
93 81 }
Show file before | Show file after | Hide comments
@@ -1,38 +1,48
1 1 package org.implab.gradle.containers.tasks;
2 2
3 import java.util.ArrayList;
4 import java.util.Collection;
3 5 import java.util.List;
4 6 import java.util.concurrent.Callable;
5 7
6 8 import org.gradle.api.provider.ListProperty;
7 9 import org.gradle.api.provider.Property;
8 10 import org.gradle.api.tasks.Input;
9 11 import org.gradle.api.tasks.Optional;
10 12 import org.implab.gradle.containers.ImageName;
11 13
12 public abstract class PushImage extends CliTask {
14 public abstract class PushImage extends DockerCliTask {
15
16 public final String PUSH_COMMAND = "push";
13 17
14 18 @Input
15 19 public abstract Property<ImageName> getImageName();
16 20
17 21 @Input
18 22 @Optional
19 23 public abstract Property<String> getTransport();
20 24
21 25 @Input
22 26 @Optional
23 27 public abstract ListProperty<String> getOptions();
24 28
25 29 public PushImage option(Callable<String> provider) {
26 30 getOptions().add(getProject().provider(provider));
27 31 return this;
28 32 }
29 33
30 34 @Override
31 protected void preparingCommand(List<String> commandLine) {
32 super.preparingCommand(commandLine);
35 protected java.util.Optional<String> getSubCommand() {
36 return java.util.Optional.of(PUSH_COMMAND);
37 }
33 38
34 commandLine.add("push");
35 commandLine.addAll(getOptions().get());
36 commandLine.add(getImageName().get().toString());
39 @Override
40 protected Collection<String> getSubCommandArguments() {
41 List<String> args = new ArrayList<>();
42
43 args.addAll(getOptions().get());
44 args.add(getImageName().get().toString());
45
46 return args;
37 47 }
38 48 }
Show file before | Show file after | Hide comments
@@ -1,91 +1,92
1 1 package org.implab.gradle.containers.tasks;
2 2
3 3 import java.util.ArrayList;
4 import java.util.Collection;
4 5 import java.util.List;
5 6 import java.util.Optional;
6 7
7 8 import org.gradle.api.file.DirectoryProperty;
8 9 import org.gradle.api.file.RegularFile;
9 10 import org.gradle.api.provider.Property;
10 11 import org.gradle.api.provider.Provider;
11 12 import org.gradle.api.tasks.Input;
12 13 import org.gradle.api.tasks.Internal;
13 14 import org.gradle.api.tasks.OutputFile;
14 15 import org.gradle.api.tasks.TaskExecutionException;
15 import org.implab.gradle.Utils;
16 16 import org.implab.gradle.containers.ImageName;
17 17
18 public abstract class SaveImage extends CliTask {
18 public abstract class SaveImage extends DockerCliTask {
19 public final String SAVE_COMMAND = "save";
19 20
20 21 @Input
21 22 public abstract Property<ImageName> getImage();
22 23
23 24 @OutputFile
24 25 public Provider<RegularFile> getArchiveFile() {
25 26 return getDestinationDirectory().file(getArchiveFileName());
26 27 }
27 28
28 29 @Internal
29 30 public abstract DirectoryProperty getDestinationDirectory();
30 31
31 32 @Internal
32 33 public abstract Property<String> getArchiveFileName();
33 34
34 35 @Internal
35 36 public abstract Property<String> getArchiveBaseName();
36 37
37 38 @Internal
38 39 public abstract Property<String> getArchiveVersion();
39 40
40 41 @Internal
41 42 public abstract Property<String> getArchiveClassifier();
42 43
43 44 @Internal
44 45 public abstract Property<String> getArchiveExtension();
45 46
46 47 public SaveImage() {
47 getArchiveFileName().convention(getProject().provider(this::conventionalArchiveFileName));
48 getArchiveBaseName().convention(getProject().provider(this::conventionalArchiveBaseName));
49 getArchiveVersion().convention(getProject().provider(() -> getProject().getVersion()).map(x -> x.toString()));
48 getArchiveFileName().convention(provider(this::conventionalArchiveFileName));
49 getArchiveBaseName().convention(provider(this::conventionalArchiveBaseName));
50 getArchiveVersion().convention(provider(() -> getProject().getVersion()).map(x -> x.toString()));
50 51 getDestinationDirectory().convention(getProject().getLayout().getBuildDirectory());
51 52 getArchiveExtension().convention("tar");
52 53 }
53 54
54 55 private String conventionalArchiveBaseName() {
55 56 ArrayList<String> parts = new ArrayList<>();
56 57 Optional.of(getProject().getGroup()).map(x -> x.toString()).ifPresent(parts::add);
57 58 parts.add(getProject().getName());
58 59 return String.join("-", parts);
59 60 }
60 61
61 62 private String conventionalArchiveFileName() {
62 63 ArrayList<String> parts = new ArrayList<>();
63 64
64 65 if (getArchiveBaseName().isPresent())
65 66 parts.add(getArchiveBaseName().get());
66 67
67 68 if (getArchiveVersion().isPresent())
68 69 parts.add(getArchiveVersion().get());
69 70
70 71 if (getArchiveClassifier().isPresent())
71 72 parts.add(getArchiveClassifier().get());
72 73
73 74 if (parts.size() == 0)
74 75 throw new TaskExecutionException(this, new Exception("The archiveFileName ism't specified"));
75 76
76 77 return String.join("-", parts) + "." + getArchiveExtension().get();
77 78 }
78 79
79 80 @Override
80 protected void preparingCommand(List<String> commandLine) {
81 super.preparingCommand(commandLine);
82
83 commandLine.add("save");
84 commandLine.add(getImage().get().toString());
81 protected Optional<String> getSubCommand() {
82 return Optional.of(SAVE_COMMAND);
85 83 }
86 84
87 85 @Override
88 protected void processStarted(Process p) {
89 Utils.redirectIO(p.getInputStream(), getArchiveFile().get().getAsFile());
86 protected Collection<String> getSubCommandArguments() {
87 return List.of(
88 getImage().get().toString(),
89 getArchiveFile().get().getAsFile().toString()
90 );
90 91 }
91 92 }
Show file before | Show file after | Hide comments
@@ -1,42 +1,51
1 1 package org.implab.gradle.containers.tasks;
2 2
3 import java.util.ArrayList;
4 import java.util.Collection;
3 5 import java.util.List;
4 6 import java.util.concurrent.Callable;
5 7
6 8 import org.gradle.api.provider.ListProperty;
7 9 import org.gradle.api.provider.Property;
8 10 import org.gradle.api.tasks.Input;
9 11 import org.gradle.api.tasks.Optional;
10 12 import org.implab.gradle.containers.ImageName;
11 13
12 public abstract class TagImage extends CliTask {
14 public abstract class TagImage extends DockerCliTask {
15 public final String TAG_COMMAND = "tag";
13 16
14 17 @Input
15 18 public abstract Property<ImageName> getSrcImage();
16 19
17 20 @Input
18 21 public abstract Property<ImageName> getDestImage();
19 22
20 23 @Input
21 24 @Optional
22 25 public abstract Property<String> getTransport();
23 26
24 27 @Input
25 28 @Optional
26 29 public abstract ListProperty<String> getOptions();
27 30
28 31 public TagImage option(Callable<String> provider) {
29 32 getOptions().add(getProject().provider(provider));
30 33 return this;
31 34 }
32 35
33 36 @Override
34 protected void preparingCommand(List<String> commandLine) {
35 super.preparingCommand(commandLine);
37 protected java.util.Optional<String> getSubCommand() {
38 return java.util.Optional.of(TAG_COMMAND);
39 }
36 40
37 commandLine.add("tag");
38 commandLine.addAll(getOptions().get());
39 commandLine.add(getSrcImage().get().toString());
40 commandLine.add(getDestImage().get().toString());
41 @Override
42 protected Collection<String> getSubCommandArguments() {
43 List<String> args = new ArrayList<>();
44
45 args.addAll(getOptions().get());
46 args.add(getSrcImage().get().toString());
47 args.add(getDestImage().get().toString());
48
49 return args;
41 50 }
42 51 }
Show file before | Show file after | Hide comments
1 NO CONTENT: modified file, binary diff hidden
Show file before | Show file after | Hide comments
@@ -1,5 +1,7
1 1 distributionBase=GRADLE_USER_HOME
2 2 distributionPath=wrapper/dists
3 distributionUrl=https\://services.gradle.org/distributions/gradle-6.8.3-bin.zip
3 distributionUrl=https\://services.gradle.org/distributions/gradle-8.4-bin.zip
4 networkTimeout=10000
5 validateDistributionUrl=true
4 6 zipStoreBase=GRADLE_USER_HOME
5 7 zipStorePath=wrapper/dists
Show file before | Show file after | Hide comments
@@ -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 6 # Licensed under the Apache License, Version 2.0 (the "License");
7 7 # you may not use this file except in compliance with the License.
8 8 # You may obtain a copy of the License at
9 9 #
10 10 # https://www.apache.org/licenses/LICENSE-2.0
11 11 #
12 12 # Unless required by applicable law or agreed to in writing, software
13 13 # distributed under the License is distributed on an "AS IS" BASIS,
14 14 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 15 # See the License for the specific language governing permissions and
16 16 # limitations under the License.
17 17 #
18 18
19 19 ##############################################################################
20 ##
21 ## Gradle start up script for UN*X
22 ##
20 #
21 # Gradle start up script for POSIX generated by Gradle.
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 65 # Attempt to set APP_HOME
66
26 67 # Resolve links: $0 may be a link
27 PRG="$0"
28 # Need this for relative symlinks.
29 while [ -h "$PRG" ] ; do
30 ls=`ls -ld "$PRG"`
31 link=`expr "$ls" : '.*-> \(.*\)$'`
32 if expr "$link" : '/.*' > /dev/null; then
33 PRG="$link"
34 else
35 PRG=`dirname "$PRG"`"/$link"
36 fi
68 app_path=$0
69
70 # Need this for daisy-chained symlinks.
71 while
72 APP_HOME=${app_path%"${app_path##*/}"} # leaves a trailing /; empty if no leading path
73 [ -h "$app_path" ]
74 do
75 ls=$( ls -ld "$app_path" )
76 link=${ls#*' -> '}
77 case $link in #(
78 /*) app_path=$link ;; #(
79 *) app_path=$APP_HOME$link ;;
80 esac
37 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"
44 APP_BASE_NAME=`basename "$0"`
45
46 # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
47 DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
83 # This is normally unused
84 # shellcheck disable=SC2034
85 APP_BASE_NAME=${0##*/}
86 # Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
87 APP_HOME=$( cd "${APP_HOME:-./}" > /dev/null && pwd -P ) || exit
48 88
49 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 92 warn () {
53 93 echo "$*"
54 }
94 } >&2
55 95
56 96 die () {
57 97 echo
58 98 echo "$*"
59 99 echo
60 100 exit 1
61 }
101 } >&2
62 102
63 103 # OS specific support (must be 'true' or 'false').
64 104 cygwin=false
65 105 msys=false
66 106 darwin=false
67 107 nonstop=false
68 case "`uname`" in
69 CYGWIN* )
70 cygwin=true
71 ;;
72 Darwin* )
73 darwin=true
74 ;;
75 MINGW* )
76 msys=true
77 ;;
78 NONSTOP* )
79 nonstop=true
80 ;;
108 case "$( uname )" in #(
109 CYGWIN* ) cygwin=true ;; #(
110 Darwin* ) darwin=true ;; #(
111 MSYS* | MINGW* ) msys=true ;; #(
112 NONSTOP* ) nonstop=true ;;
81 113 esac
82 114
83 115 CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
84 116
117
85 118 # Determine the Java command to use to start the JVM.
86 119 if [ -n "$JAVA_HOME" ] ; then
87 120 if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
88 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 123 else
91 JAVACMD="$JAVA_HOME/bin/java"
124 JAVACMD=$JAVA_HOME/bin/java
92 125 fi
93 126 if [ ! -x "$JAVACMD" ] ; then
94 127 die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
95 128
96 129 Please set the JAVA_HOME variable in your environment to match the
97 130 location of your Java installation."
98 131 fi
99 132 else
100 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.
133 JAVACMD=java
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 138 Please set the JAVA_HOME variable in your environment to match the
104 139 location of your Java installation."
105 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 140 fi
121 141 fi
122 142
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
127
128 # For Cygwin or MSYS, switch paths to Windows format before running java
129 if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
130 APP_HOME=`cygpath --path --mixed "$APP_HOME"`
131 CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
132 JAVACMD=`cygpath --unix "$JAVACMD"`
133
134 # We build the pattern for arguments to be converted via cygpath
135 ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
136 SEP=""
137 for dir in $ROOTDIRSRAW ; do
138 ROOTDIRS="$ROOTDIRS$SEP$dir"
139 SEP="|"
140 done
141 OURCYGPATTERN="(^($ROOTDIRS))"
142 # Add a user-defined pattern to the cygpath arguments
143 if [ "$GRADLE_CYGPATTERN" != "" ] ; then
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" ;;
143 # Increase the maximum file descriptors if we can.
144 if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
145 case $MAX_FD in #(
146 max*)
147 # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
148 # shellcheck disable=SC2039,SC3045
149 MAX_FD=$( ulimit -H -n ) ||
150 warn "Could not query maximum file descriptor limit"
151 esac
152 case $MAX_FD in #(
153 '' | soft) :;; #(
154 *)
155 # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
156 # shellcheck disable=SC2039,SC3045
157 ulimit -n "$MAX_FD" ||
158 warn "Could not set maximum file descriptor limit to $MAX_FD"
170 159 esac
171 160 fi
172 161
173 # Escape application args
174 save () {
175 for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
176 echo " "
177 }
178 APP_ARGS=`save "$@"`
162 # Collect all arguments for the java command, stacking in reverse order:
163 # * args from the command line
164 # * the main class name
165 # * -classpath
166 # * -D...appname settings
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
181 eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
205 # Collect all arguments for the java command:
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 249 exec "$JAVACMD" "$@"
Show file before | Show file after | Hide comments
@@ -1,100 +1,92
1 1 @rem
2 2 @rem Copyright 2015 the original author or authors.
3 3 @rem
4 4 @rem Licensed under the Apache License, Version 2.0 (the "License");
5 5 @rem you may not use this file except in compliance with the License.
6 6 @rem You may obtain a copy of the License at
7 7 @rem
8 8 @rem https://www.apache.org/licenses/LICENSE-2.0
9 9 @rem
10 10 @rem Unless required by applicable law or agreed to in writing, software
11 11 @rem distributed under the License is distributed on an "AS IS" BASIS,
12 12 @rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 13 @rem See the License for the specific language governing permissions and
14 14 @rem limitations under the License.
15 15 @rem
16 16
17 @if "%DEBUG%" == "" @echo off
17 @if "%DEBUG%"=="" @echo off
18 18 @rem ##########################################################################
19 19 @rem
20 20 @rem Gradle startup script for Windows
21 21 @rem
22 22 @rem ##########################################################################
23 23
24 24 @rem Set local scope for the variables with windows NT shell
25 25 if "%OS%"=="Windows_NT" setlocal
26 26
27 27 set DIRNAME=%~dp0
28 if "%DIRNAME%" == "" set DIRNAME=.
28 if "%DIRNAME%"=="" set DIRNAME=.
29 @rem This is normally unused
29 30 set APP_BASE_NAME=%~n0
30 31 set APP_HOME=%DIRNAME%
31 32
33 @rem Resolve any "." and ".." in APP_HOME to make it shorter.
34 for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
35
32 36 @rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
33 37 set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
34 38
35 39 @rem Find java.exe
36 40 if defined JAVA_HOME goto findJavaFromJavaHome
37 41
38 42 set JAVA_EXE=java.exe
39 43 %JAVA_EXE% -version >NUL 2>&1
40 if "%ERRORLEVEL%" == "0" goto init
44 if %ERRORLEVEL% equ 0 goto execute
41 45
42 46 echo.
43 47 echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
44 48 echo.
45 49 echo Please set the JAVA_HOME variable in your environment to match the
46 50 echo location of your Java installation.
47 51
48 52 goto fail
49 53
50 54 :findJavaFromJavaHome
51 55 set JAVA_HOME=%JAVA_HOME:"=%
52 56 set JAVA_EXE=%JAVA_HOME%/bin/java.exe
53 57
54 if exist "%JAVA_EXE%" goto init
58 if exist "%JAVA_EXE%" goto execute
55 59
56 60 echo.
57 61 echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
58 62 echo.
59 63 echo Please set the JAVA_HOME variable in your environment to match the
60 64 echo location of your Java installation.
61 65
62 66 goto fail
63 67
64 :init
65 @rem Get command-line arguments, handling Windows variants
66
67 if not "%OS%" == "Windows_NT" goto win9xME_args
68
69 :win9xME_args
70 @rem Slurp the command line arguments.
71 set CMD_LINE_ARGS=
72 set _SKIP=2
73
74 :win9xME_args_slurp
75 if "x%~1" == "x" goto execute
76
77 set CMD_LINE_ARGS=%*
78
79 68 :execute
80 69 @rem Setup the command line
81 70
82 71 set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
83 72
73
84 74 @rem Execute Gradle
85 "%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
75 "%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
86 76
87 77 :end
88 78 @rem End local scope for the variables with windows NT shell
89 if "%ERRORLEVEL%"=="0" goto mainEnd
79 if %ERRORLEVEL% equ 0 goto mainEnd
90 80
91 81 :fail
92 82 rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
93 83 rem the _cmd.exe /c_ return code!
94 if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
95 exit /b 1
84 set EXIT_CODE=%ERRORLEVEL%
85 if %EXIT_CODE% equ 0 set EXIT_CODE=1
86 if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
87 exit /b %EXIT_CODE%
96 88
97 89 :mainEnd
98 90 if "%OS%"=="Windows_NT" endlocal
99 91
100 92 :omega
Show file before | Show file after | Hide comments
@@ -1,13 +1,13
1 1 /*
2 2 * This settings file was generated by the Gradle 'init' task.
3 3 *
4 4 * The settings file is used to specify which projects to include in your build.
5 5 * In a single project build this file can be empty or even removed.
6 6 *
7 7 * Detailed information about configuring a multi-project build in Gradle can be found
8 8 * in the user guide at https://docs.gradle.org/3.5/userguide/multi_project_builds.html
9 9 */
10 10
11 rootProject.name = 'plugins'
11 rootProject.name = 'implab-gradle'
12 12
13 13 include 'container'
Show file before | Show file after | Hide comments
1 NO CONTENT: file was removed
General Comments 0
You need to be logged in to leave comments. Login now