The Activatable class provides support for remote
objects that require persistent access over time and that
can be activated by the system.

For the constructors and static exportObject methods,
the stub for a remote object being exported is obtained as described in
UnicastRemoteObject.

An attempt to serialize explicitly an instance of this class will
fail.

This exception is thrown by the RMI runtime when activation
fails during a remote call to an activatable object.

An activation descriptor contains the information necessary to
activate an object:
 the object's group identifier,
 the object's fully-qualified class name,
 the object's code location (the location of the class), a codebase URL
path,
 the object's restart "mode", and,
 a "marshalled" object that can contain object specific
initialization data.

A descriptor registered with the activation system can be used to
recreate/activate the object specified by the descriptor. The
MarshalledObject in the object's descriptor is passed
as the second argument to the remote object's constructor for
object to use during reinitialization/activation.

General exception used by the activation interfaces.

As of release 1.4, this exception has been retrofitted to conform to
the general purpose exception-chaining mechanism.  The "detail exception"
that may be provided at construction time and accessed via the public
detail field is now known as the cause, and may be
accessed via the Throwable.getCause() method, as well as
the aforementioned "legacy field."

Invoking the method Throwable.initCause(Throwable) on an
instance of ActivationException always throws IllegalStateException.

An ActivationGroup is responsible for creating new
instances of "activatable" objects in its group, informing its
ActivationMonitor when either: its object's become
active or inactive, or the group as a whole becomes inactive.

An ActivationGroup is initially created in one
of several ways:
as a side-effect of creating an ActivationDesc
    without an explicit ActivationGroupID for the
    first activatable object in the group, or
via the ActivationGroup.createGroup method
as a side-effect of activating the first object in a group
    whose ActivationGroupDesc was only registered.

Only the activator can recreate an
ActivationGroup.  The activator spawns, as needed, a
separate VM (as a child process, for example) for each registered
activation group and directs activation requests to the appropriate
group. It is implementation specific how VMs are spawned. An
activation group is created via the
ActivationGroup.createGroup static method. The
createGroup method has two requirements on the group
to be created: 1) the group must be a concrete subclass of
ActivationGroup, and 2) the group must have a
constructor that takes two arguments:


 the group's ActivationGroupID, and
 the group's initialization data (in a
     java.rmi.MarshalledObject)

When created, the default implementation of
ActivationGroup will override the system properties
with the properties requested when its
ActivationGroupDesc was created, and will set a
SecurityManager as the default system
security manager.  If your application requires specific properties
to be set when objects are activated in the group, the application
should create a special Properties object containing
these properties, then create an ActivationGroupDesc
with the Properties object, and use
ActivationGroup.createGroup before creating any
ActivationDescs (before the default
ActivationGroupDesc is created).  If your application
requires the use of a security manager other than
SecurityManager, in the
ActivativationGroupDescriptor properties list you can set
java.security.manager property to the name of the security
manager you would like to install.

ActivationGroup_Stub is a stub class
for the subclasses of java.rmi.activation.ActivationGroup
that are exported as a java.rmi.server.UnicastRemoteObject.

An activation group descriptor contains the information necessary to
create/recreate an activation group in which to activate objects.
Such a descriptor contains:
 the group's class name,
 the group's code location (the location of the group's class), and
 a "marshalled" object that can contain group specific
initialization data.

The group's class must be a concrete subclass of
ActivationGroup. A subclass of
ActivationGroup is created/recreated via the
ActivationGroup.createGroup static method that invokes
a special constructor that takes two arguments:

 the group's ActivationGroupID, and
 the group's initialization data (in a
java.rmi.MarshalledObject)

Startup options for ActivationGroup implementations.

This class allows overriding default system properties and
specifying implementation-defined options for ActivationGroups.

The identifier for a registered activation group serves several
purposes:
identifies the group uniquely within the activation system, and
contains a reference to the group's activation system so that the
group can contact its activation system when necessary.

The ActivationGroupID is returned from the call to
ActivationSystem.registerGroup and is used to identify
the group within the activation system. This group id is passed
as one of the arguments to the activation group's special constructor
when an activation group is created/recreated.

Activation makes use of special identifiers to denote remote
objects that can be activated over time. An activation identifier
(an instance of the class ActivationID) contains several
pieces of information needed for activating an object:

 a remote reference to the object's activator (a RemoteRef
instance), and
 a unique identifier (a UID
instance) for the object.

An activation identifier for an object can be obtained by registering
an object with the activation system. Registration is accomplished
in a few ways:
via the Activatable.register method
via the first Activatable constructor (that takes
three arguments and both registers and exports the object, and
via the first Activatable.exportObject method
that takes the activation descriptor, object and port as arguments;
this method both registers and exports the object.

An ActivationInstantiator is responsible for creating
instances of "activatable" objects. A concrete subclass of
ActivationGroup implements the newInstance
method to handle creating objects within the group.

An ActivationMonitor is specific to an
ActivationGroup and is obtained when a group is
reported active via a call to
ActivationSystem.activeGroup (this is done
internally). An activation group is responsible for informing its
ActivationMonitor when either: its objects become active or
inactive, or the group as a whole becomes inactive.

The ActivationSystem provides a means for registering
groups and "activatable" objects to be activated within those groups.
The ActivationSystem works closely with the
Activator, which activates objects registered via the
ActivationSystem, and the ActivationMonitor,
which obtains information about active and inactive objects,
and inactive groups.

The Activator facilitates remote object activation. A
"faulting" remote reference calls the activator's
activate method to obtain a "live" reference to a
"activatable" remote object. Upon receiving a request for activation,
the activator looks up the activation descriptor for the activation
identifier, id, determines the group in which the
object should be activated initiates object re-creation via the
group's ActivationInstantiator (via a call to the
newInstance method). The activator initiates the
execution of activation groups as necessary. For example, if an
activation group for a specific group identifier is not already
executing, the activator initiates the execution of a VM for the
group.

The Activator works closely with
ActivationSystem, which provides a means for registering
groups and objects within those groups, and ActivationMonitor,
which recives information about active and inactive objects and inactive
groups.

The activator is responsible for monitoring and detecting when
activation groups fail so that it can remove stale remote references
to groups and active object's within those groups.

An UnknownGroupException is thrown by methods of classes and
interfaces in the java.rmi.activation package when the
ActivationGroupID parameter to the method is determined to be
invalid, i.e., not known by the ActivationSystem.  An
UnknownGroupException is also thrown if the
ActivationGroupID in an ActivationDesc refers to
a group that is not registered with the ActivationSystem

An UnknownObjectException is thrown by methods of classes and
interfaces in the java.rmi.activation package when the
ActivationID parameter to the method is determined to be
invalid.  An ActivationID is invalid if it is not currently
known by the ActivationSystem.  An ActivationID
is obtained by the ActivationSystem.registerObject method.
An ActivationID is also obtained during the
Activatable.register call.