|
JavaXT
|
|
Shell Class
package javaxt.io;
import java.io.*;
//******************************************************************************
//** Shell Class
//******************************************************************************
/**
* Used to execute command line applications and return the corresponding
* output streams (standard output and error output streams).
*
******************************************************************************/
public class Shell {
private java.io.File executable;
private String[] inputs;
private java.util.List<String> output = new java.util.LinkedList<String>();
private java.util.List<String> errors = new java.util.LinkedList<String>();
private long startTime;
private long ellapsedTime;
private Process process;
//**************************************************************************
//** Constructor
//**************************************************************************
/** Creates a new instance of Shell.
* @param executable Path to the executable to run
* @param parameters Command line args passed to the executable
*/
public Shell(java.io.File executable, String[] parameters) {
this.executable = executable;
this.ellapsedTime = -1;
if (parameters==null){
parameters = new String[0];
}
inputs = new String[parameters.length+1];
inputs[0] = executable.toString();
for (int i=0; i<parameters.length; i++){
inputs[i+1] = parameters[i];
}
}
//**************************************************************************
//** Constructor
//**************************************************************************
/** Creates a new instance of Shell.
* @param executable Path to the executable to run
* @param parameters Command line args passed to the executable
*/
public Shell(javaxt.io.File executable, String[] parameters) {
this(executable.toFile(), parameters);
}
//**************************************************************************
//** Constructor
//**************************************************************************
/** Creates a new instance of Shell.
* @param cmd Command to execute. Example: "cmd /c dir C:\\temp"
*/
public Shell(String cmd){
this.executable = null;
this.ellapsedTime = -1;
String arr[] = cmd.trim().split(" ");
java.util.Vector<String> parameters = new java.util.Vector<String>();
for (int i=0; i<arr.length; i++){
String str = arr[i].trim();
if (str.length()>0) parameters.add(str);
}
inputs = new String[parameters.size()];
for (int i=0; i<parameters.size(); i++){
inputs[i] = parameters.get(i);
}
java.io.File file = new java.io.File(inputs[0]);
if (file.exists() && file.isFile()){
executable = file;
}
}
//**************************************************************************
//** Constructor
//**************************************************************************
/** Creates a new instance of Shell.
* @param cmdarray Command to execute, along with the command line args in a
* String array.
*/
public Shell(String[] cmdarray){
this.executable = null;
this.ellapsedTime = -1;
inputs = cmdarray;
java.io.File file = new java.io.File(inputs[0]);
if (file.exists() && file.isFile()){
executable = file;
}
}
//**************************************************************************
//** getOutput
//**************************************************************************
/** Used to retrieve the standard output stream. Returns a List that can be
* parsed while the executable is still running or after is has been run.
* The difference lies in when the run method is invoked. The following is
* an example of how to process the output stream while the app is running.
* The getOutput() is called BEFORE the run() method is invoked.
<pre>
File exe = new File("C:\\Program Files\\PostgreSQL\\8.4\\bin\\shp2pgsql.exe");
String[] options = new String[]{"-W", "UTF-8", "-s", "4326", "C:\country.shp", "t_country"};
javaxt.io.Shell cmd = new javaxt.io.Shell(exe, options);
java.util.List<String> output = cmd.getOutput();
cmd.run();
String line;
while (true){
synchronized (output) {
while (output.isEmpty()) {
try {
output.wait();
}
catch (InterruptedException e) {
}
}
line = output.remove(0);
}
if (line!=null){
System.out.println(line);
}
else{
break;
}
}
</pre>
* If you want to get the entire output all at once, just call the getOutput()
* AFTER the run() method. Example:
<pre>
javaxt.io.Shell cmd = new javaxt.io.Shell(exe, options);
cmd.run();
java.util.List<String> output = cmd.getOutput();
for (int i=0; i<output.size(); i++){
System.out.println(output.get(i));
}
</pre>
*
*/
public java.util.List getOutput(){ return output; }
//**************************************************************************
//** getErrors
//**************************************************************************
/** Used to retrieve the error output stream. Returns a List that can be
* parsed while the executable is still running or after is has been run.
*/
public java.util.List getErrors(){ return errors; }
//**************************************************************************
//** run
//**************************************************************************
/** Used to execute the process specified in the constructor and populate
* the output streams.
*/
public void run() {
ellapsedTime = -1;
startTime = System.currentTimeMillis();
try {
//Run executable via Command Line and pick up the output stream
Runtime runtime = Runtime.getRuntime();
if (executable!=null){
process = runtime.exec(inputs, null, executable.getParentFile());
}
else{
process = runtime.exec(inputs);
}
StreamReader s1 = new StreamReader(output, process.getInputStream());
StreamReader s2 = new StreamReader(errors, process.getErrorStream());
s1.start();
s2.start();
process.waitFor();
s1.join();
s2.join();
//Clean up!
cleanUp();
}
catch(IOException e){
throw new RuntimeException(e);
}
catch(InterruptedException e){
throw new RuntimeException(e);
}
ellapsedTime = System.currentTimeMillis()-startTime;
}
//**************************************************************************
//** stop
//**************************************************************************
/** Used to stop the current process. Note that this method does not stop
* or kill process grandchildren. This is a limitation of Java, not this
* class per se. See Sun bug 4770092 for more details.
*/
public void stop(){
if (process!=null){
process.destroy();
cleanUp();
ellapsedTime = System.currentTimeMillis()-startTime;
}
}
//**************************************************************************
//** cleanUp
//**************************************************************************
/** Used to clean up system resources after a process has been terminated.
* Based on recommendations found in "Five Common java.lang.Process Pitfalls"
* by Kyle Cartmell (http://kylecartmell.com/?p=9).
*/
private void cleanUp(){
//Explicitly clean up every instance of Process by calling close on each stream
try{process.getInputStream().close();} catch(Exception ex){}
try{process.getErrorStream().close();} catch(Exception ex){}
try{process.getOutputStream().close();} catch(Exception ex){}
//Explicitly destroy the process even if the process is already terminated
try{process.destroy();} catch(Exception ex){}
process = null;
}
//**************************************************************************
//** getEllapsedTime
//**************************************************************************
/** Used to return the total time (milliseconds) it took to execute the
* process.
*/
public long getEllapsedTime(){
return ellapsedTime;
}
/*
public void run(byte[] b){
try{
//Run executable via Command Line and pick up the output stream
Runtime runtime = Runtime.getRuntime();
Process process = runtime.exec(inputs, null, executable.getParentFile());
//process.getOutputStream().write(b);
System.out.println(b.length);
BufferedOutputStream commandsStdIn = new BufferedOutputStream(process.getOutputStream());
commandsStdIn.write(b);
commandsStdIn.flush();
commandsStdIn.close();
StreamReader s1 = new StreamReader(output, process.getInputStream());
StreamReader s2 = new StreamReader(errors, process.getErrorStream());
s1.start();
s2.start();
process.waitFor();
}
catch(Exception e){
e.printStackTrace();
}
}
*/
//**************************************************************************
//** StreamReader Class
//**************************************************************************
/** Thread used to read the standard input and output streams. */
private class StreamReader implements Runnable {
java.util.List list;
InputStream is;
Thread thread;
public StreamReader (java.util.List list, InputStream is){
this.list = list;
this.is = is;
}
public void start () {
thread = new Thread(this);
thread.start();
}
public void run () {
try {
InputStreamReader isr = new InputStreamReader (is);
BufferedReader br = new BufferedReader (isr);
while (true) {
String s = br.readLine();
if (s == null) break;
//System.out.println(s);
if (list!=null) list.add(s);
}
list.add(null);
is.close();
}
catch (Exception ex) {
//System.out.println ("Problem reading stream... :" + ex);
ex.printStackTrace ();
}
}
public void join() throws InterruptedException {
thread.join();
}
} //End StreamReader Class
}
|
|