Back to index...

	/*
	* Copyright (c) 1997, 2012, 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. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* 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.
	*/

	package sun.rmi.server;

	import java.io.IOException;
	import java.lang.reflect.Constructor;
	import java.lang.reflect.InvocationTargetException;
	import java.net.ServerSocket;
	import java.rmi.MarshalledObject;
	import java.rmi.NoSuchObjectException;
	import java.rmi.Remote;
	import java.rmi.RemoteException;
	import java.rmi.activation.Activatable;
	import java.rmi.activation.ActivationDesc;
	import java.rmi.activation.ActivationException;
	import java.rmi.activation.ActivationGroup;
	import java.rmi.activation.ActivationGroupID;
	import java.rmi.activation.ActivationID;
	import java.rmi.activation.UnknownObjectException;
	import java.rmi.server.RMIClassLoader;
	import java.rmi.server.RMIServerSocketFactory;
	import java.rmi.server.RMISocketFactory;
	import java.rmi.server.UnicastRemoteObject;
	import java.security.AccessController;
	import java.security.PrivilegedActionException;
	import java.security.PrivilegedExceptionAction;
	import java.util.ArrayList;
	import java.util.Hashtable;
	import java.util.List;
	import sun.rmi.registry.RegistryImpl;

	/**
	* The default activation group implementation.
	*
	* @author Ann Wollrath
	* @since 1.2
	* @see java.rmi.activation.ActivationGroup
	*/
	public class ActivationGroupImpl extends ActivationGroup {

	// use serialVersionUID from JDK 1.2.2 for interoperability
	private static final long serialVersionUID = 5758693559430427303L;

	/** maps persistent IDs to activated remote objects */
	private final Hashtable<ActivationID,ActiveEntry> active =
	new Hashtable<>();
	private boolean groupInactive = false;
	private final ActivationGroupID groupID;
	private final List<ActivationID> lockedIDs = new ArrayList<>();

	/**
	* Creates a default activation group implementation.
	*
	* @param id the group's identifier
	* @param data ignored
	*/
	public ActivationGroupImpl(ActivationGroupID id, MarshalledObject<?> data)
	throws RemoteException
	{
	super(id);
	groupID = id;

	/*
	* Unexport activation group impl and attempt to export it on
	* an unshared anonymous port. See 4692286.
	*/
	unexportObject(this, true);
	RMIServerSocketFactory ssf = new ServerSocketFactoryImpl();
	UnicastRemoteObject.exportObject(this, 0, null, ssf);

	if (System.getSecurityManager() == null) {
	try {
	// Provide a default security manager.
	System.setSecurityManager(new SecurityManager());

	} catch (Exception e) {
	throw new RemoteException("unable to set security manager", e);
	}
	}
	}

	/**
	* Trivial server socket factory used to export the activation group
	* impl on an unshared port.
	*/
	private static class ServerSocketFactoryImpl
	implements RMIServerSocketFactory
	{
	public ServerSocket createServerSocket(int port) throws IOException
	{
	RMISocketFactory sf = RMISocketFactory.getSocketFactory();
	if (sf == null) {
	sf = RMISocketFactory.getDefaultSocketFactory();
	}
	return sf.createServerSocket(port);
	}
	}

	/*
	* Obtains a lock on the ActivationID id before returning. Allows only one
	* thread at a time to hold a lock on a particular id. If the lock for id
	* is in use, all requests for an equivalent (in the Object.equals sense)
	* id will wait for the id to be notified and use the supplied id as the
	* next lock. The caller of "acquireLock" must execute the "releaseLock"
	* method" to release the lock and "notifyAll" waiters for the id lock
	* obtained from this method. The typical usage pattern is as follows:
	*
	* try {
	* acquireLock(id);
	* // do stuff pertaining to id...
	* } finally {
	* releaseLock(id);
	* checkInactiveGroup();
	* }
	*/
	private void acquireLock(ActivationID id) {

	ActivationID waitForID;

	for (;;) {

	synchronized (lockedIDs) {
	int index = lockedIDs.indexOf(id);
	if (index < 0) {
	lockedIDs.add(id);
	return;
	} else {
	waitForID = lockedIDs.get(index);
	}
	}

	synchronized (waitForID) {
	synchronized (lockedIDs) {
	int index = lockedIDs.indexOf(waitForID);
	if (index < 0) continue;
	ActivationID actualID = lockedIDs.get(index);
	if (actualID != waitForID)
	/*
	* don't wait on an id that won't be notified.
	*/
	continue;
	}

	try {
	waitForID.wait();
	} catch (InterruptedException ignore) {
	}
	}
	}

	}

	/*
	* Releases the id lock obtained via the "acquireLock" method and then
	* notifies all threads waiting on the lock.
	*/
	private void releaseLock(ActivationID id) {
	synchronized (lockedIDs) {
	id = lockedIDs.remove(lockedIDs.indexOf(id));
	}

	synchronized (id) {
	id.notifyAll();
	}
	}

	/**
	* Creates a new instance of an activatable remote object. The
	* <code>Activator</code> calls this method to create an activatable
	* object in this group. This method should be idempotent; a call to
	* activate an already active object should return the previously
	* activated object.
	*
	* Note: this method assumes that the Activator will only invoke
	* newInstance for the same object in a serial fashion (i.e.,
	* the activator will not allow the group to see concurrent requests
	* to activate the same object.
	*
	* @param id the object's activation identifier
	* @param desc the object's activation descriptor
	* @return a marshalled object containing the activated object's stub
	*/
	public MarshalledObject<? extends Remote>
	newInstance(final ActivationID id,
	final ActivationDesc desc)
	throws ActivationException, RemoteException
	{
	RegistryImpl.checkAccess("ActivationInstantiator.newInstance");

	if (!groupID.equals(desc.getGroupID()))
	throw new ActivationException("newInstance in wrong group");

	try {
	acquireLock(id);
	synchronized (this) {
	if (groupInactive == true)
	throw new InactiveGroupException("group is inactive");
	}

	ActiveEntry entry = active.get(id);
	if (entry != null)
	return entry.mobj;

	String className = desc.getClassName();

	final Class<? extends Remote> cl =
	RMIClassLoader.loadClass(desc.getLocation(), className)
	.asSubclass(Remote.class);
	Remote impl = null;

	final Thread t = Thread.currentThread();
	final ClassLoader savedCcl = t.getContextClassLoader();
	ClassLoader objcl = cl.getClassLoader();
	final ClassLoader ccl = covers(objcl, savedCcl) ? objcl : savedCcl;

	/*
	* Fix for 4164971: allow non-public activatable class
	* and/or constructor, create the activatable object in a
	* privileged block
	*/
	try {
	/*
	* The code below is in a doPrivileged block to
	* protect against user code which code might have set
	* a global socket factory (in which case application
	* code would be on the stack).
	*/
	impl = AccessController.doPrivileged(
	new PrivilegedExceptionAction<Remote>() {
	public Remote run() throws InstantiationException,
	NoSuchMethodException, IllegalAccessException,
	InvocationTargetException
	{
	Constructor<? extends Remote> constructor =
	cl.getDeclaredConstructor(
	ActivationID.class, MarshalledObject.class);
	constructor.setAccessible(true);
	try {
	/*
	* Fix for 4289544: make sure to set the
	* context class loader to be the class
	* loader of the impl class before
	* constructing that class.
	*/
	t.setContextClassLoader(ccl);
	return constructor.newInstance(id,
	desc.getData());
	} finally {
	t.setContextClassLoader(savedCcl);
	}
	}
	});
	} catch (PrivilegedActionException pae) {
	Throwable e = pae.getException();

	// narrow the exception's type and rethrow it
	if (e instanceof InstantiationException) {
	throw (InstantiationException) e;
	} else if (e instanceof NoSuchMethodException) {
	throw (NoSuchMethodException) e;
	} else if (e instanceof IllegalAccessException) {
	throw (IllegalAccessException) e;
	} else if (e instanceof InvocationTargetException) {
	throw (InvocationTargetException) e;
	} else if (e instanceof RuntimeException) {
	throw (RuntimeException) e;
	} else if (e instanceof Error) {
	throw (Error) e;
	}
	}

	entry = new ActiveEntry(impl);
	active.put(id, entry);
	return entry.mobj;

	} catch (NoSuchMethodException \| NoSuchMethodError e) {
	/* user forgot to provide activatable constructor?
	* or code recompiled and user forgot to provide
	* activatable constructor?
	*/
	throw new ActivationException
	("Activatable object must provide an activation"+
	" constructor", e );

	} catch (InvocationTargetException e) {
	throw new ActivationException("exception in object constructor",
	e.getTargetException());

	} catch (Exception e) {
	throw new ActivationException("unable to activate object", e);
	} finally {
	releaseLock(id);
	checkInactiveGroup();
	}
	}


	/**
	* The group's <code>inactiveObject</code> method is called
	* indirectly via a call to the <code>Activatable.inactive</code>
	* method. A remote object implementation must call
	* <code>Activatable</code>'s <code>inactive</code> method when
	* that object deactivates (the object deems that it is no longer
	* active). If the object does not call
	* <code>Activatable.inactive</code> when it deactivates, the
	* object will never be garbage collected since the group keeps
	* strong references to the objects it creates. <p>
	*
	* The group's <code>inactiveObject</code> method
	* unexports the remote object from the RMI runtime so that the
	* object can no longer receive incoming RMI calls. This call will
	* only succeed if the object has no pending/executing calls. If
	* the object does have pending/executing RMI calls, then false
	* will be returned.
	*
	* If the object has no pending/executing calls, the object is
	* removed from the RMI runtime and the group informs its
	* <code>ActivationMonitor</code> (via the monitor's
	* <code>inactiveObject</code> method) that the remote object is
	* not currently active so that the remote object will be
	* re-activated by the activator upon a subsequent activation
	* request.
	*
	* @param id the object's activation identifier
	* @returns true if the operation succeeds (the operation will
	* succeed if the object in currently known to be active and is
	* either already unexported or is currently exported and has no
	* pending/executing calls); false is returned if the object has
	* pending/executing calls in which case it cannot be deactivated
	* @exception UnknownObjectException if object is unknown (may already
	* be inactive)
	* @exception RemoteException if call informing monitor fails
	*/
	public boolean inactiveObject(ActivationID id)
	throws ActivationException, UnknownObjectException, RemoteException
	{

	try {
	acquireLock(id);
	synchronized (this) {
	if (groupInactive == true)
	throw new ActivationException("group is inactive");
	}

	ActiveEntry entry = active.get(id);
	if (entry == null) {
	// REMIND: should this be silent?
	throw new UnknownObjectException("object not active");
	}

	try {
	if (Activatable.unexportObject(entry.impl, false) == false)
	return false;
	} catch (NoSuchObjectException allowUnexportedObjects) {
	}

	try {
	super.inactiveObject(id);
	} catch (UnknownObjectException allowUnregisteredObjects) {
	}

	active.remove(id);

	} finally {
	releaseLock(id);
	checkInactiveGroup();
	}

	return true;
	}

	/*
	* Determines if the group has become inactive and
	* marks it as such.
	*/
	private void checkInactiveGroup() {
	boolean groupMarkedInactive = false;
	synchronized (this) {
	if (active.size() == 0 && lockedIDs.size() == 0 &&
	groupInactive == false)
	{
	groupInactive = true;
	groupMarkedInactive = true;
	}
	}

	if (groupMarkedInactive) {
	try {
	super.inactiveGroup();
	} catch (Exception ignoreDeactivateFailure) {
	}

	try {
	UnicastRemoteObject.unexportObject(this, true);
	} catch (NoSuchObjectException allowUnexportedGroup) {
	}
	}
	}

	/**
	* The group's <code>activeObject</code> method is called when an
	* object is exported (either by <code>Activatable</code> object
	* construction or an explicit call to
	* <code>Activatable.exportObject</code>. The group must inform its
	* <code>ActivationMonitor</code> that the object is active (via
	* the monitor's <code>activeObject</code> method) if the group
	* hasn't already done so.
	*
	* @param id the object's identifier
	* @param obj the remote object implementation
	* @exception UnknownObjectException if object is not registered
	* @exception RemoteException if call informing monitor fails
	*/
	public void activeObject(ActivationID id, Remote impl)
	throws ActivationException, UnknownObjectException, RemoteException
	{

	try {
	acquireLock(id);
	synchronized (this) {
	if (groupInactive == true)
	throw new ActivationException("group is inactive");
	}
	if (!active.contains(id)) {
	ActiveEntry entry = new ActiveEntry(impl);
	active.put(id, entry);
	// created new entry, so inform monitor of active object
	try {
	super.activeObject(id, entry.mobj);
	} catch (RemoteException e) {
	// daemon can still find it by calling newInstance
	}
	}
	} finally {
	releaseLock(id);
	checkInactiveGroup();
	}
	}

	/**
	* Entry in table for active object.
	*/
	private static class ActiveEntry {
	Remote impl;
	MarshalledObject<Remote> mobj;

	ActiveEntry(Remote impl) throws ActivationException {
	this.impl = impl;
	try {
	this.mobj = new MarshalledObject<Remote>(impl);
	} catch (IOException e) {
	throw new
	ActivationException("failed to marshal remote object", e);
	}
	}
	}

	/**
	* 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.
	*/
	private 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;
	}
	}

Back to index...