\r
package org.onap.ccsdk.apps.controllerblueprints.core.service\r
\r
+import com.att.eelf.configuration.EELFLogger\r
+import com.att.eelf.configuration.EELFManager\r
import com.fasterxml.jackson.databind.JsonNode\r
import com.google.common.base.Preconditions\r
import org.apache.commons.lang3.StringUtils\r
import org.onap.ccsdk.apps.controllerblueprints.core.*\r
import org.onap.ccsdk.apps.controllerblueprints.core.data.*\r
-import com.att.eelf.configuration.EELFLogger\r
-import com.att.eelf.configuration.EELFManager\r
import org.onap.ccsdk.apps.controllerblueprints.core.utils.JacksonUtils\r
import java.io.Serializable\r
\r
paths.add("dataTypes")\r
dataTypes.forEach { dataTypeName, dataType ->\r
paths.add(dataTypeName)\r
- message.appendln("--> Data Type :" + paths.joinToString(separator))\r
+ message.appendln("--> DataType :" + paths.joinToString(separator))\r
dataType.properties?.let { validatePropertyDefinitions(dataType.properties!!) }\r
paths.removeAt(paths.lastIndex)\r
}\r
//Check Derived From\r
checkValidNodeTypesDerivedFrom(nodeTypeName, derivedFrom)\r
\r
+ if (!BluePrintTypes.rootNodeTypes().contains(derivedFrom)) {\r
+ serviceTemplate.nodeTypes?.get(derivedFrom)\r
+ ?: throw BluePrintException(format("Failed to get derivedFrom NodeType({})'s for NodeType({}) ",\r
+ derivedFrom, nodeTypeName))\r
+ }\r
+\r
nodeType.properties?.let { validatePropertyDefinitions(nodeType.properties!!) }\r
+ nodeType.capabilities?.let { validateCapabilityDefinitions(nodeTypeName, nodeType) }\r
+ nodeType.requirements?.let { validateRequirementDefinitions(nodeTypeName, nodeType) }\r
nodeType.interfaces?.let { validateInterfaceDefinitions(nodeType.interfaces!!) }\r
paths.removeAt(paths.lastIndex)\r
}\r
@Throws(BluePrintException::class)\r
open fun checkValidNodeTypesDerivedFrom(nodeTypeName: String, derivedFrom: String) {\r
check(BluePrintTypes.validNodeTypeDerivedFroms.contains(derivedFrom)) {\r
- throw BluePrintException(format("Failed to get node type ({})'s derived from({}) definition ", nodeTypeName, derivedFrom))\r
+ throw BluePrintException(format("Failed to get node type ({})'s derivedFrom({}) definition ", nodeTypeName, derivedFrom))\r
}\r
}\r
\r
@Throws(BluePrintException::class)\r
open fun validateNodeTemplate(nodeTemplateName: String, nodeTemplate: NodeTemplate) {\r
paths.add(nodeTemplateName)\r
- message.appendln("---> Node Template :" + paths.joinToString(separator))\r
+ message.appendln("---> NodeTemplate :" + paths.joinToString(separator))\r
val type: String = nodeTemplate.type\r
\r
val nodeType: NodeType = serviceTemplate.nodeTypes?.get(type)\r
- ?: throw BluePrintException(format("Failed to get node type definition for node template : {}", nodeTemplateName))\r
+ ?: throw BluePrintException(format("Failed to get NodeType({}) definition for NodeTemplate({})", type, nodeTemplateName))\r
\r
nodeTemplate.artifacts?.let { validateArtifactDefinitions(nodeTemplate.artifacts!!) }\r
nodeTemplate.properties?.let { validatePropertyAssignments(nodeType.properties!!, nodeTemplate.properties!!) }\r
- nodeTemplate.capabilities?.let { validateCapabilityAssignments(nodeTemplate.capabilities!!) }\r
- nodeTemplate.requirements?.let { validateRequirementAssignments(nodeTemplate.requirements!!) }\r
+ nodeTemplate.capabilities?.let { validateCapabilityAssignments(nodeType, nodeTemplateName, nodeTemplate) }\r
+ nodeTemplate.requirements?.let { validateRequirementAssignments(nodeType, nodeTemplateName, nodeTemplate) }\r
nodeTemplate.interfaces?.let { validateInterfaceAssignments(nodeType, nodeTemplateName, nodeTemplate) }\r
paths.removeAt(paths.lastIndex)\r
}\r
paths.add(artifactDefinitionName)\r
message.appendln("Validating artifact " + paths.joinToString(separator))\r
val type: String = artifactDefinition.type\r
- ?: throw BluePrintException("type is missing for artifact definition :" + artifactDefinitionName)\r
+ ?: throw BluePrintException(format("type is missing for ArtifactDefinition({})", artifactDefinitionName))\r
// Check Artifact Type\r
checkValidArtifactType(artifactDefinitionName, type)\r
\r
val file: String = artifactDefinition.file\r
- ?: throw BluePrintException(format("file is missing for artifact definition : {}", artifactDefinitionName))\r
+ ?: throw BluePrintException(format("file is missing for ArtifactDefinition({})", artifactDefinitionName))\r
\r
paths.removeAt(paths.lastIndex)\r
}\r
message.appendln("---> Workflow :" + paths.joinToString(separator))\r
// Step Validation Start\r
paths.add("steps")\r
- workflow.steps?.forEach { stepName, step ->\r
+ workflow.steps?.forEach { stepName, _ ->\r
paths.add(stepName)\r
message.appendln("----> Steps :" + paths.joinToString(separator))\r
paths.removeAt(paths.lastIndex)\r
}\r
BluePrintTypes.validCollectionTypes().contains(dataType) -> {\r
val entrySchemaType: String = propertyDefinition.entrySchema?.type\r
- ?: throw BluePrintException(format("Entry schema for data type ({}) for the property ({}) not found", dataType, propertyName))\r
+ ?: throw BluePrintException(format("Entry schema for DataType ({}) for the property ({}) not found", dataType, propertyName))\r
checkPrimitiveOrComplex(entrySchemaType, propertyName)\r
}\r
else -> checkPropertyDataType(dataType, propertyName)\r
}\r
\r
@Throws(BluePrintException::class)\r
- open fun validateCapabilityAssignments(capabilities: MutableMap<String, CapabilityAssignment>) {\r
+ open fun validateCapabilityAssignments(nodeType: NodeType, nodeTemplateName: String, nodeTemplate: NodeTemplate) {\r
+ val capabilities = nodeTemplate.capabilities\r
+ paths.add("capabilities")\r
+ capabilities?.forEach { capabilityName, capabilityAssignment ->\r
+ paths.add(capabilityName)\r
+\r
+ val capabilityDefinition = nodeType.capabilities?.get(capabilityName)\r
+ ?: throw BluePrintException(format("Failed to get NodeTemplate({}) capability definition ({}) " +\r
+ "from NodeType({}) ", nodeTemplateName, capabilityName, nodeTemplate.type))\r
+\r
+ validateCapabilityAssignment(nodeTemplateName, capabilityName, capabilityDefinition, capabilityAssignment)\r
+\r
+ paths.removeAt(paths.lastIndex)\r
+ }\r
+ paths.removeAt(paths.lastIndex)\r
+ }\r
+\r
+ @Throws(BluePrintException::class)\r
+ open fun validateCapabilityAssignment(nodeTemplateName: String, capabilityName: String,\r
+ capabilityDefinition: CapabilityDefinition, capabilityAssignment: CapabilityAssignment) {\r
+\r
+ capabilityAssignment.properties?.let { validatePropertyAssignments(capabilityDefinition.properties!!, capabilityAssignment.properties!!) }\r
+\r
+ }\r
+\r
+ @Throws(BluePrintException::class)\r
+ open fun validateRequirementAssignments(nodeType: NodeType, nodeTemplateName: String, nodeTemplate: NodeTemplate) {\r
+ val requirements = nodeTemplate.requirements\r
+ paths.add("requirements")\r
+ requirements?.forEach { requirementName, requirementAssignment ->\r
+ paths.add(requirementName)\r
+ val requirementDefinition = nodeType.requirements?.get(requirementName)\r
+ ?: throw BluePrintException(format("Failed to get NodeTemplate({}) requirement definition ({}) from" +\r
+ " NodeType({}) ", nodeTemplateName, requirementName, nodeTemplate.type))\r
+ // Validate Requirement Assignment\r
+ validateRequirementAssignment(nodeTemplateName, requirementName, requirementDefinition, requirementAssignment)\r
+ paths.removeAt(paths.lastIndex)\r
+ }\r
+ paths.removeAt(paths.lastIndex)\r
\r
}\r
\r
@Throws(BluePrintException::class)\r
- open fun validateRequirementAssignments(requirements: MutableMap<String, RequirementAssignment>) {\r
+ open fun validateRequirementAssignment(nodeTemplateName: String, requirementAssignmentName: String,\r
+ requirementDefinition: RequirementDefinition, requirementAssignment: RequirementAssignment) {\r
+ log.info("Validating NodeTemplate({}) requirement assignment ({}) ", nodeTemplateName, requirementAssignmentName)\r
+ val requirementNodeTemplateName = requirementAssignment.node!!\r
+ val capabilityName = requirementAssignment.capability\r
+ val relationship = requirementAssignment.relationship!!\r
+\r
+ check(BluePrintTypes.validRelationShipDerivedFroms.contains(relationship)) {\r
+ throw BluePrintException(format("Failed to get relationship type ({}) for NodeTemplate({})'s requirement({}) ",\r
+ relationship, nodeTemplateName, requirementAssignmentName))\r
+ }\r
+\r
+ val relationShipNodeTemplate = serviceTemplate.topologyTemplate?.nodeTemplates?.get(requirementNodeTemplateName)\r
+ ?: throw BluePrintException(format("Failed to get requirement NodeTemplate({})'s for NodeTemplate({}) requirement({}) ",\r
+ requirementNodeTemplateName, nodeTemplateName, requirementAssignmentName))\r
+\r
+ relationShipNodeTemplate.capabilities?.get(capabilityName)\r
+ ?: throw BluePrintException(format("Failed to get requirement NodeTemplate({})'s capability({}) for NodeTemplate ({})'s requirement({}) ",\r
+ requirementNodeTemplateName, capabilityName, nodeTemplateName, requirementAssignmentName))\r
+\r
\r
}\r
\r
interfaces?.forEach { interfaceAssignmentName, interfaceAssignment ->\r
paths.add(interfaceAssignmentName)\r
val interfaceDefinition = nodeType.interfaces?.get(interfaceAssignmentName)\r
- ?: throw BluePrintException(format("Failed to get nodeTemplate({}) interface definition ({}) from" +\r
- " node type ({}) ", nodeTemplateName, interfaceAssignmentName, nodeTemplate.type))\r
+ ?: throw BluePrintException(format("Failed to get NodeTemplate({}) interface definition ({}) from" +\r
+ " NodeType({}) ", nodeTemplateName, interfaceAssignmentName, nodeTemplate.type))\r
\r
validateInterfaceAssignment(nodeTemplateName, interfaceAssignmentName, interfaceDefinition,\r
interfaceAssignment)\r
it.forEach { operationAssignmentName, operationAssignments ->\r
\r
val operationDefinition = interfaceDefinition.operations?.get(operationAssignmentName)\r
- ?: throw BluePrintException(format("Failed to get nodeTemplate({}) operation definition ({}) ",\r
+ ?: throw BluePrintException(format("Failed to get NodeTemplate({}) operation definition ({}) ",\r
nodeTemplateName, operationAssignmentName))\r
\r
- log.info("Validation Node Template({}) Interface({}) Operation ({})", nodeTemplateName,\r
+ log.info("Validation NodeTemplate({}) Interface({}) Operation ({})", nodeTemplateName,\r
interfaceAssignmentName, operationAssignmentName)\r
\r
val inputs = operationAssignments.inputs\r
\r
inputs?.forEach { propertyName, propertyAssignment ->\r
val propertyDefinition = operationDefinition.inputs?.get(propertyName)\r
- ?: throw BluePrintException(format("Failed to get nodeTemplate({}) operation definition ({}) " +\r
+ ?: throw BluePrintException(format("Failed to get NodeTemplate({}) operation definition ({}) " +\r
"property definition({})", nodeTemplateName, operationAssignmentName, propertyName))\r
// Check the property values with property definition\r
validatePropertyAssignment(propertyName, propertyDefinition, propertyAssignment)\r
}\r
\r
+ outputs?.forEach { propertyName, propertyAssignment ->\r
+ val propertyDefinition = operationDefinition.outputs?.get(propertyName)\r
+ ?: throw BluePrintException(format("Failed to get NodeTemplate({}) operation definition ({}) " +\r
+ "output property definition({})", nodeTemplateName, operationAssignmentName,\r
+ propertyName))\r
+ // Check the property values with property definition\r
+ validatePropertyAssignment(propertyName, propertyDefinition, propertyAssignment)\r
+ }\r
+\r
}\r
}\r
\r
}\r
\r
+ @Throws(BluePrintException::class)\r
+ open fun validateCapabilityDefinitions(nodeTypeName: String, nodeType: NodeType) {\r
+ val capabilities = nodeType.capabilities\r
+ paths.add("capabilities")\r
+ capabilities?.forEach { capabilityName, capabilityDefinition ->\r
+ paths.add(capabilityName)\r
+\r
+ validateCapabilityDefinition(nodeTypeName, nodeType, capabilityName, capabilityDefinition)\r
+\r
+ paths.removeAt(paths.lastIndex)\r
+ }\r
+ paths.removeAt(paths.lastIndex)\r
+ }\r
+\r
+ @Throws(BluePrintException::class)\r
+ open fun validateCapabilityDefinition(nodeTypeName: String, nodeType: NodeType, capabilityName: String,\r
+ capabilityDefinition: CapabilityDefinition) {\r
+ val capabilityType = capabilityDefinition.type\r
+ check(BluePrintTypes.validCapabilityTypes.contains(capabilityType)) {\r
+ throw BluePrintException(format("Failed to get CapabilityType({}) for NodeType({})",\r
+ capabilityType, nodeTypeName))\r
+ }\r
+ }\r
+\r
+ @Throws(BluePrintException::class)\r
+ open fun validateRequirementDefinitions(nodeName: String, nodeType: NodeType) {\r
+ paths.add("requirements")\r
+ val requirements = nodeType.requirements\r
+\r
+ requirements?.forEach { requirementDefinitionName, requirementDefinition ->\r
+ paths.add(requirementDefinitionName)\r
+ message.appendln("Validating : " + paths.joinToString(separator))\r
+ validateRequirementDefinition(nodeName, nodeType, requirementDefinitionName, requirementDefinition)\r
+ paths.removeAt(paths.lastIndex)\r
+ }\r
+ paths.removeAt(paths.lastIndex)\r
+ }\r
+\r
+ @Throws(BluePrintException::class)\r
+ open fun validateRequirementDefinition(nodeTypeName: String, nodeType: NodeType, requirementDefinitionName: String,\r
+ requirementDefinition: RequirementDefinition) {\r
+\r
+ log.info("Validating NodeType({}) RequirementDefinition ({}) ", nodeTypeName, requirementDefinitionName)\r
+ val requirementNodeTypeName = requirementDefinition.node!!\r
+ val capabilityName = requirementDefinition.capability\r
+ val relationship = requirementDefinition.relationship!!\r
+\r
+ check(BluePrintTypes.validRelationShipDerivedFroms.contains(relationship)) {\r
+ throw BluePrintException(format("Failed to get relationship({}) for NodeType({})'s requirement({}) ",\r
+ relationship, nodeTypeName, requirementDefinitionName))\r
+ }\r
+\r
+ val relationShipNodeType = serviceTemplate.nodeTypes?.get(requirementNodeTypeName)\r
+ ?: throw BluePrintException(format("Failed to get requirement NodeType({})'s for requirement({}) ",\r
+ requirementNodeTypeName, requirementDefinitionName))\r
+\r
+ relationShipNodeType.capabilities?.get(capabilityName)\r
+ ?: throw BluePrintException(format("Failed to get requirement NodeType({})'s capability({}) for NodeType ({})'s requirement({}) ",\r
+ requirementNodeTypeName, capabilityName, nodeTypeName, requirementDefinitionName))\r
+\r
+ }\r
+\r
\r
@Throws(BluePrintException::class)\r
open fun validateInterfaceDefinitions(interfaces: MutableMap<String, InterfaceDefinition>) {\r
\r
@Throws(BluePrintException::class)\r
open fun validateImplementation(implementation: Implementation) {\r
- checkNotEmptyNThrow(implementation.primary)\r
+ checkNotEmptyOrThrow(implementation.primary)\r
}\r
\r
@Throws(BluePrintException::class)\r
open fun checkValidArtifactType(artifactDefinitionName: String, artifactTypeName: String) {\r
\r
val artifactType = serviceTemplate.artifactTypes?.get(artifactTypeName)\r
- ?: throw BluePrintException(format("Failed to artifact type for artifact definition : {}", artifactDefinitionName))\r
+ ?: throw BluePrintException("failed to artifactType($artifactTypeName) for ArtifactDefinition($artifactDefinitionName)")\r
\r
checkValidArtifactTypeDerivedFrom(artifactTypeName, artifactType.derivedFrom)\r
}\r
@Throws(BluePrintException::class)\r
open fun checkValidArtifactTypeDerivedFrom(artifactTypeName: String, derivedFrom: String) {\r
check(BluePrintTypes.validArtifactTypeDerivedFroms.contains(derivedFrom)) {\r
- throw BluePrintException(format("Failed to get artifact type ({})'s derived from({}) definition ", artifactTypeName, derivedFrom))\r
+ throw BluePrintException("failed to get artifactType($artifactTypeName)'s derivedFrom($derivedFrom) definition")\r
}\r
}\r
\r
@Throws(BluePrintException::class)\r
open fun checkValidDataTypeDerivedFrom(dataTypeName: String, derivedFrom: String) {\r
check(BluePrintTypes.validDataTypeDerivedFroms.contains(derivedFrom)) {\r
- throw BluePrintException(format("Failed to get data type ({})'s derived from({}) definition ", dataTypeName, derivedFrom))\r
+ throw BluePrintException(format("Failed to get DataType({})'s derivedFrom({}) definition ", dataTypeName, derivedFrom))\r
+ }\r
+ }\r
+\r
+ @Throws(BluePrintException::class)\r
+ open fun checkValidRelationshipTypeDerivedFrom(relationshipTypeName: String, derivedFrom: String) {\r
+ check(BluePrintTypes.validRelationShipDerivedFroms.contains(derivedFrom)) {\r
+ throw BluePrintException(format("Failed to get relationship type ({})'s derivedFrom({}) definition ", relationshipTypeName, derivedFrom))\r
}\r
}\r
\r
} else if (BluePrintTypes.validCollectionTypes().contains(propertyType)) {\r
\r
val entrySchemaType = propertyDefinition.entrySchema?.type\r
- ?: throw BluePrintException(format("Failed to get Entry Schema type for the collection property ({})", propertyName))\r
+ ?: throw BluePrintException(format("Failed to get EntrySchema type for the collection property ({})", propertyName))\r
\r
if (!BluePrintTypes.validPropertyTypes().contains(entrySchemaType)) {\r
checkPropertyDataType(entrySchemaType, propertyName)\r
}\r
\r
check(isValid) {\r
- throw BluePrintException(format("property({}) defined of type({}) is not compatable with the value ({})",\r
+ throw BluePrintException(format("property({}) defined of type({}) is not comptable with the value ({})",\r
propertyName, propertyType, propertyAssignment))\r
}\r
}\r
\r
- private fun checkPropertyDataType(dataType: String, propertyName: String) {\r
+ private fun checkPropertyDataType(dataTypeName: String, propertyName: String) {\r
\r
- val dataType = serviceTemplate.dataTypes?.get(dataType)\r
- ?: throw BluePrintException(format("Data type ({}) for the property ({}) not found", dataType, propertyName))\r
+ val dataType = serviceTemplate.dataTypes?.get(dataTypeName)\r
+ ?: throw BluePrintException(format("DataType ({}) for the property ({}) not found", dataTypeName, propertyName))\r
\r
checkValidDataTypeDerivedFrom(propertyName, dataType.derivedFrom)\r
\r
if (BluePrintTypes.validPrimitiveTypes().contains(dataType) || checkDataType(dataType)) {\r
return true\r
} else {\r
- throw BluePrintException(format("Data type ({}) for the property ({}) is not valid", dataType))\r
+ throw BluePrintException(format("DataType({}) for the property({}) is not valid", dataType, propertyName))\r
}\r
}\r
\r
Code Review / ccsdk / cds.git / blobdiff