[jboss-cvs] JBossAS SVN: r96658 - projects/jboss-classpool/trunk/src/main/java/org/jboss/classpool/plugins/as5/jbosscl.

[jboss-cvs-commits at lists.jboss.org]

Author: flavia.rainone at jboss.com
Date: 2009-11-20 15:24:37 -0500 (Fri, 20 Nov 2009)
New Revision: 96658

Modified:
   projects/jboss-classpool/trunk/src/main/java/org/jboss/classpool/plugins/as5/jbosscl/JBossClDelegatingClassPoolFactory.java
Log:
[JBREFLECT-69] JBossClDelegatingCPFactory was creating duplicate CPs, which was resulting in non-cleaned up class pools.
Now, JBossClDelegatingCPFactory aborts the recursive creation of a CP if this CP is already being created in an outer scope of the recursion.

Modified: projects/jboss-classpool/trunk/src/main/java/org/jboss/classpool/plugins/as5/jbosscl/JBossClDelegatingClassPoolFactory.java
===================================================================
--- projects/jboss-classpool/trunk/src/main/java/org/jboss/classpool/plugins/as5/jbosscl/JBossClDelegatingClassPoolFactory.java	2009-11-20 20:22:29 UTC (rev 96657)
+++ projects/jboss-classpool/trunk/src/main/java/org/jboss/classpool/plugins/as5/jbosscl/JBossClDelegatingClassPoolFactory.java	2009-11-20 20:24:37 UTC (rev 96658)
@@ -24,12 +24,12 @@
 import java.security.AccessController;
 import java.security.PrivilegedAction;
 import java.util.Collection;
+import java.util.HashSet;
 
 import javassist.ClassPool;
 import javassist.scopedpool.ScopedClassPoolFactory;
 import javassist.scopedpool.ScopedClassPoolRepository;
 
-import org.jboss.classloader.plugins.loader.ClassLoaderToLoaderAdapter;
 import org.jboss.classloader.spi.ClassLoaderDomain;
 import org.jboss.classloader.spi.ClassLoaderSystem;
 import org.jboss.classloading.spi.RealClassLoader;
@@ -37,13 +37,11 @@
 import org.jboss.classloading.spi.dependency.Module;
 import org.jboss.classpool.domain.ClassPoolDomain;
 import org.jboss.classpool.domain.ClassPoolDomainRegistry;
-import org.jboss.classpool.domain.ClassPoolToClassPoolDomainAdapter;
 import org.jboss.classpool.plugins.as.NonDelegatingClassPool;
 import org.jboss.classpool.plugins.as.temp.TempClassPoolFactory;
 import org.jboss.classpool.plugins.as5.DomainRegistry;
 import org.jboss.classpool.plugins.as5.RegisterModuleCallback;
 import org.jboss.classpool.spi.AbstractClassPool;
-import org.jboss.classpool.spi.ClassPoolRepository;
 
 /**
  * 
@@ -56,14 +54,23 @@
    
    private final RegisterModuleCallback registerModuleCallback;
    
+   private Collection<ClassLoader> currentClassLoaders = new HashSet<ClassLoader>();
+   
    public JBossClDelegatingClassPoolFactory(DomainRegistry registry, RegisterModuleCallback registerModuleCallback)
    {
       this.registry = registry;
       this.registerModuleCallback = registerModuleCallback;
    }
    
-   public AbstractClassPool create(ClassLoader cl, ClassPool src, ScopedClassPoolRepository repository)
+   public synchronized AbstractClassPool create(ClassLoader cl, ClassPool src, ScopedClassPoolRepository repository)
    {
+      if (this.currentClassLoaders.contains(cl))
+      {
+         return null;
+      }
+      currentClassLoaders.add(cl);
+      try
+      {
       ClassPool parent = getCreateParentClassPools(cl, src, repository);
       
       if (cl instanceof RealClassLoader)
@@ -74,15 +81,26 @@
             module = getModuleForClassLoader(cl);
          }
          registerModuleCallback.registerModule(module);
-         registerBootstrapLoaders();
-         ClassPoolDomain domain = getDomain(module, cl);  
+         registerBootstrapLoaders(module, repository);
+         ClassPoolDomain domain = getDomain(module, cl, repository);
+         // this indicates that the domain corresponds to a cp that is being created
+         // to avoid duplicate class pools
+         if (domain == null)
+         {
+            return null;
+         }
          return new JBossClDelegatingClassPool(domain, cl, parent, repository, module, registerModuleCallback);
       }
       
       return new NonDelegatingClassPool(cl, parent, repository, true);
+      }
+      finally
+      {
+         this.currentClassLoaders.remove(cl);
+      }
    }
 
-   private synchronized ClassPoolDomain getDomain(Module module, ClassLoader cl)
+   private synchronized ClassPoolDomain getDomain(Module module, ClassLoader cl, ScopedClassPoolRepository repository)
    {
       ClassLoaderDomain domain = null;
       ClassLoaderSystem sys = registry.getSystem();
@@ -97,11 +115,11 @@
          domain = registry.getDefaultDomain();
       }
       
-      return getDomain(cl, domain, sys);
+      return getDomain(cl, domain, sys, repository);
    }
 
    private ClassPoolDomain getDomain(ClassLoader cl, ClassLoaderDomain domain,
-         ClassLoaderSystem sys)
+         ClassLoaderSystem sys, ScopedClassPoolRepository repository)
    {
       ClassPoolDomain poolDomain = ClassPoolDomainRegistry.getInstance().getDomain(domain);
       if (poolDomain == null)
@@ -114,15 +132,19 @@
             {
                throw new RuntimeException("No domain found, domain name: " + parentDomainName);
             }
-            ClassPoolDomain parentPoolDomain = this.getDomain(null, parentDomain, sys);
+            ClassPoolDomain parentPoolDomain = this.getDomain(null, parentDomain, sys, repository);
             poolDomain = new JBossClClassPoolDomain(domain.getName(), parentPoolDomain, domain.getParentPolicy(), registry);
          }
          else
          {
             ClassLoader parentUnitLoader = registry.getParentUnitLoader(cl);
-            ClassPool parentUnitPool = parentUnitLoader == null? null: ClassPoolRepository.getInstance().registerClassLoader(parentUnitLoader);
-            if (parentUnitPool== null)
+            if (this.currentClassLoaders.contains(parentUnitLoader))
             {
+               return null;
+            }
+            ClassPool parentUnitPool = parentUnitLoader == null? null: repository.registerClassLoader(parentUnitLoader);
+            if (parentUnitPool == null)
+            {
                poolDomain = new JBossClClassPoolDomain(domain.getName(), domain.getParentPolicy(), registry);
             }
             else
@@ -147,16 +169,27 @@
       return parent;
    }
    
-   private void registerBootstrapLoaders()
+   private void registerBootstrapLoaders(Module skip, ScopedClassPoolRepository repository)
    {
       Collection<Module> unregistered = registerModuleCallback.getUnregisteredModules();
       if (unregistered.size() > 0)
       {
          for (Module module : unregistered)
          {
+            if (module == skip)
+            {
+               continue;
+            }
             ClassLoader loader = getClassLoaderForModule(module);
-            log.debug("Registering loader for module " + module + ": " + loader);
-            ClassPoolRepository.getInstance().registerClassLoader(loader);
+            if (this.currentClassLoaders.contains(loader))
+            {
+               continue;
+            }
+            ClassPool classPool = repository.registerClassLoader(loader);
+            if (classPool == null)
+            {
+               repository.unregisterClassLoader(loader);
+            }
          }
       }
    }