scnurlcontext.java

一个类似于openJMS分布在ObjectWeb之下的JMS消息中间件。

/*
 * JORAM: Java(TM) Open Reliable Asynchronous Messaging
 * Copyright (C) 2001 - 2004 ScalAgent Distributed Technologies
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or any later version.
 * 
 * This library 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
 * Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
 * USA.
 *
 * Initial developer(s): David Feliot
 * Contributor(s):
 */
package fr.dyade.aaa.jndi2.scn;

import java.util.Hashtable;
import javax.naming.Context;
import javax.naming.Name;
import javax.naming.NameNotFoundException;
import javax.naming.NameParser;
import javax.naming.NamingEnumeration;
import javax.naming.NamingException;
import javax.naming.OperationNotSupportedException;
import javax.naming.spi.InitialContextFactory;
import javax.naming.spi.ResolveResult;

import fr.dyade.aaa.jndi2.client.NamingContextFactory;

import org.objectweb.util.monolog.api.BasicLevel;
import org.objectweb.util.monolog.api.Logger;

/**
 * Context implementation for the "scn:comp" namespace.
 * Package must be named .../scn (See Initial Context)
 * Most operations consist of retrieving the actual CompNamingContext
 * and sending it the operation for processing.
 */
public class scnURLContext implements Context {

  public final static Logger logger;
  
  static {
    logger = fr.dyade.aaa.util.Debug.getLogger("fr.dyade.aaa.jndi2.scn");    
  }

  static private final String URL_PREFIX = "scn:comp/";
  static private final String ENV_PREFIX = "env";
    
  private Hashtable myEnv;
  private InitialContextFactory namingFactory;
    
  /**
   * Constructor
   */
  public scnURLContext(Hashtable env) throws NamingException {
    if (logger.isLoggable(BasicLevel.DEBUG))
      logger.log(BasicLevel.DEBUG, 
                 "scnURLContext.<init>(" + env + ')');
    if (env != null) {
      // clone env to be able to change it.
      myEnv = (Hashtable)env.clone();

      String factoryClassName = (String)myEnv.get("scn.naming.factory.class");
      if (factoryClassName == null) {
        namingFactory = new NamingContextFactory();
      } else {
        try {
          Class factoryClass = Class.forName(factoryClassName);
          namingFactory = 
            (InitialContextFactory)factoryClass.newInstance();
        } catch (Exception exc) {
          NamingException ne = new NamingException();
          ne.setRootCause(exc);
          throw ne;
        }
      }
    }
  }
  
  /*
   * get name without the url prefix
   */
  private String getRelativeName(String name) throws NamingException {
    // We suppose that all names must be prefixed as this
    if (!name.startsWith(URL_PREFIX)) {
      throw new NameNotFoundException("Invalid name:" + name);
    }

    name = name.substring(URL_PREFIX.length());
    return name;
  }

  /*
   * Resolve the name inside the javaURLContext
   * Result must be a Context + the name in this Context
   */
  private ResolveResult findContextFor(String name) throws NamingException {
    String rname = getRelativeName(name);
    Context context = null;

    if (rname.equals("")) {
      // null name refers to this context
      context = new scnURLContext(myEnv);
    } else {
      // other names are component independant
      context = namingFactory.getInitialContext(myEnv);
    }
    
    // Check context is not null to avoid nullPointerException
    if (context == null) {
      throw new NameNotFoundException("No context for this component");
    }
    
    // Build a ResolveResult object to return
    ResolveResult r = new ResolveResult(context, rname);
    return r;
  }

  // ------------------------------------------------------------------
  // Context implementation
  // ------------------------------------------------------------------

  /**
   * Retrieves the named object.
   *
   * @param name the name of the object to look up
   * @return	the object bound to name
   * @throws	NamingException if a naming exception is encountered
   */
  public Object lookup(Name name) throws NamingException {
    // Just use the string version for now.
    return lookup(name.toString());
  }

  /**
   * Retrieves the named object.
   *
   * @param name the name of the object to look up
   * @return	the object bound to name
   * @throws	NamingException if a naming exception is encountered
   */
  public Object lookup(String name) throws NamingException {
    if (logger.isLoggable(BasicLevel.DEBUG))
      logger.log(BasicLevel.DEBUG, 
                 "scnURLContext.lookup(" + name + ')');
    // Name empty: returns a new instance of this context.
    if (name.equals("")) {
      return new scnURLContext(myEnv);
    }

    // Retrieve the correct context to resolve the reminding name
    ResolveResult r = findContextFor(name);
    Context ctx = (Context) r.getResolvedObj();
    String rname = r.getRemainingName().toString();
    

    Object o =  ctx.lookup(rname);
    return o;
    ////////////////////////////
    // Resolve the name in its proper context
    //return ctx.lookup(rname);
  }
    
  /**
   * Binds a name to an object.
   *
   * @param name the name to bind; may not be empty
   * @param obj the object to bind; possibly null
   * @throws	NameAlreadyBoundException if name is already bound
   * @throws	javax.naming.directory.InvalidAttributesException
   *	 	if object did not supply all mandatory attributes
   * @throws	NamingException if a naming exception is encountered
   *
   * @see #bind(String, Object)
   * @see #rebind(Name, Object)
   * @see javax.naming.directory.DirContext#bind(Name, Object,
   *		javax.naming.directory.Attributes)
   */
  public void bind(Name name, Object obj) throws NamingException {
    // Just use the string version for now.
    bind(name.toString(), obj);
  }

  /**
   * Binds a name to an object.
   * All intermediate contexts and the target context (that named by all
   * but terminal atomic component of the name) must already exist.
   *
   * @param name
   *		the name to bind; may not be empty
   * @param obj
   *		the object to bind; possibly null
   * @throws	NameAlreadyBoundException if name is already bound
   * @throws	javax.naming.directory.InvalidAttributesException
   *	 	if object did not supply all mandatory attributes
   * @throws	NamingException if a naming exception is encountered
   */
  public void bind(String name, Object obj) throws NamingException {
    // Retrieve the correct context for this name
    ResolveResult r = findContextFor(name);
    Context ctx = (Context) r.getResolvedObj();
    String rname = r.getRemainingName().toString();

    // Bind the name in its proper context
    ctx.bind(rname, obj);
  }

  /**
   * Binds a name to an object, overwriting any existing binding.
   * All intermediate contexts and the target context (that named by all
   * but terminal atomic component of the name) must already exist.
   *
   * If the object is a DirContext, any existing attributes
   * associated with the name are replaced with those of the object.
   * Otherwise, any existing attributes associated with the name remain
   * unchanged.
   *
   * @param name
   *		the name to bind; may not be empty
   * @param obj
   *		the object to bind; possibly null
   * @throws	javax.naming.directory.InvalidAttributesException
   *	 	if object did not supply all mandatory attributes
   * @throws	NamingException if a naming exception is encountered
   *
   */
  public void rebind(Name name, Object obj) throws NamingException {
    // Just use the string version for now.
    rebind(name.toString(), obj);
  }

  /**
   * Binds a name to an object, overwriting any existing binding.
   * See {@link #rebind(Name, Object)} for details.
   *
   * @param name
   *		the name to bind; may not be empty
   * @param obj
   *		the object to bind; possibly null
   * @throws	javax.naming.directory.InvalidAttributesException
   *	 	if object did not supply all mandatory attributes
   * @throws	NamingException if a naming exception is encountered
   */
  public void rebind(String name, Object obj) throws NamingException {
    // Retrieve the correct context for this name
    ResolveResult r = findContextFor(name);
    Context ctx = (Context) r.getResolvedObj();
    String rname = r.getRemainingName().toString();

    // Rebind the name in its proper context
    ctx.rebind(rname, obj);
  }

  /**
   * Unbinds the named object.
   * Removes the terminal atomic name in name
   * from the target context--that named by all but the terminal
   * atomic part of name.
   *
   * This method is idempotent.
   * It succeeds even if the terminal atomic name
   * is not bound in the target context, but throws
   * NameNotFoundException
   * if any of the intermediate contexts do not exist.
   *
   * Any attributes associated with the name are removed.
   * Intermediate contexts are not changed.
   *
   * @param name
   *		the name to unbind; may not be empty
   * @throws	NameNotFoundException if an intermediate context does not exist
   * @throws	NamingException if a naming exception is encountered
   * @see #unbind(String)
   */
  public void unbind(Name name) throws NamingException {
    // Just use the string version for now.
    unbind(name.toString());
  }

  /**
   * Unbinds the named object.
   * See {@link #unbind(Name)} for details.
   *
   * @param name
   *		the name to unbind; may not be empty
   * @throws	NameNotFoundException if an intermediate context does not exist
   * @throws	NamingException if a naming exception is encountered
   */
  public void unbind(String name) throws NamingException {
    // Retrieve the correct context for this name
    ResolveResult r = findContextFor(name);
    Context ctx = (Context) r.getResolvedObj();
    String rname = r.getRemainingName().toString();

    // Unbind the name in its proper context
    ctx.unbind(rname);
  }

  /**
   * Binds a new name to the object bound to an old name, and unbinds
   * the old name. This operation is not supported (read only env.)
   *
   * @param oldName
   *		the name of the existing binding; may not be empty
   * @param newName
   *		the name of the new binding; may not be empty
   * @throws	NamingException if a naming exception is encountered
   */
  public void rename(Name oldName, Name newName) throws NamingException {
    // Just use the string version for now.
    rename(oldName.toString(), newName.toString());
  }

  /**
   * Binds a new name to the object bound to an old name, and unbinds
   * the old name. Not supported.
   *
   * @param oldName
   *		the name of the existing binding; may not be empty
   * @param newName
   *		the name of the new binding; may not be empty
   * @throws	NamingException if a naming exception is encountered
   */
  public void rename(String oldName, String newName) throws NamingException {
    throw new OperationNotSupportedException("Rename not supported in java:comp");
  }

  /**
   * Enumerates the names bound in the named context, along with the
   * class names of objects bound to them.
   * The contents of any subcontexts are not included.
   *
   * If a binding is added to or removed from this context,
   * its effect on an enumeration previously returned is undefined.
   *
   * @param name
   *		the name of the context to list
   * @return	an enumeration of the names and class names of the
   *		bindings in this context.  Each element of the
   *		enumeration is of type NameClassPair.
   * @throws	NamingException if a naming exception is encountered
   *
   * @see #list(String)
   * @see #listBindings(Name)
   * @see NameClassPair
   */
  public NamingEnumeration list(Name name) throws NamingException {
    // Just use the string version for now.
    return list(name.toString());
  }

  /**
   * Enumerates the names bound in the named context, along with the
   * class names of objects bound to them.
   * See {@link #list(Name)} for details.
   *
   * @param name
   *		the name of the context to list
   * @return	an enumeration of the names and class names of the