Controller Blueprints Microservice

Add resource assignment enhancement and validation to blueprint validation and enhancement.

Change-Id: I547760012e7014cfbb7a1e3a1d8ffb77edc9b6a2
Issue-ID: CCSDK-562
Signed-off-by: Muthuramalingam, Brinda Santh(bs2796) <bs2796@att.com>

2 files changed, 313 insertions, 9 deletions

diff --git a/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/enhancer/BluePrintEnhancerService.kt b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/enhancer/BluePrintEnhancerService.kt
new file mode 100644
index 00000000..cf9e96e7
--- /dev/null
+++ b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/enhancer/BluePrintEnhancerService.kt
@@ -0,0 +1,272 @@
+/*

+ * Copyright © 2017-2018 AT&T Intellectual Property.

+ * Modifications Copyright © 2018 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.apps.controllerblueprints.service.enhancer

+

+import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintException

+import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintTypes

+import org.onap.ccsdk.apps.controllerblueprints.core.data.*

+import org.onap.ccsdk.apps.controllerblueprints.core.format

+import com.att.eelf.configuration.EELFLogger

+import com.att.eelf.configuration.EELFManager

+import org.onap.ccsdk.apps.controllerblueprints.core.service.BluePrintRepoService

+import org.onap.ccsdk.apps.controllerblueprints.core.utils.JacksonReactorUtils

+import java.io.Serializable

+

+/**

+ * BluePrintEnhancerService

+ * @author Brinda Santh

+ *

+ */

+interface BluePrintEnhancerService : Serializable {

+

+    @Throws(BluePrintException::class)

+    fun enhance(content: String): ServiceTemplate

+

+    /**

+     * Read Blueprint from CSAR structure Directory

+     */

+    @Throws(BluePrintException::class)

+    fun enhance(fileName: String, basePath: String): ServiceTemplate

+

+    @Throws(BluePrintException::class)

+    fun enhance(serviceTemplate: ServiceTemplate): ServiceTemplate

+

+    @Throws(BluePrintException::class)

+    fun enrichNodeTemplate(nodeTemplateName: String, nodeTemplate: NodeTemplate)

+

+    @Throws(BluePrintException::class)

+    fun enrichNodeType(nodeTypeName: String, nodeType: NodeType)

+

+    @Throws(BluePrintException::class)

+    fun enrichPropertyDefinition(propertyName: String, propertyDefinition: PropertyDefinition)

+}

+

+open class BluePrintEnhancerDefaultService(val bluePrintRepoService: BluePrintRepoService) : BluePrintEnhancerService {

+

+    private val log: EELFLogger = EELFManager.getInstance().getLogger(BluePrintEnhancerDefaultService::class.toString())

+

+    lateinit var serviceTemplate: ServiceTemplate

+

+    @Throws(BluePrintException::class)

+    override fun enhance(content: String): ServiceTemplate {

+        return JacksonReactorUtils.readValueFromFile(content, ServiceTemplate::class.java).map { serviceTemplate ->

+            enhance(serviceTemplate!!)

+        }.block()!!

+    }

+

+    @Throws(BluePrintException::class)

+    override fun enhance(fileName: String, basePath: String): ServiceTemplate {

+        TODO("not implemented") //To change body of created functions use File | Settings | File Templates.

+    }

+

+    @Throws(BluePrintException::class)

+    override fun enhance(serviceTemplate: ServiceTemplate): ServiceTemplate {

+        this.serviceTemplate = serviceTemplate

+        initialCleanUp()

+        enrichTopologyTemplate(serviceTemplate)

+

+        // log.info("Enriched Blueprint :\n {}", JacksonUtils.getJson(serviceTemplate, true))

+        return this.serviceTemplate

+    }

+

+    open fun initialCleanUp() {

+        serviceTemplate.artifactTypes?.clear()

+        serviceTemplate.nodeTypes?.clear()

+        serviceTemplate.dataTypes?.clear()

+

+        serviceTemplate.artifactTypes = HashMap()

+        serviceTemplate.nodeTypes = HashMap()

+        serviceTemplate.dataTypes = HashMap()

+

+    }

+

+    @Throws(BluePrintException::class)

+    open fun enrichTopologyTemplate(serviceTemplate: ServiceTemplate) {

+        serviceTemplate.topologyTemplate?.let { topologyTemplate ->

+            enrichTopologyTemplateInputs(topologyTemplate)

+            enrichTopologyTemplateNodeTemplates(topologyTemplate)

+        }

+    }

+

+    @Throws(BluePrintException::class)

+    open fun enrichTopologyTemplateInputs(topologyTemplate: TopologyTemplate) {

+        topologyTemplate.inputs?.let { inputs ->

+            enrichPropertyDefinitions(inputs)

+        }

+    }

+

+    open fun enrichTopologyTemplateNodeTemplates(topologyTemplate: TopologyTemplate) {

+        topologyTemplate.nodeTemplates?.forEach { nodeTemplateName, nodeTemplate ->

+            enrichNodeTemplate(nodeTemplateName, nodeTemplate)

+        }

+    }

+

+    @Throws(BluePrintException::class)

+    override fun enrichNodeTemplate(nodeTemplateName: String, nodeTemplate: NodeTemplate) {

+        val nodeTypeName = nodeTemplate.type

+        // Get NodeType from Repo and Update Service Template

+        val nodeType = populateNodeType(nodeTypeName)

+

+        // Enrich NodeType

+        enrichNodeType(nodeTypeName, nodeType)

+

+        //Enrich Node Template Artifacts

+        enrichNodeTemplateArtifactDefinition(nodeTemplateName, nodeTemplate)

+    }

+

+    @Throws(BluePrintException::class)

+    override fun enrichNodeType(nodeTypeName: String, nodeType: NodeType) {

+        log.debug("Enriching NodeType({})", nodeTypeName)

+        val derivedFrom = nodeType.derivedFrom

+

+        if (!BluePrintTypes.rootNodeTypes().contains(derivedFrom)) {

+            val derivedFromNodeType = populateNodeType(nodeTypeName)

+            // Enrich NodeType

+            enrichNodeType(derivedFrom, derivedFromNodeType)

+        }

+

+        // NodeType Property Definitions

+        enrichNodeTypeProperties(nodeTypeName, nodeType)

+

+        //NodeType Requirement

+        enrichNodeTypeRequirements(nodeTypeName, nodeType)

+

+        //NodeType Capability

+        enrichNodeTypeCapabilityProperties(nodeTypeName, nodeType)

+

+        //NodeType Interface

+        enrichNodeTypeInterfaces(nodeTypeName, nodeType)

+    }

+

+    open fun enrichNodeTypeProperties(nodeTypeName: String, nodeType: NodeType) {

+        nodeType.properties?.let { enrichPropertyDefinitions(nodeType.properties!!) }

+    }

+

+    open fun enrichNodeTypeRequirements(nodeTypeName: String, nodeType: NodeType) {

+

+        nodeType.requirements?.forEach { _, requirementDefinition ->

+            // Populate Requirement Node

+            requirementDefinition.node?.let { requirementNodeTypeName ->

+                // Get Requirement NodeType from Repo and Update Service Template

+                val requirementNodeType = populateNodeType(requirementNodeTypeName)

+

+                enrichNodeType(requirementNodeTypeName, requirementNodeType)

+            }

+        }

+    }

+

+    open fun enrichNodeTypeCapabilityProperties(nodeTypeName: String, nodeType: NodeType) {

+        nodeType.capabilities?.forEach { capabilityDefinitionName, capabilityDefinition ->

+            capabilityDefinition.properties?.let { properties ->

+                enrichPropertyDefinitions(properties)

+            }

+        }

+    }

+

+    open fun enrichNodeTypeInterfaces(nodeTypeName: String, nodeType: NodeType) {

+        nodeType.interfaces?.forEach { interfaceName, interfaceObj ->

+            // Populate Node type Interface Operation

+            log.debug("Enriching NodeType({}) Interface({})", nodeTypeName, interfaceName)

+            populateNodeTypeInterfaceOperation(nodeTypeName, interfaceName, interfaceObj)

+

+        }

+    }

+

+    open fun populateNodeTypeInterfaceOperation(nodeTypeName: String, interfaceName: String, interfaceObj: InterfaceDefinition) {

+

+        interfaceObj.operations?.forEach { operationName, operation ->

+            enrichNodeTypeInterfaceOperationInputs(nodeTypeName, operationName, operation)

+            enrichNodeTypeInterfaceOperationOputputs(nodeTypeName, operationName, operation)

+        }

+    }

+

+    open fun enrichNodeTypeInterfaceOperationInputs(nodeTypeName: String, operationName: String, operation: OperationDefinition) {

+        operation.inputs?.let { inputs ->

+            enrichPropertyDefinitions(inputs)

+        }

+    }

+

+    open fun enrichNodeTypeInterfaceOperationOputputs(nodeTypeName: String, operationName: String, operation: OperationDefinition) {

+        operation.outputs?.let { inputs ->

+            enrichPropertyDefinitions(inputs)

+        }

+    }

+

+    open fun enrichPropertyDefinitions(properties: MutableMap<String, PropertyDefinition>) {

+

+        properties.forEach { propertyName, propertyDefinition ->

+            enrichPropertyDefinition(propertyName, propertyDefinition)

+        }

+    }

+

+    @Throws(BluePrintException::class)

+    override fun enrichPropertyDefinition(propertyName: String, propertyDefinition: PropertyDefinition) {

+        val propertyType = propertyDefinition.type

+        if (BluePrintTypes.validPrimitiveTypes().contains(propertyType)) {

+

+        } else if (BluePrintTypes.validCollectionTypes().contains(propertyType)) {

+            val entrySchema = propertyDefinition.entrySchema

+                    ?: throw BluePrintException(format("Entry Schema is missing for collection property : {}", propertyName))

+

+            if (!BluePrintTypes.validPrimitiveTypes().contains(entrySchema.type)) {

+                populateDataTypes(entrySchema.type)

+            }

+        } else {

+            populateDataTypes(propertyType)

+        }

+

+    }

+

+    open fun enrichNodeTemplateArtifactDefinition(nodeTemplateName: String, nodeTemplate: NodeTemplate) {

+

+        nodeTemplate.artifacts?.forEach { artifactDefinitionName, artifactDefinition ->

+            val artifactTypeName = artifactDefinition.type

+                    ?: throw BluePrintException(format("Artifact type is missing for NodeTemplate({}) artifact({})", nodeTemplateName, artifactDefinitionName))

+

+            // Populate Artifact Type

+            populateArtifactType(artifactTypeName)

+        }

+    }

+

+    open fun populateNodeType(nodeTypeName: String): NodeType {

+

+        val nodeType = serviceTemplate.nodeTypes?.get(nodeTypeName)

+                ?: bluePrintRepoService.getNodeType(nodeTypeName)?.block()

+                ?: throw BluePrintException(format("Couldn't get NodeType({}) from repo.", nodeTypeName))

+        serviceTemplate.nodeTypes?.put(nodeTypeName, nodeType)

+        return nodeType

+    }

+

+    open fun populateArtifactType(artifactTypeName: String): ArtifactType {

+        val artifactType = serviceTemplate.artifactTypes?.get(artifactTypeName)

+                ?: bluePrintRepoService.getArtifactType(artifactTypeName)?.block()

+                ?: throw BluePrintException(format("Couldn't get ArtifactType({}) from repo.", artifactTypeName))

+        serviceTemplate.artifactTypes?.put(artifactTypeName, artifactType)

+        return artifactType

+    }

+

+    open fun populateDataTypes(dataTypeName: String): DataType {

+        val dataType = serviceTemplate.dataTypes?.get(dataTypeName)

+                ?: bluePrintRepoService.getDataType(dataTypeName)?.block()

+                ?: throw BluePrintException(format("Couldn't get DataType({}) from repo.", dataTypeName))

+        serviceTemplate.dataTypes?.put(dataTypeName, dataType)

+        return dataType

+    }

+

+}

+

diff --git a/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/enhancer/ResourceAssignmentEnhancerService.kt b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/enhancer/ResourceAssignmentEnhancerService.kt
index 0d08985a..de6f82ff 100644
--- a/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/enhancer/ResourceAssignmentEnhancerService.kt
+++ b/ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/enhancer/ResourceAssignmentEnhancerService.kt
@@ -19,13 +19,16 @@ package org.onap.ccsdk.apps.controllerblueprints.service.enhancer
 import com.att.eelf.configuration.EELFLogger

 import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintException

 import org.onap.ccsdk.apps.controllerblueprints.core.data.ServiceTemplate

-import org.onap.ccsdk.apps.controllerblueprints.core.service.BluePrintEnhancerDefaultService

-import org.onap.ccsdk.apps.controllerblueprints.core.service.BluePrintEnhancerService

 import org.onap.ccsdk.apps.controllerblueprints.resource.dict.ResourceAssignment

 import org.onap.ccsdk.apps.controllerblueprints.resource.dict.ResourceDefinition

 import com.att.eelf.configuration.EELFManager

+import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintTypes

+import org.onap.ccsdk.apps.controllerblueprints.core.format

+import org.onap.ccsdk.apps.controllerblueprints.resource.dict.ResourceDictionaryConstants

+import org.onap.ccsdk.apps.controllerblueprints.resource.dict.factory.ResourceSourceMappingFactory

 import org.onap.ccsdk.apps.controllerblueprints.resource.dict.service.ResourceAssignmentValidationDefaultService

 import org.onap.ccsdk.apps.controllerblueprints.resource.dict.service.ResourceDefinitionRepoService

+import org.springframework.stereotype.Service

 

 /**

  * ResourceAssignmentEnhancerService.

@@ -47,6 +50,7 @@ interface ResourceAssignmentEnhancerService {
  *

  * @author Brinda Santh

  */

+@Service

 open class ResourceAssignmentEnhancerDefaultService(private val resourceDefinitionRepoService: ResourceDefinitionRepoService)

     : ResourceAssignmentEnhancerService {

     private val log: EELFLogger = EELFManager.getInstance().getLogger(ResourceAssignmentValidationDefaultService::class.java)

@@ -58,20 +62,41 @@ open class ResourceAssignmentEnhancerDefaultService(private val resourceDefiniti
     override fun enhanceBluePrint(bluePrintEnhancerService: BluePrintEnhancerService,

                                   resourceAssignments: List<ResourceAssignment>) {

 

+        val uniqueSourceNodeTypeNames = hashSetOf<String>()

+

         // Iterate the Resource Assignment and

         resourceAssignments.map { resourceAssignment ->

             val dictionaryName = resourceAssignment.dictionaryName!!

             val dictionarySource = resourceAssignment.dictionarySource!!

-            log.info("Enriching Assignment name({}), dictionary name({}), source({})", resourceAssignment.name,

+            log.debug("Enriching Assignment name({}), dictionary name({}), source({})", resourceAssignment.name,

                     dictionaryName, dictionarySource)

-            // Get the Resource Definition from Repo

-            val resourceDefinition: ResourceDefinition = getResourceDefinition(dictionaryName)

+            val sourceNodeTypeName = ResourceSourceMappingFactory.getRegisterSourceMapping(dictionarySource)

+

+            // Add Unique Node Types

+            uniqueSourceNodeTypeNames.add(sourceNodeTypeName)

+

+            // TODO("Candidate for Optimisation")

+            if (checkResourceDefinitionNeeded(resourceAssignment)) {

+

+                bluePrintEnhancerService.enrichPropertyDefinition(resourceAssignment.name, resourceAssignment.property!!);

+

+                // Get the Resource Definition from Repo

+                val resourceDefinition: ResourceDefinition = getResourceDefinition(dictionaryName)

 

-            val sourceNodeTemplate = resourceDefinition.sources.get(dictionarySource)

+                val sourceNodeTemplate = resourceDefinition.sources.get(dictionarySource)

+                        ?: throw BluePrintException(format("failed to get assigned dictionarySource({}) from resourceDefinition({})", dictionarySource, dictionaryName))

 

-            // Enrich as NodeTemplate

-            bluePrintEnhancerService.enrichNodeTemplate(dictionarySource, sourceNodeTemplate!!)

+                // Enrich as NodeTemplate

+                bluePrintEnhancerService.enrichNodeTemplate(dictionarySource, sourceNodeTemplate)

+            }

         }

+        // Enrich the ResourceSource NodeTypes

+        uniqueSourceNodeTypeNames.map { nodeTypeName ->

+            resourceDefinitionRepoService.getNodeType(nodeTypeName).subscribe { nodeType ->

+                bluePrintEnhancerService.enrichNodeType(nodeTypeName, nodeType)

+            }

+        }

+

     }

 

     override fun enhanceBluePrint(resourceAssignments: List<ResourceAssignment>): ServiceTemplate {

@@ -82,7 +107,14 @@ open class ResourceAssignmentEnhancerDefaultService(private val resourceDefiniti
         return bluePrintEnhancerService.serviceTemplate

     }

 

+    private fun checkResourceDefinitionNeeded(resourceAssignment: ResourceAssignment): Boolean {

+        return !((resourceAssignment.dictionarySource.equals(ResourceDictionaryConstants.SOURCE_INPUT)

+                || resourceAssignment.dictionarySource.equals(ResourceDictionaryConstants.SOURCE_DEFAULT))

+                && BluePrintTypes.validPrimitiveOrCollectionPrimitive(resourceAssignment.property!!))

+    }

+

     private fun getResourceDefinition(name: String): ResourceDefinition {

-        return resourceDefinitionRepoService.getResourceDefinition(name).block()!!

+        return resourceDefinitionRepoService.getResourceDefinition(name).block()

+                ?: throw BluePrintException(format("failed to get dictionary definition({})", name))

     }

 }
\ No newline at end of file