Attachment #120980 for bug #256910

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) {
		IPath basePath = new Path(platformHome);
		if (configurationArea == null) {
			return null;
		}
		try {
			BundleInfo[] bundles = readBundles(platformHome, configurationArea);
			if (bundles == null) {
			BundleInfo bundles[] = getBundlesFromFile(bundlesTxt, home);
			if (bundles == null || bundles.length == 0) {
				return null;
			}
			int length = bundles.length;
			BundleInfo[] srcBundles = readSourceBundles(platformHome, configurationArea);
			BundleInfo srcBundles[] = getBundlesFromFile(srcBundlesTxt, home);

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

			URL[] urls = new URL[length];
			copyURLs(urls, 0, bundles);
			if (srcBundles != null && srcBundles.length > 0) {
				copyURLs(urls, bundles.length, srcBundles);
			}
			return urls;
		} catch (MalformedURLException e) {
			PDECore.log(e);
			return null;
		}
	}

	/**
	 * Returns bundles defined by the 'bundles.info' relative to the given
	 * home and configuration area, or <code>null</code> if none.
	 * The "bundles.info" file is assumed to be at a fixed location relative to the
	 * configuration area URL.
	 * 
	 * @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 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));
			File home = basePath.toFile();
			BundleInfo bundles[] = getBundlesFromFile(bundlesTxt, home);
			if (bundles == null || bundles.length == 0) {
				return null;
			}
			return bundles;
		} catch (MalformedURLException e) {
			PDECore.log(e);
			return null;
		} catch (IOException e) {
			PDECore.log(e);
			return null;
		}
	}

	/**
	 * Returns source 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.
	 * 
	 * @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 and source.info
	 * @return 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 {
			File home = basePath.toFile();
			URL srcBundlesTxt = new URL(configurationArea.getProtocol(), configurationArea.getHost(), configurationArea.getFile().concat(SRC_INFO_PATH));
			BundleInfo srcBundles[] = getBundlesFromFile(srcBundlesTxt, home);
			if (srcBundles == null || srcBundles.length == 0) {
				return null;
			}
			return srcBundles;
		} catch (MalformedURLException e) {
			PDECore.log(e);
			return null;

Lines 13-18 Link Here

(-)src/org/eclipse/pde/internal/core/PDECore.java (-2 / +15 lines)
13	import java.io.IOException;	13	import java.io.IOException;
14	import java.lang.reflect.InvocationTargetException;	14	import java.lang.reflect.InvocationTargetException;
15	import java.net.URL;	15	import java.net.URL;
		16	import java.util.Hashtable;
16	import org.eclipse.core.resources.IWorkspace;	17	import org.eclipse.core.resources.IWorkspace;
17	import org.eclipse.core.resources.ResourcesPlugin;	18	import org.eclipse.core.resources.ResourcesPlugin;
18	import org.eclipse.core.runtime.*;	19	import org.eclipse.core.runtime.*;
Lines 21-29 Link Here
21	import org.eclipse.pde.internal.core.builders.FeatureRebuilder;	22	import org.eclipse.pde.internal.core.builders.FeatureRebuilder;
22	import org.eclipse.pde.internal.core.builders.PluginRebuilder;	23	import org.eclipse.pde.internal.core.builders.PluginRebuilder;
23	import org.eclipse.pde.internal.core.schema.SchemaRegistry;	24	import org.eclipse.pde.internal.core.schema.SchemaRegistry;
		25	import org.eclipse.pde.internal.core.target.impl.TargetPlatformService;
		26	import org.eclipse.pde.internal.core.target.provisional.ITargetPlatformService;
24	import org.eclipse.update.configurator.ConfiguratorUtils;	27	import org.eclipse.update.configurator.ConfiguratorUtils;
25	import org.osgi.framework.BundleContext;	28	import org.osgi.framework.*;
26	import org.osgi.framework.ServiceReference;
27		29
28	public class PDECore extends Plugin {	30	public class PDECore extends Plugin {
29	public static final String PLUGIN_ID = "org.eclipse.pde.core"; //$NON-NLS-1$	31	public static final String PLUGIN_ID = "org.eclipse.pde.core"; //$NON-NLS-1$
Lines 117-122 Link Here
117		119
118	private PluginRebuilder fPluginRebuilder;	120	private PluginRebuilder fPluginRebuilder;
119		121
		122	/**
		123	* Target platform service.
		124	*/
		125	private ServiceRegistration fTargetPlatformService;
		126
120	public PDECore() {	127	public PDECore() {
121	inst = this;	128	inst = this;
122	}	129	}
Lines 225-230 Link Here
225	fPluginRebuilder.start();	232	fPluginRebuilder.start();
226	fFeatureRebuilder = new FeatureRebuilder();	233	fFeatureRebuilder = new FeatureRebuilder();
227	fFeatureRebuilder.start();	234	fFeatureRebuilder.start();
		235
		236	fTargetPlatformService = context.registerService(ITargetPlatformService.class.getName(), TargetPlatformService.getDefault(), new Hashtable());
228	}	237	}
229		238
230	public BundleContext getBundleContext() {	239	public BundleContext getBundleContext() {
Lines 264-269 Link Here
264	fModelManager.shutdown();	273	fModelManager.shutdown();
265	fModelManager = null;	274	fModelManager = null;
266	}	275	}
		276	if (fTargetPlatformService != null) {
		277	fTargetPlatformService.unregister();
		278	fTargetPlatformService = null;
		279	}
267	}	280	}
268		281
269	/**	282	/**

Lines 32-37 Link Here

(-)META-INF/MANIFEST.MF (+2 lines)
32	org.eclipse.pde.internal.core.search;x-friends:="org.eclipse.pde.ui",	32	org.eclipse.pde.internal.core.search;x-friends:="org.eclipse.pde.ui",
33	org.eclipse.pde.internal.core.site;x-friends:="org.eclipse.pde.ui",	33	org.eclipse.pde.internal.core.site;x-friends:="org.eclipse.pde.ui",
34	org.eclipse.pde.internal.core.target;x-friends:="org.eclipse.pde.ui",	34	org.eclipse.pde.internal.core.target;x-friends:="org.eclipse.pde.ui",
		35	org.eclipse.pde.internal.core.target.impl;x-internal:=true,
		36	org.eclipse.pde.internal.core.target.provisional;x-friends:="org.eclipse.pde.ui",
35	org.eclipse.pde.internal.core.text;	37	org.eclipse.pde.internal.core.text;
36	x-friends:="org.eclipse.pde.ui,	38	x-friends:="org.eclipse.pde.ui,
37	org.eclipse.pde.ds.core,	39	org.eclipse.pde.ds.core,




/*******************************************************************************
 * 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.InputStream;
import java.io.OutputStream;
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.*;

/**
 * Target definition implementation.
 * 
 * @since 3.5
 */
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;

	// handle
	private ITargetHandle fHandle;

	/**
	 * Constructs a target definition based on the given handle. 
	 */
	TargetDefinition(ITargetHandle handle) {
		fHandle = handle;
	}

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

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

	/**
	 * Build contents from the given stream.
	 * 
	 * @param stream input stream
	 * @throws CoreException if an error occurs
	 */
	void setContents(InputStream stream) throws CoreException {

	}

	/**
	 * Persists contents to the given stream.
	 * 
	 * @param stream output stream
	 * @throws CoreException if an error occurs
	 */
	void write(OutputStream stream) 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.core.runtime.CoreException;

/**
 * A handle to a target definition.
 * 
 * @since 3.5
 */
public interface ITargetHandle {

	/**
	 * Returns the target definition this handle references.
	 * 
	 * @return target definition
	 * @throws CoreException if the underlying target definition does not exist
	 */
	public ITargetDefinition getTargetDefinition() throws CoreException;

	/**
	 * Returns a memento for this handle.
	 * 
	 * @return a memento for this handle
	 * @exception CoreException if unable to generate a memento
	 */
	public String getMemento() throws CoreException;

	/**
	 * Returns whether or not the underlying target definition exists.
	 * 
	 * @return whether or not the underlying target definition exists
	 */
	public boolean exists();

}




/*******************************************************************************
 * 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.URI;
import java.net.URISyntaxException;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.runtime.*;
import org.eclipse.pde.internal.core.PDECore;
import org.eclipse.pde.internal.core.target.provisional.*;

/**
 * Target platform service implementation.
 * 
 * @since 3.5
 */
public class TargetPlatformService implements ITargetPlatformService {

	private static ITargetPlatformService fgDefault;

	private TargetPlatformService() {
	}

	public synchronized static ITargetPlatformService getDefault() {
		if (fgDefault == null) {
			fgDefault = new TargetPlatformService();
		}
		return fgDefault;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.internal.core.target.provisional.ITargetPlatformService#deleteTarget(org.eclipse.pde.internal.core.target.provisional.ITargetHandle)
	 */
	public void deleteTarget(ITargetHandle handle) throws CoreException {
		// TODO Auto-generated method stub

	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.internal.core.target.provisional.ITargetPlatformService#getTarget(org.eclipse.core.resources.IFile)
	 */
	public ITargetHandle getTarget(IFile file) {
		return new FileTargetHandle(file);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.internal.core.target.provisional.ITargetPlatformService#getTargetHandle(java.lang.String)
	 */
	public ITargetHandle getTargetHandle(String memento) throws CoreException {
		try {
			URI uri = new URI(memento);
			String scheme = uri.getScheme();
			if (FileTargetHandle.SCHEME.equals(scheme)) {
				return FileTargetHandle.restoreHandle(uri);
			} else if (LocalTargetHandle.SCHEME.equals(scheme)) {
				return LocalTargetHandle.restoreHandle(uri);
			}
		} catch (URISyntaxException e) {
			throw new CoreException(new Status(IStatus.ERROR, PDECore.PLUGIN_ID, "Unable to restore target memento", e));
		}
		throw new CoreException(new Status(IStatus.ERROR, PDECore.PLUGIN_ID, "Unrecognized target memento scheme", null));
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.internal.core.target.provisional.ITargetPlatformService#getTargets(org.eclipse.core.runtime.IProgressMonitor)
	 */
	public ITargetHandle[] getTargets(IProgressMonitor monitor) {
		// TODO Auto-generated method stub
		return null;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.internal.core.target.provisional.ITargetPlatformService#newDirectoryContainer(java.lang.String)
	 */
	public IBundleContainer newDirectoryContainer(String path) {
		return new DirectoryBundleContainer(path);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.internal.core.target.provisional.ITargetPlatformService#newProfileContainer(java.lang.String)
	 */
	public IBundleContainer newProfileContainer(String home) {
		return newProfileContainer(home, null);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.internal.core.target.provisional.ITargetPlatformService#newProfileContainer(java.lang.String, java.lang.String)
	 */
	public IBundleContainer newProfileContainer(String home, String configurationLocation) {
		return new ProfileBundleContainer(home, configurationLocation);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.internal.core.target.provisional.ITargetPlatformService#newTarget()
	 */
	public ITargetDefinition newTarget() {
		return new TargetDefinition(new LocalTargetHandle());
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.internal.core.target.provisional.ITargetPlatformService#saveTargetDefinition(org.eclipse.pde.internal.core.target.provisional.ITargetDefinition)
	 */
	public void saveTargetDefinition(ITargetDefinition definition) throws CoreException {
		// TODO Auto-generated method stub

	}

}




/*******************************************************************************
 * 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.InputStream;
import java.net.URI;
import java.net.URISyntaxException;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.*;
import org.eclipse.pde.internal.core.PDECore;
import org.eclipse.pde.internal.core.target.provisional.ITargetHandle;

/**
 * A handle to a target stored in the workspace as a <code>.target</code> file.
 * 
 * @since 3.5
 */
class FileTargetHandle extends AbstractTargetHandle {

	private IFile fFile;

	/**
	 * Scheme for resource target handle
	 */
	static final String SCHEME = "resource"; //$NON-NLS-1$

	/**
	 * Returns a handle for the given URI.
	 * 
	 * @param uri URI
	 * @return target handle
	 */
	static ITargetHandle restoreHandle(URI uri) {
		String part = uri.getSchemeSpecificPart();
		Path path = new Path(part);
		IFile file = ResourcesPlugin.getWorkspace().getRoot().getFile(path);
		return new FileTargetHandle(file);
	}

	/**
	 * Constructs a handle to a target in the given file.
	 * 
	 * @param file underlying file - may or may not exist
	 */
	FileTargetHandle(IFile file) {
		fFile = file;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.internal.core.target.provisional.ITargetHandle#getMemento()
	 */
	public String getMemento() throws CoreException {
		try {
			URI uri = new URI(SCHEME, fFile.getFullPath().toPortableString(), null);
			return uri.toString();
		} catch (URISyntaxException e) {
			throw new CoreException(new Status(IStatus.ERROR, PDECore.PLUGIN_ID, "Unable to generate memento for target platform", e));
		}
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.internal.core.target.impl.AbstractTargetHandle#getInputStream()
	 */
	protected InputStream getInputStream() throws CoreException {
		return fFile.getContents();
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.internal.core.target.provisional.ITargetHandle#exists()
	 */
	public boolean exists() {
		return fFile.exists();
	}

	/* (non-Javadoc)
	 * @see java.lang.Object#equals(java.lang.Object)
	 */
	public boolean equals(Object obj) {
		if (obj instanceof FileTargetHandle) {
			FileTargetHandle handle = (FileTargetHandle) obj;
			return fFile.equals(handle.fFile);
		}
		return false;
	}

	/* (non-Javadoc)
	 * @see java.lang.Object#hashCode()
	 */
	public int hashCode() {
		return fFile.hashCode() + getClass().hashCode();
	}

}




/*******************************************************************************
 * 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 
 */
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.impl;

import java.io.*;
import java.net.URI;
import java.net.URISyntaxException;
import org.eclipse.core.runtime.*;
import org.eclipse.pde.internal.core.PDECore;
import org.eclipse.pde.internal.core.target.provisional.ITargetHandle;

/**
 * A handle to a target stored with workspace metadata.
 * 
 * @since 3.5
 */
class LocalTargetHandle extends AbstractTargetHandle {

	/**
	 * Time stamp when target was created.
	 */
	private long fTimeStamp;

	/**
	 * The last time stamp handed out.
	 */
	private static long fgLastStamp = -1;

	/**
	 * URI scheme for local targets
	 */
	static final String SCHEME = "local"; //$NON-NLS-1$

	/**
	 * Path to the local directory where API descriptions are cached
	 * per project.
	 */
	static final IPath LOCAL_TARGET_CONTAINER_PATH = PDECore.getDefault().getStateLocation().append(".local_targets"); //$NON-NLS-1$

	/**
	 * Reconstructs a handle from the specified URI.
	 * 
	 * @param uri URI
	 * @return handle to a target in local metadata
	 * @exception if unable to restore
	 */
	static ITargetHandle restoreHandle(URI uri) throws CoreException {
		String part = uri.getSchemeSpecificPart();
		try {
			long stamp = Long.parseLong(part);
			return new LocalTargetHandle(stamp);
		} catch (NumberFormatException e) {
			throw new CoreException(new Status(IStatus.ERROR, PDECore.PLUGIN_ID, "Unable to restore target handle", e));
		}
	}

	/**
	 * Constructs a new target handle to a local file, based on a time stamp.
	 */
	LocalTargetHandle() {
		fTimeStamp = System.currentTimeMillis();
		if (fTimeStamp == fgLastStamp) {
			fTimeStamp++;
		}
		fgLastStamp = fTimeStamp;
	}

	/**
	 * Reconstructs a handle.
	 * 
	 * @param stamp time stamp
	 */
	private LocalTargetHandle(long stamp) {
		fTimeStamp = stamp;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.internal.core.target.impl.AbstractTargetHandle#getInputStream()
	 */
	protected InputStream getInputStream() throws CoreException {
		try {
			return new BufferedInputStream(new FileInputStream(getFile()));
		} catch (FileNotFoundException e) {
			throw new CoreException(new Status(IStatus.ERROR, PDECore.PLUGIN_ID, "Target file not found", e));
		}
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.internal.core.target.provisional.ITargetHandle#getMemento()
	 */
	public String getMemento() throws CoreException {
		try {
			URI uri = new URI(SCHEME, Long.toString(fTimeStamp), null);
			return uri.toString();
		} catch (URISyntaxException e) {
			throw new CoreException(new Status(IStatus.ERROR, PDECore.PLUGIN_ID, "Unable to generate memento for target platform", e));
		}
	}

	/* (non-Javadoc)
	 * @see org.eclipse.pde.internal.core.target.provisional.ITargetHandle#exists()
	 */
	public boolean exists() {
		return getFile().exists();
	}

	/**
	 * Returns the local file associated with this target definition.
	 * 
	 * @return target file
	 */
	private File getFile() {
		return LOCAL_TARGET_CONTAINER_PATH.append(Long.toString(fTimeStamp)).toFile();
	}

	/* (non-Javadoc)
	 * @see java.lang.Object#equals(java.lang.Object)
	 */
	public boolean equals(Object obj) {
		if (obj instanceof LocalTargetHandle) {
			LocalTargetHandle handle = (LocalTargetHandle) obj;
			return handle.fTimeStamp == fTimeStamp;
		}
		return false;
	}

	/* (non-Javadoc)
	 * @see java.lang.Object#hashCode()
	 */
	public int hashCode() {
		return (int) fTimeStamp;
	}
}




/*******************************************************************************
 * 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.core.resources.IFile;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;

/**
 * A service to manage target platform definitions available to the workspace.
 * 
 * @since 3.5
 */
public interface ITargetPlatformService {

	/**
	 * Returns handles to all target definitions known in the workspace.
	 * 
	 * @return handles to all target definitions known in the workspace
	 */
	public ITargetHandle[] getTargets(IProgressMonitor monitor);

	/**
	 * Returns a handle to a target definition backed by the underlying file.
	 * The target definition may or may not exist. If the file does not exist
	 * then this is a new target definition which becomes one of the known
	 * workspace target definitions when it is saved.
	 * 
	 * @param file target definition file that may or may not exist 
	 * @return target handle
	 */
	public ITargetHandle getTarget(IFile file);

	/**
	 * Returns a new target definition to be stored with local metadata. The target
	 * becomes one of the know workspace target definitions when it is saved.
	 * 
	 * @return new empty target definition
	 */
	public ITargetDefinition newTarget();

	/**
	 * Persists the given target definition. The target becomes one of known
	 * workspace target definitions when it is saved.
	 * <p>
	 * The target is persisted in a location determined by its handle. A handle
	 * may refer to an {@link IFile} or a workspace metadata location. Any existing
	 * target definition at the same location is overwritten.
	 * </p>
	 * @param definition definition to persist
	 * @throws CoreException if unable to persist the definition
	 */
	public void saveTargetDefinition(ITargetDefinition definition) throws CoreException;

	/**
	 * Deletes the target definition associated with the given handle.
	 * 
	 * @param handle target handle
	 * @throws CoreException if the associated target does not exist or deletion fails
	 */
	public void deleteTarget(ITargetHandle handle) throws CoreException;

	/**
	 * Creates and returns a target handle from the given memento. The memento must
	 * have been generated from {@link ITargetHandle#getMemento()}.
	 * 
	 * @param memento a target handle memento
	 * @return target handle
	 * @throws CoreException if the target handle format is invalid
	 */
	public ITargetHandle getTargetHandle(String memento) throws CoreException;

	/**
	 * 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 IBundleContainer newDirectoryContainer(String 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 IBundleContainer newProfileContainer(String home);

	/**
	 * 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 IBundleContainer newProfileContainer(String home, String 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.impl;

import java.io.InputStream;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.pde.internal.core.target.provisional.ITargetDefinition;
import org.eclipse.pde.internal.core.target.provisional.ITargetHandle;

/**
 * Common implementation of target handles.
 * 
 * @since 3.5
 */
abstract class AbstractTargetHandle implements ITargetHandle {

	/* (non-Javadoc)
	 * @see org.eclipse.pde.internal.core.target.provisional.ITargetHandle#getTargetDefinition()
	 */
	public ITargetDefinition getTargetDefinition() throws CoreException {
		TargetDefinition definition = new TargetDefinition(this);
		if (exists()) {
			definition.setContents(getInputStream());
		}
		return definition;
	}

	/**
	 * Returns an input stream of the target definition's contents.
	 * 
	 * @return stream of content
	 * @throws CoreException if an error occurs
	 */
	protected abstract InputStream getInputStream() 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.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, or <code>null</code> if none
	 * 
	 * @return name or <code>null</code>
	 */
	public String getName();

	/**
	 * Sets the name of this target.
	 * 
	 * @param name target name or <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);

	/**
	 * Returns a handle to this target definition.
	 * 
	 * @return target handle
	 */
	public ITargetHandle getHandle();
}




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

Lines 20-25 Link Here

(-)META-INF/MANIFEST.MF (-1 / +2 lines)
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.core.filesystem	23	org.eclipse.core.filesystem,
		24	org.eclipse.equinox.frameworkadmin
24	Eclipse-LazyStart: true	25	Eclipse-LazyStart: true
25	Bundle-RequiredExecutionEnvironment: J2SE-1.4	26	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 org.eclipse.core.runtime.CoreException;

import org.eclipse.pde.internal.core.target.provisional.ITargetHandle;

import org.eclipse.core.resources.IFile;

import org.eclipse.core.resources.ResourcesPlugin;

import org.eclipse.pde.internal.core.target.provisional.ITargetPlatformService;

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;
import org.osgi.framework.ServiceReference;

/**
 * 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;
	}
	
	/**
	 * Returns the target platform service or <code>null</code> if none
	 * 
	 * @return target platform service
	 */
	protected ITargetPlatformService getTargetService() {
		ServiceReference reference = MacroPlugin.getBundleContext().getServiceReference(ITargetPlatformService.class.getName());
		assertNotNull("Missing target platform service", reference);
		if (reference == null)
			return null;
		return (ITargetPlatformService) MacroPlugin.getBundleContext().getService(reference);
	}

	/**
	 * 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 = getTargetService().newTarget();
		IBundleContainer container = getTargetService().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 = getTargetService().newTarget();
		IBundleContainer container = getTargetService().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 = getTargetService().newTarget();
		IBundleContainer container = getTargetService().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 = getTargetService().newTarget();
		IBundleContainer container = getTargetService().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 = getTargetService().newTarget();
		IBundleContainer container = getTargetService().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;
	}	
	
	/**
	 * Tests restoration of a handle to target definition in an IFile 
	 * @throws CoreException 
	 */
	public void testFileTargetHandleMemento() throws CoreException {
		ITargetPlatformService service = getTargetService();
		IFile file = ResourcesPlugin.getWorkspace().getRoot().getFile(new Path("does/not/exist"));
		ITargetHandle handle = service.getTarget(file);
		assertFalse("Target should not exist", handle.exists());
		String memento = handle.getMemento();
		assertNotNull("Missing memento", memento);
		ITargetHandle handle2 = service.getTargetHandle(memento);
		assertEquals("Restore failed", handle, handle2);
		IFile file2 = ResourcesPlugin.getWorkspace().getRoot().getFile(new Path("does/not/exist/either"));
		ITargetHandle handle3 = service.getTarget(file2);
		assertFalse("Should be different targets", handle.equals(handle3));
	}
	
	/**
	 * Tests restoration of a handle to target definition in local metadata 
	 * 
	 * @throws CoreException 
	 * @throws InterruptedException 
	 */
	public void testLocalTargetHandleMemento() throws CoreException, InterruptedException {
		ITargetPlatformService service = getTargetService();
		ITargetHandle handle = service.newTarget().getHandle();
		assertFalse("Target should not exist", handle.exists());
		String memento = handle.getMemento();
		assertNotNull("Missing memento", memento);
		ITargetHandle handle2 = service.getTargetHandle(memento);
		assertEquals("Restore failed", handle, handle2);
		ITargetHandle handle3 = service.newTarget().getHandle();
		assertFalse("Should be different targets", handle.equals(handle3));
	}	
}

Return to bug 256910

Lines 54-85 Link Here

(-)src/org/eclipse/pde/internal/core/P2Utils.java (-9 / +65 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	IPath basePath = new Path(platformHome);
58	if (configurationArea == null) {	57	if (configurationArea == null) {
59	return null;	58	return null;
60	}	59	}
61	try {	60	try {
62	URL bundlesTxt = new URL(configurationArea.getProtocol(), configurationArea.getHost(), configurationArea.getFile().concat(BUNDLE_INFO_PATH));	61	BundleInfo[] bundles = readBundles(platformHome, configurationArea);
63	File home = basePath.toFile();	62	if (bundles == null) {
64	BundleInfo bundles[] = getBundlesFromFile(bundlesTxt, home);
65	if (bundles == null \|\| bundles.length == 0) {
66	return null;	63	return null;
67	}	64	}
68	int length = bundles.length;	65	int length = bundles.length;
69	URL srcBundlesTxt = new URL(configurationArea.getProtocol(), configurationArea.getHost(), configurationArea.getFile().concat(SRC_INFO_PATH));	66	BundleInfo[] srcBundles = readSourceBundles(platformHome, configurationArea);
70	BundleInfo srcBundles[] = getBundlesFromFile(srcBundlesTxt, home);
71
72	if (srcBundles != null) {	67	if (srcBundles != null) {
73	length += srcBundles.length;	68	length += srcBundles.length;
74	}	69	}
75
76	URL[] urls = new URL[length];	70	URL[] urls = new URL[length];
77	copyURLs(urls, 0, bundles);	71	copyURLs(urls, 0, bundles);
78	if (srcBundles != null && srcBundles.length > 0) {	72	if (srcBundles != null && srcBundles.length > 0) {
79	copyURLs(urls, bundles.length, srcBundles);	73	copyURLs(urls, bundles.length, srcBundles);
80	}	74	}
81	return urls;	75	return urls;
		76	} catch (MalformedURLException e) {
		77	PDECore.log(e);
		78	return null;
		79	}
		80	}
		81
		82	/**
		83	* Returns bundles defined by the 'bundles.info' relative to the given
		84	* home and configuration area, or <code>null</code> if none.
		85	* The "bundles.info" file is assumed to be at a fixed location relative to the
		86	* configuration area URL.
		87	*
		88	* @param platformHome absolute path in the local file system to an installation
		89	* @param configurationArea url location of the configuration directory to search
		90	* for bundles.info
		91	* @return all bundles in the installation or <code>null</code> if not able
		92	* to locate a bundles.info
		93	*/
		94	public static BundleInfo[] readBundles(String platformHome, URL configurationArea) {
		95	IPath basePath = new Path(platformHome);
		96	if (configurationArea == null) {
		97	return null;
		98	}
		99	try {
		100	URL bundlesTxt = new URL(configurationArea.getProtocol(), configurationArea.getHost(), configurationArea.getFile().concat(BUNDLE_INFO_PATH));
		101	File home = basePath.toFile();
		102	BundleInfo bundles[] = getBundlesFromFile(bundlesTxt, home);
		103	if (bundles == null \|\| bundles.length == 0) {
		104	return null;
		105	}
		106	return bundles;
		107	} catch (MalformedURLException e) {
		108	PDECore.log(e);
		109	return null;
		110	} catch (IOException e) {
		111	PDECore.log(e);
		112	return null;
		113	}
		114	}
82		115
		116	/**
		117	* Returns source bundles defined by the 'source.info' file in the
		118	* specified location, or <code>null</code> if none. The "source.info" file
		119	* is assumed to be at a fixed location relative to the configuration area URL.
		120	*
		121	* @param platformHome absolute path in the local file system to an installation
		122	* @param configurationArea url location of the configuration directory to search for bundles.info and source.info
		123	* @return all source bundles in the installation or <code>null</code> if not able
		124	* to locate a source.info
		125	*/
		126	public static BundleInfo[] readSourceBundles(String platformHome, URL configurationArea) {
		127	IPath basePath = new Path(platformHome);
		128	if (configurationArea == null) {
		129	return null;
		130	}
		131	try {
		132	File home = basePath.toFile();
		133	URL srcBundlesTxt = new URL(configurationArea.getProtocol(), configurationArea.getHost(), configurationArea.getFile().concat(SRC_INFO_PATH));
		134	BundleInfo srcBundles[] = getBundlesFromFile(srcBundlesTxt, home);
		135	if (srcBundles == null \|\| srcBundles.length == 0) {
		136	return null;
		137	}
		138	return srcBundles;
83	} catch (MalformedURLException e) {	139	} catch (MalformedURLException e) {
84	PDECore.log(e);	140	PDECore.log(e);
85	return null;	141	return null;

Added Link Here

(-)src/org/eclipse/pde/internal/core/target/impl/TargetDefinition.java (+248 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.io.InputStream;
14	import java.io.OutputStream;
15	import java.util.*;
16	import org.eclipse.core.runtime.CoreException;
17	import org.eclipse.core.runtime.IProgressMonitor;
18	import org.eclipse.equinox.internal.provisional.frameworkadmin.BundleInfo;
19	import org.eclipse.pde.internal.core.target.provisional.*;
20
21	/**
22	* Target definition implementation.
23	*
24	* @since 3.5
25	*/
26	class TargetDefinition implements ITargetDefinition {
27
28	// name and description
29	private String fName;
30	private String fDescription;
31
32	// arguments
33	private String fProgramArgs;
34	private String fVMArgs;
35
36	// environment settings
37	private String fEE;
38	private String fArch;
39	private String fOS;
40	private String fWS;
41	private String fNL;
42
43	// bundle containers
44	private IBundleContainer[] fContainers;
45
46	// handle
47	private ITargetHandle fHandle;
48
49	/**
50	* Constructs a target definition based on the given handle.
51	*/
52	TargetDefinition(ITargetHandle handle) {
53	fHandle = handle;
54	}
55
56	/* (non-Javadoc)
57	* @see org.eclipse.pde.internal.core.target.provisional.ITargetDefinition#getArch()
58	*/
59	public String getArch() {
60	return fArch;
61	}
62
63	/* (non-Javadoc)
64	* @see org.eclipse.pde.internal.core.target.provisional.ITargetDefinition#getBundleContainers()
65	*/
66	public IBundleContainer[] getBundleContainers() {
67	return fContainers;
68	}
69
70	/* (non-Javadoc)
71	* @see org.eclipse.pde.internal.core.target.provisional.ITargetDefinition#getDescription()
72	*/
73	public String getDescription() {
74	return fDescription;
75	}
76
77	/* (non-Javadoc)
78	* @see org.eclipse.pde.internal.core.target.provisional.ITargetDefinition#getExecutionEnvironment()
79	*/
80	public String getExecutionEnvironment() {
81	return fEE;
82	}
83
84	/* (non-Javadoc)
85	* @see org.eclipse.pde.internal.core.target.provisional.ITargetDefinition#getNL()
86	*/
87	public String getNL() {
88	return fNL;
89	}
90
91	/* (non-Javadoc)
92	* @see org.eclipse.pde.internal.core.target.provisional.ITargetDefinition#getName()
93	*/
94	public String getName() {
95	return fName;
96	}
97
98	/* (non-Javadoc)
99	* @see org.eclipse.pde.internal.core.target.provisional.ITargetDefinition#getOS()
100	*/
101	public String getOS() {
102	return fOS;
103	}
104
105	/* (non-Javadoc)
106	* @see org.eclipse.pde.internal.core.target.provisional.ITargetDefinition#getProgramArguments()
107	*/
108	public String getProgramArguments() {
109	return fProgramArgs;
110	}
111
112	/* (non-Javadoc)
113	* @see org.eclipse.pde.internal.core.target.provisional.ITargetDefinition#getVMArguments()
114	*/
115	public String getVMArguments() {
116	return fVMArgs;
117	}
118
119	/* (non-Javadoc)
120	* @see org.eclipse.pde.internal.core.target.provisional.ITargetDefinition#getWS()
121	*/
122	public String getWS() {
123	return fWS;
124	}
125
126	/* (non-Javadoc)
127	* @see org.eclipse.pde.internal.core.target.provisional.ITargetDefinition#setArch(java.lang.String)
128	*/
129	public void setArch(String arch) {
130	fArch = arch;
131	}
132
133	/* (non-Javadoc)
134	* @see org.eclipse.pde.internal.core.target.provisional.ITargetDefinition#setDescription(java.lang.String)
135	*/
136	public void setDescription(String description) {
137	fDescription = description;
138	}
139
140	/* (non-Javadoc)
141	* @see org.eclipse.pde.internal.core.target.provisional.ITargetDefinition#setExecutionEnvironment(java.lang.String)
142	*/
143	public void setExecutionEnvironment(String environment) {
144	fEE = environment;
145	}
146
147	/* (non-Javadoc)
148	* @see org.eclipse.pde.internal.core.target.provisional.ITargetDefinition#setNL(java.lang.String)
149	*/
150	public void setNL(String nl) {
151	fNL = nl;
152	}
153
154	/* (non-Javadoc)
155	* @see org.eclipse.pde.internal.core.target.provisional.ITargetDefinition#setName(java.lang.String)
156	*/
157	public void setName(String name) {
158	fName = name;
159	}
160
161	/* (non-Javadoc)
162	* @see org.eclipse.pde.internal.core.target.provisional.ITargetDefinition#setOS(java.lang.String)
163	*/
164	public void setOS(String os) {
165	fOS = os;
166	}
167
168	/* (non-Javadoc)
169	* @see org.eclipse.pde.internal.core.target.provisional.ITargetDefinition#setProgramArguments(java.lang.String)
170	*/
171	public void setProgramArguments(String args) {
172	fProgramArgs = args;
173	}
174
175	/* (non-Javadoc)
176	* @see org.eclipse.pde.internal.core.target.provisional.ITargetDefinition#setVMArguments(java.lang.String)
177	*/
178	public void setVMArguments(String args) {
179	fVMArgs = args;
180	}
181
182	/* (non-Javadoc)
183	* @see org.eclipse.pde.internal.core.target.provisional.ITargetDefinition#setWS(java.lang.String)
184	*/
185	public void setWS(String ws) {
186	fWS = ws;
187	}
188
189	/* (non-Javadoc)
190	* @see org.eclipse.pde.internal.core.target.provisional.ITargetDefinition#setBundleContainers(org.eclipse.pde.internal.core.target.provisional.IBundleContainer[])
191	*/
192	public void setBundleContainers(IBundleContainer[] containers) {
193	fContainers = containers;
194	}
195
196	/* (non-Javadoc)
197	* @see org.eclipse.pde.internal.core.target.provisional.ITargetDefinition#resolveBundles(org.eclipse.core.runtime.IProgressMonitor)
198	*/
199	public BundleInfo[] resolveBundles(IProgressMonitor monitor) throws CoreException {
200	IBundleContainer[] containers = getBundleContainers();
201	List bundles = new ArrayList();
202	for (int i = 0; i < containers.length; i++) {
203	BundleInfo[] infos = containers[i].resolveBundles(monitor);
204	bundles.addAll(Arrays.asList(infos));
205	}
206	return (BundleInfo[]) bundles.toArray(new BundleInfo[bundles.size()]);
207	}
208
209	/* (non-Javadoc)
210	* @see org.eclipse.pde.internal.core.target.provisional.ITargetDefinition#resolveSourceBundles(org.eclipse.core.runtime.IProgressMonitor)
211	*/
212	public BundleInfo[] resolveSourceBundles(IProgressMonitor monitor) throws CoreException {
213	IBundleContainer[] containers = getBundleContainers();
214	List source = new ArrayList();
215	for (int i = 0; i < containers.length; i++) {
216	BundleInfo[] infos = containers[i].resolveSourceBundles(monitor);
217	source.addAll(Arrays.asList(infos));
218	}
219	return (BundleInfo[]) source.toArray(new BundleInfo[source.size()]);
220	}
221
222	/* (non-Javadoc)
223	* @see org.eclipse.pde.internal.core.target.provisional.ITargetDefinition#getHandle()
224	*/
225	public ITargetHandle getHandle() {
226	return fHandle;
227	}
228
229	/**
230	* Build contents from the given stream.
231	*
232	* @param stream input stream
233	* @throws CoreException if an error occurs
234	*/
235	void setContents(InputStream stream) throws CoreException {
236
237	}
238
239	/**
240	* Persists contents to the given stream.
241	*
242	* @param stream output stream
243	* @throws CoreException if an error occurs
244	*/
245	void write(OutputStream stream) throws CoreException {
246
247	}
248	}

Added Link Here

(-)src/org/eclipse/pde/ui/tests/target/TargetDefinitionTests.java (+340 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 org.eclipse.core.runtime.CoreException;
14
15	import org.eclipse.pde.internal.core.target.provisional.ITargetHandle;
16
17	import org.eclipse.core.resources.IFile;
18
19	import org.eclipse.core.resources.ResourcesPlugin;
20
21	import org.eclipse.pde.internal.core.target.provisional.ITargetPlatformService;
22
23	import java.io.*;
24	import java.net.URL;
25	import java.util.*;
26	import java.util.zip.ZipEntry;
27	import java.util.zip.ZipFile;
28	import junit.framework.TestCase;
29	import org.eclipse.core.runtime.*;
30	import org.eclipse.equinox.internal.provisional.frameworkadmin.BundleInfo;
31	import org.eclipse.pde.core.plugin.TargetPlatform;
32	import org.eclipse.pde.internal.core.*;
33	import org.eclipse.pde.internal.core.target.provisional.*;
34	import org.eclipse.pde.internal.ui.tests.macro.MacroPlugin;
35	import org.osgi.framework.ServiceReference;
36
37	/**
38	* Tests for target definitions.
39	*
40	* @since 3.5
41	*/
42	public class TargetDefinitionTests extends TestCase {
43
44	/**
45	* Retrieves all bundles (source and code) in the given target definition
46	* returning them as a set of URLs.
47	*
48	* @param target target definition
49	* @return all bundle URLs
50	*/
51	protected Set getAllBundleURLs(ITargetDefinition target) throws Exception {
52	BundleInfo[] code = target.resolveBundles(null);
53	BundleInfo[] source = target.resolveSourceBundles(null);
54	Set urls = new HashSet(code.length + source.length);
55	for (int i = 0; i < code.length; i++) {
56	urls.add(code[i].getLocation().toURL());
57	}
58	for (int i = 0; i < source.length; i++) {
59	urls.add(source[i].getLocation().toURL());
60	}
61	return urls;
62	}
63
64	/**
65	* Extracts the classic plug-ins archive, if not already done, and returns a path to the
66	* root directory containing the plug-ins.
67	*
68	* @return path to the plug-ins directory
69	* @throws Exception
70	*/
71	protected IPath extracClassicPlugins() throws Exception {
72	// extract the 3.0.2 skeleton
73	IPath stateLocation = MacroPlugin.getDefault().getStateLocation();
74	IPath location = stateLocation.append("classic-plugins");
75	if (location.toFile().exists()) {
76	return location;
77	}
78	URL zipURL = MacroPlugin.getBundleContext().getBundle().getEntry("/tests/targets/classic-plugins.zip");
79	Path zipPath = new Path(new File(FileLocator.toFileURL(zipURL).getFile()).getAbsolutePath());
80	ZipFile zipFile = new ZipFile(zipPath.toFile());
81	Enumeration entries = zipFile.entries();
82	while (entries.hasMoreElements()) {
83	ZipEntry entry = (ZipEntry) entries.nextElement();
84	if (!entry.isDirectory()) {
85	IPath entryPath = stateLocation.append(entry.getName());
86	File dir = entryPath.removeLastSegments(1).toFile();
87	dir.mkdirs();
88	File file = entryPath.toFile();
89	file.createNewFile();
90	InputStream inputStream = new BufferedInputStream(zipFile.getInputStream(entry));
91	byte[] bytes = getInputStreamAsByteArray(inputStream, -1);
92	inputStream.close();
93	BufferedOutputStream outputStream = new BufferedOutputStream(new FileOutputStream(file));
94	outputStream.write(bytes);
95	outputStream.close();
96	}
97	}
98	zipFile.close();
99	return location;
100	}
101
102	/**
103	* Returns the target platform service or <code>null</code> if none
104	*
105	* @return target platform service
106	*/
107	protected ITargetPlatformService getTargetService() {
108	ServiceReference reference = MacroPlugin.getBundleContext().getServiceReference(ITargetPlatformService.class.getName());
109	assertNotNull("Missing target platform service", reference);
110	if (reference == null)
111	return null;
112	return (ITargetPlatformService) MacroPlugin.getBundleContext().getService(reference);
113	}
114
115	/**
116	* Tests that a target definition equivalent to the default target platform
117	* contains the same bundles as the default target platform (this is an
118	* explicit location with no target weaving).
119	*
120	* @throws Exception
121	*/
122	public void testDefaultTargetPlatform() throws Exception {
123	// the new way
124	ITargetDefinition definition = getTargetService().newTarget();
125	IBundleContainer container = getTargetService().newProfileContainer(TargetPlatform.getDefaultLocation());
126	definition.setBundleContainers(new IBundleContainer[]{container});
127	Set urls = getAllBundleURLs(definition);
128
129	// the old way
130	IPath location = new Path(TargetPlatform.getDefaultLocation());
131	URL[] pluginPaths = P2Utils.readBundlesTxt(location.toOSString(), location.append("configuration").toFile().toURL());
132	assertEquals("Should have same number of bundles", pluginPaths.length, urls.size());
133	for (int i = 0; i < pluginPaths.length; i++) {
134	URL url = pluginPaths[i];
135	assertTrue("Missing plug-in " + url.toString(), urls.contains(url));
136	}
137
138	}
139
140	/**
141	* Tests that a target definition equivalent to the default target platform
142	* contains the same bundles as the default target platform using the
143	* platform's configuration location (which will do target weaving). This
144	* is really only tested when run as a JUnit plug-in test suite from
145	* within Eclipse.
146	*
147	* @throws Exception
148	*/
149	public void testWovenTargetPlatform() throws Exception {
150	// the new way
151	ITargetDefinition definition = getTargetService().newTarget();
152	IBundleContainer container = getTargetService().newProfileContainer(TargetPlatform.getDefaultLocation(),
153	new File(Platform.getConfigurationLocation().getURL().getFile()).getAbsolutePath());
154	definition.setBundleContainers(new IBundleContainer[]{container});
155	Set urls = getAllBundleURLs(definition);
156
157	// the old way
158	URL[] pluginPaths = PluginPathFinder.getPluginPaths(TargetPlatform.getDefaultLocation());
159	assertEquals("Should have same number of bundles", pluginPaths.length, urls.size());
160	for (int i = 0; i < pluginPaths.length; i++) {
161	URL url = pluginPaths[i];
162	assertTrue("Missing plug-in " + url.toString(), urls.contains(url));
163	}
164
165	}
166
167	/**
168	* Tests that a bundle directory container is equivalent to scanning locations.
169	*
170	* @throws Exception
171	*/
172	public void testDirectoryBundleContainer() throws Exception {
173	// the new way
174	ITargetDefinition definition = getTargetService().newTarget();
175	IBundleContainer container = getTargetService().newDirectoryContainer(TargetPlatform.getDefaultLocation() + "/plugins");
176	definition.setBundleContainers(new IBundleContainer[]{container});
177	Set urls = getAllBundleURLs(definition);
178
179	Preferences store = PDECore.getDefault().getPluginPreferences();
180	boolean restore = store.getBoolean(ICoreConstants.TARGET_PLATFORM_REALIZATION);
181	try {
182	store.setValue(ICoreConstants.TARGET_PLATFORM_REALIZATION, false);
183	// the old way
184	URL[] pluginPaths = PluginPathFinder.getPluginPaths(TargetPlatform.getDefaultLocation());
185	assertEquals("Should have same number of bundles", pluginPaths.length, urls.size());
186	for (int i = 0; i < pluginPaths.length; i++) {
187	URL url = pluginPaths[i];
188	assertTrue("Missing plug-in " + url.toString(), urls.contains(url));
189	}
190	}
191	finally {
192	store.setValue(ICoreConstants.TARGET_PLATFORM_REALIZATION, restore);
193	}
194	}
195
196	/**
197	* Tests reading a 3.0.2 install with a mix of classic and OSGi plug-ins.
198	*
199	* @throws Exception
200	*/
201	public void testClassicPlugins() throws Exception {
202	// extract the 3.0.2 skeleton
203	IPath location = extracClassicPlugins();
204
205	// the new way
206	ITargetDefinition definition = getTargetService().newTarget();
207	IBundleContainer container = getTargetService().newDirectoryContainer(location.toOSString());
208	definition.setBundleContainers(new IBundleContainer[]{container});
209	Set urls = getAllBundleURLs(definition);
210
211	Preferences store = PDECore.getDefault().getPluginPreferences();
212	boolean restore = store.getBoolean(ICoreConstants.TARGET_PLATFORM_REALIZATION);
213	try {
214	store.setValue(ICoreConstants.TARGET_PLATFORM_REALIZATION, false);
215	// the old way
216	URL[] pluginPaths = PluginPathFinder.getPluginPaths(location.toOSString());
217	for (int i = 0; i < pluginPaths.length; i++) {
218	URL url = pluginPaths[i];
219	if (!urls.contains(url)) {
220	System.err.println(url.toString());
221	}
222	}
223	assertEquals("Wrong number of bundles", pluginPaths.length, urls.size());
224	}
225	finally {
226	store.setValue(ICoreConstants.TARGET_PLATFORM_REALIZATION, restore);
227	}
228	}
229
230	/**
231	* Tests identification of source bundles in a 3.0.2 install.
232	*
233	* @throws Exception
234	*/
235	public void testClassicSourcePlugins() throws Exception {
236	// extract the 3.0.2 skeleton
237	IPath location = extracClassicPlugins();
238
239	// the new way
240	ITargetDefinition definition = getTargetService().newTarget();
241	IBundleContainer container = getTargetService().newDirectoryContainer(location.toOSString());
242	definition.setBundleContainers(new IBundleContainer[]{container});
243	BundleInfo[] bundles = definition.resolveSourceBundles(null);
244	assertEquals("Wrong number of source bundles", 3, bundles.length);
245	Set names = new HashSet();
246	for (int i = 0; i < bundles.length; i++) {
247	names.add(bundles[i].getSymbolicName());
248	}
249	String[] expected = new String[]{"org.eclipse.platform.source", "org.eclipse.jdt.source", "org.eclipse.pde.source"};
250	for (int i = 0; i < expected.length; i++) {
251	assertTrue("Missing source for " + expected[i], names.contains(expected[i]));
252	}
253	}
254
255	/**
256	* Returns the given input stream as a byte array
257	* @param stream the stream to get as a byte array
258	* @param length the length to read from the stream or -1 for unknown
259	* @return the given input stream as a byte array
260	* @throws IOException
261	*/
262	public static byte[] getInputStreamAsByteArray(InputStream stream, int length) throws IOException {
263	byte[] contents;
264	if (length == -1) {
265	contents = new byte[0];
266	int contentsLength = 0;
267	int amountRead = -1;
268	do {
269	// read at least 8K
270	int amountRequested = Math.max(stream.available(), 8192);
271	// resize contents if needed
272	if (contentsLength + amountRequested > contents.length) {
273	System.arraycopy(contents,
274	0,
275	contents = new byte[contentsLength + amountRequested],
276	0,
277	contentsLength);
278	}
279	// read as many bytes as possible
280	amountRead = stream.read(contents, contentsLength, amountRequested);
281	if (amountRead > 0) {
282	// remember length of contents
283	contentsLength += amountRead;
284	}
285	} while (amountRead != -1);
286	// resize contents if necessary
287	if (contentsLength < contents.length) {
288	System.arraycopy(contents, 0, contents = new byte[contentsLength], 0, contentsLength);
289	}
290	} else {
291	contents = new byte[length];
292	int len = 0;
293	int readSize = 0;
294	while ((readSize != -1) && (len != length)) {
295	// See PR 1FMS89U
296	// We record first the read size. In this case length is the actual
297	// read size.
298	len += readSize;
299	readSize = stream.read(contents, len, length - len);
300	}
301	}
302	return contents;
303	}
304
305	/**
306	* Tests restoration of a handle to target definition in an IFile
307	* @throws CoreException
308	*/
309	public void testFileTargetHandleMemento() throws CoreException {
310	ITargetPlatformService service = getTargetService();
311	IFile file = ResourcesPlugin.getWorkspace().getRoot().getFile(new Path("does/not/exist"));
312	ITargetHandle handle = service.getTarget(file);
313	assertFalse("Target should not exist", handle.exists());
314	String memento = handle.getMemento();
315	assertNotNull("Missing memento", memento);
316	ITargetHandle handle2 = service.getTargetHandle(memento);
317	assertEquals("Restore failed", handle, handle2);
318	IFile file2 = ResourcesPlugin.getWorkspace().getRoot().getFile(new Path("does/not/exist/either"));
319	ITargetHandle handle3 = service.getTarget(file2);
320	assertFalse("Should be different targets", handle.equals(handle3));
321	}
322
323	/**
324	* Tests restoration of a handle to target definition in local metadata
325	*
326	* @throws CoreException
327	* @throws InterruptedException
328	*/
329	public void testLocalTargetHandleMemento() throws CoreException, InterruptedException {
330	ITargetPlatformService service = getTargetService();
331	ITargetHandle handle = service.newTarget().getHandle();
332	assertFalse("Target should not exist", handle.exists());
333	String memento = handle.getMemento();
334	assertNotNull("Missing memento", memento);
335	ITargetHandle handle2 = service.getTargetHandle(memento);
336	assertEquals("Restore failed", handle, handle2);
337	ITargetHandle handle3 = service.newTarget().getHandle();
338	assertFalse("Should be different targets", handle.equals(handle3));
339	}
340	}