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.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 org.onap.ccsdk.apps.controllerblueprints.core.utils.JacksonReactorUtils\r
  27 import java.io.Serializable\r
  28 \r
  29 /**\r
  30  * BluePrintEnhancerService\r
  31  * @author Brinda Santh\r
  32  *\r
  33  */\r
  34 interface BluePrintEnhancerService : Serializable {\r
  35 \r
  36     @Throws(BluePrintException::class)\r
  37     fun enhance(content: String): ServiceTemplate\r
  38 \r
  39     /**\r
  40      * Read Blueprint from CSAR structure Directory\r
  41      */\r
  42     @Throws(BluePrintException::class)\r
  43     fun enhance(fileName: String, basePath: String): ServiceTemplate\r
  44 \r
  45     @Throws(BluePrintException::class)\r
  46     fun enhance(serviceTemplate: ServiceTemplate): ServiceTemplate\r
  47 \r
  48     @Throws(BluePrintException::class)\r
  49     fun enrichNodeTemplate(nodeTemplateName: String, nodeTemplate: NodeTemplate)\r
  50 \r
  51     @Throws(BluePrintException::class)\r
  52     fun enrichNodeType(nodeTypeName: String, nodeType: NodeType)\r
  53 \r
  54     @Throws(BluePrintException::class)\r
  55     fun enrichPropertyDefinition(propertyName: String, propertyDefinition: PropertyDefinition)\r
  56 }\r
  57 \r
  58 open class BluePrintEnhancerDefaultService(val bluePrintRepoService: BluePrintRepoService) : BluePrintEnhancerService {\r
  59 \r
  60     private val log: EELFLogger = EELFManager.getInstance().getLogger(BluePrintEnhancerDefaultService::class.toString())\r
  61 \r
  62     lateinit var serviceTemplate: ServiceTemplate\r
  63 \r
  64     @Throws(BluePrintException::class)\r
  65     override fun enhance(content: String): ServiceTemplate {\r
  66         return JacksonReactorUtils.readValueFromFile(content, ServiceTemplate::class.java).map { serviceTemplate ->\r
  67             enhance(serviceTemplate!!)\r
  68         }.block()!!\r
  69     }\r
  70 \r
  71     @Throws(BluePrintException::class)\r
  72     override fun enhance(fileName: String, basePath: String): ServiceTemplate {\r
  73         TODO("not implemented") //To change body of created functions use File | Settings | File Templates.\r
  74     }\r
  75 \r
  76     @Throws(BluePrintException::class)\r
  77     override fun enhance(serviceTemplate: ServiceTemplate): ServiceTemplate {\r
  78         this.serviceTemplate = serviceTemplate\r
  79         initialCleanUp()\r
  80         enrichTopologyTemplate(serviceTemplate)\r
  81 \r
  82         // log.info("Enriched Blueprint :\n {}", JacksonUtils.getJson(serviceTemplate, true))\r
  83         return this.serviceTemplate\r
  84     }\r
  85 \r
  86     open fun initialCleanUp() {\r
  87         serviceTemplate.artifactTypes?.clear()\r
  88         serviceTemplate.nodeTypes?.clear()\r
  89         serviceTemplate.dataTypes?.clear()\r
  90 \r
  91         serviceTemplate.artifactTypes = HashMap()\r
  92         serviceTemplate.nodeTypes = HashMap()\r
  93         serviceTemplate.dataTypes = HashMap()\r
  94 \r
  95     }\r
  96 \r
  97     @Throws(BluePrintException::class)\r
  98     open fun enrichTopologyTemplate(serviceTemplate: ServiceTemplate) {\r
  99         serviceTemplate.topologyTemplate?.let { topologyTemplate ->\r
 100             enrichTopologyTemplateInputs(topologyTemplate)\r
 101             enrichTopologyTemplateNodeTemplates(topologyTemplate)\r
 102         }\r
 103     }\r
 104 \r
 105     @Throws(BluePrintException::class)\r
 106     open fun enrichTopologyTemplateInputs(topologyTemplate: TopologyTemplate) {\r
 107         topologyTemplate.inputs?.let { inputs ->\r
 108             enrichPropertyDefinitions(inputs)\r
 109         }\r
 110     }\r
 111 \r
 112     open fun enrichTopologyTemplateNodeTemplates(topologyTemplate: TopologyTemplate) {\r
 113         topologyTemplate.nodeTemplates?.forEach { nodeTemplateName, nodeTemplate ->\r
 114             enrichNodeTemplate(nodeTemplateName, nodeTemplate)\r
 115         }\r
 116     }\r
 117 \r
 118     @Throws(BluePrintException::class)\r
 119     override fun enrichNodeTemplate(nodeTemplateName: String, nodeTemplate: NodeTemplate) {\r
 120         val nodeTypeName = nodeTemplate.type\r
 121         // Get NodeType from Repo and Update Service Template\r
 122         val nodeType = populateNodeType(nodeTypeName)\r
 123 \r
 124         // Enrich NodeType\r
 125         enrichNodeType(nodeTypeName, nodeType)\r
 126 \r
 127         //Enrich Node Template Artifacts\r
 128         enrichNodeTemplateArtifactDefinition(nodeTemplateName, nodeTemplate)\r
 129     }\r
 130 \r
 131     @Throws(BluePrintException::class)\r
 132     override fun enrichNodeType(nodeTypeName: String, nodeType: NodeType) {\r
 133         log.debug("Enriching NodeType({})", nodeTypeName)\r
 134         val derivedFrom = nodeType.derivedFrom\r
 135 \r
 136         if (!BluePrintTypes.rootNodeTypes().contains(derivedFrom)) {\r
 137             val derivedFromNodeType = populateNodeType(nodeTypeName)\r
 138             // Enrich NodeType\r
 139             enrichNodeType(derivedFrom, derivedFromNodeType)\r
 140         }\r
 141 \r
 142         // NodeType Property Definitions\r
 143         enrichNodeTypeProperties(nodeTypeName, nodeType)\r
 144 \r
 145         //NodeType Requirement\r
 146         enrichNodeTypeRequirements(nodeTypeName, nodeType)\r
 147 \r
 148         //NodeType Capability\r
 149         enrichNodeTypeCapabilityProperties(nodeTypeName, nodeType)\r
 150 \r
 151         //NodeType Interface\r
 152         enrichNodeTypeInterfaces(nodeTypeName, nodeType)\r
 153     }\r
 154 \r
 155     open fun enrichNodeTypeProperties(nodeTypeName: String, nodeType: NodeType) {\r
 156         nodeType.properties?.let { enrichPropertyDefinitions(nodeType.properties!!) }\r
 157     }\r
 158 \r
 159     open fun enrichNodeTypeRequirements(nodeTypeName: String, nodeType: NodeType) {\r
 160 \r
 161         nodeType.requirements?.forEach { _, requirementDefinition ->\r
 162             // Populate Requirement Node\r
 163             requirementDefinition.node?.let { requirementNodeTypeName ->\r
 164                 // Get Requirement NodeType from Repo and Update Service Template\r
 165                 val requirementNodeType = populateNodeType(requirementNodeTypeName)\r
 166 \r
 167                 enrichNodeType(requirementNodeTypeName, requirementNodeType)\r
 168             }\r
 169         }\r
 170     }\r
 171 \r
 172     open fun enrichNodeTypeCapabilityProperties(nodeTypeName: String, nodeType: NodeType) {\r
 173         nodeType.capabilities?.forEach { capabilityDefinitionName, capabilityDefinition ->\r
 174             capabilityDefinition.properties?.let { properties ->\r
 175                 enrichPropertyDefinitions(properties)\r
 176             }\r
 177         }\r
 178     }\r
 179 \r
 180     open fun enrichNodeTypeInterfaces(nodeTypeName: String, nodeType: NodeType) {\r
 181         nodeType.interfaces?.forEach { interfaceName, interfaceObj ->\r
 182             // Populate Node type Interface Operation\r
 183             log.debug("Enriching NodeType({}) Interface({})", nodeTypeName, interfaceName)\r
 184             populateNodeTypeInterfaceOperation(nodeTypeName, interfaceName, interfaceObj)\r
 185 \r
 186         }\r
 187     }\r
 188 \r
 189     open fun populateNodeTypeInterfaceOperation(nodeTypeName: String, interfaceName: String, interfaceObj: InterfaceDefinition) {\r
 190 \r
 191         interfaceObj.operations?.forEach { operationName, operation ->\r
 192             enrichNodeTypeInterfaceOperationInputs(nodeTypeName, operationName, operation)\r
 193             enrichNodeTypeInterfaceOperationOputputs(nodeTypeName, operationName, operation)\r
 194         }\r
 195     }\r
 196 \r
 197     open fun enrichNodeTypeInterfaceOperationInputs(nodeTypeName: String, operationName: String, operation: OperationDefinition) {\r
 198         operation.inputs?.let { inputs ->\r
 199             enrichPropertyDefinitions(inputs)\r
 200         }\r
 201     }\r
 202 \r
 203     open fun enrichNodeTypeInterfaceOperationOputputs(nodeTypeName: String, operationName: String, operation: OperationDefinition) {\r
 204         operation.outputs?.let { inputs ->\r
 205             enrichPropertyDefinitions(inputs)\r
 206         }\r
 207     }\r
 208 \r
 209     open fun enrichPropertyDefinitions(properties: MutableMap<String, PropertyDefinition>) {\r
 210 \r
 211         properties.forEach { propertyName, propertyDefinition ->\r
 212             enrichPropertyDefinition(propertyName, propertyDefinition)\r
 213         }\r
 214     }\r
 215 \r
 216     @Throws(BluePrintException::class)\r
 217     override fun enrichPropertyDefinition(propertyName: String, propertyDefinition: PropertyDefinition) {\r
 218         val propertyType = propertyDefinition.type\r
 219         if (BluePrintTypes.validPrimitiveTypes().contains(propertyType)) {\r
 220 \r
 221         } else if (BluePrintTypes.validCollectionTypes().contains(propertyType)) {\r
 222             val entrySchema = propertyDefinition.entrySchema\r
 223                     ?: throw BluePrintException(format("Entry Schema is missing for collection property : {}", propertyName))\r
 224 \r
 225             if (!BluePrintTypes.validPrimitiveTypes().contains(entrySchema.type)) {\r
 226                 populateDataTypes(entrySchema.type)\r
 227             }\r
 228         } else {\r
 229             populateDataTypes(propertyType)\r
 230         }\r
 231 \r
 232     }\r
 233 \r
 234     open fun enrichNodeTemplateArtifactDefinition(nodeTemplateName: String, nodeTemplate: NodeTemplate) {\r
 235 \r
 236         nodeTemplate.artifacts?.forEach { artifactDefinitionName, artifactDefinition ->\r
 237             val artifactTypeName = artifactDefinition.type\r
 238                     ?: throw BluePrintException(format("Artifact type is missing for NodeTemplate({}) artifact({})", nodeTemplateName, artifactDefinitionName))\r
 239 \r
 240             // Populate Artifact Type\r
 241             populateArtifactType(artifactTypeName)\r
 242         }\r
 243     }\r
 244 \r
 245     open fun populateNodeType(nodeTypeName: String): NodeType {\r
 246 \r
 247         val nodeType = serviceTemplate.nodeTypes?.get(nodeTypeName)\r
 248                 ?: bluePrintRepoService.getNodeType(nodeTypeName)?.block()\r
 249                 ?: throw BluePrintException(format("Couldn't get NodeType({}) from repo.", nodeTypeName))\r
 250         serviceTemplate.nodeTypes?.put(nodeTypeName, nodeType)\r
 251         return nodeType\r
 252     }\r
 253 \r
 254     open fun populateArtifactType(artifactTypeName: String): ArtifactType {\r
 255         val artifactType = serviceTemplate.artifactTypes?.get(artifactTypeName)\r
 256                 ?: bluePrintRepoService.getArtifactType(artifactTypeName)?.block()\r
 257                 ?: throw BluePrintException(format("Couldn't get ArtifactType({}) from repo.", artifactTypeName))\r
 258         serviceTemplate.artifactTypes?.put(artifactTypeName, artifactType)\r
 259         return artifactType\r
 260     }\r
 261 \r
 262     open fun populateDataTypes(dataTypeName: String): DataType {\r
 263         val dataType = serviceTemplate.dataTypes?.get(dataTypeName)\r
 264                 ?: bluePrintRepoService.getDataType(dataTypeName)?.block()\r
 265                 ?: throw BluePrintException(format("Couldn't get DataType({}) from repo.", dataTypeName))\r
 266         serviceTemplate.dataTypes?.put(dataTypeName, dataType)\r
 267         return dataType\r
 268     }\r
 269 \r
 270 }\r
 271 \r