/*******************************************************************************
* Copyright (c) 2005, 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.jem.internal.proxy.core;
import java.io.*;
import java.net.URL;
import java.util.ArrayList;
import java.util.Properties;
import org.eclipse.core.runtime.*;
import org.osgi.framework.Bundle;
/**
* Utility to help finding files. It is used to find them within plugins of the current platform or to find them in the PDE target platform.
* Also if in the current platform and the current platform is in development mode it will find the bin directories for the jars instead since
* there are no jars in that case.
* It can also extract non-local files (such as files within a jar) and make a cache of them so that are a local file and not extracted everytime
* they are needed.
*
* TODO If we ever get back to continuing development we should add to this PDE Target support. And test the code here
* since it hasn't been tested yet. Also note that in configuration contributor,
* when we add the library path we expect it to be a folder. This would be a problem with jarred plugins because the directory containing the
* libraries may be the root of the plugin and localizing a directory would extract and cache the entire plugin. Need to change to figure out
* how to only extract the dll/so needed instead. Also, none of these handle the case where the bundle is actually non-local (e.g. "http:/").
* @since 1.2.0
*/
public class ProxyFindSupport {
/**
* Find the filename relative to the platform bundle. It will search in the bundle and in all fragments for the file name.
* It will return a URL for each found file.
* <p>
* This is useful for NLS purposes. In NLS situations the main bundle would contain the main non-library jar with the default properties files.
* Then a fragment for each set of languages will be installed. Within each fragment will be a jar with the same filepath, and it will
* contain the properties files for that language. This would be done only for plugin non-library jars.
* The NLS for library jars of a plugin (i.e. those jars that are the <runtime> jars for the plugin) are usually library jars themselves in
* the fragment, and they usually have a different name than the main library jar. So this should not be used for library jars.
* <p>
* If in development mode, then if the jar is not found it will look in the plugin project's build.properties to find the output directory
* of the jar. If not in the build.properties (meaning it isn't being built by PDE), it will look in the proxy.jars file (if there is one).
* This file is used for jars that are built in a separate project from the plugin but will be found in the plugin at execution.
*
* @param bundle bundle and its fragments to look in.
* @param filenameWithinBundle path to filename within the bundle and fragments. <b>This must be a file, not a directory.</b>
* For finding the bundle itself (only when the bundle is packaged as a jar), use <@link #platformFind(Bundle)>. This does not use
* the platform shortcuts like "$os$". It finds the files exactly as specified.
* @param asLocal <code>true</code> if the urls need to point to local filesystem files. This may cause caching of files locally. This
* could happen if the file is within a plugin that is jarred. <code>false</code> if the url can be a non-local filesystem url.
* @return array of URL's for found files.
*
* @since 1.2.0
*/
public static URL[] platformFindAll(Bundle bundle, IPath filenameWithinBundle, boolean asLocal) {
Bundle[] fragments = Platform.getFragments(bundle);
ArrayList urls = new ArrayList((fragments == null ? 0 : fragments.length) + 1);
String filename = filenameWithinBundle.toString();
URL url = internalFindFromBundleOnly(bundle, filename, asLocal);
if (url != null)
urls.add(url);
if (fragments != null) {
for (int i = 0; i < fragments.length; i++) {
Bundle fragment = fragments[i];
url = internalFindFromBundleOnly(fragment, filename, asLocal);
if (url != null)
urls.add(url);
}
}
return (URL[]) urls.toArray(new URL[urls.size()]);
}
/**
* @param bundle
* @param filenameWithinBundle
* @param asLocal
* @return
*
* @since 1.2.0
*/
private static URL internalFindFromBundleOnly(Bundle bundle, String filenameWithinBundle, boolean asLocal) {
try {
URL pvm = bundle.getEntry(filenameWithinBundle);
if (pvm != null)
return asLocal ? FileLocator.toFileURL(pvm) : pvm;
} catch (IOException e) {
}
if (ProxyPlugin.getPlugin().isDevMode()) {
return findDev(bundle, filenameWithinBundle, asLocal);
} else
return null;
}
/**
* Find the filename relative to the platform bundle. It will search in the bundle and in all fragments for the file name. It will return
* URL for the file if found.
* <p>
* If in development mode, then if the jar is not found it will look in the plugin project's build.properties to find the output directory
* of the jar. If not in the build.properties (meaning it isn't being built by PDE), it will look in the proxy.jars file (if there is one).
* This file is used for jars that are built in a separate project from the plugin but will be found in the plugin at execution.
*
* @param bundle bundle and its fragments to look in.
* @param filenameWithinBundle path to filename within the bundle and fragments. <b>This must be a file, not a directory.</b>
* For finding the bundle itself (only when the bundle is packaged as a jar), use <@link #platformFind(Bundle)>.
* @param asLocal <code>true</code> if the urls need to point to local filesystem files. This may cause caching of files locally. This
* could happen if the file is within a plugin that is jarred. <code>false</code> if the url can be a non-local filesystem url.
* @return the found url or <code>null</code> if not found.
*
* @since 1.2.0
*/
public static URL platformFind(Bundle bundle, IPath filenameWithinBundle, boolean asLocal) {
try {
URL pvm = FileLocator.find(bundle, filenameWithinBundle, null);
if (pvm != null)
return asLocal ? FileLocator.toFileURL(pvm) : pvm;
} catch (IOException e) {
}
if (ProxyPlugin.getPlugin().isDevMode()) {
return findDev(bundle, filenameWithinBundle.toString(), asLocal);
} else
return null;
}
private static final String BUILDPROPERTIES = "build.properties"; //$NON-NLS-1$
private static final String PROXYJARS = "proxy.jars"; //$NON-NLS-1$
private static URL findDev(Bundle bundle, String filenameWithinBundle, boolean asLocal) {
// Got this far and in dev mode means it wasn't found, so we'll try for development style.
// It is assumed that in dev mode, we are running with the IDE as local and any
// build outputs will be local so local file protocol will be returned
// from Platform.resolve(). We won't be running in dev mode with our entireplugin being in a jar,
// or on a separate system.
try {
URL bp = bundle.getEntry(BUILDPROPERTIES);
if (bp != null) {
InputStream ios = null;
try {
ios = bp.openStream();
Properties props = new Properties();
props.load(ios);
String pathString = props.getProperty("output."+filenameWithinBundle.toString()); //$NON-NLS-1$
if (pathString != null) {
URL pvm = bundle.getEntry(pathString);
if (pvm != null)
return asLocal ? FileLocator.toFileURL(pvm) : pvm;
}
} finally {
if (ios != null)
ios.close();
}
}
} catch (IOException e) {
}
try {
URL pvm = bundle.getEntry(PROXYJARS);
if (pvm != null) {
InputStream ios = null;
try {
ios = pvm.openStream();
Properties props = new Properties();
props.load(ios);
String pathString = props.getProperty(filenameWithinBundle.toString());
if (pathString != null) {
URL url = FileLocator.resolve(bundle.getEntry("/")); // It is assumed that if in debug mode, then this plugin is an imported plugin within the developement workspace. //$NON-NLS-1$
if (url.getProtocol().equals("file")) { //$NON-NLS-1$
File file = new File(url.getFile()).getParentFile(); // This gets us to workspace root of development workspace.
file = new File(file, pathString);
return file.toURL();
}
}
} finally {
if (ios != null)
ios.close();
}
}
} catch (IOException e) {
}
return null;
}
/**
* Find the bundle and all active fragments libraries. This should normally be used only when the bundle is packaged as a jar and not as a directory. It will
* return the urls to the jars of the bundle and fragments. If in development mode it will find the bundle's "." output directory.
* @param bundle
* @return array of URL's for the jarred bundle and fragments. If the bundle/fragments are not packaged as jars, then the array will be empty.
*
* @since 1.2.0
*/
public static URL[] platformFind(Bundle bundle) {
return null;
}
}