gerrit.onap Code Review - ccsdk/cds.git/blob

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