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

   1 /*\r
   2  * Copyright © 2017-2018 AT&T Intellectual Property.\r
   3  * Modifications Copyright © 2018 IBM.\r
   4  *\r
   5  * Licensed under the Apache License, Version 2.0 (the "License");\r
   6  * you may not use this file except in compliance with the License.\r
   7  * You may obtain a copy of the License at\r
   8  *\r
   9  *     http://www.apache.org/licenses/LICENSE-2.0\r
  10  *\r
  11  * Unless required by applicable law or agreed to in writing, software\r
  12  * distributed under the License is distributed on an "AS IS" BASIS,\r
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
  14  * See the License for the specific language governing permissions and\r
  15  * limitations under the License.\r
  16  */\r
  17 \r
  18 package org.onap.ccsdk.apps.controllerblueprints.service.enhancer\r
  19 \r
  20 import com.att.eelf.configuration.EELFLogger\r
  21 import com.att.eelf.configuration.EELFManager\r
  22 import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintException\r
  23 import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintTypes\r
  24 import org.onap.ccsdk.apps.controllerblueprints.core.data.*\r
  25 import org.onap.ccsdk.apps.controllerblueprints.core.format\r
  26 import org.onap.ccsdk.apps.controllerblueprints.core.service.BluePrintContext\r
  27 import org.onap.ccsdk.apps.controllerblueprints.core.service.BluePrintRepoService\r
  28 import org.onap.ccsdk.apps.controllerblueprints.core.utils.BluePrintFileUtils\r
  29 import org.onap.ccsdk.apps.controllerblueprints.core.utils.BluePrintMetadataUtils\r
  30 import java.io.Serializable\r
  31 \r
  32 /**\r
  33  * BluePrintEnhancerService\r
  34  * @author Brinda Santh\r
  35  *\r
  36  */\r
  37 interface BluePrintEnhancerService : Serializable {\r
  38 \r
  39     @Throws(BluePrintException::class)\r
  40     fun enhance(basePath: String, enrichedBasePath: String): BluePrintContext\r
  41 \r
  42     /**\r
  43      * Read Blueprint from CBA structure Directory\r
  44      */\r
  45     @Throws(BluePrintException::class)\r
  46     fun enhance(basePath: String): BluePrintContext\r
  47 \r
  48     @Throws(BluePrintException::class)\r
  49     fun enhance(serviceTemplate: ServiceTemplate): ServiceTemplate\r
  50 \r
  51     @Throws(BluePrintException::class)\r
  52     fun enrichNodeTemplate(nodeTemplateName: String, nodeTemplate: NodeTemplate)\r
  53 \r
  54     @Throws(BluePrintException::class)\r
  55     fun enrichNodeType(nodeTypeName: String, nodeType: NodeType)\r
  56 \r
  57     @Throws(BluePrintException::class)\r
  58     fun enrichPropertyDefinition(propertyName: String, propertyDefinition: PropertyDefinition)\r
  59 }\r
  60 \r
  61 open class BluePrintEnhancerDefaultService(val bluePrintRepoService: BluePrintRepoService) : BluePrintEnhancerService {\r
  62 \r
  63     private val log: EELFLogger = EELFManager.getInstance().getLogger(BluePrintEnhancerDefaultService::class.toString())\r
  64 \r
  65     lateinit var serviceTemplate: ServiceTemplate\r
  66 \r
  67     override fun enhance(basePath: String, enrichedBasePath: String): BluePrintContext {\r
  68         BluePrintFileUtils.copyBluePrint(basePath, enrichedBasePath)\r
  69         BluePrintFileUtils.deleteBluePrintTypes(enrichedBasePath)\r
  70         val enhancedBluePrintContext = enhance(enrichedBasePath)\r
  71         BluePrintFileUtils.writeBluePrintTypes(enhancedBluePrintContext)\r
  72         return enhancedBluePrintContext\r
  73     }\r
  74 \r
  75     @Throws(BluePrintException::class)\r
  76     override fun enhance(basePath: String): BluePrintContext {\r
  77         val bluePrintContext = BluePrintMetadataUtils.getBluePrintContext(basePath)\r
  78         enhance(bluePrintContext.serviceTemplate)\r
  79         return bluePrintContext\r
  80     }\r
  81 \r
  82     @Throws(BluePrintException::class)\r
  83     override fun enhance(serviceTemplate: ServiceTemplate): ServiceTemplate {\r
  84         this.serviceTemplate = serviceTemplate\r
  85         initialCleanUp()\r
  86         enrichTopologyTemplate(serviceTemplate)\r
  87 \r
  88         // log.info("Enriched Blueprint :\n {}", JacksonUtils.getJson(serviceTemplate, true))\r
  89         return this.serviceTemplate\r
  90     }\r
  91 \r
  92     open fun initialCleanUp() {\r
  93         serviceTemplate.artifactTypes?.clear()\r
  94         serviceTemplate.nodeTypes?.clear()\r
  95         serviceTemplate.dataTypes?.clear()\r
  96         serviceTemplate.policyTypes?.clear()\r
  97 \r
  98         serviceTemplate.artifactTypes = mutableMapOf()\r
  99         serviceTemplate.nodeTypes = mutableMapOf()\r
 100         serviceTemplate.dataTypes = mutableMapOf()\r
 101         serviceTemplate.policyTypes = mutableMapOf()\r
 102 \r
 103     }\r
 104 \r
 105     @Throws(BluePrintException::class)\r
 106     open fun enrichTopologyTemplate(serviceTemplate: ServiceTemplate) {\r
 107         serviceTemplate.topologyTemplate?.let { topologyTemplate ->\r
 108             enrichTopologyTemplateInputs(topologyTemplate)\r
 109             enrichTopologyTemplateNodeTemplates(topologyTemplate)\r
 110         }\r
 111     }\r
 112 \r
 113     @Throws(BluePrintException::class)\r
 114     open fun enrichTopologyTemplateInputs(topologyTemplate: TopologyTemplate) {\r
 115         topologyTemplate.inputs?.let { inputs ->\r
 116             enrichPropertyDefinitions(inputs)\r
 117         }\r
 118     }\r
 119 \r
 120     open fun enrichTopologyTemplateNodeTemplates(topologyTemplate: TopologyTemplate) {\r
 121         topologyTemplate.nodeTemplates?.forEach { nodeTemplateName, nodeTemplate ->\r
 122             enrichNodeTemplate(nodeTemplateName, nodeTemplate)\r
 123         }\r
 124     }\r
 125 \r
 126     @Throws(BluePrintException::class)\r
 127     override fun enrichNodeTemplate(nodeTemplateName: String, nodeTemplate: NodeTemplate) {\r
 128         val nodeTypeName = nodeTemplate.type\r
 129         // Get NodeType from Repo and Update Service Template\r
 130         val nodeType = populateNodeType(nodeTypeName)\r
 131 \r
 132         // Enrich NodeType\r
 133         enrichNodeType(nodeTypeName, nodeType)\r
 134 \r
 135         //Enrich Node Template Artifacts\r
 136         enrichNodeTemplateArtifactDefinition(nodeTemplateName, nodeTemplate)\r
 137     }\r
 138 \r
 139     @Throws(BluePrintException::class)\r
 140     override fun enrichNodeType(nodeTypeName: String, nodeType: NodeType) {\r
 141         log.debug("Enriching NodeType({})", nodeTypeName)\r
 142         val derivedFrom = nodeType.derivedFrom\r
 143 \r
 144         if (!BluePrintTypes.rootNodeTypes().contains(derivedFrom)) {\r
 145             val derivedFromNodeType = populateNodeType(nodeTypeName)\r
 146             // Enrich NodeType\r
 147             enrichNodeType(derivedFrom, derivedFromNodeType)\r
 148         }\r
 149 \r
 150         // NodeType Property Definitions\r
 151         enrichNodeTypeProperties(nodeTypeName, nodeType)\r
 152 \r
 153         //NodeType Requirement\r
 154         enrichNodeTypeRequirements(nodeTypeName, nodeType)\r
 155 \r
 156         //NodeType Capability\r
 157         enrichNodeTypeCapabilityProperties(nodeTypeName, nodeType)\r
 158 \r
 159         //NodeType Interface\r
 160         enrichNodeTypeInterfaces(nodeTypeName, nodeType)\r
 161     }\r
 162 \r
 163     open fun enrichNodeTypeProperties(nodeTypeName: String, nodeType: NodeType) {\r
 164         nodeType.properties?.let { enrichPropertyDefinitions(nodeType.properties!!) }\r
 165     }\r
 166 \r
 167     open fun enrichNodeTypeRequirements(nodeTypeName: String, nodeType: NodeType) {\r
 168 \r
 169         nodeType.requirements?.forEach { _, requirementDefinition ->\r
 170             // Populate Requirement Node\r
 171             requirementDefinition.node?.let { requirementNodeTypeName ->\r
 172                 // Get Requirement NodeType from Repo and Update Service Template\r
 173                 val requirementNodeType = populateNodeType(requirementNodeTypeName)\r
 174 \r
 175                 enrichNodeType(requirementNodeTypeName, requirementNodeType)\r
 176             }\r
 177         }\r
 178     }\r
 179 \r
 180     open fun enrichNodeTypeCapabilityProperties(nodeTypeName: String, nodeType: NodeType) {\r
 181         nodeType.capabilities?.forEach { _, capabilityDefinition ->\r
 182             capabilityDefinition.properties?.let { properties ->\r
 183                 enrichPropertyDefinitions(properties)\r
 184             }\r
 185         }\r
 186     }\r
 187 \r
 188     open fun enrichNodeTypeInterfaces(nodeTypeName: String, nodeType: NodeType) {\r
 189         nodeType.interfaces?.forEach { interfaceName, interfaceObj ->\r
 190             // Populate Node type Interface Operation\r
 191             log.debug("Enriching NodeType({}) Interface({})", nodeTypeName, interfaceName)\r
 192             populateNodeTypeInterfaceOperation(nodeTypeName, interfaceName, interfaceObj)\r
 193 \r
 194         }\r
 195     }\r
 196 \r
 197     open fun populateNodeTypeInterfaceOperation(nodeTypeName: String, interfaceName: String, interfaceObj: InterfaceDefinition) {\r
 198 \r
 199         interfaceObj.operations?.forEach { operationName, operation ->\r
 200             enrichNodeTypeInterfaceOperationInputs(nodeTypeName, operationName, operation)\r
 201             enrichNodeTypeInterfaceOperationOputputs(nodeTypeName, operationName, operation)\r
 202         }\r
 203     }\r
 204 \r
 205     open fun enrichNodeTypeInterfaceOperationInputs(nodeTypeName: String, operationName: String, operation: OperationDefinition) {\r
 206         operation.inputs?.let { inputs ->\r
 207             enrichPropertyDefinitions(inputs)\r
 208         }\r
 209     }\r
 210 \r
 211     open fun enrichNodeTypeInterfaceOperationOputputs(nodeTypeName: String, operationName: String, operation: OperationDefinition) {\r
 212         operation.outputs?.let { inputs ->\r
 213             enrichPropertyDefinitions(inputs)\r
 214         }\r
 215     }\r
 216 \r
 217     open fun enrichPropertyDefinitions(properties: MutableMap<String, PropertyDefinition>) {\r
 218 \r
 219         properties.forEach { propertyName, propertyDefinition ->\r
 220             enrichPropertyDefinition(propertyName, propertyDefinition)\r
 221         }\r
 222     }\r
 223 \r
 224     @Throws(BluePrintException::class)\r
 225     override fun enrichPropertyDefinition(propertyName: String, propertyDefinition: PropertyDefinition) {\r
 226         val propertyType = propertyDefinition.type\r
 227         if (BluePrintTypes.validPrimitiveTypes().contains(propertyType)) {\r
 228 \r
 229         } else if (BluePrintTypes.validCollectionTypes().contains(propertyType)) {\r
 230             val entrySchema = propertyDefinition.entrySchema\r
 231                     ?: throw BluePrintException(format("Entry Schema is missing for collection property : {}", propertyName))\r
 232 \r
 233             if (!BluePrintTypes.validPrimitiveTypes().contains(entrySchema.type)) {\r
 234                 populateDataTypes(entrySchema.type)\r
 235             }\r
 236         } else {\r
 237             populateDataTypes(propertyType)\r
 238         }\r
 239 \r
 240     }\r
 241 \r
 242     open fun enrichNodeTemplateArtifactDefinition(nodeTemplateName: String, nodeTemplate: NodeTemplate) {\r
 243 \r
 244         nodeTemplate.artifacts?.forEach { artifactDefinitionName, artifactDefinition ->\r
 245             val artifactTypeName = artifactDefinition.type\r
 246                     ?: throw BluePrintException(format("Artifact type is missing for NodeTemplate({}) artifact({})", nodeTemplateName, artifactDefinitionName))\r
 247 \r
 248             // Populate Artifact Type\r
 249             populateArtifactType(artifactTypeName)\r
 250         }\r
 251     }\r
 252 \r
 253     open fun populateNodeType(nodeTypeName: String): NodeType {\r
 254 \r
 255         val nodeType = serviceTemplate.nodeTypes?.get(nodeTypeName)\r
 256                 ?: bluePrintRepoService.getNodeType(nodeTypeName).block()\r
 257                 ?: throw BluePrintException(format("Couldn't get NodeType({}) from repo.", nodeTypeName))\r
 258         serviceTemplate.nodeTypes?.put(nodeTypeName, nodeType)\r
 259         return nodeType\r
 260     }\r
 261 \r
 262     open fun populateArtifactType(artifactTypeName: String): ArtifactType {\r
 263         val artifactType = serviceTemplate.artifactTypes?.get(artifactTypeName)\r
 264                 ?: bluePrintRepoService.getArtifactType(artifactTypeName).block()\r
 265                 ?: throw BluePrintException(format("Couldn't get ArtifactType({}) from repo.", artifactTypeName))\r
 266         serviceTemplate.artifactTypes?.put(artifactTypeName, artifactType)\r
 267         return artifactType\r
 268     }\r
 269 \r
 270     open fun populateDataTypes(dataTypeName: String): DataType {\r
 271         val dataType = serviceTemplate.dataTypes?.get(dataTypeName)\r
 272                 ?: bluePrintRepoService.getDataType(dataTypeName).block()\r
 273                 ?: throw BluePrintException(format("Couldn't get DataType({}) from repo.", dataTypeName))\r
 274         serviceTemplate.dataTypes?.put(dataTypeName, dataType)\r
 275         return dataType\r
 276     }\r
 277 \r
 278 }\r
 279 \r