Attachment #119050 for bug #256910

Lines 19-24 Link Here

(-)META-INF/MANIFEST.MF (-1 / +2 lines)
19	org.eclipse.jdt.launching,	19	org.eclipse.jdt.launching,
20	org.eclipse.pde.core,	20	org.eclipse.pde.core,
21	org.eclipse.text,	21	org.eclipse.text,
22	org.eclipse.pde.runtime	22	org.eclipse.pde.runtime,
		23	org.eclipse.equinox.frameworkadmin;bundle-version="1.0.100"
23	Eclipse-LazyStart: true	24	Eclipse-LazyStart: true
24	Bundle-RequiredExecutionEnvironment: J2SE-1.4	25	Bundle-RequiredExecutionEnvironment: J2SE-1.4




/*******************************************************************************
 * Copyright (c) 2008 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.pde.ui.tests.target;

import java.io.*;
import java.net.URL;
import java.util.*;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
import junit.framework.TestCase;
import org.eclipse.core.runtime.*;
import org.eclipse.equinox.internal.provisional.frameworkadmin.BundleInfo;
import org.eclipse.pde.core.plugin.TargetPlatform;
import org.eclipse.pde.internal.core.*;
import org.eclipse.pde.internal.core.target.provisional.*;
import org.eclipse.pde.internal.ui.tests.macro.MacroPlugin;

/**
 * Tests for target definitions.
 * 
 * @since 3.5 
 */
public class TargetDefinitionTests extends TestCase {
	
	/**
	 * Retrieves all bundles (source and code) in the given target definition
	 * returning them as a set of URLs.
	 * 
	 * @param target target definition
	 * @return all bundle URLs
	 */
	protected Set getAllBundleURLs(ITargetDefinition target) throws Exception {
		BundleInfo[] code = target.resolveBundles(null);
		BundleInfo[] source = target.resolveSourceBundles(null);
		Set urls = new HashSet(code.length + source.length);
		for (int i = 0; i < code.length; i++) {
			urls.add(code[i].getLocation().toURL());
		}
		for (int i = 0; i < source.length; i++) {
			urls.add(source[i].getLocation().toURL());
		}
		return urls;
	}
	
	/**
	 * Extracts the classic plug-ins archive, if not already done, and returns a path to the
	 * root directory containing the plug-ins.
	 * 
	 * @return path to the plug-ins directory
	 * @throws Exception
	 */
	protected IPath extracClassicPlugins() throws Exception {
		// extract the 3.0.2 skeleton
		IPath stateLocation = MacroPlugin.getDefault().getStateLocation();
		IPath location = stateLocation.append("classic-plugins");
		if (location.toFile().exists()) {
			return location;
		}
		URL zipURL = MacroPlugin.getBundleContext().getBundle().getEntry("/tests/targets/classic-plugins.zip");
		Path zipPath = new Path(new File(FileLocator.toFileURL(zipURL).getFile()).getAbsolutePath());
		ZipFile zipFile = new ZipFile(zipPath.toFile());
		Enumeration entries = zipFile.entries();
		while (entries.hasMoreElements()) {
			ZipEntry entry = (ZipEntry) entries.nextElement();
			if (!entry.isDirectory()) {
				IPath entryPath = stateLocation.append(entry.getName());
				File dir = entryPath.removeLastSegments(1).toFile();
				dir.mkdirs();
				File file = entryPath.toFile();
				file.createNewFile();
				InputStream inputStream = new BufferedInputStream(zipFile.getInputStream(entry));
				byte[] bytes = getInputStreamAsByteArray(inputStream, -1);
				inputStream.close();
				BufferedOutputStream outputStream = new BufferedOutputStream(new FileOutputStream(file));
				outputStream.write(bytes);
				outputStream.close();
			}
		}
		zipFile.close();
		return location;
	}

	/**
	 * Tests that a target definition equivalent to the default target platform
	 * contains the same bundles as the default target platform (this is an 
	 * explicit location with no target weaving).
	 * 
	 * @throws Exception
	 */
	public void testDefaultTargetPlatform() throws Exception {
		// the new way
		ITargetDefinition definition = TargetFactory.newTargetDefinition();
		IBundleContainer container = TargetFactory.newProfileContainer(TargetPlatform.getDefaultLocation());
		definition.setBundleContainers(new IBundleContainer[]{container});
		Set urls = getAllBundleURLs(definition);
		
		// the old way
		IPath location = new Path(TargetPlatform.getDefaultLocation());
		URL[] pluginPaths = P2Utils.readBundlesTxt(location.toOSString(), location.append("configuration").toFile().toURL());
		assertEquals("Should have same number of bundles", pluginPaths.length, urls.size());
		for (int i = 0; i < pluginPaths.length; i++) {
			URL url = pluginPaths[i];
			assertTrue("Missing plug-in " + url.toString(), urls.contains(url));
		}
		
	}
	
	/**
	 * Tests that a target definition equivalent to the default target platform
	 * contains the same bundles as the default target platform using the
	 * platform's configuration location (which will do target weaving). This
	 * is really only tested when run as a JUnit plug-in test suite from
	 * within Eclipse.
	 * 
	 * @throws Exception
	 */
	public void testWovenTargetPlatform() throws Exception {
		// the new way
		ITargetDefinition definition = TargetFactory.newTargetDefinition();
		IBundleContainer container = TargetFactory.newProfileContainer(TargetPlatform.getDefaultLocation(),
				new File(Platform.getConfigurationLocation().getURL().getFile()).getAbsolutePath());
		definition.setBundleContainers(new IBundleContainer[]{container});
		Set urls = getAllBundleURLs(definition);
		
		// the old way
		URL[] pluginPaths = PluginPathFinder.getPluginPaths(TargetPlatform.getDefaultLocation());
		assertEquals("Should have same number of bundles", pluginPaths.length, urls.size());
		for (int i = 0; i < pluginPaths.length; i++) {
			URL url = pluginPaths[i];
			assertTrue("Missing plug-in " + url.toString(), urls.contains(url));
		}
		
	}	

	/**
	 * Tests that a bundle directory container is equivalent to scanning locations.
	 * 
	 * @throws Exception
	 */
	public void testDirectoryBundleContainer() throws Exception {
		// the new way
		ITargetDefinition definition = TargetFactory.newTargetDefinition();
		IBundleContainer container = TargetFactory.newDirectoryContainer(TargetPlatform.getDefaultLocation() + "/plugins");
		definition.setBundleContainers(new IBundleContainer[]{container});
		Set urls = getAllBundleURLs(definition);
		
		Preferences store = PDECore.getDefault().getPluginPreferences();
		boolean restore = store.getBoolean(ICoreConstants.TARGET_PLATFORM_REALIZATION);
		try {
			store.setValue(ICoreConstants.TARGET_PLATFORM_REALIZATION, false);
			// the old way
			URL[] pluginPaths = PluginPathFinder.getPluginPaths(TargetPlatform.getDefaultLocation());
			assertEquals("Should have same number of bundles", pluginPaths.length, urls.size());
			for (int i = 0; i < pluginPaths.length; i++) {
				URL url = pluginPaths[i];
				assertTrue("Missing plug-in " + url.toString(), urls.contains(url));
			}
		}
		finally {
			store.setValue(ICoreConstants.TARGET_PLATFORM_REALIZATION, restore);
		}
	}
	
	/**
	 * Tests reading a 3.0.2 install with a mix of classic and OSGi plug-ins.
	 * 
	 * @throws Exception
	 */
	public void testClassicPlugins() throws Exception {
		// extract the 3.0.2 skeleton
		IPath location = extracClassicPlugins();
		
		// the new way
		ITargetDefinition definition = TargetFactory.newTargetDefinition();
		IBundleContainer container = TargetFactory.newDirectoryContainer(location.toOSString());
		definition.setBundleContainers(new IBundleContainer[]{container});
		Set urls = getAllBundleURLs(definition);
		
		Preferences store = PDECore.getDefault().getPluginPreferences();
		boolean restore = store.getBoolean(ICoreConstants.TARGET_PLATFORM_REALIZATION);
		try {
			store.setValue(ICoreConstants.TARGET_PLATFORM_REALIZATION, false);
			// the old way
			URL[] pluginPaths = PluginPathFinder.getPluginPaths(location.toOSString());
			for (int i = 0; i < pluginPaths.length; i++) {
				URL url = pluginPaths[i];
				if (!urls.contains(url)) {
					System.err.println(url.toString());
				}
			}
			assertEquals("Wrong number of bundles", pluginPaths.length, urls.size());
		}
		finally {
			store.setValue(ICoreConstants.TARGET_PLATFORM_REALIZATION, restore);
		}		
	}
	
	/**
	 * Tests identification of source bundles in a 3.0.2 install.
	 * 
	 * @throws Exception
	 */
	public void testClassicSourcePlugins() throws Exception {
		// extract the 3.0.2 skeleton
		IPath location = extracClassicPlugins();
		
		// the new way
		ITargetDefinition definition = TargetFactory.newTargetDefinition();
		IBundleContainer container = TargetFactory.newDirectoryContainer(location.toOSString());
		definition.setBundleContainers(new IBundleContainer[]{container});
		BundleInfo[] bundles = definition.resolveSourceBundles(null);
		assertEquals("Wrong number of source bundles", 3, bundles.length);
		Set names = new HashSet();
		for (int i = 0; i < bundles.length; i++) {
			names.add(bundles[i].getSymbolicName());
		}
		String[] expected = new String[]{"org.eclipse.platform.source", "org.eclipse.jdt.source", "org.eclipse.pde.source"};
		for (int i = 0; i < expected.length; i++) {
			assertTrue("Missing source for " + expected[i], names.contains(expected[i]));	
		}
	}

	/**
	 * Returns the given input stream as a byte array
	 * @param stream the stream to get as a byte array
	 * @param length the length to read from the stream or -1 for unknown
	 * @return the given input stream as a byte array
	 * @throws IOException
	 */
	public static byte[] getInputStreamAsByteArray(InputStream stream, int length) throws IOException {
		byte[] contents;
		if (length == -1) {
			contents = new byte[0];
			int contentsLength = 0;
			int amountRead = -1;
			do {
				// read at least 8K
				int amountRequested = Math.max(stream.available(), 8192);
				// resize contents if needed
				if (contentsLength + amountRequested > contents.length) {
					System.arraycopy(contents,
							0,
							contents = new byte[contentsLength + amountRequested],
							0,
							contentsLength);
				}
				// read as many bytes as possible
				amountRead = stream.read(contents, contentsLength, amountRequested);
				if (amountRead > 0) {
					// remember length of contents
					contentsLength += amountRead;
				}
			} while (amountRead != -1);
			// resize contents if necessary
			if (contentsLength < contents.length) {
				System.arraycopy(contents, 0, contents = new byte[contentsLength], 0, contentsLength);
			}
		} else {
			contents = new byte[length];
			int len = 0;
			int readSize = 0;
			while ((readSize != -1) && (len != length)) {
				// See PR 1FMS89U
				// We record first the read size. In this case length is the actual
				// read size.
				len += readSize;
				readSize = stream.read(contents, len, length - len);
			}
		}
		return contents;
	}	
}

Lines 145-148 Link Here

(-)src/org/eclipse/pde/internal/core/ICoreConstants.java (+3 lines)
145	public static IPath BUILD_PROPERTIES_PATH = new Path(BUILD_FILENAME_DESCRIPTOR);	145	public static IPath BUILD_PROPERTIES_PATH = new Path(BUILD_FILENAME_DESCRIPTOR);
146	public static IPath OSGI_INF_PATH = new Path(OSGI_INF_FOLDER_NAME);	146	public static IPath OSGI_INF_PATH = new Path(OSGI_INF_FOLDER_NAME);
147		147
		148	// Extension point identifiers
		149	public static final String EXTENSION_POINT_SOURCE = PDECore.PLUGIN_ID + ".source"; //$NON-NLS-1$
		150
148	}	151	}




	 * 	to locate a bundles.info
	 */
	public static URL[] readBundlesTxt(String platformHome, URL configurationArea) {
		BundleInfo[] bundles = readBundles(platformHome, configurationArea);
		BundleInfo[] source = readSourceBundles(platformHome, configurationArea);
		if (bundles != null) {
			int length = bundles.length;
			if (source != null) {
				length += source.length;
			}
			URL[] urls = new URL[length];
			int index = 0;
			try {
				for (int i = 0; i < bundles.length; i++) {
					urls[index++] = bundles[i].getLocation().toURL();
				}
				if (source != null) {
					for (int i = 0; i < source.length; i++) {
						urls[index++] = source[i].getLocation().toURL();
					}
				}
				return urls;
			} catch (MalformedURLException e) {
				PDECore.log(e);
			}
		}
		return null;
	}

	/**
	 * Returns bundles defined by the 'bundles.info' file in the
	 * specified location, or <code>null</code> if none. The "bundles.info" file
	 * is assumed to be at a fixed location relative to the configuration area URL.
	 * If bundle URLs found in the bundles.info are relative, they will be appended
	 * to platformHome to make them absolute.
	 * 
	 * @param platformHome absolute path in the local file system to an installation
	 * @param configurationArea url location of the configuration directory to search for bundles.info
	 * @return URLs of all bundles in the installation or <code>null</code> if not able
	 * 	to locate a bundles.info
	 */
	public static BundleInfo[] readBundles(String platformHome, URL configurationArea) {
		IPath basePath = new Path(platformHome);
		if (configurationArea == null) {
			return null;
		}
		try {
			URL bundlesTxt = new URL(configurationArea.getProtocol(), configurationArea.getHost(), configurationArea.getFile().concat(BUNDLE_INFO_PATH));
			return getBundlesFromFile(bundlesTxt, basePath.toFile());
			BundleInfo bundles[] = getBundlesFromFile(bundlesTxt, home);
			if (bundles == null) {
				return null;
			}
			int length = bundles.length;
			URL srcBundlesTxt = new URL(configurationArea.getProtocol(), configurationArea.getHost(), configurationArea.getFile().concat(SRC_INFO_PATH));
			BundleInfo srcBundles[] = getBundlesFromFile(srcBundlesTxt, home);

			if (srcBundles != null) {
				length += srcBundles.length;
			}

			URL[] urls = new URL[length];
			copyURLs(urls, 0, bundles);
			if (srcBundles != null) {
				copyURLs(urls, bundles.length, srcBundles);
			}
			return urls;

		} catch (MalformedURLException e) {
			PDECore.log(e);
			return null;

	}

	/**
	 * Returns bundles defined by the 'source.info' file in the
	 * specified location, or <code>null</code> if none. The "source.info" file
	 * is assumed to be at a fixed location relative to the configuration area URL.
	 * If bundle URLs found in the source.info are relative, they will be appended
	 * to platformHome to make them absolute.
	 * 
	 * @param platformHome absolute path in the local file system to an installation
	 * @param configurationArea url location of the configuration directory to search for source.info
	 * @return URLs of all source bundles in the installation or <code>null</code> if not able
	 * 	to locate a source.info
	 */
	public static BundleInfo[] readSourceBundles(String platformHome, URL configurationArea) {
		IPath basePath = new Path(platformHome);
		if (configurationArea == null) {
			return null;
		}
		try {
			URL srcBundlesTxt = new URL(configurationArea.getProtocol(), configurationArea.getHost(), configurationArea.getFile().concat(SRC_INFO_PATH));
			return getBundlesFromFile(srcBundlesTxt, basePath.toFile());
		} catch (MalformedURLException e) {
			PDECore.log(e);
			return null;
		} catch (IOException e) {
			PDECore.log(e);
			return null;
		}
	}





/*******************************************************************************
 * Copyright (c) 2008 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.pde.internal.core.target.impl;

import java.util.*;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.equinox.internal.provisional.frameworkadmin.BundleInfo;
import org.eclipse.pde.internal.core.target.provisional.IBundleContainer;
import org.eclipse.pde.internal.core.target.provisional.ITargetDefinition;

/**
 * Target definition implementation.
 * 
 * @since 3.5
 */
public class TargetDefinition implements ITargetDefinition {

	// name and description
	private String fName;
	private String fDescription;

	// arguments
	private String fProgramArgs;
	private String fVMArgs;

	// environment settings
	private String fEE;
	private String fArch;
	private String fOS;
	private String fWS;
	private String fNL;

	// bundle containers
	private IBundleContainer[] fContainers;

	/* (non-Javadoc)
	 * @see org.eclipse.pde.internal.core.target.provisional.ITargetDefinition#getArch()
	 */
	public String getArch() {
		return fArch;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.internal.core.target.provisional.ITargetDefinition#getBundleContainers()
	 */
	public IBundleContainer[] getBundleContainers() {
		return fContainers;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.internal.core.target.provisional.ITargetDefinition#getDescription()
	 */
	public String getDescription() {
		return fDescription;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.internal.core.target.provisional.ITargetDefinition#getExecutionEnvironment()
	 */
	public String getExecutionEnvironment() {
		return fEE;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.internal.core.target.provisional.ITargetDefinition#getNL()
	 */
	public String getNL() {
		return fNL;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.internal.core.target.provisional.ITargetDefinition#getName()
	 */
	public String getName() {
		return fName;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.internal.core.target.provisional.ITargetDefinition#getOS()
	 */
	public String getOS() {
		return fOS;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.internal.core.target.provisional.ITargetDefinition#getProgramArguments()
	 */
	public String getProgramArguments() {
		return fProgramArgs;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.internal.core.target.provisional.ITargetDefinition#getVMArguments()
	 */
	public String getVMArguments() {
		return fVMArgs;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.internal.core.target.provisional.ITargetDefinition#getWS()
	 */
	public String getWS() {
		return fWS;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.internal.core.target.provisional.ITargetDefinition#setArch(java.lang.String)
	 */
	public void setArch(String arch) {
		fArch = arch;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.internal.core.target.provisional.ITargetDefinition#setDescription(java.lang.String)
	 */
	public void setDescription(String description) {
		fDescription = description;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.internal.core.target.provisional.ITargetDefinition#setExecutionEnvironment(java.lang.String)
	 */
	public void setExecutionEnvironment(String environment) {
		fEE = environment;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.internal.core.target.provisional.ITargetDefinition#setNL(java.lang.String)
	 */
	public void setNL(String nl) {
		fNL = nl;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.internal.core.target.provisional.ITargetDefinition#setName(java.lang.String)
	 */
	public void setName(String name) {
		fName = name;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.internal.core.target.provisional.ITargetDefinition#setOS(java.lang.String)
	 */
	public void setOS(String os) {
		fOS = os;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.internal.core.target.provisional.ITargetDefinition#setProgramArguments(java.lang.String)
	 */
	public void setProgramArguments(String args) {
		fProgramArgs = args;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.internal.core.target.provisional.ITargetDefinition#setVMArguments(java.lang.String)
	 */
	public void setVMArguments(String args) {
		fVMArgs = args;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.internal.core.target.provisional.ITargetDefinition#setWS(java.lang.String)
	 */
	public void setWS(String ws) {
		fWS = ws;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.internal.core.target.provisional.ITargetDefinition#setBundleContainers(org.eclipse.pde.internal.core.target.provisional.IBundleContainer[])
	 */
	public void setBundleContainers(IBundleContainer[] containers) {
		fContainers = containers;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.internal.core.target.provisional.ITargetDefinition#resolveBundles(org.eclipse.core.runtime.IProgressMonitor)
	 */
	public BundleInfo[] resolveBundles(IProgressMonitor monitor) throws CoreException {
		IBundleContainer[] containers = getBundleContainers();
		List bundles = new ArrayList();
		for (int i = 0; i < containers.length; i++) {
			BundleInfo[] infos = containers[i].resolveBundles(monitor);
			bundles.addAll(Arrays.asList(infos));
		}
		return (BundleInfo[]) bundles.toArray(new BundleInfo[bundles.size()]);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.internal.core.target.provisional.ITargetDefinition#resolveSourceBundles(org.eclipse.core.runtime.IProgressMonitor)
	 */
	public BundleInfo[] resolveSourceBundles(IProgressMonitor monitor) throws CoreException {
		IBundleContainer[] containers = getBundleContainers();
		List source = new ArrayList();
		for (int i = 0; i < containers.length; i++) {
			BundleInfo[] infos = containers[i].resolveSourceBundles(monitor);
			source.addAll(Arrays.asList(infos));
		}
		return (BundleInfo[]) source.toArray(new BundleInfo[source.size()]);
	}
}




/*******************************************************************************
 * Copyright (c) 2008 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.pde.internal.core.target.impl;

import java.net.MalformedURLException;
import java.net.URL;
import org.eclipse.core.runtime.*;
import org.eclipse.equinox.internal.provisional.frameworkadmin.BundleInfo;
import org.eclipse.osgi.util.NLS;
import org.eclipse.pde.internal.core.P2Utils;
import org.eclipse.pde.internal.core.PDECore;
import org.eclipse.pde.internal.core.target.provisional.IBundleContainer;

/**
 * A bundle container representing an installed profile.
 * 
 * @since 3.5 
 */
public class ProfileBundleContainer implements IBundleContainer {

	/**
	 * Path to home/root install location
	 */
	private String fHome;

	/**
	 * Alternate configuration location or <code>null</code> if default
	 */
	private String fConfiguration;

	/**
	 * Creates a new bundle container for the profile at the specified location.
	 * 
	 * @param home path in local file system
	 * @param configurationLocation alternate configuration location or <code>null</code> for default
	 */
	public ProfileBundleContainer(String home, String configurationLocation) {
		fHome = home;
		fConfiguration = configurationLocation;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.internal.core.target.provisional.IBundleContainer#resolveBundles(org.eclipse.core.runtime.IProgressMonitor)
	 */
	public BundleInfo[] resolveBundles(IProgressMonitor monitor) throws CoreException {
		URL configUrl = getConfigurationArea();
		BundleInfo[] infos = P2Utils.readBundles(new Path(fHome).toOSString(), configUrl);
		if (infos == null) {
			throw new CoreException(new Status(IStatus.ERROR, PDECore.PLUGIN_ID, NLS.bind("Unable to resolve bundles in {0}", fHome)));
		}
		return infos;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.internal.core.target.provisional.IBundleContainer#resolveSourceBundles(org.eclipse.core.runtime.IProgressMonitor)
	 */
	public BundleInfo[] resolveSourceBundles(IProgressMonitor monitor) throws CoreException {
		URL configUrl = getConfigurationArea();
		BundleInfo[] source = P2Utils.readSourceBundles(new Path(fHome).toOSString(), configUrl);
		if (source == null) {
			source = new BundleInfo[0];
		}
		return source;
	}

	/**
	 * Returns a URL to the configuration area associated with this profile.
	 * 
	 * @return configuration area URL
	 * @throws CoreException if unable to generate a URL
	 */
	private URL getConfigurationArea() throws CoreException {
		IPath home = new Path(fHome);
		IPath configuration = null;
		if (fConfiguration == null) {
			configuration = home.append("configuration");
		} else {
			configuration = new Path(fConfiguration);
		}
		try {
			return configuration.toFile().toURL();
		} catch (MalformedURLException e) {
			throw new CoreException(new Status(IStatus.ERROR, PDECore.PLUGIN_ID, NLS.bind("Unable resolve configuration area in {0}", fHome), e));
		}
	}

}




/*******************************************************************************
 * Copyright (c) 2008 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.pde.internal.core.target.provisional;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.equinox.internal.provisional.frameworkadmin.BundleInfo;

/**
 * A collection of bundles. A bundle container abstracts the storage and location of the
 * underlying bundles and may contain a combination of executable and source bundles.
 * 
 * @since 3.5
 */
public interface IBundleContainer {

	/**
	 * Resolves and returns the executable bundles in this container, possibly empty.
	 * 
	 * @param monitor progress monitor or <code>null</code>
	 * @return executable bundles
	 * @exception CoreException if unable to resolve bundles
	 */
	public BundleInfo[] resolveBundles(IProgressMonitor monitor) throws CoreException;

	/**
	 * Resolves and returns the source bundles in this container, possibly empty.
	 * 
	 * @param monitor progress monitor or <code>null</code>
	 * @return source bundles
	 * @exception CoreException if unable to resolve bundles
	 */
	public BundleInfo[] resolveSourceBundles(IProgressMonitor monitor) throws CoreException;

}




/*******************************************************************************
 * Copyright (c) 2008 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.pde.internal.core.target.provisional;

import org.eclipse.pde.internal.core.target.impl.*;

/**
 * Creates bundle containers and target definitions.
 * 
 * @since 3.5
 */
public class TargetFactory {

	/**
	 * Returns a new empty target definition.
	 * 
	 * @return target definition
	 */
	public static ITargetDefinition newTargetDefinition() {
		return new TargetDefinition();
	}

	/**
	 * Creates and returns a bundle container that contains all bundles in the
	 * specified directory.
	 * 
	 * @param path absolute path in the local file system, may contain string variables
	 * @return bundle container
	 */
	public static IBundleContainer newDirectoryContainer(String path) {
		return new DirectoryBundleContainer(path);
	}

	/**
	 * Creates and returns a bundle container that contains all bundles installed in
	 * a profile at the specified location with a default configuration area.
	 * 
	 * @param home absolute path in the local file system to the root of an installed profile
	 * @return bundle container
	 */
	public static IBundleContainer newProfileContainer(String home) {
		return newProfileContainer(home, null);
	}

	/**
	 * Creates and returns a bundle container that contains all bundles installed in
	 * a profile at the specified location with the specified configuration area.
	 * 
	 * @param home absolute path in the local file system to the root of an installed profile
	 * @param configurationLocation absolute path in the local file system to the
	 *  configuration area for the specified installation
	 * @return bundle container
	 */
	public static IBundleContainer newProfileContainer(String home, String configurationLocation) {
		return new ProfileBundleContainer(home, configurationLocation);
	}
}




/*******************************************************************************
 * Copyright (c) 2008 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.pde.internal.core.target.provisional;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.equinox.internal.provisional.frameworkadmin.BundleInfo;
import org.eclipse.osgi.service.environment.Constants;

/**
 * Defines a target platform. A target platform is a collection of bundles configured
 * for a specific environment.
 * 
 * @since 3.5 
 */
public interface ITargetDefinition {

	/**
	 * Returns the name of this target.
	 * 
	 * @return name
	 */
	public String getName();

	/**
	 * Sets the name of this target.
	 * 
	 * @param name target name - cannot be <code>null</code>
	 */
	public void setName(String name);

	/**
	 * Returns the description of this target or <code>null</code> if none.
	 * 
	 * @return target description
	 */
	public String getDescription();

	/**
	 * Sets the description of this target, possibly <code>null</code>.
	 * 
	 * @param description target description or <code>null</code>
	 */
	public void setDescription(String description);

	/**
	 * Sets the execution environment this target requires to run. An execution 
	 * environment is specified by its associated OSGi profile identifier - for
	 * example, <code>J2SE-1.4</code>.
	 * 
	 * @param environment execution environment identifier
	 */
	public void setExecutionEnvironment(String environment);

	/**
	 * Returns the identifier of the execution environment this target requires to run.
	 * 
	 * @return execution environment identifier
	 */
	public String getExecutionEnvironment();

	/**
	 * Returns the identifier of the operating system this target is configured for,
	 * possibly <code>null</code>.
	 * 
	 * @return operating system identifier or <code>null</code> to default to the 
	 * 	running operating system
	 */
	public String getOS();

	/**
	 * Sets the operating system this target is configured for or <code>null</code> to
	 * default to the running operating system.
	 * 
	 * @param operating system identifier - one of the operating system constants
	 * 	defined by {@link Constants} or <code>null</code> to default to the running
	 * 	operating system
	 */
	public void setOS(String os);

	/**
	 * Returns the identifier of the window system this target is configured for,
	 * possibly <code>null</code>.
	 * 
	 * @return window system identifier - one of the window system constants
	 * 	defined by {@link Constants}, or <code>null</code> to default to the
	 * 	running window system
	 */
	public String getWS();

	/**
	 * Sets the window system this target is configured for or <code>null</code> to 
	 * default to the running window system.
	 * 
	 * @param window system identifier or <code>null</code> to default to the
	 * 	running window system
	 */
	public void setWS(String ws);

	/**
	 * Returns the identifier of the architecture this target is configured for,
	 * or <code>null</code> to default to the running architecture.
	 * 
	 * @return architecture identifier - one of the architecture constants
	 * 	defined by {@link Constants} or <code>null</code> to default to the running
	 * 	architecture
	 */
	public String getArch();

	/**
	 * Sets the architecture this target is configured for, or <code>null</code> to default
	 * to the running architecture.
	 * 
	 * @param architecture identifier or <code>null</code> to default to the
	 * 	running architecture.
	 */
	public void setArch(String arch);

	/**
	 * Returns the identifier of the locale this target is configured for, or <code>null</code>
	 * for default.
	 * 
	 * @return locale identifier or <code>null</code> for default
	 */
	public String getNL();

	/**
	 * Sets the locale this target is configured for or <code>null</code> for default.
	 * 
	 * @param locale identifier or <code>null</code> for default
	 */
	public void setNL(String nl);

	/**
	 * Returns the bundle containers defined by this target, possible <code>null</code>.
	 * 
	 * @return bundle containers or <code>null</code>
	 */
	public IBundleContainer[] getBundleContainers();

	/**
	 * Sets the bundle containers in this target definition or <code>null</code> if none.
	 * 
	 * @param containers bundle containers or <code>null</code>
	 */
	public void setBundleContainers(IBundleContainer[] containers);

	/**
	 * Resolves and returns all executable bundles in this target definition, possibly empty.
	 * 
	 * @param monitor progress monitor or <code>null</code>
	 * @return all executable bundles in this target definition
	 * @throws CoreException if unable to resolve
	 */
	public BundleInfo[] resolveBundles(IProgressMonitor monitor) throws CoreException;

	/**
	 * Resolves and returns all source bundles in this target definition, possibly empty.
	 * 
	 * @param monitor progress monitor or <code>null</code>
	 * @return all source bundles in this target definition
	 * @throws CoreException if unable to resolve
	 */
	public BundleInfo[] resolveSourceBundles(IProgressMonitor monitor) throws CoreException;

	/**
	 * Returns any program arguments that should be used when launching this target
	 * or <code>null</code> if none.
	 * 
	 * @return program arguments or <code>null</code> if none
	 */
	public String getProgramArguments();

	/**
	 * Sets any program arguments that should be used when launching this target
	 * or <code>null</code> if none.
	 * 
	 * @param args program arguments or <code>null</code>
	 */
	public void setProgramArguments(String args);

	/**
	 * Returns any VM arguments that should be used when launching this target
	 * or <code>null</code> if none.
	 * 
	 * @return VM arguments or <code>null</code> if none
	 */
	public String getVMArguments();

	/**
	 * Sets any VM arguments that should be used when launching this target
	 * or <code>null</code> if none.
	 * 
	 * @param args VM arguments or <code>null</code>
	 */
	public void setVMArguments(String args);
}




/*******************************************************************************
 * Copyright (c) 2008 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.pde.internal.core.target.impl;

import java.io.*;
import java.util.*;
import java.util.jar.JarFile;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
import org.eclipse.core.runtime.*;
import org.eclipse.core.runtime.spi.RegistryContributor;
import org.eclipse.core.variables.IStringVariableManager;
import org.eclipse.core.variables.VariablesPlugin;
import org.eclipse.equinox.internal.provisional.frameworkadmin.BundleInfo;
import org.eclipse.osgi.service.pluginconversion.PluginConversionException;
import org.eclipse.osgi.service.pluginconversion.PluginConverter;
import org.eclipse.osgi.util.ManifestElement;
import org.eclipse.osgi.util.NLS;
import org.eclipse.pde.internal.core.ICoreConstants;
import org.eclipse.pde.internal.core.PDECore;
import org.eclipse.pde.internal.core.target.provisional.IBundleContainer;
import org.osgi.framework.BundleException;
import org.osgi.framework.Constants;

/**
 * A directory of bundles.
 * 
 * @since 3.5
 */
public class DirectoryBundleContainer implements IBundleContainer {

	/**
	 * Path to this container's directory in the local file system.
	 * The path may contain string substitution variables.
	 */
	private String fPath;

	/**
	 * A registry can be build to identify old school source bundles.
	 */
	private IExtensionRegistry fRegistry;

	/**
	 * Constructs a directory bundle container at the given location.
	 * 
	 * @param path directory location in the local file system
	 */
	public DirectoryBundleContainer(String path) {
		fPath = path;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.internal.core.target.provisional.IBundleContainer#resolveBundles(org.eclipse.core.runtime.IProgressMonitor)
	 */
	public BundleInfo[] resolveBundles(IProgressMonitor monitor) throws CoreException {
		return resolveBundles(monitor, false);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.internal.core.target.provisional.IBundleContainer#resolveSourceBundles(org.eclipse.core.runtime.IProgressMonitor)
	 */
	public BundleInfo[] resolveSourceBundles(IProgressMonitor monitor) throws CoreException {
		return resolveBundles(monitor, true);
	}

	/**
	 * Resolves and returns source or code bundles based on the given flag.
	 * 
	 * @param monitor progress monitor or <code>null</code>
	 * @param source whether to retrieve source bundles
	 * @return bundles
	 * @throws CoreException
	 */
	private BundleInfo[] resolveBundles(IProgressMonitor monitor, boolean source) throws CoreException {
		File dir = getDirectory();
		if (dir.exists() && dir.isDirectory()) {
			try {
				File[] files = dir.listFiles();
				SubMonitor localMonitor = SubMonitor.convert(monitor, "Reading bundles...", files.length);
				List bundles = new ArrayList(files.length);
				for (int i = 0; i < files.length; i++) {
					if (localMonitor.isCanceled()) {
						throw new OperationCanceledException();
					}
					Map manifest = loadManifest(files[i]);
					if (manifest != null) {
						try {
							String header = (String) manifest.get(Constants.BUNDLE_SYMBOLICNAME);
							if (header != null) {
								ManifestElement[] elements = ManifestElement.parseHeader(Constants.BUNDLE_SYMBOLICNAME, header);
								if (elements != null) {
									String name = elements[0].getValue();
									if (name != null) {
										BundleInfo info = new BundleInfo();
										info.setSymbolicName(name);
										info.setLocation(files[i].toURI());
										header = (String) manifest.get(Constants.BUNDLE_VERSION);
										if (header != null) {
											elements = ManifestElement.parseHeader(Constants.BUNDLE_VERSION, header);
											if (elements != null) {
												info.setVersion(elements[0].getValue());
											}
										}
										if (source == isSourceBundle(files[i], name, manifest)) {
											bundles.add(info);
										}
									}
								}
							}
						} catch (BundleException e) {
							// ignore invalid bundles
						}
					}
					localMonitor.worked(1);
				}
				localMonitor.done();
				return (BundleInfo[]) bundles.toArray(new BundleInfo[bundles.size()]);
			} finally {
				if (fRegistry != null) {
					fRegistry.stop(this);
					fRegistry = null;
				}
			}
		}
		throw new CoreException(new Status(IStatus.ERROR, PDECore.PLUGIN_ID, NLS.bind("Directory does not exist: {0}", fPath)));
	}

	/**
	 * Returns whether the given bundle is a source bundle.
	 * 
	 * @param bundle location of the bundle in the file system
	 * @param symbolicName symbolic name of the bundle
	 * @param manifest the bundle's manifest
	 * @return whether the given bundle is a source bundle
	 */
	private boolean isSourceBundle(File bundle, String symbolicName, Map manifest) {
		if (manifest.containsKey(ICoreConstants.ECLIPSE_SOURCE_BUNDLE)) {
			// this is the new source bundle identifier
			return true;
		}
		// old source bundles were never jar'd
		if (bundle.isFile()) {
			return false;
		}
		// source bundles never have a class path
		if (manifest.containsKey(Constants.BUNDLE_CLASSPATH)) {
			return false;
		}
		// check for an "org.eclipse.pde.core.source" extension 
		File pxml = new File(bundle, ICoreConstants.PLUGIN_FILENAME_DESCRIPTOR);
		if (pxml.exists()) {
			IExtensionRegistry registry = getRegistry();
			RegistryContributor contributor = new RegistryContributor(symbolicName, symbolicName, null, null);
			try {
				registry.addContribution(new BufferedInputStream(new FileInputStream(pxml)), contributor, false, null, null, this);
				IExtension[] extensions = registry.getExtensions(contributor);
				for (int i = 0; i < extensions.length; i++) {
					IExtension extension = extensions[i];
					if (ICoreConstants.EXTENSION_POINT_SOURCE.equals(extension.getExtensionPointUniqueIdentifier())) {
						return true;
					}
				}
			} catch (FileNotFoundException e) {
			}
		}
		return false;
	}

	/**
	 * Returns an extension registry used to identify source bundles.
	 * 
	 * @return extension registry
	 */
	private IExtensionRegistry getRegistry() {
		if (fRegistry == null) {
			fRegistry = RegistryFactory.createRegistry(null, this, this);
			// contribute PDE source extension point
			String bogusDef = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<?eclipse version=\"3.2\"?>\n<plugin><extension-point id=\"source\" name=\"source\"/>\n</plugin>"; //$NON-NLS-1$
			RegistryContributor contributor = new RegistryContributor(PDECore.PLUGIN_ID, PDECore.PLUGIN_ID, null, null);
			fRegistry.addContribution(new ByteArrayInputStream(bogusDef.getBytes()), contributor, false, null, null, this);
		}
		return fRegistry;
	}

	/**
	 * Returns the directory to search for bundles in.
	 * 
	 * @return directory if unable to resolve variables in the path
	 */
	protected File getDirectory() throws CoreException {
		String path = fPath;
		IStringVariableManager manager = VariablesPlugin.getDefault().getStringVariableManager();
		path = manager.performStringSubstitution(fPath);
		return new File(path);
	}

	/**
	 * Parses a bunlde's manifest into a dictionary. The bundle may be in a jar
	 * or in a directory at the specified location.
	 * 
	 * @param bundleLocation root location of the bundle
	 * @return bundle manifest dictionary or <code>null</code> if none
	 * @throws CoreException if manifest has invalid syntax
	 */
	protected Map loadManifest(File bundleLocation) throws CoreException {
		ZipFile jarFile = null;
		InputStream manifestStream = null;
		String extension = new Path(bundleLocation.getName()).getFileExtension();
		try {
			if (extension != null && extension.equals("jar") && bundleLocation.isFile()) { //$NON-NLS-1$
				jarFile = new ZipFile(bundleLocation, ZipFile.OPEN_READ);
				ZipEntry manifestEntry = jarFile.getEntry(JarFile.MANIFEST_NAME);
				if (manifestEntry != null) {
					manifestStream = jarFile.getInputStream(manifestEntry);
				}
			} else {
				File file = new File(bundleLocation, JarFile.MANIFEST_NAME);
				if (file.exists()) {
					manifestStream = new FileInputStream(file);
				} else {
					File pxml = new File(bundleLocation, ICoreConstants.PLUGIN_FILENAME_DESCRIPTOR);
					File fxml = new File(bundleLocation, ICoreConstants.FRAGMENT_FILENAME_DESCRIPTOR);
					if (pxml.exists() || fxml.exists()) {
						// support classic non-OSGi plug-in
						PluginConverter converter = (PluginConverter) PDECore.getDefault().acquireService(PluginConverter.class.getName());
						if (converter != null) {
							try {
								Dictionary convert = converter.convertManifest(bundleLocation, false, null, false, null);
								if (convert != null) {
									Map map = new HashMap(convert.size(), 1.0f);
									Enumeration keys = convert.keys();
									while (keys.hasMoreElements()) {
										Object key = keys.nextElement();
										map.put(key, convert.get(key));
									}
									return map;
								}
							} catch (PluginConversionException e) {
								throw new CoreException(new Status(IStatus.ERROR, PDECore.PLUGIN_ID, NLS.bind("Error converting manifest for {0}", bundleLocation.getAbsolutePath()), e));
							}
						}
					}
				}
			}
			if (manifestStream == null) {
				return null;
			}
			return ManifestElement.parseBundleManifest(manifestStream, new Hashtable(10));
		} catch (BundleException e) {
			PDECore.log(e);
		} catch (IOException e) {
			throw new CoreException(new Status(IStatus.ERROR, PDECore.PLUGIN_ID, NLS.bind("Error reading manifest for {0}", bundleLocation.getAbsolutePath()), e));
		} finally {
			closeZipFileAndStream(manifestStream, jarFile);
		}
		return null;
	}

	/**
	 * Closes the stream and jar file if not <code>null</code>.
	 * 
	 * @param stream stream to close or <code>null</code>
	 * @param jarFile jar to close or <code>null</code>
	 */
	private void closeZipFileAndStream(InputStream stream, ZipFile jarFile) {
		try {
			if (stream != null) {
				stream.close();
			}
		} catch (IOException e) {
			PDECore.log(e);
		}
		try {
			if (jarFile != null) {
				jarFile.close();
			}
		} catch (IOException e) {
			PDECore.log(e);
		}
	}
}

Return to bug 256910

Added Link Here

(-)src/org/eclipse/pde/ui/tests/target/TargetDefinitionTests.java (+280 lines)
1	/*******************************************************************************
2	* Copyright (c) 2008 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.pde.ui.tests.target;
12
13	import java.io.*;
14	import java.net.URL;
15	import java.util.*;
16	import java.util.zip.ZipEntry;
17	import java.util.zip.ZipFile;
18	import junit.framework.TestCase;
19	import org.eclipse.core.runtime.*;
20	import org.eclipse.equinox.internal.provisional.frameworkadmin.BundleInfo;
21	import org.eclipse.pde.core.plugin.TargetPlatform;
22	import org.eclipse.pde.internal.core.*;
23	import org.eclipse.pde.internal.core.target.provisional.*;
24	import org.eclipse.pde.internal.ui.tests.macro.MacroPlugin;
25
26	/**
27	* Tests for target definitions.
28	*
29	* @since 3.5
30	*/
31	public class TargetDefinitionTests extends TestCase {
32
33	/**
34	* Retrieves all bundles (source and code) in the given target definition
35	* returning them as a set of URLs.
36	*
37	* @param target target definition
38	* @return all bundle URLs
39	*/
40	protected Set getAllBundleURLs(ITargetDefinition target) throws Exception {
41	BundleInfo[] code = target.resolveBundles(null);
42	BundleInfo[] source = target.resolveSourceBundles(null);
43	Set urls = new HashSet(code.length + source.length);
44	for (int i = 0; i < code.length; i++) {
45	urls.add(code[i].getLocation().toURL());
46	}
47	for (int i = 0; i < source.length; i++) {
48	urls.add(source[i].getLocation().toURL());
49	}
50	return urls;
51	}
52
53	/**
54	* Extracts the classic plug-ins archive, if not already done, and returns a path to the
55	* root directory containing the plug-ins.
56	*
57	* @return path to the plug-ins directory
58	* @throws Exception
59	*/
60	protected IPath extracClassicPlugins() throws Exception {
61	// extract the 3.0.2 skeleton
62	IPath stateLocation = MacroPlugin.getDefault().getStateLocation();
63	IPath location = stateLocation.append("classic-plugins");
64	if (location.toFile().exists()) {
65	return location;
66	}
67	URL zipURL = MacroPlugin.getBundleContext().getBundle().getEntry("/tests/targets/classic-plugins.zip");
68	Path zipPath = new Path(new File(FileLocator.toFileURL(zipURL).getFile()).getAbsolutePath());
69	ZipFile zipFile = new ZipFile(zipPath.toFile());
70	Enumeration entries = zipFile.entries();
71	while (entries.hasMoreElements()) {
72	ZipEntry entry = (ZipEntry) entries.nextElement();
73	if (!entry.isDirectory()) {
74	IPath entryPath = stateLocation.append(entry.getName());
75	File dir = entryPath.removeLastSegments(1).toFile();
76	dir.mkdirs();
77	File file = entryPath.toFile();
78	file.createNewFile();
79	InputStream inputStream = new BufferedInputStream(zipFile.getInputStream(entry));
80	byte[] bytes = getInputStreamAsByteArray(inputStream, -1);
81	inputStream.close();
82	BufferedOutputStream outputStream = new BufferedOutputStream(new FileOutputStream(file));
83	outputStream.write(bytes);
84	outputStream.close();
85	}
86	}
87	zipFile.close();
88	return location;
89	}
90
91	/**
92	* Tests that a target definition equivalent to the default target platform
93	* contains the same bundles as the default target platform (this is an
94	* explicit location with no target weaving).
95	*
96	* @throws Exception
97	*/
98	public void testDefaultTargetPlatform() throws Exception {
99	// the new way
100	ITargetDefinition definition = TargetFactory.newTargetDefinition();
101	IBundleContainer container = TargetFactory.newProfileContainer(TargetPlatform.getDefaultLocation());
102	definition.setBundleContainers(new IBundleContainer[]{container});
103	Set urls = getAllBundleURLs(definition);
104
105	// the old way
106	IPath location = new Path(TargetPlatform.getDefaultLocation());
107	URL[] pluginPaths = P2Utils.readBundlesTxt(location.toOSString(), location.append("configuration").toFile().toURL());
108	assertEquals("Should have same number of bundles", pluginPaths.length, urls.size());
109	for (int i = 0; i < pluginPaths.length; i++) {
110	URL url = pluginPaths[i];
111	assertTrue("Missing plug-in " + url.toString(), urls.contains(url));
112	}
113
114	}
115
116	/**
117	* Tests that a target definition equivalent to the default target platform
118	* contains the same bundles as the default target platform using the
119	* platform's configuration location (which will do target weaving). This
120	* is really only tested when run as a JUnit plug-in test suite from
121	* within Eclipse.
122	*
123	* @throws Exception
124	*/
125	public void testWovenTargetPlatform() throws Exception {
126	// the new way
127	ITargetDefinition definition = TargetFactory.newTargetDefinition();
128	IBundleContainer container = TargetFactory.newProfileContainer(TargetPlatform.getDefaultLocation(),
129	new File(Platform.getConfigurationLocation().getURL().getFile()).getAbsolutePath());
130	definition.setBundleContainers(new IBundleContainer[]{container});
131	Set urls = getAllBundleURLs(definition);
132
133	// the old way
134	URL[] pluginPaths = PluginPathFinder.getPluginPaths(TargetPlatform.getDefaultLocation());
135	assertEquals("Should have same number of bundles", pluginPaths.length, urls.size());
136	for (int i = 0; i < pluginPaths.length; i++) {
137	URL url = pluginPaths[i];
138	assertTrue("Missing plug-in " + url.toString(), urls.contains(url));
139	}
140
141	}
142
143	/**
144	* Tests that a bundle directory container is equivalent to scanning locations.
145	*
146	* @throws Exception
147	*/
148	public void testDirectoryBundleContainer() throws Exception {
149	// the new way
150	ITargetDefinition definition = TargetFactory.newTargetDefinition();
151	IBundleContainer container = TargetFactory.newDirectoryContainer(TargetPlatform.getDefaultLocation() + "/plugins");
152	definition.setBundleContainers(new IBundleContainer[]{container});
153	Set urls = getAllBundleURLs(definition);
154
155	Preferences store = PDECore.getDefault().getPluginPreferences();
156	boolean restore = store.getBoolean(ICoreConstants.TARGET_PLATFORM_REALIZATION);
157	try {
158	store.setValue(ICoreConstants.TARGET_PLATFORM_REALIZATION, false);
159	// the old way
160	URL[] pluginPaths = PluginPathFinder.getPluginPaths(TargetPlatform.getDefaultLocation());
161	assertEquals("Should have same number of bundles", pluginPaths.length, urls.size());
162	for (int i = 0; i < pluginPaths.length; i++) {
163	URL url = pluginPaths[i];
164	assertTrue("Missing plug-in " + url.toString(), urls.contains(url));
165	}
166	}
167	finally {
168	store.setValue(ICoreConstants.TARGET_PLATFORM_REALIZATION, restore);
169	}
170	}
171
172	/**
173	* Tests reading a 3.0.2 install with a mix of classic and OSGi plug-ins.
174	*
175	* @throws Exception
176	*/
177	public void testClassicPlugins() throws Exception {
178	// extract the 3.0.2 skeleton
179	IPath location = extracClassicPlugins();
180
181	// the new way
182	ITargetDefinition definition = TargetFactory.newTargetDefinition();
183	IBundleContainer container = TargetFactory.newDirectoryContainer(location.toOSString());
184	definition.setBundleContainers(new IBundleContainer[]{container});
185	Set urls = getAllBundleURLs(definition);
186
187	Preferences store = PDECore.getDefault().getPluginPreferences();
188	boolean restore = store.getBoolean(ICoreConstants.TARGET_PLATFORM_REALIZATION);
189	try {
190	store.setValue(ICoreConstants.TARGET_PLATFORM_REALIZATION, false);
191	// the old way
192	URL[] pluginPaths = PluginPathFinder.getPluginPaths(location.toOSString());
193	for (int i = 0; i < pluginPaths.length; i++) {
194	URL url = pluginPaths[i];
195	if (!urls.contains(url)) {
196	System.err.println(url.toString());
197	}
198	}
199	assertEquals("Wrong number of bundles", pluginPaths.length, urls.size());
200	}
201	finally {
202	store.setValue(ICoreConstants.TARGET_PLATFORM_REALIZATION, restore);
203	}
204	}
205
206	/**
207	* Tests identification of source bundles in a 3.0.2 install.
208	*
209	* @throws Exception
210	*/
211	public void testClassicSourcePlugins() throws Exception {
212	// extract the 3.0.2 skeleton
213	IPath location = extracClassicPlugins();
214
215	// the new way
216	ITargetDefinition definition = TargetFactory.newTargetDefinition();
217	IBundleContainer container = TargetFactory.newDirectoryContainer(location.toOSString());
218	definition.setBundleContainers(new IBundleContainer[]{container});
219	BundleInfo[] bundles = definition.resolveSourceBundles(null);
220	assertEquals("Wrong number of source bundles", 3, bundles.length);
221	Set names = new HashSet();
222	for (int i = 0; i < bundles.length; i++) {
223	names.add(bundles[i].getSymbolicName());
224	}
225	String[] expected = new String[]{"org.eclipse.platform.source", "org.eclipse.jdt.source", "org.eclipse.pde.source"};
226	for (int i = 0; i < expected.length; i++) {
227	assertTrue("Missing source for " + expected[i], names.contains(expected[i]));
228	}
229	}
230
231	/**
232	* Returns the given input stream as a byte array
233	* @param stream the stream to get as a byte array
234	* @param length the length to read from the stream or -1 for unknown
235	* @return the given input stream as a byte array
236	* @throws IOException
237	*/
238	public static byte[] getInputStreamAsByteArray(InputStream stream, int length) throws IOException {
239	byte[] contents;
240	if (length == -1) {
241	contents = new byte[0];
242	int contentsLength = 0;
243	int amountRead = -1;
244	do {
245	// read at least 8K
246	int amountRequested = Math.max(stream.available(), 8192);
247	// resize contents if needed
248	if (contentsLength + amountRequested > contents.length) {
249	System.arraycopy(contents,
250	0,
251	contents = new byte[contentsLength + amountRequested],
252	0,
253	contentsLength);
254	}
255	// read as many bytes as possible
256	amountRead = stream.read(contents, contentsLength, amountRequested);
257	if (amountRead > 0) {
258	// remember length of contents
259	contentsLength += amountRead;
260	}
261	} while (amountRead != -1);
262	// resize contents if necessary
263	if (contentsLength < contents.length) {
264	System.arraycopy(contents, 0, contents = new byte[contentsLength], 0, contentsLength);
265	}
266	} else {
267	contents = new byte[length];
268	int len = 0;
269	int readSize = 0;
270	while ((readSize != -1) && (len != length)) {
271	// See PR 1FMS89U
272	// We record first the read size. In this case length is the actual
273	// read size.
274	len += readSize;
275	readSize = stream.read(contents, len, length - len);
276	}
277	}
278	return contents;
279	}
280	}

Lines 54-85 Link Here

(-)src/org/eclipse/pde/internal/core/P2Utils.java (-28 / +63 lines)
54	* to locate a bundles.info	54	* to locate a bundles.info
55	*/	55	*/
56	public static URL[] readBundlesTxt(String platformHome, URL configurationArea) {	56	public static URL[] readBundlesTxt(String platformHome, URL configurationArea) {
		57	BundleInfo[] bundles = readBundles(platformHome, configurationArea);
		58	BundleInfo[] source = readSourceBundles(platformHome, configurationArea);
		59	if (bundles != null) {
		60	int length = bundles.length;
		61	if (source != null) {
		62	length += source.length;
		63	}
		64	URL[] urls = new URL[length];
		65	int index = 0;
		66	try {
		67	for (int i = 0; i < bundles.length; i++) {
		68	urls[index++] = bundles[i].getLocation().toURL();
		69	}
		70	if (source != null) {
		71	for (int i = 0; i < source.length; i++) {
		72	urls[index++] = source[i].getLocation().toURL();
		73	}
		74	}
		75	return urls;
		76	} catch (MalformedURLException e) {
		77	PDECore.log(e);
		78	}
		79	}
		80	return null;
		81	}
		82
		83	/**
		84	* Returns bundles defined by the 'bundles.info' file in the
		85	* specified location, or <code>null</code> if none. The "bundles.info" file
		86	* is assumed to be at a fixed location relative to the configuration area URL.
		87	* If bundle URLs found in the bundles.info are relative, they will be appended
		88	* to platformHome to make them absolute.
		89	*
		90	* @param platformHome absolute path in the local file system to an installation
		91	* @param configurationArea url location of the configuration directory to search for bundles.info
		92	* @return URLs of all bundles in the installation or <code>null</code> if not able
		93	* to locate a bundles.info
		94	*/
		95	public static BundleInfo[] readBundles(String platformHome, URL configurationArea) {
57	IPath basePath = new Path(platformHome);	96	IPath basePath = new Path(platformHome);
58	if (configurationArea == null) {	97	if (configurationArea == null) {
59	return null;	98	return null;
60	}	99	}
61	try {	100	try {
62	URL bundlesTxt = new URL(configurationArea.getProtocol(), configurationArea.getHost(), configurationArea.getFile().concat(BUNDLE_INFO_PATH));	101	URL bundlesTxt = new URL(configurationArea.getProtocol(), configurationArea.getHost(), configurationArea.getFile().concat(BUNDLE_INFO_PATH));
63	File home = basePath.toFile();	102	return getBundlesFromFile(bundlesTxt, basePath.toFile());
64	BundleInfo bundles[] = getBundlesFromFile(bundlesTxt, home);
65	if (bundles == null) {
66	return null;
67	}
68	int length = bundles.length;
69	URL srcBundlesTxt = new URL(configurationArea.getProtocol(), configurationArea.getHost(), configurationArea.getFile().concat(SRC_INFO_PATH));
70	BundleInfo srcBundles[] = getBundlesFromFile(srcBundlesTxt, home);
71
72	if (srcBundles != null) {
73	length += srcBundles.length;
74	}
75
76	URL[] urls = new URL[length];
77	copyURLs(urls, 0, bundles);
78	if (srcBundles != null) {
79	copyURLs(urls, bundles.length, srcBundles);
80	}
81	return urls;
82
83	} catch (MalformedURLException e) {	103	} catch (MalformedURLException e) {
84	PDECore.log(e);	104	PDECore.log(e);
85	return null;	105	return null;
Lines 90-105 Link Here
90	}	110	}
91		111
92	/**	112	/**
93	* Copies URLs from the given bundle info objects into the specified array starting at the given index.	113	* Returns bundles defined by the 'source.info' file in the
		114	* specified location, or <code>null</code> if none. The "source.info" file
		115	* is assumed to be at a fixed location relative to the configuration area URL.
		116	* If bundle URLs found in the source.info are relative, they will be appended
		117	* to platformHome to make them absolute.
94	*	118	*
95	* @param dest array to copy URLs into	119	* @param platformHome absolute path in the local file system to an installation
96	* @param start index to start copying into	120	* @param configurationArea url location of the configuration directory to search for source.info
97	* @param infos associated bundle infos	121	* @return URLs of all source bundles in the installation or <code>null</code> if not able
98	* @throws MalformedURLException	122	* to locate a source.info
99	*/	123	*/
100	private static void copyURLs(URL[] dest, int start, BundleInfo[] infos) throws MalformedURLException {	124	public static BundleInfo[] readSourceBundles(String platformHome, URL configurationArea) {
101	for (int i = 0; i < infos.length; i++) {	125	IPath basePath = new Path(platformHome);
102	dest[start++] = infos[i].getLocation().toURL();	126	if (configurationArea == null) {
		127	return null;
		128	}
		129	try {
		130	URL srcBundlesTxt = new URL(configurationArea.getProtocol(), configurationArea.getHost(), configurationArea.getFile().concat(SRC_INFO_PATH));
		131	return getBundlesFromFile(srcBundlesTxt, basePath.toFile());
		132	} catch (MalformedURLException e) {
		133	PDECore.log(e);
		134	return null;
		135	} catch (IOException e) {
		136	PDECore.log(e);
		137	return null;
103	}	138	}
104	}	139	}
105		140

Lines 37-42 Link Here

(-)META-INF/MANIFEST.MF (-1 / +4 lines)
37	org.eclipse.pde.internal.core.search;x-friends:="org.eclipse.pde.ui",	37	org.eclipse.pde.internal.core.search;x-friends:="org.eclipse.pde.ui",
38	org.eclipse.pde.internal.core.site;x-friends:="org.eclipse.pde.ui",	38	org.eclipse.pde.internal.core.site;x-friends:="org.eclipse.pde.ui",
39	org.eclipse.pde.internal.core.target;x-friends:="org.eclipse.pde.ui",	39	org.eclipse.pde.internal.core.target;x-friends:="org.eclipse.pde.ui",
		40	org.eclipse.pde.internal.core.target.impl;x-internal:=true,
		41	org.eclipse.pde.internal.core.target.provisional;x-internal:=true,
40	org.eclipse.pde.internal.core.text;	42	org.eclipse.pde.internal.core.text;
41	x-friends:="org.eclipse.pde.ui,	43	x-friends:="org.eclipse.pde.ui,
42	org.eclipse.pde.ds.core,	44	org.eclipse.pde.ds.core,
Lines 64-70 Link Here
64	org.eclipse.pde.build;bundle-version="[3.2.0,4.1.0)",	66	org.eclipse.pde.build;bundle-version="[3.2.0,4.1.0)",
65	org.eclipse.ant.core;bundle-version="[3.1.0,4.0.0)",	67	org.eclipse.ant.core;bundle-version="[3.1.0,4.0.0)",
66	org.eclipse.equinox.simpleconfigurator.manipulator;bundle-version="[1.0.100,2.0.0)",	68	org.eclipse.equinox.simpleconfigurator.manipulator;bundle-version="[1.0.100,2.0.0)",
67	org.eclipse.equinox.frameworkadmin;bundle-version="[1.0.100,2.0.0)"	69	org.eclipse.equinox.frameworkadmin;bundle-version="[1.0.100,2.0.0)",
		70	org.eclipse.equinox.frameworkadmin.equinox;bundle-version="1.0.100"
68	Eclipse-LazyStart: true	71	Eclipse-LazyStart: true
69	Bundle-RequiredExecutionEnvironment: J2SE-1.4	72	Bundle-RequiredExecutionEnvironment: J2SE-1.4
70	Import-Package: com.ibm.icu.util	73	Import-Package: com.ibm.icu.util

Added Link Here

(-)src/org/eclipse/pde/internal/core/target/impl/TargetDefinition.java (+210 lines)
1	/*******************************************************************************
2	* Copyright (c) 2008 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.pde.internal.core.target.impl;
12
13	import java.util.*;
14	import org.eclipse.core.runtime.CoreException;
15	import org.eclipse.core.runtime.IProgressMonitor;
16	import org.eclipse.equinox.internal.provisional.frameworkadmin.BundleInfo;
17	import org.eclipse.pde.internal.core.target.provisional.IBundleContainer;
18	import org.eclipse.pde.internal.core.target.provisional.ITargetDefinition;
19
20	/**
21	* Target definition implementation.
22	*
23	* @since 3.5
24	*/
25	public class TargetDefinition implements ITargetDefinition {
26
27	// name and description
28	private String fName;
29	private String fDescription;
30
31	// arguments
32	private String fProgramArgs;
33	private String fVMArgs;
34
35	// environment settings
36	private String fEE;
37	private String fArch;
38	private String fOS;
39	private String fWS;
40	private String fNL;
41
42	// bundle containers
43	private IBundleContainer[] fContainers;
44
45	/* (non-Javadoc)
46	* @see org.eclipse.pde.internal.core.target.provisional.ITargetDefinition#getArch()
47	*/
48	public String getArch() {
49	return fArch;
50	}
51
52	/* (non-Javadoc)
53	* @see org.eclipse.pde.internal.core.target.provisional.ITargetDefinition#getBundleContainers()
54	*/
55	public IBundleContainer[] getBundleContainers() {
56	return fContainers;
57	}
58
59	/* (non-Javadoc)
60	* @see org.eclipse.pde.internal.core.target.provisional.ITargetDefinition#getDescription()
61	*/
62	public String getDescription() {
63	return fDescription;
64	}
65
66	/* (non-Javadoc)
67	* @see org.eclipse.pde.internal.core.target.provisional.ITargetDefinition#getExecutionEnvironment()
68	*/
69	public String getExecutionEnvironment() {
70	return fEE;
71	}
72
73	/* (non-Javadoc)
74	* @see org.eclipse.pde.internal.core.target.provisional.ITargetDefinition#getNL()
75	*/
76	public String getNL() {
77	return fNL;
78	}
79
80	/* (non-Javadoc)
81	* @see org.eclipse.pde.internal.core.target.provisional.ITargetDefinition#getName()
82	*/
83	public String getName() {
84	return fName;
85	}
86
87	/* (non-Javadoc)
88	* @see org.eclipse.pde.internal.core.target.provisional.ITargetDefinition#getOS()
89	*/
90	public String getOS() {
91	return fOS;
92	}
93
94	/* (non-Javadoc)
95	* @see org.eclipse.pde.internal.core.target.provisional.ITargetDefinition#getProgramArguments()
96	*/
97	public String getProgramArguments() {
98	return fProgramArgs;
99	}
100
101	/* (non-Javadoc)
102	* @see org.eclipse.pde.internal.core.target.provisional.ITargetDefinition#getVMArguments()
103	*/
104	public String getVMArguments() {
105	return fVMArgs;
106	}
107
108	/* (non-Javadoc)
109	* @see org.eclipse.pde.internal.core.target.provisional.ITargetDefinition#getWS()
110	*/
111	public String getWS() {
112	return fWS;
113	}
114
115	/* (non-Javadoc)
116	* @see org.eclipse.pde.internal.core.target.provisional.ITargetDefinition#setArch(java.lang.String)
117	*/
118	public void setArch(String arch) {
119	fArch = arch;
120	}
121
122	/* (non-Javadoc)
123	* @see org.eclipse.pde.internal.core.target.provisional.ITargetDefinition#setDescription(java.lang.String)
124	*/
125	public void setDescription(String description) {
126	fDescription = description;
127	}
128
129	/* (non-Javadoc)
130	* @see org.eclipse.pde.internal.core.target.provisional.ITargetDefinition#setExecutionEnvironment(java.lang.String)
131	*/
132	public void setExecutionEnvironment(String environment) {
133	fEE = environment;
134	}
135
136	/* (non-Javadoc)
137	* @see org.eclipse.pde.internal.core.target.provisional.ITargetDefinition#setNL(java.lang.String)
138	*/
139	public void setNL(String nl) {
140	fNL = nl;
141	}
142
143	/* (non-Javadoc)
144	* @see org.eclipse.pde.internal.core.target.provisional.ITargetDefinition#setName(java.lang.String)
145	*/
146	public void setName(String name) {
147	fName = name;
148	}
149
150	/* (non-Javadoc)
151	* @see org.eclipse.pde.internal.core.target.provisional.ITargetDefinition#setOS(java.lang.String)
152	*/
153	public void setOS(String os) {
154	fOS = os;
155	}
156
157	/* (non-Javadoc)
158	* @see org.eclipse.pde.internal.core.target.provisional.ITargetDefinition#setProgramArguments(java.lang.String)
159	*/
160	public void setProgramArguments(String args) {
161	fProgramArgs = args;
162	}
163
164	/* (non-Javadoc)
165	* @see org.eclipse.pde.internal.core.target.provisional.ITargetDefinition#setVMArguments(java.lang.String)
166	*/
167	public void setVMArguments(String args) {
168	fVMArgs = args;
169	}
170
171	/* (non-Javadoc)
172	* @see org.eclipse.pde.internal.core.target.provisional.ITargetDefinition#setWS(java.lang.String)
173	*/
174	public void setWS(String ws) {
175	fWS = ws;
176	}
177
178	/* (non-Javadoc)
179	* @see org.eclipse.pde.internal.core.target.provisional.ITargetDefinition#setBundleContainers(org.eclipse.pde.internal.core.target.provisional.IBundleContainer[])
180	*/
181	public void setBundleContainers(IBundleContainer[] containers) {
182	fContainers = containers;
183	}
184
185	/* (non-Javadoc)
186	* @see org.eclipse.pde.internal.core.target.provisional.ITargetDefinition#resolveBundles(org.eclipse.core.runtime.IProgressMonitor)
187	*/
188	public BundleInfo[] resolveBundles(IProgressMonitor monitor) throws CoreException {
189	IBundleContainer[] containers = getBundleContainers();
190	List bundles = new ArrayList();
191	for (int i = 0; i < containers.length; i++) {
192	BundleInfo[] infos = containers[i].resolveBundles(monitor);
193	bundles.addAll(Arrays.asList(infos));
194	}
195	return (BundleInfo[]) bundles.toArray(new BundleInfo[bundles.size()]);
196	}
197
198	/* (non-Javadoc)
199	* @see org.eclipse.pde.internal.core.target.provisional.ITargetDefinition#resolveSourceBundles(org.eclipse.core.runtime.IProgressMonitor)
200	*/
201	public BundleInfo[] resolveSourceBundles(IProgressMonitor monitor) throws CoreException {
202	IBundleContainer[] containers = getBundleContainers();
203	List source = new ArrayList();
204	for (int i = 0; i < containers.length; i++) {
205	BundleInfo[] infos = containers[i].resolveSourceBundles(monitor);
206	source.addAll(Arrays.asList(infos));
207	}
208	return (BundleInfo[]) source.toArray(new BundleInfo[source.size()]);
209	}
210	}