Java Code Examples for java.lang.ProcessBuilder.Redirect

@Test
public void givenProcessBuilder_whenRedirectStandardOutput_thenSuccessAppending() throws IOException, InterruptedException {
    ProcessBuilder processBuilder = new ProcessBuilder("java", "-version");

    File log = tempFolder.newFile("java-version-append.log");
    processBuilder.redirectErrorStream(true);
    processBuilder.redirectOutput(Redirect.appendTo(log));

    Process process = processBuilder.start();

    assertEquals("If redirected output, should be -1 ", -1, process.getInputStream()
        .read());

    int exitCode = process.waitFor();
    assertEquals("No errors should be detected", 0, exitCode);

    List<String> lines = Files.lines(log.toPath())
        .collect(Collectors.toList());

    assertThat("Results should not be empty", lines, is(not(empty())));
    assertThat("Results should contain java version: ", lines, hasItem(containsString("java version")));
}
 

private void installPlugin(File pluginManager, InstallationDescription.Plugin plugin) throws IOException, InterruptedException {
    logger.info("> " + pluginManager + " install " + plugin.getExpression());
    ProcessBuilder builder = new ProcessBuilder();
    builder.redirectOutput(Redirect.PIPE);
    builder.redirectErrorStream(true);
    builder.command(prepareInstallCommand(pluginManager, plugin));
    Process process = builder.start();
    BufferedReader bReader = new BufferedReader(new InputStreamReader(process.getInputStream(), UTF_8));
    String line;
    while ((line = bReader.readLine()) != null) {
        logger.info(String.format("Plugin install %s: %s", plugin, line));
    }
    if (process.waitFor() != 0) {
        throw new EmbeddedElasticsearchStartupException("Unable to install plugin: " + plugin);
    }
}
 

/**
 * Returns a {@link ProcessBuilder.Redirect} appropriate for the parameters. If a file redirected
 * to exists, deletes the file before redirecting to it.
 */
private Redirect getRedirect(StreamAction action, File file) {
  switch (action) {
    case DISCARD:
      return Redirect.to(new File("/dev/null"));

    case REDIRECT:
      // We need to use Redirect.appendTo() here, because on older Linux kernels writes are
      // otherwise not atomic and might result in lost log messages:
      // https://lkml.org/lkml/2014/3/3/308
      if (file.exists()) {
        file.delete();
      }
      return Redirect.appendTo(file);

    case STREAM:
      return Redirect.PIPE;

    default:
      throw new IllegalStateException();
  }
}
 

public void receive(Path destinationPath, Consumer<OutputStream> callback) {
    try {
        Process process = processBuilder("btrfs", "receive", "-e",
                destinationPath.toAbsolutePath().toString())
                .redirectOutput(Redirect.PIPE).start();
        callback.consume(process.getOutputStream());
        process.getOutputStream().close();
        int exitValue = process.waitFor();
        if (exitValue != 0) {
            throw new IOException("exit code: " + exitValue);
        }
    }
    catch (IOException | InterruptedException e) {
        throw new RuntimeException(
                "Error while receiving snapshot sub volume in "
                        + destinationPath, e);
    }
}
 

public void run() {
    ArrayList<String> cmd = new ArrayList<>();
    cmd.add("ffmpeg");       // binary should be on path
    cmd.add("-y");           // always overwrite files
    cmd.add("-f");           // format
    cmd.add("avfoundation"); // apple's system audio---something else for windows
    cmd.add("-i");           // input
    cmd.add(":" + deviceId); // device id returned by ffmpeg list
    cmd.add(captureFile.getAbsolutePath());

    ProcessBuilder pb = new ProcessBuilder(cmd);
    pb.redirectErrorStream(true);
    pb.redirectOutput(Redirect.PIPE);
    StringJoiner out = new StringJoiner("\n");
    try {
        proc = pb.start();
        try (BufferedReader reader = new BufferedReader(
            new InputStreamReader(proc.getInputStream()))) {

            reader.lines().forEach(out::add);
        }
        proc.waitFor();
    } catch (IOException | InterruptedException ign) {}
    System.out.println("FFMpeg output was: " + out.toString());
}
 

private ProcessBuilder prepareBuilder(
    ProcessBuilder builder, SubProcessCommandLineArgs commands, SubProcessIOFiles outPutFiles)
    throws IllegalStateException {

  // Check we are not over the max size of command line parameters
  if (getTotalCommandBytes(commands) > MAX_SIZE_COMMAND_LINE_ARGS) {
    throw new IllegalStateException("Command is over 2MB in size");
  }

  appendExecutablePath(builder);

  // Add the result file path to the builder at position 1, 0 is reserved for the process itself
  builder.command().add(1, outPutFiles.resultFile.toString());

  // Shift commands by 2 ordinal positions and load into the builder
  for (SubProcessCommandLineArgs.Command s : commands.getParameters()) {
    builder.command().add(s.ordinalPosition + 2, s.value);
  }

  builder.redirectError(Redirect.appendTo(outPutFiles.errFile.toFile()));
  builder.redirectOutput(Redirect.appendTo(outPutFiles.outFile.toFile()));

  return builder;
}
 

public void start(final String processName) throws IOException {
  final Config config = Config.load(this.configFilePath);
  final Path workPath = config.workDir();

  final List<String> params = Lists.newArrayList();
  params.add(executableLocation());
  params.add(configFilePath.toString());

  final ProcessBuilder processBuilder = new ProcessBuilder(params)
      .directory(new File(System.getProperty("user.dir")))
      .redirectErrorStream(true)
      .redirectInput(Redirect.INHERIT);

  try {
    final Process process = processBuilder.start();
    outputProcessorExecutor.submit(() -> printOutput(processName, process));
    processes.put(processName, process);
  } catch (final IOException e) {
    LOG.error("Error starting Orion process", e);
  }

  loadPortsFile(workPath);
}
 

public Process startSecondJVM(Class<?> mainClassToStart) throws IOException {
	String separator = System.getProperty("file.separator");
	String classpath = System.getProperty("java.class.path");
	String path = System.getProperty("java.home") + separator + "bin"
			+ separator + "java";

	ProcessBuilder processBuilder = new ProcessBuilder(path, "-Xdebug",
			"-Xrunjdwp:transport=dt_socket,address=" + debugPort
					+ ",server=y,suspend=y", "-cp", classpath,
			mainClassToStart.getCanonicalName());
	processBuilder.redirectOutput(ProcessBuilder.Redirect.INHERIT);
	final Process process = processBuilder.start();
	Thread closeChildThread = new Thread() {
		public void run() {
			process.destroy();
		}
	};
	Runtime.getRuntime().addShutdownHook(closeChildThread);
	return process;

}
 

/**
 * Returns a {@link java.lang.ProcessBuilder.Redirect} appropriate for the parameters. If a file
 * redirected to exists, deletes the file before redirecting to it.
 */
private Redirect getRedirect(StreamAction action, File file) {
  switch (action) {
    case DISCARD:
      return Redirect.to(new File("/dev/null"));

    case REDIRECT:
      // We need to use Redirect.appendTo() here, because on older Linux kernels writes are
      // otherwise not atomic and might result in lost log messages:
      // https://lkml.org/lkml/2014/3/3/308
      if (file.exists()) {
        file.delete();
      }
      return Redirect.appendTo(file);

    case STREAM:
      return Redirect.PIPE;

    default:
      throw new IllegalStateException();
  }
}
 

@Test
public void exitIfChangedFiles() throws Exception {
  Path path = testFolder.newFile("Test.java").toPath();
  Files.write(path, "class Test {\n}\n".getBytes(UTF_8));
  Process process =
      new ProcessBuilder(
              ImmutableList.of(
                  Paths.get(System.getProperty("java.home")).resolve("bin/java").toString(),
                  "-cp",
                  System.getProperty("java.class.path"),
                  Main.class.getName(),
                  "-n",
                  "--set-exit-if-changed",
                  path.toAbsolutePath().toString()))
          .redirectError(Redirect.PIPE)
          .redirectOutput(Redirect.PIPE)
          .start();
  process.waitFor();
  String err = new String(ByteStreams.toByteArray(process.getErrorStream()), UTF_8);
  String out = new String(ByteStreams.toByteArray(process.getInputStream()), UTF_8);
  assertThat(err).isEmpty();
  assertThat(out).isEqualTo(path.toAbsolutePath().toString() + System.lineSeparator());
  assertThat(process.exitValue()).isEqualTo(1);
}
 

private static List<String> runCmd(List<String> args) {
    List<String>   lines   = new ArrayList<>();
    ProcessBuilder builder = new ProcessBuilder(args);
    builder.redirectOutput(Redirect.PIPE).redirectErrorStream(true);
    try {
        boolean hadMsg  = false;
        Process process = builder.start();
        try (BufferedReader in = new BufferedReader(new InputStreamReader(process.getInputStream(), StandardCharsets.UTF_8))) {
            String line = in.readLine();
            while (line != null) {
                lines.add(line);
                line = in.readLine();
            }
        }
    } catch (IOException exception) {
        System.out.println();
        exception.printStackTrace(System.err);
        System.exit(1);
    }
    return lines;
}
 

private ProcessBuilder processBuilder(SshTarget target,
        List<String> commands) {
    // construct command
    LinkedList<String> list = new LinkedList<String>();
    list.add("ssh");

    // add port
    if (target.getPort() != null) {
        list.add("-p");
        list.add(target.getPort().toString());
    }

    // add host
    list.add(target.getHost());

    // add commands
    list.addAll(commands);

    return new ProcessBuilder().redirectError(Redirect.INHERIT).command(
            list);
}
 

/** Run shell script with command line arguments */
public static void runScript(final String cmd[], final File outFile) {

	try {
		final ProcessBuilder pb = new ProcessBuilder(cmd);
		if (outFile != null)
			pb.redirectOutput(outFile);
		else
			pb.redirectOutput(Redirect.INHERIT);
		pb.redirectError(Redirect.INHERIT);
		final Process process = pb.start();
		process.waitFor();
		process.destroy();
	} catch (final Exception e) {
		e.printStackTrace();
	}

}
 

public static void main(String[] args) throws IOException, InterruptedException {
	ProcessBuilder ls = new ProcessBuilder()
			.command("tree", "-i")
			.directory(Paths.get("/home/nipa").toFile());
	ProcessBuilder grepPdf = new ProcessBuilder()
			.command("grep", "pdf")
			.redirectOutput(Redirect.INHERIT);
	List<Process> lsThenGrep = ProcessBuilder.startPipeline(asList(ls, grepPdf));

	System.out.println("Started processes...");

	CompletableFuture[] lsThenGrepFutures = lsThenGrep.stream()
			// onExit returns a CompletableFuture<Process>
			.map(Process::onExit)
			.map(processFuture -> processFuture.thenAccept(
					process -> System.out.println("Process " + process.pid() + " finished.")))
			.toArray(CompletableFuture[]::new);
	// wait until all processes are finished
	CompletableFuture
			.allOf(lsThenGrepFutures)
			.join();
}
 

private ProcessBuilder prepareBuilder(
    ProcessBuilder builder, SubProcessCommandLineArgs commands, SubProcessIOFiles outPutFiles)
    throws IllegalStateException {

  // Check we are not over the max size of command line parameters
  if (getTotalCommandBytes(commands) > MAX_SIZE_COMMAND_LINE_ARGS) {
    throw new IllegalStateException("Command is over 2MB in size");
  }

  appendExecutablePath(builder);

  // Add the result file path to the builder at position 1, 0 is reserved for the process itself
  builder.command().add(1, outPutFiles.resultFile.toString());

  // Shift commands by 2 ordinal positions and load into the builder
  for (SubProcessCommandLineArgs.Command s : commands.getParameters()) {
    builder.command().add(s.ordinalPosition + 2, s.value);
  }

  builder.redirectError(Redirect.appendTo(outPutFiles.errFile.toFile()));
  builder.redirectOutput(Redirect.appendTo(outPutFiles.outFile.toFile()));

  return builder;
}
 

private void start(ProcessBuilder builder, Path workDir, boolean deleteOnExit) throws IOException {
	String workDirPath = workDir.toFile().getAbsolutePath();

	this.stdout = Files.createFile(Paths.get(workDirPath, "stdout_" + instanceNumber + ".log")).toFile();
	this.attributes.put("stdout", stdout.getAbsolutePath());

	this.stderr = Files.createFile(Paths.get(workDirPath, "stderr_" + instanceNumber + ".log")).toFile();
	this.attributes.put("stderr", stderr.getAbsolutePath());

	if (deleteOnExit) {
		this.stdout.deleteOnExit();
		this.stderr.deleteOnExit();
	}
	builder.redirectOutput(Redirect.to(this.stdout));
	builder.redirectError(Redirect.to(this.stderr));

	this.start(builder, workDir);
}
 

@Test
public void exitIfChangedStdin() throws Exception {
  Path path = testFolder.newFile("Test.java").toPath();
  Files.write(path, "class Test {\n}\n".getBytes(UTF_8));
  Process process =
      new ProcessBuilder(
              ImmutableList.of(
                  Paths.get(System.getProperty("java.home")).resolve("bin/java").toString(),
                  "-cp",
                  System.getProperty("java.class.path"),
                  Main.class.getName(),
                  "-n",
                  "--set-exit-if-changed",
                  "-"))
          .redirectInput(path.toFile())
          .redirectError(Redirect.PIPE)
          .redirectOutput(Redirect.PIPE)
          .start();
  process.waitFor();
  String err = new String(ByteStreams.toByteArray(process.getErrorStream()), UTF_8);
  String out = new String(ByteStreams.toByteArray(process.getInputStream()), UTF_8);
  assertThat(err).isEmpty();
  assertThat(out).isEqualTo("<stdin>" + System.lineSeparator());
  assertThat(process.exitValue()).isEqualTo(1);
}
 

public static void exec(Consumer<Character> charConsumer, String... command) {
    File tempFile = null;
    try {
        tempFile = File.createTempFile("sdk", "log");
        logger.debug("Command to be executed: {}", (Object) command);
        String[] commands = new String[command.length + 2];
        commands[0] = getBash();
        commands[1] = "-c";
        System.arraycopy(command, 0, commands, 2, command.length);
        ProcessBuilder pb = new ProcessBuilder(commands)
                .directory(new File("."))
                .redirectErrorStream(true)
                .redirectOutput(Redirect.to(tempFile));
        Process process = pb.start();
        OutputStream outputStream = process.getOutputStream();
        PrintWriter printWriter = new PrintWriter(outputStream);
        // say yes
        printWriter.write("n\n");
        printWriter.flush();
        try (InputStreamReader isr = new InputStreamReader(new FileInputStream(tempFile))) {
            while (process.isAlive()) {
                int ch = isr.read();
                if (ch < 0) {
                    Thread.sleep(10);
                    continue;
                }
                charConsumer.accept((char) ch);
            }
        }
    } catch (IOException | InterruptedException e) {
        throw new RuntimeException(e);
    } finally {
        if (tempFile != null && tempFile.exists()) {
            if (!tempFile.delete()) {
                logger.warn("Failed to delete {} even though it exists, try deleteOnExit", tempFile);
                tempFile.deleteOnExit();
            }
        }
    }
}
 

private void execute(String command, File directory)
		throws Exception {
	System.out.println("$ " + command);
	ProcessBuilder pb = new ProcessBuilder(command.split(" "));
	pb.directory(directory);
	pb.redirectErrorStream(true);
       pb.redirectOutput(Redirect.INHERIT);
       Process p = pb.start();
       p.waitFor();
}
 

@Override
public Process launch(String program, List<String> args) throws IOException {
  List<String> arguments = new ArrayList<>();
  arguments.add(program);
  arguments.addAll(args);

  ProcessBuilder processBuilder =
      new ProcessBuilder()
          .command(arguments)
          .redirectErrorStream(true)
          .redirectOutput(Redirect.PIPE);

  return processBuilder.start();
}
 

@Test
public void testLaunch() throws Exception {
  List<String> args = new ArrayList<>();
  args.add("arg1");
  args.add("arg2");

  ProcessBuilder processBuilder = PowerMock.createMock(ProcessBuilder.class);

  PowerMock.expectNew(ProcessBuilder.class, new Class[] {}).andReturn(processBuilder);

  Capture<List<String>> captureCommands = Capture.newInstance();
  expect(processBuilder.command(capture(captureCommands))).andReturn(processBuilder);
  expect(processBuilder.redirectErrorStream(true)).andReturn(processBuilder);
  expect(processBuilder.redirectOutput(Redirect.PIPE)).andReturn(processBuilder);

  Process process = mock(Process.class);
  expect(processBuilder.start()).andReturn(process);

  PowerMock.replayAll(ProcessBuilder.class, processBuilder);

  assertEquals(process, processLauncher.launch("program-name", args));

  PowerMock.verify(ProcessBuilder.class, processBuilder);

  List<String> commands = captureCommands.getValue();
  assertEquals(3, commands.size());
  assertEquals("program-name", commands.get(0));
  assertEquals("arg1", commands.get(1));
  assertEquals("arg2", commands.get(2));
}
 

public void restart() {
    ProcessBuilder builder = new ProcessBuilder();
    if (config.startScript != null) builder.command(Collections.singletonList(config.startScript));
    else throw new IllegalArgumentException("Please create start script and link it as startScript in config.");
    builder.directory(this.dir.toFile());
    builder.inheritIO();
    builder.redirectErrorStream(true);
    builder.redirectOutput(Redirect.PIPE);
    try {
        builder.start();
    } catch (IOException e) {
        LogHelper.error(e);
    }
}
 

/**
 * Returns a new default executor that will delegate execution to {@link Runtime#exec(String[], String[], File)}.
 * This executor is mainly intended for headless case, but may be useful in the UI case as well. However, the main
 * executor to be used in the UI case is returned by method <code>RunnerFrontEndUI#createUIExecutor()</code>.
 */
public IExecutor createDefaultExecutor() {
	return new IExecutor() {
		@Override
		public Process exec(String[] cmdLine, File workingDirectory, Map<String, String> envp)
				throws ExecutionException {

			ProcessBuilder pb = new ProcessBuilder(cmdLine);
			pb.environment().putAll(envp);
			pb.directory(workingDirectory);
			pb.inheritIO();

			// Special case for running from Java-code & capturing output of run-result:
			String errFile = System.getProperty("org.eclipse.n4js.runner.RunnerFrontEnd.ERRORFILE", "");
			String outFile = System.getProperty("org.eclipse.n4js.runner.RunnerFrontEnd.OUTPUTFILE", "");
			if (errFile != null && errFile.length() > 0) {
				pb.redirectError(Redirect.to(new File(errFile)));
			}
			if (outFile != null && outFile.length() > 0) {
				pb.redirectOutput(Redirect.to(new File(outFile)));
			}

			try {
				return pb.start();
			} catch (IOException e) {
				throw new ExecutionException(e);
			}
		}
	};
}
 

public ProcessRunner ( final ProcessBuilder processBuilder )
{
    this.processBuilder = processBuilder;
    processBuilder.redirectError ( Redirect.INHERIT );
    processBuilder.redirectOutput ( Redirect.INHERIT );
    processBuilder.redirectInput ( Redirect.INHERIT );
}
 

private ProcessBuilder processBuilder(LinkedList<String> list) {
    if (useStrace()) {
        list.addFirst("-ff");
        list.addFirst("strace." + MDC.get("id") + ".log");
        list.addFirst("-o");
        list.addFirst("strace");
    }
    if (useSudo()) {
        list.addFirst("sudo");
    }
    log.debug("created process builder: " + list);
    return new ProcessBuilder().redirectError(Redirect.INHERIT)
            .redirectOutput(Redirect.INHERIT).command(list);
}
 

@Override
public IQData start() throws InterruptedException {
	File rawFile = new File(config.getTempDirectory(), req.getSatelliteId() + "-" + req.getId() + ".raw.gz");
	Long startTimeMillis = null;
	Long endTimeMillis = null;
	try {
		Integer ppm = config.getInteger("ppm.current");
		if (ppm == null) {
			ppm = 0;
		}
		startTimeMillis = System.currentTimeMillis();
		rtlSdr = factory.create(config.getProperty("satellites.rtlsdrwrapper.path") + " -rtl " + config.getProperty("satellites.rtlsdr.path") + " -f " + req.getActualFrequency() + " -s " + req.getInputSampleRate() + " -g " + config.getProperty("satellites.rtlsdr.gain") + " -p " + ppm + " -o " + rawFile.getAbsolutePath(), Redirect.INHERIT, false);
		int responseCode = rtlSdr.waitFor();
		// rtl_sdr should be killed by the reaper process
		// all other codes are invalid. even 0
		if (responseCode != 143) {
			LOG.error("[{}] invalid response code rtl_sdr: {}", req.getId(), responseCode);
			Util.deleteQuietly(rawFile);
		} else {
			LOG.info("[{}] rtl_sdr stopped: {}", req.getId(), responseCode);
		}
	} catch (IOException e) {
		LOG.error("[{}] unable to run", req.getId(), e);
	} finally {
		endTimeMillis = System.currentTimeMillis();
	}
	IQData result = new IQData();
	result.setActualStart(startTimeMillis);
	result.setActualEnd(endTimeMillis);

	if (rawFile.exists()) {
		result.setDataFile(rawFile);
	}
	return result;
}
 

public ProcessWrapper create(String commandLine, Redirect redirectError, boolean inheritIO) throws IOException {
	LOG.info("started with arguments: {}", commandLine);
	ProcessBuilder processBuilder = new ProcessBuilder(SPACE.split(commandLine));
	if (redirectError != null) {
		processBuilder.redirectError(redirectError);
	}
	if (inheritIO) {
		processBuilder.inheritIO();
	}
	return new ProcessWrapperImpl(processBuilder.start());
}
 

private void copyLogTail() {
  if (configuration.getTailLogLinesToSave() <= 0) {
    return;
  }

  final Path tailOfLogPath = taskDefinition.getServiceFinishedTailLogPath();

  if (Files.exists(tailOfLogPath)) {
    log.debug("{} already existed, skipping tail", tailOfLogPath);
    return;
  }

  final List<String> cmd = ImmutableList.of(
    "tail",
    "-n",
    Integer.toString(configuration.getTailLogLinesToSave()),
    taskDefinition.getServiceLogOut()
  );

  try {
    new SimpleProcessManager(log).runCommand(cmd, Redirect.to(tailOfLogPath.toFile()));
  } catch (Throwable t) {
    log.error(
      "Failed saving tail of log {} to {}",
      taskDefinition.getServiceLogOut(),
      taskDefinition.getServiceFinishedTailLogPath(),
      t
    );
  }
}
 

public List<String> runCommandWithOutput(
  final List<String> command,
  final Set<Integer> acceptableExitCodes
)
  throws InterruptedException, ProcessFailedException {
  return runCommand(command, Redirect.PIPE, acceptableExitCodes);
}
 

public List<String> runCommand(
  final List<String> command,
  final Redirect redirectOutput
)
  throws InterruptedException, ProcessFailedException {
  return runCommand(command, redirectOutput, Sets.newHashSet(0));
}