1 /*
   2  * Copyright (c) 1998, 2015, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 
  24 import java.io.*;
  25 import java.net.BindException;
  26 import java.rmi.*;
  27 import java.rmi.activation.*;
  28 import java.rmi.registry.*;
  29 import java.util.concurrent.TimeoutException;
  30 
  31 /**
  32  * Utility class that creates an instance of rmid with a policy
  33  * file of name <code>TestParams.defaultPolicy</code>.
  34  *
  35  * Activation groups should run with the same security manager as the
  36  * test.
  37  */
  38 public class RMID extends JavaVM {
  39 
  40     // TODO: adjust these based on the timeout factor
  41     // such as jcov.sleep.multiplier; see start(long) method.
  42     // Also consider the test.timeout.factor property (a float).
  43     private static final long TIMEOUT_SHUTDOWN_MS = 60_000L;
  44     private static final long TIMEOUT_DESTROY_MS  = 10_000L;
  45     private static final long STARTTIME_MS        = 15_000L;
  46     private static final long POLLTIME_MS         = 2000L;
  47 
  48     private static final String SYSTEM_NAME = ActivationSystem.class.getName();
  49         // "java.rmi.activation.ActivationSystem"
  50 
  51     public static String MANAGER_OPTION="-Djava.security.manager=";
  52 
  53     /** Test port for rmid */
  54     private final int port;
  55 
  56     /** Initial log name */
  57     protected static String log = "log";
  58     /** rmid's logfile directory; currently must be "." */
  59     protected static String LOGDIR = ".";
  60 
  61     private static void mesg(Object mesg) {
  62         System.err.println("RMID: " + mesg.toString());
  63     }
  64 
  65     /** make test options and arguments */
  66     private static String makeOptions(boolean debugExec) {
  67 
  68         String options = " -Dsun.rmi.server.activation.debugExec=" +
  69             debugExec;
  70         // +
  71         //" -Djava.compiler= ";
  72 
  73         // if test params set, want to propagate them
  74         if (!TestParams.testSrc.equals("")) {
  75             options += " -Dtest.src=" + TestParams.testSrc + " ";
  76         }
  77         //if (!TestParams.testClasses.equals("")) {
  78         //    options += " -Dtest.classes=" + TestParams.testClasses + " ";
  79         //}
  80         options += " -Dtest.classes=" + TestParams.testClasses //;
  81          +
  82          " -Djava.rmi.server.logLevel=v ";
  83 
  84         // +
  85         // " -Djava.security.debug=all ";
  86 
  87         // Set execTimeout to 60 sec (default is 30 sec)
  88         // to avoid spurious timeouts on slow machines.
  89         options += " -Dsun.rmi.activation.execTimeout=60000";
  90 
  91         return options;
  92     }
  93 
  94     private static String makeArgs(boolean includePortArg, int port) {
  95         String propagateManager = null;
  96 
  97         // rmid will run with a security manager set, but no policy
  98         // file - it should not need one.
  99         if (System.getSecurityManager() == null) {
 100             propagateManager = MANAGER_OPTION +
 101                 TestParams.defaultSecurityManager;
 102         } else {
 103             propagateManager = MANAGER_OPTION +
 104                 System.getSecurityManager().getClass().getName();
 105         }
 106 
 107         // getAbsolutePath requires permission to read user.dir
 108         String args =
 109             " -log " + (new File(LOGDIR, log)).getAbsolutePath();
 110 
 111         if (includePortArg) {
 112             args += " -port " + port;
 113         }
 114 
 115         // +
 116         //      " -C-Djava.compiler= ";
 117 
 118         // if test params set, want to propagate them
 119         if (!TestParams.testSrc.equals("")) {
 120             args += " -C-Dtest.src=" + TestParams.testSrc;
 121         }
 122         if (!TestParams.testClasses.equals("")) {
 123             args += " -C-Dtest.classes=" + TestParams.testClasses;
 124         }
 125 
 126         if (!TestParams.testJavaOpts.equals("")) {
 127             for (String a : TestParams.testJavaOpts.split(" +")) {
 128                 args += " -C" + a;
 129             }
 130         }
 131 
 132         if (!TestParams.testVmOpts.equals("")) {
 133             for (String a : TestParams.testVmOpts.split(" +")) {
 134                 args += " -C" + a;
 135             }
 136         }
 137 
 138         args += " -C-Djava.rmi.server.useCodebaseOnly=false ";
 139 
 140         args += " " + getCodeCoverageArgs();
 141         return args;
 142     }
 143 
 144     /**
 145      * Routine that creates an rmid that will run with or without a
 146      * policy file.
 147      */
 148     public static RMID createRMID() {
 149         return createRMID(System.out, System.err, true, true,
 150                         TestLibrary.getUnusedRandomPort());
 151     }
 152 
 153     public static RMID createRMID(OutputStream out, OutputStream err,
 154                                   boolean debugExec)
 155     {
 156         return createRMID(out, err, debugExec, true,
 157                           TestLibrary.getUnusedRandomPort());
 158     }
 159 
 160     public static RMID createRMID(OutputStream out, OutputStream err,
 161                                   boolean debugExec, boolean includePortArg,
 162                                   int port)
 163     {
 164         String options = makeOptions(debugExec);
 165         String args = makeArgs(includePortArg, port);
 166         RMID rmid = new RMID("sun.rmi.server.Activation", options, args,
 167                              out, err, port);
 168         rmid.setPolicyFile(TestParams.defaultRmidPolicy);
 169 
 170         return rmid;
 171     }
 172 
 173 
 174     /**
 175      * Private constructor. RMID instances should be created
 176      * using the static factory methods.
 177      */
 178     private RMID(String classname, String options, String args,
 179                    OutputStream out, OutputStream err, int port)
 180     {
 181         super(classname, options, args, out, err);
 182         this.port = port;
 183     }
 184 
 185     private void checkAddressInUser() throws BindException {
 186         if (outputContains("Address already in use")
 187                 || outputContains("Port already in use")) {
 188             throw new BindException("Address already in use at port: " + port);
 189         }
 190     }
 191 
 192     /**
 193      * Removes rmid's log file directory.
 194      */
 195     public static void removeLog() {
 196         File f = new File(LOGDIR, log);
 197 
 198         if (f.exists()) {
 199             mesg("Removing rmid's old log file.");
 200             String[] files = f.list();
 201 
 202             if (files != null) {
 203                 for (int i=0; i<files.length; i++) {
 204                     (new File(f, files[i])).delete();
 205                 }
 206             }
 207 
 208             if (! f.delete()) {
 209                 mesg("Warning: unable to delete old log file.");
 210             }
 211         }
 212     }
 213 
 214     /**
 215      * This method is used for adding arguments to rmid (not its VM)
 216      * for passing as VM options to its child group VMs.
 217      * Returns the extra command line arguments required
 218      * to turn on jcov code coverage analysis for rmid child VMs.
 219      */
 220     protected static String getCodeCoverageArgs() {
 221         return TestLibrary.getExtraProperty("rmid.jcov.args","");
 222     }
 223 
 224     /**
 225      * Looks up the activation system in the registry on the given port,
 226      * returning its stub, or null if it's not present. This method differs from
 227      * ActivationGroup.getSystem() because this method looks on a specific port
 228      * instead of using the java.rmi.activation.port property like
 229      * ActivationGroup.getSystem() does. This method also returns null instead
 230      * of throwing exceptions.
 231      */
 232     public static ActivationSystem lookupSystem(int port) {
 233         try {
 234             return (ActivationSystem)LocateRegistry.getRegistry(port).lookup(SYSTEM_NAME);
 235         } catch (RemoteException | NotBoundException ex) {
 236             return null;
 237         }
 238     }
 239 
 240     public static RMID launch() throws IOException {
 241         RMID rmid = null;
 242         for (int i = 0; i < 20; i++) {
 243             RMID.removeLog();
 244             rmid = RMID.createRMID();
 245             try {
 246                 rmid.start();
 247                 break;
 248             } catch (BindException ex) {
 249                 System.err.format("%ncatch BindException(%s), "
 250                         + "continue to launch rmid again...%n%n", ex.getMessage());
 251                 continue;
 252             }
 253         }
 254         return rmid;
 255     }
 256 
 257     /**
 258      * Starts rmid and waits up to the default timeout period
 259      * to confirm that it's running.
 260      */
 261     public void start() throws IOException {
 262         start(STARTTIME_MS);
 263     }
 264 
 265     /**
 266      * Starts rmid and waits up to the given timeout period
 267      * to confirm that it's running.
 268      */
 269     public void start(long waitTime) throws IOException {
 270 
 271         // if rmid is already running, then the test will fail with
 272         // a well recognized exception (port already in use...).
 273 
 274         mesg("Starting rmid on port " + port + ".");
 275         super.start();
 276 
 277         // int slopFactor = 1;
 278         // try {
 279         //     slopFactor = Integer.valueOf(
 280         //         TestLibrary.getExtraProperty("jcov.sleep.multiplier","1"));
 281         // } catch (NumberFormatException ignore) {}
 282         // waitTime = waitTime * slopFactor;
 283 
 284         long startTime = System.currentTimeMillis();
 285         long deadline = TestLibrary.computeDeadline(startTime, waitTime);
 286 
 287         while (true) {
 288             try {
 289                 Thread.sleep(POLLTIME_MS);
 290             } catch (InterruptedException ie) {
 291                 Thread.currentThread().interrupt();
 292                 mesg("Starting rmid interrupted, giving up at " +
 293                     (System.currentTimeMillis() - startTime) + "ms.");
 294                 return;
 295             }
 296 
 297             try {
 298                 checkAddressInUser();
 299                 int status = vm.exitValue();
 300                 TestLibrary.bomb("Rmid process exited with status " + status + " after " +
 301                     (System.currentTimeMillis() - startTime) + "ms.");
 302             } catch (IllegalThreadStateException ignore) { }
 303 
 304             // The rmid process is alive; check to see whether
 305             // it responds to a remote call.
 306 
 307             if (lookupSystem(port) != null) {
 308                 /*
 309                  * We need to set the java.rmi.activation.port value as the
 310                  * activation system will use the property to determine the
 311                  * port #.  The activation system will use this value if set.
 312                  * If it isn't set, the activation system will set it to an
 313                  * incorrect value.
 314                  */
 315                 System.setProperty("java.rmi.activation.port", Integer.toString(port));
 316                 mesg("Started successfully after " +
 317                     (System.currentTimeMillis() - startTime) + "ms.");
 318                 return;
 319             }
 320 
 321             if (System.currentTimeMillis() > deadline) {
 322                 checkAddressInUser();
 323                 TestLibrary.bomb("Failed to start rmid, giving up after " +
 324                     (System.currentTimeMillis() - startTime) + "ms.", null);
 325             }
 326         }
 327     }
 328 
 329     /**
 330      * Destroys rmid and restarts it. Note that this does NOT clean up
 331      * the log file, because it stores information about restartable
 332      * and activatable objects that must be carried over to the new
 333      * rmid instance.
 334      */
 335     public void restart() throws IOException {
 336         destroy();
 337         start();
 338     }
 339 
 340     /**
 341      * Ask rmid to shutdown gracefully using a remote method call.
 342      * catch any errors that might occur from rmid not being present
 343      * at time of shutdown invocation. If the remote call is
 344      * successful, wait for the process to terminate. Return true
 345      * if the process terminated, otherwise return false.
 346      */
 347     private boolean shutdown() throws InterruptedException {
 348         mesg("shutdown()");
 349         long startTime = System.currentTimeMillis();
 350         ActivationSystem system = lookupSystem(port);
 351         if (system == null) {
 352             mesg("lookupSystem() returned null after " +
 353                 (System.currentTimeMillis() - startTime) + "ms.");
 354             return false;
 355         }
 356 
 357         try {
 358             mesg("ActivationSystem.shutdown()");
 359             system.shutdown();
 360         } catch (Exception e) {
 361             mesg("Caught exception from ActivationSystem.shutdown():");
 362             e.printStackTrace();
 363         }
 364 
 365         try {
 366             waitFor(TIMEOUT_SHUTDOWN_MS);
 367             mesg("Shutdown successful after " +
 368                 (System.currentTimeMillis() - startTime) + "ms.");
 369             return true;
 370         } catch (TimeoutException ex) {
 371             mesg("Shutdown timed out after " +
 372                 (System.currentTimeMillis() - startTime) + "ms:");
 373             ex.printStackTrace();
 374             return false;
 375         }
 376     }
 377 
 378     /**
 379      * Ask rmid to shutdown gracefully but then destroy the rmid
 380      * process if it does not exit by itself.  This method only works
 381      * if rmid is a child process of the current VM.
 382      */
 383     public void destroy() {
 384         if (vm == null) {
 385             throw new IllegalStateException("can't wait for RMID that isn't running");
 386         }
 387 
 388         long startTime = System.currentTimeMillis();
 389 
 390         // First, attempt graceful shutdown of the activation system.
 391         try {
 392             if (! shutdown()) {
 393                 // Graceful shutdown failed, use Process.destroy().
 394                 mesg("Destroying RMID process.");
 395                 vm.destroy();
 396                 try {
 397                     waitFor(TIMEOUT_DESTROY_MS);
 398                     mesg("Destroy successful after " +
 399                         (System.currentTimeMillis() - startTime) + "ms.");
 400                 } catch (TimeoutException ex) {
 401                     mesg("Destroy timed out, giving up after " +
 402                         (System.currentTimeMillis() - startTime) + "ms:");
 403                     ex.printStackTrace();
 404                 }
 405             }
 406         } catch (InterruptedException ie) {
 407             mesg("Shutdown/destroy interrupted, giving up at " +
 408                 (System.currentTimeMillis() - startTime) + "ms.");
 409             ie.printStackTrace();
 410             Thread.currentThread().interrupt();
 411             return;
 412         }
 413 
 414         vm = null;
 415     }
 416 
 417     /**
 418      * Shuts down rmid and then removes its log file.
 419      */
 420     public void cleanup() {
 421         destroy();
 422         RMID.removeLog();
 423     }
 424 
 425     /**
 426      * Gets the port on which this rmid is listening.
 427      */
 428     public int getPort() {
 429         return port;
 430     }
 431 }
--- EOF ---