Wrap Database in DatabaseService

Author: daplf

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.database.DatabaseService
 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
@@ -15,13 +15,12 @@ import java.nio.file.Path
  * Manages the class path (compiled JARs, etc), the Java source path
  * and the compiler. Note that Kotlin sources are stored in SourcePath.
  */
-class CompilerClassPath(private val config: CompilerConfiguration) : Closeable {
+class CompilerClassPath(private val config: CompilerConfiguration, private val databaseService: DatabaseService) : Closeable {
     val workspaceRoots = mutableSetOf<Path>()
 
     private val javaSourcePath = mutableSetOf<Path>()
     private val buildScriptClassPath = mutableSetOf<Path>()
     val classPath = mutableSetOf<ClassPathEntry>()
-    var db: Database? = null
     val outputDirectory: File = Files.createTempDirectory("klsBuildOutput").toFile()
     val javaHome: String? = System.getProperty("java.home", null)
 
@@ -41,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, db)
+        val resolver = defaultClassPathResolver(workspaceRoots, databaseService.db)
         var refreshCompiler = updateJavaSourcePath
 
         if (updateClassPath) {

server/src/main/kotlin/org/javacs/kt/Configuration.kt

@@ -6,9 +6,7 @@ import com.google.gson.JsonDeserializer
 import com.google.gson.JsonElement
 import com.google.gson.JsonParseException
 import org.eclipse.lsp4j.InitializeParams
-import org.jetbrains.exposed.sql.Database
 import java.lang.reflect.Type
-import java.nio.file.Files
 import java.nio.file.InvalidPathException
 import java.nio.file.Path
 import java.nio.file.Paths
@@ -49,18 +47,12 @@ public data class ExternalSourcesConfiguration(
 )
 
 
-fun setupServerDatabase(params: InitializeParams): Database? {
-    val dbName = "kls_database"
-
+fun getStoragePath(params: InitializeParams): Path? {
     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)) {
-                return Database.connect("jdbc:sqlite:${Path.of(storagePath.toString(), dbName)}.db")
-            }
-        }
+        return options.storagePath
     }
 
     return null

server/src/main/kotlin/org/javacs/kt/KotlinLanguageServer.kt

@@ -8,6 +8,7 @@ import org.eclipse.lsp4j.services.LanguageClientAware
 import org.eclipse.lsp4j.services.LanguageServer
 import org.eclipse.lsp4j.services.NotebookDocumentService
 import org.javacs.kt.command.ALL_COMMANDS
+import org.javacs.kt.database.DatabaseService
 import org.javacs.kt.progress.LanguageClientProgress
 import org.javacs.kt.progress.Progress
 import org.javacs.kt.semantictokens.semanticTokensLegend
@@ -23,11 +24,12 @@ import java.util.concurrent.CompletableFuture.completedFuture
 
 class KotlinLanguageServer : LanguageServer, LanguageClientAware, Closeable {
     val config = Configuration()
-    val classPath = CompilerClassPath(config.compiler)
+    val databaseService = DatabaseService()
+    val classPath = CompilerClassPath(config.compiler, databaseService)
 
     private val tempDirectory = TemporaryDirectory()
     private val uriContentProvider = URIContentProvider(ClassContentProvider(config.externalSources, classPath, tempDirectory, CompositeSourceArchiveProvider(JdkSourceArchiveProvider(classPath), ClassPathSourceArchiveProvider(classPath))))
-    val sourcePath = SourcePath(classPath, uriContentProvider, config.indexing)
+    val sourcePath = SourcePath(classPath, uriContentProvider, config.indexing, databaseService)
     val sourceFiles = SourceFiles(sourcePath, uriContentProvider)
 
     private val textDocuments = KotlinTextDocumentService(sourceFiles, sourcePath, config, tempDirectory, uriContentProvider, classPath)
@@ -90,10 +92,8 @@ class KotlinLanguageServer : LanguageServer, LanguageClientAware, Closeable {
         serverCapabilities.executeCommandProvider = ExecuteCommandOptions(ALL_COMMANDS)
         serverCapabilities.documentHighlightProvider = Either.forLeft(true)
 
-        val db = setupServerDatabase(params)
-
-        sourcePath.index = if (db != null) SymbolIndex(db) else SymbolIndex()
-        classPath.db = db
+        val storagePath = getStoragePath(params)
+        databaseService.setup(storagePath)
 
         val clientCapabilities = params.capabilities
         config.completion.snippets.enabled = clientCapabilities?.textDocument?.completion?.completionItem?.snippetSupport ?: false

server/src/main/kotlin/org/javacs/kt/SourcePath.kt

@@ -8,6 +8,7 @@ import org.javacs.kt.util.describeURI
 import org.javacs.kt.index.SymbolIndex
 import org.javacs.kt.progress.Progress
 import com.intellij.lang.Language
+import org.javacs.kt.database.DatabaseService
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.resolve.BindingContext
@@ -22,14 +23,15 @@ import java.util.concurrent.locks.ReentrantLock
 class SourcePath(
     private val cp: CompilerClassPath,
     private val contentProvider: URIContentProvider,
-    private val indexingConfig: IndexingConfiguration
+    private val indexingConfig: IndexingConfiguration,
+    private val databaseService: DatabaseService
 ) {
     private val files = mutableMapOf<URI, SourceFile>()
     private val parseDataWriteLock = ReentrantLock()
 
     private val indexAsync = AsyncExecutor()
     var indexEnabled: Boolean by indexingConfig::enabled
-    lateinit var index: SymbolIndex
+    val index = SymbolIndex(databaseService)
 
     var beforeCompileCallback: () -> Unit = {}
 

server/src/main/kotlin/org/javacs/kt/index/SymbolIndex.kt

@@ -7,6 +7,7 @@ import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
 import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe
 import org.jetbrains.kotlin.name.FqName
 import org.javacs.kt.LOG
+import org.javacs.kt.database.DatabaseService
 import org.javacs.kt.progress.Progress
 import org.jetbrains.exposed.dao.IntEntity
 import org.jetbrains.exposed.dao.IntEntityClass
@@ -81,8 +82,12 @@ class PositionEntity(id: EntityID<Int>) : IntEntity(id) {
  * A global view of all available symbols across all packages.
  */
 class SymbolIndex(
-    private val db: Database = Database.connect("jdbc:h2:mem:symbolindex;DB_CLOSE_DELAY=-1", "org.h2.Driver")
+    private val databaseService: DatabaseService
 ) {
+    private val db: Database by lazy {
+        databaseService.db ?: Database.connect("jdbc:h2:mem:symbolindex;DB_CLOSE_DELAY=-1", "org.h2.Driver")
+    }
+
     var progressFactory: Progress.Factory = Progress.Factory.None
 
     init {

server/src/test/kotlin/org/javacs/kt/CompiledFileTest.kt

@@ -2,6 +2,7 @@ package org.javacs.kt
 
 import org.hamcrest.Matchers.equalTo
 import org.javacs.kt.compiler.Compiler
+import org.javacs.kt.database.DatabaseService
 import org.junit.AfterClass
 import org.junit.Assert.assertThat
 import org.junit.Test
@@ -29,7 +30,7 @@ class CompiledFileTest {
         val file = testResourcesRoot().resolve("compiledFile/CompiledFileExample.kt")
         val content = Files.readAllLines(file).joinToString("\n")
         val parse = compiler.createKtFile(content, file)
-        val classPath = CompilerClassPath(CompilerConfiguration())
+        val classPath = CompilerClassPath(CompilerConfiguration(), DatabaseService())
         val sourcePath = listOf(parse)
         val (context, container) = compiler.compileKtFiles(sourcePath, sourcePath)
         CompiledFile(content, parse, context, container, sourcePath, classPath)

shared/src/main/kotlin/org/javacs/kt/database/DatabaseService.kt

@@ -0,0 +1,23 @@
+package org.javacs.kt.database
+
+import org.jetbrains.exposed.sql.Database
+import java.nio.file.Files
+import java.nio.file.Path
+
+class DatabaseService {
+
+    var db: Database? = null
+        private set
+
+    fun setup(storagePath: Path?) {
+        val dbName = "kls_database"
+
+        db = storagePath?.let {
+            if (Files.isDirectory(it)) {
+                Database.connect("jdbc:sqlite:${Path.of(storagePath.toString(), dbName)}.db")
+            } else {
+                null
+            }
+        }
+    }
+}