NamingManager.java

package org.objectweb.jonas.naming;

import java.util.Hashtable;

import javax.ejb.spi.HandleDelegate;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;

import org.omg.CORBA.ORB;

import org.objectweb.carol.jndi.spi.JacORBIIOPContext;

import org.objectweb.jonas_ejb.container.JHandleDelegate;

import org.objectweb.jonas_lib.naming.ContainerNaming;

import org.objectweb.jonas.common.Log;

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

public class NamingManager implements ContainerNaming {

    private static Logger logger = null;

    private ThreadLocal threadContext = new ThreadLocal();

    private InitialContext ictx = null;

    private static Context serverContext = null;

    private Hashtable myEnv = null;

    private Hashtable clBindings = null;

    private static Context clientCtx = null;

    private static NamingManager unique = null;

    private Object userTransaction = null;

    private HandleDelegate handleDelegate = null;

    private NamingManager() throws NamingException {
        logger = Log.getLogger(Log.JONAS_NAMING_PREFIX);
        try {
            ictx = new InitialContext();
            // there is a bug in carol that makes this not work.
            //myEnv = ictx.getEnvironment();
            clBindings = new Hashtable();

        } catch (NamingException n) {
            logger.log(BasicLevel.ERROR, "NamingManager: " + n.getExplanation());
            Throwable t = n.getRootCause();
            if (t != null) {
                if (t.getMessage().startsWith("Connection refused to host:")) {
                    logger.log(BasicLevel.ERROR, "NamingManager: rmi registry not started ?");
                } else if (t.getMessage().startsWith("error during remote invocation")) {
                    logger.log(BasicLevel.ERROR, "NamingManager: jrmi registry not started ?");
                } else {
                    logger.log(BasicLevel.ERROR, "NamingManager: " + t.getMessage());
                }
            }
            throw n;
        }

    }

    public static NamingManager getInstance() throws NamingException {
        if (unique == null) {
            unique = new NamingManager();
        }
        return unique;
    }

    // ------------------------------------------------------------------
    // ContainerNaming implementation
    // ------------------------------------------------------------------

    public InitialContext getInitialContext() {
        return ictx;
    }

    public HandleDelegate getHandleDelegate() {
        if (handleDelegate == null) {
            handleDelegate = new JHandleDelegate();
        }
        return handleDelegate;
    }

    public Context createEnvironmentContext(String namespace) throws NamingException {

        logger.log(BasicLevel.DEBUG, namespace);
        
        // Create a new environment
        CompNamingContext ctx = new CompNamingContext(namespace);

        // Create subContext
        Context compCtx = ctx.createSubcontext("comp");

        // Bind java:comp/UserTransaction
        if (userTransaction == null) {
            try {
                userTransaction = ictx.lookup("javax.transaction.UserTransaction");
            } catch (NamingException ne) {
                if (logger.isLoggable(BasicLevel.DEBUG)) {
                    logger.log(BasicLevel.DEBUG, "Cannot lookup UserTransaction.");
                }
            }
        }
        if (userTransaction != null) {
            compCtx.rebind("UserTransaction", userTransaction);
        }

        ORB orb = JacORBIIOPContext.getOrb();
        if (orb != null) {
            try {
                // Bind the java:comp/ORB object instance
                compCtx.rebind("ORB", orb);
            } catch (NamingException e) {
                String err = "Cannot create URL for java:comp/ORB object : " + e;
                logger.log(BasicLevel.ERROR, err);
                throw new NamingException(err);
            }
        }

        // Bind java:comp/HandleDelegate
        compCtx.rebind("HandleDelegate", getHandleDelegate());

        return ctx;
    }

    public Context getComponentContext() throws NamingException {

        Context ctx = null;

        // Check if there is a context to the local thread
        // For ejbs
        ctx = (Context) threadContext.get();
        if (ctx != null) {
            logger.log(BasicLevel.DEBUG, "return Context for ejb");
            return ctx;
        }

        // Check if there is a context which match the currentThread
        // classLoader
        // For webapps
        ClassLoader cl = Thread.currentThread().getContextClassLoader();
        if ((cl != null) && (cl.getParent() != null)) {
            ctx = (Context) clBindings.get(cl.getParent());
            if (ctx != null) {
                logger.log(BasicLevel.DEBUG, "return Context for webapp");
                return ctx;
            }
        }

        // Check static context. use in client. One context per JVM.
        if (clientCtx != null) {
            ctx = clientCtx;
            if (ctx != null) {
                logger.log(BasicLevel.DEBUG, "return Context for client");
                return ctx;
            }
        }

        // No context found. This is outside of a j2ee component or server
        // component.
        if (ctx == null) {
            ctx = getServerContext();
            logger.log(BasicLevel.DEBUG, "return default server Context");
        }
        return ctx;
    }

    public Context setComponentContext(Context ctx) {
        if (logger.isLoggable(BasicLevel.DEBUG)) {
            if (ctx == null) {
                logger.log(BasicLevel.DEBUG, "reset to null");
            } else {
                try {
                    logger.log(BasicLevel.DEBUG, "name = " + ctx.getNameInNamespace());
                } catch (NamingException e) {
                    logger.log(BasicLevel.ERROR, "bad name");
                }
            }
        }
        Context ret = (Context) threadContext.get();
        threadContext.set(ctx);
        return ret;
    }

    public void setComponentContext(Context ctx, ClassLoader cl) {
        if (logger.isLoggable(BasicLevel.DEBUG)) {
            logger.log(BasicLevel.DEBUG, "class loader = " + cl);
        }
        clBindings.put(cl, ctx);
    }

    public void setClientContainerComponentContext(Context ctx) {
        logger.log(BasicLevel.DEBUG, "");
        clientCtx = ctx;
    }

    public Context getComponentContext(ClassLoader cl) {
        if (logger.isLoggable(BasicLevel.DEBUG)) {
            logger.log(BasicLevel.DEBUG, "class loader = " + cl);
        }
        return (Context) clBindings.get(cl);
    }

    public void unSetComponentContext(ClassLoader cl) {
        if (logger.isLoggable(BasicLevel.DEBUG)) {
            logger.log(BasicLevel.DEBUG, "class loader = " + cl);
        }
        clBindings.remove(cl);
    }

    public Hashtable getEnv() {
        return myEnv;
    }

    public Context createImmutableEnvironmentContext(String namespace) throws NamingException {
        logger.log(BasicLevel.ERROR, "Not Implemented");
        return null;
    }

    // ------------------------------------------------------------------
    // other proprietary methods
    // ------------------------------------------------------------------

    public Context getServerContext() {
        if (serverContext == null) {
            try {
                serverContext = createEnvironmentContext("server");
            } catch (NamingException e) {
                logger.log(BasicLevel.ERROR, "cannot create serverContext:" + e);
             }
        }
        return serverContext;
    }

}

---