Switch to DB based implementation

daplf · daplf · commit 18ff7e81f326 · 2023-04-09T12:57:03.000+01:00
diff --git a/server/build.gradle b/server/build.gradle
@@ -48,6 +48,7 @@ dependencies {
     implementation 'com.h2database:h2:1.4.200'
     implementation 'com.github.fwcd.ktfmt:ktfmt:b5d31d1'
     implementation 'com.beust:jcommander:1.78'
+    implementation("org.xerial:sqlite-jdbc:3.41.2.1")
 
     testImplementation 'org.hamcrest:hamcrest-all:1.3'
     testImplementation 'junit:junit:4.11'
diff --git a/server/src/main/kotlin/org/javacs/kt/CompilerClassPath.kt b/server/src/main/kotlin/org/javacs/kt/CompilerClassPath.kt
@@ -3,8 +3,8 @@ 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 org.jetbrains.exposed.sql.Database
 import java.io.Closeable
 import java.io.File
 import java.nio.file.FileSystems
@@ -20,7 +20,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
+    lateinit var db: Database
     val outputDirectory: File = Files.createTempDirectory("klsBuildOutput").toFile()
     val javaHome: String? = System.getProperty("java.home", null)
 
@@ -40,7 +40,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, storage)
+        val resolver = defaultClassPathResolver(workspaceRoots, db)
         var refreshCompiler = updateJavaSourcePath
 
         if (updateClassPath) {
diff --git a/server/src/main/kotlin/org/javacs/kt/Configuration.kt b/server/src/main/kotlin/org/javacs/kt/Configuration.kt
@@ -2,7 +2,7 @@ package org.javacs.kt
 
 import com.google.gson.*
 import org.eclipse.lsp4j.InitializeParams
-import org.javacs.kt.storage.Storage
+import org.jetbrains.exposed.sql.Database
 import java.lang.reflect.Type
 import java.nio.file.Files
 import java.nio.file.Path
@@ -44,28 +44,26 @@ public data class ExternalSourcesConfiguration(
 )
 
 
-fun parseServerConfiguration(params: InitializeParams): ServerConfiguration? {
-    val gson = GsonBuilder().registerTypeHierarchyAdapter(Path::class.java, GsonPathConverter()).create()
-
-    var storage: Storage? = null
+fun setupServerDatabase(params: InitializeParams): Database {
+    var db: Database? = null
+    val dbName = "kls_database"
 
     params.initializationOptions?.let { initializationOptions ->
+        val gson = GsonBuilder().registerTypeHierarchyAdapter(Path::class.java, GsonPathConverter()).create()
         val options = gson.fromJson(initializationOptions as JsonElement, InitializationOptions::class.java)
 
         options.storagePath?.let { storagePath ->
             if (Files.isDirectory(storagePath)) {
-                storage = Storage(storagePath)
+                db = Database.connect("jdbc:sqlite:$storagePath$dbName.db")
             }
         }
     }
 
-    return ServerConfiguration(storage)
+    return db ?: Database.connect("jdbc:h2:mem:$dbName;DB_CLOSE_DELAY=-1", "org.h2.Driver")
 }
 
 data class InitializationOptions(val storagePath: Path?)
 
-data class ServerConfiguration(val storage: Storage?)
-
 class GsonPathConverter : JsonDeserializer<Path?> {
 
     @Throws(JsonParseException::class)
@@ -84,6 +82,5 @@ public data class Configuration(
     val completion: CompletionConfiguration = CompletionConfiguration(),
     val linting: LintingConfiguration = LintingConfiguration(),
     var indexing: IndexingConfiguration = IndexingConfiguration(),
-    val externalSources: ExternalSourcesConfiguration = ExternalSourcesConfiguration(),
-    var server: ServerConfiguration? = null
+    val externalSources: ExternalSourcesConfiguration = ExternalSourcesConfiguration()
 )
diff --git a/server/src/main/kotlin/org/javacs/kt/KotlinLanguageServer.kt b/server/src/main/kotlin/org/javacs/kt/KotlinLanguageServer.kt
@@ -14,6 +14,7 @@ import org.javacs.kt.util.AsyncExecutor
 import org.javacs.kt.util.TemporaryDirectory
 import org.javacs.kt.util.parseURI
 import org.javacs.kt.externalsources.*
+import org.javacs.kt.index.SymbolIndex
 import java.io.Closeable
 import java.nio.file.Paths
 import java.util.concurrent.CompletableFuture
@@ -87,9 +88,10 @@ class KotlinLanguageServer : LanguageServer, LanguageClientAware, Closeable {
         serverCapabilities.documentRangeFormattingProvider = Either.forLeft(true)
         serverCapabilities.executeCommandProvider = ExecuteCommandOptions(ALL_COMMANDS)
 
-        config.server = parseServerConfiguration(params)
+        val db = setupServerDatabase(params)
 
-        classPath.storage = config.server?.storage?.getSlice("classpath")
+        sourcePath.index = SymbolIndex(db)
+        classPath.db = db
 
         val clientCapabilities = params.capabilities
         config.completion.snippets.enabled = clientCapabilities?.textDocument?.completion?.completionItem?.snippetSupport ?: false
diff --git a/server/src/main/kotlin/org/javacs/kt/SourcePath.kt b/server/src/main/kotlin/org/javacs/kt/SourcePath.kt
@@ -29,7 +29,7 @@ class SourcePath(
 
     private val indexAsync = AsyncExecutor()
     var indexEnabled: Boolean by indexingConfig::enabled
-    val index = SymbolIndex()
+    lateinit var index: SymbolIndex
 
     var beforeCompileCallback: () -> Unit = {}
 
diff --git a/server/src/main/kotlin/org/javacs/kt/index/SymbolIndex.kt b/server/src/main/kotlin/org/javacs/kt/index/SymbolIndex.kt
@@ -78,14 +78,12 @@ class PositionEntity(id: EntityID<Int>) : IntEntity(id) {
 /**
  * A global view of all available symbols across all packages.
  */
-class SymbolIndex {
-    private val db = Database.connect("jdbc:h2:mem:symbolindex;DB_CLOSE_DELAY=-1", "org.h2.Driver")
-
+class SymbolIndex(private val db: Database) {
     var progressFactory: Progress.Factory = Progress.Factory.None
 
     init {
         transaction(db) {
-            SchemaUtils.create(Symbols, Locations, Ranges, Positions)
+            SchemaUtils.createMissingTablesAndColumns(Symbols, Locations, Ranges, Positions)
         }
     }
 
@@ -97,6 +95,9 @@ class SymbolIndex {
         progressFactory.create("Indexing").thenApplyAsync { progress ->
             try {
                 transaction(db) {
+                    // Remove everything first.
+                    Symbols.deleteAll()
+                    // Add new ones.
                     addDeclarations(allDescriptors(module, exclusions))
 
                     val finished = System.currentTimeMillis()
diff --git a/shared/build.gradle b/shared/build.gradle
@@ -14,7 +14,8 @@ java {
 
 dependencies {
     implementation 'org.jetbrains.kotlin:kotlin-stdlib-jdk8'
+    implementation "org.jetbrains.exposed:exposed-core:$exposedVersion"
+    implementation "org.jetbrains.exposed:exposed-dao:$exposedVersion"
     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/CachedClassPathResolver.kt b/shared/src/main/kotlin/org/javacs/kt/classpath/CachedClassPathResolver.kt
@@ -1,28 +1,111 @@
 package org.javacs.kt.classpath
 
-import kotlinx.serialization.Serializable
-import org.javacs.kt.storage.SetOfPathsAsStringSerializer
-import org.javacs.kt.storage.Storage
+import org.jetbrains.exposed.dao.IntEntity
+import org.jetbrains.exposed.dao.IntEntityClass
+import org.jetbrains.exposed.dao.id.EntityID
+import org.jetbrains.exposed.dao.id.IntIdTable
+import org.jetbrains.exposed.sql.*
+import org.jetbrains.exposed.sql.transactions.transaction
 import java.nio.file.Path
+import java.nio.file.Paths
+
+private const val MAX_PATH_LENGTH = 255
+
+private object ClassPathMetadataCache : IntIdTable() {
+    val includesSources = bool("includessources")
+    val buildFileVersion = long("buidlfileversion").nullable()
+}
+
+private object ClassPathCacheEntry : IntIdTable() {
+    val compiledJar = varchar("compiledjar", length = MAX_PATH_LENGTH)
+    val sourceJar = varchar("sourcejar", length = MAX_PATH_LENGTH).nullable()
+}
+
+private object BuildScriptClassPathCacheEntry : IntIdTable() {
+    val jar = varchar("jar", length = MAX_PATH_LENGTH)
+}
+
+class ClassPathMetadataCacheEntity(id: EntityID<Int>) : IntEntity(id) {
+    companion object : IntEntityClass<ClassPathMetadataCacheEntity>(ClassPathMetadataCache)
+
+    var includesSources by ClassPathMetadataCache.includesSources
+    var buildFileVersion by ClassPathMetadataCache.buildFileVersion
+}
+
+class ClassPathCacheEntryEntity(id: EntityID<Int>) : IntEntity(id) {
+    companion object : IntEntityClass<ClassPathCacheEntryEntity>(ClassPathCacheEntry)
+
+    var compiledJar by ClassPathCacheEntry.compiledJar
+    var sourceJar by ClassPathCacheEntry.sourceJar
+}
+
+class BuildScriptClassPathCacheEntryEntity(id: EntityID<Int>) : IntEntity(id) {
+    companion object : IntEntityClass<BuildScriptClassPathCacheEntryEntity>(BuildScriptClassPathCacheEntry)
+
+    var jar by BuildScriptClassPathCacheEntry.jar
+}
 
 /** A classpath resolver that caches another resolver */
-internal class CachedClassPathResolver(private val wrapped: ClassPathResolver, private val storage: Storage?) : ClassPathResolver {
+internal class CachedClassPathResolver(private val wrapped: ClassPathResolver, private val db: Database) : ClassPathResolver {
     override val resolverType: String get() = "Cached + ${wrapped.resolverType}"
 
-    private var cachedClassPath: ClasspathCache? = storage?.getObject("cachedClasspath")
-    private var cachedBuildScriptClassPath: Set<Path>? = storage?.getObject("cachedBuildScriptClassPath", SetOfPathsAsStringSerializer)
+    private var cachedClassPathEntries: Set<ClassPathEntry>
+        get() = transaction(db) { ClassPathCacheEntryEntity.all() }.map {
+            ClassPathEntry(
+                compiledJar = Paths.get(it.compiledJar),
+                sourceJar = if (it.sourceJar != null) Paths.get(it.sourceJar) else null
+            )
+        }.toSet()
+        set(newEntries) = transaction(db) {
+            ClassPathCacheEntry.deleteAll()
+            newEntries.map {
+                ClassPathCacheEntryEntity.new {
+                    compiledJar = it.compiledJar.toString()
+                    sourceJar = it.sourceJar.toString()
+                }
+            }
+        }
+
+    private var cachedBuildScriptClassPathEntries: Set<Path>
+        get() = transaction(db) { BuildScriptClassPathCacheEntryEntity.all() }.map { Paths.get(it.jar) }.toSet()
+        set(newEntries) = transaction(db) {
+            BuildScriptClassPathCacheEntry.deleteAll()
+            newEntries.map { BuildScriptClassPathCacheEntryEntity.new { jar = it.toString() } }
+        }
+
+    private var cachedClassPathMetadata
+        get() = transaction(db) { ClassPathMetadataCacheEntity.all().map {
+            ClasspathMetadata(
+                includesSources = it.includesSources,
+                buildFileVersion = it.buildFileVersion
+            )
+        }.firstOrNull() }
+        set(newClassPathMetadata) = transaction(db) {
+            ClassPathMetadataCache.deleteAll()
+            val newClassPathMetadataRow = newClassPathMetadata ?: ClasspathMetadata()
+            ClassPathMetadataCacheEntity.new {
+                includesSources = newClassPathMetadataRow.includesSources
+                buildFileVersion = newClassPathMetadataRow.buildFileVersion
+            }
+        }
+
+    init {
+        transaction(db) {
+            SchemaUtils.createMissingTablesAndColumns(ClassPathMetadataCache, ClassPathCacheEntry, BuildScriptClassPathCacheEntry)
+        }
+    }
 
     override val classpath: Set<ClassPathEntry> get() {
-        cachedClassPath?.let { if (!dependenciesChanged()) return it.classpathEntries }
+        cachedClassPathEntries.let { if (!dependenciesChanged()) return it }
 
         val newClasspath = wrapped.classpath
-        updateClasspathCache(ClasspathCache(newClasspath, false))
+        updateClasspathCache(newClasspath, false)
 
         return newClasspath
     }
 
     override val buildScriptClasspath: Set<Path> get() {
-        cachedBuildScriptClassPath?.let { if (!dependenciesChanged()) return it }
+        if (!dependenciesChanged()) return cachedBuildScriptClassPathEntries
 
         val newBuildScriptClasspath = wrapped.buildScriptClasspath
 
@@ -31,35 +114,39 @@ internal class CachedClassPathResolver(private val wrapped: ClassPathResolver, p
     }
 
     override val classpathWithSources: Set<ClassPathEntry> get() {
-        cachedClassPath?.let { if (!dependenciesChanged() && it.includesSources) return it.classpathEntries }
+        cachedClassPathMetadata?.let { if (!dependenciesChanged() && it.includesSources) return cachedClassPathEntries }
 
         val newClasspath = wrapped.classpathWithSources
-        updateClasspathCache(ClasspathCache(newClasspath, true))
+        updateClasspathCache(newClasspath, true)
 
         return newClasspath
     }
 
     override val currentBuildFileVersion: Long get() = wrapped.currentBuildFileVersion
 
-    private fun updateClasspathCache(newClasspathCache: ClasspathCache) {
-        storage?.setObject("cachedClasspath", newClasspathCache)
-        storage?.setObject("cachedBuildFileVersion", currentBuildFileVersion)
-        cachedClassPath = newClasspathCache
+    private fun updateClasspathCache(newClasspathEntries: Set<ClassPathEntry>, includesSources: Boolean) {
+        transaction(db) {
+            cachedClassPathEntries = newClasspathEntries
+            cachedClassPathMetadata = cachedClassPathMetadata?.copy(
+                includesSources = includesSources,
+                buildFileVersion = currentBuildFileVersion
+            ) ?: ClasspathMetadata()
+        }
     }
 
     private fun updateBuildScriptClasspathCache(newClasspath: Set<Path>) {
-        storage?.setObject("cachedBuildScriptClassPath", newClasspath, SetOfPathsAsStringSerializer)
-        storage?.setObject("cachedBuildFileVersion", currentBuildFileVersion)
-        cachedBuildScriptClassPath = newClasspath
+        transaction(db) {
+            cachedBuildScriptClassPathEntries = newClasspath
+            cachedClassPathMetadata = cachedClassPathMetadata?.copy(buildFileVersion = currentBuildFileVersion) ?: ClasspathMetadata()
+        }
     }
 
     private fun dependenciesChanged(): Boolean {
-        return storage?.getObject<Long>("cachedBuildFileVersion") ?: 0 < wrapped.currentBuildFileVersion
+        return (cachedClassPathMetadata?.buildFileVersion ?: 0) < wrapped.currentBuildFileVersion
     }
 }
 
-@Serializable
-private data class ClasspathCache(
-    val classpathEntries: Set<ClassPathEntry>,
-    val includesSources: Boolean
+private data class ClasspathMetadata(
+    val includesSources: Boolean = false,
+    val buildFileVersion: Long? = null
 )
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,13 +1,8 @@
 package org.javacs.kt.classpath
 
-import kotlinx.serialization.Serializable
-import org.javacs.kt.storage.PathAsStringSerializer
 import java.nio.file.Path
 
-@Serializable
 data class ClassPathEntry(
-    @Serializable(with = PathAsStringSerializer::class)
     val compiledJar: Path,
-    @Serializable(with = PathAsStringSerializer::class)
     val sourceJar: Path? = null
 )
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,18 +1,18 @@
 package org.javacs.kt.classpath
 
 import org.javacs.kt.LOG
-import org.javacs.kt.storage.Storage
+import org.jetbrains.exposed.sql.Database
 import java.nio.file.Path
 import java.nio.file.PathMatcher
 import java.nio.file.FileSystems
 
-fun defaultClassPathResolver(workspaceRoots: Collection<Path>, storage: Storage? = null): ClassPathResolver =
+fun defaultClassPathResolver(workspaceRoots: Collection<Path>, db: Database): ClassPathResolver =
     CachedClassPathResolver(
         WithStdlibResolver(
             ShellClassPathResolver.global(workspaceRoots.firstOrNull())
                 .or(workspaceRoots.asSequence().flatMap { workspaceResolvers(it) }.joined)
         ).or(BackupClassPathResolver),
-        storage
+        db
     )
 
 /** Searches the workspace for all files that could provide classpath info. */
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
`@@ -14,7 +14,8 @@ java {`
`14`	`14`
`15`	`15`	`dependencies {`
`16`	`16`	`implementation 'org.jetbrains.kotlin:kotlin-stdlib-jdk8'`
	`17`	`+ implementation "org.jetbrains.exposed:exposed-core:$exposedVersion"`
	`18`	`+ implementation "org.jetbrains.exposed:exposed-dao:$exposedVersion"`
`17`	`19`	`testImplementation 'org.hamcrest:hamcrest-all:1.3'`
`18`	`20`	`testImplementation 'junit:junit:4.11'`
`19`		`- implementation 'org.jetbrains.kotlinx:kotlinx-serialization-json:1.2.2'`
`20`	`21`	`}`