JContainer.java

package org.objectweb.jonas_ejb.container;

import java.lang.reflect.Method;
import java.util.Collections;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Properties;
import java.util.Set;

import javax.ejb.AccessLocalException;
import javax.ejb.EJBException;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.LinkRef;
import javax.naming.NamingException;
import javax.naming.Reference;
import javax.naming.StringRefAddr;
import javax.resource.spi.ActivationSpec;
import javax.security.jacc.PolicyContext;

import org.objectweb.jonas.common.JProp;
import org.objectweb.jonas.resource.Rar;
import org.objectweb.jonas.ws.JServiceFactory;
import org.objectweb.jonas.ws.JServiceFactoryFinder;
import org.objectweb.jonas_ejb.container.jorm.RdbFactory;
import org.objectweb.jonas_ejb.deployment.api.BeanDesc;
import org.objectweb.jonas_ejb.deployment.api.EntityBmpDesc;
import org.objectweb.jonas_ejb.deployment.api.EntityCmpDesc;
import org.objectweb.jonas_ejb.deployment.api.EntityDesc;
import org.objectweb.jonas_ejb.deployment.api.EntityJdbcCmp1Desc;
import org.objectweb.jonas_ejb.deployment.api.EntityJdbcCmp2Desc;
import org.objectweb.jonas_ejb.deployment.api.MessageDrivenDesc;
import org.objectweb.jonas_ejb.deployment.api.SessionStatefulDesc;
import org.objectweb.jonas_ejb.deployment.api.SessionStatelessDesc;
import org.objectweb.jonas_ejb.lib.EJBInvocation;

import org.objectweb.jonas_lib.deployment.api.EjbLocalRefDesc;
import org.objectweb.jonas_lib.deployment.api.EjbRefDesc;
import org.objectweb.jonas_lib.deployment.api.EnvEntryDesc;
import org.objectweb.jonas_lib.deployment.api.MessageDestinationRefDesc;
import org.objectweb.jonas_lib.deployment.api.ResourceEnvRefDesc;
import org.objectweb.jonas_lib.deployment.api.ResourceRefDesc;
import org.objectweb.jonas_lib.naming.ContainerNaming;
import org.objectweb.jonas_lib.security.PermissionManagerException;

import org.objectweb.jonas_jms.api.JmsManager;

import org.objectweb.jonas_ws.deployment.api.ServiceRefDesc;

import org.objectweb.transaction.jta.TransactionManager;

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

public class JContainer implements Container {

    public static final String DEFAULT_FACTORY_CLASS_NAME = "org.objectweb.jonas_ejb.container.JEntityFactory";

    private static final int DEFAULT_THREAD_POOL_SIZE = 10;

    private static ThreadPool threadpool = null;

    private HashMap beanList = new HashMap();

    private String earFileName = null;

    private String fileName;

    private String externalFileName;

    private JmsManager jms = null;

    private ClassLoader loader = null;

    private int maxthreadpoolsize = ThreadPool.DEFAULT_POOL_MAX_SIZE;

    private String myname;

    private ContainerNaming naming = null;

    private PermissionManager permissionManager = null;

    private PrincipalFactory principalFactory = null;

    private boolean securityFlag = true;

    private JStatefulPool statefulSessionPool = null;

    private Swapper swapper;

    private int threadpoolsize = DEFAULT_THREAD_POOL_SIZE;

    private TransactionManager tm = null;

    private static final String DEFAULT_ACTIVATION_SPEC_NAME = "joramActivationSpec";

    public JContainer(String name, String extFileName, String file, ClassLoader ld) {
        myname = name;
        externalFileName = extFileName;
        fileName = file;
        loader = ld;
        swapper = new Swapper(this);
        swapper.start();
        TraceEjb.interp.log(BasicLevel.DEBUG, "New Container extFN= " + externalFileName + " filename=" + fileName);
    }

    // -------------------------------------------------------------------
    // Methods used by JOnAS Server (but not part of JContainer interface)
    // -------------------------------------------------------------------

    public synchronized BeanFactory addBean(BeanDesc dd) {
        BeanFactory bf = null;
        String beanName = dd.getEjbName();
        if (dd instanceof SessionStatefulDesc) {
            TraceEjb.interp.log(BasicLevel.DEBUG, "add SessionStatefulBean " + beanName);
            if (statefulSessionPool == null) {
                statefulSessionPool = new JStatefulPool();
            }
            bf = new JStatefulFactory((SessionStatefulDesc) dd, this, statefulSessionPool);
        } else if (dd instanceof SessionStatelessDesc) {
            TraceEjb.interp.log(BasicLevel.DEBUG, "add SessionStatelessBean " + beanName);
            bf = new JStatelessFactory((SessionStatelessDesc) dd, this);
        } else if (dd instanceof MessageDrivenDesc) {
            TraceEjb.interp.log(BasicLevel.DEBUG, "add MessageDrivenBean " + beanName);
            Object obj = null;
            InitialContext ictx = null;
            String destJName = ((MessageDrivenDesc) dd).getDestinationJndiName();
            try {
                ictx = naming.getInitialContext();
                obj = ictx.lookup(destJName);
            } catch (Exception ex) {
                TraceEjb.interp.log(BasicLevel.DEBUG, "Can not find destination JNDI name " + destJName);
            }
            if (obj != null && obj instanceof ActivationSpec) {
                bf = new JMdbEndpointFactory((MessageDrivenDesc) dd, this, (ActivationSpec) obj);
            } else if (getJmsManager() == null) {
                // This is the case where we need to attach the MDB to an RAR, but it is either configured
                // as an EJB 2.0 MDB or incorrectly for a 2.1 MDB.
                if (((MessageDrivenDesc)  dd).getDestination() != null) {
                    TraceEjb.interp.log(BasicLevel.DEBUG, "JMS service not started and specified ActivationSpec(" + destJName + ") not deployed");
                    throw new EJBException("JMS service not started and specified ActivationSpec(" + destJName + ") not deployed");
                }

                // Get the default ActivationSpec name and attempt to configure it
                String dest = Rar.getDefaultAS();  //default name
                if (dest == null) {
                    dest = DEFAULT_ACTIVATION_SPEC_NAME;  //default name
                }

                try {
                    obj = ictx.lookup(dest);
                } catch (Exception ex) {
                    TraceEjb.interp.log(BasicLevel.DEBUG, "JMS service not started and default ActivationSpec(" + dest + ") not deployed");
                    throw new EJBException("JMS service not started and default ActivationSpec(" + dest + ") not deployed", ex);
                }
                if (obj != null && obj instanceof ActivationSpec) {
                    bf = new JMdbEndpointFactory((MessageDrivenDesc) dd, dest, this, (ActivationSpec) obj);
                } else {
                    TraceEjb.interp.log(BasicLevel.DEBUG, "Invalid destination: No ActivationSpec deployed matching " + dest);
                    throw new EJBException("Invalid destination: No ActivationSpec deployed matching " + dest);
                }
            } else {
                // This is the case where a 2.1 MDB is trying to connect to an RAR that isn't deployed
                if (((MessageDrivenDesc)  dd).getDestination() != null) {
                    TraceEjb.interp.log(BasicLevel.DEBUG, "JMS service started and specified ActivationSpec(" + destJName + ") not deployed");
                    throw new EJBException("JMS service started and specified ActivationSpec(" + destJName + ") not deployed");
                }
                if (threadpool == null) {
                    threadpool = new ThreadPool(threadpoolsize, maxthreadpoolsize);
                }
                bf = new JMdbFactory((MessageDrivenDesc) dd, this, threadpool);
            }
        } else if (dd instanceof EntityJdbcCmp2Desc) {
            EntityJdbcCmp2Desc ecd = (EntityJdbcCmp2Desc) dd;
            // TODO We only manage "Jdbc" CMP2 entity beans today.
            TraceEjb.interp.log(BasicLevel.DEBUG, "add CMP2 EntityBean " + beanName);
            // Instanciate the Factory depending on the mapper
            String cn = null;
            try {
                String dsn = ecd.getDatasourceJndiName();
                // Pb: We need the mapper to instanciate the Factory.
                // The mapper is in the Datasource. No way to get it in a
                // standard way
                // since Datasource interface is very simple (getConnection()
                // only)
                //
                // This will now try to call a getMapperName method for the
                // datasource,
                // if it doesn't exist then get the mapper.properties file and
                // look for the
                // jndiname. This allows flexibility for additional data source
                // support,
                // but still is not perfect.

                InitialContext ictx = naming.getInitialContext();
                String mapperName = null;
                // Attempt to call getMapperName method and if it doesn't exist
                // then
                // read the mapper.properties file
                try {
                    Object cls = ictx.lookup(dsn);
                    Method meth = cls.getClass().getMethod("getMapperName", (Class[]) null);
                    mapperName = (String) meth.invoke(cls, (Object[]) null);
                } catch (Exception e1) {
                    TraceEjb.interp.log(BasicLevel.DEBUG, "Cannot read mapper name : " + e1.getMessage());
                }
                if (mapperName == null || mapperName.trim().length() == 0) {
                    // Method doesn't exist so go read mapper.properties and
                    // look for jndiname mapping
                    try {
                        JProp dsProps = JProp.getInstance("mapper");
                        mapperName = dsProps.getValue(dsn, "");
                    } catch (Exception e2) {
                        throw new EJBException("Unable to retrieve mapperName for " + dsn);
                    }
                    if (mapperName == null) {
                        throw new EJBException("Unable to retrieve mapperName for " + dsn);
                    }
                }

                cn = ecd.getFactoryClassName();
                bf = (JEntityFactory) loader.loadClass(cn).newInstance();
                ((RdbFactory) bf).init(ecd, this, mapperName);
                setSwapTime(((EntityDesc) ecd).getPassivationTimeout());
                TraceEjb.interp.log(BasicLevel.INFO, beanName + " is loaded and using " + mapperName);
            } catch (Exception e) {
                TraceEjb.interp.log(BasicLevel.ERROR, "Impossible to instanciate the entity factory: " + cn, e);
                throw new EJBException("Impossible to instanciate the entity factory: " + cn, e);
            }
        } else if (dd instanceof EntityDesc) {
            TraceEjb.interp.log(BasicLevel.DEBUG, "add EntityBean " + beanName);
            // Instanciate the default factory
            String cn = null;
            try {
                cn = DEFAULT_FACTORY_CLASS_NAME;
                bf = (JEntityFactory) loader.loadClass(cn).newInstance();
            } catch (Exception e) {
                throw new EJBException("Impossible to instanciate the specified entity factory: " + cn, e);
            }
            ((JEntityFactory) bf).init((EntityDesc) dd, this);
            setSwapTime(((EntityDesc) dd).getPassivationTimeout());
        } else {
            throw new EJBException("Bad Descriptor Type for " + beanName);
        }
        beanList.put(beanName, bf);
        TraceEjb.interp.log(BasicLevel.INFO, beanName + " available");
        return bf;
    }

    private Set beansDependence(Enumeration beanFactories, String rName, boolean isResRef) {
        HashSet result = new HashSet();
        BeanFactory bf = null;
        while (beanFactories.hasMoreElements()) {
            // for each bean,
            bf = (BeanFactory) beanFactories.nextElement();
            BeanDesc ejbDesc = bf.getDeploymentDescriptor();

            boolean isDependent = false; // suppose its not dependent

            // get its type from the DeploymentDescriptor
            String ejbType = null;
            if (bf instanceof JEntityFactory) {
                if (ejbDesc instanceof EntityBmpDesc) {
                    ejbType = "ejbbmp";
                }
                if (ejbDesc instanceof EntityCmpDesc) {
                    ejbType = "ejbcmp";
                }
            } else if (bf instanceof JStatefulFactory) {
                ejbType = "ejbsbf";
            } else if (bf instanceof JStatelessFactory) {
                ejbType = "ejbsbl";
            } else if (bf instanceof JMdbFactory || bf instanceof JMdbEndpointFactory) {
                ejbType = "ejbmdb";
            }

            if (isResRef) {
                // if this is a cmp bean, directly compare rName with the data
                // source JNDI name
                // from its deployment descriptor
                if (ejbType.equals("ejbcmp")) {
                    String jndiName = null;
                    if (ejbDesc instanceof EntityJdbcCmp1Desc) {
                        jndiName = ((EntityJdbcCmp1Desc) ejbDesc).getDatasourceJndiName();
                    } else if (ejbDesc instanceof EntityJdbcCmp2Desc) {
                        jndiName = ((EntityJdbcCmp2Desc) ejbDesc).getDatasourceJndiName();
                    }
                    isDependent = rName.equals(jndiName);
                }
                // get the description of the bean's resource-refs
                ResourceRefDesc[] rrDesc = ejbDesc.getResourceRefDesc();
                for (int i = 0; i < rrDesc.length; i++) {
                    // for each resource-ref compare its name with rName
                    if (rrDesc[i].getJndiName().equals(rName)) {
                        isDependent = true;
                        break;
                    }
                }
            } else {
                if (ejbType.equals("ejbmdb")) {
                    if (rName.equals(((MessageDrivenDesc) ejbDesc).getDestinationJndiName())) {
                        isDependent = true;
                    }
                }
                // get the description of the bean's resource-env-refs
                ResourceEnvRefDesc[] rerDesc = ejbDesc.getResourceEnvRefDesc();
                for (int i = 0; i < rerDesc.length; i++) {
                    // for each resource-env-ref compare its name with rName
                    if (rerDesc[i].getJndiName().equals(rName)) {
                        isDependent = true;
                        break;
                    }
                }
            }

            if (isDependent) {
                Properties toAdd = new Properties();
                toAdd.setProperty("type", ejbType);
                toAdd.setProperty("fname", getFileName());
                toAdd.setProperty("name", ejbDesc.getEjbName());
                toAdd.setProperty("cname", getName());
                String earFileName = getEarFileName();
                if (earFileName != null) {
                    toAdd.setProperty("earFileName", earFileName);
                }
                result.add(toAdd);
            }

        }
        return result;
    }

    protected void checkSecurity(String ejbName, EJBInvocation ejbInv, boolean inRunAs) {
        String oldContextId = PolicyContext.getContextID();

        boolean accessIsOk = false;
        try {
            // Set contextID to PermissionManager contextID (EJB ContextID)
            if (permissionManager != null) {
                accessIsOk = permissionManager.checkSecurity(ejbName, ejbInv, inRunAs);
            }
        } catch (Exception e) {
            TraceEjb.security.log(BasicLevel.ERROR, "Error while checking security : '" + e.getMessage() + "'.");
        } finally {
            PolicyContext.setContextID(oldContextId);
        }
        if (!accessIsOk) {
            throw new AccessLocalException("Access Denied");
        }

    }

    public BeanFactory getBeanFactory(String ejbName) {
        return (BeanFactory) beanList.get(ejbName);
    }

    public int getBeanNb() {
        return beanList.size();
    }

    public ClassLoader getClassLoader() {
        if (loader == null) {
            TraceEjb.logger.log(BasicLevel.ERROR, "container has been removed");
            //return Thread.currentThread().getContextClassLoader();
            return null;
        } else {
            return loader;
        }
    }

    public ContainerNaming getContainerNaming() {
        return naming;
    }

    public Set getDataSourceDependence(String dsName) {
        // the true param corresponds to a resource-ref
        return beansDependence(Collections.enumeration(beanList.values()), dsName, true);
    }

    public String getEarFileName() {
        return earFileName;
    }

    public int getEntityBMPNb() {
        BeanFactory bf;
        int total = 0;
        Iterator it = beanList.values().iterator();
        while (it.hasNext()) {
            bf = (BeanFactory) it.next();
            if (bf.getDeploymentDescriptor() instanceof EntityBmpDesc) {
                total++;
            }
        }
        return total;
    }

    public int getEntityCMPNb() {
        BeanFactory bf;
        int total = 0;
        Iterator it = beanList.values().iterator();
        while (it.hasNext()) {
            bf = (BeanFactory) it.next();
            if (bf.getDeploymentDescriptor() instanceof EntityCmpDesc) {
                total++;
            }
        }
        return total;
    }

    public String getFileName() {
        return fileName;
    }

    public String getExternalFileName() {
        return externalFileName;
    }

    public Set getJmsConnectionFactoryDependence(String cfName) {
        // the true param corresponds to a resource-ref
        return beansDependence(Collections.enumeration(beanList.values()), cfName, true);
    }

    public Set getJmsDestinationDependence(String destName) {
        // the true param corresponds to a resource-ref
        return beansDependence(Collections.enumeration(beanList.values()), destName, false);
    }

    public JmsManager getJmsManager() {
        return jms;
    }

    public Set getMailFactoryDependence(String mfName) {
        // the true param corresponds to a resource-ref
        return beansDependence(Collections.enumeration(beanList.values()), mfName, true);
    }

    public int getMaxThreadPoolSize() {
        return maxthreadpoolsize;
    }

    public int getMessageDrivenNb() {
        BeanFactory bf;
        int total = 0;
        Iterator it = beanList.values().iterator();
        while (it.hasNext()) {
            bf = (BeanFactory) it.next();
            if (bf.getDeploymentDescriptor() instanceof MessageDrivenDesc) {
                total++;
            }
        }
        return total;
    }

    public String getName() {
        return myname;
    }

    public PermissionManager getPermissionManager() {
        return permissionManager;
    }

    public PrincipalFactory getPrincipalFactory() {
        return principalFactory;
    }

    public int getStatefulSessionNb() {
        BeanFactory bf;
        int total = 0;
        Iterator it = beanList.values().iterator();
        while (it.hasNext()) {
            bf = (BeanFactory) it.next();
            if (bf.getDeploymentDescriptor() instanceof SessionStatefulDesc) {
                total++;
            }
        }
        return total;
    }

    public int getStatelessSessionNb() {
        BeanFactory bf;
        int total = 0;
        Iterator it = beanList.values().iterator();
        while (it.hasNext()) {
            bf = (BeanFactory) it.next();
            if (bf.getDeploymentDescriptor() instanceof SessionStatelessDesc) {
                total++;
            }
        }
        return total;
    }

    public int getSwapTime() {
        return swapper.getSwapperTimeout();
    }

    public TransactionManager getTransactionManager() {
        return tm;
    }

    public boolean isInEarCase() {
        return (earFileName != null);
    }

    // ---------------------------------------------------------------
    // Container Implementation
    // ---------------------------------------------------------------

    public String[] listBeanNames() {
        return (String[]) beanList.keySet().toArray(new String[0]);
    }

    // -------------------------------------------------------------------
    // Other public methods, used internally in this package.
    // -------------------------------------------------------------------

    public void registerBF(BeanFactory bf) {
        swapper.addBeanFactory(bf);
    }

    public void registerBFS(BeanFactory bf) {
        swapper.addBeanFactorySync(bf);
    }

    public synchronized void remove() {
        TraceEjb.interp.log(BasicLevel.DEBUG, myname);

        // Stop the swapper.
        swapper.stopIt();

        // synchronize all entity beans before removing them.
        // must be done here, not in the swapper.
        syncAll(false);

        // remove all factories
        Iterator it = beanList.values().iterator();
        while (it.hasNext()) {
            BeanFactory bf = (BeanFactory) it.next();
            try {
                bf.stop();
                TraceEjb.interp.log(BasicLevel.INFO, myname + ": " + bf.getEJBName() + " no longer available");
            } catch (Exception e) {
                TraceEjb.logger.log(BasicLevel.ERROR, myname, e);
            }
        }
        beanList.clear();

        // to unload all classes.
        loader = null;

        // Remove permission manager
        try {
            if (permissionManager != null) {
                permissionManager.delete();
            }
        } catch (PermissionManagerException pme) {
            TraceEjb.logger.log(BasicLevel.ERROR, myname, pme);
        }
        permissionManager = null;

        // Run the garbage collector
        Runtime.getRuntime().gc();
    }

    public void setBeanEnvironment(Context ctx, BeanDesc dd) throws NamingException {

        // Set bean context
        // Build comp/env
        Context ctxold = naming.setComponentContext(ctx);
        Context envCtx = ctx.createSubcontext("comp/env");

        // Bean Environment
        EnvEntryDesc[] envt = dd.getEnvEntryDesc();
        for (int i = 0; i < envt.length; i++) {
            // get information in descriptor
            String name = envt[i].getName();
            Object obj = envt[i].getValue();
            // register object in JNDI
            if (TraceEjb.isDebugIc()) {
                TraceEjb.interp.log(BasicLevel.DEBUG, myname + ": Binding object " + name + " -> " + obj);
            }
            envCtx.rebind(name, obj);
        }

        // Resource References
        ResourceRefDesc[] resref = dd.getResourceRefDesc();
        for (int i = 0; i < resref.length; i++) {
            // get information in descriptor
            String name = resref[i].getName();
            String resname = resref[i].getJndiName();
            String type = resref[i].getTypeName();
            // build the LinkRef that will be registered:
            // FactoryClassName = null, size = 1, refAddr = resname.

            // register object in JNDI
            if (TraceEjb.isDebugIc()) {
                TraceEjb.interp.log(BasicLevel.DEBUG, myname + ": Linking resource " + name + " -> " + resname);
            }

            if (type.equalsIgnoreCase("java.net.URL")) {
                // Specify the factory to use with the right URL
                Reference ref = new Reference("java.net.URL", "org.objectweb.jonas_lib.naming.factory.URLFactory", null);
                StringRefAddr refAddr = new StringRefAddr("url", resname);
                ref.add(refAddr);
                envCtx.rebind(name, ref);
            } else {
                LinkRef lref = new LinkRef(resname);
                envCtx.rebind(name, lref);
            }
        }

        // Resource Environment References
        ResourceEnvRefDesc[] resEnvref = dd.getResourceEnvRefDesc();
        for (int i = 0; i < resEnvref.length; i++) {
            // get information in descriptor
            String name = resEnvref[i].getName();
            String resname = resEnvref[i].getJndiName();
            LinkRef lref = new LinkRef(resname);

            if (TraceEjb.isDebugIc()) {
                TraceEjb.interp.log(BasicLevel.DEBUG, myname + ": Linking resource environment " + name + " -> "
                        + resname);
            }
            envCtx.rebind(name, lref);
        }

        // EJB References
        EjbRefDesc[] ejbref = dd.getEjbRefDesc();
        for (int i = 0; i < ejbref.length; i++) {
            // get information in descriptor
            String name = ejbref[i].getEjbRefName();
            String ejbname = null;
            ejbname = ejbref[i].getJndiName();
            LinkRef lref = new LinkRef(ejbname);

            if (TraceEjb.isDebugIc()) {
                TraceEjb.interp.log(BasicLevel.DEBUG, myname + ": Linking ejb " + name + " -> " + ejbname);
            }
            envCtx.rebind(name, lref);
        }

        // EJB Local Refs
        // We use here ejb-link tag. This should be used also for ejb-ref when
        // we are able to manage references to another jar file.
        EjbLocalRefDesc[] ejblocalref = dd.getEjbLocalRefDesc();
        for (int i = 0; i < ejblocalref.length; i++) {
            String name = ejblocalref[i].getEjbRefName();
            String ejbname = ejblocalref[i].getJndiLocalName();
            LinkRef lref = new LinkRef(ejbname);
            if (TraceEjb.isDebugIc()) {
                TraceEjb.interp.log(BasicLevel.DEBUG, myname + ": Linking ejb " + name + " -> " + ejbname);
            }
            envCtx.rebind(name, lref);
        }

        // ServiceRef
        ServiceRefDesc[] serviceRefs = dd.getServiceRefDesc();
        if (serviceRefs.length != 0) {

            // get the JServiceFactory
            JServiceFactory factory = null;
            
            for (int i = 0; i < serviceRefs.length; i++) {

                if (factory == null) {
                    factory = JServiceFactoryFinder.getJOnASServiceFactory();
                }
                // Create the Service from the ServiceRef description
                String refname = serviceRefs[i].getServiceRefName();

                // create a full Reference
                Reference ref;
                try {
                    ref = factory.getServiceReference(serviceRefs[i], loader);
                } catch (Exception e1) {
                    throw new NamingException(e1.getMessage());
                }
                envCtx.rebind(refname, ref);
                if (TraceEjb.isDebugIc()) {
                    TraceEjb.interp.log(BasicLevel.DEBUG, "Adding service-ref 'java:comp/env/" + refname + "'");
                }
            }
        }

        // MessageDestination References
        MessageDestinationRefDesc[] mdref = dd.getMessageDestinationRefDesc();
        for (int i = 0; i < mdref.length; i++) {
            // get information in descriptor
            String name = mdref[i].getMessageDestinationRefName();
            String mdname = null;
            mdname = mdref[i].getJndiName();
            LinkRef lref = new LinkRef(mdname);

            if (TraceEjb.isDebugIc()) {
                TraceEjb.interp.log(BasicLevel.DEBUG, myname + ": Linking message-destination " + name + " -> " + mdname);
            }
            envCtx.rebind(name, lref);
        }

        // Reset bean context
        naming.setComponentContext(ctxold);
    }

    public void setContainerNaming(ContainerNaming naming) {
        this.naming = naming;
    }

    public void setEarFileName(String fileName) {
        earFileName = fileName;
    }

    public void setJmsManager(JmsManager jms) {
        this.jms = jms;
    }

    public void setMaxThreadPoolSize(int sz) {
        maxthreadpoolsize = sz;
    }

    public void setPermissionManager(PermissionManager permissionManager) {
        this.permissionManager = permissionManager;
    }

    public void setPrincipalFactory(PrincipalFactory pf) {
        principalFactory = pf;
    }

    public void setSecurity(boolean b) {
        securityFlag = b;
    }

    public void setSwapTime(int t) {
        if (t > 0) {
            TraceEjb.swapper.log(BasicLevel.DEBUG, myname + " sec=" + t);
            swapper.setSwapperTimeout(t);
        }
    }

    public void setThreadPoolSize(int sz) {
        threadpoolsize = sz;
    }

    public void setTransactionManager(TransactionManager tm) {
        this.tm = tm;
    }

    public synchronized void syncAll(boolean passivate) {
        TraceEjb.interp.log(BasicLevel.DEBUG, myname);
        BeanFactory bf = null;
        Iterator it = beanList.values().iterator();
        while (it.hasNext()) {
            bf = (BeanFactory) it.next();
            if (passivate) {
                bf.reduceCache();
            } else {
                bf.sync();
            }
        }
    }

    public String getContextId() {
        return externalFileName;
    }
}

---