libjava/gnu/java/rmi/server/UnicastServerRef.java

   1 /*
   2   Copyright (c) 1996, 1997, 1998, 1999, 2002 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., 59 Temple Place, Suite 330, Boston, MA
  19 02111-1307 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 package gnu.java.rmi.server;
  39
  40 import java.net.ServerSocket;
  41 import java.net.Socket;
  42 import java.net.InetAddress;
  43 import java.net.UnknownHostException;
  44 import java.rmi.Remote;
  45 import java.rmi.RemoteException;
  46 import java.rmi.server.RemoteStub;
  47 import java.rmi.server.ObjID;
  48 import java.rmi.server.ServerRef;
  49 import java.rmi.server.RemoteRef;
  50 import java.rmi.server.ServerNotActiveException;
  51 import java.rmi.server.RMIClientSocketFactory;
  52 import java.rmi.server.RMIServerSocketFactory;
  53 import java.rmi.server.UID;
  54 import java.rmi.server.Skeleton;
  55 import java.rmi.server.RemoteCall;
  56 import java.lang.reflect.Constructor;
  57 import java.lang.reflect.Method;
  58 import java.lang.reflect.InvocationTargetException;
  59 import java.lang.Thread;
  60 import java.lang.Exception;
  61 import java.io.IOException;
  62 import java.io.DataInputStream;
  63 import java.io.DataOutputStream;
  64 import java.io.ObjectInputStream;
  65 import java.io.ObjectOutputStream;
  66 import java.io.ObjectInput;
  67 import java.io.ObjectOutput;
  68 import java.util.Hashtable;
  69
  70 public class UnicastServerRef
  71         extends UnicastRef
  72         implements ServerRef{ //SHOULD implement ServerRef
  73
  74 final static private Class[] stubprototype = new Class[] { RemoteRef.class };
  75
  76 Remote myself; //save the remote object itself
  77 private Skeleton skel;
  78 private RemoteStub stub;
  79 private Hashtable methods = new Hashtable();
  80
  81 /**
  82  * Used by serialization.
  83  */
  84 UnicastServerRef()
  85 {
  86 }
  87
  88 public UnicastServerRef(ObjID id, int port, RMIServerSocketFactory ssf) {
  89         super(id);
  90         manager = UnicastConnectionManager.getInstance(port, ssf);
  91 }
  92
  93 public RemoteStub exportObject(Remote obj) throws RemoteException {
  94         if (myself == null) {
  95                 myself = obj;
  96                 // Save it to server manager, to let client calls in the same VM to issue
  97                 //  local call
  98                 manager.serverobj = obj;
  99
 100                 // Find and install the stub
 101                 Class cls = obj.getClass();
 102                 stub = (RemoteStub)getHelperClass(cls, "_Stub");
 103                 if (stub == null) {
 104                         throw new RemoteException("failed to export: " + cls);
 105                 }
 106
 107                 // Find and install the skeleton (if there is one)
 108                 skel = (Skeleton)getHelperClass(cls, "_Skel");
 109
 110                 // Build hash of methods which may be called.
 111                 buildMethodHash(obj.getClass(), true);
 112
 113                 // Export it.
 114                 UnicastServer.exportObject(this);
 115         }
 116
 117         return (stub);
 118 }
 119
 120 public RemoteStub exportObject(Remote remote, Object obj)
 121         throws RemoteException
 122 {
 123     //FIX ME
 124         return exportObject(remote);
 125 }
 126
 127 public RemoteStub getStub(){
 128     return stub;
 129 }
 130
 131
 132 public boolean unexportObject(Remote obj, boolean force) throws RemoteException {
 133     // Remove all hashes of methods which may be called.
 134     buildMethodHash(obj.getClass(), false);
 135     return UnicastServer.unexportObject(this, force);
 136 }
 137
 138 private Object getHelperClass(Class cls, String type) {
 139         try {
 140             String classname = cls.getName();
 141                 ClassLoader cl = cls.getClassLoader(); //DONT use "Class scls = Class.forName(classname + type);"
 142                 Class scls = cl.loadClass(classname + type);
 143                 if (type.equals("_Stub")) {
 144                         try {
 145                                 // JDK 1.2 stubs
 146                                 Constructor con = scls.getConstructor(stubprototype);
 147                                 return (con.newInstance(new Object[]{this}));
 148                         }
 149                         catch (NoSuchMethodException e) {
 150                         }
 151                         catch (InstantiationException e) {
 152                         }
 153                         catch (IllegalAccessException e) {
 154                         }
 155                         catch (IllegalArgumentException e) {
 156                         }
 157                         catch (InvocationTargetException e) {
 158                         }
 159                         // JDK 1.1 stubs
 160                         RemoteStub stub = (RemoteStub)scls.newInstance();
 161                         UnicastRemoteStub.setStubRef(stub, this);
 162                         return (stub);
 163                 }
 164                 else {
 165                         // JDK 1.1 skel
 166                         return (scls.newInstance());
 167                 }
 168         }
 169         catch (ClassNotFoundException e) {
 170         }
 171         catch (InstantiationException e) {
 172         }
 173         catch (IllegalAccessException e) {
 174         }
 175         return (null);
 176 }
 177
 178 public String getClientHost() throws ServerNotActiveException {
 179         throw new Error("Not implemented");
 180 }
 181
 182 private void buildMethodHash(Class cls, boolean build) {
 183         Method[] meths = cls.getMethods();
 184         for (int i = 0; i < meths.length; i++) {
 185                 /* Don't need to include any java.xxx related stuff */
 186                 if (meths[i].getDeclaringClass().getName().startsWith("java.")) {
 187                         continue;
 188                 }
 189                 long hash = RMIHashes.getMethodHash(meths[i]);
 190                 if(build)
 191                     methods.put(new Long (hash), meths[i]);
 192                 else
 193                     methods.remove(new Long (hash));
 194 //System.out.println("meth = " + meths[i] + ", hash = " + hash);
 195         }
 196 }
 197
 198 Class getMethodReturnType(int method, long hash) throws Exception
 199 {
 200     if (method == -1) {
 201         Method meth = (Method)methods.get(new Long (hash));
 202         return meth.getReturnType();
 203     }else
 204         return null;
 205 }
 206
 207 public Object incomingMessageCall(UnicastConnection conn, int method, long hash) throws Exception {
 208 //System.out.println("method = " + method + ", hash = " + hash);
 209         // If method is -1 then this is JDK 1.2 RMI - so use the hash
 210         // to locate the method
 211         if (method == -1) {
 212                 Method meth = (Method)methods.get(new Long (hash));
 213 //System.out.println("class = " + myself.getClass() + ", meth = " + meth);
 214                 if (meth == null) {
 215                         throw new NoSuchMethodException();
 216                 }
 217
 218                 ObjectInputStream in = conn.getObjectInputStream();
 219                 int nrargs = meth.getParameterTypes().length;
 220                 Object[] args = new Object[nrargs];
 221                 for (int i = 0; i < nrargs; i++) {
 222                         /**
 223                          * For debugging purposes - we don't handle CodeBases
 224                          * quite right so we don't always find the stubs.  This
 225                          * lets us know that.
 226                          */
 227                         try {
 228                                 args[i] = in.readObject();
 229                         }
 230                         catch (Exception t) {
 231                                 t.printStackTrace();
 232                                 throw t;
 233                         }
 234                 }
 235                 //We must reinterpret the exception thrown by meth.invoke()
 236                 //return (meth.invoke(myself, args));
 237                 Object ret = null;
 238                 try{
 239                     ret = meth.invoke(myself, args);
 240                 }catch(InvocationTargetException e){
 241                     throw (Exception)(e.getTargetException());
 242                 }
 243                 return ret;
 244         }
 245         // Otherwise this is JDK 1.1 style RMI - we find the skeleton
 246         // and invoke it using the method number.  We wrap up our
 247         // connection system in a UnicastRemoteCall so it appears in a
 248         // way the Skeleton can handle.
 249         else {
 250                 if (skel == null) {
 251                         throw new NoSuchMethodException();
 252                 }
 253                 UnicastRemoteCall call = new UnicastRemoteCall(conn);
 254                 skel.dispatch(myself, call, method, hash);
 255                 return (call.returnValue());
 256         }
 257 }
 258
 259 }