Classloading and versioning
While hacking the demo, I had 'problems' creating this 'expected' behavior:
I have foo.jar which contains FooBar service.
This FooBar service uses two other services - AlesService and ScottService.
<bean name="FooBarService" class="org.jboss.foo.FooBarService"> <property name="alesService"><inject/></property> <property name="scottService"><inject/></property> </bean>
Then I have two similar jars - acme1 and acme2.
Containing AlesService(Impl) and ScottService(Impl).
acme1 has all classes in version 1.
Where acme2 has ales package in version 2 and scott package in version 3.
Then I have the following classloading metadata in foo.jar:
<classloading xmlns="urn:jboss:classloading:1.0" export-all="NON_EMPTY"> <capabilities> <package name="org.jboss.acme.foo" version="1"/> </capabilities> <requirements> <package name="org.jboss.acme.ales" from="1" to="2" from-inclusive="true"/> <package name="org.jboss.acme.scott" from="3" to="4" from-inclusive="true"/> </requirements> </classloading>
Expecting that FooBar would use AlesService(Impl) from acme1 and ScottService(Impl) from acme2.
But that's not what happened when using the bootstrap configuration similar to what we use in AS5_trunk. :-(
Either I don't know how to properly configure this, or it's broken. ;-)
The problems that I've found:
When ClassLoaderPolicy returns non-null getExported delegate loader, this gets cached in BaseClassLoaderDomain::classLoadersByPackageName
if (packageNames != null && info.getExported() != null)
{
for (String packageName : packageNames)
{
List<ClassLoaderInformation> list = classLoadersByPackageName.get(packageName);
if (list == null)
{
list = new CopyOnWriteArrayList<ClassLoaderInformation>();
classLoadersByPackageName.put(packageName, list);
}
list.add(info);
and this is then used when looking up the class in other bundles as well, but w/o knowing the right version:
BaseClassLoaderDomain::findLoaderInExports
List<ClassLoaderInformation> list = classLoadersByPackageName.get(packageName);
if (trace)
log.trace(this + " trying to load " + name + " from all exports of package " + packageName + " " + list);
if (list != null && list.isEmpty() == false)
{
for (ClassLoaderInformation info : list)
{
BaseDelegateLoader exported = info.getExported();
// See whether the policies allow caching/blacklisting
BaseClassLoaderPolicy loaderPolicy = exported.getPolicy();
if (loaderPolicy == null || loaderPolicy.isCacheable() == false)
canCache = false;
if (loaderPolicy == null || loaderPolicy.isBlackListable() == false)
canBlackList = false;
if (exported.getResource(name) != null)
{
if (canCache)
globalClassCache.put(name, exported);
return exported;
}
}
}
So, when attempting to load class with the same name from foo.jar's classlaoder, but expecting it in diff version, I still get the previous one.
OK, then I disabled this exported usage - either by returning null on getExported or null getPackageNames.
Still didn't work as expected. :-(
Now the version-unaware delegates were kicking in:
BaseClassLoaderDomain::findLoaderInImports
for (DelegateLoader delegate : delegates)
{
if (trace)
log.trace(this + " trying to load " + name + " from import " + delegate + " for " + info.getClassLoader());
if (delegate.getResource(name) != null)
{
info.cacheLoader(name, delegate);
return delegate;
}
}
where by default in CLPolicy we return exported, which is just filtered by package names - no version awareness.
So again the previous classloader was picked.
What I had to do then - and I don't see why this isn't default behavior - is the following piece of code:
public DelegateLoader getDelegateLoader(Module module, Requirement requirement)
{
List<Capability> capabilities = getCapabilities();
if (capabilities != null && capabilities.isEmpty() == false)
{
for(Capability capability : capabilities)
{
if (capability.resolves(this, requirement))
return new FilteredDelegateLoader(getPolicy(), new CapabilityFilter(capability));
}
// none of the capabilities match - don't put it as delegate
return null;
}
return super.getDelegateLoader(module, requirement);
}
public class CapabilityFilter implements ClassFilter
{
private Capability capability;
public CapabilityFilter(Capability capability)
{
if (capability == null)
throw new IllegalArgumentException("Null capability.");
this.capability = capability;
}
public boolean matchesClassName(String className)
{
return matchesPackageName(ClassLoaderUtils.getClassPackageName(className));
}
public boolean matchesResourcePath(String resourcePath)
{
return matchesPackageName(ClassLoaderUtils.getResourcePackageName(resourcePath));
}
public boolean matchesPackageName(String packageName)
{
if (capability instanceof ExportPackages)
{
ExportPackages ep = (ExportPackages)capability;
Set<String> packages = ep.getPackageNames(null);
if (packages != null && packages.contains(packageName))
return true;
}
return false;
}
}
This finally got me to my expected behavior. :-)
All this code can be found here:
- http://anonsvn.jboss.org/repos/jbossas/projects/demos/osgi/
