it.unibo.alchemist.boundary.variables.JSR223Variable.kt Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of alchemist-loading Show documentation
Alchemist Machinery to load from files
The newest version!
/*
 * Copyright (C) 2010-2023, Danilo Pianini and contributors
 * listed, for each module, in the respective subproject's build.gradle.kts file.
 *
 * This file is part of Alchemist, and is distributed under the terms of the
 * GNU General Public License, with a linking exception,
 * as described in the file LICENSE in the Alchemist distribution's top directory.
 */

package it.unibo.alchemist.boundary.variables

import it.unibo.alchemist.boundary.DependentVariable
import it.unibo.alchemist.boundary.loader.syntax.DocumentRoot
import kotlinx.coroutines.TimeoutCancellationException
import kotlinx.coroutines.runBlocking
import kotlinx.coroutines.withTimeout
import javax.script.Bindings
import javax.script.ScriptEngineManager
import javax.script.ScriptException
import javax.script.SimpleBindings
import kotlin.reflect.jvm.jvmName

/**
 * This variable loads any [JSR-233](https://archive.is/PGdk8) language available in the classpath.
 *
 * @constructor builds a new JSR223Variable given a language name and a script.
 *
 * @param language can be the name of the language, the file extension, or its mime type
 * @param formula the script that will get interpreted
 * @param timeout how long should the interpreter be allowed to compute before giving up, in ms. Defaults to 1000ms.
 */
data class JSR223Variable @JvmOverloads constructor(
    val language: String,
    val formula: String,
    val timeout: Long = 1000,
) : DependentVariable {

    private val engine by lazy {
        with(ScriptEngineManager()) {
            getEngineByName(language)
                ?: getEngineByExtension(language)
                ?: getEngineByMimeType(language)
                ?: throw IllegalArgumentException(
                    "$language is not an available language. Your environment supports the following languages: ${
                        engineFactories.joinToString(
                            separator = System.lineSeparator(),
                            prefix = System.lineSeparator(),
                        ) {
                            " - ${it.languageName}, " +
                                "aka ${it.extensions + it.mimeTypes} " +
                                "(${it.languageVersion} on ${it.engineName} ${it.engineVersion})"
                        }
                    }",
                )
        }
    }

    /**
     * Given the current controlled variables, computes the current values for
     * this variable.
     *
     * @param variables
     * a mapping between variable names and values
     * @return the value for this value
     * @throws IllegalStateException
     * if the value can not be computed, e.g. because there are
     * unassigned required variables
     */
    override fun getWith(variables: Map): Any? = synchronized(engine) {
        runCatching {
            runBlocking {
                withTimeout(timeout) {
                    engine.eval(formula, variables.asBindings())
                }
            }
        }.getOrElse { cause ->
            val whatHappened = "A $language script evaluation failed"
            val whyHappened = when (cause) {
                is ScriptException -> "due to an error in the script: ${cause.message}"
                is TimeoutCancellationException -> """
                    because it reached its ${timeout}ms timeout.
                    This is usually a sign that something is looping.
                    Either make the script run faster, or allow for a longer time by specifiying a different
                    `${DocumentRoot.DependentVariable.timeout}`.
                """.trimIndent().replace(Regex("\\R"), "")
                else -> """
                    |for a reason unknown to Alchemist. 
                    |${cause::class.jvmName}: ${cause.message}"
                """.trimMargin()
            }
            val inspection = "context: $variables\nscript:\n$formula"
            throw IllegalArgumentException("$whatHappened $whyHappened\n$inspection", cause)
        }
    }

    private fun Map.asBindings(): Bindings = SimpleBindings(toMutableMap())
}