/*******************************************************************************
* Copyright (c) 2008, 2010 VMware Inc.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* VMware Inc. - initial contribution
*******************************************************************************/
package org.eclipse.virgo.kernel.userregion.internal.equinox;
import java.io.IOException;
import java.lang.instrument.ClassFileTransformer;
import java.lang.instrument.IllegalClassFormatException;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.net.URL;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.security.ProtectionDomain;
import java.sql.Driver;
import java.sql.DriverManager;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.Vector;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.CopyOnWriteArrayList;
import org.eclipse.osgi.baseadaptor.BaseData;
import org.eclipse.osgi.baseadaptor.bundlefile.BundleEntry;
import org.eclipse.osgi.baseadaptor.loader.ClasspathEntry;
import org.eclipse.osgi.baseadaptor.loader.ClasspathManager;
import org.eclipse.osgi.framework.adaptor.ClassLoaderDelegate;
import org.eclipse.osgi.internal.baseadaptor.DefaultClassLoader;
import org.eclipse.osgi.service.resolver.PlatformAdmin;
import org.osgi.framework.Bundle;
import org.osgi.framework.BundleContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.eclipse.virgo.kernel.osgi.framework.ExtendedClassNotFoundException;
import org.eclipse.virgo.kernel.osgi.framework.ExtendedNoClassDefFoundError;
import org.eclipse.virgo.kernel.osgi.framework.InstrumentableClassLoader;
import org.eclipse.virgo.kernel.osgi.framework.OsgiFrameworkUtils;
/**
* Extension to {@link DefaultClassLoader} that adds instrumentation support.
* <p/>
*
* <strong>Concurrent Semantics</strong><br />
*
* As threadsafe as <code>DefaultClassLoader</code>.
*
*/
public final class KernelBundleClassLoader extends DefaultClassLoader implements InstrumentableClassLoader {
static {
try {
Method parallelCapableMethod = ClassLoader.class.getDeclaredMethod("registerAsParallelCapable", (Class[]) null);
parallelCapableMethod.setAccessible(true);
parallelCapableMethod.invoke(null, new Object[0]);
} catch (Throwable e) {
// must avoid failing in clinit
}
}
private static final String[] EXCLUDED_PACKAGES = new String[] { "java.", "javax.", "sun.", "oracle." };
private static final String HEADER_INSTRUMENT_PACKAGE = "Instrument-Package";
private static final Logger LOGGER = LoggerFactory.getLogger(KernelBundleClassLoader.class);
private final List<ClassFileTransformer> classFileTransformers = new CopyOnWriteArrayList<ClassFileTransformer>();
private final String[] instrumentedPackages;
private final String[] classpath;
private final String bundleScope;
private final Set<Class<Driver>> loadedDriverClasses = new HashSet<Class<Driver>>();
private final Object monitor = new Object();
private volatile boolean instrumented;
/**
* Constructs a new <code>ServerBundleClassLoader</code>.
*
* @param parent the parent <code>ClassLoader</code>.
* @param delegate the delegate for this ClassLoader</code>
* @param domain the domain for this ClassLoader</code>
* @param bundledata the bundledata for this ClassLoader</code>
* @param classpath the classpath for this ClassLoader</code>
*/
KernelBundleClassLoader(ClassLoader parent, ClassLoaderDelegate delegate, ProtectionDomain domain, BaseData bundledata, String[] classpath) {
super(parent, delegate, domain, bundledata, classpath);
this.classpath = classpath;
this.bundleScope = OsgiFrameworkUtils.getScopeName(bundledata.getBundle());
this.instrumentedPackages = findInstrumentedPackages(bundledata.getBundle());
}
/**
* {@inheritDoc}
*/
public void addClassFileTransformer(ClassFileTransformer transformer) {
this.instrumented = true;
synchronized (this.classFileTransformers) {
if (this.classFileTransformers.contains(transformer)) {
return;
}
this.classFileTransformers.add(transformer);
}
Bundle[] bundles = getDependencyBundles(false);
for (Bundle bundle : bundles) {
if (propagateInstrumentationTo(bundle)) {
ClassLoader bundleClassLoader = getBundleClassLoader(bundle);
if (bundleClassLoader instanceof KernelBundleClassLoader) {
((KernelBundleClassLoader) bundleClassLoader).addClassFileTransformer(transformer);
}
}
}
}
/**
* @param bundle
* @return
*/
private ClassLoader getBundleClassLoader(Bundle bundle) {
return EquinoxUtils.getBundleClassLoader(bundle);
}
/**
* {@inheritDoc}
*/
@Override
protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
try {
Class<?> loadedClass = super.loadClass(name, resolve);
storeClassIfDriver(loadedClass);
return loadedClass;
} catch (ClassNotFoundException e) {
throw new ExtendedClassNotFoundException(this, e);
} catch (NoClassDefFoundError e) {
throw new ExtendedNoClassDefFoundError(this, e);
}
}
/**
* {@inheritDoc}
*/
public boolean isInstrumented() {
return this.instrumented;
}
/**
* {@inheritDoc}
*/
public int getClassFileTransformerCount() {
return this.classFileTransformers.size();
}
/**
* Finds the explicit list of packages to include in instrumentation (if specified).
*/
private String[] findInstrumentedPackages(Bundle bundle) {
String headerValue = (String) bundle.getHeaders().get(HEADER_INSTRUMENT_PACKAGE);
if (headerValue == null || headerValue.length() == 0) {
return new String[0];
} else {
String[] vals = headerValue.split(",");
String[] packageNames = new String[vals.length];
for (int x = 0; x < packageNames.length; x++) {
packageNames[x] = vals[x].trim();
}
return packageNames;
}
}
private boolean propagateInstrumentationTo(Bundle bundle) {
return !EquinoxUtils.isSystemBundle(bundle) && this.bundleScope != null && this.bundleScope.equals(OsgiFrameworkUtils.getScopeName(bundle));
}
private boolean shouldInstrument(String className) {
return includedForInstrumentation(className) && !excludedFromInstrumentation(className);
}
private boolean includedForInstrumentation(String className) {
if (this.instrumentedPackages.length == 0) {
return true;
}
for (String instrumentedPackage : this.instrumentedPackages) {
if (className.startsWith(instrumentedPackage)) {
return true;
}
}
return false;
}
private boolean excludedFromInstrumentation(String className) {
for (String excludedPackage : EXCLUDED_PACKAGES) {
if (className.startsWith(excludedPackage)) {
return true;
}
}
return false;
}
/**
* {@inheritDoc}
*/
public ThrowAwayClassLoader createThrowAway() {
final ClasspathManager manager = new ClasspathManager(this.manager.getBaseData(), this.classpath, this);
manager.initialize();
return AccessController.doPrivileged(new PrivilegedAction<ThrowAwayClassLoader>() {
public ThrowAwayClassLoader run() {
return new ThrowAwayClassLoader(manager);
}
});
}
/**
* {@inheritDoc}
*/
@Override
public Class<?> defineClass(String name, byte[] classbytes, ClasspathEntry classpathEntry, BundleEntry entry) {
byte[] transformedBytes = classbytes;
if (shouldInstrument(name)) {
for (ClassFileTransformer transformer : this.classFileTransformers) {
try {
String transformName = name.replaceAll("\\.", "/");
byte[] transform = transformer.transform(this, transformName, null, this.domain, transformedBytes);
if (transform != null) {
transformedBytes = transform;
}
} catch (IllegalClassFormatException e) {
throw new ClassFormatError("Error reading class from bundle entry '" + entry.getName() + "'. " + e.getMessage());
}
}
}
try {
Class<?> definedClass = super.defineClass(name, transformedBytes, classpathEntry, entry);
storeClassIfDriver(definedClass);
return definedClass;
} catch (NoClassDefFoundError e) {
throw new ExtendedNoClassDefFoundError(this, e);
}
}
/**
* @param definedClass
*/
@SuppressWarnings("unchecked")
private void storeClassIfDriver(Class<?> candidateClass) {
if (Driver.class.isAssignableFrom(candidateClass)) {
synchronized (this.monitor) {
this.loadedDriverClasses.add((Class<Driver>) candidateClass);
}
}
}
@Override
public void close() {
clearJdbcDrivers();
}
private void clearJdbcDrivers() {
Set<Class<Driver>> localLoadedDriverClasses;
synchronized (this.monitor) {
localLoadedDriverClasses = new HashSet<Class<Driver>>(this.loadedDriverClasses);
}
synchronized (DriverManager.class) {
try { // Java 6
Field writeDriversField = DriverManager.class.getDeclaredField("writeDrivers");
writeDriversField.setAccessible(true);
Vector<?> writeDrivers = (Vector<?>) writeDriversField.get(null);
Iterator<?> driverElements = writeDrivers.iterator();
while (driverElements.hasNext()) {
Object driverObj = driverElements.next();
Field driverField = driverObj.getClass().getDeclaredField("driver");
driverField.setAccessible(true);
if (localLoadedDriverClasses.contains(driverField.get(driverObj).getClass())) {
driverElements.remove();
}
}
Vector<?> readDrivers = (Vector<?>) writeDrivers.clone();
Field readDriversField = DriverManager.class.getDeclaredField("readDrivers");
readDriversField.setAccessible(true);
readDriversField.set(null, readDrivers);
LOGGER.debug("Cleared JDBC drivers for " + this + " using Java 6 strategy");
} catch (Exception javaSixWayFailed) {
try { // Java 7
Field registeredDriversField = DriverManager.class.getDeclaredField("registeredDrivers");
registeredDriversField.setAccessible(true);
CopyOnWriteArrayList<?> registeredDrivers = (CopyOnWriteArrayList<?>) registeredDriversField.get(null);
Iterator<?> driverElements = registeredDrivers.iterator();
List<Object> driverElementsToRemove = new ArrayList<Object>();
while (driverElements.hasNext()) {
Object driverObj = driverElements.next();
Field driverField = driverObj.getClass().getDeclaredField("driver");
driverField.setAccessible(true);
if (localLoadedDriverClasses.contains(driverField.get(driverObj).getClass())) {
driverElementsToRemove.add(driverObj);
}
}
for (Object driverObj : driverElementsToRemove) {
registeredDrivers.remove(driverObj);
}
LOGGER.debug("Cleared JDBC drivers for " + this + " using Java 7 strategy");
} catch (Exception e) {
LOGGER.warn("Failure when clearing JDBC drivers for " + this, e);
}
}
}
}
@Override
public String toString() {
return String.format("%s: [bundle=%s]", getClass().getSimpleName(), this.delegate);
}
private Bundle[] getDependencyBundles(boolean includeDependenciesFragments) {
Bundle bundle = this.manager.getBaseData().getBundle();
BundleContext systemBundleContext = getBundleContext();
PlatformAdmin serverAdmin = getPlatformAdmin();
Bundle[] deps = EquinoxUtils.getDirectDependencies(bundle, systemBundleContext, serverAdmin, includeDependenciesFragments);
return deps;
}
/**
* Gets the {@link BundleContext} for this ClassLoader's {@link Bundle}.
*
* @return the <code>BundleContext</code>.
*/
private BundleContext getBundleContext() {
return this.manager.getBaseData().getAdaptor().getContext();
}
/**
* Gets the {@link PlatformAdmin} service.
*
* @return the <code>PlatformAdmin</code> service.
*/
private PlatformAdmin getPlatformAdmin() {
return this.manager.getBaseData().getAdaptor().getPlatformAdmin();
}
/**
* Throwaway classloader for OSGi bundles.
* <p/>
*
* <strong>Concurrent Semantics</strong><br />
*
* As threadsafe as {@link ClassLoader}.
*
*/
final class ThrowAwayClassLoader extends ClassLoader {
private final ConcurrentMap<String, Class<?>> loadedClasses = new ConcurrentHashMap<String, Class<?>>();
private final ClasspathManager manager;
/**
* @param manager
*/
private ThrowAwayClassLoader(ClasspathManager manager) {
this.manager = manager;
}
/**
* {@inheritDoc}
*/
@Override
public Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
if (!shouldInstrument(name)) {
return KernelBundleClassLoader.this.loadClass(name, resolve);
}
Class<?> cls = KernelBundleClassLoader.this.findLoadedClass(name);
if (cls == null) {
cls = this.loadedClasses.get(name);
if (cls == null) {
cls = findClassInternal(name, true);
if (cls == null) {
cls = KernelBundleClassLoader.this.loadClass(name, resolve);
}
}
}
if (cls == null) {
throw new ClassNotFoundException(name);
}
if (resolve) {
resolveClass(cls);
}
// TODO review findbugs warning vs. failing tests in LoadTimeWeavingTests
this.loadedClasses.putIfAbsent(name, cls);
return cls;
}
/**
* Attempts to find a <code>Class</code> from the enclosing bundle.
*
* @param name the name of the <code>Class</code>
* @param traverseDependencies should dependency bundles be checked for the class.
*/
Class<?> findClassInternal(String name, boolean traverseDependencies) {
String path = name.replaceAll("\\.", "/").concat(".class");
BundleEntry entry = this.manager.findLocalEntry(path);
if (entry == null) {
if (traverseDependencies) {
return findClassFromImport(name);
} else {
return null;
}
}
byte[] bytes;
try {
bytes = entry.getBytes();
} catch (IOException e) {
bytes = null;
}
return bytes == null ? null : defineClass(name, bytes, 0, bytes.length);
}
/**
* Attempts to locate a <code>Class</code> from one of the imported bundles.
*
* @param name the <code>Class</code> name.
* @return the located <code>Class</code>, or <code>null</code> if no <code>Class</code> can be found.
*/
private Class<?> findClassFromImport(String name) {
Bundle[] deps = getDependencyBundles(false);
for (Bundle dep : deps) {
ClassLoader depClassLoader = getBundleClassLoader(dep);
if (depClassLoader instanceof KernelBundleClassLoader) {
KernelBundleClassLoader pbcl = (KernelBundleClassLoader) depClassLoader;
Class<?> loadedClass = pbcl.publicFindLoaded(name);
if (loadedClass != null) {
return loadedClass;
}
ThrowAwayClassLoader throwAway = pbcl.createThrowAway();
Class<?> cls = throwAway.findClassInternal(name, false);
if (cls != null) {
return cls;
}
}
}
return null;
}
/**
* {@inheritDoc}
*/
@Override
public URL getResource(String name) {
return KernelBundleClassLoader.this.getResource(name);
}
/**
* {@inheritDoc}
*/
@Override
public Enumeration<URL> getResources(String name) throws IOException {
return KernelBundleClassLoader.this.getResources(name);
}
}
}