Merge pull request #41 from EchoNineLabs/fix/caching

fix script caching / checksum calculation

Author: Saturn745

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

@@ -0,0 +1,34 @@
+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 kotlin.io.path.Path
+
+typealias DependencyTree = MutableMap<String, List<String>>
+
+class ImportsCache {
+    private val mutex = Mutex()
+    private val gson = GsonBuilder().setPrettyPrinting().create()
+    private val file = Path(Kite.instance?.dataFolder?.path ?: System.getProperty("user.dir", "."), "cache", ".imports").toFile()
+
+    private val typeToken = object : TypeToken<DependencyTree>() { /* TYPE MARKER */ }
+
+    var cache: DependencyTree = mutableMapOf()
+        private set
+
+    suspend fun write(name: String, dependencies: List<String>) = mutex.withLock {
+        // Creating parent directories and file in case it does not exist.
+        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,6 +8,10 @@ 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
@@ -54,6 +58,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 +140,9 @@ 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.IO).launch {
+                    importsCache.write(context.compilationConfiguration[displayName]!!, importedSources.map { it.file.path }.toList())
+                }
             }.asSuccess()
         })
     }
@@ -146,40 +157,26 @@ 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())
+                    // Updating digest with all imported scripts.
+                    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 cacheFileName = "${compilationConfiguration[displayName]}.${hash}.cache.jar"
-                    
+                    // Converting checksum to a human-readable format so it can be included in the cache file name.
+                    val hash = checksum.digest().joinToString("") { "%02x".format(it) }
+                    val cacheFileName = "$name.$hash.cache.jar"
                     // Purging old cache files with different hashes (not the current one).
                     cacheDirectory.listFiles()
                         ?.filter {
-                            it.name.endsWith(".cache.jar") && 
-                            it.name.split(".").first() == compilationConfiguration[displayName] &&
+                            it.name.endsWith(".cache.jar") &&
+                            it.name.split(".").first() == name &&
                             it.name != cacheFileName
                         }
                         ?.forEach { it.delete() }
-                    
                     return@CompiledScriptJarsCache File(cacheDirectory, cacheFileName)
                 })
             }