[ccsdk/cds.git] /

/*\r
 *  Copyright © 2017-2018 AT&T Intellectual Property.\r
 *  Modifications Copyright © 2018 IBM.\r
 *\r
 *  Licensed under the Apache License, Version 2.0 (the "License");\r
 *  you may not use this file except in compliance with the License.\r
 *  You may obtain a copy of the License at\r
 *\r
 *      http://www.apache.org/licenses/LICENSE-2.0\r
 *\r
 *  Unless required by applicable law or agreed to in writing, software\r
 *  distributed under the License is distributed on an "AS IS" BASIS,\r
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
 *  See the License for the specific language governing permissions and\r
 *  limitations under the License.\r
 */\r
\r
package org.onap.ccsdk.apps.blueprintsprocessor.functions.resource.resolution\r
\r
import com.fasterxml.jackson.databind.node.JsonNodeFactory
import org.onap.ccsdk.apps.blueprintsprocessor.functions.resource.resolution.processor.ResourceAssignmentProcessor\r
import org.onap.ccsdk.apps.blueprintsprocessor.functions.resource.resolution.utils.ResourceAssignmentUtils\r
import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintConstants\r
import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintProcessorException\r
import org.onap.ccsdk.apps.controllerblueprints.core.service.BluePrintRuntimeService\r
import org.onap.ccsdk.apps.controllerblueprints.core.service.BluePrintTemplateService
import org.onap.ccsdk.apps.controllerblueprints.core.utils.JacksonUtils\r
import org.onap.ccsdk.apps.controllerblueprints.resource.dict.ResourceAssignment\r
import org.onap.ccsdk.apps.controllerblueprints.resource.dict.ResourceDefinition\r
import org.onap.ccsdk.apps.controllerblueprints.resource.dict.utils.BulkResourceSequencingUtils\r
import org.slf4j.LoggerFactory\r
import org.springframework.beans.factory.annotation.Autowired\r
import org.springframework.context.ApplicationContext\r
import org.springframework.stereotype.Service\r
import java.io.File\r
\r
/**\r
 * ResourceResolutionService\r
 * @author Brinda Santh\r
 * 8/14/2018\r
 */\r
\r
@Service\r
class ResourceResolutionService {\r
\r
    private val log = LoggerFactory.getLogger(ResourceResolutionService::class.java)\r
\r
    @Autowired\r
    private lateinit var applicationContext: ApplicationContext\r
\r
    fun registeredResourceSources(): List<String> {\r
        return applicationContext.getBeanNamesForType(ResourceAssignmentProcessor::class.java)\r
                .filter { it.startsWith(ResourceResolutionConstants.PREFIX_RESOURCE_ASSIGNMENT_PROCESSOR) }\r
                .map { it.substringAfter(ResourceResolutionConstants.PREFIX_RESOURCE_ASSIGNMENT_PROCESSOR) }\r
    }\r
\r
\r
    fun resolveResources(bluePrintRuntimeService: BluePrintRuntimeService<*>, nodeTemplateName: String,\r
                         artifactNames: List<String>): MutableMap<String, String> {\r
\r
        val resolvedParams: MutableMap<String, String> = hashMapOf()\r
        artifactNames.forEach { artifactName ->\r
            val resolvedContent = resolveResources(bluePrintRuntimeService, nodeTemplateName, artifactName)\r
            resolvedParams[artifactName] = resolvedContent\r
        }\r
        return resolvedParams\r
    }\r
\r
\r
    fun resolveResources(bluePrintRuntimeService: BluePrintRuntimeService<*>, nodeTemplateName: String, artifactName: String): String {\r
\r
        var resolvedContent = ""\r
        // Velocity Artifact Definition Name\r
        val templateArtifactName = "$artifactName-template"\r
        // Resource Assignment Artifact Definition Name\r
        val mappingArtifactName = "$artifactName-mapping"\r
\r
        log.info("Resolving resource for template artifact($templateArtifactName) with resource assignment artifact($mappingArtifactName)")\r
\r
        val resourceAssignmentContent = bluePrintRuntimeService.resolveNodeTemplateArtifact(nodeTemplateName, mappingArtifactName)\r
\r
        val resourceAssignments: MutableList<ResourceAssignment> = JacksonUtils.getListFromJson(resourceAssignmentContent, ResourceAssignment::class.java)\r
                as? MutableList<ResourceAssignment>\r
                ?: throw BluePrintProcessorException("couldn't get Dictionary Definitions")\r
\r
        // Get the Resource Dictionary Name\r
        val dictionaryFile = bluePrintRuntimeService.bluePrintContext().rootPath.plus(File.separator)\r
                .plus(BluePrintConstants.TOSCA_DEFINITIONS_DIR).plus(File.separator)\r
                .plus(ResourceResolutionConstants.FILE_NAME_RESOURCE_DEFINITION_TYPES)\r
\r
        val resourceDictionaries: MutableMap<String, ResourceDefinition> = JacksonUtils.getMapFromFile(dictionaryFile, ResourceDefinition::class.java)\r
                ?: throw BluePrintProcessorException("couldn't get Dictionary Definitions")\r
\r
        // Resolve resources
        executeProcessors(bluePrintRuntimeService, resourceDictionaries, resourceAssignments, templateArtifactName)\r
\r
        // Check Template is there\r
        val templateContent = bluePrintRuntimeService.resolveNodeTemplateArtifact(nodeTemplateName, templateArtifactName)
\r
        val resolvedParamJsonContent = ResourceAssignmentUtils.generateResourceDataForAssignments(resourceAssignments.toList())
\r
        if (templateContent.isNotEmpty()) {\r
            resolvedContent = BluePrintTemplateService.generateContent(templateContent, resolvedParamJsonContent)
        } else {\r
            resolvedContent = resolvedParamJsonContent\r
        }\r
        return resolvedContent\r
    }\r
\r
    private fun executeProcessors(blueprintRuntimeService: BluePrintRuntimeService<*>,\r
                                  resourceDictionaries: MutableMap<String, ResourceDefinition>,\r
                                  resourceAssignments: MutableList<ResourceAssignment>,\r
                                  templateArtifactName: String) {\r
\r
        val bulkSequenced = BulkResourceSequencingUtils.process(resourceAssignments)\r
        val resourceAssignmentRuntimeService = ResourceAssignmentUtils.transformToRARuntimeService(blueprintRuntimeService, templateArtifactName)\r
\r
        bulkSequenced.map { batchResourceAssignments ->\r
            batchResourceAssignments.filter { it.name != "*" && it.name != "start" }\r
                    .map { resourceAssignment ->\r
                        val dictionarySource = resourceAssignment.dictionarySource\r
                        val processorInstanceName = ResourceResolutionConstants.PREFIX_RESOURCE_ASSIGNMENT_PROCESSOR.plus(dictionarySource)\r
\r
                        val resourceAssignmentProcessor = applicationContext.getBean(processorInstanceName) as? ResourceAssignmentProcessor\r
                                ?: throw BluePrintProcessorException("failed to get resource processor for instance name($processorInstanceName) " +\r
                                        "for resource assignment(${resourceAssignment.name})")\r
                        try {\r
                            // Set BluePrint Runtime Service\r
                            resourceAssignmentProcessor.raRuntimeService = resourceAssignmentRuntimeService\r
                            // Set Resource Dictionaries\r
                            resourceAssignmentProcessor.resourceDictionaries = resourceDictionaries\r
                            // Invoke Apply Method\r
                            resourceAssignmentProcessor.apply(resourceAssignment)\r
                        } catch (e: RuntimeException) {\r
                            resourceAssignmentProcessor.recover(e, resourceAssignment)\r
                            throw BluePrintProcessorException(e)\r
                        }\r
                    }\r
        }\r
    }\r
\r
}\r