/*
* Copyright (c) 1998, 2013, 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.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/**
*
*/
import java.io.*;
import java.rmi.*;
import java.rmi.activation.*;
/**
* Utility class that creates an instance of rmid with a policy
* file of name <code>TestParams.defaultPolicy</code>.
*
* Activation groups should run with the same security manager as the
* test.
*/
public class RMID extends JavaVM {
public static String MANAGER_OPTION="-Djava.security.manager=";
/** Test port for rmid */
private final int port;
/** Initial log name */
protected static String log = "log";
/** rmid's logfile directory; currently must be "." */
protected static String LOGDIR = ".";
private static void mesg(Object mesg) {
System.err.println("RMID: " + mesg.toString());
}
/** make test options and arguments */
private static String makeOptions(boolean debugExec) {
String options = " -Dsun.rmi.server.activation.debugExec=" +
debugExec;
// +
//" -Djava.compiler= ";
// if test params set, want to propagate them
if (!TestParams.testSrc.equals("")) {
options += " -Dtest.src=" + TestParams.testSrc + " ";
}
//if (!TestParams.testClasses.equals("")) {
// options += " -Dtest.classes=" + TestParams.testClasses + " ";
//}
options += " -Dtest.classes=" + TestParams.testClasses //;
+
" -Djava.rmi.server.logLevel=v ";
// +
// " -Djava.security.debug=all ";
return options;
}
private static String makeArgs(boolean includePortArg, int port) {
String propagateManager = null;
// rmid will run with a security manager set, but no policy
// file - it should not need one.
if (System.getSecurityManager() == null) {
propagateManager = MANAGER_OPTION +
TestParams.defaultSecurityManager;
} else {
propagateManager = MANAGER_OPTION +
System.getSecurityManager().getClass().getName();
}
// getAbsolutePath requires permission to read user.dir
String args =
" -log " + (new File(LOGDIR, log)).getAbsolutePath();
if (includePortArg) {
args += " -port " + port;
}
// +
// " -C-Djava.compiler= ";
// if test params set, want to propagate them
if (!TestParams.testSrc.equals("")) {
args += " -C-Dtest.src=" + TestParams.testSrc;
}
if (!TestParams.testClasses.equals("")) {
args += " -C-Dtest.classes=" + TestParams.testClasses;
}
args += " -C-Djava.rmi.server.useCodebaseOnly=false ";
args += " " + getCodeCoverageArgs();
return args;
}
/**
* Routine that creates an rmid that will run with or without a
* policy file.
*/
public static RMID createRMID() {
return createRMID(System.out, System.err, true);
}
public static RMID createRMID(boolean debugExec) {
return createRMID(System.out, System.err, debugExec);
}
public static RMID createRMID(OutputStream out, OutputStream err) {
return createRMID(out, err, true);
}
public static RMID createRMID(OutputStream out, OutputStream err,
boolean debugExec)
{
return createRMID(out, err, debugExec, true,
TestLibrary.getUnusedRandomPort());
}
public static RMID createRMID(OutputStream out, OutputStream err,
boolean debugExec, boolean includePortArg,
int port)
{
String options = makeOptions(debugExec);
String args = makeArgs(includePortArg, port);
RMID rmid = new RMID("sun.rmi.server.Activation", options, args,
out, err, port);
rmid.setPolicyFile(TestParams.defaultRmidPolicy);
return rmid;
}
/**
* Test RMID should be created with the createRMID method.
*/
protected RMID(String classname, String options, String args,
OutputStream out, OutputStream err, int port)
{
super(classname, options, args, out, err);
this.port = port;
}
public static void removeLog() {
/*
* Remove previous log file directory before
* starting up rmid.
*/
File f = new File(LOGDIR, log);
if (f.exists()) {
mesg("removing rmid's old log file...");
String[] files = f.list();
if (files != null) {
for (int i=0; i<files.length; i++) {
(new File(f, files[i])).delete();
}
}
if (f.delete() != true) {
mesg("\t" + " unable to delete old log file.");
}
}
}
/**
* This method is used for adding arguments to rmid (not its VM)
* for passing as VM options to its child group VMs.
* Returns the extra command line arguments required
* to turn on jcov code coverage analysis for rmid child VMs.
*/
protected static String getCodeCoverageArgs() {
return TestLibrary.getExtraProperty("rmid.jcov.args","");
}
public void start() throws IOException {
start(10000);
}
public void slowStart() throws IOException {
start(60000);
}
public void start(long waitTime) throws IOException {
// if rmid is already running, then the test will fail with
// a well recognized exception (port already in use...).
mesg("starting rmid on port #" + port + "...");
super.start();
int slopFactor = 1;
try {
slopFactor = Integer.valueOf(
TestLibrary.getExtraProperty("jcov.sleep.multiplier","1"));
} catch (NumberFormatException ignore) {}
waitTime = waitTime * slopFactor;
// We check several times (as many as provides passed waitTime) to
// see if Rmid is currently running. Waiting steps last 100 msecs.
final long rmidStartSleepTime = 100;
do {
// Sleeping for another rmidStartSleepTime time slice.
try {
Thread.sleep(Math.min(waitTime, rmidStartSleepTime));
} catch (InterruptedException ie) {
Thread.currentThread().interrupt();
mesg("Thread interrupted while checking for start of Activation System. Giving up check.");
mesg("Activation System state unknown");
return;
}
waitTime -= rmidStartSleepTime;
// Checking if rmid is present
if (ActivationLibrary.rmidRunning(port)) {
/**
* We need to set the java.rmi.activation.port value as the
* activation system will use the property to determine the
* port #. The activation system will use this value if set.
* If it isn't set, the activation system will set it to an
* incorrect value.
*/
System.setProperty("java.rmi.activation.port", Integer.toString(port));
mesg("finished starting rmid.");
return;
}
else {
mesg("rmid still not started");
}
} while (waitTime > 0);
TestLibrary.bomb("start rmid failed... giving up", null);
}
public void restart() throws IOException {
destroy();
start();
}
/**
* Ask rmid to shutdown gracefully using a remote method call.
* catch any errors that might occur from rmid not being present
* at time of shutdown invocation.
*
* Shutdown does not nullify possible references to the rmid
* process object (destroy does though).
*/
public static void shutdown(int port) {
try {
ActivationSystem system = null;
try {
mesg("getting a reference to the activation system");
system = (ActivationSystem) Naming.lookup("//:" +
port +
"/java.rmi.activation.ActivationSystem");
mesg("obtained a reference to the activation system");
} catch (RemoteException re) {
mesg("could not contact registry while trying to shutdown activation system");
} catch (java.net.MalformedURLException mue) {
}
if (system == null) {
TestLibrary.bomb("reference to the activation system was null");
}
system.shutdown();
} catch (RemoteException re) {
mesg("shutting down the activation daemon failed");
} catch (Exception e) {
mesg("caught exception trying to shutdown rmid");
mesg(e.getMessage());
e.printStackTrace();
}
mesg("testlibrary finished shutting down rmid");
}
/**
* Ask rmid to shutdown gracefully but then destroy the rmid
* process if it does not exit by itself. This method only works
* if rmid is a child process of the current VM.
*/
public void destroy() {
// attempt graceful shutdown of the activation system
shutdown(port);
if (vm != null) {
try {
/* Waiting for distant RMID process to shutdown.
* Waiting is bounded at a hardcoded max of 60 secs (1 min).
* Waiting by steps of 200 msecs, thus at most 300 such attempts
* for termination of distant RMID process. If process is not
* known to be terminated properly after that time,
* we give up for a gracefull termination, and thus go for
* forcibly destroying the process.
*/
boolean vmEnded = false;
int waitingTrials = 0;
final int maxTrials = 300;
final long vmProcessEndWaitInterval = 200;
int vmExitValue;
do {
try {
Thread.sleep(vmProcessEndWaitInterval);
waitingTrials++;
vmExitValue = vm.exitValue();
mesg("rmid exited on shutdown request");
vmEnded = true;
} catch (IllegalThreadStateException illegal) {
mesg("RMID's process still not terminated after more than " +
(waitingTrials * vmProcessEndWaitInterval) + " milliseconds");
}
}
while (!vmEnded &&
(waitingTrials < maxTrials));
if (waitingTrials >= maxTrials) {
mesg("RMID's process still not terminated after more than " +
(waitingTrials * vmProcessEndWaitInterval) + " milliseconds." +
"Givinp up gracefull termination...");
mesg("destroying RMID's process using Process.destroy()");
super.destroy();
}
} catch (InterruptedException ie) {
Thread.currentThread().interrupt();
mesg("Thread interrupted while checking for termination of distant rmid vm. Giving up check.");
} catch (Exception e) {
mesg("caught unexpected exception trying to destroy rmid: " +
e.getMessage());
e.printStackTrace();
}
// rmid will not restart if its process is not null
vm = null;
}
}
public int getPort() {return port;}
}