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

   1 /*
   2  * Copyright © 2017-2018 AT&T Intellectual Property.
   3  * Modifications Copyright © 2018 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.onap.ccsdk.cds.controllerblueprints.core.BlueprintException
  21 import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintTypes
  22 import org.onap.ccsdk.cds.controllerblueprints.core.checkNotEmpty
  23 import org.onap.ccsdk.cds.controllerblueprints.core.data.CapabilityDefinition
  24 import org.onap.ccsdk.cds.controllerblueprints.core.data.Implementation
  25 import org.onap.ccsdk.cds.controllerblueprints.core.data.InterfaceDefinition
  26 import org.onap.ccsdk.cds.controllerblueprints.core.data.NodeType
  27 import org.onap.ccsdk.cds.controllerblueprints.core.data.OperationDefinition
  28 import org.onap.ccsdk.cds.controllerblueprints.core.data.RequirementDefinition
  29 import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintNodeTypeValidator
  30 import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BlueprintTypeValidatorService
  31 import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintContext
  32 import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintRuntimeService
  33 import org.slf4j.LoggerFactory
  34 import org.springframework.beans.factory.config.ConfigurableBeanFactory
  35 import org.springframework.context.annotation.Scope
  36 import org.springframework.stereotype.Service
  37
  38 @Service("default-node-type-validator")
  39 @Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
  40 open class BlueprintNodeTypeValidatorImpl(private val bluePrintTypeValidatorService: BlueprintTypeValidatorService) : BlueprintNodeTypeValidator {
  41
  42     private val log = LoggerFactory.getLogger(BlueprintServiceTemplateValidatorImpl::class.toString())
  43
  44     lateinit var bluePrintRuntimeService: BlueprintRuntimeService<*>
  45     lateinit var bluePrintContext: BlueprintContext
  46     var paths: MutableList<String> = arrayListOf()
  47
  48     override fun validate(bluePrintRuntimeService: BlueprintRuntimeService<*>, nodeTypeName: String, nodeType: NodeType) {
  49         log.trace("Validating NodeType($nodeTypeName)")
  50         this.bluePrintRuntimeService = bluePrintRuntimeService
  51         this.bluePrintContext = bluePrintRuntimeService.bluePrintContext()
  52
  53         paths.add(nodeTypeName)
  54
  55         val derivedFrom: String = nodeType.derivedFrom
  56         // Check Derived From
  57         checkValidNodeTypesDerivedFrom(nodeTypeName, derivedFrom)
  58
  59         if (!BlueprintTypes.rootNodeTypes().contains(derivedFrom)) {
  60             bluePrintContext.serviceTemplate.nodeTypes?.get(derivedFrom)
  61                 ?: throw BlueprintException("Failed to get derivedFrom NodeType($derivedFrom)'s for NodeType($nodeTypeName)")
  62         }
  63
  64         nodeType.attributes?.let {
  65             bluePrintTypeValidatorService.validateAttributeDefinitions(bluePrintRuntimeService, nodeType.attributes!!)
  66         }
  67
  68         nodeType.properties?.let {
  69             bluePrintTypeValidatorService.validatePropertyDefinitions(bluePrintRuntimeService, nodeType.properties!!)
  70         }
  71
  72         nodeType.capabilities?.let { validateCapabilityDefinitions(nodeTypeName, nodeType) }
  73         nodeType.requirements?.let { validateRequirementDefinitions(nodeTypeName, nodeType) }
  74         nodeType.interfaces?.let { validateInterfaceDefinitions(nodeType.interfaces!!) }
  75
  76         paths.removeAt(paths.lastIndex)
  77     }
  78
  79     fun checkValidNodeTypesDerivedFrom(nodeTypeName: String, derivedFrom: String) {
  80         check(BlueprintTypes.validNodeTypeDerivedFroms.contains(derivedFrom)) {
  81             throw BlueprintException("Failed to get node type ($nodeTypeName)'s  derivedFrom($derivedFrom) definition ")
  82         }
  83     }
  84
  85     open fun validateCapabilityDefinitions(nodeTypeName: String, nodeType: NodeType) {
  86         val capabilities = nodeType.capabilities
  87         paths.add("capabilities")
  88         capabilities?.forEach { capabilityName, capabilityDefinition ->
  89             paths.add(capabilityName)
  90
  91             validateCapabilityDefinition(nodeTypeName, nodeType, capabilityName, capabilityDefinition)
  92
  93             paths.removeAt(paths.lastIndex)
  94         }
  95         paths.removeAt(paths.lastIndex)
  96     }
  97
  98     open fun validateCapabilityDefinition(
  99         nodeTypeName: String,
 100         nodeType: NodeType,
 101         capabilityName: String,
 102         capabilityDefinition: CapabilityDefinition
 103     ) {
 104         val capabilityType = capabilityDefinition.type
 105         check(BlueprintTypes.validCapabilityTypes.contains(capabilityType)) {
 106             throw BlueprintException("failed to get CapabilityType($capabilityType) for NodeType($nodeTypeName)")
 107         }
 108     }
 109
 110     open fun validateRequirementDefinitions(nodeName: String, nodeType: NodeType) {
 111         paths.add("requirements")
 112         val requirements = nodeType.requirements
 113
 114         requirements?.forEach { requirementDefinitionName, requirementDefinition ->
 115             paths.add(requirementDefinitionName)
 116             validateRequirementDefinition(nodeName, nodeType, requirementDefinitionName, requirementDefinition)
 117             paths.removeAt(paths.lastIndex)
 118         }
 119         paths.removeAt(paths.lastIndex)
 120     }
 121
 122     open fun validateRequirementDefinition(
 123         nodeTypeName: String,
 124         nodeType: NodeType,
 125         requirementDefinitionName: String,
 126         requirementDefinition: RequirementDefinition
 127     ) {
 128
 129         log.info("validating NodeType({}) RequirementDefinition ({}) ", nodeTypeName, requirementDefinitionName)
 130         val requirementNodeTypeName = requirementDefinition.node!!
 131         val capabilityName = requirementDefinition.capability
 132         val relationship = requirementDefinition.relationship!!
 133
 134         check(BlueprintTypes.validRelationShipDerivedFroms.contains(relationship)) {
 135             throw BlueprintException("failed to get relationship($relationship) for NodeType($nodeTypeName)'s requirement($requirementDefinitionName)")
 136         }
 137
 138         val relationShipNodeType = bluePrintContext.serviceTemplate.nodeTypes?.get(requirementNodeTypeName)
 139             ?: throw BlueprintException("failed to get requirement NodeType($requirementNodeTypeName)'s for requirement($requirementDefinitionName) ")
 140
 141         relationShipNodeType.capabilities?.get(capabilityName)
 142             ?: throw BlueprintException(
 143                 "failed to get requirement NodeType($requirementNodeTypeName)'s " +
 144                     "capability($nodeTypeName) for NodeType ($capabilityName)'s requirement($requirementDefinitionName) "
 145             )
 146     }
 147
 148     open fun validateInterfaceDefinitions(interfaces: MutableMap<String, InterfaceDefinition>) {
 149         paths.add("interfaces")
 150         interfaces.forEach { interfaceName, interfaceDefinition ->
 151             paths.add(interfaceName)
 152             interfaceDefinition.operations?.let { validateOperationDefinitions(interfaceDefinition.operations!!) }
 153             paths.removeAt(paths.lastIndex)
 154         }
 155         paths.removeAt(paths.lastIndex)
 156     }
 157
 158     open fun validateOperationDefinitions(operations: MutableMap<String, OperationDefinition>) {
 159         paths.add("operations")
 160         operations.forEach { opertaionName, operationDefinition ->
 161             paths.add(opertaionName)
 162             operationDefinition.implementation?.let { validateImplementation(operationDefinition.implementation!!) }
 163
 164             operationDefinition.inputs?.let {
 165                 bluePrintTypeValidatorService.validatePropertyDefinitions(bluePrintRuntimeService, operationDefinition.inputs!!)
 166             }
 167
 168             operationDefinition.outputs?.let {
 169                 bluePrintTypeValidatorService.validatePropertyDefinitions(bluePrintRuntimeService, operationDefinition.outputs!!)
 170             }
 171             paths.removeAt(paths.lastIndex)
 172         }
 173         paths.removeAt(paths.lastIndex)
 174     }
 175
 176     open fun validateImplementation(implementation: Implementation) {
 177         checkNotEmpty(implementation.primary) { "couldn't get implementation" }
 178     }
 179 }