ms/controllerblueprints/modules/core/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/core/service/BluePrintEnhancerService.kt

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