Attachment #11842 for bug #30971

This Bugzilla instance is a read-only archive of historic NetBeans bug reports. To report a bug in NetBeans please follow the project's instructions for reporting issues.

View | Details | Raw Unified | Return to bug 30971
Collapse All | Expand All




OpenIDE-Module-Localizing-Bundle: org/netbeans/core/Bundle.properties
OpenIDE-Module-Layer: org/netbeans/core/resources/mf-layer.xml
OpenIDE-Module-Provides: org.openide.modules.InstalledFileLocator
Covered-Packages: org.netbeans.beaninfo,org.netbeans.beaninfo.editors,
 org.netbeans.beaninfo.editors.resources,org.netbeans.core,
 org.netbeans.core.actions,org.netbeans.core.awt,
 org.netbeans.core.filesystems,
 org.netbeans.core.modules,org.netbeans.core.perftool,
 org.netbeans.core.projects,org.netbeans.core.projects.cache,
 org.netbeans.core.resources,org.netbeans.core.resources.actions,
 org.netbeans.core.resources.frames,org.netbeans.core.resources.welcome,
 org.netbeans.core.resources.windowmanager,org.netbeans.core.ui,
 org.netbeans.core.windows,org.netbeans.core.windows.dnd,
 org.netbeans.core.windows.frames,org.netbeans.core.windows.layers,
 org.netbeans.core.windows.nodes,org.netbeans.core.windows.toolbars,
 org.netbeans.core.windows.util,org.netbeans.core.xml,
 META-INF,META-INF.services





import java.util.*;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.jar.JarEntry;

/**
 * A ProxyClassLoader capable of loading classes from a set of jar files

    /** Creates new JarClassLoader.
     * Gives transitive flag as true.
     */
    public JarClassLoader (List files, ProxyClassLoader[] parents) {
        this(files, parents, true);
    }
    

     * @since org.netbeans.core/1 > 1.6
     * @see ProxyClassLoader#ProxyClassLoader(ClassLoader[],boolean)
     */
    public JarClassLoader(List files, ProxyClassLoader[] parents, boolean transitive) {
        super(parents, getCoveredPackages(files), transitive);

        sources = new Source[files.size()];
        try {

        return val;
    }

    protected Class doLoadClass(String name) {
//    protected Class simpleFindClass(String name, String path, String pkgnameSlashes) {
        String path = name.replace('.', '/').concat(".class"); // NOI18N

        // look up the Sources and return a class based on their content
        for( int i=0; i<sources.length; i++ ) {
            Source src = sources[i];

            // to have the same Package object, proper sealing check, etc.; so be safe,
            // overhead is probably small (check in parents, nope, check super which
            // delegates to system loaders).
            Package pkg = getPackageFast(pkgName, true);
            if (pkg != null) {
                // XXX full sealing check, URLClassLoader does something more
                if (pkg.isSealed() && !pkg.isSealed(src.getURL())) throw new SecurityException("sealing violation"); // NOI18N

        } 
        return null;
    }
    
    // look up the jars and return a resource based on a content of jars
    protected URL findResource(String name) {
        for( int i=0; i<sources.length; i++ ) {

     * Should help reloading modules with changed resources.
     */
    public void destroy() {
//        super.destroy();
        for (int i = 0; i < sources.length; i++) {
            if (sources[i] instanceof JarSource) {
                JarFile j = ((JarSource)sources[i]).getJarFile();

    
    static void notify (int x, Throwable t) {
        t.printStackTrace();
    }
    
static long sum = 0;

    private static Iterator getCoveredPackages(List files) {
long time = System.currentTimeMillis();
        Set known = new HashSet();
        for (Iterator it = files.iterator(); it.hasNext();) {
            JarFile act = (JarFile)it.next();
	    Manifest m = null;
	    try {
	        m = act.getManifest();
	    } catch (IOException io) {
io.printStackTrace();
	    }
	    if (m != null) {
		Attributes attr = m.getMainAttributes();
		String pack = attr.getValue("Covered-Packages");
		if (pack != null) {
//System.err.println("pack=" + pack);
		    Enumeration en = new StringTokenizer(pack,",");
		    while (en.hasMoreElements()) {
			String str = (String)en.nextElement();
//System.err.println("Adding package '" + str + "'");
			known.add(str);
		    }
		    continue;
		}
	    }
            Enumeration en = act.entries();
            while (en.hasMoreElements()) {
                JarEntry je = (JarEntry)en.nextElement();
                if (! je.isDirectory()) {
                    String itm = je.getName();
                    int slash=itm.lastIndexOf('/');
                    String pkg = itm.substring(0, slash).replace('/','.');
                    known.add(pkg);
                }
            }
        }
time = System.currentTimeMillis()-time;
sum += time;
System.err.println("Scanned packages took " + time + "ms, total=" + sum + "ms");
        return known.iterator();
    }
}

Lines 76-84 Link Here

(-)bootstrap/src/org/netbeans/Main.java (-4 / +6 lines)
76	}	76	}
77		77
78	// XXX separate openide.jar and core*.jar into different classloaders	78	// XXX separate openide.jar and core*.jar into different classloaders
79	ClassLoader loader = new BootClassLoader(list, new ClassLoader[] {	79	ClassLoader loader = new BootClassLoader(list, new ProxyClassLoader[0]
80	Main.class.getClassLoader()	80	// {
81	});	81	// Main.class.getClassLoader()
		82	// }
		83	);
82		84
83	String className = System.getProperty(	85	String className = System.getProperty(
84	"netbeans.mainclass", "org.netbeans.core.Main" // NOI18N	86	"netbeans.mainclass", "org.netbeans.core.Main" // NOI18N
Lines 119-125 Link Here
119	}	121	}
120		122
121	private static final class BootClassLoader extends JarClassLoader {	123	private static final class BootClassLoader extends JarClassLoader {
122	public BootClassLoader(List cp, ClassLoader[] parents) {	124	public BootClassLoader(List cp, ProxyClassLoader[] parents) {
123	super(cp, parents);	125	super(cp, parents);
124	}	126	}
125	/** Startup optimalization. See issue 27226. */	127	/** Startup optimalization. See issue 27226. */




 * http://www.sun.com/
 * 
 * The Original Code is NetBeans. The Initial Developer of the Original
 * Code is Sun Microsystems, Inc. Portions Copyright 1997-2002 Sun
 * Microsystems, Inc. All Rights Reserved.
 */


import java.security.PrivilegedAction;

/**
 * A special class loader optimized for working in the enviroment
 * of a deeply nested classloader hierarchy. It uses shared knowledge
 * about package population to direct the loading request directly
 * to the correct classloader.
 * It itself doesn't load classes or resources, but allows subclasses
 * to add such functionality.
 *
 * @author  Petr Nejedly
 */
public class ProxyClassLoader extends ClassLoader {
//XXX - add destroy() which will clean system-wide mapping cache
    private static final Enumeration EMPTY = new ArrayEnumeration (new Object[0]);
    
    private static ClassLoader systemCL = ClassLoader.getSystemClassLoader();
     * All known package owners.
     * Packages are given in format <samp>org/netbeans/modules/foo/</samp>.
     * Of type <code>Map&lt;String,ClassLoader&gt;</code>.
     */
    private final Map domainsByPackage = new HashMap(); 
    /** All known packages, of type <code>Map&lt;String,Package&gt;</code> */
    private final Map packages = new HashMap();

    /** All parents of this classloader, including their parents recursively */
    private ClassLoader[] parents;

    /** if true, we have been destroyed */
    private boolean dead = false;
    
    private final boolean transitive;
    
    /** Create a multi-parented classloader.
     * Loads recursively from parents.
     * @param parents list of parent classloaders. 
     * @throws IllegalArgumentException if there are any nulls or duplicate
     * parent loaders or cycles.
     */
    public ProxyClassLoader( ClassLoader[] parents ) {
        this(parents, true);
    }
    
    /** Create a multi-parented classloader.
     * @param parents list of parent classloaders. 
     * @param transitive whether other PCLs depending on this one will
     *                   automatically search through its parent list
     * @throws IllegalArgumentException if there are any nulls or duplicate
     * parent loaders or cycles.
     * @since org.netbeans.core/1 > 1.6
     */
    public ProxyClassLoader(ClassLoader[] parents, boolean transitive) {
        if (parents.length == 0) {
            throw new IllegalArgumentException ("ProxyClassLoader must have a parent"); // NOI18N
        }
        
        this.transitive = transitive;
        
        Set check = new HashSet(Arrays.asList(parents)); // Set<ClassLoader>
        if (check.size() < parents.length) throw new IllegalArgumentException("duplicate parents"); // NOI18N
        if (check.contains(null)) throw new IllegalArgumentException("null parent in " + check); // NOI18N

    /** A Map<String,Set<ClassLoader>> of all packages known by all classloaders */
    private static Map packageCoverage = new HashMap();
    
    private boolean transitive;
    private Set parentSet = new HashSet();
    private ProxyClassLoader[] parents;
    private Map packages = new HashMap();
    
    private static Map sclPackages = new HashMap(); 
    
    /**
     * @param parents all direct parents of this classloader, except system one.
     * @param coveredPackages Enumeration of Strings if format "org.something"
     *   containing all packages to be covered by this classloader.
     */
    public ProxyClassLoader(ProxyClassLoader[] parents, Iterator coveredPackages, boolean transitive) {
	this.transitive = transitive;
	
	this.parents = coalesceParents(parents);
	parentSet.addAll(Arrays.asList(this.parents));
//System.err.println("Covered packages:");    
	while (coveredPackages.hasNext()) {
	    String pkg = (String)coveredPackages.next();
//System.err.println("  '" + pkg  +"'");
	    Set delegates = (Set)packageCoverage.get(pkg);
	    if (delegates == null) {
		delegates = new HashSet();
		packageCoverage.put(pkg, delegates);
	    }
	    delegates.add(this);
	}
    }
    
        // this is used only by system classloader, maybe we can redesign it a bit
    // to live without this functionality, then destroy may also go away
    /** Add new parents dynamically.
     * @param parents the new parents to add (append to list)
     * @throws IllegalArgumentException in case of a null or cyclic parent (duplicate OK)
     */
    public synchronized void append(ProxyClassLoader[] nueparents) throws IllegalArgumentException {
        // XXX should this be synchronized?
        if (nueparents == null) throw new IllegalArgumentException("null parents array"); // NOI18N
        for (int i = 0; i < nueparents.length; i++) {
            if (nueparents[i] == null) throw new IllegalArgumentException("null parent"); // NOI18N
        }
        
        this.parents = coalesceAppend(parents, nueparents);
        parentSet.clear();
	parentSet.addAll(Arrays.asList(this.parents));
    }

    
//\\    
    /** Try to destroy this classloader.
     * Subsequent attempts to use it will log an error (at most one though).
     */

     * Loads the class with the specified name.  The implementation of
     * this method searches for classes in the following order:<p>
     * <ol>
     * <li> Looks for a known package and pass the loading to the ClassLoader
            for that package.
     * <li> For unknown packages passes the call directly
     *      already been loaded.
     * <li> Checks the caches whether another class from the same package
     *      was already loaded and uses the same classloader
     * <li> Tries to find the class using parent loaders in their order.
     * <li> Calls the {@link #simpleFindClass} method to find
     *      the class using this class loader.
     * </ol>
     *
     * @param     name the name of the class

     */
    protected synchronized final Class loadClass(String name, boolean resolve)
                                            throws ClassNotFoundException {
        Class cls = null;
        
	int last = name.lastIndexOf('.');
        String pkg = (last >= 0) ? name.substring(0, last) : "";
        
	Set del = (Set)packageCoverage.get(pkg);

	Boolean boo = (Boolean)sclPackages.get(pkg);
	if (boo == null || boo.booleanValue()) {
	    try {
        	cls = systemCL.loadClass(name);
		if (boo == null) sclPackages.put(pkg, Boolean.TRUE);
		return cls; // try SCL first
	    } catch (ClassNotFoundException e) {
//		sclPackages.put(pkg, Boolean.FALSE); // quite brave assumption
	    }
	}

        if (del == null) {
            // uncovered package, go directly to SCL
            cls = systemCL.loadClass(name);
        } else if (del.size() == 1) {
            // simple package coverage
            ProxyClassLoader pcl = (ProxyClassLoader)del.iterator().next();
            if (pcl == this || parentSet.contains(pcl)) {
		cls = pcl.selfLoadClass(name);
//System.err.println("selfLoadClass(" + pcl + "): " + cls );
		if (cls != null) sclPackages.put(pkg, Boolean.FALSE);
	    } else { // maybe it is also covered by SCL
        	cls = systemCL.loadClass(name);
	    }
        } else {
            // multicovered package, search in order
            for (int i=0; i<parents.length; i++) { // all our accessible parents
                if (del.contains(parents[i])) { // that cover given package
                    cls = parents[i].selfLoadClass(name);
                    if (cls != null) break;
                }
            }
	    if (cls == null && del.contains(this)) cls = selfLoadClass(name);
	    if (cls != null) sclPackages.put(pkg, Boolean.FALSE);
	    if (cls == null) cls = systemCL.loadClass(name); // XXX
        }
        if(cls == null) throw new ClassNotFoundException(name);
        if (resolve) resolveClass(cls);
        return cls;
    }
    
    /** May return null */
    private synchronized Class selfLoadClass(String name) {
        Class cls = findLoadedClass(name);
        if (cls == null) cls = doLoadClass(name);
        return cls;
    }
    
    /** This ClassLoader can't load anything itself. Subclasses

     * <CODE>null</CODE> if it can't load required class.
     *
     * @param  name the name of the class
     * @param  fileName the expected filename of the classfile, like
     *      <CODE>java/lang/Object.class</CODE> for <CODE>java.lang.Object</CODE>
     *      The ClassLoader implementation may or may not use it, depending
     *      whether it is usefull to it.
     * @param pkg the package name, in the format org/netbeans/modules/foo/
     * @return the resulting <code>Class</code> object or <code>null</code>
     */
    protected Class doLoadClass(String name) {
        return null;
    }
    

    /**
     * Finds the resource with the given name.
     * this method searches for resources in the following order:<p>
     * <ol>
     * <li> Checks the caches whether another resource or class from the same
     *      package was already loaded and uses the same classloader.
     * <li> Tries to find the resources using parent loaders in their order.
     * <li> Calls the {@link #findResource(String)} method to find
     *      the resources using this class loader.
     * </ol>
     *
     * @param  name a "/"-separated path name that identifies the resource.
     * @return a URL for reading the resource, or <code>null</code> if
     *      the resource could not be found.
     * @see #findResource(String)
     */
    public final URL getResource(final String name) {
        URL url = null;
        
	int last = name.lastIndexOf('/');
        String pkg = (last >= 0) ? name.substring(0, last).replace('/', '.') : "";
	Set del = (Set)packageCoverage.get(pkg);

        if (del == null) {
            // uncovered package, go directly to SCL
            url = systemCL.getResource(name);
        } else if (del.size() == 1) {
            // simple package coverage
            ProxyClassLoader pcl = (ProxyClassLoader)del.iterator().next();
            if (pcl == this || parentSet.contains(pcl)) url = pcl.findResource(name);
        } else {
            // multicovered package, search in order
            for (int i=0; i<parents.length; i++) { // all our accessible parents
                if (del.contains(parents[i])) { // that cover given package
                    url = parents[i].findResource(name);
                    if (url != null) break;
                }
                if (u != null) return u;
            }
	    if (url == null && del.contains(this)) url = findResource(name);
        }
        return url;
        ClassLoader owner = (ClassLoader)domainsByPackage.get(pkg);

        if (owner != null) { // known package
            // Note that shouldDelegateResource should already be true for this!
            if (owner instanceof ProxyClassLoader) {
                return ((ProxyClassLoader)owner).findResource(name); // we have its parents, skip them
	    } else {
                return owner.getResource(name);     // know nothing about this loader and his structure
            }
        } 
        
        // virgin package
        URL retVal = null;
        for (int i = 0; i < parents.length; i++) {
            owner = parents[i];
            if (!shouldDelegateResource(pkg, owner)) continue;
            if (owner instanceof ProxyClassLoader) {
                retVal = ((ProxyClassLoader)owner).findResource(name); // skip parents (checked already)
            } else {
                retVal = owner.getResource(name); // know nothing about this loader and his structure
            }
            if (retVal != null) {
                domainsByPackage.put(pkg, owner);
                return retVal;
            }
        }
        
        // try it ourself
        retVal = findResource(name);
        if (retVal != null) {
            domainsByPackage.put(pkg, this);
        }
        return retVal;
    }

    /** This ClassLoader can't load anything itself. Subclasses

     * @throws IOException if I/O errors occur
     */    
    protected final synchronized Enumeration findResources(String name) throws IOException {
        zombieCheck(name);
        final int slashIdx = name.lastIndexOf('/');
        if (slashIdx == -1) return EMPTY; // won't load from the default package
        final String pkg = name.substring(0, slashIdx + 1);

        // Don't bother optimizing this call by domains.
        Enumeration[] es = new Enumeration[parents.length + 2];
        es[0] = systemCL.getResources(name);
        for (int i = 1; i <= parents.length; i++) {
            es[i] = parents[i-1].simpleFindResources(name);
                es[i] = EMPTY;
                continue;
            }
            if (parents[i] instanceof ProxyClassLoader) {
                es[i] = ((ProxyClassLoader)parents[i]).simpleFindResources(name);
            } else {
                es[i] = parents[i].getResources(name);
            }
        }
        es[parents.length+1] = simpleFindResources(name);
        // Should not be duplicates, assuming the parent loaders are properly distinct
        // from one another and do not overlap in JAR usage, which they ought not.
        // Anyway MetaInfServicesLookup, the most important client of this method, does

        return new AAEnum (es);
    }

    /** This ClassLoader can't load anything itself. Subclasses
     * may override this method to do some resource loading themselves, this
     * implementation simply delegates to findResources method of the superclass
     * that should return empty Enumeration.
     *
     * @param  name the resource name
     * @return an Enumeration of URLs for the resources
     * @throws IOException if I/O errors occur
     */
    protected Enumeration simpleFindResources(String name) throws IOException {
        return super.findResources(name);
    }

     * @return the Package corresponding to the given name, or null if not found
     */
    protected Package getPackage(String name) {
        return getPackageFast(name, true);
        return getPackageFast(name, name.replace('.', '/') + '/', true);
    }
    
    /**

     * @param sname package name in org/netbeans/modules/foo/ format
     * @param recurse whether to also ask parents
     */
    protected Package getPackageFast(String name, boolean recurse) {
        synchronized (packages) {
            Package pkg = (Package)packages.get(name);
            if (pkg != null) {

                return null;
            }
            for (int i = 0; i < parents.length; i++) {
                ProxyClassLoader par = parents[i];
                pkg = par.getPackageFast(name, false);
                if (pkg != null) break;
                    if (pkg != null) {
                        break;
                    }
                }
            }
            if (pkg == null) {
                // Cannot access either Package.getSystemPackage nor ClassLoader.getPackage
                // from here, so do the best we can though it will cause unnecessary
                // duplication of the package cache (PCL.packages vs. CL.packages):

     * <code>ClassLoader</code>
     */
    protected synchronized Package[] getPackages() {
	Map all = new HashMap(); // Map<String,Package>
        Map all = new HashMap(); // Map<String,Package>
        // XXX call shouldDelegateResource on each?
        addPackages(all, super.getPackages());
        for (int i = 0; i < parents.length; i++) {
            ProxyClassLoader par = parents[i];
            // XXX should ideally use shouldDelegateResource here...
            addPackages(all, par.getPackages());
                addPackages(all, ((ProxyClassLoader)par).getPackages());
            }
        }
        synchronized (packages) {
            Iterator it = all.entrySet().iterator();

     * @return optimized list of parents (no nulls or duplicates)
     * @throws IllegalArgumentException if there are cycles
     */
    private ProxyClassLoader[] coalesceParents(ProxyClassLoader[] loaders) throws IllegalArgumentException {
        int likelySize = loaders.length * 5 + 10;
        Set resultingUnique = new HashSet(likelySize); // Set<ClassLoader>
        List resulting = new ArrayList(likelySize); // List<ClassLoader>
        for (int i = 0; i < loaders.length; i++) {
            addRec(resultingUnique, resulting, loaders[i]);
        }
        ProxyClassLoader[] ret = (ProxyClassLoader[])resulting.toArray(new ProxyClassLoader[resulting.size()]);
        return ret;
    }
    
    /** Coalesce a new set of loaders into the existing ones.
     */
    private ProxyClassLoader[] coalesceAppend(ProxyClassLoader[] existing, ProxyClassLoader[] appended) throws IllegalArgumentException {
        int likelySize = existing.length + 3;
        Set resultingUnique = new HashSet(likelySize);
        List existingL = Arrays.asList(existing);

        for (int i = 0; i < appended.length; i++) {
            addRec(resultingUnique, resulting, appended[i]);
        }
        ProxyClassLoader[] ret = (ProxyClassLoader[])resulting.toArray(new ProxyClassLoader[resulting.size()]);
        return ret;
    }   
    
    private void addRec(Set resultingUnique, List resulting, ProxyClassLoader loader) throws IllegalArgumentException {
        if (loader == this) throw new IllegalArgumentException("cycle in parents"); // NOI18N
        if (resultingUnique.contains(loader)) return;
        if (loader.transitive) {
            ProxyClassLoader[] parents = loader.parents;
            for (int i = 0; i < parents.length; i++) {
                addRec(resultingUnique, resulting, parents[i]);
            }

        resulting.add(loader);
    }

    /** A method that finds a class either in itself or in parents.
     * It uses dual signaling for class not found: it can either return null
     * or throw CNFE itself.
     * @param name class name, e.g. "org.netbeans.modules.foo.Clazz"
     * @param fileName resource name, e.g. "org/netbeans/modules/foo/Clazz.class"
     * @param pkg package component, e.g. "org/netbeans/modules/foo/"
     * @return a class or null if not found. It can also throw an exception.
     * @throws ClassNotFoundException in case it doesn't found a class
     * and a parent eglible for loading it thrown it already.
     */
    private final Class smartLoadClass(String name, String fileName, String pkg) throws ClassNotFoundException {
	// First, check if the class has already been loaded
	Class c = findLoadedClass(name);
	if(c != null) return c;
        
        final ClassLoader owner = isSpecialResource(pkg) ? null : (ClassLoader)domainsByPackage.get(pkg);
        if (owner == this) {
            return simpleFindClass(name, fileName, pkg);
        }
        if (owner != null) {
            // Note that shouldDelegateResource should already be true as we hit this pkg before.
            if (owner instanceof ProxyClassLoader) {
                return ((ProxyClassLoader)owner).fullFindClass(name, fileName, pkg);
            } else {
                return owner.loadClass(name); // May throw CNFE, will be propagated
            }
        }
        
        // Virgin package, do the parent scan 
        c = loadInOrder(name, fileName, pkg);

        if (c != null) {
            final ClassLoader owner2 = getClassClassLoader(c); // who got it?
            domainsByPackage.put(pkg, owner2);
        }
        return c;
    }

    // #29844 run as privileged as it may get called by loadClassInternal() used
    // during class resolving by JVM with arbitrary ProtectionDomain context stack
    private static ClassLoader getClassClassLoader(final Class c) {
        return (ClassLoader) AccessController.doPrivileged(new PrivilegedAction() {
            public Object run() {
                return c.getClassLoader();
            }
        });
    }

    private final Class loadInOrder( String name, String fileName, String pkg ) throws ClassNotFoundException {
        ClassNotFoundException cached = null;
        for (int i = 0; i < parents.length; i++) {
	    ClassLoader par = parents[i];
            if (!shouldDelegateResource(pkg, par)) continue;
	    if (par instanceof ProxyClassLoader) {
                ProxyClassLoader pcl = (ProxyClassLoader)par;
		Class c = pcl.fullFindClass(name, fileName, pkg);
                // pcl might have have c in its already-loaded classes even though
                // it was not the defining class loader. In that case, if pcl was
                // not transitive (should not expose its own parents), reject this.
                if (c != null && (pcl.transitive || getClassClassLoader(c) == pcl)) return c;
	    } else {
                // The following is an optimization, it should not affect semantics:
                boolean skip = false;
                if (name.startsWith("org.netbeans.") || // NOI18N
                        name.startsWith("org.openide.") || // NOI18N
                        name.endsWith(".Bundle") || // NOI18N
                        name.endsWith("BeanInfo") || // NOI18N
                        name.endsWith("Editor")) { // NOI18N
                    if (par.getResource(fileName) == null) {
                        // We would just throw CNFE anyway, don't bother!
                        // Avg. (over ten runs after primer, w/ netbeans.close):
                        // before: 13.87s after: 13.40s saved: 1.3%
                        skip = true;
                    }
                }
                if (!skip) {
                    try {
                        return par.loadClass(name);
                    } catch( ClassNotFoundException cnfe ) {
                        cached = cnfe;
                    }
                }
	    }
	}

        Class c = simpleFindClass(name, fileName, pkg); // Try it ourselves
        if (c != null) return c;
        if (cached != null) throw cached;
	return null;
    }

    private synchronized Class fullFindClass(String name, String fileName, String pkg) {
	Class c = findLoadedClass(name);
	return (c == null) ? simpleFindClass(name, fileName, pkg) : c;
    }    

    private void addPackages(Map all, Package[] pkgs) {
        // Would be easier if Package.equals() was just defined sensibly...
        for (int i = 0; i < pkgs.length; i++) {
            all.put(pkgs[i].getName(), pkgs[i]);
        }
    }
    
    /** Test whether a given resource name is something that any JAR might
     * have, and for which the domain cache should be disabled.
     * The result must not change from one call to the next with the same argument.
     * By default the domain cache is disabled only for META-INF/* JAR information.
     * @param pkg the package component of the resource path ending with a slash,
     *        e.g. "org/netbeans/modules/foo/"
     * @return true if it is a special resource, false for normal domain-cached resource
     * @since org.netbeans.core/1 1.3
     */
    protected boolean isSpecialResource(String pkg) {
        if (pkg.startsWith("META-INF/")) return true; // NOI18N
        return false;
    }
    
    /** Test whether a given resource request (for a class or not) should be
     * searched for in the specified parent classloader or not.
     * The result must not change from one call to the next with the same arguments.
     * By default, always true. Subclasses may override to "mask" certain
     * packages from view, possibly according to the classloader chain.
     * @param pkg the package component of the resource path ending with a slash,
     *        e.g. "org/netbeans/modules/foo/"
     * @param parent a classloader which is a direct or indirect parent of this one
     * @return true if the request should be delegated to this parent; false to
     *         only search elsewhere (other parents, this loader's own namespace)
     * @since org.netbeans.core/1 1.3
     */
    protected boolean shouldDelegateResource(String pkg, ClassLoader parent) {
        return true;
    }
    
    




        mgr.refineClassLoader(this, loaders);
        
        try {
            classloader = new OneModuleClassLoader(classp, (ProxyClassLoader[])loaders.toArray(new ProxyClassLoader[loaders.size()]));
        } catch (IllegalArgumentException iae) {
            // Should not happen, but just in case.
            IOException ioe = new IOException(iae.toString());

    /** Turn off the classloader and release all resources. */
    void classLoaderDown() {
        if (isFixed()) return; // don't touch it
//        if (classloader instanceof ProxyClassLoader) {
//            ((ProxyClassLoader)classloader).destroy();
//        }
        classloader = null;
        Util.err.log("classLoaderDown on " + this + ": releaseCount=" + releaseCount + " released=" + released);
        released = false;

         *      The items are JarFiles for jars and Files for directories
         * @param parents a set of parent classloaders (from other modules)
         */
        public OneModuleClassLoader(List classp, ProxyClassLoader[] parents) throws IllegalArgumentException {
            super(classp, parents, false);
            rc = releaseCount++;
        }

            if (mgr.isSpecialResource(pkg)) {
                return true;
            }
	    return false;
//            return super.isSpecialResource(pkg);
        }
        
        protected boolean shouldDelegateResource(String pkg, ClassLoader parent) {
//            if (!super.shouldDelegateResource(pkg, parent)) {
//                return false;
//            }
            Module other;
            if (parent instanceof Util.ModuleProvider) {
                other = ((Util.ModuleProvider)parent).getModule();




import org.openide.modules.Dependency;
import org.openide.ErrorManager;
import org.netbeans.JarClassLoader;
import org.netbeans.ProxyClassLoader;

/** Manages a collection of modules.
 * Must use {@link #mutex} to access its important methods.

            // Normal case.
            classLoaderPatches = Collections.EMPTY_LIST;
        }
        classLoader = new SystemClassLoader(classLoaderPatches, new ProxyClassLoader[] {(ProxyClassLoader)ModuleManager.class.getClassLoader()}, Collections.EMPTY_SET);
        updateContextClassLoaders(classLoader, true);
    }
    

        // it is likely that some of these classloaders will overlap.
        Set foundParents = new HashSet(modules.size() * 4 / 3 + 2); // Set<ClassLoader>
        List parents = new ArrayList(modules.size() + 1); // List<ClassLoader>
        ProxyClassLoader base = (ProxyClassLoader)ModuleManager.class.getClassLoader();
        foundParents.add(base);
        parents.add(base);
        Iterator it = modules.iterator();

                parents.add(m.getClassLoader());
            }
        }
        ProxyClassLoader[] parentCLs = (ProxyClassLoader[])parents.toArray(new ProxyClassLoader[parents.size()]);
        SystemClassLoader nue;
        try {
            nue = new SystemClassLoader(classLoaderPatches, parentCLs, modules);
        } catch (IllegalArgumentException iae) {
            Util.err.notify(iae);
            nue = new SystemClassLoader(classLoaderPatches, new ProxyClassLoader[] {(ProxyClassLoader)ModuleManager.class.getClassLoader()}, Collections.EMPTY_SET);
        }
        synchronized (classLoaderLock) {
            classLoader = nue;

        private final StringBuffer debugme;
        private boolean empty = true;
        
        public SystemClassLoader(List files, ProxyClassLoader[] parents, Set modules) throws IllegalArgumentException {
            super(files, parents, false);
            allPermissions = new Permissions();
            allPermissions.add(new AllPermission());

            }
        }
        
        public void append(ProxyClassLoader[] ls, List modules) throws IllegalArgumentException {
            super.append(ls);
            debugme.deleteCharAt(debugme.length() - 1);
            record(modules);

            if (installer.isSpecialResource(pkg)) {
                return true;
            }
//            return super.isSpecialResource(pkg);
return false;
        }
        
        /** Provide all permissions for any code loaded from the files list

        protected PermissionCollection getPermissions(CodeSource cs) {
            return allPermissions;
        }
//<<<<
        protected URL fileToURL(File f) throws MalformedURLException {
            return Utilities.toURL(f);
        }

private long resTime;
private long clTime;

//	public URL getResource(String name) {
//	    long time = System.currentTimeMillis();
//	    URL ret = super.getResource(name);
//	    time = System.currentTimeMillis() - time;
//	    resTime += time;
//System.err.println("  SCL.getResource(" + name + " took " + time + "ms, total=" + resTime + "ms");
//	    return ret;
//	}

    }


                    Module m = (Module)teIt.next();
                    fallback.addFirst(m);
                    Util.err.log("enable: bringing up: " + m);
//                    ev.log(Events.PERF_START, "bringing up classloader on " + m.getCodeName() ); // NOI18N
                    try {
                        // Calculate the parents to initialize the classloader with.
                        Dependency[] dependencies = m.getDependenciesArray();

                        throw ie;
                    }
                    m.setEnabled(true);
//                    ev.log(Events.PERF_END, "bringing up classloader on " + m.getCodeName() ); // NOI18N
                    // Check package dependencies.
//                    ev.log(Events.PERF_START, "package dependency check on " + m.getCodeName() ); // NOI18N
                    Util.err.log("enable: checking package dependencies for " + m);
                    Dependency[] dependencies = m.getDependenciesArray();
                    for (int i = 0; i < dependencies.length; i++) {

                        }
                        Util.err.log("Successful check for: " + dep);
                    }
//                    ev.log(Events.PERF_END, "package dependency check on " + m.getCodeName() ); // NOI18N
                    // Prepare to load it.
//                    ev.log(Events.PERF_START, "ModuleInstaller.prepare " + m.getCodeName() ); // NOI18N
                    installer.prepare(m);
//                    ev.log(Events.PERF_END, "ModuleInstaller.prepare " + m.getCodeName() ); // NOI18N
                    ev.log(Events.PERF_TICK, "ModuleInstaller.prepare " + m.getCodeName() ); // NOI18N
                }
                ev.log(Events.PERF_END, "module preparation" ); // NOI18N


                    probs.add(failedPackageDep);
                } else {
                    // Some other problem (exception).
                    probs.add(ie); 
                }
                // Other modules may have depended on this one and now will not be OK.
                // So clear all "soft" problems from the cache.

                while (teIt.hasNext()) {
                    nueclassloaders.add(((Module)teIt.next()).getClassLoader());
                }
                classLoader.append((ProxyClassLoader[])(nueclassloaders.toArray(new ProxyClassLoader[nueclassloaders.size()])), toEnable);
            } else {
                Util.err.log("enable: no class loader yet, not appending");
            }

Return to bug 30971

Lines 26-31 Link Here

(-)bootstrap/src/org/netbeans/JarClassLoader.java (-6 / +55 lines)
26	import java.util.*;	26	import java.util.*;
27	import java.lang.reflect.Field;	27	import java.lang.reflect.Field;
28	import java.lang.reflect.Modifier;	28	import java.lang.reflect.Modifier;
		29	import java.util.jar.JarEntry;
29		30
30	/**	31	/**
31	* A ProxyClassLoader capable of loading classes from a set of jar files	32	* A ProxyClassLoader capable of loading classes from a set of jar files
Lines 43-49 Link Here
43	/** Creates new JarClassLoader.	44	/** Creates new JarClassLoader.
44	* Gives transitive flag as true.	45	* Gives transitive flag as true.
45	*/	46	*/
46	public JarClassLoader (List files, ClassLoader[] parents) {	47	public JarClassLoader (List files, ProxyClassLoader[] parents) {
47	this(files, parents, true);	48	this(files, parents, true);
48	}	49	}
49		50
Lines 51-58 Link Here
51	* @since org.netbeans.core/1 > 1.6	52	* @since org.netbeans.core/1 > 1.6
52	* @see ProxyClassLoader#ProxyClassLoader(ClassLoader[],boolean)	53	* @see ProxyClassLoader#ProxyClassLoader(ClassLoader[],boolean)
53	*/	54	*/
54	public JarClassLoader(List files, ClassLoader[] parents, boolean transitive) {	55	public JarClassLoader(List files, ProxyClassLoader[] parents, boolean transitive) {
55	super(parents, transitive);	56	super(parents, getCoveredPackages(files), transitive);
56		57
57	sources = new Source[files.size()];	58	sources = new Source[files.size()];
58	try {	59	try {
Lines 109-115 Link Here
109	return val;	110	return val;
110	}	111	}
111		112
112	protected Class simpleFindClass(String name, String path, String pkgnameSlashes) {	113	protected Class doLoadClass(String name) {
		114	// protected Class simpleFindClass(String name, String path, String pkgnameSlashes) {
		115	String path = name.replace('.', '/').concat(".class"); // NOI18N
		116
113	// look up the Sources and return a class based on their content	117	// look up the Sources and return a class based on their content
114	for( int i=0; i<sources.length; i++ ) {	118	for( int i=0; i<sources.length; i++ ) {
115	Source src = sources[i];	119	Source src = sources[i];
Lines 128-134 Link Here
128	// to have the same Package object, proper sealing check, etc.; so be safe,	132	// to have the same Package object, proper sealing check, etc.; so be safe,
129	// overhead is probably small (check in parents, nope, check super which	133	// overhead is probably small (check in parents, nope, check super which
130	// delegates to system loaders).	134	// delegates to system loaders).
131	Package pkg = getPackageFast(pkgName, pkgnameSlashes, isSpecialResource(pkgnameSlashes));	135	Package pkg = getPackageFast(pkgName, true);
132	if (pkg != null) {	136	if (pkg != null) {
133	// XXX full sealing check, URLClassLoader does something more	137	// XXX full sealing check, URLClassLoader does something more
134	if (pkg.isSealed() && !pkg.isSealed(src.getURL())) throw new SecurityException("sealing violation"); // NOI18N	138	if (pkg.isSealed() && !pkg.isSealed(src.getURL())) throw new SecurityException("sealing violation"); // NOI18N
Lines 141-146 Link Here
141	}	145	}
142	return null;	146	return null;
143	}	147	}
		148
144	// look up the jars and return a resource based on a content of jars	149	// look up the jars and return a resource based on a content of jars
145	protected URL findResource(String name) {	150	protected URL findResource(String name) {
146	for( int i=0; i<sources.length; i++ ) {	151	for( int i=0; i<sources.length; i++ ) {
Lines 228-234 Link Here
228	* Should help reloading modules with changed resources.	233	* Should help reloading modules with changed resources.
229	*/	234	*/
230	public void destroy() {	235	public void destroy() {
231	super.destroy();	236	// super.destroy();
232	for (int i = 0; i < sources.length; i++) {	237	for (int i = 0; i < sources.length; i++) {
233	if (sources[i] instanceof JarSource) {	238	if (sources[i] instanceof JarSource) {
234	JarFile j = ((JarSource)sources[i]).getJarFile();	239	JarFile j = ((JarSource)sources[i]).getJarFile();
Lines 445-449 Link Here
445		450
446	static void notify (int x, Throwable t) {	451	static void notify (int x, Throwable t) {
447	t.printStackTrace();	452	t.printStackTrace();
		453	}
		454
		455	static long sum = 0;
		456
		457	private static Iterator getCoveredPackages(List files) {
		458	long time = System.currentTimeMillis();
		459	Set known = new HashSet();
		460	for (Iterator it = files.iterator(); it.hasNext();) {
		461	JarFile act = (JarFile)it.next();
		462	Manifest m = null;
		463	try {
		464	m = act.getManifest();
		465	} catch (IOException io) {
		466	io.printStackTrace();
		467	}
		468	if (m != null) {
		469	Attributes attr = m.getMainAttributes();
		470	String pack = attr.getValue("Covered-Packages");
		471	if (pack != null) {
		472	//System.err.println("pack=" + pack);
		473	Enumeration en = new StringTokenizer(pack,",");
		474	while (en.hasMoreElements()) {
		475	String str = (String)en.nextElement();
		476	//System.err.println("Adding package '" + str + "'");
		477	known.add(str);
		478	}
		479	continue;
		480	}
		481	}
		482	Enumeration en = act.entries();
		483	while (en.hasMoreElements()) {
		484	JarEntry je = (JarEntry)en.nextElement();
		485	if (! je.isDirectory()) {
		486	String itm = je.getName();
		487	int slash=itm.lastIndexOf('/');
		488	String pkg = itm.substring(0, slash).replace('/','.');
		489	known.add(pkg);
		490	}
		491	}
		492	}
		493	time = System.currentTimeMillis()-time;
		494	sum += time;
		495	System.err.println("Scanned packages took " + time + "ms, total=" + sum + "ms");
		496	return known.iterator();
448	}	497	}
449	}	498	}

Lines 947-953 Link Here

(-)src/org/netbeans/core/modules/Module.java (-9 / +10 lines)
947	mgr.refineClassLoader(this, loaders);	947	mgr.refineClassLoader(this, loaders);
948		948
949	try {	949	try {
950	classloader = new OneModuleClassLoader(classp, (ClassLoader[])loaders.toArray(new ClassLoader[loaders.size()]));	950	classloader = new OneModuleClassLoader(classp, (ProxyClassLoader[])loaders.toArray(new ProxyClassLoader[loaders.size()]));
951	} catch (IllegalArgumentException iae) {	951	} catch (IllegalArgumentException iae) {
952	// Should not happen, but just in case.	952	// Should not happen, but just in case.
953	IOException ioe = new IOException(iae.toString());	953	IOException ioe = new IOException(iae.toString());
Lines 960-968 Link Here
960	/** Turn off the classloader and release all resources. */	960	/** Turn off the classloader and release all resources. */
961	void classLoaderDown() {	961	void classLoaderDown() {
962	if (isFixed()) return; // don't touch it	962	if (isFixed()) return; // don't touch it
963	if (classloader instanceof ProxyClassLoader) {	963	// if (classloader instanceof ProxyClassLoader) {
964	((ProxyClassLoader)classloader).destroy();	964	// ((ProxyClassLoader)classloader).destroy();
965	}	965	// }
966	classloader = null;	966	classloader = null;
967	Util.err.log("classLoaderDown on " + this + ": releaseCount=" + releaseCount + " released=" + released);	967	Util.err.log("classLoaderDown on " + this + ": releaseCount=" + releaseCount + " released=" + released);
968	released = false;	968	released = false;
Lines 1078-1084 Link Here
1078	* The items are JarFiles for jars and Files for directories	1078	* The items are JarFiles for jars and Files for directories
1079	* @param parents a set of parent classloaders (from other modules)	1079	* @param parents a set of parent classloaders (from other modules)
1080	*/	1080	*/
1081	public OneModuleClassLoader(List classp, ClassLoader[] parents) throws IllegalArgumentException {	1081	public OneModuleClassLoader(List classp, ProxyClassLoader[] parents) throws IllegalArgumentException {
1082	super(classp, parents, false);	1082	super(classp, parents, false);
1083	rc = releaseCount++;	1083	rc = releaseCount++;
1084	}	1084	}
Lines 1110-1122 Link Here
1110	if (mgr.isSpecialResource(pkg)) {	1110	if (mgr.isSpecialResource(pkg)) {
1111	return true;	1111	return true;
1112	}	1112	}
1113	return super.isSpecialResource(pkg);	1113	return false;
		1114	// return super.isSpecialResource(pkg);
1114	}	1115	}
1115		1116
1116	protected boolean shouldDelegateResource(String pkg, ClassLoader parent) {	1117	protected boolean shouldDelegateResource(String pkg, ClassLoader parent) {
1117	if (!super.shouldDelegateResource(pkg, parent)) {	1118	// if (!super.shouldDelegateResource(pkg, parent)) {
1118	return false;	1119	// return false;
1119	}	1120	// }
1120	Module other;	1121	Module other;
1121	if (parent instanceof Util.ModuleProvider) {	1122	if (parent instanceof Util.ModuleProvider) {
1122	other = ((Util.ModuleProvider)parent).getModule();	1123	other = ((Util.ModuleProvider)parent).getModule();

Lines 34-39 Link Here

(-)src/org/netbeans/core/modules/ModuleManager.java (-15 / +34 lines)
34	import org.openide.modules.Dependency;	34	import org.openide.modules.Dependency;
35	import org.openide.ErrorManager;	35	import org.openide.ErrorManager;
36	import org.netbeans.JarClassLoader;	36	import org.netbeans.JarClassLoader;
		37	import org.netbeans.ProxyClassLoader;
37		38
38	/** Manages a collection of modules.	39	/** Manages a collection of modules.
39	* Must use {@link #mutex} to access its important methods.	40	* Must use {@link #mutex} to access its important methods.
Lines 96-102 Link Here
96	// Normal case.	97	// Normal case.
97	classLoaderPatches = Collections.EMPTY_LIST;	98	classLoaderPatches = Collections.EMPTY_LIST;
98	}	99	}
99	classLoader = new SystemClassLoader(classLoaderPatches, new ClassLoader[] {ModuleManager.class.getClassLoader()}, Collections.EMPTY_SET);	100	classLoader = new SystemClassLoader(classLoaderPatches, new ProxyClassLoader[] {(ProxyClassLoader)ModuleManager.class.getClassLoader()}, Collections.EMPTY_SET);
100	updateContextClassLoaders(classLoader, true);	101	updateContextClassLoaders(classLoader, true);
101	}	102	}
102		103
Lines 293-299 Link Here
293	// it is likely that some of these classloaders will overlap.	294	// it is likely that some of these classloaders will overlap.
294	Set foundParents = new HashSet(modules.size() * 4 / 3 + 2); // Set<ClassLoader>	295	Set foundParents = new HashSet(modules.size() * 4 / 3 + 2); // Set<ClassLoader>
295	List parents = new ArrayList(modules.size() + 1); // List<ClassLoader>	296	List parents = new ArrayList(modules.size() + 1); // List<ClassLoader>
296	ClassLoader base = ModuleManager.class.getClassLoader();	297	ProxyClassLoader base = (ProxyClassLoader)ModuleManager.class.getClassLoader();
297	foundParents.add(base);	298	foundParents.add(base);
298	parents.add(base);	299	parents.add(base);
299	Iterator it = modules.iterator();	300	Iterator it = modules.iterator();
Lines 306-318 Link Here
306	parents.add(m.getClassLoader());	307	parents.add(m.getClassLoader());
307	}	308	}
308	}	309	}
309	ClassLoader[] parentCLs = (ClassLoader[])parents.toArray(new ClassLoader[parents.size()]);	310	ProxyClassLoader[] parentCLs = (ProxyClassLoader[])parents.toArray(new ProxyClassLoader[parents.size()]);
310	SystemClassLoader nue;	311	SystemClassLoader nue;
311	try {	312	try {
312	nue = new SystemClassLoader(classLoaderPatches, parentCLs, modules);	313	nue = new SystemClassLoader(classLoaderPatches, parentCLs, modules);
313	} catch (IllegalArgumentException iae) {	314	} catch (IllegalArgumentException iae) {
314	Util.err.notify(iae);	315	Util.err.notify(iae);
315	nue = new SystemClassLoader(classLoaderPatches, new ClassLoader[] {ModuleManager.class.getClassLoader()}, Collections.EMPTY_SET);	316	nue = new SystemClassLoader(classLoaderPatches, new ProxyClassLoader[] {(ProxyClassLoader)ModuleManager.class.getClassLoader()}, Collections.EMPTY_SET);
316	}	317	}
317	synchronized (classLoaderLock) {	318	synchronized (classLoaderLock) {
318	classLoader = nue;	319	classLoader = nue;
Lines 362-368 Link Here
362	private final StringBuffer debugme;	363	private final StringBuffer debugme;
363	private boolean empty = true;	364	private boolean empty = true;
364		365
365	public SystemClassLoader(List files, ClassLoader[] parents, Set modules) throws IllegalArgumentException {	366	public SystemClassLoader(List files, ProxyClassLoader[] parents, Set modules) throws IllegalArgumentException {
366	super(files, parents, false);	367	super(files, parents, false);
367	allPermissions = new Permissions();	368	allPermissions = new Permissions();
368	allPermissions.add(new AllPermission());	369	allPermissions.add(new AllPermission());
Lines 402-408 Link Here
402	}	403	}
403	}	404	}
404		405
405	public void append(ClassLoader[] ls, List modules) throws IllegalArgumentException {	406	public void append(ProxyClassLoader[] ls, List modules) throws IllegalArgumentException {
406	super.append(ls);	407	super.append(ls);
407	debugme.deleteCharAt(debugme.length() - 1);	408	debugme.deleteCharAt(debugme.length() - 1);
408	record(modules);	409	record(modules);
Lines 422-428 Link Here
422	if (installer.isSpecialResource(pkg)) {	423	if (installer.isSpecialResource(pkg)) {
423	return true;	424	return true;
424	}	425	}
425	return super.isSpecialResource(pkg);	426	// return super.isSpecialResource(pkg);
		427	return false;
426	}	428	}
427		429
428	/** Provide all permissions for any code loaded from the files list	430	/** Provide all permissions for any code loaded from the files list
Lines 431-436 Link Here
431	protected PermissionCollection getPermissions(CodeSource cs) {	433	protected PermissionCollection getPermissions(CodeSource cs) {
432	return allPermissions;	434	return allPermissions;
433	}	435	}
		436	//<<<<
		437	protected URL fileToURL(File f) throws MalformedURLException {
		438	return Utilities.toURL(f);
		439	}
		440
		441	private long resTime;
		442	private long clTime;
		443
		444	// public URL getResource(String name) {
		445	// long time = System.currentTimeMillis();
		446	// URL ret = super.getResource(name);
		447	// time = System.currentTimeMillis() - time;
		448	// resTime += time;
		449	//System.err.println(" SCL.getResource(" + name + " took " + time + "ms, total=" + resTime + "ms");
		450	// return ret;
		451	// }
434		452
435	}	453	}
436		454
Lines 753-759 Link Here
753	Module m = (Module)teIt.next();	771	Module m = (Module)teIt.next();
754	fallback.addFirst(m);	772	fallback.addFirst(m);
755	Util.err.log("enable: bringing up: " + m);	773	Util.err.log("enable: bringing up: " + m);
756	ev.log(Events.PERF_START, "bringing up classloader on " + m.getCodeName() ); // NOI18N	774	// ev.log(Events.PERF_START, "bringing up classloader on " + m.getCodeName() ); // NOI18N
757	try {	775	try {
758	// Calculate the parents to initialize the classloader with.	776	// Calculate the parents to initialize the classloader with.
759	Dependency[] dependencies = m.getDependenciesArray();	777	Dependency[] dependencies = m.getDependenciesArray();
Lines 780-788 Link Here
780	throw ie;	798	throw ie;
781	}	799	}
782	m.setEnabled(true);	800	m.setEnabled(true);
783	ev.log(Events.PERF_END, "bringing up classloader on " + m.getCodeName() ); // NOI18N	801	// ev.log(Events.PERF_END, "bringing up classloader on " + m.getCodeName() ); // NOI18N
784	// Check package dependencies.	802	// Check package dependencies.
785	ev.log(Events.PERF_START, "package dependency check on " + m.getCodeName() ); // NOI18N	803	// ev.log(Events.PERF_START, "package dependency check on " + m.getCodeName() ); // NOI18N
786	Util.err.log("enable: checking package dependencies for " + m);	804	Util.err.log("enable: checking package dependencies for " + m);
787	Dependency[] dependencies = m.getDependenciesArray();	805	Dependency[] dependencies = m.getDependenciesArray();
788	for (int i = 0; i < dependencies.length; i++) {	806	for (int i = 0; i < dependencies.length; i++) {
Lines 796-806 Link Here
796	}	814	}
797	Util.err.log("Successful check for: " + dep);	815	Util.err.log("Successful check for: " + dep);
798	}	816	}
799	ev.log(Events.PERF_END, "package dependency check on " + m.getCodeName() ); // NOI18N	817	// ev.log(Events.PERF_END, "package dependency check on " + m.getCodeName() ); // NOI18N
800	// Prepare to load it.	818	// Prepare to load it.
801	ev.log(Events.PERF_START, "ModuleInstaller.prepare " + m.getCodeName() ); // NOI18N	819	// ev.log(Events.PERF_START, "ModuleInstaller.prepare " + m.getCodeName() ); // NOI18N
802	installer.prepare(m);	820	installer.prepare(m);
803	ev.log(Events.PERF_END, "ModuleInstaller.prepare " + m.getCodeName() ); // NOI18N	821	// ev.log(Events.PERF_END, "ModuleInstaller.prepare " + m.getCodeName() ); // NOI18N
		822	ev.log(Events.PERF_TICK, "ModuleInstaller.prepare " + m.getCodeName() ); // NOI18N
804	}	823	}
805	ev.log(Events.PERF_END, "module preparation" ); // NOI18N	824	ev.log(Events.PERF_END, "module preparation" ); // NOI18N
806		825
Lines 817-823 Link Here
817	probs.add(failedPackageDep);	836	probs.add(failedPackageDep);
818	} else {	837	} else {
819	// Some other problem (exception).	838	// Some other problem (exception).
820	probs.add(ie);	839	probs.add(ie);
821	}	840	}
822	// Other modules may have depended on this one and now will not be OK.	841	// Other modules may have depended on this one and now will not be OK.
823	// So clear all "soft" problems from the cache.	842	// So clear all "soft" problems from the cache.
Lines 853-859 Link Here
853	while (teIt.hasNext()) {	872	while (teIt.hasNext()) {
854	nueclassloaders.add(((Module)teIt.next()).getClassLoader());	873	nueclassloaders.add(((Module)teIt.next()).getClassLoader());
855	}	874	}
856	classLoader.append((ClassLoader[])(nueclassloaders.toArray(new ClassLoader[nueclassloaders.size()])), toEnable);	875	classLoader.append((ProxyClassLoader[])(nueclassloaders.toArray(new ProxyClassLoader[nueclassloaders.size()])), toEnable);
857	} else {	876	} else {
858	Util.err.log("enable: no class loader yet, not appending");	877	Util.err.log("enable: no class loader yet, not appending");
859	}	878	}

Lines 7-10 Link Here

(-)manifest.mf (+14 lines)
7	OpenIDE-Module-Localizing-Bundle: org/netbeans/core/Bundle.properties	7	OpenIDE-Module-Localizing-Bundle: org/netbeans/core/Bundle.properties
8	OpenIDE-Module-Layer: org/netbeans/core/resources/mf-layer.xml	8	OpenIDE-Module-Layer: org/netbeans/core/resources/mf-layer.xml
9	OpenIDE-Module-Provides: org.openide.modules.InstalledFileLocator	9	OpenIDE-Module-Provides: org.openide.modules.InstalledFileLocator
		10	Covered-Packages: org.netbeans.beaninfo,org.netbeans.beaninfo.editors,
		11	org.netbeans.beaninfo.editors.resources,org.netbeans.core,
		12	org.netbeans.core.actions,org.netbeans.core.awt,
		13	org.netbeans.core.filesystems,
		14	org.netbeans.core.modules,org.netbeans.core.perftool,
		15	org.netbeans.core.projects,org.netbeans.core.projects.cache,
		16	org.netbeans.core.resources,org.netbeans.core.resources.actions,
		17	org.netbeans.core.resources.frames,org.netbeans.core.resources.welcome,
		18	org.netbeans.core.resources.windowmanager,org.netbeans.core.ui,
		19	org.netbeans.core.windows,org.netbeans.core.windows.dnd,
		20	org.netbeans.core.windows.frames,org.netbeans.core.windows.layers,
		21	org.netbeans.core.windows.nodes,org.netbeans.core.windows.toolbars,
		22	org.netbeans.core.windows.util,org.netbeans.core.xml,
		23	META-INF,META-INF.services
10		24