Source for java.rmi.Naming

   1: /* Naming.java --
   2:    Copyright (c) 1996, 1997, 1998, 1999, 2004, 2006  
   3:    Free Software Foundation, Inc.
   4: 
   5: This file is part of GNU Classpath.
   6: 
   7: GNU Classpath is free software; you can redistribute it and/or modify
   8: it under the terms of the GNU General Public License as published by
   9: the Free Software Foundation; either version 2, or (at your option)
  10: any later version.
  11:  
  12: GNU Classpath is distributed in the hope that it will be useful, but
  13: WITHOUT ANY WARRANTY; without even the implied warranty of
  14: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15: General Public License for more details.
  16: 
  17: You should have received a copy of the GNU General Public License
  18: along with GNU Classpath; see the file COPYING.  If not, write to the
  19: Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  20: 02110-1301 USA.
  21: 
  22: Linking this library statically or dynamically with other modules is
  23: making a combined work based on this library.  Thus, the terms and
  24: conditions of the GNU General Public License cover the whole
  25: combination.
  26: 
  27: As a special exception, the copyright holders of this library give you
  28: permission to link this library with independent modules to produce an
  29: executable, regardless of the license terms of these independent
  30: modules, and to copy and distribute the resulting executable under
  31: terms of your choice, provided that you also meet, for each linked
  32: independent module, the terms and conditions of the license of that
  33: module.  An independent module is a module which is not derived from
  34: or based on this library.  If you modify this library, you may extend
  35: this exception to your version of the library, but you are not
  36: obligated to do so.  If you do not wish to do so, delete this
  37: exception statement from your version. */
  38: 
  39: 
  40: package java.rmi;
  41: 
  42: import java.net.MalformedURLException;
  43: import java.net.URI;
  44: import java.net.URISyntaxException;
  45: import java.net.URL;
  46: import java.rmi.registry.LocateRegistry;
  47: import java.rmi.registry.Registry;
  48: 
  49: /**
  50:  * <p>
  51:  * The <code>Naming</code> class handles interactions with RMI registries.
  52:  * Each method takes a URL in <code>String</code> form, which points to
  53:  * the RMI registry.  The scheme of the URL is irrelevant.  The relevant
  54:  * part is:
  55:  * </p>
  56:  * <p>
  57:  * <code>//host:port/name</code>
  58:  * </p>
  59:  * <p>
  60:  * which tells the method how to locate and access the registry.  The host
  61:  * and port are both optional, and default to `localhost' and the standard
  62:  * RMI registry port (1099) respectively.  The name is simply a string
  63:  * used to refer to a particular service hosted by the registry.  The
  64:  * registry does not attempt to interpret this further.
  65:  * </p>
  66:  * <p>
  67:  * RMI services are registered using one of these names, and the same name
  68:  * is later used by the client to lookup the service and access its methods. 
  69:  * Registries can be shared by multiple services, or a service can create
  70:  * its own registry using <code>createRegistry()</code>.
  71:  * </p>
  72:  *
  73:  * @author Original author unknown.
  74:  * @author Ingo Proetel (proetel@aicas.com)
  75:  * @author Guilhem Lavaux (guilhem@kaffe.org)
  76:  * @author Jeroen Frijters (jeroen@frijters.net)
  77:  * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
  78:  * @since 1.1
  79:  */
  80: public final class Naming
  81: {
  82:   /**
  83:    * This class isn't intended to be instantiated.
  84:    */
  85:   private Naming()
  86:   {
  87:   }
  88: 
  89:   /**
  90:    * Looks for the remote object that is associated with the named service. 
  91:    * Name and location is given in form of a URL without a scheme:
  92:    * 
  93:    * <pre>
  94:    * //host:port/service-name
  95:    * </pre>
  96:    * 
  97:    * The port is optional.
  98:    * 
  99:    * @param name the service name and location
 100:    * @return Remote-object that implements the named service
 101:    * @throws NotBoundException if no object implements the service
 102:    * @throws MalformedURLException
 103:    * @throws RemoteException
 104:    */
 105:   public static Remote lookup(String name) throws NotBoundException,
 106:     MalformedURLException, RemoteException
 107:   {
 108:     URL u = parseURL(name);
 109:     String serviceName = getName(u);
 110:     return (getRegistry(u).lookup(serviceName));
 111:   }
 112: 
 113:   /**
 114:    * Try to bind the given object to the given service name.
 115:    * 
 116:    * @param name
 117:    * @param obj
 118:    * @throws AlreadyBoundException
 119:    * @throws MalformedURLException
 120:    * @throws RemoteException
 121:    */
 122:   public static void bind(String name, Remote obj)
 123:     throws AlreadyBoundException, MalformedURLException, RemoteException
 124:   {
 125:     URL u = parseURL(name);
 126:     String serviceName = getName(u);
 127:     getRegistry(u).bind(serviceName, obj);
 128:   }
 129: 
 130:   /**
 131:    * Remove a binding for a given service name.
 132:    * 
 133:    * @param name
 134:    * @throws RemoteException
 135:    * @throws NotBoundException
 136:    * @throws MalformedURLException
 137:    */
 138:   public static void unbind(String name) throws RemoteException,
 139:     NotBoundException, MalformedURLException
 140:   {
 141:     URL u = parseURL(name);
 142:     String serviceName = getName(u);
 143:     getRegistry(u).unbind(serviceName);
 144:   }
 145: 
 146:   /**
 147:    * Forces the binding between the given Remote-object and the given service
 148:    * name, even if there was already an object bound to this name.
 149:    * 
 150:    * @param name
 151:    * @param obj
 152:    * @throws RemoteException
 153:    * @throws MalformedURLException
 154:    */
 155:   public static void rebind(String name, Remote obj) throws RemoteException,
 156:     MalformedURLException
 157:   {
 158:     URL u = parseURL(name);
 159:     String serviceName = getName(u);
 160:     getRegistry(u).rebind(serviceName, obj);
 161:   }
 162: 
 163:   /**
 164:    * Lists all services at the named registry.
 165:    * 
 166:    * @param name url that specifies the registry
 167:    * @return list of services at the name registry
 168:    * @throws RemoteException
 169:    * @throws MalformedURLException
 170:    */
 171:   public static String[] list(String name) throws RemoteException,
 172:     MalformedURLException
 173:   {
 174:     return (getRegistry(parseURL(name)).list());
 175:   }
 176: 
 177:   private static Registry getRegistry(URL u) throws RemoteException
 178:   {
 179:     if (u.getPort() == - 1)
 180:       {
 181:         return (LocateRegistry.getRegistry(u.getHost()));
 182:       }
 183:     else
 184:       {
 185:         return (LocateRegistry.getRegistry(u.getHost(), u.getPort()));
 186:       }
 187:   }
 188: 
 189:   /**
 190:    * Parses the supplied URL and converts it to use the HTTP protocol. From an
 191:    * RMI perspective, the scheme is irrelevant and we want to be able to create
 192:    * a URL for which a handler is available.
 193:    * 
 194:    * @param name the URL in String form.
 195:    * @throws MalformedURLException if the URL is invalid.
 196:    */
 197:   private static URL parseURL(String name) throws MalformedURLException
 198:   {
 199:     try
 200:       {
 201:         URI uri = new URI(name);
 202:         String host = uri.getHost();
 203:         int port = uri.getPort();
 204:         String query = uri.getQuery();
 205:         String path = uri.getPath();
 206:         return new URL("http", (host == null ? "localhost" : host),
 207:             (port == - 1 ? 1099 : port), uri.getPath()
 208:                                          + (query == null ? "" : query));
 209:       }
 210:     catch (URISyntaxException e)
 211:       {
 212:         throw new MalformedURLException("The URL syntax was invalid: "
 213:                                         + e.getMessage());
 214:       }
 215:   }
 216: 
 217:   /**
 218:    * Checks that the URL contains a name, and removes any leading slashes.
 219:    * 
 220:    * @param url the URL to check.
 221:    * @throws MalformedURLException if no name is specified.
 222:    */
 223:   private static String getName(URL url) throws MalformedURLException
 224:   {
 225:     String filename = url.getFile();
 226:     if (filename.length() == 0)
 227:       throw new MalformedURLException("No path specified: " + url);
 228:     // If the filename begins with a slash we must cut it for
 229:     // name resolution.
 230:     if (filename.charAt(0) == '/')
 231:       return filename.substring(1);
 232:     return filename;
 233:   }
 234: }