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

*/

* Web application builder.

*

* @version $Rev$ $Date$

*/

    public static final String OPENEJB_CROSSCONTEXT_PROPERTY = "openejb.crosscontext";

    public static final String OPENEJB_SESSION_MANAGER_PROPERTY = "openejb.session.manager";

    public static final String OPENEJB_JSESSION_ID_SUPPORT = "openejb.jsessionid-support";

    public static final String OPENEJB_MYFACES_DISABLE_DEFAULT_VALUES = "openejb.myfaces.disable-default-values";

    /**

     * Flag for ignore context

     */

    public static final String IGNORE_CONTEXT = TomcatWebAppBuilder.class.getName() + ".IGNORE";

    /**

     * Logger instance

     */

    private static final Logger logger = Logger.getInstance(LogCategory.OPENEJB.createChild("tomcat"), "org.apache.openejb.util.resources");

    public static final String DEFAULT_J2EE_SERVER = "Apache TomEE";

    public static final String OPENEJB_WEBAPP_MODULE_ID = "openejb.webapp.moduleId";

    public static final String TOMEE_EAT_EXCEPTION_PROP = "tomee.eat-exception";

    public static final String TOMEE_INIT_J2EE_INFO = "tomee.init-J2EE-info";

    private static final boolean FORCE_RELOADABLE = SystemInstance.get().getOptions().get("tomee.force-reloadable", false);

    private static final boolean SKIP_TLD = SystemInstance.get().getOptions().get("tomee.skip-tld", false);

    private static final Method getNamingContextName; // it just sucks but that's private

    static {

        try {

            getNamingContextName = StandardContext.class.getDeclaredMethod("getNamingContextName");

            getNamingContextName.setAccessible(true);

        } catch (final NoSuchMethodException e) {

            throw new OpenEJBRuntimeException("can't find method getNamingContextName", e);

        }

    }

    private final Map<String, Realm> realms = new ConcurrentHashMap<String, Realm>();

    private final Map<ClassLoader, InstanceManager> instanceManagers = new ConcurrentHashMap<ClassLoader, InstanceManager>();

    /**

     * Context information for web applications

     */

    private final Map<String, ContextInfo> infos = new HashMap<String, ContextInfo>();

    /**

     * Global listener for Tomcat fired events.

     */

    private final GlobalListenerSupport globalListenerSupport;

    /**

     * OpenEJB configuration factory instance

     */

    private final ConfigurationFactory configurationFactory;

    /**

     * Tomcat host config elements

     */

    //Key is the host name

    private final Map<String, HostConfig> deployers = new TreeMap<>();

    private final Hosts hosts;

    /**

     * Deployed web applications

     */

    // todo merge this map witth the infos map above

    private final Map<String, DeployedApplication> deployedApps = new TreeMap<>();

    /**

     * OpenEJB deployment loader instance

     */

    private final DeploymentLoader deploymentLoader;

    /**

     * OpenEJB assembler instance

     * TODO can we use the SPI interface instead?

     */

    private Assembler assembler;

    /**

     * OpenEJB container system

     * TODO can we use the SPI interface instead?

     */

    private CoreContainerSystem containerSystem;

    private final Map<ClassLoader, Map<String, Set<String>>> jsfClasses = new HashMap<>();

    private Class<?> sessionManagerClass;

    private final Set<CatalinaCluster> clusters = new HashSet<CatalinaCluster>();

    private ClassLoader parentClassLoader;

    private boolean initJEEInfo = true;

    /**

     * Creates a new web application builder

     * instance.

     */

    public TomcatWebAppBuilder() {

        SystemInstance.get().setComponent(WebAppBuilder.class, this);

        SystemInstance.get().setComponent(TomcatWebAppBuilder.class, this);

        initJEEInfo = "true".equalsIgnoreCase(SystemInstance.get().getProperty(TOMEE_INIT_J2EE_INFO, "true"));

        // TODO: re-write this bit, so this becomes part of the listener, and we register this with the mbean server.

        final StandardServer standardServer = TomcatHelper.getServer();

        globalListenerSupport = new GlobalListenerSupport(standardServer, this);

        //Getting host config listeners

        hosts = new Hosts();

        SystemInstance.get().setComponent(Hosts.class, hosts);

        for (final Service service : standardServer.findServices()) {

            if (service.getContainer() instanceof Engine) {

                final Engine engine = (Engine) service.getContainer();

                // add the global router if relevant

                final URL globalRouterConf = RouterValve.serverRouterConfigurationURL();

                if (globalRouterConf != null) {

                    final RouterValve routerValve = new RouterValve();

                    routerValve.setConfigurationPath(globalRouterConf);

                    engine.getPipeline().addValve(routerValve);

                }

                parentClassLoader = engine.getParentClassLoader();

                manageCluster(engine.getCluster());

                hosts.setDefault(engine.getDefaultHost());

                addTomEERealm(engine);

                for (final Container engineChild : engine.findChildren()) {

                    if (engineChild instanceof StandardHost) {

                        final StandardHost host = (StandardHost) engineChild;

                        manageCluster(host.getCluster());

                        addTomEERealm(host);

                        hosts.add(host);

                        for (final LifecycleListener listener : host.findLifecycleListeners()) {

                            if (listener instanceof HostConfig) {

                                final HostConfig hostConfig = (HostConfig) listener;

                                deployers.put(host.getName(), hostConfig);

                            }

                        }

                    }

                }

            }

        }

        SystemInstance.get().addObserver(new ClusterObserver(clusters));

        configurationFactory = new ConfigurationFactory();

        deploymentLoader = new DeploymentLoader();

        setComponentsUsedByCDI();

    }

    private void setComponentsUsedByCDI() {

        final SystemInstance systemInstance = SystemInstance.get();

        if (systemInstance.getComponent(HttpServletRequest.class) == null) {

            systemInstance.setComponent(HttpServletRequest.class, Proxys.threadLocalProxy(HttpServletRequest.class, OpenEJBSecurityListener.requests));

        }

        if (systemInstance.getComponent(HttpSession.class) == null) {

            systemInstance.setComponent(javax.servlet.http.HttpSession.class, Proxys.threadLocalRequestSessionProxy(OpenEJBSecurityListener.requests));

        }

        if (systemInstance.getComponent(ServletContext.class) == null) {

            systemInstance.setComponent(ServletContext.class, Proxys.handlerProxy(ServletContext.class, new ServletContextHandler()));

        }

    }

    private void manageCluster(final Cluster cluster) {

        if (cluster == null || cluster instanceof SimpleTomEETcpCluster) {

            return;

        }

        Cluster current = cluster;

        if (cluster instanceof SimpleTcpCluster) {

            final Container container = cluster.getContainer();

            current = new SimpleTomEETcpCluster((SimpleTcpCluster) cluster);

            container.setCluster(current);

        }

        if (current instanceof CatalinaCluster) {

            final CatalinaCluster haCluster = (CatalinaCluster) current;

            haCluster.addClusterListener(TomEEClusterListener.INSTANCE); // better to be a singleton

            clusters.add(haCluster);

        }

    }

    private void addTomEERealm(final Engine engine) {

        final Realm realm = engine.getRealm();

        if (realm != null && !(realm instanceof TomEERealm) && (engine.getParent() == null || (!realm.equals(engine.getParent().getRealm())))) {

            final Realm tomeeRealm = tomeeRealm(realm);

            engine.setRealm(tomeeRealm);

            if (LifecycleState.STARTING_PREP.equals(engine.getState())) {

                try {

                    Lifecycle.class.cast(tomeeRealm).start();

                } catch (final LifecycleException e) {

                    throw new IllegalStateException(e);

                }

            }

        }

    }

    private void addTomEERealm(final Host host) {

        final Realm realm = host.getRealm();

        if (realm != null && !(realm instanceof TomEERealm) && (host.getParent() == null || (!realm.equals(host.getParent().getRealm())))) {

            host.setRealm(tomeeRealm(realm));

        }

    }

    protected Realm tomeeRealm(final Realm realm) {

        final TomEERealm trealm = new TomEERealm();

        trealm.setRealmPath("/tomee");

        trealm.addRealm(realm);

        return trealm;

    }

    /**

     * Start operation.

     */

    public void start() {

        globalListenerSupport.start();

    }

    /**

     * Stop operation.

     */

    public void stop() {

        globalListenerSupport.stop();

    }

    public void start(final StandardServer server) {

        if (SystemInstance.get().isDefaultProfile()) { // add user tomee is no user are specified

            try {

                final NamingResourcesImpl resources = server.getGlobalNamingResources();

                final ContextResource userDataBaseResource = resources.findResource("UserDatabase");

                final UserDatabase db = (UserDatabase) server.getGlobalNamingContext().lookup(userDataBaseResource.getName());

                if (!db.getUsers().hasNext() && db instanceof MemoryUserDatabase) {

                    final MemoryUserDatabase mudb = (MemoryUserDatabase) db;

                    final boolean oldRo = mudb.getReadonly();

                    try {

                        ((MemoryUserDatabase) db).setReadonly(false);

                        db.createRole("tomee-admin", "tomee admin role");

                        db.createUser("tomee", "tomee", "TomEE");

                        db.findUser("tomee").addRole(db.findRole("tomee-admin"));

                    } finally {

                        mudb.setReadonly(oldRo);

                    }

                }

            } catch (final Throwable t) {

                // no-op

            }

        }

    }

    //

    // OpenEJB WebAppBuilder

    //

    /**

     * {@inheritDoc}

     */

    @Override

    public void deployWebApps(final AppInfo appInfo, final ClassLoader classLoader) throws Exception {

        for (final WebAppInfo webApp : appInfo.webApps) {

            // look for context.xml

            final File war = new File(webApp.path);

            InputStream contextXml = null;

            URL contextXmlUrl = null;

            if (war.isDirectory()) {

                final File cXml = new File(war, Constants.ApplicationContextXml).getAbsoluteFile();

                if (cXml.exists()) {

                    contextXml = IO.read(cXml);

                    contextXmlUrl = cXml.toURI().toURL();

                    logger.info("using context file " + cXml.getAbsolutePath());

                }

            } else { // war

                final JarFile warAsJar = new JarFile(war);

                final JarEntry entry = warAsJar.getJarEntry(Constants.ApplicationContextXml);

                if (entry != null) {

                    contextXmlUrl = new URL("jar:" + war.getAbsoluteFile().toURI().toURL().toExternalForm() + "!/" + Constants.ApplicationContextXml);

                    contextXml = warAsJar.getInputStream(entry);

                }

            }

            if (getContextInfo(webApp.host, webApp.contextRoot) != null) {

                continue;

            }

            StandardContext standardContext;

            {

                final ClassLoader containerLoader = Helper.get();

                final Host host = hosts.getDefault();

                if (StandardHost.class.isInstance(host)) {

                    try {

                        standardContext = StandardContext.class.cast(containerLoader.loadClass(StandardHost.class.cast(host).getContextClass()).newInstance());

                    } catch (final Throwable th) {

                        logger.warning("Can't use context class specified, using default StandardContext", th);

                        standardContext = new StandardContext();

                    }

                } else {

                    standardContext = new StandardContext();

                }

                // should be optional but in maven parent is app loader and not maven loader which is the real parent

                final ClassLoader currentParent = standardContext.getParentClassLoader();

                if (currentParent == null || isParent(currentParent, containerLoader)) {

                    standardContext.setParentClassLoader(containerLoader);

                }

            }

            if (contextXml != null) {

                standardContext.setConfigFile(contextXmlUrl);

            }

            if (standardContext.getPath() != null) {

                webApp.contextRoot = standardContext.getPath();

            }

            if (webApp.contextRoot.startsWith("/") || webApp.contextRoot.startsWith(File.separator)) {

                webApp.contextRoot = webApp.contextRoot.substring(1);

            }

            if (webApp.contextRoot.startsWith(File.separator)) {

                webApp.contextRoot = webApp.contextRoot.replaceFirst(File.separator, "");

            }

            // /!\ take care, StandardContext default host = "_" and not null or localhost

            final String hostname = Contexts.getHostname(standardContext);

            if (hostname != null && !"_".equals(hostname)) {

                webApp.host = hostname;

            }

            final ApplicationParameter appParam = new ApplicationParameter();

            appParam.setName(OPENEJB_WEBAPP_MODULE_ID);

            appParam.setValue(webApp.moduleId);

            standardContext.addApplicationParameter(appParam);

            if (getContextInfo(webApp.host, webApp.contextRoot) == null) {

                if (standardContext.getPath() == null) {

                    if (webApp.contextRoot != null && webApp.contextRoot.startsWith("/")) {

                        standardContext.setPath(webApp.contextRoot);

                    } else if (isRoot(webApp.contextRoot)) {

                        standardContext.setPath("");

                    } else {

                        standardContext.setPath("/" + webApp.contextRoot);

                    }

                }

                if (standardContext.getDocBase() == null) {

                    standardContext.setDocBase(webApp.path);

                }

                if (standardContext.getDocBase() != null && standardContext.getDocBase().endsWith(".war")) {

                    DeploymentLoader.unpack(new File(standardContext.getDocBase()));

                    if (standardContext.getPath().endsWith(".war")) {

                        standardContext.setPath(removeFirstSlashAndWar("/" + standardContext.getPath()));

                        standardContext.setName(standardContext.getPath());

                        webApp.contextRoot = standardContext.getPath();

                    }

                    standardContext.setDocBase(standardContext.getDocBase().substring(0, standardContext.getDocBase().length() - 4));

                }

                if (isRoot(standardContext.getName())) {

                    standardContext.setName("");

                    webApp.contextRoot = "";

                }

                if (getContextInfo(webApp.host, webApp.contextRoot) != null) { // possible because of the previous renaming

                    continue;

                }

                // add classloader which is an URLClassLoader created by openejb

                // {@see Assembler}

                //

                // we add it as parent classloader since we scanned classes with this classloader

                // that's why we force delegate to true.

                //

                // However since this classloader and the webappclassloader will have a lot

                // of common classes/resources we have to avoid duplicated resources

                // so we contribute a custom loader.

                //

                // Note: the line standardContext.getLoader().setDelegate(true);

                // could be hardcoded in the custom loader

                // but here we have all the classloading logic

                if (classLoader != null) {

                    standardContext.setParentClassLoader(classLoader);

                    standardContext.setDelegate(true);

                }

                String host = webApp.host;

                if (host == null) {

                    host = hosts.getDefaultHost();

                    logger.info("using default host: " + host);

                }

                if (classLoader != null) {

                    appInfo.autoDeploy = false;

                    deployWar(standardContext, host, appInfo);

                } else { // force a normal deployment with lazy building of AppInfo

                    deployWar(standardContext, host, null);

                }

            }

        }

    }

    private static boolean isParent(final ClassLoader parent, final ClassLoader child) {

        ClassLoader current = child;

        while (current != null) {

            if (current == parent) {

                return true;

            }

            current = current.getParent();

        }

        return child.getParent() == null && child != ClassLoader.getSystemClassLoader(); // maven ClassRealm classloader...yeah that's not awesome

    }

    private static boolean isRoot(final String name) {

        return "/ROOT".equals(name) || "ROOT".equals(name) || name == null || name.isEmpty() || "ROOT.war".equals(name);

    }

    public void deployWar(final StandardContext standardContext, final String host, final AppInfo info) {

        // TODO: instead of storing deployers, we could just lookup the right hostconfig for the server.

        final HostConfig deployer = deployers.get(host);

        if (isReady(deployer)) { // if not ready using directly host to avoid a NPE

            if (info != null) {

                final ContextInfo contextInfo = addContextInfo(host, standardContext);

                contextInfo.appInfo = info;

                contextInfo.deployer = deployer;

            }

            deployer.manageApp(standardContext);

        } else {

            final Host theHost = hosts.get(host);

            if (theHost != null) {

                if (info != null) {

                    final ContextInfo contextInfo = addContextInfo(host, standardContext);

                    contextInfo.appInfo = info;

                    contextInfo.host = theHost;

                }

                theHost.addChild(standardContext);

            }

        }

    }

    public synchronized ContextInfo standaAloneWebAppInfo(final File file) {

        for (final ContextInfo info : infos.values()) {

            if (info.appInfo != null && info.appInfo.webAppAlone

                    && ((file.equals(new File(info.appInfo.path)) || file.equals(new File(info.appInfo.path + ".war"))))) {

                return info;

            }

            if (info.standardContext != null && (file.equals(new File(info.standardContext.getDocBase())) || file.equals(new File(info.standardContext.getDocBase() + ".war")))) {

                return info;

            }

        }

        // still not found - trying another algorithm - weird but it seems to happen

        final String path = file.getAbsolutePath();

        for (final ContextInfo info : infos.values()) {

            if (info.appInfo != null && info.appInfo.webAppAlone

                    && (info.appInfo.path.endsWith(path) || (info.appInfo.path + ".war").endsWith(path))) {

                return info;

            }

        }

        return null;

    }

    public synchronized Collection<String> availableApps() {

        final Collection<String> apps = new ArrayList<>();

        for (final ContextInfo info : infos.values()) {

            if (info.appInfo != null) {

                apps.add(info.appInfo.path);

            } else if (info.standardContext != null) {

                apps.add("[not deployed] " + info.standardContext.getName());

            }

        }

        return apps;

    }

    // TODO: find something more sexy

    private static final AtomicReference<Field> HOST_CONFIG_HOST = new AtomicReference<>(null);

    static {

        try { // do it only once

            HOST_CONFIG_HOST.set(HostConfig.class.getDeclaredField("host"));

        } catch (final NoSuchFieldException e) {

            // no-op

        }

    }

    private static boolean isReady(final HostConfig deployer) {

        if (deployer != null && HOST_CONFIG_HOST.get() != null) {

            try {

                return HOST_CONFIG_HOST.get().get(deployer) != null;

            } catch (final Exception e) {

                // no-op

            }

        }

        return false;

    }

    /**

     * just to avoid a lot of log lines which are often useless.

     *

     * @param context the servlet context to init.

     */

    private static void addMyFacesDefaultParameters(final ClassLoader classLoader, final ServletContext context) {

        if (!SystemInstance.get().getOptions().get(OPENEJB_MYFACES_DISABLE_DEFAULT_VALUES, false)) {

            if (classLoader != null) {

                try { // if myfaces is not here we doesn't need any trick

                    classLoader.loadClass("org.apache.myfaces.shared.config.MyfacesConfig");

                } catch (final ClassNotFoundException cnfe) {

                    return;

                }

            }

            setInitParameter(context, "org.apache.myfaces.LOG_WEB_CONTEXT_PARAMS", "false");

        }

    }

    private static void setInitParameter(final ServletContext context, final String key, final String value) {

        if (context.getInitParameter(key) == null) {

            context.setInitParameter(key, value);

        }

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public void undeployWebApps(final AppInfo appInfo) throws Exception {

        for (final WebAppInfo webApp : appInfo.webApps) {

            final ContextInfo contextInfo = getContextInfo(webApp.host, webApp.contextRoot);

            if (contextInfo != null) {

                final StandardContext standardContext = contextInfo.standardContext;

                if (!appInfo.webAppAlone || !appInfo.properties.containsKey("tomee.destroying")) {

                    undeploy(standardContext, contextInfo);

                    final File extracted = Contexts.warPath(standardContext);

                    if (isExtracted(extracted)) {

                        deleteDir(extracted);

                    }

                    removeContextInfo(standardContext);

                }

            }

        }

    }

    @SuppressWarnings("PMD.UnusedFormalParameter")

    private boolean isExtracted(final File extracted) {

        // TODO: do we want to delete it?

        return false;

    }

    /**

     * Deletes given directory.

     *

     * @param dir directory

     */

    private void deleteDir(final File dir) {

        if (dir == null) {

            return;

        }

        if (dir.isFile()) {

            return;

        }

        final File[] files = dir.listFiles();

        if (files != null) {

            for (final File file : files) {

                if (file.isDirectory()) {

                    deleteDir(file);

                } else {

                    if (!file.delete()) {

                        file.deleteOnExit();

                    }

                }

            }

        }

        if (!dir.delete()) {

            dir.deleteOnExit();

        }

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public void init(final StandardContext standardContext) {

        if (isIgnored(standardContext)) {

            return;

        }

        // just adding a carriage return to get logs more readable

        logger.info("------------------------- "

                + Contexts.getHostname(standardContext).replace("_", hosts.getDefaultHost()) + " -> "

                + finalName(standardContext.getPath()));

        if (FORCE_RELOADABLE && getContextInfo(standardContext) == null) { // don't do it for ears

            standardContext.setReloadable(true);

        }

        if (SKIP_TLD) {

            if (standardContext.getJarScanner() != null && standardContext.getJarScanner().getJarScanFilter() != null) {

                final JarScanFilter jarScanFilter = standardContext.getJarScanner().getJarScanFilter();

                if (StandardJarScanFilter.class.isInstance(jarScanFilter)) {

                    StandardJarScanFilter.class.cast(jarScanFilter).setDefaultTldScan(false);

                }

            }

        }

        final String name = standardContext.getName();

        initJ2EEInfo(standardContext);

        File warFile = Contexts.warPath(standardContext);

        if (!warFile.isDirectory()) {

            try {

                warFile = DeploymentLoader.unpack(warFile);

            } catch (final OpenEJBException e) {

                logger.error("can't unpack '" + warFile.getAbsolutePath() + "'");

            }

        }

        standardContext.setCrossContext(SystemInstance.get().getOptions().get(OPENEJB_CROSSCONTEXT_PROPERTY, false));

        standardContext.setNamingResources(new OpenEJBNamingResource(standardContext.getNamingResources()));

        String sessionManager = SystemInstance.get().getOptions().get(OPENEJB_SESSION_MANAGER_PROPERTY + "." + name, (String) null);

        if (sessionManager == null) {

            sessionManager = SystemInstance.get().getOptions().get(OPENEJB_SESSION_MANAGER_PROPERTY, (String) null);

        }

        if (sessionManager != null) {

            if (sessionManagerClass == null) {

                try { // the manager should be in standardclassloader

                    sessionManagerClass = TomcatHelper.getServer().getParentClassLoader().loadClass(sessionManager);