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