test/hotspot/jtreg/vmTestbase/vm/share/process/ProcessExecutor.java - platform/libcore - Git at Google

 /*
  * Copyright (c) 2011, 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 vm.share.process;

 import nsk.share.TestBug;
 import nsk.share.TestFailure;
 import nsk.share.log.Log;
 import vm.share.ProcessUtils;

 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.io.BufferedReader;
 import java.io.OutputStream;
 import java.io.PrintStream;
 import java.io.PipedInputStream;
 import java.io.PipedOutputStream;
 import java.io.IOException;
 import java.util.*;
 import java.lang.reflect.Field;

 public class ProcessExecutor {
     private static long CLEANUP_TIMEOUT = 60000;
     private Process process;
     private StreamReader stdoutReader = new StreamReader("stdout");
     private StreamReader stderrReader = new StreamReader("stderr");
     private Waiter waiter = new Waiter();
     private OutputStream stdin;
     private volatile boolean running;
     private volatile int result = -1;
     private List<String> args = new ArrayList<String>();

     public int getResult() {
         return result;
     }

     public void clearArgs() {
         this.args.clear();
     }

     public void addArg(String arg) {
         this.args.add(arg);
     }

     public void addArgs(String[] args) {
         for (String arg : args) {
             this.args.add(arg);
         }
     }

     public void addArgs(Collection<String> args) {
         this.args.addAll(args);
     }

     private void printCommandLine() {
         for (String arg : args) {
             System.out.println(arg);
         }
     }

     /*
      * Start process.
      */
     public void start() {
         if (process != null) {
             throw new TestBug("Process is already started");
         }
         printCommandLine();
         try {
             process = createProcess();
             stdoutReader.setDescription("stdout: " + toString());
             stdoutReader.setStream(process.getInputStream());
             stderrReader.setDescription("stderr: " + toString());
             stderrReader.setStream(process.getErrorStream());
             stdin = process.getOutputStream();
             stdoutReader.start();
             stderrReader.start();
             waiter.start();
         } catch (IOException e) {
             throw new TestFailure("Error running process: " + toString(), e);
         }
     }

     protected Process createProcess() throws IOException {
         String[] commandLine = args.toArray(new String[args.size()]);
         return Runtime.getRuntime().exec(commandLine);
     }

     /**
      * Run and wait for completion.
      */
     public int execute(long timeout) {
         if (timeout <= 0) {
             throw new TestBug("Positive timeout is required");
         }
         start();
         return waitFor(timeout);
     }

     public int waitFor(long timeout) {
         if (process == null) {
             throw new TestBug("Process is not yet started");
         }
         if (timeout <= 0) {
             throw new TestBug("Positive timeout is required");
         }
         long timeleft = timeout;
         long startTime = 0;
         while (timeleft > 0) {
             try {
                 startTime = System.currentTimeMillis();
                 waiter.join(timeout);
                 return result;
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
             timeleft -= (System.currentTimeMillis() - startTime);
         }
         return -1;
     }

     public int getPid() {
         return ProcessUtils.getPid(process);
     }

     public OutputStream getStdIn() {
         if (process == null) {
             throw new TestBug(
                     "Process is not running; prepare writers after it is started");
         }
         return stdin;
     }

     public PrintStream getStdInPrint() {
         return new PrintStream(getStdIn(),
                 true); // Autoflush is important here.
     }

 /*
     public InputStream getStdOut() {
                 if (process != null)
                         throw new TestBug("Process is already running; prepare readers before it is started or some output may be missed");
                 return stdoutReader.getInputStream();
         }

         public BufferedReader getStdOutReader() {
                 return new BufferedReader(new InputStreamReader(getStdOut()));
         }

         public InputStream getStdErr() {
                 if (process != null)
                         throw new TestBug("Process is already running; prepare readers before it is started or some output may be missed");
                 return stderrReader.getInputStream();
         }

         public BufferedReader getStdErrReader() {
                 return new BufferedReader(new InputStreamReader(getStdOut()));
         }

         public String getStdoutOutput() {
                 if (stdoutReader == null)
                         throw new TestBug("Process is not running");
                 return stdoutReader.getOutput();
         }

         public String getStderrOutput() {
                 if (stderrReader == null)
                         throw new TestBug("Process is not running");
                 return stderrReader.getOutput();
         }
         */

     public void addStdOutListener(StreamListener l) {
         stdoutReader.addListener(l);
     }

     public void addStdErrListener(StreamListener l) {
         stderrReader.addListener(l);
     }

     public void logStdOut(String prefix, Log log) {
         stdoutReader.addListener(new StreamLogger(prefix, log));
     }

     public void logStdErr(String prefix, Log log) {
         stderrReader.addListener(new StreamLogger(prefix, log));
     }

     public void logStdOutErr(String prefix, Log log) {
         logStdOut(prefix, log);
         logStdErr("(stderr)" + prefix, log);
     }

     public boolean isStarted() {
         return (process != null);
     }

     public void kill() {
         if (process == null) {
             throw new TestBug("Process is not running");
         }
         process.destroy();
         if (stdoutReader != null) {
             stdoutReader.kill();
         }
         if (stderrReader != null) {
             stderrReader.kill();
         }
         if (waiter != null && waiter.isAlive()) {
             waiter.kill();
         }
         process = null;
     }

     public void finish() {
         if (stdoutReader != null) {
             try {
                 stdoutReader.join(CLEANUP_TIMEOUT);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
             stdoutReader = null;
         }
         if (stderrReader != null) {
             try {
                 stderrReader.join(CLEANUP_TIMEOUT);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
             stderrReader = null;
         }
         process = null;
     }

     public String toString() {
         String ts = "";
         if (args != null) {
             for (String s : args) {
                 ts += s;
                 ts += " ";
             }
         }
         return ts;
     }

     private class Waiter extends Thread {
         public Waiter() {
             super("Process Waiter: (not setup)");
             setDaemon(true);
         }

         public void run() {
             setName("Process Waiter: " + ProcessExecutor.this);
             try {
                 result = process.waitFor();
             } catch (InterruptedException e) {
                 // Ignore
             }
         }

         public void kill() {
             this.interrupt();
             long timeleft = CLEANUP_TIMEOUT;
             long startTime = 0;
             while (timeleft > 0) {
                 try {
                     startTime = System.currentTimeMillis();
                     this.join(timeleft);
                     return;
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
                 timeleft -= (System.currentTimeMillis() - startTime);
             }
         }
     }
 }
	/*
	* Copyright (c) 2011, 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 vm.share.process;

	import nsk.share.TestBug;
	import nsk.share.TestFailure;
	import nsk.share.log.Log;
	import vm.share.ProcessUtils;

	import java.io.InputStream;
	import java.io.InputStreamReader;
	import java.io.BufferedReader;
	import java.io.OutputStream;
	import java.io.PrintStream;
	import java.io.PipedInputStream;
	import java.io.PipedOutputStream;
	import java.io.IOException;
	import java.util.*;
	import java.lang.reflect.Field;

	public class ProcessExecutor {
	private static long CLEANUP_TIMEOUT = 60000;
	private Process process;
	private StreamReader stdoutReader = new StreamReader("stdout");
	private StreamReader stderrReader = new StreamReader("stderr");
	private Waiter waiter = new Waiter();
	private OutputStream stdin;
	private volatile boolean running;
	private volatile int result = -1;
	private List<String> args = new ArrayList<String>();

	public int getResult() {
	return result;
	}

	public void clearArgs() {
	this.args.clear();
	}

	public void addArg(String arg) {
	this.args.add(arg);
	}

	public void addArgs(String[] args) {
	for (String arg : args) {
	this.args.add(arg);
	}
	}

	public void addArgs(Collection<String> args) {
	this.args.addAll(args);
	}

	private void printCommandLine() {
	for (String arg : args) {
	System.out.println(arg);
	}
	}

	/*
	* Start process.
	*/
	public void start() {
	if (process != null) {
	throw new TestBug("Process is already started");
	}
	printCommandLine();
	try {
	process = createProcess();
	stdoutReader.setDescription("stdout: " + toString());
	stdoutReader.setStream(process.getInputStream());
	stderrReader.setDescription("stderr: " + toString());
	stderrReader.setStream(process.getErrorStream());
	stdin = process.getOutputStream();
	stdoutReader.start();
	stderrReader.start();
	waiter.start();
	} catch (IOException e) {
	throw new TestFailure("Error running process: " + toString(), e);
	}
	}

	protected Process createProcess() throws IOException {
	String[] commandLine = args.toArray(new String[args.size()]);
	return Runtime.getRuntime().exec(commandLine);
	}

	/**
	* Run and wait for completion.
	*/
	public int execute(long timeout) {
	if (timeout <= 0) {
	throw new TestBug("Positive timeout is required");
	}
	start();
	return waitFor(timeout);
	}

	public int waitFor(long timeout) {
	if (process == null) {
	throw new TestBug("Process is not yet started");
	}
	if (timeout <= 0) {
	throw new TestBug("Positive timeout is required");
	}
	long timeleft = timeout;
	long startTime = 0;
	while (timeleft > 0) {
	try {
	startTime = System.currentTimeMillis();
	waiter.join(timeout);
	return result;
	} catch (InterruptedException e) {
	e.printStackTrace();
	}
	timeleft -= (System.currentTimeMillis() - startTime);
	}
	return -1;
	}

	public int getPid() {
	return ProcessUtils.getPid(process);
	}

	public OutputStream getStdIn() {
	if (process == null) {
	throw new TestBug(
	"Process is not running; prepare writers after it is started");
	}
	return stdin;
	}

	public PrintStream getStdInPrint() {
	return new PrintStream(getStdIn(),
	true); // Autoflush is important here.
	}

	/*
	public InputStream getStdOut() {
	if (process != null)
	throw new TestBug("Process is already running; prepare readers before it is started or some output may be missed");
	return stdoutReader.getInputStream();
	}

	public BufferedReader getStdOutReader() {
	return new BufferedReader(new InputStreamReader(getStdOut()));
	}

	public InputStream getStdErr() {
	if (process != null)
	throw new TestBug("Process is already running; prepare readers before it is started or some output may be missed");
	return stderrReader.getInputStream();
	}

	public BufferedReader getStdErrReader() {
	return new BufferedReader(new InputStreamReader(getStdOut()));
	}

	public String getStdoutOutput() {
	if (stdoutReader == null)
	throw new TestBug("Process is not running");
	return stdoutReader.getOutput();
	}

	public String getStderrOutput() {
	if (stderrReader == null)
	throw new TestBug("Process is not running");
	return stderrReader.getOutput();
	}
	*/

	public void addStdOutListener(StreamListener l) {
	stdoutReader.addListener(l);
	}

	public void addStdErrListener(StreamListener l) {
	stderrReader.addListener(l);
	}

	public void logStdOut(String prefix, Log log) {
	stdoutReader.addListener(new StreamLogger(prefix, log));
	}

	public void logStdErr(String prefix, Log log) {
	stderrReader.addListener(new StreamLogger(prefix, log));
	}

	public void logStdOutErr(String prefix, Log log) {
	logStdOut(prefix, log);
	logStdErr("(stderr)" + prefix, log);
	}

	public boolean isStarted() {
	return (process != null);
	}

	public void kill() {
	if (process == null) {
	throw new TestBug("Process is not running");
	}
	process.destroy();
	if (stdoutReader != null) {
	stdoutReader.kill();
	}
	if (stderrReader != null) {
	stderrReader.kill();
	}
	if (waiter != null && waiter.isAlive()) {
	waiter.kill();
	}
	process = null;
	}

	public void finish() {
	if (stdoutReader != null) {
	try {
	stdoutReader.join(CLEANUP_TIMEOUT);
	} catch (InterruptedException e) {
	e.printStackTrace();
	}
	stdoutReader = null;
	}
	if (stderrReader != null) {
	try {
	stderrReader.join(CLEANUP_TIMEOUT);
	} catch (InterruptedException e) {
	e.printStackTrace();
	}
	stderrReader = null;
	}
	process = null;
	}

	public String toString() {
	String ts = "";
	if (args != null) {
	for (String s : args) {
	ts += s;
	ts += " ";
	}
	}
	return ts;
	}

	private class Waiter extends Thread {
	public Waiter() {
	super("Process Waiter: (not setup)");
	setDaemon(true);
	}

	public void run() {
	setName("Process Waiter: " + ProcessExecutor.this);
	try {
	result = process.waitFor();
	} catch (InterruptedException e) {
	// Ignore
	}
	}

	public void kill() {
	this.interrupt();
	long timeleft = CLEANUP_TIMEOUT;
	long startTime = 0;
	while (timeleft > 0) {
	try {
	startTime = System.currentTimeMillis();
	this.join(timeleft);
	return;
	} catch (InterruptedException e) {
	e.printStackTrace();
	}
	timeleft -= (System.currentTimeMillis() - startTime);
	}
	}
	}
	}