| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| */ |
| package org.apache.ivyde.internal.eclipse.cpcontainer; |
| |
| import java.io.File; |
| import java.io.IOException; |
| import java.net.MalformedURLException; |
| import java.net.URL; |
| import java.text.ParseException; |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.LinkedHashSet; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| |
| import org.apache.ivy.Ivy; |
| import org.apache.ivy.core.module.descriptor.Artifact; |
| import org.apache.ivy.core.module.id.ModuleRevisionId; |
| import org.apache.ivy.core.report.ArtifactDownloadReport; |
| import org.apache.ivy.core.resolve.DownloadOptions; |
| import org.apache.ivy.osgi.core.BundleInfo; |
| import org.apache.ivy.osgi.core.ExportPackage; |
| import org.apache.ivy.osgi.core.ManifestParser; |
| import org.apache.ivyde.eclipse.cp.ClasspathSetup; |
| import org.apache.ivyde.eclipse.cp.IvyClasspathContainerConfiguration; |
| import org.apache.ivyde.eclipse.cp.MappingSetup; |
| import org.apache.ivyde.internal.eclipse.IvyDEMessage; |
| import org.apache.ivyde.internal.eclipse.IvyPlugin; |
| import org.apache.ivyde.internal.eclipse.resolve.ResolveResult; |
| import org.apache.ivyde.internal.eclipse.workspaceresolver.WorkspaceResolver; |
| import org.eclipse.core.runtime.IPath; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.core.runtime.Path; |
| import org.eclipse.jdt.core.IAccessRule; |
| import org.eclipse.jdt.core.IClasspathAttribute; |
| import org.eclipse.jdt.core.IClasspathEntry; |
| import org.eclipse.jdt.core.IJavaProject; |
| import org.eclipse.jdt.core.JavaCore; |
| |
| /** |
| * This class is mapping the resolved artifacts between them. After a resolve process, this class |
| * will build the classpath based on the retrieved artifacts and will search for sources and |
| * javadocs and make them attached. |
| */ |
| public class IvyClasspathContainerMapper { |
| |
| private static final String IVYDE_NS = "http://ant.apache.org/ivy/ivyde/ns/"; |
| |
| private static final String IVYDE_NS_PREFIX = "ivyde:"; |
| |
| private final IProgressMonitor monitor; |
| |
| private final Ivy ivy; |
| |
| private final IJavaProject javaProject; |
| |
| private final Collection<ArtifactDownloadReport> all; |
| |
| private final Map<ModuleRevisionId, Artifact[]> artifactsByDependency; |
| |
| private final Map<ArtifactDownloadReport, Set<String>> retrievedArtifacts; |
| |
| private ClasspathSetup classpathSetup; |
| |
| private MappingSetup mapping; |
| |
| private boolean osgiAvailable; |
| |
| private boolean osgiClasspathAvailable; |
| |
| private IvyAttachementManager attachementManager = IvyPlugin.getDefault() |
| .getIvyAttachementManager(); |
| |
| public IvyClasspathContainerMapper(IProgressMonitor monitor, Ivy ivy, |
| IvyClasspathContainerConfiguration conf, ResolveResult resolveResult) { |
| this.monitor = monitor; |
| this.ivy = ivy; |
| this.javaProject = conf.getJavaProject(); |
| this.classpathSetup = conf.getInheritedClasspathSetup(); |
| this.mapping = conf.getInheritedMappingSetup(); |
| this.all = resolveResult.getArtifactReports(); |
| this.artifactsByDependency = resolveResult.getArtifactsByDependency(); |
| this.retrievedArtifacts = resolveResult.getRetrievedArtifacts(); |
| this.osgiAvailable = IvyPlugin.getDefault().isOsgiAvailable(); |
| this.osgiClasspathAvailable = IvyPlugin.getDefault().isOsgiClasspathAvailable(); |
| } |
| |
| public IClasspathEntry[] map() { |
| IClasspathEntry[] classpathEntries; |
| Collection<IClasspathEntry> paths = new LinkedHashSet<IClasspathEntry>(); |
| |
| IvyDEMessage.verbose("Building classpath from " + all.size() + " resolved artifact(s)"); |
| |
| for (ArtifactDownloadReport artifact : all) { |
| if (artifact.getType().equals(WorkspaceResolver.ECLIPSE_PROJECT_TYPE)) { |
| IvyDEMessage.verbose("Found an workspace dependency on project " |
| + artifact.getName()); |
| // This is a java project in the workspace, add project path |
| // but only add it if it is not a self dependency |
| if (javaProject == null |
| || !artifact.getName().equals(javaProject.getPath().toString())) { |
| IAccessRule[] rules = getAccessRules(javaProject); |
| paths.add(JavaCore.newProjectEntry(new Path(artifact.getName()), rules, true, |
| null, true)); |
| } else { |
| IvyDEMessage.verbose("Skipping self dependency on project " |
| + artifact.getName()); |
| } |
| } else if (artifact.getLocalFile() != null && accept(artifact.getArtifact())) { |
| IvyDEMessage.verbose("Adding " + artifact.getName() + " to the classpath"); |
| |
| // handle unzipped jar with 'Bundle-Classpath' |
| if (osgiClasspathAvailable && artifact.getLocalFile().isDirectory() |
| && classpathSetup.isReadOSGiMetadata()) { |
| File manifestFile = new File(artifact.getLocalFile(), "META-INF/MANIFEST.MF"); |
| if (!manifestFile.exists()) { |
| // no manifest : back to simple classpath |
| paths.add(buildEntry(artifact)); |
| } else { |
| try { |
| BundleInfo bundleInfo = ManifestParser.parseManifest(manifestFile); |
| if (bundleInfo.getClasspath() == null) { |
| // no inner classpath : a simple entry |
| paths.add(buildEntry(artifact)); |
| } else { |
| IAccessRule[] rules = getAccessRules(bundleInfo); |
| for (String innerPath : bundleInfo.getClasspath()) { |
| IClasspathEntry buildEntry = buildEntry(artifact, rules, |
| manifestFile, innerPath); |
| if (buildEntry != null) { |
| paths.add(buildEntry); |
| } |
| } |
| } |
| } catch (IOException e) { |
| IvyDEMessage.error( |
| "Unreadable MANIFEST.MF for artifact " + artifact.getName() + ": " |
| + manifestFile.getAbsolutePath() + " (" + e.getMessage() |
| + ")", e); |
| } catch (ParseException e) { |
| IvyDEMessage.error( |
| "Malformed MANIFEST.MF for artifact " + artifact.getName() + ": " |
| + manifestFile.getAbsolutePath() + " (" + e.getMessage() |
| + ")", e); |
| } |
| } |
| } else { |
| // simple entry |
| paths.add(buildEntry(artifact)); |
| } |
| } |
| |
| } |
| classpathEntries = (IClasspathEntry[]) paths.toArray(new IClasspathEntry[paths.size()]); |
| |
| return classpathEntries; |
| } |
| |
| private IClasspathEntry buildEntry(ArtifactDownloadReport artifact, IAccessRule[] rules, |
| File manifestFile, String innerPath) { |
| IPath classpathArtifact = getArtifactPath(artifact, "/" + innerPath); |
| if (!classpathArtifact.toFile().exists()) { |
| // an non existing inner jar is 'just' a broken MANIFEST.MF, which happens sometimes |
| // with Eclipse bundles |
| IvyDEMessage.warn("The MANIFEST of " + artifact + " (" + manifestFile |
| + ") is referencing a non exitant jar " + classpathArtifact + ". Ignoring it"); |
| return null; |
| } |
| return doBuildEntry(artifact, classpathArtifact, rules); |
| } |
| |
| private IClasspathEntry buildEntry(ArtifactDownloadReport artifact) { |
| IPath classpathArtifact = getArtifactPath(artifact, ""); |
| return doBuildEntry(artifact, classpathArtifact, null); |
| } |
| |
| private IClasspathEntry doBuildEntry(ArtifactDownloadReport artifact, IPath classpathArtifact, |
| IAccessRule[] rules) { |
| IPath sourcesArtifact = getArtifactPath(artifact, sourceArtifactMatcher, |
| mapping.isMapIfOnlyOneSource(), ""); |
| IPath javadocArtifact = getArtifactPath(artifact, javadocArtifactMatcher, |
| mapping.isMapIfOnlyOneJavadoc(), ""); |
| IPath sources = attachementManager.getSourceAttachment(classpathArtifact, sourcesArtifact); |
| IPath sourcesRoot = attachementManager.getSourceAttachmentRoot(classpathArtifact, |
| sourcesArtifact); |
| IClasspathAttribute[] att = getExtraAttribute(classpathArtifact, javadocArtifact); |
| |
| if (sources != null) { |
| IvyDEMessage.debug("Attaching sources " + sources + " to " + classpathArtifact); |
| } |
| if (javadocArtifact != null) { |
| IvyDEMessage.debug("Attaching javadoc " + javadocArtifact + " to " + classpathArtifact); |
| } |
| if (rules != null) { |
| IvyDEMessage.debug("Setting OSGi access rules on " + classpathArtifact); |
| } |
| return JavaCore.newLibraryEntry(classpathArtifact, sources, sourcesRoot, rules, att, false); |
| } |
| |
| private IAccessRule[] getAccessRules(IJavaProject javaProject) { |
| if (!osgiAvailable || !classpathSetup.isReadOSGiMetadata()) { |
| return null; |
| } |
| // TODO |
| // Nicolas: AFAIU, the access rules seems to have to be set on the imported project itself |
| // rather than filtering here, afterwards |
| return null; |
| } |
| |
| private IAccessRule[] getAccessRules(BundleInfo bundleInfo) { |
| if (bundleInfo == null || !classpathSetup.isReadOSGiMetadata()) { |
| return null; |
| } |
| IAccessRule[] rules = new IAccessRule[bundleInfo.getExports().size() + 1]; |
| int i = 0; |
| for (ExportPackage exportPackage : bundleInfo.getExports()) { |
| rules[i++] = JavaCore.newAccessRule( |
| new Path(exportPackage.getName().replace('.', IPath.SEPARATOR) + "/*"), |
| IAccessRule.K_ACCESSIBLE); |
| } |
| rules[i++] = JavaCore.newAccessRule(new Path("**/*"), IAccessRule.K_NON_ACCESSIBLE |
| | IAccessRule.IGNORE_IF_BETTER); |
| return rules; |
| } |
| |
| private Path getArtifactPath(ArtifactDownloadReport artifact, String innerPath) { |
| if (retrievedArtifacts != null) { |
| Set<String> pathSet = retrievedArtifacts.get(artifact); |
| if (pathSet != null && !pathSet.isEmpty()) { |
| return new Path((String) pathSet.iterator().next() + innerPath); |
| } |
| } |
| return new Path(artifact.getLocalFile().getAbsolutePath() + innerPath); |
| } |
| |
| interface ArtifactMatcher { |
| boolean matchName(Artifact artifact, String artifactName); |
| |
| boolean match(Artifact a); |
| |
| String getName(); |
| } |
| |
| private Path getArtifactPath(ArtifactDownloadReport adr, ArtifactMatcher matcher, |
| boolean mapIfOnlyOne, String innerPath) { |
| Artifact artifact = adr.getArtifact(); |
| monitor.subTask("searching " + matcher.getName() + " for " + artifact); |
| for (ArtifactDownloadReport otherAdr : all) { |
| Artifact a = otherAdr.getArtifact(); |
| if (otherAdr.getLocalFile() != null && matcher.matchName(artifact, a.getName()) |
| && a.getModuleRevisionId().equals(artifact.getModuleRevisionId()) |
| && matcher.match(a)) { |
| return getArtifactPath(otherAdr, innerPath); |
| } |
| } |
| // we haven't found source artifact in resolved artifacts, |
| // let's look in the module declaring the artifact |
| ModuleRevisionId mrid = artifact.getId().getModuleRevisionId(); |
| Artifact[] artifacts = (Artifact[]) artifactsByDependency.get(mrid); |
| if (artifacts != null) { |
| Artifact foundArtifact = null; |
| int nbFound = 0; |
| for (int i = 0; i < artifacts.length; i++) { |
| Artifact metaArtifact = artifacts[i]; |
| if (matcher.match(metaArtifact)) { |
| if (matcher.matchName(artifact, metaArtifact.getName())) { |
| // we've found a matching artifact, let's provision it |
| ArtifactDownloadReport metaAdr = ivy.getResolveEngine().download( |
| metaArtifact, new DownloadOptions()); |
| if (metaAdr.getLocalFile() != null && metaAdr.getLocalFile().exists()) { |
| return getArtifactPath(metaAdr, innerPath); |
| } |
| } |
| // keep a reference to the artifact so we could fall back |
| // to map-if-only-one |
| nbFound++; |
| foundArtifact = metaArtifact; |
| } |
| } |
| if (mapIfOnlyOne) { |
| // we haven't found artifact in the module declaring the artifact and having |
| // a matching name. |
| if (nbFound == 1) { |
| // If there is only 1 found artifact, it is the winner ;-) |
| ArtifactDownloadReport metaAdr = ivy.getResolveEngine().download(foundArtifact, |
| new DownloadOptions()); |
| if (metaAdr.getLocalFile() != null && metaAdr.getLocalFile().exists()) { |
| return new Path(metaAdr.getLocalFile().getAbsolutePath()); |
| } |
| } |
| } |
| } |
| |
| return null; |
| } |
| |
| private ArtifactMatcher sourceArtifactMatcher = new ArtifactMatcher() { |
| public boolean matchName(Artifact artifact, String source) { |
| return isArtifactName(artifact, source, mapping.getSourceSuffixes(), "source"); |
| } |
| |
| public boolean match(Artifact a) { |
| return mapping.getSourceTypes().contains(a.getType()); |
| } |
| |
| public String getName() { |
| return "sources"; |
| } |
| }; |
| |
| private ArtifactMatcher javadocArtifactMatcher = new ArtifactMatcher() { |
| public boolean matchName(Artifact artifact, String javadoc) { |
| return isArtifactName(artifact, javadoc, mapping.getJavadocSuffixes(), "javadoc"); |
| } |
| |
| public boolean match(Artifact a) { |
| return mapping.getJavadocTypes().contains(a.getType()); |
| } |
| |
| public String getName() { |
| return "javadoc"; |
| } |
| }; |
| |
| private boolean isArtifactName(Artifact artifact, String name, Collection<String> suffixes, |
| String type) { |
| String artifactNameToMatch = (String) artifact.getExtraAttribute(IVYDE_NS_PREFIX + type); |
| if (artifactNameToMatch != null) { |
| // some name is specified, it overrides suffix matching |
| return name.equals(artifactNameToMatch); |
| } |
| String jar = artifact.getName(); |
| if (name.equals(jar)) { |
| return true; |
| } |
| for (String suffix : suffixes) { |
| if (name.equals(jar + suffix)) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| private IClasspathAttribute[] getExtraAttribute(IPath classpathArtifact, IPath javadocArtifact) { |
| List<IClasspathAttribute> result = new ArrayList<IClasspathAttribute>(); |
| URL url = attachementManager.getDocAttachment(classpathArtifact); |
| |
| if (url == null) { |
| IPath path = javadocArtifact; |
| if (path != null) { |
| String u; |
| try { |
| u = "jar:" + path.toFile().toURI().toURL().toExternalForm() + "!/"; |
| try { |
| url = new URL(u); |
| } catch (MalformedURLException e) { |
| // this should not happen |
| IvyPlugin.logError("The jar URL for the javadoc is not formed correctly " |
| + u, e); |
| } |
| } catch (MalformedURLException e) { |
| // this should not happen |
| IvyPlugin.logError("The path has not a correct URL: " + path, e); |
| } |
| } |
| } |
| |
| if (url != null) { |
| result.add(JavaCore.newClasspathAttribute( |
| IClasspathAttribute.JAVADOC_LOCATION_ATTRIBUTE_NAME, url.toExternalForm())); |
| } |
| return result.toArray(new IClasspathAttribute[result.size()]); |
| } |
| |
| /** |
| * Check if the artifact is an artifact which can be added to the classpath container |
| * |
| * @param artifact |
| * the artifact to check |
| * @return <code>true</code> if the artifact can be added |
| */ |
| public boolean accept(Artifact artifact) { |
| boolean accepted = classpathSetup.getAcceptedTypes().contains(artifact.getType()); |
| if (!accepted && classpathSetup.getAcceptedTypes().size() == 1 |
| && classpathSetup.getAcceptedTypes().get(0).equals("*")) { |
| accepted = true; |
| } |
| return accepted && !mapping.getSourceTypes().contains(artifact.getType()) |
| && !mapping.getJavadocTypes().contains(artifact.getType()); |
| } |
| |
| } |
