Author: [log in to unmask]
Date: Thu Apr 16 15:56:54 2015
New Revision: 2727

Log:
Make sure session always disconnects by interrupting the processing thread if necessary.

Modified:
    java/trunk/monitoring-app/src/main/java/org/hps/monitoring/application/EventProcessing.java

Modified: java/trunk/monitoring-app/src/main/java/org/hps/monitoring/application/EventProcessing.java
 =============================================================================
--- java/trunk/monitoring-app/src/main/java/org/hps/monitoring/application/EventProcessing.java	(original)
+++ java/trunk/monitoring-app/src/main/java/org/hps/monitoring/application/EventProcessing.java	Thu Apr 16 15:56:54 2015
@@ -246,13 +246,13 @@
      */
     synchronized void connect() throws IOException {
         // Setup the network connection if using an ET server.
-        if (usingEtServer()) {
+        if (this.usingEtServer()) {
             // Create a connection to the ET server.
             try {
                 this.logger.fine("connecting to ET system ...");
 
                 // Create the main ET system connection.
-                createEtConnection();
+                this.createEtConnection();
 
                 // FIXME: Separate event processing ET stations not currently used due to synchronization and ET issues.
 
@@ -324,8 +324,8 @@
     synchronized void disconnect() {
 
         // Cleanup the ET connection.
-        if (usingEtServer()) {
-            closeEtConnection();
+        if (this.usingEtServer()) {
+            this.closeEtConnection();
         }
 
         // Change application state to disconnected.
@@ -438,10 +438,10 @@
     void setup(final ConfigurationModel configurationModel) {
 
         // Setup LCSim from the configuration.
-        setupLcsim(configurationModel);
+        this.setupLcsim(configurationModel);
 
         // Now setup the CompositeLoop.
-        setupLoop(configurationModel);
+        this.setupLoop(configurationModel);
     }
 
     /**
@@ -484,14 +484,14 @@
 
             // Setup the event builder to translate from EVIO to LCIO.
             // This must happen before Driver setup so the builder's listeners are activated first!
-            createEventBuilder(configurationModel);
+            this.createEventBuilder(configurationModel);
 
             // Configure the job manager for the XML steering.
             this.sessionState.jobManager.setPerformDryRun(true);
             if (steeringType == SteeringType.RESOURCE) {
-                setupSteeringResource(steering);
+                this.setupSteeringResource(steering);
             } else if (steeringType.equals(SteeringType.FILE)) {
-                setupSteeringFile(steering);
+                this.setupSteeringFile(steering);
             }
 
             // Set conditions tag if applicable.
@@ -650,23 +650,37 @@
     synchronized void stop() {
 
         // Kill session watchdog thread.
-        killWatchdogThread();
+        this.killWatchdogThread();
 
         // Wake up all ET stations to unblock the system and make sure stations are detached properly.
-        if (usingEtServer()) {
-            wakeUpEtStations();
+        if (this.usingEtServer()) {
+            this.wakeUpEtStations();
         }
 
         // Stop the event processing now that ET system should be unblocked.
-        this.logger.fine("sending STOP command to loop ...");
+        this.logger.finer("sending STOP command to loop ...");
         this.sessionState.loop.execute(Command.STOP);
-        this.logger.fine("loop got command STOP");
-
-        // Cleanup the event processing thread since it was told to stop now.
+        this.logger.finer("loop got STOP command");
+
+        this.logger.finer("processing thread is alive: " + this.sessionState.processingThread.isAlive());
+
         try {
-            this.logger.fine("waiting for event processing thread to end ...");
+            // Give the event processing thread a chance to end cleanly.
+            this.logger.finer("waiting for event processing thread to end ...");
+            this.sessionState.processingThread.join(5000);
+            this.logger.finer("processing thread is alive: " + this.sessionState.processingThread.isAlive());
+            // this.logger.finer("event processing thread ended cleanly");
+        } catch (final InterruptedException e) {
+            e.printStackTrace();
+        }
+
+        try {
+            this.logger.finer("processing thread is alive: " + this.sessionState.processingThread.isAlive());
+            // In this case the thread needs to be interrupted and then joined.
+            this.logger.finer("interrupting event processing thread");
+            this.sessionState.processingThread.interrupt();
             this.sessionState.processingThread.join();
-            this.logger.fine("event processing thread ended");
+            this.logger.finer("event processing thread ended after interrupt");
         } catch (final InterruptedException e) {
             e.printStackTrace();
         }
@@ -681,10 +695,10 @@
         this.sessionState.loop = null;
 
         // Disconnect from the ET system.
-        disconnect();
+        this.disconnect();
 
         // Invalidate the event processing object so it is unusable now.
-        invalidate();
+        this.invalidate();
     }
 
     /**