/***
    * Redistribution and use of this software and associated documentation
    * ("Software"), with or without modification, are permitted provided
    * that the following conditions are met:
    *
    * 1. Redistributions of source code must retain copyright
    *    statements and notices.  Redistributions must also contain a
    *    copy of this document.
    *
   * 2. Redistributions in binary form must reproduce the
   *    above copyright notice, this list of conditions and the
   *    following disclaimer in the documentation and/or other
   *    materials provided with the distribution.
   *
   * 3. The name "Exolab" must not be used to endorse or promote
   *    products derived from this Software without prior written
   *    permission of Exoffice Technologies.  For written permission,
   *    please contact info@exolab.org.
   *
   * 4. Products derived from this Software may not be called "Exolab"
   *    nor may "Exolab" appear in their names without prior written
   *    permission of Exoffice Technologies. Exolab is a registered
   *    trademark of Exoffice Technologies.
   *
   * 5. Due credit should be given to the Exolab Project
   *    (http://www.exolab.org/).
   *
   * THIS SOFTWARE IS PROVIDED BY EXOFFICE TECHNOLOGIES AND CONTRIBUTORS
   * ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT
   * NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
   * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
   * EXOFFICE TECHNOLOGIES OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
   * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
   * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
   * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
   * OF THE POSSIBILITY OF SUCH DAMAGE.
   *
   * Copyright 2000-2001,2003 (C) Exoffice Technologies Inc. All Rights Reserved.
   *
   * $Id: RmiJndiInitialContextFactory.java,v 1.20 2004/01/29 12:14:14 tanderson Exp $
   *
   * Date         Author  Changes
   * 3/16/2000    jima    Created
   */
  package org.exolab.jms.jndi.rmi;
  
  import java.net.MalformedURLException;
  import java.rmi.Naming;
  import java.rmi.NotBoundException;
  import java.rmi.RemoteException;
  import java.util.Hashtable;
  
  import javax.naming.CommunicationException;
  import javax.naming.ConfigurationException;
  import javax.naming.Context;
  import javax.naming.NameParser;
  import javax.naming.NamingException;
  import javax.naming.ServiceUnavailableException;
  import javax.naming.spi.InitialContextFactory;
  
  import org.apache.avalon.excalibur.naming.DefaultNamespace;
  import org.apache.avalon.excalibur.naming.NamingProvider;
  import org.apache.avalon.excalibur.naming.RemoteContext;
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  
  import org.exolab.core.util.URI;
  import org.exolab.jms.jndi.JndiConstants;
  
  
  /***
   * This is the client side helper class that retrieves the root context
   * of the JNDI server. This class implements the InitialContextFactory
   * interface
   *
   * @version     $Revision: 1.20 $ $Date: 2004/01/29 12:14:14 $
   * @author      <a href="mailto:jima@intalio.com">Jim Alateras</a>
   */
  public class RmiJndiInitialContextFactory implements InitialContextFactory {
  
      /***
       * The logger
       */
      private static final Log _log =
          LogFactory.getLog(RmiJndiInitialContextFactory.class);
  
  
      /***
       * This class is required to have a default constructor
       */
      public RmiJndiInitialContextFactory() {
      }
  
      /***
       * This routine will extract the port number of the RMI registry from
       * the environment and uses it to establish a connection with the JNDI
      * server. It then makes a call to retrieve the initial context which
      * it then returns to the client
      *
      * @param environment the environment specifying information to be used in
      * the creation of the initial context.
      * @return the initial context
      */
     public Context getInitialContext(Hashtable environment)
         throws NamingException {
         Context result = null;
         if (environment == null) {
             throw new ConfigurationException(
                 "Cannot connect to JNDI provider - environment not set");
         }
         String url = (String) environment.get(Context.PROVIDER_URL);
         if (url != null) {
             URI uri;
             try {
                 uri = new URI(url);
             } catch (URI.MalformedURIException exception) {
                 throw new ConfigurationException(
                     "Malformed JNDI provider URL: " + url);
             }
             String path = uri.getPath();
             if (path == null || path.length() == 0) {
                 url += "/JndiServer";
             } else if (path.equals("/")) {
                 url += "JndiServer";
             }
         } else {
             url = getDeprecatedEnvironment(environment);
         }
 
         NamingProvider provider;
         try {
             provider = (NamingProvider) Naming.lookup(url);
         } catch (MalformedURLException exception) {
             throw new ConfigurationException(
                 "Malformed JNDI provider URL: " + url);
         } catch (NotBoundException exception) {
             throw new ServiceUnavailableException(
                 "JNDI service is not bound in the registry for URL: " + url);
         } catch (RemoteException exception) {
             NamingException error = new CommunicationException(
                 "Failed to lookup JNDI provider for URL: " + url);
             error.setRootCause(exception);
             throw error;
         }
 
         NameParser parser;
         try {
             parser = provider.getNameParser();
         } catch (NamingException exception) {
             throw exception;
         } catch (Exception exception) {
             NamingException error = new ServiceUnavailableException(
                 exception.getMessage());
             error.setRootCause(exception);
             throw error;
         }
         DefaultNamespace namespace = new DefaultNamespace(parser);
         Hashtable env = new Hashtable(environment);
         env.put(RemoteContext.NAMING_PROVIDER, provider);
         env.put(RemoteContext.NAMESPACE, namespace);
         return new RemoteContext(env, parser.parse(""));
     }
 
     /***
      * Returns the RMI url using the old environment properties, logging a
      * warning. This method will be removed in future releases
      */
     private String getDeprecatedEnvironment(Hashtable environment) {
         _log.warn(
             getClass().getName()
             + ": using deprecated environment. Use Context.PROVIDER_URL");
 
         StringBuffer url = new StringBuffer("rmi://");
         String host = (String) environment.get(JndiConstants.HOST_PROPERTY);
         Integer port = (Integer) environment.get(
             JndiConstants.PORT_NUMBER_PROPERTY);
         String name = (String) environment.get(JndiConstants.NAME_PROPERTY);
 
         // if the host is specified then use it, otherwise use localhost
         if (host != null) {
             url.append(host);
             url.append(":");
         } else {
             url.append("localhost:");
         }
 
         // if the port has been specified then use it otherwise use
         // the default port
         if (port != null) {
             url.append(port.toString());
             url.append("/");
         } else {
             url.append("1099/");
         }
 
         // now append the server name
         if (name != null) {
             url.append(name);
         } else {
             url.append("JndiServer");
         }
         return url.toString();
     }
 
 } //-- RmiJndiInitialContextFactory