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

             plugins {
                 id "java-library"
                 id "ivy-publish"
             }
             java {
                 withJavadocJar()
                 withSourcesJar()
                     toolchain {
                     languageVersion = JavaLanguageVersion.of(17)
                 }
             }
             dependencies {
-                compileOnly "org.eclipse.jdt:org.eclipse.jdt.annotation:2.3.0"
+                compileOnly libs.jdt.annotations
                 api gradleApi()
             }
             task printVersion{
                 doLast {
                     println "project: $project.group:$project.name:$project.version"
                     println "jar: ${->jar.archiveFileName.get()}"
                 }
             }
             publishing {
                 repositories {
                     ivy {
                         url "${System.properties["user.home"]}/ivy-repo"
                     }
                 }
                 publications {
                     ivy(IvyPublication) {
                         from components.java
                         descriptor.description {
                             text = providers.provider({ description })
                         }
                     }
                 }
             }

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

             package org.implab.gradle.common.exec;
+            import java.util.function.Consumer;
             import org.eclipse.jdt.annotation.NonNullByDefault;
             import org.implab.gradle.common.utils.Values;
             /** Command builder interface, used to specify the executable and parameters */
             @NonNullByDefault
             public interface CommandBuilder {
                 /** Sets the executable, the parameters are left intact. */
                 CommandBuilder executable(String executable);
                 /**
                  * Sets the specified executable and parameters, old executable and parameters
                  * are discarded.
                  */
                 default CommandBuilder commandLine(String executable, String... args) {
                     return executable(executable)
                             .arguments(args);
                 }
                 /**
                  * Sets the specified executable and parameters, old executable and parameters
                  * are discarded.
                  *
                  * @param command The command line. Must contain at least one element
                  *                (executable).
                  *
                  */
                 default CommandBuilder commandLine(Iterable<? extends String> command) {
                     var iterator = command.iterator();
                     // set executable
                     executable(Values.take(iterator).orElseThrow());
                     // cleat arguments
                     arguments();
                     // set new arguments
                     while (iterator.hasNext())
                         addArguments(iterator.next());
                     return this;
                 }
+                default Consumer<Boolean> flag(String name) {
+                    return f -> {
+                        if (f)
+                            addArguments(name);
+                    };
+                }
+                default Consumer<String> param(String name) {
+                    return v -> {
+                        if (v != null && v.length() > 0)
+                            addArguments(name, v);
+                    };
+                }
                 /** Adds the specified arguments to this builder */
-                CommandBuilder addArguments(String arg0, String... args);
+                CommandBuilder addArguments(String... args);
                 default CommandBuilder addArguments(Iterable<String> args) {
                     for (String arg : args)
                         addArguments(arg);
                     return this;
                 }
                 /** Replaces arguments in the builder with the specified one. */
                 default CommandBuilder arguments(String... args) {
                     return arguments(Values.iterable(args));
                 }
                 /** Replaces arguments in the builder with the specified one. */
                 CommandBuilder arguments(Iterable<String> args);
                 default CommandBuilder from(CommandSpec commandSpec) {
                     return executable(commandSpec.executable())
                             .arguments(commandSpec.arguments());
                 }
             }

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

             package org.implab.gradle.common.exec;
             import java.io.File;
             import java.util.Map;
             import java.util.Optional;
             import org.eclipse.jdt.annotation.NonNullByDefault;
             @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);
                 /** Specifies the working directory */
                 EnvironmentBuilder workingDirectory(Optional<? extends File> directory);
                 /** Copies the supplied environment to this one */
                 default EnvironmentBuilder from(EnvironmentSpec environmentSpec) {
                     return environment(environmentSpec.environment())
                         .workingDirectory(environmentSpec.workingDirectory());
                 }
             }

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

             package org.implab.gradle.common.exec;
             import java.io.File;
             import java.util.Map;
             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

             package org.implab.gradle.common.exec;
             import java.util.ArrayList;
             import java.util.HashMap;
             import java.util.List;
             import java.util.Map;
             import java.util.Optional;
             import java.util.concurrent.CompletableFuture;
             import org.eclipse.jdt.annotation.NonNullByDefault;
             import org.eclipse.jdt.annotation.Nullable;
             import java.io.File;
             import java.io.IOException;
             import static java.util.Objects.requireNonNull;
             /** 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;
                 private RedirectFrom inputRedirect;
                 private RedirectTo outputRedirect;
                 private RedirectTo errorRedirect;
                 @Override
                 public ExecBuilder executable(String executable) {
                     requireNonNull(executable, "cmd can't be null");
                     this.executable = executable;
                     return this;
                 }
                 @Override
                 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;
                 }
                 /** Sets the working directory */
                 @Override
                 public ExecBuilder workingDirectory(File directory) {
                     requireNonNull(directory, "directory parameter can't be null");
                     this.directory = directory;
                     return this;
                 }
                 @Override
                 public ExecBuilder workingDirectory(Optional<? extends File> directory) {
                     requireNonNull(directory, "directory parameter can't be null");
                     this.directory = directory.orElse(null);
                     return this;
                 }
+                @Override
+                public ExecBuilder inheritEnvironment(boolean inherit) {
+                    this.inheritEnvironment = inherit;
+                    return this;
+                }
                 /**
                  * Sets the environment value. The value cannot be null.
                  *
                  * @param envVar The name of the environment variable
                  * @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");
                     environment.put(envVar, value);
                     return this;
                 }
                 @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();
                     environment.putAll(env);
                     return this;
                 }
                 /**
                  * Sets redirection for the stdin, {@link RedirectFrom} will be applied
                  * every time the process is started.
                  *
                  * <p>
                  * If redirection
                  */
                 @Override
                 public ExecBuilder stdin(RedirectFrom from) {
                     requireNonNull(from, "from parameter can't be null");
                     inputRedirect = from;
                     return this;
                 }
                 @Override
                 public ExecBuilder stdin(Optional<? extends RedirectFrom> from) {
                     requireNonNull(from, "from parameter can't be null");
                     inputRedirect = from.orElse(null);
                     return this;
                 }
                 /**
                  * Sets redirection for the stdout, {@link RedirectTo} will be applied
                  * every time the process is started.
                  */
                 @Override
                 public ExecBuilder stdout(RedirectTo out) {
                     requireNonNull(out, "out parameter can't be null");
                     outputRedirect = out;
                     return this;
                 }
                 @Override
                 public ExecBuilder stdout(Optional<? extends RedirectTo> to) {
                     requireNonNull(to, "from parameter can't be null");
                     outputRedirect = to.orElse(null);
                     return this;
                 }
                 /**
                  * Sets redirection for the stderr, {@link RedirectTo} will be applied
                  * every time the process is started.
                  */
                 @Override
                 public ExecBuilder stderr(RedirectTo err) {
                     requireNonNull(err, "err parameter can't be null");
                     errorRedirect = err;
                     return this;
                 }
                 @Override
                 public ExecBuilder stderr(Optional<? extends RedirectTo> to) {
                     requireNonNull(to, "from parameter can't be null");
                     errorRedirect = to.orElse(null);
                     return this;
                 }
                 @Override
                 public ExecBuilder from(CommandSpec commandSpec) {
                     CommandBuilder.super.from(commandSpec);
                     return this;
                 }
                 @Override
                 public ExecBuilder from(PipeSpec pipeSpec) {
                     PipeBuilder.super.from(pipeSpec);
                     return this;
                 }
                 @Override
                 public ExecBuilder from(EnvironmentSpec environmentSpec) {
                     EnvironmentBuilder.super.from(environmentSpec);
                     return this;
                 }
                 /** Implement this function to */
                 protected abstract CompletableFuture<Integer> startInternal(
                         CommandSpec command,
                         EnvironmentSpec environment,
                         PipeSpec redirect) throws IOException;
                 /**
                  * Creates and starts new process and returns {@link CompletableFuture}. The
                  * process may be a remote process, or a shell process or etc.
                  *
                  * @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");
                     var commandLine = new ArrayList<String>();
                     commandLine.add(executable);
                     commandLine.addAll(arguments);
                     return startInternal(
-                        new SelfCommandSpec(),
+                            new SelfCommandSpec(),
-                        new SelfEnvironmentSpec(),
+                            new SelfEnvironmentSpec(),
-                        new SelfPipeSpec()
+                            new SelfPipeSpec());
-                    );
                 }
                 private class SelfCommandSpec implements CommandSpec {
                     @Override
                     public String executable() {
                         return executable;
                     }
                     @Override
                     public List<String> arguments() {
                         return arguments;
                     }
                 }
                 private class SelfEnvironmentSpec implements EnvironmentSpec {
+                    @Override
+                    public boolean inheritEnvironment() {
+                        return inheritEnvironment;
+                    }
                     @Override
                     public Map<String, String> environment() {
                         return environment;
                     }
                     @Override
                     public Optional<File> workingDirectory() {
-                        return Optional.ofNullable( directory);
+                        return Optional.ofNullable(directory);
                     }
                 }
                 private class SelfPipeSpec implements PipeSpec {
                     @Override
                     public Optional<RedirectTo> stdout() {
                         return Optional.ofNullable(outputRedirect);
                     }
                     @Override
                     public Optional<RedirectTo> stderr() {
                         return Optional.ofNullable(errorRedirect);
                     }
                     @Override
                     public Optional<RedirectFrom> stdin() {
                         return Optional.ofNullable(inputRedirect);
                     }
                 }
             }

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

             package org.implab.gradle.common.exec;
             import java.io.IOException;
             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

             package org.implab.gradle.common.exec;
             import java.io.File;
             import java.io.FileInputStream;
             import java.io.InputStream;
             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) {
                             from.transferTo(to);
                         } catch (Exception e) {
                             // silence!
                         }
                     });
                 }
                 public static RedirectFrom stream(final InputStream from) {
                     return to -> CompletableFuture.runAsync(() -> {
                         try (from; to) {
                             from.transferTo(to);
                         } catch (Exception e) {
                             // silence!
                         }
                     });
                 }
                 public static RedirectFrom any(final Object output) {
                     if (output instanceof File f) {
                         return file(f);
                     } else if (output instanceof InputStream stm) {
                         return stream(stm);
                     } else if (output instanceof RedirectFrom self) {
                         return self;
                     } else {
                         throw new IllegalArgumentException("The specified argument type isn't supported: " + output.getClass());
                     }
                 }
             }

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

             package org.implab.gradle.common.exec;
             import java.io.File;
             import java.io.FileOutputStream;
             import java.io.InputStream;
             import java.io.OutputStream;
             import java.util.Scanner;
             import java.util.concurrent.CompletableFuture;
             import java.util.function.Consumer;
             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 {
                 CompletableFuture<Void> redirect(InputStream from);
                 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
                         public void accept(String s) {
                             consumer.accept(s);
                         }
                     });
                 }
+                /** Creates a redirect to the specified consumer */
                 public static RedirectTo consumer(final StringConsumer consumer) {
                     return (src) -> CompletableFuture.runAsync(() -> {
                         try (Scanner sc = new Scanner(src)) {
                             while (sc.hasNextLine()) {
                                 consumer.accept(sc.nextLine());
                             }
                         }
                     });
                 }
+                /**
+                 * 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)) {
                             src.transferTo(out);
                         } catch (Exception e) {
                             // silence!
                         }
                     });
                 }
+                /** Creates a redirect to the specified output stream. */
                 public static RedirectTo stream(final OutputStream dest) {
                     return src -> CompletableFuture.runAsync(() -> {
                         try (dest; src) {
                             src.transferTo(dest);
                         } catch (Exception e) {
                             // silence!
                         }
                     });
                 }
+                /**
+                 * 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));
                     } else if (output instanceof File f) {
                         return file(f);
                     } else if (output instanceof OutputStream stm) {
                         return stream(stm);
                     } else if (output instanceof RedirectTo self) {
                         return self;
                     } else {
                         throw new IllegalArgumentException("The specified argument type isn't supported: " + output.getClass());
                     }
                 }
             }

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

             package org.implab.gradle.common.exec;
             import java.io.IOException;
             import java.lang.ProcessBuilder.Redirect;
             import java.util.ArrayList;
             import java.util.concurrent.CompletableFuture;
             class SystemExecBuilder extends ExecBuilder {
                 @Override
                 protected CompletableFuture<Integer> startInternal(
-                    CommandSpec command,
+                        CommandSpec command,
                         EnvironmentSpec environment,
                         PipeSpec redirect) throws IOException {
                     var builder = new ProcessBuilder(command.commandLine());
                     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<?>>();
                     if (!redirect.stdout().isPresent())
                         builder.redirectOutput(Redirect.DISCARD);
                     if (!redirect.stderr().isPresent())
                         builder.redirectError(Redirect.DISCARD);
                     // run process
                     var proc = builder.start();
                     tasks.add(proc.onExit());
                     redirect.stdin().map(from -> from.redirect(proc.getOutputStream())).ifPresent(tasks::add);
                     redirect.stdout().map(to -> to.redirect(proc.getInputStream())).ifPresent(tasks::add);
                     redirect.stderr().map(to -> to.redirect(proc.getErrorStream())).ifPresent(tasks::add);
                     return CompletableFuture
                             .allOf(tasks.toArray(new CompletableFuture<?>[0]))
                             .thenApply(t -> proc.exitValue());
                 }
             }

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

             package org.implab.gradle.common.tasks;
             import java.io.IOException;
             import java.util.Map;
             import java.util.concurrent.ExecutionException;
             import java.util.stream.Stream;
             import org.gradle.api.DefaultTask;
             import org.gradle.api.file.DirectoryProperty;
             import org.gradle.api.provider.ListProperty;
             import org.gradle.api.provider.MapProperty;
             import org.gradle.api.tasks.Internal;
             import org.gradle.api.tasks.TaskAction;
             import org.implab.gradle.common.dsl.CommandSpec;
             import org.implab.gradle.common.dsl.PipeSpec;
             import org.implab.gradle.common.dsl.RedirectFromSpec;
             import org.implab.gradle.common.dsl.RedirectToSpec;
             import org.implab.gradle.common.dsl.EnvironmentSpec;
             import org.implab.gradle.common.exec.ExecBuilder;
             import org.implab.gradle.common.utils.ObjectsMixin;
             import org.implab.gradle.common.utils.Strings;
             import org.implab.gradle.common.utils.ThrowingConsumer;
             public abstract class ShellExecTask
                     extends DefaultTask
                     implements CommandSpec, PipeSpec, EnvironmentSpec, ObjectsMixin {
                 private final RedirectToSpec redirectStderr = new RedirectToSpec();
                 private final RedirectToSpec redirectStdout = new RedirectToSpec();
                 private final RedirectFromSpec redirectStdin = new RedirectFromSpec();
                 @Internal
                 @Override
                 public abstract DirectoryProperty getWorkingDirectory();
                 @Internal
                 @Override
                 public abstract MapProperty<String, String> getEnvironment();
                 @Internal
                 @Override
                 public abstract ListProperty<String> getCommandLine();
                 /**
                  * STDIN redirection, if not specified, no input will be passed to the command
                  */
                 @Internal
                 @Override
                 public RedirectFromSpec getStdin() {
                     return redirectStdin;
                 }
                 /**
                  * STDOUT redirection, if not specified, redirected to logger::info
                  */
                 @Internal
                 @Override
                 public RedirectToSpec getStdout() {
                     return redirectStdout;
                 }
                 /**
                  * STDERR redirection, if not specified, redirected to logger::error
                  */
                 @Internal
                 @Override
                 public RedirectToSpec getStderr() {
                     return redirectStderr;
                 }
                 @Override
                 public void commandLine(Object arg0, Object... args) {
                     getCommandLine().set(provider(() -> Stream.concat(
                             Stream.of(arg0),
                             Stream.of(args))
                             .map(Strings::asString).toList()));
                 }
                 @Override
                 public void args(Object arg0, Object... args) {
                     getCommandLine().addAll(provider(() -> Stream.concat(
                             Stream.of(arg0),
                             Stream.of(args))
                             .map(Strings::asString).toList()));
                 }
                 protected abstract ExecBuilder execBuilder();
                 @TaskAction
                 public final void run() throws IOException, InterruptedException, ExecutionException {
                     var execBuilder = execBuilder();
                     execBuilder.workingDirectory(getWorkingDirectory().get().getAsFile());
                     execBuilder.environment(getEnvironment().getOrElse(Map.of()));
                     execBuilder.commandLine(getCommandLine().get());
                     getStdout().getRedirection().ifPresent(execBuilder::stdout);
                     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 {
                     throw new IOException(String.format("The process is terminated with code %s", code));
                 }
             }

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