tomcat-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From cos...@apache.org
Subject svn commit: r534293 [11/11] - in /tomcat/sandbox/tomcat-lite: ./ bin/ external/ java/ java/org/apache/commons/logging/ java/org/apache/tomcat/lite/ java/org/apache/tomcat/lite/ctxmap/ java/org/apache/tomcat/lite/http/ java/org/apache/tomcat/lite/http11...
Date Wed, 02 May 2007 02:22:50 GMT
Modified: tomcat/sandbox/tomcat-lite/java/org/apache/tomcat/util/loader/Repository.java
URL: http://svn.apache.org/viewvc/tomcat/sandbox/tomcat-lite/java/org/apache/tomcat/util/loader/Repository.java?view=diff&rev=534293&r1=534292&r2=534293
==============================================================================
--- tomcat/sandbox/tomcat-lite/java/org/apache/tomcat/util/loader/Repository.java (original)
+++ tomcat/sandbox/tomcat-lite/java/org/apache/tomcat/util/loader/Repository.java Tue May  1 19:22:45 2007
@@ -14,314 +14,220 @@
  * limitations under the License.
  */
 
-
 package org.apache.tomcat.util.loader;
 
-
 import java.io.BufferedReader;
 import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
-import java.net.MalformedURLException;
 import java.net.URL;
+import java.net.URLClassLoader;
+import java.util.ArrayList;
 import java.util.Enumeration;
-import java.util.HashMap;
 import java.util.Hashtable;
+import java.util.Iterator;
 import java.util.Map;
 import java.util.Vector;
 
-
 /**
- * A group of modules.  
- * 
- * Modules can have one or more jars and classes dirs, and are reloaded as a 
- * unit. Each module has an internal class loader.
- * 
- * The module will delegate to the associated repository in addition to the 
- * normal delegation rules. The repository will search on all sibling modules.
+ * Class loader similar with the MLetClassLoader and JBoss - it maintains a list
+ * of 'modules' ( similar with mbeans - a single jar or dir ), each of them can
+ * be reloaded independently, without reloading the whole repository.
  * 
- * This mechanism is defined in the MLetClassLoader and is also used by JBoss 
- * and few other servers.
- * 
- *  Use: 
- *   - create a Repository in all situations where you would need a separate
- *     class loader - each webapp, common/, server/, etc.
- *   - set the parent hierarchy
- *   - add modules to each repo - a module can be a single jar/classes, or 
- *     multiple jars. I think single jar modules may be better.  
- *   - get the classloader from repository 
+ * This works well as long as the interface between modules don't change - it is
+ * a bit better than hot-reloading of classes, which requires each class method
+ * signatures to be unchanged.
  * 
  * @author Costin Manolache
  */
 public class Repository {
-   
-    private static final boolean DEBUG=System.getProperty("loader.debug.Repository") != null;
-    
-    // Allows the (experimental) use of jar indexes
-    // Right now ( for small set of jars, incomplete build ) it's a tiny 3.5 -> 3.4 sec dif.
-    private static final boolean USE_IDX=System.getProperty("loader.Repository.noIndex") == null;
-    
-    private Vector loaders=new Vector();
-    private String name;
-    private Vector grpModules=new Vector();
-    //private transient Loader loader;
-    
-    private transient RepositoryClassLoader groupClassLoader;
-    private Hashtable prefixes=new Hashtable();
 
-    // For delegation
-    private ClassLoader parentClassLoader;
-    private Repository parent;
+    // Use jar indexes. Most loaders don't - it's a small optimization,
+    // but it's a good practice.
+    private static final boolean USE_IDX = true;
 
+    Vector loaders = new Vector();
 
-    public Repository() {
-    }
+    private RepositoryClassLoader groupClassLoader;
 
-    public void addModule(  Module mod ) {
-        mod.setRepository( this );
+    private ClassLoader parent;
 
-        grpModules.addElement(mod);
-        
-        if( parentClassLoader != null ) 
-            mod.setParentClassLoader( parentClassLoader );
+    // From jar index: package -> Module or Module[]
+    private Hashtable prefixes = new Hashtable();
+
+    // Collects all jars without INDEX.LIST.
+    private ArrayList missingIndexList = new ArrayList();
 
-        if(! mod.isStarted()) {
-            mod.start();
+    /**
+     * Should this class loader delegate to the parent class loader
+     * <strong>before</strong> searching its own repositories (i.e. the usual
+     * Java2 delegation model)? 
+     */
+    private boolean delegate = true;
+
+    public Repository() {
+        this(null, null, true);
+    }
+    
+    public Repository(URL[] cp, ClassLoader parent) {
+        this(cp, parent, true);
+    }
+
+    public Repository(URL[] cp, ClassLoader parent, boolean delegate) {
+        if (parent == null) {
+            parent = Thread.currentThread().getContextClassLoader();
         }
-        
-        try {
-            if( USE_IDX ) {
-                processJarIndex(mod);
-                // TODO: if we are in the initial starting, write cache only once
-                // TODO: write it only if there is a change in the timestamp
-                writeCacheIdx();
+        this.parent = parent;
+        if (cp != null) {
+            for (int i = 0; i < cp.length; i++) {
+                addURL(cp[i]);
             }
-        } catch (Exception e) {
-            // TODO Auto-generated catch block
-            e.printStackTrace();
         }
     }
-    
-    public void newModule( String path ) {
-        Module m=new Module();
-        m.setPath( path );
-        addModule( m );
-    }
-    
-    public Enumeration getModules() {
-        return grpModules.elements();
+
+    public void setParentClassLoader(ClassLoader myL) {
+        this.parent = myL;
     }
     
-    /** Reload any module that is modified
+    /**
+     * Return a class loader associated with the group. This will delegate to
+     * all modules in the group, then to parent.
      */
-    public void checkReload() {
-        try {
-        Enumeration mE=grpModules.elements();
-        while( mE.hasMoreElements() ) {
-            Module m=(Module)mE.nextElement();
-            boolean modif=m.modified();
-            log("Modified " + m + " " + modif);
-            
-            if( modif ) {
-                m.stop();
-                m.start();
+    public URLClassLoader getClassLoader() {
+        if (groupClassLoader == null) {
+            if (parent == null) {
+                groupClassLoader = new RepositoryClassLoader(new URL[0], this);
+            } else {
+                groupClassLoader = new RepositoryClassLoader(new URL[0], parent,
+                        this);
             }
         }
-        } catch( Throwable t ) {
-            t.printStackTrace();
-        }
+        return groupClassLoader;
     }
 
-    /** Verify if any module is modified. This is a deep search, including dirs.
-     *  Expensive operation.
-     *  
-     * @return
-     */
-    public boolean isModified() {
-        try {
-            Enumeration mE=grpModules.elements();
-            while( mE.hasMoreElements() ) {
-                Module m=(Module)mE.nextElement();
-                boolean modif=m.modified();
-                log("Modified " + m + " " + modif);
-                if( modif ) return true;
-            }
-        } catch( Throwable t ) {
-            t.printStackTrace();
-        }
-        return false;
+    public void addURL(URL url) {
+        ModuleClassLoader mod = new ModuleClassLoader(new URL[] { url },
+                parent, delegate, this);
+        addModuleClassLoader(mod);
     }
     
-    Repository getParent() {
-        return parent;
+    public void addURL(URL[] url) {
+        for (int i = 0; i < url.length; i++) {
+            addURL(url[i]);
+        }
     }
     
-    public String toString() {
-        return "Repository " + name + "(" + getClasspathString() + ")";
+    Enumeration getModules() {
+        return loaders.elements();
     }
-
-    public String getClasspathString() {
-        StringBuffer sb=new StringBuffer();
-        Enumeration mE=grpModules.elements();
-        while( mE.hasMoreElements() ) {
-            Module m=(Module)mE.nextElement();
-            sb.append( m.getClasspathString() + ":");
+    
+    ModuleClassLoader createClassLoader(URL[] classpath) throws Exception {
+        ModuleClassLoader classLoader = null;
+        if (parent == null) {
+            parent = Thread.currentThread().getContextClassLoader();
         }
-        return sb.toString();
+        classLoader = new ModuleClassLoader(classpath, parent,
+                delegate, this);
+
+        loaders.addElement(classLoader);
+
+        return classLoader;
     }
 
     /**
+     * Verify if any module is modified. This is a deep search, including dirs.
      * 
-     * @param parent The parent group
-     */
-    public void setParent(Repository parent) {
-        this.parent = parent;
-    }
-    
-    /** Set the parent class loader - can be used instead of setParent, 
-     * in case this is the top loader and needs to delagate to embedding app
-     * 
-     * @param myL
-     */
-    public void setParentClassLoader(ClassLoader myL) {
-        this.parentClassLoader=myL;
-    }
-
-
-    /** Add a class loder to the group.
-     *
-     *  If this is a StandardClassLoader instance, it will be able to delegate
-     * to the group.
-     *
-     *  If it's a regular ClassLoader - it'll be searched for classes, but
-     * it will not be able to delegate to peers.
-     *
-     * In future we may fine tune this by using manifests.
+     * @return
      */
-    void addClassLoader(ClassLoader cl ) {
-        if( ( cl instanceof ModuleClassLoader )) {
-            ((ModuleClassLoader)cl).setRepository(this);
+    public boolean isModified() {
+        try {
+            Enumeration mE = loaders.elements();
+            while (mE.hasMoreElements()) {
+                ModuleClassLoader m = (ModuleClassLoader) mE.nextElement();
+                boolean modif = m.modified();
+                if (modif)
+                    return true;
+            }
+        } catch (Throwable t) {
+            t.printStackTrace();
         }
-        loaders.addElement(cl);
-        //    log("Adding classloader " + cl);
-    }
-
-    public String getName() {
-        return name;
+        return false;
     }
 
-    public void removeClassLoader(ClassLoader cl) {
-        int oldSize=loaders.size();
-        loaders.removeElement(cl);
-
-        if(DEBUG) log("removed " + loaders.size() + "/" + oldSize + ": "  + cl);
-        // TODO: remove from index
+    public String toString() {
+        return "Repository " + "(" + getClasspathString() + ")";
     }
 
-    /** Return a class loader associated with the group.
-     *  This will delegate to all modules in the group, then to parent.
-     * 
-     * @return
-     */
-    public ClassLoader getClassLoader() {
-        if( groupClassLoader==null ) {
-            
-            ClassLoader pcl=parentClassLoader;
-            if( pcl==null && parent!=null ) {
-                pcl=parent.getClassLoader();
-            } 
-            if( pcl==null ) {
-                pcl=Thread.currentThread().getContextClassLoader();
-             }
-
-            if( pcl == null ) {
-                // allow delegation to embedding app
-                groupClassLoader=new RepositoryClassLoader(new URL[0], this);
-            } else {
-                groupClassLoader=new RepositoryClassLoader(new URL[0], pcl, this);
+    public String getClasspathString() {
+        StringBuffer sb = new StringBuffer();
+        Enumeration mE = loaders.elements();
+        while (mE.hasMoreElements()) {
+            ModuleClassLoader m = (ModuleClassLoader) mE.nextElement();
+            URL[] urls = m.getURLs();
+            for (int i = 0; i < urls.length; i++) {
+                sb.append(urls[i].getFile()).append(":");
             }
-            if( DEBUG ) log("---------- Created repository loader " + pcl );
         }
-        return groupClassLoader;
+        return sb.toString();
     }
 
-    public void addDir(File directory) {
-        try {
-            URL url=directory.toURL();
-            Module mod = new Module();
-            mod.setClasspath(new URL[] {url});
-            addModule(mod);
-        } catch (MalformedURLException e) {
-            e.printStackTrace();
-        }
 
-    }
-    
-    public void addLibs(File directory) {
-        if (!directory.isDirectory() || !directory.exists() ||
-                !directory.canRead()) {
-            if (DEBUG)
-                log("  Not found:  "+ directory.getAbsolutePath());
-            return;
-        }
-        String filenames[] = directory.list();
-        for (int j = 0; j < filenames.length; j++) {
-            String filename = filenames[j].toLowerCase();
-            if (!filename.endsWith(".jar"))
-                continue;
-            File file = new File(directory, filenames[j]);
-            try {
-                URL url=file.toURL();
-                Module mod = new Module();
-                mod.setClasspath(new URL[] {url});
-                addModule(mod);
-            } catch (MalformedURLException e) {
-                e.printStackTrace();
+
+    void addModuleClassLoader(ModuleClassLoader mod) {
+        loaders.addElement(mod);
+        try {
+            if (USE_IDX) {
+                processJarIndex(mod);
             }
+        } catch (Exception e) {
+            // TODO Auto-generated catch block
+            e.printStackTrace();
         }
     }
-    
-    /** 
-     * Find a class in the group. It'll iterate over each loader
-     * and try to find the class - using only the method that
-     * search locally or on parent ( i.e. not in group, to avoid
-     * recursivity ).
-     *
-     *
+
+    /**
+     * Find a class in the group. It'll iterate over each loader and try to find
+     * the class - using only the method that search locally or on parent ( i.e.
+     * not in group, to avoid recursivity ).
+     * 
+     * 
      * @param classN
      * @return
      */
-    Class findClass(ClassLoader caller, String classN ) {
-        Class clazz=null;
-        
+    Class findClass(ClassLoader caller, String classN) {
+        Class clazz = null;
+
         // do we have it in index ?
-        if( USE_IDX ) {
-            int lastIdx=classN.lastIndexOf(".");
-            String prefix=(lastIdx>0) ? classN.substring(0, lastIdx) : classN;
-            Object mO=prefixes.get(prefix.replace('.', '/'));
-            if( mO!=null ) {
-                if( mO instanceof Module ) {
-                    Module m=(Module)mO;
+        if (USE_IDX) {
+            int lastIdx = classN.lastIndexOf(".");
+            String prefix = (lastIdx > 0) ? classN.substring(0, lastIdx)
+                    : classN;
+            Object mO = prefixes.get(prefix.replace('.', '/'));
+            if (mO != null) {
+                if (mO instanceof ModuleClassLoader) {
+                    ModuleClassLoader m = (ModuleClassLoader) mO;
                     try {
-                        Class c=((ModuleClassLoader)m.getClassLoader()).findLocalClass(classN);
-                        //log("Prefix: " +prefix + " " + classN  + " " + m);
+                        Class c = m.findLocalClass(classN);
+                        // log("Prefix: " +prefix + " " + classN + " " + m);
                         return c;
                     } catch (Exception e) {
-                        //log("Prefix err: " +prefix + " " + classN  + " " + m + " " + e);
-                        //return null;
+                        // log("Prefix err: " +prefix + " " + classN + " " + m +
+                        // " " + e);
+                        // return null;
                     }
                 } else {
-                    Module mA[]=(Module[])mO;
-                    for( int i=0; i<mA.length; i++ ) {
-                        Module m=mA[i];
+                    ModuleClassLoader mA[] = (ModuleClassLoader[]) mO;
+                    for (int i = 0; i < mA.length; i++) {
+                        ModuleClassLoader m = mA[i];
                         try {
-                            Class c=((ModuleClassLoader)m.getClassLoader()).findLocalClass(classN);
-                            //log("Prefix: " +prefix + " " + classN  + " " + m);
+                            Class c = m.findLocalClass(classN);
+                            // log("Prefix: " +prefix + " " + classN + " " + m);
                             return c;
                         } catch (Exception e) {
-                            //log("Prefix err: " +prefix + " " + classN  + " " + m + " " + e);
-                            //return null;
+                            // log("Prefix err: " +prefix + " " + classN + " " +
+                            // m + " " + e);
+                            // return null;
                         }
                     }
                 }
@@ -329,185 +235,592 @@
         }
 
         // TODO: move the vector to a []
-        for( int i=loaders.size()-1; i>=0; i-- ) {
-            
+        for (int i = loaders.size() - 1; i >= 0; i--) {
+
             // TODO: for regular CL, just use loadClass, they'll not recurse
-            // The behavior for non-SCL or not in the group loader is the same as for parent loader
-            ModuleClassLoader cl=(ModuleClassLoader)loaders.elementAt(i);
+            // The behavior for non-SCL or not in the group loader is the same
+            // as for
+            // parent loader
+            ModuleClassLoader cl = (ModuleClassLoader) loaders.elementAt(i);
             // TODO: move loaders with index in separate vector
-            //if( cl.getModule().hasIndex ) continue;
-            if( cl== caller ) continue;
-            //if( classN.indexOf("SmtpCoyoteProtocolHandler") > 0 ) {
-            //log("try " + cl.debugObj + " " + name + " " + classN + " " + loaders.size());
-            //}
+            // if( cl.getModule().hasIndex ) continue;
+            if (cl == caller)
+                continue;
+            // if( classN.indexOf("SmtpCoyoteProtocolHandler") > 0 ) {
+            // log("try " + cl.debugObj + " " + name + " " + classN + " " +
+            // loaders.size());
+            // }
             try {
-                if( cl instanceof ModuleClassLoader ) {
-                    clazz=((ModuleClassLoader)cl).findLocalClass(classN );
+                if (cl instanceof ModuleClassLoader) {
+                    clazz = ((ModuleClassLoader) cl).findLocalClass(classN);
                 } else {
-                    clazz=cl.findClass(classN);
+                    clazz = cl.findClass(classN);
                 }
 
-                //System.err.println("GRPLD: " + classN + " from " + info.get(cl));
+                // System.err.println("GRPLD: " + classN + " from " +
+                // info.get(cl));
                 return clazz;
             } catch (ClassNotFoundException e) {
-                //System.err.println("CNF: " + classN + " " + info.get(cl) );
-                //if( classN.indexOf("smtp") > 0 ) e.printStackTrace();
+                // System.err.println("CNF: " + classN + " " + info.get(cl) );
+                // if( classN.indexOf("smtp") > 0 ) e.printStackTrace();
             }
         }
         return null;
     }
-    
+
     /**
      * @param loader
      * @param name2
      * @return
      */
     URL findResource(ModuleClassLoader caller, String classN) {
-        URL url=null;
-        if( DEBUG ) log("Repository.findResource " + classN + " " + caller );
-        for( int i=loaders.size()-1; i>=0; i-- ) {
+        URL url = null;
+        for (int i = loaders.size() - 1; i >= 0; i--) {
             // TODO: for regular CL, just use loadClass, they'll not recurse
-            // The behavior for non-SCL or not in the group loader is the same as for parent loader
-            ModuleClassLoader cl=(ModuleClassLoader)loaders.elementAt(i);
-            if( cl== caller ) continue;
-            url=((ModuleClassLoader)cl).findResource(classN );
-            if( url!=null )
+            // The behavior for non-SCL or not in the group loader is the same
+            // as for
+            // parent loader
+            ModuleClassLoader cl = (ModuleClassLoader) loaders.elementAt(i);
+            if (cl == caller)
+                continue;
+            url = ((ModuleClassLoader) cl).findResource(classN);
+            if (url != null)
                 return url;
         }
         return null;
     }
 
-    private void log(String s) {
-        System.err.println("Repository (" + name + "): " + s );
+    public Class findClass(String name) throws ClassNotFoundException {
+        Enumeration modulesE = getModules();
+        while (modulesE.hasMoreElements()) {
+            try {
+                ModuleClassLoader m = (ModuleClassLoader) modulesE
+                        .nextElement();
+                return m.findClass2(name, false);
+            } catch (ClassNotFoundException ex) {
+                // ignore
+            }
+        }
+        throw new ClassNotFoundException(name);
+    }
+
+    public URL findResource(final String name) {
+        URL url = null;
+        Enumeration modulesE = getModules();
+        while (modulesE.hasMoreElements()) {
+            ModuleClassLoader m = (ModuleClassLoader) modulesE.nextElement();
+            url = m.findResource2(name, false);
+            if (url != null) {
+                return url;
+            }
+        }
+        return null;
+    }
+
+    public Enumeration findResources(String name) throws IOException {
+        Vector result = new Vector();
+
+        Enumeration modulesE = getModules();
+        while (modulesE.hasMoreElements()) {
+            ModuleClassLoader m = (ModuleClassLoader) modulesE.nextElement();
+            Enumeration myRes = m.findResources2(name, false);
+            if (myRes != null) {
+                while (myRes.hasMoreElements()) {
+                    result.addElement(myRes.nextElement());
+                }
+            }
+        }
+
+        return result.elements();
+    }
+
+    public URL getResource(String name) {
+
+        URL url = null;
+        Enumeration modulesE = getModules();
+        while (modulesE.hasMoreElements()) {
+            ModuleClassLoader m = (ModuleClassLoader) modulesE.nextElement();
+            url = m.getResource2(name, null, false);
+            if (url != null) {
+                return url;
+            }
+        }
+
+        return null;
+    }
+
+    public Class loadClass(String name, boolean resolve)
+            throws ClassNotFoundException {
+
+        Enumeration modulesE = getModules();
+        while (modulesE.hasMoreElements()) {
+            try {
+                ModuleClassLoader m = (ModuleClassLoader) modulesE
+                        .nextElement();
+                return m.loadClass2(name, resolve, false);
+            } catch (ClassNotFoundException ex) {
+                // ignore
+            }
+        }
+
+        throw new ClassNotFoundException(name);
     }
 
+
     /**
-     * @param name2
+     * Reload any module that is modified
      */
-    public void setName(String name2) {
-        this.name=name2;
+    public void checkReload() {
+        try {
+            Enumeration mE = loaders.elements();
+            ArrayList toReload = null;
+            while (mE.hasMoreElements()) {
+                ModuleClassLoader m = (ModuleClassLoader) mE.nextElement();
+                boolean modif = m.modified();
+                if (modif) {
+                    toReload = new ArrayList();
+                    toReload.add(m);
+                }
+            }
+            Iterator reloadIt = toReload.iterator();
+            while (reloadIt.hasNext()) {
+                ModuleClassLoader m = (ModuleClassLoader) reloadIt.next();
+                URL[] cp = m.getURLs();
+                loaders.removeElement(m);
+                missingIndexList.remove(m);
+                if (prefixes.containsValue(m)) {
+                    ArrayList toRemove = new ArrayList();
+                    Iterator prefI = prefixes.entrySet().iterator();
+                    while (prefI.hasNext()) {
+                        Map.Entry entry = (Map.Entry) prefI.next();
+                        if (entry.getValue() == m) {
+                            toRemove.add(entry.getKey());
+                        }
+                    }
+                    prefI = toRemove.iterator();
+                    while (prefI.hasNext()) {
+                        prefixes.remove(prefI.next());
+                    }
+                }
+
+                m = createClassLoader(cp);
+                loaders.addElement(m);
+            }
+
+        } catch (Throwable t) {
+            t.printStackTrace();
+        }
     }
 
-    // Collects all jars without INDEX.LIST. Can be used for debugging.
-    public static Map missingIndexList = new HashMap();
-    
-    /*
-     * Work in progress: 
-     * 
-     * -use the INDEX.LIST to get prefixes to avoid linear
-     * search in repositories.
-     * 
-     * - serialize the state ( including timestamps ) to improve startup time
-     * ( avoids the need to open all jars - if INDEX.LIST is ok)
-     */
-    
+
     /**
      * Read the index. The index contain packages and top level resources
      * 
      * @param cl
      * @throws Exception
      */
-    private void processJarIndex(Module m) throws Exception {
-        ModuleClassLoader cl=(ModuleClassLoader)m.createClassLoader();
-        // only support index for modules with a single jar in CP
-        String cp=m.getClasspathString();
-        if( ! cp.endsWith(".jar")) return;
-        URL urlIdx=cl.findResource("META-INF/INDEX.LIST");
-        if( urlIdx == null ) {
-            missingIndexList.put(cp, "1");
+    private void processJarIndex(ModuleClassLoader cl) throws Exception {
+        String cp = cl.getURLs()[0].toString();
+        if (!cp.endsWith(".jar")) {
+            missingIndexList.add(cl);
+            return;
+        }
+
+        // ModuleClassLoader cl = (ModuleClassLoader) m.createClassLoader();
+        URL urlIdx = cl.findResource("META-INF/INDEX.LIST");
+        if (urlIdx == null) {
+            missingIndexList.add(cl);
             return;
         }
+
         try {
-            InputStream is=urlIdx.openStream();
-            if( is==null ) {
-                log("Can't read " + urlIdx + " " + m.getClasspathString());
+            InputStream is = urlIdx.openStream();
+            if (is == null) {
+                missingIndexList.add(cl);
+                return;
+            }
+            BufferedReader br = new BufferedReader(new InputStreamReader(is));
+            String line = br.readLine();
+            if (line == null) {
+                missingIndexList.add(cl);
                 return;
             }
-            BufferedReader br=new BufferedReader( new InputStreamReader(is) );
-            String line=br.readLine();
-            if( line==null ) return;
-            if( ! line.startsWith( "JarIndex-Version:") ||  
-                    ! line.endsWith("1.0")) {
-                log("Invalid signature " + line + " " + m.getClasspathString());
+            if (!line.startsWith("JarIndex-Version:") || !line.endsWith("1.0")) {
+                missingIndexList.add(cl);
+                return;
             }
             br.readLine(); // ""
-            
-            while( readSection(br, m) ) {
+            while (readSection(br, cl)) {
             }
-           
-            m.hasIndex=true;
         } catch (IOException e) {
-            // TODO Auto-generated catch block
-            e.printStackTrace();
+            missingIndexList.add(cl);
         }
     }
-    
-    private boolean readSection( BufferedReader br, Module m) throws IOException {
-        String jarName=br.readLine();
-        if( jarName==null ) return false; // done
-        if( "".equals( jarName )) {
-            log("Invalid jarName " + jarName + " " + m.getClasspathString() );
-            return false;
-        }
-        //log("Index " + jarName + " " + m.getClasspathString());
-        String prefix=null;
-        while( ((prefix=br.readLine()) != null ) && 
-                (! "".equals( prefix )) ) {
-            //log("found " + prefix + " " + m);
-            Object o=prefixes.get(prefix);
-            if( o == null ) {
+
+    private boolean readSection(BufferedReader br, ModuleClassLoader m)
+            throws IOException {
+        String jarName = br.readLine();
+        if (jarName == null)
+            return false; // done
+        if ("".equals(jarName)) {
+            throw new IOException("Invalid jarName " + jarName);
+        }
+
+        String prefix = null;
+        while (((prefix = br.readLine()) != null) && (!"".equals(prefix))) {
+            Object o = prefixes.get(prefix);
+            if (o == null) {
+                // Common case
                 prefixes.put(prefix, m);
             } else {
-                Module mA[]=null;
-                if( o instanceof Module ) {
-                    mA=new Module[2];
-                    mA[0]=(Module)o;
-                    mA[1]=m;
+                ModuleClassLoader mA[] = null;
+                if (o instanceof ModuleClassLoader) {
+                    mA = new ModuleClassLoader[2];
+                    mA[0] = (ModuleClassLoader) o;
+                    mA[1] = m;
                 } else {
-                    Object oldA[]=(Module[])o;
-                    mA=new Module[oldA.length + 1];
+                    Object oldA[] = (ModuleClassLoader[]) o;
+                    mA = new ModuleClassLoader[oldA.length + 1];
                     System.arraycopy(oldA, 0, mA, 0, oldA.length);
-                    mA[oldA.length]=m;
+                    mA[oldA.length] = m;
                 }
-                prefixes.put( prefix, mA);
-                //log("Multiple prefixes: " + prefix + " " + mA);
-                
+                prefixes.put(prefix, mA);
             }
         }
-        
-        return prefix!=null;
+        return prefix != null;
     }
 
-
-    /** Read loader.REPO.cache from work dir
-     * 
-     * This file will hold timestamps for each module/jar and cache the INDEX -
-     * to avoid opening the jars/modules that are not used 
-     * 
-     * @throws IOException
-     */
-    private void readCachedIdx() throws IOException {
-        
-    }
-    
-    /** Check the index and verify that:
-     * - all jars are older than timestamp and still exist
-     * - there are no new jars 
+    /**
+     * Class loader associated with a repository.
      * 
-     * @throws IOException
+     * This class loader will never load any class by itself it will just
+     * delegate to modules.
      */
-    private void checkCacheIdx() throws IOException {
-        
-    }
-    
-    
-    private void writeCacheIdx() throws IOException {
-        // For each module we write the timestamp, filename then the index
-        // The idea is to load this single file to avoid scanning many jars
+    static class RepositoryClassLoader extends URLClassLoader {
 
-        // we'll use the cache 
-        
+        private Repository repository;
+
+        public RepositoryClassLoader(URL repositories[], ClassLoader parent,
+                Repository lg) {
+            super(repositories, parent);
+            this.repository = lg;
+        }
+
+        public RepositoryClassLoader(URL repositories[], Repository lg) {
+            super(repositories);
+            this.repository = lg;
+        }
         
+        public void addURL(URL url) {
+            repository.addURL(url);
+        }
+
+        public Class findClass(String name) throws ClassNotFoundException {
+            return repository.findClass(name);
+        }
+
+        public URL findResource(final String name) {
+            return repository.findResource(name);
+        }
+
+        public Enumeration findResources(String name) throws IOException {
+            return repository.findResources(name);
+        }
+
+        public URL getResource(String name) {
+            return repository.getResource(name);
+        }
+
+        public Class loadClass(String name, boolean resolve)
+                throws ClassNotFoundException {
+            return repository.loadClass(name, resolve);
+        }
     }
 
+    static class ModuleClassLoader extends URLClassLoader {
+        public ModuleClassLoader(URL repositories[], ClassLoader parent,
+                boolean delegate, Repository lg) {
+            super(repositories, parent);
+            this.delegate = delegate;
+            this.repository = lg;
+            lastModified = System.currentTimeMillis();
+        }
+
+        protected long lastModified = 0L;
+
+        protected Repository repository;
+
+        protected boolean delegate = false;
+
+        // ---------------------------------------------------- ClassLoader
+        // Methods
+
+        public Class findClass(String name) throws ClassNotFoundException {
+            return findClass2(name, true);
+        }
+
+        public Class findClass2(String name, boolean del2repo)
+                throws ClassNotFoundException {
+            if (del2repo) {
+                return repository.findClass(name);
+            }
+            Class clazz = super.findClass(name);
+            // if( clazz.getClassLoader() != this )
+            // log("findClass() FOUND " + clazz + " Loaded by " +
+            // clazz.getClassLoader());
+            return (clazz);
+        }
+
+        /**
+         * Same as findClass, but also checks if the class has been previously
+         * loaded.
+         * 
+         * In most implementations, findClass() doesn't check with
+         * findLoadedClass(). In order to implement repository, we need to ask
+         * each loader in the group to load only from it's local resources -
+         * however this will lead to errors ( duplicated definition ) if
+         * findClass() is used.
+         */
+        public Class findLocalClass(String name) throws ClassNotFoundException {
+            Class clazz = findLoadedClass(name);
+            if (clazz != null) {
+                return (clazz);
+            }
+            return findClass(name);
+        }
+
+        public URL findResource(final String name) {
+            return findResource2(name, true);
+        }
+
+        public URL findResource2(final String name, boolean del2repo) {
+            if (del2repo) {
+                return repository.findResource(name);
+            }
+            return super.findResource(name);
+        }
+
+        public Enumeration findResources(String name) throws IOException {
+            return findResources2(name, true);
+        }
+
+        Enumeration findResources2(String name, boolean del2repo)
+                throws IOException {
+            if (del2repo) {
+                return repository.findResources(name);
+            }
+            return super.findResources(name);
+        }
+
+        public URL getResource(String name) {
+            return getResource2(name, null, true);
+        }
+
+        /**
+         * getResource() - same thing, but don't delegate to repo if called from
+         * repo
+         */
+        URL getResource2(String name, ClassLoader originator,
+                         boolean delegate2repo) {
+
+            URL url = null;
+
+            // (1) Delegate to parent if requested
+            if (delegate) {
+                url = getResourceParentDelegate(name);
+                if (url != null)
+                    return url;
+            }
+
+            // (2) Search local repositories
+            url = findResource(name);
+            if (url != null) {
+                // TODO: antijar locking - WebappClassLoader is making
+                // a copy ( is it ??)
+                // log("getResource() found locally " + delegate + " " +
+                // name + " " + url);
+                return (url);
+            }
+
+            // (3) load from one of the classes in the group
+            if (delegate2repo && repository != null) {
+                url = repository.findResource(this, name);
+                if (url != null) {
+                    // log("getResource() FOUND from group " +
+                    // repository.getName()
+                    // + " " + name + " " + url);
+                    return url;
+                }
+            }
+
+            // (4) Delegate to parent unconditionally if not already attempted
+            if (!delegate) {
+                url = getResourceParentDelegate(name);
+                if (url != null)
+                    return url;
+            }
+
+            // (5) Resource was not found
+            return (null);
+
+        }
+
+        // TODO: repository should handle this !
+        // to avoid duplication - get resource from parent, when delegating
+        private URL getResourceParentDelegate(String name) {
+            URL url = null;
+            ClassLoader loader = getParent();
+
+            if (loader == null) {
+                loader = getSystemClassLoader();
+            }
+            url = loader.getResource(name);
+            if (url != null) {
+                // log("getResource() found by system " + delegate + " " +
+                // name + " " + url);
+                return (url);
+            }
+            return url;
+        }
+
+        public Class loadClass(String name, boolean resolve)
+                throws ClassNotFoundException {
+            return loadClass2(name, resolve, true);
+        }
+
+        public Class loadClass2(String name, boolean resolve, boolean del2repo)
+                throws ClassNotFoundException {
+
+            Class clazz = null;
+
+            // (0) Check our previously loaded local class cache
+            clazz = findLoadedClass(name);
+            if (clazz != null) {
+                if (resolve)
+                    resolveClass(clazz);
+                return (clazz);
+            }
+
+            // (1) Try loading the class with the system class loader, to
+            // prevent
+            // the webapp from overriding J2SE classes
+            try {
+                clazz = getSystemClassLoader().loadClass(name);
+                if (clazz != null) {
+                    if (resolve)
+                        resolveClass(clazz);
+                    return (clazz);
+                }
+            } catch (ClassNotFoundException e) {
+            }
+
+            // TODO: delegate based on filter
+            boolean delegateLoad = delegate;// || filter(name);
+
+            // (1) Delegate to our parent if requested
+            if (delegateLoad) {
+                ClassLoader loader = getParent();
+                if (loader != null) {
+                    try {
+                        clazz = loader.loadClass(name);
+                        if (clazz != null) {
+                            // log("loadClass() FOUND by parent " + delegate + "
+                            // "
+                            // + name + " , " + resolve);
+                            if (resolve)
+                                resolveClass(clazz);
+                            return (clazz);
+                        }
+                    } catch (ClassNotFoundException e) {
+                    }
+                }
+            }
+
+            // (2) Search local repositories
+            try {
+                clazz = findClass(name);
+                if (clazz != null) {
+                    // log("loadClass - FOUND findClass " + delegate + " " +
+                    // name + " , " + resolve);
+                    if (resolve)
+                        resolveClass(clazz);
+                    return (clazz);
+                }
+            } catch (ClassNotFoundException e) {
+            }
+
+            // (3) Other peer loaders
+            if (del2repo && repository != null) {
+                Class cls = repository.findClass(this, name);
+                if (cls != null) {
+                    // log("loadClass(): FOUND from group " +
+                    // repository.getName()
+                    // + " " + name);
+                    if (resolve)
+                        resolveClass(clazz);
+                    return cls;
+                }
+            }
+
+            // (4) Delegate to parent unconditionally
+            if (!delegateLoad) {
+                ClassLoader loader = getParent();
+                if (loader != null) {
+                    try {
+                        clazz = loader.loadClass(name);
+                        if (clazz != null) {
+                            // log("loadClass() FOUND parent " + delegate + " "
+                            // +
+                            // name + " , " + resolve);
+                            if (resolve)
+                                resolveClass(clazz);
+                            return (clazz);
+                        }
+                    } catch (ClassNotFoundException e) {
+                        ;
+                    }
+                }
+            }
+            throw new ClassNotFoundException(name);
+        }
+
+        /**
+         * Have one or more classes or resources been modified so that a reload
+         * is appropriate?
+         */
+        boolean modified() {
+            URL cp[] = getURLs();
+            if (cp != null) {
+                for (int i = 0; i < cp.length; i++) {
+                    // assume dirs are used only for debug and small
+                    File f = new File(cp[i].getFile());
+                    if (f.isDirectory()) {
+                        return null != dirCheck(f, 10);
+                    } else {
+                        long lm = f.lastModified();
+                        if (lm > lastModified) {
+                            return true;
+                        }
+                    }
+                }
+            }
+
+            return (false);
+        }
+
+        private File dirCheck(File dir, int level) {
+            File subd[] = dir.listFiles();
+            for (int i = 0; i < subd.length; i++) {
+                if (subd[i].isDirectory() && level > 0) {
+                    return dirCheck(subd[i], level - 1);
+                } else {
+                    long lm = subd[i].lastModified();
+                    if (lm > lastModified) {
+                        return subd[i];
+                    }
+                }
+            }
+            return null;
+        }
+    }
 }

Added: tomcat/sandbox/tomcat-lite/java/org/apache/tomcat/util/res/StringManager.java
URL: http://svn.apache.org/viewvc/tomcat/sandbox/tomcat-lite/java/org/apache/tomcat/util/res/StringManager.java?view=auto&rev=534293
==============================================================================
--- tomcat/sandbox/tomcat-lite/java/org/apache/tomcat/util/res/StringManager.java (added)
+++ tomcat/sandbox/tomcat-lite/java/org/apache/tomcat/util/res/StringManager.java Tue May  1 19:22:45 2007
@@ -0,0 +1,283 @@
+/*
+ *  Copyright 1999-2004 The Apache Software Foundation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package org.apache.tomcat.util.res;
+
+import java.text.MessageFormat;
+import java.util.Hashtable;
+import java.util.Locale;
+import java.util.MissingResourceException;
+import java.util.ResourceBundle;
+
+/**
+ * An internationalization / localization helper class which reduces
+ * the bother of handling ResourceBundles and takes care of the
+ * common cases of message formating which otherwise require the
+ * creation of Object arrays and such.
+ *
+ * <p>The StringManager operates on a package basis. One StringManager
+ * per package can be created and accessed via the getManager method
+ * call.
+ *
+ * <p>The StringManager will look for a ResourceBundle named by
+ * the package name given plus the suffix of "LocalStrings". In
+ * practice, this means that the localized information will be contained
+ * in a LocalStrings.properties file located in the package
+ * directory of the classpath.
+ *
+ * <p>Please see the documentation for java.util.ResourceBundle for
+ * more information.
+ *
+ * @author James Duncan Davidson [duncan@eng.sun.com]
+ * @author James Todd [gonzo@eng.sun.com]
+ * @author Mel Martinez [mmartinez@g1440.com]
+ * @see java.util.ResourceBundle
+ */
+
+public class StringManager {
+
+    /**
+     * The ResourceBundle for this StringManager.
+     */
+
+    private ResourceBundle bundle;
+    private Locale locale;
+
+    /**
+     * Creates a new StringManager for a given package. This is a
+     * private method and all access to it is arbitrated by the
+     * static getManager method call so that only one StringManager
+     * per package will be created.
+     *
+     * @param packageName Name of package to create StringManager for.
+     */
+
+    private StringManager(String packageName) {
+	this( packageName, Locale.getDefault() );
+    }
+
+    private StringManager(String packageName, Locale loc) {
+        String bundleName = packageName + ".LocalStrings";
+        bundle = ResourceBundle.getBundle(bundleName, loc);
+        // Get the actual locale, which may be different from the requested one
+        locale = bundle.getLocale();
+    }
+
+    private StringManager(ResourceBundle bundle )
+    {
+	this.bundle=bundle;
+        locale = bundle.getLocale();
+    }
+
+    /**
+        Get a string from the underlying resource bundle or return
+        null if the String is not found.
+     
+        @param key to desired resource String
+        @return resource String matching <i>key</i> from underlying
+                bundle or null if not found.
+        @throws IllegalArgumentException if <i>key</i> is null.        
+     */
+
+    public String getString(String key) {
+        if(key == null){
+            String msg = "key may not have a null value";
+
+            throw new IllegalArgumentException(msg);
+        }
+
+        String str = null;
+
+        try{
+	        str = bundle.getString(key);
+        }catch(MissingResourceException mre){
+            //bad: shouldn't mask an exception the following way:
+            //   str = "[cannot find message associated with key '" + key + "' due to " + mre + "]";
+	        //     because it hides the fact that the String was missing
+	        //     from the calling code.
+	        //good: could just throw the exception (or wrap it in another)
+	        //      but that would probably cause much havoc on existing
+	        //      code.
+	        //better: consistent with container pattern to
+	        //      simply return null.  Calling code can then do
+	        //      a null check.
+	        str = null;
+        }
+
+        return str;
+    }
+
+    /**
+     * Get a string from the underlying resource bundle and format
+     * it with the given set of arguments.
+     *
+     * @param key
+     * @param args
+     */
+
+    public String getString(String key, Object[] args) {
+        String iString = null;
+        String value = getString(key);
+
+        // this check for the runtime exception is some pre 1.1.6
+        // VM's don't do an automatic toString() on the passed in
+        // objects and barf out
+
+        try {
+            // ensure the arguments are not null so pre 1.2 VM's don't barf
+            if(args==null){
+                args = new Object[1];
+            }
+            
+            Object[] nonNullArgs = args;
+            for (int i=0; i<args.length; i++) {
+                if (args[i] == null) {
+                    if (nonNullArgs==args){
+                        nonNullArgs=(Object[])args.clone();
+                    }
+                    nonNullArgs[i] = "null";
+                }
+            }
+            if( value==null ) value=key;
+	    MessageFormat mf = new MessageFormat(value);
+            mf.setLocale(locale);
+            iString = mf.format(nonNullArgs, new StringBuffer(), null).toString();
+        } catch (IllegalArgumentException iae) {
+            StringBuffer buf = new StringBuffer();
+            buf.append(value);
+            for (int i = 0; i < args.length; i++) {
+                buf.append(" arg[" + i + "]=" + args[i]);
+            }
+            iString = buf.toString();
+        }
+        return iString;
+    }
+
+    /**
+     * Get a string from the underlying resource bundle and format it
+     * with the given object argument. This argument can of course be
+     * a String object.
+     *
+     * @param key
+     * @param arg
+     */
+
+    public String getString(String key, Object arg) {
+	Object[] args = new Object[] {arg};
+	return getString(key, args);
+    }
+
+    /**
+     * Get a string from the underlying resource bundle and format it
+     * with the given object arguments. These arguments can of course
+     * be String objects.
+     *
+     * @param key
+     * @param arg1
+     * @param arg2
+     */
+
+    public String getString(String key, Object arg1, Object arg2) {
+	Object[] args = new Object[] {arg1, arg2};
+	return getString(key, args);
+    }
+    
+    /**
+     * Get a string from the underlying resource bundle and format it
+     * with the given object arguments. These arguments can of course
+     * be String objects.
+     *
+     * @param key
+     * @param arg1
+     * @param arg2
+     * @param arg3
+     */
+
+    public String getString(String key, Object arg1, Object arg2,
+			    Object arg3) {
+	Object[] args = new Object[] {arg1, arg2, arg3};
+	return getString(key, args);
+    }
+
+    /**
+     * Get a string from the underlying resource bundle and format it
+     * with the given object arguments. These arguments can of course
+     * be String objects.
+     *
+     * @param key
+     * @param arg1
+     * @param arg2
+     * @param arg3
+     * @param arg4
+     */
+
+    public String getString(String key, Object arg1, Object arg2,
+			    Object arg3, Object arg4) {
+	Object[] args = new Object[] {arg1, arg2, arg3, arg4};
+	return getString(key, args);
+    }
+    // --------------------------------------------------------------
+    // STATIC SUPPORT METHODS
+    // --------------------------------------------------------------
+
+    private static Hashtable managers = new Hashtable();
+
+    /**
+     * Get the StringManager for a particular package. If a manager for
+     * a package already exists, it will be reused, else a new
+     * StringManager will be created and returned.
+     *
+     * @param packageName The package name
+     */
+    public synchronized static StringManager getManager(String packageName) {
+      StringManager mgr = (StringManager)managers.get(packageName);
+      if (mgr == null) {
+          mgr = new StringManager(packageName);
+          managers.put(packageName, mgr);
+      }
+      return mgr;
+    }
+
+    /**
+     * Get the StringManager for a particular package. If a manager for
+     * a package already exists, it will be reused, else a new
+     * StringManager will be created and returned.
+     *
+     * @param bundle The resource bundle
+     */
+    public synchronized static StringManager getManager(ResourceBundle bundle) {
+      return new StringManager( bundle );
+    }
+
+    /**
+     * Get the StringManager for a particular package and Locale. If a manager for
+     * a package already exists, it will be reused, else a new
+     * StringManager will be created for that Locale and returned.
+     *
+     * @param packageName The package name
+     * @param loc The locale
+     */
+
+   public synchronized static StringManager getManager(String packageName,Locale loc) {
+      StringManager mgr = (StringManager)managers.get(packageName+"_"+loc.toString());
+      if (mgr == null) {
+          mgr = new StringManager(packageName,loc);
+          managers.put(packageName+"_"+loc.toString(), mgr);
+      }
+      return mgr;
+    }
+
+}



---------------------------------------------------------------------
To unsubscribe, e-mail: dev-unsubscribe@tomcat.apache.org
For additional commands, e-mail: dev-help@tomcat.apache.org


Mime
View raw message