001 /* ActivationGroup.java -- the RMI activation group.
002 Copyright (c) 1996, 1997, 1998, 1999, 2006 Free Software Foundation, Inc.
003
004 This file is part of GNU Classpath.
005
006 GNU Classpath is free software; you can redistribute it and/or modify
007 it under the terms of the GNU General Public License as published by
008 the Free Software Foundation; either version 2, or (at your option)
009 any later version.
010
011 GNU Classpath is distributed in the hope that it will be useful, but
012 WITHOUT ANY WARRANTY; without even the implied warranty of
013 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
014 General Public License for more details.
015
016 You should have received a copy of the GNU General Public License
017 along with GNU Classpath; see the file COPYING. If not, write to the
018 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
019 02110-1301 USA.
020
021 Linking this library statically or dynamically with other modules is
022 making a combined work based on this library. Thus, the terms and
023 conditions of the GNU General Public License cover the whole
024 combination.
025
026 As a special exception, the copyright holders of this library give you
027 permission to link this library with independent modules to produce an
028 executable, regardless of the license terms of these independent
029 modules, and to copy and distribute the resulting executable under
030 terms of your choice, provided that you also meet, for each linked
031 independent module, the terms and conditions of the license of that
032 module. An independent module is a module which is not derived from
033 or based on this library. If you modify this library, you may extend
034 this exception to your version of the library, but you are not
035 obligated to do so. If you do not wish to do so, delete this
036 exception statement from your version. */
037
038
039 package java.rmi.activation;
040
041 import gnu.java.rmi.activation.DefaultActivationGroup;
042 import gnu.java.rmi.activation.DefaultActivationSystem;
043
044 import java.lang.reflect.Constructor;
045 import java.rmi.MarshalledObject;
046 import java.rmi.Remote;
047 import java.rmi.RemoteException;
048 import java.rmi.server.UnicastRemoteObject;
049
050 /**
051 * The entity that receives the request to activate object and activates it.
052 * Frequently there is one activation group per virtual machine.
053 *
054 * @author Audrius Meskauskas (audriusa@Bioinformatics.org) (from stub)
055 */
056 public abstract class ActivationGroup
057 extends UnicastRemoteObject
058 implements ActivationInstantiator
059 {
060
061 /**
062 * Use the SVUID for interoperability.
063 */
064 static final long serialVersionUID = - 7696947875314805420L;
065
066 /**
067 * The Id of the current group on this VM (null if none).
068 */
069 static ActivationGroupID currentGroupId = null;
070
071 /**
072 * The groups identifier.
073 */
074 final ActivationGroupID groupId;
075
076 /**
077 * The groups activation monitor.
078 */
079 ActivationMonitor monitor;
080
081 /**
082 * The groups incarnation number.
083 */
084 long incarnation;
085
086 /**
087 * The groups activation system.
088 */
089 static ActivationSystem system;
090
091 /**
092 * Used during the group creation (required constructor).
093 */
094 static final Class[] cConstructorTypes = new Class[]
095 {
096 ActivationGroupID.class,
097 MarshalledObject.class
098 };
099
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,
318 MarshalledObject<? extends Remote> mObject)
319 throws ActivationException, UnknownObjectException, RemoteException
320 {
321 if (monitor!=null)
322 monitor.activeObject(id, mObject);
323
324 id.group = this;
325 }
326
327 /**
328 * Makes the call back to the groups {@link ActivationMonitor} and sets
329 * the current group to null.
330 */
331 protected void inactiveGroup() throws UnknownGroupException, RemoteException
332 {
333 if (monitor!=null)
334 monitor.inactiveGroup(groupId, incarnation);
335
336 if (currentGroupId!=null && currentGroupId.equals(groupId))
337 currentGroupId = null;
338 }
339
340 }