| /* |
| * 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.ivy.ant; |
| |
| import java.io.File; |
| import java.net.MalformedURLException; |
| import java.net.URISyntaxException; |
| import java.net.URL; |
| import java.text.ParseException; |
| import java.util.ArrayList; |
| import java.util.Date; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Map.Entry; |
| |
| import org.apache.ivy.core.module.descriptor.Artifact; |
| import org.apache.ivy.core.module.descriptor.DefaultArtifact; |
| import org.apache.ivy.core.module.descriptor.DependencyDescriptor; |
| import org.apache.ivy.core.module.descriptor.ModuleDescriptor; |
| import org.apache.ivy.core.report.ArtifactDownloadReport; |
| import org.apache.ivy.core.report.DownloadReport; |
| import org.apache.ivy.core.report.DownloadStatus; |
| import org.apache.ivy.core.resolve.DownloadOptions; |
| import org.apache.ivy.core.resolve.ResolveData; |
| import org.apache.ivy.core.resolve.ResolvedModuleRevision; |
| import org.apache.ivy.plugins.parser.ModuleDescriptorParserRegistry; |
| import org.apache.ivy.plugins.resolver.AbstractWorkspaceResolver; |
| import org.apache.ivy.util.Message; |
| import org.apache.tools.ant.BuildException; |
| import org.apache.tools.ant.types.DataType; |
| import org.apache.tools.ant.types.ResourceCollection; |
| import org.apache.tools.ant.types.resources.FileResource; |
| |
| public class AntWorkspaceResolver extends DataType { |
| |
| public static final class WorkspaceArtifact { |
| |
| private String name; |
| |
| private String type; |
| |
| private String ext; |
| |
| private String path; |
| |
| public void setName(String name) { |
| this.name = name; |
| } |
| |
| public void setType(String type) { |
| this.type = type; |
| } |
| |
| public void setExt(String ext) { |
| this.ext = ext; |
| } |
| |
| public void setPath(String path) { |
| this.path = path; |
| } |
| } |
| |
| private List<ResourceCollection> allResources = new ArrayList<ResourceCollection>(); |
| |
| private boolean haltOnError = true; |
| |
| private Resolver resolver; |
| |
| private String name; |
| |
| private List<WorkspaceArtifact> artifacts = new ArrayList<WorkspaceArtifact>(); |
| |
| public void setName(String name) { |
| this.name = name; |
| } |
| |
| public void setHaltonerror(boolean haltOnError) { |
| this.haltOnError = haltOnError; |
| } |
| |
| public void addConfigured(ResourceCollection resources) { |
| if (!resources.isFilesystemOnly()) { |
| throw new BuildException("Only filesystem resource collection is supported"); |
| } |
| allResources.add(resources); |
| } |
| |
| public WorkspaceArtifact createArtifact() { |
| WorkspaceArtifact a = new WorkspaceArtifact(); |
| artifacts.add(a); |
| return a; |
| } |
| |
| public Resolver getResolver() { |
| if (resolver == null) { |
| if (name == null) { |
| throw new BuildException("A name is required"); |
| } |
| resolver = new Resolver(); |
| resolver.setName(name); |
| } |
| return resolver; |
| } |
| |
| private String getProjectName(File ivyFile) { |
| return ivyFile.getParentFile().getName(); |
| } |
| |
| private class Resolver extends AbstractWorkspaceResolver { |
| |
| private Map<ModuleDescriptor, File> md2IvyFile; |
| |
| private synchronized Map<ModuleDescriptor, File> getModuleDescriptors() { |
| if (md2IvyFile == null) { |
| md2IvyFile = new HashMap<ModuleDescriptor, File>(); |
| for (ResourceCollection resources : allResources) { |
| for (Iterator it = resources.iterator(); it.hasNext();) { |
| File ivyFile = ((FileResource) it.next()).getFile(); |
| try { |
| ModuleDescriptor md = ModuleDescriptorParserRegistry.getInstance() |
| .parseDescriptor(getParserSettings(), ivyFile.toURI().toURL(), |
| isValidate()); |
| md2IvyFile.put(md, ivyFile); |
| Message.debug("Add " + md.getModuleRevisionId().getModuleId()); |
| } catch (Exception ex) { |
| if (haltOnError) { |
| throw new BuildException("impossible to parse ivy file " + ivyFile |
| + " exception=" + ex, ex); |
| } else { |
| Message.warn("impossible to parse ivy file " + ivyFile |
| + " exception=" + ex.getMessage()); |
| } |
| } |
| } |
| } |
| } |
| return md2IvyFile; |
| } |
| |
| public ResolvedModuleRevision getDependency(DependencyDescriptor dd, ResolveData data) |
| throws ParseException { |
| Map<ModuleDescriptor, File> mds = getModuleDescriptors(); |
| for (Entry<ModuleDescriptor, File> md : mds.entrySet()) { |
| ResolvedModuleRevision rmr = checkCandidate(dd, md.getKey(), |
| getProjectName(md.getValue())); |
| if (rmr != null) { |
| return rmr; |
| } |
| } |
| return null; |
| } |
| |
| @Override |
| protected List<Artifact> createWorkspaceArtifacts(ModuleDescriptor md) { |
| List<Artifact> res = new ArrayList<Artifact>(); |
| |
| for (WorkspaceArtifact wa : artifacts) { |
| String name = wa.name; |
| String type = wa.type; |
| String ext = wa.ext; |
| String path = wa.path; |
| if (name == null) { |
| name = md.getModuleRevisionId().getName(); |
| } |
| if (type == null) { |
| type = "jar"; |
| } |
| if (ext == null) { |
| ext = "jar"; |
| } |
| if (path == null) { |
| path = "target" + File.separator + "dist" + File.separator + type + "s" |
| + File.separator + name + "." + ext; |
| } |
| |
| URL url; |
| File ivyFile = md2IvyFile.get(md); |
| File artifactFile = new File(ivyFile.getParentFile(), path); |
| try { |
| url = artifactFile.toURI().toURL(); |
| } catch (MalformedURLException e) { |
| throw new RuntimeException("Unsupported file path : " + artifactFile, e); |
| } |
| |
| res.add(new DefaultArtifact(md.getModuleRevisionId(), new Date(), name, type, ext, |
| url, null)); |
| } |
| |
| return res; |
| } |
| |
| public DownloadReport download(Artifact[] artifacts, DownloadOptions options) { |
| // Not much to do here - downloads are not required for workspace projects. |
| DownloadReport dr = new DownloadReport(); |
| for (int i = 0; i < artifacts.length; i++) { |
| ArtifactDownloadReport adr = new ArtifactDownloadReport(artifacts[i]); |
| dr.addArtifactReport(adr); |
| URL url = artifacts[i].getUrl(); |
| if (url == null || !url.getProtocol().equals("file")) { |
| // this is not an artifact managed by this resolver |
| adr.setDownloadStatus(DownloadStatus.FAILED); |
| return dr; |
| } |
| File f; |
| try { |
| f = new File(url.toURI()); |
| } catch (URISyntaxException e) { |
| f = new File(url.getPath()); |
| } |
| adr.setLocalFile(f); |
| adr.setDownloadStatus(DownloadStatus.NO); |
| adr.setSize(0); |
| Message.verbose("\t[IN WORKSPACE] " + artifacts[i]); |
| } |
| return dr; |
| } |
| } |
| |
| } |