+++ /dev/null
-/*
- * 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 com.google.common.cache.CacheBuilder
-import com.google.common.cache.CacheLoader
-import com.google.common.cache.LoadingCache
-import kotlinx.coroutines.async
-import kotlinx.coroutines.coroutineScope
-import kotlinx.coroutines.sync.Mutex
-import kotlinx.coroutines.sync.withLock
-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.ArrayList
-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
- }
- val mutexCache: LoadingCache<String, Mutex> = CacheBuilder.newBuilder()
- .build(CacheLoader.from { s -> Mutex() })
- }
-
- /** 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 if needed */
- log.debug("Jar Exists : ${bluePrintSourceCode.targetJarFile.exists()}, Regenerate : ${bluePrintSourceCode.regenerate}")
-
- mutexCache.get(bluePrintSourceCode.targetJarFile.absolutePath).withLock {
- if (!bluePrintSourceCode.targetJarFile.exists() || bluePrintSourceCode.regenerate) {
- compile(bluePrintSourceCode)
- }
- }
-
- 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
-
- 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 }
-}
Code Review / ccsdk / cds.git / blobdiff