org.gradle.process.ExecSpec Java Examples

void copyTo(ExecSpec exec) {
  if (executable != null) {
    exec.executable(executable);
  }
  if (arguments != null) {
    exec.args(arguments);
  }
  if (environment != null) {
    exec.environment(environment);
  }
  if (ignoreExitValue != null) {
    exec.setIgnoreExitValue(ignoreExitValue);
  }
  if (workingDir != null) {
    exec.workingDir(workingDir);
  }
  if (standardInput != null) {
    exec.setStandardInput(standardInput);
  }
  if (standardOutput != null) {
    exec.setStandardOutput(standardOutput);
  }
  if (standardError != null) {
    exec.setErrorOutput(standardError);
  }
}
 

/**
 * Executes an external program by customizing a {@link ExecSpec} with the supplied {@link
 * Action}. If the customized {@link ExecSpec} is serializable, the execution will happen in
 * parallel with others by running in {@link WorkerExecutor}, otherwise it will be invoked
 * serially.
 */
public static void exec(
    Project project, WorkerExecutor workerExecutor, Action<? super ExecSpec> action) {
  var customizer = new ExecCustomizer(project);
  action.execute(customizer);
  if (customizer.isSerializable()) {
    project.getLogger().info("Executing command in worker executor.");
    workerExecutor
        .noIsolation()
        .submit(
            ExecWorkAction.class, parameters -> parameters.getExecCustomizer().set(customizer));
  } else {
    project.getLogger().info("Executing command serially.");
    project.exec(customizer::copyTo);
  }
}
 

public static synchronized File doZipAlign(final AndroidBuilder androidBuilder, Project project, final File apkFile) {

        final File zipalignedFile = new File(apkFile.getParent(), apkFile.getName().replace(".apk", "-zipaligned.apk"));

        project.exec(new Action<ExecSpec>() {
            @Override
            public void execute(ExecSpec execSpec) {

                String path = androidBuilder.getTargetInfo()
                        .getBuildTools().getPath(ZIP_ALIGN);
                execSpec.executable(new File(path));
                execSpec.args("-f", "4");
                execSpec.args(apkFile);
                execSpec.args(zipalignedFile);
            }
        });

        return zipalignedFile;
    }
 

public static synchronized File doZipAlign(final AndroidBuilder androidBuilder, Project project, final File apkFile) {

        final File zipalignedFile = new File(apkFile.getParent(), apkFile.getName().replace(".apk", "-zipaligned.apk"));

        project.exec(new Action<ExecSpec>() {
            @Override
            public void execute(ExecSpec execSpec) {

                String path = androidBuilder.getTargetInfo()
                        .getBuildTools().getPath(ZIP_ALIGN);
                execSpec.executable(new File(path));
                execSpec.args("-f", "4");
                execSpec.args(apkFile);
                execSpec.args(zipalignedFile);
            }
        });

        return zipalignedFile;
    }
 

@Override
public void execute(ExecSpec execSpec) {
    execSpec.commandLine(pythonExtension.getDetails().getVirtualEnvInterpreter());
    execSpec.args(pythonExtension.getDetails().getVirtualEnvironment().getPex());

    System.out.println(outputFile.getAbsolutePath());

    execSpec.args(Arrays.asList("--no-pypi",
        "--cache-dir", pexCache.getAbsolutePath(),
        "--output-file", outputFile.getAbsolutePath(),
        "--repo", wheelCache.getAbsolutePath(),
        "--python-shebang", pexShebang.getAbsolutePath()));

    if (entryPoint != null) {
        execSpec.args(Arrays.asList("--entry-point", entryPoint));
    }

    execSpec.args(pexOptions);
    execSpec.args(pexRequirements(dependencies));

    execSpec.setStandardOutput(outputStream);
    execSpec.setErrorOutput(outputStream);
    execSpec.setIgnoreExitValue(true);
}
 

public static void goExec(ExecSpec exec, Project project, String command, Iterable<String> args) {
  var toolManager = DownloadedToolManager.get(project);
  exec.executable(toolManager.getBinDir("go").resolve(command));
  exec.args(args);
  exec.environment("GOROOT", toolManager.getToolDir("go").resolve("go"));
  exec.environment(
      "GOPATH", project.getExtensions().getByType(ExtraPropertiesExtension.class).get("gopath"));
  if (!"true"
      .equals(project.getRootProject().findProperty("org.curioswitch.curiostack.goModUpdate"))) {
    exec.environment("GOFLAGS", "-mod=readonly");
  }

  toolManager.addAllToPath(exec);
}
 

@Override
public ExecSpec commandLine(Iterable<?> args) {
  List<Object> argsList = ImmutableList.copyOf(args);
  executable(argsList.get(0));
  setArgs(argsList.subList(1, argsList.size()));
  return this;
}
 

public static void addExecToProject(Project project) {
  project
      .getExtensions()
      .getExtraProperties()
      .set(
          "condaExec",
          (Action<Action<ExecSpec>>)
              execSpecAction ->
                  project.exec(
                      exec -> {
                        execSpecAction.execute(exec);
                        condaExec(exec, project);
                      }));
}
 

@Override
public void execute(ExecSpec execSpec) {
    execSpec.setExecutable(processInfo.getExecutable());
    execSpec.args(processInfo.getArgs());
    execSpec.environment(processInfo.getEnvironment());
    execSpec.setStandardOutput(processOutput.getStandardOutput());
    execSpec.setErrorOutput(processOutput.getErrorOutput());

    // we want the caller to be able to do its own thing.
    execSpec.setIgnoreExitValue(true);
}
 

@TaskAction
public void zipAlign() {
    getProject().exec(new Action<ExecSpec>() {
        @Override
        public void execute(ExecSpec execSpec) {
            execSpec.executable(getZipAlignExe());
            execSpec.args("-f", "4");
            execSpec.args(getInputFile());
            execSpec.args(getOutputFile());
        }
    });
}
 

public TerraformTask setExecCustomizer(Action<ExecSpec> execCustomizer) {
  this.execCustomizer = requireNonNull(execCustomizer, "execCustomizer");
  return this;
}
 

@Input
public Action<ExecSpec> getExecCustomizer() {
  return execCustomizer;
}
 

public CondaExecTask setExecCustomizer(Action<ExecSpec> execCustomizer) {
  this.execCustomizer = execCustomizer;
  return this;
}
 

public static void condaExec(ExecSpec exec, Project project) {
  condaExec(exec, DownloadedToolManager.get(project), "miniconda-build");
}
 

@Override
public ExecResult exec(Action<? super ExecSpec> action) {
    return project.exec(action);
}
 

public void setOutputs(ExecSpec execSpec) {
    execSpec.setStandardOutput(teeStdOut);
    execSpec.setErrorOutput(teeErrOut);
}
 

public void configureExecution(ExecSpec spec) {
}
 

/**
 * The action that configures the execution of command line
 */
public Action<ExecSpec> getSetupAction() {
    return setupAction;
}
 

public static Action<ExecSpec> ignoreResult() {
    return spec -> spec.setIgnoreExitValue(true);
}
 

public static Action<ExecSpec> ignoreResult(final File workingDir) {
    return spec -> {
        spec.setIgnoreExitValue(true);
        spec.setWorkingDir(workingDir);
    };
}
 

public ExecSpecBackedArgCollector(ExecSpec action) {
    this.action = action;
}
 

public void contributeCommandLineOptions(ExecSpec execHandleBuilder) {
    execHandleBuilder
        .args(GUtil.prefix("-J", jFlags)) // J flags can not be set in the option file
        .args(GUtil.prefix("@", GFileUtils.toPaths(optionFiles))); // add additional option files
}
 

public ExecResult exec(Closure closure) {
    return exec(new ClosureBackedAction<ExecSpec>(closure));
}
 

public ExecResult exec(Action<? super ExecSpec> action) {
    return getProcessOperations().exec(action);
}
 

public ExecResult exec(Action<? super ExecSpec> action) {
    ExecAction execAction = instantiator.newInstance(DefaultExecAction.class, fileResolver);
    action.execute(execAction);
    return execAction.execute();
}
 

public ExecResult exec(Closure closure) {
    return processOperations.exec(new ClosureBackedAction<ExecSpec>(closure));
}
 

public ExecResult exec(Action<? super ExecSpec> action) {
    return processOperations.exec(action);
}
 

/**
 * {@inheritDoc}
 */
public ExecSpec commandLine(Iterable<?> args) {
    execAction.commandLine(args);
    return this;
}
 

/**
 * {@inheritDoc}
 */
public ExecSpec setIgnoreExitValue(boolean ignoreExitValue) {
    execAction.setIgnoreExitValue(ignoreExitValue);
    return this;
}
 

public ExecSpecBackedArgCollector(ExecSpec action) {
    this.action = action;
}