-
Notifications
You must be signed in to change notification settings - Fork 26
/
ResolutionCache.scala
64 lines (55 loc) · 2.91 KB
/
ResolutionCache.scala
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
package sbt
import java.io.File
import org.apache.ivy.core
import core.IvyPatternHelper
import core.cache.{CacheMetadataOptions, DefaultRepositoryCacheManager, DefaultResolutionCacheManager, ResolutionCacheManager}
import core.module.id.ModuleRevisionId
import ResolutionCache.{Name, ReportDirectory, ResolvedName, ResolvedPattern}
/** Replaces the standard Ivy resolution cache in order to:
* 1. Separate cached resolved Ivy files from resolution reports, making the resolution reports easier to find.
* 2. Have them per-project for easier cleaning (possible with standard cache, but central to this custom one).
* 3. Cache location includes extra attributes so that cross builds of a plugin do not overwrite each other.
*/
private[sbt] final class ResolutionCache(base: File) extends ResolutionCacheManager
{
private[this] def resolvedFileInCache(m: ModuleRevisionId, name: String, ext: String): File = {
val p = ResolvedPattern
val f = IvyPatternHelper.substitute(p, m.getOrganisation, m.getName, m.getBranch, m.getRevision, name, name, ext, null, null, m.getAttributes, null)
new File(base, f)
}
private[this] def reportBase(resolveId: String): File =
new File(new File(base, ReportDirectory), resolveId)
def getResolutionCacheRoot: File = base
def clean() { IO.delete(base) }
override def toString = Name
def getResolvedIvyFileInCache(mrid: ModuleRevisionId): File =
resolvedFileInCache(mrid, ResolvedName, "xml")
def getResolvedIvyPropertiesInCache(mrid: ModuleRevisionId): File =
resolvedFileInCache(mrid, ResolvedName, "properties")
def getConfigurationResolveReportInCache(resolveId: String, conf: String): File =
new File(reportBase(resolveId), "/" + conf + "-" + ResolvedName)
def getConfigurationResolveReportsInCache(resolveId: String): Array[File] =
IO.listFiles(reportBase(resolveId)).flatMap(d => IO.listFiles(d))
}
private[sbt] object ResolutionCache
{
/** Removes cached files from the resolution cache for the module with ID `mrid`
* and the resolveId (as set on `ResolveOptions`). */
private[sbt] def cleanModule(mrid: ModuleRevisionId, resolveId: String, manager: ResolutionCacheManager)
{
val files =
Option(manager.getResolvedIvyFileInCache(mrid)).toList :::
Option(manager.getResolvedIvyPropertiesInCache(mrid)).toList :::
Option(manager.getConfigurationResolveReportsInCache(resolveId)).toList.flatten
IO.delete(files)
}
private val ReportDirectory = "reports"
// name of the file providing a dependency resolution report for a configuration
private val ReportFileName = "report.xml"
// base name (name except for extension) of resolution report file
private val ResolvedName = "resolved.xml"
// Cache name
private val Name = "sbt-resolution-cache"
// use sbt-specific extra attributes so that resolved xml files do not get overwritten when using different Scala/sbt versions
private val ResolvedPattern = "[organisation]/[module]/" + Resolver.PluginPattern + "[revision]/[artifact].[ext]"
}