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

Save This Page
Home » apache-tomcat-6.0.16-src » org.apache » catalina » startup » [javadoc | source]