2006-05-18 19:29:21 +02:00
|
|
|
/* ActivationGroup.java -- the RMI activation group.
|
|
|
|
Copyright (c) 1996, 1997, 1998, 1999, 2006 Free Software Foundation, Inc.
|
2005-07-16 02:30:23 +02:00
|
|
|
|
|
|
|
This file is part of GNU Classpath.
|
|
|
|
|
|
|
|
GNU Classpath is free software; you can redistribute it and/or modify
|
|
|
|
it under the terms of the GNU General Public License as published by
|
|
|
|
the Free Software Foundation; either version 2, or (at your option)
|
|
|
|
any later version.
|
|
|
|
|
|
|
|
GNU Classpath 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 for more details.
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
along with GNU Classpath; see the file COPYING. If not, write to the
|
|
|
|
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
|
|
|
|
02110-1301 USA.
|
|
|
|
|
|
|
|
Linking this library statically or dynamically with other modules is
|
|
|
|
making a combined work based on this library. Thus, the terms and
|
|
|
|
conditions of the GNU General Public License cover the whole
|
|
|
|
combination.
|
|
|
|
|
|
|
|
As a special exception, the copyright holders of this library give you
|
|
|
|
permission to link this library with independent modules to produce an
|
|
|
|
executable, regardless of the license terms of these independent
|
|
|
|
modules, and to copy and distribute the resulting executable under
|
|
|
|
terms of your choice, provided that you also meet, for each linked
|
|
|
|
independent module, the terms and conditions of the license of that
|
|
|
|
module. An independent module is a module which is not derived from
|
|
|
|
or based on this library. If you modify this library, you may extend
|
|
|
|
this exception to your version of the library, but you are not
|
|
|
|
obligated to do so. If you do not wish to do so, delete this
|
|
|
|
exception statement from your version. */
|
|
|
|
|
|
|
|
|
|
|
|
package java.rmi.activation;
|
|
|
|
|
2006-05-18 19:29:21 +02:00
|
|
|
import gnu.java.rmi.activation.DefaultActivationGroup;
|
|
|
|
import gnu.java.rmi.activation.DefaultActivationSystem;
|
|
|
|
|
|
|
|
import java.lang.reflect.Constructor;
|
2005-07-16 02:30:23 +02:00
|
|
|
import java.rmi.MarshalledObject;
|
|
|
|
import java.rmi.Remote;
|
|
|
|
import java.rmi.RemoteException;
|
|
|
|
import java.rmi.server.UnicastRemoteObject;
|
|
|
|
|
2006-05-18 19:29:21 +02:00
|
|
|
/**
|
|
|
|
* The entity that receives the request to activate object and activates it.
|
|
|
|
* Frequently there is one activation group per virtual machine.
|
|
|
|
*
|
|
|
|
* @author Audrius Meskauskas (audriusa@Bioinformatics.org) (from stub)
|
|
|
|
*/
|
|
|
|
public abstract class ActivationGroup
|
|
|
|
extends UnicastRemoteObject
|
|
|
|
implements ActivationInstantiator
|
2005-07-16 02:30:23 +02:00
|
|
|
{
|
|
|
|
|
2006-05-18 19:29:21 +02:00
|
|
|
/**
|
|
|
|
* Use the SVUID for interoperability.
|
|
|
|
*/
|
|
|
|
static final long serialVersionUID = - 7696947875314805420L;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* The Id of the current group on this VM (null if none).
|
|
|
|
*/
|
|
|
|
static ActivationGroupID currentGroupId = null;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* The groups identifier.
|
|
|
|
*/
|
|
|
|
final ActivationGroupID groupId;
|
2005-07-16 02:30:23 +02:00
|
|
|
|
2006-05-18 19:29:21 +02:00
|
|
|
/**
|
|
|
|
* The groups activation monitor.
|
|
|
|
*/
|
|
|
|
ActivationMonitor monitor;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* The groups incarnation number.
|
|
|
|
*/
|
|
|
|
long incarnation;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* The groups activation system.
|
|
|
|
*/
|
|
|
|
static ActivationSystem system;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Used during the group creation (required constructor).
|
|
|
|
*/
|
|
|
|
static final Class[] cConstructorTypes = new Class[]
|
|
|
|
{
|
|
|
|
ActivationGroupID.class,
|
|
|
|
MarshalledObject.class
|
|
|
|
};
|
2005-07-16 02:30:23 +02:00
|
|
|
|
2006-05-18 19:29:21 +02:00
|
|
|
/**
|
|
|
|
* Create the new activation group with the given group id.
|
|
|
|
*
|
|
|
|
* @param aGroupId the group Id.
|
|
|
|
*
|
|
|
|
* @throws RemoteException if the group export fails.
|
|
|
|
*/
|
|
|
|
protected ActivationGroup(ActivationGroupID aGroupId) throws RemoteException
|
|
|
|
{
|
|
|
|
groupId = aGroupId;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* The method is called when the object is exported. The group must notify
|
|
|
|
* the activation monitor, if this was not already done before.
|
|
|
|
*
|
|
|
|
* @param id the object activation id
|
|
|
|
* @param obj the remote object implementation
|
|
|
|
*
|
|
|
|
* @throws ActivationException if the group is inactive
|
|
|
|
* @throws UnknownObjectException if such object is not known
|
|
|
|
* @throws RemoteException if the call to monitor fails
|
|
|
|
*/
|
|
|
|
public abstract void activeObject(ActivationID id, Remote obj)
|
|
|
|
throws ActivationException, UnknownObjectException, RemoteException;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Notifies the monitor about the object being inactivated.
|
|
|
|
*
|
|
|
|
* @param id the object being inactivated.
|
|
|
|
* @return true always (must be overridden to return other values).
|
|
|
|
* @throws ActivationException never
|
|
|
|
* @throws UnknownObjectException if the object is not known
|
|
|
|
* @throws RemoteException if the remote call to monitor fails
|
|
|
|
*/
|
|
|
|
public boolean inactiveObject(ActivationID id) throws ActivationException,
|
|
|
|
UnknownObjectException, RemoteException
|
|
|
|
{
|
|
|
|
if (monitor != null)
|
|
|
|
monitor.inactiveObject(id);
|
|
|
|
return true;
|
|
|
|
}
|
2005-07-16 02:30:23 +02:00
|
|
|
|
2006-05-18 19:29:21 +02:00
|
|
|
/**
|
|
|
|
* Create the new instance of the activation group, using the class name and
|
|
|
|
* location information, stored in the passed descriptor. The method expects
|
|
|
|
* the group class to have the two parameter constructor, the first parameter
|
|
|
|
* being the {@link ActivationGroupID} and the second the
|
|
|
|
* {@link MarshalledObject}. The group must be first be registered with the
|
|
|
|
* ActivationSystem. Once a group is created, the currentGroupID method
|
|
|
|
* returns the identifier for this group until the group becomes inactive.
|
|
|
|
*
|
|
|
|
* @param id the activation group id
|
|
|
|
* @param desc the group descriptor, providing the information, necessary to
|
|
|
|
* create the group
|
|
|
|
* @param incarnation the incarnation number
|
|
|
|
* @return the created group instance
|
|
|
|
* @throws ActivationException if the activation fails due any reason
|
|
|
|
*/
|
|
|
|
public static ActivationGroup createGroup(ActivationGroupID id,
|
|
|
|
ActivationGroupDesc desc,
|
|
|
|
long incarnation)
|
|
|
|
throws ActivationException
|
|
|
|
{
|
|
|
|
// If the activation system is not yet set, set it to the system.
|
|
|
|
// passed in the group id.
|
|
|
|
if (system == null)
|
|
|
|
system = id.system;
|
|
|
|
|
|
|
|
ActivationGroup group = null;
|
2005-07-16 02:30:23 +02:00
|
|
|
|
2006-05-18 19:29:21 +02:00
|
|
|
// TODO at the moment all groups are created on the current jre and the
|
|
|
|
// group class must be reachable via thread context class loader.
|
|
|
|
Class groupClass;
|
2005-07-16 02:30:23 +02:00
|
|
|
|
2006-05-18 19:29:21 +02:00
|
|
|
if (desc.className != null)
|
|
|
|
{
|
|
|
|
try
|
|
|
|
{
|
|
|
|
ClassLoader loader = Thread.currentThread().getContextClassLoader();
|
|
|
|
groupClass = loader.loadClass(desc.className);
|
|
|
|
}
|
|
|
|
catch (ClassNotFoundException e)
|
|
|
|
{
|
|
|
|
ActivationException acex = new ActivationException(
|
|
|
|
"Cannot load " + desc.className);
|
|
|
|
acex.detail = e;
|
|
|
|
throw acex;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
groupClass = DefaultActivationGroup.class;
|
2005-07-16 02:30:23 +02:00
|
|
|
|
2006-05-18 19:29:21 +02:00
|
|
|
try
|
|
|
|
{
|
|
|
|
Constructor constructor = groupClass.getConstructor(cConstructorTypes);
|
|
|
|
group = (ActivationGroup) constructor.newInstance(
|
|
|
|
new Object[] { id, desc.data });
|
|
|
|
}
|
|
|
|
catch (Exception e)
|
|
|
|
{
|
|
|
|
ActivationException acex = new ActivationException(
|
|
|
|
"Cannot instantiate " + desc.className);
|
|
|
|
acex.detail = e;
|
|
|
|
throw acex;
|
|
|
|
}
|
2005-07-16 02:30:23 +02:00
|
|
|
|
2006-05-18 19:29:21 +02:00
|
|
|
currentGroupId = id;
|
|
|
|
try
|
|
|
|
{
|
|
|
|
group.monitor = getSystem().activeGroup(id, group, incarnation);
|
|
|
|
return group;
|
|
|
|
}
|
|
|
|
catch (RemoteException e)
|
|
|
|
{
|
|
|
|
ActivationException acex = new ActivationException("createGroup");
|
|
|
|
acex.detail = e;
|
|
|
|
throw acex;
|
|
|
|
}
|
|
|
|
}
|
2005-07-16 02:30:23 +02:00
|
|
|
|
2006-05-18 19:29:21 +02:00
|
|
|
/**
|
|
|
|
* Get the id of current activation group.
|
|
|
|
*
|
|
|
|
* @return the id of the current activation group or null if none exists.
|
|
|
|
*/
|
|
|
|
public static ActivationGroupID currentGroupID()
|
|
|
|
{
|
|
|
|
try
|
|
|
|
{
|
|
|
|
if (currentGroupId==null)
|
|
|
|
{
|
|
|
|
// This will also assing the currentGroupId to the current
|
|
|
|
// (default) group of the default system.
|
|
|
|
setSystem(DefaultActivationSystem.get());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
catch (ActivationException e)
|
|
|
|
{
|
|
|
|
InternalError ierr = new InternalError("Unable to activate AS");
|
|
|
|
ierr.initCause(e);
|
|
|
|
throw ierr;
|
|
|
|
}
|
|
|
|
|
|
|
|
return currentGroupId;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Set the activation system for this virtual machine. The system can only
|
|
|
|
* be set if no group is active.
|
|
|
|
*
|
|
|
|
* @param aSystem the system to set
|
|
|
|
*
|
|
|
|
* @throws ActivationException if some group is active now.
|
|
|
|
*/
|
|
|
|
public static void setSystem(ActivationSystem aSystem)
|
|
|
|
throws ActivationException
|
|
|
|
{
|
|
|
|
if (currentGroupId!=null)
|
|
|
|
throw new ActivationException("Group active");
|
|
|
|
else
|
|
|
|
{
|
|
|
|
try
|
|
|
|
{
|
|
|
|
// Register the default transient activation system and group.
|
|
|
|
system = aSystem;
|
|
|
|
ActivationGroupDesc def = new ActivationGroupDesc(
|
|
|
|
DefaultActivationGroup.class.getName(),
|
|
|
|
"",
|
|
|
|
null,
|
|
|
|
null,
|
|
|
|
null);
|
|
|
|
currentGroupId = system.registerGroup(def);
|
|
|
|
}
|
|
|
|
catch (Exception ex)
|
|
|
|
{
|
|
|
|
InternalError ierr = new InternalError("Unable to start default AG");
|
|
|
|
ierr.initCause(ex);
|
|
|
|
throw ierr;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the current activation system. If the system is not set via
|
|
|
|
* {@link #setSystem} method, the default system for this virtual machine is
|
|
|
|
* returned. The default system is first searched by name
|
|
|
|
* "java.rmi.activation.ActivationSystem" on the activation registry port. The
|
|
|
|
* default value of the activation registry port is
|
|
|
|
* {@link ActivationSystem#SYSTEM_PORT}, but it can be changed by putting the
|
|
|
|
* system property java.rmi.activation.port. Both activation system and
|
|
|
|
* activation registry are provided by the RMI daemon tool, RMID, if it is
|
|
|
|
* running on the local host. If the RMID is not running, the internal
|
|
|
|
* transient activation system will be created and returned. This internal
|
|
|
|
* system is highly limited in in capabilities and is not intended to be used
|
|
|
|
* anywhere apart automated testing.
|
|
|
|
*
|
|
|
|
* @return the activation system for this virtual machine
|
|
|
|
* @throws ActivationException
|
|
|
|
*/
|
|
|
|
public static ActivationSystem getSystem() throws ActivationException
|
|
|
|
{
|
|
|
|
if (system == null)
|
|
|
|
system = DefaultActivationSystem.get();
|
|
|
|
return system;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Makes the call back to the groups {@link ActivationMonitor}.
|
|
|
|
*
|
|
|
|
* @param id the id obj the object being activated
|
|
|
|
* @param mObject the marshalled object, contains the activated remote object
|
|
|
|
* stub.
|
|
|
|
* @throws ActivationException on activation error
|
|
|
|
* @throws UnknownObjectException if such object is not registered
|
|
|
|
* @throws RemoteException on remote call (to monitor) error
|
|
|
|
*/
|
Import GNU Classpath (libgcj-import-20070727).
libjava/
2007-08-04 Matthias Klose <doko@ubuntu.com>
Import GNU Classpath (libgcj-import-20070727).
* Regenerate class and header files.
* Regenerate auto* files.
* include/jvm.h:
* jni-libjvm.cc (Jv_JNI_InvokeFunctions): Rename type.
* jni.cc (_Jv_JNIFunctions, _Jv_JNI_InvokeFunctions): Likewise.
* jni.cc (_Jv_JNI_CallAnyMethodA, _Jv_JNI_CallAnyVoidMethodA,
_Jv_JNI_CallMethodA, _Jv_JNI_CallVoidMethodA,
_Jv_JNI_CallStaticMethodA, _Jv_JNI_CallStaticVoidMethodA,
_Jv_JNI_NewObjectA, _Jv_JNI_SetPrimitiveArrayRegion): Constify
jvalue parameter.
* java/lang/reflect/natMethod.cc (_Jv_CallAnyMethodA): Likewise.
* java/lang/VMFloat.java (toString, parseFloat): New.
* gnu/awt/xlib/XToolkit.java (setAlwaysOnTop, isModalityTypeSupported,
isModalExclusionTypeSupported): New (stub only).
* gnu/awt/xlib/XCanvasPeer.java (requestFocus): Likewise.
* gnu/awt/xlib/XFramePeer.java (updateMinimumSize, updateIconImages,
updateFocusableWindowState, setModalBlocked, getBoundsPrivate,
setAlwaysOnTop): Likewise.
* gnu/awt/xlib/XFontPeer.java (canDisplay): Update signature.
* scripts/makemake.tcl: Ignore gnu/javax/sound/sampled/gstreamer,
ignore javax.sound.sampled.spi.MixerProvider, ignore .in files.
* HACKING: Mention --enable-gstreamer-peer, removal of generated files.
libjava/classpath/
2007-08-04 Matthias Klose <doko@ubuntu.com>
* java/util/EnumMap.java (clone): Add cast.
From-SVN: r127204
2007-08-04 12:53:49 +02:00
|
|
|
protected void activeObject(ActivationID id,
|
|
|
|
MarshalledObject<? extends Remote> mObject)
|
2006-05-18 19:29:21 +02:00
|
|
|
throws ActivationException, UnknownObjectException, RemoteException
|
|
|
|
{
|
|
|
|
if (monitor!=null)
|
|
|
|
monitor.activeObject(id, mObject);
|
|
|
|
|
|
|
|
id.group = this;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Makes the call back to the groups {@link ActivationMonitor} and sets
|
|
|
|
* the current group to null.
|
|
|
|
*/
|
|
|
|
protected void inactiveGroup() throws UnknownGroupException, RemoteException
|
|
|
|
{
|
|
|
|
if (monitor!=null)
|
|
|
|
monitor.inactiveGroup(groupId, incarnation);
|
|
|
|
|
|
|
|
if (currentGroupId!=null && currentGroupId.equals(groupId))
|
|
|
|
currentGroupId = null;
|
|
|
|
}
|
2005-07-16 02:30:23 +02:00
|
|
|
|
|
|
|
}
|