WIP (works now).

Author: kreinhard

application/src/main/kotlin/de/micromata/kotlinscripting/CustomClassLoader.kt

@@ -7,6 +7,9 @@ import java.util.*
 
 private val log = KotlinLogging.logger {}
 
+/**
+ * Custom class loader for testing purposes.
+ */
 class CustomClassLoader(parent: ClassLoader?) : ClassLoader("CustomClassLoader", parent) {
     override fun loadClass(name: String, resolve: Boolean): Class<*> {
         log.info { "loadClass(\"$name\", $resolve)" }

application/src/main/kotlin/de/micromata/kotlinscripting/MyScriptingHost.kt

@@ -7,16 +7,20 @@ import kotlin.script.experimental.jvmhost.BasicJvmScriptingHost
 
 private val log = KotlinLogging.logger {}
 
+/**
+ * If you want to pass a threadlocal variable, you can use this class.
+ * Otherwise, BasicJvmScriptingHost() can be used directly.
+ */
 class CustomScriptingHost(
-    private val customClassLoader: ClassLoader
+    // private val customClassLoader: ClassLoader
 ) : BasicJvmScriptingHost() {
 
     override fun eval(
         script: SourceCode,
         compilationConfiguration: ScriptCompilationConfiguration,
         evaluationConfiguration: ScriptEvaluationConfiguration?
     ): ResultWithDiagnostics<EvaluationResult> {
-        val originalClassLoader = Thread.currentThread().contextClassLoader
+        //val originalClassLoader = Thread.currentThread().contextClassLoader
         return try {
             ThreadLocalStorage.threadLocal.set(Constants.THREADLOCAL_TEST)
             // Trying to set the custom ClassLoader here.

application/src/main/kotlin/de/micromata/kotlinscripting/ScriptExecutor.kt

@@ -17,27 +17,26 @@ class ScriptExecutor {
     private var evalException: Exception? = null
 
     fun executeScript(): ResultWithDiagnostics<EvaluationResult>? {
-        val classLoader = CustomClassLoader(Thread.currentThread().contextClassLoader)
+        //val classLoader = CustomClassLoader(Thread.currentThread().contextClassLoader)
 
-        val scriptingHost = CustomScriptingHost(classLoader)
+        val scriptingHost = CustomScriptingHost() // (classLoader)
         val compilationConfig = ScriptCompilationConfiguration {
             jvm {
-                dependenciesFromClassloader(classLoader = classLoader, wholeClasspath = true)
-                //dependencies(JvmDependency(dependencies))
-                //dependenciesFromClassloader(classLoader = classLoader, wholeClasspath = true)
+                // dependenciesFromClassloader(classLoader = classLoader, wholeClasspath = true)
+                dependenciesFromClassloader(wholeClasspath = true)
             }
             providedProperties("context" to KotlinScriptContext::class)
             compilerOptions.append("-nowarn")
         }
         val context = KotlinScriptContext()
         context.setProperty("testVariable", Constants.TEST_VAR)
         val evaluationConfiguration = ScriptEvaluationConfiguration {
-            jvm {
-                baseClassLoader(classLoader)
-            }
+            /*jvm {
+                baseClassLoader(classLoader) // Without effect. ClassLoader will be overwritten by the UrlClassLoader.
+            }*/
             providedProperties("context" to context)
         }
-        val scriptSource = script.toScriptSource()
+        val scriptSource = Constants.CHECK_SCRIPT.toScriptSource()
         val executor = Executors.newSingleThreadExecutor()
         var future: Future<ResultWithDiagnostics<EvaluationResult>>? = null
         try {
@@ -59,36 +58,4 @@ class ScriptExecutor {
         }
         return null
     }
-
-    companion object {
-        val simplestScript = "\"Hello world!\""
-        val script = """
-            import de.micromata.kotlinscripting.business.ThreadLocalStorage
-            val sb = StringBuilder()
-            sb.appendLine("Hello world!")
-            val threadLocalVal = ThreadLocalStorage.threadLocal.get()
-            if (threadLocalVal == "${Constants.THREADLOCAL_TEST}") {
-                sb.appendLine("ThreadLocal: ${'$'}threadLocalVal (OK)")
-            } else {
-                sb.appendLine("ThreadLocal: ${'$'}threadLocalVal (*** ERROR, ${Constants.THREADLOCAL_TEST} expected)")
-            }
-            val testVar = context.getProperty("testVariable")
-            if (testVar == "${Constants.TEST_VAR}") {
-                sb.appendLine("Context: ${'$'}testVar (OK)")
-            } else {
-                sb.appendLine("Context: ${'$'}testVar (*** ERROR, ${Constants.TEST_VAR} expected)")
-            }
-            var loader = Thread.currentThread().contextClassLoader
-            val classLoaders = mutableListOf<ClassLoader>()
-            while (loader != null) {
-                classLoaders.add(loader)
-                loader = loader.parent
-            }
-            sb.append("ClassLoader: ")
-            sb.appendLine("${'$'}{classLoaders.joinToString(", parent: ") { it.toString() }}")
-            sb.appendLine("Classpath: ${'$'}{System.getProperty("java.class.path")}")
-            //sb.appendLine(de.micromata.springbootkotlinscripting.ScriptExecutor.script)
-            sb.toString()
-        """.trimIndent()
-    }
 }

business/src/main/kotlin/de/micromata/kotlinscripting/Constants.kt

@@ -1,6 +1,38 @@
 package de.micromata.kotlinscripting
 
 object Constants {
-    val THREADLOCAL_TEST = "Hello script! Greetings from ThreadLocal."
-    val TEST_VAR = "Hello script! Greetings from testVar."
+    const val THREADLOCAL_TEST = "Hello script! Greetings from ThreadLocal."
+    const val TEST_VAR = "Hello script! Greetings from testVar."
+
+
+    const val HELLO_WORLD_SCRIPT = "\"Hello world!\""
+    val CHECK_SCRIPT = """
+            import de.micromata.kotlinscripting.business.ThreadLocalStorage
+            val sb = StringBuilder()
+            sb.appendLine("Hello world!")
+            val threadLocalVal = ThreadLocalStorage.threadLocal.get()
+            if (threadLocalVal == "${Constants.THREADLOCAL_TEST}") {
+                sb.appendLine("ThreadLocal: ${'$'}threadLocalVal (OK)")
+            } else {
+                sb.appendLine("ThreadLocal: ${'$'}threadLocalVal (*** ERROR, ${Constants.THREADLOCAL_TEST} expected)")
+            }
+            val testVar = context.getProperty("testVariable")
+            if (testVar == "${Constants.TEST_VAR}") {
+                sb.appendLine("Context: ${'$'}testVar (OK)")
+            } else {
+                sb.appendLine("Context: ${'$'}testVar (*** ERROR, ${Constants.TEST_VAR} expected)")
+            }
+            var loader = Thread.currentThread().contextClassLoader
+            val classLoaders = mutableListOf<ClassLoader>()
+            while (loader != null) {
+                classLoaders.add(loader)
+                loader = loader.parent
+            }
+            sb.append("ClassLoader: ")
+            sb.appendLine("${'$'}{classLoaders.joinToString(", parent: ") { it.toString() }}")
+            sb.appendLine("Classpath: ${'$'}{System.getProperty("java.class.path")}")
+            //sb.appendLine(de.micromata.springbootkotlinscripting.ScriptExecutor.script)
+            sb.toString()
+        """.trimIndent()
+
 }