##// 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 plugins {
1 plugins {
2 id "java-gradle-plugin"
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 repositories {
9 repositories {
8 mavenCentral()
10 mavenCentral()
9 }
11 }
10
12
11 gradlePlugin {
13 gradlePlugin {
14 website = 'https://code.implab.org/implab/gradle-container-plugin'
15 vcsUrl = 'https://code.implab.org/implab/gradle-container-plugin'
12 plugins {
16 plugins {
13 containerPlugin {
17 containerPlugin {
14 id = 'org.implab.gradle-container'
18 id = 'org.implab.gradle-container'
15 displayName = "Container building plugin"
19 displayName = "Container building plugin"
16 description = 'Build and publish container images with docker or podman. Simple wrapper around cli.'
20 description = 'Build and publish container images with docker or podman. Simple wrapper around cli.'
17 implementationClass = 'org.implab.gradle.containers.ContainerPlugin'
21 implementationClass = 'org.implab.gradle.containers.ContainerPlugin'
22 tags.set(['containers', 'image', 'docker', 'podman'])
18 }
23 }
19 }
24 }
20 }
25 }
21
26
22 pluginBundle {
27
23 website = 'https://code.implab.org/implab/gradle-container-plugin'
28 task printVersion {
24 vcsUrl = 'https://code.implab.org/implab/gradle-container-plugin'
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 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
Show file before | Show file after | Hide comments
@@ -1,95 +1,101
1 package org.implab.gradle.containers;
1 package org.implab.gradle.containers;
2
2
3 import org.gradle.api.Plugin;
3 import org.gradle.api.Plugin;
4 import org.gradle.api.Project;
4 import org.gradle.api.Project;
5 import org.gradle.api.artifacts.Dependency;
5 import org.gradle.api.artifacts.Dependency;
6 import org.gradle.api.file.ProjectLayout;
6 import org.gradle.api.file.ProjectLayout;
7 import org.gradle.api.model.ObjectFactory;
7 import org.gradle.api.model.ObjectFactory;
8 import org.gradle.api.plugins.ExtraPropertiesExtension;
8 import org.gradle.api.plugins.ExtraPropertiesExtension;
9 import org.gradle.api.tasks.Copy;
9 import org.gradle.api.tasks.Copy;
10 import org.gradle.api.tasks.Delete;
10 import org.gradle.api.tasks.Delete;
11 import org.gradle.api.tasks.TaskProvider;
11 import org.gradle.api.tasks.TaskProvider;
12 import org.implab.gradle.containers.tasks.BuildImage;
12 import org.implab.gradle.containers.tasks.BuildImage;
13 import org.implab.gradle.containers.tasks.PushImage;
13 import org.implab.gradle.containers.tasks.PushImage;
14 import org.implab.gradle.containers.tasks.RunImage;
14 import org.implab.gradle.containers.tasks.SaveImage;
15 import org.implab.gradle.containers.tasks.SaveImage;
15 import org.implab.gradle.containers.tasks.TagImage;
16 import org.implab.gradle.containers.tasks.TagImage;
16
17
17 public class ContainerPlugin implements Plugin<Project> {
18 public class ContainerPlugin implements Plugin<Project> {
18
19
19 public static final String BUILD_GROUP = "build";
20 public static final String BUILD_GROUP = "build";
20
21
21 public static final String CONTAINER_EXTENSION_NAME = "container";
22 public static final String CONTAINER_EXTENSION_NAME = "container";
22
23
23 public static final String ARCHIVE_CONFIGURATION = "archive";
24 public static final String ARCHIVE_CONFIGURATION = "archive";
24
25
25 private ContainerExtension containerExtension;
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 public void apply(Project project) {
34 public void apply(Project project) {
28 ObjectFactory factory = project.getObjects();
35 ObjectFactory factory = project.getObjects();
29 ProjectLayout layout = project.getLayout();
36 ProjectLayout layout = project.getLayout();
30 containerExtension = new ContainerExtension(factory, layout, project);
37 containerExtension = new ContainerExtension(factory, layout, project);
31
38
32 containerExtension.getImageAuthority()
39 containerExtension.getImageAuthority()
33 .convention(project.provider(() -> (String) project.getProperties().get("imagesAuthority")));
40 .convention(project.provider(() -> (String) project.getProperties().get("imagesAuthority")));
34
41
35 containerExtension.getImageGroup()
42 containerExtension.getImageGroup()
36 .convention(project.provider(() -> (String) project.getProperties().get("imagesGroup")));
43 .convention(project.provider(() -> (String) project.getProperties().get("imagesGroup")));
37
44
38 project.getExtensions().add(CONTAINER_EXTENSION_NAME, containerExtension);
45 project.getExtensions().add(CONTAINER_EXTENSION_NAME, containerExtension);
39
46
40 ExtraPropertiesExtension extras = project.getExtensions().getExtraProperties();
47 exportClasses(
41 extras.set(BuildImage.class.getSimpleName(), BuildImage.class);
48 project,
42 extras.set(PushImage.class.getSimpleName(), PushImage.class);
49 BuildImage.class, PushImage.class, SaveImage.class, TagImage.class, RunImage.class);
43 extras.set(SaveImage.class.getSimpleName(), SaveImage.class);
44 extras.set(TagImage.class.getSimpleName(), TagImage.class);
45
50
46 project.getConfigurations().create(Dependency.DEFAULT_CONFIGURATION, c -> {
51 project.getConfigurations().create(Dependency.DEFAULT_CONFIGURATION, c -> {
47 c.setCanBeConsumed(true);
52 c.setCanBeConsumed(true);
48 c.setCanBeResolved(false);
53 c.setCanBeResolved(false);
49 });
54 });
50
55
51 project.getConfigurations().create(ARCHIVE_CONFIGURATION, c -> {
56 project.getConfigurations().create(ARCHIVE_CONFIGURATION, c -> {
52 c.setCanBeConsumed(true);
57 c.setCanBeConsumed(true);
53 c.setCanBeResolved(false);
58 c.setCanBeResolved(false);
54 });
59 });
55
60
56 TaskProvider<Copy> processResourcesTask = project.getTasks().register("processResources", Copy.class, t -> {
61 TaskProvider<Copy> processResourcesTask = project.getTasks().register("processResources", Copy.class, t -> {
57 t.setGroup(BUILD_GROUP);
62 t.setGroup(BUILD_GROUP);
58 t.from(layout.getProjectDirectory().dir("src/main"));
63 t.from(layout.getProjectDirectory().dir("src/main"));
59 t.into(containerExtension.getContextDirectory());
64 t.into(containerExtension.getContextDirectory());
60 });
65 });
61
66
62 TaskProvider<BuildImage> buildImageTask = project.getTasks().register("buildImage", BuildImage.class, t -> {
67 TaskProvider<BuildImage> buildImageTask = project.getTasks().register("buildImage", BuildImage.class, t -> {
63 t.setGroup(BUILD_GROUP);
68 t.setGroup(BUILD_GROUP);
64 t.dependsOn(processResourcesTask);
69 t.dependsOn(processResourcesTask);
65
70
66 t.getContextDirectory().set(containerExtension.getContextDirectory());
71 t.getContextDirectory().set(containerExtension.getContextDirectory());
67 t.getImageIdFile().set(containerExtension.getImageIdFile());
72 t.getImageIdFile().set(containerExtension.getImageIdFile());
68
73
69 t.getImageName().set(containerExtension.getImageName());
74 t.getImageName().set(containerExtension.getImageName());
70 });
75 });
71
76
72 project.getTasks().register("clean", Delete.class, t -> {
77 project.getTasks().register("clean", Delete.class, t -> {
73 t.delete(layout.getBuildDirectory());
78 t.delete(layout.getBuildDirectory());
74 });
79 });
75
80
76 project.getTasks().register("build", t -> {
81 project.getTasks().register("build", t -> {
77 t.setGroup(BUILD_GROUP);
82 t.setGroup(BUILD_GROUP);
78 t.dependsOn(buildImageTask);
83 t.dependsOn(buildImageTask);
79 });
84 });
80
85
81 project.getTasks().register("pushImage", PushImage.class, t -> {
86 project.getTasks().register("pushImage", PushImage.class, t -> {
82 t.dependsOn(buildImageTask);
87 t.dependsOn(buildImageTask);
83 t.getImageName().set(buildImageTask.flatMap(b -> b.getImageName()));
88 t.getImageName().set(buildImageTask.flatMap(b -> b.getImageName()));
84 });
89 });
85
90
86 project.getTasks().register("saveImage", SaveImage.class, t -> {
91 project.getTasks().register("saveImage", SaveImage.class, t -> {
87 t.dependsOn(buildImageTask);
92 t.dependsOn(buildImageTask);
88 t.getImage().set(buildImageTask.flatMap(b -> b.getImageName()));
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 -> {
96 project.getArtifacts().add(Dependency.DEFAULT_CONFIGURATION, buildImageTask.flatMap(x -> x.getImageIdFile()),
92 t.builtBy(buildImageTask);
97 t -> {
93 });
98 t.builtBy(buildImageTask);
99 });
94 }
100 }
95 }
101 }
Show file before | Show file after | Hide comments
@@ -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<>();
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"));
82 // add --target if specified for multi-stage build
36 commandLine.add(getImageName().get().toString());
83 if (getBuildTarget().isPresent()) {
37 }
84 args.add("--target");
85 args.add(getBuildTarget().get());
86 }
38
87
39 @Override
88 // add extra parameters
40 protected void processStarted(Process p) {
89 getExtraCommandArgs().getOrElse(Collections.emptyList())
41 Utils.redirectIO(p.getInputStream(), getImageIdFile().get().getAsFile());
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 package org.implab.gradle.containers.tasks;
1 package org.implab.gradle.containers.tasks;
2
2
3 import java.io.File;
3 import java.io.File;
4 import java.util.ArrayList;
4 import java.util.Collection;
5 import java.util.Collections;
5 import java.util.List;
6 import java.util.List;
7 import java.util.Optional;
6
8
7 import org.gradle.api.DefaultTask;
9 import org.gradle.api.DefaultTask;
8 import org.gradle.api.logging.Logger;
10 import org.gradle.api.file.DirectoryProperty;
9 import org.gradle.api.provider.Property;
11 import org.gradle.api.provider.Property;
10 import org.gradle.api.provider.Provider;
12 import org.gradle.api.provider.Provider;
11 import org.gradle.api.tasks.Input;
13 import org.gradle.api.tasks.Input;
12 import org.gradle.api.tasks.Internal;
14 import org.gradle.api.tasks.Internal;
13 import org.gradle.api.tasks.TaskAction;
15 import org.gradle.api.tasks.TaskAction;
14 import org.implab.gradle.Utils;
15 import org.implab.gradle.containers.ContainerExtension;
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 private final Property<String> cliCmd;
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() {
33 @Internal
24 cliCmd = getProject().getObjects().property(String.class);
34 protected Optional<String> getSubCommand() {
25 cliCmd.convention(getContainerExtension().getCliCmd());
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 @Input
43 @Input
31 public Property<String> getCliCmd() {
44 public Property<String> getCliCmd() {
32 return cliCmd;
45 return cliCmd;
33 }
46 }
34
47
35 public void setCliCmd(String cliCmd) {
48 public void setCliCmd(String cliCmd) {
36 this.cliCmd.set(cliCmd);
49 this.cliCmd.set(cliCmd);
37 }
50 }
38
51
39 @Internal
52 @Internal
40 protected ContainerExtension getContainerExtension() {
53 protected ContainerExtension getContainerExtension() {
41 return getProject().getExtensions().getByType(ContainerExtension.class);
54 return getProject().getExtensions().getByType(ContainerExtension.class);
42 }
55 }
43
56
44 @TaskAction
57 @TaskAction
45 public void Run() throws Exception {
58 public void Run() throws Exception {
46 final Logger log = getLogger();
59 Execute();
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);
68 }
60 }
69
61
70 protected void preparingCommand(List<String> commandLine) {
62 public void preparingCommand(List<String> commandLine) {
71 commandLine.add(cliCmd.get());
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 protected void setWorkingDir(Provider<File> workingDir) {
74 protected void setWorkingDir(Provider<File> workingDir) {
75 this.workingDir.set(workingDir);
75 this.workingDir.fileProvider(workingDir);
76 }
76 }
77
77
78 protected void setWorkingDir(File workingDir) {
78 protected void setWorkingDir(File workingDir) {
79 this.workingDir.set(workingDir);
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 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;
3 import java.util.List;
5 import java.util.List;
4 import java.util.concurrent.Callable;
6 import java.util.concurrent.Callable;
5
7
6 import org.gradle.api.provider.ListProperty;
8 import org.gradle.api.provider.ListProperty;
7 import org.gradle.api.provider.Property;
9 import org.gradle.api.provider.Property;
8 import org.gradle.api.tasks.Input;
10 import org.gradle.api.tasks.Input;
9 import org.gradle.api.tasks.Optional;
11 import org.gradle.api.tasks.Optional;
10 import org.implab.gradle.containers.ImageName;
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 @Input
18 @Input
15 public abstract Property<ImageName> getImageName();
19 public abstract Property<ImageName> getImageName();
16
20
17 @Input
21 @Input
18 @Optional
22 @Optional
19 public abstract Property<String> getTransport();
23 public abstract Property<String> getTransport();
20
24
21 @Input
25 @Input
22 @Optional
26 @Optional
23 public abstract ListProperty<String> getOptions();
27 public abstract ListProperty<String> getOptions();
24
28
25 public PushImage option(Callable<String> provider) {
29 public PushImage option(Callable<String> provider) {
26 getOptions().add(getProject().provider(provider));
30 getOptions().add(getProject().provider(provider));
27 return this;
31 return this;
28 }
32 }
29
33
30 @Override
34 @Override
31 protected void preparingCommand(List<String> commandLine) {
35 protected java.util.Optional<String> getSubCommand() {
32 super.preparingCommand(commandLine);
36 return java.util.Optional.of(PUSH_COMMAND);
37 }
33
38
34 commandLine.add("push");
39 @Override
35 commandLine.addAll(getOptions().get());
40 protected Collection<String> getSubCommandArguments() {
36 commandLine.add(getImageName().get().toString());
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 package org.implab.gradle.containers.tasks;
1 package org.implab.gradle.containers.tasks;
2
2
3 import java.util.ArrayList;
3 import java.util.ArrayList;
4 import java.util.Collection;
4 import java.util.List;
5 import java.util.List;
5 import java.util.Optional;
6 import java.util.Optional;
6
7
7 import org.gradle.api.file.DirectoryProperty;
8 import org.gradle.api.file.DirectoryProperty;
8 import org.gradle.api.file.RegularFile;
9 import org.gradle.api.file.RegularFile;
9 import org.gradle.api.provider.Property;
10 import org.gradle.api.provider.Property;
10 import org.gradle.api.provider.Provider;
11 import org.gradle.api.provider.Provider;
11 import org.gradle.api.tasks.Input;
12 import org.gradle.api.tasks.Input;
12 import org.gradle.api.tasks.Internal;
13 import org.gradle.api.tasks.Internal;
13 import org.gradle.api.tasks.OutputFile;
14 import org.gradle.api.tasks.OutputFile;
14 import org.gradle.api.tasks.TaskExecutionException;
15 import org.gradle.api.tasks.TaskExecutionException;
15 import org.implab.gradle.Utils;
16 import org.implab.gradle.containers.ImageName;
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 @Input
21 @Input
21 public abstract Property<ImageName> getImage();
22 public abstract Property<ImageName> getImage();
22
23
23 @OutputFile
24 @OutputFile
24 public Provider<RegularFile> getArchiveFile() {
25 public Provider<RegularFile> getArchiveFile() {
25 return getDestinationDirectory().file(getArchiveFileName());
26 return getDestinationDirectory().file(getArchiveFileName());
26 }
27 }
27
28
28 @Internal
29 @Internal
29 public abstract DirectoryProperty getDestinationDirectory();
30 public abstract DirectoryProperty getDestinationDirectory();
30
31
31 @Internal
32 @Internal
32 public abstract Property<String> getArchiveFileName();
33 public abstract Property<String> getArchiveFileName();
33
34
34 @Internal
35 @Internal
35 public abstract Property<String> getArchiveBaseName();
36 public abstract Property<String> getArchiveBaseName();
36
37
37 @Internal
38 @Internal
38 public abstract Property<String> getArchiveVersion();
39 public abstract Property<String> getArchiveVersion();
39
40
40 @Internal
41 @Internal
41 public abstract Property<String> getArchiveClassifier();
42 public abstract Property<String> getArchiveClassifier();
42
43
43 @Internal
44 @Internal
44 public abstract Property<String> getArchiveExtension();
45 public abstract Property<String> getArchiveExtension();
45
46
46 public SaveImage() {
47 public SaveImage() {
47 getArchiveFileName().convention(getProject().provider(this::conventionalArchiveFileName));
48 getArchiveFileName().convention(provider(this::conventionalArchiveFileName));
48 getArchiveBaseName().convention(getProject().provider(this::conventionalArchiveBaseName));
49 getArchiveBaseName().convention(provider(this::conventionalArchiveBaseName));
49 getArchiveVersion().convention(getProject().provider(() -> getProject().getVersion()).map(x -> x.toString()));
50 getArchiveVersion().convention(provider(() -> getProject().getVersion()).map(x -> x.toString()));
50 getDestinationDirectory().convention(getProject().getLayout().getBuildDirectory());
51 getDestinationDirectory().convention(getProject().getLayout().getBuildDirectory());
51 getArchiveExtension().convention("tar");
52 getArchiveExtension().convention("tar");
52 }
53 }
53
54
54 private String conventionalArchiveBaseName() {
55 private String conventionalArchiveBaseName() {
55 ArrayList<String> parts = new ArrayList<>();
56 ArrayList<String> parts = new ArrayList<>();
56 Optional.of(getProject().getGroup()).map(x -> x.toString()).ifPresent(parts::add);
57 Optional.of(getProject().getGroup()).map(x -> x.toString()).ifPresent(parts::add);
57 parts.add(getProject().getName());
58 parts.add(getProject().getName());
58 return String.join("-", parts);
59 return String.join("-", parts);
59 }
60 }
60
61
61 private String conventionalArchiveFileName() {
62 private String conventionalArchiveFileName() {
62 ArrayList<String> parts = new ArrayList<>();
63 ArrayList<String> parts = new ArrayList<>();
63
64
64 if (getArchiveBaseName().isPresent())
65 if (getArchiveBaseName().isPresent())
65 parts.add(getArchiveBaseName().get());
66 parts.add(getArchiveBaseName().get());
66
67
67 if (getArchiveVersion().isPresent())
68 if (getArchiveVersion().isPresent())
68 parts.add(getArchiveVersion().get());
69 parts.add(getArchiveVersion().get());
69
70
70 if (getArchiveClassifier().isPresent())
71 if (getArchiveClassifier().isPresent())
71 parts.add(getArchiveClassifier().get());
72 parts.add(getArchiveClassifier().get());
72
73
73 if (parts.size() == 0)
74 if (parts.size() == 0)
74 throw new TaskExecutionException(this, new Exception("The archiveFileName ism't specified"));
75 throw new TaskExecutionException(this, new Exception("The archiveFileName ism't specified"));
75
76
76 return String.join("-", parts) + "." + getArchiveExtension().get();
77 return String.join("-", parts) + "." + getArchiveExtension().get();
77 }
78 }
78
79
79 @Override
80 @Override
80 protected void preparingCommand(List<String> commandLine) {
81 protected Optional<String> getSubCommand() {
81 super.preparingCommand(commandLine);
82 return Optional.of(SAVE_COMMAND);
82
83 commandLine.add("save");
84 commandLine.add(getImage().get().toString());
85 }
83 }
86
84
87 @Override
85 @Override
88 protected void processStarted(Process p) {
86 protected Collection<String> getSubCommandArguments() {
89 Utils.redirectIO(p.getInputStream(), getArchiveFile().get().getAsFile());
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 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;
3 import java.util.List;
5 import java.util.List;
4 import java.util.concurrent.Callable;
6 import java.util.concurrent.Callable;
5
7
6 import org.gradle.api.provider.ListProperty;
8 import org.gradle.api.provider.ListProperty;
7 import org.gradle.api.provider.Property;
9 import org.gradle.api.provider.Property;
8 import org.gradle.api.tasks.Input;
10 import org.gradle.api.tasks.Input;
9 import org.gradle.api.tasks.Optional;
11 import org.gradle.api.tasks.Optional;
10 import org.implab.gradle.containers.ImageName;
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 @Input
17 @Input
15 public abstract Property<ImageName> getSrcImage();
18 public abstract Property<ImageName> getSrcImage();
16
19
17 @Input
20 @Input
18 public abstract Property<ImageName> getDestImage();
21 public abstract Property<ImageName> getDestImage();
19
22
20 @Input
23 @Input
21 @Optional
24 @Optional
22 public abstract Property<String> getTransport();
25 public abstract Property<String> getTransport();
23
26
24 @Input
27 @Input
25 @Optional
28 @Optional
26 public abstract ListProperty<String> getOptions();
29 public abstract ListProperty<String> getOptions();
27
30
28 public TagImage option(Callable<String> provider) {
31 public TagImage option(Callable<String> provider) {
29 getOptions().add(getProject().provider(provider));
32 getOptions().add(getProject().provider(provider));
30 return this;
33 return this;
31 }
34 }
32
35
33 @Override
36 @Override
34 protected void preparingCommand(List<String> commandLine) {
37 protected java.util.Optional<String> getSubCommand() {
35 super.preparingCommand(commandLine);
38 return java.util.Optional.of(TAG_COMMAND);
39 }
36
40
37 commandLine.add("tag");
41 @Override
38 commandLine.addAll(getOptions().get());
42 protected Collection<String> getSubCommandArguments() {
39 commandLine.add(getSrcImage().get().toString());
43 List<String> args = new ArrayList<>();
40 commandLine.add(getDestImage().get().toString());
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
NO CONTENT: modified file, binary diff hidden
Show file before | Show file after | Hide comments
@@ -1,5 +1,7
1 distributionBase=GRADLE_USER_HOME
1 distributionBase=GRADLE_USER_HOME
2 distributionPath=wrapper/dists
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 zipStoreBase=GRADLE_USER_HOME
6 zipStoreBase=GRADLE_USER_HOME
5 zipStorePath=wrapper/dists
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 # 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
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
140 fi
121 fi
141 fi
122
142
123 # For Darwin, add options to specify how the application appears in the dock
143 # Increase the maximum file descriptors if we can.
124 if $darwin; then
144 if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
125 GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
145 case $MAX_FD in #(
126 fi
146 max*)
127
147 # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
128 # For Cygwin or MSYS, switch paths to Windows format before running java
148 # shellcheck disable=SC2039,SC3045
129 if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
149 MAX_FD=$( ulimit -H -n ) ||
130 APP_HOME=`cygpath --path --mixed "$APP_HOME"`
150 warn "Could not query maximum file descriptor limit"
131 CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
151 esac
132 JAVACMD=`cygpath --unix "$JAVACMD"`
152 case $MAX_FD in #(
133
153 '' | soft) :;; #(
134 # We build the pattern for arguments to be converted via cygpath
154 *)
135 ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
155 # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
136 SEP=""
156 # shellcheck disable=SC2039,SC3045
137 for dir in $ROOTDIRSRAW ; do
157 ulimit -n "$MAX_FD" ||
138 ROOTDIRS="$ROOTDIRS$SEP$dir"
158 warn "Could not set maximum file descriptor limit to $MAX_FD"
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" ;;
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" "$@"
Show file before | Show file after | Hide comments
@@ -1,100 +1,92
1 @rem
1 @rem
2 @rem Copyright 2015 the original author or authors.
2 @rem Copyright 2015 the original author or authors.
3 @rem
3 @rem
4 @rem Licensed under the Apache License, Version 2.0 (the "License");
4 @rem Licensed under the Apache License, Version 2.0 (the "License");
5 @rem you may not use this file except in compliance with the License.
5 @rem you may not use this file except in compliance with the License.
6 @rem You may obtain a copy of the License at
6 @rem You may obtain a copy of the License at
7 @rem
7 @rem
8 @rem https://www.apache.org/licenses/LICENSE-2.0
8 @rem https://www.apache.org/licenses/LICENSE-2.0
9 @rem
9 @rem
10 @rem Unless required by applicable law or agreed to in writing, software
10 @rem Unless required by applicable law or agreed to in writing, software
11 @rem distributed under the License is distributed on an "AS IS" BASIS,
11 @rem distributed under the License is distributed on an "AS IS" BASIS,
12 @rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 @rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 @rem See the License for the specific language governing permissions and
13 @rem See the License for the specific language governing permissions and
14 @rem limitations under the License.
14 @rem limitations under the License.
15 @rem
15 @rem
16
16
17 @if "%DEBUG%" == "" @echo off
17 @if "%DEBUG%"=="" @echo off
18 @rem ##########################################################################
18 @rem ##########################################################################
19 @rem
19 @rem
20 @rem Gradle startup script for Windows
20 @rem Gradle startup script for Windows
21 @rem
21 @rem
22 @rem ##########################################################################
22 @rem ##########################################################################
23
23
24 @rem Set local scope for the variables with windows NT shell
24 @rem Set local scope for the variables with windows NT shell
25 if "%OS%"=="Windows_NT" setlocal
25 if "%OS%"=="Windows_NT" setlocal
26
26
27 set DIRNAME=%~dp0
27 set DIRNAME=%~dp0
28 if "%DIRNAME%" == "" set DIRNAME=.
28 if "%DIRNAME%"=="" set DIRNAME=.
29 @rem This is normally unused
29 set APP_BASE_NAME=%~n0
30 set APP_BASE_NAME=%~n0
30 set APP_HOME=%DIRNAME%
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 @rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
36 @rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
33 set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
37 set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
34
38
35 @rem Find java.exe
39 @rem Find java.exe
36 if defined JAVA_HOME goto findJavaFromJavaHome
40 if defined JAVA_HOME goto findJavaFromJavaHome
37
41
38 set JAVA_EXE=java.exe
42 set JAVA_EXE=java.exe
39 %JAVA_EXE% -version >NUL 2>&1
43 %JAVA_EXE% -version >NUL 2>&1
40 if "%ERRORLEVEL%" == "0" goto init
44 if %ERRORLEVEL% equ 0 goto execute
41
45
42 echo.
46 echo.
43 echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
47 echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
44 echo.
48 echo.
45 echo Please set the JAVA_HOME variable in your environment to match the
49 echo Please set the JAVA_HOME variable in your environment to match the
46 echo location of your Java installation.
50 echo location of your Java installation.
47
51
48 goto fail
52 goto fail
49
53
50 :findJavaFromJavaHome
54 :findJavaFromJavaHome
51 set JAVA_HOME=%JAVA_HOME:"=%
55 set JAVA_HOME=%JAVA_HOME:"=%
52 set JAVA_EXE=%JAVA_HOME%/bin/java.exe
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 echo.
60 echo.
57 echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
61 echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
58 echo.
62 echo.
59 echo Please set the JAVA_HOME variable in your environment to match the
63 echo Please set the JAVA_HOME variable in your environment to match the
60 echo location of your Java installation.
64 echo location of your Java installation.
61
65
62 goto fail
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 :execute
68 :execute
80 @rem Setup the command line
69 @rem Setup the command line
81
70
82 set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
71 set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
83
72
73
84 @rem Execute Gradle
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 :end
77 :end
88 @rem End local scope for the variables with windows NT shell
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 :fail
81 :fail
92 rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
82 rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
93 rem the _cmd.exe /c_ return code!
83 rem the _cmd.exe /c_ return code!
94 if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
84 set EXIT_CODE=%ERRORLEVEL%
95 exit /b 1
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 :mainEnd
89 :mainEnd
98 if "%OS%"=="Windows_NT" endlocal
90 if "%OS%"=="Windows_NT" endlocal
99
91
100 :omega
92 :omega
Show file before | Show file after | Hide comments
@@ -1,13 +1,13
1 /*
1 /*
2 * This settings file was generated by the Gradle 'init' task.
2 * This settings file was generated by the Gradle 'init' task.
3 *
3 *
4 * The settings file is used to specify which projects to include in your build.
4 * The settings file is used to specify which projects to include in your build.
5 * In a single project build this file can be empty or even removed.
5 * In a single project build this file can be empty or even removed.
6 *
6 *
7 * Detailed information about configuring a multi-project build in Gradle can be found
7 * Detailed information about configuring a multi-project build in Gradle can be found
8 * in the user guide at https://docs.gradle.org/3.5/userguide/multi_project_builds.html
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 include 'container'
13 include 'container'
Show file before | Show file after | Hide comments
1 NO CONTENT: file was removed
NO CONTENT: file was removed
General Comments 0
You need to be logged in to leave comments. Login now