Cache dependencies

daplf · daplf · commit 07812355784f · 2022-03-17T00:30:44.000Z
diff --git a/server/src/main/kotlin/org/javacs/kt/CompilerClassPath.kt b/server/src/main/kotlin/org/javacs/kt/CompilerClassPath.kt
@@ -3,6 +3,7 @@ package org.javacs.kt
 import org.javacs.kt.classpath.ClassPathEntry
 import org.javacs.kt.classpath.defaultClassPathResolver
 import org.javacs.kt.compiler.Compiler
+import org.javacs.kt.storage.Storage
 import org.javacs.kt.util.AsyncExecutor
 import java.io.Closeable
 import java.nio.file.FileSystems
@@ -17,6 +18,7 @@ class CompilerClassPath(private val config: CompilerConfiguration) : Closeable {
     private val javaSourcePath = mutableSetOf<Path>()
     private val buildScriptClassPath = mutableSetOf<Path>()
     val classPath = mutableSetOf<ClassPathEntry>()
+    var storage: Storage? = null
 
     var compiler = Compiler(javaSourcePath, classPath.map { it.compiledJar }.toSet(), buildScriptClassPath)
         private set
@@ -34,7 +36,7 @@ class CompilerClassPath(private val config: CompilerConfiguration) : Closeable {
         updateJavaSourcePath: Boolean = true
     ): Boolean {
         // TODO: Fetch class path and build script class path concurrently (and asynchronously)
-        val resolver = defaultClassPathResolver(workspaceRoots)
+        val resolver = defaultClassPathResolver(workspaceRoots, storage)
         var refreshCompiler = updateJavaSourcePath
 
         if (updateClassPath) {
diff --git a/server/src/main/kotlin/org/javacs/kt/KotlinLanguageServer.kt b/server/src/main/kotlin/org/javacs/kt/KotlinLanguageServer.kt
@@ -7,20 +7,22 @@ import org.eclipse.lsp4j.services.LanguageClient
 import org.eclipse.lsp4j.services.LanguageClientAware
 import org.eclipse.lsp4j.services.LanguageServer
 import org.javacs.kt.command.ALL_COMMANDS
-import org.javacs.kt.externalsources.JarClassContentProvider
+import org.javacs.kt.config.ServerConfiguration
+import org.javacs.kt.config.parseServerConfiguration
 import org.javacs.kt.externalsources.ClassPathSourceJarProvider
+import org.javacs.kt.externalsources.JarClassContentProvider
+import org.javacs.kt.progress.LanguageClientProgress
+import org.javacs.kt.progress.Progress
+import org.javacs.kt.semantictokens.semanticTokensLegend
 import org.javacs.kt.util.AsyncExecutor
 import org.javacs.kt.util.TemporaryDirectory
 import org.javacs.kt.util.parseURI
-import org.javacs.kt.progress.Progress
-import org.javacs.kt.progress.LanguageClientProgress
-import org.javacs.kt.semantictokens.semanticTokensLegend
-import java.net.URI
 import java.io.Closeable
 import java.nio.file.Paths
 import java.util.concurrent.CompletableFuture
 import java.util.concurrent.CompletableFuture.completedFuture
 
+
 class KotlinLanguageServer : LanguageServer, LanguageClientAware, Closeable {
     val config = Configuration()
     val classPath = CompilerClassPath(config.compiler)
@@ -43,6 +45,8 @@ class KotlinLanguageServer : LanguageServer, LanguageClientAware, Closeable {
             sourcePath.progressFactory = factory
         }
 
+    private var serverConfiguration: ServerConfiguration? = null
+
     companion object {
         val VERSION: String? = System.getProperty("kotlinLanguageServer.version")
     }
@@ -89,6 +93,10 @@ class KotlinLanguageServer : LanguageServer, LanguageClientAware, Closeable {
         serverCapabilities.documentRangeFormattingProvider = Either.forLeft(true)
         serverCapabilities.executeCommandProvider = ExecuteCommandOptions(ALL_COMMANDS)
 
+        serverConfiguration = parseServerConfiguration(params)
+
+        classPath.storage = serverConfiguration?.storage?.getSlice("classpath")
+
         val clientCapabilities = params.capabilities
         config.completion.snippets.enabled = clientCapabilities?.textDocument?.completion?.completionItem?.snippetSupport ?: false
 
diff --git a/server/src/main/kotlin/org/javacs/kt/config/Config.kt b/server/src/main/kotlin/org/javacs/kt/config/Config.kt
@@ -0,0 +1,45 @@
+package org.javacs.kt.config
+
+import com.google.gson.*
+import org.eclipse.lsp4j.InitializeParams
+import org.javacs.kt.LOG
+import org.javacs.kt.storage.Storage
+import java.lang.reflect.Type
+import java.nio.file.Files
+import java.nio.file.Path
+import java.nio.file.Paths
+
+fun parseServerConfiguration(params: InitializeParams): ServerConfiguration? {
+    val gson = GsonBuilder().registerTypeHierarchyAdapter(Path::class.java, GsonPathConverter()).create()
+
+    var storage: Storage? = null
+
+    if (params.initializationOptions != null) {
+        val options = gson.fromJson(params.initializationOptions as JsonElement, InitializationOptions::class.java)
+
+        if (options.storagePath != null) {
+            if (Files.exists(options.storagePath) && Files.isDirectory(options.storagePath)) {
+                storage = Storage(options.storagePath)
+            }
+        }
+    }
+
+    return ServerConfiguration(storage)
+}
+
+data class InitializationOptions(val storagePath: Path?)
+
+data class ServerConfiguration(val storage: Storage?)
+
+class GsonPathConverter : JsonDeserializer<Path?> {
+
+    @Throws(JsonParseException::class)
+    override fun deserialize(json: JsonElement, type: Type?, context: JsonDeserializationContext?): Path? {
+        return try {
+            Paths.get(json.asString)
+        } catch (ex: Exception) {
+            LOG.printStackTrace(ex)
+            null
+        }
+    }
+}
diff --git a/server/src/test/kotlin/org/javacs/kt/ClassPathTest.kt b/server/src/test/kotlin/org/javacs/kt/ClassPathTest.kt
@@ -21,7 +21,7 @@ class ClassPathTest {
 
         assertTrue(Files.exists(buildFile))
 
-        val resolvers = defaultClassPathResolver(listOf(workspaceRoot))
+        val resolvers = defaultClassPathResolver(listOf(workspaceRoot), null)
         print(resolvers)
         val classPath = resolvers.classpathOrEmpty.map { it.toString() }
 
diff --git a/shared/build.gradle b/shared/build.gradle
@@ -1,6 +1,7 @@
 plugins {
     id 'org.jetbrains.kotlin.jvm'
     id 'maven-publish'
+    id "org.jetbrains.kotlin.plugin.serialization" version "$kotlinVersion"
 }
 
 version = projectVersion
@@ -15,4 +16,5 @@ dependencies {
     implementation 'org.jetbrains.kotlin:kotlin-stdlib-jdk8'
     testImplementation 'org.hamcrest:hamcrest-all:1.3'
 	testImplementation 'junit:junit:4.11'
+    implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.2.2")
 }
diff --git a/shared/src/main/kotlin/org/javacs/kt/classpath/ClassPathEntry.kt b/shared/src/main/kotlin/org/javacs/kt/classpath/ClassPathEntry.kt
@@ -1,5 +1,14 @@
 package org.javacs.kt.classpath
 
+import kotlinx.serialization.Serializable
+import org.javacs.kt.storage.PathAsStringSerializer
 import java.nio.file.Path
 
-data class ClassPathEntry(val compiledJar: Path, val sourceJar: Path?)
+@Serializable
+data class ClassPathEntry(
+    @Serializable(with = PathAsStringSerializer::class)
+    val compiledJar: Path,
+
+    @Serializable(with = PathAsStringSerializer::class)
+    val sourceJar: Path?
+)
diff --git a/shared/src/main/kotlin/org/javacs/kt/classpath/DefaultClassPathResolver.kt b/shared/src/main/kotlin/org/javacs/kt/classpath/DefaultClassPathResolver.kt
@@ -1,28 +1,29 @@
 package org.javacs.kt.classpath
 
 import org.javacs.kt.LOG
+import org.javacs.kt.storage.Storage
 import java.nio.file.Path
 import java.nio.file.PathMatcher
 import java.nio.file.FileSystems
 
-fun defaultClassPathResolver(workspaceRoots: Collection<Path>): ClassPathResolver =
+fun defaultClassPathResolver(workspaceRoots: Collection<Path>, storage: Storage?): ClassPathResolver =
     WithStdlibResolver(
         ShellClassPathResolver.global(workspaceRoots.firstOrNull())
-            .or(workspaceRoots.asSequence().flatMap(::workspaceResolvers).joined)
+            .or(workspaceRoots.asSequence().flatMap { workspaceResolvers(it, storage) }.joined)
     ).or(BackupClassPathResolver)
 
 /** Searches the workspace for all files that could provide classpath info. */
-private fun workspaceResolvers(workspaceRoot: Path): Sequence<ClassPathResolver> {
+private fun workspaceResolvers(workspaceRoot: Path, storage: Storage?): Sequence<ClassPathResolver> {
     val ignored: List<PathMatcher> = ignoredPathPatterns(workspaceRoot, workspaceRoot.resolve(".gitignore"))
-    return folderResolvers(workspaceRoot, ignored).asSequence()
+    return folderResolvers(workspaceRoot, ignored, storage).asSequence()
 }
 
 /** Searches the folder for all build-files. */
-private fun folderResolvers(root: Path, ignored: List<PathMatcher>): Collection<ClassPathResolver> =
+private fun folderResolvers(root: Path, ignored: List<PathMatcher>, storage: Storage?): Collection<ClassPathResolver> =
     root.toFile()
         .walk()
         .onEnter { file -> ignored.none { it.matches(file.toPath()) } }
-        .mapNotNull { asClassPathProvider(it.toPath()) }
+        .mapNotNull { asClassPathProvider(it.toPath(), storage) }
         .toList()
 
 /** Tries to read glob patterns from a gitignore. */
@@ -47,7 +48,7 @@ private fun ignoredPathPatterns(root: Path, gitignore: Path): List<PathMatcher>
         ?: emptyList()
 
 /** Tries to create a classpath resolver from a file using as many sources as possible */
-private fun asClassPathProvider(path: Path): ClassPathResolver? =
-    MavenClassPathResolver.maybeCreate(path)
-        ?: GradleClassPathResolver.maybeCreate(path)
+private fun asClassPathProvider(path: Path, storage: Storage?): ClassPathResolver? =
+    MavenClassPathResolver.maybeCreate(path, storage)
+        ?: GradleClassPathResolver.maybeCreate(path, storage)
         ?: ShellClassPathResolver.maybeCreate(path)
diff --git a/shared/src/main/kotlin/org/javacs/kt/classpath/GradleClassPathResolver.kt b/shared/src/main/kotlin/org/javacs/kt/classpath/GradleClassPathResolver.kt
@@ -1,6 +1,8 @@
 package org.javacs.kt.classpath
 
 import org.javacs.kt.LOG
+import org.javacs.kt.storage.SetOfPathsAsStringSerializer
+import org.javacs.kt.storage.Storage
 import org.javacs.kt.util.execAndReadStdoutAndStderr
 import org.javacs.kt.util.KotlinLSException
 import org.javacs.kt.util.isOSWindows
@@ -10,34 +12,65 @@ import java.nio.file.Files
 import java.nio.file.Path
 import java.nio.file.Paths
 
-internal class GradleClassPathResolver(private val path: Path, private val includeKotlinDSL: Boolean): ClassPathResolver {
+internal class GradleClassPathResolver(private val path: Path, private val includeKotlinDSL: Boolean, private val storage: Storage?): ClassPathResolver {
     override val resolverType: String = "Gradle"
-    private val projectDirectory: Path get() = path.getParent()
+    private val projectDirectory: Path get() = path.parent
+
+    private var cachedClassPath: Set<ClassPathEntry>? = storage?.getObject("gradleClassPath")
+    private var cachedBuildScriptClassPath: Set<Path>? = storage?.getObject("gradleBuildScriptClassPath", SetOfPathsAsStringSerializer)
+
     override val classpath: Set<ClassPathEntry> get() {
+        cachedClassPath?.let { if (!dependenciesChanged()) return it }
+
         val scripts = listOf("projectClassPathFinder.gradle")
         val tasks = listOf("kotlinLSPProjectDeps")
 
-        return readDependenciesViaGradleCLI(projectDirectory, scripts, tasks)
+        val newClasspath = readDependenciesViaGradleCLI(projectDirectory, scripts, tasks)
             .apply { if (isNotEmpty()) LOG.info("Successfully resolved dependencies for '${projectDirectory.fileName}' using Gradle") }
             .map { ClassPathEntry(it, null) }.toSet()
+
+        updateClasspathCache(newClasspath)
+        return newClasspath
     }
     override val buildScriptClasspath: Set<Path> get() {
         return if (includeKotlinDSL) {
+            cachedBuildScriptClassPath?.let { if (!dependenciesChanged()) return it }
+
             val scripts = listOf("kotlinDSLClassPathFinder.gradle")
             val tasks = listOf("kotlinLSPKotlinDSLDeps")
 
-            return readDependenciesViaGradleCLI(projectDirectory, scripts, tasks)
+            val newBuildScriptClasspath = readDependenciesViaGradleCLI(projectDirectory, scripts, tasks)
                 .apply { if (isNotEmpty()) LOG.info("Successfully resolved build script dependencies for '${projectDirectory.fileName}' using Gradle") }
+
+            updateBuildScriptClasspathCache(newBuildScriptClasspath)
+            return newBuildScriptClasspath
         } else {
             emptySet()
         }
     }
 
+    private fun updateClasspathCache(newClasspath: Set<ClassPathEntry>) {
+        storage?.setObject("gradleClasspath", newClasspath)
+        storage?.setObject("buildScriptFileVersion", getCurrentBuildScriptFileVersion())
+        cachedClassPath = newClasspath
+    }
+
+    private fun updateBuildScriptClasspathCache(newClasspath: Set<Path>) {
+        storage?.setObject("gradleBuildScriptClasspath", newClasspath, SetOfPathsAsStringSerializer)
+        storage?.setObject("buildScriptFileVersion", getCurrentBuildScriptFileVersion())
+        cachedBuildScriptClassPath = newClasspath
+    }
+
+    private fun dependenciesChanged(): Boolean =
+        storage?.getObject<Long>("buildScriptFileVersion") ?: 0 < getCurrentBuildScriptFileVersion()
+
+    private fun getCurrentBuildScriptFileVersion(): Long = path.toFile().lastModified()
+
     companion object {
         /** Create a Gradle resolver if a file is a pom. */
-        fun maybeCreate(file: Path): GradleClassPathResolver? =
+        fun maybeCreate(file: Path, storage: Storage?): GradleClassPathResolver? =
             file.takeIf { file.endsWith("build.gradle") || file.endsWith("build.gradle.kts") }
-                ?.let { GradleClassPathResolver(it, includeKotlinDSL = file.toString().endsWith(".kts")) }
+                ?.let { GradleClassPathResolver(it, includeKotlinDSL = file.toString().endsWith(".kts"), storage) }
     }
 }
 
@@ -84,6 +117,7 @@ private fun readDependenciesViaGradleCLI(projectDirectory: Path, gradleScripts:
         .toSet()
 
     tmpScripts.forEach(Files::delete)
+
     return dependencies
 }
 
diff --git a/shared/src/main/kotlin/org/javacs/kt/classpath/MavenClassPathResolver.kt b/shared/src/main/kotlin/org/javacs/kt/classpath/MavenClassPathResolver.kt
@@ -1,18 +1,25 @@
 package org.javacs.kt.classpath
 
+import kotlinx.serialization.Serializable
 import org.javacs.kt.LOG
+import org.javacs.kt.storage.Storage
 import org.javacs.kt.util.findCommandOnPath
 import org.javacs.kt.util.execAndReadStdoutAndStderr
 import java.nio.file.Path
 import java.nio.file.Files
 import java.io.File
 
 /** Resolver for reading maven dependencies */
-internal class MavenClassPathResolver private constructor(private val pom: Path) : ClassPathResolver {
+internal class MavenClassPathResolver private constructor(private val pom: Path, private val storage: Storage?) : ClassPathResolver {
     private var artifacts: Set<Artifact>? = null
 
     override val resolverType: String = "Maven"
+
+    private var cachedClassPath: MavenClasspathCache? = storage?.getObject("mavenClasspath")
+
     override val classpath: Set<ClassPathEntry> get() {
+        cachedClassPath?.let { if (!dependenciesChanged()) return it.classpathEntries }
+
         val dependenciesOutput = generateMavenDependencyList(pom)
         val artifacts = readMavenDependencyList(dependenciesOutput)
 
@@ -25,10 +32,17 @@ internal class MavenClassPathResolver private constructor(private val pom: Path)
         Files.deleteIfExists(dependenciesOutput)
 
         this.artifacts = artifacts
-        return artifacts.mapNotNull { findMavenArtifact(it, false)?.let { it1 -> ClassPathEntry(it1, null) } }.toSet()
+
+        val newClasspath = artifacts.mapNotNull { findMavenArtifact(it, false)?.let { it1 -> ClassPathEntry(it1, null) } }.toSet()
+
+        updateClasspathCache(MavenClasspathCache(newClasspath, false))
+
+        return newClasspath
     }
 
     override val classpathWithSources: Set<ClassPathEntry> get() {
+        cachedClassPath?.let { if (!dependenciesChanged() && it.includesSources) return it.classpathEntries }
+
         // Fetch artifacts if not yet present.
         var artifacts: Set<Artifact>
         if (this.artifacts != null) {
@@ -45,17 +59,33 @@ internal class MavenClassPathResolver private constructor(private val pom: Path)
         artifacts = readMavenDependencyListWithSources(artifacts, sourcesOutput)
 
         Files.deleteIfExists(sourcesOutput)
-        return artifacts.mapNotNull {
+        val newClasspath = artifacts.mapNotNull {
             findMavenArtifact(it, false)?.let {
                 it1 -> ClassPathEntry(it1, if (it.source) findMavenArtifact(it, it.source) else null)
             }
         }.toSet()
+
+        updateClasspathCache(MavenClasspathCache(newClasspath, true))
+
+        return newClasspath
+    }
+
+    private fun updateClasspathCache(newClasspathCache: MavenClasspathCache) {
+        storage?.setObject("mavenClasspath", newClasspathCache)
+        storage?.setObject("mavenPomFileVersion", getCurrentPomFileVersion())
+        cachedClassPath = newClasspathCache
     }
 
+    private fun dependenciesChanged(): Boolean {
+        return storage?.getObject<Long>("mavenPomFileVersion") ?: 0 < getCurrentPomFileVersion()
+    }
+
+    private fun getCurrentPomFileVersion(): Long = pom.toFile().lastModified()
+
     companion object {
         /** Create a maven resolver if a file is a pom. */
-        fun maybeCreate(file: Path): MavenClassPathResolver? =
-            file.takeIf { it.endsWith("pom.xml") }?.let { MavenClassPathResolver(it) }
+        fun maybeCreate(file: Path, storage: Storage?): MavenClassPathResolver? =
+            file.takeIf { it.endsWith("pom.xml") }?.let { MavenClassPathResolver(it, storage) }
     }
 }
 
@@ -201,3 +231,9 @@ data class Artifact(
 ) {
     override fun toString() = "$group:$artifact:$version"
 }
+
+@Serializable
+private data class MavenClasspathCache(
+    val classpathEntries: Set<ClassPathEntry>,
+    val includesSources: Boolean
+)
diff --git a/shared/src/main/kotlin/org/javacs/kt/storage/Storage.kt b/shared/src/main/kotlin/org/javacs/kt/storage/Storage.kt

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,7 @@`
`1`	`1`	`plugins {`
`2`	`2`	`id 'org.jetbrains.kotlin.jvm'`
`3`	`3`	`id 'maven-publish'`
	`4`	`+ id "org.jetbrains.kotlin.plugin.serialization" version "$kotlinVersion"`
`4`	`5`	`}`
`5`	`6`
`6`	`7`	`version = projectVersion`
`@@ -15,4 +16,5 @@ dependencies {`
`15`	`16`	`implementation 'org.jetbrains.kotlin:kotlin-stdlib-jdk8'`
`16`	`17`	`testImplementation 'org.hamcrest:hamcrest-all:1.3'`
`17`	`18`	`testImplementation 'junit:junit:4.11'`
	`19`	`+ implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.2.2")`
`18`	`20`	`}`