source: trunk/gli/src/org/greenstone/gatherer/shell/GShell.java@ 6051

/**
 *#########################################################################
 *
 * A component of the Gatherer application, part of the Greenstone digital
 * library suite from the New Zealand Digital Library Project at the
 * University of Waikato, New Zealand.
 *
 * <BR><BR>
 *
 * Author: John Thompson, Greenstone Digital Library, University of Waikato
 *
 * <BR><BR>
 *
 * Copyright (C) 1999 New Zealand Digital Library Project
 *
 * <BR><BR>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * <BR><BR>
 *
 * This program 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 for more details.
 *
 * <BR><BR>
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *########################################################################
 */
package org.greenstone.gatherer.shell;

import java.io.*;
import javax.swing.*;
import javax.swing.event.*;
import javax.swing.tree.*;
import org.greenstone.gatherer.Dictionary;
import org.greenstone.gatherer.Gatherer;
import org.greenstone.gatherer.msm.GreenstoneArchiveParser;
import org.greenstone.gatherer.shell.GShellListener;
import org.greenstone.gatherer.shell.GShellProgressMonitor;

/** The <strong>GShell</strong> is reponsible for running a separately threaded process in the command shell. This is necessary for executing the Perl Scripts and also for other system related funcitonality.
 */
public class GShell
    extends Thread {
    /** A flag used to determine if this process has been asked to cancel. */
    private boolean cancel = false;
    /** The list of listeners associated with this class. */
    private EventListenerList listeners = null;
    /** The current status of this shell process. */
    private int status = -1;
    /** The type of message being sent. */
    private int msg_type = -1;
    /** The type of shell process. */
    private int type = -1;
    /** The caller of this process, and thus the class most interested in messages. */
    private GShellListener caller = null;
    /** The progress monitor associated with this process. */
    private GShellProgressMonitor progress = null;
    /** Arguments to be given to the process (including the executable you are calling. */
    private String args[] = null;
    /** Element in process type enumeration. */
    static final public int BUILD = 0;
    /** Element in process type enumeration. */
    static final public int IMPORT = 1;
    /** Element in process type enumeration. */
    static final public int NEW = 2;
    /** Element in process type enumeration. */
    static final public int EXPORT = 3;
    /** Element in process type enumeration. */
    static final public int OTHER = 4;
    /** Element in status type enumeration. */
    static final public int ERROR = 0;
    /** Element in status type enumeration. */
    static final public int OK = 1;
    static final public int CANCELLED = 2;
    /** Element in process type name enumeration. */
    static public String GSHELL_BUILD = "gshell_build";
    /** Element in process type name enumeration. */
    static public String GSHELL_IMPORT = "gshell_import";
    /** Element in process type name enumeration. */
    static public String GSHELL_NEW = "gshell_new";
    /** Element in process type name enumeration */
    static public String GSHELL_EXPORT = "gshell_export";

    /** 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) {
        Gatherer.printStackTrace(exception);
    }
    return process_running;
    }

    /** Constructor gatherer all the data required to create a new process, and emit meaningfull messages.
     * @param args A <strong>String[]</strong> containing the arguments to the process thread, including the name of the executable.
     * @param type An <strong>int</strong> that indicates what group of processes this process belongs to, as some are treated slightly differently (i.e an IMPORT type process is always followed by a BUILD one).
     * @param msg_type As process threads may be background (like a makecol.pl call) or important processes in their own right (such as an IMPORT-BUILD) we must be able to set what level messages posted by this class will have by usings this <strong>int</strong>.
     * @param caller The default <i>GShellListener</i> that is interested in the progress of this process.
     * @param progress The <i>GShellProgressMonitor</i> associated with this process.
     * @param name A <strong>String</strong> identifier given to the process, for convience and debug reasons.
     */
    public GShell(String args[], int type, int msg_type, GShellListener caller, GShellProgressMonitor progress, String name) {
    super(name);
    this.args = args;
    this.msg_type = msg_type;
    this.type = type;
    this.caller = caller;
    this.progress = progress;
    this.status = 0;
    // Lower this jobs priority
    this.setPriority(Thread.MIN_PRIORITY);
    listeners = new EventListenerList();
    listeners.add(GShellListener.class, caller);
    }
    /** This method adds another shell listener to this process.
     * @param listener The new <i>GShellListener</i>.
     */
    public void addGShellListener(GShellListener listener) {
    listeners.add(GShellListener.class, listener);
    }
    /** This method removes a certain shell listener from this process.
     * @param listener The <i>GShellListener</i> to be removed.
     */
    /* private void removeGShellListener(GShellListener listener) {
    listeners.remove(GShellListener.class, listener);
    } */
    /** Any threaded class must include this method to allow the thread body to be run. */
    public void run() {
        if(progress != null) {
            progress.start();
        }
        // Determine if the user has asked for an outfile.
        String out_name = null;
        BufferedOutputStream bos = null;
        if(type == IMPORT || type == BUILD) {
            if(type == IMPORT) {
            out_name = (String) Gatherer.c_man.getCollection().build_options.getImportValue("out");
            }
            else {
            out_name = (String) Gatherer.c_man.getCollection().build_options.getBuildValue("out");
            }
            if(out_name != null && out_name.length() > 0) {
            try {
                bos = new BufferedOutputStream(new FileOutputStream(new File(out_name), true));
            }
            catch (Exception error) {
                Gatherer.printStackTrace(error);
            }
            }
        }
        // Issue a processBegun event
        fireProcessBegun(type, status);
        try {

        String command = "";
        for(int i = 0; i < args.length; i++) {
        command = command + args[i] + " ";
        }
        ///ystem.err.println("Command: " + command);
        fireMessage(type, Dictionary.get("GShell.Command") + ": " + command, status);

        Runtime rt = Runtime.getRuntime();
        Process prcs = rt.exec(args);
        InputStreamReader eisr = new InputStreamReader( prcs.getErrorStream() );
        InputStreamReader stdisr = new InputStreamReader( prcs.getInputStream() );
        //BufferedReader ebr = new BufferedReader( eisr );
        //BufferedReader stdinbr = new BufferedReader( stdinisr );
        // Captures the std err of a program and pipes it into std in of java

        StringBuffer eline_buffer = new StringBuffer();
        StringBuffer stdline_buffer = new StringBuffer();
        while(type != GShell.NEW && processRunning(prcs) && !hasSignalledStop()) {
        // Hopefully this doesn't block if the process is trying to write to STDOUT.
        if(eisr.ready()) {
            int c = eisr.read();
            ///atherer.println("eisr: '" + (char) c + "'");
            if(c == '\n' || c == '\r') {
            if(eline_buffer.length() > 0) {
                String eline = eline_buffer.toString();
                ///atherer.println("* " + eline + " *");
                if(progress != null) {
                progress.parse(eline);
                }
                if(bos != null) {
                try {
                    bos.write(eline.getBytes(), 0, eline.length());
                }
                catch(Exception error) {
                    Gatherer.printStackTrace(error);
                }
                }
                fireMessage(type, typeAsString(type) + "> " + eline, status);
                eline = null;
                eline_buffer = new StringBuffer();
            }
            }
            else {
            eline_buffer.append((char)c);
            }
        }
        // Hopefully this won't block if the process is trying to write to STDERR
        else if(stdisr.ready()) {
            int c = stdisr.read();
            ///atherer.println("eisr: '" + (char) c + "'");
            if(c == '\n' || c == '\r') {
            if(stdline_buffer.length() > 0) {
                String stdline = stdline_buffer.toString();
                ///atherer.println("+ " + stdline + " +");
                fireMessage(type, typeAsString(type) + "> " + stdline, status);
                stdline = null;
                stdline_buffer = new StringBuffer();
            }
            }
            else {
            stdline_buffer.append((char)c);
            }
        }
        else {
            try {
            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(eisr.ready()) {
                int c = eisr.read();
                ///atherer.println("eisr: '" + (char) c + "'");
                if(c == '\n' || c == '\r') {
                    if(eline_buffer.length() > 0) {
                        String eline = eline_buffer.toString();
                        ///atherer.println("* " + eline + " *");
                        if(progress != null) {
                            progress.parse(eline);
                        }
                        if(bos != null) {
                            try {
                                bos.write(eline.getBytes(), 0, eline.length());
                            }
                            catch(Exception error) {
                                Gatherer.printStackTrace(error);
                            }
                        }
                        fireMessage(type, typeAsString(type) + "> " + eline, status);
                        eline = null;
                        eline_buffer = new StringBuffer();
                    }
                }
                else {
                    eline_buffer.append((char)c);
                }
            }
            while(stdisr.ready()) {
                int c = stdisr.read();
                ///atherer.println("eisr: '" + (char) c + "'");
                if(c == '\n' || c == '\r') {
                    if(stdline_buffer.length() > 0) {
                        String stdline = stdline_buffer.toString();
                        ///atherer.println("+ " + stdline + " +");
                        fireMessage(type, typeAsString(type) + "> " + stdline, status);
                        stdline = null;
                        stdline_buffer = new StringBuffer();
                    }
                }
                else {
                    stdline_buffer.append((char)c);
                }
            }

        // Ensure that any messages still remaining in the string buffers are fired off.
        if(eline_buffer.length() > 0) {
            String eline = eline_buffer.toString();
            if(progress != null) {
                progress.parse(eline);
            }
            if(bos != null) {
                try {
                    bos.write(eline.getBytes(), 0, eline.length());
                }
                catch(Exception error) {
                    Gatherer.printStackTrace(error);
                }
            }
            fireMessage(type, typeAsString(type) + "> " + eline, status);
            eline = null;
        }

        if(stdline_buffer.length() > 0) {
            String stdline = stdline_buffer.toString();
            fireMessage(type, typeAsString(type) + "> " + stdline, status);
            stdline = null;
        }

        if(!hasSignalledStop()) {
        // Now display final message based on exit value
        prcs.waitFor();

        if(prcs.exitValue() == 0) {
            status = OK;
            fireMessage(type, typeAsString(type) + "> " + Dictionary.get("GShell.Success"), status);
        }
        else {
            status = ERROR;
            fireMessage(type, typeAsString(type) + "> " + Dictionary.get("GShell.Failure"), status);
        }
        }
        else {
        // I need to somehow kill the child process. Unfortunately Thread.stop() and Process.destroy() both fail to do this. But now, thankx to the magic of Michaels 'close the stream suggestion', it works fine (no it doesn't!)
        prcs.getInputStream().close();
        prcs.getErrorStream().close();
        prcs.getOutputStream().close();
        prcs.destroy();
        status = CANCELLED;
        }
    }
    // Exception
    catch (Exception error) {
        Gatherer.printStackTrace(error);
        status = ERROR;
    }
    // If no error occured, and this was an import process we now extract any new metadata from the archive directory.
    if(status == OK && type == IMPORT) {
        fireMessage(type, typeAsString(type) + "> " + Dictionary.get("GShell.Parsing_Metadata_Start"), status);
        new GreenstoneArchiveParser(progress, this);
        fireMessage(type, typeAsString(type) + "> " + Dictionary.get("GShell.Parsing_Metadata_Complete"), status);
    }
    // Tidy up.
    if(progress != null) {
        progress.stop();
    }
    // We're done.
    fireProcessComplete(type, status);
    // Close bos
    if(bos != null) {
        try {
        bos.close();
        bos = null;
        }
        catch(Exception error) {
        Gatherer.printStackTrace(error);
        }
    }
    }
    /** Method for firing a message to all interested listeners.
     * @param type An <strong>int</strong> indicating the process type.
     * @param message The message as a <strong>String</strong>.
     * @param status An <strong>int</strong> specifying the current status of the process.
     */
    public void fireMessage(int type, String message, int status) {
    GShellEvent event = new GShellEvent(this, 0, type, message, status);
    Object[] concerned = listeners.getListenerList();
    for(int i = 0; i < concerned.length ; i++) {
        if(concerned[i] == GShellListener.class) {
        ((GShellListener)concerned[i+1]).message(event);
        }
    }
    }

    /** Method for firing a process begun event which is called, strangly enough, when the process begins.
     * @param type An <strong>int</strong> indicating the process type.
     * @param status An <strong>int</strong> specifying the current status of the process.
     */
    protected void fireProcessBegun(int type, int status) {
    GShellEvent event = new GShellEvent(this, 0, type, "", status);
    Object[] concerned = listeners.getListenerList();
    for(int i = 0; i < concerned.length ; i++) {
        if(concerned[i] == GShellListener.class) {
        ((GShellListener)concerned[i+1]).processBegun(event);
        }
    }
    }
    /** Method for firing a process complete event which is called, no surprise here, when the process ends.
     * @param type An <strong>int</strong> indicating the process type.
     * @param status An <strong>int</strong> specifying the current status of the process.
     */
    protected void fireProcessComplete(int type, int status) {
    GShellEvent event = new GShellEvent(this, 0, type, "", status);
    Object[] concerned = listeners.getListenerList();
    for(int i = 0; i < concerned.length ; i++) {
        if(concerned[i] == GShellListener.class) {
        ((GShellListener)concerned[i+1]).processComplete(event);
        }
    }
    }

    /** Method to determine if the user, via the progress monitor, has signalled stop.
     * @return A <strong>boolean</strong> indicating if the user wanted to stop.
     */
    private boolean hasSignalledStop() {
    boolean has_signalled_stop = false;
    if(progress != null) {
        return progress.hasSignalledStop();
    }
    return has_signalled_stop;
    }

    /** Converts a type into a text representation.
     * @param type An <strong>int</strong> which maps to a shell process type.
     * @return A <strong>String</strong> which is the thread process's text name.
     */
    public String typeAsString(int type) {
    String name = null;
    switch(type) {
    case BUILD:
        name = Dictionary.get("GShell.Build");
        break;
    case IMPORT:
        name = Dictionary.get("GShell.Import");
        break;
    case NEW:
        name = Dictionary.get("GShell.New");
        break;
    case EXPORT:
        name= Dictionary.get("GShell.Export");
        break;
    default:
        name = Dictionary.get("GShell.Other");
    }
    return name;
    }
}