/* license-start
*
* Copyright (C) 2008 - 2013 Crispico, <http://www.crispico.com/>.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation version 3.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details, at <http://www.gnu.org/licenses/>.
*
* Contributors:
* Crispico - Initial API and implementation
*
* license-end
*/
/*******************************************************************************
* Copyright (c) 2005-2007 Cognos Incorporated, 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:
* Cognos Incorporated - initial API and implementation
* IBM Corporation - bug fixes and enhancements
* Code 9 - bug fixes and enhancements
*******************************************************************************/
package org.eclipse.equinox.servletbridge;
import java.io.*;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.*;
import java.security.*;
import java.util.*;
import java.util.jar.*;
import javax.servlet.ServletConfig;
import javax.servlet.ServletContext;
// MODIF_FROM_ORIGINAL begin
// IMPORTANT !!!
// see FlowerFrameworkLauncher for details
// MODIF_FROM_ORIGINAL end
/**
* The FrameworkLauncher provides the logic to:
* 1) init
* 2) deploy
* 3) start
* 4) stop
* 5) undeploy
* 6) destroy
* an instance of the OSGi framework.
* These 6 methods are provided to help manage the life-cycle and are called from outside this
* class by the BridgeServlet. To create an extended FrameworkLauncher over-ride these methods to allow
* custom behavior.
*/
public class FrameworkLauncher {
private static final String WS_DELIM = " \t\n\r\f"; //$NON-NLS-1$
protected static final String FILE_SCHEME = "file:"; //$NON-NLS-1$
protected static final String FRAMEWORK_BUNDLE_NAME = "org.eclipse.osgi"; //$NON-NLS-1$
protected static final String STARTER = "org.eclipse.core.runtime.adaptor.EclipseStarter"; //$NON-NLS-1$
protected static final String FRAMEWORKPROPERTIES = "org.eclipse.osgi.framework.internal.core.FrameworkProperties"; //$NON-NLS-1$
protected static final String NULL_IDENTIFIER = "@null"; //$NON-NLS-1$
protected static final String OSGI_FRAMEWORK = "osgi.framework"; //$NON-NLS-1$
protected static final String OSGI_INSTANCE_AREA = "osgi.instance.area"; //$NON-NLS-1$
protected static final String OSGI_CONFIGURATION_AREA = "osgi.configuration.area"; //$NON-NLS-1$
protected static final String OSGI_INSTALL_AREA = "osgi.install.area"; //$NON-NLS-1$
protected static final String OSGI_FORCED_RESTART = "osgi.forcedRestart"; //$NON-NLS-1$
protected static final String RESOURCE_BASE = "/WEB-INF/"; //$NON-NLS-1$
protected static final String ECLIPSE = "eclipse/"; //$NON-NLS-1$
protected static final String LAUNCH_INI = "launch.ini"; //$NON-NLS-1$
private static final String MANIFEST_VERSION = "Manifest-Version"; //$NON-NLS-1$
private static final String BUNDLE_MANIFEST_VERSION = "Bundle-ManifestVersion"; //$NON-NLS-1$
private static final String BUNDLE_NAME = "Bundle-Name"; //$NON-NLS-1$
private static final String BUNDLE_SYMBOLIC_NAME = "Bundle-SymbolicName"; //$NON-NLS-1$
private static final String BUNDLE_VERSION = "Bundle-Version"; //$NON-NLS-1$
private static final String FRAGMENT_HOST = "Fragment-Host"; //$NON-NLS-1$
private static final String EXPORT_PACKAGE = "Export-Package"; //$NON-NLS-1$
private static final String CONFIG_COMMANDLINE = "commandline"; //$NON-NLS-1$
private static final String CONFIG_EXTENDED_FRAMEWORK_EXPORTS = "extendedFrameworkExports"; //$NON-NLS-1$
private static final String CONFIG_OVERRIDE_AND_REPLACE_EXTENSION_BUNDLE = "overrideAndReplaceExtensionBundle"; //$NON-NLS-1$
static final PermissionCollection allPermissions = new PermissionCollection() {
private static final long serialVersionUID = 482874725021998286L;
// The AllPermission permission
Permission allPermission = new AllPermission();
// A simple PermissionCollection that only has AllPermission
public void add(Permission permission) {
// do nothing
}
public boolean implies(Permission permission) {
return true;
}
public Enumeration elements() {
return new Enumeration() {
int cur = 0;
public boolean hasMoreElements() {
return cur < 1;
}
public Object nextElement() {
if (cur == 0) {
cur = 1;
return allPermission;
}
throw new NoSuchElementException();
}
};
}
};
static {
// We do this to ensure the anonymous Enumeration class in allPermissions is pre-loaded
if (allPermissions.elements() == null)
throw new IllegalStateException();
}
protected ServletConfig config;
protected ServletContext context;
protected String resourceBase;
private File platformDirectory;
private ClassLoader frameworkContextClassLoader;
private URLClassLoader frameworkClassLoader;
void init(ServletConfig servletConfig) {
config = servletConfig;
context = servletConfig.getServletContext();
initResourceBase();
init();
}
/**
* try to find the resource base for this webapp by looking for the launcher initialization file.
*/
protected void initResourceBase() {
try {
if (context.getResource(RESOURCE_BASE + LAUNCH_INI) != null) {
resourceBase = RESOURCE_BASE;
return;
}
if (context.getResource(RESOURCE_BASE + ECLIPSE + LAUNCH_INI) != null) {
resourceBase = RESOURCE_BASE + ECLIPSE;
return;
}
} catch (MalformedURLException e) {
// ignore
}
// If things don't work out, use the default resource base
resourceBase = RESOURCE_BASE;
}
/**
* init is the first method called on the FrameworkLauncher and can be used for any initial setup.
* The default behavior is to do nothing.
*/
public void init() {
// do nothing for now
}
/**
* destroy is the last method called on the FrameworkLauncher and can be used for any final cleanup.
* The default behavior is to do nothing.
*/
public void destroy() {
// do nothing for now
}
/**
* deploy is used to move the OSGi framework libraries into a location suitable for execution.
* The default behavior is to copy the contents of the webapp's WEB-INF/eclipse directory
* to the webapp's temp directory.
*/
public synchronized void deploy() {
if (platformDirectory != null) {
context.log("Framework is already deployed"); //$NON-NLS-1$
return;
}
File servletTemp = (File) context.getAttribute("javax.servlet.context.tempdir"); //$NON-NLS-1$
platformDirectory = new File(servletTemp, "eclipse"); //$NON-NLS-1$
if (!platformDirectory.exists()) {
platformDirectory.mkdirs();
}
copyResource(resourceBase + "configuration/", new File(platformDirectory, "configuration")); //$NON-NLS-1$ //$NON-NLS-2$
copyResource(resourceBase + "features/", new File(platformDirectory, "features")); //$NON-NLS-1$ //$NON-NLS-2$
File plugins = new File(platformDirectory, "plugins"); //$NON-NLS-1$
copyResource(resourceBase + "plugins/", plugins); //$NON-NLS-1$
copyResource(resourceBase + "p2/", new File(platformDirectory, "p2")); //$NON-NLS-1$ //$NON-NLS-2$
deployExtensionBundle(plugins);
copyResource(resourceBase + ".eclipseproduct", new File(platformDirectory, ".eclipseproduct")); //$NON-NLS-1$ //$NON-NLS-2$
}
/**
* deployExtensionBundle will generate the Servletbridge extensionbundle if it is not already present in the platform's
* plugin directory. By default it exports "org.eclipse.equinox.servletbridge" and a versioned export of the Servlet API.
* Additional exports can be added by using the "extendedFrameworkExports" initial-param in the ServletConfig
*/
private void deployExtensionBundle(File plugins) {
File extensionBundle = new File(plugins, "org.eclipse.equinox.servletbridge.extensionbundle_1.0.0.jar"); //$NON-NLS-1$
File extensionBundleDir = new File(plugins, "org.eclipse.equinox.servletbridge.extensionbundle_1.0.0"); //$NON-NLS-1$
if (Boolean.valueOf(config.getInitParameter(CONFIG_OVERRIDE_AND_REPLACE_EXTENSION_BUNDLE)).booleanValue()) {
extensionBundle.delete();
deleteDirectory(extensionBundleDir);
} else if (extensionBundle.exists() || extensionBundleDir.isDirectory())
return;
Manifest mf = new Manifest();
Attributes attribs = mf.getMainAttributes();
attribs.putValue(MANIFEST_VERSION, "1.0"); //$NON-NLS-1$
attribs.putValue(BUNDLE_MANIFEST_VERSION, "2"); //$NON-NLS-1$
attribs.putValue(BUNDLE_NAME, "Servletbridge Extension Bundle"); //$NON-NLS-1$
attribs.putValue(BUNDLE_SYMBOLIC_NAME, "org.eclipse.equinox.servletbridge.extensionbundle"); //$NON-NLS-1$
attribs.putValue(BUNDLE_VERSION, "1.0.0"); //$NON-NLS-1$
attribs.putValue(FRAGMENT_HOST, "system.bundle; extension:=framework"); //$NON-NLS-1$
String servletVersion = context.getMajorVersion() + "." + context.getMinorVersion(); //$NON-NLS-1$
String packageExports = "org.eclipse.equinox.servletbridge; version=1.0" + //$NON-NLS-1$
", javax.servlet; version=" + servletVersion + //$NON-NLS-1$
", javax.servlet.http; version=" + servletVersion + //$NON-NLS-1$
", javax.servlet.resources; version=" + servletVersion; //$NON-NLS-1$
String extendedExports = config.getInitParameter(CONFIG_EXTENDED_FRAMEWORK_EXPORTS);
if (extendedExports != null && extendedExports.trim().length() != 0)
packageExports += ", " + extendedExports; //$NON-NLS-1$
attribs.putValue(EXPORT_PACKAGE, packageExports);
try {
JarOutputStream jos = null;
try {
jos = new JarOutputStream(new FileOutputStream(extensionBundle), mf);
jos.finish();
} finally {
if (jos != null)
jos.close();
}
} catch (IOException e) {
context.log("Error generating extension bundle", e); //$NON-NLS-1$
}
}
/** undeploy is the reverse operation of deploy and removes the OSGi framework libraries from their
* execution location. Typically this method will only be called if a manual undeploy is requested in the
* ServletBridge.
* By default, this method removes the OSGi install and also removes the workspace.
*/
public synchronized void undeploy() {
if (platformDirectory == null) {
context.log("Undeploy unnecessary. - (not deployed)"); //$NON-NLS-1$
return;
}
if (frameworkClassLoader != null) {
throw new IllegalStateException("Could not undeploy Framework - (not stopped)"); //$NON-NLS-1$
}
deleteDirectory(new File(platformDirectory, "configuration")); //$NON-NLS-1$
deleteDirectory(new File(platformDirectory, "features")); //$NON-NLS-1$
deleteDirectory(new File(platformDirectory, "plugins")); //$NON-NLS-1$
deleteDirectory(new File(platformDirectory, "workspace")); //$NON-NLS-1$
deleteDirectory(new File(platformDirectory, "p2")); //$NON-NLS-1$
new File(platformDirectory, ".eclipseproduct").delete(); //$NON-NLS-1$
platformDirectory = null;
}
/** start is used to "start" a previously deployed OSGi framework
* The default behavior will read launcher.ini to create a set of initial properties and
* use the "commandline" configuration parameter to create the equivalent command line arguments
* available when starting Eclipse.
*/
public synchronized void start() {
if (platformDirectory == null)
throw new IllegalStateException("Could not start the Framework - (not deployed)"); //$NON-NLS-1$
if (frameworkClassLoader != null) {
context.log("Framework is already started"); //$NON-NLS-1$
return;
}
Map initalPropertyMap = buildInitialPropertyMap();
String[] args = buildCommandLineArguments();
ClassLoader original = Thread.currentThread().getContextClassLoader();
try {
// MODIF_FROM_ORIGINAL begin
/**
* Setting this property will allow getting framework properties directly from System (e.g. we
* need the <code>org.osgi.framework.os.name</code> property to be able to display tree nodes whose
* paths are longer than 260 characters).
*
* @see FrameworkProperties.internalGetProperties()
*
* @author Mariana
*/
System.setProperty("osgi.framework.useSystemProperties", "true"); //$NON-NLS-1$ //$NON-NLS-2$
// MODIF_FROM_ORIGINAL end
URL[] osgiURLArray = {new URL((String) initalPropertyMap.get(OSGI_FRAMEWORK))};
frameworkClassLoader = new ChildFirstURLClassLoader(osgiURLArray, this.getClass().getClassLoader());
Class clazz = frameworkClassLoader.loadClass(STARTER);
Method setInitialProperties = clazz.getMethod("setInitialProperties", new Class[] {Map.class}); //$NON-NLS-1$
setInitialProperties.invoke(null, new Object[] {initalPropertyMap});
registerRestartHandler(clazz);
Method runMethod = clazz.getMethod("startup", new Class[] {String[].class, Runnable.class}); //$NON-NLS-1$
runMethod.invoke(null, new Object[] {args, null});
frameworkContextClassLoader = Thread.currentThread().getContextClassLoader();
} catch (InvocationTargetException ite) {
Throwable t = ite.getTargetException();
if (t == null)
t = ite;
context.log("Error while starting Framework", t); //$NON-NLS-1$
throw new RuntimeException(t.getMessage());
} catch (Exception e) {
context.log("Error while starting Framework", e); //$NON-NLS-1$
throw new RuntimeException(e.getMessage());
} finally {
Thread.currentThread().setContextClassLoader(original);
}
}
private void registerRestartHandler(Class starterClazz) throws NoSuchMethodException, ClassNotFoundException, IllegalAccessException, InvocationTargetException {
Method registerFrameworkShutdownHandler = null;
try {
registerFrameworkShutdownHandler = starterClazz.getDeclaredMethod("internalAddFrameworkShutdownHandler", new Class[] {Runnable.class}); //$NON-NLS-1$
} catch (NoSuchMethodException e) {
// Ok. However we will not support restart events. Log this as info
context.log(starterClazz.getName() + " does not support setting a shutdown handler. Restart handling is disabled."); //$NON-NLS-1$
return;
}
if (!registerFrameworkShutdownHandler.isAccessible())
registerFrameworkShutdownHandler.setAccessible(true);
Runnable restartHandler = createRestartHandler();
registerFrameworkShutdownHandler.invoke(null, new Object[] {restartHandler});
}
private Runnable createRestartHandler() throws ClassNotFoundException, NoSuchMethodException {
Class frameworkPropertiesClazz = frameworkClassLoader.loadClass(FRAMEWORKPROPERTIES);
final Method getProperty = frameworkPropertiesClazz.getMethod("getProperty", new Class[] {String.class}); //$NON-NLS-1$
Runnable restartHandler = new Runnable() {
public void run() {
try {
String forcedRestart = (String) getProperty.invoke(null, new Object[] {OSGI_FORCED_RESTART});
if (Boolean.valueOf(forcedRestart).booleanValue()) {
stop();
start();
}
} catch (InvocationTargetException ite) {
Throwable t = ite.getTargetException();
if (t == null)
t = ite;
throw new RuntimeException(t.getMessage());
} catch (Exception e) {
throw new RuntimeException(e.getMessage());
}
}
};
return restartHandler;
}
/** buildInitialPropertyMap create the initial set of properties from the contents of launch.ini
* and for a few other properties necessary to launch defaults are supplied if not provided.
* The value '@null' will set the map value to null.
* @return a map containing the initial properties
*/
protected Map buildInitialPropertyMap() {
Map initialPropertyMap = new HashMap();
Properties launchProperties = loadProperties(resourceBase + LAUNCH_INI);
for (Iterator it = launchProperties.entrySet().iterator(); it.hasNext();) {
Map.Entry entry = (Map.Entry) it.next();
String key = (String) entry.getKey();
String value = (String) entry.getValue();
if (key.endsWith("*")) { //$NON-NLS-1$
if (value.equals(NULL_IDENTIFIER)) {
clearPrefixedSystemProperties(key.substring(0, key.length() - 1), initialPropertyMap);
}
} else if (value.equals(NULL_IDENTIFIER))
initialPropertyMap.put(key, null);
else
initialPropertyMap.put(entry.getKey(), entry.getValue());
}
try {
// install.area if not specified
if (initialPropertyMap.get(OSGI_INSTALL_AREA) == null)
initialPropertyMap.put(OSGI_INSTALL_AREA, platformDirectory.toURL().toExternalForm());
// configuration.area if not specified
if (initialPropertyMap.get(OSGI_CONFIGURATION_AREA) == null) {
File configurationDirectory = new File(platformDirectory, "configuration"); //$NON-NLS-1$
if (!configurationDirectory.exists()) {
configurationDirectory.mkdirs();
}
initialPropertyMap.put(OSGI_CONFIGURATION_AREA, configurationDirectory.toURL().toExternalForm());
}
// instance.area if not specified
if (initialPropertyMap.get(OSGI_INSTANCE_AREA) == null) {
File workspaceDirectory = new File(platformDirectory, "workspace"); //$NON-NLS-1$
if (!workspaceDirectory.exists()) {
workspaceDirectory.mkdirs();
}
initialPropertyMap.put(OSGI_INSTANCE_AREA, workspaceDirectory.toURL().toExternalForm());
}
// osgi.framework if not specified
if (initialPropertyMap.get(OSGI_FRAMEWORK) == null) {
// search for osgi.framework in osgi.install.area
String installArea = (String) initialPropertyMap.get(OSGI_INSTALL_AREA);
// only support file type URLs for install area
if (installArea.startsWith(FILE_SCHEME))
installArea = installArea.substring(FILE_SCHEME.length());
String path = new File(installArea, "plugins").toString(); //$NON-NLS-1$
path = searchFor(FRAMEWORK_BUNDLE_NAME, path);
if (path == null)
throw new RuntimeException("Could not find framework"); //$NON-NLS-1$
initialPropertyMap.put(OSGI_FRAMEWORK, new File(path).toURL().toExternalForm());
}
} catch (MalformedURLException e) {
throw new RuntimeException("Error establishing location"); //$NON-NLS-1$
}
return initialPropertyMap;
}
/**
* clearPrefixedSystemProperties clears System Properties by writing null properties in the targetPropertyMap that match a prefix
*/
private static void clearPrefixedSystemProperties(String prefix, Map targetPropertyMap) {
for (Iterator it = System.getProperties().keySet().iterator(); it.hasNext();) {
String propertyName = (String) it.next();
if (propertyName.startsWith(prefix) && !targetPropertyMap.containsKey(propertyName)) {
targetPropertyMap.put(propertyName, null);
}
}
}
/**
* buildCommandLineArguments parses the commandline config parameter into a set of arguments
* @return an array of String containing the commandline arguments
*/
protected String[] buildCommandLineArguments() {
List args = new ArrayList();
String commandLine = config.getInitParameter(CONFIG_COMMANDLINE);
if (commandLine != null) {
StringTokenizer tokenizer = new StringTokenizer(commandLine, WS_DELIM);
while (tokenizer.hasMoreTokens()) {
String arg = tokenizer.nextToken();
if (arg.startsWith("\"")) { //$NON-NLS-1$
if (arg.endsWith("\"")) { //$NON-NLS-1$
if (arg.length() >= 2) {
// strip the beginning and ending quotes
arg = arg.substring(1, arg.length() - 1);
}
} else {
String remainingArg = tokenizer.nextToken("\""); //$NON-NLS-1$
arg = arg.substring(1) + remainingArg;
// skip to next whitespace separated token
tokenizer.nextToken(WS_DELIM);
}
} else if (arg.startsWith("'")) { //$NON-NLS-1$
if (arg.endsWith("'")) { //$NON-NLS-1$
if (arg.length() >= 2) {
// strip the beginning and ending quotes
arg = arg.substring(1, arg.length() - 1);
}
} else {
String remainingArg = tokenizer.nextToken("'"); //$NON-NLS-1$
arg = arg.substring(1) + remainingArg;
// skip to next whitespace separated token
tokenizer.nextToken(WS_DELIM);
}
}
args.add(arg);
}
}
return (String[]) args.toArray(new String[] {});
}
/**
* stop is used to "shutdown" the framework and make it avialable for garbage collection.
* The default implementation also has special handling for Apache Commons Logging to "release" any
* resources associated with the frameworkContextClassLoader.
*/
public synchronized void stop() {
if (platformDirectory == null) {
context.log("Shutdown unnecessary. (not deployed)"); //$NON-NLS-1$
return;
}
if (frameworkClassLoader == null) {
context.log("Framework is already shutdown"); //$NON-NLS-1$
return;
}
ClassLoader original = Thread.currentThread().getContextClassLoader();
try {
Class clazz = frameworkClassLoader.loadClass(STARTER);
Method method = clazz.getDeclaredMethod("shutdown", (Class[]) null); //$NON-NLS-1$
Thread.currentThread().setContextClassLoader(frameworkContextClassLoader);
method.invoke(clazz, (Object[]) null);
// ACL keys its loggers off of the ContextClassLoader which prevents GC without calling release.
// This section explicitly calls release if ACL is used.
try {
clazz = this.getClass().getClassLoader().loadClass("org.apache.commons.logging.LogFactory"); //$NON-NLS-1$
method = clazz.getDeclaredMethod("release", new Class[] {ClassLoader.class}); //$NON-NLS-1$
method.invoke(clazz, new Object[] {frameworkContextClassLoader});
} catch (ClassNotFoundException e) {
// ignore, ACL is not being used
}
} catch (Exception e) {
context.log("Error while stopping Framework", e); //$NON-NLS-1$
return;
} finally {
frameworkClassLoader = null;
frameworkContextClassLoader = null;
Thread.currentThread().setContextClassLoader(original);
}
}
/**
* copyResource is a convenience method to recursively copy resources from the ServletContext to
* an installation target. The default behavior will create a directory if the resourcepath ends
* in '/' and a file otherwise.
* @param resourcePath - The resource root path
* @param target - The root location where resources are to be copied
*/
protected void copyResource(String resourcePath, File target) {
if (resourcePath.endsWith("/")) { //$NON-NLS-1$
target.mkdir();
Set paths = context.getResourcePaths(resourcePath);
if (paths == null)
return;
for (Iterator it = paths.iterator(); it.hasNext();) {
String path = (String) it.next();
File newFile = new File(target, path.substring(resourcePath.length()));
copyResource(path, newFile);
}
} else {
try {
if (target.createNewFile()) {
InputStream is = null;
OutputStream os = null;
try {
is = context.getResourceAsStream(resourcePath);
if (is == null)
return;
os = new FileOutputStream(target);
byte[] buffer = new byte[8192];
int bytesRead = is.read(buffer);
while (bytesRead != -1) {
os.write(buffer, 0, bytesRead);
bytesRead = is.read(buffer);
}
} finally {
if (is != null)
is.close();
if (os != null)
os.close();
}
}
} catch (IOException e) {
context.log("Error copying resources", e); //$NON-NLS-1$
}
}
}
/**
* deleteDirectory is a convenience method to recursively delete a directory
* @param directory - the directory to delete.
* @return was the delete successful
*/
protected static boolean deleteDirectory(File directory) {
if (directory.isDirectory()) {
File[] files = directory.listFiles();
for (int i = 0; i < files.length; i++) {
if (files[i].isDirectory()) {
deleteDirectory(files[i]);
} else {
files[i].delete();
}
}
}
return directory.delete();
}
/**
* Used when to set the ContextClassLoader when the BridgeServlet delegates to a Servlet
* inside the framework
* @return a Classloader with the OSGi framework's context class loader.
*/
public synchronized ClassLoader getFrameworkContextClassLoader() {
return frameworkContextClassLoader;
}
/**
* Platfom Directory is where the OSGi software is installed
* @return the framework install location
*/
protected synchronized File getPlatformDirectory() {
return platformDirectory;
}
/**
* loadProperties is a convenience method to load properties from a servlet context resource
* @param resource - The target to read properties from
* @return the properties
*/
protected Properties loadProperties(String resource) {
Properties result = new Properties();
InputStream in = null;
try {
URL location = context.getResource(resource);
if (location != null) {
in = location.openStream();
result.load(in);
}
} catch (MalformedURLException e) {
// no url to load from
} catch (IOException e) {
// its ok if there is no file
} finally {
if (in != null) {
try {
in.close();
} catch (IOException e) {
// ignore
}
}
}
return result;
}
/***************************************************************************
* See org.eclipse.core.launcher [copy of searchFor, findMax,
* compareVersion, getVersionElements] TODO: If these methods were made
* public and static we could use them directly
**************************************************************************/
/**
* Searches for the given target directory starting in the "plugins" subdirectory
* of the given location. If one is found then this location is returned;
* otherwise an exception is thrown.
* @param target
*
* @return the location where target directory was found
* @param start the location to begin searching
*/
protected String searchFor(final String target, String start) {
FileFilter filter = new FileFilter() {
public boolean accept(File candidate) {
return candidate.getName().equals(target) || candidate.getName().startsWith(target + "_"); //$NON-NLS-1$
}
};
File[] candidates = new File(start).listFiles(filter);
if (candidates == null)
return null;
String[] arrays = new String[candidates.length];
for (int i = 0; i < arrays.length; i++) {
arrays[i] = candidates[i].getName();
}
int result = findMax(arrays);
if (result == -1)
return null;
return candidates[result].getAbsolutePath().replace(File.separatorChar, '/') + (candidates[result].isDirectory() ? "/" : ""); //$NON-NLS-1$//$NON-NLS-2$
}
protected int findMax(String[] candidates) {
int result = -1;
Object maxVersion = null;
for (int i = 0; i < candidates.length; i++) {
String name = candidates[i];
String version = ""; //$NON-NLS-1$ // Note: directory with version suffix is always > than directory without version suffix
int index = name.indexOf('_');
if (index != -1)
version = name.substring(index + 1);
Object currentVersion = getVersionElements(version);
if (maxVersion == null) {
result = i;
maxVersion = currentVersion;
} else {
if (compareVersion((Object[]) maxVersion, (Object[]) currentVersion) < 0) {
result = i;
maxVersion = currentVersion;
}
}
}
return result;
}
/**
* Compares version strings.
* @param left
* @param right
* @return result of comparison, as integer;
* <code><0</code> if left < right;
* <code>0</code> if left == right;
* <code>>0</code> if left > right;
*/
private int compareVersion(Object[] left, Object[] right) {
int result = ((Integer) left[0]).compareTo((Integer) right[0]); // compare major
if (result != 0)
return result;
result = ((Integer) left[1]).compareTo((Integer) right[1]); // compare minor
if (result != 0)
return result;
result = ((Integer) left[2]).compareTo((Integer) right[2]); // compare service
if (result != 0)
return result;
return ((String) left[3]).compareTo((String) right[3]); // compare qualifier
}
/**
* Do a quick parse of version identifier so its elements can be correctly compared.
* If we are unable to parse the full version, remaining elements are initialized
* with suitable defaults.
* @param version
* @return an array of size 4; first three elements are of type Integer (representing
* major, minor and service) and the fourth element is of type String (representing
* qualifier). Note, that returning anything else will cause exceptions in the caller.
*/
private Object[] getVersionElements(String version) {
if (version.endsWith(".jar")) //$NON-NLS-1$
version = version.substring(0, version.length() - 4);
Object[] result = {new Integer(0), new Integer(0), new Integer(0), ""}; //$NON-NLS-1$
StringTokenizer t = new StringTokenizer(version, "."); //$NON-NLS-1$
String token;
int i = 0;
while (t.hasMoreTokens() && i < 4) {
token = t.nextToken();
if (i < 3) {
// major, minor or service ... numeric values
try {
result[i++] = new Integer(token);
} catch (Exception e) {
// invalid number format - use default numbers (0) for the rest
break;
}
} else {
// qualifier ... string value
result[i++] = token;
}
}
return result;
}
/**
* The ChildFirstURLClassLoader alters regular ClassLoader delegation and will check the URLs
* used in its initialization for matching classes before delegating to it's parent.
* Sometimes also referred to as a ParentLastClassLoader
*/
protected class ChildFirstURLClassLoader extends URLClassLoader {
public ChildFirstURLClassLoader(URL[] urls) {
super(urls);
}
public ChildFirstURLClassLoader(URL[] urls, ClassLoader parent) {
super(urls, parent);
}
public ChildFirstURLClassLoader(URL[] urls, ClassLoader parent, URLStreamHandlerFactory factory) {
super(urls, parent, factory);
}
public URL getResource(String name) {
URL resource = findResource(name);
if (resource == null) {
ClassLoader parent = getParent();
if (parent != null)
resource = parent.getResource(name);
}
return resource;
}
protected synchronized Class loadClass(String name, boolean resolve) throws ClassNotFoundException {
Class clazz = findLoadedClass(name);
if (clazz == null) {
try {
clazz = findClass(name);
} catch (ClassNotFoundException e) {
ClassLoader parent = getParent();
if (parent != null)
clazz = parent.loadClass(name);
else
clazz = getSystemClassLoader().loadClass(name);
}
}
if (resolve)
resolveClass(clazz);
return clazz;
}
// we want to ensure that the framework has AllPermissions
protected PermissionCollection getPermissions(CodeSource codesource) {
return allPermissions;
}
}
}