// ========================================================================
// Copyright (c) 2009 Intalio, Inc.
// ------------------------------------------------------------------------
// 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. 
// Contributors:
//    Hugues Malphettes - initial API and implementation
// ========================================================================
package org.eclipse.jetty.osgi.boot.internal.webapp;

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.StringTokenizer;
import java.util.jar.JarFile;
import java.util.zip.ZipEntry;

import org.eclipse.jetty.deploy.AppProvider;
import org.eclipse.jetty.deploy.ContextDeployer;
import org.eclipse.jetty.deploy.DeploymentManager;
import org.eclipse.jetty.deploy.WebAppDeployer;
import org.eclipse.jetty.osgi.boot.JettyBootstrapActivator;
import org.eclipse.jetty.osgi.boot.OSGiAppProvider;
import org.eclipse.jetty.osgi.boot.OSGiWebappConstants;
import org.eclipse.jetty.osgi.boot.internal.jsp.TldLocatableURLClassloader;
import org.eclipse.jetty.osgi.boot.utils.BundleClassLoaderHelper;
import org.eclipse.jetty.osgi.boot.utils.BundleFileLocatorHelper;
import org.eclipse.jetty.osgi.boot.utils.WebappRegistrationCustomizer;
import org.eclipse.jetty.osgi.boot.utils.internal.DefaultBundleClassLoaderHelper;
import org.eclipse.jetty.osgi.boot.utils.internal.DefaultFileLocatorHelper;
import org.eclipse.jetty.server.Handler;
import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.server.handler.ContextHandler;
import org.eclipse.jetty.server.handler.ContextHandlerCollection;
import org.eclipse.jetty.server.handler.DefaultHandler;
import org.eclipse.jetty.server.handler.HandlerCollection;
import org.eclipse.jetty.server.handler.RequestLogHandler;
import org.eclipse.jetty.server.nio.SelectChannelConnector;
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.webapp.WebAppContext;
import org.eclipse.jetty.xml.XmlConfiguration;
import org.osgi.framework.Bundle;
import org.osgi.framework.BundleContext;
import org.xml.sax.SAXException;
import org.xml.sax.SAXParseException;

/**
 * Bridges the jetty deployers with the OSGi lifecycle where applications are
 * managed inside OSGi-bundles.
 * <p>
 * This class should be called as a consequence of the activation of a new
 * service that is a ContextHandler.<br/>
 * This way the new webapps are exposed as OSGi services.
 * </p>
 * <p>
 * Helper methods to register a bundle that is a web-application or a context.
 * </p>
 * Limitations:
 * <ul>
 * <li>support for jarred webapps is somewhat limited.</li>
 * </ul>
 */
public class WebappRegistrationHelper
{

    private static Logger __logger = Log.getLogger(WebappRegistrationHelper.class.getName());

    private static boolean INITIALIZED = false;

    /**
     * By default set to: {@link DefaultBundleClassLoaderHelper}. It supports
     * equinox and apache-felix fragment bundles that are specific to an OSGi
     * implementation should set a different implementation.
     */
    public static BundleClassLoaderHelper BUNDLE_CLASS_LOADER_HELPER = null;
    /**
     * By default set to: {@link DefaultBundleClassLoaderHelper}. It supports
     * equinox and apache-felix fragment bundles that are specific to an OSGi
     * implementation should set a different implementation.
     */
    public static BundleFileLocatorHelper BUNDLE_FILE_LOCATOR_HELPER = null;

    /**
     * By default set to: {@link DefaultBundleClassLoaderHelper}. It supports
     * equinox and apache-felix fragment bundles that are specific to an OSGi
     * implementation should set a different implementation.
     * <p>
     * Several of those objects can be added here: For example we could have an optional fragment that setups
     * a specific implementation of JSF for the whole of jetty-osgi.
     * </p>
     */
    public static Collection<WebappRegistrationCustomizer> JSP_REGISTRATION_HELPERS = new ArrayList<WebappRegistrationCustomizer>();

    private Server _server;
    private ContextHandlerCollection _ctxtHandler;

    /**
     * this class loader loads the jars inside {$jetty.home}/lib/ext it is meant
     * as a migration path and for jars that are not OSGi ready. also gives
     * access to the jsp jars.
     */
    // private URLClassLoader _libExtClassLoader;

    /**
     * This is the class loader that should be the parent classloader of any
     * webapp classloader. It is in fact the _libExtClassLoader with a trick to
     * let the TldScanner find the jars where the tld files are.
     */
    private URLClassLoader _commonParentClassLoaderForWebapps;

    private DeploymentManager _deploymentManager;

    private OSGiAppProvider _provider;

    public WebappRegistrationHelper(Server server)
    {
        _server = server;
        staticInit();
    }

    // Inject the customizing classes that might be defined in fragment bundles.
    private static synchronized void staticInit()
    {
        if (!INITIALIZED)
        {
            INITIALIZED = true;
            // setup the custom BundleClassLoaderHelper
            try
            {
                BUNDLE_CLASS_LOADER_HELPER = (BundleClassLoaderHelper)Class.forName(BundleClassLoaderHelper.CLASS_NAME).newInstance();
            }
            catch (Throwable t)
            {
                // System.err.println("support for equinox and felix");
                BUNDLE_CLASS_LOADER_HELPER = new DefaultBundleClassLoaderHelper();
            }
            // setup the custom FileLocatorHelper
            try
            {
                BUNDLE_FILE_LOCATOR_HELPER = (BundleFileLocatorHelper)Class.forName(BundleFileLocatorHelper.CLASS_NAME).newInstance();
            }
            catch (Throwable t)
            {
                // System.err.println("no jsp/jasper support");
                BUNDLE_FILE_LOCATOR_HELPER = new DefaultFileLocatorHelper();
            }
        }
    }

    /**
     * Removes quotes around system property values before we try to make them
     * into file pathes.
     */
    public static String stripQuotesIfPresent(String filePath)
    {
        if (filePath == null)
            return null;

        if ((filePath.startsWith("\"") || filePath.startsWith("'")) && (filePath.endsWith("\"") || filePath.endsWith("'")))
            return filePath.substring(1,filePath.length() - 1);
        return filePath;
    }
    
    /**
     * Look for the home directory of jetty as defined by the system property
     * 'jetty.home'. If undefined, look at the current bundle and uses its own
     * jettyhome folder for this feature.
     * <p>
     * Special case: inside eclipse-SDK:<br/>
     * If the bundle is jarred, see if we are inside eclipse-PDE itself. In that
     * case, look for the installation directory of eclipse-PDE, try to create a
     * jettyhome folder there and install the sample jettyhome folder at that
     * location. This makes the installation in eclipse-SDK easier. <br/>
     * This is a bit redundant with the work done by the jetty configuration
     * launcher.
     * </p>
     * 
     * @param context
     * @throws Exception
     */
    public void setup(BundleContext context, Map<String, String> configProperties) throws Exception
    {
        File _installLocation = BUNDLE_FILE_LOCATOR_HELPER.getBundleInstallLocation(context.getBundle());
        // debug:
        // new File("~/proj/eclipse-install/eclipse-3.5.1-SDK-jetty7/" +
        // "dropins/jetty7/plugins/org.eclipse.jetty.osgi.boot_0.0.1.001-SNAPSHOT.jar");
        boolean bootBundleCanBeJarred = true;
        String jettyHome = stripQuotesIfPresent(System.getProperty("jetty.home"));

        if (jettyHome == null || jettyHome.length() == 0)
        {
            if (_installLocation.getName().endsWith(".jar"))
            {
                jettyHome = JettyHomeHelper.setupJettyHomeInEclipsePDE(_installLocation);
            }
            if (jettyHome == null)
            {
                jettyHome = _installLocation.getAbsolutePath() + "/jettyhome";
                bootBundleCanBeJarred = false;
            }
        }
        // in case we stripped the quotes.
        System.setProperty("jetty.home",jettyHome);

        String jettyLogs = stripQuotesIfPresent(System.getProperty("jetty.logs"));
        if (jettyLogs == null || jettyLogs.length() == 0)
        {
            System.setProperty("jetty.logs",jettyHome + "/logs");
        }

        if (!bootBundleCanBeJarred && !_installLocation.isDirectory())
        {
            String install = _installLocation != null?_installLocation.getCanonicalPath():" unresolved_install_location";
            throw new IllegalArgumentException("The system property -Djetty.home" + " must be set to a directory or the bundle "
                    + context.getBundle().getSymbolicName() + " installed here " + install + " must be unjarred.");

        }
        try
        {
            System.err.println("JETTY_HOME set to " + new File(jettyHome).getCanonicalPath());
        }
        catch (Throwable t)
        {
            System.err.println("JETTY_HOME _set to " + new File(jettyHome).getAbsolutePath());
        }

        ClassLoader contextCl = Thread.currentThread().getContextClassLoader();
        try
        {

            // passing this bundle's classloader as the context classlaoder
            // makes sure there is access to all the jetty's bundles

            File jettyHomeF = new File(jettyHome);
            URLClassLoader libExtClassLoader = null;
            try
            {
            	libExtClassLoader = LibExtClassLoaderHelper.createLibEtcClassLoaderHelper(jettyHomeF,_server,
            			JettyBootstrapActivator.class.getClassLoader());
            }
            catch (MalformedURLException e)
            {
                e.printStackTrace();
            }

            Thread.currentThread().setContextClassLoader(libExtClassLoader);

            String jettyetc = System.getProperty(OSGiWebappConstants.SYS_PROP_JETTY_ETC_FILES,"etc/jetty.xml");
            StringTokenizer tokenizer = new StringTokenizer(jettyetc,";,");
            
            Map<Object,Object> id_map = new HashMap<Object,Object>();
            id_map.put("Server",_server);
            Map<Object,Object> properties = new HashMap<Object,Object>();
            properties.put("jetty.home",jettyHome);
            properties.put("jetty.host",System.getProperty("jetty.host",""));
            properties.put("jetty.port",System.getProperty("jetty.port","8080"));
            properties.put("jetty.port.ssl",System.getProperty("jetty.port.ssl","8443"));

            while (tokenizer.hasMoreTokens())
            {
                String etcFile = tokenizer.nextToken().trim();
                File conffile = etcFile.startsWith("/")?new File(etcFile):new File(jettyHomeF,etcFile);
                if (!conffile.exists())
                {
                    __logger.warn("Unable to resolve the jetty/etc file " + etcFile);

                    if ("etc/jetty.xml".equals(etcFile))
                    {
                        // Missing jetty.xml file, so create a minimal Jetty configuration
                        __logger.info("Configuring default server on 8080");
                        SelectChannelConnector connector = new SelectChannelConnector();
                        connector.setPort(8080);
                        _server.addConnector(connector);

                        HandlerCollection handlers = new HandlerCollection();
                        ContextHandlerCollection contexts = new ContextHandlerCollection();
                        RequestLogHandler requestLogHandler = new RequestLogHandler();
                        handlers.setHandlers(new Handler[] { contexts, new DefaultHandler(), requestLogHandler });
                        _server.setHandler(handlers);
                    }
                }
                else
                {
                    try
                    {
                        // Execute a Jetty configuration file
                        XmlConfiguration config = new XmlConfiguration(new FileInputStream(conffile));
                        config.setIdMap(id_map);
                        config.setProperties(properties);
                        config.configure();
                        id_map=config.getIdMap();
                    }
                    catch (SAXParseException saxparse)
                    {
                        Log.getLogger(WebappRegistrationHelper.class.getName()).warn("Unable to configure the jetty/etc file " + etcFile,saxparse);
                        throw saxparse;
                    }
                }
            }

            init();

            //now that we have an app provider we can call the registration customizer.
            try
            {
                URL[] jarsWithTlds = getJarsWithTlds();
                _commonParentClassLoaderForWebapps = jarsWithTlds == null?libExtClassLoader:new TldLocatableURLClassloader(libExtClassLoader,getJarsWithTlds());
            }
            catch (MalformedURLException e)
            {
                e.printStackTrace();
            }

            
            _server.start();
        }
        catch (Throwable t)
        {
            t.printStackTrace();
        }
        finally
        {
            Thread.currentThread().setContextClassLoader(contextCl);
        }

    }

    /**
     * Must be called after the server is configured.
     * 
     * Locate the actual instance of the ContextDeployer and WebAppDeployer that
     * was created when configuring the server through jetty.xml. If there is no
     * such thing it won't be possible to deploy webapps from a context and we
     * throw IllegalStateExceptions.
     */
    private void init()
    {
        // Get the context handler
        _ctxtHandler = (ContextHandlerCollection)_server.getChildHandlerByClass(ContextHandlerCollection.class);
        
        // get a deployerManager
        List<DeploymentManager> deployers = _server.getBeans(DeploymentManager.class);
        if (deployers != null && !deployers.isEmpty())
        {
            _deploymentManager = deployers.get(0);
            
            for (AppProvider provider : _deploymentManager.getAppProviders())
            {
                if (provider instanceof OSGiAppProvider)
                {
                    _provider=(OSGiAppProvider)provider;
                    break;
                }
            }
            if (_provider == null)
            {
            	//create it on the fly with reasonable default values.
            	try
            	{
					_provider = new OSGiAppProvider();
					_provider.setMonitoredDir(
							Resource.newResource(getDefaultOSGiContextsHome(
									new File(System.getProperty("jetty.home"))).toURI()));
				} catch (IOException e) {
					e.printStackTrace();
				}
            	_deploymentManager.addAppProvider(_provider);
            }
        }

        if (_ctxtHandler == null || _provider==null)
            throw new IllegalStateException("ERROR: No ContextHandlerCollection or OSGiAppProvider configured");
        

    }

    /**
     * Deploy a new web application on the jetty server.
     * 
     * @param bundle
     *            The bundle
     * @param webappFolderPath
     *            The path to the root of the webapp. Must be a path relative to
     *            bundle; either an absolute path.
     * @param contextPath
     *            The context path. Must start with "/"
     * @param extraClasspath
     * @param overrideBundleInstallLocation
     * @param webXmlPath
     * @param defaultWebXmlPath
     *            TODO: parameter description
     * @return The contexthandler created and started
     * @throws Exception
     */
    public ContextHandler registerWebapplication(Bundle bundle, String webappFolderPath, String contextPath, String extraClasspath,
            String overrideBundleInstallLocation, String webXmlPath, String defaultWebXmlPath) throws Exception
    {
        File bundleInstall = overrideBundleInstallLocation == null?BUNDLE_FILE_LOCATOR_HELPER.getBundleInstallLocation(bundle):new File(
                overrideBundleInstallLocation);
        File webapp = null;
        if (webappFolderPath != null && webappFolderPath.length() != 0 && !webappFolderPath.equals("."))
        {
            if (webappFolderPath.startsWith("/") || webappFolderPath.startsWith("file:/"))
            {
                webapp = new File(webappFolderPath);
            }
            else
            {
                webapp = new File(bundleInstall,webappFolderPath);
            }
        }
        else
        {
            webapp = bundleInstall;
        }
        if (!webapp.exists())
        {
            throw new IllegalArgumentException("Unable to locate " + webappFolderPath + " inside "
                    + (bundleInstall != null?bundleInstall.getAbsolutePath():"unlocated bundle '" + bundle.getSymbolicName() + "'"));
        }
        return registerWebapplication(bundle,webapp,contextPath,extraClasspath,bundleInstall,webXmlPath,defaultWebXmlPath);
    }

    /**
     * TODO: refactor this into the createContext method of OSGiAppProvider.
     * @see WebAppDeployer#scan()

     * @param contributor
     * @param webapp
     * @param contextPath
     * @param extraClasspath
     * @param bundleInstall
     * @param webXmlPath
     * @param defaultWebXmlPath
     * @return The contexthandler created and started
     * @throws Exception
     */
    public ContextHandler registerWebapplication(Bundle contributor, File webapp, String contextPath, String extraClasspath, File bundleInstall,
            String webXmlPath, String defaultWebXmlPath) throws Exception
    {

        ClassLoader contextCl = Thread.currentThread().getContextClassLoader();
        String[] oldServerClasses = null;
        WebAppContext context = null;
        try
        {
            // make sure we provide access to all the jetty bundles by going
            // through this bundle.
            OSGiWebappClassLoader composite = createWebappClassLoader(contributor);
            // configure with access to all jetty classes and also all the classes
            // that the contributor gives access to.
            Thread.currentThread().setContextClassLoader(composite);

            context = new WebAppContext(webapp.getAbsolutePath(),contextPath);
            context.setExtraClasspath(extraClasspath);

            if (webXmlPath != null && webXmlPath.length() != 0)
            {
                File webXml = null;
                if (webXmlPath.startsWith("/") || webXmlPath.startsWith("file:/"))
                {
                    webXml = new File(webXmlPath);
                }
                else
                {
                    webXml = new File(bundleInstall,webXmlPath);
                }
                if (webXml.exists())
                {
                    context.setDescriptor(webXml.getAbsolutePath());
                }
            }

            if (defaultWebXmlPath == null || defaultWebXmlPath.length() == 0)
            {
            	//use the one defined by the OSGiAppProvider.
            	defaultWebXmlPath = _provider.getDefaultsDescriptor();
            }
            if (defaultWebXmlPath != null && defaultWebXmlPath.length() != 0)
            {
                File defaultWebXml = null;
                if (defaultWebXmlPath.startsWith("/") || defaultWebXmlPath.startsWith("file:/"))
                {
                    defaultWebXml = new File(webXmlPath);
                }
                else
                {
                    defaultWebXml = new File(bundleInstall,defaultWebXmlPath);
                }
                if (defaultWebXml.exists())
                {
                    context.setDefaultsDescriptor(defaultWebXml.getAbsolutePath());
                }
            }
            
            //other parameters that might be defines on the OSGiAppProvider:
            context.setParentLoaderPriority(_provider.isParentLoaderPriority());

            configureWebAppContext(context,contributor);
            configureWebappClassLoader(contributor,context,composite);

            // @see
            // org.eclipse.jetty.webapp.JettyWebXmlConfiguration#configure(WebAppContext)
            // during initialization of the webapp all the jetty packages are
            // visible
            // through the webapp classloader.
            oldServerClasses = context.getServerClasses();
            context.setServerClasses(null);
            _provider.addContext(context);

            return context;
        }
        finally
        {
            if (context != null && oldServerClasses != null)
            {
                context.setServerClasses(oldServerClasses);
            }
            Thread.currentThread().setContextClassLoader(contextCl);
        }

    }

    /**
     * Stop a ContextHandler and remove it from the collection.
     * 
     * @see ContextDeployer#undeploy
     * @param contextHandler
     * @throws Exception
     */
    public void unregister(ContextHandler contextHandler) throws Exception
    {
        contextHandler.stop();
        _ctxtHandler.removeHandler(contextHandler);
    }

    /**
     * @return The default folder in which the context files of the osgi bundles
     *         are located and watched. Or null when the system property
     *         "jetty.osgi.contexts.home" is not defined.
     *         If the configuration file defines the OSGiAppProvider's context.
     *         This will not be taken into account.
     */
    File getDefaultOSGiContextsHome(File jettyHome)
    {
        String jettyContextsHome = System.getProperty("jetty.osgi.contexts.home");
        if (jettyContextsHome != null)
        {
            File contextsHome = new File(jettyContextsHome);
            if (!contextsHome.exists() || !contextsHome.isDirectory())
            {
                throw new IllegalArgumentException("the ${jetty.osgi.contexts.home} '" + jettyContextsHome + " must exist and be a folder");
            }
            return contextsHome;
        }
        return new File(jettyHome, "/contexts");
    }
    
    File getOSGiContextsHome()
    {
    	return _provider.getContextXmlDirAsFile();
    }

    /**
     * This type of registration relies on jetty's complete context xml file.
     * Context encompasses jndi and all other things. This makes the definition
     * of the webapp a lot more self-contained.
     * 
     * @param contributor
     * @param contextFileRelativePath
     * @param extraClasspath
     * @param overrideBundleInstallLocation
     * @return The contexthandler created and started
     * @throws Exception
     */
    public ContextHandler registerContext(Bundle contributor, String contextFileRelativePath, String extraClasspath, String overrideBundleInstallLocation)
            throws Exception
    {
        File contextsHome = _provider.getContextXmlDirAsFile();
        if (contextsHome != null)
        {
            File prodContextFile = new File(contextsHome,contributor.getSymbolicName() + "/" + contextFileRelativePath);
            if (prodContextFile.exists())
            {
                return registerContext(contributor,prodContextFile,extraClasspath,overrideBundleInstallLocation);
            }
        }
        File contextFile = overrideBundleInstallLocation != null?new File(overrideBundleInstallLocation,contextFileRelativePath):new File(
                BUNDLE_FILE_LOCATOR_HELPER.getBundleInstallLocation(contributor),contextFileRelativePath);
        if (contextFile.exists())
        {
            return registerContext(contributor,contextFile,extraClasspath,overrideBundleInstallLocation);
        }
        else
        {
            if (contextFileRelativePath.startsWith("./"))
            {
                contextFileRelativePath = contextFileRelativePath.substring(1);
            }
            if (!contextFileRelativePath.startsWith("/"))
            {
                contextFileRelativePath = "/" + contextFileRelativePath;
            }
            if (overrideBundleInstallLocation == null)
            {
                URL contextURL = contributor.getEntry(contextFileRelativePath);
                if (contextURL != null)
                {
                    return registerContext(contributor,contextURL.openStream(),extraClasspath,overrideBundleInstallLocation);
                }
            }
            else
            {
                JarFile zipFile = null;
                try
                {
                    zipFile = new JarFile(overrideBundleInstallLocation);
                    ZipEntry entry = zipFile.getEntry(contextFileRelativePath.substring(1));
                    return registerContext(contributor,zipFile.getInputStream(entry),extraClasspath,overrideBundleInstallLocation);
                }
                catch (Throwable t)
                {

                }
                finally
                {
                    if (zipFile != null)
                        try
                        {
                            zipFile.close();
                        }
                        catch (IOException ioe)
                        {
                        }
                }
            }
            throw new IllegalArgumentException("Could not find the context " + "file " + contextFileRelativePath + " for the bundle "
                    + contributor.getSymbolicName() + (overrideBundleInstallLocation != null?" using the install location " + overrideBundleInstallLocation:""));
        }
    }

    /**
     * This type of registration relies on jetty's complete context xml file.
     * Context encompasses jndi and all other things. This makes the definition
     * of the webapp a lot more self-contained.
     * 
     * @param webapp
     * @param contextPath
     * @param classInBundle
     * @throws Exception
     */
    private ContextHandler registerContext(Bundle contributor, File contextFile, String extraClasspath, String overrideBundleInstallLocation) throws Exception
    {
        InputStream contextFileInputStream = null;
        try
        {
            contextFileInputStream = new BufferedInputStream(new FileInputStream(contextFile));
            return registerContext(contributor,contextFileInputStream,extraClasspath,overrideBundleInstallLocation);
        }
        finally
        {
            if (contextFileInputStream != null)
                try
                {
                    contextFileInputStream.close();
                }
                catch (IOException ioe)
                {
                }
        }
    }

    /**
     * @param contributor
     * @param contextFileInputStream
     * @return The ContextHandler created and registered or null if it did not
     *         happen.
     * @throws Exception
     */
    private ContextHandler registerContext(Bundle contributor, InputStream contextFileInputStream, String extraClasspath, String overrideBundleInstallLocation)
            throws Exception
    {
        ClassLoader contextCl = Thread.currentThread().getContextClassLoader();
        String[] oldServerClasses = null;
        WebAppContext webAppContext = null;
        try
        {
            // make sure we provide access to all the jetty bundles by going
            // through this bundle.
            OSGiWebappClassLoader composite = createWebappClassLoader(contributor);
            // configure with access to all jetty classes and also all the
            // classes
            // that the contributor gives access to.
            Thread.currentThread().setContextClassLoader(composite);
            ContextHandler context = createContextHandler(contributor,contextFileInputStream,extraClasspath,overrideBundleInstallLocation);
            if (context == null)
            {
                return null;// did not happen
            }

            // ok now register this webapp. we checked when we started jetty
            // that there
            // was at least one such handler for webapps.
            //the actual registration must happen via the new Deployment API.
//            _ctxtHandler.addHandler(context);

            configureWebappClassLoader(contributor,context,composite);
            if (context instanceof WebAppContext)
            {
                webAppContext = (WebAppContext)context;
                // @see
                // org.eclipse.jetty.webapp.JettyWebXmlConfiguration#configure(WebAppContext)
                oldServerClasses = webAppContext.getServerClasses();
                webAppContext.setServerClasses(null);
            }

             _provider.addContext(context);
            return context;
        }
        finally
        {
            if (webAppContext != null)
            {
                webAppContext.setServerClasses(oldServerClasses);
            }
            Thread.currentThread().setContextClassLoader(contextCl);
        }

    }

    /**
     * TODO: right now only the jetty-jsp bundle is scanned for common taglibs.
     * Should support a way to plug more bundles that contain taglibs.
     * 
     * The jasper TldScanner expects a URLClassloader to parse a jar for the
     * /META-INF/*.tld it may contain. We place the bundles that we know contain
     * such tag-libraries. Please note that it will work if and only if the
     * bundle is a jar (!) Currently we just hardcode the bundle that contains
     * the jstl implemenation.
     * 
     * A workaround when the tld cannot be parsed with this method is to copy
     * and paste it inside the WEB-INF of the webapplication where it is used.
     * 
     * Support only 2 types of packaging for the bundle: - the bundle is a jar
     * (recommended for runtime.) - the bundle is a folder and contain jars in
     * the root and/or in the lib folder (nice for PDE developement situations)
     * Unsupported: the bundle is a jar that embeds more jars.
     * 
     * @return
     * @throws Exception
     */
    private URL[] getJarsWithTlds() throws Exception
    {
        ArrayList<URL> res = new ArrayList<URL>();
        for (WebappRegistrationCustomizer regCustomizer : JSP_REGISTRATION_HELPERS)
        {
            URL[] urls = regCustomizer.getJarsWithTlds(_provider, BUNDLE_FILE_LOCATOR_HELPER);
            for (URL url : urls)
            {
                if (!res.contains(url))
                    res.add(url);
            }
        }
        if (!res.isEmpty())
            return res.toArray(new URL[res.size()]);
        else
            return null;
    }

    /**
     * Applies the properties of WebAppDeployer as defined in jetty.xml.
     * 
     * @see {WebAppDeployer#scan} around the comment
     *      <code>// configure it</code>
     */
    protected void configureWebAppContext(WebAppContext wah, Bundle contributor)
    {
        // rfc66
        wah.setAttribute(OSGiWebappConstants.RFC66_OSGI_BUNDLE_CONTEXT,contributor.getBundleContext());

        //spring-dm-1.2.1 looks for the BundleContext as a different attribute.
        //not a spec... but if we want to support 
        //org.springframework.osgi.web.context.support.OsgiBundleXmlWebApplicationContext
        //then we need to do this to:
        wah.setAttribute("org.springframework.osgi.web." + BundleContext.class.getName(),
                        contributor.getBundleContext());
        
    }

    /**
     * @See {@link ContextDeployer#scan}
     * @param contextFile
     * @return
     */
    protected ContextHandler createContextHandler(Bundle bundle, File contextFile, String extraClasspath, String overrideBundleInstallLocation)
    {
        try
        {
            return createContextHandler(bundle,new BufferedInputStream(new FileInputStream(contextFile)),extraClasspath,overrideBundleInstallLocation);
        }
        catch (FileNotFoundException e)
        {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * @See {@link ContextDeployer#scan}
     * @param contextFile
     * @return
     */
    @SuppressWarnings("unchecked")
    protected ContextHandler createContextHandler(Bundle bundle, InputStream contextInputStream, String extraClasspath, String overrideBundleInstallLocation)
    {
        /*
         * Do something identical to what the ContextProvider would have done:
         * XmlConfiguration xmlConfiguration=new
         * XmlConfiguration(resource.getURL()); HashMap properties = new
         * HashMap(); properties.put("Server", _contexts.getServer()); if
         * (_configMgr!=null) properties.putAll(_configMgr.getProperties());
         * 
         * xmlConfiguration.setProperties(properties); ContextHandler
         * context=(ContextHandler)xmlConfiguration.configure();
         * context.setAttributes(new AttributesMap(_contextAttributes));
         */
        try
        {
            XmlConfiguration xmlConfiguration = new XmlConfiguration(contextInputStream);
            HashMap properties = new HashMap();
            properties.put("Server",_server);
            
            // insert the bundle's location as a property.
            setThisBundleHomeProperty(bundle,properties,overrideBundleInstallLocation);
            xmlConfiguration.setProperties(properties);

            ContextHandler context = (ContextHandler)xmlConfiguration.configure();
            if (context instanceof WebAppContext)
            {
                ((WebAppContext)context).setExtraClasspath(extraClasspath);
                ((WebAppContext)context).setParentLoaderPriority(_provider.isParentLoaderPriority());
                if (_provider.getDefaultsDescriptor() != null && _provider.getDefaultsDescriptor().length() != 0)
                {
                	((WebAppContext)context).setDefaultsDescriptor(_provider.getDefaultsDescriptor());
                }
            }

            // rfc-66:
            context.setAttribute(OSGiWebappConstants.RFC66_OSGI_BUNDLE_CONTEXT,bundle.getBundleContext());

            //spring-dm-1.2.1 looks for the BundleContext as a different attribute.
            //not a spec... but if we want to support 
            //org.springframework.osgi.web.context.support.OsgiBundleXmlWebApplicationContext
            //then we need to do this to:
            context.setAttribute("org.springframework.osgi.web." + BundleContext.class.getName(),
                            bundle.getBundleContext());
            return context;
        }
        catch (FileNotFoundException e)
        {
            return null;
        }
        catch (SAXException e)
        {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        catch (IOException e)
        {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        catch (Throwable e)
        {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        finally
        {
            if (contextInputStream != null)
                try
                {
                    contextInputStream.close();
                }
                catch (IOException ioe)
                {
                }
        }
        return null;
    }

    /**
     * Configure a classloader onto the context. If the context is a
     * WebAppContext, build a WebAppClassLoader that has access to all the jetty
     * classes thanks to the classloader of the JettyBootStrapper bundle and
     * also has access to the classloader of the bundle that defines this
     * context.
     * <p>
     * If the context is not a WebAppContext, same but with a simpler
     * URLClassLoader. Note that the URLClassLoader is pretty much fake: it
     * delegate all actual classloading to the parent classloaders.
     * </p>
     * <p>
     * The URL[] returned by the URLClassLoader create contained specifically
     * the jars that some j2ee tools expect and look into. For example the jars
     * that contain tld files for jasper's jstl support.
     * </p>
     * <p>
     * Also as the jars in the lib folder and the classes in the classes folder
     * might already be in the OSGi classloader we filter them out of the
     * WebAppClassLoader
     * </p>
     * 
     * @param context
     * @param contributor
     * @param webapp
     * @param contextPath
     * @param classInBundle
     * @throws Exception
     */
    protected void configureWebappClassLoader(Bundle contributor, ContextHandler context, OSGiWebappClassLoader webappClassLoader) throws Exception
    {
        if (context instanceof WebAppContext)
        {
            WebAppContext webappCtxt = (WebAppContext)context;
            context.setClassLoader(webappClassLoader);
            webappClassLoader.setWebappContext(webappCtxt);
        }
        else
        {
            context.setClassLoader(webappClassLoader);
        }
    }

    /**
     * No matter what the type of webapp, we create a WebappClassLoader.
     */
    protected OSGiWebappClassLoader createWebappClassLoader(Bundle contributor) throws Exception
    {
        // we use a temporary WebAppContext object.
        // if this is a real webapp we will set it on it a bit later: once we
        // know.
        OSGiWebappClassLoader webappClassLoader = new OSGiWebappClassLoader(_commonParentClassLoaderForWebapps,new WebAppContext(),contributor);
        return webappClassLoader;
    }

    /**
     * Set the property &quot;this.bundle.install&quot; to point to the location
     * of the bundle. Useful when <SystemProperty name="this.bundle.home"/> is
     * used.
     */
    private void setThisBundleHomeProperty(Bundle bundle, HashMap<String, Object> properties, String overrideBundleInstallLocation)
    {
        try
        {
            File location = overrideBundleInstallLocation != null?new File(overrideBundleInstallLocation):BUNDLE_FILE_LOCATOR_HELPER
                    .getBundleInstallLocation(bundle);
            properties.put("this.bundle.install",location.getCanonicalPath());
        }
        catch (Throwable t)
        {
            System.err.println("Unable to set 'this.bundle.install' " + " for the bundle " + bundle.getSymbolicName());
            t.printStackTrace();
        }
    }


}