/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.dragome.callbackevictor.serverside;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import com.dragome.callbackevictor.serverside.bytecode.transformation.ResourceTransformer;
import com.dragome.callbackevictor.serverside.bytecode.transformation.asm.AsmClassTransformer;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.net.URLClassLoader;
import java.security.AccessControlContext;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.security.ProtectionDomain;
import java.util.ArrayList;
import java.util.List;
/**
* {@link URLClassLoader} with bytecode instrumentation for javaflow.
*
* <p>
* This class loader is useful where the application can set up multiple
* class loaders (such as in a container environment,
* <a href="http://classworlds.codehaus.org/">ClassWorlds</a>, or
* <a href="http://forehead.werken.com/">Forehead</a>) and when you can
* isolate the continuation-enabled portion of your application into a separate
* jar file.
*/
public final class ContinuationClassLoader extends URLClassLoader {
private final static Log log = LogFactory.getLog(ContinuationClassLoader.class);
private final ResourceTransformer transformer;
/**
* Indicates whether the parent class loader should be
* consulted before trying to load with this class loader.
*/
private boolean parentFirst = true;
/**
* These are the package roots that are to be loaded by the parent class
* loader regardless of whether the parent class loader is being searched
* first or not.
*/
private List<String> systemPackages = new ArrayList<String>();
/**
* These are the package roots that are to be loaded by this class loader
* regardless of whether the parent class loader is being searched first
* or not.
*/
private List<String> loaderPackages = new ArrayList<String>();
/**
* Whether or not this classloader will ignore the base
* classloader if it can't find a class.
*
* @see #setIsolated(boolean)
*/
private boolean ignoreBase = false;
/* The context to be used when loading classes and resources */
private final AccessControlContext acc;
private static final int BUFFER_SIZE = 4096;
/**
* Creates a classloader by using the classpath given.
*
* @param urls
* The URLs from which to load classes and resources
* @param parent
* The parent classloader to which unsatisfied loading
* attempts are delegated. May be <code>null</code>,
* in which case the {@link ClassLoader#getSystemClassLoader() system classloader}
* is used as the parent.
* @param transformer
* This transformer is used to perform the byte-code enhancement.
* May not be null.
*/
public ContinuationClassLoader(URL[] urls, ClassLoader parent, ResourceTransformer transformer) {
super(urls,fixNullParent(parent));
if(transformer==null)
throw new IllegalArgumentException();
this.transformer = transformer;
acc = AccessController.getContext();
}
public ContinuationClassLoader(URL[] urls, ClassLoader parent) {
this(urls,parent,new AsmClassTransformer());
}
private static ClassLoader fixNullParent(ClassLoader classLoader) {
if(classLoader!=null) {
return classLoader;
} else {
return getSystemClassLoader();
}
}
/**
* Control whether class lookup is delegated to the parent loader first
* or after this loader. Use with extreme caution. Setting this to
* false violates the class loader hierarchy and can lead to Linkage errors
*
* @param parentFirst if true, delegate initial class search to the parent
* classloader.
*/
public void setParentFirst(boolean parentFirst) {
this.parentFirst = parentFirst;
}
/**
* Sets whether this classloader should run in isolated mode. In
* isolated mode, classes not found on the given classpath will
* not be referred to the parent class loader but will cause a
* ClassNotFoundException.
*
* @param isolated Whether or not this classloader should run in
* isolated mode.
*/
public void setIsolated(boolean isolated) {
ignoreBase = isolated;
}
/**
* Adds a package root to the list of packages which must be loaded on the
* parent loader.
*
* All subpackages are also included.
*
* @param packageRoot The root of all packages to be included.
* Should not be <code>null</code>.
*/
public synchronized void addSystemPackageRoot(String packageRoot) {
systemPackages.add(appendDot(packageRoot));
}
/**
* Adds a package root to the list of packages which must be loaded using
* this loader.
*
* All subpackages are also included.
*
* @param packageRoot The root of all packages to be included.
* Should not be <code>null</code>.
*/
public synchronized void addLoaderPackageRoot(String packageRoot) {
loaderPackages.add(appendDot(packageRoot));
}
private String appendDot(String str) {
if(str.endsWith("."))
str += '.';
return str;
}
/**
* Loads a class through this class loader even if that class is available
* on the parent classpath.
*
* This ensures that any classes which are loaded by the returned class
* will use this classloader.
*
* @param classname The name of the class to be loaded.
* Must not be <code>null</code>.
*
* @return the required Class object
*
* @exception ClassNotFoundException if the requested class does not exist
* on this loader's classpath.
*/
public Class<?> forceLoadClass(String classname)
throws ClassNotFoundException {
log.debug("force loading " + classname);
Class<?> theClass = findLoadedClass(classname);
if (theClass == null) {
theClass = findClass(classname);
}
return theClass;
}
/**
* Tests whether or not the parent classloader should be checked for
* a resource before this one. If the resource matches both the
* "use parent classloader first" and the "use this classloader first"
* lists, the latter takes priority.
*
* @param resourceName The name of the resource to check.
* Must not be <code>null</code>.
*
* @return whether or not the parent classloader should be checked for a
* resource before this one is.
*/
private synchronized boolean isParentFirst(String resourceName) {
// default to the global setting and then see
// if this class belongs to a package which has been
// designated to use a specific loader first
// (this one or the parent one)
// XXX - shouldn't this always return false in isolated mode?
boolean useParentFirst = parentFirst;
for (final String packageName : systemPackages) {
if (resourceName.startsWith(packageName)) {
useParentFirst = true;
break;
}
}
for (final String packageName : loaderPackages) {
if (resourceName.startsWith(packageName)) {
useParentFirst = false;
break;
}
}
return useParentFirst;
}
/**
* Loads a class with this class loader.
*
* This class attempts to load the class in an order determined by whether
* or not the class matches the system/loader package lists, with the
* loader package list taking priority. If the classloader is in isolated
* mode, failure to load the class in this loader will result in a
* ClassNotFoundException.
*
* @param classname The name of the class to be loaded.
* Must not be <code>null</code>.
* @param resolve <code>true</code> if all classes upon which this class
* depends are to be loaded.
*
* @return the required Class object
*
* @exception ClassNotFoundException if the requested class does not exist
* on the system classpath (when not in isolated mode) or this loader's
* classpath.
*/
protected synchronized Class<?> loadClass(String classname, boolean resolve)
throws ClassNotFoundException {
// 'sync' is needed - otherwise 2 threads can load the same class
// twice, resulting in LinkageError: duplicated class definition.
// findLoadedClass avoids that, but without sync it won't work.
Class<?> theClass = findLoadedClass(classname);
if (theClass != null) {
return theClass;
}
if (isParentFirst(classname)) {
try {
theClass = getParent().loadClass(classname);
log.debug("Class " + classname + " loaded from parent loader "
+ "(parentFirst)");
} catch (ClassNotFoundException cnfe) {
theClass = findClass(classname);
log.debug("Class " + classname + " loaded from ant loader "
+ "(parentFirst)");
}
} else {
try {
theClass = findClass(classname);
log.debug("Class " + classname + " loaded from ant loader");
} catch (ClassNotFoundException cnfe) {
if (ignoreBase) {
throw cnfe;
}
theClass = getParent().loadClass(classname);
log.debug("Class " + classname + " loaded from parent loader");
}
}
if (resolve) {
resolveClass(theClass);
}
return theClass;
}
/**
* Define a class given its bytes
*
* @param classData the bytecode data for the class
* @param classname the name of the class
*
* @return the Class instance created from the given data
*/
protected Class<?> defineClassFromData(final byte[] classData, final String classname) {
return AccessController.doPrivileged(new PrivilegedAction<Class<?>>() {
public Class<?> run() {
// define a package if necessary.
int i = classname.lastIndexOf('.');
if (i>0) {
final String packageName = classname.substring(0,i);
final Package pkg = getPackage(packageName);
if (pkg == null) {
definePackage(packageName,null,null,null,null,null,null,null);
}
}
final byte[] newData = transformer.transform(classData);
final ProtectionDomain domain = this.getClass().getProtectionDomain();
return defineClass(classname,newData,0,newData.length,domain);
}
}, acc);
}
/**
* Reads a class definition from a stream.
*
* @param stream The stream from which the class is to be read.
* Must not be <code>null</code>.
* @param classname The name of the class in the stream.
* Must not be <code>null</code>.
*
* @return the Class object read from the stream.
*
* @exception IOException if there is a problem reading the class from the
* stream.
* @exception SecurityException if there is a security problem while
* reading the class from the stream.
*/
private Class<?> getClassFromStream(InputStream stream, String classname) throws IOException, SecurityException {
final ByteArrayOutputStream baos = new ByteArrayOutputStream();
try {
int bytesRead;
byte[] buffer = new byte[BUFFER_SIZE];
while ((bytesRead = stream.read(buffer, 0, BUFFER_SIZE)) != -1) {
baos.write(buffer, 0, bytesRead);
}
byte[] classData = baos.toByteArray();
return defineClassFromData(classData, classname);
} finally {
baos.close();
}
}
/**
* Searches for and load a class on the classpath of this class loader.
*
* @param name The name of the class to be loaded. Must not be
* <code>null</code>.
*
* @return the required Class object
*
* @exception ClassNotFoundException if the requested class does not exist
* on this loader's classpath.
*/
public Class<?> findClass(final String name) throws ClassNotFoundException {
log.debug("Finding class " + name);
// locate the class file
String classFileName = name.replace('.', '/') + ".class";
InputStream stream = getResourceAsStream(classFileName);
if(stream==null)
throw new ClassNotFoundException(name);
try {
return getClassFromStream(stream, name);
} catch (IOException e) {
throw new ClassNotFoundException(name,e);
} finally {
try {
stream.close();
} catch (IOException e) {
// ignore
}
}
}
/**
* Finds the resource with the given name. A resource is
* some data (images, audio, text, etc) that can be accessed by class
* code in a way that is independent of the location of the code.
*
* @param name The name of the resource for which a stream is required.
* Must not be <code>null</code>.
* @return a URL for reading the resource, or <code>null</code> if the
* resource could not be found or the caller doesn't have
* adequate privileges to get the resource.
*/
public synchronized URL getResource(String name) {
// we need to search the components of the path to see if
// we can find the class we want.
if (isParentFirst(name)) {
return super.getResource(name);
}
// try this class loader first, then parent
URL url = findResource(name);
if(url==null) {
url = getParent().getResource(name);
}
return url;
}
}