0.10/commons/src/main/java/org/apache/oodt/commons/object/jndi/RMIContext.java

// Licensed to the Apache Software Foundation (ASF) under one or more contributor
// license agreements.  See the NOTICE.txt file distributed with this work for
// additional information regarding copyright ownership.  The ASF licenses this
// file to you under the Apache License, Version 2.0 (the "License"); you may not
// use this file except in compliance with the License.  You may obtain a copy of
// the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
// License for the specific language governing permissions and limitations under
// the License.

package org.apache.oodt.commons.object.jndi;

import java.rmi.AlreadyBoundException;
import java.rmi.NotBoundException;
import java.rmi.Remote;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
import java.util.Arrays;
import java.util.Collections;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.List;
import javax.naming.CommunicationException;
import javax.naming.CompositeName;
import javax.naming.Context;
import javax.naming.InvalidNameException;
import javax.naming.Name;
import javax.naming.NameAlreadyBoundException;
import javax.naming.NameClassPair;
import javax.naming.NameNotFoundException;
import javax.naming.NameParser;
import javax.naming.NamingEnumeration;
import javax.naming.NamingException;
import javax.naming.NotContextException;
import javax.naming.OperationNotSupportedException;

/**
 * Context for binding and looking up distributed objects in RMI.
 *
 * @author Kelly
 * @version $Revision: 1.1 $
 */



public class RMIContext implements Context {
	/*
	* Construct the RMI object context.
	* 
	* @param host Host name.
	* @param port Port number.
	*/
	public RMIContext(String host, int port) {
        	Hashtable environment = new Hashtable();
		environment.put("host", host);
		environment.put("port", new Integer(port));
		initEnv(environment);
	}
	
	/**
	 * Construct the RMI object context.
	 *
	 * @param environment Its environment, currently unused.
	 */
        public RMIContext(Hashtable environment) {
                initEnv(environment);
	}

	/* Initializes environment
	*
	* @param environment Its environment, currently unused.
	*/
	private void initEnv(Hashtable environment) {
		if (environment == null)
                        throw new IllegalArgumentException("Nonnull environment required");
                this.environment = (Hashtable) environment.clone();
        }

	public Object lookup(String name) throws NamingException {
		checkName(name);
		name = toRMIName(name);
		if (name.length() == 0) return new RMIContext(environment);
		Registry registry = getRegistry();
		try {
			return registry.lookup(name);
		} catch (NotBoundException ex) {
			throw new NameNotFoundException(name + " not found in RMI registry " + registry);
		} catch (RemoteException ex) {
			throw new NamingException("Remote exception: " + ex.getMessage());
		}
	}

	public Object lookup(Name name) throws NamingException {
		return lookup(name.toString());
	}

	public void bind(String name, Object obj) throws NamingException {
		checkName(name);
		Registry registry = getRegistry();
		try {
			registry.bind(toRMIName(name), (Remote) obj);
		} catch (AlreadyBoundException ex) {
			throw new NameAlreadyBoundException(name + " already bound in RMI registry " + registry);
		} catch (RemoteException ex) {
			throw new NamingException("Remote exception: " + ex.getMessage());
		}
	}

	public void bind(Name name, Object obj) throws NamingException {
		bind(name.toString(), obj);
	}

	public void rebind(String name, Object obj) throws NamingException {
		checkName(name);
		try {
			Registry registry = getRegistry();
			registry.rebind(toRMIName(name), (Remote) obj);
		} catch (RemoteException ex) {
			ex.printStackTrace();
			throw new NamingException("Remote exception: " + ex.getMessage());
		}
	}

	public void rebind(Name name, Object obj) throws NamingException {
		rebind(name.toString(), obj);
	}

	public void unbind(String name) throws NamingException {
		checkName(name);
		Registry registry = getRegistry();
		try {
			registry.unbind(toRMIName(name));
		} catch (NotBoundException ex) {
			throw new NameNotFoundException(name + " not found in RMI registry " + registry);
		} catch (RemoteException ex) {
			throw new NamingException("Remote exception: " + ex.getMessage());
		}
	}

	public void unbind(Name name) throws NamingException {
		unbind(name.toString());
	}

	public void rename(String oldName, String newName) throws NamingException {
		checkName(newName);
		throw new OperationNotSupportedException("Not yet implemented");
	}

	public void rename(Name oldName, Name newName) throws NamingException {
		rename(oldName.toString(), newName.toString());
	}

	public NamingEnumeration list(String name) throws NamingException {
		if (name.length() > 0) 
			throw new NotContextException("Subcontexts not supported");
				
		final Iterator i = getCurrentBindings().iterator();
		return new NamingEnumeration() {
			public void close() {}
			public boolean hasMore() {
				return i.hasNext();
			}
			public Object next() throws NamingException {
				String n = "urn:eda:rmi:" + (String) i.next();
				org.apache.oodt.commons.Service server = (org.apache.oodt.commons.Service) lookup(n);
				try {
					return new NameClassPair(n, server.getServerInterfaceName());
				} catch (RemoteException ex) {
					throw new CommunicationException(ex.getMessage());
				}
			}
			public boolean hasMoreElements() {
				return hasMore();
			}
			public Object nextElement() {
				Object next = null;
				try {
					next = next();
				} catch (RuntimeException ex) {
					throw ex;
				} catch (Exception ignore) {}
				return next;
			}
		};
	}
		
	public NamingEnumeration list(Name name) throws NamingException {
		return list(name.toString());
	}

	public NamingEnumeration listBindings(String name) throws NamingException {
		if (name.length() > 0) 
			throw new NotContextException("Subcontexts not supported");
		final Iterator i = getCurrentBindings().iterator();
		return new NamingEnumeration() {
			public void close() {}
			public boolean hasMore() {
				return i.hasNext();
			}
			public Object next() throws NamingException {
				String n = "urn:eda:rmi:" + (String) i.next();
				return new javax.naming.Binding(n, lookup(n));
			}
			public boolean hasMoreElements() {
				return hasMore();
			}
			public Object nextElement() {
				Object next = null;
				try {
					next = next();
				} catch (RuntimeException ex) {
					throw ex;
				} catch (Exception ignore) {}
				return next;
			}
		};
	}

	public NamingEnumeration listBindings(Name name) throws NamingException {
		return listBindings(name.toString());
	}

	public void destroySubcontext(String name) throws NamingException {
		throw new OperationNotSupportedException("Not yet implemented");
	}

	public void destroySubcontext(Name name) throws NamingException {
		destroySubcontext(name.toString());
	}

	public Context createSubcontext(String name) throws NamingException {
		throw new OperationNotSupportedException("Subcontexts not supported");
	}

	public Context createSubcontext(Name name) throws NamingException {
		return createSubcontext(name.toString());
	}

	public Object lookupLink(String name) throws NamingException {
		return lookup(name);
	}

	public Object lookupLink(Name name) throws NamingException {
		return lookupLink(name.toString());
	}

	public NameParser getNameParser(String name) throws NamingException {
		return nameParser;
	}

	public NameParser getNameParser(Name name) throws NamingException {
		return getNameParser(name.toString());
	}

	public String composeName(String name, String prefix) throws NamingException {
		Name result = composeName(new CompositeName(name), new CompositeName(prefix));
		return result.toString();
	}

	public Name composeName(Name name, Name prefix) throws NamingException {
		Name result = (Name) prefix.clone();
		result.addAll(name);
		return result;
	}

	public Object addToEnvironment(String propName, Object propVal) throws NamingException {
		if (environment == null) environment = new Hashtable();
		return environment.put(propName, propVal);
	}

	public Object removeFromEnvironment(String propName) throws NamingException {
		if (environment == null) return null;
		return environment.remove(propName);
	}

	public Hashtable getEnvironment() throws NamingException {
		if (environment == null) return new Hashtable();
		return (Hashtable) environment.clone();
	}

	public String getNameInNamespace() throws NamingException {
		return "";
	}

	public void close() throws NamingException {
		environment = null;
	}

	/**
	 * Get the current bindings in the RMI registry.
	 *
	 * @return A list of the current bindings, as simple string names.
	 */
	private List getCurrentBindings() throws NamingException {
		List names = null;
		try {
			Registry registry = getRegistry();
			names = Arrays.asList(registry.list());
		} catch (RemoteException ex) {
			names = Collections.EMPTY_LIST;
		}
		return names;
	}

	/**
	 * Convert the context object name into an rmiregistry name.
	 *
	 * @param name Context name.
	 * @return rmiregistry name.
	 */
	private String toRMIName(String name) {
		if (name == null) return "";
		if (name.startsWith("urn:eda:rmi:"))
			return name.substring(12);
		if (name.startsWith("rmi:"))
			return name.substring(4);
		return name;
	}

	/**
	 * Get the RMI registry.
	 *
	 * @return a <code>Registry</code> value.
	 * @throws NamingException if an error occurs.
	 */
	private Registry getRegistry() throws NamingException {
		if (registry != null) return registry;
		try {
			String host = environment.containsKey("host")? (String) environment.get("host") : "localhost";
			int port = environment.containsKey("port")? ((Integer) environment.get("port")).intValue()
				: Registry.REGISTRY_PORT;

			
			registry = LocateRegistry.getRegistry(host, port);
		} catch (RemoteException ex) {
			throw new NamingException("Remote exception locating registry: " + ex.getMessage());
		}
		return registry;
	}

	/**
	 * Ensure the name is an RMI object context name.
	 *
	 * RMI object context names are URNs in the <code>eda</code> namespace, in the
	 * <code>rmi</code> subnamespace.
	 *
	 * @param name Name to check.
	 * @throws InvalidNameException If <var>name</var>'s not an RMI object context name.
	 */
	private void checkName(String name) throws InvalidNameException {
		if (name == null)
			throw new IllegalArgumentException("Can't check a null name");
		if (name.length() == 0)
			throw new InvalidNameException("Name's length is zero");
		if (!name.startsWith("urn:eda:rmi:"))
			throw new InvalidNameException("Not an RMI name; try urn:eda:rmi:yadda-yadda");
	}

	/** Context's environment; currently unused. */
	private Hashtable environment;

	/** RMI Registry. */
	private Registry registry;

	/** Parser for object names. */
	private static final NameParser nameParser = new ObjectNameParser();
}