* Licensed to the Apache Software Foundation (ASF) under one or more

* contributor license agreements.  See the NOTICE file distributed with

* this work for additional information regarding copyright ownership.

* The ASF licenses this file to You under the Apache License, Version 2.0

* (the "License"); you may not use this file except in compliance with

* the License.  You may obtain a copy of the License at

*

*     http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

* See the License for the specific language governing permissions and

* limitations under the License.

*/

    static {

        AsmParameterNameLoader.install();

        // avoid linkage error on mac

        // adding just in case others run into in their tests

        JULLoggerFactory.class.getName();

    }

    public static final String OPENEJB_URL_PKG_PREFIX = IvmContext.class.getPackage().getName();

    public static final Logger logger = Logger.getInstance(LogCategory.OPENEJB_STARTUP, Assembler.class);

    public static final String OPENEJB_JPA_DEPLOY_TIME_ENHANCEMENT_PROP = "openejb.jpa.deploy-time-enhancement";

    private static final String GLOBAL_UNIQUE_ID = "global";

    Messages messages = new Messages(Assembler.class.getPackage().getName());

    private final CoreContainerSystem containerSystem;

    private final PersistenceClassLoaderHandler persistenceClassLoaderHandler;

    private final JndiBuilder jndiBuilder;

    private TransactionManager transactionManager;

    private SecurityService securityService;

    protected OpenEjbConfigurationFactory configFactory;

    private final Map<String, AppInfo> deployedApplications = new HashMap<String, AppInfo>();

    private final Set<String> moduleIds = new HashSet<String>();

    private final Set<ObjectName> containerObjectNames = new HashSet<ObjectName>();

    private final RemoteResourceMonitor remoteResourceMonitor = new RemoteResourceMonitor();

    @Override

    public org.apache.openejb.spi.ContainerSystem getContainerSystem() {

        return containerSystem;

    }

    @Override

    public TransactionManager getTransactionManager() {

        return transactionManager;

    }

    @Override

    public SecurityService getSecurityService() {

        return securityService;

    }

    public synchronized void addDeploymentListener(final DeploymentListener deploymentListener) {

        logger.warning("DeploymentListener API is replaced by @Observes event");

        SystemInstance.get().addObserver(new DeploymentListenerObserver(deploymentListener));

    }

    public synchronized void removeDeploymentListener(final DeploymentListener deploymentListener) {

        // the wrapping is done here to get the correct equals/hashcode methods

        SystemInstance.get().removeObserver(new DeploymentListenerObserver(deploymentListener));

    }

    protected SafeToolkit toolkit = SafeToolkit.getToolkit("Assembler");

    protected OpenEjbConfiguration config;

    public Assembler() {

        this(new IvmJndiFactory());

    }

    public Assembler(final JndiFactory jndiFactory) {

        persistenceClassLoaderHandler = new PersistenceClassLoaderHandlerImpl();

        installNaming();

        final SystemInstance system = SystemInstance.get();

        system.setComponent(org.apache.openejb.spi.Assembler.class, this);

        system.setComponent(Assembler.class, this);

        containerSystem = new CoreContainerSystem(jndiFactory);

        system.setComponent(ContainerSystem.class, containerSystem);

        jndiBuilder = new JndiBuilder(containerSystem.getJNDIContext());

        setConfiguration(new OpenEjbConfiguration());

        final ApplicationServer appServer = system.getComponent(ApplicationServer.class);

        if (appServer == null) {

            system.setComponent(ApplicationServer.class, new org.apache.openejb.core.ServerFederation());

        }

        system.setComponent(EjbResolver.class, new EjbResolver(null, EjbResolver.Scope.GLOBAL));

        installExtensions();

        system.fireEvent(new AssemblerCreated());

    }

    private void installExtensions() {

        EventHelper.installExtensions(new ResourceFinder("META-INF"));

    }

    private void setConfiguration(final OpenEjbConfiguration config) {

        this.config = config;

        if (config.containerSystem == null) {

            config.containerSystem = new ContainerSystemInfo();

        }

        if (config.facilities == null) {

            config.facilities = new FacilitiesInfo();

        }

        SystemInstance.get().setComponent(OpenEjbConfiguration.class, this.config);

    }

    @Override

    public void init(final Properties props) throws OpenEJBException {

        this.props = new Properties(props);

        final Options options = new Options(props, SystemInstance.get().getOptions());

        final String className = options.get("openejb.configurator", "org.apache.openejb.config.ConfigurationFactory");

        if ("org.apache.openejb.config.ConfigurationFactory".equals(className)) {

            configFactory = new ConfigurationFactory(); // no need to use reflection

        } else {

            configFactory = (OpenEjbConfigurationFactory) toolkit.newInstance(className);

        }

        configFactory.init(props);

        SystemInstance.get().setComponent(OpenEjbConfigurationFactory.class, configFactory);

    }

    public static void installNaming() {

        if (SystemInstance.get().hasProperty("openejb.geronimo"))

            return;

        /* Add IntraVM JNDI service /////////////////////*/

        installNaming(OPENEJB_URL_PKG_PREFIX);

        /*\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\*/

    }

    public static void installNaming(final String prefix) {

        installNaming(prefix, false);

    }

    public static synchronized void installNaming(final String prefix, final boolean clean) {

        final Properties systemProperties = System.getProperties();

        String str = systemProperties.getProperty(Context.URL_PKG_PREFIXES);

        if (str == null || clean) {

            str = prefix;

        } else if (!str.contains(prefix)) {

            str = str + ":" + prefix;

        }

        systemProperties.setProperty(Context.URL_PKG_PREFIXES, str);

    }

    private static final ThreadLocal<Map<String, Object>> context = new ThreadLocal<Map<String, Object>>();

    public static void setContext(final Map<String, Object> map) {

        context.set(map);

    }

    public static Map<String, Object> getContext() {

        Map<String, Object> map = context.get();

        if (map == null) {

            map = new HashMap<String, Object>();

            context.set(map);

        }

        return map;

    }

    @Override

    public void build() throws OpenEJBException {

        setContext(new HashMap<String, Object>());

        try {

            final OpenEjbConfiguration config = getOpenEjbConfiguration();

            buildContainerSystem(config);

        } catch (OpenEJBException ae) {

            /* OpenEJBExceptions contain useful information and are debbugable.

             * Let the exception pass through to the top and be logged.

             */

            throw ae;

        } catch (Exception e) {

            /* General Exceptions at this level are too generic and difficult to debug.

             * These exceptions are considered unknown bugs and are fatal.

             * If you get an error at this level, please trap and handle the error

             * where it is most relevant.

             */

            OpenEJBErrorHandler.handleUnknownError(e, "Assembler");

            throw new OpenEJBException(e);

        } finally {

            context.set(null);

        }

    }

    protected OpenEjbConfiguration getOpenEjbConfiguration() throws OpenEJBException {

        return configFactory.getOpenEjbConfiguration();

    }

    /////////////////////////////////////////////////////////////////////

    ////

    ////    Public Methods Used for Assembly

    ////

    /////////////////////////////////////////////////////////////////////

    /**

     * When given a complete OpenEjbConfiguration graph this method

     * will construct an entire container system and return a reference to that

     * container system, as ContainerSystem instance.

     * <p/>

     * This method leverage the other assemble and apply methods which

     * can be used independently.

     * <p/>

     * Assembles and returns the {@link org.apache.openejb.core.CoreContainerSystem} using the

     * information from the {@link OpenEjbConfiguration} object passed in.

     * <pre>

     * This method performs the following actions(in order):

     *

     * 1  Assembles ProxyFactory

     * 2  Assembles External JNDI Contexts

     * 3  Assembles TransactionService

     * 4  Assembles SecurityService

     * 5  Assembles ConnectionManagers

     * 6  Assembles Connectors

     * 7  Assembles Containers

     * 8  Assembles Applications

     * </pre>

     *

     * @param configInfo OpenEjbConfiguration

     * @throws Exception if there was a problem constructing the ContainerSystem.

     * @see OpenEjbConfiguration

     */

    @SuppressWarnings("ThrowableResultOfMethodCallIgnored")

    public void buildContainerSystem(final OpenEjbConfiguration configInfo) throws Exception {

        if (SystemInstance.get().getOptions().get(OPENEJB_JPA_DEPLOY_TIME_ENHANCEMENT_PROP, false)) {

            SystemInstance.get().addObserver(new DeployTimeEnhancer());

        }

        for (final ServiceInfo serviceInfo : configInfo.facilities.services) {

            createService(serviceInfo);

        }

        final ContainerSystemInfo containerSystemInfo = configInfo.containerSystem;

        if (configInfo.facilities.intraVmServer != null) {

            createProxyFactory(configInfo.facilities.intraVmServer);

        }

        for (final JndiContextInfo contextInfo : configInfo.facilities.remoteJndiContexts) {

            createExternalContext(contextInfo);

        }

        createTransactionManager(configInfo.facilities.transactionService);

        createSecurityService(configInfo.facilities.securityService);

        for (final ResourceInfo resourceInfo : configInfo.facilities.resources) {

            createResource(resourceInfo);

        }

        // Containers

        for (final ContainerInfo serviceInfo : containerSystemInfo.containers) {

            createContainer(serviceInfo);

        }

        for (final AppInfo appInfo : containerSystemInfo.applications) {

            try {

                createApplication(appInfo, createAppClassLoader(appInfo));

            } catch (DuplicateDeploymentIdException e) {

                // already logged.

            } catch (Throwable e) {

                logger.error("appNotDeployed", e, appInfo.path);

                final DeploymentExceptionManager exceptionManager = SystemInstance.get().getComponent(DeploymentExceptionManager.class);

                if (exceptionManager != null && e instanceof Exception) {

                    exceptionManager.saveDeploymentException(appInfo, (Exception) e);

                }

            }

        }

        SystemInstance.get().fireEvent(new ContainerSystemPostCreate());

    }

    public boolean isDeployed(final String path) {

        return deployedApplications.containsKey(ProvisioningUtil.realLocation(path));

    }

    public Collection<AppInfo> getDeployedApplications() {

        return new ArrayList<AppInfo>(deployedApplications.values());

    }

    public AppContext createApplication(final EjbJarInfo ejbJar) throws NamingException, IOException, OpenEJBException {

        return createEjbJar(ejbJar);

    }

    public AppContext createEjbJar(final EjbJarInfo ejbJar) throws NamingException, IOException, OpenEJBException {

        final AppInfo appInfo = new AppInfo();

        appInfo.path = ejbJar.path;

        appInfo.appId = ejbJar.moduleName;

        appInfo.ejbJars.add(ejbJar);

        return createApplication(appInfo);

    }

    public AppContext createApplication(final EjbJarInfo ejbJar, final ClassLoader classLoader) throws NamingException, IOException, OpenEJBException {

        return createEjbJar(ejbJar, classLoader);

    }

    public AppContext createEjbJar(final EjbJarInfo ejbJar, final ClassLoader classLoader) throws NamingException, IOException, OpenEJBException {

        final AppInfo appInfo = new AppInfo();

        appInfo.path = ejbJar.path;

        appInfo.appId = ejbJar.moduleName;

        appInfo.ejbJars.add(ejbJar);

        return createApplication(appInfo, classLoader);

    }

    public AppContext createClient(final ClientInfo clientInfo) throws NamingException, IOException, OpenEJBException {

        final AppInfo appInfo = new AppInfo();

        appInfo.path = clientInfo.path;

        appInfo.appId = clientInfo.moduleId;

        appInfo.clients.add(clientInfo);

        return createApplication(appInfo);

    }

    public AppContext createClient(final ClientInfo clientInfo, final ClassLoader classLoader) throws NamingException, IOException, OpenEJBException {

        final AppInfo appInfo = new AppInfo();

        appInfo.path = clientInfo.path;

        appInfo.appId = clientInfo.moduleId;

        appInfo.clients.add(clientInfo);

        return createApplication(appInfo, classLoader);

    }

    public AppContext createConnector(final ConnectorInfo connectorInfo) throws NamingException, IOException, OpenEJBException {

        final AppInfo appInfo = new AppInfo();

        appInfo.path = connectorInfo.path;

        appInfo.appId = connectorInfo.moduleId;

        appInfo.connectors.add(connectorInfo);

        return createApplication(appInfo);

    }

    public AppContext createConnector(final ConnectorInfo connectorInfo, final ClassLoader classLoader) throws NamingException, IOException, OpenEJBException {

        final AppInfo appInfo = new AppInfo();

        appInfo.path = connectorInfo.path;

        appInfo.appId = connectorInfo.moduleId;

        appInfo.connectors.add(connectorInfo);

        return createApplication(appInfo, classLoader);

    }

    public AppContext createWebApp(final WebAppInfo webAppInfo) throws NamingException, IOException, OpenEJBException {

        final AppInfo appInfo = new AppInfo();

        appInfo.path = webAppInfo.path;

        appInfo.appId = webAppInfo.moduleId;

        appInfo.webApps.add(webAppInfo);

        return createApplication(appInfo);

    }

    public AppContext createWebApp(final WebAppInfo webAppInfo, final ClassLoader classLoader) throws NamingException, IOException, OpenEJBException {

        final AppInfo appInfo = new AppInfo();

        appInfo.path = webAppInfo.path;

        appInfo.appId = webAppInfo.moduleId;

        appInfo.webApps.add(webAppInfo);

        return createApplication(appInfo, classLoader);

    }

    public AppContext createApplication(final AppInfo appInfo) throws OpenEJBException, IOException, NamingException {

        return createApplication(appInfo, createAppClassLoader(appInfo));

    }

    public AppContext createApplication(final AppInfo appInfo, final ClassLoader classLoader) throws OpenEJBException, IOException, NamingException {

        return createApplication(appInfo, classLoader, true);

    }

    public AppContext createApplication(final AppInfo appInfo, ClassLoader classLoader, final boolean start) throws OpenEJBException, IOException, NamingException {

        // The path is used in the UrlCache, command line deployer, JNDI name templates, tomcat integration and a few other places

        if (appInfo.appId == null) {

            throw new IllegalArgumentException("AppInfo.appId cannot be null");

        }

        if (appInfo.path == null) {

            appInfo.path = appInfo.appId;

        }

        logger.info("createApplication.start", appInfo.path);

        //        try {

        //            Thread.sleep(5000);

        //        } catch (InterruptedException e) {

        //            e.printStackTrace();

        //            Thread.interrupted();

        //        }

        // To start out, ensure we don't already have any beans deployed with duplicate IDs.  This

        // is a conflict we can't handle.

        final List<String> used = new ArrayList<String>();

        for (final EjbJarInfo ejbJarInfo : appInfo.ejbJars) {

            for (final EnterpriseBeanInfo beanInfo : ejbJarInfo.enterpriseBeans) {

                if (containerSystem.getBeanContext(beanInfo.ejbDeploymentId) != null) {

                    used.add(beanInfo.ejbDeploymentId);

                }

            }

        }

        if (used.size() > 0) {

            String message = logger.error("createApplication.appFailedDuplicateIds", appInfo.path);

            for (final String id : used) {

                logger.debug("createApplication.deploymentIdInUse", id);

                message += "\n    " + id;

            }

            throw new DuplicateDeploymentIdException(message);

        }

        //Construct the global and app jndi contexts for this app

        final InjectionBuilder injectionBuilder = new InjectionBuilder(classLoader);

        final Set<Injection> injections = new HashSet<Injection>();

        injections.addAll(injectionBuilder.buildInjections(appInfo.globalJndiEnc));

        injections.addAll(injectionBuilder.buildInjections(appInfo.appJndiEnc));

        final JndiEncBuilder globalBuilder = new JndiEncBuilder(appInfo.globalJndiEnc, injections, appInfo.appId, null, GLOBAL_UNIQUE_ID, classLoader);

        final Map<String, Object> globalBindings = globalBuilder.buildBindings(JndiEncBuilder.JndiScope.global);

        final Context globalJndiContext = globalBuilder.build(globalBindings);

        final JndiEncBuilder appBuilder = new JndiEncBuilder(appInfo.appJndiEnc, injections, appInfo.appId, null, appInfo.appId, classLoader);

        final Map<String, Object> appBindings = appBuilder.buildBindings(JndiEncBuilder.JndiScope.app);

        final Context appJndiContext = appBuilder.build(appBindings);

        try {

            // Generate the cmp2/cmp1 concrete subclasses

            final CmpJarBuilder cmpJarBuilder = new CmpJarBuilder(appInfo, classLoader);

            final File generatedJar = cmpJarBuilder.getJarFile();

            if (generatedJar != null) {

                classLoader = ClassLoaderUtil.createClassLoader(appInfo.path, new URL[]{generatedJar.toURI().toURL()}, classLoader);

            }

            final AppContext appContext = new AppContext(appInfo.appId, SystemInstance.get(), classLoader, globalJndiContext, appJndiContext, appInfo.standaloneModule);

            appContext.getProperties().putAll(appInfo.properties);

            appContext.getInjections().addAll(injections);

            appContext.getBindings().putAll(globalBindings);

            appContext.getBindings().putAll(appBindings);

            containerSystem.addAppContext(appContext);

            appContext.set(AsynchronousPool.class, AsynchronousPool.create(appContext));

            final Context containerSystemContext = containerSystem.getJNDIContext();

            if (!SystemInstance.get().hasProperty("openejb.geronimo")) {

                // Bean Validation

                // ValidatorFactory needs to be put in the map sent to the entity manager factory

                // so it has to be constructed before

                final List<CommonInfoObject> vfs = new ArrayList<CommonInfoObject>();

                for (final ClientInfo clientInfo : appInfo.clients) {

                    vfs.add(clientInfo);

                }

                for (final ConnectorInfo connectorInfo : appInfo.connectors) {

                    vfs.add(connectorInfo);

                }

                for (final EjbJarInfo ejbJarInfo : appInfo.ejbJars) {

                    vfs.add(ejbJarInfo);

                }

                for (final WebAppInfo webAppInfo : appInfo.webApps) {

                    vfs.add(webAppInfo);

                }

                final Map<String, ValidatorFactory> validatorFactories = new HashMap<String, ValidatorFactory>();

                for (final CommonInfoObject info : vfs) {

                    ValidatorFactory factory = null;

                    try {

                        factory = ValidatorBuilder.buildFactory(classLoader, info.validationInfo);

                    } catch (ValidationException ve) {

                        logger.warning("can't build the validation factory for module " + info.uniqueId, ve);

                    }

                    if (factory != null) {

                        validatorFactories.put(info.uniqueId, factory);

                    }

                }

                moduleIds.addAll(validatorFactories.keySet());

                // validators bindings

                for (final Entry<String, ValidatorFactory> validatorFactory : validatorFactories.entrySet()) {

                    final String id = validatorFactory.getKey();

                    final ValidatorFactory factory = validatorFactory.getValue();

                    try {

                        containerSystemContext.bind(VALIDATOR_FACTORY_NAMING_CONTEXT + id, factory);

                        Validator validator;

                        try {

                            validator = factory.usingContext().getValidator();

                        } catch (Exception e) {

                            validator = (Validator) Proxy.newProxyInstance(appContext.getClassLoader(), new Class<?>[]{Validator.class}, new LazyValidator(factory));

                        }

                        containerSystemContext.bind(VALIDATOR_NAMING_CONTEXT + id, validator);

                    } catch (NameAlreadyBoundException e) {

                        throw new OpenEJBException("ValidatorFactory already exists for module " + id, e);

                    } catch (Exception e) {

                        throw new OpenEJBException(e);

                    }

                }

            }

            // JPA - Persistence Units MUST be processed first since they will add ClassFileTransformers

            // to the class loader which must be added before any classes are loaded

            final Map<String, String> units = new HashMap<String, String>();

            final PersistenceBuilder persistenceBuilder = new PersistenceBuilder(persistenceClassLoaderHandler);

            for (final PersistenceUnitInfo info : appInfo.persistenceUnits) {

                final ReloadableEntityManagerFactory factory;

                try {

                    factory = persistenceBuilder.createEntityManagerFactory(info, classLoader);

                    containerSystem.getJNDIContext().bind(PERSISTENCE_UNIT_NAMING_CONTEXT + info.id, factory);

                    units.put(info.name, PERSISTENCE_UNIT_NAMING_CONTEXT + info.id);

                } catch (NameAlreadyBoundException e) {

                    throw new OpenEJBException("PersistenceUnit already deployed: " + info.persistenceUnitRootUrl);

                } catch (Exception e) {

                    throw new OpenEJBException(e);

                }

                factory.register();

            }

            logger.debug("Loaded peristence units: " + units);

            // Connectors

            for (final ConnectorInfo connector : appInfo.connectors) {

                final ClassLoader oldClassLoader = Thread.currentThread().getContextClassLoader();

                Thread.currentThread().setContextClassLoader(classLoader);

                try {

                    // todo add undeployment code for these

                    if (connector.resourceAdapter != null) {

                        createResource(connector.resourceAdapter);

                    }

                    for (final ResourceInfo outbound : connector.outbound) {

                        createResource(outbound);

                    }

                    for (final MdbContainerInfo inbound : connector.inbound) {

                        createContainer(inbound);

                    }

                    for (final ResourceInfo adminObject : connector.adminObject) {

                        createResource(adminObject);

                    }

                } finally {

                    Thread.currentThread().setContextClassLoader(oldClassLoader);

                }

            }

            final List<BeanContext> allDeployments = initEjbs(classLoader, appInfo, appContext, injections, new ArrayList<BeanContext>(), null);

            new CdiBuilder().build(appInfo, appContext, allDeployments);

            ensureWebBeansContext(appContext);

            appJndiContext.bind("app/BeanManager", appContext.getBeanManager());

            appContext.getBindings().put("app/BeanManager", appContext.getBeanManager());

            startEjbs(start, allDeployments);

            // App Client

            for (final ClientInfo clientInfo : appInfo.clients) {

                // determine the injections

                final List<Injection> clientInjections = injectionBuilder.buildInjections(clientInfo.jndiEnc);

                // build the enc

                final JndiEncBuilder jndiEncBuilder = new JndiEncBuilder(clientInfo.jndiEnc, clientInjections, "Bean", clientInfo.moduleId, null, clientInfo.uniqueId, classLoader);

                // if there is at least a remote client classes

                // or if there is no local client classes

                // then, we can set the client flag

                if ((clientInfo.remoteClients.size() > 0) || (clientInfo.localClients.size() == 0)) {

                    jndiEncBuilder.setClient(true);

                }

                jndiEncBuilder.setUseCrossClassLoaderRef(false);

                final Context context = jndiEncBuilder.build(JndiEncBuilder.JndiScope.comp);

                //                Debug.printContext(context);

                containerSystemContext.bind("openejb/client/" + clientInfo.moduleId, context);

                if (clientInfo.path != null) {

                    context.bind("info/path", clientInfo.path);

                }

                if (clientInfo.mainClass != null) {

                    context.bind("info/mainClass", clientInfo.mainClass);

                }

                if (clientInfo.callbackHandler != null) {

                    context.bind("info/callbackHandler", clientInfo.callbackHandler);

                }

                context.bind("info/injections", clientInjections);

                for (final String clientClassName : clientInfo.remoteClients) {

                    containerSystemContext.bind("openejb/client/" + clientClassName, clientInfo.moduleId);

                }

                for (final String clientClassName : clientInfo.localClients) {

                    containerSystemContext.bind("openejb/client/" + clientClassName, clientInfo.moduleId);

                    logger.getChildLogger("client").info("createApplication.createLocalClient", clientClassName, clientInfo.moduleId);

                }

            }

            final SystemInstance systemInstance = SystemInstance.get();

            // WebApp

            final WebAppBuilder webAppBuilder = systemInstance.getComponent(WebAppBuilder.class);

            if (webAppBuilder != null) {

                webAppBuilder.deployWebApps(appInfo, classLoader);

            }

            if (start) {

                final EjbResolver globalEjbResolver = systemInstance.getComponent(EjbResolver.class);

                globalEjbResolver.addAll(appInfo.ejbJars);

            }

            // bind all global values on global context

            for (final Map.Entry<String, Object> value : appContext.getBindings().entrySet()) {

                final String path = value.getKey();

                // keep only global bindings

                if (path.startsWith("module/") || path.startsWith("app/") || path.startsWith("comp/") || path.equalsIgnoreCase("global/dummy")) {

                    continue;

                }

                // a bit weird but just to be consistent if user doesn't lookup directly the resource

                final Context lastContext = Contexts.createSubcontexts(containerSystemContext, path);

                try {

                    lastContext.rebind(path.substring(path.lastIndexOf("/") + 1, path.length()), value.getValue());

                } catch (NameAlreadyBoundException nabe) {

                    nabe.printStackTrace();

                }

                containerSystemContext.rebind(path, value.getValue());

            }

            // deploy MBeans

            for (final String mbean : appInfo.mbeans) {

                deployMBean(appContext.getWebBeansContext(), classLoader, mbean, appInfo.jmx, appInfo.appId);

            }

            for (final EjbJarInfo ejbJarInfo : appInfo.ejbJars) {

                for (final String mbean : ejbJarInfo.mbeans) {

                    deployMBean(appContext.getWebBeansContext(), classLoader, mbean, appInfo.jmx, ejbJarInfo.moduleName);

                }

            }

            for (final ConnectorInfo connectorInfo : appInfo.connectors) {

                for (final String mbean : connectorInfo.mbeans) {

                    deployMBean(appContext.getWebBeansContext(), classLoader, mbean, appInfo.jmx, appInfo.appId + ".add-lib");