test/java/rmi/activation/Activatable/shutdownGracefully/ShutdownGracefully.java
Print this page
*** 1,7 ****
/*
! * Copyright (c) 1999, 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.
--- 1,7 ----
/*
! * 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,30 ****
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/* @test
! * @bug 4183169
* @summary Minor problem with the way ReliableLog handles IOExceptions.
*
* @author Laird Dornin; code borrowed from Ann Wollrath
*
* @library ../../../testlibrary
--- 20,30 ----
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/* @test
! * @bug 4183169 8032050
* @summary Minor problem with the way ReliableLog handles IOExceptions.
*
* @author Laird Dornin; code borrowed from Ann Wollrath
*
* @library ../../../testlibrary
*** 34,43 ****
--- 34,44 ----
*/
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,59 ****
* 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
{
private static RegisteringActivatable registering = null;
private final static long SHUTDOWN_TIMEOUT = 400 * 1000;
--- 50,60 ----
* 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 RegisteringActivatable
{
private static RegisteringActivatable registering = null;
private final static long SHUTDOWN_TIMEOUT = 400 * 1000;
*** 130,233 ****
ActivationGroupID secondGroupID =
system.registerGroup(groupDesc);
desc = new ActivationDesc(secondGroupID,
"ShutdownGracefully", null, null);
try {
registering = (RegisteringActivatable)
Activatable.register(desc);
! System.err.println("second activate and deactivate " +
! "object via method call");
} 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) {
! 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");
! }
! }
! } 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();
}
}
/**
* implementation of RegisteringActivatable
--- 131,166 ----
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.
+ */
+ boolean isRegisterSucceed = false;
try {
registering = (RegisteringActivatable)
Activatable.register(desc);
! isRegisterSucceed = true;
} catch (ActivationException e) {
System.err.println("received exception from registration " +
"call that should have failed...");
}
! int exitCode = rmid.waitFor(SHUTDOWN_TIMEOUT);
! System.err.println("RMID has exited gracefully with exitcode:" + exitCode);
! rmid = null;
! if(isRegisterSucceed)
! TestLibrary.bomb("\nfailure: The registration request succeeded unexpectedly");
! } catch (TimeoutException e) {
! TestLibrary.bomb("\nfailure: RMID hasn't exited gracefuuly in expected time");
} catch (Exception e) {
TestLibrary.bomb("\nfailure: unexpected exception ", e);
} finally {
! if (rmid != null)
! rmid.destroy();
}
}
/**
* implementation of RegisteringActivatable
*** 238,262 ****
// register/export anonymously
super(id, 0);
}
/**
! * Spawns a thread to deactivate the object.
*/
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) {
! }
ActivationLibrary.deactivate(this, getID());
}
}
--- 171,184 ----
// register/export anonymously
super(id, 0);
}
/**
! * 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 {
! Activatable.unexportObject(this, true);
ActivationLibrary.deactivate(this, getID());
}
}