* 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.

*/

    public static final String OPENEJB_JDBC_DATASOURCE_CREATOR = "openejb.jdbc.datasource-creator";

    public static final String ADDITIONAL_DEPLOYMENTS = "conf/deployments.xml";

    static final String CONFIGURATION_PROPERTY = "openejb.configuration";

    static final String CONF_FILE_PROPERTY = "openejb.conf.file";

    private static final String DEBUGGABLE_VM_HACKERY_PROPERTY = "openejb.debuggable-vm-hackery";

    protected static final String VALIDATION_SKIP_PROPERTY = "openejb.validation.skip";

    private static final Logger logger = Logger.getInstance(LogCategory.OPENEJB_STARTUP_CONFIG, ConfigurationFactory.class);

    private static final Messages messages = new Messages(ConfigurationFactory.class);

    private static final String IGNORE_DEFAULT_VALUES_PROP = "IgnoreDefaultValues";

    private static final boolean WSDL4J_AVAILABLE = exists("javax.wsdl.xml.WSDLLocator");

    private String configLocation;

    private OpenEjbConfiguration sys;

    private Openejb openejb;

    private final DynamicDeployer deployer;

    private final DeploymentLoader deploymentLoader;

    private final boolean offline;

    private final boolean serviceTypeIsAdjustable; // offline is a bit different from this and offline could be off and this on

    private static final String CLASSPATH_AS_EAR = "openejb.deployments.classpath.ear";

    static final String WEBSERVICES_ENABLED = "openejb.webservices.enabled";

    static final String OFFLINE_PROPERTY = "openejb.offline";

    public ConfigurationFactory() {

        this(!shouldAutoDeploy());

    }

    private static boolean exists(final String s) {

        try {

            ConfigurationFactory.class.getClassLoader().loadClass(s);

            return true;

        } catch (final ClassNotFoundException e) {

            return false;

        } catch (final NoClassDefFoundError e) {

            return false;

        }

    }

    private static boolean shouldAutoDeploy() {

        final Options options = SystemInstance.get().getOptions();

        final boolean b = options.get(ConfigurationFactory.OFFLINE_PROPERTY, false);

        return options.get("tomee.autoconfig", !b);

    }

    public ConfigurationFactory(final boolean offline) {

        this(offline, (DynamicDeployer) null);

    }

    public ConfigurationFactory(final boolean offline, final DynamicDeployer preAutoConfigDeployer) {

        this.offline = offline;

        this.serviceTypeIsAdjustable = SystemInstance.get().getOptions().get("openejb.service-type-adjustement", true);

        this.deploymentLoader = new DeploymentLoader();

        LocalMBeanServer.reset();

        final Options options = SystemInstance.get().getOptions();

        if (SystemInstance.get().getComponent(DataSourceCreator.class) == null) {

            final String creator = options.get(OPENEJB_JDBC_DATASOURCE_CREATOR, (String) null);

            if (creator == null) {

                SystemInstance.get().setComponent(DataSourceCreator.class, new DefaultDataSourceCreator());

            } else {

                try {

                    SystemInstance.get().setComponent(DataSourceCreator.class, DataSourceFactory.creator(creator, false));

                } catch (final Exception e) {

                    logger.error("can't load " + creator + " will use the default creator", e);

                    SystemInstance.get().setComponent(DataSourceCreator.class, new DefaultDataSourceCreator());

                }

            }

        }

        if (SystemInstance.get().getComponent(ClassLoaderEnricher.class) == null) {

            SystemInstance.get().setComponent(ClassLoaderEnricher.class, new ClassLoaderEnricher());

        }

        // annotation deployer encapsulate some logic, to be able to push to it some config

        // we give the ability here to get the internal deployer to push the config values

        final AnnotationDeployer annotationDeployer = new AnnotationDeployer();

        final BeanProperties beanProperties = new BeanProperties();

        final AppContextConfigDeployer appContextConfigDeployer = new AppContextConfigDeployer(annotationDeployer.getEnvEntriesPropertiesDeployer(), beanProperties);

        final Chain chain = new Chain();

        chain.add(new SystemPropertiesOverride());

        chain.add(new GeneratedClientModules.Add());

        chain.add(new ReadDescriptors());

        chain.add(appContextConfigDeployer);

        chain.add(new ApplicationProperties());

        chain.add(new ModuleProperties());

        chain.add(new LegacyProcessor());

        chain.add(annotationDeployer);

        chain.add(beanProperties);

        chain.add(new ProxyBeanClassUpdate());

        chain.add(new GeneratedClientModules.Prune());

        chain.add(new ClearEmptyMappedName());

        //START SNIPPET: code

        if (!options.get(VALIDATION_SKIP_PROPERTY, false)) {

            chain.add(new ValidateModules());

        } else {

            DeploymentLoader.logger.info("validationDisabled", VALIDATION_SKIP_PROPERTY);

        }

        //END SNIPPET: code

        chain.add(new InitEjbDeployments());

        if (options.get(DEBUGGABLE_VM_HACKERY_PROPERTY, false)) {

            chain.add(new DebuggableVmHackery());

        }

        if (options.get(WEBSERVICES_ENABLED, true) && WSDL4J_AVAILABLE) {

            chain.add(new WsDeployer());

        } else {

            chain.add(new RemoveWebServices());

        }

        chain.add(new CmpJpaConversion());

        // By default all vendor support is enabled

        final Set<Vendor> support = SystemInstance.get().getOptions().getAll("openejb.vendor.config", Vendor.values());

        if (support.contains(Vendor.GERONIMO) || SystemInstance.get().hasProperty("openejb.geronimo")) {

            chain.add(new OpenEjb2Conversion());

        }

        if (support.contains(Vendor.GLASSFISH)) {

            chain.add(new SunConversion());

        }

        if (support.contains(Vendor.WEBLOGIC)) {

            chain.add(new WlsConversion());

        }

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

            // must be after CmpJpaConversion since it adds new persistence-context-refs

            chain.add(new GeronimoMappedName());

        }

        if (null != preAutoConfigDeployer) {

            chain.add(preAutoConfigDeployer);

        }

        chain.add(new ConvertDataSourceDefinitions());

        chain.add(new CleanEnvEntries());

        chain.add(new LinkBuiltInTypes());

        if (offline) {

            final AutoConfig autoConfig = new AutoConfig(this);

            autoConfig.autoCreateResources(false);

            autoConfig.autoCreateContainers(false);

            chain.add(autoConfig);

        } else {

            chain.add(new AutoConfig(this));

        }

        chain.add(new ApplyOpenejbJar());

        chain.add(new MappedNameBuilder());

        chain.add(new ActivationConfigPropertyOverride());

        chain.add(new OutputGeneratedDescriptors());

        //        chain.add(new MergeWebappJndiContext());

        this.deployer = chain;

    }

    public ConfigurationFactory(final boolean offline, final OpenEjbConfiguration configuration) {

        this(offline, (DynamicDeployer) null, configuration);

    }

    public ConfigurationFactory(final boolean offline,

                                final DynamicDeployer preAutoConfigDeployer,

                                final OpenEjbConfiguration configuration) {

        this(offline, preAutoConfigDeployer);

        sys = configuration;

    }

    public ConfigurationFactory(final boolean offline, final Chain deployerChain, final OpenEjbConfiguration configuration) {

        this.offline = offline;

        this.deploymentLoader = new DeploymentLoader();

        this.deployer = deployerChain;

        this.sys = configuration;

        this.serviceTypeIsAdjustable = true;

    }

    public static List<HandlerChainInfo> toHandlerChainInfo(final HandlerChains chains) {

        final List<HandlerChainInfo> handlerChains = new ArrayList<HandlerChainInfo>();

        if (chains == null) {

            return handlerChains;

        }

        for (final HandlerChain handlerChain : chains.getHandlerChain()) {

            final HandlerChainInfo handlerChainInfo = new HandlerChainInfo();

            handlerChainInfo.serviceNamePattern = handlerChain.getServiceNamePattern();

            handlerChainInfo.portNamePattern = handlerChain.getPortNamePattern();

            handlerChainInfo.protocolBindings.addAll(handlerChain.getProtocolBindings());

            for (final Handler handler : handlerChain.getHandler()) {

                final HandlerInfo handlerInfo = new HandlerInfo();

                handlerInfo.handlerName = handler.getHandlerName();

                handlerInfo.handlerClass = handler.getHandlerClass();

                handlerInfo.soapHeaders.addAll(handler.getSoapHeader());

                handlerInfo.soapRoles.addAll(handler.getSoapRole());

                for (final ParamValue param : handler.getInitParam()) {

                    handlerInfo.initParams.setProperty(param.getParamName(), param.getParamValue());

                }

                handlerChainInfo.handlers.add(handlerInfo);

            }

            handlerChains.add(handlerChainInfo);

        }

        return handlerChains;

    }

    public static class ProxyBeanClassUpdate implements DynamicDeployer {

        @SuppressWarnings("unchecked")

        @Override

        public AppModule deploy(final AppModule appModule) throws OpenEJBException {

            for (final EjbModule module : appModule.getEjbModules()) {

                for (final EnterpriseBean eb : module.getEjbJar().getEnterpriseBeans()) {

                    if (!(eb instanceof SessionBean)) {

                        continue;

                    }

                    final SessionBean bean = (SessionBean) eb;

                    final Class<?> ejbClass;

                    try {

                        ejbClass = module.getClassLoader().loadClass(bean.getEjbClass());

                    } catch (final ClassNotFoundException e) {

                        logger.warning("can't load " + bean.getEjbClass());

                        continue;

                    }

                    final Class<?> proxyClass;

                    if (ejbClass.isInterface()) { // dynamic proxy implementation

                        bean.setLocal(ejbClass.getName());

                        final Proxy proxyAnnotation = (Proxy) new MetaAnnotatedClass(ejbClass).getAnnotation(Proxy.class);

                        if (proxyAnnotation != null) {

                            proxyClass = proxyAnnotation.value();

                        } else {

                            proxyClass = QueryProxy.class;

                        }

                        bean.setProxy(proxyClass.getName());

                    } else {

                        continue;

                    }

                    for (final EnvEntry entry : bean.getEnvEntry()) {

                        if ("java:comp/env/implementingInterfaceClass".equals(entry.getName())) {

                            entry.setEnvEntryValue(ejbClass.getName());

                        }

                    }

                }

            }

            return appModule;

        }

    }

    public static class Chain implements DynamicDeployer {

        private final List<DynamicDeployer> chain = new ArrayList<DynamicDeployer>();

        public boolean add(final DynamicDeployer o) {

            return chain.add(o);

        }

        @Override

        public AppModule deploy(AppModule appModule) throws OpenEJBException {

            for (final DynamicDeployer deployer : chain) {

                appModule = deployer.deploy(appModule);

            }

            return appModule;

        }

    }

    @Override

    public void init(final Properties props) throws OpenEJBException {

        configLocation = props.getProperty(CONF_FILE_PROPERTY);

        if (configLocation == null) {

            configLocation = props.getProperty(CONFIGURATION_PROPERTY);

        }

        configLocation = ConfigUtils.searchForConfiguration(configLocation);

        if (configLocation != null) {

            logger.info("openejb configuration file is '" + configLocation + "'");

            props.setProperty(CONFIGURATION_PROPERTY, configLocation);

        }

    }

    protected void install(final ContainerInfo serviceInfo) throws OpenEJBException {

        if (sys != null) {

            sys.containerSystem.containers.add(serviceInfo);

        } else if (!offline) {

            final Assembler assembler = SystemInstance.get().getComponent(Assembler.class);

            assembler.createContainer(serviceInfo);

        }

    }

    protected void install(final ResourceInfo serviceInfo) throws OpenEJBException {

        if (sys != null) {

            sys.facilities.resources.add(serviceInfo);

        } else if (!offline) {

            final Assembler assembler = SystemInstance.get().getComponent(Assembler.class);

            assembler.createResource(serviceInfo);

        }

    }

    public OpenEjbConfiguration getOpenEjbConfiguration(final File configuartionFile) throws OpenEJBException {

        if (configuartionFile != null) {

            return getOpenEjbConfiguration(JaxbOpenejb.readConfig(configuartionFile.getAbsolutePath()));

        } else {

            return getOpenEjbConfiguration((Openejb) null);

        }

    }

    public OpenEjbConfiguration getOpenEjbConfiguration(final Openejb providedConf) throws OpenEJBException {

        if (sys != null) {

            return sys;

        }

        if (providedConf != null) {

            openejb = providedConf;

        } else if (configLocation != null) {

            openejb = JaxbOpenejb.readConfig(configLocation);

        } else {

            openejb = JaxbOpenejb.createOpenejb();

        }

        loadPropertiesDeclaredConfiguration(openejb);

        sys = new OpenEjbConfiguration();

        sys.containerSystem = new ContainerSystemInfo();

        sys.facilities = new FacilitiesInfo();

        // listener + some config can be defined as service

        for (final Service service : openejb.getServices()) {

            final ServiceInfo info = configureService(service, ServiceInfo.class);

            sys.facilities.services.add(info);

        }

        for (final JndiProvider provider : openejb.getJndiProvider()) {

            final JndiContextInfo info = configureService(provider, JndiContextInfo.class);

            sys.facilities.remoteJndiContexts.add(info);

        }

        sys.facilities.securityService = configureService(openejb.getSecurityService(), SecurityServiceInfo.class);

        sys.facilities.transactionService = configureService(openejb.getTransactionManager(), TransactionServiceInfo.class);

        final List<ResourceInfo> resources = new ArrayList<ResourceInfo>();

        for (final Resource resource : openejb.getResource()) {

            final ResourceInfo resourceInfo = configureService(resource, ResourceInfo.class);

            resources.add(resourceInfo);

        }

        Collections.sort(resources, new ResourceInfoComparator(resources));

        sys.facilities.resources.addAll(resources);

        //        ConnectionManagerInfo service = configureService(openejb.getConnectionManager(), ConnectionManagerInfo.class);

        //        sys.facilities.connectionManagers.add(service);

        if (openejb.getProxyFactory() != null) {

            sys.facilities.intraVmServer = configureService(openejb.getProxyFactory(), ProxyFactoryInfo.class);

        }

        for (final Container declaration : openejb.getContainer()) {

            final ContainerInfo info = createContainerInfo(declaration);

            sys.containerSystem.containers.add(info);

        }

        final List<File> declaredApps = getDeclaredApps();

        for (final File jarFile : declaredApps) {

            try {

                final AppInfo appInfo = configureApplication(jarFile);

                sys.containerSystem.applications.add(appInfo);

            } catch (final OpenEJBException alreadyHandled) {

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

                if (exceptionManager != null) {

                    exceptionManager.pushDelpoymentException(alreadyHandled);

                }

            }

        }

        final boolean embedded = SystemInstance.get().hasProperty(EJBContainer.class.getName());

        final Options options = SystemInstance.get().getOptions();

        if (options.get("openejb.system.apps", false)) {

            try {

                final AppInfo appInfo = configureApplication(new AppModule(SystemApps.getSystemModule()));

                // they doesn't use CDI so no need to activate it

                // 1) will be faster

                // 2) will let embedded containers (tomee-embedded mainly) not be noised by it in our singleton service

                appInfo.properties.put("openejb.cdi.activated", "false");

                sys.containerSystem.applications.add(appInfo);

            } catch (final OpenEJBException e) {

                logger.error("Unable to load the system applications.", e);

            }

        } else if (options.get(DEPLOYMENTS_CLASSPATH_PROPERTY, !embedded)) {

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

            final ArrayList<File> jarFiles = getModulesFromClassPath(declaredApps, classLoader);

            final String appId = "classpath.ear";

            final boolean classpathAsEar = options.get(CLASSPATH_AS_EAR, true);

            try {

                if (classpathAsEar && !jarFiles.isEmpty()) {

                    final AppInfo appInfo = configureApplication(classLoader, appId, jarFiles);

                    sys.containerSystem.applications.add(appInfo);

                } else {

                    for (final File jarFile : jarFiles) {

                        final AppInfo appInfo = configureApplication(jarFile);

                        sys.containerSystem.applications.add(appInfo);

                    }

                }

                if (jarFiles.size() == 0) {

                    logger.warning("config.noModulesFoundToDeploy");

                }

            } catch (final OpenEJBException alreadyHandled) {

                logger.debug("config.alreadyHandled");

            }

        }

        for (final Deployments deployments : openejb.getDeployments()) {

            if (deployments.isAutoDeploy()) {

                if (deployments.getDir() != null) {

                    sys.containerSystem.autoDeploy.add(deployments.getDir());

                }

            }

        }

        final OpenEjbConfiguration finished = sys;

        sys = null;

        openejb = null;

        return finished;

    }

    /**

     * Main loop that gets executed when OpenEJB starts up Reads config files and produces the basic "AST" the assembler needs to actually build the contianer system

     * <p/>

     * This method is called by the Assembler once at startup.

     *

     * @return OpenEjbConfiguration

     * @throws OpenEJBException

     */

    @Override

    public OpenEjbConfiguration getOpenEjbConfiguration() throws OpenEJBException {

        return getOpenEjbConfiguration((Openejb) null);

    }

    private List<File> getDeclaredApps() {

        // make a copy of the list because we update it

        final List<Deployments> deployments = new ArrayList<Deployments>();

        if (openejb != null) {

            deployments.addAll(openejb.getDeployments());

        }

        Collection<Deployments> additionalDeploymentsList = Collections.emptyList();

        try {

            final File additionalDeploymentFile = SystemInstance.get().getBase().getFile(ADDITIONAL_DEPLOYMENTS, false);

            if (additionalDeploymentFile.exists()) {

                InputStream fis = null;

                try {

                    fis = IO.read(additionalDeploymentFile);

                    final AdditionalDeployments additionalDeployments = JaxbOpenejb.unmarshal(AdditionalDeployments.class, fis);

                    additionalDeploymentsList = additionalDeployments.getDeployments();

                } catch (final Exception e) {

                    logger.error("can't read " + ADDITIONAL_DEPLOYMENTS, e);

                } finally {

                    IO.close(fis);

                }

            }

        } catch (final Exception e) {

            logger.info("No additional deployments found: " + e);

        }

        // resolve jar locations //////////////////////////////////////  BEGIN  ///////

        final FileUtils base = SystemInstance.get().getBase();

        final List<Deployments> autoDeploy = new ArrayList<Deployments>();

        final List<File> declaredAppsUrls = new ArrayList<File>();

        for (final Deployments deployment : deployments) {

            try {

                DeploymentsResolver.loadFrom(deployment, base, declaredAppsUrls);

                if (deployment.isAutoDeploy()) {

                    autoDeploy.add(deployment);

                }

            } catch (final SecurityException se) {

                logger.warning("Security check failed on deployment: " + deployment.getFile(), se);

            }

        }

        for (final Deployments additionalDep : additionalDeploymentsList) {

            if (additionalDep.getFile() != null) {

                declaredAppsUrls.add(Files.path(base.getDirectory().getAbsoluteFile(), additionalDep.getFile()));

            } else if (additionalDep.getDir() != null) {

                declaredAppsUrls.add(Files.path(base.getDirectory().getAbsoluteFile(), additionalDep.getDir()));

            }

            if (additionalDep.isAutoDeploy()) {

                autoDeploy.add(additionalDep);

            }

        }

        if (autoDeploy.size() > 0) {

            final AutoDeployer autoDeployer = new AutoDeployer(this, autoDeploy);

            SystemInstance.get().setComponent(AutoDeployer.class, autoDeployer);

            SystemInstance.get().addObserver(autoDeployer);

        }

        return declaredAppsUrls;

    }

    public ArrayList<File> getModulesFromClassPath(final List<File> declaredApps, final ClassLoader classLoader) {

        final FileUtils base = SystemInstance.get().getBase();

        final List<URL> classpathAppsUrls = new ArrayList<URL>();

        DeploymentsResolver.loadFromClasspath(base, classpathAppsUrls, classLoader);

        final ArrayList<File> jarFiles = new ArrayList<File>();

        for (final URL path : classpathAppsUrls) {

            final File file = URLs.toFile(path);

            if (declaredApps != null && declaredApps.contains(file)) {

                continue;

            }

            jarFiles.add(file);

        }

        return jarFiles;

    }

    public ContainerInfo createContainerInfo(final Container container) throws OpenEJBException {

        final Class<? extends ContainerInfo> infoClass = getContainerInfoType(container.getType());

        if (infoClass == null) {

            throw new OpenEJBException(messages.format("unrecognizedContainerType", container.getType()));

        }

        return configureService(container, infoClass);

    }

    private void loadPropertiesDeclaredConfiguration(final Openejb openejb) {

        final Properties sysProps = new Properties(System.getProperties());

        sysProps.putAll(SystemInstance.get().getProperties());

        for (final Map.Entry<Object, Object> entry : sysProps.entrySet()) {

            final Object o = entry.getValue();

            if (!(o instanceof String)) {

                continue;

            }

            if (!((String) o).startsWith("new://")) {

                continue;

            }

            final String name = (String) entry.getKey();

            final String value = (String) entry.getValue();

            try {

                final Object service = toConfigDeclaration(name, value);

                openejb.add(service);

            } catch (final URISyntaxException e) {

                logger.error("Error declaring service '" + name + "'. Invalid Service URI '" + value + "'.  java.net.URISyntaxException: " + e.getMessage());

            } catch (final OpenEJBException e) {

                logger.error(e.getMessage());

            }

        }

    }

    protected Object toConfigDeclaration(final String name, String value) throws URISyntaxException, OpenEJBException {

        //        value = value.replaceFirst("(.)#", "$1%23");

        value = value.replaceFirst("(provider=[^#=&]+)#", "$1%23");

        final URI uri = URLs.uri(value);

        return toConfigDeclaration(name, uri);

    }

    public Object toConfigDeclaration(final String id, final URI uri) throws OpenEJBException {

        final String serviceType;

        try {

            serviceType = uri.getHost();

            final Object object;

            try {

                object = JaxbOpenejb.create(serviceType);

            } catch (final Exception e) {

                throw new OpenEJBException("Invalid URI '" + uri + "'. " + e.getMessage());

            }

            final Map<String, String> map;

            try {

                map = URISupport.parseParamters(uri);

            } catch (final URISyntaxException e) {

                throw new OpenEJBException("Unable to parse URI parameters '" + uri + "'. URISyntaxException: " + e.getMessage());

            }

            if (object instanceof AbstractService) {

                final AbstractService service = (AbstractService) object;

                service.setId(id);

                service.setType(map.remove("type"));

                service.setProvider(map.remove("provider"));

                service.setClassName(map.remove("class-name"));

                service.setConstructor(map.remove("constructor"));

                service.setFactoryName(map.remove("factory-name"));

                final String cp = map.remove("classpath");

                if (null != cp) {

                    service.setClasspath(cp);

                }

                if (object instanceof Resource) {

                    final String aliases = map.remove("aliases");

                    if (aliases != null) {

                        ((Resource) object).getAliases().addAll(Arrays.asList(aliases.split(",")));

                    }

                }

                service.getProperties().putAll(map);

            } else if (object instanceof Deployments) {

                final Deployments deployments = (Deployments) object;

                deployments.setDir(map.remove("dir"));

                deployments.setFile(map.remove("jar"));

                final String cp = map.remove("classpath");

                if (cp != null) {

                    final String[] paths = cp.split(File.pathSeparator);

                    final List<URL> urls = new ArrayList<URL>();

                    for (final String path : paths) {

                        urls.add(new File(PropertyPlaceHolderHelper.value(ProvisioningUtil.realLocation(path))).toURI().normalize().toURL());

                    }

                    deployments.setClasspath(new URLClassLoaderFirst(urls.toArray(new URL[urls.size()]), ParentClassLoaderFinder.Helper.get()));

                }

            }

            return object;

        } catch (final Exception e) {

            throw new OpenEJBException("Error declaring service '" + id + "'. Unable to create Service definition from URI '" + uri.toString() + "'", e);

        }

    }

    public AppInfo configureApplication(final File jarFile) throws OpenEJBException {

        logger.debug("Beginning load: " + jarFile.getAbsolutePath());

        try {

            final AppModule appModule = deploymentLoader.load(jarFile);

            final AppInfo appInfo = configureApplication(appModule);

            // TODO This is temporary -- we need to do this in AppInfoBuilder

            appInfo.paths.add(appInfo.path);

            appInfo.paths.add(jarFile.getAbsolutePath());

            return appInfo;

        } catch (final ValidationFailedException e) {

            logger.warning("configureApplication.loadFailed", jarFile.getAbsolutePath(), e.getMessage()); // DO not include the stacktrace in the message

            throw e;

        } catch (final OpenEJBException e) {

            // DO NOT REMOVE THE EXCEPTION FROM THIS LOG MESSAGE

            // removing this message causes NO messages to be printed when embedded

            logger.warning("configureApplication.loadFailed", e, jarFile.getAbsolutePath(), e.getMessage());

            throw e;

        }

    }

    /**

     * embedded usage

     *

     * @param classLoader classloader

     * @param id          id supplied from embedded properties or null

     * @param jarFiles    list of ejb modules

     * @return configured AppInfo

     * @throws OpenEJBException on error

     */

    public AppInfo configureApplication(final ClassLoader classLoader, final String id, final List<File> jarFiles) throws OpenEJBException {

        final AppModule collection = loadApplication(classLoader, id, jarFiles);

        final AppInfo appInfo;

        try {

            appInfo = configureApplication(collection);

        } catch (final ValidationFailedException e) {

            logger.warning("configureApplication.loadFailed", collection.getModuleId(), e.getMessage()); // DO not include the stacktrace in the message

            throw e;

        } catch (final OpenEJBException e) {

            // DO NOT REMOVE THE EXCEPTION FROM THIS LOG MESSAGE

            // removing this message causes NO messages to be printed when embedded

            logger.warning("configureApplication.loadFailed", e, collection.getModuleId(), e.getMessage());

            throw e;

        }

        return appInfo;

    }

    @SuppressWarnings("unchecked")

    public AppModule loadApplication(final ClassLoader classLoader, String id, final List<File> jarFiles) throws OpenEJBException {

        final boolean standaloneModule = id == null;

        if (standaloneModule) {

            id = "";

        }

        final Application application = new Application();

        application.setApplicationName(id);

        final AppModule collection = new AppModule(classLoader, id, application, standaloneModule);

        final Map<String, Object> altDDs = collection.getAltDDs();

        for (final File jarFile : jarFiles) {

            logger.info("Beginning load: " + jarFile.getAbsolutePath());

            try {

                final AppModule module = deploymentLoader.load(jarFile);

                collection.getAdditionalLibraries().addAll(module.getAdditionalLibraries());

                collection.getClientModules().addAll(module.getClientModules());

                collection.getEjbModules().addAll(module.getEjbModules());

                collection.addPersistenceModules(module.getPersistenceModules());

                collection.getConnectorModules().addAll(module.getConnectorModules());

                collection.getWebModules().addAll(module.getWebModules());

                collection.getWatchedResources().addAll(module.getWatchedResources());

                // Merge altDDs

                for (final Map.Entry<String, Object> entry : module.getAltDDs().entrySet()) {

                    final Object existingValue = altDDs.get(entry.getKey());

                    if (existingValue == null) {

                        altDDs.put(entry.getKey(), entry.getValue());

                    } else if (entry.getValue() instanceof Collection) {

                        if (existingValue instanceof Collection) {

                            final Collection values = (Collection) existingValue;

                            values.addAll((Collection) entry.getValue());

                        }

                    } else if (entry.getValue() instanceof Map) {

                        if (existingValue instanceof Map) {

                            final Map values = (Map) existingValue;

                            values.putAll((Map) entry.getValue());

                        }

                    }

                }

            } catch (final ValidationFailedException e) {

                logger.warning("configureApplication.loadFailed", jarFile.getAbsolutePath(), e.getMessage()); // DO not include the stacktrace in the message

                throw e;

            } catch (final OpenEJBException e) {

                // DO NOT REMOVE THE EXCEPTION FROM THIS LOG MESSAGE

                // removing this message causes NO messages to be printed when embedded

                logger.warning("configureApplication.loadFailed", e, jarFile.getAbsolutePath(), e.getMessage());

                throw e;

            }

        }

        return collection;

    }

    public EjbJarInfo configureApplication(final EjbJar ejbJar) throws OpenEJBException {

        final EjbModule ejbModule = new EjbModule(ejbJar);

        return configureApplication(ejbModule);

    }

    public EjbJarInfo configureApplication(final EjbModule ejbModule) throws OpenEJBException {

        final AppInfo appInfo = configureApplication(new AppModule(ejbModule));

        return appInfo.ejbJars.get(0);

    }

    public ClientInfo configureApplication(final ClientModule clientModule) throws OpenEJBException {

        final AppInfo appInfo = configureApplication(new AppModule(clientModule));

        return appInfo.clients.get(0);

    }

    public ConnectorInfo configureApplication(final ConnectorModule connectorModule) throws OpenEJBException {

        final AppInfo appInfo = configureApplication(new AppModule(connectorModule));

        return appInfo.connectors.get(0);

    }

    public WebAppInfo configureApplication(final WebModule webModule) throws OpenEJBException {

        final AppInfo appInfo = configureApplication(new AppModule(webModule));

        return appInfo.webApps.get(0);

    }

    public AppInfo configureApplication(final AppModule appModule) throws OpenEJBException {

        final Collection<Class<?>> extensions = new HashSet<Class<?>>();

        final Collection<String> notLoaded = new HashSet<String>();

        final List<URL> libs = appModule.getAdditionalLibraries();

        if (libs != null && libs.size() > 0) {

            final ResourceFinder finder = new ResourceFinder("META-INF", libs.toArray(new URL[libs.size()]));

            extensions.addAll(Extensions.findExtensions(finder));

            notLoaded.addAll(finder.getResourcesNotLoaded());

        }

        for (final EjbModule ejb : appModule.getEjbModules()) {

            try {

                final URI uri = ejb.getModuleUri();

                if (uri.isAbsolute()) {

                    final URL url = uri.toURL();

                    if (libs != null && !libs.contains(url)) {

                        final ResourceFinder finder = new ResourceFinder("META-INF", url);

                        extensions.addAll(Extensions.findExtensions(finder));

                        notLoaded.addAll(finder.getResourcesNotLoaded());

                    }

                }

            } catch (final IllegalArgumentException iae) {

                logger.debug("can't look for server event listener for module " + ejb.getModuleUri(), iae);

            } catch (final MalformedURLException mue) {

                logger.debug("can't look for server event listener for module " + ejb.getModuleUri(), mue);

            } catch (final Exception e) {

                logger.error("can't look for server event listener for module " + ejb.getJarLocation());

            }

        }

        for (final WebModule web : appModule.getWebModules()) {

            final List<URL> webLibs = web.getScannableUrls();

            if (webLibs != null && webLibs.size() > 0) {

                final ResourceFinder finder = new ResourceFinder("META-INF", webLibs.toArray(new URL[webLibs.size()]));

                extensions.addAll(Extensions.findExtensions(finder));

                notLoaded.addAll(finder.getResourcesNotLoaded());

            }

        }

        // add it as early as possible, the ones needing the app classloader will be added later

        Extensions.addExtensions(extensions);

        final String location = appModule.getJarLocation();

        logger.info("config.configApp", null != location ? location : appModule.getModuleId());

        deployer.deploy(appModule);

        final AppInfoBuilder appInfoBuilder = new AppInfoBuilder(this);

        final AppInfo info = appInfoBuilder.build(appModule);

        info.eventClassesNeedingAppClassloader.addAll(notLoaded);

        return info;

    }

    private static class DefaultService {

        private final Class<? extends org.apache.openejb.config.Service> type;

        private final String id;

        public DefaultService(final String id, final Class<? extends org.apache.openejb.config.Service> type) {

            this.id = id;

            this.type = type;

        }

    }

    private static final Map<Class<? extends ServiceInfo>, DefaultService> defaultProviders = new HashMap<Class<? extends ServiceInfo>, DefaultService>();

    private static final Map<Class<? extends ServiceInfo>, Class<? extends org.apache.openejb.config.Service>> types = new HashMap<Class<? extends ServiceInfo>, Class<? extends org.apache.openejb.config.Service>>();

    /**

     * This is the magic that allows people to be really vague in their openejb.xml and not specify

     * the provider for one of their declared services.  We look here for the default service id

     *

     * We then look in the default provider "namespace" that is setup, which will usually be either one of:

     *

     *   - org.apache.openejb

     *   - org.apache.openejb.embedded

     *   - org.apache.openejb.tomcat

     *   - org.apache.openejb.jetty

     *

     * As in:

     *

     *   - META-INF/<provider>/service-jar.xml

     *

     */

    static {

        defaultProviders.put(MdbContainerInfo.class, new DefaultService("MESSAGE", Container.class));

        defaultProviders.put(ManagedContainerInfo.class, new DefaultService("MANAGED", Container.class));

        defaultProviders.put(StatefulSessionContainerInfo.class, new DefaultService("STATEFUL", Container.class));

        defaultProviders.put(StatelessSessionContainerInfo.class, new DefaultService("STATELESS", Container.class));

        defaultProviders.put(SingletonSessionContainerInfo.class, new DefaultService("SINGLETON", Container.class));

        defaultProviders.put(CmpEntityContainerInfo.class, new DefaultService("CMP_ENTITY", Container.class));

        defaultProviders.put(BmpEntityContainerInfo.class, new DefaultService("BMP_ENTITY", Container.class));

        defaultProviders.put(SecurityServiceInfo.class, new DefaultService("SecurityService", SecurityService.class));

        defaultProviders.put(TransactionServiceInfo.class, new DefaultService("TransactionManager", TransactionManager.class));

        defaultProviders.put(ConnectionManagerInfo.class, new DefaultService("ConnectionManager", ConnectionManager.class));

        defaultProviders.put(ProxyFactoryInfo.class, new DefaultService("ProxyFactory", ProxyFactory.class));

        for (final Map.Entry<Class<? extends ServiceInfo>, DefaultService> entry : defaultProviders.entrySet()) {

            types.put(entry.getKey(), entry.getValue().type);

        }

        types.put(ResourceInfo.class, Resource.class);

    }

    public <T extends ServiceInfo> T configureService(final Class<? extends T> type) throws OpenEJBException {