src/main/java/net/sf/taverna/t2/maven/plugins/MavenOsgiUtils.java - incubator-taverna-osgi - Git at Google

 /*******************************************************************************
  * Copyright (C) 2013 The University of Manchester
  *
  *  Modifications to the initial code base are copyright of their
  *  respective authors, or their employers as appropriate.
  *
  *  This program is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU Lesser General Public License
  *  as published by the Free Software Foundation; either version 2.1 of
  *  the License, or (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful, but
  *  WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  *  Lesser General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser General Public
  *  License along with this program; if not, write to the Free Software
  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  ******************************************************************************/
 package net.sf.taverna.t2.maven.plugins;

 import java.io.File;
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.Set;
 import java.util.jar.Attributes;
 import java.util.jar.JarFile;
 import java.util.jar.Manifest;

 import org.apache.maven.RepositoryUtils;
 import org.apache.maven.artifact.Artifact;
 import org.apache.maven.plugin.MojoExecutionException;
 import org.apache.maven.plugin.logging.Log;
 import org.apache.maven.project.DefaultDependencyResolutionRequest;
 import org.apache.maven.project.DependencyResolutionException;
 import org.apache.maven.project.DependencyResolutionResult;
 import org.apache.maven.project.MavenProject;
 import org.apache.maven.project.ProjectDependenciesResolver;
 import org.eclipse.aether.RepositorySystemSession;
 import org.eclipse.aether.graph.DependencyNode;
 import org.eclipse.aether.util.filter.ScopeDependencyFilter;

 import uk.org.taverna.commons.profile.xml.jaxb.BundleInfo;
 import aQute.bnd.header.Attrs;
 import aQute.bnd.header.OSGiHeader;
 import aQute.bnd.header.Parameters;
 import aQute.bnd.osgi.Constants;
 import aQute.bnd.version.Version;
 import aQute.bnd.version.VersionRange;

 /**
  * @author David Withers
  */
 public class MavenOsgiUtils {

 	private final MavenProject project;
 	private final RepositorySystemSession repositorySystemSession;
 	private final ProjectDependenciesResolver projectDependenciesResolver;
 	private final Log log;

 	private Set<String> javaPackages;
 	private Set<String> systemPackages;

 	public MavenOsgiUtils(MavenProject project, RepositorySystemSession repositorySystemSession,
 			ProjectDependenciesResolver projectDependenciesResolver, Log log) {
 		this(project, repositorySystemSession, projectDependenciesResolver, new HashSet<String>(),
 				log);
 	}

 	public MavenOsgiUtils(MavenProject project, RepositorySystemSession repositorySystemSession,
 			ProjectDependenciesResolver projectDependenciesResolver, Set<String> systemPackages,
 			Log log) {
 		this.project = project;
 		this.repositorySystemSession = repositorySystemSession;
 		this.projectDependenciesResolver = projectDependenciesResolver;
 		this.systemPackages = systemPackages;
 		this.log = log;
 		javaPackages = Utils.getJavaPackages(log);
 	}

 	public Set<BundleArtifact> getBundleDependencies(String... scopes)
 			throws MojoExecutionException {
 		ScopeDependencyFilter scopeFilter = new ScopeDependencyFilter(Arrays.asList(scopes), null);

 		DefaultDependencyResolutionRequest dependencyResolutionRequest = new DefaultDependencyResolutionRequest(
 				project, repositorySystemSession);
 		dependencyResolutionRequest.setResolutionFilter(scopeFilter);

 		DependencyResolutionResult dependencyResolutionResult;
 		try {
 			dependencyResolutionResult = projectDependenciesResolver
 					.resolve(dependencyResolutionRequest);
 		} catch (DependencyResolutionException ex) {
 			throw new MojoExecutionException(ex.getMessage(), ex);
 		}

 		DependencyNode dependencyGraph = dependencyResolutionResult.getDependencyGraph();
 		if (dependencyGraph != null) {
 			checkBundleDependencies(dependencyGraph.getChildren());
 			return getBundleArtifacts(dependencyGraph.getChildren());
 		} else {
 			return new HashSet<BundleArtifact>();
 		}
 	}

 	public Set<BundleArtifact> getBundleArtifacts(List<DependencyNode> nodes) {
 		Set<BundleArtifact> bundleArtifacts = new HashSet<BundleArtifact>();
 		for (DependencyNode node : nodes) {
 			Artifact artifact = RepositoryUtils.toArtifact(node.getDependency().getArtifact());
 			String symbolicName = getManifestAttribute(artifact, Constants.BUNDLE_SYMBOLICNAME);
 			if (symbolicName != null) {
 				String version = getManifestAttribute(artifact, Constants.BUNDLE_VERSION);
 				bundleArtifacts.add(new BundleArtifact(artifact, symbolicName, version));
 				bundleArtifacts.addAll(getBundleArtifacts(node.getChildren()));
 			} else {
 				log.warn("Not an OSGi bundle : " + artifact.getId());
 			}
 		}
 		return bundleArtifacts;
 	}

 	public Set<Artifact> getAllArtifacts(List<DependencyNode> nodes) {
 		Set<Artifact> artifacts = new HashSet<Artifact>();
 		for (DependencyNode node : nodes) {
 			Artifact artifact = RepositoryUtils.toArtifact(node.getDependency().getArtifact());
 			if (isBundle(artifact)) {
 				artifacts.add(artifact);
 				artifacts.addAll(getAllArtifacts(node.getChildren()));
 			}
 		}
 		return artifacts;
 	}

 	public Set<Artifact> getArtifacts(List<DependencyNode> nodes) {
 		Set<Artifact> artifacts = new HashSet<Artifact>();
 		for (DependencyNode node : nodes) {
 			Artifact artifact = RepositoryUtils.toArtifact(node.getDependency().getArtifact());
 			if (isBundle(artifact)) {
 				artifacts.add(artifact);
 			}
 		}
 		return artifacts;
 	}

 	public List<BundleInfo> getBundles(Set<BundleArtifact> bundleDependencies)
 			throws MojoExecutionException {
 		List<BundleInfo> bundles = new ArrayList<BundleInfo>();
 		for (BundleArtifact bundleArtifact : bundleDependencies) {
 			Artifact artifact = bundleArtifact.getArtifact();
 			BundleInfo bundle = new BundleInfo();
 			bundle.setSymbolicName(bundleArtifact.getSymbolicName());
 			bundle.setVersion(bundleArtifact.getVersion());
 			bundle.setFileName(new File(artifact.getGroupId(), artifact.getFile().getName())
 					.getPath());
 			bundles.add(bundle);
 		}
 		Collections.sort(bundles, new BundleComparator());
 		return bundles;
 	}

 	public Map<String, Set<PackageVersion>> getPackageDependencies(List<DependencyNode> nodes) {
 		Map<String, Set<PackageVersion>> exportVersions = calculatePackageVersions(
 				getAllArtifacts(nodes), true, false);
 		return getPackageDependencies(getArtifacts(nodes), exportVersions);
 	}

 	public Map<String, Set<PackageVersion>> getPackageDependencies(Set<Artifact> requiredArtifacts,
 			Map<String, Set<PackageVersion>> exportVersions) {
 		Map<String, Set<PackageVersion>> importVersions = calculatePackageVersions(
 				requiredArtifacts, false, true);
 		Set<Artifact> newRequiredArtifacts = new HashSet<Artifact>();
 		for (Entry<String, Set<PackageVersion>> entry : importVersions.entrySet()) {
 			if (!javaPackages.contains(entry.getKey())) {
 				String packageName = entry.getKey();
 				Set<PackageVersion> importsVersions = entry.getValue();
 				Set<PackageVersion> exportsVersions = exportVersions.get(packageName);
 				if (exportVersions.containsKey(entry.getKey())) {
 					for (Artifact artifact : getRequiredArtifacts(importsVersions, exportsVersions)) {
 						if (!requiredArtifacts.contains(artifact)) {
 							newRequiredArtifacts.add(artifact);
 						}
 					}
 				}
 			}
 		}
 		if (!newRequiredArtifacts.isEmpty()) {
 			newRequiredArtifacts.addAll(requiredArtifacts);
 			return getPackageDependencies(newRequiredArtifacts, exportVersions);
 		}
 		return importVersions;
 	}

 	/**
 	 * Returns the minimum set of artifacts required to satisfy the range of importVersions.
 	 *
 	 * @param importsVersions
 	 *            the version ranges required for the package
 	 * @param exportVersions
 	 *            the available versions for the package
 	 * @return the minimum set of artifacts required to satisfy the range of importVersions
 	 */
 	private Set<Artifact> getRequiredArtifacts(Set<PackageVersion> importsVersions,
 			Set<PackageVersion> exportVersions) {
 		Set<Artifact> requiredArtifacts = new HashSet<Artifact>();
 		List<Set<PackageVersion>> exportsSubsets = Utils.getSubsets(exportVersions);
 		for (Set<PackageVersion> exportsSubset : exportsSubsets) {
 			if (satisfiesImports(importsVersions, exportsSubset)) {
 				for (PackageVersion exportVersion : exportsSubset) {
 					requiredArtifacts.add(exportVersion.getArtifact());
 				}
 				break;
 			}
 		}
 		return requiredArtifacts;
 	}

 	private boolean satisfiesImports(Set<PackageVersion> imports, Set<PackageVersion> exports) {
 		for (PackageVersion importVersion : imports) {
 			if (!satisfiesImport(importVersion, exports)) {
 				return false;
 			}
 		}
 		return true;
 	}

 	private boolean satisfiesImport(PackageVersion importVersion, Set<PackageVersion> exports) {
 		for (PackageVersion exportVersion : exports) {
 			if (importVersion.getVersionRange().includes(exportVersion.getVersionRange().getLow())) {
 				return true;
 			}
 		}
 		return false;
 	}

 	public void checkBundleDependencies(List<DependencyNode> nodes) {
 		Map<Artifact, Set<Package>> unresolvedArtifacts = new HashMap<Artifact, Set<Package>>();
 		Set<Artifact> artifacts = getAllArtifacts(nodes);
 		Map<String, Set<PackageVersion>> exports = calculatePackageVersions(artifacts, true, false);
 		for (Artifact artifact : artifacts) {
 			if (isBundle(artifact)) {
 				Parameters imports = getManifestAttributeParameters(artifact,
 						Constants.IMPORT_PACKAGE);
 				if (imports != null) {
 					for (String packageName : imports.keySet()) {
 						boolean exportMissing = true;
 						VersionRange importRange = null;
 						Attrs attrs = imports.get(packageName);
 						if (isOptional(attrs)) {
 							exportMissing = false;
 						} else if (javaPackages.contains(packageName)
 								|| systemPackages.contains(packageName)
 								|| packageName.startsWith("org.osgi.")) {
 							exportMissing = false;
 						} else if (attrs == null || attrs.get(Constants.VERSION_ATTRIBUTE) == null) {
 							if (exports.containsKey(packageName)) {
 								exportMissing = false;
 							}
 						} else {
 							importRange = getVersionRange(attrs);
 							if (exports.containsKey(packageName)) {
 								for (PackageVersion exportVersion : exports.get(packageName)) {
 									if (importRange.includes(exportVersion.getVersionRange()
 											.getLow())) {
 										exportMissing = false;
 										break;
 									}
 								}
 							}
 						}
 						if (exportMissing) {
 							if (!unresolvedArtifacts.containsKey(artifact)) {
 								unresolvedArtifacts.put(artifact, new HashSet<Package>());
 							}
 							unresolvedArtifacts.get(artifact).add(
 									new Package(packageName, importRange));
 						}
 					}
 				}
 			}
 		}
 		for (Entry<Artifact, Set<Package>> unresolvedArtifact : unresolvedArtifacts.entrySet()) {
 			log.warn("Bundle : " + unresolvedArtifact.getKey().getId()
 					+ " has unresolved package dependencies:");
 			for (Package unresolvedPackage : unresolvedArtifact.getValue()) {
 				log.warn("    " + unresolvedPackage);
 			}
 		}
 	}

 	public Map<String, Set<PackageVersion>> calculatePackageVersions(Set<Artifact> artifacts,
 			boolean export, boolean unique) {
 		Map<String, Set<PackageVersion>> packageVersions = new HashMap<String, Set<PackageVersion>>();
 		for (Artifact artifact : artifacts) {
 			if (isBundle(artifact)) {
 				Parameters packages = getManifestAttributeParameters(artifact,
 						export ? Constants.EXPORT_PACKAGE : Constants.IMPORT_PACKAGE);
 				if (packages != null) {
 					for (String packageName : packages.keySet()) {
 						if (!packageVersions.containsKey(packageName)) {
 							packageVersions.put(packageName, new HashSet<PackageVersion>());
 						}
 						Set<PackageVersion> versions = packageVersions.get(packageName);
 						VersionRange versionRange = getVersionRange(packages.get(packageName));
 						boolean optional = isOptional(packages.get(packageName));
 						if (unique) {
 							// check if this version range is unique
 							boolean uniqueVersion = true;
 							for (PackageVersion version : versions) {
 								if (equals(versionRange, version.getVersionRange())) {
 									uniqueVersion = false;
 									break;
 								}
 							}
 							if (uniqueVersion) {
 								versions.add(new PackageVersion(versionRange, artifact, optional));
 							}
 						} else {
 							versions.add(new PackageVersion(versionRange, artifact, optional));
 						}
 					}
 				}
 			}
 		}
 		return packageVersions;
 	}

 	public Version getVersion(Attrs attrs) {
 		if (attrs == null) {
 			return Version.LOWEST;
 		}
 		return Version.parseVersion(attrs.get(Constants.VERSION_ATTRIBUTE));
 	}

 	public VersionRange getVersionRange(Attrs attrs) {
 		if (attrs == null) {
 			return new VersionRange("0");
 		}
 		String version = attrs.get(Constants.VERSION_ATTRIBUTE);
 		if (version == null) {
 			return new VersionRange("0");
 		}
 		return new VersionRange(version);
 	}

 	public boolean isBundle(Artifact artifact) {
 		return getManifestAttribute(artifact, Constants.BUNDLE_SYMBOLICNAME) != null;
 	}

 	public boolean isOptional(Attrs attrs) {
 		return attrs != null && "optional".equals(attrs.get(Constants.RESOLUTION_DIRECTIVE));
 	}

 	public boolean equals(VersionRange v1, VersionRange v2) {
 		return v1 == v2 || v1.toString().equals(v2.toString());
 	}

 	public Parameters getManifestAttributeParameters(Artifact artifact, String attributeName) {
 		String attributeValue = getManifestAttribute(artifact, attributeName);
 		if (attributeValue != null) {
 			return OSGiHeader.parseHeader(attributeValue);
 		}
 		return null;
 	}

 	public String getManifestAttribute(Artifact artifact, String attributeName) {
 		Manifest manifest = getManifest(artifact);
 		if (manifest != null) {
 			Attributes mainAttributes = manifest.getMainAttributes();
 			return mainAttributes.getValue(attributeName);
 		}
 		return null;
 	}

 	public Manifest getManifest(Artifact artifact) {
 		if (artifact != null) {
 			File file = artifact.getFile();
 			if (file != null) {
 				try {
 					JarFile jarFile = new JarFile(artifact.getFile());
 					return jarFile.getManifest();
 				} catch (IOException e) {
 					return null;
 				}
 			}
 		}
 		return null;
 	}

 	private final class BundleComparator implements Comparator<BundleInfo> {

 		@Override
 		public int compare(BundleInfo bundle1, BundleInfo bundle2) {
 			return bundle1.getSymbolicName().compareTo(bundle2.getSymbolicName());
 		}

 	}

 	// public static void main(String[] args) throws Exception {
 	// MavenOsgiUtils mavenOsgiUtils = new MavenOsgiUtils();
 	// Parameters exports = mavenOsgiUtils.getImports(new
 	// File("/Users/david/Documents/workspace-trunk/taverna-plugin-impl/target/taverna-plugin-impl-0.1.0-SNAPSHOT.jar"));
 	// for (String key : exports.keySet()) {
 	// System.out.println(key + " " + mavenOsgiUtils.getVersionRange(exports.get(key)));
 	// }
 	// }
 }
	/*******************************************************************************
	* Copyright (C) 2013 The University of Manchester
	*
	* Modifications to the initial code base are copyright of their
	* respective authors, or their employers as appropriate.
	*
	* This program is free software; you can redistribute it and/or
	* modify it under the terms of the GNU Lesser General Public License
	* as published by the Free Software Foundation; either version 2.1 of
	* the License, or (at your option) any later version.
	*
	* This program is distributed in the hope that it will be useful, but
	* WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	* Lesser General Public License for more details.
	*
	* You should have received a copy of the GNU Lesser General Public
	* License along with this program; if not, write to the Free Software
	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
	******************************************************************************/
	package net.sf.taverna.t2.maven.plugins;

	import java.io.File;
	import java.io.IOException;
	import java.util.ArrayList;
	import java.util.Arrays;
	import java.util.Collections;
	import java.util.Comparator;
	import java.util.HashMap;
	import java.util.HashSet;
	import java.util.List;
	import java.util.Map;
	import java.util.Map.Entry;
	import java.util.Set;
	import java.util.jar.Attributes;
	import java.util.jar.JarFile;
	import java.util.jar.Manifest;

	import org.apache.maven.RepositoryUtils;
	import org.apache.maven.artifact.Artifact;
	import org.apache.maven.plugin.MojoExecutionException;
	import org.apache.maven.plugin.logging.Log;
	import org.apache.maven.project.DefaultDependencyResolutionRequest;
	import org.apache.maven.project.DependencyResolutionException;
	import org.apache.maven.project.DependencyResolutionResult;
	import org.apache.maven.project.MavenProject;
	import org.apache.maven.project.ProjectDependenciesResolver;
	import org.eclipse.aether.RepositorySystemSession;
	import org.eclipse.aether.graph.DependencyNode;
	import org.eclipse.aether.util.filter.ScopeDependencyFilter;

	import uk.org.taverna.commons.profile.xml.jaxb.BundleInfo;
	import aQute.bnd.header.Attrs;
	import aQute.bnd.header.OSGiHeader;
	import aQute.bnd.header.Parameters;
	import aQute.bnd.osgi.Constants;
	import aQute.bnd.version.Version;
	import aQute.bnd.version.VersionRange;

	/**
	* @author David Withers
	*/
	public class MavenOsgiUtils {

	private final MavenProject project;
	private final RepositorySystemSession repositorySystemSession;
	private final ProjectDependenciesResolver projectDependenciesResolver;
	private final Log log;

	private Set<String> javaPackages;
	private Set<String> systemPackages;

	public MavenOsgiUtils(MavenProject project, RepositorySystemSession repositorySystemSession,
	ProjectDependenciesResolver projectDependenciesResolver, Log log) {
	this(project, repositorySystemSession, projectDependenciesResolver, new HashSet<String>(),
	log);
	}

	public MavenOsgiUtils(MavenProject project, RepositorySystemSession repositorySystemSession,
	ProjectDependenciesResolver projectDependenciesResolver, Set<String> systemPackages,
	Log log) {
	this.project = project;
	this.repositorySystemSession = repositorySystemSession;
	this.projectDependenciesResolver = projectDependenciesResolver;
	this.systemPackages = systemPackages;
	this.log = log;
	javaPackages = Utils.getJavaPackages(log);
	}

	public Set<BundleArtifact> getBundleDependencies(String... scopes)
	throws MojoExecutionException {
	ScopeDependencyFilter scopeFilter = new ScopeDependencyFilter(Arrays.asList(scopes), null);

	DefaultDependencyResolutionRequest dependencyResolutionRequest = new DefaultDependencyResolutionRequest(
	project, repositorySystemSession);
	dependencyResolutionRequest.setResolutionFilter(scopeFilter);

	DependencyResolutionResult dependencyResolutionResult;
	try {
	dependencyResolutionResult = projectDependenciesResolver
	.resolve(dependencyResolutionRequest);
	} catch (DependencyResolutionException ex) {
	throw new MojoExecutionException(ex.getMessage(), ex);
	}

	DependencyNode dependencyGraph = dependencyResolutionResult.getDependencyGraph();
	if (dependencyGraph != null) {
	checkBundleDependencies(dependencyGraph.getChildren());
	return getBundleArtifacts(dependencyGraph.getChildren());
	} else {
	return new HashSet<BundleArtifact>();
	}
	}

	public Set<BundleArtifact> getBundleArtifacts(List<DependencyNode> nodes) {
	Set<BundleArtifact> bundleArtifacts = new HashSet<BundleArtifact>();
	for (DependencyNode node : nodes) {
	Artifact artifact = RepositoryUtils.toArtifact(node.getDependency().getArtifact());
	String symbolicName = getManifestAttribute(artifact, Constants.BUNDLE_SYMBOLICNAME);
	if (symbolicName != null) {
	String version = getManifestAttribute(artifact, Constants.BUNDLE_VERSION);
	bundleArtifacts.add(new BundleArtifact(artifact, symbolicName, version));
	bundleArtifacts.addAll(getBundleArtifacts(node.getChildren()));
	} else {
	log.warn("Not an OSGi bundle : " + artifact.getId());
	}
	}
	return bundleArtifacts;
	}

	public Set<Artifact> getAllArtifacts(List<DependencyNode> nodes) {
	Set<Artifact> artifacts = new HashSet<Artifact>();
	for (DependencyNode node : nodes) {
	Artifact artifact = RepositoryUtils.toArtifact(node.getDependency().getArtifact());
	if (isBundle(artifact)) {
	artifacts.add(artifact);
	artifacts.addAll(getAllArtifacts(node.getChildren()));
	}
	}
	return artifacts;
	}

	public Set<Artifact> getArtifacts(List<DependencyNode> nodes) {
	Set<Artifact> artifacts = new HashSet<Artifact>();
	for (DependencyNode node : nodes) {
	Artifact artifact = RepositoryUtils.toArtifact(node.getDependency().getArtifact());
	if (isBundle(artifact)) {
	artifacts.add(artifact);
	}
	}
	return artifacts;
	}

	public List<BundleInfo> getBundles(Set<BundleArtifact> bundleDependencies)
	throws MojoExecutionException {
	List<BundleInfo> bundles = new ArrayList<BundleInfo>();
	for (BundleArtifact bundleArtifact : bundleDependencies) {
	Artifact artifact = bundleArtifact.getArtifact();
	BundleInfo bundle = new BundleInfo();
	bundle.setSymbolicName(bundleArtifact.getSymbolicName());
	bundle.setVersion(bundleArtifact.getVersion());
	bundle.setFileName(new File(artifact.getGroupId(), artifact.getFile().getName())
	.getPath());
	bundles.add(bundle);
	}
	Collections.sort(bundles, new BundleComparator());
	return bundles;
	}

	public Map<String, Set<PackageVersion>> getPackageDependencies(List<DependencyNode> nodes) {
	Map<String, Set<PackageVersion>> exportVersions = calculatePackageVersions(
	getAllArtifacts(nodes), true, false);
	return getPackageDependencies(getArtifacts(nodes), exportVersions);
	}

	public Map<String, Set<PackageVersion>> getPackageDependencies(Set<Artifact> requiredArtifacts,
	Map<String, Set<PackageVersion>> exportVersions) {
	Map<String, Set<PackageVersion>> importVersions = calculatePackageVersions(
	requiredArtifacts, false, true);
	Set<Artifact> newRequiredArtifacts = new HashSet<Artifact>();
	for (Entry<String, Set<PackageVersion>> entry : importVersions.entrySet()) {
	if (!javaPackages.contains(entry.getKey())) {
	String packageName = entry.getKey();
	Set<PackageVersion> importsVersions = entry.getValue();
	Set<PackageVersion> exportsVersions = exportVersions.get(packageName);
	if (exportVersions.containsKey(entry.getKey())) {
	for (Artifact artifact : getRequiredArtifacts(importsVersions, exportsVersions)) {
	if (!requiredArtifacts.contains(artifact)) {
	newRequiredArtifacts.add(artifact);
	}
	}
	}
	}
	}
	if (!newRequiredArtifacts.isEmpty()) {
	newRequiredArtifacts.addAll(requiredArtifacts);
	return getPackageDependencies(newRequiredArtifacts, exportVersions);
	}
	return importVersions;
	}

	/**
	* Returns the minimum set of artifacts required to satisfy the range of importVersions.
	*
	* @param importsVersions
	* the version ranges required for the package
	* @param exportVersions
	* the available versions for the package
	* @return the minimum set of artifacts required to satisfy the range of importVersions
	*/
	private Set<Artifact> getRequiredArtifacts(Set<PackageVersion> importsVersions,
	Set<PackageVersion> exportVersions) {
	Set<Artifact> requiredArtifacts = new HashSet<Artifact>();
	List<Set<PackageVersion>> exportsSubsets = Utils.getSubsets(exportVersions);
	for (Set<PackageVersion> exportsSubset : exportsSubsets) {
	if (satisfiesImports(importsVersions, exportsSubset)) {
	for (PackageVersion exportVersion : exportsSubset) {
	requiredArtifacts.add(exportVersion.getArtifact());
	}
	break;
	}
	}
	return requiredArtifacts;
	}

	private boolean satisfiesImports(Set<PackageVersion> imports, Set<PackageVersion> exports) {
	for (PackageVersion importVersion : imports) {
	if (!satisfiesImport(importVersion, exports)) {
	return false;
	}
	}
	return true;
	}

	private boolean satisfiesImport(PackageVersion importVersion, Set<PackageVersion> exports) {
	for (PackageVersion exportVersion : exports) {
	if (importVersion.getVersionRange().includes(exportVersion.getVersionRange().getLow())) {
	return true;
	}
	}
	return false;
	}

	public void checkBundleDependencies(List<DependencyNode> nodes) {
	Map<Artifact, Set<Package>> unresolvedArtifacts = new HashMap<Artifact, Set<Package>>();
	Set<Artifact> artifacts = getAllArtifacts(nodes);
	Map<String, Set<PackageVersion>> exports = calculatePackageVersions(artifacts, true, false);
	for (Artifact artifact : artifacts) {
	if (isBundle(artifact)) {
	Parameters imports = getManifestAttributeParameters(artifact,
	Constants.IMPORT_PACKAGE);
	if (imports != null) {
	for (String packageName : imports.keySet()) {
	boolean exportMissing = true;
	VersionRange importRange = null;
	Attrs attrs = imports.get(packageName);
	if (isOptional(attrs)) {
	exportMissing = false;
	} else if (javaPackages.contains(packageName)
	\|\| systemPackages.contains(packageName)
	\|\| packageName.startsWith("org.osgi.")) {
	exportMissing = false;
	} else if (attrs == null \|\| attrs.get(Constants.VERSION_ATTRIBUTE) == null) {
	if (exports.containsKey(packageName)) {
	exportMissing = false;
	}
	} else {
	importRange = getVersionRange(attrs);
	if (exports.containsKey(packageName)) {
	for (PackageVersion exportVersion : exports.get(packageName)) {
	if (importRange.includes(exportVersion.getVersionRange()
	.getLow())) {
	exportMissing = false;
	break;
	}
	}
	}
	}
	if (exportMissing) {
	if (!unresolvedArtifacts.containsKey(artifact)) {
	unresolvedArtifacts.put(artifact, new HashSet<Package>());
	}
	unresolvedArtifacts.get(artifact).add(
	new Package(packageName, importRange));
	}
	}
	}
	}
	}
	for (Entry<Artifact, Set<Package>> unresolvedArtifact : unresolvedArtifacts.entrySet()) {
	log.warn("Bundle : " + unresolvedArtifact.getKey().getId()
	+ " has unresolved package dependencies:");
	for (Package unresolvedPackage : unresolvedArtifact.getValue()) {
	log.warn(" " + unresolvedPackage);
	}
	}
	}

	public Map<String, Set<PackageVersion>> calculatePackageVersions(Set<Artifact> artifacts,
	boolean export, boolean unique) {
	Map<String, Set<PackageVersion>> packageVersions = new HashMap<String, Set<PackageVersion>>();
	for (Artifact artifact : artifacts) {
	if (isBundle(artifact)) {
	Parameters packages = getManifestAttributeParameters(artifact,
	export ? Constants.EXPORT_PACKAGE : Constants.IMPORT_PACKAGE);
	if (packages != null) {
	for (String packageName : packages.keySet()) {
	if (!packageVersions.containsKey(packageName)) {
	packageVersions.put(packageName, new HashSet<PackageVersion>());
	}
	Set<PackageVersion> versions = packageVersions.get(packageName);
	VersionRange versionRange = getVersionRange(packages.get(packageName));
	boolean optional = isOptional(packages.get(packageName));
	if (unique) {
	// check if this version range is unique
	boolean uniqueVersion = true;
	for (PackageVersion version : versions) {
	if (equals(versionRange, version.getVersionRange())) {
	uniqueVersion = false;
	break;
	}
	}
	if (uniqueVersion) {
	versions.add(new PackageVersion(versionRange, artifact, optional));
	}
	} else {
	versions.add(new PackageVersion(versionRange, artifact, optional));
	}
	}
	}
	}
	}
	return packageVersions;
	}

	public Version getVersion(Attrs attrs) {
	if (attrs == null) {
	return Version.LOWEST;
	}
	return Version.parseVersion(attrs.get(Constants.VERSION_ATTRIBUTE));
	}

	public VersionRange getVersionRange(Attrs attrs) {
	if (attrs == null) {
	return new VersionRange("0");
	}
	String version = attrs.get(Constants.VERSION_ATTRIBUTE);
	if (version == null) {
	return new VersionRange("0");
	}
	return new VersionRange(version);
	}

	public boolean isBundle(Artifact artifact) {
	return getManifestAttribute(artifact, Constants.BUNDLE_SYMBOLICNAME) != null;
	}

	public boolean isOptional(Attrs attrs) {
	return attrs != null && "optional".equals(attrs.get(Constants.RESOLUTION_DIRECTIVE));
	}

	public boolean equals(VersionRange v1, VersionRange v2) {
	return v1 == v2 \|\| v1.toString().equals(v2.toString());
	}

	public Parameters getManifestAttributeParameters(Artifact artifact, String attributeName) {
	String attributeValue = getManifestAttribute(artifact, attributeName);
	if (attributeValue != null) {
	return OSGiHeader.parseHeader(attributeValue);
	}
	return null;
	}

	public String getManifestAttribute(Artifact artifact, String attributeName) {
	Manifest manifest = getManifest(artifact);
	if (manifest != null) {
	Attributes mainAttributes = manifest.getMainAttributes();
	return mainAttributes.getValue(attributeName);
	}
	return null;
	}

	public Manifest getManifest(Artifact artifact) {
	if (artifact != null) {
	File file = artifact.getFile();
	if (file != null) {
	try {
	JarFile jarFile = new JarFile(artifact.getFile());
	return jarFile.getManifest();
	} catch (IOException e) {
	return null;
	}
	}
	}
	return null;
	}

	private final class BundleComparator implements Comparator<BundleInfo> {

	@Override
	public int compare(BundleInfo bundle1, BundleInfo bundle2) {
	return bundle1.getSymbolicName().compareTo(bundle2.getSymbolicName());
	}

	}

	// public static void main(String[] args) throws Exception {
	// MavenOsgiUtils mavenOsgiUtils = new MavenOsgiUtils();
	// Parameters exports = mavenOsgiUtils.getImports(new
	// File("/Users/david/Documents/workspace-trunk/taverna-plugin-impl/target/taverna-plugin-impl-0.1.0-SNAPSHOT.jar"));
	// for (String key : exports.keySet()) {
	// System.out.println(key + " " + mavenOsgiUtils.getVersionRange(exports.get(key)));
	// }
	// }
	}