CompNamingContext.java

package org.objectweb.jonas.naming;

import java.util.Enumeration;
import java.util.Hashtable;
import java.util.NoSuchElementException;

import javax.naming.Binding;
import javax.naming.CompositeName;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.InvalidNameException;
import javax.naming.LinkRef;
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;
import javax.naming.RefAddr;
import javax.naming.Reference;

import org.objectweb.jonas.common.Log;
import org.objectweb.util.monolog.api.BasicLevel;
import org.objectweb.util.monolog.api.Logger;

public class CompNamingContext implements Context {

    private static Logger logger = null;

    private Hashtable myEnv = null;

    private Hashtable bindings = new Hashtable();

    private static NameParser myParser = new EJBNameParser();

    private String compId;

    public CompNamingContext(String id, Hashtable env) {
        if (env != null) {
            // clone env to be able to change it.
            myEnv = (Hashtable) (env.clone());
        }
        compId = id;
        logger = Log.getLogger(Log.JONAS_NAMING_PREFIX);
    }

    public CompNamingContext(String id) {
        myEnv = new Hashtable();
        compId = id;
        logger = Log.getLogger(Log.JONAS_NAMING_PREFIX);
    }

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

    public Object lookup(Name name) throws NamingException {
        // Just use the string version for now.
        return lookup(name.toString());
    }

    public Object lookup(String name) throws NamingException {
        logger.log(BasicLevel.DEBUG, name);

        Name n = new CompositeName(name);
        if (n.size() < 1) {
            // Empty name means this context
            logger.log(BasicLevel.DEBUG, "empty name");
            return this;
        }

        if (n.size() == 1) {
            // leaf in the env tree
            Object ret = bindings.get(name);
            if (ret == null) {
                logger.log(BasicLevel.DEBUG, " " + name + " not found.");
                throw new NameNotFoundException(name);
            }
            if (ret instanceof LinkRef) {
                // Handle special case of the LinkRef since I think
                // it's not handled by std NamingManager.getObjectInstance().
                // The name hidden in linkref is in the initial context.

                InitialContext ictx = NamingManager.getInstance().getInitialContext();
                RefAddr ra = ((Reference) ret).get(0);
                try {
                    ret = ictx.lookup((String) ra.getContent());
                } catch (Exception e) {
                    NamingException ne = new NamingException(e.getMessage());
                    ne.setRootCause(e);
                    logger.log(BasicLevel.WARN, "unexpected exception " + e.getMessage());
                    throw ne;
                }
            } else if (ret instanceof Reference) {
                //Use NamingManager to build an object
                try {
                    Object o = javax.naming.spi.NamingManager.getObjectInstance(ret, n, this, myEnv);
                    ret = o;
                } catch (NamingException e) {
                    throw e;
                } catch (Exception e) {
                    NamingException ne = new NamingException(e.getMessage());
                    ne.setRootCause(e);
                    throw ne;
                }
                if (ret == null) {
                    logger.log(BasicLevel.WARN, "Can not build an object with the reference " + name);
                    throw new NamingException("Can not build an object with the reference '" + name  + "'");
                }
            }
            return ret;
        } else {
            // sub context in the env tree
            String suffix = n.getSuffix(1).toString();
            // should throw exception if sub context not found!
            Context subctx = lookupCtx(n.get(0));
            return subctx.lookup(suffix);
        }
    }

    public void bind(Name name, Object obj) throws NamingException {
        // Just use the string version for now.
        bind(name.toString(), obj);
    }

    public void bind(String name, Object obj) throws NamingException {

        logger.log(BasicLevel.DEBUG, name);

        Name n = new CompositeName(name);
        if (n.size() < 1) {
            logger.log(BasicLevel.ERROR, "CompNamingContext bind empty name ?");
            throw new InvalidNameException("CompNamingContext cannot bind empty name");
        }

        if (n.size() == 1) {
            // leaf in the env tree
            if (bindings.get(name) != null) {
                logger.log(BasicLevel.ERROR, "CompNamingContext: trying to overbind");
                throw new NameAlreadyBoundException("CompNamingContext: Use rebind to bind over a name");
            }
            bindings.put(name, obj);
        } else {
            // sub context in the env tree
            String suffix = n.getSuffix(1).toString();
            // must create the subcontext first if it does not exist yet.
            Context subctx;
            try {
                subctx = lookupCtx(n.get(0));
            } catch (NameNotFoundException e) {
                subctx = createSubcontext(n.get(0));
            }
            subctx.bind(suffix, obj);
        }
    }

    public void rebind(Name name, Object obj) throws NamingException {
        // Just use the string version for now.
        rebind(name.toString(), obj);
    }

    public void rebind(String name, Object obj) throws NamingException {

        logger.log(BasicLevel.DEBUG, name);

        Name n = new CompositeName(name);
        if (n.size() < 1) {
            logger.log(BasicLevel.ERROR, "CompNamingContext rebind empty name ?");
            throw new InvalidNameException("CompNamingContext cannot rebind empty name");
        }

        if (n.size() == 1) {
            // leaf in the env tree
            bindings.put(name, obj);
        } else {
            // sub context in the env tree
            String suffix = n.getSuffix(1).toString();
            // must create the subcontext first if it does not exist yet.
            Context subctx;
            try {
                subctx = lookupCtx(n.get(0));
            } catch (NameNotFoundException e) {
                subctx = createSubcontext(n.get(0));
            }
            subctx.rebind(suffix, obj);
        }
    }

    public void unbind(Name name) throws NamingException {
        // Just use the string version for now.
        unbind(name.toString());
    }

    public void unbind(String name) throws NamingException {

        logger.log(BasicLevel.DEBUG, name);

        Name n = new CompositeName(name);
        if (n.size() < 1) {
            logger.log(BasicLevel.ERROR, "CompNamingContext unbind empty name ?");
            throw new InvalidNameException("CompNamingContext cannot unbind empty name");
        }

        if (n.size() == 1) {
            // leaf in the env tree
            if (bindings.get(name) == null) {
                logger.log(BasicLevel.ERROR, "CompNamingContext nothing to unbind");
                throw new NameNotFoundException(name);
            }
            bindings.remove(name);
        } else {
            // sub context in the env tree
            String suffix = n.getSuffix(1).toString();
            // should throw exception if sub context not found!
            Context subctx = lookupCtx(n.get(0));
            subctx.unbind(suffix);
        }
    }

    public void rename(Name oldName, Name newName) throws NamingException {
        // Just use the string version for now.
        rename(oldName.toString(), newName.toString());
    }

    public void rename(String oldName, String newName) throws NamingException {

        logger.log(BasicLevel.ERROR, "CompNamingContext rename " + oldName + " in " + newName);

        Object obj = lookup(oldName);
        rebind(newName, obj);
        unbind(oldName);
    }

    public NamingEnumeration list(Name name) throws NamingException {
        // Just use the string version for now.
        return list(name.toString());
    }

    public NamingEnumeration list(String name) throws NamingException {

        logger.log(BasicLevel.DEBUG, name);

        if (name.length() == 0) {
            // List this context
            return new ListOfNames(bindings);
        }
        Object obj = lookup(name);
        if (obj instanceof Context) {
            return ((Context) obj).list("");
        } else {
            logger.log(BasicLevel.ERROR, "CompNamingContext: can only list a Context");
            throw new NotContextException(name);
        }
    }

    public NamingEnumeration listBindings(Name name) throws NamingException {
        // Just use the string version for now.
        return listBindings(name.toString());
    }

    public NamingEnumeration listBindings(String name) throws NamingException {

        logger.log(BasicLevel.DEBUG, name);

        if (name.length() == 0) {
            // List this context
            return new ListOfBindings(bindings);
        }
        Object obj = lookup(name);
        if (obj instanceof Context) {
            return ((Context) obj).listBindings("");
        } else {
            logger.log(BasicLevel.ERROR, "CompNamingContext: can only list a Context");
            throw new NotContextException(name);
        }
    }

    public void destroySubcontext(Name name) throws NamingException {
        // Just use the string version for now.
        destroySubcontext(name.toString());
    }

    public void destroySubcontext(String name) throws NamingException {

        logger.log(BasicLevel.ERROR, "CompNamingContext try to destroySubcontext " + name);

        throw new OperationNotSupportedException("CompNamingContext: destroySubcontext");
    }

    public Context createSubcontext(Name name) throws NamingException {
        // Just use the string version for now.
        return createSubcontext(name.toString());
    }

    public Context createSubcontext(String name) throws NamingException {

        logger.log(BasicLevel.DEBUG, name);

        Name n = new CompositeName(name);
        if (n.size() < 1) {
            logger.log(BasicLevel.ERROR, "CompNamingContext createSubcontext with empty name ?");
            throw new InvalidNameException("CompNamingContext cannot create empty Subcontext");
        }

        Context ctx = null; // returned ctx
        if (n.size() == 1) {
            // leaf in the env tree: create ctx and bind it in parent.
            ctx = new CompNamingContext(compId, myEnv);
            bindings.put(name, ctx);
        } else {
            // as for bind, we must create first all the subcontexts
            // if they don't exist yet.
            String suffix = n.getSuffix(1).toString();
            Context subctx;
            name = n.get(0);
            try {
                subctx = lookupCtx(name);
            } catch (NameNotFoundException e) {
                subctx = createSubcontext(name);
            }
            ctx = subctx.createSubcontext(suffix);
        }
        return ctx;
    }

    public Object lookupLink(Name name) throws NamingException {
        // Just use the string version for now.
        return lookupLink(name.toString());
    }

    public Object lookupLink(String name) throws NamingException {

        logger.log(BasicLevel.DEBUG, name);

        // To be done. For now: just return the object
        logger.log(BasicLevel.ERROR, "CompNamingContext lookupLink not implemented yet!");
        return lookup(name);
    }

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

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

    public Name composeName(Name name, Name prefix) throws NamingException {

        logger.log(BasicLevel.ERROR, "CompNamingContext composeName not implemented!");
        throw new OperationNotSupportedException("CompNamingContext composeName");
    }

    public String composeName(String name, String prefix) throws NamingException {

        logger.log(BasicLevel.ERROR, "CompNamingContext composeName " + name + " " + prefix);

        throw new OperationNotSupportedException("CompNamingContext composeName");
    }

    public Object addToEnvironment(String propName, Object propVal) throws NamingException {

        logger.log(BasicLevel.DEBUG, propName);

        if (myEnv == null) {
            myEnv = new Hashtable();
        }
        return myEnv.put(propName, propVal);
    }

    public Object removeFromEnvironment(String propName) throws NamingException {

        logger.log(BasicLevel.DEBUG, propName);

        if (myEnv == null) {
            return null;
        }
        return myEnv.remove(propName);
    }

    public Hashtable getEnvironment() throws NamingException {

        logger.log(BasicLevel.DEBUG, "");

        if (myEnv == null) {
            myEnv = new Hashtable();
        }
        return myEnv;
    }

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

    public String getNameInNamespace() {
        // this is used today for debug only.
        return compId;
    }

    // ------------------------------------------------------------------
    // Private Methods
    // ------------------------------------------------------------------

    private Context lookupCtx(String name) throws NamingException {
        Object obj = bindings.get(name);
        if (obj == null) {
            throw new NameNotFoundException();
        }
        if (obj instanceof CompNamingContext) {
            return (Context) obj;
        } else {
            throw new NameAlreadyBoundException(name);
        }
    }

    // ------------------------------------------------------------------
    // Inner classes for enumerating lists of bindings
    // ------------------------------------------------------------------

    class ListOfNames implements NamingEnumeration {
        protected Enumeration names;
        protected Hashtable bindings;

        // Constructor. Called by list()
        // copy bindings locally in this object and build an
        // enumeration of the keys.

        ListOfNames (Hashtable bindings) {
            this.bindings = bindings;
            this.names = bindings.keys();
        }

        // Methods implementing NamingEnumeration interface:
        // - hasMore
        // - next
        // - close
        public boolean hasMore() throws NamingException {
            return names.hasMoreElements();
        }

        public Object next() throws NamingException {
            String name = (String) names.nextElement();
            String className = bindings.get(name).getClass().getName();
            return new NameClassPair(name, className);
        }

        public void close() {
        }

        // Methods inherited from Enumeration:
        // - nextElement
        // - hasMoreElements

        public Object nextElement() {
            try {
                return next();
            } catch (NamingException e) {
                throw new NoSuchElementException(e.toString());
            }
        }

        public boolean hasMoreElements() {
            try {
                return hasMore();
            } catch (NamingException e) {
                return false;
            }
        }

    }

    class ListOfBindings extends ListOfNames {

        ListOfBindings (Hashtable bindings) {
            super(bindings);
        }

        // next() is the only different method.
        // It returns a Binding instead of a NameClassPair
        public Object next() throws NamingException {
            String name = (String) names.nextElement();
            return new Binding(name, this.bindings.get(name));
        }
    }
}

---