libjava/classpath/java/rmi/activation/ActivationGroup.java

   1 /* ActivationGroup.java -- the RMI activation group.
   2    Copyright (c) 1996, 1997, 1998, 1999, 2006 Free Software Foundation, Inc.
   3
   4 This file is part of GNU Classpath.
   5
   6 GNU Classpath is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Classpath is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Classpath; see the file COPYING.  If not, write to the
  18 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19 02110-1301 USA.
  20
  21 Linking this library statically or dynamically with other modules is
  22 making a combined work based on this library.  Thus, the terms and
  23 conditions of the GNU General Public License cover the whole
  24 combination.
  25
  26 As a special exception, the copyright holders of this library give you
  27 permission to link this library with independent modules to produce an
  28 executable, regardless of the license terms of these independent
  29 modules, and to copy and distribute the resulting executable under
  30 terms of your choice, provided that you also meet, for each linked
  31 independent module, the terms and conditions of the license of that
  32 module.  An independent module is a module which is not derived from
  33 or based on this library.  If you modify this library, you may extend
  34 this exception to your version of the library, but you are not
  35 obligated to do so.  If you do not wish to do so, delete this
  36 exception statement from your version. */
  37
  38
  39 package java.rmi.activation;
  40
  41 import gnu.java.rmi.activation.DefaultActivationGroup;
  42 import gnu.java.rmi.activation.DefaultActivationSystem;
  43
  44 import java.lang.reflect.Constructor;
  45 import java.rmi.MarshalledObject;
  46 import java.rmi.Remote;
  47 import java.rmi.RemoteException;
  48 import java.rmi.server.UnicastRemoteObject;
  49
  50 /**
  51  * The entity that receives the request to activate object and activates it.
  52  * Frequently there is one activation group per virtual machine.
  53  *
  54  * @author Audrius Meskauskas (audriusa@Bioinformatics.org) (from stub)
  55  */
  56 public abstract class ActivationGroup
  57     extends UnicastRemoteObject
  58     implements ActivationInstantiator
  59 {
  60
  61   /**
  62    * Use the SVUID for interoperability.
  63    */
  64   static final long serialVersionUID = - 7696947875314805420L;
  65
  66   /**
  67    * The Id of the current group on this VM (null if none).
  68    */
  69   static ActivationGroupID currentGroupId = null;
  70
  71   /**
  72    * The groups identifier.
  73    */
  74   final ActivationGroupID groupId;
  75
  76   /**
  77    * The groups activation monitor.
  78    */
  79   ActivationMonitor monitor;
  80
  81   /**
  82    * The groups incarnation number.
  83    */
  84   long incarnation;
  85
  86   /**
  87    * The groups activation system.
  88    */
  89   static ActivationSystem system;
  90
  91   /**
  92    * Used during the group creation (required constructor).
  93    */
  94   static final Class[] cConstructorTypes = new Class[]
  95                                                    {
  96                                                     ActivationGroupID.class,
  97                                                     MarshalledObject.class
  98                                                    };
  99
 100   /**
 101    * Create the new activation group with the given group id.
 102    *
 103    * @param aGroupId the group Id.
 104    *
 105    * @throws RemoteException if the group export fails.
 106    */
 107   protected ActivationGroup(ActivationGroupID aGroupId) throws RemoteException
 108   {
 109     groupId = aGroupId;
 110   }
 111
 112   /**
 113    * The method is called when the object is exported. The group must notify
 114    * the activation monitor, if this was not already done before.
 115    *
 116    * @param id the object activation id
 117    * @param obj the remote object implementation
 118    *
 119    * @throws ActivationException if the group is inactive
 120    * @throws UnknownObjectException if such object is not known
 121    * @throws RemoteException if the call to monitor fails
 122    */
 123   public abstract void activeObject(ActivationID id, Remote obj)
 124       throws ActivationException, UnknownObjectException, RemoteException;
 125
 126   /**
 127    * Notifies the monitor about the object being inactivated.
 128    *
 129    * @param id the object being inactivated.
 130    * @return true always (must be overridden to return other values).
 131    * @throws ActivationException never
 132    * @throws UnknownObjectException if the object is not known
 133    * @throws RemoteException if the remote call to monitor fails
 134    */
 135   public boolean inactiveObject(ActivationID id) throws ActivationException,
 136       UnknownObjectException, RemoteException
 137   {
 138     if (monitor != null)
 139       monitor.inactiveObject(id);
 140     return true;
 141   }
 142
 143   /**
 144    * Create the new instance of the activation group, using the class name and
 145    * location information, stored in the passed descriptor. The method expects
 146    * the group class to have the two parameter constructor, the first parameter
 147    * being the {@link ActivationGroupID} and the second the
 148    * {@link MarshalledObject}. The group must be first be registered with the
 149    * ActivationSystem. Once a group is created, the currentGroupID method
 150    * returns the identifier for this group until the group becomes inactive.
 151    *
 152    * @param id the activation group id
 153    * @param desc the group descriptor, providing the information, necessary to
 154    *          create the group
 155    * @param incarnation the incarnation number
 156    * @return the created group instance
 157    * @throws ActivationException if the activation fails due any reason
 158    */
 159   public static ActivationGroup createGroup(ActivationGroupID id,
 160                                             ActivationGroupDesc desc,
 161                                             long incarnation)
 162       throws ActivationException
 163   {
 164     // If the activation system is not yet set, set it to the system.
 165     // passed in the group id.
 166     if (system == null)
 167       system = id.system;
 168
 169     ActivationGroup group = null;
 170
 171     // TODO at the moment all groups are created on the current jre and the
 172     // group class must be reachable via thread context class loader.
 173     Class groupClass;
 174
 175     if (desc.className != null)
 176       {
 177         try
 178           {
 179             ClassLoader loader = Thread.currentThread().getContextClassLoader();
 180             groupClass = loader.loadClass(desc.className);
 181           }
 182         catch (ClassNotFoundException e)
 183           {
 184             ActivationException acex = new ActivationException(
 185               "Cannot load " + desc.className);
 186             acex.detail = e;
 187             throw acex;
 188           }
 189       }
 190     else
 191       groupClass = DefaultActivationGroup.class;
 192
 193     try
 194       {
 195         Constructor constructor = groupClass.getConstructor(cConstructorTypes);
 196         group = (ActivationGroup) constructor.newInstance(
 197           new Object[] { id, desc.data });
 198       }
 199     catch (Exception e)
 200       {
 201         ActivationException acex = new ActivationException(
 202           "Cannot instantiate " + desc.className);
 203         acex.detail = e;
 204         throw acex;
 205       }
 206
 207     currentGroupId = id;
 208     try
 209       {
 210         group.monitor = getSystem().activeGroup(id, group, incarnation);
 211         return group;
 212       }
 213     catch (RemoteException e)
 214       {
 215         ActivationException acex = new ActivationException("createGroup");
 216         acex.detail = e;
 217         throw acex;
 218       }
 219   }
 220
 221   /**
 222    * Get the id of current activation group.
 223    *
 224    * @return the id of the current activation group or null if none exists.
 225    */
 226   public static ActivationGroupID currentGroupID()
 227   {
 228     try
 229       {
 230         if (currentGroupId==null)
 231           {
 232             // This will also assing the currentGroupId to the current
 233             // (default) group of the default system.
 234             setSystem(DefaultActivationSystem.get());
 235           }
 236       }
 237     catch (ActivationException e)
 238       {
 239         InternalError ierr = new InternalError("Unable to activate AS");
 240         ierr.initCause(e);
 241         throw ierr;
 242       }
 243
 244     return currentGroupId;
 245   }
 246
 247   /**
 248    * Set the activation system for this virtual machine. The system can only
 249    * be set if no group is active.
 250    *
 251    * @param aSystem the system to set
 252    *
 253    * @throws ActivationException if some group is active now.
 254    */
 255   public static void setSystem(ActivationSystem aSystem)
 256       throws ActivationException
 257   {
 258     if (currentGroupId!=null)
 259       throw new ActivationException("Group active");
 260     else
 261       {
 262         try
 263           {
 264             // Register the default transient activation system and group.
 265             system = aSystem;
 266             ActivationGroupDesc def = new ActivationGroupDesc(
 267                DefaultActivationGroup.class.getName(),
 268               "",
 269               null,
 270               null,
 271               null);
 272             currentGroupId = system.registerGroup(def);
 273           }
 274         catch (Exception ex)
 275         {
 276           InternalError ierr = new InternalError("Unable to start default AG");
 277           ierr.initCause(ex);
 278           throw ierr;
 279         }
 280       }
 281   }
 282
 283   /**
 284    * Get the current activation system. If the system is not set via
 285    * {@link #setSystem} method, the default system for this virtual machine is
 286    * returned. The default system is first searched by name
 287    * "java.rmi.activation.ActivationSystem" on the activation registry port. The
 288    * default value of the activation registry port is
 289    * {@link ActivationSystem#SYSTEM_PORT}, but it can be changed by putting the
 290    * system property java.rmi.activation.port. Both activation system and
 291    * activation registry are provided by the RMI daemon tool, RMID, if it is
 292    * running on the local host. If the RMID is not running, the internal
 293    * transient activation system will be created and returned. This internal
 294    * system is highly limited in in capabilities and is not intended to be used
 295    * anywhere apart automated testing.
 296    *
 297    * @return the activation system for this virtual machine
 298    * @throws ActivationException
 299    */
 300   public static ActivationSystem getSystem() throws ActivationException
 301   {
 302     if (system == null)
 303       system = DefaultActivationSystem.get();
 304     return system;
 305   }
 306
 307   /**
 308    * Makes the call back to the groups {@link ActivationMonitor}.
 309    *
 310    * @param id the id obj the object being activated
 311    * @param mObject the marshalled object, contains the activated remote object
 312    *          stub.
 313    * @throws ActivationException on activation error
 314    * @throws UnknownObjectException if such object is not registered
 315    * @throws RemoteException on remote call (to monitor) error
 316    */
 317   protected void activeObject(ActivationID id, MarshalledObject mObject)
 318       throws ActivationException, UnknownObjectException, RemoteException
 319   {
 320     if (monitor!=null)
 321       monitor.activeObject(id, mObject);
 322
 323     id.group = this;
 324   }
 325
 326   /**
 327    * Makes the call back to the groups {@link ActivationMonitor} and sets
 328    * the current group to null.
 329    */
 330   protected void inactiveGroup() throws UnknownGroupException, RemoteException
 331   {
 332     if (monitor!=null)
 333       monitor.inactiveGroup(groupId, incarnation);
 334
 335     if (currentGroupId!=null && currentGroupId.equals(groupId))
 336       currentGroupId = null;
 337   }
 338
 339 }