implab/gradle-common Commit - r14:bed0567066c1

WIP

cin -

r14:bed0567066c1 default

parent child

Context file:

r14:bed0567066c1

Collapse all files

gradle/libs.versions.toml created 644 +7 0

@@ -0,0 +1,7
	1	[versions]
	2	immutables = "2.10.1"
	3	jdt = "2.3.0"
	4
	5	[libraries]
	6	immutables = { module = "org.immutables:value", version.ref = "immutables" }
	7	jdt-annotations = { module = "org.eclipse.jdt:org.eclipse.jdt.annotation", version.ref = "jdt" }

common/build.gradle +2 -1

             }
             dependencies {
-                compileOnly "org.eclipse.jdt:org.eclipse.jdt.annotation:2.3.0"
+                compileOnly libs.jdt.annotations
                 api gradleApi()
             }

common/src/main/java/org/implab/gradle/common/exec/CommandBuilder.java +17 -1

@@ -1,5 +1,7
1	package org.implab.gradle.common.exec;	1	package org.implab.gradle.common.exec;
2		2
		3	import java.util.function.Consumer;
		4
3	import org.eclipse.jdt.annotation.NonNullByDefault;	5	import org.eclipse.jdt.annotation.NonNullByDefault;
4	import org.implab.gradle.common.utils.Values;	6	import org.implab.gradle.common.utils.Values;
5		7
@@ -42,8 +44,22 public interface CommandBuilder {
42	return this;	44	return this;
43	}	45	}
44		46
		47	default Consumer<Boolean> flag(String name) {
		48	return f -> {
		49	if (f)
		50	addArguments(name);
		51	};
		52	}
		53
		54	default Consumer<String> param(String name) {
		55	return v -> {
		56	if (v != null && v.length() > 0)
		57	addArguments(name, v);
		58	};
		59	}
		60
45	/** Adds the specified arguments to this builder */	61	/** Adds the specified arguments to this builder */
46	CommandBuilder addArguments(~~String~~ ~~arg0~~, String... args);	62	CommandBuilder addArguments(String... args);
47		63
48	default CommandBuilder addArguments(Iterable<String> args) {	64	default CommandBuilder addArguments(Iterable<String> args) {
49	for (String arg : args)	65	for (String arg : args)

common/src/main/java/org/implab/gradle/common/exec/EnvironmentBuilder.java +5 -3

             @NonNullByDefault
             public interface EnvironmentBuilder {
                 /** Sets the specified environment variable */
-                EnvironmentBuilder setVariable(String envVar, String value);
+                EnvironmentBuilder putEnvironment(String envVar, String value);
                 /** Replaces environment with the supplied one */
                 EnvironmentBuilder environment(Map<String, ? extends String> env);
-                /** Unsets the specified variable. If the variable is inherited it removed anyway. */
+                /**
-                EnvironmentBuilder unsetVariable(String envVar);
+                 * Enables or disables environment inheritance for the child process
+                 */
+                EnvironmentBuilder inheritEnvironment(boolean inherit);
                 /** Specifies the working directory */
                 EnvironmentBuilder workingDirectory(File directory);

common/src/main/java/org/implab/gradle/common/exec/EnvironmentSpec.java +3 0

             import java.util.Optional;
             public interface EnvironmentSpec {
+                boolean inheritEnvironment();
                 Map<String,String> environment();
                 Optional<File> workingDirectory();

common/src/main/java/org/implab/gradle/common/exec/ExecBuilder.java +28 -29

             /** Command line builder */
             @NonNullByDefault
             public abstract class ExecBuilder implements
-                CommandBuilder,
+                    CommandBuilder,
-                PipeBuilder,
+                    PipeBuilder,
-                EnvironmentBuilder,
+                    EnvironmentBuilder,
-                Runnable
+                    Executable {
                 private String executable;
                 private final List<String> arguments = new ArrayList<>();
+                private boolean inheritEnvironment = true;
                 private final Map<String, String> environment = new HashMap<>();
                 private @Nullable File directory;
                 public ExecBuilder arguments(Iterable<String> args) {
                     requireNonNull(args, "Args must not be null");
                     arguments.clear();
-                    for(var arg: args)
+                    for (var arg : args)
                         arguments.add(arg);
                     return this;
                 }
                 @Override
-                public ExecBuilder addArguments(String arg0, String... args) {
+                public ExecBuilder addArguments(String... args) {
-                    requireNonNull(arg0, "arg0 parameter can't be null");
-                    arguments.add(arg0);
                     for (var arg : args)
-                        arguments.add(arg);
+                        arguments.add(requireNonNull(arg, "arguments element shouldn't be null"));
                     return this;
                 }
                 @Override
                 public ExecBuilder workingDirectory(File directory) {
                     requireNonNull(directory, "directory parameter can't be null");
                     this.directory = directory;
                     return this;
                 }
                     return this;
                 }
+                @Override
+                public ExecBuilder inheritEnvironment(boolean inherit) {
+                    this.inheritEnvironment = inherit;
+                    return this;
+                }
                 /**
                  * Sets the environment value. The value cannot be null.
                  *
                  * @param value  The value to set,
                  */
                 @Override
-                public ExecBuilder setVariable(String envVar, String value) {
+                public ExecBuilder putEnvironment(String envVar, String value) {
                     requireNonNull(value, "Value can't be null");
                     requireNonNull(envVar, "envVar parameter can't be null");
                 }
                 @Override
-                public ExecBuilder unsetVariable(String envVar) {
+                public ExecBuilder environment(Map<String, ? extends String> env) {
-                    requireNonNull(envVar, "envVar parameter can't be null");
-                    environment.remove(envVar);
-                    return this;
-                @Override
-                public ExecBuilder environment(Map<String,? extends String> env) {
                     requireNonNull(env, "env parameter can't be null");
                     environment.clear();
                 @Override
                 public ExecBuilder stdin(RedirectFrom from) {
                     requireNonNull(from, "from parameter can't be null");
                     inputRedirect = from;
                     return this;
                 }
                  * @return
                  * @throws IOException
                  */
-                public CompletableFuture<Integer> run() throws IOException {
+                public CompletableFuture<Integer> exec() throws IOException {
                     if (executable == null || executable.isEmpty())
                         throw new IllegalStateException("The executable isn't set");
                     commandLine.addAll(arguments);
                     return startInternal(
-                        new SelfCommandSpec(),
+                            new SelfCommandSpec(),
-                        new SelfEnvironmentSpec(),
+                            new SelfEnvironmentSpec(),
-                        new SelfPipeSpec()
+                            new SelfPipeSpec());
-                    );
                 }
                 private class SelfCommandSpec implements CommandSpec {
                 }
                 private class SelfEnvironmentSpec implements EnvironmentSpec {
+                    @Override
+                    public boolean inheritEnvironment() {
+                        return inheritEnvironment;
+                    }
                     @Override
                     public Map<String, String> environment() {
                     @Override
                     public Optional<File> workingDirectory() {
-                        return Optional.ofNullable( directory);
+                        return Optional.ofNullable(directory);
                     }
                 }

common/src/main/java/org/implab/gradle/common/exec/Executable.java ~~common/src/main/java/org/implab/gradle/common/exec/Runnable.java~~ renamed +5 -6

             import java.util.concurrent.CompletableFuture;
             import java.util.concurrent.CompletionException;
-            public interface Runnable {
+            public interface Executable {
-                CompletableFuture<Integer> run() throws IOException;
+                CompletableFuture<Integer> exec() throws IOException;
                 /** Starts process and will throw error if error code is non-zero */
-                default CompletableFuture<Integer> run(boolean throwOnError) throws IOException {
+                default CompletableFuture<Void> execChecked() throws IOException {
-                    return run().thenApply(code -> {
+                    return exec().thenAccept(code -> {
-                        if (!throwOnError && code != 0)
+                        if (code != 0)
                         throw new CompletionException(new IOException(
                                 String.format("The process is terminated with code %d", code)));
-                        return code;
                     });
                 }
             }

common/src/main/java/org/implab/gradle/common/exec/RedirectFrom.java +7 -3

             import java.io.OutputStream;
             import java.util.concurrent.CompletableFuture;
-            /** Describes how to redirect input streams. This interface is used to configure
+            /**
+             * Describes how to redirect input streams. This interface is used to configure
              * lazy redirection. {@link #redirect(OutputStream)} is called when the process
-             * is started.
+             * is started. Before the process is started the redirection isn't invoked and
+             * no resources are allocated or used.
              */
             public interface RedirectFrom {
                 CompletableFuture<Void> redirect(OutputStream to);
+                /**
+                 * Read file contents and redirect it to the output stream.
+                 */
                 public static RedirectFrom file(final File file) {
                     return to -> CompletableFuture.runAsync(() -> {
                         try (var from = new FileInputStream(file); to) {
                     }
                 }
             }

common/src/main/java/org/implab/gradle/common/exec/RedirectTo.java +16 -1

             import org.eclipse.jdt.annotation.NonNullByDefault;
             /**
-             * RedirectSpec
+             * Redirection specification for the {@link InputStream}. Redirection is invoked
+             * when the {@link InputStream} becomes available, for example, on process
+             * start. Before the process is started the redirection isn't invoked and no
+             * resources are allocated or used.
              */
             @NonNullByDefault
             public interface RedirectTo {
                 public interface StringConsumer extends Consumer<String> {
                 }
+                /** Creates a redirect to the specified consumer */
                 public static RedirectTo consumer(final Consumer<String> consumer) {
                     return consumer(new StringConsumer() {
                         @Override
                     });
                 }
+                /** Creates a redirect to the specified consumer */
                 public static RedirectTo consumer(final StringConsumer consumer) {
                     return (src) -> CompletableFuture.runAsync(() -> {
                         try (Scanner sc = new Scanner(src)) {
                     });
                 }
+                /**
+                 * Creates a redirect to the specified file. There will be opened the output
+                 * stream in this redirection and original stream will be transferred to this
+                 * this output stream.
+                 */
                 public static RedirectTo file(final File file) {
                     return src -> CompletableFuture.runAsync(() -> {
                         try (OutputStream out = new FileOutputStream(file)) {
                     });
                 }
+                /** Creates a redirect to the specified output stream. */
                 public static RedirectTo stream(final OutputStream dest) {
                     return src -> CompletableFuture.runAsync(() -> {
                         try (dest; src) {
                     });
                 }
+                /**
+                 * Creates the redirection to the specified destination, actual type of
+                 * redirection will be determined from the type of the output object.
+                 */
                 public static RedirectTo any(final Object output) {
                     if (output instanceof StringConsumer fn) {
                         return consumer(s -> fn.accept(s));

common/src/main/java/org/implab/gradle/common/exec/SystemExecBuilder.java +5 -1

             class SystemExecBuilder extends ExecBuilder {
                 @Override
                 protected CompletableFuture<Integer> startInternal(
-                    CommandSpec command,
+                        CommandSpec command,
                         EnvironmentSpec environment,
                         PipeSpec redirect) throws IOException {
                     environment.workingDirectory().ifPresent(builder::directory);
+                    // if the env isn't inherited we need to clear it
+                    if (!environment.inheritEnvironment())
+                        builder.environment().clear();
                     builder.environment().putAll(environment.environment());
                     var tasks = new ArrayList<CompletableFuture<?>>();

common/src/main/java/org/implab/gradle/common/tasks/ShellExecTask.java +1 -1

                     getStderr().getRedirection().ifPresent(execBuilder::stderr);
                     getStdin().getRedirection().ifPresent(execBuilder::stdin);
-                    execBuilder.run().thenAccept(ThrowingConsumer.guard(this::checkRetCode)).join();
+                    execBuilder.exec().thenAccept(ThrowingConsumer.guard(this::checkRetCode)).join();
                 }
                 protected void checkRetCode(Integer code) throws IOException {

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages