EJBServiceImpl.java

package org.objectweb.jonas.container;

import java.io.File;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import java.util.StringTokenizer;
import java.util.Vector;

import javax.management.MBeanException;
import javax.management.MBeanServer;
import javax.management.ObjectName;
import javax.management.OperationsException;
import javax.management.modelmbean.ModelMBean;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;

import org.apache.commons.modeler.ManagedBean;
import org.apache.commons.modeler.Registry;

import org.objectweb.transaction.jta.TransactionManager;

import org.objectweb.jonas_ejb.container.BeanFactory;
import org.objectweb.jonas_ejb.container.Container;
import org.objectweb.jonas_ejb.container.JContainer;
import org.objectweb.jonas_ejb.container.JEntityFactory;
import org.objectweb.jonas_ejb.container.JMdbEndpointFactory;
import org.objectweb.jonas_ejb.container.JMdbFactory;
import org.objectweb.jonas_ejb.container.JSessionFactory;
import org.objectweb.jonas_ejb.container.JStatelessFactory;
import org.objectweb.jonas_ejb.container.PermissionManager;
import org.objectweb.jonas_ejb.container.ThreadPool;
import org.objectweb.jonas_ejb.deployment.api.BeanDesc;
import org.objectweb.jonas_ejb.deployment.api.DeploymentDesc;
import org.objectweb.jonas_ejb.deployment.api.EntityBmpDesc;
import org.objectweb.jonas_ejb.deployment.api.EntityCmpDesc;
import org.objectweb.jonas_ejb.deployment.api.SessionStatefulDesc;
import org.objectweb.jonas_ejb.deployment.api.SessionStatelessDesc;
import org.objectweb.jonas_ejb.deployment.lib.wrapper.EjbManagerWrapper;

import org.objectweb.jonas_lib.deployment.api.DeploymentDescException;
import org.objectweb.jonas_lib.deployment.work.CleanerException;
import org.objectweb.jonas_lib.deployment.work.DeployerLog;
import org.objectweb.jonas_lib.deployment.work.DeployerLogException;
import org.objectweb.jonas_lib.deployment.work.FileManager;
import org.objectweb.jonas_lib.deployment.work.JarCleanTask;
import org.objectweb.jonas_lib.deployment.work.WorkCleaner;
import org.objectweb.jonas_lib.loader.EjbJarClassLoader;

import org.objectweb.jonas_jms.api.JmsManager;

import org.objectweb.jonas.common.JModule;
import org.objectweb.jonas.common.JProp;
import org.objectweb.jonas.common.Log;
import org.objectweb.jonas.ear.EarServiceImpl;
import org.objectweb.jonas.jms.JmsService;
import org.objectweb.jonas.jmx.J2eeObjectName;
import org.objectweb.jonas.jmx.JmxService;
import org.objectweb.jonas.jmx.JonasObjectName;
import org.objectweb.jonas.jtm.TransactionService;
import org.objectweb.jonas.management.JonasMBeanTools;
import org.objectweb.jonas.naming.CompNamingContext;
import org.objectweb.jonas.naming.NamingManager;
import org.objectweb.jonas.security.SecurityService;
import org.objectweb.jonas.server.LoaderManager;
import org.objectweb.jonas.service.AbsServiceImpl;
import org.objectweb.jonas.service.ServiceException;
import org.objectweb.jonas.service.ServiceManager;

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

public class EJBServiceImpl extends AbsServiceImpl implements EJBService, EJBServiceImplMBean {

    private static Logger servlog = null;

    private static Logger loaderlog = null;

    private TransactionManager tm = null;

    private JmsManager jms = null;

    private MBeanServer mbeanServer = null;

    private SecurityService securityService = null;

    private static WorkCleaner workCleaner = null;

    private Vector ejbNames = new Vector();

    private Vector containers = new Vector();

    private static final int DEFAULT_THREAD_POOL_SIZE = 0;

    private int threadPoolSize;

    private int maxthreadPoolSize;

    protected static final String JONAS_BASE = JProp.getJonasBase();

    protected static final String EJBJARS_DIR = JONAS_BASE + File.separator + "ejbjars";

    private ArrayList autoloadDirectories = new ArrayList();

    public static final String JONAS_EJB = "jonas.service.ejb";

    public static final String AUTOLOADDIR = JONAS_EJB + ".autoloaddir";

    public static final String MDBTHREADPOOLSIZE = JONAS_EJB + ".mdbthreadpoolsize";

    public static final String MDBMAXTHREADPOOLSIZE = JONAS_EJB + ".mdbmaxthreadpoolsize";

    public static final String PARSINGWITHVALIDATION = JONAS_EJB + ".parsingwithvalidation";

    public static final String DESCRIPTORS = JONAS_EJB + ".descriptors";

    public static final String CLASS = JONAS_EJB + ".class";

    public static final String BMP = "Bean-Managed";

    public static final String CMP = "Container-Managed";

    private ClassLoader appsClassLoader = null;

    private static final String WORK_DIR = JProp.getWorkDir();

    private static final String WORK_EJBJARS_DIR = WORK_DIR + File.separator + "ejbjars";

    private static String ejbjarsDir = null;

    private DeployerLog jarDeployerLog = null;

    // -------------------------------------------------------------------
    // JOnAS Service Implementation
    // -------------------------------------------------------------------

    public void doInit(Context ctx) throws ServiceException {
        servlog = Log.getLogger(Log.JONAS_SERVER_PREFIX);
        loaderlog = Log.getLogger(Log.JONAS_LOADER_PREFIX);

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

        // get apps ClassLoader
        try {
            LoaderManager lm = LoaderManager.getInstance();
            appsClassLoader = lm.getAppsLoader();
        } catch (Exception e) {
            servlog.log(BasicLevel.ERROR, "Cannot get the Applications ClassLoader from EJB Container Service: " + e);
            throw new ServiceException("Cannot get the Applications ClassLoader from EJB Container Service", e);
        }

        ServiceManager serviceManager = null;
        try {
            serviceManager = ServiceManager.getInstance();
        } catch (Exception e) {
            servlog.log(BasicLevel.ERROR, "Cannot initialize the EJB Container Service: " + e);
            throw new ServiceException("Cannot initialize the EJB Container Service", e);
        }
        // Get the used services
        try {
            // Get the Transaction Manager via the jtm service
            TransactionService jtmService = (TransactionService) serviceManager.getTransactionService();
            tm = jtmService.getTransactionManager();
        } catch (ServiceException e) {
            servlog.log(BasicLevel.ERROR, "Cannot initialize the EJB Container Service: " + e);
            throw new ServiceException("Cannot initialize the EJB Container Service", e);
        }

        try {
            // Get the Security service
            securityService = (SecurityService) serviceManager.getSecurityService();
        } catch (ServiceException se) {
            // The Security service may not be started
            securityService = null;
        }

        try {
            // Get the JMS manager via the JMS service
            JmsService jmsService = (JmsService) serviceManager.getJmsService();
            jms = jmsService.getJmsManager();
        } catch (ServiceException e) {
            // the JMS service may not be started
            jms = null;
        }

        try {
            // Get the JMX Server via JMX Service
            JmxService jmxService = (JmxService) serviceManager.getJmxService();
            mbeanServer = jmxService.getJmxServer();
        } catch (ServiceException e) {
            // the JMX service may not be started
            mbeanServer = null;
        }

        // Set the XML parsing mode to no validation
        String parsingMode;
        try {
            parsingMode = (String) ctx.lookup(PARSINGWITHVALIDATION);
        } catch (NamingException e) {
            // No problem if there is no value for 'parsingwithvalidation'
            // (false by default)
            parsingMode = "false";
        }
        if ("false".equalsIgnoreCase(parsingMode)) {
            EjbManagerWrapper.setParsingWithValidation(false);
            servlog.log(BasicLevel.DEBUG, "XML parsing without validation");
        } else {
            servlog.log(BasicLevel.DEBUG, "XML parsing with validation");
        }

        // Init the ejb names to be loaded when starting
        String descsValue;
        try {
            descsValue = (String) ctx.lookup(DESCRIPTORS);
        } catch (NamingException e) {
            // No problem if there is no value for 'descriptors' (no ejb to
            // load)
            descsValue = null;
        }
        if (descsValue != null) {
            StringTokenizer st = new StringTokenizer(descsValue, ",");
            while (st.hasMoreTokens()) {
                String fileName = st.nextToken().trim();
                ejbNames.add(fileName);
            }
        }

        // Add the jars of the jonas.service.ejb.autoloaddir property
        String dirValue;
        ArrayList autoDirs = new ArrayList();
        try {
            dirValue = (String) ctx.lookup(AUTOLOADDIR);
        } catch (NamingException e) {
            // No problem if there is no value for 'autoloaddir'
            //(no ejb to load)
            dirValue = null;
        }
        if (dirValue != null) {
            StringTokenizer st = new StringTokenizer(dirValue, ",");
            while (st.hasMoreTokens()) {
                String dirName = st.nextToken().trim();
                addEjbjars(dirName);
                autoDirs.add(dirName);
            }
        }
        // Build autoload directories
        File oFile;
        for (int i = 0; i < autoDirs.size(); i++) {
            try {
                oFile = new File(EJBJARS_DIR, autoDirs.get(i).toString());
                if (oFile.exists()) {
                    autoloadDirectories.add(oFile.getCanonicalPath());
                } else {
                    oFile = new File(autoDirs.get(i).toString());
                }
            } catch (Exception e) {
                String err = "Error when trying to verify Ejbjar autoload directory : " + autoDirs.get(i);
                servlog.log(BasicLevel.ERROR, err + " " + e.getMessage());
            }
        }

        // MDB thread pool size
        try {
            String plz = (String) ctx.lookup(MDBTHREADPOOLSIZE);
            threadPoolSize = (new Integer(plz)).intValue();
        } catch (NamingException e) {
            // default value will be used.
            threadPoolSize = DEFAULT_THREAD_POOL_SIZE;
        }
        // MAX thread pool size
        try {
            String mxplz = (String) ctx.lookup(MDBMAXTHREADPOOLSIZE);
            maxthreadPoolSize = (new Integer(mxplz)).intValue();
        } catch (NamingException e) {
            // default value will be used.
            maxthreadPoolSize = ThreadPool.DEFAULT_POOL_MAX_SIZE;
        }
        servlog.log(BasicLevel.DEBUG, "EJB Container Service initialized");

    }

    public void doStart() throws ServiceException {

        ejbjarsDir = WORK_EJBJARS_DIR + File.separator + getJonasServerName();

        URL ejbjarsUrl = null;
        try {
            ejbjarsUrl = new File(ejbjarsDir).toURL();
        } catch (MalformedURLException mue) {
            throw new ServiceException("Error when trying to get the URL of the jonasroot/apps directory", mue);
        }

        File fLog = new File(ejbjarsUrl.getFile() + File.separator + getJonasServerName() + ".log");
        if (!fLog.exists()) {
            try {
                //create
                fLog.getParentFile().mkdirs();
                fLog.createNewFile();
            } catch (IOException e) {
                throw new ServiceException("cannot create the log file" + fLog);
            }
        }

        //get the logger
        try {
            jarDeployerLog = new DeployerLog(fLog);
        } catch (DeployerLogException e) {
            throw new ServiceException("Can not get an EarDeployerLog", e);
        }

        // create the jar deployment work file control task
        JarCleanTask jarCleanTask = new JarCleanTask(jarDeployerLog);

        //get the cleaner ref
        workCleaner = WorkCleaner.getInstance();

        // add the jar deployment work file control task
        try {
            workCleaner.registerTask(jarCleanTask);
        } catch (CleanerException ce) {
            throw new ServiceException("Cannot register the JAR clean task", ce);

        }

        // force the cleaning immediately
        workCleaner.executeTasks();

        // Creates all predefined containers
        // 1 container per ejbjar file.
        String fileName = null;
        Context contctx = null;
        for (int i = 0; i < ejbNames.size(); i++) {
            fileName = (String) ejbNames.elementAt(i);
            try {
                contctx = new CompNamingContext(fileName);
                contctx.rebind("filename", fileName);
            } catch (NamingException ne) {
                servlog.log(BasicLevel.WARN, "Cannot create container for " + fileName
                        + " because of a NamingException : " + ne.toString());
            }

            try {
                createContainer(contctx);
            } catch (Exception e) {
                servlog.log(BasicLevel.WARN, "Cannot create container for " + fileName + " because of Exception : "
                        + e.toString());
                // Close naming context
                try {
                    contctx.close();
                } catch (NamingException nne) {
                    servlog.log(BasicLevel.DEBUG, "Cannot close deploy context for " + fileName, nne);
                }
            }
        }

        // Register EJBService MBean : EJBServiceImplMBean
        if (mbeanServer != null) {
            try {
                mbeanServer.registerMBean(this, JonasObjectName.ejbService());
            } catch (MBeanException mbe) {
                // registration failed because a MBeanException
                servlog.log(BasicLevel.WARN, "Cannot register the EJB Container Service in the MBean Server.");
                servlog.log(BasicLevel.WARN, "Regstration failure cause : " + mbe.getTargetException().toString());
            } catch (OperationsException me) {
                // registration failed because a OperationsException JMX
                // Exception
                servlog.log(BasicLevel.WARN, "Cannot register the EJB Container Service in the MBean Server.");
                servlog.log(BasicLevel.WARN, "Regstration failure cause : " + me.toString());
            }
        }
    }

    public void doStop() {

        Enumeration lc = containers.elements();
        while (lc.hasMoreElements()) {
            Container cont = (Container) lc.nextElement();
            removeContainer(cont);
        }
        if (mbeanServer != null) {
            try {
                // unregister EJBService MBean : EJBServiceImplMBean
                mbeanServer.unregisterMBean(JonasObjectName.ejbService());
            } catch (Exception e) {
                servlog.log(BasicLevel.ERROR, "Cannot stop the EJB Container Service: " + e);
            }
        }

        servlog.log(BasicLevel.DEBUG, "EJB Container Service stopped");
    }

    // -------------------------------------------------------------------
    // EJBService Implementation
    // -------------------------------------------------------------------

    public String createContainer(Context ctx) throws Exception {
        servlog.log(BasicLevel.DEBUG, "");

        // Get the file name
        String fileName = (String) ctx.lookup("filename");
        File f = new File(fileName).getCanonicalFile();
        boolean isEjbJar = fileName.toLowerCase().endsWith(".jar");

        // check if the file exists
        // In case of the name is a ejb-jar file name, check also in
        // the JONAS_BASE/ejbjars directory
        try {
            if (!f.exists() && isEjbJar) {
                String ejbjarFileName = EJBJARS_DIR + File.separator + fileName;
                f = new File(ejbjarFileName).getCanonicalFile();
                if (!f.exists()) {
                    servlog.log(BasicLevel.ERROR, "createContainer: " + fileName + " not found");
                    throw new NamingException(fileName + " not found");
                }
            }
        } catch (IOException e) {
            String err = "Invalid ejbjar file name '" + fileName;
            servlog.log(BasicLevel.ERROR, err);
            throw new Exception(err + e.getMessage());
        }
        boolean isEjbJarFile = isEjbJar && f.isFile();
        boolean isEjbJarXml = fileName.toLowerCase().endsWith(".xml") && f.isFile();

        // Force fileName with slash to avoid conflict under Windows (slash and
        // back-slash)
        try {
            fileName = f.toURL().getPath();
        } catch (MalformedURLException e) {
            servlog.log(BasicLevel.ERROR, "Invalid ejb-jar file name '" + fileName + "': " + e);
        }

        if (f.isFile()) {
            if (!isEjbJar && !isEjbJarXml) {
                throw new ServiceException("The ejbjar to deploy is not a jar file nor an xml file");
            }
        }

        // Check if container already exists
        if (getContainer(fileName) != null) {
            servlog.log(BasicLevel.ERROR, "createContainer: " + fileName + " already exists");
            throw new Exception("Container already exists");
        }

        // In order to avoid lock problem after undeploy
        // the jar file is copied under the working directory before its loading
        // ! only if the ejbjars isn't included in an ear
        boolean isInEar = true;
        try {
            ctx.lookup("earClassLoader");
        } catch (NamingException ne) {
            isInEar = false;
        }

        String wkFileName = null;

        if (!isInEar && isEjbJarFile) {
            // Get the destination file
            wkFileName = ejbjarsDir + File.separator + FileManager.fileToTimeStampDir(f.toURL(), ".jar");

            servlog.log(BasicLevel.DEBUG, "filename=" + fileName);
            servlog.log(BasicLevel.DEBUG, "wkFilename=" + wkFileName);

            // copy the file
            FileManager.copyFile(fileName, wkFileName);

            // add an entry in the log file
            try {
                jarDeployerLog.addEntry(f, new File(wkFileName));
            } catch (DeployerLogException e) {
                String err = "Error while adding the " + fileName + " entry in the log file";
                servlog.log(BasicLevel.ERROR, err + " : " + e.getMessage());
                throw new Exception(err, e);
            }

            servlog.log(BasicLevel.DEBUG, "Create wk file :" + wkFileName);

        } else {
            // in this case, no needs to copy the file
            wkFileName = fileName;
            servlog.log(BasicLevel.DEBUG, "No needs wk file :" + wkFileName);
        }

        // Classloader
        URL[] url = null;
        try {
            url = new URL[1];
            url[0] = (new File(wkFileName)).toURL();
        } catch (MalformedURLException e) {
            servlog.log(BasicLevel.ERROR, "Invalid ejb-jar file name '" + wkFileName + "'", e);
        }

        // Get the classloaders
        URLClassLoader ejbClassLoader = null;
        URLClassLoader earClassLoader = null;
        try {
            earClassLoader = (URLClassLoader) ctx.lookup("earClassLoader");
            ejbClassLoader = (URLClassLoader) ctx.lookup("ejbClassLoader");
            loaderlog.log(BasicLevel.DEBUG, "earClassLoader=" + earClassLoader);
        } catch (NamingException ne) {
            // no ear classloader => ejb application case (not ear case).
            if (isEjbJar) {
                ejbClassLoader = new EjbJarClassLoader(url, appsClassLoader);
            } else {
                ejbClassLoader = (URLClassLoader) appsClassLoader;
            }
            loaderlog.log(BasicLevel.DEBUG, "parent Loader=" + appsClassLoader);
        }
        loaderlog.log(BasicLevel.DEBUG, "ejbClassLoader=" + ejbClassLoader);

        // Get the deployment descriptor from file
        DeploymentDesc dd = null;
        try {
            // ejb-jar file
            dd = EjbManagerWrapper.getDeploymentDesc(url[0], ejbClassLoader, earClassLoader);
        } catch (DeploymentDescException e) {
            servlog.log(BasicLevel.ERROR, "Cannot read the deployment descriptors '" + fileName + "': " + e);
            throw new ServiceException(e.getMessage(), e);
        }

        // container name
        String cname = buildEJBModuleName(fileName);
        if (cname == null) {
            //use displayName
            cname = "EJB container ";
            if (dd.getDisplayName() != null) {
                cname += dd.getDisplayName();
            }
        }

        // Create the Container Object
        JContainer cont = new JContainer(cname, fileName, wkFileName, ejbClassLoader);
        cont.setContainerNaming(NamingManager.getInstance());
        cont.setTransactionManager(tm);
        cont.setPrincipalFactory(new PrincipalFactoryImpl());
        cont.setJmsManager(jms);

        // Set the name of the ear application containing this container
        // in the case of an ear application.
        String earFileName;
        try {
            earFileName = (String) ctx.lookup("earFileName");
            cont.setEarFileName(earFileName);
        } catch (NamingException ne) {
            earFileName = null;
        }

        // unset the security if no security service
        if (securityService == null) {
            servlog.log(BasicLevel.DEBUG, "EJB Container Service: working without Security Service");
            cont.setSecurity(false);
        } else {
            PermissionManager permissionManager = null;
            try {
                permissionManager = new PermissionManager(dd, cont.getContextId());
                permissionManager.translateEjbDeploymentDescriptor();
                // if not in ear case, commit the policy configuration, else it
                // is done
                // by EAR service after linking all policy configuration objects
                if (!isInEar) {
                    permissionManager.commit();
                }
            } catch (Exception e) {
                servlog.log(BasicLevel.ERROR, "Can't build permission manager object for the ejbjar '" + fileName
                        + "' : " + e.getMessage());
            }
            cont.setPermissionManager(permissionManager);
        }

        // Set thread pool size if it has been set in properties
        // Note that this ThreadPool is used only for MDB (jms), but it could
        // be used for other purpose later.
        cont.setThreadPoolSize(threadPoolSize);
        cont.setMaxThreadPoolSize(maxthreadPoolSize);

        String domainName = getDomainName();
        String serverName = getJonasServerName();
        String j2eeAppName = EarServiceImpl.buildJ2eeApplicationName(earFileName);
        Registry oRegistry = JonasMBeanTools.getRegistry();
        EJBModule ejbModuleMBean = null;
        ObjectName onEjbModule = null;

        // MBeans to register if the deployment is successful
        Map mbeansToRegister = new HashMap();

        // EJBModule MBean registering
        if (mbeanServer != null) {
            // Use the conatiner name (the 'name' constructor parameter of
            // JContainer class)
            // as the "name" keyProperty for the J2ee ObjectName construction
            onEjbModule = J2eeObjectName.getEJBModule(domainName, serverName, j2eeAppName, cname);

            ejbModuleMBean = new EJBModule(onEjbModule.toString(), cont, fileName, cname);
            ejbModuleMBean.setDeploymentDescriptor(dd.getXmlContent());
            ejbModuleMBean.setJonasDeploymentDescriptor(dd.getJOnASXmlContent());

            // Use Jakarta Common Modeler API
            ManagedBean oManaged = oRegistry.findManagedBean("EJBModule");
            ModelMBean oMBean = oManaged.createMBean(ejbModuleMBean);
            mbeansToRegister.put(oMBean, onEjbModule);
        }

        // Process each bean from the DD
        BeanDesc[] beans = dd.getBeanDesc();
        for (int i = 0; i < beans.length; i++) {
            BeanFactory bf = cont.addBean(beans[i]);
            beans[i].setBeanFactory(bf);
            if (mbeanServer != null) {
                try {
                    // register MBean for this ejb
                    String beanName = beans[i].getEjbName();
                    if ((beans[i] instanceof EntityBmpDesc) || (beans[i] instanceof EntityCmpDesc)) {
                        JEntityFactory jef = (JEntityFactory) bf;
                        ObjectName onEntityBean = J2eeObjectName.getEntityBean(domainName, cname, serverName,
                                j2eeAppName, beanName);
                        EntityBean entityBeanMBean; // new EntityBean
                        // declaration
                        if (beans[i] instanceof EntityBmpDesc) {
                            entityBeanMBean = new EntityBean(onEntityBean.toString(), jef, BMP);
                        } else {
                            entityBeanMBean = new EntityBean(onEntityBean.toString(), jef, CMP);
                        }
                        ManagedBean oManaged = oRegistry.findManagedBean("EntityBean");
                        ModelMBean oMBean = oManaged.createMBean(entityBeanMBean);
                        mbeansToRegister.put(oMBean, onEntityBean);
                        // Update the EJBModule
                        ejbModuleMBean.addEjb(onEntityBean.toString());
                    } else if (beans[i] instanceof SessionStatefulDesc) {
                        JSessionFactory jsf = (JSessionFactory) bf;
                        ObjectName onStatefulSessionBean = J2eeObjectName.getStatefulSessionBean(domainName, cname,
                                serverName, j2eeAppName, beanName);
                        StatefulSessionBean sessionBeanMBean = new StatefulSessionBean(
                                onStatefulSessionBean.toString(), jsf);
                        ManagedBean oManaged = oRegistry.findManagedBean("StatefulSessionBean");
                        ModelMBean oMBean = oManaged.createMBean(sessionBeanMBean);
                        mbeansToRegister.put(oMBean, onStatefulSessionBean);
                        // Update the EJBModule
                        ejbModuleMBean.addEjb(onStatefulSessionBean.toString());
                    } else if (beans[i] instanceof SessionStatelessDesc) {
                        JStatelessFactory jsf = (JStatelessFactory) bf;
                        ObjectName onStatelessSessionBean = J2eeObjectName.getStatelessSessionBean(domainName, cname,
                                serverName, j2eeAppName, beanName);
                        StatelessSessionBean sessionBeanMBean = new StatelessSessionBean(onStatelessSessionBean
                                .toString(), jsf);
                        ManagedBean oManaged = oRegistry.findManagedBean("StatelessSessionBean");
                        ModelMBean oMBean = oManaged.createMBean(sessionBeanMBean);
                        mbeansToRegister.put(oMBean, onStatelessSessionBean);
                        // Update the EJBModule
                        ejbModuleMBean.addEjb(onStatelessSessionBean.toString());
                    } else {
                        ObjectName onMessageDrivenBean = J2eeObjectName.getMessageDrivenBean(domainName, cname,
                                serverName, j2eeAppName, beanName);
                        MessageDrivenBean messageDrivenBeanMBean = null;
                        if (bf instanceof JMdbFactory) {
                            JMdbFactory jmf = (JMdbFactory) bf;
                            messageDrivenBeanMBean = new MessageDrivenBean(onMessageDrivenBean.toString(), jmf);
                        } else {
                            JMdbEndpointFactory jmf = (JMdbEndpointFactory) bf;
                            messageDrivenBeanMBean = new MessageDrivenBean(onMessageDrivenBean.toString(), jmf);
                        }
                        ManagedBean oManaged = oRegistry.findManagedBean("MessageDrivenBean");
                        ModelMBean oMBean = oManaged.createMBean(messageDrivenBeanMBean);
                        mbeansToRegister.put(oMBean, onMessageDrivenBean);
                        // Update the EJBModule
                        ejbModuleMBean.addEjb(onMessageDrivenBean.toString());
                    }
                } catch (Exception e) {
                    servlog.log(BasicLevel.ERROR, "Cannot create container: " + e);
                }
            }
        }
        // Init now pools of instances, in case min-pool-size have been defined.
        // This must be done once all beans have been deployed.
        for (int i = 0; i < beans.length; i++) {
            BeanFactory bf = beans[i].getBeanFactory();
            bf.initInstancePool();
        }
        
        // Deployment was successful, add the bean as deployed and create the
        // MBeans
        containers.addElement(cont);
        for (Iterator it = mbeansToRegister.keySet().iterator(); it.hasNext();) {
            ModelMBean mbean = (ModelMBean) it.next();
            ObjectName oName = (ObjectName) mbeansToRegister.get(mbean);
            mbeanServer.registerMBean(mbean, oName);

        }

        servlog.log(BasicLevel.DEBUG, "created container for " + fileName);
        //return cont;
        return onEjbModule.toString();
    }

    public Container getContainer(String fileName) {
        servlog.log(BasicLevel.DEBUG, fileName);

        // In case of the name is a ejb-jar file name, check also in
        // the JONAS_BASE/ejbjars directory and JONAS_BASE/ejbjars/autoload

        String ejbjarFileName = EJBJARS_DIR + File.separator + fileName;
        File f = null;
        String pathEjbJarDirFile;
        String pathFile = "";
        try {
            f = new File(ejbjarFileName).getCanonicalFile();
            // Force pathEjbJarDirFile with slash to avoid conflict under
            // Windows (slash and back-slash)
            pathEjbJarDirFile = f.toURL().getPath();
        } catch (Exception e) {
            // If filename was an absolute path, it can throw an exception
            // The pathFile will be empty
            pathEjbJarDirFile = "";
        }
        try {
            f = new File(fileName).getCanonicalFile();
            // Force pathFile with slash to avoid conflict under Windows (slash
            // and back-slash)
            pathFile = f.toURL().getPath();
        } catch (Exception e) {
            String err = "Error while trying to get canonical file '" + fileName + "'";
            servlog.log(BasicLevel.ERROR, err);
            return null;
        }

        // for each container loaded
        Enumeration lc = containers.elements();
        while (lc.hasMoreElements()) {
            Container cont = (JContainer) lc.nextElement();
            String contName = cont.getExternalFileName();

            // first, search abs path
            if (contName.equals(pathFile)) {
                return cont;
            } else if (contName.equals(pathEjbJarDirFile)) {
                // next, search in ejbjar path
                return cont;
            } else {
                // else search in autoloadir
                List lAlDirs = getAutoloadDirectories();
                for (int i = 0; i < lAlDirs.size(); i++) {
                    String alDir = (String) lAlDirs.get(i);

                    String alFileName = alDir + File.separator + fileName;
                    try {
                        f = new File(alFileName).getCanonicalFile();
                        // Force alFileName with slash to avoid conflict under
                        // Windows (slash and back-slash)
                        alFileName = f.toURL().getPath();
                    } catch (Exception e) {
                        // If filename was an absolute path, it can throw an
                        // exception
                        alFileName = alDir + File.separator + fileName;
                    }
                    servlog.log(BasicLevel.DEBUG, "alFileName= " + alFileName);

                    if (contName.equals(alFileName)) {
                        return cont;
                    }
                }
            }
        }

        // not found
        return null;
    }

    public void removeContainer(Container cont) {
        servlog.log(BasicLevel.DEBUG, cont.getName());

        if (mbeanServer != null) {
            String moduleName = cont.getName();
            String earFileName = cont.getEarFileName();
            String earName = null;
            if (earFileName != null) {
                earName = EarServiceImpl.buildJ2eeApplicationName(earFileName);
            }
            String domainName = getDomainName();
            String serverName = getJonasServerName();
            ObjectName onEjbModule = J2eeObjectName.getEJBModule(domainName, serverName, earName, moduleName);

            // try to remove MBeans corresponding to the EJBs in the module
            ObjectName onEjb = null;
            try {
                String[] onEjbs = (String[]) mbeanServer.getAttribute(onEjbModule, "ejbs");
                for (int i = 0; i < onEjbs.length; i++) {
                    onEjb = new ObjectName(onEjbs[i]);
                    mbeanServer.unregisterMBean(onEjb);
                }
            } catch (Exception e) {
                servlog.log(BasicLevel.ERROR, "Problem when trying to unregsiter MBean " + onEjb.toString() + ": " + e);
            }

            // try to remove MBean corresponding to the module
            try {
                mbeanServer.unregisterMBean(onEjbModule);
                if (servlog.isLoggable(BasicLevel.DEBUG)) {
                    servlog.log(BasicLevel.DEBUG, "unregistered MBean: " + onEjbModule.toString());
                }
            } catch (Exception e) {
                servlog.log(BasicLevel.ERROR, "Problem when trying to unregsiter MBean " + onEjbModule.toString()
                        + ": " + e);
            }
        }
        cont.remove();
        containers.removeElement(cont);

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

    }

    public Container[] listContainers() {
        servlog.log(BasicLevel.DEBUG, "size= " + containers.size());

        Container[] ret = new Container[containers.size()];
        containers.copyInto(ret);
        return ret;
    }

    public void syncAllEntities(boolean passivate) {
        servlog.log(BasicLevel.DEBUG, "");

        Enumeration lc = containers.elements();
        while (lc.hasMoreElements()) {
            JContainer cont = (JContainer) lc.nextElement();
            cont.syncAll(passivate);
        }
    }

    public Integer getCurrentNumberOfContainer() {
        return new Integer(containers.size());
    }

    public Integer getTotalCurrentNumberOfBeanType() {
        int count = 0;
        Enumeration lc = containers.elements();
        while (lc.hasMoreElements()) {
            JContainer cont = (JContainer) lc.nextElement();
            count += cont.getBeanNb();
        }
        return new Integer(count);
    }

    public Integer getTotalCurrentNumberOfBMPType() {
        int count = 0;
        Enumeration lc = containers.elements();
        while (lc.hasMoreElements()) {
            JContainer cont = (JContainer) lc.nextElement();
            count += cont.getEntityBMPNb();
        }
        return new Integer(count);
    }

    public Integer getTotalCurrentNumberOfCMPType() {
        int count = 0;
        Enumeration lc = containers.elements();
        while (lc.hasMoreElements()) {
            JContainer cont = (JContainer) lc.nextElement();
            count += cont.getEntityCMPNb();
        }
        return new Integer(count);
    }

    public Integer getTotalCurrentNumberOfSBFType() {
        int count = 0;
        Enumeration lc = containers.elements();
        while (lc.hasMoreElements()) {
            JContainer cont = (JContainer) lc.nextElement();
            count += cont.getStatefulSessionNb();
        }
        return new Integer(count);
    }

    public Integer getTotalCurrentNumberOfSBLType() {
        int count = 0;
        Enumeration lc = containers.elements();
        while (lc.hasMoreElements()) {
            JContainer cont = (JContainer) lc.nextElement();
            count += cont.getStatelessSessionNb();
        }
        return new Integer(count);
    }

    public Integer getTotalCurrentNumberOfMDBType() {
        int count = 0;
        Enumeration lc = containers.elements();
        while (lc.hasMoreElements()) {
            JContainer cont = (JContainer) lc.nextElement();
            count += cont.getMessageDrivenNb();
        }
        return new Integer(count);
    }

    public void removeContainer(String fileName) throws Exception {
        removeContainerMBean(fileName);
    }

    public void removeContainerMBean(String fileName) throws Exception {
        Container cont = null;
        try {
            cont = getContainer(fileName);
        } catch (Exception e) {
            String err = "Error while trying to find file '" + fileName + "'";
            servlog.log(BasicLevel.ERROR, err);
            throw new Exception(err);
        }

        if (cont != null) {
            removeContainer(cont, false);
        } else {
            String err = "Cannot remove the non-existant container '" + fileName + "'";
            servlog.log(BasicLevel.ERROR, err);
            throw new Exception(err);
        }
    }

    public String createContainer(String file) throws Exception {
        return createContainerMBean(file);
    }

    public String createContainerMBean(String file) throws Exception {
        String ejbModuleObjectName = null;
        try {
            Context contctx = new CompNamingContext(file);
            contctx.rebind("filename", file);
            ejbModuleObjectName = createContainer(contctx);
        } catch (Exception e) {
            throw new Exception("Cannot create Container: " + e.toString());
        }
        return ejbModuleObjectName;
    }

    public Boolean isJarDeployed(String fileName) {
        return new Boolean(isJarLoaded(fileName));
    }

    public boolean isJarDeployedByWorkName(String workFileName) {
        servlog.log(BasicLevel.DEBUG, workFileName);

        // for each container loaded
        Enumeration lc = containers.elements();
        while (lc.hasMoreElements()) {
            Container cont = (JContainer) lc.nextElement();

            // get name of the container (basename)
            // cont.getFileName return the internal name (working copy)
            String contName = new File(cont.getFileName()).getName();
            if (contName.equals(workFileName)) {
                return true;
            }
        }

        // not found
        return false;
    }

    // Kind of resources:
    static final int DATASOURCE = 1;

    static final int JMS_DESTINATION = 2;

    static final int JMS_FACTORY = 3;

    static final int MAIL_FACTORY = 4;

    Set getDependence(String name, int type) {
        Set resultObjectName = null; // to be returned by this method
        Set resultProperties = new HashSet(); // constructed by the JContainer
        Enumeration lc = containers.elements();
        try {
            Context ctx = new InitialContext();
            ctx.lookup(name);
            ctx.close();
            // this resource is rebind
            while (lc.hasMoreElements()) {
                JContainer cont = (JContainer) lc.nextElement();
                Set depProps = null; // Dependences described as a set of
                // Properties objects
                switch (type) {

                case DATASOURCE:
                    depProps = cont.getDataSourceDependence(name);
                    break;

                case JMS_DESTINATION:
                    depProps = cont.getJmsDestinationDependence(name);
                    break;

                case JMS_FACTORY:
                    depProps = cont.getJmsConnectionFactoryDependence(name);
                    break;

                case MAIL_FACTORY:
                    depProps = cont.getMailFactoryDependence(name);
                    break;

                }
                resultProperties.addAll(depProps);
                // change string to ObjectName
                try {
                    resultObjectName = convertToObjectNames(resultProperties);
                } catch (Exception e) {
                    servlog.log(BasicLevel.ERROR, "EjbServiceImpl: Object Name Error:" + e);
                }
            }
        } catch (NamingException ne) {
            // unexisting ds
            resultObjectName = new HashSet();
        }
        return resultObjectName;
    }

    private Set convertToObjectNames(Set resultProperties) {
        Set resultObjectName = new HashSet();
        Iterator it = resultProperties.iterator();
        String domainName = getDomainName();
        String serverName = getJonasServerName();
        Properties item = null; // a item in resultProperties
        String ejbType = null;
        String ejbName = null;
        String fileName = null;
        String earFileName = null;
        String moduleName = null;
        String j2eeAppName = null;
        while (it.hasNext()) {
            item = (Properties) it.next();
            ObjectName ejbObjectName = null;
            // See JContainer.beansDependence() method for info about the
            // Properties object containt
            ejbType = item.getProperty("type");
            ejbName = item.getProperty("name");
            fileName = item.getProperty("fname");
            earFileName = item.getProperty("earFileName");
            //moduleName = buildEJBModuleName(fileName);
            moduleName = item.getProperty("cname");
            if (earFileName != null) {
                j2eeAppName = EarServiceImpl.buildJ2eeApplicationName(earFileName);
            }

            if (ejbType.equals("ejbbmp") || ejbType.equals("ejbcmp")) {
                ejbObjectName = J2eeObjectName.getEntityBean(domainName, moduleName, serverName, j2eeAppName, ejbName);
            } else if (ejbType.equals("ejbsbf")) {
                ejbObjectName = J2eeObjectName.getStatefulSessionBean(domainName, moduleName, serverName, j2eeAppName,
                        ejbName);
            } else if (ejbType.equals("ejbsbl")) {
                ejbObjectName = J2eeObjectName.getStatelessSessionBean(domainName, moduleName, serverName, j2eeAppName,
                        ejbName);
            } else if (ejbType.equals("ejbmdb")) {
                ejbObjectName = J2eeObjectName.getMessageDrivenBean(domainName, moduleName, serverName, j2eeAppName,
                        ejbName);
            }
            if (ejbObjectName != null) {
                resultObjectName.add(ejbObjectName);
            }
        }
        return resultObjectName;
    }

    public Set getDataSourceDependence(String dsName) {
        return getDependence(dsName, DATASOURCE);
    }

    public Set getJmsDestinationDependence(String destName) {
        return getDependence(destName, JMS_DESTINATION);
    }

    public Set getJmsConnectionFactoryDependence(String cfName) {
        return getDependence(cfName, JMS_FACTORY);
    }

    public Set getMailFactoryDependence(String mfName) {
        return getDependence(mfName, MAIL_FACTORY);
    }

    public List getInstalledJars() throws Exception {
        // get JAR files found in JONAS_BASE/ejbjars
        ArrayList al = JModule.getInstalledContainersInDir(EJBJARS_DIR, JModule.EJBJAR_EXTENSION,
                JModule.EJBJAR_CHILD_DIR, JModule.EJBJAR_CONFIRM_FILE);
        // get JAR files found in all autoload directories
        for (int i = 0; i < autoloadDirectories.size(); i++) {
            al.addAll(JModule.getInstalledContainersInDir(autoloadDirectories.get(i).toString(),
                    JModule.EJBJAR_EXTENSION, JModule.EJBJAR_CHILD_DIR, JModule.EJBJAR_CONFIRM_FILE));
        }
        return al;
    }

    public void deployJars(Context ctx) throws ServiceException {

        // Get the 6 parameters from the context
        // - earRootUrl the root of the ear application.
        // - earClassLoader the ear classLoader of the ear application.
        // - ejbClassLoader the ejb classLoader for the ejbjars.
        // - jarURLs the list of the urls of the ejb-jars to deploy.
        // - roleNames the role names of the security-role
        URL earRootUrl = null;
        URL earUrl = null;
        ClassLoader earClassLoader = null;
        ClassLoader ejbClassLoader = null;
        URL[] jarURLs = null;
        String[] roleNames = null;
        try {
            earRootUrl = (URL) ctx.lookup("earRootUrl");
            earUrl = (URL) ctx.lookup("earUrl");
            earClassLoader = (ClassLoader) ctx.lookup("earClassLoader");
            ejbClassLoader = (ClassLoader) ctx.lookup("ejbClassLoader");
            jarURLs = (URL[]) ctx.lookup("jarURLs");
            roleNames = (String[]) ctx.lookup("roleNames");
        } catch (NamingException e) {
            String err = "Error while getting parameter from context param :" + e.getMessage();
            servlog.log(BasicLevel.ERROR, err);
            throw new ServiceException(err, e);
        }

        // Deploy all the ejb-jars of the ear application.
        for (int i = 0; i < jarURLs.length; i++) {

            // Get the name of an ejb-jar to deploy.
            String fileName = jarURLs[i].getFile();
            servlog.log(BasicLevel.DEBUG, "Deploy '" + fileName + "' for the ear service.");

            // The context to give for the creation of the container
            // associated to the ejb-jar.
            Context contctx = null;
            try {
                contctx = new CompNamingContext(fileName);
                contctx.rebind("filename", fileName);
                contctx.rebind("earClassLoader", earClassLoader);
                contctx.rebind("ejbClassLoader", ejbClassLoader);
                contctx.rebind("earRoot", earRootUrl.getFile());
                contctx.rebind("earFileName", earUrl.getFile());
                contctx.rebind("roleNames", roleNames);
                createContainer(contctx);
            } catch (Exception e) {
                // An ejb-jar is corrupted so undeploy all the deployed jar
                // of the ear application.
                servlog.log(BasicLevel.ERROR, "Error when deploying '" + fileName + "'");
                servlog.log(BasicLevel.ERROR, e.getMessage());
                servlog.log(BasicLevel.ERROR, "Undeploy ejb-jar of the ear application");

                for (int j = 0; j <= i; j++) {
                    Container cont = getContainer(jarURLs[j].getFile());
                    if (cont != null) {
                        removeContainer(cont, true);
                    } else {
                        servlog.log(BasicLevel.ERROR, "Cannot remove the non-existant container '" + fileName + "'");
                    }
                }
                throw new ServiceException("Error during the deployment", e);
            }
        }
        //return ejbClassLoader;
    }

    public void unDeployJars(URL[] urls) {
        for (int i = 0; i < urls.length; i++) {
            String fileName = urls[i].getFile();
            Container cont = getContainer(urls[i].getFile());
            if (cont != null) {
                removeContainer(cont, true);
            } else {
                servlog.log(BasicLevel.ERROR, "Cannot remove the non-existant container '" + fileName + "'");
            }
        }
    }

    public void removeContainer(Container cont, boolean isEarCase) {
        if (isEarCase == (cont.getEarFileName() != null)) {
            removeContainer(cont);
        } else {
            String err = "Cannot remove container '" + cont.getName()
                    + "' it is in an ear application. You must undeploy the ear associated.";
            servlog.log(BasicLevel.ERROR, err);
        }
    }

    public void removeCache(ClassLoader earClassLoader) {
        EjbManagerWrapper.removeCache(earClassLoader);
    }

    private void addEjbjars(String dirPath) {
        boolean found = false;

        // Look the directory relative to where the JOnAS server is launch or
        // if the path is absolute.
        File dir = new File(dirPath);
        found = dir.isDirectory();

        if (!found) {
            // Look the directory relative to the $JONAS_BASE/ejbjars directory
            dir = new File(EJBJARS_DIR + File.separator + dirPath);
            found = dir.isDirectory();
        }

        if (found) {
            addEjbjarsFrom(dir);
        } else {
            String err = "Warning: Cannot load dir: '" + dirPath + "' ";
            err += "is not a directory or directory doesn't exist";
            servlog.log(BasicLevel.WARN, err);
        }
    }

    private void addEjbjarsFrom(File dir) throws ServiceException {

        try {
            if (dir.isDirectory()) {
                File[] files = dir.listFiles();
                for (int i = 0; i < files.length; i++) {
                    if (files[i].getPath().toLowerCase().endsWith(".jar")) {
                        ejbNames.add(files[i].getCanonicalPath());
                    } else if (files[i].isDirectory()) {
                        addEjbjarsFrom(files[i]);
                    }
                }
            } else {
                String err = "Cannot load dir: '" + dir.getPath();
                err += "' is not a directory";
                servlog.log(BasicLevel.ERROR, err);
                throw new ServiceException(err);
            }
        } catch (IOException e) {
            String err = "Invalid file name '" + dir.getPath();
            servlog.log(BasicLevel.ERROR, err);
            throw new ServiceException(err, e);
        }
    }

    public boolean isJarLoaded(String fileName) {
        return (getContainer(fileName) != null);
    }

    public List getDeployedJars() {
        ArrayList al = new ArrayList();
        Container oContainer;
        for (Enumeration jars = containers.elements(); jars.hasMoreElements();) {
            oContainer = (Container) jars.nextElement();
            try {
                al.add((new File(oContainer.getExternalFileName())).toURL().getPath());
            } catch (Exception e) {
                // none
            }
        }
        return al;
    }

    public List getDeployableJars() throws Exception {
        List al = getInstalledJars();
        al.removeAll(getDeployedJars());
        return al;
    }

    public List getAutoloadDirectories() {
        ArrayList al = new ArrayList();
        for (int i = 0; i < autoloadDirectories.size(); i++) {
            try {
                al.add((new File(autoloadDirectories.get(i).toString())).toURL().getPath());
            } catch (Exception e) {
                // none
            }
        }
        return al;
    }

    public String getEjbjarsDirectory() {
        String sRet;
        try {
            sRet = (new File(EJBJARS_DIR)).toURL().getPath();
        } catch (Exception e) {
            sRet = null;
        }
        return sRet;
    }

    public static String buildEJBModuleName(URL pUrl) {
        String sName;
        try {
            sName = new File(pUrl.getFile()).getName();
            if ("file".equals(pUrl.getProtocol())) {
                sName = buildEJBModuleName(sName);
            }
        } catch (NullPointerException e) {
            sName = null;
        }
        return sName;
    }

    public static String buildEJBModuleName(String pFilename) {
        String sName;
        try {
            sName = new File(pFilename).getName();
            int iPos = sName.lastIndexOf('.');
            if (iPos > -1) {
                sName = sName.substring(0, iPos);
            }
        } catch (NullPointerException e) {
            sName = null;
        }
        return sName;
    }
}

---