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

package org.greenstone.gatherer.shell;
/**
 *#########################################################################
 *
 * 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.
 *########################################################################
 */
import java.io.*;
import javax.swing.*;
import javax.swing.event.*;
import javax.swing.tree.*;
import org.greenstone.gatherer.Gatherer;
import org.greenstone.gatherer.Message;
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 OTHER = 3;
     /** Element in status type enumeration. */
     static final public int ERROR = 0;
     /** Element in status type enumeration. */
     static final public int OK = 1;
     /** 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";
     /** 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.
      */
     public 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() {
          // Setup
          if(progress != null) {
                progress.start();
          }
          // Determine if the user has asked for an outfile.
          String out_name = null;
          FileOutputStream fos = 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) {
                     File out = new File(out_name);
                     try {
                          if(out.exists()) {
                                boolean append = true;
                                fos = new FileOutputStream(out, append);
                                bos = new BufferedOutputStream(fos);
                          }
                     } 
                     catch (Exception error) {
                          error.printStackTrace();
                     }
                }
          }
          // 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, get("Command") + ": " + command, status);
                message(Message.EVENT, get("Command") + ": " + command);
                
                Runtime rt = Runtime.getRuntime();
                Process prcs = rt.exec(args);
                InputStreamReader eisr = new InputStreamReader( prcs.getErrorStream() );
                InputStreamReader stdinisr = 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
                String eline = null;
                String stdinline = null;
                while (((eline = ebr.readLine()) != null || (stdinline = stdinbr.readLine()) != null) && !hasSignalledStop()) {
                     if(eline != null) {
                          if(progress != null) {
                                progress.parse(eline);
                          }
                          if(bos != null) {
                                bos.write(eline.getBytes(), 0, eline.length());
                          }
                          ///ystem.err.println("stderr: " + eline);
                          fireMessage(type, typeAsString(type) + "> " + eline, 
                                          status);
                          message(Message.INFO, eline);
                     }
                     if(stdinline != null) {
                          if(bos != null) {
                                //bos.write(stdinline.getBytes(), 0, stdinline.length());
                          }
                          ///ystem.err.println("stdin: " + stdinline);
                          fireMessage(type, typeAsString(type) + "> " + stdinline,
                                          status);
                          message(Message.INFO, stdinline);
                     }
                }

                if(!hasSignalledStop()) {
                     // Now display final message based on exit value
                     prcs.waitFor();
                     
                     if(prcs.exitValue() == 0) {
                          status = OK;
                          fireMessage(type, typeAsString(type) + "> " + get("Success"), status);
                          message(Message.MAIN, get("Success"));
                     } else {
                          status = ERROR;
                          fireMessage(type, typeAsString(type) + "> " + get("Failure"), status);
                          message(Message.ERROR, get("Failure"));
                     }
                }
                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.getOutputStream().close();
                     prcs.destroy();
                     status = ERROR;
                }
          }
          // Exception
          catch (Exception error) {
                message(Message.ERROR, get("Failure"));
                message(Message.ERROR, error.toString());
                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) + "> " + get("Parsing_Metadata_Start"), status);
                new GreenstoneArchiveParser(progress, this);
                fireMessage(type, typeAsString(type) + "> " + get("Parsing_Metadata_Complete"), status);
          }
          // Tidy up.
          if(progress != null) {
                progress.stop();
          }
          if(bos != null) {
                try {
                     bos.close();
                }
                catch (Exception e) {
                }
          }
          // We're done.
          fireProcessComplete(type, status);
    }
     /** 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);
                }
          }
     }
     /** Retrieve a phrase from the dictionary based on the given key.
      * @param key A <strong>String</strong> used to match against a phrase from the <strong>Dictionary</strong>.
      * @return The phrase as a <strong>String</strong>.
      */
     private String get(String key) {
          if(key.indexOf('.') == -1) {
                key = "GShell." + key;
          }
          return Gatherer.dictionary.get(key);
     }
     /** 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;
     }
     /** Creates and dispatches a message given the initial details.
      * @param level An <strong>int</strong> indicating the message level for this message.
      * @param message A <strong>String</strong> which contains the payload of this message.
      */
     private void message(int level, String message) {
          Message msg = new Message(msg_type, level, message);
          if(Gatherer.g_man != null) {
                Gatherer.log.add(msg);
          }
     }
     /** 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 = get("Build");
                break;
          case IMPORT:
                name = get("Import");
                break;
          case NEW:
                name = get("New");
                break;
          default:
                name = get("Other");
          }
          return name;
     }
}