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