/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
*
*/
import com.sun.jini.jeri.internal.runtime.Util;
import java.io.File;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.rmi.Naming;
import java.rmi.NoSuchObjectException;
import java.rmi.Remote;
import java.rmi.RemoteException;
import java.rmi.MarshalledObject;
import java.rmi.activation.Activatable;
import java.rmi.activation.ActivationDesc;
import java.rmi.activation.ActivationException;
import java.rmi.activation.ActivationID;
import java.rmi.server.ExportException;
import java.rmi.server.RMIClassLoader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import net.jini.activation.ActivatableInvocationHandler;
import net.jini.activation.ActivationExporter;
import net.jini.activation.ActivationGroup;
import net.jini.core.constraint.RemoteMethodControl;
import net.jini.export.Exporter;
import net.jini.jeri.BasicILFactory;
import net.jini.jeri.BasicJeriExporter;
import net.jini.jeri.tcp.TcpServerEndpoint;
import net.jini.jrmp.JrmpExporter;
import net.jini.security.proxytrust.ProxyTrust;
import net.jini.security.proxytrust.TrustEquivalence;
/**
* Class of test utility/library methods related to Activatable
* objects.
*/
public class ActivationLibrary {
/** time safeDestroy should wait before failing on shutdown rmid */
final static int SAFE_WAIT_TIME = 60000;
static void mesg(Object mesg) {
System.err.println("ACTIVATION_LIBRARY: " + mesg.toString());
}
/**
* Deactivate an activated Activatable
*/
public static void deactivate(Remote remote, ActivationID id) {
deactivate(remote, id, null);
}
/**
* Deactivates an activated object. If exporter is null, then
* deactivate using pre 1.4-APIs; otherwise use the new 1.4
* API.
*/
public static void deactivate(Remote remote,
ActivationID id,
Exporter exporter)
{
int i = 0;
do {
i++;
try {
boolean success =
((exporter == null) ?
Activatable.inactive(id) :
ActivationGroup.inactive(id, exporter));
if (success) {
mesg("inactive successful");
return;
} else {
Thread.sleep(1000);
}
} catch (InterruptedException e) {
continue;
} catch (Exception e) {
e.printStackTrace();
break;
}
} while (i < 5);
mesg("giving up on deactivation after " + i + " attempts");
mesg("unexporting object forcibly instead");
forcedUnexport(remote, exporter);
}
/**
* Forcibly unexports the object.
*/
public static void forcedUnexport(Remote remote, Exporter exporter) {
try {
// forcibly unexport the object
if (exporter == null) {
Activatable.unexportObject(remote, true);
} else {
exporter.unexport(true);
}
} catch (NoSuchObjectException ex) {
}
}
/**
* Simple method call to see if rmid is running.
*
* This method intentionally avoids performing a lookup on the
* activation system.
*/
public static boolean rmidRunning(int port) {
int allowedNotReady = 10;
int connectionRefusedExceptions = 0;
for (int i = 0; i < 15 ; i++) {
try {
Thread.sleep(500);
if (containsString(Naming.list("//:" + port ),
"java.rmi.activation.ActivationSystem"))
{
return true;
}
} catch (java.rmi.ConnectException ce) {
// ignore connect exceptions until we decide rmid is not up
if ((connectionRefusedExceptions ++) >= allowedNotReady) {
return false;
}
} catch (Exception e) {
// print out other types of exceptions as an FYI.
// test should not fail as rmid is likely to be in an
// undetermined state at this point.
mesg("caught an exception trying to" +
" start rmid, last exception was: " +
e.getMessage());
e.printStackTrace();
}
}
return false;
}
/**
* Check to see if an arry of Strings contains a given string.
*/
private static boolean
containsString(String[] strings, String contained)
{
if (strings == null) {
if (contained == null) {
return true;
}
return false;
}
for (int i = 0 ; i < strings.length ; i ++ ) {
if ((strings[i] != null) &&
(strings[i].indexOf(contained) >= 0))
{
return true;
}
}
return false;
}
/** cleanup after rmid */
public static void rmidCleanup(RMID rmid) {
if (rmid != null) {
if (!ActivationLibrary.safeDestroy(rmid,
SAFE_WAIT_TIME))
{
TestLibrary.bomb("rmid not destroyed in: " +
SAFE_WAIT_TIME +
" milliseconds");
}
}
RMID.removeLog();
}
/**
* Invoke shutdown on rmid in a way that will not cause a test
* to hang.
*
* @return whether or not shutdown completed succesfully in the
* timeAllowed
*/
public static boolean safeDestroy(RMID rmid, long timeAllowed) {
DestroyThread destroyThread = new DestroyThread(rmid);
destroyThread.start();
try {
destroyThread.join(timeAllowed);
} catch (InterruptedException ie) {
Thread.currentThread().interrupt();
}
return destroyThread.shutdownSucceeded();
}
/**
* Thread class to handle the destruction of rmid
*/
static class DestroyThread extends Thread {
RMID rmid = null;
boolean succeeded = false;
DestroyThread(RMID rmid) {
this.rmid = rmid;
this.setDaemon(true);
}
public void run() {
if (ActivationLibrary.
rmidRunning(TestLibrary.RMID_PORT))
{
rmid.destroy();
synchronized (this) {
// flag that the test was able to shutdown rmid
succeeded = true;
}
mesg("finished destroying rmid");
} else {
mesg("tried to shutdown when rmid was not running");
}
}
public synchronized boolean shutdownSucceeded() {
return succeeded;
}
}
public static Remote createProxy(ActivationID id, ActivationDesc desc)
{
try {
Class cl = RMIClassLoader.loadClass(desc.getLocation(),
desc.getClassName());
Class[] remoteInterfaces = Util.getRemoteInterfaces(cl);
InvocationHandler handler =
new ActivatableInvocationHandler(id, null);
return (Remote) newProxyInstance(null, remoteInterfaces, handler);
} catch (Exception e) {
throw (RuntimeException)
new RuntimeException("proxy creation failed").initCause(e);
}
}
public static Remote createSecureProxy(ActivationID id,
ActivationDesc desc)
{
try {
Class cl = RMIClassLoader.loadClass(desc.getLocation(),
desc.getClassName());
Class[] remoteInterfaces = Util.getRemoteInterfaces(cl);
List list = new ArrayList(Arrays.asList(remoteInterfaces));
if (list.remove(ProxyTrust.class)) {
remoteInterfaces =
(Class[]) list.toArray(new Class[list.size()]);
}
InvocationHandler handler =
new ActivatableInvocationHandler(id, null);
return (Remote) newProxyInstance(remoteInterfaces,
new Class[]{
RemoteMethodControl.class,
TrustEquivalence.class},
handler);
} catch (Exception e) {
throw (RuntimeException)
new RuntimeException("proxy creation failed").initCause(e);
}
}
/**
* Returns a proxy that implements the concatenation of the specified
* interfaces, containing the specified invocation handler.
*/
public static Remote newProxyInstance(Class[] ifs1,
Class[] ifs2,
InvocationHandler ih)
{
Class[] ifs = combineInterfaces(ifs1, ifs2);
return (Remote) Proxy.newProxyInstance(pickClassLoader(ifs), ifs, ih);
}
/**
* Returns a concatenated array of the interfaces in i1 and i2.
*/
public static Class[] combineInterfaces(Class[] i1, Class[] i2) {
if (i1 == null) {
return i2;
} else if (i2 == null) {
return i1;
} else {
Class[] interfaces = new Class[i1.length + i2.length];
System.arraycopy(i1, 0, interfaces, 0, i1.length);
System.arraycopy(i2, 0, interfaces, i1.length, i2.length);
return interfaces;
}
}
/**
* Returns the preferred classloader to use for defining a proxy class
* that implements all of the specified interfaces.
*/
private static ClassLoader pickClassLoader(Class[] ifs) {
outer:
for (int i = ifs.length; --i >= 0; ) {
ClassLoader l = ifs[i].getClassLoader();
for (int j = ifs.length; --j >= 0; ) {
if (!covers(l, ifs[j].getClassLoader())) {
continue outer;
}
}
return l;
}
throw new IllegalArgumentException(
"no classloader covers all interfaces");
}
/**
* Returns true if the first argument is either equal to, or is a
* descendant of, the second argument. Null is treated as the root of
* the tree.
*/
public static boolean covers(ClassLoader sub, ClassLoader sup) {
if (sup == null) {
return true;
} else if (sub == null) {
return false;
}
do {
if (sub == sup) {
return true;
}
sub = sub.getParent();
} while (sub != null);
return false;
}
public static Remote register(String exportType, ActivationDesc desc)
throws ActivationException, RemoteException
{
if (exportType.equals("default")) {
return Activatable.register(desc);
} else {
ActivationID id =
ActivationGroup.getSystem().registerObject(desc);
if (exportType.equals("basic")) {
return createSecureProxy(id, desc);
} else if (exportType.equals("jrmp")) {
return createProxy(id, desc);
} else {
throw new ActivationException("unknown exportType");
}
}
}
public static class ExportHelper implements Runnable {
private final String exportType;
private final ActivationID id;
private final Remote impl;
private Remote stub;
private Exporter exporter = null;
public ExportHelper(MarshalledObject mobj,
Remote impl,
ActivationID id)
throws ActivationException
{
try {
this.exportType = (String) mobj.get();
} catch (Exception e) {
throw new ActivationException(
"MarshalledObject.get failed", e);
}
this.impl = impl;
this.id = id;
}
public ExportHelper(String exportType,
Remote impl,
ActivationID id)
throws ActivationException
{
this.exportType = exportType;
this.impl = impl;
this.id = id;
}
public Remote export() throws RemoteException {
if (exportType.equals("default")) {
stub = Activatable.exportObject(impl, id, 0);
} else {
Exporter uexporter;
if (exportType.equals("basic")) {
uexporter = new
BasicJeriExporter(TcpServerEndpoint.getInstance(0),
new BasicILFactory(),
true, true);
} else if (exportType.equals("jrmp")) {
uexporter = new JrmpExporter();
} else {
throw new ExportException("unknown exportType");
}
exporter = new ActivationExporter(id, uexporter);
stub = exporter.export(impl);
}
System.err.println("stub = " + stub.toString());
return stub;
}
public Remote getStub() {
return stub;
}
public ActivationID getActivationID() {
return id;
}
public void deactivate() {
(new Thread(this, "ExportHelper")).start();
}
public void run() {
ActivationLibrary.deactivate(impl, id, exporter);
}
}
}