private static ClassLoader internalGetFelixBundleClassLoader(Bundle bundle) {
// assume felix:
try {
// now get the current module from the bundle.
// and return the private field m_classLoader of ModuleImpl
if (Felix_BundleImpl_m_modules_field == null) {
Felix_BundleImpl_m_modules_field =
bundle
.getClass()
.getClassLoader()
.loadClass("org.apache.felix.framework.BundleImpl")
.getDeclaredField("m_modules");
Felix_BundleImpl_m_modules_field.setAccessible(true);
}
Object[] moduleArray = (Object[]) Felix_BundleImpl_m_modules_field.get(bundle);
Object currentModuleImpl = moduleArray[moduleArray.length - 1];
if (Felix_ModuleImpl_m_classLoader_field == null && currentModuleImpl != null) {
Felix_ModuleImpl_m_classLoader_field =
bundle
.getClass()
.getClassLoader()
.loadClass("org.apache.felix.framework.ModuleImpl")
.getDeclaredField("m_classLoader");
Felix_ModuleImpl_m_classLoader_field.setAccessible(true);
}
// first make sure that the classloader is ready:
// the m_classLoader field must be initialized by the
// ModuleImpl.getClassLoader() private method.
ClassLoader cl = (ClassLoader) Felix_ModuleImpl_m_classLoader_field.get(currentModuleImpl);
if (cl == null) {
// looks like it was not ready:
// the m_classLoader field must be initialized by the
// ModuleImpl.getClassLoader() private method.
// this call will do that.
bundle.loadClass("java.lang.Object");
cl = (ClassLoader) Felix_ModuleImpl_m_classLoader_field.get(currentModuleImpl);
// System.err.println("Got the bundle class loader of felix_: "
// + cl);
return cl;
} else {
// System.err.println("Got the bundle class loader of felix: " +
// cl);
return cl;
}
} catch (Throwable t) {
t.printStackTrace();
}
return null;
}
private static ClassLoader internalGetEquinoxBundleClassLoader(Bundle bundle) {
// assume equinox:
try {
if (Equinox_BundleHost_getBundleLoader_method == null) {
Equinox_BundleHost_getBundleLoader_method =
bundle
.getClass()
.getClassLoader()
.loadClass("org.eclipse.osgi.framework.internal.core.BundleHost")
.getDeclaredMethod("getBundleLoader", new Class[] {});
Equinox_BundleHost_getBundleLoader_method.setAccessible(true);
}
Object bundleLoader =
Equinox_BundleHost_getBundleLoader_method.invoke(bundle, new Object[] {});
if (Equinox_BundleLoader_createClassLoader_method == null && bundleLoader != null) {
Equinox_BundleLoader_createClassLoader_method =
bundleLoader
.getClass()
.getClassLoader()
.loadClass("org.eclipse.osgi.internal.loader.BundleLoader")
.getDeclaredMethod("createClassLoader", new Class[] {});
Equinox_BundleLoader_createClassLoader_method.setAccessible(true);
}
return (ClassLoader)
Equinox_BundleLoader_createClassLoader_method.invoke(bundleLoader, new Object[] {});
} catch (Throwable t) {
t.printStackTrace();
}
return null;
}
/**
* Returns the underlying BundleContext for the given Bundle. This uses reflection and highly
* dependent of the OSGi implementation. Should not be used if OSGi 4.1 is being used.
*
* @param bundle OSGi bundle
* @return the bundle context for this bundle
*/
public static BundleContext getBundleContext(final Bundle bundle) {
if (bundle == null) return null;
// try Equinox getContext
Method meth = ReflectionUtils.findMethod(bundle.getClass(), "getContext", new Class[0]);
// fallback to getBundleContext (OSGi 4.1)
if (meth == null)
meth = ReflectionUtils.findMethod(bundle.getClass(), "getBundleContext", new Class[0]);
final Method m = meth;
if (meth != null) {
ReflectionUtils.makeAccessible(meth);
return (BundleContext) ReflectionUtils.invokeMethod(m, bundle);
}
// fallback to field inspection (KF and Prosyst)
final BundleContext[] ctx = new BundleContext[1];
ReflectionUtils.doWithFields(
bundle.getClass(),
new FieldCallback() {
public void doWith(final Field field)
throws IllegalArgumentException, IllegalAccessException {
ReflectionUtils.makeAccessible(field);
ctx[0] = (BundleContext) field.get(bundle);
}
},
new FieldFilter() {
public boolean matches(Field field) {
return BundleContext.class.isAssignableFrom(field.getType());
}
});
return ctx[0];
}
private static void init(Bundle bundle) {
identifiedOsgiImpl = true;
try {
isEquinox =
bundle
.getClass()
.getClassLoader()
.loadClass("org.eclipse.osgi.framework.internal.core.BundleHost")
!= null;
} catch (Throwable t) {
isEquinox = false;
}
if (!isEquinox) {
try {
isFelix =
bundle.getClass().getClassLoader().loadClass("org.apache.felix.framework.BundleImpl")
!= null;
} catch (Throwable t2) {
isFelix = false;
}
}
// System.err.println("isEquinox=" + isEquinox);
// System.err.println("isFelix=" + isFelix);
}
protected File getEclipseBundleFileUsingReflection(Bundle bundle) {
try {
Object proxy = bundle.getClass().getMethod("getLoaderProxy").invoke(bundle);
Object loader = proxy.getClass().getMethod("getBundleLoader").invoke(proxy);
URL root =
(URL) loader.getClass().getMethod("findResource", String.class).invoke(loader, "/");
Field field = root.getClass().getDeclaredField("handler");
field.setAccessible(true);
Object handler = field.get(root);
Field entryField = handler.getClass().getSuperclass().getDeclaredField("bundleEntry");
entryField.setAccessible(true);
Object entry = entryField.get(handler);
Field fileField = entry.getClass().getDeclaredField("file");
fileField.setAccessible(true);
return (File) fileField.get(entry);
} catch (Throwable e) {
log.error("Cannot access to eclipse bundle system files of " + bundle.getSymbolicName());
return null;
}
}
/** @see WebXmlParser#parse(InputStream) */
public WebApp parse(final Bundle bundle, final InputStream inputStream) {
final WebApp webApp = new WebApp(); // changed to final because of inner
// class.
try {
final Element rootElement = getRootElement(inputStream);
if (rootElement != null) {
// webApp = new WebApp();
// web-app attributes
String version = getAttribute(rootElement, "version");
Integer majorVersion = null;
if (version != null && !version.isEmpty() && version.length() > 2) {
LOG.debug("version found in web.xml - " + version);
try {
majorVersion = Integer.parseInt(version.split("\\.")[0]);
} catch (NumberFormatException nfe) {
// munch do nothing here stay with null therefore
// annotation scanning is disabled.
}
} else if (version != null && !version.isEmpty() && version.length() > 0) {
try {
majorVersion = Integer.parseInt(version);
} catch (NumberFormatException e) {
// munch do nothing here stay with null....
}
}
Boolean metaDataComplete =
Boolean.parseBoolean(getAttribute(rootElement, "metadata-complete", "false"));
webApp.setMetaDataComplete(metaDataComplete);
LOG.debug("metadata-complete is: " + metaDataComplete);
// web-app elements
webApp.setDisplayName(getTextContent(getChild(rootElement, "display-name")));
parseContextParams(rootElement, webApp);
parseSessionConfig(rootElement, webApp);
parseServlets(rootElement, webApp);
parseFilters(rootElement, webApp);
parseListeners(rootElement, webApp);
parseErrorPages(rootElement, webApp);
parseWelcomeFiles(rootElement, webApp);
parseMimeMappings(rootElement, webApp);
parseSecurity(rootElement, webApp);
LOG.debug("scanninf for ServletContainerInitializers");
ServiceLoader<ServletContainerInitializer> serviceLoader =
ServiceLoader.load(
ServletContainerInitializer.class, bundle.getClass().getClassLoader());
if (serviceLoader != null) {
LOG.debug("ServletContainerInitializers found");
while (serviceLoader.iterator().hasNext()) {
// for (ServletContainerInitializer service :
// serviceLoader) {
ServletContainerInitializer service = null;
try {
bundle.loadClass(ServletContainerInitializer.class.getName());
Object obj = serviceLoader.iterator().next();
if (obj instanceof ServletContainerInitializer)
service = (ServletContainerInitializer) obj;
else continue;
} catch (ServiceConfigurationError e) {
LOG.error("ServiceConfigurationError loading ServletContainerInitializer", e);
continue;
} catch (ClassNotFoundException e) {
LOG.error("ServiceConfigurationError loading ServletContainerInitializer", e);
continue;
}
WebAppServletContainerInitializer webAppServletContainerInitializer =
new WebAppServletContainerInitializer();
webAppServletContainerInitializer.setServletContainerInitializer(service);
if (!webApp.getMetaDataComplete() && majorVersion != null && majorVersion >= 3) {
HandlesTypes annotation = service.getClass().getAnnotation(HandlesTypes.class);
Class[] classes;
if (annotation != null) {
// add annotated classes to service
classes = annotation.value();
webAppServletContainerInitializer.setClasses(classes);
}
}
webApp.addServletContainerInitializer(webAppServletContainerInitializer);
}
}
if (!webApp.getMetaDataComplete() && majorVersion != null && majorVersion >= 3) {
LOG.debug("metadata-complete is either false or not set");
LOG.debug("scanning for annotated classes");
Enumeration<?> clazzes = bundle.findEntries("/", "*.class", true);
for (; clazzes.hasMoreElements(); ) {
URL clazzUrl = (URL) clazzes.nextElement();
Class<?> clazz;
String clazzFile = clazzUrl.getFile();
LOG.debug("Class file found at :" + clazzFile);
if (clazzFile.startsWith("/WEB-INF/classes"))
clazzFile = clazzFile.replaceFirst("/WEB-INF/classes", "");
else if (clazzFile.startsWith("/WEB-INF/lib"))
clazzFile = clazzFile.replaceFirst("/WEB-INF/lib", "");
String clazzName =
clazzFile.replaceAll("/", ".").replaceAll(".class", "").replaceFirst(".", "");
try {
clazz = bundle.loadClass(clazzName);
} catch (ClassNotFoundException e) {
LOG.debug("Class {} not found", clazzName);
continue;
}
if (clazz.isAnnotationPresent(WebServlet.class)) {
LOG.debug("found WebServlet annotation on class: " + clazz);
WebServletAnnotationScanner annonScanner =
new WebServletAnnotationScanner(bundle, clazz.getCanonicalName());
annonScanner.scan(webApp);
} else if (clazz.isAnnotationPresent(WebFilter.class)) {
LOG.debug("found WebFilter annotation on class: " + clazz);
WebFilterAnnotationScanner filterScanner =
new WebFilterAnnotationScanner(bundle, clazz.getCanonicalName());
filterScanner.scan(webApp);
} else if (clazz.isAnnotationPresent(WebListener.class)) {
LOG.debug("found WebListener annotation on class: " + clazz);
addWebListener(webApp, clazz.getSimpleName());
}
}
LOG.debug("class scanning done");
}
// special handling for finding JSF Context listeners wrapped in
// *.tld files
Enumeration tldEntries = bundle.getResources("*.tld");
// Enumeration tldEntries = bundle.findEntries("/", "*.tld",
// true);
while (tldEntries != null && tldEntries.hasMoreElements()) {
URL url = (URL) tldEntries.nextElement();
Element rootTld = getRootElement(url.openStream());
if (rootTld != null) {
parseListeners(rootTld, webApp);
}
}
} else {
LOG.warn("The parsed web.xml does not have a root element");
return null;
}
} catch (ParserConfigurationException ignore) {
LOG.error("Cannot parse web.xml", ignore);
} catch (IOException ignore) {
LOG.error("Cannot parse web.xml", ignore);
} catch (SAXException ignore) {
LOG.error("Cannot parse web.xml", ignore);
}
return webApp;
}