1 files changed, 274 insertions, 0 deletions
diff --git a/ms/blueprintsprocessor/modules/blueprints/blueprint-validation/src/main/kotlin/org/onap/ccsdk/cds/controllerblueprints/validation/BluePrintNodeTemplateValidatorImpl.kt b/ms/blueprintsprocessor/modules/blueprints/blueprint-validation/src/main/kotlin/org/onap/ccsdk/cds/controllerblueprints/validation/BluePrintNodeTemplateValidatorImpl.kt
new file mode 100644
index 000000000..6fa83119e
--- /dev/null
+++ b/ms/blueprintsprocessor/modules/blueprints/blueprint-validation/src/main/kotlin/org/onap/ccsdk/cds/controllerblueprints/validation/BluePrintNodeTemplateValidatorImpl.kt
@@ -0,0 +1,274 @@
+/*
+ * Copyright © 2017-2018 AT&T Intellectual Property.
+ * Modifications Copyright © 2018-2019 IBM.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.ccsdk.cds.controllerblueprints.validation
+
+import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintException
+import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintTypes
+import org.onap.ccsdk.cds.controllerblueprints.core.data.ArtifactDefinition
+import org.onap.ccsdk.cds.controllerblueprints.core.data.CapabilityAssignment
+import org.onap.ccsdk.cds.controllerblueprints.core.data.CapabilityDefinition
+import org.onap.ccsdk.cds.controllerblueprints.core.data.InterfaceAssignment
+import org.onap.ccsdk.cds.controllerblueprints.core.data.InterfaceDefinition
+import org.onap.ccsdk.cds.controllerblueprints.core.data.NodeTemplate
+import org.onap.ccsdk.cds.controllerblueprints.core.data.NodeType
+import org.onap.ccsdk.cds.controllerblueprints.core.data.RequirementAssignment
+import org.onap.ccsdk.cds.controllerblueprints.core.data.RequirementDefinition
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintNodeTemplateValidator
+import org.onap.ccsdk.cds.controllerblueprints.core.interfaces.BluePrintTypeValidatorService
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintContext
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintRuntimeService
+import org.onap.ccsdk.cds.controllerblueprints.validation.utils.PropertyAssignmentValidationUtils
+import org.slf4j.LoggerFactory
+import org.springframework.beans.factory.config.ConfigurableBeanFactory
+import org.springframework.context.annotation.Scope
+import org.springframework.stereotype.Service
+
+@Service("default-node-template-validator")
+@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
+open class BluePrintNodeTemplateValidatorImpl(private val bluePrintTypeValidatorService: BluePrintTypeValidatorService) :
+    BluePrintNodeTemplateValidator {
+
+    private val log = LoggerFactory.getLogger(BluePrintNodeTemplateValidatorImpl::class.toString())
+
+    lateinit var bluePrintRuntimeService: BluePrintRuntimeService<*>
+    lateinit var bluePrintContext: BluePrintContext
+    lateinit var propertyAssignmentValidationUtils: PropertyAssignmentValidationUtils
+    var paths: MutableList<String> = arrayListOf()
+
+    override fun validate(bluePrintRuntimeService: BluePrintRuntimeService<*>, name: String, nodeTemplate: NodeTemplate) {
+        log.debug("Validating NodeTemplate($name)")
+
+        this.bluePrintRuntimeService = bluePrintRuntimeService
+        this.bluePrintContext = bluePrintRuntimeService.bluePrintContext()
+
+        propertyAssignmentValidationUtils = PropertyAssignmentValidationUtils(bluePrintContext)
+
+        paths.add(name)
+
+        val type: String = nodeTemplate.type
+
+        val nodeType: NodeType = bluePrintContext.serviceTemplate.nodeTypes?.get(type)
+            ?: throw BluePrintException("Failed to get NodeType($type) definition for NodeTemplate($name)")
+
+        nodeTemplate.properties?.let {
+            propertyAssignmentValidationUtils
+                .validatePropertyAssignments(nodeType.properties!!, nodeTemplate.properties!!)
+        }
+        nodeTemplate.capabilities?.let { validateCapabilityAssignments(nodeType, name, nodeTemplate) }
+        nodeTemplate.requirements?.let { validateRequirementAssignments(nodeType, name, nodeTemplate) }
+        nodeTemplate.interfaces?.let { validateInterfaceAssignments(nodeType, name, nodeTemplate) }
+        nodeTemplate.artifacts?.let { validateArtifactDefinitions(nodeTemplate.artifacts!!) }
+
+        // Perform Extension Validation
+        validateExtension("$type-node-template-validator", name, nodeTemplate)
+
+        paths.removeAt(paths.lastIndex)
+    }
+
+    @Throws(BluePrintException::class)
+    open fun validateArtifactDefinitions(artifacts: MutableMap<String, ArtifactDefinition>) {
+        paths.add("artifacts")
+        artifacts.forEach { artifactDefinitionName, artifactDefinition ->
+            bluePrintTypeValidatorService.validateArtifactDefinition(
+                bluePrintRuntimeService,
+                artifactDefinitionName, artifactDefinition
+            )
+        }
+        paths.removeAt(paths.lastIndex)
+    }
+
+    @Throws(BluePrintException::class)
+    open fun validateCapabilityAssignments(nodeType: NodeType, nodeTemplateName: String, nodeTemplate: NodeTemplate) {
+        val capabilities = nodeTemplate.capabilities
+        paths.add("capabilities")
+        capabilities?.forEach { capabilityName, capabilityAssignment ->
+            paths.add(capabilityName)
+
+            val capabilityDefinition = nodeType.capabilities?.get(capabilityName)
+                ?: throw BluePrintException(
+                    "Failed to get NodeTemplate($nodeTemplateName) capability definition ($capabilityName) " +
+                        "from NodeType(${nodeTemplate.type})"
+                )
+
+            validateCapabilityAssignment(nodeTemplateName, capabilityName, capabilityDefinition, capabilityAssignment)
+
+            paths.removeAt(paths.lastIndex)
+        }
+        paths.removeAt(paths.lastIndex)
+    }
+
+    @Throws(BluePrintException::class)
+    open fun validateCapabilityAssignment(
+        nodeTemplateName: String,
+        capabilityName: String,
+        capabilityDefinition: CapabilityDefinition,
+        capabilityAssignment: CapabilityAssignment
+    ) {
+
+        capabilityAssignment.properties?.let {
+            propertyAssignmentValidationUtils
+                .validatePropertyAssignments(capabilityDefinition.properties!!, capabilityAssignment.properties!!)
+        }
+    }
+
+    @Throws(BluePrintException::class)
+    open fun validateRequirementAssignments(nodeType: NodeType, nodeTemplateName: String, nodeTemplate: NodeTemplate) {
+        val requirements = nodeTemplate.requirements
+        paths.add("requirements")
+        requirements?.forEach { requirementName, requirementAssignment ->
+            paths.add(requirementName)
+            val requirementDefinition = nodeType.requirements?.get(requirementName)
+                ?: throw BluePrintException(
+                    "Failed to get NodeTemplate($nodeTemplateName) requirement definition ($requirementName) from" +
+                        " NodeType(${nodeTemplate.type})"
+                )
+            // Validate Requirement Assignment
+            validateRequirementAssignment(nodeTemplateName, requirementName, requirementDefinition, requirementAssignment)
+            paths.removeAt(paths.lastIndex)
+        }
+        paths.removeAt(paths.lastIndex)
+    }
+
+    @Throws(BluePrintException::class)
+    open fun validateRequirementAssignment(
+        nodeTemplateName: String,
+        requirementAssignmentName: String,
+        requirementDefinition: RequirementDefinition,
+        requirementAssignment: RequirementAssignment
+    ) {
+        log.debug(
+            "Validating NodeTemplate({}) requirement assignment ({}) ", nodeTemplateName,
+            requirementAssignmentName
+        )
+        val requirementNodeTemplateName = requirementAssignment.node!!
+        val capabilityName = requirementAssignment.capability
+        val relationship = requirementAssignment.relationship!!
+
+        check(BluePrintTypes.validRelationShipDerivedFroms.contains(relationship)) {
+            throw BluePrintException("Failed to get relationship type ($relationship) for NodeTemplate($nodeTemplateName)'s requirement($requirementAssignmentName)")
+        }
+
+        val relationShipNodeTemplate = bluePrintContext.serviceTemplate.topologyTemplate?.nodeTemplates?.get(requirementNodeTemplateName)
+            ?: throw BluePrintException(
+                "Failed to get requirement NodeTemplate($requirementNodeTemplateName)'s " +
+                    "for NodeTemplate($nodeTemplateName) requirement($requirementAssignmentName)"
+            )
+
+        relationShipNodeTemplate.capabilities?.get(capabilityName)
+            ?: throw BluePrintException(
+                "Failed to get requirement NodeTemplate($requirementNodeTemplateName)'s " +
+                    "capability($capabilityName) for NodeTemplate ($nodeTemplateName)'s requirement($requirementAssignmentName)"
+            )
+    }
+
+    @Throws(BluePrintException::class)
+    open fun validateInterfaceAssignments(nodeType: NodeType, nodeTemplateName: String, nodeTemplate: NodeTemplate) {
+
+        val interfaces = nodeTemplate.interfaces
+        paths.add("interfaces")
+        interfaces?.forEach { interfaceAssignmentName, interfaceAssignment ->
+            paths.add(interfaceAssignmentName)
+            val interfaceDefinition = nodeType.interfaces?.get(interfaceAssignmentName)
+                ?: throw BluePrintException(
+                    "Failed to get NodeTemplate($nodeTemplateName) interface definition ($interfaceAssignmentName) from" +
+                        " NodeType(${nodeTemplate.type})"
+                )
+
+            validateInterfaceAssignment(
+                nodeTemplateName, interfaceAssignmentName, interfaceDefinition,
+                interfaceAssignment
+            )
+            paths.removeAt(paths.lastIndex)
+        }
+        paths.removeAt(paths.lastIndex)
+    }
+
+    @Throws(BluePrintException::class)
+    open fun validateInterfaceAssignment(
+        nodeTemplateName: String,
+        interfaceAssignmentName: String,
+        interfaceDefinition: InterfaceDefinition,
+        interfaceAssignment: InterfaceAssignment
+    ) {
+
+        val operations = interfaceAssignment.operations
+        operations?.let {
+            validateInterfaceOperationsAssignment(
+                nodeTemplateName, interfaceAssignmentName, interfaceDefinition,
+                interfaceAssignment
+            )
+        }
+    }
+
+    @Throws(BluePrintException::class)
+    open fun validateInterfaceOperationsAssignment(
+        nodeTemplateName: String,
+        interfaceAssignmentName: String,
+        interfaceDefinition: InterfaceDefinition,
+        interfaceAssignment: InterfaceAssignment
+    ) {
+
+        val operations = interfaceAssignment.operations
+        operations?.let {
+            it.forEach { operationAssignmentName, operationAssignments ->
+
+                val operationDefinition = interfaceDefinition.operations?.get(operationAssignmentName)
+                    ?: throw BluePrintException("Failed to get NodeTemplate($nodeTemplateName) operation definition ($operationAssignmentName)")
+
+                log.debug(
+                    "Validation NodeTemplate($nodeTemplateName) Interface($interfaceAssignmentName) Operation " +
+                        "($operationAssignmentName)"
+                )
+
+                val inputs = operationAssignments.inputs
+                val outputs = operationAssignments.outputs
+
+                inputs?.forEach { propertyName, propertyAssignment ->
+                    val propertyDefinition = operationDefinition.inputs?.get(propertyName)
+                        ?: throw BluePrintException(
+                            "Failed to get NodeTemplate($nodeTemplateName) operation " +
+                                "definition ($operationAssignmentName) property definition($propertyName)"
+                        )
+                    // Check the property values with property definition
+                    propertyAssignmentValidationUtils
+                        .validatePropertyAssignment(propertyName, propertyDefinition, propertyAssignment)
+                }
+
+                outputs?.forEach { propertyName, propertyAssignment ->
+                    val propertyDefinition = operationDefinition.outputs?.get(propertyName)
+                        ?: throw BluePrintException(
+                            "Failed to get NodeTemplate($nodeTemplateName) operation definition ($operationAssignmentName) " +
+                                "output property definition($propertyName)"
+                        )
+                    // Check the property values with property definition
+                    propertyAssignmentValidationUtils
+                        .validatePropertyAssignment(propertyName, propertyDefinition, propertyAssignment)
+                }
+            }
+        }
+    }
+
+    private fun validateExtension(referencePrefix: String, name: String, nodeTemplate: NodeTemplate) {
+        val customValidator = bluePrintTypeValidatorService
+            .bluePrintValidator(referencePrefix, BluePrintNodeTemplateValidator::class.java)
+
+        customValidator?.let {
+            it.validate(bluePrintRuntimeService, name, nodeTemplate)
+        }
+    }
+}