From e3931dbfece96d054a5b501eb2d194b91e1733bb Mon Sep 17 00:00:00 2001 From: Josh Suereth Date: Tue, 16 Dec 2014 13:14:14 -0500 Subject: [PATCH] Create a new Ivy DependencyResolver which uses Aether. * Here we wire Aether into the Ivy dependency chain * Add hooks into Aether to use Ivy's http library (so credentials are configured the same) * Create the actual Resolver which extracts metadata information from Aether * Deprecate old Ivy-Maven integrations * Create hooks in existing Resolver facilities to expose a flag to enable the new behavior. * Create notes documenting the feature. * Create a new resolver type `MavenCache` which denotes how to read/write local maven cache metadata correctly. We use this type for publishM2 and mavenLocal. * Update failing -SNAPSHOT related tests to use new Aether resolver * Create specification for expected behavior from the new resolvers. Known to fix #1322, #321, #647, #1616 --- build.sbt | 2 +- .../ReplaceMavenConfigurationMappings.scala | 5 + .../resolver/MavenRepositoryResolver.scala | 656 ++++++++++++++++++ .../MavenRepositorySystemFactory.scala | 140 ++++ .../internal/SbtArtifactDescriptorReader.java | 556 +++++++++++++++ .../internal/SbtExtraProperties.java | 23 + .../internal/SbtRepositoryLayout.scala | 100 +++ ivy/src/main/scala/sbt/ConvertResolver.scala | 33 +- ivy/src/main/scala/sbt/CustomPomParser.scala | 2 + ivy/src/main/scala/sbt/Ivy.scala | 11 +- ivy/src/main/scala/sbt/MakePom.scala | 2 + ivy/src/main/scala/sbt/Resolver.scala | 20 +- ivy/src/main/scala/sbt/UpdateOptions.scala | 18 +- .../scala/sbt/ivyint/SbtChainResolver.scala | 31 +- ivy/src/test/scala/BaseIvySpecification.scala | 29 +- ivy/src/test/scala/MavenResolutionSpec.scala | 291 ++++++++ .../actions/src/main/scala/sbt/CacheIvy.scala | 3 +- notes/0.13.8/aether-resolvers.markdown | 44 ++ project/Dependencies.scala | 37 + project/Util.scala | 1 + .../cache-classifiers/a/build.sbt | 4 +- .../cache-classifiers/b/build.sbt | 2 +- .../configurations/build.sbt | 2 +- .../cross-ivy-maven/build.sbt | 2 + .../dependency-management/mvn-local/build.sbt | 7 +- .../dependency-management/mvn-local/test | 1 + .../dependency-management/pom-advanced/test | 4 +- .../pom-parent-pom/build.sbt | 22 + .../1.0-SNAPSHOT/_maven.repositories | 4 + .../example-child-1.0-SNAPSHOT.jar | Bin 0 -> 1460 bytes .../example-child-1.0-SNAPSHOT.pom | 16 + .../1.0-SNAPSHOT/maven-metadata-local.xml | 24 + .../example-child/maven-metadata-local.xml | 11 + .../1.0-SNAPSHOT/_maven.repositories | 3 + .../example-parent-1.0-SNAPSHOT.pom | 10 + .../1.0-SNAPSHOT/maven-metadata-local.xml | 19 + .../example-parent/maven-metadata-local.xml | 11 + .../dependency-management/pom-parent-pom/test | 2 + .../snapshot-resolution/build.sbt | 1 + .../snapshot-resolution/pending | 35 + .../dependency-management/t468/build.sbt | 3 +- 41 files changed, 2144 insertions(+), 43 deletions(-) create mode 100644 ivy/src/main/scala/org/apache/ivy/plugins/resolver/MavenRepositoryResolver.scala create mode 100644 ivy/src/main/scala/org/apache/ivy/plugins/resolver/MavenRepositorySystemFactory.scala create mode 100644 ivy/src/main/scala/org/apache/maven/repository/internal/SbtArtifactDescriptorReader.java create mode 100644 ivy/src/main/scala/org/apache/maven/repository/internal/SbtExtraProperties.java create mode 100644 ivy/src/main/scala/org/apache/maven/repository/internal/SbtRepositoryLayout.scala create mode 100644 ivy/src/test/scala/MavenResolutionSpec.scala create mode 100644 notes/0.13.8/aether-resolvers.markdown create mode 100644 sbt/src/sbt-test/dependency-management/pom-parent-pom/build.sbt create mode 100644 sbt/src/sbt-test/dependency-management/pom-parent-pom/local-repo/com/example/example-child/1.0-SNAPSHOT/_maven.repositories create mode 100644 sbt/src/sbt-test/dependency-management/pom-parent-pom/local-repo/com/example/example-child/1.0-SNAPSHOT/example-child-1.0-SNAPSHOT.jar create mode 100644 sbt/src/sbt-test/dependency-management/pom-parent-pom/local-repo/com/example/example-child/1.0-SNAPSHOT/example-child-1.0-SNAPSHOT.pom create mode 100644 sbt/src/sbt-test/dependency-management/pom-parent-pom/local-repo/com/example/example-child/1.0-SNAPSHOT/maven-metadata-local.xml create mode 100644 sbt/src/sbt-test/dependency-management/pom-parent-pom/local-repo/com/example/example-child/maven-metadata-local.xml create mode 100644 sbt/src/sbt-test/dependency-management/pom-parent-pom/local-repo/com/example/example-parent/1.0-SNAPSHOT/_maven.repositories create mode 100644 sbt/src/sbt-test/dependency-management/pom-parent-pom/local-repo/com/example/example-parent/1.0-SNAPSHOT/example-parent-1.0-SNAPSHOT.pom create mode 100644 sbt/src/sbt-test/dependency-management/pom-parent-pom/local-repo/com/example/example-parent/1.0-SNAPSHOT/maven-metadata-local.xml create mode 100644 sbt/src/sbt-test/dependency-management/pom-parent-pom/local-repo/com/example/example-parent/maven-metadata-local.xml create mode 100644 sbt/src/sbt-test/dependency-management/pom-parent-pom/test diff --git a/build.sbt b/build.sbt index 06cbf7a66..1faa99e75 100644 --- a/build.sbt +++ b/build.sbt @@ -215,7 +215,7 @@ lazy val ivyProj = (project in file("ivy")). settings(baseSettings: _*). settings( name := "Ivy", - libraryDependencies ++= Seq(ivy, jsch, json4sNative, jawnParser, jawnJson4s), + libraryDependencies ++= Seq(ivy, jsch, json4sNative, jawnParser, jawnJson4s) ++ aetherLibs, testExclusive) // Runner for uniform test interface diff --git a/ivy/src/main/scala/org/apache/ivy/plugins/parser/m2/ReplaceMavenConfigurationMappings.scala b/ivy/src/main/scala/org/apache/ivy/plugins/parser/m2/ReplaceMavenConfigurationMappings.scala index 68a9dad40..0e85d5b6b 100644 --- a/ivy/src/main/scala/org/apache/ivy/plugins/parser/m2/ReplaceMavenConfigurationMappings.scala +++ b/ivy/src/main/scala/org/apache/ivy/plugins/parser/m2/ReplaceMavenConfigurationMappings.scala @@ -26,6 +26,11 @@ import org.apache.ivy.core.module.descriptor.DefaultDependencyDescriptor; */ object ReplaceMavenConfigurationMappings { + def addMappings(dd: DefaultDependencyDescriptor, scope: String, isOptional: Boolean) = { + val mapping = ReplaceMavenConfigurationMappings.REPLACEMENT_MAVEN_MAPPINGS.get(scope) + mapping.addMappingConfs(dd, isOptional) + } + val REPLACEMENT_MAVEN_MAPPINGS = { // Here we copy paste from Ivy val REPLACEMENT_MAPPINGS = new java.util.HashMap[String, PomModuleDescriptorBuilder.ConfMapper] diff --git a/ivy/src/main/scala/org/apache/ivy/plugins/resolver/MavenRepositoryResolver.scala b/ivy/src/main/scala/org/apache/ivy/plugins/resolver/MavenRepositoryResolver.scala new file mode 100644 index 000000000..253830e6e --- /dev/null +++ b/ivy/src/main/scala/org/apache/ivy/plugins/resolver/MavenRepositoryResolver.scala @@ -0,0 +1,656 @@ +package org.apache.ivy.plugins.resolver + +import java.io.{ File, IOException } +import java.text.ParseException +import java.util.Date +import org.apache.ivy.core.IvyContext +import org.apache.ivy.core.module.descriptor._ +import org.apache.ivy.core.module.id.{ ModuleId, ArtifactId, ModuleRevisionId } +import org.apache.ivy.core.report.{ ArtifactDownloadReport, DownloadStatus, MetadataArtifactDownloadReport, DownloadReport } +import org.apache.ivy.core.resolve.{ ResolvedModuleRevision, ResolveData, DownloadOptions } +import org.apache.ivy.core.settings.IvySettings +import org.apache.ivy.plugins.matcher.ExactPatternMatcher +import org.apache.ivy.plugins.parser.m2.{ PomModuleDescriptorBuilder, ReplaceMavenConfigurationMappings } +import org.apache.ivy.plugins.parser.xml.XmlModuleDescriptorWriter +import org.apache.ivy.plugins.resolver.MavenRepositoryResolver.JarPackaging +import org.apache.ivy.plugins.resolver.util.ResolvedResource +import org.apache.ivy.util.Message +import org.apache.maven.repository.internal.{ SbtRepositoryLayout, SbtExtraProperties } +import org.eclipse.aether.{ RepositorySystemSession, RepositorySystem } +import org.eclipse.aether.artifact.{ DefaultArtifact => AetherArtifact } +import org.eclipse.aether.metadata.{ Metadata, DefaultMetadata } +import org.eclipse.aether.resolution.{ + ArtifactDescriptorRequest => AetherDescriptorRequest, + ArtifactDescriptorResult => AetherDescriptorResult, + MetadataRequest => AetherMetadataRequest, + ArtifactRequest => AetherArtifactRequest, + ArtifactResolutionException +} +import org.eclipse.aether.deployment.{ DeployRequest => AetherDeployRequest } +import org.eclipse.aether.installation.{ InstallRequest => AetherInstallRequest } +import org.apache.ivy.core.cache.{ ModuleDescriptorWriter, ArtifactOrigin } +import sbt.{ CustomPomParser, MavenCache, MavenRepository } +import scala.collection.JavaConverters._ + +object MavenRepositoryResolver { + val MAVEN_METADATA_XML = "maven-metadata.xml" + val CLASSIFIER_ATTRIBUTE = "e:classifier" + + val JarPackagings = Set("eclipse-plugin", "hk2-jar", "orbit", "scala-jar", "jar", "bundle") + + object JarPackaging { + def unapply(in: String): Boolean = JarPackagings.contains(in) + } + + // Example: 2014 12 18 09 33 56 + val LAST_UPDATE_FORMAT = new java.text.SimpleDateFormat("yyyyMMddhhmmss") + def parseTimeString(in: String): Option[Long] = + try Some(LAST_UPDATE_FORMAT.parse(in).getTime) + catch { + case _: java.text.ParseException => None + } + + val DEFAULT_ARTIFACT_CONFIGURATION = "master" + +} + +/** + * A resolver instance which can resolve from a REMOTE maven repository. + * + * Note: This creates its *own* local cache directory for cache metadata. using its name. + * + */ +class MavenRemoteRepositoryResolver(val repo: MavenRepository, settings: IvySettings) extends AbstractMavenRepositoryResolver(settings) { + setName(repo.name) + override def toString = s"${repo.name}: ${repo.root}" + protected val system = MavenRepositorySystemFactory.newRepositorySystemImpl + // Note: All maven repository resolvers will use the SAME maven cache. + // We're not sure if we care whether or not this means that the wrong resolver may report finding an artifact. + // The key is not to duplicate files repeatedly across many caches. + private val localRepo = new java.io.File(settings.getDefaultIvyUserDir, s"maven-cache") + sbt.IO.createDirectory(localRepo) + protected val session = MavenRepositorySystemFactory.newSessionImpl(system, localRepo) + private val aetherRepository = { + new org.eclipse.aether.repository.RemoteRepository.Builder(repo.name, SbtRepositoryLayout.LAYOUT_NAME, repo.root).build() + } + // TODO - Check if isUseCacheOnly is used correctly. + private def isUseCacheOnly: Boolean = + Option(IvyContext.getContext).flatMap(x => Option(x.getResolveData)).flatMap(x => Option(x.getOptions)).map(_.isUseCacheOnly).getOrElse(false) + protected def addRepositories(request: AetherDescriptorRequest): AetherDescriptorRequest = + if (isUseCacheOnly) request else request.addRepository(aetherRepository) + protected def addRepositories(request: AetherArtifactRequest): AetherArtifactRequest = + if (isUseCacheOnly) request else request.addRepository(aetherRepository) + /** Actually publishes aether artifacts. */ + protected def publishArtifacts(artifacts: Seq[AetherArtifact]): Unit = { + val request = new AetherDeployRequest() + request.setRepository(aetherRepository) + artifacts foreach request.addArtifact + system.deploy(session, request) + } + protected def getPublicationTime(mrid: ModuleRevisionId): Option[Long] = { + val metadataRequest = new AetherMetadataRequest() + metadataRequest.setMetadata( + new DefaultMetadata( + mrid.getOrganisation, + mrid.getName, + mrid.getRevision, + MavenRepositoryResolver.MAVEN_METADATA_XML, + Metadata.Nature.RELEASE_OR_SNAPSHOT)) + if (!isUseCacheOnly) metadataRequest.setRepository(aetherRepository) + val metadataResultOpt = + try system.resolveMetadata(session, java.util.Arrays.asList(metadataRequest)).asScala.headOption + catch { + case e: org.eclipse.aether.resolution.ArtifactResolutionException => None + } + try metadataResultOpt match { + case Some(md) if md.isResolved => + import org.apache.maven.artifact.repository.metadata.io.xpp3.MetadataXpp3Reader + import org.codehaus.plexus.util.ReaderFactory + val readMetadata = { + val reader = ReaderFactory.newXmlReader(md.getMetadata.getFile) + try new MetadataXpp3Reader().read(reader, false) + finally reader.close() + } + val timestampOpt = + for { + v <- Option(readMetadata.getVersioning) + sp <- Option(v.getSnapshot) + ts <- Option(sp.getTimestamp) + t <- MavenRepositoryResolver.parseTimeString(ts) + } yield t + val lastUpdatedOpt = + for { + v <- Option(readMetadata.getVersioning) + lu <- Option(v.getLastUpdated) + d <- MavenRepositoryResolver.parseTimeString(lu) + } yield d + // TODO - Only look at timestamp *IF* the version is for a snapshot. + timestampOpt orElse lastUpdatedOpt + case _ => None + } + } +} + +/** + * A resolver instance which can resolve from a maven CACHE. + * + * Note: This should never hit somethign remote, as it just looks in the maven cache for things already resolved. + */ +class MavenCacheRepositoryResolver(val repo: MavenCache, settings: IvySettings) extends AbstractMavenRepositoryResolver(settings) { + setName(repo.name) + protected val system = MavenRepositorySystemFactory.newRepositorySystemImpl + sbt.IO.createDirectory(repo.rootFile) + protected val session = MavenRepositorySystemFactory.newSessionImpl(system, repo.rootFile) + protected def setRepository(request: AetherMetadataRequest): AetherMetadataRequest = request + protected def addRepositories(request: AetherDescriptorRequest): AetherDescriptorRequest = request + protected def addRepositories(request: AetherArtifactRequest): AetherArtifactRequest = request + protected def publishArtifacts(artifacts: Seq[AetherArtifact]): Unit = { + val request = new AetherInstallRequest() + artifacts foreach request.addArtifact + system.install(session, request) + } + // TODO - Share this with non-local repository code, since it's MOSTLY the same. + protected def getPublicationTime(mrid: ModuleRevisionId): Option[Long] = { + val metadataRequest = new AetherMetadataRequest() + metadataRequest.setMetadata( + new DefaultMetadata( + mrid.getOrganisation, + mrid.getName, + mrid.getRevision, + MavenRepositoryResolver.MAVEN_METADATA_XML, + Metadata.Nature.RELEASE_OR_SNAPSHOT)) + val metadataResultOpt = + try system.resolveMetadata(session, java.util.Arrays.asList(metadataRequest)).asScala.headOption + catch { + case e: org.eclipse.aether.resolution.ArtifactResolutionException => None + } + try metadataResultOpt match { + case Some(md) if md.isResolved => + import org.apache.maven.artifact.repository.metadata.io.xpp3.MetadataXpp3Reader + import org.codehaus.plexus.util.ReaderFactory + val readMetadata = { + val reader = ReaderFactory.newXmlReader(md.getMetadata.getFile) + try new MetadataXpp3Reader().read(reader, false) + finally reader.close() + } + val timestampOpt = + for { + v <- Option(readMetadata.getVersioning) + sp <- Option(v.getSnapshot) + ts <- Option(sp.getTimestamp) + t <- MavenRepositoryResolver.parseTimeString(ts) + } yield t + val lastUpdatedOpt = + for { + v <- Option(readMetadata.getVersioning) + lu <- Option(v.getLastUpdated) + d <- MavenRepositoryResolver.parseTimeString(lu) + } yield d + // TODO - Only look at timestamp *IF* the version is for a snapshot. + timestampOpt orElse lastUpdatedOpt + case _ => None + } + } + override def toString = s"${repo.name}: ${repo.root}" +} + +/** An exception we can throw if we encounter issues. */ +class MavenResolutionException(msg: String) extends RuntimeException(msg) {} + +abstract class AbstractMavenRepositoryResolver(settings: IvySettings) extends AbstractResolver { + + /** Our instance of the aether repository system. */ + protected val system: RepositorySystem + /** + * Our instance of the aether repository system session. + * + * TODO - We may want to tie this into an IvyContext. + */ + protected val session: RepositorySystemSession + + /** Determine the publication time of a module. The mechanism may differ if the repository is remote vs. local. */ + protected def getPublicationTime(mrid: ModuleRevisionId): Option[Long] + /** Inject necessary repositories into a descriptor request. */ + protected def addRepositories(request: AetherDescriptorRequest): AetherDescriptorRequest + protected def addRepositories(request: AetherArtifactRequest): AetherArtifactRequest + + /** Actually publishes aether artifacts. */ + protected def publishArtifacts(artifacts: Seq[AetherArtifact]): Unit + + // TOOD - deal with packaging here. + private def aetherArtifactIdFromMrid(mrid: ModuleRevisionId): String = + getSbtVersion(mrid) match { + case Some(sbt) => s"${mrid.getName}_sbt_$sbt" + case None => mrid.getName + } + private def aetherCoordsFromMrid(mrid: ModuleRevisionId): String = + s"${mrid.getOrganisation}:${aetherArtifactIdFromMrid(mrid)}:${mrid.getRevision}" + + private def aetherCoordsFromMrid(mrid: ModuleRevisionId, packaging: String): String = + s"${mrid.getOrganisation}:${aetherArtifactIdFromMrid(mrid)}:$packaging:${mrid.getRevision}" + + private def aetherCoordsFromMrid(mrid: ModuleRevisionId, packaging: String, extension: String): String = + s"${mrid.getOrganisation}:${aetherArtifactIdFromMrid(mrid)}:$extension:$packaging:${mrid.getRevision}" + + // Handles appending licenses to the module descriptor fromthe pom. + private def addLicenseInfo(md: DefaultModuleDescriptor, map: java.util.Map[String, AnyRef]) = { + val count = map.get(SbtExtraProperties.LICENSE_COUNT_KEY) match { + case null => 0 + case x: java.lang.Integer => x.intValue + case x: String => x.toInt + case _ => 0 + } + for { + i <- 0 until count + name <- Option(map.get(SbtExtraProperties.makeLicenseName(i))).map(_.toString) + url <- Option(map.get(SbtExtraProperties.makeLicenseUrl(i))).map(_.toString) + } md.addLicense(new License(name, url)) + } + + // This grabs the dependency for Ivy. + override def getDependency(dd: DependencyDescriptor, rd: ResolveData): ResolvedModuleRevision = { + val context = IvyContext.pushNewCopyContext + try { + // TODO - Check to see if we're asking for latest.* version, and if so, we should run a latest version query + // first and use that result to return the metadata/final module. + Message.debug(s"Requesting conf [${dd.getModuleConfigurations.mkString(",")}] from Aether module ${dd.getDependencyRevisionId} in resolver ${getName}") + val request = new AetherDescriptorRequest() + val coords = aetherCoordsFromMrid(dd.getDependencyRevisionId) + Message.debug(s"Aether about to resolve [$coords]...") + request.setArtifact(new AetherArtifact(coords, getArtifactProperties(dd.getDependencyRevisionId))) + addRepositories(request) + val result = system.readArtifactDescriptor(session, request) + val packaging = getPackagingFromPomProperties(result.getProperties) + Message.debug(s"Aether resolved ${dd.getDependencyId} w/ packaging ${packaging}") + + // TODO - better pub date if we have no metadata. + val lastModifiedTime = getPublicationTime(dd.getDependencyRevisionId) getOrElse 0L + + // Construct a new Ivy module descriptor + val desc: ModuleDescriptor = { + // TODO - Better detection of snapshot and handling latest.integration/latest.snapshot + val status = + if (dd.getDependencyRevisionId.getRevision.endsWith("-SNAPSHOT")) "integration" + else "release" + val md = + new DefaultModuleDescriptor(dd.getDependencyRevisionId, status, null /* pubDate */ , false) + //DefaultModuleDescriptor.newDefaultInstance(dd.getDependencyRevisionId) + // Here we add the standard configurations + for (config <- PomModuleDescriptorBuilder.MAVEN2_CONFIGURATIONS) { + md.addConfiguration(config) + } + + // Here we look into the artifacts specified from the dependency descriptor *and* those that are defaulted, + // and append them to the appropriate configurations. + addArtifactsFromPom(dd, packaging, md, lastModifiedTime) + // Here we add dependencies. + addDependenciesFromAether(result, md) + // Here we use pom.xml Dependency management section to create Ivy dependency mediators. + addManagedDependenciesFromAether(result, md) + // TODO - Add excludes? + + // Here we rip out license info. + addLicenseInfo(md, result.getProperties) + md.addExtraInfo(SbtExtraProperties.MAVEN_PACKAGING_KEY, packaging) + Message.debug(s"Setting publication date to ${new Date(lastModifiedTime)}") + // TODO - Figure out the differences between these items. + md.setPublicationDate(new Date(lastModifiedTime)) + md.setLastModified(lastModifiedTime) + md.setResolvedPublicationDate(new Date(lastModifiedTime)) + md.check() + // TODO - do we need the toSystem? + toSystem(md) + } + + // Here we need to pretend we downloaded the pom.xml file + val pom = DefaultArtifact.newPomArtifact(dd.getDependencyRevisionId, new java.util.Date(lastModifiedTime)) + val madr = new MetadataArtifactDownloadReport(pom) + madr.setSearched(true) + madr.setDownloadStatus(DownloadStatus.SUCCESSFUL) // TODO - Figure this things out for this report. + val rmr = new ResolvedModuleRevision(this, this, desc, madr, false /* Force */ ) + + // TODO - Here we cache the transformed pom.xml into an ivy.xml in the cache because ChainResolver will be looking at it. + // This doesn't appear to really work correctly. + // However, I think the chain resolver doesn't use this instance anyway. Ideally we don't put anything + // in the ivy cache, but this should be "ok". + getRepositoryCacheManager.originalToCachedModuleDescriptor(this, + null /* ivyRef. Just passed back to us. */ , + pom, + rmr, + new ModuleDescriptorWriter() { + def write(originalMdResource: ResolvedResource, md: ModuleDescriptor, src: File, dest: File): Unit = { + // a basic ivy file is written containing default data + XmlModuleDescriptorWriter.write(md, dest); + } + } + ) + rmr + } catch { + case e: org.eclipse.aether.resolution.ArtifactDescriptorException => + Message.warn(s"Failed to read descriptor ${dd} from ${getName}, ${e.getMessage}") + e.printStackTrace(System.err) + rd.getCurrentResolvedModuleRevision + case e: MavenResolutionException => + Message.debug(s"Resolution Exception from ${getName}, ${e.getMessage}, returning: ${rd.getCurrentResolvedModuleRevision}") + rd.getCurrentResolvedModuleRevision + } finally IvyContext.popContext() + } + + def getSbtVersion(dd: ModuleRevisionId): Option[String] = + Option(dd.getExtraAttribute(CustomPomParser.SbtVersionKey)) + + def getArtifactProperties(dd: ModuleRevisionId): java.util.Map[String, String] = { + val m = new java.util.HashMap[String, String] + Option(dd.getExtraAttribute(CustomPomParser.ScalaVersionKey)) foreach { sv => + m.put(SbtExtraProperties.POM_SCALA_VERSION, sv) + } + getSbtVersion(dd) foreach { sv => + m.put(SbtExtraProperties.POM_SBT_VERSION, sv) + } + m + } + + final def checkJarArtifactExists(dd: DependencyDescriptor): Boolean = { + // TODO - We really want this to be as fast/efficient as possible! + val request = new AetherArtifactRequest() + val art = new AetherArtifact( + aetherCoordsFromMrid(dd.getDependencyRevisionId, "jar"), + getArtifactProperties(dd.getDependencyRevisionId)) + request.setArtifact(art) + addRepositories(request) + try { + val result = system.resolveArtifact(session, request) + result.isResolved && !result.isMissing + } catch { + case e: ArtifactResolutionException => + // Ignore, as we're just working around issues with pom.xml's with no jars or POM packaging + Message.debug(s"Could not find $art in ${getName}") + false + } + } + + /** Determines which artifacts are associated with this maven module and appends them to the descriptor. */ + def addArtifactsFromPom(dd: DependencyDescriptor, packaging: String, md: DefaultModuleDescriptor, lastModifiedTime: Long): Unit = { + Message.debug(s"Calculating artifacts for ${dd.getDependencyId} w/ packaging $packaging") + // Here we add in additional artifact requests, which ALLWAYS have to be explicit since + // Maven/Aether doesn't include all known artifacts in a pom.xml + // TODO - This does not appear to be working correctly. + if (dd.getAllDependencyArtifacts.isEmpty) { + val artifactId = s"${dd.getDependencyId.getName}-${dd.getDependencyRevisionId.getRevision}" + // Add the artifacts we know about the module + packaging match { + case "pom" => + // THere we have to attempt to download the JAR and see if it comes, if not, we can punt. + // This is because sometimes pom-packaging attaches a JAR. + if (checkJarArtifactExists(dd)) { + val defaultArt = + new DefaultArtifact(md.getModuleRevisionId, new Date(lastModifiedTime), artifactId, packaging, "jar") + md.addArtifact(MavenRepositoryResolver.DEFAULT_ARTIFACT_CONFIGURATION, defaultArt) + } + case JarPackaging() => + // Here we fail the resolution. This is an issue when pom.xml files exist with no JAR, which happens + // on maven central for some reason on old artifacts. + if (!checkJarArtifactExists(dd)) + throw new MavenResolutionException(s"Failed to find JAR file associated with $dd") + // Assume for now everything else is a jar. + val defaultArt = + new DefaultArtifact(md.getModuleRevisionId, new Date(lastModifiedTime), artifactId, packaging, "jar") + // TODO - Unfortunately we have to try to download the JAR file HERE and then fail resolution if we cannot find it. + // This is because sometime a pom.xml exists with no JARs. + md.addArtifact(MavenRepositoryResolver.DEFAULT_ARTIFACT_CONFIGURATION, defaultArt) + case _ => // Ignore, we have no idea what this artifact is. + Message.warn(s"Not adding artifacts for resolution because we don't understand packaging: $packaging") + } + + } else { + // NOTE: this means that someone is requested specific artifacts from us. What we need to do is *only* download the + // requested artifacts rather than the default "jar". What's odd, is that pretty much this almost ALWAYS happens. + // but in some circumstances, the above logic is checked. + // Additionally, we may want to somehow merge the "defined" artifacts from maven with the requested ones here, rather + // than having completely separate logic. For now, this appears to work the same way it was before. + // Since we aren't accurately guessing what maven files are meant to be included as artifacts ANYWAY, this + // is probably the right way to go. + for (requestedArt <- dd.getAllDependencyArtifacts) { + getClassifier(requestedArt) match { + case None => + // This is the default artifact. We do need to add this, and to the default configuration. + val defaultArt = + new DefaultArtifact(md.getModuleRevisionId, new Date(lastModifiedTime), requestedArt.getName, requestedArt.getType, requestedArt.getExt) + md.addArtifact(MavenRepositoryResolver.DEFAULT_ARTIFACT_CONFIGURATION, defaultArt) + case Some(scope) => + Message.debug(s"Adding additional artifact in $scope, $requestedArt") + // TODO - more Extra attributes? + val mda = + new MDArtifact( + md, + requestedArt.getName, + requestedArt.getType, + requestedArt.getExt, + requestedArt.getUrl, + requestedArt.getExtraAttributes) + md.addArtifact(getConfiguration(scope), mda) + } + } + } + } + + /** Adds the dependency mediators required based on the managed dependency instances from this pom. */ + def addManagedDependenciesFromAether(result: AetherDescriptorResult, md: DefaultModuleDescriptor) { + for (d <- result.getManagedDependencies.asScala) { + + if (d.getArtifact.getArtifactId == "stringtemplate") { + Message.warn(s"Found managed stringtemplate in $md !") + } + + md.addDependencyDescriptorMediator( + ModuleId.newInstance(d.getArtifact.getGroupId, d.getArtifact.getArtifactId), + ExactPatternMatcher.INSTANCE, + new OverrideDependencyDescriptorMediator(null, d.getArtifact.getVersion) { + override def mediate(dd: DependencyDescriptor): DependencyDescriptor = { + super.mediate(dd) + } + }) + + } + } + + /** Adds the list of dependencies this artifact has on other artifacts. */ + def addDependenciesFromAether(result: AetherDescriptorResult, md: DefaultModuleDescriptor) { + for (d <- result.getDependencies.asScala) { + // TODO - Is this correct for changing detection. We should use the Ivy mechanism configured... + val isChanging = d.getArtifact.getVersion.endsWith("-SNAPSHOT") + val drid = ModuleRevisionId.newInstance(d.getArtifact.getGroupId, d.getArtifact.getArtifactId, d.getArtifact.getVersion) + // Note: The previous maven integration ALWAYS set force to true for dependnecies. If we do not do this, for some + // reason, Ivy will create dummy nodes when doing dependnecy mediation (e.g. dependencyManagement of one pom overrides version of a dependency) + // which was leading to "data not found" exceptions as Ivy would pick the correct IvyNode in the dependency tree but never load it with data.... + val dd = new DefaultDependencyDescriptor(md, drid, /* force */ true, isChanging, true) {} + + // TODO - Configuration mappings (are we grabbing scope correctly, or should the default not always be compile?) + val scope = Option(d.getScope).filterNot(_.isEmpty).getOrElse("compile") + val mapping = ReplaceMavenConfigurationMappings.addMappings(dd, scope, d.isOptional) + // TODO - include rules and exclude rules. + Message.debug(s"Adding maven transitive dependency ${md.getModuleRevisionId} -> ${dd}") + // TODO - Unify this borrowed Java code into something a bit friendlier. + // Now we add the artifact.... + if ((d.getArtifact.getClassifier != null) || ((d.getArtifact.getExtension != null) && !("jar" == d.getArtifact.getExtension))) { + val tpe: String = + if (d.getArtifact.getExtension != null) d.getArtifact.getExtension + else "jar" + val ext: String = tpe match { + case "test-jar" => "jar" + case JarPackaging() => "jar" + case other => other + } + // Here we add the classifier, hopefully correctly... + val extraAtt = new java.util.HashMap[String, AnyRef]() + if (d.getArtifact.getClassifier != null) { + extraAtt.put("m:classifier", d.getArtifact.getClassifier) + } + val depArtifact: DefaultDependencyArtifactDescriptor = + new DefaultDependencyArtifactDescriptor(dd, dd.getDependencyId.getName, tpe, ext, null, extraAtt) + val optionalizedScope: String = if (d.isOptional) "optional" else scope + // TOOD - We may need to fix the configuration mappings here. + dd.addDependencyArtifact(optionalizedScope, depArtifact) + } + // TODO - is toSystem call correct? + md.addDependency(dd) + + if (d.getArtifact.getArtifactId == "stringtemplate") { + Message.warn(s"Found stringtemplate dependency! $dd") + } + } + } + + // This method appears to be deprecated/unused in all of Ivy so we do not implement it. + override def findIvyFileRef(dd: DependencyDescriptor, rd: ResolveData): ResolvedResource = { + Message.error(s"Looking for ivy file ref, method not implemented! MavenRepositoryResolver($getName) will always return null.") + null + } + + private def getPackagingFromPomProperties(props: java.util.Map[String, AnyRef]): String = + if (props.containsKey(SbtExtraProperties.MAVEN_PACKAGING_KEY)) + props.get(SbtExtraProperties.MAVEN_PACKAGING_KEY).toString + else "jar" + + override def download(artifacts: Array[Artifact], dopts: DownloadOptions): DownloadReport = { + // TODO - Status reports on download and possibly parallel downloads + val report = new DownloadReport + val requests = + for (a <- artifacts) yield { + val request = new AetherArtifactRequest + val aetherArt = + getClassifier(a) match { + case None | Some("") => + new AetherArtifact( + aetherCoordsFromMrid(a.getModuleRevisionId), + getArtifactProperties(a.getModuleRevisionId)) + case Some(other) => new AetherArtifact( + aetherCoordsFromMrid(a.getModuleRevisionId, other, a.getExt), + getArtifactProperties(a.getModuleRevisionId)) + } + Message.debug(s"Requesting download of [$aetherArt]") + request.setArtifact(aetherArt) + addRepositories(request) + request + } + val (aetherResults, failed) = + try { + (system.resolveArtifacts(session, requests.toList.asJava).asScala, false) + } catch { + case e: org.eclipse.aether.resolution.ArtifactResolutionException => + Message.error(s"Failed to resolve artifacts from ${getName}, ${e.getMessage}") + (e.getResults.asScala, true) + } + for ((result, art) <- aetherResults zip artifacts) { + Message.debug(s"Aether resolved artifact result: $result") + val adr = new ArtifactDownloadReport(art) + adr.setDownloadDetails(result.toString) + // TODO - Fill this out with a real estimate on time... + adr.setDownloadTimeMillis(0L) + // TODO - what is artifact origin actuallyused for? + adr.setArtifactOrigin(new ArtifactOrigin( + art, + true, + getName)) + if (result.isMissing) { + adr.setDownloadStatus(DownloadStatus.FAILED) + adr.setDownloadDetails(ArtifactDownloadReport.MISSING_ARTIFACT) + } else if (!result.isResolved) { + adr.setDownloadStatus(DownloadStatus.FAILED) + adr.setDownloadDetails(result.toString) + // TODO - we should set download status to NO in the event we don't care about an artifact... + } else { + val file = result.getArtifact.getFile + Message.debug(s"Succesffully downloaded: $file") + adr.setLocalFile(file) + adr.setSize(file.length) + adr.setDownloadStatus(DownloadStatus.SUCCESSFUL) + } + report.addArtifactReport(adr) + } + report + } + + case class PublishTransaction(module: ModuleRevisionId, artifacts: Seq[(Artifact, File)]) + private var currentTransaction: Option[PublishTransaction] = None + + override def beginPublishTransaction(module: ModuleRevisionId, overwrite: Boolean): Unit = { + currentTransaction match { + case Some(t) => throw new IllegalStateException(s"Publish Transaction already open for [$getName]") + case None => currentTransaction = Some(PublishTransaction(module, Nil)) + } + } + override def abortPublishTransaction(): Unit = { + currentTransaction = None + } + + def getClassifier(art: Artifact): Option[String] = + // TODO - Do we need to look anywere else? + Option(art.getExtraAttribute("classifier")) + + def getClassifier(art: org.apache.ivy.core.module.descriptor.DependencyArtifactDescriptor): Option[String] = + art.getType match { + case "doc" | "javadoc" => Some("javadoc") + case "src" | "source" => Some("sources") + case "test-jar" | "test" => Some("tests") + case _ => + // Look for extra attributes + art.getExtraAttribute(MavenRepositoryResolver.CLASSIFIER_ATTRIBUTE) match { + case null => None + case c => Some(c) + } + } + + def getConfiguration(classifier: String): String = + classifier match { + // TODO - choice of configuration actually depends on whether or not the artifact is + // REQUESTED by the user, in which case it should be on master. + // Currently, we don't actually look for sources/javadoc/test artifacts at all, + // which means any artifact is in the master configuration, but we should + // fix this for better integration into the maven ecosystem from ivy. + //case "sources" => "sources" + //case "javadoc" => "javadoc" + case other => MavenRepositoryResolver.DEFAULT_ARTIFACT_CONFIGURATION + } + + override def commitPublishTransaction(): Unit = { + // TODO - actually send all artifacts to aether + currentTransaction match { + case Some(t) => + Message.debug(s"Publishing module ${t.module}, with artifact count = ${t.artifacts.size}") + val artifacts = + for ((art, file) <- t.artifacts) yield { + Message.debug(s" - Publishing $art (${art.getType})(${art.getExtraAttribute("classifier")}) in [${art.getConfigurations.mkString(",")}] from $file") + new AetherArtifact( + t.module.getOrganisation, + aetherArtifactIdFromMrid(t.module), + getClassifier(art).orNull, + art.getExt, + t.module.getRevision, + getArtifactProperties(t.module), + file + ) + } + publishArtifacts(artifacts) + // TODO - Any kind of validity checking? + currentTransaction = None + case None => throw new IllegalStateException(s"Publish Transaction already open for [$getName]") + } + } + + override def publish(art: Artifact, file: File, overwrite: Boolean): Unit = { + currentTransaction match { + case Some(t) => + val allArts = t.artifacts ++ List(art -> file) + currentTransaction = Some(t.copy(artifacts = allArts)) + case None => + throw new IllegalStateException(("MavenRepositories require transactional publish")) + } + } + + override def equals(a: Any): Boolean = + a match { + case x: AbstractMavenRepositoryResolver => x.getName == getName + case _ => false + } +} diff --git a/ivy/src/main/scala/org/apache/ivy/plugins/resolver/MavenRepositorySystemFactory.scala b/ivy/src/main/scala/org/apache/ivy/plugins/resolver/MavenRepositorySystemFactory.scala new file mode 100644 index 000000000..367143a57 --- /dev/null +++ b/ivy/src/main/scala/org/apache/ivy/plugins/resolver/MavenRepositorySystemFactory.scala @@ -0,0 +1,140 @@ +package org.apache.ivy.plugins.resolver + +import java.net.URI + +import org.apache.ivy.plugins.repository.Resource +import org.apache.ivy.plugins.repository.url.URLResource +import org.apache.ivy.util.Message +import org.apache.ivy.util.url.URLHandlerRegistry +import org.eclipse.aether.artifact.Artifact +import org.eclipse.aether.impl.{ MetadataGeneratorFactory, ArtifactDescriptorReader, RepositoryConnectorProvider, DefaultServiceLocator } +import org.eclipse.aether.metadata.Metadata +import org.eclipse.aether.spi.connector.RepositoryConnectorFactory +import org.eclipse.aether.spi.connector.layout.{ RepositoryLayoutFactory, RepositoryLayoutProvider, RepositoryLayout } +import org.eclipse.aether.spi.connector.layout.RepositoryLayout.Checksum +import org.eclipse.aether.{ + RepositorySystem, + RepositorySystemSession +} + +import org.eclipse.aether.repository.{ RemoteRepository, LocalRepository } +import org.eclipse.aether.RepositorySystemSession +import org.apache.maven.repository.internal._ +import org.eclipse.aether.spi.connector.transport._ +import org.eclipse.aether.connector.basic.BasicRepositoryConnectorFactory +import java.io.File + +/** Helper methods for dealing with starting up Aether. */ +object MavenRepositorySystemFactory { + def newRepositorySystemImpl: RepositorySystem = { + // For now we just log Aether instantiation issues. These should probably cause fatal errors. + val locator = MavenRepositorySystemUtils.newServiceLocator() + locator.setErrorHandler(new DefaultServiceLocator.ErrorHandler { + override def serviceCreationFailed(tpe: Class[_], impl: Class[_], exception: Throwable): Unit = { + Message.error(s"Failed to create $tpe, of class $impl") + } + }) + // Here we register the Ivy <-> Aether transport bridge + locator.addService(classOf[TransporterFactory], classOf[MyTransportFactory]) + // This connects the download mechanism to our transports. Why is it needed? no clue. + locator.addService(classOf[RepositoryConnectorFactory], classOf[BasicRepositoryConnectorFactory]) + + // Plugins cause issues here, as their layout is super odd. Here we inject a new plugin layout + locator.addService(classOf[RepositoryLayoutFactory], classOf[SbtPluginLayoutFactory]) + + // Here we add the metadata services so aether will automatically add maven-metadata.xml files. + locator.addService(classOf[MetadataGeneratorFactory], classOf[SnapshotMetadataGeneratorFactory]) + locator.addService(classOf[MetadataGeneratorFactory], classOf[VersionsMetadataGeneratorFactory]) + + // Add our hook for parsing pom.xml files. + locator.setService(classOf[ArtifactDescriptorReader], classOf[SbtArtifactDescriptorReader]) + // Finally, use the DI to create our repository system. + locator.getService(classOf[RepositorySystem]) + } + def newSessionImpl(system: RepositorySystem, localRepoDir: File): RepositorySystemSession = { + val session = MavenRepositorySystemUtils.newSession() + val localRepo = new LocalRepository(localRepoDir) + session setLocalRepositoryManager (system.newLocalRepositoryManager(session, localRepo)) + // Here we set a descriptor policy that FORCES the pom.xml to exist, otherwise Ivy's resolution + // algorithm freaks out. What we could do is also do the ivy lame-thing of checking for a JAR + // instead of a pom.xml, but let's see if this is actually a problem in practice. + val descriptorPolicy = new org.eclipse.aether.util.repository.SimpleArtifactDescriptorPolicy( + /* ignoreMissing */ false, /* ignoreInvalid. */ true) + session.setArtifactDescriptorPolicy(descriptorPolicy) + session + } + + def defaultLocalRepo: java.io.File = { + new java.io.File(s"${sys.props("user.home")}/.m2/repository") + } +} +/** Override aether's default transport with Ivy-ones. */ +class MyTransportFactory extends TransporterFactory { + override def newInstance(session: RepositorySystemSession, repository: RemoteRepository): Transporter = + repository.getProtocol match { + case "http" | "https" => new HttpTransport(repository) + case "file" => new FileTransport(repository) + case other => throw new IllegalArgumentException(s"Unsupported transport protocol: $other") + } + override def getPriority: Float = 1.0f +} + +/** Aether Http <-> Ivy Http adapter. Aether's is better, but Ivy's has configuration hooks in sbt. */ +class HttpTransport(repository: RemoteRepository) extends AbstractTransporter { + class NotFoundException(msg: String) extends Exception(msg) + private def toURL(task: TransportTask): java.net.URL = + try new java.net.URL(s"${repository.getUrl}/${task.getLocation.toASCIIString}") + catch { + case e: IllegalArgumentException => throw new IllegalArgumentException(s" URL (${task.getLocation}) is not absolute.") + } + private def toResource(task: TransportTask): Resource = new URLResource(toURL(task)) + override def implPeek(peek: PeekTask): Unit = { + if (!toResource(peek).exists()) throw new NotFoundException(s"Could not find ${peek.getLocation}") + } + override def implClose(): Unit = () + override def implGet(out: GetTask): Unit = { + if (!toResource(out).exists()) throw new NotFoundException(s"Could not find ${out.getLocation}") + URLHandlerRegistry.getDefault.download(toURL(out), out.getDataFile, null) + } + override def implPut(put: PutTask): Unit = { + URLHandlerRegistry.getDefault.upload(put.getDataFile, toURL(put), null) + } + override def classify(err: Throwable): Int = + err match { + // TODO - Implement + case _: NotFoundException => Transporter.ERROR_NOT_FOUND + case _ => Transporter.ERROR_OTHER + } +} + +class FileTransport(repository: RemoteRepository) extends AbstractTransporter { + class NotFoundException(msg: String) extends Exception(msg) + private def toURL(task: TransportTask): java.net.URL = + try new java.net.URL(s"${repository.getUrl}/${task.getLocation.toASCIIString}") + catch { + case e: IllegalArgumentException => throw new IllegalArgumentException(s" URL (${task.getLocation}) is not absolute.") + } + private def toResource(task: TransportTask): Resource = new URLResource(toURL(task)) + private def toFile(task: TransportTask): java.io.File = + new java.io.File(toURL(task).toURI) + override def implPeek(peek: PeekTask): Unit = { + if (!toFile(peek).exists()) throw new NotFoundException(s"Could not find ${peek.getLocation}") + } + override def implClose(): Unit = () + override def implGet(out: GetTask): Unit = { + val from = toFile(out) + if (!from.exists()) throw new NotFoundException(s"Could not find ${out.getLocation}") + sbt.IO.copyFile(from, out.getDataFile, true) + } + override def implPut(put: PutTask): Unit = { + val to = toFile(put) + val from = put.getDataFile + sbt.IO.copyFile(from, to, true) + } + override def classify(err: Throwable): Int = + err match { + // TODO - Implement + case _: NotFoundException => Transporter.ERROR_NOT_FOUND + case _ => Transporter.ERROR_OTHER + } +} \ No newline at end of file diff --git a/ivy/src/main/scala/org/apache/maven/repository/internal/SbtArtifactDescriptorReader.java b/ivy/src/main/scala/org/apache/maven/repository/internal/SbtArtifactDescriptorReader.java new file mode 100644 index 000000000..316cee911 --- /dev/null +++ b/ivy/src/main/scala/org/apache/maven/repository/internal/SbtArtifactDescriptorReader.java @@ -0,0 +1,556 @@ +package org.apache.maven.repository.internal; + +/* + * 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. + */ + +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashMap; +import java.util.LinkedHashMap; +import java.util.LinkedHashSet; +import java.util.List; +import java.util.Map; +import java.util.Properties; +import java.util.Set; + +import javax.inject.Inject; +import javax.inject.Named; + +import org.apache.maven.model.DependencyManagement; +import org.apache.maven.model.DistributionManagement; +import org.apache.maven.model.License; +import org.apache.maven.model.Model; +import org.apache.maven.model.Prerequisites; +import org.apache.maven.model.Relocation; +import org.apache.maven.model.Repository; +import org.apache.maven.model.building.DefaultModelBuilderFactory; +import org.apache.maven.model.building.DefaultModelBuildingRequest; +import org.apache.maven.model.building.FileModelSource; +import org.apache.maven.model.building.ModelBuilder; +import org.apache.maven.model.building.ModelBuildingException; +import org.apache.maven.model.building.ModelBuildingRequest; +import org.apache.maven.model.building.ModelProblem; +import org.apache.maven.model.resolution.UnresolvableModelException; +import org.codehaus.plexus.component.annotations.Component; +import org.codehaus.plexus.component.annotations.Requirement; +import org.eclipse.aether.RepositoryException; +import org.eclipse.aether.RepositoryEvent.EventType; +import org.eclipse.aether.RepositoryEvent; +import org.eclipse.aether.RepositorySystemSession; +import org.eclipse.aether.RequestTrace; +import org.eclipse.aether.artifact.Artifact; +import org.eclipse.aether.artifact.ArtifactProperties; +import org.eclipse.aether.artifact.ArtifactType; +import org.eclipse.aether.artifact.ArtifactTypeRegistry; +import org.eclipse.aether.artifact.DefaultArtifact; +import org.eclipse.aether.artifact.DefaultArtifactType; +import org.eclipse.aether.graph.Dependency; +import org.eclipse.aether.graph.Exclusion; +import org.eclipse.aether.impl.*; +import org.eclipse.aether.repository.WorkspaceRepository; +import org.eclipse.aether.resolution.ArtifactDescriptorException; +import org.eclipse.aether.resolution.ArtifactDescriptorPolicy; +import org.eclipse.aether.resolution.ArtifactDescriptorPolicyRequest; +import org.eclipse.aether.resolution.ArtifactDescriptorRequest; +import org.eclipse.aether.resolution.ArtifactDescriptorResult; +import org.eclipse.aether.resolution.ArtifactRequest; +import org.eclipse.aether.resolution.ArtifactResolutionException; +import org.eclipse.aether.resolution.ArtifactResult; +import org.eclipse.aether.resolution.VersionRequest; +import org.eclipse.aether.resolution.VersionResolutionException; +import org.eclipse.aether.resolution.VersionResult; +import org.eclipse.aether.spi.locator.Service; +import org.eclipse.aether.spi.locator.ServiceLocator; +import org.eclipse.aether.spi.log.Logger; +import org.eclipse.aether.spi.log.LoggerFactory; +import org.eclipse.aether.spi.log.NullLoggerFactory; +import org.eclipse.aether.transfer.ArtifactNotFoundException; + +/** + * A hacked version of maven's default artifact descriptor reader which we use in place of the standard aether adapter. + * + * This adds the following to the parsing of maven files: + * + * Additonal properties: + * + * - `sbt.pom.packaging` - The pom.packaging value. + * + * + * @author Benjamin Bentmann + * @author Josh Suereth - Adapted for sbt + */ +@Named +@Component( role = ArtifactDescriptorReader.class ) +public class SbtArtifactDescriptorReader + implements ArtifactDescriptorReader, Service +{ + + @SuppressWarnings( "unused" ) + @Requirement( role = LoggerFactory.class ) + private Logger logger = NullLoggerFactory.LOGGER; + + @Requirement + private RemoteRepositoryManager remoteRepositoryManager; + + @Requirement + private VersionResolver versionResolver; + + @Requirement + private VersionRangeResolver versionRangeResolver; + + @Requirement + private ArtifactResolver artifactResolver; + + @Requirement + private RepositoryEventDispatcher repositoryEventDispatcher; + + @Requirement + private ModelBuilder modelBuilder; + + public SbtArtifactDescriptorReader() + { + // enable no-arg constructor + } + + @Inject + SbtArtifactDescriptorReader( RemoteRepositoryManager remoteRepositoryManager, VersionResolver versionResolver, + ArtifactResolver artifactResolver, ModelBuilder modelBuilder, + RepositoryEventDispatcher repositoryEventDispatcher, LoggerFactory loggerFactory ) + { + setRemoteRepositoryManager( remoteRepositoryManager ); + setVersionResolver( versionResolver ); + setArtifactResolver( artifactResolver ); + setModelBuilder( modelBuilder ); + setLoggerFactory( loggerFactory ); + setRepositoryEventDispatcher( repositoryEventDispatcher ); + } + + public void initService( ServiceLocator locator ) + { + setLoggerFactory(locator.getService(LoggerFactory.class)); + setRemoteRepositoryManager(locator.getService(RemoteRepositoryManager.class)); + setVersionResolver(locator.getService(VersionResolver.class)); + setArtifactResolver(locator.getService(ArtifactResolver.class)); + setRepositoryEventDispatcher(locator.getService(RepositoryEventDispatcher.class)); + setVersionRangeResolver(locator.getService(VersionRangeResolver.class)); + modelBuilder = locator.getService( ModelBuilder.class ); + if ( modelBuilder == null ) + { + setModelBuilder( new DefaultModelBuilderFactory().newInstance() ); + } + } + + public SbtArtifactDescriptorReader setLoggerFactory( LoggerFactory loggerFactory ) + { + this.logger = NullLoggerFactory.getSafeLogger( loggerFactory, getClass() ); + return this; + } + + void setLogger( LoggerFactory loggerFactory ) + { + // plexus support + setLoggerFactory( loggerFactory ); + } + + public SbtArtifactDescriptorReader setRemoteRepositoryManager( RemoteRepositoryManager remoteRepositoryManager ) + { + if ( remoteRepositoryManager == null ) + { + throw new IllegalArgumentException( "remote repository manager has not been specified" ); + } + this.remoteRepositoryManager = remoteRepositoryManager; + return this; + } + + public SbtArtifactDescriptorReader setVersionResolver( VersionResolver versionResolver ) + { + if ( versionResolver == null ) + { + throw new IllegalArgumentException( "version resolver has not been specified" ); + } + this.versionResolver = versionResolver; + return this; + } + + public SbtArtifactDescriptorReader setArtifactResolver( ArtifactResolver artifactResolver ) + { + if ( artifactResolver == null ) + { + throw new IllegalArgumentException( "artifact resolver has not been specified" ); + } + this.artifactResolver = artifactResolver; + return this; + } + + public SbtArtifactDescriptorReader setRepositoryEventDispatcher( RepositoryEventDispatcher repositoryEventDispatcher ) + { + if ( repositoryEventDispatcher == null ) + { + throw new IllegalArgumentException( "repository event dispatcher has not been specified" ); + } + this.repositoryEventDispatcher = repositoryEventDispatcher; + return this; + } + + public SbtArtifactDescriptorReader setModelBuilder( ModelBuilder modelBuilder ) + { + if ( modelBuilder == null ) + { + throw new IllegalArgumentException( "model builder has not been specified" ); + } + this.modelBuilder = modelBuilder; + return this; + } + + public ArtifactDescriptorResult readArtifactDescriptor( RepositorySystemSession session, + ArtifactDescriptorRequest request ) + throws ArtifactDescriptorException + { + ArtifactDescriptorResult result = new ArtifactDescriptorResult( request ); + + Model model = loadPom( session, request, result ); + + if ( model != null ) + { + ArtifactTypeRegistry stereotypes = session.getArtifactTypeRegistry(); + + for ( Repository r : model.getRepositories() ) + { + result.addRepository( ArtifactDescriptorUtils.toRemoteRepository( r ) ); + } + + for ( org.apache.maven.model.Dependency dependency : model.getDependencies() ) + { + result.addDependency( convert( dependency, stereotypes ) ); + } + + DependencyManagement mngt = model.getDependencyManagement(); + if ( mngt != null ) + { + for ( org.apache.maven.model.Dependency dependency : mngt.getDependencies() ) + { + result.addManagedDependency( convert( dependency, stereotypes ) ); + } + } + + Map properties = new LinkedHashMap(); + + Prerequisites prerequisites = model.getPrerequisites(); + if ( prerequisites != null ) + { + properties.put( "prerequisites.maven", prerequisites.getMaven() ); + } + + List licenses = model.getLicenses(); + properties.put( SbtExtraProperties.LICENSE_COUNT_KEY, licenses.size() ); + for ( int i = 0; i < licenses.size(); i++ ) + { + License license = licenses.get( i ); + properties.put( SbtExtraProperties.makeLicenseName(i), license.getName() ); + properties.put( SbtExtraProperties.makeLicenseUrl(i), license.getUrl() ); + properties.put( "license." + i + ".comments", license.getComments() ); + properties.put( "license." + i + ".distribution", license.getDistribution() ); + } + + // SBT ADDED - Here we push in the pom packaging type for Ivy expectations. + final String packaging = + (model.getPackaging() == null) ? "jar" : model.getPackaging(); + properties.put(SbtExtraProperties.MAVEN_PACKAGING_KEY, packaging); + // SBT ADDED - Here we inject the sbt/scala version we parse out of the pom. + final Properties mprops = model.getProperties(); + if(mprops.containsKey(SbtExtraProperties.POM_SBT_VERSION)) { + final String sbtVersion = mprops.getProperty(SbtExtraProperties.POM_SBT_VERSION); + properties.put(SbtExtraProperties.SBT_VERSION_KEY, sbtVersion); + } + if(mprops.containsKey(SbtExtraProperties.POM_SCALA_VERSION)) { + properties.put(SbtExtraProperties.SCALA_VERSION_KEY, mprops.getProperty(SbtExtraProperties.POM_SCALA_VERSION)); + } + + // TODO - Add extra attributes, e.g. sbtVersion + scalaVersion. + + result.setProperties( properties); + + setArtifactProperties( result, model ); + } + + return result; + } + + // SBT FIX - We make sure that artifact properties are copied over here, so we can find sbt-plugin POM files. + public static Artifact toPomArtifact(Artifact artifact) { + Artifact pomArtifact = artifact; + if(artifact.getClassifier().length() > 0 || !"pom".equals(artifact.getExtension())) { + // TODO - only copy over sbt-important properties. + pomArtifact = new DefaultArtifact(artifact.getGroupId(), artifact.getArtifactId(), "pom", artifact.getVersion()).setProperties(artifact.getProperties()); + } + return pomArtifact; + } + + private Model loadPom( RepositorySystemSession session, ArtifactDescriptorRequest request, + ArtifactDescriptorResult result ) + throws ArtifactDescriptorException + { + RequestTrace trace = RequestTrace.newChild( request.getTrace(), request ); + + Set visited = new LinkedHashSet(); + for ( Artifact artifact = request.getArtifact();; ) + { + // SBT FIX - we need to use our own variant here to preserve extra attributes. + // Artifact pomArtifact = ArtifactDescriptorUtils.toPomArtifact( artifact ); + Artifact pomArtifact = toPomArtifact(artifact); + try + { + VersionRequest versionRequest = + new VersionRequest( artifact, request.getRepositories(), request.getRequestContext() ); + versionRequest.setTrace( trace ); + VersionResult versionResult = versionResolver.resolveVersion( session, versionRequest ); + + artifact = artifact.setVersion( versionResult.getVersion() ); + + versionRequest = + new VersionRequest( pomArtifact, request.getRepositories(), request.getRequestContext() ); + versionRequest.setTrace( trace ); + versionResult = versionResolver.resolveVersion( session, versionRequest ); + + pomArtifact = pomArtifact.setVersion( versionResult.getVersion() ); + } + catch ( VersionResolutionException e ) + { + result.addException( e ); + throw new ArtifactDescriptorException( result ); + } + + if ( !visited.add( artifact.getGroupId() + ':' + artifact.getArtifactId() + ':' + artifact.getBaseVersion() ) ) + { + RepositoryException exception = + new RepositoryException( "Artifact relocations form a cycle: " + visited ); + invalidDescriptor( session, trace, artifact, exception ); + if ( ( getPolicy( session, artifact, request ) & ArtifactDescriptorPolicy.IGNORE_INVALID ) != 0 ) + { + return null; + } + result.addException( exception ); + throw new ArtifactDescriptorException( result ); + } + + ArtifactResult resolveResult; + try + { + ArtifactRequest resolveRequest = + new ArtifactRequest( pomArtifact, request.getRepositories(), request.getRequestContext() ); + resolveRequest.setTrace( trace ); + resolveResult = artifactResolver.resolveArtifact( session, resolveRequest ); + pomArtifact = resolveResult.getArtifact(); + result.setRepository( resolveResult.getRepository() ); + } + catch ( ArtifactResolutionException e ) + { + if ( e.getCause() instanceof ArtifactNotFoundException ) + { + missingDescriptor( session, trace, artifact, (Exception) e.getCause() ); + if ( ( getPolicy( session, artifact, request ) & ArtifactDescriptorPolicy.IGNORE_MISSING ) != 0 ) + { + return null; + } + } + result.addException( e ); + throw new ArtifactDescriptorException( result ); + } + + Model model; + try + { + ModelBuildingRequest modelRequest = new DefaultModelBuildingRequest(); + modelRequest.setValidationLevel( ModelBuildingRequest.VALIDATION_LEVEL_MINIMAL ); + modelRequest.setProcessPlugins(false); + modelRequest.setTwoPhaseBuilding(false); + modelRequest.setSystemProperties(toProperties(session.getUserProperties(), + session.getSystemProperties())); + modelRequest.setModelCache(DefaultModelCache.newInstance(session)); + modelRequest.setModelResolver( + new DefaultModelResolver( + session, + trace.newChild(modelRequest), + request.getRequestContext(), + artifactResolver, + versionRangeResolver, + remoteRepositoryManager, + request.getRepositories()) + ); + if ( resolveResult.getRepository() instanceof WorkspaceRepository ) + { + modelRequest.setPomFile( pomArtifact.getFile() ); + } + else + { + modelRequest.setModelSource( new FileModelSource( pomArtifact.getFile() ) ); + } + + model = modelBuilder.build( modelRequest ).getEffectiveModel(); + } + catch ( ModelBuildingException e ) + { + for ( ModelProblem problem : e.getProblems() ) + { + if ( problem.getException() instanceof UnresolvableModelException ) + { + result.addException( problem.getException() ); + throw new ArtifactDescriptorException( result ); + } + } + invalidDescriptor( session, trace, artifact, e ); + if ( ( getPolicy( session, artifact, request ) & ArtifactDescriptorPolicy.IGNORE_INVALID ) != 0 ) + { + return null; + } + result.addException( e ); + throw new ArtifactDescriptorException( result ); + } + + Relocation relocation = getRelocation( model ); + + if ( relocation != null ) + { + result.addRelocation( artifact ); + artifact = + new RelocatedArtifact( artifact, relocation.getGroupId(), relocation.getArtifactId(), + relocation.getVersion() ); + result.setArtifact( artifact ); + } + else + { + return model; + } + } + } + + private Properties toProperties( Map dominant, Map recessive ) + { + Properties props = new Properties(); + if ( recessive != null ) + { + props.putAll( recessive ); + } + if ( dominant != null ) + { + props.putAll( dominant ); + } + return props; + } + + private Relocation getRelocation( Model model ) + { + Relocation relocation = null; + DistributionManagement distMngt = model.getDistributionManagement(); + if ( distMngt != null ) + { + relocation = distMngt.getRelocation(); + } + return relocation; + } + + private void setArtifactProperties( ArtifactDescriptorResult result, Model model ) + { + String downloadUrl = null; + DistributionManagement distMngt = model.getDistributionManagement(); + if ( distMngt != null ) + { + downloadUrl = distMngt.getDownloadUrl(); + } + if ( downloadUrl != null && downloadUrl.length() > 0 ) + { + Artifact artifact = result.getArtifact(); + Map props = new HashMap( artifact.getProperties() ); + props.put( ArtifactProperties.DOWNLOAD_URL, downloadUrl ); + result.setArtifact( artifact.setProperties( props ) ); + } + } + + private Dependency convert( org.apache.maven.model.Dependency dependency, ArtifactTypeRegistry stereotypes ) + { + ArtifactType stereotype = stereotypes.get( dependency.getType() ); + if ( stereotype == null ) + { + stereotype = new DefaultArtifactType( dependency.getType() ); + } + + boolean system = dependency.getSystemPath() != null && dependency.getSystemPath().length() > 0; + + Map props = null; + if ( system ) + { + props = Collections.singletonMap( ArtifactProperties.LOCAL_PATH, dependency.getSystemPath() ); + } + + Artifact artifact = + new DefaultArtifact( dependency.getGroupId(), dependency.getArtifactId(), dependency.getClassifier(), null, + dependency.getVersion(), props, stereotype ); + + List exclusions = new ArrayList( dependency.getExclusions().size() ); + for ( org.apache.maven.model.Exclusion exclusion : dependency.getExclusions() ) + { + exclusions.add( convert( exclusion ) ); + } + + Dependency result = new Dependency( artifact, dependency.getScope(), dependency.isOptional(), exclusions ); + + return result; + } + + private Exclusion convert( org.apache.maven.model.Exclusion exclusion ) + { + return new Exclusion( exclusion.getGroupId(), exclusion.getArtifactId(), "*", "*" ); + } + + private void missingDescriptor( RepositorySystemSession session, RequestTrace trace, Artifact artifact, + Exception exception ) + { + RepositoryEvent.Builder event = new RepositoryEvent.Builder( session, EventType.ARTIFACT_DESCRIPTOR_MISSING ); + event.setTrace( trace ); + event.setArtifact( artifact ); + event.setException( exception ); + + repositoryEventDispatcher.dispatch( event.build() ); + } + + private void invalidDescriptor( RepositorySystemSession session, RequestTrace trace, Artifact artifact, + Exception exception ) + { + RepositoryEvent.Builder event = new RepositoryEvent.Builder( session, EventType.ARTIFACT_DESCRIPTOR_INVALID ); + event.setTrace( trace ); + event.setArtifact( artifact ); + event.setException( exception ); + + repositoryEventDispatcher.dispatch( event.build() ); + } + + private int getPolicy( RepositorySystemSession session, Artifact artifact, ArtifactDescriptorRequest request ) + { + ArtifactDescriptorPolicy policy = session.getArtifactDescriptorPolicy(); + if ( policy == null ) + { + return ArtifactDescriptorPolicy.STRICT; + } + return policy.getPolicy( session, new ArtifactDescriptorPolicyRequest( artifact, request.getRequestContext() ) ); + } + + public void setVersionRangeResolver(final VersionRangeResolver versionRangeResolver) { + this.versionRangeResolver = versionRangeResolver; + } +} \ No newline at end of file diff --git a/ivy/src/main/scala/org/apache/maven/repository/internal/SbtExtraProperties.java b/ivy/src/main/scala/org/apache/maven/repository/internal/SbtExtraProperties.java new file mode 100644 index 000000000..32937677b --- /dev/null +++ b/ivy/src/main/scala/org/apache/maven/repository/internal/SbtExtraProperties.java @@ -0,0 +1,23 @@ +package org.apache.maven.repository.internal; + +/** + * Created by jsuereth on 12/20/14. + */ +public class SbtExtraProperties { + public static final String MAVEN_PACKAGING_KEY = "sbt.pom.packaging"; + public static final String SCALA_VERSION_KEY = "sbt.pom.scalaversion"; + public static final String SBT_VERSION_KEY = "sbt.pom.sbtversion"; + + public static final String POM_SCALA_VERSION = "scalaVersion"; + public static final String POM_SBT_VERSION = "sbtVersion"; + + public static final String LICENSE_COUNT_KEY = "license.count"; + + public static String makeLicenseName(int i) { + return "license." + i + ".name"; + } + public static String makeLicenseUrl(int i) { + return "license." + i + ".url"; + } + +} diff --git a/ivy/src/main/scala/org/apache/maven/repository/internal/SbtRepositoryLayout.scala b/ivy/src/main/scala/org/apache/maven/repository/internal/SbtRepositoryLayout.scala new file mode 100644 index 000000000..23fe7630a --- /dev/null +++ b/ivy/src/main/scala/org/apache/maven/repository/internal/SbtRepositoryLayout.scala @@ -0,0 +1,100 @@ +package org.apache.maven.repository.internal + +import org.apache.ivy.util.Message +import org.eclipse.aether.spi.connector.layout.{ RepositoryLayout, RepositoryLayoutFactory } +import org.eclipse.aether.RepositorySystemSession +import org.eclipse.aether.repository.RemoteRepository +import org.eclipse.aether.transfer.NoRepositoryLayoutException +import org.eclipse.aether.metadata.Metadata +import org.eclipse.aether.spi.connector.layout.RepositoryLayout.Checksum +import org.eclipse.aether.artifact.Artifact +import java.net.URI + +import scala.util.matching.Regex + +/** A factory which knows how to create repository layouts which can find sbt plugins. */ +class SbtPluginLayoutFactory extends RepositoryLayoutFactory { + def newInstance(session: RepositorySystemSession, repository: RemoteRepository): RepositoryLayout = { + repository.getContentType match { + case SbtRepositoryLayout.LAYOUT_NAME => + SbtRepositoryLayout + case _ => throw new NoRepositoryLayoutException(repository, "Not an sbt-plugin repository") + } + } + def getPriority: Float = 100.0f +} + +object SbtRepositoryLayout extends RepositoryLayout { + + val LAYOUT_NAME = "sbt-plugin" + + // get location is ALMOST the same for Metadata + artifact... but subtle differences are important. + + def getLocation(artifact: Artifact, upload: Boolean): URI = { + import collection.JavaConverters._ + val sbtVersion = Option(artifact.getProperties.get(SbtExtraProperties.POM_SBT_VERSION)) + val scalaVersion = Option(artifact.getProperties.get(SbtExtraProperties.POM_SCALA_VERSION)) + val path = new StringBuilder(128) + path.append(artifact.getGroupId.replace('.', '/')).append('/') + (sbtVersion zip scalaVersion).headOption match { + case Some((sbt, scala)) => + if (artifact.getArtifactId contains "_sbt_") { + // TODO - Write this handler. + val SbtNameVersionSplit(name, sbt2) = artifact.getArtifactId + path.append(name).append('_').append(scala).append('_').append(sbt).append('/') + } else path.append(artifact.getArtifactId).append('_').append(scala).append('_').append(sbt).append('/') + case None => + // TODO - Should we automatically append the _ here if it's not there? Probably not for now. + path.append(artifact.getArtifactId).append('/') + } + path.append(artifact.getBaseVersion).append('/') + sbtVersion match { + case Some(_) if artifact.getArtifactId contains "_sbt_" => + val SbtNameVersionSplit(name, sbt2) = artifact.getArtifactId + path.append(name).append('-').append(artifact.getVersion) + case None => path.append(artifact.getArtifactId).append('-').append(artifact.getVersion) + } + + if (artifact.getClassifier != null && !artifact.getClassifier.trim.isEmpty) { + path.append("-").append(artifact.getClassifier) + } + if (artifact.getExtension.length > 0) { + path.append('.').append(artifact.getExtension) + } + URI.create(path.toString()) + } + + // Trickery for disambiguating sbt plugins in maven repositories. + val SbtNameVersionSplit = new Regex("(.*)_sbt_(.*)") + + def getLocation(metadata: Metadata, upload: Boolean): URI = { + val sbtVersion = Option(metadata.getProperties.get(SbtExtraProperties.POM_SBT_VERSION)) + val scalaVersion = Option(metadata.getProperties.get(SbtExtraProperties.POM_SCALA_VERSION)) + val path = new StringBuilder(128) + path.append(metadata.getGroupId.replace('.', '/')).append('/') + (sbtVersion zip scalaVersion).headOption match { + case Some((sbt, scala)) => + if (metadata.getArtifactId contains "_sbt_") { + val SbtNameVersionSplit(name, sbt2) = metadata.getArtifactId + path.append(name).append('_').append(scala).append('_').append(sbt).append('/') + // TODO - Write this handler. + } else path.append(metadata.getArtifactId).append('_').append(scala).append('_').append(sbt).append('/') + case None => + // TODO - Should we automatically append the _ here? Proabbly not for now. + path.append(metadata.getArtifactId).append('/') + } + if (metadata.getVersion.length > 0) + path.append(metadata.getVersion).append('/') + path.append(metadata.getType) + URI.create(path.toString) + } + + // TODO - This should be the same as configured from Ivy... + def getChecksums(artifact: Artifact, upload: Boolean, location: URI): java.util.List[Checksum] = + getChecksums(location) + def getChecksums(metadata: Metadata, upload: Boolean, location: URI): java.util.List[Checksum] = + getChecksums(location) + + private def getChecksums(location: URI): java.util.List[Checksum] = + java.util.Arrays.asList(Checksum.forLocation(location, "SHA-1"), Checksum.forLocation(location, "MD5")) +} \ No newline at end of file diff --git a/ivy/src/main/scala/sbt/ConvertResolver.scala b/ivy/src/main/scala/sbt/ConvertResolver.scala index 35cfb669f..9c7545eb9 100644 --- a/ivy/src/main/scala/sbt/ConvertResolver.scala +++ b/ivy/src/main/scala/sbt/ConvertResolver.scala @@ -94,24 +94,37 @@ private[sbt] object ConvertResolver { } } + private[sbt] val USE_AETHER_PROPERTY = "sbt.use.aether" + private def isUseAetherForResolution(settings: IvySettings): Boolean = + settings.getVariable(USE_AETHER_PROPERTY) == "true" + /** Converts the given sbt resolver into an Ivy resolver..*/ def apply(r: Resolver, settings: IvySettings, log: Logger) = { r match { case repo: MavenRepository => { - val pattern = Collections.singletonList(Resolver.resolvePattern(repo.root, Resolver.mavenStyleBasePattern)) - final class PluginCapableResolver extends IBiblioResolver with ChecksumFriendlyURLResolver with DescriptorRequired { - def setPatterns() { // done this way for access to protected methods. - setArtifactPatterns(pattern) - setIvyPatterns(pattern) + if (isUseAetherForResolution(settings)) { + repo match { + case cache: MavenCache => new org.apache.ivy.plugins.resolver.MavenCacheRepositoryResolver(cache, settings) + case _ => new org.apache.ivy.plugins.resolver.MavenRemoteRepositoryResolver(repo, settings) } + } else { + val pattern = Collections.singletonList(Resolver.resolvePattern(repo.root, Resolver.mavenStyleBasePattern)) + final class PluginCapableResolver extends IBiblioResolver with ChecksumFriendlyURLResolver with DescriptorRequired { + def setPatterns() { + // done this way for access to protected methods. + setArtifactPatterns(pattern) + setIvyPatterns(pattern) + } + } + val resolver = new PluginCapableResolver + resolver.setRepository(new LocalIfFileRepo) + initializeMavenStyle(resolver, repo.name, repo.root) + resolver.setPatterns() // has to be done after initializeMavenStyle, which calls methods that overwrite the patterns + resolver } - val resolver = new PluginCapableResolver - resolver.setRepository(new LocalIfFileRepo) - initializeMavenStyle(resolver, repo.name, repo.root) - resolver.setPatterns() // has to be done after initializeMavenStyle, which calls methods that overwrite the patterns - resolver + } // TODO: HTTP repository is no longer recommended. #1541 // Remove `JavaNet1Repository` when we bump up the API. diff --git a/ivy/src/main/scala/sbt/CustomPomParser.scala b/ivy/src/main/scala/sbt/CustomPomParser.scala index 202216700..d639532a7 100644 --- a/ivy/src/main/scala/sbt/CustomPomParser.scala +++ b/ivy/src/main/scala/sbt/CustomPomParser.scala @@ -13,6 +13,7 @@ import java.io.{ File, InputStream } import java.net.URL import java.util.regex.Pattern +@deprecated("0.13.8", "We now use an Aether-based pom parser.") final class CustomPomParser(delegate: ModuleDescriptorParser, transform: (ModuleDescriptorParser, ModuleDescriptor) => ModuleDescriptor) extends ModuleDescriptorParser { override def parseDescriptor(ivySettings: ParserSettings, descriptorURL: URL, validate: Boolean) = transform(this, delegate.parseDescriptor(ivySettings, descriptorURL, validate)) @@ -26,6 +27,7 @@ final class CustomPomParser(delegate: ModuleDescriptorParser, transform: (Module override def getType() = delegate.getType() override def getMetadataArtifact(mrid: ModuleRevisionId, res: Resource) = delegate.getMetadataArtifact(mrid, res) } +@deprecated("0.13.8", "We now use an Aether-based pom parser.") object CustomPomParser { // Evil hackery to override the default maven pom mappings. diff --git a/ivy/src/main/scala/sbt/Ivy.scala b/ivy/src/main/scala/sbt/Ivy.scala index 32f2f6440..d2d0388ee 100644 --- a/ivy/src/main/scala/sbt/Ivy.scala +++ b/ivy/src/main/scala/sbt/Ivy.scala @@ -14,19 +14,20 @@ import java.util.{ Collection, Collections => CS, Date } import CS.singleton import org.apache.ivy.Ivy +import org.apache.ivy.core.report.ResolveReport import org.apache.ivy.core.{ IvyPatternHelper, LogOptions, IvyContext } -import org.apache.ivy.core.cache.{ CacheMetadataOptions, DefaultRepositoryCacheManager, ModuleDescriptorWriter } +import org.apache.ivy.core.cache.{ ResolutionCacheManager, CacheMetadataOptions, DefaultRepositoryCacheManager, ModuleDescriptorWriter } import org.apache.ivy.core.event.EventManager import org.apache.ivy.core.module.descriptor.{ Artifact => IArtifact, DefaultArtifact, DefaultDependencyArtifactDescriptor, MDArtifact } import org.apache.ivy.core.module.descriptor.{ DefaultDependencyDescriptor, DefaultModuleDescriptor, DependencyDescriptor, ModuleDescriptor, License } import org.apache.ivy.core.module.descriptor.{ OverrideDependencyDescriptorMediator } import org.apache.ivy.core.module.id.{ ArtifactId, ModuleId, ModuleRevisionId } -import org.apache.ivy.core.resolve.{ IvyNode, ResolveData, ResolvedModuleRevision, ResolveEngine } +import org.apache.ivy.core.resolve._ import org.apache.ivy.core.settings.IvySettings import org.apache.ivy.core.sort.SortEngine import org.apache.ivy.plugins.latest.{ LatestStrategy, LatestRevisionStrategy, ArtifactInfo } import org.apache.ivy.plugins.matcher.PatternMatcher -import org.apache.ivy.plugins.parser.m2.PomModuleDescriptorParser +import org.apache.ivy.plugins.parser.m2.{ PomModuleDescriptorParser } import org.apache.ivy.plugins.resolver.{ ChainResolver, DependencyResolver, BasicResolver } import org.apache.ivy.plugins.resolver.util.{ HasLatestStrategy, ResolvedResource } import org.apache.ivy.plugins.version.ExactVersionMatcher @@ -68,9 +69,12 @@ final class IvySbt(val configuration: IvyConfiguration) { private lazy val settings: IvySettings = { val is = new IvySettings + is.setBaseDir(baseDirectory) is.setCircularDependencyStrategy(configuration.updateOptions.circularDependencyLevel.ivyStrategy) CustomPomParser.registerDefault + is.setVariable(ConvertResolver.USE_AETHER_PROPERTY, s"${configuration.updateOptions.aetherResolution}") + configuration match { case e: ExternalIvyConfiguration => IvySbt.addResolvers(e.extraResolvers, is, configuration.log) @@ -104,6 +108,7 @@ final class IvySbt(val configuration: IvyConfiguration) { super.bind() } } + i.setSettings(settings) i.bind() i.getLoggerEngine.pushLogger(new IvyLoggerInterface(configuration.log)) diff --git a/ivy/src/main/scala/sbt/MakePom.scala b/ivy/src/main/scala/sbt/MakePom.scala index eba0cd94d..3bc3520fd 100644 --- a/ivy/src/main/scala/sbt/MakePom.scala +++ b/ivy/src/main/scala/sbt/MakePom.scala @@ -330,6 +330,8 @@ class MakePom(val log: Logger) { val repositories = if (includeAll) allResolvers(settings) else resolvers(settings.getDefaultResolver) val mavenRepositories = repositories.flatMap { + case m: org.apache.ivy.plugins.resolver.MavenRemoteRepositoryResolver if m.repo.root != DefaultMavenRepository.root => + MavenRepository(m.repo.name, m.repo.root) :: Nil case m: IBiblioResolver if m.isM2compatible && m.getRoot != DefaultMavenRepository.root => MavenRepository(m.getName, m.getRoot) :: Nil case _ => Nil diff --git a/ivy/src/main/scala/sbt/Resolver.scala b/ivy/src/main/scala/sbt/Resolver.scala index 406c27e78..ce3a2830f 100644 --- a/ivy/src/main/scala/sbt/Resolver.scala +++ b/ivy/src/main/scala/sbt/Resolver.scala @@ -30,8 +30,23 @@ final class RawRepository(val resolver: DependencyResolver) extends Resolver { } } sealed case class ChainedResolver(name: String, resolvers: Seq[Resolver]) extends Resolver + +/** An instance of a remote maven repository. Note: This will use Aether/Maven to resolve artifacts. */ sealed case class MavenRepository(name: String, root: String) extends Resolver { override def toString = name + ": " + root + def isCache: Boolean = false +} + +/** + * An instance of maven CACHE directory. You cannot treat a cache directory the same as a a remote repository because + * the metadata is different (see Aether ML discussion). + */ +final class MavenCache(name: String, val rootFile: File) extends MavenRepository(name, rootFile.toURI.toURL.toString) { + override val toString = "cache:" + name + ": " + rootFile.getAbsolutePath + override def isCache: Boolean = true +} +object MavenCache { + def apply(name: String, rootFile: File): MavenCache = new MavenCache(name, rootFile) } final class Patterns(val ivyPatterns: Seq[String], val artifactPatterns: Seq[String], val isMavenCompatible: Boolean, val descriptorOptional: Boolean, val skipConsistencyCheck: Boolean) { @@ -334,8 +349,9 @@ object Resolver { loadHomeFromSettings(() => new File(new File(System.getenv("M2_HOME")), "conf/settings.xml")) getOrElse new File(Path.userHome, ".m2/repository") } - def publishMavenLocal = Resolver.file("publish-m2-local", mavenLocalDir) - def mavenLocal = MavenRepository("Maven2 Local", mavenLocalDir.toURI.toString) + // TODO - should this just be the *exact* same as mavenLocal? probably... + def publishMavenLocal: MavenCache = new MavenCache("publish-m2-local", mavenLocalDir) + def mavenLocal: MavenRepository = new MavenCache("Maven2 Local", mavenLocalDir) def defaultLocal = defaultUserFileRepository("local") def defaultShared = defaultUserFileRepository("shared") def defaultUserFileRepository(id: String) = diff --git a/ivy/src/main/scala/sbt/UpdateOptions.scala b/ivy/src/main/scala/sbt/UpdateOptions.scala index 1d4688481..e13fed72f 100644 --- a/ivy/src/main/scala/sbt/UpdateOptions.scala +++ b/ivy/src/main/scala/sbt/UpdateOptions.scala @@ -17,7 +17,13 @@ final class UpdateOptions private[sbt] ( /** If set to true, use consolidated resolution. */ val consolidatedResolution: Boolean, /** If set to true, use cached resolution. */ - val cachedResolution: Boolean) { + val cachedResolution: Boolean, + /** If set to true, use aether for resolving maven artifacts. */ + val aetherResolution: Boolean) { + + /** Enables Aether for dependency resolution. */ + def withAetherResolution(aetherResolution: Boolean): UpdateOptions = + copy(aetherResolution = aetherResolution) def withCircularDependencyLevel(circularDependencyLevel: CircularDependencyLevel): UpdateOptions = copy(circularDependencyLevel = circularDependencyLevel) @@ -35,11 +41,13 @@ final class UpdateOptions private[sbt] ( circularDependencyLevel: CircularDependencyLevel = this.circularDependencyLevel, latestSnapshots: Boolean = this.latestSnapshots, consolidatedResolution: Boolean = this.consolidatedResolution, - cachedResolution: Boolean = this.cachedResolution): UpdateOptions = + cachedResolution: Boolean = this.cachedResolution, + aetherResolution: Boolean = this.aetherResolution): UpdateOptions = new UpdateOptions(circularDependencyLevel, latestSnapshots, consolidatedResolution, - cachedResolution) + cachedResolution, + aetherResolution) override def equals(o: Any): Boolean = o match { case o: UpdateOptions => @@ -65,5 +73,7 @@ object UpdateOptions { circularDependencyLevel = CircularDependencyLevel.Warn, latestSnapshots = false, consolidatedResolution = false, - cachedResolution = false) + cachedResolution = false, + // TODO - Disable this before release, but make sure test suite passes with it on. + aetherResolution = true) } diff --git a/ivy/src/main/scala/sbt/ivyint/SbtChainResolver.scala b/ivy/src/main/scala/sbt/ivyint/SbtChainResolver.scala index a4d60c997..13c2642ec 100644 --- a/ivy/src/main/scala/sbt/ivyint/SbtChainResolver.scala +++ b/ivy/src/main/scala/sbt/ivyint/SbtChainResolver.scala @@ -12,7 +12,7 @@ import org.apache.ivy.core.resolve.{ ResolvedModuleRevision, ResolveData } import org.apache.ivy.plugins.latest.LatestStrategy import org.apache.ivy.plugins.repository.file.{ FileRepository => IFileRepository, FileResource } import org.apache.ivy.plugins.repository.url.URLResource -import org.apache.ivy.plugins.resolver.{ ChainResolver, BasicResolver, DependencyResolver } +import org.apache.ivy.plugins.resolver._ import org.apache.ivy.plugins.resolver.util.{ HasLatestStrategy, ResolvedResource } import org.apache.ivy.util.{ Message, MessageLogger, StringUtils => IvyStringUtils } @@ -155,34 +155,39 @@ private[sbt] case class SbtChainResolver( val sorted = if (useLatest) (foundRevisions.sortBy { case (rmr, resolver) => + Message.warn(s"Sorrting results from $rmr, using ${rmr.getPublicationDate} and ${rmr.getDescriptor.getPublicationDate}") // Just issue warning about issues with publication date, and fake one on it for now. - rmr.getDescriptor.getPublicationDate match { - case null => + Option(rmr.getPublicationDate) orElse Option(rmr.getDescriptor.getPublicationDate) match { + case None => (resolver.findIvyFileRef(dd, data), rmr.getDescriptor) match { case (null, _) => // In this instance, the dependency is specified by a direct URL or some other sort of "non-ivy" file if (dd.isChanging) Message.warn(s"Resolving a changing dependency (${rmr.getId}) with no ivy/pom file!, resolution order is undefined!") + 0L case (ivf, dmd: DefaultModuleDescriptor) => val lmd = new java.util.Date(ivf.getLastModified) Message.debug(s"Getting no publication date from resolver: ${resolver} for ${rmr.getId}, setting to: ${lmd}") dmd.setPublicationDate(lmd) + ivf.getLastModified case _ => Message.warn(s"Getting null publication date from resolver: ${resolver} for ${rmr.getId}, resolution order is undefined!") + 0L } - case _ => // All other cases ok - } - rmr.getDescriptor.getPublicationDate match { - case null => 0L - case d => d.getTime + case Some(date) => // All other cases ok + date.getTime } }).reverse.headOption map { case (rmr, resolver) => + Message.warn(s"Choosing ${resolver} for ${rmr.getId}") // Now that we know the real latest revision, let's force Ivy to use it val artifactOpt = findFirstArtifactRef(rmr.getDescriptor, dd, data, resolver) artifactOpt match { case None if resolver.getName == "inter-project" => // do nothing - case None => throw new RuntimeException(s"\t${resolver.getName}: no ivy file nor artifact found for $rmr") + case None if resolver.isInstanceOf[AbstractMavenRepositoryResolver] => + // do nothing for now.... + // We want to see if the maven caching is sufficient and we do not need to duplicate within the ivy cache... + case None => throw new RuntimeException(s"\t${resolver.getName}: no ivy file nor artifact found for $rmr") case Some(artifactRef) => val systemMd = toSystem(rmr.getDescriptor) getRepositoryCacheManager.cacheModuleDescriptor(resolver, artifactRef, @@ -210,6 +215,9 @@ private[sbt] case class SbtChainResolver( } // Ivy seem to not want to use the module descriptor found at the latest resolver private[this] def reparseModuleDescriptor(dd: DependencyDescriptor, data: ResolveData, resolver: DependencyResolver, rmr: ResolvedModuleRevision): ResolvedModuleRevision = + // TODO - Redownloading/parsing the ivy file is not really the best way to make this correct. + // We should figure out a better alternative, or directly attack the resolvers Ivy uses to + // give them correct behavior around -SNAPSHOT. Option(resolver.findIvyFileRef(dd, data)) flatMap { ivyFile => ivyFile.getResource match { case r: FileResource => @@ -222,7 +230,10 @@ private[sbt] case class SbtChainResolver( } case _ => None } - } getOrElse rmr + } getOrElse { + Message.warn(s"Unable to reparse ${dd.getDependencyRevisionId} from $resolver, using ${rmr.getPublicationDate}") + rmr + } /** Ported from BasicResolver#findFirstAirfactRef. */ private[this] def findFirstArtifactRef(md: ModuleDescriptor, dd: DependencyDescriptor, data: ResolveData, resolver: DependencyResolver): Option[ResolvedResource] = { diff --git a/ivy/src/test/scala/BaseIvySpecification.scala b/ivy/src/test/scala/BaseIvySpecification.scala index 09d7da7a2..1be01ab25 100644 --- a/ivy/src/test/scala/BaseIvySpecification.scala +++ b/ivy/src/test/scala/BaseIvySpecification.scala @@ -4,6 +4,8 @@ import Path._, Configurations._ import java.io.File import org.specs2._ import cross.CrossVersionUtil +import sbt.PublishConfiguration +import sbt.ivyint.SbtChainResolver trait BaseIvySpecification extends Specification { def currentBase: File = new File(".") @@ -12,6 +14,8 @@ trait BaseIvySpecification extends Specification { def currentDependency: File = currentBase / "target" / "dependency" def defaultModuleId: ModuleID = ModuleID("com.example", "foo", "0.1.0", Some("compile")) lazy val log = ConsoleLogger() + + def configurations = Seq(Compile, Test, Runtime) def module(moduleId: ModuleID, deps: Seq[ModuleID], scalaFullVersion: Option[String], uo: UpdateOptions = UpdateOptions()): IvySbt#Module = { val ivyScala = scalaFullVersion map { fv => @@ -28,21 +32,24 @@ trait BaseIvySpecification extends Specification { module = moduleId, moduleInfo = ModuleInfo("foo"), dependencies = deps, - configurations = Seq(Compile, Test, Runtime), + configurations = configurations, ivyScala = ivyScala) val ivySbt = new IvySbt(mkIvyConfiguration(uo)) new ivySbt.Module(moduleSetting) } + def resolvers: Seq[Resolver] = Seq(DefaultMavenRepository) + + def chainResolver = ChainedResolver("sbt-chain", resolvers) + def mkIvyConfiguration(uo: UpdateOptions): IvyConfiguration = { val paths = new IvyPaths(currentBase, Some(currentTarget)) - val rs = Seq(DefaultMavenRepository) val other = Nil - val moduleConfs = Seq(ModuleConfiguration("*", DefaultMavenRepository)) + val moduleConfs = Seq(ModuleConfiguration("*", chainResolver)) val off = false val check = Nil val resCacheDir = currentTarget / "resolution-cache" - new InlineIvyConfiguration(paths, rs, other, moduleConfs, off, None, check, Some(resCacheDir), uo, log) + new InlineIvyConfiguration(paths, resolvers, other, moduleConfs, off, None, check, Some(resCacheDir), uo, log) } def ivyUpdateEither(module: IvySbt#Module): Either[UnresolvedWarning, UpdateReport] = { @@ -58,4 +65,18 @@ trait BaseIvySpecification extends Specification { case Left(w) => throw w.resolveException } + + def mkPublishConfiguration(resolver: Resolver, artifacts: Map[Artifact, File]): PublishConfiguration = { + new PublishConfiguration( + ivyFile = None, + resolverName = resolver.name, + artifacts = artifacts, + checksums = Seq(), + logging = UpdateLogging.Full, + overwrite = true) + } + + def ivyPublish(module: IvySbt#Module, config: PublishConfiguration) = { + IvyActions.publish(module, config, log) + } } diff --git a/ivy/src/test/scala/MavenResolutionSpec.scala b/ivy/src/test/scala/MavenResolutionSpec.scala new file mode 100644 index 000000000..f7b46895d --- /dev/null +++ b/ivy/src/test/scala/MavenResolutionSpec.scala @@ -0,0 +1,291 @@ +package sbt + +import java.io.FileInputStream + +import org.specs2._ + +class MavenResolutionSpec extends BaseIvySpecification { + def is = args(sequential = true) ^ s2""".stripMargin + + This is a specification to check the maven resolution + + Resolving a maven dependency should + handle sbt plugins $resolveSbtPlugins + use ivy for conflict resolution $resolveMajorConflicts + handle cross configuration deps $resolveCrossConfigurations + publish with maven-metadata $publishMavenMetadata + resolve transitive maven dependencies $resolveTransitiveMavenDependency + resolve intransitive maven dependencies $resolveIntransitiveMavenDependency + handle transitive configuration shifts $resolveTransitiveConfigurationMavenDependency + resolve source and doc $resolveSourceAndJavadoc + resolve nonstandard (jdk5) classifier $resolveNonstandardClassifier + Resolve pom artifact dependencies $resolvePomArtifactAndDependencies + Fail if JAR artifact is not found w/ POM $failIfMainArtifactMissing + Fail if POM.xml is not found $failIfPomMissing + resolve publication date for -SNAPSHOT $resolveSnapshotPubDate + + """ // */ + + // TODO - test latest.integration and .+ + + def akkaActor = ModuleID("com.typesafe.akka", "akka-actor_2.11", "2.3.8", Some("compile")) + def akkaActorTestkit = ModuleID("com.typesafe.akka", "akka-testkit_2.11", "2.3.8", Some("test")) + def testngJdk5 = ModuleID("org.testng", "testng", "5.7", Some("compile")).classifier("jdk15") + def jmxri = ModuleID("com.sun.jmx", "jmxri", "1.2.1", Some("compile")) + def scalaLibraryAll = ModuleID("org.scala-lang", "scala-library-all", "2.11.4", Some("compile")) + def scalaCompiler = ModuleID("org.scala-lang", "scala-compiler", "2.8.1", Some("scala-tool->default(compile)")) + def scalaContinuationPlugin = ModuleID("org.scala-lang.plugins", "continuations", "2.8.1", Some("plugin->default(compile)")) + def sbtPlugin = + ModuleID("com.github.mpeltonen", "sbt-idea", "1.6.0", Some("compile")). + extra(CustomPomParser.SbtVersionKey -> "0.13", CustomPomParser.ScalaVersionKey -> "2.10"). + copy(crossVersion = CrossVersion.Disabled) + def oldSbtPlugin = + ModuleID("com.github.mpeltonen", "sbt-idea", "1.6.0", Some("compile")). + extra(CustomPomParser.SbtVersionKey -> "0.12", CustomPomParser.ScalaVersionKey -> "2.9.2"). + copy(crossVersion = CrossVersion.Disabled) + def majorConflictLib = ModuleID("com.joestelmach", "natty", "0.3", Some("compile")) + // TODO - This snapshot and resolver should be something we own/control so it doesn't disappear on us. + def testSnapshot = ModuleID("com.typesafe", "config", "0.4.9-SNAPSHOT", Some("compile")) + val SnapshotResolver = MavenRepository("some-snapshots", "https://oss.sonatype.org/content/repositories/snapshots/") + + override def resolvers = Seq(DefaultMavenRepository, SnapshotResolver, Resolver.publishMavenLocal) + import Configurations.{ Compile, Test, Runtime, CompilerPlugin, ScalaTool } + override def configurations = Seq(Compile, Test, Runtime, CompilerPlugin, ScalaTool) + + import ShowLines._ + + def defaultUpdateOptions = UpdateOptions().withAetherResolution(true) + + def resolveMajorConflicts = { + val m = module(ModuleID("com.example", "foo", "0.1.0", Some("compile")), + Seq(majorConflictLib), None, defaultUpdateOptions) + val report = ivyUpdate(m) // must not(throwAn[IllegalStateException]) + val jars = + for { + conf <- report.configurations + if conf.configuration == Compile.name + m <- conf.modules + if (m.module.name contains "stringtemplate") + (a, f) <- m.artifacts + if a.extension == "jar" + } yield f + jars must haveSize(1) + } + + def resolveCrossConfigurations = { + val m = module(ModuleID("com.example", "foo", "0.1.0", Some("compile")), + Seq(scalaCompiler, scalaContinuationPlugin), None, defaultUpdateOptions) + val report = ivyUpdate(m) + val jars = + for { + conf <- report.configurations + if conf.configuration == ScalaTool.name + m <- conf.modules + if (m.module.name contains "scala-compiler") + (a, f) <- m.artifacts + if a.extension == "jar" + } yield f + jars must haveSize(1) + } + + def resolveSbtPlugins = { + + def sha(f: java.io.File): String = sbt.Hash.toHex(sbt.Hash(f)) + def findSbtIdeaJars(dep: ModuleID, name: String) = { + val m = module(ModuleID("com.example", name, "0.1.0", Some("compile")), Seq(dep), None, defaultUpdateOptions) + val report = ivyUpdate(m) + for { + conf <- report.configurations + if conf.configuration == "compile" + m <- conf.modules + if (m.module.name contains "sbt-idea") + (a, f) <- m.artifacts + if a.extension == "jar" + } yield (f, sha(f)) + } + + val oldJars = findSbtIdeaJars(oldSbtPlugin, "old") + System.err.println(s"${oldJars.mkString("\n")}") + val newJars = findSbtIdeaJars(sbtPlugin, "new") + System.err.println(s"${newJars.mkString("\n")}") + (newJars must haveSize(1)) and (oldJars must haveSize(1)) and (oldJars.map(_._2) must not(containTheSameElementsAs(newJars.map(_._2)))) + } + + def resolveSnapshotPubDate = { + val m = module(ModuleID("com.example", "foo", "0.1.0", Some("compile")), Seq(testSnapshot), Some("2.10.2"), defaultUpdateOptions.withLatestSnapshots(true)) + val report = ivyUpdate(m) + val pubTime = + for { + conf <- report.configurations + if conf.configuration == "compile" + m <- conf.modules + if m.module.revision endsWith "-SNAPSHOT" + date <- m.publicationDate + } yield date + (pubTime must haveSize(1)) + } + + def resolvePomArtifactAndDependencies = { + val m = module(ModuleID("com.example", "foo", "0.1.0", Some("compile")), Seq(scalaLibraryAll), Some("2.10.2"), defaultUpdateOptions) + val report = ivyUpdate(m) + val jars = + for { + conf <- report.configurations + if conf.configuration == "compile" + m <- conf.modules + if (m.module.name == "scala-library") || (m.module.name contains "parser") + (a, f) <- m.artifacts + if a.extension == "jar" + } yield f + jars must haveSize(2) + } + + def failIfPomMissing = { + // TODO - we need the jar to not exist too. + val m = module(ModuleID("com.example", "foo", "0.1.0", Some("compile")), Seq(ModuleID("org.scala-sbt", "does-not-exist", "1.0", Some("compile"))), Some("2.10.2"), defaultUpdateOptions) + ivyUpdate(m) must throwAn[Exception] + } + + def failIfMainArtifactMissing = { + val m = module(ModuleID("com.example", "foo", "0.1.0", Some("compile")), Seq(jmxri), Some("2.10.2"), defaultUpdateOptions) + ivyUpdate(m) must throwAn[Exception] + } + + def resolveNonstandardClassifier = { + val m = module(ModuleID("com.example", "foo", "0.1.0", Some("compile")), Seq(testngJdk5), Some("2.10.2"), defaultUpdateOptions) + val report = ivyUpdate(m) + val jars = + for { + conf <- report.configurations + if conf.configuration == "compile" + m <- conf.modules + if m.module.name == "testng" + (a, f) <- m.artifacts + if a.extension == "jar" + } yield f + (report.configurations must haveSize(configurations.size)) and + (jars must haveSize(1)) + (jars.forall(_.exists) must beTrue) + + } + + def resolveTransitiveMavenDependency = { + val m = module(ModuleID("com.example", "foo", "0.1.0", Some("compile")), Seq(akkaActor), Some("2.10.2"), defaultUpdateOptions) + val report = ivyUpdate(m) + val jars = + for { + conf <- report.configurations + if conf.configuration == "compile" + m <- conf.modules + if m.module.name == "scala-library" + (a, f) <- m.artifacts + if a.extension == "jar" + } yield f + (report.configurations must haveSize(configurations.size)) and + (jars must not(beEmpty)) and + (jars.forall(_.exists) must beTrue) + + } + + def resolveIntransitiveMavenDependency = { + val m = module(ModuleID("com.example", "foo", "0.1.0", Some("compile")), Seq(akkaActorTestkit.intransitive()), Some("2.10.2"), defaultUpdateOptions) + val report = ivyUpdate(m) + val transitiveJars = + for { + conf <- report.configurations + if conf.configuration == "compile" + m <- conf.modules + if (m.module.name contains "akka-actor") && !(m.module.name contains "testkit") + (a, f) <- m.artifacts + if a.extension == "jar" + } yield f + val directJars = + for { + conf <- report.configurations + if conf.configuration == "compile" + m <- conf.modules + if (m.module.name contains "akka-actor") && (m.module.name contains "testkit") + (a, f) <- m.artifacts + if a.extension == "jar" + } yield f + (report.configurations must haveSize(configurations.size)) and + (transitiveJars must beEmpty) and (directJars.forall(_.exists) must beTrue) + } + + def resolveTransitiveConfigurationMavenDependency = { + val m = module(ModuleID("com.example", "foo", "0.1.0", Some("compile")), Seq(akkaActorTestkit), Some("2.10.2"), defaultUpdateOptions) + val report = ivyUpdate(m) + val jars = + for { + conf <- report.configurations + if conf.configuration == "test" + m <- conf.modules + if m.module.name contains "akka-actor" + (a, f) <- m.artifacts + if a.extension == "jar" + } yield f + (report.configurations must haveSize(configurations.size)) and + (jars must not(beEmpty)) and + (jars.forall(_.exists) must beTrue) + + } + + def resolveSourceAndJavadoc = { + val m = module( + ModuleID("com.example", "foo", "0.1.0", Some("sources")), + Seq(akkaActor.artifacts(Artifact(akkaActor.name, "javadoc"), Artifact(akkaActor.name, "sources"))), + Some("2.10.2"), + defaultUpdateOptions + ) + val report = ivyUpdate(m) + val jars = + for { + conf <- report.configurations + // We actually injected javadoc/sources into the compile scope, due to how we did the request. + // SO, we report that here. + if conf.configuration == "compile" + m <- conf.modules + (a, f) <- m.artifacts + if (f.getName contains "sources") || (f.getName contains "javadoc") + } yield f + (report.configurations must haveSize(configurations.size)) and + (jars must haveSize(2)) + } + + def publishMavenMetadata = { + val m = module( + ModuleID("com.example", "test-it", "1.0-SNAPSHOT", Some("compile")), + Seq(), + None, + defaultUpdateOptions.withLatestSnapshots(true) + ) + sbt.IO.withTemporaryDirectory { dir => + val pomFile = new java.io.File(dir, "pom.xml") + sbt.IO.write(pomFile, + """ + | + | com.example + | test-it + | 1.0-SNAPSHOT + | + """.stripMargin) + val jarFile = new java.io.File(dir, "test-it-1.0-SNAPSHOT.jar") + sbt.IO.touch(jarFile) + System.err.println(s"DEBUGME - Publishing $m to ${Resolver.publishMavenLocal}") + ivyPublish(m, mkPublishConfiguration( + Resolver.publishMavenLocal, + Map( + Artifact("test-it-1.0-SNAPSHOT.jar") -> pomFile, + Artifact("test-it-1.0-SNAPSHOT.pom", "pom", "pom") -> jarFile + ))) + } + val baseLocalMavenDir: java.io.File = Resolver.publishMavenLocal.rootFile + val allFiles: Seq[java.io.File] = sbt.PathFinder(new java.io.File(baseLocalMavenDir, "com/example/test-it")).***.get + val metadataFiles = allFiles.filter(_.getName contains "maven-metadata-local") + // TODO - maybe we check INSIDE the metadata, or make sure we can get a publication date on resolve... + // We end up with 4 files, two mavne-metadata files, and 2 maven-metadata-local files. + metadataFiles must haveSize(2) + } + +} + diff --git a/main/actions/src/main/scala/sbt/CacheIvy.scala b/main/actions/src/main/scala/sbt/CacheIvy.scala index b3fb41adb..8560fcab4 100644 --- a/main/actions/src/main/scala/sbt/CacheIvy.scala +++ b/main/actions/src/main/scala/sbt/CacheIvy.scala @@ -156,6 +156,7 @@ object CacheIvy { implicit def moduleConfIC: InputCache[ModuleConfiguration] = wrapIn object L3 { + implicit def mavenCacheToHL = (m: MavenCache) => m.name :+: m.rootFile.getAbsolutePath :+: HNil implicit def mavenRToHL = (m: MavenRepository) => m.name :+: m.root :+: HNil implicit def fileRToHL = (r: FileRepository) => r.name :+: r.configuration :+: r.patterns :+: HNil implicit def urlRToHL = (u: URLRepository) => u.name :+: u.patterns :+: HNil @@ -169,7 +170,7 @@ object CacheIvy { implicit lazy val chainedIC: InputCache[ChainedResolver] = InputCache.lzy(wrapIn) implicit lazy val resolverIC: InputCache[Resolver] = - unionInputCache[Resolver, ChainedResolver :+: JavaNet1Repository :+: MavenRepository :+: FileRepository :+: URLRepository :+: SshRepository :+: SftpRepository :+: RawRepository :+: HNil] + unionInputCache[Resolver, ChainedResolver :+: JavaNet1Repository :+: MavenRepository :+: MavenCache :+: FileRepository :+: URLRepository :+: SshRepository :+: SftpRepository :+: RawRepository :+: HNil] implicit def moduleIC: InputCache[ModuleID] = wrapIn implicitly[InputCache[Seq[Configuration]]] diff --git a/notes/0.13.8/aether-resolvers.markdown b/notes/0.13.8/aether-resolvers.markdown new file mode 100644 index 000000000..5becc7e85 --- /dev/null +++ b/notes/0.13.8/aether-resolvers.markdown @@ -0,0 +1,44 @@ + [@jsuereth]: https://github.com/jsuereth + [1676]: https://github.com/sbt/sbt/issues/1676 + [1322]: https://github.com/sbt/sbt/issues/1322 + [679]: https://github.com/sbt/sbt/issues/679 + [647]: https://github.com/sbt/sbt/issues/647 + [1616]: https://github.com/sbt/sbt/issues/1616 + +### Fixes with compatibility implications + +### Improvements + +### Aether Resolution + +sbt 0.13.8 adds the ability to use Eclipse Aether to resolve maven dependencies. This is designed to work within Ivy +so that both Aether + Ivy dependencies cohesively depend on each other. + +The key called `updateOptions` has been expanded to enable Aether resolutions via the following setting: + + updateOptions := updateOptions.value.withAetherResolution(true) + +This will create a new `~/.ivy2/maven-cache` directory which contains the Aether cache of files. You may notice some +file will be re-downloaded for the new cache layout. Additionally, sbt will now be able to fully construct +`maven-metadata.xml` files when publishing to remote repositories or when publishing to the local `~/.m2/repository`. +This should help erase many of the deficiencies encountered when using Maven and sbt together. + +Note: The setting must be places on EVERY subproject within a build if you wish to fully use Aether for all projects. + +Known limitations: + +* The current implementation does not support ivy-style version numbers, such as "2.10.+" or "latest.snapshot". This + is a fixable situation, but the version range query and Ivy -> Maven version range translation code has not been migrated. + + + +### Bug fixes + +- sbt doens't honor Maven's uniqueVersions (use aether resolver to fix). [#1322][1322] by [@jsuereth][@jsuereth] +- sbt doens't see new SNAPSHOT dependency versions in local maven repos (use withLatestSnapshots + aether resolver to fix) [#321][321] by [@jsuereth][@jsuereth] +- Property in pom's version field results to wrong dependency resolution (use aether resolver to fix). [#647][647] by [@jsuereth][@jsuereth] +- Maven local resolver with parent POM (use aether resolver). [#1616][1616] by [@jsuereth][@jsuereth] + +// Possibly fixed, need verification. +- 1676 - SNAPSHOT dependency not updated ??? +- 679 - Incorrect Maven Snapshot file resolution ???? \ No newline at end of file diff --git a/project/Dependencies.scala b/project/Dependencies.scala index 887324c4f..cefb127ad 100644 --- a/project/Dependencies.scala +++ b/project/Dependencies.scala @@ -27,4 +27,41 @@ object Dependencies { } lazy val scalaXml = scala211Module("scala-xml", "1.0.1") lazy val scalaParsers = scala211Module("scala-parser-combinators", "1.0.1") + + // Maven related dependnecy craziness + //val mvnEmbedder = "org.apache.maven" % "maven-embedder" % mvnVersion + val mvnWagonVersion = "2.4" + val mvnVersion = "3.2.3" + val aetherVersion = "1.0.1.v20141111" + + val mvnAether = "org.apache.maven" % "maven-aether-provider" % mvnVersion + val aether = "org.eclipse.aether" % "aether" % aetherVersion + val aetherImpl = "org.eclipse.aether" % "aether-impl" % aetherVersion + val aetherUtil = "org.eclipse.aether" % "aether-util" % aetherVersion + val aetherTransportFile = "org.eclipse.aether" % "aether-transport-file" % aetherVersion + val aetherTransportWagon = "org.eclipse.aether" % "aether-transport-wagon" % aetherVersion + val aetherTransportHttp = "org.eclipse.aether" % "aether-transport-http" % aetherVersion + val aetherConnectorBasic = "org.eclipse.aether" % "aether-connector-basic" % aetherVersion + val sisuPlexus = ("org.eclipse.sisu" % "org.eclipse.sisu.plexus" % "0.3.0.M1").exclude("javax.enterprise", "cdi-api").exclude("com.google.code.findbugs", "jsr305") + val guice = "com.google.inject" % "guice" % "3.0" + val guava = "com.google.guava" % "guava" % "18.0" + val javaxInject = "javax.inject" % "javax.inject" % "1" + + //val sisuGuice = ("org.eclipse.sisu" % "sisu-guice" % "3.1.0").classifier("no_aop").exclude("javax.enterprise", "cdi-api", ) + + /* + val mvnWagon = "org.apache.maven.wagon" % "wagon-http" % mvnWagonVersion + val mvnWagonProviderApi = "org.apache.maven.wagon" % "wagon-provider-api" % mvnWagonVersion + val mvnWagonLwHttp = "org.apache.maven.wagon" % "wagon-http-lightweight" % mvnWagonVersion + val mvnWagonFile = "org.apache.maven.wagon" % "wagon-file" % mvnWagonVersion + */ + def aetherLibs = + Seq( + guava, + javaxInject, + sisuPlexus, + aetherImpl, + aetherConnectorBasic, + mvnAether) + } diff --git a/project/Util.scala b/project/Util.scala index 6217cce8b..ed39672a0 100644 --- a/project/Util.scala +++ b/project/Util.scala @@ -135,6 +135,7 @@ object %s { sourceGenerators <+= generateKeywords map (x => Seq(x)) )) } + object Licensed { lazy val notice = SettingKey[File]("notice") lazy val extractLicenses = TaskKey[Seq[File]]("extract-licenses") diff --git a/sbt/src/sbt-test/dependency-management/cache-classifiers/a/build.sbt b/sbt/src/sbt-test/dependency-management/cache-classifiers/a/build.sbt index 66e3e8487..6a81f8446 100644 --- a/sbt/src/sbt-test/dependency-management/cache-classifiers/a/build.sbt +++ b/sbt/src/sbt-test/dependency-management/cache-classifiers/a/build.sbt @@ -6,4 +6,6 @@ version := "1.0.0-SNAPSHOT" publishArtifact in (Test,packageBin) := true -publishTo := Some(Resolver.file("demo", (baseDirectory in ThisBuild).value / "demo-repo")) +publishTo := Some(MavenCache("demo", ((baseDirectory in ThisBuild).value / "demo-repo"))) + +//Resolver.file("demo", (baseDirectory in ThisBuild).value / "demo-repo")) diff --git a/sbt/src/sbt-test/dependency-management/cache-classifiers/b/build.sbt b/sbt/src/sbt-test/dependency-management/cache-classifiers/b/build.sbt index 093ba87bc..b57c5eff7 100644 --- a/sbt/src/sbt-test/dependency-management/cache-classifiers/b/build.sbt +++ b/sbt/src/sbt-test/dependency-management/cache-classifiers/b/build.sbt @@ -1,7 +1,7 @@ libraryDependencies += "org.example" %% "artifacta" % "1.0.0-SNAPSHOT" withSources() classifier("tests") externalResolvers := Seq( - "demo" at ( (baseDirectory in ThisBuild).value / "demo-repo").toURI.toString, + MavenCache("demo", ((baseDirectory in ThisBuild).value / "demo-repo")), DefaultMavenRepository ) diff --git a/sbt/src/sbt-test/dependency-management/configurations/build.sbt b/sbt/src/sbt-test/dependency-management/configurations/build.sbt index ae702547f..0bd0da113 100644 --- a/sbt/src/sbt-test/dependency-management/configurations/build.sbt +++ b/sbt/src/sbt-test/dependency-management/configurations/build.sbt @@ -1,7 +1,7 @@ // the default, but make it explicit publishMavenStyle := true -publishTo <<= baseDirectory(bd => Some( Resolver.file("test-repo", bd / "repo") ) ) +publishTo <<= baseDirectory(bd => Some( MavenRepository("test-repo", (bd / "repo").toURI.toASCIIString )) ) name := "test" diff --git a/sbt/src/sbt-test/dependency-management/cross-ivy-maven/build.sbt b/sbt/src/sbt-test/dependency-management/cross-ivy-maven/build.sbt index 60a2d2c01..b07c2caeb 100644 --- a/sbt/src/sbt-test/dependency-management/cross-ivy-maven/build.sbt +++ b/sbt/src/sbt-test/dependency-management/cross-ivy-maven/build.sbt @@ -3,6 +3,8 @@ val repoFile = file("mvn-repo") resolvers += "bad-mvn-repo" at repoFile.toURI.toURL.toString +resolvers += Resolver.typesafeIvyRepo("releases") + libraryDependencies += "bad" % "mvn" % "1.0" TaskKey[Unit]("check") := { diff --git a/sbt/src/sbt-test/dependency-management/mvn-local/build.sbt b/sbt/src/sbt-test/dependency-management/mvn-local/build.sbt index f56f1ba15..65715e00d 100644 --- a/sbt/src/sbt-test/dependency-management/mvn-local/build.sbt +++ b/sbt/src/sbt-test/dependency-management/mvn-local/build.sbt @@ -12,13 +12,16 @@ lazy val main = project. settings( uniqueName, libraryDependencies += (projectID in library).value, - fullResolvers := fullResolvers.value.filterNot(_.name == "inter-project") + fullResolvers := fullResolvers.value.filterNot(_.name == "inter-project"), + // TODO - should this not be needed? + updateOptions := updateOptions.value.withLatestSnapshots(true).withAetherResolution(true) ) lazy val library = project. settings(commonSettings: _*). settings( - uniqueName + uniqueName, + updateOptions := updateOptions.value.withAetherResolution(true) ) def uniqueName = diff --git a/sbt/src/sbt-test/dependency-management/mvn-local/test b/sbt/src/sbt-test/dependency-management/mvn-local/test index 1050ee336..2740387f2 100644 --- a/sbt/src/sbt-test/dependency-management/mvn-local/test +++ b/sbt/src/sbt-test/dependency-management/mvn-local/test @@ -19,6 +19,7 @@ $ copy-file changes/mainB1.scala main/B.scala -> main/compile $ copy-file changes/libA.scala library/A.scala +> debug > library/publishM2 # should succeed even without 'update' because Ivy should use the jar from the origin and not copy it to its cache > main/compile diff --git a/sbt/src/sbt-test/dependency-management/pom-advanced/test b/sbt/src/sbt-test/dependency-management/pom-advanced/test index 792d32857..db838494e 100644 --- a/sbt/src/sbt-test/dependency-management/pom-advanced/test +++ b/sbt/src/sbt-test/dependency-management/pom-advanced/test @@ -1,9 +1,9 @@ # write the default pom. The only repositories should be Scala Tools Releases and Snapshots -> check-pom https://oss.sonatype.org/content/repositories/releases/ https://oss.sonatype.org/content/repositories/snapshots/ +> check-pom https://oss.sonatype.org/content/repositories/releases https://oss.sonatype.org/content/repositories/snapshots # include file:// repositories. The generated repositories section should include the local Maven repository as well $ touch repo.all -> check-pom https://oss.sonatype.org/content/repositories/releases/ https://oss.sonatype.org/content/repositories/snapshots/ file://*.m2/repository/ +> check-pom https://oss.sonatype.org/content/repositories/releases https://oss.sonatype.org/content/repositories/snapshots file://*.m2/repository # include file:// repositories. The generated repositories section should include the local Maven repository as well $ delete repo.all diff --git a/sbt/src/sbt-test/dependency-management/pom-parent-pom/build.sbt b/sbt/src/sbt-test/dependency-management/pom-parent-pom/build.sbt new file mode 100644 index 000000000..53d830e83 --- /dev/null +++ b/sbt/src/sbt-test/dependency-management/pom-parent-pom/build.sbt @@ -0,0 +1,22 @@ +name := "test-parent-pom" + +val localMavenRepo = file("local-repo") + val cleanExampleCache = taskKey[Unit]("Cleans the example cache.") + +resolvers += + MavenRepository("Maven2 Local Test", localMavenRepo.toURI.toString) + + +libraryDependencies += + "com.example" % "example-child" % "1.0-SNAPSHOT" + +version := "1.0-SNAPSHOT" + + +cleanExampleCache := { + ivySbt.value.withIvy(streams.value.log) { ivy => + val cacheDir = ivy.getSettings.getDefaultRepositoryCacheBasedir + // TODO - Is this actually ok? + IO.delete(cacheDir / "com.example") + } +} diff --git a/sbt/src/sbt-test/dependency-management/pom-parent-pom/local-repo/com/example/example-child/1.0-SNAPSHOT/_maven.repositories b/sbt/src/sbt-test/dependency-management/pom-parent-pom/local-repo/com/example/example-child/1.0-SNAPSHOT/_maven.repositories new file mode 100644 index 000000000..461d5e15d --- /dev/null +++ b/sbt/src/sbt-test/dependency-management/pom-parent-pom/local-repo/com/example/example-child/1.0-SNAPSHOT/_maven.repositories @@ -0,0 +1,4 @@ +#NOTE: This is an internal implementation file, its format can be changed without prior notice. +#Tue Dec 16 09:06:35 EST 2014 +example-child-1.0-SNAPSHOT.jar>= +example-child-1.0-SNAPSHOT.pom>= diff --git a/sbt/src/sbt-test/dependency-management/pom-parent-pom/local-repo/com/example/example-child/1.0-SNAPSHOT/example-child-1.0-SNAPSHOT.jar b/sbt/src/sbt-test/dependency-management/pom-parent-pom/local-repo/com/example/example-child/1.0-SNAPSHOT/example-child-1.0-SNAPSHOT.jar new file mode 100644 index 0000000000000000000000000000000000000000..a2a5e09d23a49c1e914ac35a69383622bd285587 GIT binary patch literal 1460 zcmWIWW@h1H0D(&$6I{UzD8UJ&eO*Hwbv^yu^aG&EI2bMhm3bRsgZ*3~+9=KSU$gDb`lo)+nNojal9t?R_W{$xqm6fx}s zDiu5DbO#B02L+eR)mkee!!0z~I7qZc_;k=`pp2JsvDbk|kw=%VbX}<`DX>u_cKwu` z39M;VY#-H@?TOhF!vJ#{rVsd$otB$emYN6m2c}|aOvTChxq7J;iMa(isdzMM;@1c@ zKsPxfGbaUZ3sMXo-lUf`h9K@&T z8(QG$8)jetKMrp&gh=-eCnm6b<)S%M~{)qxwT}nu~Bi*4qy^yWD;S{QrLl$b_2!%S$lpvF9d)=J%MIQS%mV zgFv|p0zj_N0A?06S0EdNp4VW;V$W?bgSRy1lVU71?;(N?d&)zYeh`?uiFP!|bVND~ T@MdKL8N?2Rl0aixnL#`N)>5<_ literal 0 HcmV?d00001 diff --git a/sbt/src/sbt-test/dependency-management/pom-parent-pom/local-repo/com/example/example-child/1.0-SNAPSHOT/example-child-1.0-SNAPSHOT.pom b/sbt/src/sbt-test/dependency-management/pom-parent-pom/local-repo/com/example/example-child/1.0-SNAPSHOT/example-child-1.0-SNAPSHOT.pom new file mode 100644 index 000000000..1912aef83 --- /dev/null +++ b/sbt/src/sbt-test/dependency-management/pom-parent-pom/local-repo/com/example/example-child/1.0-SNAPSHOT/example-child-1.0-SNAPSHOT.pom @@ -0,0 +1,16 @@ + + + 4.0.0 + + + com.example + example-parent + 1.0-SNAPSHOT + + + com.example + example-child + 1.0-SNAPSHOT + jar + + diff --git a/sbt/src/sbt-test/dependency-management/pom-parent-pom/local-repo/com/example/example-child/1.0-SNAPSHOT/maven-metadata-local.xml b/sbt/src/sbt-test/dependency-management/pom-parent-pom/local-repo/com/example/example-child/1.0-SNAPSHOT/maven-metadata-local.xml new file mode 100644 index 000000000..bbe40373c --- /dev/null +++ b/sbt/src/sbt-test/dependency-management/pom-parent-pom/local-repo/com/example/example-child/1.0-SNAPSHOT/maven-metadata-local.xml @@ -0,0 +1,24 @@ + + + com.example + example-child + 1.0-SNAPSHOT + + + true + + 20141216140635 + + + jar + 1.0-SNAPSHOT + 20141216140635 + + + pom + 1.0-SNAPSHOT + 20141216140635 + + + + diff --git a/sbt/src/sbt-test/dependency-management/pom-parent-pom/local-repo/com/example/example-child/maven-metadata-local.xml b/sbt/src/sbt-test/dependency-management/pom-parent-pom/local-repo/com/example/example-child/maven-metadata-local.xml new file mode 100644 index 000000000..2facbd8e1 --- /dev/null +++ b/sbt/src/sbt-test/dependency-management/pom-parent-pom/local-repo/com/example/example-child/maven-metadata-local.xml @@ -0,0 +1,11 @@ + + + com.example + example-child + + + 1.0-SNAPSHOT + + 20141216140635 + + diff --git a/sbt/src/sbt-test/dependency-management/pom-parent-pom/local-repo/com/example/example-parent/1.0-SNAPSHOT/_maven.repositories b/sbt/src/sbt-test/dependency-management/pom-parent-pom/local-repo/com/example/example-parent/1.0-SNAPSHOT/_maven.repositories new file mode 100644 index 000000000..ccab5d80d --- /dev/null +++ b/sbt/src/sbt-test/dependency-management/pom-parent-pom/local-repo/com/example/example-parent/1.0-SNAPSHOT/_maven.repositories @@ -0,0 +1,3 @@ +#NOTE: This is an internal implementation file, its format can be changed without prior notice. +#Tue Dec 16 09:01:47 EST 2014 +example-parent-1.0-SNAPSHOT.pom>= diff --git a/sbt/src/sbt-test/dependency-management/pom-parent-pom/local-repo/com/example/example-parent/1.0-SNAPSHOT/example-parent-1.0-SNAPSHOT.pom b/sbt/src/sbt-test/dependency-management/pom-parent-pom/local-repo/com/example/example-parent/1.0-SNAPSHOT/example-parent-1.0-SNAPSHOT.pom new file mode 100644 index 000000000..364d37255 --- /dev/null +++ b/sbt/src/sbt-test/dependency-management/pom-parent-pom/local-repo/com/example/example-parent/1.0-SNAPSHOT/example-parent-1.0-SNAPSHOT.pom @@ -0,0 +1,10 @@ + + + 4.0.0 + + com.example + example-parent + 1.0-SNAPSHOT + pom + + diff --git a/sbt/src/sbt-test/dependency-management/pom-parent-pom/local-repo/com/example/example-parent/1.0-SNAPSHOT/maven-metadata-local.xml b/sbt/src/sbt-test/dependency-management/pom-parent-pom/local-repo/com/example/example-parent/1.0-SNAPSHOT/maven-metadata-local.xml new file mode 100644 index 000000000..4ead096b3 --- /dev/null +++ b/sbt/src/sbt-test/dependency-management/pom-parent-pom/local-repo/com/example/example-parent/1.0-SNAPSHOT/maven-metadata-local.xml @@ -0,0 +1,19 @@ + + + com.example + example-parent + 1.0-SNAPSHOT + + + true + + 20141216140147 + + + pom + 1.0-SNAPSHOT + 20141216140147 + + + + diff --git a/sbt/src/sbt-test/dependency-management/pom-parent-pom/local-repo/com/example/example-parent/maven-metadata-local.xml b/sbt/src/sbt-test/dependency-management/pom-parent-pom/local-repo/com/example/example-parent/maven-metadata-local.xml new file mode 100644 index 000000000..7f9f36778 --- /dev/null +++ b/sbt/src/sbt-test/dependency-management/pom-parent-pom/local-repo/com/example/example-parent/maven-metadata-local.xml @@ -0,0 +1,11 @@ + + + com.example + example-parent + + + 1.0-SNAPSHOT + + 20141216140147 + + diff --git a/sbt/src/sbt-test/dependency-management/pom-parent-pom/test b/sbt/src/sbt-test/dependency-management/pom-parent-pom/test new file mode 100644 index 000000000..c0f560f2f --- /dev/null +++ b/sbt/src/sbt-test/dependency-management/pom-parent-pom/test @@ -0,0 +1,2 @@ +> cleanExampleCache +> update \ No newline at end of file diff --git a/sbt/src/sbt-test/dependency-management/snapshot-resolution/build.sbt b/sbt/src/sbt-test/dependency-management/snapshot-resolution/build.sbt index b9bf6cf04..4aaacae00 100644 --- a/sbt/src/sbt-test/dependency-management/snapshot-resolution/build.sbt +++ b/sbt/src/sbt-test/dependency-management/snapshot-resolution/build.sbt @@ -21,6 +21,7 @@ lazy val common = project. case repo: PatternsBasedRepository => repo.patterns.isMavenCompatible case _: RawRepository => false // TODO - look deeper case _: MavenRepository => true + case _: MavenCache => true case _ => false // TODO - Handle chain repository? } case _ => true diff --git a/sbt/src/sbt-test/dependency-management/snapshot-resolution/pending b/sbt/src/sbt-test/dependency-management/snapshot-resolution/pending index e69de29bb..85317974a 100644 --- a/sbt/src/sbt-test/dependency-management/snapshot-resolution/pending +++ b/sbt/src/sbt-test/dependency-management/snapshot-resolution/pending @@ -0,0 +1,35 @@ +# Validate that a bad dependency fails the compile +$ copy-file changes/BadCommon.scala common/src/main/scala/Common.scala +> common/publish + +# Force dep resolution to be successful, then compilation to fail +> dependent/update +-> dependent/compile + +# Push new good change to a DIFFERENT repository. +$ copy-file changes/GoodCommon.scala common/src/main/scala/Common.scala +# Sleep to ensure timestamp change +$ sleep 1000 +> common/publishLocal + +# This should compile now, because Ivy should look at each repository for the most up-to-date file. +> dependent/update +> dependent/compile + +# Now let's try this on the opposite order: pubishLocal => publish +$ copy-file changes/BadCommon.scala common/src/main/scala/Common.scala +> common/publishLocal + +# Force dep resolution to be successful, then compilation to fail +> dependent/update +-> dependent/compile + +# Push new good change to a DIFFERENT repository. +$ copy-file changes/GoodCommon.scala common/src/main/scala/Common.scala +# Sleep to ensure timestamp change +$ sleep 1000 +> common/publish + +# This should compile now gain, because Ivy should look at each repository for the most up-to-date file. +> dependent/update +> dependent/compile diff --git a/sbt/src/sbt-test/dependency-management/t468/build.sbt b/sbt/src/sbt-test/dependency-management/t468/build.sbt index a47ffb223..99b52332b 100644 --- a/sbt/src/sbt-test/dependency-management/t468/build.sbt +++ b/sbt/src/sbt-test/dependency-management/t468/build.sbt @@ -16,7 +16,8 @@ TaskKey[Unit]("check-update") <<= update map { report => TaskKey[Unit]("check-classpath") <<= dependencyClasspath in Compile map { cp => val jars = cp.files.map(_.getName).toSet - val expected = Set("org.sat4j.pb-2.3.1.jar", "org.sat4j.core-2.3.1.jar") + // Note: pb depends on tests artifact in core for no good reason. Previously this was not correctly added to the classpath. + val expected = Set("org.sat4j.pb-2.3.1.jar", "org.sat4j.core-2.3.1.jar", "org.sat4j.core-2.3.1-tests.jar") if(jars != expected) error("Expected jars " + expected + ", got: " + jars) } \ No newline at end of file