implab/gradle-common Commit - r7:4ba61464d214

Refactoring exec classes

cin -

r7:4ba61464d214 default

parent child

Context file:

r7:4ba61464d214

Collapse all files

common/src/main/java/org/implab/gradle/common/exec/ExecShell.java created 644 +16 0

@@ -0,0 +1,16
	1	package org.implab.gradle.common.exec;
	2
	3	/** Shell used to start processes */
	4	public interface ExecShell {
	5
	6	/** Creates new process builder {@link ExecBuilder} */
	7	ExecBuilder builder();
	8
	9	/**
	10	* Creates default process execution "shell" which will execute processes
	11	* directly.
	12	*/
	13	static ExecShell system() {
	14	return () -> new SystemExecBuilder();
	15	}
	16	}

common/src/main/java/org/implab/gradle/common/dsl/ProcessSpec.java +2 -2

             package org.implab.gradle.common.dsl;
             import java.io.File;
             import java.util.ArrayList;
             import java.util.Collection;
             import java.util.List;
-            import org.implab.gradle.common.exec.Executor;
+            import org.implab.gradle.common.exec.ExecBuilder;
             import org.implab.gradle.common.exec.RedirectFrom;
             import org.implab.gradle.common.exec.RedirectTo;
             public class ProcessSpec {
                 private RedirectFrom inputRedirect;
                 private RedirectTo outputRedirect;
                 private RedirectTo errorRedirect;
                 private List<String> command = new ArrayList<>();
                 private File directory;
                 public ProcessSpec command(String... args) {
                     command = new ArrayList<>();
                     args(args);
                     return this;
                 }
                 public ProcessSpec directory(File workingDir) {
                     directory = workingDir;
                     return this;
                 }
                 public ProcessSpec command(Collection<String> args) {
                     command = new ArrayList<>();
                     args(args);
                     return this;
                 }
                 public ProcessSpec args(String... args) {
                     for (String arg : args)
                         command.add(arg);
                     return this;
                 }
                 public ProcessSpec args(Collection<String> args) {
                     command.addAll(args);
                     return this;
                 }
                 public ProcessSpec stderr(RedirectTo to) {
                     errorRedirect = to;
                     return this;
                 }
                 public ProcessSpec stdin(RedirectFrom from) {
                     inputRedirect = from;
                     return this;
                 }
                 public ProcessSpec stdout(RedirectTo to) {
                     outputRedirect = to;
                     return this;
                 }
-                public void accept(Executor executor) {
+                public void accept(ExecBuilder executor) {
                     command.forEach(executor::argument);
                     executor.directory(directory);
                     if (inputRedirect != null)
                         executor.stdin(inputRedirect);
                     if (outputRedirect != null)
                         executor.stdout(outputRedirect);
                     if (errorRedirect != null)
                         executor.stderr(errorRedirect);
                 }
             }

common/src/main/java/org/implab/gradle/common/exec/ExecBuilder.java ~~common/src/main/java/org/implab/gradle/common/exec/Executor.java~~ renamed +42 -6

@@ -1,25 +1,61
1	package org.implab.gradle.common.exec;	1	package org.implab.gradle.common.exec;
2		2
3	import java.util.concurrent.CompletableFuture;	3	import java.util.concurrent.CompletableFuture;
4		4
		5	import org.eclipse.jdt.annotation.NonNullByDefault;
		6
5	import java.io.File;	7	import java.io.File;
6	import java.io.IOException;	8	import java.io.IOException;
7		9
8	/** Interface for a command line execution. */	10	/** Command line builder */
9	public interface Executor {	11	@NonNullByDefault
		12	public interface ExecBuilder {
		13
		14	/** Sets command line, clears previous one if any */
		15	void command(String cmd, String... args);
		16
		17	/** Adds an argument to the command line */
10	void argument(String arg);	18	void argument(String arg);
11		19
		20	/** Sets the working directory */
12	void directory(File directory);	21	void directory(File directory);
13		22
		23	/**
		24	* Sets the environment value. The value cannot be null.
		25	*
		26	* @param envVar The name of the environment variable
		27	* @param value The value to set,
		28	*/
		29	void setEnvironment(String envVar, String value);
		30
		31	void unsetEnvironment(String envVar);
		32
		33	/**
		34	* Sets redirection for the stdin, {@link RedirectFrom} will be applied
		35	* every time the process is started.
		36	*
		37	* <p>If redirection
		38	*/
14	void stdin(RedirectFrom from);	39	void stdin(RedirectFrom from);
15		40
		41	/**
		42	* Sets redirection for the stdout, {@link RedirectTo} will be applied
		43	* every time the process is started.
		44	*/
16	void stdout(RedirectTo out);	45	void stdout(RedirectTo out);
17		46
		47	/**
		48	* Sets redirection for the stderr, {@link RedirectTo} will be applied
		49	* every time the process is started.
		50	*/
18	void stderr(RedirectTo err);	51	void stderr(RedirectTo err);
19		52
		53	/**
		54	* Creates and starts new process and returns {@link CompletableFuture}. The
		55	* process may be a remote process, or a shell process or etc.
		56	* @return
		57	* @throws IOException
		58	*/
20	CompletableFuture<Integer> start() throws IOException;	59	CompletableFuture<Integer> start() throws IOException;
21		60
22	public static Executor system() {
23	return new SystemExec();
24	}
25	}	61	}

common/src/main/java/org/implab/gradle/common/exec/RedirectFrom.java +4 0

             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
+             * lazy redirection. {@link #redirect(OutputStream)} is called when the process
+             * is started.
+             */
             public interface RedirectFrom {
                 CompletableFuture<Void> redirect(OutputStream to);
                 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!
                         }
                     });
                 }
             }

common/src/main/java/org/implab/gradle/common/exec/SystemExecBuilder.java ~~common/src/main/java/org/implab/gradle/common/exec/SystemExec.java~~ renamed +27 -5

             package org.implab.gradle.common.exec;
             import java.io.File;
             import java.io.IOException;
             import java.lang.ProcessBuilder.Redirect;
             import java.util.ArrayList;
             import java.util.concurrent.CompletableFuture;
-            class SystemExec implements Executor {
+            class SystemExecBuilder implements ExecBuilder {
                 private final ProcessBuilder builder = new ProcessBuilder();
                 private RedirectFrom inputRedirect;
                 private RedirectTo outputRedirect;
                 private RedirectTo errorRedirect;
                 @Override
                 public CompletableFuture<Integer> start() throws IOException {
                     // TODO Auto-generated method stub
                     var tasks = new ArrayList<CompletableFuture<?>>();
                     // discard stdout if not redirected
                     if (outputRedirect == null)
                         builder.redirectOutput(Redirect.DISCARD);
                     // discard stderr if not redirected
                     if (errorRedirect == null)
                         builder.redirectError(Redirect.DISCARD);
                     // run process
                     var proc = builder.start();
                     tasks.add(proc.onExit());
                     if (inputRedirect != null)
                         tasks.add(inputRedirect.redirect(proc.getOutputStream()));
                     if (outputRedirect != null)
                         tasks.add(outputRedirect.redirect(proc.getInputStream()));
                     if (errorRedirect != null)
                         tasks.add(errorRedirect.redirect(proc.getErrorStream()));
                     return CompletableFuture
                             .allOf(tasks.toArray(new CompletableFuture<?>[0]))
                             .thenApply(t -> proc.exitValue());
                 }
-                public void command(String... args) {
+                @Override
-                    builder.command(args);
                 public void directory(File workingDir) {
                     builder.directory(workingDir);
                 }
+                @Override
                 public void stderr(RedirectTo to) {
                     errorRedirect = to;
                 }
+                @Override
                 public void stdin(RedirectFrom from) {
                     inputRedirect = from;
                 }
+                @Override
                 public void stdout(RedirectTo to) {
                     outputRedirect = to;
                 }
                 @Override
                 public void argument(String arg) {
                     builder.command().add(arg);
                 }
+                @Override
+                public void setEnvironment(String envVar, String value) {
+                    builder.environment().put(envVar, value);
+                }
+                @Override
+                public void unsetEnvironment(String envVar) {
+                    builder.environment().remove(envVar);
+                }
+                @Override
+                public void command(String cmd, String... args) {
+                    var commandLine = new ArrayList<String>();
+                    commandLine.add(cmd);
+                    for (var arg : args)
+                        commandLine.add(arg);
+                    builder.command(commandLine);
+                }
             }

common/src/main/java/org/implab/gradle/common/tasks/ExternalTask.java +2 -2

             package org.implab.gradle.common.tasks;
             import java.io.IOException;
             import java.util.Optional;
             import java.util.concurrent.ExecutionException;
             import org.gradle.api.DefaultTask;
             import org.implab.gradle.common.dsl.ProcessSpec;
-            import org.implab.gradle.common.exec.Executor;
+            import org.implab.gradle.common.exec.ExecBuilder;
             import org.implab.gradle.common.exec.RedirectFrom;
             import org.implab.gradle.common.exec.RedirectTo;
             public abstract class ExternalTask extends DefaultTask {
                 /**
                  * A default redirection to the build log when loglevel is set to INFO,
                  * otherwise returns an empty redirection.
                  */
                 protected Optional<RedirectTo> loggerInfoRedirect() {
                     return getLogger().isInfoEnabled()
                             ? Optional.of(RedirectTo.consumer(getLogger()::info))
                             : Optional.empty();
                 }
                 /**
                  * A default redirection to the build log when loglevel is set to ERROR,
                  * otherwise returns an empty redirection. Note that ERROR level is set
                  * by default for a build runs.
                  */
                 protected Optional<RedirectTo> loggerErrorRedirect() {
                     return getLogger().isErrorEnabled()
                             ? Optional.of(RedirectTo.consumer(getLogger()::error))
                             : Optional.empty();
                 }
                 /**
                  * Stdout redirection for {@link #exec(ProcessSpec)}, default implementation
                  * will forward stdout to the build log through {@link #loggerErrorRedirect()}
                  */
                 protected Optional<RedirectTo> stdoutRedirection() {
                     return loggerInfoRedirect();
                 }
                 /**
                  * Stderr redirection for {@link #exec(ProcessSpec)}, default implementation
                  * will forward stderr to build log through {@link #loggerErrorRedirect()}.
                  */
                 protected Optional<RedirectTo> stderrRedirection() {
                     return loggerErrorRedirect();
                 }
                 /**
                  * Stdin redirection for {@link #exec(ProcessSpec)}, empty by default.
                  */
                 protected Optional<RedirectFrom> stdinRedirection() {
                     return Optional.empty();
                 }
                 /**
                  * Executes the specified process specification
                  *
                  * @param spec
                  * @throws InterruptedException
                  * @throws ExecutionException
                  * @throws IOException
                  */
                 protected void exec(ProcessSpec spec) throws InterruptedException, ExecutionException, IOException {
                     var executor = exec();
                     stdoutRedirection().ifPresent(executor::stdout);
                     stderrRedirection().ifPresent(executor::stderr);
                     stdinRedirection().ifPresent(executor::stdin);
                     getLogger().info("Staring: {}", spec.command());
                     spec.accept(executor);
                     // runs the command and checks the error code
                     var code = executor.start().get();
                     // check success code
                     if (code != 0)
                         throw new IOException("The process exited with error code " + code);
                 }
                 protected boolean checkRetCode(ProcessSpec proc, int code)
                         throws InterruptedException, ExecutionException, IOException {
                     var executor = exec();
                     if (getLogger().isInfoEnabled()) {
                         loggerInfoRedirect().ifPresent(executor::stdout);
                         loggerInfoRedirect().ifPresent(executor::stderr);
                     }
                     getLogger().info("Starting: {}", proc.command());
                     proc.accept(executor);
                     return executor.start().get() == code;
                 }
-                protected abstract Executor exec();
+                protected abstract ExecBuilder exec();
             }

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