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  * 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.core.service\r
  19 \r
  20 import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintException\r
  21 import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintTypes\r
  22 import org.onap.ccsdk.apps.controllerblueprints.core.data.*\r
  23 import org.onap.ccsdk.apps.controllerblueprints.core.format\r
  24 import com.att.eelf.configuration.EELFLogger\r
  25 import com.att.eelf.configuration.EELFManager\r
  26 import java.io.Serializable\r
  27 \r
  28 /**\r
  29  * BluePrintEnhancerService\r
  30  * @author Brinda Santh\r
  31  *\r
  32  */\r
  33 interface BluePrintEnhancerService : Serializable {\r
  34 \r
  35     @Throws(BluePrintException::class)\r
  36     fun enhance(content: String): ServiceTemplate\r
  37 \r
  38     @Throws(BluePrintException::class)\r
  39     fun enhance(serviceTemplate: ServiceTemplate): ServiceTemplate\r
  40 \r
  41     /**\r
  42      * Read Blueprint from CSAR structure Directory\r
  43      */\r
  44     @Throws(BluePrintException::class)\r
  45     fun enhance(fileName: String, basePath: String): ServiceTemplate\r
  46 }\r
  47 \r
  48 open class BluePrintEnhancerDefaultService(val bluePrintRepoService: BluePrintRepoService) : BluePrintEnhancerService {\r
  49 \r
  50     private val log: EELFLogger = EELFManager.getInstance().getLogger(BluePrintEnhancerDefaultService::class.toString())\r
  51 \r
  52     lateinit var serviceTemplate: ServiceTemplate\r
  53 \r
  54     override fun enhance(content: String): ServiceTemplate {\r
  55         TODO("not implemented") //To change body of created functions use File | Settings | File Templates.\r
  56     }\r
  57 \r
  58     override fun enhance(fileName: String, basePath: String): ServiceTemplate {\r
  59         TODO("not implemented") //To change body of created functions use File | Settings | File Templates.\r
  60     }\r
  61 \r
  62     override fun enhance(serviceTemplate: ServiceTemplate): ServiceTemplate {\r
  63         this.serviceTemplate = serviceTemplate\r
  64         initialCleanUp()\r
  65         enrichTopologyTemplate(serviceTemplate)\r
  66 \r
  67        // log.info("Enriched Blueprint :\n {}", JacksonUtils.getJson(serviceTemplate, true))\r
  68         return this.serviceTemplate\r
  69     }\r
  70 \r
  71     open fun initialCleanUp() {\r
  72         serviceTemplate.artifactTypes?.clear()\r
  73         serviceTemplate.nodeTypes?.clear()\r
  74         serviceTemplate.dataTypes?.clear()\r
  75 \r
  76         serviceTemplate.artifactTypes = HashMap()\r
  77         serviceTemplate.nodeTypes = HashMap()\r
  78         serviceTemplate.dataTypes = HashMap()\r
  79 \r
  80     }\r
  81 \r
  82     open fun enrichTopologyTemplate(serviceTemplate: ServiceTemplate) {\r
  83         serviceTemplate.topologyTemplate?.let { topologyTemplate ->\r
  84             enrichTopologyTemplateInputs(topologyTemplate)\r
  85             enrichTopologyTemplateNodeTemplates(topologyTemplate)\r
  86         }\r
  87     }\r
  88 \r
  89     open fun enrichTopologyTemplateInputs(topologyTemplate: TopologyTemplate) {\r
  90         topologyTemplate.inputs?.let { inputs ->\r
  91             enrichPropertyDefinitions(inputs)\r
  92         }\r
  93     }\r
  94 \r
  95     open fun enrichTopologyTemplateNodeTemplates(topologyTemplate: TopologyTemplate) {\r
  96         topologyTemplate.nodeTemplates?.forEach { nodeTemplateName, nodeTemplate ->\r
  97             enrichNodeTemplate(nodeTemplateName, nodeTemplate)\r
  98         }\r
  99     }\r
 100 \r
 101     @Throws(BluePrintException::class)\r
 102     open fun enrichNodeTemplate(nodeTemplateName: String, nodeTemplate: NodeTemplate) {\r
 103         val nodeTypeName = nodeTemplate.type\r
 104         // Get NodeType from Repo and Update Service Template\r
 105         val nodeType = populateNodeType(nodeTypeName)\r
 106 \r
 107         // Enrich NodeType\r
 108         enrichNodeType(nodeTypeName, nodeType)\r
 109 \r
 110         //Enrich Node Template Artifacts\r
 111         enrichNodeTemplateArtifactDefinition(nodeTemplateName, nodeTemplate)\r
 112     }\r
 113 \r
 114     open fun enrichNodeType(nodeTypeName: String, nodeType: NodeType) {\r
 115 \r
 116         // NodeType Property Definitions\r
 117         enrichNodeTypeProperties(nodeTypeName, nodeType)\r
 118 \r
 119         //NodeType Requirement\r
 120         enrichNodeTypeRequirements(nodeTypeName, nodeType)\r
 121 \r
 122         //NodeType Capability\r
 123         enrichNodeTypeCapabilityProperties(nodeTypeName, nodeType)\r
 124 \r
 125         //NodeType Interface\r
 126         enrichNodeTypeInterfaces(nodeTypeName, nodeType)\r
 127     }\r
 128 \r
 129     open fun enrichNodeTypeProperties(nodeTypeName: String, nodeType: NodeType) {\r
 130         nodeType.properties?.let { enrichPropertyDefinitions(nodeType.properties!!) }\r
 131     }\r
 132 \r
 133     open fun enrichNodeTypeRequirements(nodeTypeName: String, nodeType: NodeType) {\r
 134 \r
 135         nodeType.requirements?.forEach { requirementDefinitionName, requirementDefinition ->\r
 136             // Populate Requirement Node\r
 137             requirementDefinition.node?.let { requirementNodeTypeName ->\r
 138                 // Get Requirement NodeType from Repo and Update Service Template\r
 139                 val requirementNodeType = populateNodeType(requirementNodeTypeName)\r
 140 \r
 141                 enrichNodeType(requirementNodeTypeName, requirementNodeType)\r
 142             }\r
 143         }\r
 144     }\r
 145 \r
 146     open fun enrichNodeTypeCapabilityProperties(nodeTypeName: String, nodeType: NodeType) {\r
 147         nodeType.capabilities?.forEach { capabilityDefinitionName, capabilityDefinition ->\r
 148             capabilityDefinition.properties?.let { properties ->\r
 149                 enrichPropertyDefinitions(properties)\r
 150             }\r
 151         }\r
 152     }\r
 153 \r
 154     open fun enrichNodeTypeInterfaces(nodeTypeName: String, nodeType: NodeType) {\r
 155         nodeType.interfaces?.forEach { interfaceName, interfaceObj ->\r
 156             // Populate Node type Interface Operation\r
 157             log.info("*** ** Enriching NodeType: {} Interface {}", nodeTypeName, interfaceName)\r
 158             populateNodeTypeInterfaceOperation(nodeTypeName, interfaceName, interfaceObj)\r
 159 \r
 160         }\r
 161     }\r
 162 \r
 163     open fun populateNodeTypeInterfaceOperation(nodeTypeName: String, interfaceName: String, interfaceObj: InterfaceDefinition) {\r
 164 \r
 165         interfaceObj.operations?.forEach { operationName, operation ->\r
 166             enrichNodeTypeInterfaceOperationInputs(nodeTypeName, operationName, operation)\r
 167             enrichNodeTypeInterfaceOperationOputputs(nodeTypeName, operationName, operation)\r
 168         }\r
 169     }\r
 170 \r
 171     open fun enrichNodeTypeInterfaceOperationInputs(nodeTypeName: String, operationName: String, operation: OperationDefinition) {\r
 172         operation.inputs?.let { inputs ->\r
 173             enrichPropertyDefinitions(inputs)\r
 174         }\r
 175     }\r
 176 \r
 177     open fun enrichNodeTypeInterfaceOperationOputputs(nodeTypeName: String, operationName: String, operation: OperationDefinition) {\r
 178         operation.outputs?.let { inputs ->\r
 179             enrichPropertyDefinitions(inputs)\r
 180         }\r
 181     }\r
 182 \r
 183     open fun enrichPropertyDefinitions(properties: MutableMap<String, PropertyDefinition>) {\r
 184 \r
 185         properties.forEach { propertyName, propertyDefinition ->\r
 186             enrichPropertyDefinition(propertyName, propertyDefinition)\r
 187         }\r
 188     }\r
 189 \r
 190     open fun enrichPropertyDefinition(propertyName: String, propertyDefinition: PropertyDefinition) {\r
 191         val propertyType = propertyDefinition.type\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 = bluePrintRepoService.getNodeType(nodeTypeName)?.block()\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 = bluePrintRepoService.getArtifactType(artifactTypeName)?.block()\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 = bluePrintRepoService.getDataType(dataTypeName)?.block()\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