aboutsummaryrefslogtreecommitdiffstats
path: root/gcc-4.4.3/libjava/classpath/gnu/java/rmi/server/UnicastServer.java
diff options
context:
space:
mode:
Diffstat (limited to 'gcc-4.4.3/libjava/classpath/gnu/java/rmi/server/UnicastServer.java')
-rw-r--r--gcc-4.4.3/libjava/classpath/gnu/java/rmi/server/UnicastServer.java321
1 files changed, 321 insertions, 0 deletions
diff --git a/gcc-4.4.3/libjava/classpath/gnu/java/rmi/server/UnicastServer.java b/gcc-4.4.3/libjava/classpath/gnu/java/rmi/server/UnicastServer.java
new file mode 100644
index 000000000..7fe539546
--- /dev/null
+++ b/gcc-4.4.3/libjava/classpath/gnu/java/rmi/server/UnicastServer.java
@@ -0,0 +1,321 @@
+/* UnicastServer.java --
+ Copyright (c) 1996, 1997, 1998, 1999, 2002, 2004
+ Free Software Foundation, Inc.
+
+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 gnu.java.rmi.server;
+
+import gnu.java.rmi.dgc.DGCImpl;
+import gnu.java.util.WeakIdentityHashMap;
+
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.rmi.NoSuchObjectException;
+import java.rmi.Remote;
+import java.rmi.RemoteException;
+import java.rmi.ServerError;
+import java.rmi.activation.ActivationException;
+import java.rmi.activation.ActivationID;
+import java.rmi.server.ObjID;
+import java.rmi.server.UID;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Hashtable;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.WeakHashMap;
+
+public class UnicastServer
+ implements ProtocolConstants
+{
+
+ /**
+ * Mapping OBJID to server ref by .equals().
+ */
+ static private Map objects = Collections.synchronizedMap(new WeakHashMap());
+
+ /**
+ * Mapping obj itself to server ref by identity.
+ */
+ static private Map refcache = Collections.synchronizedMap(new WeakIdentityHashMap());
+
+ /**
+ * Mapping the registered activatable objects into they server references.
+ */
+ public static Map actIds = new Hashtable();
+
+ /**
+ * The reference to the local distributed garbage collector.
+ */
+ static private DGCImpl dgc;
+
+ /**
+ * Connect this server reference to the server, allowing the local
+ * implementation, associated with this object, to receive remote calls.
+ *
+ * @param obj the server reference, encloses the (usually local) remote
+ * object.
+ */
+ public static void exportObject(UnicastServerRef obj)
+ {
+ startDGC();
+ objects.put(obj.objid, obj);
+ refcache.put(obj.myself, obj);
+ obj.manager.startServer();
+ }
+
+ /**
+ * Register the activatable object into the table of the activatable
+ * objects.
+ */
+ public static void registerActivatable(ActivatableServerRef ref)
+ {
+ actIds.put(ref.actId, ref);
+ }
+
+ /**
+ * Export tha activatable object. The object id is placed into the map,
+ * but the object itself not. This is enough to deliver call to
+ * the ref.incomingMessageCall where the object will be instantiated,
+ * if not present.
+ */
+ public static void exportActivatableObject(ActivatableServerRef ref)
+ {
+ startDGC();
+ objects.put(ref.objid, ref);
+ ref.manager.startServer();
+ actIds.put(ref.actId, ref);
+ }
+
+
+ /**
+ * Get the activatable server reference that is handling activation of the
+ * given activation id.
+ */
+ public static ActivatableServerRef getActivatableRef(ActivationID id)
+ throws ActivationException
+ {
+ ActivatableServerRef ref = (ActivatableServerRef) actIds.get(id);
+ if (ref == null)
+ throw new ActivationException(id + " was not registered with this server");
+ return ref;
+ }
+
+ /**
+ * Unregister the previously registered activatable server reference.
+ */
+ public static void unregisterActivatable(ActivationID id)
+ {
+ actIds.remove(id);
+ }
+
+ // FIX ME: I haven't handle force parameter
+ /**
+ * Remove the given server reference. The remote object, associated with
+ * this reference, will no longer receive remote calls via this server.
+ */
+ public static boolean unexportObject(UnicastServerRef obj, boolean force)
+ {
+ objects.remove(obj.objid);
+ refcache.remove(obj.myself);
+ obj.manager.stopServer();
+
+ if (obj instanceof ActivatableServerRef)
+ {
+ ActivationID id = ((ActivatableServerRef) obj).actId;
+ unregisterActivatable(id);
+ }
+ return true;
+ }
+
+ /**
+ * Get the exported reference of the given Remote. The identity map is used,
+ * the non-null value will only be returned if exactly the passed remote
+ * is part of the registered UnicastServerRef.
+ *
+ * @param remote the Remote that is connected to this server via
+ * {@link UnicastServerRef}.
+ *
+ * @return the UnicastServerRef that is used to connect the passed
+ * remote with this server or null, if this Remote is not connected
+ * to this server.
+ */
+ public static UnicastServerRef getExportedRef(Remote remote)
+ {
+ return (UnicastServerRef) refcache.get(remote);
+ }
+
+ /**
+ * Get the server references to the object, previously exported via this
+ * server. As the identity map is scanned, more than one reference may match
+ * this Id.
+ *
+ * @param id the id of the exported object
+ * @return the server reference to this object, null if none.
+ */
+ public static Collection getExported(Object id)
+ {
+ synchronized (objects)
+ {
+ ArrayList list = new ArrayList();
+ Iterator iter = objects.entrySet().iterator();
+ Map.Entry e;
+ Object key;
+ while (iter.hasNext())
+ {
+ e = (Map.Entry) iter.next();
+ key = e.getKey();
+ if (key != null && key.equals(id))
+ list.add(e.getValue());
+ }
+ return list;
+ }
+ }
+
+ private static synchronized void startDGC()
+ {
+ if (dgc == null)
+ {
+ try
+ {
+ dgc = new DGCImpl();
+ // Changed DGCImpl to inherit UnicastServerRef directly
+ // ((UnicastServerRef)dgc.getRef()).exportObject(dgc);
+ dgc.exportObject(dgc);
+ }
+ catch (RemoteException e)
+ {
+ e.printStackTrace();
+ }
+ }
+ }
+
+ public static void dispatch(UnicastConnection conn) throws Exception
+ {
+ switch (conn.getDataInputStream().readUnsignedByte())
+ {
+ case MESSAGE_CALL:
+ incomingMessageCall(conn);
+ break;
+ case MESSAGE_PING:
+ // jdk sends a ping before each method call -> answer it!
+ DataOutputStream out = conn.getDataOutputStream();
+ out.writeByte(MESSAGE_PING_ACK);
+ out.flush();
+ break;
+ default:
+ throw new Exception("bad method type");
+ }
+ }
+
+ /**
+ * This method is invoked when the remote call is received. The method
+ * dispatches the call to the responsible object, connected to this
+ * server via UnicastServerReference.
+ */
+ private static void incomingMessageCall(UnicastConnection conn)
+ throws IOException
+ {
+ ObjectInputStream in = conn.startObjectInputStream(); // (re)start
+ // ObjectInputStream
+
+ ObjID objid = ObjID.read(in);
+ int method = in.readInt();
+ long hash = in.readLong();
+
+ // System.out.println("ObjID: " + objid + ", method: " + method + ", hash: "
+ // + hash);
+
+ // Use the objid to locate the relevant UnicastServerRef
+ UnicastServerRef uref = (UnicastServerRef) objects.get(objid);
+ Object returnval;
+ int returncode = RETURN_ACK;
+ // returnval is from Method.invoke(), so we must check the return class to
+ // see
+ // if it's primitive type
+ Class returncls = null;
+ if (uref != null)
+ {
+ try
+ {
+ // Dispatch the call to it.
+ returnval = uref.incomingMessageCall(conn, method, hash);
+ returncls = uref.getMethodReturnType(method, hash);
+ }
+ catch (Exception e)
+ {
+ returnval = e;
+ returncode = RETURN_NACK;
+ }
+ catch (Error e)
+ {
+ returnval = new ServerError(
+ "Server error, ObjID: " + objid +
+ ", method: " + method + ", hash: "+ hash, e);
+ returncode = RETURN_NACK;
+ }
+ }
+ else
+ {
+ returnval = new NoSuchObjectException("ObjID: " + objid);
+ returncode = RETURN_NACK;
+ }
+
+ conn.getDataOutputStream().writeByte(MESSAGE_CALL_ACK);
+
+ ObjectOutputStream out = conn.startObjectOutputStream(); // (re)start
+ // ObjectOutputStream
+
+ out.writeByte(returncode);
+ (new UID()).write(out);
+
+ // System.out.println("returnval=" + returnval + " returncls=" + returncls);
+
+ if (returnval != null && returncls != null)
+ ((RMIObjectOutputStream) out).writeValue(returnval, returncls);
+
+ // 1.1/1.2 void return type detection:
+ else if (! (returnval instanceof RMIVoidValue || returncls == Void.TYPE))
+ out.writeObject(returnval);
+
+ out.flush();
+ }
+
+}