path: root/jetty-maven-plugin/src/main/java/org/eclipse/jetty/maven/plugin/JettyWebAppContext.java

//
//  ========================================================================
//  Copyright (c) 1995-2015 Mort Bay Consulting Pty. Ltd.
//  ------------------------------------------------------------------------
//  All rights reserved. This program and the accompanying materials
//  are made available under the terms of the Eclipse Public License v1.0
//  and Apache License v2.0 which accompanies this distribution.
//
//      The Eclipse Public License is available at
//      http://www.eclipse.org/legal/epl-v10.html
//
//      The Apache License v2.0 is available at
//      http://www.opensource.org/licenses/apache2.0.php
//
//  You may elect to redistribute this code under either of these licenses.
//  ========================================================================
//

package org.eclipse.jetty.maven.plugin;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.lang.reflect.Method;
import java.net.MalformedURLException;
import java.util.ArrayList;
import java.util.EventListener;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;

import org.eclipse.jetty.annotations.AnnotationConfiguration;
import org.eclipse.jetty.plus.webapp.EnvConfiguration;
import org.eclipse.jetty.plus.webapp.PlusConfiguration;
import org.eclipse.jetty.quickstart.PreconfigureDescriptorProcessor;
import org.eclipse.jetty.quickstart.QuickStartDescriptorGenerator;
import org.eclipse.jetty.servlet.FilterHolder;
import org.eclipse.jetty.servlet.FilterMapping;
import org.eclipse.jetty.servlet.ServletHolder;
import org.eclipse.jetty.servlet.ServletMapping;
import org.eclipse.jetty.util.StringUtil;
import org.eclipse.jetty.util.URIUtil;
import org.eclipse.jetty.util.log.Log;
import org.eclipse.jetty.util.log.Logger;
import org.eclipse.jetty.util.resource.Resource;
import org.eclipse.jetty.util.resource.ResourceCollection;
import org.eclipse.jetty.webapp.Configuration;
import org.eclipse.jetty.webapp.FragmentConfiguration;
import org.eclipse.jetty.webapp.JettyWebXmlConfiguration;
import org.eclipse.jetty.webapp.MetaInfConfiguration;
import org.eclipse.jetty.webapp.WebAppContext;
import org.eclipse.jetty.webapp.WebInfConfiguration;
import org.eclipse.jetty.webapp.WebXmlConfiguration;

/**
 * JettyWebAppContext
 * 
 * Extends the WebAppContext to specialize for the maven environment.
 * We pass in the list of files that should form the classpath for
 * the webapp when executing in the plugin, and any jetty-env.xml file
 * that may have been configured.
 *
 */
public class JettyWebAppContext extends WebAppContext
{
    private static final Logger LOG = Log.getLogger(JettyWebAppContext.class);
    
   

    private static final String DEFAULT_CONTAINER_INCLUDE_JAR_PATTERN = ".*/javax.servlet-[^/]*\\.jar$|.*/servlet-api-[^/]*\\.jar$|.*javax.servlet.jsp.jstl-[^/]*\\.jar|.*taglibs-standard-impl-.*\\.jar";
    private static final String WEB_INF_CLASSES_PREFIX = "/WEB-INF/classes";
    private static final String WEB_INF_LIB_PREFIX = "/WEB-INF/lib";

    private final Configuration[] _defaultConfigurations = {
                                                             new MavenWebInfConfiguration(),
                                                             new WebXmlConfiguration(),
                                                             new MetaInfConfiguration(),
                                                             new FragmentConfiguration(),
                                                             new EnvConfiguration(),
                                                             new PlusConfiguration(),
                                                             new AnnotationConfiguration(),
                                                             new JettyWebXmlConfiguration()
                                                            };

    private final Configuration[] _quickStartConfigurations = {
                                                                new MavenQuickStartConfiguration(),
                                                                new EnvConfiguration(),
                                                                new PlusConfiguration(),
                                                                new JettyWebXmlConfiguration()
                                                               };

    private File _classes = null;
    private File _testClasses = null;
    private final List<File> _webInfClasses = new ArrayList<File>();
    private final List<File> _webInfJars = new ArrayList<File>();
    private final Map<String, File> _webInfJarMap = new HashMap<String, File>();
    private List<File> _classpathFiles;  //webInfClasses+testClasses+webInfJars
    private String _jettyEnvXml;
    private List<Overlay> _overlays;
    private Resource _quickStartWebXml;
    
 
    
    /**
     * Set the "org.eclipse.jetty.server.webapp.ContainerIncludeJarPattern" with a pattern for matching jars on
     * container classpath to scan. This is analogous to the WebAppContext.setAttribute() call.
     */
    private String _containerIncludeJarPattern = null;
    
    /**
     * Set the "org.eclipse.jetty.server.webapp.WebInfIncludeJarPattern" with a pattern for matching jars on
     * webapp's classpath to scan. This is analogous to the WebAppContext.setAttribute() call.
     */
    private String _webInfIncludeJarPattern = null;
  

    
    /**
     * If there is no maven-war-plugin config for ordering of the current project in the
     * sequence of overlays, use this to control whether the current project is added 
     * first or last in list of overlaid resources
     */
    private boolean _baseAppFirst = true;



    private boolean _isGenerateQuickStart;
    private PreconfigureDescriptorProcessor _preconfigProcessor;
   

  
    /* ------------------------------------------------------------ */
    public JettyWebAppContext ()
    throws Exception
    {
        super();   
        // Turn off copyWebInf option as it is not applicable for plugin.
        super.setCopyWebInf(false);
    }
    
    /* ------------------------------------------------------------ */
    public void setContainerIncludeJarPattern(String pattern)
    {
        _containerIncludeJarPattern = pattern;
    }
    
    /* ------------------------------------------------------------ */
    public String getContainerIncludeJarPattern()
    {
        return _containerIncludeJarPattern;
    }
    
    /* ------------------------------------------------------------ */
    public String getWebInfIncludeJarPattern()
    {
        return _webInfIncludeJarPattern;
    }
    
    /* ------------------------------------------------------------ */
    public void setWebInfIncludeJarPattern(String pattern)
    {
        _webInfIncludeJarPattern = pattern;
    }
   
    /* ------------------------------------------------------------ */
    public List<File> getClassPathFiles()
    {
        return this._classpathFiles;
    }
    
    /* ------------------------------------------------------------ */
    public void setJettyEnvXml (String jettyEnvXml)
    {
        this._jettyEnvXml = jettyEnvXml;
    }
    
    /* ------------------------------------------------------------ */
    public String getJettyEnvXml()
    {
        return this._jettyEnvXml;
    }

    /* ------------------------------------------------------------ */
    public void setClasses(File dir)
    {
        _classes = dir;
    }
    
    /* ------------------------------------------------------------ */
    public File getClasses()
    {
        return _classes;
    }
    
    /* ------------------------------------------------------------ */
    public void setWebInfLib (List<File> jars)
    {
        _webInfJars.addAll(jars);
    }
    
    /* ------------------------------------------------------------ */
    public void setTestClasses (File dir)
    {
        _testClasses = dir;
    }
    
    /* ------------------------------------------------------------ */
    public File getTestClasses ()
    {
        return _testClasses;
    }
    
    
    /* ------------------------------------------------------------ */
    /**
     * Ordered list of wars to overlay on top of the current project. The list
     * may contain an overlay that represents the current project.
     * @param overlays the list of overlays
     */
    public void setOverlays (List<Overlay> overlays)
    {
        _overlays = overlays;
    }
    
    /* ------------------------------------------------------------ */
    public List<Overlay> getOverlays()
    {
        return _overlays;
    }

    /* ------------------------------------------------------------ */
    public void setBaseAppFirst(boolean value)
    {
        _baseAppFirst = value;
    }

    /* ------------------------------------------------------------ */
    public boolean getBaseAppFirst()
    {
        return _baseAppFirst;
    }
    
    /* ------------------------------------------------------------ */
    public void setQuickStartWebDescriptor (Resource quickStartWebXml)
    {
        _quickStartWebXml = quickStartWebXml;
    }
    
    /* ------------------------------------------------------------ */
    public Resource getQuickStartWebDescriptor ()
    {
        return _quickStartWebXml;
    }
    
    /* ------------------------------------------------------------ */
    /**
     * This method is provided as a convenience for jetty maven plugin configuration 
     * @param resourceBases Array of resources strings to set as a {@link ResourceCollection}. Each resource string may be a comma separated list of resources
     * @see Resource
     */
    public void setResourceBases(String[] resourceBases)
    {
        List<String> resources = new ArrayList<String>();
        for (String rl:resourceBases)
        {
            String[] rs = StringUtil.csvSplit(rl);
            for (String r:rs)
                resources.add(r);
        }
        
        setBaseResource(new ResourceCollection(resources.toArray(new String[resources.size()])));
    }
    
    /* ------------------------------------------------------------ */
    public List<File> getWebInfLib()
    {
        return _webInfJars;
    }
    
    /* ------------------------------------------------------------ */
    public void setGenerateQuickStart (boolean quickStart)
    {
        _isGenerateQuickStart = quickStart;
    }
    
    /* ------------------------------------------------------------ */
    public boolean isGenerateQuickStart()
    {
        return _isGenerateQuickStart;
    }
    
   
    
    /* ------------------------------------------------------------ */
    @Override
    protected void startWebapp() throws Exception
    {
        if (isGenerateQuickStart())
        {
            if (getQuickStartWebDescriptor() == null)
                throw new IllegalStateException ("No location to generate quickstart descriptor");

            QuickStartDescriptorGenerator generator = new QuickStartDescriptorGenerator(this, _preconfigProcessor.getXML());
            try (FileOutputStream fos = new FileOutputStream(getQuickStartWebDescriptor().getFile()))
            {
                generator.generateQuickStartWebXml(fos);
            }
        }
        else
        {
            if (LOG.isDebugEnabled()) { LOG.debug("Calling full start on webapp");}
            super.startWebapp();
        }
    }
    
    /* ------------------------------------------------------------ */
    @Override
    protected void stopWebapp() throws Exception
    {
        if (isGenerateQuickStart())
            return;

        if (LOG.isDebugEnabled()) { LOG.debug("Calling stop of fully started webapp");}
        super.stopWebapp();
    }
    
    /* ------------------------------------------------------------ */
    @Override
    public void doStart () throws Exception
    {
        //choose if this will be a quickstart or normal start
        if (!isGenerateQuickStart() && getQuickStartWebDescriptor() != null)
            setConfigurations(_quickStartConfigurations);
        else
        {
            setConfigurations(_defaultConfigurations);
            if (isGenerateQuickStart())
            {
                _preconfigProcessor = new PreconfigureDescriptorProcessor();
                getMetaData().addDescriptorProcessor(_preconfigProcessor);
            }
        }
        
        //inject configurations with config from maven plugin    
        for (Configuration c:getConfigurations())
        {
            if (c instanceof EnvConfiguration && getJettyEnvXml() != null)
                ((EnvConfiguration)c).setJettyEnvXml(Resource.toURL(new File(getJettyEnvXml())));
            else if (c instanceof MavenQuickStartConfiguration && getQuickStartWebDescriptor() != null)
                ((MavenQuickStartConfiguration)c).setQuickStartWebXml(getQuickStartWebDescriptor());         
        }

        //Set up the pattern that tells us where the jars are that need scanning

        //Allow user to set up pattern for names of jars from the container classpath
        //that will be scanned - note that by default NO jars are scanned
        String tmp = _containerIncludeJarPattern;
        if (tmp==null || "".equals(tmp))
            tmp = (String)getAttribute(WebInfConfiguration.CONTAINER_JAR_PATTERN);           
        
        tmp = addPattern(tmp, DEFAULT_CONTAINER_INCLUDE_JAR_PATTERN);
        setAttribute(WebInfConfiguration.CONTAINER_JAR_PATTERN, tmp);
        
        //Allow user to set up pattern of jar names from WEB-INF that will be scanned.
        //Note that by default ALL jars considered to be in WEB-INF will be scanned - setting
        //a pattern restricts scanning
        if (_webInfIncludeJarPattern != null)
            setAttribute(WebInfConfiguration.WEBINF_JAR_PATTERN, _webInfIncludeJarPattern);
   
        //Set up the classes dirs that comprises the equivalent of WEB-INF/classes
        if (_testClasses != null)
            _webInfClasses.add(_testClasses);
        if (_classes != null)
            _webInfClasses.add(_classes);
        
        // Set up the classpath
        _classpathFiles = new ArrayList<File>();
        _classpathFiles.addAll(_webInfClasses);
        _classpathFiles.addAll(_webInfJars);

        // Initialize map containing all jars in /WEB-INF/lib
        _webInfJarMap.clear();
        for (File file : _webInfJars)
        {
            // Return all jar files from class path
            String fileName = file.getName();
            if (fileName.endsWith(".jar"))
                _webInfJarMap.put(fileName, file);
        }
        
        //check for CDI
        initCDI();
        
        // CHECK setShutdown(false);
        super.doStart();
    }
    
    
    /* ------------------------------------------------------------ */
    public void doStop () throws Exception
    { 
        if (_classpathFiles != null)
            _classpathFiles.clear();
        _classpathFiles = null;
        
        _classes = null;
        _testClasses = null;
        
        if (_webInfJarMap != null)
            _webInfJarMap.clear();
       
        _webInfClasses.clear();
        _webInfJars.clear();
        
        
        
        // CHECK setShutdown(true);
        //just wait a little while to ensure no requests are still being processed
        Thread.currentThread().sleep(500L);

        super.doStop();

        //remove all listeners, servlets and filters. This is because we will re-apply
        //any context xml file, which means they would potentially be added multiple times.
        setEventListeners(new EventListener[0]);
        getServletHandler().setFilters(new FilterHolder[0]);
        getServletHandler().setFilterMappings(new FilterMapping[0]);
        getServletHandler().setServlets(new ServletHolder[0]);
        getServletHandler().setServletMappings(new ServletMapping[0]);
    }
    
    
    /* ------------------------------------------------------------ */
    @Override
    public Resource getResource(String uriInContext) throws MalformedURLException
    {
        Resource resource = null;
        // Try to get regular resource
        resource = super.getResource(uriInContext);

        // If no regular resource exists check for access to /WEB-INF/lib or /WEB-INF/classes
        if ((resource == null || !resource.exists()) && uriInContext != null && _classes != null)
        {
            String uri = URIUtil.canonicalPath(uriInContext);
            if (uri == null)
                return null;

            try
            {
                // Replace /WEB-INF/classes with candidates for the classpath
                if (uri.startsWith(WEB_INF_CLASSES_PREFIX))
                {
                    if (uri.equalsIgnoreCase(WEB_INF_CLASSES_PREFIX) || uri.equalsIgnoreCase(WEB_INF_CLASSES_PREFIX+"/"))
                    {
                        //exact match for a WEB-INF/classes, so preferentially return the resource matching the web-inf classes
                        //rather than the test classes
                        if (_classes != null)
                            return Resource.newResource(_classes);
                        else if (_testClasses != null)
                            return Resource.newResource(_testClasses);
                    }
                    else
                    {
                        //try matching                       
                        Resource res = null;
                        int i=0;
                        while (res == null && (i < _webInfClasses.size()))
                        {
                            String newPath = uri.replace(WEB_INF_CLASSES_PREFIX, _webInfClasses.get(i).getPath());
                            res = Resource.newResource(newPath);
                            if (!res.exists())
                            {
                                res = null; 
                                i++;
                            }
                        }
                        return res;
                    }
                }       
                else if (uri.startsWith(WEB_INF_LIB_PREFIX))
                {
                    // Return the real jar file for all accesses to
                    // /WEB-INF/lib/*.jar
                    String jarName = uri.replace(WEB_INF_LIB_PREFIX, "");
                    if (jarName.startsWith("/") || jarName.startsWith("\\")) 
                        jarName = jarName.substring(1);
                    if (jarName.length()==0) 
                        return null;
                    File jarFile = _webInfJarMap.get(jarName);
                    if (jarFile != null)
                        return Resource.newResource(jarFile.getPath());

                    return null;
                }
            }
            catch (MalformedURLException e)
            {
                throw e;
            }
            catch (IOException e)
            {
                LOG.ignore(e);
            }
        }
        return resource;
    }
    
    
    /* ------------------------------------------------------------ */
    @Override
    public Set<String> getResourcePaths(String path)
    {
        // Try to get regular resource paths - this will get appropriate paths from any overlaid wars etc
        Set<String> paths = super.getResourcePaths(path);
        
        if (path != null)
        {
            TreeSet<String> allPaths = new TreeSet<String>();
            allPaths.addAll(paths);
            
            //add in the dependency jars as a virtual WEB-INF/lib entry
            if (path.startsWith(WEB_INF_LIB_PREFIX))
            {
                for (String fileName : _webInfJarMap.keySet())
                {
                    // Return all jar files from class path
                    allPaths.add(WEB_INF_LIB_PREFIX + "/" + fileName);
                }
            }
            else if (path.startsWith(WEB_INF_CLASSES_PREFIX))
            {
                int i=0;
               
                while (i < _webInfClasses.size())
                {
                    String newPath = path.replace(WEB_INF_CLASSES_PREFIX, _webInfClasses.get(i).getPath());
                    allPaths.addAll(super.getResourcePaths(newPath));
                    i++;
                }
            }
            return allPaths;
        }
        return paths;
    }
    
    /* ------------------------------------------------------------ */
    public String addPattern (String s, String pattern)
    {
        if (s == null)
            s = "";
        else
            s = s.trim();
        
        if (!s.contains(pattern))
        {
            if (s.length() != 0)
                s = s + "|";
            s = s + pattern;
        }
        
        return s;
    }
    
    
    /* ------------------------------------------------------------ */
    public void initCDI()
    {
        Class cdiInitializer = null;
        try
        {
            cdiInitializer = Thread.currentThread().getContextClassLoader().loadClass("org.eclipse.jetty.cdi.servlet.JettyWeldInitializer");
            Method initWebAppMethod = cdiInitializer.getMethod("initWebApp", new Class[]{WebAppContext.class});
            initWebAppMethod.invoke(null, new Object[]{this});
        }
        catch (ClassNotFoundException e)
        {
            LOG.debug("o.e.j.cdi.servlet.JettyWeldInitializer not found, no cdi integration available");
        }
        catch (NoSuchMethodException e)
        {
            LOG.warn("o.e.j.cdi.servlet.JettyWeldInitializer.initWebApp() not found, no cdi integration available");
        }
        catch (Exception e)
        {
           LOG.warn("Problem initializing cdi", e);
        }
    }
}