ProcessExecutor.java

/*
 * Copyright (c) 2008, 2018, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */
package nsk.share.aod;

import java.io.*;
import java.util.*;
import nsk.share.*;

public class ProcessExecutor {

    private String[] cmdLine;

    private long timeout;

    private boolean printProcessOutput;

    private String processOutputPrefix;

    private InputStreamReaderThread outReader;

    private InputStreamReaderThread errReader;

    private Process startedProcess;

    private ProcessWaiterThread processWaiter;

    private long expectedFinishTime;

    private volatile boolean executionCompleted;

    private int exitCode;

    private class InputStreamReaderThread extends Thread {
        private BufferedReader in;

        private String outputPrefix;

        private List<String> output = new ArrayList<String>();

        private volatile boolean streamWasAbruptlyClosed;

        private Throwable unexpectedException;

        public InputStreamReaderThread(InputStream in, String prefix) {
            this.in = new BufferedReader(new InputStreamReader(in));
            this.outputPrefix = prefix;
            setDaemon(true);
        }

        public void streamWasAbruptlyClosed(boolean newValue) {
            streamWasAbruptlyClosed = newValue;
        }

        public void run() {
            try {
                while (true) {
                    String line = in.readLine();
                    if (line == null)
                        return;

                    output.add(line);

                    if (printProcessOutput)
                        System.out.println(outputPrefix + line);
                }
            } catch (IOException e) {
                if (!streamWasAbruptlyClosed) {
                    unexpectedException = e;
                    e.printStackTrace( );
                }
            } catch (Throwable t) {
                unexpectedException = t;
                t.printStackTrace( );
            }
        }

        void checkStatus() {
            if (unexpectedException != null)
                throw new Failure("Exception was thrown during InputStreamReaderThread work: " + unexpectedException,
                        unexpectedException);
        }
    }

    private class ProcessWaiterThread extends Thread {

        private Throwable unexpectedException;

        private Process process;

        private InputStreamReaderThread outReader;

        private InputStreamReaderThread errReader;

        ProcessWaiterThread(Process process, InputStreamReaderThread outReader, InputStreamReaderThread errReader) {
            this.process = process;
            this.outReader = outReader;
            this.errReader = errReader;

            setDaemon(true);
        }

        public void run() {
            try {
                exitCode = process.waitFor();
                outReader.join();
                errReader.join();

                synchronized (ProcessWaiterThread.this) {
                    executionCompleted = true;
                    ProcessWaiterThread.this.notify();
                }
            } catch (InterruptedException e) {
                /*
                 * ProcessWaiterThread is interrupted if started process
                 * didn't finish in expected time
                 */
            } catch (Throwable t) {
                unexpectedException = t;
                t.printStackTrace();
            }
        }

        void checkStatus() {
            if (unexpectedException != null)
                throw new Failure("Exception was thrown during ProcessWaiterThread work: "
                        + unexpectedException, unexpectedException);
        }
    }

    public ProcessExecutor(String cmdLine, long timeout) {
        this.cmdLine = new String[]{cmdLine};
        this.timeout = timeout;
    }

    public ProcessExecutor(String cmdLine, long timeout, String outputPrefix) {
        this(cmdLine, timeout);
        this.printProcessOutput = true;
        this.processOutputPrefix = outputPrefix;
    }

    public void startProcess() throws IOException {
        if (cmdLine.length == 1)
            startedProcess = Runtime.getRuntime().exec(cmdLine[0]);
        else
            startedProcess = Runtime.getRuntime().exec(cmdLine);

        expectedFinishTime = System.currentTimeMillis() + timeout;

        outReader = new InputStreamReaderThread(startedProcess.getInputStream(),
                processOutputPrefix == null ? "" : processOutputPrefix + " (stdout): ");
        errReader = new InputStreamReaderThread(startedProcess.getErrorStream(),
                processOutputPrefix == null ? "" : processOutputPrefix + " (stderr): ");

        outReader.start();
        errReader.start();

        processWaiter = new ProcessWaiterThread(startedProcess, outReader, errReader);
        processWaiter.start();
    }


    public void waitForProcess() throws InterruptedException {
        synchronized (processWaiter) {
            while ((System.currentTimeMillis() < expectedFinishTime) && !executionCompleted) {
                processWaiter.wait(expectedFinishTime - System.currentTimeMillis());
            }
        }

        if (!executionCompleted) {
            destroyProcessAndWaitThreads();

            executionCompleted = true;

            throw new Failure("Execution timed out (timeout: " + timeout + "ms)");
        }
    }

    private void destroyProcessAndWaitThreads() {
        outReader.streamWasAbruptlyClosed(true);
        errReader.streamWasAbruptlyClosed(true);

        processWaiter.interrupt();
        startedProcess.destroy();

        try {
            outReader.join();
            errReader.join();
            processWaiter.join();

            outReader.checkStatus();
            errReader.checkStatus();
            processWaiter.checkStatus();
        } catch (InterruptedException e) {
            throw new Failure("Unexpected InterruptedException", e);
        }
    }

    private void checkProcessState() {
        if (!executionCompleted)
            throw new IllegalStateException("Process didn't finish execution");
    }

    public void destroyProcess() {
        if (executionCompleted)
            return;

        destroyProcessAndWaitThreads();
    }

    public long pid() {
        return startedProcess.pid();
    }

    public int getExitCode() {
        checkProcessState();

        return exitCode;
    }

    public List<String> getProcessOut() {
        checkProcessState();

        return outReader.output;
    }

    public List<String> getProcessErr() {
        checkProcessState();

        return errReader.output;
    }
}