import jetbrains.buildServer.ExecResult; //导入依赖的package包/类
public int dumpPdbGuidsToFile(Collection<File> files, File output, BuildProgressLogger buildLogger) throws IOException {
  final GeneralCommandLine commandLine = new GeneralCommandLine();
  commandLine.setExePath(myExePath.getPath());
  commandLine.addParameter(DUMP_SYMBOL_SIGN_CMD);
  commandLine.addParameter(String.format("/o=%s", output.getPath()));
  commandLine.addParameter(String.format("/i=%s", dumpPathsToFile(files).getPath()));
  buildLogger.message(String.format("Running command %s", commandLine.getCommandLineString()));
  final ExecResult execResult = SimpleCommandLineProcessRunner.runCommand(commandLine, null);
  final String stdout = execResult.getStdout();
  if(!stdout.isEmpty()){
    buildLogger.message("Stdout: " + stdout);
  }
  final int exitCode = execResult.getExitCode();
  if (exitCode != 0) {
    buildLogger.warning(String.format("%s ends with non-zero exit code %s.", SYMBOLS_EXE, execResult));
    buildLogger.warning("Stdout: " + stdout);
    buildLogger.warning("Stderr: " + execResult.getStderr());
    final Throwable exception = execResult.getException();
    if(exception != null){
      buildLogger.exception(exception);
    }
  }
  return exitCode;
}
 

import jetbrains.buildServer.ExecResult; //导入依赖的package包/类
@Nullable
private String runCommand(@NotNull String command) {
  final GeneralCommandLine cmd = new GeneralCommandLine();
  cmd.setExePath("/bin/sh");
  cmd.addParameter("-c");
  cmd.addParameter(command);

  final ExecResult result = SimpleCommandLineProcessRunner.runCommand(cmd, new byte[0]);

  //noinspection ThrowableResultOfMethodCallIgnored
  if (result.getException() != null || result.getExitCode() != 0) {
    LOG.info(("Failed to call '" + command+ "'. Exit code: " + result.getExitCode() + "\n " + result.getStdout() + "\n" + result.getStderr()).trim());
    return null;
  }

  return result.getStdout().trim();
}
 

import jetbrains.buildServer.ExecResult; //导入依赖的package包/类
private void processExecStep(SoftInstallExecStep step)
        throws SoftInstallException
{
  final String cmdLine = step.getCmdLine();
  myBuildLogger.message("RUNNING: " + cmdLine);

  ExecResult result = runCommand(cmdLine);
  final int exitCode = result.getExitCode();

  final String stdout = result.getStdout();
  if (stdout.length() > 0) {
    logMessage(stdout);
  }

  final String stderr = result.getStderr();
  if (stderr.length() > 0) {
    if (exitCode != 0) myBuildLogger.error(stderr);
    else logMessage(stderr);
  }

  if (exitCode != 0) {
    throw new SoftInstallException("Exit code "+ exitCode +" from process: " + cmdLine);
  }
}
 

import jetbrains.buildServer.ExecResult; //导入依赖的package包/类
ExecResult runCommand(@NotNull String commandLine)
        throws SoftInstallException
{
  Pair<File,String> systemCommandInterpreter = getSystemCommandIntepreter();
  if (!systemCommandInterpreter.first.isFile()) {
    throw new SoftInstallException("System command interpreter not found: " + systemCommandInterpreter);
  }

  final List<String> givenArgs = parseCommandLine(commandLine);

  ArrayList<String> allArgs = new ArrayList<String>(givenArgs.size()+1);
  allArgs.add(systemCommandInterpreter.second);
  allArgs.addAll(givenArgs);

  try {
    return runExeFile(systemCommandInterpreter.first, allArgs, null);
  }
  catch (ExecutionException ee) {
    throw new SoftInstallException("Failed to run: " + commandLine);
  }
}
 

import jetbrains.buildServer.ExecResult; //导入依赖的package包/类
private static void enableExecution(@NotNull final File filePath) {
  final GeneralCommandLine commandLine = new GeneralCommandLine();
  
  commandLine.setExePath("chmod");
  commandLine.addParameter("+x");
  commandLine.addParameter(filePath.getName());
  commandLine.setWorkDirectory(filePath.getParent());

  final ExecResult execResult = SimpleCommandLineProcessRunner.runCommand(commandLine, null);
  if (execResult.getExitCode() != 0) {
    LOG.warn("Failed to set executable attribute for " + filePath + ": chmod +x exit code is " + execResult.getExitCode());
  }
}
 

import jetbrains.buildServer.ExecResult; //导入依赖的package包/类
/**
 * Returns True if Existed Tool myConfigName
 * @return
 */
public boolean isExistedTool(){
  final GeneralCommandLine commandLine = new GeneralCommandLine();
  commandLine.setExePath(myToolName);
  commandLine.addParameter(myVersionArg);
  final ExecResult execResult = SimpleCommandLineProcessRunner.runCommand(commandLine, (byte[])null);
  if (execResult.getExitCode() == 0){
    myVersion = findVersion(stringArrayToString(execResult.getOutLines()));
  }
  return execResult.getExitCode() == 0;
}
 

import jetbrains.buildServer.ExecResult; //导入依赖的package包/类
/**
 * Set executable attribute for file.
 * @param filePath File to be setted executable attribute
 * @param baseDir Directory to be setted Work Directory
 */
private static void enableExecution(@NotNull final String filePath, @NotNull final String baseDir) {
  final GeneralCommandLine commandLine = new GeneralCommandLine();
  commandLine.setExePath("chmod");
  commandLine.addParameter("+x");
  commandLine.addParameter(filePath);
  commandLine.setWorkDirectory(baseDir);
  final ExecResult execResult = SimpleCommandLineProcessRunner.runCommand(commandLine, null);
  if(execResult.getExitCode() != 0) {
    Loggers.AGENT.warn("Failed to set executable attribute for " + filePath + ": chmod +x exit code is " + execResult.getExitCode());
  }
}
 

import jetbrains.buildServer.ExecResult; //导入依赖的package包/类
public ExecResult doCommand(final PdbStrExeCommands cmd, final File pdbFile, final File inputStreamFile, final String streamName){
  final GeneralCommandLine commandLine = new GeneralCommandLine();
  commandLine.setWorkDirectory(myPath.getParent());
  commandLine.setExePath(myPath.getPath());
  commandLine.addParameter(cmd.getCmdSwitch());
  commandLine.addParameter(String.format("%s:%s", PATH_TO_PDB_FILE_SWITCH, pdbFile.getAbsolutePath()));
  commandLine.addParameter(String.format("%s:%s", PATH_TO_INPUT_FILE_SWITCH, inputStreamFile.getAbsolutePath()));
  commandLine.addParameter(STREAM_NAME_SWITCH + ":" + streamName);
  return SimpleCommandLineProcessRunner.runCommand(commandLine, null);
}
 

import jetbrains.buildServer.ExecResult; //导入依赖的package包/类
public Collection<File> getReferencedSourceFiles(File symbolsFile) {
  final GeneralCommandLine commandLine = new GeneralCommandLine();
  commandLine.setExePath(mySrcToolPath.getPath());
  commandLine.addParameter(symbolsFile.getAbsolutePath());
  commandLine.addParameter(DUMP_SOURCES_FROM_PDB_SWITCH);
  final ExecResult execResult = SimpleCommandLineProcessRunner.runCommand(commandLine, null);
  return CollectionsUtil.convertAndFilterNulls(Arrays.asList(execResult.getOutLines()), new Converter<File, String>() {
    public File createFrom(@NotNull String source) {
      final File file = new File(source);
      if (file.isFile()) return file;
      return null; //last string is not a source file path
    }
  });
}
 

import jetbrains.buildServer.ExecResult; //导入依赖的package包/类
@Test
public void testRead() throws Exception {
  final File tempFile = createTempFile();
  assertTrue(tempFile.length() == 0);
  ExecResult execResult = myTool.doCommand(PdbStrExeCommands.READ, myIndexedPdbFile, tempFile, PdbStrExe.SRCSRV_STREAM_NAME);
  assertEquals(0, execResult.getExitCode());
  assertFalse(tempFile.length() == 0);
}
 

import jetbrains.buildServer.ExecResult; //导入依赖的package包/类
private Result<AccessControlEntry, Boolean> processResult(@NotNull final AccessControlEntry entry, @NotNull final ExecResult result) {
  if(result.getExitCode() != 0) {
    final String resultStr = result.toString();
    LOG.warn(resultStr);
    return new Result<AccessControlEntry, Boolean>(entry, false);
  }

  return new Result<AccessControlEntry, Boolean>(entry, true);
}
 

import jetbrains.buildServer.ExecResult; //导入依赖的package包/类
@Nullable
private Result<AccessControlEntry, Boolean> tryExecChmod(@NotNull final AccessControlEntry entry, @NotNull final Iterable<String> chmodPermissions)
{
  final String chmodPermissionsStr = StringUtil.join("", chmodPermissions);
  if(StringUtil.isEmptyOrSpaces(chmodPermissionsStr)) {
    return null;
  }

  final ArrayList<CommandLineArgument> args = new ArrayList<CommandLineArgument>();
  if (entry.getPermissions().contains(AccessPermissions.Recursive)) {
    args.add(new CommandLineArgument("-R", CommandLineArgument.Type.PARAMETER));
  }
  args.add(new CommandLineArgument(chmodPermissionsStr, CommandLineArgument.Type.PARAMETER));
  args.add(new CommandLineArgument(entry.getFile().getAbsolutePath(), CommandLineArgument.Type.PARAMETER));
  final CommandLineSetup chmodCommandLineSetup = new CommandLineSetup(CHMOD_TOOL_NAME, args, Collections.<CommandLineResource>emptyList());
  try {
    final ExecResult result = myCommandLineExecutor.runProcess(chmodCommandLineSetup, EXECUTION_TIMEOUT_SECONDS);
    if(result == null) {
      return null;
    }

    return processResult(entry, result);
  }
  catch (ExecutionException e) {
    LOG.error(e);
    return new Result<AccessControlEntry, Boolean>(entry, e);
  }
}
 

import jetbrains.buildServer.ExecResult; //导入依赖的package包/类
static ExecResult runExeFile(final @NotNull File exeFile,
                             final @Nullable List<String> args,
                             final @Nullable String inputText)
        throws ExecutionException
{
  GeneralCommandLine cmdLine = new GeneralCommandLine();
  cmdLine.setExePath(exeFile.getAbsolutePath());
  cmdLine.setPassParentEnvs(true);
  if (args != null)
      cmdLine.addParameters(args);

  final byte[] input = inputText != null
          ? inputText.getBytes()
          : new byte[0];

  try
  {
    ExecResult execResult;
    final Thread currentThread = Thread.currentThread();
    final String threadName = currentThread.getName();
    final String newThreadName = "SoftInstall: waiting for: " + cmdLine.getCommandLineString();
    currentThread.setName(newThreadName);
    try
    {
      execResult = SimpleCommandLineProcessRunner.runCommand(cmdLine, input);
    }
    finally
    {
      currentThread.setName(threadName);
    }
    return execResult;
  }
  catch (Exception e)
  {
    throw new ExecutionException(e.getMessage(), e);
  }
}
 

import jetbrains.buildServer.ExecResult; //导入依赖的package包/类
@Nullable
public ExecResult runProcess(@NotNull final CommandLineSetup commandLineSetup, final int executionTimeoutSeconds) throws ExecutionException {
  final GeneralCommandLine cmd = new GeneralCommandLine();
  cmd.setExePath(commandLineSetup.getToolPath());
  for (CommandLineArgument arg: commandLineSetup.getArgs()) {
    cmd.addParameter(arg.getValue());
  }

  try {
    LOG.info("Exec: " + cmd.getCommandLineString());
    final jetbrains.buildServer.CommandLineExecutor executor = new jetbrains.buildServer.CommandLineExecutor(cmd);
    final ExecResult result = executor.runProcess(executionTimeoutSeconds);
    if(LOG.isDebugEnabled()) {
      StringBuilder resultStr = new StringBuilder();
      if (result != null) {
        resultStr.append("exit code: ");
        resultStr.append(result.getExitCode());
        final String[] outLines = result.getOutLines();
        if (outLines != null) {
          resultStr.append("out: ");
          for (String line : outLines) {
            if (!StringUtil.isEmpty(line)) {
              resultStr.append(line);
            }

            resultStr.append(LINE_SEPARATOR);
          }
        }
      } else {
        resultStr.append("has no result");
      }

      LOG.debug("Result: " + resultStr);
    }

    return result;
  }
  catch (RuntimeException ex) {
    throw new ExecutionException(ex.getMessage());
  }
}
 

import jetbrains.buildServer.ExecResult; //导入依赖的package包/类
@Nullable
ExecResult runProcess(@NotNull final CommandLineSetup commandLineSetup, final int executionTimeoutSeconds) throws ExecutionException;
 

import jetbrains.buildServer.ExecResult; //导入依赖的package包/类
@Test(dataProvider = "getSetPermissionsForLinuxCases")
public void shouldSetPermissionsForLinux(
  @NotNull final AccessControlList accessControlList,
  final int exitCode,
  @Nullable final Exception error,
  @Nullable final List<CommandLineSetup> expectedCommandLineSetups,
  @Nullable final List<Object> expectedResult) throws ExecutionException {
  // Given
  final FileAccessService instance = createInstance();
  final ArrayList<CommandLineSetup> actualCommandLineSetups = new ArrayList<CommandLineSetup>();

  myCtx.checking(new Expectations() {{
    allowing(myCommandLineExecutor).runProcess(with(any(CommandLineSetup.class)), with(any(int.class)));
    if(error != null) {
      will(throwException(error));
    }
    else {
      will(new CustomAction("runProcess") {
        @Override
        public Object invoke(final Invocation invocation) throws Throwable {
          actualCommandLineSetups.add((CommandLineSetup)invocation.getParameter(0));
          final ExecResult execResult = new ExecResult();
          execResult.setExitCode(exitCode);
          return execResult;
        }
      });
    }
  }});

  // When
  final Iterable<Result<AccessControlEntry, Boolean>> result = instance.setAccess(accessControlList);
  final List<Object> actualResult = CollectionsUtil.convertCollection(
    Lists.newArrayList(result), new Converter<Object, Result<AccessControlEntry, Boolean>>() {
      @Override
      public Object createFrom(@NotNull final Result<AccessControlEntry, Boolean> aceResult) {
        if(aceResult.isSuccessful()) {
          return aceResult.getValue();
        }

        return null;
      }
    });

  // Then
  myCtx.assertIsSatisfied();
  then(actualCommandLineSetups).isEqualTo(expectedCommandLineSetups);
  then(actualResult).isEqualTo(expectedResult);
}
 

import jetbrains.buildServer.ExecResult; //导入依赖的package包/类
@Test(dataProvider = "getSetPermissionsForWindowsCases")
public void shouldSetPermissionsForWindows(
  @NotNull final AccessControlList accessControlList,
  final int exitCode,
  @Nullable final Exception error,
  @Nullable final List<CommandLineSetup> expectedCommandLineSetups,
  @Nullable final List<Object> expectedResult) throws ExecutionException {
  // Given
  final FileAccessService instance = createInstance();
  final ArrayList<CommandLineSetup> actualCommandLineSetups = new ArrayList<CommandLineSetup>();

  myCtx.checking(new Expectations() {{
    allowing(myCommandLineExecutor).runProcess(with(any(CommandLineSetup.class)), with(any(int.class)));
    if(error != null) {
      will(throwException(error));
    }
    else {
      will(new CustomAction("runProcess") {
        @Override
        public Object invoke(final Invocation invocation) throws Throwable {
          actualCommandLineSetups.add((CommandLineSetup)invocation.getParameter(0));
          final ExecResult execResult = new ExecResult();
          execResult.setExitCode(exitCode);
          return execResult;
        }
      });
    }
  }});

  final Iterable<Result<AccessControlEntry, Boolean>> result = instance.setAccess(accessControlList);
  final List<Object> actualResult = CollectionsUtil.convertCollection(
    Lists.newArrayList(result), new Converter<Object, Result<AccessControlEntry, Boolean>>() {
      @Override
      public Object createFrom(@NotNull final Result<AccessControlEntry, Boolean> aceResult) {
        if(aceResult.isSuccessful()) {
          return aceResult.getValue();
        }

        return null;
      }
    });

  // Then
  myCtx.assertIsSatisfied();
  then(actualCommandLineSetups).isEqualTo(expectedCommandLineSetups);
  then(actualResult).isEqualTo(expectedResult);
}