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

}