test/java/rmi/activation/Activatable/shutdownGracefully/ShutdownGracefully.java

Print this page
rev 9281 : 8032050: Clean up for java/rmi/activation/Activatable/shutdownGracefully/ShutdownGracefully.java
Reviewed-by: smarks

@@ -1,7 +1,7 @@
 /*
- * Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1999, 2014, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.

@@ -20,11 +20,11 @@
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */
 
 /* @test
- * @bug 4183169
+ * @bug 4183169 8032050
  * @summary Minor problem with the way ReliableLog handles IOExceptions.
  *
  * @author Laird Dornin; code borrowed from Ann Wollrath
  *
  * @library ../../../testlibrary

@@ -34,10 +34,11 @@
  */
 
 import java.rmi.activation.*;
 import java.rmi.*;
 import java.util.Properties;
+import java.util.concurrent.TimeoutException;
 
 /**
  * The test creates an rmid with a special security manager.  After
  * rmid makes two registrations (which is greater than rmid's
  * snapshotInterval) the security manager stops allowing rmid to write

@@ -49,20 +50,24 @@
  * shuts down in a graceful manner without any explicit request to do
  * so.  The test will not exit for 400 seconds if rmid does not exit
  * (after that time, the test will fail).
  */
 public class ShutdownGracefully
-    extends Activatable implements Runnable, RegisteringActivatable
+    extends Activatable implements RegisteringActivatable
 {
     private static RegisteringActivatable registering = null;
 
     private final static long SHUTDOWN_TIMEOUT = 400 * 1000;
 
     public static void main(String args[]) {
 
         RMID rmid = null;
+        // flag to show if test succeed
+        boolean testSucceeded = false;
 
+        // error message
+        String failure = null;
         System.err.println("\nRegression test for bug/rfe 4183169\n");
 
         try {
             TestLibrary.suggestSecurityManager(
                 "java.rmi.RMISecurityManager");

@@ -130,105 +135,39 @@
             ActivationGroupID secondGroupID =
                 system.registerGroup(groupDesc);
             desc = new ActivationDesc(secondGroupID,
                 "ShutdownGracefully", null, null);
 
+            /*
+             * registration request is expected to be failed. succeeded case
+             * should be recorded. And raise error after clean up  rmid.
+             */
             try {
                 registering = (RegisteringActivatable)
                     Activatable.register(desc);
-
-                System.err.println("second activate and deactivate " +
-                                   "object via method call");
+                failure = "The registration request succeeded unexpectedly";
             } catch (ActivationException e) {
                 System.err.println("received exception from registration " +
                                    "call that should have failed...");
-            }
-
-            /*
-             * no longer needed because the security manager
-             * throws an exception during snapshot
-             */
-            /*
-            try {
-                registering.shutdown();
-
-                System.err.println("received exception from remote " +
-                                   "call that should have failed...");
-            } catch (RemoteException e) {
-            }
-            */
-
-        } catch (Exception e) {
-            TestLibrary.bomb("\nfailure: unexpected exception ", e);
-        } finally {
-            try {
-                Thread.sleep(4000);
-            } catch (InterruptedException e) {
-            }
-
-            registering = null;
-
-            // Need to make sure that rmid goes away by itself
-            JavaVM rmidProcess = rmid;
-            if (rmidProcess != null) {
+                // Need wait rmid prcoess terminates.
                 try {
-                    Runnable waitThread =
-                        new ShutdownDetectThread(rmidProcess);
-
-                    synchronized (waitThread) {
-                        (new Thread(waitThread)).start();
-                        waitThread.wait(SHUTDOWN_TIMEOUT);
-                        System.err.println("rmid has shutdown");
-
-                        if (!rmidDone) {
-                            // ensure that this rmid does not infect
-                            // other tests.
-                            rmidProcess.destroy();
-                            TestLibrary.bomb("rmid did not shutdown " +
-                                             "gracefully in time");
+                    int exitCode = rmid.waitFor(SHUTDOWN_TIMEOUT);
+                    System.err.println("RMID has exited gracefully with exitcode:" + exitCode);
+                    rmid = null;
+                    testSucceeded = true;
+                } catch (TimeoutException te) {
+                    failure = "RMID hasn't exited gracefully in expected time";
                         }
                     }
                 } catch (Exception e) {
-                    TestLibrary.bomb("exception waiting for rmid " +
-                                     "to shut down");
-                }
-            }
-            // else rmid should be down
-        }
-
-        System.err.println
-            ("\nsuccess: ShutdownGracefully test passed ");
-    }
-
-    private static boolean rmidDone = false;
-
-    /**
-     * class that waits for rmid to exit
-     */
-    private static class ShutdownDetectThread implements Runnable {
-        private JavaVM rmidProcess = null;
-
-        ShutdownDetectThread(JavaVM rmidProcess) {
-            this.rmidProcess = rmidProcess;
-        }
-        public void run() {
-            System.err.println("waiting for rmid to shutdown");
-
-            try {
-                rmidProcess.waitFor();
-            } catch (InterruptedException e) {
-                // should not happen
-            }
-
-            synchronized (this) {
-                // notify parent thread when rmid has exited
-                this.notify();
-                rmidDone = true;
-            }
-
-            RMID.removeLog();
+            failure = "unexpected exception " + e;
+        } finally {
+            if (rmid != null)
+                rmid.destroy();
         }
+        if (!testSucceeded)
+            TestLibrary.bomb("\nfailure: " + failure);
     }
 
     /**
      * implementation of RegisteringActivatable
      */

@@ -238,25 +177,14 @@
         // register/export anonymously
         super(id, 0);
     }
 
     /**
-     * Spawns a thread to deactivate the object.
+     * Deactivates the object. We need to unexport forcibly because this call
+     * in-progress on this object, which is the same object that we are trying
+     * to deactivate.
      */
     public void shutdown() throws Exception {
-        (new Thread(this, "ShutdownGracefully")).start();
-    }
-
-    /**
-     * Thread to deactivate object. First attempts to make object
-     * inactive (via the inactive method).  If that fails (the
-     * object may still have pending/executing calls), then
-     * unexport the object forcibly.
-     */
-    public void run() {
-        try {
-            Thread.sleep(50 * 1000);
-        } catch (InterruptedException e) {
-        }
+        Activatable.unexportObject(this, true);
         ActivationLibrary.deactivate(this, getID());
     }
 }