2 * Copyright © 2017-2018 AT&T Intellectual Property.
\r
3 * Modifications Copyright © 2018 IBM.
\r
5 * Licensed under the Apache License, Version 2.0 (the "License");
\r
6 * you may not use this file except in compliance with the License.
\r
7 * You may obtain a copy of the License at
\r
9 * http://www.apache.org/licenses/LICENSE-2.0
\r
11 * Unless required by applicable law or agreed to in writing, software
\r
12 * distributed under the License is distributed on an "AS IS" BASIS,
\r
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
\r
14 * See the License for the specific language governing permissions and
\r
15 * limitations under the License.
\r
18 package org.onap.ccsdk.apps.blueprintsprocessor.functions.resource.resolution
\r
20 import org.onap.ccsdk.apps.blueprintsprocessor.functions.resource.resolution.processor.ResourceAssignmentProcessor
\r
21 import org.onap.ccsdk.apps.blueprintsprocessor.functions.resource.resolution.utils.ResourceAssignmentUtils
\r
22 import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintConstants
\r
23 import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintProcessorException
\r
24 import org.onap.ccsdk.apps.controllerblueprints.core.service.BluePrintRuntimeService
\r
25 import org.onap.ccsdk.apps.controllerblueprints.core.utils.JacksonUtils
\r
26 import org.onap.ccsdk.apps.controllerblueprints.resource.dict.ResourceAssignment
\r
27 import org.onap.ccsdk.apps.controllerblueprints.resource.dict.ResourceDefinition
\r
28 import org.onap.ccsdk.apps.controllerblueprints.resource.dict.utils.BulkResourceSequencingUtils
\r
29 import org.slf4j.LoggerFactory
\r
30 import org.springframework.beans.factory.annotation.Autowired
\r
31 import org.springframework.context.ApplicationContext
\r
32 import org.springframework.stereotype.Service
\r
36 * ResourceResolutionService
\r
37 * @author Brinda Santh
\r
42 class ResourceResolutionService {
\r
44 private val log = LoggerFactory.getLogger(ResourceResolutionService::class.java)
\r
47 private lateinit var applicationContext: ApplicationContext
\r
49 fun registeredResourceSources(): List<String> {
\r
50 return applicationContext.getBeanNamesForType(ResourceAssignmentProcessor::class.java)
\r
51 .filter { it.startsWith(ResourceResolutionConstants.PREFIX_RESOURCE_ASSIGNMENT_PROCESSOR) }
\r
52 .map { it.substringAfter(ResourceResolutionConstants.PREFIX_RESOURCE_ASSIGNMENT_PROCESSOR) }
\r
56 fun resolveResources(bluePrintRuntimeService: BluePrintRuntimeService<*>, nodeTemplateName: String,
\r
57 artifactNames: List<String>): MutableMap<String, String> {
\r
59 val resolvedParams: MutableMap<String, String> = hashMapOf()
\r
60 artifactNames.forEach { artifactName ->
\r
61 val resolvedContent = resolveResources(bluePrintRuntimeService, nodeTemplateName, artifactName)
\r
62 resolvedParams[artifactName] = resolvedContent
\r
64 return resolvedParams
\r
68 fun resolveResources(bluePrintRuntimeService: BluePrintRuntimeService<*>, nodeTemplateName: String, artifactName: String): String {
\r
70 var resolvedContent = ""
\r
71 // Velocity Artifact Definition Name
\r
72 val templateArtifactName = "$artifactName-template"
\r
73 // Resource Assignment Artifact Definition Name
\r
74 val mappingArtifactName = "$artifactName-mapping"
\r
76 log.info("Resolving resource for template artifact($templateArtifactName) with resource assignment artifact($mappingArtifactName)")
\r
78 val resourceAssignmentContent = bluePrintRuntimeService.resolveNodeTemplateArtifact(nodeTemplateName, mappingArtifactName)
\r
80 val resourceAssignments: MutableList<ResourceAssignment> = JacksonUtils.getListFromJson(resourceAssignmentContent, ResourceAssignment::class.java)
\r
81 as? MutableList<ResourceAssignment>
\r
82 ?: throw BluePrintProcessorException("couldn't get Dictionary Definitions")
\r
84 // Get the Resource Dictionary Name
\r
85 val dictionaryFile = bluePrintRuntimeService.bluePrintContext().rootPath.plus(File.separator)
\r
86 .plus(BluePrintConstants.TOSCA_DEFINITIONS_DIR).plus(File.separator)
\r
87 .plus(ResourceResolutionConstants.FILE_NAME_RESOURCE_DEFINITION_TYPES)
\r
89 val resourceDictionaries: MutableMap<String, ResourceDefinition> = JacksonUtils.getMapFromFile(dictionaryFile, ResourceDefinition::class.java)
\r
90 ?: throw BluePrintProcessorException("couldn't get Dictionary Definitions")
\r
92 executeProcessors(bluePrintRuntimeService, resourceDictionaries, resourceAssignments, templateArtifactName)
\r
94 // Check Template is there
\r
95 val templateContent = bluePrintRuntimeService.resolveNodeTemplateArtifact(nodeTemplateName, mappingArtifactName)
\r
97 // TODO ("Generate Param JSON from Resource Assignment")
\r
98 val resolvedParamJsonContent = "{}"
\r
100 if (templateContent.isNotEmpty()) {
\r
101 // TODO ( "Mash Data and Content")
\r
102 resolvedContent = "Mashed Content"
\r
105 resolvedContent = resolvedParamJsonContent
\r
107 return resolvedContent
\r
111 private fun executeProcessors(blueprintRuntimeService: BluePrintRuntimeService<*>,
\r
112 resourceDictionaries: MutableMap<String, ResourceDefinition>,
\r
113 resourceAssignments: MutableList<ResourceAssignment>,
\r
114 templateArtifactName: String) {
\r
116 val bulkSequenced = BulkResourceSequencingUtils.process(resourceAssignments)
\r
117 val resourceAssignmentRuntimeService = ResourceAssignmentUtils.transformToRARuntimeService(blueprintRuntimeService, templateArtifactName)
\r
119 bulkSequenced.map { batchResourceAssignments ->
\r
120 batchResourceAssignments.filter { it.name != "*" && it.name != "start" }
\r
121 .map { resourceAssignment ->
\r
122 val dictionarySource = resourceAssignment.dictionarySource
\r
123 val processorInstanceName = ResourceResolutionConstants.PREFIX_RESOURCE_ASSIGNMENT_PROCESSOR.plus(dictionarySource)
\r
125 val resourceAssignmentProcessor = applicationContext.getBean(processorInstanceName) as? ResourceAssignmentProcessor
\r
126 ?: throw BluePrintProcessorException("failed to get resource processor for instance name($processorInstanceName) " +
\r
127 "for resource assignment(${resourceAssignment.name})")
\r
129 // Set BluePrint Runtime Service
\r
130 resourceAssignmentProcessor.raRuntimeService = resourceAssignmentRuntimeService
\r
131 // Set Resource Dictionaries
\r
132 resourceAssignmentProcessor.resourceDictionaries = resourceDictionaries
\r
133 // Invoke Apply Method
\r
134 resourceAssignmentProcessor.apply(resourceAssignment)
\r
135 } catch (e: RuntimeException) {
\r
136 resourceAssignmentProcessor.recover(e, resourceAssignment)
\r
137 throw BluePrintProcessorException(e)
\r