/*******************************************************************************
* Copyright (c) 2001, 2006 IBM Corporation and others.
* 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:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.jst.j2ee.commonarchivecore.internal.util;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLConnection;
import java.net.URLStreamHandler;
import java.security.ProtectionDomain;
import java.util.HashSet;
import java.util.Set;
import org.eclipse.jst.j2ee.commonarchivecore.internal.Archive;
import org.eclipse.jst.j2ee.commonarchivecore.internal.CommonArchiveResourceHandler;
import org.eclipse.jst.j2ee.commonarchivecore.internal.EARFile;
import org.eclipse.jst.j2ee.commonarchivecore.internal.File;
import org.eclipse.jst.j2ee.commonarchivecore.internal.exception.ArchiveRuntimeException;
import org.eclipse.jst.j2ee.core.internal.plugin.J2EECorePlugin;
/**
* Class loader which loads a given set of classes stored in byte arrays. (Assumption: System
* classes and those in the set are the only classes needed to resolve each one)
*/
public class ArchiveFileDynamicClassLoader extends ClassLoader {
protected Archive archive = null;
protected ClassLoader extraClassLoader;
protected boolean inEARFile;
private static final String URL_PROTOCOL = "archive"; //$NON-NLS-1$
private ArchiveURLStreamHandler handler;
protected ProtectionDomain protectionDomain;
/**
* <p>This constructor accepts a protection domain, which is used
* by <code>findClass</code>.</p>
*
* @see ArchiveFileDynamicClassLoader#findClass(String)
*/
public ArchiveFileDynamicClassLoader(Archive anArchive, ClassLoader parentCl, ClassLoader extraCl, ProtectionDomain pDomain) {
super(parentCl);
setArchive(anArchive);
setExtraClassLoader(extraCl);
inEARFile = anArchive.getContainer() != null && anArchive.getContainer().isEARFile();
handler = new ArchiveURLStreamHandler();
protectionDomain = pDomain;
}
public ArchiveFileDynamicClassLoader(Archive anArchive, ClassLoader parentCl, ClassLoader extraCl) {
this(anArchive, parentCl, extraCl, null);
}
/**
* <p>Loads a specified class. Called only after the parent class loader has had
* its chance to load the class, as per the Java2 delegation model.</p>
*
* <p>When non-null, the receiver's protection
* domain is passed in to the call to <code>defineClass</code>.</p>
*
* @see ClassLoader#defineClass(String, byte[], int)
* @see ClassLoader#defineClass(String, byte[], int, ProtectionDomain)
*/
@Override
protected Class findClass(String name) throws ClassNotFoundException {
Class result;
// Load class bytes from current set of class byte[]'s
byte[] bytes = getClassBytesFor(name);
if (bytes != null) {
if ( protectionDomain == null ) {
result = defineClass(name, bytes, 0, bytes.length);
} else {
result = defineClass(name, bytes, 0, bytes.length, protectionDomain);
}
if (result == null) {
throw new ClassNotFoundException(name);
} // endif
} else {
throw new ClassNotFoundException(name);
} // endif
return result;
}
/**
* Insert the method's description here. Creation date: (12/17/00 9:59:57 PM)
*
* @return com.ibm.etools.commonarchive.Archive
*/
public Archive getArchive() {
return archive;
}
private byte[] getData(File file) {
if (null != file) {
try {
return ArchiveUtil.inputStreamToBytes(file.getInputStream());
} catch (FileNotFoundException e) {
return null;
} catch (IOException e) {
throw new ArchiveRuntimeException(CommonArchiveResourceHandler.getString(CommonArchiveResourceHandler.io_ex_loading_EXC_, (new Object[]{file.getName()})), e); // = "An IO exception occurred loading " }
}
}
return null;
}
protected byte[] getClassBytesFor(String className) {
if (className == null)
return null;
// Change the class name to a jar entry name
String jarEntryName = ArchiveUtil.classNameToUri(className);
return getData(getFile(jarEntryName));
}
protected EARFile getEARFile() {
return (EARFile) getArchive().getContainer();
}
/**
* Insert the method's description here. Creation date: (11/21/00 6:58:05 PM)
*
* @return java.lang.ClassLoader
*/
public java.lang.ClassLoader getExtraClassLoader() {
return extraClassLoader;
}
/**
* Used for dynamic class loading in dependent jars in ears; the set is used to terminate a
* cycle if one exists; the cycle is invalid, but you never know what people might try...
*/
protected synchronized Class loadClass(String name, Set visitedArchives) throws ClassNotFoundException {
if (visitedArchives.contains(getArchive()))
throw new ClassNotFoundException(name);
visitedArchives.add(getArchive());
try {
return super.loadClass(name, false);
} catch (ClassNotFoundException ex) {
return loadClassInDependentJarInEAR(name, visitedArchives);
}
}
@Override
protected synchronized Class loadClass(String name, boolean resolve) throws ClassNotFoundException {
try {
return super.loadClass(name, resolve);
} catch (ClassNotFoundException ex) {
Class c = loadClassInDependentJar(name);
if (c != null && resolve)
resolveClass(c);
return c;
}
}
protected Class loadClassInDependentJar(String name) throws ClassNotFoundException {
if (inEARFile) {
return loadClassInDependentJarInEAR(name);
} else if (getExtraClassLoader() != null) {
return getExtraClassLoader().loadClass(name);
}
throw new ClassNotFoundException(name);
}
protected Class loadClassInDependentJarInEAR(String name, Set visitedArchives) throws ClassNotFoundException {
Object obj = getResourceInDependentJarInEAR(name, visitedArchives, CLASS_TYPE);
if (obj == null) {
throw new ClassNotFoundException(name);
}
return (Class) obj;
}
protected Class loadClassInDependentJarInEAR(String name) throws ClassNotFoundException {
Object obj = getResourceInDependentJarInEAR(name, CLASS_TYPE);
if (obj == null) {
throw new ClassNotFoundException(name);
}
return (Class) obj;
}
protected File getFileFromDependentJar(String name) {
Object obj = getResourceInDependentJarInEAR(name, FILE_TYPE);
if (obj != null) {
return (File) obj;
}
return null;
}
protected static final int CLASS_TYPE = 0;
protected static final int FILE_TYPE = 1;
protected Object getResourceInDependentJarInEAR(String name, int type) {
Set visitedArchives = new HashSet(5);
visitedArchives.add(getArchive());
return getResourceInDependentJarInEAR(name, visitedArchives, type);
}
protected Object getResourceInDependentJarInEAR(String name, Set visitedArchives, int type) {
String[] classpath = archive.getManifest().getClassPathTokenized();
for (int i = 0; i < classpath.length; i++) {
try {
String uri = ArchiveUtil.deriveEARRelativeURI(classpath[i], archive);
if (uri == null)
continue;
File jarFile = getEARFile().getFile(uri);
if (jarFile.isArchive()) {
Archive dep = (Archive) jarFile;
switch (type) {
case CLASS_TYPE :
try {
return ((ArchiveFileDynamicClassLoader) dep.getArchiveClassLoader()).loadClass(name, visitedArchives);
} catch (ClassNotFoundException noDice) {
continue;
}
case FILE_TYPE :
try {
return dep.getFile(name);
} catch (FileNotFoundException noDice) {
continue;
}
}
}
} catch (java.io.FileNotFoundException depJarNotInEAR) {
}
}
return null;
}
/**
* Insert the method's description here. Creation date: (12/17/00 9:59:57 PM)
*
* @param newArchive
* com.ibm.etools.commonarchive.Archive
*/
public void setArchive(Archive newArchive) {
archive = newArchive;
}
/**
* Insert the method's description here. Creation date: (11/21/00 6:58:05 PM)
*
* @param newExtraClassLoader
* java.lang.ClassLoader
*/
public void setExtraClassLoader(java.lang.ClassLoader newExtraClassLoader) {
extraClassLoader = newExtraClassLoader;
}
@Override
public InputStream getResourceAsStream(String name) {
try {
File file = getFile(name);
if (null != file) {
return file.getInputStream();
}
} catch (IOException e) {
throw new ArchiveRuntimeException(CommonArchiveResourceHandler.getString(CommonArchiveResourceHandler.io_ex_loading_EXC_, (new Object[]{name})), e); // = "An IO exception occurred loading "
}
return null;
}
protected File getFileFromArchive(String name) {
try {
return getArchive().getFile(name);
} catch (FileNotFoundException e) {
}
return null;
}
protected File getFile(String name) {
File file = getFileFromArchive(name);
if (file == null) {
file = getFileFromDependentJar(name);
}
return file;
}
@Override
protected URL findResource(String name) {
if (getFile(name) != null) {
try {
return new URL(null, URL_PROTOCOL + "://" + name, handler); //$NON-NLS-1$
} catch (MalformedURLException e) {
J2EECorePlugin.logError(e);
throw new RuntimeException(e);
}
}
return null;
}
private class ArchiveURLStreamHandler extends URLStreamHandler {
public ArchiveURLStreamHandler() {
}
@Override
protected URLConnection openConnection(URL url) throws IOException {
return new ArchiveURLConnection(url);
}
}
private class ArchiveURLConnection extends URLConnection {
private String resourceName;
protected ArchiveURLConnection(URL url) {
super(url);
resourceName = url.toString().substring(URL_PROTOCOL.length() + 3);
}
@Override
public void connect() throws IOException {
}
@Override
public InputStream getInputStream() throws IOException {
return getResourceAsStream(resourceName);
}
}
}