final String findLocalLibrary(final String name) {
String result = null;
try {
result = (String) searchHooks(name, PRE_LIBRARY);
} catch (FileNotFoundException e) {
return null;
} catch (ClassNotFoundException e) {
// will not happen
}
if (result != null) return result;
result = bundle.getBundleData().findLibrary(name);
if (result != null) return result;
// look in fragments imports ...
BundleFragment[] fragments = bundle.getFragments();
if (fragments != null)
for (int i = 0; i < fragments.length; i++) {
result = fragments[i].getBundleData().findLibrary(name);
if (result != null) return result;
}
try {
return (String) searchHooks(name, POST_LIBRARY);
} catch (FileNotFoundException e) {
return null; // this is not necessary; but being consistent in case another step is added
// below
} catch (ClassNotFoundException e) {
// will not happen
}
return null;
}
public final synchronized BundleClassLoader createClassLoader() {
if (classloader != null) return classloader;
String[] classpath;
try {
classpath = bundle.getBundleData().getClassPath();
} catch (BundleException e) {
// no classpath
classpath = new String[0];
bundle.getFramework().publishFrameworkEvent(FrameworkEvent.ERROR, bundle, e);
}
if (classpath == null) {
// no classpath
classpath = new String[0];
bundle
.getFramework()
.publishFrameworkEvent(
FrameworkEvent.ERROR,
bundle,
new BundleException(Msg.BUNDLE_NO_CLASSPATH_MATCH, BundleException.MANIFEST_ERROR));
}
BundleClassLoader bcl = createBCLPrevileged(bundle.getProtectionDomain(), classpath);
parent = getParentPrivileged(bcl);
classloader = bcl;
return classloader;
}
/*
* get the loader proxy for a bundle description
*/
public final BundleLoaderProxy getLoaderProxy(BundleDescription source) {
BundleLoaderProxy sourceProxy = (BundleLoaderProxy) source.getUserObject();
if (sourceProxy == null) {
// may need to force the proxy to be created
long exportingID = source.getBundleId();
BundleHost exportingBundle = (BundleHost) bundle.getFramework().getBundle(exportingID);
if (exportingBundle == null) return null;
sourceProxy = exportingBundle.getLoaderProxy();
}
return sourceProxy;
}
/**
* Call bundle's BundleActivator.stop() This method is called by Bundle.stopWorker to stop the
* bundle.
*
* @exception BundleException if the bundle has a class that implements the BundleActivator
* interface, and the BundleActivator.stop() method failed
*/
protected void stop() throws BundleException {
try {
AccessController.doPrivileged(
new PrivilegedExceptionAction<Object>() {
public Object run() throws Exception {
if (activator != null) {
// make sure the context class loader is set correctly
Object previousTCCL = setContextFinder();
try {
/* Stop the bundle synchronously */
activator.stop(BundleContextImpl.this);
} finally {
if (previousTCCL != Boolean.FALSE)
Thread.currentThread().setContextClassLoader((ClassLoader) previousTCCL);
}
}
return null;
}
});
} catch (Throwable t) {
if (t instanceof PrivilegedActionException) {
t = ((PrivilegedActionException) t).getException();
}
if (Debug.DEBUG_GENERAL) {
Debug.printStackTrace(t);
}
String clazz = (activator == null) ? "" : activator.getClass().getName(); // $NON-NLS-1$
throw new BundleException(
NLS.bind(
Msg.BUNDLE_ACTIVATOR_EXCEPTION,
new Object[] {
clazz,
"stop",
bundle.getSymbolicName() == null
? "" + bundle.getBundleId()
: bundle.getSymbolicName()
}),
BundleException.ACTIVATOR_ERROR,
t); //$NON-NLS-1$ //$NON-NLS-2$
} finally {
activator = null;
}
}
BundleClassLoader createBCL(final BundleProtectionDomain pd, final String[] cp) {
BundleClassLoader bcl = bundle.getBundleData().createClassLoader(BundleLoader.this, pd, cp);
// attach existing fragments to classloader
BundleFragment[] fragments = bundle.getFragments();
if (fragments != null)
for (int i = 0; i < fragments.length; i++) {
try {
bcl.attachFragment(
fragments[i].getBundleData(),
fragments[i].getProtectionDomain(),
fragments[i].getBundleData().getClassPath());
} catch (BundleException be) {
bundle.getFramework().publishFrameworkEvent(FrameworkEvent.ERROR, bundle, be);
}
}
// finish the initialization of the classloader.
bcl.initialize();
return bcl;
}
private boolean isRequestFromVM() {
if (bundle.getFramework().isBootDelegationPackage("*")
|| !bundle.getFramework().contextBootDelegation) // $NON-NLS-1$
return false;
// works around VM bugs that require all classloaders to have access to parent packages
Class[] context = CLASS_CONTEXT.getClassContext();
if (context == null || context.length < 2) return false;
// skip the first class; it is the ClassContext class
for (int i = 1; i < context.length; i++)
// find the first class in the context which is not BundleLoader or instanceof ClassLoader
if (context[i] != BundleLoader.class && !ClassLoader.class.isAssignableFrom(context[i])) {
// only find in parent if the class is not "Class" (Class#forName case) or if the class is
// not loaded with a BundleClassLoader
ClassLoader cl = getClassLoader(context[i]);
if (cl
!= FW_CLASSLOADER) { // extra check incase an adaptor adds another class into the stack
// besides an instance of ClassLoader
if (Class.class != context[i] && !(cl instanceof BundleClassLoader)) return true;
break;
}
}
return false;
}
private Object searchHooks(String name, int type)
throws ClassNotFoundException, FileNotFoundException {
ClassLoaderDelegateHook[] delegateHooks = bundle.getFramework().getDelegateHooks();
if (delegateHooks == null) return null;
Object result = null;
for (int i = 0; i < delegateHooks.length && result == null; i++) {
switch (type) {
case PRE_CLASS:
result = delegateHooks[i].preFindClass(name, createClassLoader(), bundle.getBundleData());
break;
case POST_CLASS:
result =
delegateHooks[i].postFindClass(name, createClassLoader(), bundle.getBundleData());
break;
case PRE_RESOURCE:
result =
delegateHooks[i].preFindResource(name, createClassLoader(), bundle.getBundleData());
break;
case POST_RESOURCE:
result =
delegateHooks[i].postFindResource(name, createClassLoader(), bundle.getBundleData());
break;
case PRE_RESOURCES:
result =
delegateHooks[i].preFindResources(name, createClassLoader(), bundle.getBundleData());
break;
case POST_RESOURCES:
result =
delegateHooks[i].postFindResources(name, createClassLoader(), bundle.getBundleData());
break;
case PRE_LIBRARY:
result =
delegateHooks[i].preFindLibrary(name, createClassLoader(), bundle.getBundleData());
break;
case POST_LIBRARY:
result =
delegateHooks[i].postFindLibrary(name, createClassLoader(), bundle.getBundleData());
break;
}
}
return result;
}
/**
* Call bundle's BundleActivator.start() This method is called by Bundle.startWorker to start the
* bundle.
*
* @exception BundleException if the bundle has a class that implements the BundleActivator
* interface, but Framework couldn't instantiate it, or the BundleActivator.start() method
* failed
*/
protected void start() throws BundleException {
activator = bundle.loadBundleActivator();
if (activator != null) {
try {
startActivator(activator);
} catch (BundleException be) {
activator = null;
throw be;
}
}
/* activator completed successfully. We must use this
same activator object when we stop this bundle. */
}
/*
* This method is used by Bundle.getResources to do proper parent delegation.
*/
public Enumeration getResources(String name) throws IOException {
if ((name.length() > 1) && (name.charAt(0) == '/')) /* if name has a leading slash */
name = name.substring(1); /* remove leading slash before search */
String pkgName = getResourcePackageName(name);
// follow the OSGi delegation model
// First check the parent classloader for system resources, if it is a java resource.
Enumeration result = null;
if (pkgName.startsWith(JAVA_PACKAGE)
|| bundle.getFramework().isBootDelegationPackage(pkgName)) {
// 1) if startsWith "java." delegate to parent and terminate search
// 2) if part of the bootdelegation list then delegate to parent and continue of failure
ClassLoader parentCL = getParentClassLoader();
result = parentCL == null ? null : parentCL.getResources(name);
if (pkgName.startsWith(JAVA_PACKAGE)) return result;
}
return compoundEnumerations(result, findResources(name));
}
private PackageSource findDynamicSource(String pkgName) {
if (isDynamicallyImported(pkgName)) {
ExportPackageDescription exportPackage =
bundle
.getFramework()
.getAdaptor()
.getState()
.linkDynamicImport(proxy.getBundleDescription(), pkgName);
if (exportPackage != null) {
PackageSource source = createExportPackageSource(exportPackage, null);
synchronized (this) {
if (importedSources == null) importedSources = new KeyedHashSet(false);
}
synchronized (importedSources) {
importedSources.add(source);
}
return source;
}
}
return null;
}
/**
* Return a string representation of this loader.
*
* @return String
*/
public final String toString() {
BundleData result = bundle.getBundleData();
return result == null ? "BundleLoader.bundledata == null!" : result.toString(); // $NON-NLS-1$
}
URL findResource(String name, boolean checkParent) {
if ((name.length() > 1) && (name.charAt(0) == '/')) /* if name has a leading slash */
name = name.substring(1); /* remove leading slash before search */
String pkgName = getResourcePackageName(name);
boolean bootDelegation = false;
ClassLoader parentCL = getParentClassLoader();
// follow the OSGi delegation model
// First check the parent classloader for system resources, if it is a java resource.
if (checkParent && parentCL != null) {
if (pkgName.startsWith(JAVA_PACKAGE))
// 1) if startsWith "java." delegate to parent and terminate search
// we never delegate java resource requests past the parent
return parentCL.getResource(name);
else if (bundle.getFramework().isBootDelegationPackage(pkgName)) {
// 2) if part of the bootdelegation list then delegate to parent and continue of failure
URL result = parentCL.getResource(name);
if (result != null) return result;
bootDelegation = true;
}
}
URL result = null;
try {
result = (URL) searchHooks(name, PRE_RESOURCE);
} catch (FileNotFoundException e) {
return null;
} catch (ClassNotFoundException e) {
// will not happen
}
if (result != null) return result;
// 3) search the imported packages
PackageSource source = findImportedSource(pkgName, null);
if (source != null)
// 3) found import source terminate search at the source
return source.getResource(name);
// 4) search the required bundles
source = findRequiredSource(pkgName, null);
if (source != null)
// 4) attempt to load from source but continue on failure
result = source.getResource(name);
// 5) search the local bundle
if (result == null) result = findLocalResource(name);
if (result != null) return result;
// 6) attempt to find a dynamic import source; only do this if a required source was not found
if (source == null) {
source = findDynamicSource(pkgName);
if (source != null)
// must return the result of the dynamic import and do not continue
return source.getResource(name);
}
if (result == null)
try {
result = (URL) searchHooks(name, POST_RESOURCE);
} catch (FileNotFoundException e) {
return null;
} catch (ClassNotFoundException e) {
// will not happen
}
// do buddy policy loading
if (result == null && policy != null) result = policy.doBuddyResourceLoading(name);
if (result != null) return result;
// hack to support backwards compatibiility for bootdelegation
// or last resort; do class context trick to work around VM bugs
if (parentCL != null
&& !bootDelegation
&& ((checkParent && bundle.getFramework().compatibiltyBootDelegation) || isRequestFromVM()))
// we don't need to continue if the resource is not found here
return parentCL.getResource(name);
return result;
}
private Class findClassInternal(String name, boolean checkParent, ClassLoader parentCL)
throws ClassNotFoundException {
if (Debug.DEBUG && Debug.DEBUG_LOADER)
Debug.println(
"BundleLoader["
+ this
+ "].loadBundleClass("
+ name
+ ")"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
String pkgName = getPackageName(name);
boolean bootDelegation = false;
// follow the OSGi delegation model
if (checkParent && parentCL != null && bundle.getFramework().isBootDelegationPackage(pkgName))
// 2) if part of the bootdelegation list then delegate to parent and continue of failure
try {
return parentCL.loadClass(name);
} catch (ClassNotFoundException cnfe) {
// we want to continue
bootDelegation = true;
}
Class result = null;
try {
result = (Class) searchHooks(name, PRE_CLASS);
} catch (ClassNotFoundException e) {
throw e;
} catch (FileNotFoundException e) {
// will not happen
}
if (result != null) return result;
// 3) search the imported packages
PackageSource source = findImportedSource(pkgName, null);
if (source != null) {
// 3) found import source terminate search at the source
result = source.loadClass(name);
if (result != null) return result;
throw new ClassNotFoundException(name);
}
// 4) search the required bundles
source = findRequiredSource(pkgName, null);
if (source != null)
// 4) attempt to load from source but continue on failure
result = source.loadClass(name);
// 5) search the local bundle
if (result == null) result = findLocalClass(name);
if (result != null) return result;
// 6) attempt to find a dynamic import source; only do this if a required source was not found
if (source == null) {
source = findDynamicSource(pkgName);
if (source != null) {
result = source.loadClass(name);
if (result != null) return result;
// must throw CNFE if dynamic import source does not have the class
throw new ClassNotFoundException(name);
}
}
if (result == null)
try {
result = (Class) searchHooks(name, POST_CLASS);
} catch (ClassNotFoundException e) {
throw e;
} catch (FileNotFoundException e) {
// will not happen
}
// do buddy policy loading
if (result == null && policy != null) result = policy.doBuddyClassLoading(name);
if (result != null) return result;
// hack to support backwards compatibiility for bootdelegation
// or last resort; do class context trick to work around VM bugs
if (parentCL != null
&& !bootDelegation
&& ((checkParent && bundle.getFramework().compatibiltyBootDelegation) || isRequestFromVM()))
// we don't need to continue if a CNFE is thrown here.
try {
return parentCL.loadClass(name);
} catch (ClassNotFoundException e) {
// we want to generate our own exception below
}
throw new ClassNotFoundException(name);
}
/*
* Close the the BundleLoader.
*
*/
synchronized void close() {
if ((loaderFlags & FLAG_CLOSED) != 0) return;
if (classloader != null) classloader.close();
if (policy != null) policy.close(bundle.getFramework().getSystemBundleContext());
loaderFlags |= FLAG_CLOSED; /* This indicates the BundleLoader is destroyed */
}
/**
* BundleLoader runtime constructor. This object is created lazily when the first request for a
* resource is made to this bundle.
*
* @param bundle Bundle object for this loader.
* @param proxy the BundleLoaderProxy for this loader.
* @exception org.osgi.framework.BundleException
*/
protected BundleLoader(BundleHost bundle, BundleLoaderProxy proxy) throws BundleException {
this.bundle = bundle;
this.proxy = proxy;
try {
bundle.getBundleData().open(); /* make sure the BundleData is open */
} catch (IOException e) {
throw new BundleException(Msg.BUNDLE_READ_EXCEPTION, e);
}
BundleDescription description = proxy.getBundleDescription();
// init the require bundles list.
BundleDescription[] required = description.getResolvedRequires();
if (required.length > 0) {
// get a list of re-exported symbolic names
HashSet reExportSet = new HashSet(required.length);
BundleSpecification[] requiredSpecs = description.getRequiredBundles();
if (requiredSpecs != null && requiredSpecs.length > 0)
for (int i = 0; i < requiredSpecs.length; i++)
if (requiredSpecs[i].isExported()) reExportSet.add(requiredSpecs[i].getName());
requiredBundles = new BundleLoaderProxy[required.length];
int[] reexported = new int[required.length];
int reexportIndex = 0;
for (int i = 0; i < required.length; i++) {
requiredBundles[i] = getLoaderProxy(required[i]);
if (reExportSet.contains(required[i].getSymbolicName())) reexported[reexportIndex++] = i;
}
if (reexportIndex > 0) {
reexportTable = new int[reexportIndex];
System.arraycopy(reexported, 0, reexportTable, 0, reexportIndex);
} else {
reexportTable = null;
}
requiredSources = new KeyedHashSet(10, false);
} else {
requiredBundles = null;
reexportTable = null;
requiredSources = null;
}
// init the provided packages set
ExportPackageDescription[] exports = description.getSelectedExports();
if (exports != null && exports.length > 0) {
exportedPackages =
Collections.synchronizedCollection(
exports.length > 10
? (Collection) new HashSet(exports.length)
: new ArrayList(exports.length));
initializeExports(exports, exportedPackages);
} else {
exportedPackages = Collections.synchronizedCollection(new ArrayList(0));
}
ExportPackageDescription substituted[] = description.getSubstitutedExports();
if (substituted.length > 0) {
substitutedPackages =
substituted.length > 10
? (Collection) new HashSet(substituted.length)
: new ArrayList(substituted.length);
for (int i = 0; i < substituted.length; i++)
substitutedPackages.add(substituted[i].getName());
} else {
substitutedPackages = null;
}
// This is the fastest way to access to the description for fragments since the
// hostdescription.getFragments() is slow
BundleFragment[] fragmentObjects = bundle.getFragments();
BundleDescription[] fragments =
new BundleDescription[fragmentObjects == null ? 0 : fragmentObjects.length];
for (int i = 0; i < fragments.length; i++)
fragments[i] = fragmentObjects[i].getBundleDescription();
// init the dynamic imports tables
if (description.hasDynamicImports()) addDynamicImportPackage(description.getImportPackages());
// ...and its fragments
for (int i = 0; i < fragments.length; i++)
if (fragments[i].isResolved() && fragments[i].hasDynamicImports())
addDynamicImportPackage(fragments[i].getImportPackages());
// Initialize the policy handler
String buddyList = null;
try {
buddyList = (String) bundle.getBundleData().getManifest().get(Constants.BUDDY_LOADER);
} catch (BundleException e) {
// do nothing; buddyList == null
}
policy =
buddyList != null
? new PolicyHandler(this, buddyList, bundle.getFramework().getPackageAdmin())
: null;
if (policy != null) policy.open(bundle.getFramework().getSystemBundleContext());
}
/**
* Calls the start method of a BundleActivator.
*
* @param bundleActivator that activator to start
*/
protected void startActivator(final BundleActivator bundleActivator) throws BundleException {
if (Profile.PROFILE && Profile.STARTUP)
Profile.logEnter("BundleContextImpl.startActivator()", null); // $NON-NLS-1$
try {
AccessController.doPrivileged(
new PrivilegedExceptionAction<Object>() {
public Object run() throws Exception {
if (bundleActivator != null) {
if (Profile.PROFILE && Profile.STARTUP)
Profile.logTime(
"BundleContextImpl.startActivator()",
"calling "
+ bundle.getLocation()
+ " bundle activator"); //$NON-NLS-1$//$NON-NLS-2$//$NON-NLS-3$
// make sure the context class loader is set correctly
Object previousTCCL = setContextFinder();
/* Start the bundle synchronously */
try {
bundleActivator.start(BundleContextImpl.this);
} finally {
if (previousTCCL != Boolean.FALSE)
Thread.currentThread().setContextClassLoader((ClassLoader) previousTCCL);
}
if (Profile.PROFILE && Profile.STARTUP)
Profile.logTime(
"BundleContextImpl.startActivator()",
"returned from "
+ bundle.getLocation()
+ " bundle activator"); //$NON-NLS-1$//$NON-NLS-2$//$NON-NLS-3$
}
return null;
}
});
} catch (Throwable t) {
if (t instanceof PrivilegedActionException) {
t = ((PrivilegedActionException) t).getException();
}
if (Debug.DEBUG_GENERAL) {
Debug.printStackTrace(t);
}
String clazz = null;
clazz = bundleActivator.getClass().getName();
throw new BundleException(
NLS.bind(
Msg.BUNDLE_ACTIVATOR_EXCEPTION,
new Object[] {
clazz,
"start",
bundle.getSymbolicName() == null
? "" + bundle.getBundleId()
: bundle.getSymbolicName()
}),
BundleException.ACTIVATOR_ERROR,
t); //$NON-NLS-1$ //$NON-NLS-2$
} finally {
if (Profile.PROFILE && Profile.STARTUP)
Profile.logExit("BundleContextImpl.startActivator()"); // $NON-NLS-1$
}
}