diff options
Diffstat (limited to 'ms')
6 files changed, 176 insertions, 385 deletions
diff --git a/ms/controllerblueprints/modules/blueprint-core/src/main/kotlin/org/onap/ccsdk/cds/controllerblueprints/core/scripts/BluePrintCompileService.kt b/ms/controllerblueprints/modules/blueprint-core/src/main/kotlin/org/onap/ccsdk/cds/controllerblueprints/core/scripts/BluePrintCompileService.kt new file mode 100644 index 000000000..baae3372d --- /dev/null +++ b/ms/controllerblueprints/modules/blueprint-core/src/main/kotlin/org/onap/ccsdk/cds/controllerblueprints/core/scripts/BluePrintCompileService.kt @@ -0,0 +1,174 @@ +/* + * Copyright © 2019 IBM. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.onap.ccsdk.cds.controllerblueprints.core.scripts + +import kotlinx.coroutines.async +import kotlinx.coroutines.coroutineScope +import org.jetbrains.kotlin.cli.common.ExitCode +import org.jetbrains.kotlin.cli.common.arguments.parseCommandLineArguments +import org.jetbrains.kotlin.cli.common.messages.CompilerMessageLocation +import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity +import org.jetbrains.kotlin.cli.common.messages.MessageCollector +import org.jetbrains.kotlin.cli.jvm.K2JVMCompiler +import org.jetbrains.kotlin.config.Services +import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException +import org.onap.ccsdk.cds.controllerblueprints.core.checkFileExists +import org.onap.ccsdk.cds.controllerblueprints.core.logger +import java.io.File +import java.net.URLClassLoader +import java.util.* +import kotlin.script.experimental.api.SourceCode +import kotlin.script.experimental.jvm.util.classpathFromClasspathProperty +import kotlin.system.measureTimeMillis + + +open class BluePrintCompileService { + val log = logger(BluePrintCompileService::class) + + companion object { + val classPaths = classpathFromClasspathProperty()?.joinToString(File.pathSeparator) { + it.absolutePath + } + } + + /** Compile the [bluePrintSourceCode] and get the [kClassName] instance for the constructor [args] */ + suspend fun <T> eval(bluePrintSourceCode: BluePrintSourceCode, kClassName: String, + args: ArrayList<Any?>?): T { + /** Compile the source code */ + compile(bluePrintSourceCode) + /** Get the class loader with compiled jar */ + val classLoaderWithDependencies = BluePrintCompileCache.classLoader(bluePrintSourceCode.cacheKey) + /* Create the instance from the class loader */ + return instance(classLoaderWithDependencies, kClassName, args) + } + + /** Compile [bluePrintSourceCode] and put into cache */ + suspend fun compile(bluePrintSourceCode: BluePrintSourceCode) { + //TODO("Include Multiple folders") + val sourcePath = bluePrintSourceCode.blueprintKotlinSources.first() + val compiledJarFile = bluePrintSourceCode.targetJarFile + + /** Check cache is present for the blueprint scripts */ + val hasCompiledCache = BluePrintCompileCache.hasClassLoader(bluePrintSourceCode.cacheKey) + + log.debug("Jar Exists : ${compiledJarFile.exists()}, Regenerate : ${bluePrintSourceCode.regenerate}," + + " Compiled hash(${bluePrintSourceCode.cacheKey}) : $hasCompiledCache") + + if (!compiledJarFile.exists() || bluePrintSourceCode.regenerate || !hasCompiledCache) { + log.info("compiling for cache key(${bluePrintSourceCode.cacheKey})") + coroutineScope { + val timeTaken = measureTimeMillis { + /** Create compile arguments */ + val args = mutableListOf<String>().apply { + add("-no-stdlib") + add("-no-reflect") + add("-module-name") + add(bluePrintSourceCode.moduleName) + add("-cp") + add(classPaths!!) + add(sourcePath) + add("-d") + add(compiledJarFile.absolutePath) + } + val deferredCompile = async { + val k2jvmCompiler = K2JVMCompiler() + /** Construct Arguments */ + val arguments = k2jvmCompiler.createArguments() + parseCommandLineArguments(args, arguments) + val messageCollector = CompilationMessageCollector() + /** Compile with arguments */ + val exitCode: ExitCode = k2jvmCompiler.exec(messageCollector, Services.EMPTY, arguments) + when (exitCode) { + ExitCode.OK -> { + checkFileExists(compiledJarFile) + { "couldn't generate compiled jar(${compiledJarFile.absolutePath})" } + } + else -> { + throw BluePrintException("$exitCode :${messageCollector.errors().joinToString("\n")}") + } + } + } + deferredCompile.await() + } + log.info("compiled in ($timeTaken)mSec for cache key(${bluePrintSourceCode.cacheKey})") + } + } + } + + /** create class [kClassName] instance from [classLoader] */ + fun <T> instance(classLoader: URLClassLoader, kClassName: String, args: ArrayList<Any?>? = arrayListOf()): T { + val kClazz = classLoader.loadClass(kClassName) + ?: throw BluePrintException("failed to load class($kClassName) from current class loader.") + + val instance = if (args.isNullOrEmpty()) { + kClazz.newInstance() + } else { + kClazz.constructors + .single().newInstance(*args.toArray()) + } ?: throw BluePrintException("failed to create class($kClassName) instance for constructor argument($args).") + return instance as T + } +} + +/** Compile source code information */ +open class BluePrintSourceCode : SourceCode { + lateinit var blueprintKotlinSources: MutableList<String> + lateinit var moduleName: String + lateinit var targetJarFile: File + lateinit var cacheKey: String + var regenerate: Boolean = false + + override val text: String + get() = "" + + override val locationId: String? = null + + override val name: String? + get() = moduleName +} + +/** Class to collect compilation Data */ +data class CompiledMessageData( + val severity: CompilerMessageSeverity, + val message: String, + val location: CompilerMessageLocation? +) + +/** Class to collect compilation results */ +class CompilationMessageCollector : MessageCollector { + + private val compiledMessages: MutableList<CompiledMessageData> = arrayListOf() + + override fun report(severity: CompilerMessageSeverity, message: String, location: CompilerMessageLocation?) { + synchronized(compiledMessages) { + compiledMessages.add(CompiledMessageData(severity, message, location)) + } + } + + override fun hasErrors() = + synchronized(compiledMessages) { + compiledMessages.any { it.severity.isError } + } + + override fun clear() { + synchronized(compiledMessages) { + compiledMessages.clear() + } + } + + fun errors(): List<CompiledMessageData> = compiledMessages.filter { it.severity == CompilerMessageSeverity.ERROR } +}
\ No newline at end of file diff --git a/ms/controllerblueprints/modules/blueprint-core/src/main/kotlin/org/onap/ccsdk/cds/controllerblueprints/core/scripts/BluePrintCompiledScript.kt b/ms/controllerblueprints/modules/blueprint-core/src/main/kotlin/org/onap/ccsdk/cds/controllerblueprints/core/scripts/BluePrintCompiledScript.kt deleted file mode 100644 index 2f131f6f6..000000000 --- a/ms/controllerblueprints/modules/blueprint-core/src/main/kotlin/org/onap/ccsdk/cds/controllerblueprints/core/scripts/BluePrintCompiledScript.kt +++ /dev/null @@ -1,51 +0,0 @@ -/* - * Copyright © 2017-2018 AT&T Intellectual Property. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.onap.ccsdk.cds.controllerblueprints.core.scripts - -import java.io.Serializable -import kotlin.reflect.KClass -import kotlin.script.experimental.api.* - -open class BluePrintCompiledScript<out BCS : String>( - val cacheKey: String, - val scriptCompilationConfiguration: ScriptCompilationConfiguration) : - CompiledScript<BCS>, Serializable { - - lateinit var scriptClassFQName: String - - override val compilationConfiguration: ScriptCompilationConfiguration - get() = scriptCompilationConfiguration - - override suspend fun getClass(scriptEvaluationConfiguration: ScriptEvaluationConfiguration?) - : ResultWithDiagnostics<KClass<*>> = try { - - /** Get the class loader from the cache */ - val classLoaderWithDependencies = BluePrintCompileCache.classLoader(cacheKey) - - val clazz = classLoaderWithDependencies.loadClass(scriptClassFQName).kotlin - clazz.asSuccess() - } catch (e: Throwable) { - ResultWithDiagnostics.Failure( - ScriptDiagnostic( - "Unable to instantiate class $scriptClassFQName", - exception = e - ) - ) - } - -} - diff --git a/ms/controllerblueprints/modules/blueprint-core/src/main/kotlin/org/onap/ccsdk/cds/controllerblueprints/core/scripts/BluePrintCompilerProxy.kt b/ms/controllerblueprints/modules/blueprint-core/src/main/kotlin/org/onap/ccsdk/cds/controllerblueprints/core/scripts/BluePrintCompilerProxy.kt deleted file mode 100644 index 546631240..000000000 --- a/ms/controllerblueprints/modules/blueprint-core/src/main/kotlin/org/onap/ccsdk/cds/controllerblueprints/core/scripts/BluePrintCompilerProxy.kt +++ /dev/null @@ -1,170 +0,0 @@ -/* - * Copyright © 2017-2018 AT&T Intellectual Property. - * Modifications Copyright © 2018 IBM. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.onap.ccsdk.cds.controllerblueprints.core.scripts - -import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys -import org.jetbrains.kotlin.cli.common.config.addKotlinSourceRoots -import org.jetbrains.kotlin.cli.common.environment.setIdeaIoUseFallback -import org.jetbrains.kotlin.cli.common.messages.AnalyzerWithCompilerReport -import org.jetbrains.kotlin.cli.common.messages.CompilerMessageLocation -import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity -import org.jetbrains.kotlin.cli.common.messages.MessageCollector -import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles -import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment -import org.jetbrains.kotlin.cli.jvm.compiler.KotlinToJVMBytecodeCompiler -import org.jetbrains.kotlin.cli.jvm.config.JvmClasspathRoot -import org.jetbrains.kotlin.com.intellij.openapi.util.Disposer -import org.jetbrains.kotlin.config.* -import org.onap.ccsdk.cds.controllerblueprints.core.checkFileExists -import org.slf4j.LoggerFactory -import kotlin.script.experimental.api.* -import kotlin.script.experimental.host.ScriptingHostConfiguration -import kotlin.script.experimental.jvm.util.classpathFromClasspathProperty -import kotlin.script.experimental.jvmhost.KJvmCompilerProxy - -open class BluePrintsCompilerProxy(private val hostConfiguration: ScriptingHostConfiguration) : KJvmCompilerProxy { - - private val log = LoggerFactory.getLogger(BluePrintsCompilerProxy::class.java)!! - - override fun compile(script: SourceCode, scriptCompilationConfiguration: ScriptCompilationConfiguration) - : ResultWithDiagnostics<CompiledScript<*>> { - - val messageCollector = ScriptDiagnosticsMessageCollector() - - fun failure(vararg diagnostics: ScriptDiagnostic): ResultWithDiagnostics.Failure = - ResultWithDiagnostics.Failure(*messageCollector.diagnostics.toTypedArray(), *diagnostics) - - // Compile the Code - try { - - log.trace("Scripting Host Configuration : $hostConfiguration") - - setIdeaIoUseFallback() - - val blueprintSourceCode = script as BluePrintSourceCode - - val compiledJarFile = blueprintSourceCode.targetJarFile - - /** Check cache is present for the blueprint scripts */ - val hasCompiledCache = BluePrintCompileCache.hasClassLoader(blueprintSourceCode.cacheKey) - - log.debug("Jar Exists : ${compiledJarFile.exists()}, Regenerate : ${blueprintSourceCode.regenerate}," + - " Compiled hash(${blueprintSourceCode.cacheKey}) : $hasCompiledCache") - - if (!compiledJarFile.exists() || blueprintSourceCode.regenerate || !hasCompiledCache) { - log.info("compiling for cache key(${blueprintSourceCode.cacheKey})") - - var environment: KotlinCoreEnvironment? = null - - val rootDisposable = Disposer.newDisposable() - - try { - - // Clean the cache, if present - if (hasCompiledCache) { - BluePrintCompileCache.cleanClassLoader(blueprintSourceCode.cacheKey) - } - - val compilerConfiguration = CompilerConfiguration().apply { - - put(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY, messageCollector) - put(CommonConfigurationKeys.MODULE_NAME, blueprintSourceCode.moduleName) - put(JVMConfigurationKeys.OUTPUT_JAR, compiledJarFile) - put(JVMConfigurationKeys.RETAIN_OUTPUT_IN_MEMORY, false) - - // Load Current Class loader to Compilation Class loader - val currentClassLoader = classpathFromClasspathProperty() - currentClassLoader?.forEach { - add(CLIConfigurationKeys.CONTENT_ROOTS, JvmClasspathRoot(it)) - } - - // Add all Kotlin Sources - addKotlinSourceRoots(blueprintSourceCode.blueprintKotlinSources) - // for Kotlin 1.3.30 greater - //add(ComponentRegistrar.PLUGIN_COMPONENT_REGISTRARS, ScriptingCompilerConfigurationComponentRegistrar()) - - languageVersionSettings = LanguageVersionSettingsImpl( - LanguageVersion.LATEST_STABLE, ApiVersion.LATEST_STABLE, mapOf(AnalysisFlags.skipMetadataVersionCheck to true) - ) - } - - //log.info("Executing with compiler configuration : $compilerConfiguration") - - environment = KotlinCoreEnvironment.createForProduction(rootDisposable, compilerConfiguration, - EnvironmentConfigFiles.JVM_CONFIG_FILES) - - // Compile Kotlin Sources - val compiled = KotlinToJVMBytecodeCompiler.compileBunchOfSources(environment) - - val analyzerWithCompilerReport = AnalyzerWithCompilerReport(messageCollector, - environment.configuration.languageVersionSettings) - - if (analyzerWithCompilerReport.hasErrors()) { - return ResultWithDiagnostics.Failure(messageCollector.diagnostics) - } - } finally { - rootDisposable.dispose() - } - } - - checkFileExists(compiledJarFile) { "couldn't generate compiled jar(${compiledJarFile.absolutePath})" } - - val compiledScript = BluePrintCompiledScript<String>(blueprintSourceCode.cacheKey, scriptCompilationConfiguration) - - return compiledScript.asSuccess() - - } catch (ex: Throwable) { - return failure(ex.asDiagnostics()) - } - } -} - -class ScriptDiagnosticsMessageCollector : MessageCollector { - - private val _diagnostics = arrayListOf<ScriptDiagnostic>() - - val diagnostics: List<ScriptDiagnostic> get() = _diagnostics - - override fun clear() { - _diagnostics.clear() - } - - override fun hasErrors(): Boolean = - _diagnostics.any { it.severity == ScriptDiagnostic.Severity.ERROR } - - - override fun report(severity: CompilerMessageSeverity, message: String, location: CompilerMessageLocation?) { - val mappedSeverity = when (severity) { - CompilerMessageSeverity.EXCEPTION, - CompilerMessageSeverity.ERROR -> ScriptDiagnostic.Severity.ERROR - CompilerMessageSeverity.STRONG_WARNING, - CompilerMessageSeverity.WARNING -> ScriptDiagnostic.Severity.WARNING - CompilerMessageSeverity.INFO -> ScriptDiagnostic.Severity.INFO - CompilerMessageSeverity.LOGGING -> ScriptDiagnostic.Severity.DEBUG - else -> null - } - if (mappedSeverity != null) { - val mappedLocation = location?.let { - if (it.line < 0 && it.column < 0) null // special location created by CompilerMessageLocation.create - else SourceCode.Location(SourceCode.Position(it.line, it.column)) - } - _diagnostics.add(ScriptDiagnostic(message, mappedSeverity, location?.path, mappedLocation)) - } - } -} - diff --git a/ms/controllerblueprints/modules/blueprint-core/src/main/kotlin/org/onap/ccsdk/cds/controllerblueprints/core/scripts/BluePrintScriptingHost.kt b/ms/controllerblueprints/modules/blueprint-core/src/main/kotlin/org/onap/ccsdk/cds/controllerblueprints/core/scripts/BluePrintScriptingHost.kt deleted file mode 100644 index d35f2b49b..000000000 --- a/ms/controllerblueprints/modules/blueprint-core/src/main/kotlin/org/onap/ccsdk/cds/controllerblueprints/core/scripts/BluePrintScriptingHost.kt +++ /dev/null @@ -1,94 +0,0 @@ -/* - * Copyright © 2017-2018 AT&T Intellectual Property. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.onap.ccsdk.cds.controllerblueprints.core.scripts - -import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException -import org.slf4j.LoggerFactory -import java.util.* -import kotlin.reflect.full.createInstance -import kotlin.script.experimental.api.* -import kotlin.script.experimental.host.BasicScriptingHost -import kotlin.script.experimental.jvm.defaultJvmScriptingHostConfiguration -import kotlin.script.experimental.jvmhost.JvmScriptCompiler -import kotlin.script.experimental.jvmhost.impl.withDefaults - -val blueprintScriptCompiler = JvmScriptCompiler(defaultJvmScriptingHostConfiguration, - BluePrintsCompilerProxy(defaultJvmScriptingHostConfiguration.withDefaults())) - -open class BlueprintScriptingHost(evaluator: ScriptEvaluator) : BasicScriptingHost(blueprintScriptCompiler, evaluator) { - - override fun eval(script: SourceCode, compilationConfiguration: ScriptCompilationConfiguration, - evaluationConfiguration: ScriptEvaluationConfiguration?): ResultWithDiagnostics<EvaluationResult> = - - runInCoroutineContext { - blueprintScriptCompiler(script, compilationConfiguration) - .onSuccess { compiledScript -> - evaluator(compiledScript, evaluationConfiguration ?: ScriptEvaluationConfiguration.Default) - }.onFailure { failedResult -> - val messages = failedResult.reports.joinToString("\n") - throw BluePrintProcessorException(messages) - } - } -} - -open class BluePrintScriptEvaluator(private val scriptClassName: String) : ScriptEvaluator { - - private val log = LoggerFactory.getLogger(BluePrintScriptEvaluator::class.java)!! - - override suspend operator fun invoke(compiledScript: CompiledScript<*>, - scriptEvaluationConfiguration: ScriptEvaluationConfiguration - ): ResultWithDiagnostics<EvaluationResult> = - try { - log.debug("Getting script class name($scriptClassName) from the compiled sources ") - - val bluePrintCompiledScript = compiledScript as BluePrintCompiledScript - bluePrintCompiledScript.scriptClassFQName = scriptClassName - - when (val classResult = compiledScript.getClass(scriptEvaluationConfiguration)) { - is ResultWithDiagnostics.Failure -> classResult - is ResultWithDiagnostics.Success -> { - - val scriptClass = classResult.value - val args = ArrayList<Any?>() - scriptEvaluationConfiguration.get(ScriptEvaluationConfiguration.providedProperties)?.forEach { - args.add(it.value) - } - scriptEvaluationConfiguration.get(ScriptEvaluationConfiguration.implicitReceivers)?.let { - args.addAll(it) - } - scriptEvaluationConfiguration.get(ScriptEvaluationConfiguration.constructorArgs)?.let { - args.addAll(it) - } - - val instance = if (args.isNotEmpty()) { - scriptClass.java.constructors.single().newInstance(*args.toArray()) - ?: throw BluePrintProcessorException("failed to create instance from the script") - } else { - scriptClass.createInstance() - } - - log.debug("Created script instance of type ${instance.javaClass}") - - ResultWithDiagnostics.Success(EvaluationResult(ResultValue.Value(scriptClass.qualifiedName!!, - instance, "", instance), - scriptEvaluationConfiguration)) - } - } - } catch (e: Throwable) { - ResultWithDiagnostics.Failure(e.asDiagnostics("Error evaluating script")) - } -}
\ No newline at end of file diff --git a/ms/controllerblueprints/modules/blueprint-core/src/main/kotlin/org/onap/ccsdk/cds/controllerblueprints/core/scripts/BluePrintScriptsConfiguration.kt b/ms/controllerblueprints/modules/blueprint-core/src/main/kotlin/org/onap/ccsdk/cds/controllerblueprints/core/scripts/BluePrintScriptsConfiguration.kt deleted file mode 100644 index e01923723..000000000 --- a/ms/controllerblueprints/modules/blueprint-core/src/main/kotlin/org/onap/ccsdk/cds/controllerblueprints/core/scripts/BluePrintScriptsConfiguration.kt +++ /dev/null @@ -1,59 +0,0 @@ -/* - * Copyright © 2017-2018 AT&T Intellectual Property. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.onap.ccsdk.cds.controllerblueprints.core.scripts - -import java.io.File -import kotlin.script.experimental.annotations.KotlinScript -import kotlin.script.experimental.api.* -import kotlin.script.experimental.jvm.jvm -import kotlin.script.experimental.jvm.util.classpathFromClasspathProperty - -@KotlinScript( - fileExtension = "cba.kts", - compilationConfiguration = BluePrintScripCompilationConfiguration::class, - displayName = "Controller Blueprint Archive Kotlin Scripts" -) -abstract class BluePrintKotlinScript - -object BluePrintScripCompilationConfiguration : ScriptCompilationConfiguration( - { - jvm { - //classpathFromClassloader(BluePrintScripCompilationConfiguration::class.java.classLoader) - classpathFromClasspathProperty() - } - ide { - acceptedLocations(ScriptAcceptedLocation.Everywhere) - } - - } -) - -open class BluePrintSourceCode : SourceCode { - lateinit var blueprintKotlinSources: MutableList<String> - lateinit var moduleName: String - lateinit var targetJarFile: File - lateinit var cacheKey: String - var regenerate: Boolean = false - - override val text: String - get() = "" - - override val locationId: String? = null - - override val name: String? - get() = moduleName -} diff --git a/ms/controllerblueprints/modules/blueprint-core/src/main/kotlin/org/onap/ccsdk/cds/controllerblueprints/core/scripts/BluePrintScriptsServiceImpl.kt b/ms/controllerblueprints/modules/blueprint-core/src/main/kotlin/org/onap/ccsdk/cds/controllerblueprints/core/scripts/BluePrintScriptsServiceImpl.kt index 360035327..c067bf3d9 100644 --- a/ms/controllerblueprints/modules/blueprint-core/src/main/kotlin/org/onap/ccsdk/cds/controllerblueprints/core/scripts/BluePrintScriptsServiceImpl.kt +++ b/ms/controllerblueprints/modules/blueprint-core/src/main/kotlin/org/onap/ccsdk/cds/controllerblueprints/core/scripts/BluePrintScriptsServiceImpl.kt @@ -24,9 +24,6 @@ import org.onap.ccsdk.cds.controllerblueprints.core.normalizedPathName import org.onap.ccsdk.cds.controllerblueprints.core.utils.BluePrintFileUtils import org.onap.ccsdk.cds.controllerblueprints.core.utils.BluePrintMetadataUtils import java.util.* -import kotlin.script.experimental.api.ResultValue -import kotlin.script.experimental.api.resultOrNull -import kotlin.script.experimental.jvmhost.createJvmCompilationConfigurationFromTemplate open class BluePrintScriptsServiceImpl : BluePrintScriptsService { @@ -34,14 +31,8 @@ open class BluePrintScriptsServiceImpl : BluePrintScriptsService { val log = logger(BluePrintScriptsServiceImpl::class) override suspend fun <T> scriptInstance(bluePrintSourceCode: BluePrintSourceCode, scriptClassName: String): T { - val compilationConfiguration = createJvmCompilationConfigurationFromTemplate<BluePrintKotlinScript>() - val scriptEvaluator = BluePrintScriptEvaluator(scriptClassName) - - val compiledResponse = BlueprintScriptingHost(scriptEvaluator) - .eval(bluePrintSourceCode, compilationConfiguration, null) - - val returnValue = compiledResponse.resultOrNull()?.returnValue as? ResultValue.Value - return returnValue?.value!! as T + val bluePrintCompileService = BluePrintCompileService() + return bluePrintCompileService.eval(bluePrintSourceCode, scriptClassName, null) } override suspend fun <T> scriptInstance(blueprintBasePath: String, artifactName: String, artifactVersion: String, |