gerrit.onap Code Review - ccsdk/cds.git/blob

   1 /*\r
   2  *  Copyright © 2017-2018 AT&T Intellectual Property.\r
   3  *  Modifications Copyright © 2018 IBM.\r
   4  *\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
   8  *\r
   9  *      http://www.apache.org/licenses/LICENSE-2.0\r
  10  *\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
  16  */\r
  17 \r
  18 package org.onap.ccsdk.apps.blueprintsprocessor.functions.resource.resolution\r
  19 \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.service.BluePrintTemplateService
  26 import org.onap.ccsdk.apps.controllerblueprints.core.utils.JacksonUtils\r
  27 import org.onap.ccsdk.apps.controllerblueprints.resource.dict.ResourceAssignment\r
  28 import org.onap.ccsdk.apps.controllerblueprints.resource.dict.ResourceDefinition\r
  29 import org.onap.ccsdk.apps.controllerblueprints.resource.dict.utils.BulkResourceSequencingUtils\r
  30 import org.slf4j.LoggerFactory\r
  31 import org.springframework.context.ApplicationContext\r
  32 import org.springframework.stereotype.Service\r
  33 import java.io.File\r
  34 \r
  35 interface ResourceResolutionService {
  36
  37     fun registeredResourceSources(): List<String>
  38
  39     fun resolveResources(bluePrintRuntimeService: BluePrintRuntimeService<*>, nodeTemplateName: String,
  40                          artifactNames: List<String>): MutableMap<String, String>
  41
  42     fun resolveResources(bluePrintRuntimeService: BluePrintRuntimeService<*>, nodeTemplateName: String,
  43                          artifactPrefix: String): String
  44
  45     fun resolveResources(bluePrintRuntimeService: BluePrintRuntimeService<*>, nodeTemplateName: String,
  46                          artifactMapping: String, artifactTemplate: String?): String
  47
  48     fun resolveResourceAssignments(blueprintRuntimeService: BluePrintRuntimeService<*>,
  49                                    resourceDictionaries: MutableMap<String, ResourceDefinition>,
  50                                    resourceAssignments: MutableList<ResourceAssignment>,
  51                                    identifierName: String)
  52 }
  53 \r
  54 @Service\r
  55 open class ResourceResolutionServiceImpl(private var applicationContext: ApplicationContext) :
  56         ResourceResolutionService {
  57 \r
  58     private val log = LoggerFactory.getLogger(ResourceResolutionService::class.java)\r
  59 \r
  60     override fun registeredResourceSources(): List<String> {
  61         return applicationContext.getBeanNamesForType(ResourceAssignmentProcessor::class.java)\r
  62                 .filter { it.startsWith(ResourceResolutionConstants.PREFIX_RESOURCE_ASSIGNMENT_PROCESSOR) }\r
  63                 .map { it.substringAfter(ResourceResolutionConstants.PREFIX_RESOURCE_ASSIGNMENT_PROCESSOR) }\r
  64     }\r
  65 \r
  66     override fun resolveResources(bluePrintRuntimeService: BluePrintRuntimeService<*>, nodeTemplateName: String,
  67                                   artifactNames: List<String>): MutableMap<String, String> {
  68 \r
  69         val resolvedParams: MutableMap<String, String> = hashMapOf()\r
  70         artifactNames.forEach { artifactName ->\r
  71             val resolvedContent = resolveResources(bluePrintRuntimeService, nodeTemplateName, artifactName)\r
  72             resolvedParams[artifactName] = resolvedContent\r
  73         }\r
  74         return resolvedParams\r
  75     }\r
  76 \r
  77     override fun resolveResources(bluePrintRuntimeService: BluePrintRuntimeService<*>, nodeTemplateName: String,
  78                                   artifactPrefix: String): String {
  79 \r
  80         // Velocity Artifact Definition Name\r
  81         val artifactTemplate = "$artifactPrefix-template"
  82         // Resource Assignment Artifact Definition Name\r
  83         val artifactMapping = "$artifactPrefix-mapping"
  84
  85         return resolveResources(bluePrintRuntimeService, nodeTemplateName, artifactMapping, artifactTemplate)
  86     }
  87
  88 \r
  89     override fun resolveResources(bluePrintRuntimeService: BluePrintRuntimeService<*>, nodeTemplateName: String,
  90                                   artifactMapping: String, artifactTemplate: String?): String {
  91 \r
  92         var resolvedContent = ""
  93         log.info("Resolving resource for template artifact($artifactTemplate) with resource assignment artifact($artifactMapping)")
  94
  95         val identifierName = artifactTemplate ?: "no-template"
  96
  97         val resourceAssignmentContent = bluePrintRuntimeService.resolveNodeTemplateArtifact(nodeTemplateName, artifactMapping)
  98 \r
  99         val resourceAssignments: MutableList<ResourceAssignment> = JacksonUtils.getListFromJson(resourceAssignmentContent, ResourceAssignment::class.java)\r
 100                 as? MutableList<ResourceAssignment>\r
 101                 ?: throw BluePrintProcessorException("couldn't get Dictionary Definitions")\r
 102 \r
 103         // Get the Resource Dictionary Name\r
 104         val dictionaryFile = bluePrintRuntimeService.bluePrintContext().rootPath.plus(File.separator)\r
 105                 .plus(BluePrintConstants.TOSCA_DEFINITIONS_DIR).plus(File.separator)\r
 106                 .plus(ResourceResolutionConstants.FILE_NAME_RESOURCE_DEFINITION_TYPES)\r
 107 \r
 108         val resourceDictionaries: MutableMap<String, ResourceDefinition> = JacksonUtils.getMapFromFile(dictionaryFile, ResourceDefinition::class.java)\r
 109                 ?: throw BluePrintProcessorException("couldn't get Dictionary Definitions")\r
 110 \r
 111         // Resolve resources
 112         resolveResourceAssignments(bluePrintRuntimeService, resourceDictionaries, resourceAssignments, identifierName)
 113 \r
 114         val resolvedParamJsonContent = ResourceAssignmentUtils.generateResourceDataForAssignments(resourceAssignments.toList())
 115 \r
 116         // Check Template is there
 117         if (artifactTemplate != null) {
 118             val templateContent = bluePrintRuntimeService.resolveNodeTemplateArtifact(nodeTemplateName, artifactTemplate)
 119             resolvedContent = BluePrintTemplateService.generateContent(templateContent, resolvedParamJsonContent)
 120         } else {\r
 121             resolvedContent = resolvedParamJsonContent\r
 122         }\r
 123         return resolvedContent\r
 124     }\r
 125 \r
 126     override fun resolveResourceAssignments(blueprintRuntimeService: BluePrintRuntimeService<*>,
 127                                             resourceDictionaries: MutableMap<String, ResourceDefinition>,
 128                                             resourceAssignments: MutableList<ResourceAssignment>,
 129                                             identifierName: String) {
 130 \r
 131         val bulkSequenced = BulkResourceSequencingUtils.process(resourceAssignments)\r
 132         val resourceAssignmentRuntimeService = ResourceAssignmentUtils.transformToRARuntimeService(blueprintRuntimeService, identifierName)
 133 \r
 134         bulkSequenced.map { batchResourceAssignments ->\r
 135             batchResourceAssignments.filter { it.name != "*" && it.name != "start" }\r
 136                     .map { resourceAssignment ->\r
 137                         val dictionarySource = resourceAssignment.dictionarySource\r
 138                         val processorInstanceName = ResourceResolutionConstants.PREFIX_RESOURCE_ASSIGNMENT_PROCESSOR.plus(dictionarySource)\r
 139 \r
 140                         val resourceAssignmentProcessor = applicationContext.getBean(processorInstanceName) as? ResourceAssignmentProcessor\r
 141                                 ?: throw BluePrintProcessorException("failed to get resource processor for instance name($processorInstanceName) " +\r
 142                                         "for resource assignment(${resourceAssignment.name})")\r
 143                         try {\r
 144                             // Set BluePrint Runtime Service\r
 145                             resourceAssignmentProcessor.raRuntimeService = resourceAssignmentRuntimeService\r
 146                             // Set Resource Dictionaries\r
 147                             resourceAssignmentProcessor.resourceDictionaries = resourceDictionaries\r
 148                             // Invoke Apply Method\r
 149                             resourceAssignmentProcessor.apply(resourceAssignment)\r
 150                         } catch (e: RuntimeException) {\r
 151                             resourceAssignmentProcessor.recover(e, resourceAssignment)\r
 152                             throw BluePrintProcessorException(e)\r
 153                         }\r
 154                     }\r
 155         }\r
 156     }\r
 157 \r
 158 }\r