ms/controllerblueprints/modules/blueprint-validation/src/main/kotlin/org/onap/ccsdk/cds/controllerblueprints/validation/BluePrintNodeTemplateValidatorImpl.kt

   1 /*
   2  * Copyright © 2017-2018 AT&T Intellectual Property.
   3  * Modifications Copyright © 2018-2019 IBM.
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18 package org.onap.ccsdk.cds.controllerblueprints.validation
  19
  20 import org.slf4j.LoggerFactory
  21 import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
  22 import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintTypes
  23 import org.onap.ccsdk.cds.controllerblueprints.core.data.*
  24 import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintNodeTemplateValidator
  25 import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintTypeValidatorService
  26 import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintContext
  27 import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintRuntimeService
  28 import org.onap.ccsdk.cds.controllerblueprints.validation.utils.PropertyAssignmentValidationUtils
  29 import org.springframework.beans.factory.config.ConfigurableBeanFactory
  30 import org.springframework.context.annotation.Scope
  31 import org.springframework.stereotype.Service
  32
  33
  34 @Service("default-node-template-validator")
  35 @Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
  36 open class BluePrintNodeTemplateValidatorImpl(private val bluePrintTypeValidatorService: BluePrintTypeValidatorService) : BluePrintNodeTemplateValidator {
  37
  38     private val log= LoggerFactory.getLogger(BluePrintNodeTemplateValidatorImpl::class.toString())
  39
  40     lateinit var bluePrintRuntimeService: BluePrintRuntimeService<*>
  41     lateinit var bluePrintContext: BluePrintContext
  42     lateinit var propertyAssignmentValidationUtils: PropertyAssignmentValidationUtils
  43     var paths: MutableList<String> = arrayListOf()
  44
  45     override fun validate(bluePrintRuntimeService: BluePrintRuntimeService<*>, name: String, nodeTemplate: NodeTemplate) {
  46         log.debug("Validating NodeTemplate($name)")
  47
  48         this.bluePrintRuntimeService = bluePrintRuntimeService
  49         this.bluePrintContext = bluePrintRuntimeService.bluePrintContext()
  50
  51         propertyAssignmentValidationUtils = PropertyAssignmentValidationUtils(bluePrintContext)
  52
  53         paths.add(name)
  54
  55         val type: String = nodeTemplate.type
  56
  57         val nodeType: NodeType = bluePrintContext.serviceTemplate.nodeTypes?.get(type)
  58                 ?: throw BluePrintException("Failed to get NodeType($type) definition for NodeTemplate($name)")
  59
  60         nodeTemplate.properties?.let {
  61             propertyAssignmentValidationUtils
  62                     .validatePropertyAssignments(nodeType.properties!!, nodeTemplate.properties!!)
  63         }
  64         nodeTemplate.capabilities?.let { validateCapabilityAssignments(nodeType, name, nodeTemplate) }
  65         nodeTemplate.requirements?.let { validateRequirementAssignments(nodeType, name, nodeTemplate) }
  66         nodeTemplate.interfaces?.let { validateInterfaceAssignments(nodeType, name, nodeTemplate) }
  67         nodeTemplate.artifacts?.let { validateArtifactDefinitions(nodeTemplate.artifacts!!) }
  68
  69         // Perform Extension Validation
  70         validateExtension("$type-node-template-validator", name, nodeTemplate)
  71
  72         paths.removeAt(paths.lastIndex)
  73     }
  74
  75     @Throws(BluePrintException::class)
  76     open fun validateArtifactDefinitions(artifacts: MutableMap<String, ArtifactDefinition>) {
  77         paths.add("artifacts")
  78         artifacts.forEach { artifactDefinitionName, artifactDefinition ->
  79             bluePrintTypeValidatorService.validateArtifactDefinition(bluePrintRuntimeService,
  80                     artifactDefinitionName, artifactDefinition)
  81         }
  82         paths.removeAt(paths.lastIndex)
  83     }
  84
  85     @Throws(BluePrintException::class)
  86     open fun validateCapabilityAssignments(nodeType: NodeType, nodeTemplateName: String, nodeTemplate: NodeTemplate) {
  87         val capabilities = nodeTemplate.capabilities
  88         paths.add("capabilities")
  89         capabilities?.forEach { capabilityName, capabilityAssignment ->
  90             paths.add(capabilityName)
  91
  92             val capabilityDefinition = nodeType.capabilities?.get(capabilityName)
  93                     ?: throw BluePrintException("Failed to get NodeTemplate($nodeTemplateName) capability definition ($capabilityName) " +
  94                             "from NodeType(${nodeTemplate.type})")
  95
  96             validateCapabilityAssignment(nodeTemplateName, capabilityName, capabilityDefinition, capabilityAssignment)
  97
  98             paths.removeAt(paths.lastIndex)
  99         }
 100         paths.removeAt(paths.lastIndex)
 101     }
 102
 103     @Throws(BluePrintException::class)
 104     open fun validateCapabilityAssignment(nodeTemplateName: String, capabilityName: String,
 105                                           capabilityDefinition: CapabilityDefinition, capabilityAssignment: CapabilityAssignment) {
 106
 107         capabilityAssignment.properties?.let {
 108             propertyAssignmentValidationUtils
 109                     .validatePropertyAssignments(capabilityDefinition.properties!!, capabilityAssignment.properties!!)
 110         }
 111
 112     }
 113
 114     @Throws(BluePrintException::class)
 115     open fun validateRequirementAssignments(nodeType: NodeType, nodeTemplateName: String, nodeTemplate: NodeTemplate) {
 116         val requirements = nodeTemplate.requirements
 117         paths.add("requirements")
 118         requirements?.forEach { requirementName, requirementAssignment ->
 119             paths.add(requirementName)
 120             val requirementDefinition = nodeType.requirements?.get(requirementName)
 121                     ?: throw BluePrintException("Failed to get NodeTemplate($nodeTemplateName) requirement definition ($requirementName) from" +
 122                             " NodeType(${nodeTemplate.type})")
 123             // Validate Requirement Assignment
 124             validateRequirementAssignment(nodeTemplateName, requirementName, requirementDefinition, requirementAssignment)
 125             paths.removeAt(paths.lastIndex)
 126         }
 127         paths.removeAt(paths.lastIndex)
 128
 129     }
 130
 131     @Throws(BluePrintException::class)
 132     open fun validateRequirementAssignment(nodeTemplateName: String, requirementAssignmentName: String,
 133                                            requirementDefinition: RequirementDefinition, requirementAssignment: RequirementAssignment) {
 134         log.debug("Validating NodeTemplate({}) requirement assignment ({}) ", nodeTemplateName,
 135                 requirementAssignmentName)
 136         val requirementNodeTemplateName = requirementAssignment.node!!
 137         val capabilityName = requirementAssignment.capability
 138         val relationship = requirementAssignment.relationship!!
 139
 140         check(BluePrintTypes.validRelationShipDerivedFroms.contains(relationship)) {
 141             throw BluePrintException("Failed to get relationship type ($relationship) for NodeTemplate($nodeTemplateName)'s requirement($requirementAssignmentName)")
 142         }
 143
 144         val relationShipNodeTemplate = bluePrintContext.serviceTemplate.topologyTemplate?.nodeTemplates?.get(requirementNodeTemplateName)
 145                 ?: throw BluePrintException("Failed to get requirement NodeTemplate($requirementNodeTemplateName)'s " +
 146                         "for NodeTemplate($nodeTemplateName) requirement($requirementAssignmentName)")
 147
 148         relationShipNodeTemplate.capabilities?.get(capabilityName)
 149                 ?: throw BluePrintException("Failed to get requirement NodeTemplate($requirementNodeTemplateName)'s " +
 150                         "capability($capabilityName) for NodeTemplate ($nodeTemplateName)'s requirement($requirementAssignmentName)")
 151
 152
 153     }
 154
 155     @Throws(BluePrintException::class)
 156     open fun validateInterfaceAssignments(nodeType: NodeType, nodeTemplateName: String, nodeTemplate: NodeTemplate) {
 157
 158         val interfaces = nodeTemplate.interfaces
 159         paths.add("interfaces")
 160         interfaces?.forEach { interfaceAssignmentName, interfaceAssignment ->
 161             paths.add(interfaceAssignmentName)
 162             val interfaceDefinition = nodeType.interfaces?.get(interfaceAssignmentName)
 163                     ?: throw BluePrintException("Failed to get NodeTemplate($nodeTemplateName) interface definition ($interfaceAssignmentName) from" +
 164                             " NodeType(${nodeTemplate.type})")
 165
 166             validateInterfaceAssignment(nodeTemplateName, interfaceAssignmentName, interfaceDefinition,
 167                     interfaceAssignment)
 168             paths.removeAt(paths.lastIndex)
 169         }
 170         paths.removeAt(paths.lastIndex)
 171
 172
 173     }
 174
 175     @Throws(BluePrintException::class)
 176     open fun validateInterfaceAssignment(nodeTemplateName: String, interfaceAssignmentName: String,
 177                                          interfaceDefinition: InterfaceDefinition,
 178                                          interfaceAssignment: InterfaceAssignment) {
 179
 180         val operations = interfaceAssignment.operations
 181         operations?.let {
 182             validateInterfaceOperationsAssignment(nodeTemplateName, interfaceAssignmentName, interfaceDefinition,
 183                     interfaceAssignment)
 184         }
 185
 186     }
 187
 188     @Throws(BluePrintException::class)
 189     open fun validateInterfaceOperationsAssignment(nodeTemplateName: String, interfaceAssignmentName: String,
 190                                                    interfaceDefinition: InterfaceDefinition,
 191                                                    interfaceAssignment: InterfaceAssignment) {
 192
 193         val operations = interfaceAssignment.operations
 194         operations?.let {
 195             it.forEach { operationAssignmentName, operationAssignments ->
 196
 197                 val operationDefinition = interfaceDefinition.operations?.get(operationAssignmentName)
 198                         ?: throw BluePrintException("Failed to get NodeTemplate($nodeTemplateName) operation definition ($operationAssignmentName)")
 199
 200                 log.debug("Validation NodeTemplate($nodeTemplateName) Interface($interfaceAssignmentName) Operation " +
 201                         "($operationAssignmentName)")
 202
 203                 val inputs = operationAssignments.inputs
 204                 val outputs = operationAssignments.outputs
 205
 206                 inputs?.forEach { propertyName, propertyAssignment ->
 207                     val propertyDefinition = operationDefinition.inputs?.get(propertyName)
 208                             ?: throw BluePrintException("Failed to get NodeTemplate($nodeTemplateName) operation " +
 209                                     "definition ($operationAssignmentName) property definition($propertyName)")
 210                     // Check the property values with property definition
 211                     propertyAssignmentValidationUtils
 212                             .validatePropertyAssignment(propertyName, propertyDefinition, propertyAssignment)
 213                 }
 214
 215                 outputs?.forEach { propertyName, propertyAssignment ->
 216                     val propertyDefinition = operationDefinition.outputs?.get(propertyName)
 217                             ?: throw BluePrintException("Failed to get NodeTemplate($nodeTemplateName) operation definition ($operationAssignmentName) " +
 218                                     "output property definition($propertyName)")
 219                     // Check the property values with property definition
 220                     propertyAssignmentValidationUtils
 221                             .validatePropertyAssignment(propertyName, propertyDefinition, propertyAssignment)
 222                 }
 223
 224             }
 225         }
 226
 227     }
 228
 229
 230     private fun validateExtension(referencePrefix: String, name: String, nodeTemplate: NodeTemplate) {
 231         val customValidator = bluePrintTypeValidatorService
 232                 .bluePrintValidator(referencePrefix, BluePrintNodeTemplateValidator::class.java)
 233
 234         customValidator?.let {
 235             it.validate(bluePrintRuntimeService, name, nodeTemplate)
 236         }
 237     }
 238
 239 }