Java Code Examples for com.intellij.execution.configurations.GeneralCommandLine#withEnvironment()

/**
 * Creates the command line to run.
 * <p>
 * If a project is supplied, it will be used to determine the ANDROID_HOME variable for the subprocess.
 */
@NotNull
public GeneralCommandLine createGeneralCommandLine(@Nullable Project project) {
  final GeneralCommandLine line = new GeneralCommandLine();
  line.setCharset(CharsetToolkit.UTF8_CHARSET);
  line.withEnvironment(FlutterSdkUtil.FLUTTER_HOST_ENV, FlutterSdkUtil.getFlutterHostEnvValue());
  final String androidHome = IntelliJAndroidSdk.chooseAndroidHome(project, false);
  if (androidHome != null) {
    line.withEnvironment("ANDROID_HOME", androidHome);
  }
  line.setExePath(FileUtil.toSystemDependentName(sdk.getHomePath() + "/bin/" + FlutterSdkUtil.flutterScriptName()));
  if (workDir != null) {
    line.setWorkDirectory(workDir.getPath());
  }
  if (!isDoctorCommand()) {
    line.addParameter("--no-color");
  }
  line.addParameters(type.subCommand);
  line.addParameters(args);
  return line;
}
 

/**
 * Creates the command line to run.
 * <p>
 * If a project is supplied, it will be used to determine the ANDROID_HOME variable for the subprocess.
 */
@NotNull
public GeneralCommandLine createGeneralCommandLine(@Nullable Project project) {
  final GeneralCommandLine line = new GeneralCommandLine();
  line.setCharset(CharsetToolkit.UTF8_CHARSET);
  line.withEnvironment(FlutterSdkUtil.FLUTTER_HOST_ENV, FlutterSdkUtil.getFlutterHostEnvValue());
  final String androidHome = IntelliJAndroidSdk.chooseAndroidHome(project, false);
  if (androidHome != null) {
    line.withEnvironment("ANDROID_HOME", androidHome);
  }
  line.setExePath(FileUtil.toSystemDependentName(sdk.getHomePath() + "/bin/" + FlutterSdkUtil.flutterScriptName()));
  if (workDir != null) {
    line.setWorkDirectory(workDir.getPath());
  }
  if (!isDoctorCommand()) {
    line.addParameter("--no-color");
  }
  line.addParameters(type.subCommand);
  line.addParameters(args);
  return line;
}
 

@NotNull
public static GeneralCommandLine createCommandLine(String workingDir, BashRunConfiguration runConfig) {
    String interpreterPath;
    if (runConfig.isUseProjectInterpreter()) {
        interpreterPath = BashProjectSettings.storedSettings(runConfig.getProject()).getProjectInterpreter();
    } else {
        interpreterPath = runConfig.getInterpreterPath();
    }

    GeneralCommandLine cmd = new GeneralCommandLine();
    cmd.setExePath(interpreterPath);
    cmd.getParametersList().addParametersString(runConfig.getInterpreterOptions());

    cmd.addParameter(runConfig.getScriptName());
    cmd.getParametersList().addParametersString(runConfig.getProgramParameters());

    cmd.withWorkDirectory(workingDir);
    cmd.withParentEnvironmentType(runConfig.isPassParentEnvs() ? GeneralCommandLine.ParentEnvironmentType.CONSOLE : GeneralCommandLine.ParentEnvironmentType.NONE);
    cmd.withEnvironment(runConfig.getEnvs());
    return cmd;
}
 

private void addProgramArguments(GeneralCommandLine commandLine) {
    if (programParameters == null) {
        return;
    }
    String parameters = programParameters.getProgramParameters();
    if (!Strings.isEmpty(parameters)) {
        commandLine.addParameters(programParameters.getProgramParameters().split(" "));
    }
    Map<String, String> envs = programParameters.getEnvs();
    if (!envs.isEmpty()) {
        commandLine.withEnvironment(envs);
    }
    if (Strings.isNotEmpty(programParameters.getWorkingDirectory())) {
        commandLine.setWorkDirectory(new File(programParameters.getWorkingDirectory()));
    }
}
 

/**
 * @param project a project
 * @param command a command to execute (if empty string, the parameter is ignored)
 * @param doStartNotify true if the handler should call OSHandler#startNotify
 */
public BuckCommandHandler(Project project, BuckCommand command, boolean doStartNotify) {
  this.doStartNotify = doStartNotify;

  String buckExecutable =
      BuckExecutableSettingsProvider.getInstance(project).resolveBuckExecutable();

  this.project = project;
  this.buckModule = project.getComponent(BuckModule.class);
  this.command = command;
  commandLine = new GeneralCommandLine();
  commandLine.setExePath(buckExecutable);
  commandLine.withWorkDirectory(calcWorkingDirFor(project));
  commandLine.withEnvironment(EnvironmentUtil.getEnvironmentMap());
  commandLine.addParameter(command.name());
  for (String parameter : command.getParameters()) {
    commandLine.addParameter(parameter);
  }
}
 

private GeneralCommandLine toCommandLine() {
  final GeneralCommandLine result = new GeneralCommandLine().withWorkDirectory(workDir);
  result.setCharset(CharsetToolkit.UTF8_CHARSET);
  result.setExePath(FileUtil.toSystemDependentName(command));
  result.withEnvironment(FlutterSdkUtil.FLUTTER_HOST_ENV, FlutterSdkUtil.getFlutterHostEnvValue());
  if (androidHome != null) {
    result.withEnvironment("ANDROID_HOME", androidHome);
  }
  for (String param : parameters) {
    result.addParameter(param);
  }
  return result;
}
 

private GeneralCommandLine toCommandLine() {
  final GeneralCommandLine result = new GeneralCommandLine().withWorkDirectory(workDir);
  result.setCharset(CharsetToolkit.UTF8_CHARSET);
  result.setExePath(FileUtil.toSystemDependentName(command));
  result.withEnvironment(FlutterSdkUtil.FLUTTER_HOST_ENV, FlutterSdkUtil.getFlutterHostEnvValue());
  if (androidHome != null) {
    result.withEnvironment("ANDROID_HOME", androidHome);
  }
  for (String param : parameters) {
    result.addParameter(param);
  }
  return result;
}
 

protected OSProcessHandler prepareProcessHandler(@NotNull String exePath, @Nullable String workingDirectory, String[] parameters, @Nullable Map<String, String> environment) throws ExecutionException {
    GeneralCommandLine commandLine = new GeneralCommandLine(exePath);
    commandLine.addParameters(parameters);
    if (workingDirectory != null) {
        commandLine.setWorkDirectory(workingDirectory);
    }

    commandLine.withEnvironment(environment);

    return new ColoredProcessHandler(commandLine);
}
 

/** Returns the port number of Buck's HTTP server, if it can be determined. */
public static int getPort(Project project, String path)
    throws NumberFormatException, IOException, ExecutionException {
  String exec = BuckExecutableSettingsProvider.getInstance(project).resolveBuckExecutable();

  if (Strings.isNullOrEmpty(exec)) {
    throw new RuntimeException("Buck executable is not defined in settings.");
  }

  GeneralCommandLine commandLine = new GeneralCommandLine();
  commandLine.setExePath(exec);
  commandLine.withWorkDirectory(path);
  commandLine.withEnvironment(EnvironmentUtil.getEnvironmentMap());
  commandLine.addParameter("server");
  commandLine.addParameter("status");
  commandLine.addParameter("--reuse-current-config");
  commandLine.addParameter("--http-port");
  commandLine.setRedirectErrorStream(true);

  Process p = commandLine.createProcess();
  BufferedReader reader = new BufferedReader(new InputStreamReader(p.getInputStream()));

  String line;
  while ((line = reader.readLine()) != null) {
    if (line.startsWith(SEARCH_FOR)) {
      return Integer.parseInt(line.substring(SEARCH_FOR.length()));
    }
  }
  throw new RuntimeException(
      "Configured buck executable did not report a valid port string,"
          + " ensure "
          + commandLine.getCommandLineString()
          + " can be run from "
          + path);
}
 

public void configureCommandLine(@Nonnull GeneralCommandLine commandLine, boolean consoleParentEnvs) {
  if (myPassParentEnvs) {
    commandLine.withParentEnvironmentType(consoleParentEnvs ? GeneralCommandLine.ParentEnvironmentType.CONSOLE
                                                            : GeneralCommandLine.ParentEnvironmentType.SYSTEM);
  }
  else {
    commandLine.withParentEnvironmentType(GeneralCommandLine.ParentEnvironmentType.NONE);
  }
  commandLine.withEnvironment(myEnvs);
}
 

/**
 * Adds current Java to the PATH environment variable for the passed command line.
 */
public static GeneralCommandLine patchPathEnvironmentVariable(GeneralCommandLine commandLine) {
    return commandLine.withEnvironment("PATH", getPatchedPathWithCurrentJavaBinLocation());
}