Save This Page
Home » Tomcat-6.0.20 » org.apache » catalina » startup » [javadoc | source]
    1   /*
    2    * Licensed to the Apache Software Foundation (ASF) under one or more
    3    * contributor license agreements.  See the NOTICE file distributed with
    4    * this work for additional information regarding copyright ownership.
    5    * The ASF licenses this file to You under the Apache License, Version 2.0
    6    * (the "License"); you may not use this file except in compliance with
    7    * the License.  You may obtain a copy of the License at
    8    * 
    9    *      http://www.apache.org/licenses/LICENSE-2.0
   10    * 
   11    * Unless required by applicable law or agreed to in writing, software
   12    * distributed under the License is distributed on an "AS IS" BASIS,
   13    * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   14    * See the License for the specific language governing permissions and
   15    * limitations under the License.
   16    */
   17   
   18   
   19   package org.apache.catalina.startup;
   20   
   21   
   22   import java.io.File;
   23   import java.io.FileInputStream;
   24   import java.io.FileOutputStream;
   25   import java.io.IOException;
   26   import java.io.InputStream;
   27   import java.io.ObjectInputStream;
   28   import java.io.ObjectOutputStream;
   29   import java.net.URISyntaxException;
   30   import java.net.URL;
   31   import java.net.URLClassLoader;
   32   import java.util.ArrayList;
   33   import java.util.Enumeration;
   34   import java.util.HashMap;
   35   import java.util.HashSet;
   36   import java.util.Iterator;
   37   import java.util.Map;
   38   import java.util.Set;
   39   import java.util.StringTokenizer;
   40   import java.util.jar.JarEntry;
   41   import java.util.jar.JarFile;
   42   
   43   import javax.naming.NameClassPair;
   44   import javax.naming.NamingEnumeration;
   45   import javax.naming.NamingException;
   46   import javax.naming.directory.DirContext;
   47   import javax.servlet.ServletException;
   48   
   49   import org.apache.catalina.Context;
   50   import org.apache.catalina.Globals;
   51   import org.apache.catalina.Lifecycle;
   52   import org.apache.catalina.LifecycleEvent;
   53   import org.apache.catalina.LifecycleListener;
   54   import org.apache.catalina.core.StandardContext;
   55   import org.apache.catalina.core.StandardHost;
   56   import org.apache.catalina.util.StringManager;
   57   import org.apache.tomcat.util.digester.Digester;
   58   import org.xml.sax.InputSource;
   59   
   60   /**
   61    * Startup event listener for a <b>Context</b> that configures application
   62    * listeners configured in any TLD files.
   63    *
   64    * @author Craig R. McClanahan
   65    * @author Jean-Francois Arcand
   66    * @author Costin Manolache
   67    */
   68   public final class TldConfig  implements LifecycleListener {
   69   
   70       // Names of JARs that are known not to contain any TLDs
   71       private static HashSet<String> noTldJars;
   72   
   73       private static org.apache.juli.logging.Log log=
   74           org.apache.juli.logging.LogFactory.getLog( TldConfig.class );
   75   
   76       /*
   77        * Initializes the set of JARs that are known not to contain any TLDs
   78        */
   79       static {
   80           noTldJars = new HashSet<String>();
   81           // Bootstrap JARs
   82           noTldJars.add("bootstrap.jar");
   83           noTldJars.add("commons-daemon.jar");
   84           noTldJars.add("tomcat-juli.jar");
   85           // Main JARs
   86           noTldJars.add("annotations-api.jar");
   87           noTldJars.add("catalina.jar");
   88           noTldJars.add("catalina-ant.jar");
   89           noTldJars.add("catalina-ha.jar");
   90           noTldJars.add("catalina-tribes.jar");
   91           noTldJars.add("el-api.jar");
   92           noTldJars.add("jasper.jar");
   93           noTldJars.add("jasper-el.jar");
   94           noTldJars.add("jasper-jdt.jar");
   95           noTldJars.add("jsp-api.jar");
   96           noTldJars.add("servlet-api.jar");
   97           noTldJars.add("tomcat-coyote.jar");
   98           noTldJars.add("tomcat-dbcp.jar");
   99           // i18n JARs
  100           noTldJars.add("tomcat-i18n-en.jar");
  101           noTldJars.add("tomcat-i18n-es.jar");
  102           noTldJars.add("tomcat-i18n-fr.jar");
  103           noTldJars.add("tomcat-i18n-ja.jar");
  104           // Misc JARs not included with Tomcat
  105           noTldJars.add("ant.jar");
  106           noTldJars.add("commons-dbcp.jar");
  107           noTldJars.add("commons-beanutils.jar");
  108           noTldJars.add("commons-fileupload-1.0.jar");
  109           noTldJars.add("commons-pool.jar");
  110           noTldJars.add("commons-digester.jar");
  111           noTldJars.add("commons-logging.jar");
  112           noTldJars.add("commons-collections.jar");
  113           noTldJars.add("jmx.jar");
  114           noTldJars.add("jmx-tools.jar");
  115           noTldJars.add("xercesImpl.jar");
  116           noTldJars.add("xmlParserAPIs.jar");
  117           noTldJars.add("xml-apis.jar");
  118           // JARs from J2SE runtime
  119           noTldJars.add("sunjce_provider.jar");
  120           noTldJars.add("ldapsec.jar");
  121           noTldJars.add("localedata.jar");
  122           noTldJars.add("dnsns.jar");
  123           noTldJars.add("tools.jar");
  124           noTldJars.add("sunpkcs11.jar");
  125       }
  126   
  127   
  128       // ----------------------------------------------------- Instance Variables
  129   
  130       /**
  131        * The Context we are associated with.
  132        */
  133       private Context context = null;
  134   
  135   
  136       /**
  137        * The string resources for this package.
  138        */
  139       private static final StringManager sm =
  140           StringManager.getManager(Constants.Package);
  141   
  142       /**
  143        * The <code>Digester</code> we will use to process tag library
  144        * descriptor files.
  145        */
  146       private static Digester tldDigester = null;
  147   
  148   
  149       /**
  150        * Attribute value used to turn on/off TLD validation
  151        */
  152        private static boolean tldValidation = false;
  153   
  154   
  155       /**
  156        * Attribute value used to turn on/off TLD  namespace awarenes.
  157        */
  158       private static boolean tldNamespaceAware = false;
  159   
  160       private boolean rescan=true;
  161   
  162       private ArrayList<String> listeners = new ArrayList<String>();
  163   
  164       // --------------------------------------------------------- Public Methods
  165   
  166       /**
  167        * Sets the list of JARs that are known not to contain any TLDs.
  168        *
  169        * @param jarNames List of comma-separated names of JAR files that are 
  170        * known not to contain any TLDs 
  171        */
  172       public static void setNoTldJars(String jarNames) {
  173           if (jarNames != null) {
  174               noTldJars.clear();
  175               StringTokenizer tokenizer = new StringTokenizer(jarNames, ",");
  176               while (tokenizer.hasMoreElements()) {
  177                   noTldJars.add(tokenizer.nextToken());
  178               }
  179           }
  180       }
  181   
  182       /**
  183        * Set the validation feature of the XML parser used when
  184        * parsing xml instances.
  185        * @param tldValidation true to enable xml instance validation
  186        */
  187       public void setTldValidation(boolean tldValidation){
  188           TldConfig.tldValidation = tldValidation;
  189       }
  190   
  191       /**
  192        * Get the server.xml <host> attribute's xmlValidation.
  193        * @return true if validation is enabled.
  194        *
  195        */
  196       public boolean getTldValidation(){
  197           return tldValidation;
  198       }
  199   
  200       /**
  201        * Get the server.xml <host> attribute's xmlNamespaceAware.
  202        * @return true if namespace awarenes is enabled.
  203        *
  204        */
  205       public boolean getTldNamespaceAware(){
  206           return tldNamespaceAware;
  207       }
  208   
  209   
  210       /**
  211        * Set the namespace aware feature of the XML parser used when
  212        * parsing xml instances.
  213        * @param tldNamespaceAware true to enable namespace awareness
  214        */
  215       public void setTldNamespaceAware(boolean tldNamespaceAware){
  216           TldConfig.tldNamespaceAware = tldNamespaceAware;
  217       }    
  218   
  219   
  220       public boolean isRescan() {
  221           return rescan;
  222       }
  223   
  224       public void setRescan(boolean rescan) {
  225           this.rescan = rescan;
  226       }
  227   
  228       public Context getContext() {
  229           return context;
  230       }
  231   
  232       public void setContext(Context context) {
  233           this.context = context;
  234       }
  235   
  236       public void addApplicationListener( String s ) {
  237           //if(log.isDebugEnabled())
  238               log.debug( "Add tld listener " + s);
  239           listeners.add(s);
  240       }
  241   
  242       public String[] getTldListeners() {
  243           String result[]=new String[listeners.size()];
  244           listeners.toArray(result);
  245           return result;
  246       }
  247   
  248   
  249       /**
  250        * Scan for and configure all tag library descriptors found in this
  251        * web application.
  252        *
  253        * @exception Exception if a fatal input/output or parsing error occurs
  254        */
  255       public void execute() throws Exception {
  256           long t1=System.currentTimeMillis();
  257   
  258           File tldCache=null;
  259   
  260           if (context instanceof StandardContext) {
  261               File workDir= (File)
  262                   ((StandardContext)context).getServletContext().getAttribute(Globals.WORK_DIR_ATTR);
  263               //tldCache=new File( workDir, "tldCache.ser");
  264           }
  265   
  266           // Option to not rescan
  267           if( ! rescan ) {
  268               // find the cache
  269               if( tldCache!= null && tldCache.exists()) {
  270                   // just read it...
  271                   processCache(tldCache);
  272                   return;
  273               }
  274           }
  275   
  276           /*
  277            * Acquire the list of TLD resource paths, possibly embedded in JAR
  278            * files, to be processed
  279            */
  280           Set resourcePaths = tldScanResourcePaths();
  281           Map jarPaths = getJarPaths();
  282   
  283           // Check to see if we can use cached listeners
  284           if (tldCache != null && tldCache.exists()) {
  285               long lastModified = getLastModified(resourcePaths, jarPaths);
  286               if (lastModified < tldCache.lastModified()) {
  287                   processCache(tldCache);
  288                   return;
  289               }
  290           }
  291   
  292           // Scan each accumulated resource path for TLDs to be processed
  293           Iterator paths = resourcePaths.iterator();
  294           while (paths.hasNext()) {
  295               String path = (String) paths.next();
  296               if (path.endsWith(".jar")) {
  297                   tldScanJar(path);
  298               } else {
  299                   tldScanTld(path);
  300               }
  301           }
  302           if (jarPaths != null) {
  303               paths = jarPaths.values().iterator();
  304               while (paths.hasNext()) {
  305                   tldScanJar((File) paths.next());
  306               }
  307           }
  308   
  309           String list[] = getTldListeners();
  310   
  311           if( tldCache!= null ) {
  312               log.debug( "Saving tld cache: " + tldCache + " " + list.length);
  313               try {
  314                   FileOutputStream out=new FileOutputStream(tldCache);
  315                   ObjectOutputStream oos=new ObjectOutputStream( out );
  316                   oos.writeObject( list );
  317                   oos.close();
  318               } catch( IOException ex ) {
  319                   ex.printStackTrace();
  320               }
  321           }
  322   
  323           if( log.isDebugEnabled() )
  324               log.debug( "Adding tld listeners:" + list.length);
  325           for( int i=0; list!=null && i<list.length; i++ ) {
  326               context.addApplicationListener(list[i]);
  327           }
  328   
  329           long t2=System.currentTimeMillis();
  330           if( context instanceof StandardContext ) {
  331               ((StandardContext)context).setTldScanTime(t2-t1);
  332           }
  333   
  334       }
  335   
  336       // -------------------------------------------------------- Private Methods
  337   
  338       /*
  339        * Returns the last modification date of the given sets of resources.
  340        *
  341        * @param resourcePaths
  342        * @param jarPaths
  343        *
  344        * @return Last modification date
  345        */
  346       private long getLastModified(Set resourcePaths, Map jarPaths)
  347               throws Exception {
  348   
  349           long lastModified = 0;
  350   
  351           Iterator paths = resourcePaths.iterator();
  352           while (paths.hasNext()) {
  353               String path = (String) paths.next();
  354               URL url = context.getServletContext().getResource(path);
  355               if (url == null) {
  356                   log.debug( "Null url "+ path );
  357                   break;
  358               }
  359               long lastM = url.openConnection().getLastModified();
  360               if (lastM > lastModified) lastModified = lastM;
  361               if (log.isDebugEnabled()) {
  362                   log.debug( "Last modified " + path + " " + lastM);
  363               }
  364           }
  365   
  366           if (jarPaths != null) {
  367               paths = jarPaths.values().iterator();
  368               while (paths.hasNext()) {
  369                   File jarFile = (File) paths.next();
  370                   long lastM = jarFile.lastModified();
  371                   if (lastM > lastModified) lastModified = lastM;
  372                   if (log.isDebugEnabled()) {
  373                       log.debug("Last modified " + jarFile.getAbsolutePath()
  374                                 + " " + lastM);
  375                   }
  376               }
  377           }
  378   
  379           return lastModified;
  380       }
  381   
  382       private void processCache(File tldCache ) throws IOException {
  383           // read the cache and return;
  384           try {
  385               FileInputStream in=new FileInputStream(tldCache);
  386               ObjectInputStream ois=new ObjectInputStream( in );
  387               String list[]=(String [])ois.readObject();
  388               if( log.isDebugEnabled() )
  389                   log.debug("Reusing tldCache " + tldCache + " " + list.length);
  390               for( int i=0; list!=null && i<list.length; i++ ) {
  391                   context.addApplicationListener(list[i]);
  392               }
  393               ois.close();
  394           } catch( ClassNotFoundException ex ) {
  395               ex.printStackTrace();
  396           }
  397       }
  398   
  399       /**
  400        * Scan the JAR file at the specified resource path for TLDs in the
  401        * <code>META-INF</code> subdirectory, and scan each TLD for application
  402        * event listeners that need to be registered.
  403        *
  404        * @param resourcePath Resource path of the JAR file to scan
  405        *
  406        * @exception Exception if an exception occurs while scanning this JAR
  407        */
  408       private void tldScanJar(String resourcePath) throws Exception {
  409   
  410           if (log.isDebugEnabled()) {
  411               log.debug(" Scanning JAR at resource path '" + resourcePath + "'");
  412           }
  413   
  414           URL url = context.getServletContext().getResource(resourcePath);
  415           if (url == null) {
  416               throw new IllegalArgumentException
  417                                   (sm.getString("contextConfig.tldResourcePath",
  418                                                 resourcePath));
  419           }
  420   
  421           File file = null;
  422           try {
  423               file = new File(url.toURI());
  424           } catch (URISyntaxException e) {
  425               // Ignore, probably an unencoded char
  426               file = new File(url.getFile());
  427           }
  428           try {
  429               file = file.getCanonicalFile();
  430           } catch (IOException e) {
  431               // Ignore
  432           }
  433           tldScanJar(file);
  434   
  435       }
  436   
  437       /**
  438        * Scans all TLD entries in the given JAR for application listeners.
  439        *
  440        * @param file JAR file whose TLD entries are scanned for application
  441        * listeners
  442        */
  443       private void tldScanJar(File file) throws Exception {
  444   
  445           JarFile jarFile = null;
  446           String name = null;
  447   
  448           String jarPath = file.getAbsolutePath();
  449   
  450           try {
  451               jarFile = new JarFile(file);
  452               Enumeration entries = jarFile.entries();
  453               while (entries.hasMoreElements()) {
  454                   JarEntry entry = (JarEntry) entries.nextElement();
  455                   name = entry.getName();
  456                   if (!name.startsWith("META-INF/")) {
  457                       continue;
  458                   }
  459                   if (!name.endsWith(".tld")) {
  460                       continue;
  461                   }
  462                   if (log.isTraceEnabled()) {
  463                       log.trace("  Processing TLD at '" + name + "'");
  464                   }
  465                   try {
  466                       tldScanStream(new InputSource(jarFile.getInputStream(entry)));
  467                   } catch (Exception e) {
  468                       log.error(sm.getString("contextConfig.tldEntryException",
  469                                              name, jarPath, context.getPath()),
  470                                 e);
  471                   }
  472               }
  473           } catch (Exception e) {
  474               log.error(sm.getString("contextConfig.tldJarException",
  475                                      jarPath, context.getPath()),
  476                         e);
  477           } finally {
  478               if (jarFile != null) {
  479                   try {
  480                       jarFile.close();
  481                   } catch (Throwable t) {
  482                       // Ignore
  483                   }
  484               }
  485           }
  486       }
  487   
  488       /**
  489        * Scan the TLD contents in the specified input stream, and register
  490        * any application event listeners found there.  <b>NOTE</b> - It is
  491        * the responsibility of the caller to close the InputStream after this
  492        * method returns.
  493        *
  494        * @param resourceStream InputStream containing a tag library descriptor
  495        *
  496        * @exception Exception if an exception occurs while scanning this TLD
  497        */
  498       private void tldScanStream(InputSource resourceStream)
  499           throws Exception {
  500   
  501           synchronized (tldDigester) {
  502               try {
  503                   tldDigester.push(this);
  504                   tldDigester.parse(resourceStream);
  505               } finally {
  506                   tldDigester.reset();
  507               }
  508           }
  509   
  510       }
  511   
  512       /**
  513        * Scan the TLD contents at the specified resource path, and register
  514        * any application event listeners found there.
  515        *
  516        * @param resourcePath Resource path being scanned
  517        *
  518        * @exception Exception if an exception occurs while scanning this TLD
  519        */
  520       private void tldScanTld(String resourcePath) throws Exception {
  521   
  522           if (log.isDebugEnabled()) {
  523               log.debug(" Scanning TLD at resource path '" + resourcePath + "'");
  524           }
  525   
  526           InputSource inputSource = null;
  527           try {
  528               InputStream stream =
  529                   context.getServletContext().getResourceAsStream(resourcePath);
  530               if (stream == null) {
  531                   throw new IllegalArgumentException
  532                   (sm.getString("contextConfig.tldResourcePath",
  533                           resourcePath));
  534               }
  535               inputSource = new InputSource(stream);
  536               if (inputSource == null) {
  537                   throw new IllegalArgumentException
  538                       (sm.getString("contextConfig.tldResourcePath",
  539                                     resourcePath));
  540               }
  541               tldScanStream(inputSource);
  542           } catch (Exception e) {
  543                throw new ServletException
  544                    (sm.getString("contextConfig.tldFileException", resourcePath,
  545                                  context.getPath()),
  546                     e);
  547           } 
  548   
  549       }
  550   
  551       /**
  552        * Accumulate and return a Set of resource paths to be analyzed for
  553        * tag library descriptors.  Each element of the returned set will be
  554        * the context-relative path to either a tag library descriptor file,
  555        * or to a JAR file that may contain tag library descriptors in its
  556        * <code>META-INF</code> subdirectory.
  557        *
  558        * @exception IOException if an input/output error occurs while
  559        *  accumulating the list of resource paths
  560        */
  561       private Set tldScanResourcePaths() throws IOException {
  562           if (log.isDebugEnabled()) {
  563               log.debug(" Accumulating TLD resource paths");
  564           }
  565           Set resourcePaths = new HashSet();
  566   
  567           // Accumulate resource paths explicitly listed in the web application
  568           // deployment descriptor
  569           if (log.isTraceEnabled()) {
  570               log.trace("  Scanning <taglib> elements in web.xml");
  571           }
  572           String taglibs[] = context.findTaglibs();
  573           for (int i = 0; i < taglibs.length; i++) {
  574               String resourcePath = context.findTaglib(taglibs[i]);
  575               // FIXME - Servlet 2.4 DTD implies that the location MUST be
  576               // a context-relative path starting with '/'?
  577               if (!resourcePath.startsWith("/")) {
  578                   resourcePath = "/WEB-INF/" + resourcePath;
  579               }
  580               if (log.isTraceEnabled()) {
  581                   log.trace("   Adding path '" + resourcePath +
  582                       "' for URI '" + taglibs[i] + "'");
  583               }
  584               resourcePaths.add(resourcePath);
  585           }
  586   
  587           DirContext resources = context.getResources();
  588           if (resources != null) {
  589               tldScanResourcePathsWebInf(resources, "/WEB-INF", resourcePaths);
  590           }
  591   
  592           // Return the completed set
  593           return (resourcePaths);
  594   
  595       }
  596   
  597       /*
  598        * Scans the web application's subdirectory identified by rootPath,
  599        * along with its subdirectories, for TLDs.
  600        *
  601        * Initially, rootPath equals /WEB-INF. The /WEB-INF/classes and
  602        * /WEB-INF/lib subdirectories are excluded from the search, as per the
  603        * JSP 2.0 spec.
  604        *
  605        * @param resources The web application's resources
  606        * @param rootPath The path whose subdirectories are to be searched for
  607        * TLDs
  608        * @param tldPaths The set of TLD resource paths to add to
  609        */
  610       private void tldScanResourcePathsWebInf(DirContext resources,
  611                                               String rootPath,
  612                                               Set tldPaths) 
  613               throws IOException {
  614   
  615           if (log.isTraceEnabled()) {
  616               log.trace("  Scanning TLDs in " + rootPath + " subdirectory");
  617           }
  618   
  619           try {
  620               NamingEnumeration items = resources.list(rootPath);
  621               while (items.hasMoreElements()) {
  622                   NameClassPair item = (NameClassPair) items.nextElement();
  623                   String resourcePath = rootPath + "/" + item.getName();
  624                   if (!resourcePath.endsWith(".tld")
  625                           && (resourcePath.startsWith("/WEB-INF/classes")
  626                               || resourcePath.startsWith("/WEB-INF/lib"))) {
  627                       continue;
  628                   }
  629                   if (resourcePath.endsWith(".tld")) {
  630                       if (log.isTraceEnabled()) {
  631                           log.trace("   Adding path '" + resourcePath + "'");
  632                       }
  633                       tldPaths.add(resourcePath);
  634                   } else {
  635                       tldScanResourcePathsWebInf(resources, resourcePath,
  636                                                  tldPaths);
  637                   }
  638               }
  639           } catch (NamingException e) {
  640               ; // Silent catch: it's valid that no /WEB-INF directory exists
  641           }
  642       }
  643   
  644       /**
  645        * Returns a map of the paths to all JAR files that are accessible to the
  646        * webapp and will be scanned for TLDs.
  647        *
  648        * The map always includes all the JARs under WEB-INF/lib, as well as
  649        * shared JARs in the classloader delegation chain of the webapp's
  650        * classloader.
  651        *
  652        * The latter constitutes a Tomcat-specific extension to the TLD search
  653        * order defined in the JSP spec. It allows tag libraries packaged as JAR
  654        * files to be shared by web applications by simply dropping them in a 
  655        * location that all web applications have access to (e.g.,
  656        * <CATALINA_HOME>/common/lib).
  657        *
  658        * The set of shared JARs to be scanned for TLDs is narrowed down by
  659        * the <tt>noTldJars</tt> class variable, which contains the names of JARs
  660        * that are known not to contain any TLDs.
  661        *
  662        * @return Map of JAR file paths
  663        */
  664       private Map getJarPaths() {
  665   
  666           HashMap jarPathMap = null;
  667   
  668           ClassLoader webappLoader = Thread.currentThread().getContextClassLoader();
  669           ClassLoader loader = webappLoader;
  670           while (loader != null) {
  671               if (loader instanceof URLClassLoader) {
  672                   URL[] urls = ((URLClassLoader) loader).getURLs();
  673                   for (int i=0; i<urls.length; i++) {
  674                       // Expect file URLs, these are %xx encoded or not depending
  675                       // on the class loader
  676                       // This is definitely not as clean as using JAR URLs either
  677                       // over file or the custom jndi handler, but a lot less
  678                       // buggy overall
  679                       
  680                       // Check that the URL is using file protocol, else ignore it
  681                       if (!"file".equals(urls[i].getProtocol())) {
  682                           continue;
  683                       }
  684                       
  685                       File file = null;
  686                       try {
  687                           file = new File(urls[i].toURI());
  688                       } catch (URISyntaxException e) {
  689                           // Ignore, probably an unencoded char
  690                           file = new File(urls[i].getFile());
  691                       }
  692                       try {
  693                           file = file.getCanonicalFile();
  694                       } catch (IOException e) {
  695                           // Ignore
  696                       }
  697                       if (!file.exists()) {
  698                           continue;
  699                       }
  700                       String path = file.getAbsolutePath();
  701                       if (!path.endsWith(".jar")) {
  702                           continue;
  703                       }
  704                       /*
  705                        * Scan all JARs from WEB-INF/lib, plus any shared JARs
  706                        * that are not known not to contain any TLDs
  707                        */
  708                       if (loader == webappLoader
  709                               || noTldJars == null
  710                               || !noTldJars.contains(file.getName())) {
  711                           if (jarPathMap == null) {
  712                               jarPathMap = new HashMap();
  713                               jarPathMap.put(path, file);
  714                           } else if (!jarPathMap.containsKey(path)) {
  715                               jarPathMap.put(path, file);
  716                           }
  717                       }
  718                   }
  719               }
  720               loader = loader.getParent();
  721           }
  722   
  723           return jarPathMap;
  724       }
  725   
  726       public void lifecycleEvent(LifecycleEvent event) {
  727           // Identify the context we are associated with
  728           try {
  729               context = (Context) event.getLifecycle();
  730           } catch (ClassCastException e) {
  731               log.error(sm.getString("tldConfig.cce", event.getLifecycle()), e);
  732               return;
  733           }
  734           
  735           if (event.getType().equals(Lifecycle.INIT_EVENT)) {
  736               init();
  737           } else if (event.getType().equals(Lifecycle.START_EVENT)) {
  738               try {
  739                   execute();
  740               } catch (Exception e) {
  741                   log.error(sm.getString(
  742                           "tldConfig.execute", context.getPath()), e);
  743               }
  744           } // Ignore the other event types - nothing to do 
  745       }
  746       
  747       private void init() {
  748           if (tldDigester == null){
  749               // (1)  check if the attribute has been defined
  750               //      on the context element.
  751               setTldValidation(context.getTldValidation());
  752               setTldNamespaceAware(context.getTldNamespaceAware());
  753       
  754               // (2) if the attribute wasn't defined on the context
  755               //     try the host.
  756               if (!tldValidation) {
  757                 setTldValidation(
  758                         ((StandardHost) context.getParent()).getXmlValidation());
  759               }
  760       
  761               if (!tldNamespaceAware) {
  762                 setTldNamespaceAware(
  763                         ((StandardHost) context.getParent()).getXmlNamespaceAware());
  764               }
  765   
  766               tldDigester = DigesterFactory.newDigester(tldValidation, 
  767                       tldNamespaceAware, 
  768                       new TldRuleSet());
  769               tldDigester.getParser();
  770           }
  771       }
  772   }

Save This Page
Home » Tomcat-6.0.20 » org.apache » catalina » startup » [javadoc | source]