* JBoss, Home of Professional Open Source

* Copyright 2014, Red Hat Middleware LLC, and individual contributors

* by the @authors tag. See the copyright.txt in the distribution for a

* full listing of individual contributors.

*

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

*/

*

* @author Martin Kouba

* @see Listener

* @see EnhancedListener

*/

    public static final String BEAN_MANAGER_ATTRIBUTE_NAME = WeldServletLifecycle.class.getPackage().getName() + "." + BeanManager.class.getName();

    /**

     * Must be synchronized with org.jboss.weld.Container.CONTEXT_ID_KEY

     */

    private static final String CONTEXT_ID_KEY = "WELD_CONTEXT_ID_KEY";

    static final String INSTANCE_ATTRIBUTE_NAME = WeldServletLifecycle.class.getPackage().getName() + ".lifecycleInstance";

    private static final String BOOTSTRAP_IMPL_CLASS_NAME = "org.jboss.weld.bootstrap.WeldBootstrap";

    private static final String WELD_LISTENER_CLASS_NAME = "org.jboss.weld.servlet.WeldInitialListener";

    private static final String EXPRESSION_FACTORY_NAME = "org.jboss.weld.el.ExpressionFactory";

    private static final String CONTEXT_PARAM_ARCHIVE_ISOLATION = WeldServletLifecycle.class.getPackage().getName() + ".archive.isolation";

    private final transient CDI11Bootstrap bootstrap;

    private final transient ServletListener weldListener;

    private Container container;

    // WELD-1665 Bootstrap might be already performed

    private boolean isBootstrapNeeded = true;

    WeldServletLifecycle() {

        try {

            bootstrap = Reflections.newInstance(BOOTSTRAP_IMPL_CLASS_NAME);

        } catch (IllegalArgumentException e) {

            throw WeldServletLogger.LOG.errorLoadingWeldBootstrap(e);

        }

        try {

            weldListener = Reflections.newInstance(WELD_LISTENER_CLASS_NAME);

        } catch (IllegalArgumentException e) {

            throw WeldServletLogger.LOG.errorLoadingWeldListener(e);

        }

    }

    /**

     *

     * @param context

     * @return <code>true</code> if initialized properly, <code>false</code> otherwise

     */

    boolean initialize(ServletContext context) {

        WeldManager manager = (WeldManager) context.getAttribute(BEAN_MANAGER_ATTRIBUTE_NAME);

        if (manager != null) {

            isBootstrapNeeded = false;

        }

        if (isBootstrapNeeded) {

            CDI11Deployment deployment = createDeployment(context, bootstrap);

            if (deployment.getBeanDeploymentArchives().isEmpty()) {

                // Skip initialization - there is no bean archive in the deployment

                CommonLogger.LOG.initSkippedNoBeanArchiveFound();

                return false;

            }

            ResourceInjectionServices resourceInjectionServices = new ServletResourceInjectionServices() {

            };

            try {

                for (BeanDeploymentArchive archive : deployment.getBeanDeploymentArchives()) {

                    archive.getServices().add(ResourceInjectionServices.class, resourceInjectionServices);

                }

            } catch (NoClassDefFoundError e) {

                // Support GAE

                WeldServletLogger.LOG.resourceInjectionNotAvailable();

            }

            String id = context.getInitParameter(CONTEXT_ID_KEY);

            if (id != null) {

                bootstrap.startContainer(id, Environments.SERVLET, deployment);

            } else {

                bootstrap.startContainer(Environments.SERVLET, deployment);

            }

            bootstrap.startInitialization();

            /*

             * This should work fine as all bean archives share the same classloader. The only difference this can make is per-BDA (CDI 1.0 style) enablement of

             * alternatives, interceptors and decorators. Nothing we can do about that.

             */

            manager = bootstrap.getManager(deployment.getBeanDeploymentArchives().iterator().next());

            // Push the manager into the servlet context so we can access in JSF

            context.setAttribute(BEAN_MANAGER_ATTRIBUTE_NAME, manager);

        }

        ContainerContext containerContext = new ContainerContext(context, manager);

        StringBuilder dump = new StringBuilder();

        Container container = findContainer(containerContext, dump);

        if (container == null) {

            WeldServletLogger.LOG.noSupportedServletContainerDetected();

            WeldServletLogger.LOG.debugv("Exception dump from Container lookup: {0}", dump);

        } else {

            container.initialize(containerContext);

            this.container = container;

        }

        if (JspFactory.getDefaultFactory() != null) {

            JspApplicationContext jspApplicationContext = JspFactory.getDefaultFactory().getJspApplicationContext(context);

            // Register the ELResolver with JSP

            jspApplicationContext.addELResolver(manager.getELResolver());

            // Register ELContextListener with JSP

            try {

                jspApplicationContext.addELContextListener(Reflections.<ELContextListener> newInstance("org.jboss.weld.el.WeldELContextListener"));

            } catch (IllegalArgumentException e) {

                throw WeldServletLogger.LOG.errorLoadingWeldELContextListener(e);

            }

            // Push the wrapped expression factory into the servlet context so that Tomcat or Jetty can hook it in using a container code

            context.setAttribute(EXPRESSION_FACTORY_NAME, manager.wrapExpressionFactory(jspApplicationContext.getExpressionFactory()));

        }

        if (isBootstrapNeeded) {

            bootstrap.deployBeans().validateBeans().endInitialization();

        }

        return true;

    }

    void destroy(ServletContext context) {

        if (isBootstrapNeeded) {

            // Shutdown only if bootstrap not skipped

            bootstrap.shutdown();

        }

        if (container != null) {

            container.destroy(new ContainerContext(context, null));

        }

    }

    /**

     *

     * @return the original Weld listener all notifications should be delegated to

     */

    ServletListener getWeldListener() {

        return weldListener;

    }

    /**

     * Create servlet deployment.

     *

     * Can be overridden with custom servlet deployment. e.g. exact resources listing in restricted env like GAE

     *

     * @param context the servlet context

     * @param bootstrap the bootstrap

     * @return new servlet deployment

     */

    protected CDI11Deployment createDeployment(ServletContext context, CDI11Bootstrap bootstrap) {

        ResourceLoader resourceLoader = new WeldResourceLoader();

        final Iterable<Metadata<Extension>> extensions = bootstrap.loadExtensions(WeldResourceLoader.getClassLoader());

        final TypeDiscoveryConfiguration typeDiscoveryConfiguration = bootstrap.startExtensions(extensions);

        DiscoveryStrategy strategy = DiscoveryStrategyFactory.create(resourceLoader, bootstrap, typeDiscoveryConfiguration.getKnownBeanDefiningAnnotations());

        strategy.registerHandler(new ServletContextBeanArchiveHandler(context));

        strategy.setScanner(new WebAppBeanArchiveScanner(resourceLoader, bootstrap, context));

        Set<WeldBeanDeploymentArchive> beanDeploymentArchives = strategy.performDiscovery();

        String isolation = context.getInitParameter(CONTEXT_PARAM_ARCHIVE_ISOLATION);

        if (isolation != null && Boolean.valueOf(isolation).equals(Boolean.FALSE)) {

            CommonLogger.LOG.archiveIsolationDisabled();

            beanDeploymentArchives = Collections.singleton(WeldBeanDeploymentArchive.merge(bootstrap, beanDeploymentArchives));

        } else {

            CommonLogger.LOG.archiveIsolationEnabled();

        }

        CDI11Deployment deployment = new WeldDeployment(resourceLoader, bootstrap, beanDeploymentArchives, extensions);

        if (strategy.getClassFileServices() != null) {

            deployment.getServices().add(ClassFileServices.class, strategy.getClassFileServices());

        }

        return deployment;

    }

    /**

     * Find container env.

     *

     * @param ctx the container context

     * @param dump the exception dump

     * @return valid container or null

     */

    protected Container findContainer(ContainerContext ctx, StringBuilder dump) {

        Container container = null;

        // 1. Custom container class

        String containerClass = ctx.getServletContext().getInitParameter(Container.CONTEXT_PARAM_CONTAINER_CLASS);

        if (containerClass != null) {

            try {

                container = Reflections.newInstance(containerClass);

                WeldServletLogger.LOG.containerDetectionSkipped(containerClass);

            } catch (IllegalArgumentException e) {

                WeldServletLogger.LOG.unableToInstantiateCustomContainerClass(containerClass);

            }

        }

        if (container == null) {

            // 2. Service providers

            Iterable<Container> extContainers = ServiceLoader.load(Container.class, getClass().getClassLoader());

            container = checkContainers(ctx, dump, extContainers);

            if (container == null) {

                // 3. Built-in containers in predefined order

                container = checkContainers(ctx, dump, Arrays.asList(TomcatContainer.INSTANCE, JettyContainer.INSTANCE, GwtDevHostedModeContainer.INSTANCE));

            }

        }

        return container;

    }

    protected Container checkContainers(ContainerContext cc, StringBuilder dump, Iterable<Container> containers) {

        for (Container c : containers) {

            try {

                if (c.touch(cc)) {

                    return c;

                }

            } catch (Throwable t) {

                dump.append(c).append("->").append(t.getMessage()).append("\n");

            }

        }

        return null;

    }

}