Changeset 31639 for main/trunk/gli/src/org/greenstone/gatherer/util/SafeProcess.java

Timestamp:

2017-05-01T20:07:17+12:00 (7 years ago)

Author:

ak19

Message:

1. Correcting switch statement in SafeProcess and tidying up some debugging. 2. GShell needs to have its own LineByLineHandlers not CustomProcessHandlers, since most of the err/out stream processing code should be the default provided by SafeProcess. 3. GShell.gotException wasn't being called during an expected InterruptedException on Cancel, so corrected that to make the code write a message to the DebugStream as the original code did when a build operation had been cancelled.

File:

• main/trunk/gli/src/org/greenstone/gatherer/util/SafeProcess.java (modified) (17 diffs)

main/trunk/gli/src/org/greenstone/gatherer/util/SafeProcess.java

@@ -21 +21 @@
 
 public class SafeProcess {
+    //public static int DEBUG = 0;
 
     public static final int STDERR = 0;
@@ -99 +100 @@
     public void setSplitStdErrorNewLines(boolean split) {
     splitStdErrorNewLines = split;
-    }
-
-    // logger and DebugStream print commands are synchronized, therefore thread safe.
-    public static void log(String msg) {
-    //logger.info(msg);
-
-    System.err.println(msg);
-
-    //DebugStream.println(msg);
-    }
-
-    public static void log(String msg, Exception e) { // Print stack trace on the exception
-    //logger.error(msg, e);
-
-    System.err.println(msg);
-    e.printStackTrace();
-
-    //DebugStream.println(msg);
-    //DebugStream.printStackTrace(e);
-    }
-
-    public static void log(Exception e) {
-    //logger.error(e);
-
-    e.printStackTrace();
-
-    //DebugStream.printStackTrace(e);
-    }
-
-    public static void log(String msg, Exception e, boolean printStackTrace) {
-    if(printStackTrace) { 
-        log(msg, e);
-    } else {
-        log(msg);
-    }
     }
 
@@ -184 +150 @@
         this.exitValue = process.waitFor(); // can throw an InterruptedException if process did not terminate
     } catch(InterruptedException ie) {
-        
         log("*** Process interrupted (InterruptedException). Expected to be a Cancel operation.");
             // don't print stacktrace: an interrupt here is not an error, it's expected to be a cancel action
+        if(exceptionHandler != null) {      
+        exceptionHandler.gotException(ie);
+        }           
         
         // propagate interrupts to worker threads here
@@ -204 +172 @@
         // to swallow the interrupt this time and not let it propagate by commenting out the next line?
         //Thread.currentThread().interrupt(); // re-interrupt the thread
-        
+
         inputGobbler.interrupt();
         errorGobbler.interrupt();
         outputGobbler.interrupt();
-        
+
+        // even after the interrupts, we want to proceed to calling join() on all the worker threads
+        // in order to wait for each of them to die before attempting to destroy the process if it
+        // still hasn't terminated after all that.
     } finally {     
         
@@ -358 +329 @@
     
     } finally { 
-
-        log("*** In finally of SafeProcess.runProcess(3 params)");
+        //String cmd = (this.command == null) ? Arrays.toString(this.command_args) : this.command;
+        //log("*** In finally of SafeProcess.runProcess(3 params): " + cmd);
 
         if( process != null ) {
@@ -440 +411 @@
         // http://www.javaworld.com/article/2071275/core-java/when-runtime-exec---won-t.html?page=2
         // http://mark.koli.ch/leaky-pipes-remember-to-close-your-streams-when-using-javas-runtimegetruntimeexec        
+        
+        //String cmd = (this.command == null) ? Arrays.toString(this.command_args) : this.command;
+        //log("*** In finally of SafeProcess.runProcess(2 params): " + cmd);
+
         if( process != null ) {
         log("*** Going to call process.destroy 1");
@@ -446 +421 @@
         log("*** Have called process.destroy 1");
         }
-        log("*** In finally of SafeProcess.runProcess(2 params)");
     }
     
@@ -484 +458 @@
     protected CustomProcessHandler(int src) {
     this.source = src; // STDERR or STDOUT or STDIN
-
-    // modify threadname to prefix stream src (stdin/stderr/stdout)
-    // Useful for debugging if thread is named clearly
-    String stream;
-    switch(src) {
-    case SafeProcess.STDERR:
-       stream = "stderr"; 
-    case SafeProcess.STDOUT:
-        stream = "stdout";
-    default:
-        stream = "stdin";
-    }
-    Thread.currentThread().setName(stream + Thread.currentThread().getName());
+    }
+
+    public String getThreadNamePrefix() {
+    return SafeProcess.streamToString(this.source); 
     }
     
@@ -510 +475 @@
     protected LineByLineHandler(int src) {
     this.source = src; // STDERR or STDOUT
+    }
+
+    public String getThreadNamePrefix() {
+    return SafeProcess.streamToString(this.source); 
     }
 
@@ -530 +499 @@
     private LineByLineHandler lineByLineHandler = null;
 
+    protected InputStreamGobbler() {
+    super("InputStreamGobbler");
+    }
+
     public InputStreamGobbler(InputStream is)
     {
-    super("InputStreamGobbler"); // thread name
+    this(); // sets thread name
     this.is = is;
     this.split_newlines = false;
@@ -539 +512 @@
     public InputStreamGobbler(InputStream is, boolean split_newlines)
     {
-    super("InputStreamGobbler"); // thread name
+    this(); // sets thread name
     this.is = is;
     this.split_newlines = split_newlines;
@@ -546 +519 @@
     public InputStreamGobbler(InputStream is, CustomProcessHandler customHandler)
     {
-    super("InputStreamGobbler"); // thread name
+    this(); // thread name
     this.is = is;
     this.customHandler = customHandler;
+    this.adjustThreadName(customHandler.getThreadNamePrefix());
+    }
+
+    
+    private void adjustThreadName(String prefix) {  
+    this.setName(prefix + this.getName());
     }
 
     public void setLineByLineHandler(LineByLineHandler lblHandler) {
     this.lineByLineHandler = lblHandler;
+    this.adjustThreadName(lblHandler.getThreadNamePrefix());
     }
 
@@ -579 +559 @@
         lineByLineHandler.gotException(ioe);
         } else {
-        log("Exception when reading from a process' stdout/stderr stream: ", ioe);
+        log("Exception when reading process stream with " + this.getName() + ": ", ioe);
         }
     } finally {
-        log("*********");
         if(this.isInterrupted()) {
-        log("We've been asked to stop.");       
+        log("@@@ Successfully interrupted " + this.getName() + ".");
         }
         SafeProcess.closeResource(br);
-        log("*** In finally of " + this.getName());
-        log("*********");
     }
     }
@@ -619 +596 @@
     private CustomProcessHandler customHandler = null;
 
+    protected OutputStreamGobbler() {
+    super("stdinOutputStreamGobbler"); // thread name
+    }
+
     public OutputStreamGobbler(OutputStream os) {
-    super("OutputStreamGobbler"); // thread name
+    this(); // set thread name
     this.os = os;
     }
@@ -626 +607 @@
     public OutputStreamGobbler(OutputStream os, String inputstr)
     {
-    super("OutputStreamGobbler"); // thread name
+    this(); // set thread name
     this.os = os;
     this.inputstr = inputstr;
@@ -632 +613 @@
 
     public OutputStreamGobbler(OutputStream os, CustomProcessHandler customHandler) {
-    super("OutputStreamGobbler"); // thread name
+    this(); // set thread name
     this.os = os;
     this.customHandler = customHandler;
@@ -692 +673 @@
 } // end static inner class OutputStreamGobbler
 
+//**************** Static methods **************//
+
+
+    // logger and DebugStream print commands are synchronized, therefore thread safe.
+    public static void log(String msg) {
+    //logger.info(msg);
+
+    System.err.println(msg);
+
+    //DebugStream.println(msg);
+    }
+
+    public static void log(String msg, Exception e) { // Print stack trace on the exception
+    //logger.error(msg, e);
+
+    System.err.println(msg);
+    e.printStackTrace();
+
+    //DebugStream.println(msg);
+    //DebugStream.printStackTrace(e);
+    }
+
+    public static void log(Exception e) {
+    //logger.error(e);
+
+    e.printStackTrace();
+
+    //DebugStream.printStackTrace(e);
+    }
+
+    public static void log(String msg, Exception e, boolean printStackTrace) {
+    if(printStackTrace) { 
+        log(msg, e);
+    } else {
+        log(msg);
+    }
+    }
+
+    public static String streamToString(int src) {
+    String stream;
+    switch(src) {
+    case STDERR:
+        stream = "stderr"; 
+        break;
+    case STDOUT:
+        stream = "stdout";
+        break;
+    default:
+        stream = "stdin";
+    }
+    return stream;
+    }
 
 //**************** Useful static methods. Copied from GLI's Utility.java ******************