luke
/
sbt
mirror of https://github.com/sbt/sbt.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Start to use bits of the high level API of coursier 

Its parameters mostly
This commit is contained in:
Alexandre Archambault 2019-02-06 15:22:42 -08:00
parent 4226df911d
commit bc69e0b11a
7 changed files with 84 additions and 89 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
modules/lm-coursier/src/main/scala/coursier/lmcoursier/ArtifactsParams.scala
View File

@ -1,23 +1,15 @@
package coursier.lmcoursier
import java.io.File
import coursier.cache.CacheLogger
import coursier.{Cache, CachePolicy}
import coursier.core.{Classifier, Resolution}
import scala.concurrent.duration.Duration
import coursier.params.CacheParams
final case class ArtifactsParams(
classifiers: Option[Seq[Classifier]],
res: Seq[Resolution],
includeSignatures: Boolean,
parallelDownloads: Int,
createLogger: () => CacheLogger,
cache: File,
artifactsChecksums: Seq[Option[String]],
ttl: Option[Duration],
cachePolicies: Seq[CachePolicy],
projectName: String,
sbtClassifiers: Boolean
sbtClassifiers: Boolean,
cacheParams: CacheParams
)

10
modules/lm-coursier/src/main/scala/coursier/lmcoursier/ArtifactsRun.scala
View File

@ -39,18 +39,18 @@ object ArtifactsRun {
val printOptionalMessage = verbosityLevel >= 0 && verbosityLevel <= 1
val artifactFilesOrErrors = try {
pool = Schedulable.fixedThreadPool(params.parallelDownloads)
pool = Schedulable.fixedThreadPool(params.cacheParams.parallel)
artifactsLogger = params.createLogger()
val artifactFileOrErrorTasks = allArtifacts.toVector.distinct.map { a =>
Cache.file[Task](
a,
params.cache,
params.cachePolicies,
checksums = params.artifactsChecksums,
params.cacheParams.cacheLocation,
params.cacheParams.cachePolicies,
checksums = params.cacheParams.checksum,
logger = Some(artifactsLogger),
pool = pool,
ttl = params.ttl
ttl = params.cacheParams.ttl
)
.run
.map((a, _))

41
modules/lm-coursier/src/main/scala/coursier/lmcoursier/CoursierDependencyResolution.scala
View File

@ -2,12 +2,13 @@ package coursier.lmcoursier
import java.io.{File, OutputStreamWriter}
import _root_.coursier.{Artifact, Cache, CachePolicy, FileError, Organization, Resolution, TermDisplay, organizationString}
import _root_.coursier.{Artifact, CachePolicy, FileError, Organization, Resolution, TermDisplay, organizationString}
import _root_.coursier.core.{Classifier, Configuration, ModuleName}
import _root_.coursier.extra.Typelevel
import _root_.coursier.ivy.IvyRepository
import _root_.coursier.lmcoursier.Inputs.withAuthenticationByHost
import coursier.cache.CacheDefaults
import coursier.params.CacheParams
import sbt.internal.librarymanagement.IvySbt
import sbt.librarymanagement._
import sbt.util.Logger
@ -143,25 +144,27 @@ class CoursierDependencyResolution(conf: CoursierConfiguration) extends Dependen
dependencies = dependencies,
fallbackDependencies = conf.fallbackDependencies,
configGraphs = configGraphs,
autoScalaLib = conf.autoScalaLibrary,
autoScalaLibOpt = if (conf.autoScalaLibrary) Some((so, sv)) else None,
mainRepositories = mainRepositories,
parentProjectCache = Map.empty,
interProjectDependencies = conf.interProjectDependencies,
internalRepositories = internalRepositories,
userEnabledProfiles = conf.mavenProfiles.toSet,
userForceVersions = Map.empty,
typelevel = typelevel,
so = so,
sv = sv,
sbtClassifiers = false,
parallelDownloads = conf.parallelDownloads,
projectName = projectName,
maxIterations = conf.maxIterations,
createLogger = createLogger,
cache = cache,
cachePolicies = cachePolicies,
ttl = ttl,
checksums = checksums
cacheParams = coursier.params.CacheParams(
cacheLocation = cache,
cachePolicies = cachePolicies,
ttl = ttl,
checksum = checksums,
parallel = conf.parallelDownloads
),
params = coursier.params.ResolutionParams(
maxIterations = conf.maxIterations,
profiles = conf.mavenProfiles.toSet,
forceVersion = Map.empty
)
)
def artifactsParams(resolutions: Map[Set[Configuration], Resolution]) =
@ -169,14 +172,16 @@ class CoursierDependencyResolution(conf: CoursierConfiguration) extends Dependen
classifiers = classifiers,
res = resolutions.values.toSeq,
includeSignatures = false,
parallelDownloads = conf.parallelDownloads,
createLogger = createLogger,
cache = cache,
artifactsChecksums = checksums,
ttl = ttl,
cachePolicies = cachePolicies,
projectName = projectName,
sbtClassifiers = false
sbtClassifiers = false,
cacheParams = CacheParams(
parallel = conf.parallelDownloads,
cacheLocation = cache,
checksum = checksums,
ttl = ttl,
cachePolicies = cachePolicies
)
)
val sbtBootJarOverrides = SbtBootJars(

31
modules/lm-coursier/src/main/scala/coursier/lmcoursier/ResolutionParams.scala
View File

@ -1,41 +1,31 @@
package coursier.lmcoursier
import java.io.File
import java.net.URL
import coursier.cache.CacheLogger
import coursier.{Cache, CachePolicy, FallbackDependenciesRepository, ProjectCache, Resolution, moduleNameString}
import coursier.{FallbackDependenciesRepository, ProjectCache, Resolution, moduleNameString}
import coursier.core._
import coursier.extra.Typelevel
import coursier.ivy.PropertiesPattern
import sbt.librarymanagement.{Resolver, URLRepository}
import scala.collection.mutable.ArrayBuffer
import scala.concurrent.duration.Duration
final case class ResolutionParams(
dependencies: Seq[(Configuration, Dependency)],
fallbackDependencies: Seq[FallbackDependency],
configGraphs: Seq[Set[Configuration]],
autoScalaLib: Boolean,
autoScalaLibOpt: Option[(Organization, String)],
mainRepositories: Seq[Repository],
parentProjectCache: ProjectCache,
interProjectDependencies: Seq[Project],
internalRepositories: Seq[Repository],
userEnabledProfiles: Set[String],
userForceVersions: Map[Module, String],
typelevel: Boolean,
so: Organization,
sv: String,
sbtClassifiers: Boolean,
parallelDownloads: Int,
projectName: String,
maxIterations: Int,
createLogger: () => CacheLogger,
cache: File,
cachePolicies: Seq[CachePolicy],
ttl: Option[Duration],
checksums: Seq[Option[String]]
cacheParams: coursier.params.CacheParams,
params: coursier.params.ResolutionParams
) {
val fallbackDependenciesRepositories =
@ -79,14 +69,17 @@ final case class ResolutionParams(
},
filter = noOptionalFilter,
userActivations =
if (userEnabledProfiles.isEmpty)
if (params.profiles.isEmpty)
None
else
Some(userEnabledProfiles.iterator.map(_ -> true).toMap),
Some(params.profiles.iterator.map(_ -> true).toMap),
forceVersions =
// order matters here
userForceVersions ++
(if (autoScalaLib && (configs(Configuration.compile) || configs(Configuration("scala-tool")))) forcedScalaModules(so, sv) else Map()) ++
params.forceVersion ++
autoScalaLibOpt
.filter(_ => configs(Configuration.compile) || configs(Configuration("scala-tool")))
.map { case (so, sv) => forcedScalaModules(so, sv) }
.getOrElse(Map.empty) ++
interProjectDependencies.map(_.moduleVersion),
projectCache = parentProjectCache,
mapDependencies = if (typelevel && (configs(Configuration.compile) || configs(Configuration("scala-tool")))) typelevelOrgSwap else None
@ -97,7 +90,7 @@ final case class ResolutionParams(
lazy val resolutionKey = SbtCoursierCache.ResolutionKey(
dependencies,
repositories,
userEnabledProfiles,
params.profiles,
allStartRes,
sbtClassifiers
)

6
modules/lm-coursier/src/main/scala/coursier/lmcoursier/ResolutionRun.scala
View File

@ -29,10 +29,10 @@ object ResolutionRun {
val printOptionalMessage = verbosityLevel >= 0 && verbosityLevel <= 1
val resOrError: Either[ResolutionError, Resolution] = try {
pool = Schedulable.fixedThreadPool(params.parallelDownloads)
pool = Schedulable.fixedThreadPool(params.cacheParams.parallel)
resLogger = params.createLogger()
val fetchs = Cache.fetchs[Task](params.cache, params.cachePolicies, checksums = params.checksums, logger = Some(resLogger), pool = pool, ttl = params.ttl)
val fetchs = Cache.fetchs[Task](params.cacheParams.cacheLocation, params.cacheParams.cachePolicies, checksums = params.cacheParams.checksum, logger = Some(resLogger), pool = pool, ttl = params.cacheParams.ttl)
val fetch = ResolutionProcess.fetch(
params.repositories,
@ -84,7 +84,7 @@ object ResolutionRun {
startRes
.process
.run(fetch, params.maxIterations)
.run(fetch, params.params.maxIterations)
.attempt
.unsafeRun()(ExecutionContext.fromExecutorService(pool))
.left

25
modules/sbt-coursier/src/main/scala/coursier/sbtcoursier/ArtifactsTasks.scala
View File

@ -5,6 +5,7 @@ import java.io.File
import coursier.{Artifact, FileError}
import coursier.core._
import coursier.lmcoursier._
import coursier.params.CacheParams
import coursier.sbtcoursier.Keys._
import coursier.sbtcoursiershared.SbtCoursierShared.autoImport.{coursierCache, coursierCreateLogger}
import sbt.Def
@ -53,17 +54,19 @@ object ArtifactsTasks {
val res = resTask.value
val params = ArtifactsParams(
classifiers,
res,
includeSignatures,
parallelDownloads,
createLogger.create,
cache,
artifactsChecksums,
ttl,
cachePolicies,
projectName,
sbtClassifiers
classifiers = classifiers,
res = res,
includeSignatures = includeSignatures,
createLogger = createLogger.create,
projectName = projectName,
sbtClassifiers = sbtClassifiers,
cacheParams = CacheParams(
parallel = parallelDownloads,
cacheLocation = cache,
checksum = artifactsChecksums,
ttl = ttl,
cachePolicies = cachePolicies
)
)
val resOrError = ArtifactsRun.artifacts(

46
modules/sbt-coursier/src/main/scala/coursier/sbtcoursier/ResolutionTasks.scala
View File

@ -123,28 +123,30 @@ object ResolutionTasks {
val resOrError = ResolutionRun.resolutions(
ResolutionParams(
currentProject.dependencies,
fallbackDependencies,
configGraphs,
autoScalaLib,
mainRepositories,
parentProjectCache,
interProjectDependencies,
internalRepositories,
userEnabledProfiles,
userForceVersions,
typelevel,
so,
sv,
sbtClassifiers,
parallelDownloads,
projectName,
maxIterations,
createLogger.create,
cache,
cachePolicies,
ttl,
checksums
dependencies = currentProject.dependencies,
fallbackDependencies = fallbackDependencies,
configGraphs = configGraphs,
autoScalaLibOpt = if (autoScalaLib) Some((so, sv)) else None,
mainRepositories = mainRepositories,
parentProjectCache = parentProjectCache,
interProjectDependencies = interProjectDependencies,
internalRepositories = internalRepositories,
typelevel = typelevel,
sbtClassifiers = sbtClassifiers,
projectName = projectName,
createLogger = createLogger.create,
cacheParams = coursier.params.CacheParams(
cacheLocation = cache,
cachePolicies = cachePolicies,
ttl = ttl,
checksum = checksums,
parallel = parallelDownloads
),
params = coursier.params.ResolutionParams(
maxIterations = maxIterations,
profiles = userEnabledProfiles,
forceVersion = userForceVersions
)
),
verbosityLevel,
log