(draft) fix script caching / checksum calculation

Author: Grabsky

src/main/kotlin/dev/echonine/kite/scripting/cache/ImportsCache.kt

@@ -0,0 +1,36 @@
+package dev.echonine.kite.scripting.cache
+
+import com.google.gson.GsonBuilder
+import com.google.gson.reflect.TypeToken
+import dev.echonine.kite.Kite
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import java.io.File
+
+typealias DependencyTree = List<String>
+
+class ImportsCache {
+
+    private val mutex = Mutex()
+    private val gson = GsonBuilder().setPrettyPrinting().create()
+    private val file = Kite.instance!!.dataFolder.resolve("cache" + File.separator + ".imports")
+
+    private val typeToken = object : TypeToken<MutableMap<String, DependencyTree>>() { /* TYPE MARKER */ }
+
+    var cache: MutableMap<String, DependencyTree> = mutableMapOf()
+        private set
+
+    suspend fun write(name: String, dependencies: List<String>) = mutex.withLock {
+        if (!file.exists()) {
+            file.parentFile.mkdirs()
+            file.createNewFile()
+        }
+        // Reading file contents.
+        cache = file.bufferedReader().use { gson.fromJson(it, typeToken) } ?: mutableMapOf()
+        // Putting list of dependencies / imports to the map.
+        cache[name] = dependencies
+        // Saving contents to the file.
+        file.bufferedWriter().use { gson.toJson(cache, typeToken.type, it) }
+    }
+
+}

src/main/kotlin/dev/echonine/kite/scripting/configuration/KiteCompilationConfiguration.kt

@@ -8,13 +8,18 @@ import dev.echonine.kite.api.annotations.Repository
 import dev.echonine.kite.scripting.configuration.compat.DynamicServerJarCompat
 import dev.echonine.kite.scripting.Script
 import dev.echonine.kite.scripting.ScriptContext
+import dev.echonine.kite.scripting.cache.ImportsCache
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
 import org.bukkit.Server
 import org.bukkit.plugin.java.JavaPlugin
 import revxrsal.zapper.DependencyManager
 import revxrsal.zapper.classloader.URLClassLoaderWrapper
 import java.io.File
 import java.net.URLClassLoader
 import java.security.MessageDigest
+import kotlin.coroutines.CoroutineContext
 import kotlin.script.experimental.api.*
 import kotlin.script.experimental.host.FileBasedScriptSource
 import kotlin.script.experimental.host.FileScriptSource
@@ -54,6 +59,10 @@ val cacheDirectory by lazy {
     File(Kite.instance?.dataFolder?.path ?: System.getProperty("user.dir", "."), "cache")
 }
 
+val importsCache by lazy {
+    ImportsCache()
+}
+
 @Suppress("JavaIoSerializableObjectMustHaveReadResolve")
 object KiteCompilationConfiguration : ScriptCompilationConfiguration({
     // Adding Bukkit APIs and Kite to default imports.
@@ -132,6 +141,10 @@ object KiteCompilationConfiguration : ScriptCompilationConfiguration({
                 dependencies.append(JvmDependency(scriptDependencies.map { File(libsDirectory, it) }.filter { it.exists() }))
                 // Appending imported sources to the script.
                 importedSources.takeUnless { it.isEmpty() }?.let { importScripts.append(it) }
+                CoroutineScope(Dispatchers.Default).launch {
+                    importsCache.write(context.compilationConfiguration[displayName]!!, importedSources.map { it.file.path }.toList())
+                }
+
             }.asSuccess()
         })
     }
@@ -146,31 +159,18 @@ object KiteCompilationConfiguration : ScriptCompilationConfiguration({
             if (cacheDirectory.isDirectory || cacheDirectory.mkdirs()) {
                 // Configuring compilation cache.
                 compilationCache(CompiledScriptJarsCache { script, compilationConfiguration ->
+                    val name = compilationConfiguration[displayName]
+                    val checksum = MessageDigest.getInstance("MD5")
                     // Getting the MD5 checksum and including it in the file name.
                     // MD5 checksum acts as a file identifier here.
-                    val mainScriptHash = script.text.toByteArray().let {
-                        val md = MessageDigest.getInstance("MD5")
-                        md.update(it)
-                        md.digest().joinToString("") { byte -> "%02x".format(byte) }
+                    checksum.update(script.text.toByteArray())
+                    // ...
+                    importsCache.cache[name]?.forEach {
+                        checksum.update(File(it).readBytes())
                     }
-                    // Also hash the imported scripts
-                    val importsHash = (compilationConfiguration[importScripts]
-                        ?: emptyList<FileScriptSource>()).joinToString("") { importedScript ->
-                        importedScript.text.toByteArray().let {
-                            val md = MessageDigest.getInstance("MD5")
-                            md.update(it)
-                            md.digest().joinToString("") { byte -> "%02x".format(byte) }
-                        }
-                    }
-
-                    // Creating the final hash by combining the main script hash and imports hash
-                    val hash = MessageDigest.getInstance("MD5").apply {
-                        update(mainScriptHash.toByteArray())
-                        update(importsHash.toByteArray())
-                    }.digest().joinToString("") { byte -> "%02x".format(byte) }
-                    
+                    // ...
+                    val hash = checksum.digest().joinToString("") { "%02x".format(it) }
                     val cacheFileName = "${compilationConfiguration[displayName]}.${hash}.cache.jar"
-                    
                     // Purging old cache files with different hashes (not the current one).
                     cacheDirectory.listFiles()
                         ?.filter {