WIP

Author: kreinhard

application/build.gradle.kts

@@ -15,9 +15,14 @@ val kotlinVersion = "2.0.21"
 
 val kotlinCompilerDependency = configurations.create("kotlinCompilerDependency")
 val kotlinCompilerDependencies = mutableListOf<String>()
+val versionOfSubmodules = "0.0.1"
+// All submodules must be unpacked with direct usage in scripts:
+val unpackSubmodules = listOf("business") // business must be unpacked, because KotlinScriptContext is used by scripts.
 
 dependencies {
-    implementation(project(":business"))
+    unpackSubmodules.forEach { module ->
+        implementation(project(":$module"))
+    }
     // Spring Boot
     implementation("org.springframework.boot:spring-boot-starter")
     implementation("org.springframework.boot:spring-boot-starter-web")
@@ -46,13 +51,16 @@ dependencies {
     testImplementation("org.springframework.boot:spring-boot-starter-test")
 }
 
-val kotlinCompilerDependencyFiles = kotlinCompilerDependency.map { it.name }
+val kotlinCompilerDependencyFiles = kotlinCompilerDependency.map { it.name } + unpackSubmodules.map { "$it-$versionOfSubmodules.jar" }
 tasks.named<BootJar>("bootJar") {
     // println(kotlinCompilerDependencyFiles.joinToString())
     exclude(kotlinCompilerDependencyFiles.map { "**/$it" })
 }
 
 tasks.withType<Jar> {
+    unpackSubmodules.forEach { module ->
+        dependsOn(":$module:jar")
+    }
     duplicatesStrategy = DuplicatesStrategy.EXCLUDE
     from({
         configurations.runtimeClasspath.get().filter {

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

@@ -1,7 +1,9 @@
 package de.micromata.kotlinscripting
 
+import org.jetbrains.kotlin.ir.types.IdSignatureValues.result
 import org.springframework.boot.autoconfigure.SpringBootApplication
 import org.springframework.boot.runApplication
+import kotlin.script.experimental.api.ResultValue
 import kotlin.script.experimental.api.ResultWithDiagnostics
 import kotlin.script.experimental.api.valueOrNull
 
@@ -15,13 +17,21 @@ class DemoApplication {
 
             val scriptExecutor = ScriptExecutor()
             val result = scriptExecutor.executeScript()
-            if (result is ResultWithDiagnostics<*>) {
-                println("Script result: ${result.valueOrNull()}")
+            if (result is ResultWithDiagnostics.Success) {
+                val returnValue = result.valueOrNull()?.returnValue
+                val output = if (returnValue is ResultValue.Value) {
+                    returnValue.value
+                }   else {
+                    returnValue
+                }
+                println("Script result with success: ${output}")
+            } else if (result is ResultWithDiagnostics<*>) {
+                println("*** Script result: ${result.valueOrNull()}")
                 result.reports.forEach {
                     println("Script report: ${it.message}")
                 }
             } else {
-                println("Script result: $result")
+                println("*** Script result: $result")
             }
         }
     }

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

@@ -1,5 +1,6 @@
 package de.micromata.kotlinscripting
 
+import de.micromata.kotlinscripting.business.ThreadLocalStorage
 import mu.KotlinLogging
 import kotlin.script.experimental.api.*
 import kotlin.script.experimental.jvmhost.BasicJvmScriptingHost
@@ -17,13 +18,14 @@ class CustomScriptingHost(
     ): ResultWithDiagnostics<EvaluationResult> {
         val originalClassLoader = Thread.currentThread().contextClassLoader
         return try {
-            // Setzen des gewünschten ClassLoaders
-            Thread.currentThread().contextClassLoader = customClassLoader
-            log.info { "CustomScriptingHost: Setting custom ClassLoader: $customClassLoader" }
+            ThreadLocalStorage.threadLocal.set(Constants.THREADLOCAL_TEST)
+            // Trying to set the custom ClassLoader here.
+            // Thread.currentThread().contextClassLoader = customClassLoader
+            // log.info { "CustomScriptingHost: Setting custom ClassLoader: $customClassLoader" }
             super.eval(script, compilationConfiguration, evaluationConfiguration)
         } finally {
-            // Zurücksetzen des ursprünglichen ClassLoaders
-            Thread.currentThread().contextClassLoader = originalClassLoader
+            // Resetting the original ClassLoader:
+            // Thread.currentThread().contextClassLoader = originalClassLoader
         }
     }
 }

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

@@ -1,41 +1,41 @@
 package de.micromata.kotlinscripting
 
 import mu.KotlinLogging
-import java.io.File
 import java.util.concurrent.Executors
 import java.util.concurrent.Future
 import java.util.concurrent.TimeUnit
 import java.util.concurrent.TimeoutException
 import kotlin.script.experimental.api.*
 import kotlin.script.experimental.host.toScriptSource
-import kotlin.script.experimental.jvm.JvmDependencyFromClassLoader
 import kotlin.script.experimental.jvm.baseClassLoader
+import kotlin.script.experimental.jvm.dependenciesFromClassloader
 import kotlin.script.experimental.jvm.jvm
 
 private val log = KotlinLogging.logger {}
 
 class ScriptExecutor {
     private var evalException: Exception? = null
 
-    fun executeScript(): Any? {
+    fun executeScript(): ResultWithDiagnostics<EvaluationResult>? {
         val classLoader = CustomClassLoader(Thread.currentThread().contextClassLoader)
 
-        //val scriptingHost = BasicJvmScriptingHost()
         val scriptingHost = CustomScriptingHost(classLoader)
-        val dependencies =
-            listOf(File("/Users/kai/workspace/Micromata/SpringBoot-KotlinScripting/build/libs/SpringBoot-KotlinScripting-0.0.1-SNAPSHOT.jar"))
         val compilationConfig = ScriptCompilationConfiguration {
             jvm {
-                dependencies(JvmDependencyFromClassLoader { classLoader })
+                dependenciesFromClassloader(classLoader = classLoader, wholeClasspath = true)
                 //dependencies(JvmDependency(dependencies))
                 //dependenciesFromClassloader(classLoader = classLoader, wholeClasspath = true)
             }
+            providedProperties("context" to KotlinScriptContext::class)
+            compilerOptions.append("-nowarn")
         }
+        val context = KotlinScriptContext()
+        context.setProperty("testVariable", Constants.TEST_VAR)
         val evaluationConfiguration = ScriptEvaluationConfiguration {
             jvm {
-                //actualClassLoader(CustomClassLoader(Thread.currentThread().contextClassLoader))
                 baseClassLoader(classLoader)
             }
+            providedProperties("context" to context)
         }
         val scriptSource = script.toScriptSource()
         val executor = Executors.newSingleThreadExecutor()
@@ -44,7 +44,7 @@ class ScriptExecutor {
             future = executor.submit<ResultWithDiagnostics<EvaluationResult>> {
                 scriptingHost.eval(scriptSource, compilationConfig, evaluationConfiguration)
             }
-            return future.get(500, TimeUnit.SECONDS)  // Timeout
+            return future.get(10, TimeUnit.SECONDS)  // Timeout
         } catch (ex: TimeoutException) {
             log.info("Script execution was cancelled due to timeout.")
             future?.cancel(true)  // Attempt to cancel
@@ -61,17 +61,34 @@ class ScriptExecutor {
     }
 
     companion object {
+        val simplestScript = "\"Hello world!\""
         val script = """
-            // Don't use StringBuilder here, because it's might not be available in the script classpath.
-            var result = "Hello world!\n"
+            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) {
-                result += "ClassLoader: ${'$'}loader\n"
+                classLoaders.add(loader)
                 loader = loader.parent
             }
-            result += "Classpath: ${'$'}{System.getProperty("java.class.path")}\n"
+            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)
-            result
+            sb.toString()
         """.trimIndent()
     }
 }

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

@@ -0,0 +1,6 @@
+package de.micromata.kotlinscripting
+
+object Constants {
+    val THREADLOCAL_TEST = "Hello script! Greetings from ThreadLocal."
+    val TEST_VAR = "Hello script! Greetings from testVar."
+}

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

@@ -0,0 +1,39 @@
+/////////////////////////////////////////////////////////////////////////////
+//
+// Project ProjectForge Community Edition
+//         www.projectforge.org
+//
+// Copyright (C) 2001-2024 Micromata GmbH, Germany (www.micromata.com)
+//
+// ProjectForge is dual-licensed.
+//
+// This community edition is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License as published
+// by the Free Software Foundation; version 3 of the License.
+//
+// This community edition is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
+// Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this program; if not, see http://www.gnu.org/licenses/.
+//
+/////////////////////////////////////////////////////////////////////////////
+
+package de.micromata.kotlinscripting
+
+/**
+ * Context for bindings.
+ */
+class KotlinScriptContext {
+    private val propertyValues = mutableMapOf<String, Any?>()
+
+    fun setProperty(name: String, value: Any?) {
+        propertyValues[name] = value
+    }
+
+    fun getProperty(name: String): Any? {
+        return propertyValues[name]
+    }
+}

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

@@ -0,0 +1,8 @@
+package de.micromata.kotlinscripting.business
+
+/**
+ * ThreadLocalStorage object for testing access of ThreadLocal variables inside scripts.
+ */
+object ThreadLocalStorage {
+    val threadLocal = ThreadLocal.withInitial { "Default Value" }
+}