Artifact moduleArtifact, ResourceDownloader downloader, CacheMetadataOptions options)
throws ParseException {
ModuleDescriptorParser parser = ModuleDescriptorParserRegistry
.getInstance().getParser(mdRef.getResource());
Date cachedPublicationDate = null;
ArtifactDownloadReport report;
ModuleRevisionId mrid = moduleArtifact.getModuleRevisionId();
Artifact originalMetadataArtifact = getOriginalMetadataArtifact(moduleArtifact);
if (!lockMetadataArtifact(mrid)) {
Message.error("impossible to acquire lock for " + mrid);
return null;
}
try {
// now let's see if we can find it in cache and if it is up to date
ResolvedModuleRevision rmr = doFindModuleInCache(mrid, options, null);
if (rmr != null) {
if (rmr.getDescriptor().isDefault() && rmr.getResolver() != resolver) {
Message.verbose("\t" + getName() + ": found revision in cache: " + mrid
+ " (resolved by " + rmr.getResolver().getName()
+ "): but it's a default one, maybe we can find a better one");
} else {
if (!isCheckmodified(dd, options) && !isChanging(dd, options)) {
Message.verbose("\t" + getName() + ": revision in cache: " + mrid);
rmr.getReport().setSearched(true);
return rmr;
}
long repLastModified = mdRef.getLastModified();
long cacheLastModified = rmr.getDescriptor().getLastModified();
if (!rmr.getDescriptor().isDefault() && repLastModified <= cacheLastModified) {
Message.verbose("\t" + getName() + ": revision in cache (not updated): "
+ mrid);
rmr.getReport().setSearched(true);
return rmr;
} else {
Message.verbose("\t" + getName() + ": revision in cache is not up to date: "
+ mrid);
if (isChanging(dd, options)) {
// ivy file has been updated, we should see if it has a new publication
// date to see if a new download is required (in case the dependency is
// a changing one)
cachedPublicationDate =
rmr.getDescriptor().getResolvedPublicationDate();
}
}
}
}
// now download module descriptor and parse it
report = download(
originalMetadataArtifact,
new ArtifactResourceResolver() {
public ResolvedResource resolve(Artifact artifact) {
return mdRef;
}
}, downloader,
new CacheDownloadOptions().setListener(options.getListener()).setForce(true));
Message.verbose("\t" + report);
if (report.getDownloadStatus() == DownloadStatus.FAILED) {
Message.warn("problem while downloading module descriptor: " + mdRef.getResource()
+ ": " + report.getDownloadDetails()
+ " (" + report.getDownloadTimeMillis() + "ms)");
return null;
}
URL cachedMDURL = null;
try {
cachedMDURL = report.getLocalFile().toURL();
} catch (MalformedURLException ex) {
Message.warn("malformed url exception for original in cache file: "
+ report.getLocalFile() + ": " + ex.getMessage());
return null;
}
try {
ModuleDescriptor md = parser.parseDescriptor(
settings, cachedMDURL, mdRef.getResource(), options.isValidate());
if (md == null) {
throw new IllegalStateException(
"module descriptor parser returned a null module descriptor, "
+ "which is not allowed. "
+ "parser=" + parser
+ "; parser class=" + parser.getClass().getName()
+ "; module descriptor resource=" + mdRef.getResource());
}
Message.debug("\t" + getName() + ": parsed downloaded md file for " + mrid
+ "; parsed=" + md.getModuleRevisionId());
// check if we should delete old artifacts
boolean deleteOldArtifacts = false;
if (cachedPublicationDate != null
&& !cachedPublicationDate.equals(md.getResolvedPublicationDate())) {
// artifacts have changed, they should be downloaded again
Message.verbose(mrid + " has changed: deleting old artifacts");
deleteOldArtifacts = true;
}
if (deleteOldArtifacts) {
String[] confs = md.getConfigurationsNames();
for (int i = 0; i < confs.length; i++) {
Artifact[] arts = md.getArtifacts(confs[i]);
for (int j = 0; j < arts.length; j++) {
Artifact transformedArtifact = NameSpaceHelper.transform(
arts[j], options.getNamespace().getToSystemTransformer());
ArtifactOrigin origin = getSavedArtifactOrigin(
transformedArtifact);
File artFile = getArchiveFileInCache(
transformedArtifact, origin, false);
if (artFile.exists()) {
Message.debug("deleting " + artFile);
artFile.delete();
}
removeSavedArtifactOrigin(transformedArtifact);
}
}
} else if (isChanging(dd, options)) {
Message.verbose(mrid
+ " is changing, but has not changed: will trust cached artifacts if any");
}
MetadataArtifactDownloadReport madr
= new MetadataArtifactDownloadReport(md.getMetadataArtifact());
madr.setSearched(true);
madr.setDownloadStatus(report.getDownloadStatus());
madr.setDownloadDetails(report.getDownloadDetails());
madr.setArtifactOrigin(report.getArtifactOrigin());
madr.setDownloadTimeMillis(report.getDownloadTimeMillis());
madr.setOriginalLocalFile(report.getLocalFile());
madr.setSize(report.getSize());
saveArtifactOrigin(md.getMetadataArtifact(), report.getArtifactOrigin());
return new ResolvedModuleRevision(resolver, resolver, md, madr);
} catch (IOException ex) {
Message.warn("io problem while parsing ivy file: " + mdRef.getResource() + ": "
+ ex.getMessage());