source: trunk/gsdl3/src/java/org/greenstone/gsdl3/util/Processing.java@ 13270

package org.greenstone.gsdl3.util;

import java.io.InputStreamReader;

import org.apache.log4j.*;

public class Processing {

      static Logger logger = Logger.getLogger(org.greenstone.gsdl3.util.Processing.class.getName());
 
      /** Determine if the given process is still executing. It does this by attempting to throw an exception - not the most efficient way, but the only one as far as I know
     * @param process the Process to test
     * @return true if it is still executing, false otherwise
     */
    static public boolean processRunning(Process process) {
    boolean process_running = false;

    try {
        process.exitValue(); // This will throw an exception if the process hasn't ended yet.
    }
    catch(IllegalThreadStateException itse) {
        process_running = true;
    }
    catch(Exception exception) {
        exception.printStackTrace();        
    }
    return process_running;
    }
    
    static public int runProcess(String  command) {
    
    logger.error("executing command "+command);
    int exit_value = -1;
    try {
        Process prcs = Runtime.getRuntime().exec(command);
        
        InputStreamReader error_stream = new InputStreamReader( prcs.getErrorStream(), "UTF-8" );
        InputStreamReader output_stream = new InputStreamReader( prcs.getInputStream(), "UTF-8"  );
        
        StringBuffer error_buffer = new StringBuffer();
        StringBuffer output_buffer = new StringBuffer();
        
        while(processRunning(prcs)) {
        // Hopefully this doesn't block if the process is trying to write to STDOUT.
        if((error_stream!=null)) {// && error_stream.ready()) { 
            while (error_stream.ready()) {
            error_buffer.append((char)error_stream.read());
            }
            //error_buffer = get_stream_char(error_stream,error_buffer,bos);
        }
        //Hopefully this won't block if the process is trying to write to STDERR
        /*else if*/ while (output_stream.ready()) {
            output_buffer.append((char)output_stream.read());
            //output_buffer = get_stream_char(output_stream,output_buffer,bos);
        }
        //else {
        try {
            Thread.sleep(100);
        }
        catch(Exception exception) {
        }
        // }
        }
        
        // Of course, just because the process is finished doesn't
        // mean the incoming streams are empty. Unfortunately I've
        // got no chance of preserving order, so I'll process the
        // error stream first, then the out stream
        while(error_stream.ready()) {
        error_buffer.append((char)error_stream.read());
        //error_buffer = get_stream_char(error_stream,error_buffer,bos);
        }
        
        while(output_stream.ready()) {
        output_buffer.append((char)output_stream.read());
        //output_buffer = get_stream_char(output_stream,output_buffer,bos);
        }
        
        // do something with the messages
        logger.error("err>"+error_buffer.toString());
        logger.error("out>"+output_buffer.toString());
        // Ensure that any messages still remaining in the string buffers are fired off.
        // Now display final message based on exit value
        
        prcs.waitFor(); 
        error_stream.close();
        output_stream.close();
        error_buffer = null;
        output_buffer = null;
        
        exit_value =  prcs.exitValue();
    } catch (Exception e) {
        logger.error(e);
        return 1;
    }
    return exit_value;
    
    
    }
   

}