| /* |
| * 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.easyant.tasks; |
| |
| import org.apache.ivy.Ivy; |
| import org.apache.ivy.ant.AntMessageLogger; |
| import org.apache.ivy.core.cache.DefaultRepositoryCacheManager; |
| import org.apache.ivy.core.cache.DefaultResolutionCacheManager; |
| import org.apache.ivy.core.cache.RepositoryCacheManager; |
| import org.apache.ivy.core.cache.ResolutionCacheManager; |
| import org.apache.ivy.core.module.descriptor.Configuration; |
| import org.apache.ivy.core.module.descriptor.DefaultDependencyDescriptor; |
| import org.apache.ivy.core.module.descriptor.DefaultModuleDescriptor; |
| import org.apache.ivy.core.module.descriptor.ModuleDescriptor; |
| import org.apache.ivy.core.module.id.ModuleId; |
| import org.apache.ivy.core.module.id.ModuleRevisionId; |
| import org.apache.ivy.core.report.ArtifactDownloadReport; |
| import org.apache.ivy.core.report.ConfigurationResolveReport; |
| import org.apache.ivy.core.report.ResolveReport; |
| import org.apache.ivy.core.resolve.ResolveOptions; |
| import org.apache.ivy.core.retrieve.RetrieveOptions; |
| import org.apache.ivy.core.settings.IvySettings; |
| import org.apache.ivy.core.sort.SortOptions; |
| import org.apache.ivy.plugins.parser.ModuleDescriptorParser; |
| import org.apache.ivy.plugins.parser.ModuleDescriptorParserRegistry; |
| import org.apache.ivy.plugins.report.XmlReportParser; |
| import org.apache.ivy.plugins.repository.url.URLResource; |
| import org.apache.ivy.plugins.resolver.FileSystemResolver; |
| import org.apache.tools.ant.BuildException; |
| import org.apache.tools.ant.Project; |
| import org.apache.tools.ant.Task; |
| import org.apache.tools.ant.taskdefs.Delete; |
| import org.apache.tools.ant.taskdefs.ImportTask; |
| import org.apache.tools.ant.types.Path; |
| import org.apache.tools.ant.types.Path.PathElement; |
| |
| import java.io.File; |
| import java.io.IOException; |
| import java.net.MalformedURLException; |
| import java.net.URL; |
| import java.text.ParseException; |
| import java.util.*; |
| |
| /** |
| * EXPERIMENTAL, IT IS NOT INTENDED FOR PUBLIC USE |
| * <p/> |
| * An Ant task which resolve some build scripts and import them |
| */ |
| public class ImportAntscripts extends Task { |
| |
| private File ivyfile; |
| |
| private File ivysettings; |
| |
| private Ivy externalIvy; |
| |
| public void setIvyfile(File ivyfile) { |
| this.ivyfile = ivyfile; |
| } |
| |
| public void setIvysettings(File ivysettings) { |
| this.ivysettings = ivysettings; |
| } |
| |
| @Override |
| public void execute() throws BuildException { |
| long startTime = System.currentTimeMillis(); |
| |
| if (getOwningTarget() == null || !"".equals(getOwningTarget().getName())) { |
| throw new BuildException("import only allowed as a top-level task"); |
| } |
| |
| if (ivyfile == null) { |
| throw new BuildException("ivyfile is required"); |
| } |
| if (ivysettings == null) { |
| throw new BuildException("ivysettings is required"); |
| } |
| |
| boolean refresh = false; |
| String refreshValue = getProject().getProperty("easyant.refresh"); |
| if (refreshValue != null) { |
| refresh = Boolean.parseBoolean(refreshValue); |
| } |
| |
| // configure ivy, which may be the local retrieve repo, depending of the setup |
| Ivy ivy = getIvy(); |
| ivy.pushContext(); |
| |
| try { |
| ModuleDescriptor md = getMd(ivy, ivyfile); |
| |
| ArtifactDownloadReport[] artifacts; |
| List<ModuleDescriptor> dependencies = new ArrayList<ModuleDescriptor>(); |
| |
| // first, let's resolve the ant scripts, just the scripts, not their possible jar dependencies, thus only |
| // the configuration "default" |
| |
| XmlReportParser xmlreport = null; |
| if (!refresh) { |
| // first try to relad the resolve from the last report |
| xmlreport = getResolveReport(ivy, md.getModuleRevisionId().getModuleId(), "default", ivyfile); |
| } |
| if (xmlreport != null) { |
| // collect the ant scripts |
| artifacts = xmlreport.getArtifactReports(); |
| |
| // collect the descriptor associated with each ant script |
| ModuleRevisionId[] depIds = xmlreport.getDependencyRevisionIds(); |
| for (ModuleRevisionId depId : depIds) { |
| File depIvyFile = xmlreport.getMetadataArtifactReport(depId).getLocalFile(); |
| dependencies.add(getMd(ivy, depIvyFile)); |
| } |
| } else { |
| // do a full resolve |
| |
| // if in a retrieved setup, clean the repo and repopulate it |
| maybeClearLocalRepo(); |
| maybeRetrieve(md, "default"); |
| |
| // launch the actual resolve |
| ResolveReport resolveReport = resolve(ivy, md, "default"); |
| ConfigurationResolveReport confReport = resolveReport.getConfigurationReport("default"); |
| |
| // collect the ant scripts |
| artifacts = confReport.getAllArtifactsReports(); |
| |
| // collect the descriptor associated with each ant script |
| Set<ModuleRevisionId> mrids = confReport.getModuleRevisionIds(); |
| for (ModuleRevisionId mrid : mrids) { |
| dependencies.add(confReport.getDependency(mrid).getDescriptor()); |
| } |
| } |
| |
| int nbPaths = 1; |
| |
| // save the collection of ant scripts as a path |
| Path antScriptsPath = makePath("easyant.antscripts", sortArtifacts(ivy, artifacts, dependencies)); |
| |
| // now, for each ant script descriptor, search for an ivy configuration which is used by the ant script |
| // itself |
| |
| for (ModuleDescriptor depmd : dependencies) { |
| log("Searching for external conf for " + depmd.getModuleRevisionId(), Project.MSG_VERBOSE); |
| String[] confs = depmd.getConfigurationsNames(); |
| log("configurations for " + depmd.getModuleRevisionId() + " : " + Arrays.toString(confs), |
| Project.MSG_DEBUG); |
| |
| // some trick here: launching a resolve on a module won't resolve the artifacts of the module itself but |
| // only of its dependencies. So we'll create a mock one which will depend on the real one |
| String mockOrg = "_easyant_mocks_"; |
| String mockName = depmd.getModuleRevisionId().getOrganisation() + "__" |
| + depmd.getModuleRevisionId().getName(); |
| ModuleRevisionId mockmrid = ModuleRevisionId.newInstance(mockOrg, mockName, depmd.getModuleRevisionId() |
| .getBranch(), depmd.getRevision(), depmd.getExtraAttributes()); |
| DefaultModuleDescriptor mock = new DefaultModuleDescriptor(mockmrid, depmd.getStatus(), |
| depmd.getPublicationDate(), depmd.isDefault()); |
| DefaultDependencyDescriptor mockdd = new DefaultDependencyDescriptor(depmd.getModuleRevisionId(), false); |
| for (String conf : confs) { |
| mock.addConfiguration(new Configuration(conf)); |
| mockdd.addDependencyConfiguration(conf, conf); |
| } |
| mock.addDependency(mockdd); |
| |
| for (String conf : confs) { |
| if (conf.equals("default")) { |
| continue; |
| } |
| |
| nbPaths++; |
| log("Found configuration " + conf, Project.MSG_VERBOSE); |
| |
| // same process than for the ant script: |
| // * trust the last resolve report |
| // * or launch a full resolve |
| // A full resolve might trigger a retrieve to populate the local repo |
| |
| XmlReportParser xmldepreport = null; |
| if (!refresh) { |
| xmldepreport = getResolveReport(ivy, mock.getModuleRevisionId().getModuleId(), conf, null); |
| } |
| if (xmldepreport != null) { |
| artifacts = xmldepreport.getArtifactReports(); |
| } else { |
| maybeRetrieve(mock, conf); |
| ResolveReport resolveReport = resolve(ivy, mock, conf); |
| ConfigurationResolveReport confReport = resolveReport.getConfigurationReport(conf); |
| artifacts = confReport.getAllArtifactsReports(); |
| } |
| |
| // finally make the resolved artifact a path which can be used by the ant script itself |
| makePath(depmd.getModuleRevisionId().getModuleId().toString() + "[" + conf + "]", |
| Arrays.asList(artifacts)); |
| } |
| } |
| |
| log(nbPaths + " paths resolved in " + (System.currentTimeMillis() - startTime) + "ms.", Project.MSG_VERBOSE); |
| |
| log("Importing " + antScriptsPath.size() + " ant scripts", Project.MSG_VERBOSE); |
| Iterator<?> itScripts = antScriptsPath.iterator(); |
| while (itScripts.hasNext()) { |
| log("\t" + itScripts.next(), Project.MSG_VERBOSE); |
| } |
| |
| ImportTask importTask = new ImportTask(); |
| importTask.setProject(getProject()); |
| importTask.setOwningTarget(getOwningTarget()); |
| importTask.setLocation(getLocation()); |
| importTask.add(antScriptsPath); |
| importTask.execute(); |
| } finally { |
| ivy.popContext(); |
| } |
| |
| } |
| |
| private List<ArtifactDownloadReport> sortArtifacts(Ivy ivy, ArtifactDownloadReport[] artifacts, |
| List<ModuleDescriptor> dependencies) { |
| // first lets map the artifacts to their id |
| Map<ModuleRevisionId, List<ArtifactDownloadReport>> artifactsById = new HashMap<ModuleRevisionId, List<ArtifactDownloadReport>>(); |
| for (ArtifactDownloadReport artifact : artifacts) { |
| List<ArtifactDownloadReport> artifactsForId = artifactsById.get(artifact.getArtifact() |
| .getModuleRevisionId()); |
| if (artifactsForId == null) { |
| artifactsForId = new ArrayList<ArtifactDownloadReport>(); |
| artifactsById.put(artifact.getArtifact().getModuleRevisionId(), artifactsForId); |
| } |
| artifactsForId.add(artifact); |
| } |
| |
| List<ModuleDescriptor> sorted = ivy.sortModuleDescriptors(dependencies, SortOptions.DEFAULT); |
| |
| List<ArtifactDownloadReport> sortedArifacts = new ArrayList<ArtifactDownloadReport>(artifacts.length); |
| for (ModuleDescriptor md : sorted) { |
| List<ArtifactDownloadReport> artifactsForId = artifactsById.get(md.getModuleRevisionId()); |
| if (artifactsForId != null) { |
| sortedArifacts.addAll(artifactsForId); |
| } |
| } |
| |
| return sortedArifacts; |
| } |
| |
| private Ivy getIvy() { |
| Ivy ivy = getLocalRepoIvy(); |
| if (ivy != null) { |
| return ivy; |
| } |
| return getExternalIvy(); |
| } |
| |
| /** |
| * @return the ivy instance corresponding to the ivysettings.xml provided by the end user |
| */ |
| private Ivy getExternalIvy() { |
| if (externalIvy == null) { |
| externalIvy = new Ivy(); |
| try { |
| externalIvy.configure(ivysettings); |
| } catch (ParseException e) { |
| throw new BuildException("Incorrect setup of the ivysettings for easyant (" + e.getMessage() + ")", e); |
| } catch (IOException e) { |
| throw new BuildException("Incorrect setup of the ivysettings for easyant (" + e.getMessage() + ")", e); |
| } |
| AntMessageLogger.register(this, externalIvy); |
| } |
| return externalIvy; |
| } |
| |
| /** |
| * Parse an ivy.xml |
| */ |
| private ModuleDescriptor getMd(Ivy ivy, File file) { |
| URL url; |
| try { |
| url = file.toURI().toURL(); |
| } catch (MalformedURLException e) { |
| throw new BuildException("[easyant bug] a file has not a proper url", e); |
| } |
| URLResource res = new URLResource(url); |
| ModuleDescriptorParser mdparser = ModuleDescriptorParserRegistry.getInstance().getParser(res); |
| ModuleDescriptor md; |
| ivy.pushContext(); |
| try { |
| md = mdparser.parseDescriptor(ivy.getSettings(), url, true); |
| } catch (ParseException e) { |
| throw new BuildException("The file " + file + " is not a correct ivy file (" + e.getMessage() + ")", e); |
| } catch (IOException e) { |
| throw new BuildException("The file " + file + " could not be read (" + e.getMessage() + ")", e); |
| } |
| return md; |
| } |
| |
| /** |
| * Try to load a resolve report. If not found, not available, out of date or contains resolve errors, it returns |
| * <code>null</code>. |
| */ |
| private XmlReportParser getResolveReport(Ivy ivy, ModuleId mid, String conf, File ivyfile) { |
| File report = ivy.getResolutionCacheManager().getConfigurationResolveReportInCache( |
| ResolveOptions.getDefaultResolveId(mid), conf); |
| if (!report.exists()) { |
| return null; |
| } |
| if (ivyfile != null && ivyfile.lastModified() > report.lastModified()) { |
| return null; |
| } |
| // found a report, try to parse it. |
| try { |
| log("Reading resolve report " + report, Project.MSG_DEBUG); |
| XmlReportParser reportparser = new XmlReportParser(); |
| reportparser.parse(report); |
| if (reportparser.hasError()) { |
| return null; |
| } |
| log("Loading last resolve report for " + mid + "[" + conf + "]", Project.MSG_VERBOSE); |
| return reportparser; |
| } catch (ParseException e) { |
| return null; |
| } |
| } |
| |
| /** |
| * Launch an actual resolve |
| */ |
| private ResolveReport resolve(Ivy ivy, ModuleDescriptor md, String conf) { |
| ResolveOptions options = new ResolveOptions(); |
| options.setConfs(new String[]{conf}); |
| ResolveReport report; |
| try { |
| report = ivy.resolve(md, options); |
| } catch (ParseException e) { |
| throw new BuildException("Error while resolving " + ivyfile, e); |
| } catch (IOException e) { |
| throw new BuildException("Error while resolving " + ivyfile, e); |
| } |
| |
| if (report.hasError()) { |
| throw new BuildException("[easyant bug] fail to resolve antlib dependencies"); |
| } |
| |
| return report; |
| } |
| |
| /** |
| * Make an array of artifacts a path and save it in the ant references |
| */ |
| private Path makePath(String pathId, List<ArtifactDownloadReport> artifacts) { |
| log("Path '" + pathId + "' computed with " + artifacts.size() + " files", Project.MSG_VERBOSE); |
| Path path = new Path(getProject()); |
| for (ArtifactDownloadReport artifact : artifacts) { |
| if (artifact.getLocalFile() != null) { |
| PathElement pe = path.createPathElement(); |
| pe.setLocation(artifact.getLocalFile()); |
| log("Adding to path '" + pathId + "': " + artifact.getLocalFile(), Project.MSG_DEBUG); |
| } |
| } |
| |
| getProject().addReference(pathId, path); |
| return path; |
| } |
| |
| /** |
| * If it is setup to have a retrieved local repo, get the basedir of the repo. Returns <code>null</code> otherwise |
| */ |
| private File getLocalRepoBaseDir() { |
| String basedirValue = getProject().getProperty("easyant.localrepo.basedir"); |
| if (basedirValue == null) { |
| return null; |
| } |
| return getProject().resolveFile(basedirValue); |
| } |
| |
| /** |
| * Build the ivy instance to be used on the local retrieved repo |
| */ |
| private Ivy getLocalRepoIvy() { |
| File basedir = getLocalRepoBaseDir(); |
| if (basedir == null) { |
| return null; |
| } |
| |
| IvySettings settings = new IvySettings(); |
| settings.setBaseDir(basedir); |
| settings.setDefaultUseOrigin(true); |
| |
| File cacheDir = new File(basedir, ".cache"); |
| |
| ResolutionCacheManager resolutionCacheManager = new DefaultResolutionCacheManager(cacheDir); |
| settings.setResolutionCacheManager(resolutionCacheManager); |
| |
| RepositoryCacheManager repositoryCacheManager = new DefaultRepositoryCacheManager("default-cache", settings, |
| cacheDir); |
| settings.setDefaultRepositoryCacheManager(repositoryCacheManager); |
| |
| FileSystemResolver localResolver = new FileSystemResolver(); |
| localResolver.setName("local-repo"); |
| localResolver.addIvyPattern(basedir.getAbsolutePath() + "/[organization]/[module]/[revision]/ivy.xml"); |
| localResolver.addArtifactPattern(basedir.getAbsolutePath() |
| + "/[organization]/[module]/[revision]/[type]s/[artifact].[ext]"); |
| |
| settings.addResolver(localResolver); |
| |
| settings.setDefaultResolver("local-repo"); |
| |
| Ivy ivy = Ivy.newInstance(settings); |
| AntMessageLogger.register(this, ivy); |
| return ivy; |
| } |
| |
| /** |
| * If setup with a local repo, clean it |
| */ |
| private void maybeClearLocalRepo() { |
| File basedir = getLocalRepoBaseDir(); |
| if (basedir == null) { |
| return; |
| } |
| |
| log("Deleting the local repository '" + basedir + "'", Project.MSG_VERBOSE); |
| |
| Delete delete = new Delete(); |
| delete.setFailOnError(false); |
| delete.setDir(basedir); |
| } |
| |
| /** |
| * If setup with a local repo, resolve the module and retrieve the artifacts into the local repo. |
| */ |
| private void maybeRetrieve(ModuleDescriptor md, String conf) { |
| File basedir = getLocalRepoBaseDir(); |
| if (basedir == null) { |
| return; |
| } |
| |
| log("Populating the local repository '" + basedir + "' with dependencies of " + md, Project.MSG_VERBOSE); |
| |
| Ivy ivy = getExternalIvy(); |
| try { |
| ivy.setVariable("easyant.localrepo.basedir", basedir.getCanonicalPath()); |
| } catch (IOException e) { |
| throw new BuildException("Unable to compute the path to the local repository", e); |
| } |
| ResolveReport resolve = resolve(ivy, md, conf); |
| |
| RetrieveOptions options = new RetrieveOptions(); |
| options.setSync(false); |
| options.setResolveId(resolve.getResolveId()); |
| options.setConfs(new String[]{conf}); |
| options.setDestIvyPattern("${easyant.localrepo.basedir}/[organization]/[module]/[revision]/ivy.xml"); |
| try { |
| ivy.retrieve(md.getModuleRevisionId(), |
| "${easyant.localrepo.basedir}/[organization]/[module]/[revision]/[type]s/[artifact].[ext]", options); |
| } catch (IOException e) { |
| throw new BuildException("Unable to build the local repository", e); |
| } |
| } |
| } |
