Changeset 38943 for main/trunk/greenstone3/src/java/org/greenstone/applet/phind/JPhind.java

Timestamp:

2024-04-23T16:08:12+12:00 (8 weeks ago)

Author:

anupama

Message:

JPhind is still being run as an application, but: 1. I've now changed the Java code to have a shutdown handler for if run as a webswing applet and to have a windowClosing handler for when run as a (webswing) application. It didn't appear to need a windowClosing handler before as it doesn't have any internal threads and didn't need thread cleanup, but having a skeleton windowClosing handler is good for if a GS3 developer needs to in future add some cleanup. 2. The mostly static parameters to Phind are now moved back from webswing.config.in to pages/webswing-phind.xsl (which only sets the webswing parameter to indicate it's being run through webswing). We don't actually have an applet element (yet) for Phind webswing: it was being pushed out by the GS3 Java code service PhindPhraseBrowse.java, but that is a different URL that we have replaced with the webswing-phind url. More incremental modifications to come. Next up will be running JPhind as a webswing applet (with or without a shim applet HTML element existing on the page).

File:

• main/trunk/greenstone3/src/java/org/greenstone/applet/phind/JPhind.java (modified) (11 diffs)

main/trunk/greenstone3/src/java/org/greenstone/applet/phind/JPhind.java

@@ -94 +94 @@
 import org.webswing.toolkit.api.WebswingUtil;
 
+import org.webswing.toolkit.api.lifecycle.WebswingShutdownListener;
+import org.webswing.toolkit.api.lifecycle.OnBeforeShutdownEvent;
+
 import javax.swing.JApplet;
 import javax.swing.JComponent;
@@ -108 +111 @@
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
+import java.awt.event.WindowAdapter;
+import java.awt.event.WindowEvent;
 
 import java.awt.BorderLayout;
@@ -136 +141 @@
 
 public class JPhind extends JApplet 
-    implements ActionListener {
-
+    implements ActionListener, WebswingShutdownListener {
+
+    int verbosity_ = 3;
+    
     // if run as webswing vs either commandline application or as applet through appletviewer
     boolean isWebswing = false;
@@ -264 +271 @@
         // HttpUtils.parseQueryString() deprecated, so hacking decode xtra key-value pairs
         // https://stackoverflow.com/questions/13592236/parse-a-uri-string-into-name-value-collection?page=1&tab=scoredesc#tab-top
-        // String.split() is preferred over Tokenizer but 2nd parameter behaves differently
-        // than I expected.
-        // https://docs.oracle.com/javase/6/docs/api/java/lang/String.html#split%28java.lang.String,%20int%29
         if(key.equals("xtraParams")) {
             value = value.replace("&", "&"); // just in case we have html entities
-            String[] param_list = value.split("&", 0); // 0 for all occurrences
-            for(String key_val : param_list) {          
-            String[] paramPair = key_val.split("=", 2); // get first 2 strings, key and val
-            //System.err.println("key_val: " + key_val);
-            if(paramPair.length == 2) {
-                String xtraParamsKey = paramPair[0];
-                String xtraParamsVal = paramPair[1];
-                //System.err.println("key - val: " + xtraParamsKey + " - " + xtraParamsVal);
-                appParams.put(xtraParamsKey, xtraParamsVal);
-            }
-            }
+            parseXtraParams(value, "=", "&", appParams);            
         }
-        
         key = value = null;
         }
@@ -294 +287 @@
     /**
      * Overriding (J)Applet method getParameter to first check appParams map
-     * if Phind was run run as an application.
+     * if Phind was run as an application.
+     * If run as an applet, we still check the appParams first for if the param-name
+     * exists in any xtraParams manually parsed into appParams, before finally
+     * checking the Applet method getParameter().
      * https://stackoverflow.com/questions/15905127/overridden-methods-in-javadoc
     */
@@ -303 +299 @@
     }
     else {
+        if(appParams != null) {
+        String value = appParams.get(name);
+        if(value != null) {
+            return value;
+        }
+        }
         return super.getParameter(name);
     }
@@ -321 +323 @@
     }
 
-
+    // Given a string xtraParams of key-value pairs separatod by pairSeparators,
+    // parses out each (key, value) and puts them into the given map, allocating it if
+    // necessary, and returns this map.
+    Map parseXtraParams(String xtraParams, String kvSeparator, String kvPairSeparator, Map map) {
+    
+    // String.split() is preferred over Tokenizer but 2nd parameter behaves differently
+    // than I expected.
+    // https://docs.oracle.com/javase/6/docs/api/java/lang/String.html#split%28java.lang.String,%20int%29
+    String[] param_list = xtraParams.split(kvPairSeparator, 0);// 0 means for all occurrences
+    
+    if(map == null) {
+        map = new HashMap<String,String>(param_list.length);
+    }
+    
+    for(String key_val : param_list) {
+        String[] paramPair = key_val.split(kvSeparator, 2); // get first 2 strings, key and val
+        //System.err.println("key_val: " + key_val);
+        if(paramPair.length == 2) {
+        String xtraParamsKey = paramPair[0];
+        String xtraParamsVal = paramPair[1];
+        // Let's remove any bookending quotes from value, this is necessary for some
+        // values when run as a webswing applet
+        if(xtraParamsVal.startsWith("\"") && xtraParamsVal.endsWith("\"")) {
+            xtraParamsVal = xtraParamsVal.substring(1, xtraParamsVal.length()-1);
+        }
+
+        if (verbosity_ >= 4) {
+            System.err.println("*** xtraParams key - val: " + xtraParamsKey + " - " + xtraParamsVal);
+        }
+        map.put(xtraParamsKey, xtraParamsVal);
+        }
+    }
+
+    return map;
+    }
+    
     public void init() {
 
@@ -329 +366 @@
     getParameters();
 
+    // if running as a *webswing applet*, need to do extra work when shutdown is called
+    // It will be triggered from a JavaScript call to webswing's kill(). By default that
+    // generates a windowClosing event, which is only detected if we're running as a
+    // webswing application. For a webswing applet, we add a shutdownlistener to do more
+    // when JS calls webswing's kill(): Phind has no threads that we need to implement
+    // stop() and destroy() (we'll call them in sequence anyway to futureproof the shutdown)
+    // but especially, we call System.exit(0) on shutdown, which we do NOT want to do
+    // if we're running as a regular applet instead of webswing applet.
+    if(isWebswing && isRunAsApplet) {
+        WebswingUtil.getWebswingApi().addShutdownListener(this);
+    }
+    
+    
     // Initialise the user interface
     setBackground(panel_bg);
@@ -445 +495 @@
     }
 
+    // implementing WebswingShutdownListener
+    /**
+     * Invoked before Webswing requests application to exit.
+     * Do not execute long operations in this listener - listener execution will be interrupted if blocking for &gt; 3 seconds and the application will exit without delay.
+     * Connection to server is still open when this callback is triggered.
+     * This method can delay the shutdown. Calling {@link WebswingApi#resetInactivityTimeout()} within the delay period will cancel the shutdown sequence.
+     *
+     * This method is not called on the event dispatch thread.
+     *
+     * @param event Event contains the reason of this shutdown - either triggered from Admin console's rest interface or by inactivity
+     * @return number of seconds to delay the shutdown, returning 0 will cause shutdown without delay (even if {@link WebswingApi#resetInactivityTimeout()} has been called)
+     */
+    public int onBeforeShutdown(OnBeforeShutdownEvent event) {
+    return 0; // seconds to delay before starting shutdown procedure
+    }
+
+    // If you add more cleanup code here for when run as a webswing applet,
+    // think if it should be added in the windowClosing handler in main() as well.
+    /**
+     * Invoked when Webswing requests swing application to exit. 
+     * This method should cause this process to exit (not necessarily in the same thread).
+     * When this method is called, connection to server is already closed
+     *
+     * This method is not called on the event dispatch thread.
+     */
+    public void onShutdown() {
+    // https://docs.oracle.com/javase%2F7%2Fdocs%2Fapi%2F%2F/java/applet/Applet.html#destroy()
+    //   destroy(): "Called by the browser or applet viewer to inform this applet that
+    //   it is being reclaimed and that it should destroy any resources that it has
+    //   allocated. The stop method will always be called before destroy."
+    // Running in webswing code here now, we're in the position of the browser at this point,
+    // and must keep to the above contract.
+    if (verbosity_ >= 3) {
+        System.err.println("------- JPhind: WebswingShutdownListener.onShutdown() - shutting down");        
+    }
+    stop();
+    destroy();
+    
+    // System.exit(0) is not done for regular applets, but this shutdown handler is *only*
+    // registered if Phind is run as a *webswing applet*. Webswing running applets isn't
+    // entirely the same as  a browser running applets, but more like a framework that
+    // launches an applet semi like an application (perhaps in a container).
+    // We found we could call System.exit(0) on a webswing applet here and it doesn't have
+    // the side-effect of shutting down the webswing running it or anything, so it seems
+    // fine to do, and we feel we *need* to do it as we'd like to clean up resources onShutdown
+    // Note that onShutdown is a custom handler we register if we run as a webswing applet,
+    // so that our webswing applet responds as we intend to the JavaScript kill() call that
+    // comes in when a user navigates away from the page running the webswing applet.
+    // Without implememnting WebswingShutdownListener, the webswing applet would not have
+    // terminated, but still linger on. Phind is not a multi-threaded applet, so the calls to
+    // stop() and destroy() above do not stop any internal threads launched, but the Phind
+    // program would still have allocated memory and we'd like them deallocated when the
+    // user navigates away.
+    System.exit(0); 
+    
+    }
+    
     // Search for a word 
     //
@@ -754 +861 @@
     // Get the applet parameters
     void getParameters() {
+    
+    // To get the webswing applet version of JPhind to work when
+    // specifiying custom parameters outside the webswing.config.in file,
+    // we have xtraParams, a string of key1::value1;;key2::value2 pairs
+    // that we first need to extract and add to final list of applet parameters
+    // we're working with.
+    String xtraParams = getParameter("xtraParams");
+    if(xtraParams != null) {
+        // will optionally create appParams and add the key,value pairs in xtraParams into it
+        // after splitting key::value;;k2::v2 etc
+        appParams = parseXtraParams(xtraParams, "::", ";;", appParams);
+    }
+
+    verbosity_ = parameterValue("verbosity", verbosity_);
+    
     String webswing = parameterValue("webswing", "0");
     isWebswing = webswing.equals("1") ? true : false;
@@ -1166 +1288 @@
         // https://stackoverflow.com/questions/19433358/difference-between-dispose-and-exit-on-close-in-java
         // default: https://docs.oracle.com/javase/8/docs/api/javax/swing/JFrame.html#EXIT_ON_CLOSE
-        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); // don't do EXIT_ON_CLOSE in Applets!
+        // don't do EXIT_ON_CLOSE in Applets. But being in main() means we're being run
+        // as an application.
+        // When the windowClosing event is received, EXIT_ON_CLOSE will call windowClosing handlers
+        // and then I think do a System.exit(0).
+        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
         frame.setVisible(true);
-
+        
+        
+        // There's no real cleanup to do now, but adding in the skeleton for application shutdown
+        // if there's ever any need for cleanup code. You'll then want to add cleanup code here
+        // iff JPhind is run as a application or as a webswing application. Then you'll want to
+        // add cleanup code to stop()/destroy() too which get called if running as a regular
+        // applet and also get called by our onShutDown() handler of WebswingShutdownListener
+        // for the webswing applet case.
+        frame.addWindowListener(new WindowAdapter() {
+        public void windowClosing(WindowEvent e) {
+            // Calling phind.showStatus() here doesn't work, maybe it's too late at this pt
+            // and the JFrame is already being dismantled?
+
+            
+            if(phind.isWebswing) {
+            // This call will only work if run as *webswing application* and the user
+            // manually clicked on the JPhind frame's window close button. Not if
+            // the user navigated away: at that point the webpage has already
+            // unloaded and its webswing listeners too, so the javascript
+            // can't echo this message to console:
+                WebswingUtil.getWebswingApi().sendActionEvent("javaToWebswingJSConsoleLog", "JPhind run as application - quitting now", null);          
+            }
+            
+            // Print stmts go to the terminal if run as a regular application. If run as
+            // webswing application/applet, then into packages/tomcat/bin/logs/webswing.log
+            System.err.println("\n\n*** Exitting the JPhind application...");
+        }
+        });
     }
     }