From 5eebfaa6ac0d4cb4fdf20d19ead7cd0303fc6f29 Mon Sep 17 00:00:00 2001 From: "Muthuramalingam, Brinda Santh(bs2796)" Date: Thu, 13 Sep 2018 00:20:34 +0000 Subject: 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) --- .../service/BluePrintEnhancerService.java | 23 +- .../service/BluePrintRepoDBService.java | 97 -------- .../service/ResourceDefinitionRepoDBService.java | 115 +++++++++ .../service/enhancer/BluePrintEnhancerService.kt | 272 +++++++++++++++++++++ .../enhancer/ResourceAssignmentEnhancerService.kt | 50 +++- 5 files changed, 442 insertions(+), 115 deletions(-) delete mode 100644 ms/controllerblueprints/modules/service/src/main/java/org/onap/ccsdk/apps/controllerblueprints/service/BluePrintRepoDBService.java create mode 100644 ms/controllerblueprints/modules/service/src/main/java/org/onap/ccsdk/apps/controllerblueprints/service/ResourceDefinitionRepoDBService.java create mode 100644 ms/controllerblueprints/modules/service/src/main/kotlin/org/onap/ccsdk/apps/controllerblueprints/service/enhancer/BluePrintEnhancerService.kt (limited to 'ms/controllerblueprints/modules/service/src/main') diff --git a/ms/controllerblueprints/modules/service/src/main/java/org/onap/ccsdk/apps/controllerblueprints/service/BluePrintEnhancerService.java b/ms/controllerblueprints/modules/service/src/main/java/org/onap/ccsdk/apps/controllerblueprints/service/BluePrintEnhancerService.java index 8e98f947..ef3b4a48 100644 --- a/ms/controllerblueprints/modules/service/src/main/java/org/onap/ccsdk/apps/controllerblueprints/service/BluePrintEnhancerService.java +++ b/ms/controllerblueprints/modules/service/src/main/java/org/onap/ccsdk/apps/controllerblueprints/service/BluePrintEnhancerService.java @@ -25,12 +25,13 @@ import org.jetbrains.annotations.NotNull; import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintException; import org.onap.ccsdk.apps.controllerblueprints.core.ConfigModelConstant; import org.onap.ccsdk.apps.controllerblueprints.core.data.*; -import org.onap.ccsdk.apps.controllerblueprints.core.service.BluePrintEnhancerDefaultService; -import org.onap.ccsdk.apps.controllerblueprints.core.service.BluePrintRepoService; +import org.onap.ccsdk.apps.controllerblueprints.resource.dict.service.ResourceDefinitionRepoService; +import org.onap.ccsdk.apps.controllerblueprints.service.enhancer.BluePrintEnhancerDefaultService; import org.onap.ccsdk.apps.controllerblueprints.core.utils.JacksonUtils; import org.onap.ccsdk.apps.controllerblueprints.resource.dict.ResourceAssignment; import com.att.eelf.configuration.EELFLogger; import com.att.eelf.configuration.EELFManager; +import org.onap.ccsdk.apps.controllerblueprints.service.enhancer.ResourceAssignmentEnhancerService; import org.springframework.stereotype.Service; import java.util.HashMap; @@ -48,14 +49,18 @@ public class BluePrintEnhancerService extends BluePrintEnhancerDefaultService { private static EELFLogger log = EELFManager.getInstance().getLogger(BluePrintEnhancerService.class); + private ResourceAssignmentEnhancerService resourceAssignmentEnhancerService; + private Map recipeDataTypes = new HashMap<>(); - public BluePrintEnhancerService(BluePrintRepoService bluePrintEnhancerRepoDBService) { - super(bluePrintEnhancerRepoDBService); + public BluePrintEnhancerService(ResourceDefinitionRepoService resourceDefinitionRepoService, + ResourceAssignmentEnhancerService resourceAssignmentEnhancerService) { + super(resourceDefinitionRepoService); + this.resourceAssignmentEnhancerService = resourceAssignmentEnhancerService; } @Override - public void enrichTopologyTemplate(@NotNull ServiceTemplate serviceTemplate) throws BluePrintException{ + public void enrichTopologyTemplate(@NotNull ServiceTemplate serviceTemplate) throws BluePrintException { super.enrichTopologyTemplate(serviceTemplate); // Update the Recipe Inputs and DataTypes @@ -101,7 +106,7 @@ public class BluePrintEnhancerService extends BluePrintEnhancerDefaultService { // Modified for ONAP converted Object to JsonNode JsonNode recipeNames = nodeTemplate.getProperties().get(ConfigModelConstant.PROPERTY_RECIPE_NAMES); - log.info("Processing Receipe Names : {} ", recipeNames); + log.info("Processing Recipe Names : {} ", recipeNames); if (recipeNames != null && recipeNames.isArray() && recipeNames.size() > 0) { @@ -159,6 +164,9 @@ public class BluePrintEnhancerService extends BluePrintEnhancerDefaultService { JacksonUtils.getListFromJson(resourceAssignmentContent, ResourceAssignment.class); Preconditions.checkNotNull(resourceAssignments, "Failed to Processing Resource Mapping " + resourceAssignmentContent); + // Enhance Resource Assignment + resourceAssignmentEnhancerService.enhanceBluePrint(this, resourceAssignments); + dataTypeProperties = new HashMap<>(); for (ResourceAssignment resourceAssignment : resourceAssignments) { @@ -167,9 +175,6 @@ public class BluePrintEnhancerService extends BluePrintEnhancerDefaultService { && resourceAssignment.getProperty() != null && StringUtils.isNotBlank(resourceAssignment.getName())) { - // Enrich the Property Definition - super.enrichPropertyDefinition(resourceAssignment.getName(), resourceAssignment.getProperty()); - dataTypeProperties.put(resourceAssignment.getName(), resourceAssignment.getProperty()); } diff --git a/ms/controllerblueprints/modules/service/src/main/java/org/onap/ccsdk/apps/controllerblueprints/service/BluePrintRepoDBService.java b/ms/controllerblueprints/modules/service/src/main/java/org/onap/ccsdk/apps/controllerblueprints/service/BluePrintRepoDBService.java deleted file mode 100644 index 5510e480..00000000 --- a/ms/controllerblueprints/modules/service/src/main/java/org/onap/ccsdk/apps/controllerblueprints/service/BluePrintRepoDBService.java +++ /dev/null @@ -1,97 +0,0 @@ -/* - * 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; - -import com.fasterxml.jackson.databind.JsonNode; -import com.google.common.base.Preconditions; -import org.apache.commons.lang3.StringUtils; -import org.jetbrains.annotations.NotNull; -import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintException; -import org.onap.ccsdk.apps.controllerblueprints.core.data.*; -import org.onap.ccsdk.apps.controllerblueprints.core.service.BluePrintRepoService; -import org.onap.ccsdk.apps.controllerblueprints.core.utils.JacksonUtils; -import org.onap.ccsdk.apps.controllerblueprints.service.domain.ModelType; -import org.onap.ccsdk.apps.controllerblueprints.service.repository.ModelTypeRepository; -import org.springframework.stereotype.Service; -import reactor.core.publisher.Mono; - -import java.util.Optional; - -/** - * BluePrintRepoDBService - * - * @author Brinda Santh - */ -@Service -@SuppressWarnings("unused") -public class BluePrintRepoDBService implements BluePrintRepoService { - - private ModelTypeRepository modelTypeRepository; - @SuppressWarnings("unused") - public BluePrintRepoDBService(ModelTypeRepository modelTypeRepository) { - this.modelTypeRepository = modelTypeRepository; - } - - @Override - public Mono getNodeType(@NotNull String nodeTypeName) throws BluePrintException { - return getModelType(nodeTypeName, NodeType.class); - } - - @Override - public Mono getDataType(@NotNull String dataTypeName) throws BluePrintException { - return getModelType(dataTypeName, DataType.class); - } - - @Override - public Mono getArtifactType(@NotNull String artifactTypeName) throws BluePrintException { - return getModelType(artifactTypeName, ArtifactType.class); - } - - @Override - public Mono getRelationshipType(@NotNull String relationshipTypeName) throws BluePrintException { - return getModelType(relationshipTypeName, RelationshipType.class); - } - - @Override - public Mono getCapabilityDefinition(@NotNull String capabilityDefinitionName) throws BluePrintException { - return getModelType(capabilityDefinitionName, CapabilityDefinition.class); - } - - private Mono getModelType(String modelName, Class valueClass) throws BluePrintException { - Preconditions.checkArgument(StringUtils.isNotBlank(modelName), - "Failed to get model from repo, model name is missing"); - - return getModelDefinition(modelName).map(modelDefinition -> { - Preconditions.checkNotNull(modelDefinition, - String.format("Failed to get model content for model name (%s)", modelName)); - return JacksonUtils.readValue(modelDefinition, valueClass); - } - ); - } - - private Mono getModelDefinition(String modelName) throws BluePrintException { - JsonNode modelDefinition; - Optional modelTypeDb = modelTypeRepository.findByModelName(modelName); - if (modelTypeDb.isPresent()) { - modelDefinition = modelTypeDb.get().getDefinition(); - } else { - throw new BluePrintException(String.format("failed to get model definition (%s) from repo", modelName)); - } - return Mono.just(modelDefinition); - } -} diff --git a/ms/controllerblueprints/modules/service/src/main/java/org/onap/ccsdk/apps/controllerblueprints/service/ResourceDefinitionRepoDBService.java b/ms/controllerblueprints/modules/service/src/main/java/org/onap/ccsdk/apps/controllerblueprints/service/ResourceDefinitionRepoDBService.java new file mode 100644 index 00000000..16cc8415 --- /dev/null +++ b/ms/controllerblueprints/modules/service/src/main/java/org/onap/ccsdk/apps/controllerblueprints/service/ResourceDefinitionRepoDBService.java @@ -0,0 +1,115 @@ +/* + * 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; + +import com.fasterxml.jackson.databind.JsonNode; +import com.google.common.base.Preconditions; +import org.apache.commons.lang3.StringUtils; +import org.jetbrains.annotations.NotNull; +import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintException; +import org.onap.ccsdk.apps.controllerblueprints.core.data.*; +import org.onap.ccsdk.apps.controllerblueprints.core.utils.JacksonUtils; +import org.onap.ccsdk.apps.controllerblueprints.resource.dict.ResourceDefinition; +import org.onap.ccsdk.apps.controllerblueprints.resource.dict.service.ResourceDefinitionRepoService; +import org.onap.ccsdk.apps.controllerblueprints.service.domain.ModelType; +import org.onap.ccsdk.apps.controllerblueprints.service.domain.ResourceDictionary; +import org.onap.ccsdk.apps.controllerblueprints.service.repository.ModelTypeRepository; +import org.onap.ccsdk.apps.controllerblueprints.service.repository.ResourceDictionaryRepository; +import org.springframework.stereotype.Service; +import reactor.core.publisher.Mono; + +import java.util.Optional; + +/** + * ResourceDefinitionRepoDBService + * + * @author Brinda Santh + */ +@Service +@SuppressWarnings("unused") +public class ResourceDefinitionRepoDBService implements ResourceDefinitionRepoService { + + private ModelTypeRepository modelTypeRepository; + private ResourceDictionaryRepository resourceDictionaryRepository; + + @SuppressWarnings("unused") + public ResourceDefinitionRepoDBService(ModelTypeRepository modelTypeRepository, + ResourceDictionaryRepository resourceDictionaryRepository) { + this.modelTypeRepository = modelTypeRepository; + this.resourceDictionaryRepository = resourceDictionaryRepository; + } + + @Override + public Mono getNodeType(@NotNull String nodeTypeName) throws BluePrintException { + return getModelType(nodeTypeName, NodeType.class); + } + + @Override + public Mono getDataType(@NotNull String dataTypeName) throws BluePrintException { + return getModelType(dataTypeName, DataType.class); + } + + @Override + public Mono getArtifactType(@NotNull String artifactTypeName) throws BluePrintException { + return getModelType(artifactTypeName, ArtifactType.class); + } + + @Override + public Mono getRelationshipType(@NotNull String relationshipTypeName) throws BluePrintException { + return getModelType(relationshipTypeName, RelationshipType.class); + } + + @Override + public Mono getCapabilityDefinition(@NotNull String capabilityDefinitionName) throws BluePrintException { + return getModelType(capabilityDefinitionName, CapabilityDefinition.class); + } + + @NotNull + @Override + public Mono getResourceDefinition(@NotNull String resourceDefinitionName) throws BluePrintException{ + Optional dbResourceDictionary = resourceDictionaryRepository.findByName(resourceDefinitionName); + if(dbResourceDictionary.isPresent()){ + return Mono.just(dbResourceDictionary.get().getDefinition()); + }else{ + throw new BluePrintException(String.format("failed to get resource dictionary (%s) from repo", resourceDefinitionName)); + } + } + + private Mono getModelType(String modelName, Class valueClass) throws BluePrintException { + Preconditions.checkArgument(StringUtils.isNotBlank(modelName), + "Failed to get model from repo, model name is missing"); + + return getModelDefinition(modelName).map(modelDefinition -> { + Preconditions.checkNotNull(modelDefinition, + String.format("Failed to get model content for model name (%s)", modelName)); + return JacksonUtils.readValue(modelDefinition, valueClass); + } + ); + } + + private Mono getModelDefinition(String modelName) throws BluePrintException { + JsonNode modelDefinition; + Optional modelTypeDb = modelTypeRepository.findByModelName(modelName); + if (modelTypeDb.isPresent()) { + modelDefinition = modelTypeDb.get().getDefinition(); + } else { + throw new BluePrintException(String.format("failed to get model definition (%s) from repo", modelName)); + } + return Mono.just(modelDefinition); + } +} 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) { + + 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) { + val uniqueSourceNodeTypeNames = hashSetOf() + // 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): 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 -- cgit 1.2.3-korg