ms/blueprintsprocessor/modules/blueprints/blueprint-core/src/main/kotlin/org/onap/ccsdk/cds/controllerblueprints/core/utils/BluePrintMetadataUtils.kt

   1 /*
   2  * Copyright © 2017-2018 AT&T Intellectual Property.
   3  * Modifications Copyright © 2018-2019 IBM.
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18 package org.onap.ccsdk.cds.controllerblueprints.core.utils
  19
  20 import com.fasterxml.jackson.databind.JsonNode
  21 import kotlinx.coroutines.runBlocking
  22 import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
  23 import org.onap.ccsdk.cds.controllerblueprints.core.asJsonPrimitive
  24 import org.onap.ccsdk.cds.controllerblueprints.core.checkNotEmpty
  25 import org.onap.ccsdk.cds.controllerblueprints.core.data.ToscaMetaData
  26 import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintDefinitions
  27 import org.onap.ccsdk.cds.controllerblueprints.core.normalizedFile
  28 import org.onap.ccsdk.cds.controllerblueprints.core.normalizedPathName
  29 import org.onap.ccsdk.cds.controllerblueprints.core.readNBLines
  30 import org.onap.ccsdk.cds.controllerblueprints.core.scripts.BluePrintScriptsServiceImpl
  31 import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintContext
  32 import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintImportService
  33 import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintRuntimeService
  34 import org.onap.ccsdk.cds.controllerblueprints.core.service.DefaultBluePrintRuntimeService
  35 import org.slf4j.LoggerFactory
  36 import java.io.File
  37 import java.util.Properties
  38
  39 class BluePrintMetadataUtils {
  40     companion object {
  41         private val log = LoggerFactory.getLogger(this::class.toString())
  42
  43         suspend fun toscaMetaData(basePath: String): ToscaMetaData {
  44             val toscaMetaPath = basePath.plus(BluePrintConstants.PATH_DIVIDER)
  45                 .plus(BluePrintConstants.TOSCA_METADATA_ENTRY_DEFINITION_FILE)
  46             return toscaMetaDataFromMetaFile(toscaMetaPath)
  47         }
  48
  49         suspend fun entryDefinitionFile(basePath: String): String {
  50             val toscaMetaPath = basePath.plus(BluePrintConstants.PATH_DIVIDER)
  51                 .plus(BluePrintConstants.TOSCA_METADATA_ENTRY_DEFINITION_FILE)
  52             return toscaMetaDataFromMetaFile(toscaMetaPath).entityDefinitions
  53         }
  54
  55         fun bluePrintEnvProperties(basePath: String): Properties {
  56             val blueprintsEnvFilePath = basePath.plus(File.separator)
  57                 .plus(BluePrintConstants.TOSCA_ENVIRONMENTS_DIR)
  58             return environmentFileProperties(blueprintsEnvFilePath)
  59         }
  60
  61         fun environmentFileProperties(pathName: String): Properties {
  62             val properties = Properties()
  63             val envDir = normalizedFile(pathName)
  64             // Verify if the environment directory exists
  65             if (envDir.exists() && envDir.isDirectory) {
  66                 // Find all available environment files
  67                 envDir.listFiles()!!
  68                     .filter { it.name.endsWith(".properties") }
  69                     .forEach {
  70                         val istream = it.inputStream()
  71                         properties.load(istream)
  72                         istream.close()
  73                     }
  74             }
  75             return properties
  76         }
  77
  78         private suspend fun toscaMetaDataFromMetaFile(metaFilePath: String): ToscaMetaData {
  79             val toscaMetaData = ToscaMetaData()
  80             val lines = normalizedFile(metaFilePath).readNBLines()
  81             lines.forEach { line ->
  82                 if (line.contains(":")) {
  83                     val keyValue = line.split(":")
  84                     if (keyValue.size == 2) {
  85                         val value: String = keyValue[1].trim()
  86                         when (keyValue[0]) {
  87                             "TOSCA-Meta-File-Version" -> toscaMetaData.toscaMetaFileVersion = value
  88                             "CSAR-Version" -> toscaMetaData.csarVersion = value
  89                             "Created-By" -> toscaMetaData.createdBy = value
  90                             "Entry-Definitions" -> toscaMetaData.entityDefinitions = value
  91                             "Template-Name" -> toscaMetaData.templateName = value
  92                             "Template-Version" -> toscaMetaData.templateVersion = value
  93                             "Template-Tags" -> toscaMetaData.templateTags = value
  94                         }
  95                     }
  96                 }
  97             }
  98             return toscaMetaData
  99         }
 100
 101         fun getBluePrintRuntime(id: String, blueprintBasePath: String):
 102                 BluePrintRuntimeService<MutableMap<String, JsonNode>> {
 103             val bluePrintContext: BluePrintContext = getBluePrintContext(blueprintBasePath)
 104             return getBluePrintRuntime(id, bluePrintContext)
 105         }
 106
 107         fun getBluePrintRuntime(id: String, bluePrintContext: BluePrintContext):
 108                 BluePrintRuntimeService<MutableMap<String, JsonNode>> {
 109             checkNotEmpty(bluePrintContext.rootPath) { "blueprint context root path is missing." }
 110             checkNotEmpty(bluePrintContext.entryDefinition) { "blueprint context entry definition is missing." }
 111             val blueprintBasePath = bluePrintContext.rootPath
 112             val bluePrintRuntimeService = DefaultBluePrintRuntimeService(id, bluePrintContext)
 113             bluePrintRuntimeService.put(BluePrintConstants.PROPERTY_BLUEPRINT_BASE_PATH, blueprintBasePath.asJsonPrimitive())
 114             bluePrintRuntimeService.put(BluePrintConstants.PROPERTY_BLUEPRINT_PROCESS_ID, id.asJsonPrimitive())
 115             return bluePrintRuntimeService
 116         }
 117
 118         suspend fun getBaseEnhancementBluePrintRuntime(id: String, blueprintBasePath: String):
 119                 BluePrintRuntimeService<MutableMap<String, JsonNode>> {
 120
 121             val bluePrintContext: BluePrintContext = getBaseEnhancementBluePrintContext(blueprintBasePath)
 122
 123             val bluePrintRuntimeService = DefaultBluePrintRuntimeService(id, bluePrintContext)
 124             bluePrintRuntimeService.put(BluePrintConstants.PROPERTY_BLUEPRINT_BASE_PATH, blueprintBasePath.asJsonPrimitive())
 125             bluePrintRuntimeService.put(BluePrintConstants.PROPERTY_BLUEPRINT_PROCESS_ID, id.asJsonPrimitive())
 126
 127             return bluePrintRuntimeService
 128         }
 129
 130         fun getBluePrintRuntime(id: String, blueprintBasePath: String, executionContext: MutableMap<String, JsonNode>):
 131                 BluePrintRuntimeService<MutableMap<String, JsonNode>> {
 132             val bluePrintContext: BluePrintContext = getBluePrintContext(blueprintBasePath)
 133             val bluePrintRuntimeService = DefaultBluePrintRuntimeService(id, bluePrintContext)
 134             executionContext.forEach {
 135                 bluePrintRuntimeService.put(it.key, it.value)
 136             }
 137
 138             bluePrintRuntimeService.setExecutionContext(executionContext)
 139             return bluePrintRuntimeService
 140         }
 141
 142         fun getBluePrintContext(blueprintBasePath: String): BluePrintContext = runBlocking {
 143
 144             val toscaMetaData: ToscaMetaData = toscaMetaData(blueprintBasePath)
 145
 146             log.info("Reading blueprint path($blueprintBasePath) and entry definition file (${toscaMetaData.entityDefinitions})")
 147
 148             // If the EntryDefinition is Kotlin file, compile and get Service Template
 149             if (toscaMetaData.entityDefinitions.endsWith("kt")) {
 150                 readBlueprintKotlinFile(toscaMetaData, blueprintBasePath)
 151             } else {
 152                 readBlueprintFile(toscaMetaData.entityDefinitions, blueprintBasePath)
 153             }
 154         }
 155
 156         private suspend fun getBaseEnhancementBluePrintContext(blueprintBasePath: String): BluePrintContext {
 157             val toscaMetaData: ToscaMetaData = toscaMetaData(blueprintBasePath)
 158             // Clean Type files
 159             BluePrintFileUtils.deleteBluePrintTypes(blueprintBasePath)
 160             val rootFilePath: String = blueprintBasePath.plus(File.separator).plus(toscaMetaData.entityDefinitions)
 161             val rootServiceTemplate = ServiceTemplateUtils.getServiceTemplate(rootFilePath)
 162
 163             // Clean the Import Definitions
 164             BluePrintFileUtils.cleanImportTypes(rootServiceTemplate)
 165
 166             val blueprintContext = BluePrintContext(rootServiceTemplate)
 167             blueprintContext.rootPath = blueprintBasePath
 168             blueprintContext.entryDefinition = toscaMetaData.entityDefinitions
 169             return blueprintContext
 170         }
 171
 172         private suspend fun readBlueprintFile(entityDefinitions: String, basePath: String): BluePrintContext {
 173             val normalizedBasePath = normalizedPathName(basePath)
 174             val rootFilePath = normalizedPathName(normalizedBasePath, entityDefinitions)
 175             val rootServiceTemplate = ServiceTemplateUtils.getServiceTemplate(rootFilePath)
 176             // Recursively Import Template files
 177             val schemaImportResolverUtils = BluePrintImportService(rootServiceTemplate, normalizedBasePath)
 178             val completeServiceTemplate = schemaImportResolverUtils.getImportResolvedServiceTemplate()
 179             val blueprintContext = BluePrintContext(completeServiceTemplate)
 180             blueprintContext.rootPath = normalizedBasePath
 181             blueprintContext.entryDefinition = entityDefinitions
 182             return blueprintContext
 183         }
 184
 185         /** Reade the Service Template Definitions from the Kotlin file */
 186         private suspend fun readBlueprintKotlinFile(toscaMetaData: ToscaMetaData, basePath: String): BluePrintContext {
 187
 188             checkNotNull(toscaMetaData.templateName) { "couldn't find 'Template-Name' key in TOSCA.meta" }
 189             checkNotNull(toscaMetaData.templateVersion) { "couldn't find 'Template-Version' key in TOSCA.meta" }
 190
 191             val definitionClassName = toscaMetaData.entityDefinitions.removeSuffix(".kt")
 192             val normalizedBasePath = normalizedPathName(basePath)
 193
 194             val bluePrintScriptsService = BluePrintScriptsServiceImpl()
 195             val bluePrintDefinitions = bluePrintScriptsService
 196                 .scriptInstance<BluePrintDefinitions>(
 197                     normalizedBasePath, toscaMetaData.templateName!!,
 198                     toscaMetaData.templateVersion!!, definitionClassName, false
 199                 )
 200             // Get the Service Template
 201             val serviceTemplate = bluePrintDefinitions.serviceTemplate()
 202
 203             // Clean the Default type import Definitions
 204             BluePrintFileUtils.cleanImportTypes(serviceTemplate)
 205
 206             val blueprintContext = BluePrintContext(serviceTemplate)
 207             blueprintContext.rootPath = normalizedBasePath
 208             blueprintContext.entryDefinition = toscaMetaData.entityDefinitions
 209             blueprintContext.otherDefinitions = bluePrintDefinitions.otherDefinitions()
 210             return blueprintContext
 211         }
 212     }
 213 }