// ========================================================================
// Copyright (c) 2004-2009 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.webapp;
import java.io.IOException;
import java.net.URI;
import java.net.URL;
import java.util.ArrayList;
import java.util.Collection;
import java.util.EventListener;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.servlet.Servlet;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import org.eclipse.jetty.util.Loader;
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.xml.XmlParser;
/* ------------------------------------------------------------ */
/** TagLibConfiguration.
*
* The class searches for TLD descriptors found in web.xml, in WEB-INF/*.tld files of the web app
* or *.tld files within jars found in WEB-INF/lib of the webapp. Any listeners defined in these
* tld's are added to the context.
*
* <bile>This is total rubbish special case for JSPs! If there was a general use-case for web app
* frameworks to register listeners directly, then a generic mechanism could have been added to the servlet
* spec. Instead some special purpose JSP support is required that breaks all sorts of encapsulation rules as
* the servlet container must go searching for and then parsing the descriptors for one particular framework.
* It only appears to be used by JSF, which is being developed by the same developer who implemented this
* feature in the first place!
* </bile>
*
*
* Note- this has been superceded by the new TldScanner in jasper which uses ServletContainerInitializer to
* find all the listeners in tag libs and register them.
*/
public class TagLibConfiguration extends AbstractConfiguration
{
private static final Logger LOG = Log.getLogger(TagLibConfiguration.class);
public static final String TLD_RESOURCES = "org.eclipse.jetty.tlds";
/**
* TagLibListener
*
* A listener that does the job of finding .tld files that contain
* (other) listeners that need to be called by the servlet container.
*
* This implementation is necessitated by the fact that it is only
* after all the Configuration classes have run that we will
* parse web.xml/fragments etc and thus find tlds mentioned therein.
*
* Note: TagLibConfiguration is not used in jetty-8 as jasper (JSP engine)
* uses the new TldScanner class - a ServletContainerInitializer from
* Servlet Spec 3 - to find all listeners in taglibs and register them
* with the servlet container.
*/
public class TagLibListener implements ServletContextListener {
private List<EventListener> _tldListeners;
private WebAppContext _context;
public TagLibListener (WebAppContext context) {
_context = context;
}
public void contextDestroyed(ServletContextEvent sce)
{
if (_tldListeners == null)
return;
for (int i=_tldListeners.size()-1; i>=0; i--) {
EventListener l = _tldListeners.get(i);
if (l instanceof ServletContextListener) {
((ServletContextListener)l).contextDestroyed(sce);
}
}
}
public void contextInitialized(ServletContextEvent sce)
{
try
{
//For jasper 2.1:
//Get the system classpath tlds and tell jasper about them, if jasper is on the classpath
try
{
Class clazz = getClass().getClassLoader().loadClass("org.apache.jasper.compiler.TldLocationsCache");
Collection<Resource> tld_resources = (Collection<Resource>)_context.getAttribute(TLD_RESOURCES);
Map<URI, List<String>> tldMap = new HashMap<URI, List<String>>();
if (tld_resources != null)
{
//get the jar file names of the files
for (Resource r:tld_resources)
{
Resource jarResource = extractJarResource(r);
//jasper is happy with an empty list of tlds
if (!tldMap.containsKey(jarResource.getURI()))
tldMap.put(jarResource.getURI(), null);
}
//set the magic context attribute that tells jasper about the system tlds
sce.getServletContext().setAttribute("com.sun.appserv.tld.map", tldMap);
}
}
catch (ClassNotFoundException e)
{
LOG.ignore(e);
}
//find the tld files and parse them to get out their
//listeners
Set<Resource> tlds = findTldResources();
List<TldDescriptor> descriptors = parseTlds(tlds);
processTlds(descriptors);
if (_tldListeners == null)
return;
//call the listeners that are ServletContextListeners, put the
//rest into the context's list of listeners to call at the appropriate
//moment
for (EventListener l:_tldListeners) {
if (l instanceof ServletContextListener) {
((ServletContextListener)l).contextInitialized(sce);
} else {
_context.addEventListener(l);
}
}
}
catch (Exception e) {
LOG.warn(e);
}
}
private Resource extractJarResource (Resource r)
{
if (r == null)
return null;
try
{
String url = r.getURI().toURL().toString();
int idx = url.lastIndexOf("!/");
if (idx >= 0)
url = url.substring(0, idx);
if (url.startsWith("jar:"))
url = url.substring(4);
return Resource.newResource(url);
}
catch (IOException e)
{
LOG.warn(e);
return null;
}
}
/**
* Find all the locations that can harbour tld files that may contain
* a listener which the web container is supposed to instantiate and
* call.
*
* @return
* @throws IOException
*/
private Set<Resource> findTldResources () throws IOException {
Set<Resource> tlds = new HashSet<Resource>();
// Find tld's from web.xml
// When web.xml was processed, it should have created aliases for all TLDs. So search resources aliases
// for aliases ending in tld
if (_context.getResourceAliases()!=null &&
_context.getBaseResource()!=null &&
_context.getBaseResource().exists())
{
Iterator<String> iter=_context.getResourceAliases().values().iterator();
while(iter.hasNext())
{
String location = iter.next();
if (location!=null && location.toLowerCase().endsWith(".tld"))
{
if (!location.startsWith("/"))
location="/WEB-INF/"+location;
Resource l=_context.getBaseResource().addPath(location);
tlds.add(l);
}
}
}
// Look for any tlds in WEB-INF directly.
Resource web_inf = _context.getWebInf();
if (web_inf!=null)
{
String[] contents = web_inf.list();
for (int i=0;contents!=null && i<contents.length;i++)
{
if (contents[i]!=null && contents[i].toLowerCase().endsWith(".tld"))
{
Resource l=web_inf.addPath(contents[i]);
tlds.add(l);
}
}
}
//Look for tlds in common location of WEB-INF/tlds
if (web_inf != null) {
Resource web_inf_tlds = _context.getWebInf().addPath("/tlds/");
if (web_inf_tlds.exists() && web_inf_tlds.isDirectory()) {
String[] contents = web_inf_tlds.list();
for (int i=0;contents!=null && i<contents.length;i++)
{
if (contents[i]!=null && contents[i].toLowerCase().endsWith(".tld"))
{
Resource l=web_inf_tlds.addPath(contents[i]);
tlds.add(l);
}
}
}
}
// Add in tlds found in META-INF of jars. The jars that will be scanned are controlled by
// the patterns defined in the context attributes: org.eclipse.jetty.server.webapp.ContainerIncludeJarPattern,
// and org.eclipse.jetty.server.webapp.WebInfIncludeJarPattern
@SuppressWarnings("unchecked")
Collection<Resource> tld_resources=(Collection<Resource>)_context.getAttribute(TLD_RESOURCES);
if (tld_resources!=null)
tlds.addAll(tld_resources);
return tlds;
}
/**
* Parse xml into in-memory tree
* @param tlds
* @return
*/
private List<TldDescriptor> parseTlds (Set<Resource> tlds) {
List<TldDescriptor> descriptors = new ArrayList<TldDescriptor>();
Resource tld = null;
Iterator<Resource> iter = tlds.iterator();
while (iter.hasNext())
{
try
{
tld = iter.next();
if (LOG.isDebugEnabled()) LOG.debug("TLD="+tld);
TldDescriptor d = new TldDescriptor(tld);
d.parse();
descriptors.add(d);
}
catch(Exception e)
{
LOG.warn("Unable to parse TLD: " + tld,e);
}
}
return descriptors;
}
/**
* Create listeners from the parsed tld trees
* @param descriptors
* @throws Exception
*/
private void processTlds (List<TldDescriptor> descriptors) throws Exception {
TldProcessor processor = new TldProcessor();
for (TldDescriptor d:descriptors)
processor.process(_context, d);
_tldListeners = new ArrayList<EventListener>(processor.getListeners());
}
}
/**
* TldDescriptor
*
*
*/
public static class TldDescriptor extends Descriptor
{
protected static XmlParser __parserSingleton;
public TldDescriptor(Resource xml)
{
super(xml);
}
@Override
public void ensureParser() throws ClassNotFoundException
{
if (__parserSingleton == null)
__parserSingleton = newParser();
_parser = __parserSingleton;
}
@Override
public XmlParser newParser() throws ClassNotFoundException
{
// Create a TLD parser
XmlParser parser = new XmlParser(false);
URL taglib11=null;
URL taglib12=null;
URL taglib20=null;
URL taglib21=null;
try
{
Class<?> jsp_page = Loader.loadClass(WebXmlConfiguration.class,"javax.servlet.jsp.JspPage");
taglib11=jsp_page.getResource("javax/servlet/jsp/resources/web-jsptaglibrary_1_1.dtd");
taglib12=jsp_page.getResource("javax/servlet/jsp/resources/web-jsptaglibrary_1_2.dtd");
taglib20=jsp_page.getResource("javax/servlet/jsp/resources/web-jsptaglibrary_2_0.xsd");
taglib21=jsp_page.getResource("javax/servlet/jsp/resources/web-jsptaglibrary_2_1.xsd");
}
catch(Exception e)
{
LOG.ignore(e);
}
finally
{
if(taglib11==null)
taglib11=Loader.getResource(Servlet.class,"javax/servlet/jsp/resources/web-jsptaglibrary_1_1.dtd",true);
if(taglib12==null)
taglib12=Loader.getResource(Servlet.class,"javax/servlet/jsp/resources/web-jsptaglibrary_1_2.dtd",true);
if(taglib20==null)
taglib20=Loader.getResource(Servlet.class,"javax/servlet/jsp/resources/web-jsptaglibrary_2_0.xsd",true);
if(taglib21==null)
taglib21=Loader.getResource(Servlet.class,"javax/servlet/jsp/resources/web-jsptaglibrary_2_1.xsd",true);
}
if(taglib11!=null)
{
redirect(parser, "web-jsptaglib_1_1.dtd",taglib11);
redirect(parser, "web-jsptaglibrary_1_1.dtd",taglib11);
}
if(taglib12!=null)
{
redirect(parser, "web-jsptaglib_1_2.dtd",taglib12);
redirect(parser, "web-jsptaglibrary_1_2.dtd",taglib12);
}
if(taglib20!=null)
{
redirect(parser, "web-jsptaglib_2_0.xsd",taglib20);
redirect(parser, "web-jsptaglibrary_2_0.xsd",taglib20);
}
if(taglib21!=null)
{
redirect(parser, "web-jsptaglib_2_1.xsd",taglib21);
redirect(parser, "web-jsptaglibrary_2_1.xsd",taglib21);
}
parser.setXpath("/taglib/listener/listener-class");
return parser;
}
public void parse ()
throws Exception
{
ensureParser();
try
{
//xerces on apple appears to sometimes close the zip file instead
//of the inputstream, so try opening the input stream, but if
//that doesn't work, fallback to opening a new url
_root = _parser.parse(_xml.getInputStream());
}
catch (Exception e)
{
_root = _parser.parse(_xml.getURL().toString());
}
if (_root==null)
{
LOG.warn("No TLD root in {}",_xml);
}
}
}
/**
* TldProcessor
*
* Process TldDescriptors representing tag libs to find listeners.
*/
public class TldProcessor extends IterativeDescriptorProcessor
{
public static final String TAGLIB_PROCESSOR = "org.eclipse.jetty.tagLibProcessor";
XmlParser _parser;
List<XmlParser.Node> _roots = new ArrayList<XmlParser.Node>();
List<EventListener> _listeners;
public TldProcessor ()
throws Exception
{
_listeners = new ArrayList<EventListener>();
registerVisitor("listener", this.getClass().getDeclaredMethod("visitListener", __signature));
}
public void visitListener (WebAppContext context, Descriptor descriptor, XmlParser.Node node)
{
String className=node.getString("listener-class",false,true);
if (LOG.isDebugEnabled())
LOG.debug("listener="+className);
try
{
Class<?> listenerClass = context.loadClass(className);
EventListener l = (EventListener)listenerClass.newInstance();
_listeners.add(l);
}
catch(Exception e)
{
LOG.warn("Could not instantiate listener "+className+": "+e);
LOG.debug(e);
}
catch(Error e)
{
LOG.warn("Could not instantiate listener "+className+": "+e);
LOG.debug(e);
}
}
@Override
public void end(WebAppContext context, Descriptor descriptor)
{
}
@Override
public void start(WebAppContext context, Descriptor descriptor)
{
}
public List<EventListener> getListeners() {
return _listeners;
}
}
@Override
public void preConfigure(WebAppContext context) throws Exception
{
try
{
Class<?> jsp_page = Loader.loadClass(WebXmlConfiguration.class,"javax.servlet.jsp.JspPage");
}
catch (Exception e)
{
//no jsp available, don't parse TLDs
return;
}
TagLibListener tagLibListener = new TagLibListener(context);
context.addEventListener(tagLibListener);
}
@Override
public void configure (WebAppContext context) throws Exception
{
}
@Override
public void postConfigure(WebAppContext context) throws Exception
{
}
@Override
public void cloneConfigure(WebAppContext template, WebAppContext context) throws Exception
{
}
@Override
public void deconfigure(WebAppContext context) throws Exception
{
}
}