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