plugins/org.eclipse.jem.proxy/proxy/org/eclipse/jem/internal/proxy/core/ProxyFindSupport.java - gerrit/jeetools/webtools.javaee - Git at Google

 /*******************************************************************************
  * 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;
 	}


 }
	/*******************************************************************************
	* 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;
	}


	}