What is the best practice dealing with process.getErrorStream()

Question

I've been playing around creating Process objects with ProcessBuilder. I can use getErrorStream() and getOutputStream() to read the output from the process, but it seems I have to do this on another thread. If I simply call process.waitFor() and then try to read the streams that doesn't work. So I do something like final InputStream errorStream = process.getErrorStream();
final StringWriter errWriter = new StringWriter();
ExecutorService executorService = Executors.newCachedThreadPool();
executorService.execute(
    new Runnable() {
        public void run() {
            try {
                IOUtils.copy(errorStream, errWriter, "UTF-8");
         } catch (IOException e) {
                getLog().error(e.getMessage(), e);
int exitValue = process.waitFor();
getLog().info("exitValue = " + exitValue);
getLog().info("errString =\n" + errWriter); This works, but it seems rather inelegant somehow.
The basic problem is that the Runnable never completes on its own. Through experimentation, I believe that when the process is actually done, errorStream is never closed, or never gets an end-of-file. My current code works because when it goes to read errWriter it just reads what is currently in the buffer. However, if I wanted to clean things up and use executorService.submit() to submit a Callable and get back a Future, then a lot more code is needed because "IOUtils.copy(errorStream, errWriter, "UTF-8");" never terminates.
Am I misunderstanding something, or is process.getErrorStream() just a crappy API?
What do other people do when they want to get the error and output results from running a process?
Edited by: Eric Kolotyluk on Aug 16, 2012 5:26 PM

Answer 1

OK, I found a better solution.Future<String> errString = executorService.submit(
    new Callable<String>() {
        public String call() throws Exception {
            StringWriter errWriter = new StringWriter();
            IOUtil.copy(process.getErrorStream(), errWriter, "UTF-8");
            return errWriter.toString();
int exitValue = process.waitFor();
getLog().info("exitValue = " + exitValue);
try {
    getLog().info("errString =\n" + errString.get());
} catch (ExecutionException e) {
    throw new MojoExecutionException("proxygen: ExecutionException");
} The problem I was having before seemed to be that the call to Apache's IOUtil.copy(errorStream, errWriter, "UTF-8"); was not working right, it did not seem to be terminating on EOS. But now it seems to be working fine, so I must have been chasing some other problem (or non-problem).
So, it does seem the best thing to do is read the error and output streams from the process on their own daemon threads, and then call process.waitFor(). The ExecutorService API makes this easy, and using a Callable to return a future value does the right thing. Also, Callable is a little nicer as the call method can throw an Exception, so my code does not need to worry about that (and the readability is better).
Thanks for helping to clarify my thoughts and finding a good solution :-)
Now, it would be really nice if the Process API had a method like process.getFutureErrorString() which does what my code does.
Cheers, Eric