| /******************************************************************************* |
| * Copyright (c) 2000, 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 |
| * Sonatype Inc. - adopted to work outside of eclipse workspace |
| *******************************************************************************/ |
| package org.eclipse.tycho.core.osgitools; |
| |
| import java.io.File; |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.TreeMap; |
| |
| import org.codehaus.plexus.component.annotations.Component; |
| import org.codehaus.plexus.component.annotations.Requirement; |
| import org.eclipse.osgi.internal.resolver.ExportPackageDescriptionImpl; |
| import org.eclipse.osgi.service.resolver.BaseDescription; |
| import org.eclipse.osgi.service.resolver.BundleDescription; |
| import org.eclipse.osgi.service.resolver.BundleSpecification; |
| import org.eclipse.osgi.service.resolver.ExportPackageDescription; |
| import org.eclipse.osgi.service.resolver.HostSpecification; |
| import org.eclipse.osgi.service.resolver.ImportPackageSpecification; |
| import org.eclipse.osgi.service.resolver.StateHelper; |
| import org.eclipse.osgi.util.ManifestElement; |
| import org.eclipse.tycho.classpath.ClasspathEntry.AccessRule; |
| import org.eclipse.tycho.core.osgitools.DefaultClasspathEntry.DefaultAccessRule; |
| import org.osgi.framework.Constants; |
| |
| /** |
| * Helper class that computes compile dependencies of a bundle project. |
| * |
| * Code below is copy&paste of org.eclipse.pde.internal.core.RequiredPluginsClasspathContainer |
| * adopted to work outside of Eclipse runtime. |
| * |
| * Note that some functionality, namely SecondaryDependencies, ExtraClasspathEntries and |
| * isPatchFragment, has been removed due to time constraints. |
| */ |
| @Component(role = DependencyComputer.class) |
| public class DependencyComputer { |
| |
| @Requirement |
| private BundleReader manifestReader; |
| |
| public static class DependencyEntry { |
| public final BundleDescription desc; |
| public final List<AccessRule> rules; |
| |
| public DependencyEntry(BundleDescription desc, List<AccessRule> rules) { |
| this.desc = desc; |
| this.rules = rules; |
| } |
| |
| @Override |
| public int hashCode() { |
| final int prime = 31; |
| int result = 1; |
| result = prime * result + ((desc == null) ? 0 : desc.hashCode()); |
| result = prime * result + ((rules == null) ? 0 : rules.hashCode()); |
| return result; |
| } |
| |
| @Override |
| public boolean equals(Object obj) { |
| if (this == obj) |
| return true; |
| if (obj == null) |
| return false; |
| if (getClass() != obj.getClass()) |
| return false; |
| DependencyEntry other = (DependencyEntry) obj; |
| if (desc == null) { |
| if (other.desc != null) |
| return false; |
| } else if (!desc.equals(other.desc)) |
| return false; |
| if (rules == null) { |
| if (other.rules != null) |
| return false; |
| } else if (!rules.equals(other.rules)) |
| return false; |
| return true; |
| } |
| |
| } |
| |
| public List<DependencyEntry> computeDependencies(StateHelper helper, BundleDescription desc) { |
| ArrayList<DependencyEntry> entries = new ArrayList<>(); |
| |
| if (desc == null) |
| return entries; |
| |
| Map<BundleDescription, ArrayList<AccessRule>> map = retrieveVisiblePackagesFromState(helper, desc); |
| |
| HashSet<BundleDescription> added = new HashSet<>(); |
| |
| // to avoid cycles, e.g. when a bundle imports a package it exports |
| added.add(desc); |
| |
| HostSpecification host = desc.getHost(); |
| if (host != null) { |
| addHostPlugin(host, added, map, entries); |
| } |
| |
| // add dependencies |
| BundleSpecification[] required = desc.getRequiredBundles(); |
| for (BundleSpecification required1 : required) { |
| addDependency((BundleDescription) required1.getSupplier(), added, map, entries); |
| } |
| |
| // addSecondaryDependencies(desc, added, entries); |
| |
| // add Import-Package |
| // sort by symbolicName_version to get a consistent order |
| Map<String, BundleDescription> sortedMap = new TreeMap<>(); |
| for (BundleDescription bundle : map.keySet()) { |
| sortedMap.put(bundle.toString(), bundle); |
| } |
| for (BundleDescription bundle : sortedMap.values()) { |
| addDependencyViaImportPackage(bundle, added, map, entries); |
| } |
| |
| // addExtraClasspathEntries(added, entries); |
| |
| // for (int i = 0; i < entries.size(); i++) { |
| // System.err.println(i + "\t" + entries.get(i).desc); |
| // } |
| |
| return entries; |
| } |
| |
| private Map<BundleDescription, ArrayList<AccessRule>> retrieveVisiblePackagesFromState(StateHelper helper, |
| BundleDescription desc) { |
| Map<BundleDescription, ArrayList<AccessRule>> visiblePackages = new HashMap<>(); |
| addVisiblePackagesFromState(helper, desc, visiblePackages); |
| if (desc.getHost() != null) |
| addVisiblePackagesFromState(helper, (BundleDescription) desc.getHost().getSupplier(), visiblePackages); |
| return visiblePackages; |
| } |
| |
| private void addVisiblePackagesFromState(StateHelper helper, BundleDescription desc, |
| Map<BundleDescription, ArrayList<AccessRule>> visiblePackages) { |
| if (desc == null) |
| return; |
| ExportPackageDescription[] exports = helper.getVisiblePackages(desc, StateHelper.VISIBLE_INCLUDE_EE_PACKAGES); |
| for (ExportPackageDescription export : exports) { |
| BundleDescription exporter = export.getExporter(); |
| if (exporter == null) |
| continue; |
| ArrayList<AccessRule> list = visiblePackages.get(exporter); |
| if (list == null) |
| list = new ArrayList<>(); |
| AccessRule rule = getRule(helper, desc, export); |
| if (!list.contains(rule)) |
| list.add(rule); |
| visiblePackages.put(exporter, list); |
| } |
| } |
| |
| private AccessRule getRule(StateHelper helper, BundleDescription desc, ExportPackageDescription export) { |
| boolean discouraged = helper.getAccessCode(desc, export) == StateHelper.ACCESS_DISCOURAGED; |
| String name = export.getName(); |
| String path = (name.equals(".")) ? "*" : name.replaceAll("\\.", "/") + "/*"; |
| return new DefaultAccessRule(path, discouraged); |
| } |
| |
| protected void addDependencyViaImportPackage(BundleDescription desc, HashSet<BundleDescription> added, |
| Map<BundleDescription, ArrayList<AccessRule>> map, ArrayList<DependencyEntry> entries) { |
| if (desc == null || !added.add(desc)) |
| return; |
| |
| addPlugin(desc, true, map, entries); |
| |
| if (hasExtensibleAPI(desc) && desc.getContainingState() != null) { |
| BundleDescription[] fragments = desc.getFragments(); |
| for (BundleDescription fragment : fragments) { |
| if (fragment.isResolved()) { |
| addDependencyViaImportPackage(fragment, added, map, entries); |
| } |
| } |
| } |
| } |
| |
| private void addDependency(BundleDescription desc, HashSet<BundleDescription> added, |
| Map<BundleDescription, ArrayList<AccessRule>> map, ArrayList<DependencyEntry> entries) { |
| addDependency(desc, added, map, entries, true); |
| } |
| |
| private void addDependency(BundleDescription desc, HashSet<BundleDescription> added, |
| Map<BundleDescription, ArrayList<AccessRule>> map, ArrayList<DependencyEntry> entries, boolean useInclusion) { |
| if (desc == null || !added.add(desc)) |
| return; |
| |
| BundleDescription[] fragments = hasExtensibleAPI(desc) ? desc.getFragments() : new BundleDescription[0]; |
| |
| // add fragment patches before host |
| for (BundleDescription fragment : fragments) { |
| if (fragment.isResolved() && isPatchFragment(fragment)) { |
| addDependency(fragment, added, map, entries, useInclusion); |
| } |
| } |
| |
| addPlugin(desc, useInclusion, map, entries); |
| |
| // add fragments that are not patches after the host |
| for (BundleDescription fragment : fragments) { |
| if (fragment.isResolved() && !isPatchFragment(fragment)) { |
| addDependency(fragment, added, map, entries, useInclusion); |
| } |
| } |
| |
| BundleSpecification[] required = desc.getRequiredBundles(); |
| for (BundleSpecification required1 : required) { |
| addDependency((BundleDescription) required1.getSupplier(), added, map, entries, useInclusion); |
| } |
| } |
| |
| private boolean isPatchFragment(BundleDescription bundleDescription) { |
| return false; // TODO |
| } |
| |
| private boolean addPlugin(BundleDescription desc, boolean useInclusions, |
| Map<BundleDescription, ArrayList<AccessRule>> map, ArrayList<DependencyEntry> entries) { |
| List<AccessRule> rules = useInclusions ? getInclusions(map, desc) : null; |
| DependencyEntry entry = new DependencyEntry(desc, rules); |
| if (!entries.contains(entry)) |
| entries.add(entry); |
| return true; |
| } |
| |
| private List<AccessRule> getInclusions(Map<BundleDescription, ArrayList<AccessRule>> map, BundleDescription desc) { |
| ArrayList<AccessRule> rules; |
| |
| if (desc.getHost() != null) |
| rules = map.get((BundleDescription) desc.getHost().getSupplier()); |
| else |
| rules = map.get(desc); |
| |
| return rules != null ? rules : new ArrayList<AccessRule>(); |
| } |
| |
| private void addHostPlugin(HostSpecification hostSpec, HashSet<BundleDescription> added, |
| Map<BundleDescription, ArrayList<AccessRule>> map, ArrayList<DependencyEntry> entries) { |
| BaseDescription desc = hostSpec.getSupplier(); |
| |
| if (desc instanceof BundleDescription) { |
| BundleDescription host = (BundleDescription) desc; |
| |
| // add host plug-in |
| if (added.add(host) && addPlugin(host, false, map, entries)) { |
| BundleSpecification[] required = host.getRequiredBundles(); |
| for (BundleSpecification required1 : required) { |
| addDependency((BundleDescription) required1.getSupplier(), added, map, entries); |
| } |
| |
| // add Import-Package |
| ImportPackageSpecification[] imports = host.getImportPackages(); |
| for (ImportPackageSpecification import1 : imports) { |
| BaseDescription supplier = import1.getSupplier(); |
| if (supplier instanceof ExportPackageDescription) { |
| addDependencyViaImportPackage(((ExportPackageDescription) supplier).getExporter(), added, map, |
| entries); |
| } |
| } |
| } |
| } |
| } |
| |
| private boolean hasExtensibleAPI(BundleDescription desc) { |
| // TODO re-enable Eclipse-ExtensibleAPI |
| return true; //"true".equals(state.getManifestAttribute(desc, "Eclipse-ExtensibleAPI")); |
| } |
| |
| /** |
| * Although totally not obvious from the specification text, section 3.15 "Extension Bundles" of |
| * OSGi Core Spec apparently says that framework extension bundles can export additional |
| * packaged of the underlying JRE. More specific explanation is provided in [1] and I verified |
| * that at least Equinox 3.7.1 does indeed behave like described. |
| * <p/> |
| * There does not seem to be a way to tell which packages exported by a framework extension |
| * bundle are supposed to come from JRE and which from the bundle itself, so returned classpath |
| * access rules include all packages exported by the framework extension bundles. |
| * |
| * [1] http://blog.meschberger.ch/2008/10/osgi-bundles-require-classes-from.html |
| */ |
| public List<AccessRule> computeBootClasspathExtraAccessRules(StateHelper helper, BundleDescription desc) { |
| List<AccessRule> result = new ArrayList<>(); |
| ExportPackageDescription[] exports = helper.getVisiblePackages(desc); |
| for (ExportPackageDescription export : exports) { |
| BundleDescription host = export.getExporter(); |
| BaseDescription fragment = ((ExportPackageDescriptionImpl) export).getFragmentDeclaration(); |
| if (host.getBundleId() == 0 && fragment != null && isFrameworkExtension(fragment.getSupplier())) { |
| result.add(getRule(helper, host, export)); |
| } |
| } |
| return result; |
| } |
| |
| private boolean isFrameworkExtension(BundleDescription bundle) { |
| OsgiManifest mf = manifestReader.loadManifest(new File(bundle.getLocation())); |
| ManifestElement[] elements = mf.getManifestElements(Constants.FRAGMENT_HOST); |
| if (elements.length == 1) { |
| if (Constants.EXTENSION_FRAMEWORK.equals(elements[0].getDirective(Constants.EXTENSION_DIRECTIVE))) { |
| return true; |
| } |
| } |
| return false; |
| } |
| } |
