Add support for resource-resolution storage

Change-Id: I0113191075804f6b77ce54c741bf0a1ccd356c77
Issue-ID: CCSDK-338
Signed-off-by: Alexis de Talhouët <adetalhouet89@gmail.com>

8 files changed, 458 insertions, 258 deletions

diff --git a/ms/blueprintsprocessor/functions/resource-resolution/pom.xml b/ms/blueprintsprocessor/functions/resource-resolution/pom.xml
index c9f4c588..9d56829a 100644
--- a/ms/blueprintsprocessor/functions/resource-resolution/pom.xml
+++ b/ms/blueprintsprocessor/functions/resource-resolution/pom.xml
@@ -29,11 +29,10 @@
     <description>Blueprints Processor Function - Resource Resolution</description>
 
     <dependencies>
-        <!--<dependency>
-            <groupId>org.onap.ccsdk.apps.controllerblueprints</groupId>
-            <artifactId>db-resources</artifactId>
-            <version>${project.version}</version>
-        </dependency>-->
+        <dependency>
+            <groupId>org.onap.ccsdk.apps.blueprintsprocessor</groupId>
+            <artifactId>db-lib</artifactId>
+        </dependency>
         <dependency>
             <groupId>org.onap.ccsdk.apps.blueprintsprocessor.functions</groupId>
             <artifactId>python-executor</artifactId>
diff --git a/ms/blueprintsprocessor/functions/resource-resolution/src/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/functions/resource/resolution/ResourceResolutionComponent.kt b/ms/blueprintsprocessor/functions/resource-resolution/src/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/functions/resource/resolution/ResourceResolutionComponent.kt
index 53a2153a..819fe3f8 100644
--- a/ms/blueprintsprocessor/functions/resource-resolution/src/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/functions/resource/resolution/ResourceResolutionComponent.kt
+++ b/ms/blueprintsprocessor/functions/resource-resolution/src/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/functions/resource/resolution/ResourceResolutionComponent.kt
@@ -1,49 +1,62 @@
-/*

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

- *

- * 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.blueprintsprocessor.functions.resource.resolution

-

-import org.onap.ccsdk.apps.blueprintsprocessor.core.api.data.ExecutionServiceInput

-import org.onap.ccsdk.apps.blueprintsprocessor.services.execution.AbstractComponentFunction

-import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintProcessorException

-import org.onap.ccsdk.apps.controllerblueprints.core.asJsonNode

-import org.onap.ccsdk.apps.controllerblueprints.core.utils.JacksonUtils

-import org.springframework.beans.factory.config.ConfigurableBeanFactory

-import org.springframework.context.annotation.Scope

-import org.springframework.stereotype.Component

-

-@Component("component-resource-resolution")

-@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)

-open class ResourceResolutionComponent(private val resourceResolutionService: ResourceResolutionService) : AbstractComponentFunction() {

-

-    override fun process(executionRequest: ExecutionServiceInput) {

-

-        val artifactPrefixNamesNode = getOperationInput(ResourceResolutionConstants.INPUT_ARTIFACT_PREFIX_NAMES)

-

-        val artifactPrefixNames = JacksonUtils.getListFromJsonNode(artifactPrefixNamesNode, String::class.java)

-                ?: throw BluePrintProcessorException("couldn't transform ${artifactPrefixNamesNode.asText()} to string array")

-

-        val resolvedParamContents = resourceResolutionService.resolveResources(bluePrintRuntimeService, nodeTemplateName, artifactPrefixNames)

-

-        // Set Output Attributes

-        bluePrintRuntimeService.setNodeTemplateAttributeValue(nodeTemplateName,

-                ResourceResolutionConstants.OUTPUT_ASSIGNMENT_PARAMS, resolvedParamContents.asJsonNode())

-    }

-

-    override fun recover(runtimeException: RuntimeException, executionRequest: ExecutionServiceInput) {

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

-    }

+/*
+ * Copyright © 2017-2018 AT&T Intellectual Property.
+ *
+ * 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.blueprintsprocessor.functions.resource.resolution
+
+import org.onap.ccsdk.apps.blueprintsprocessor.core.api.data.ExecutionServiceInput
+import org.onap.ccsdk.apps.blueprintsprocessor.services.execution.AbstractComponentFunction
+import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.apps.controllerblueprints.core.asJsonNode
+import org.onap.ccsdk.apps.controllerblueprints.core.utils.JacksonUtils
+import org.springframework.beans.factory.config.ConfigurableBeanFactory
+import org.springframework.context.annotation.Scope
+import org.springframework.stereotype.Component
+
+@Component("component-resource-resolution")
+@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
+open class ResourceResolutionComponent(private val resourceResolutionService: ResourceResolutionService) :
+    AbstractComponentFunction() {
+
+    override fun process(executionRequest: ExecutionServiceInput) {
+
+        val properties: MutableMap<String, Any> = mutableMapOf()
+
+        try {
+            val key = getOperationInput(ResourceResolutionConstants.RESOURCE_RESOLUTION_INPUT_KEY)
+            val storeResult = getOperationInput(ResourceResolutionConstants.RESOURCE_RESOLUTION_INPUT_STORE_RESULT)
+            properties[ResourceResolutionConstants.RESOURCE_RESOLUTION_INPUT_KEY] = key.asText()
+            properties[ResourceResolutionConstants.RESOURCE_RESOLUTION_INPUT_STORE_RESULT] = storeResult.asBoolean()
+        } catch (e: BluePrintProcessorException) {
+            // NoOp - these property aren't mandatory, so don't fail the process if not provided.
+        }
+
+        val artifactPrefixNamesNode = getOperationInput(ResourceResolutionConstants.INPUT_ARTIFACT_PREFIX_NAMES)
+        val artifactPrefixNames = JacksonUtils.getListFromJsonNode(artifactPrefixNamesNode, String::class.java)
+
+        val resolvedParamContents = resourceResolutionService.resolveResources(bluePrintRuntimeService,
+            nodeTemplateName,
+            artifactPrefixNames,
+            properties)
+
+        // Set Output Attributes
+        bluePrintRuntimeService.setNodeTemplateAttributeValue(nodeTemplateName,
+            ResourceResolutionConstants.OUTPUT_ASSIGNMENT_PARAMS, resolvedParamContents.asJsonNode())
+    }
+
+    override fun recover(runtimeException: RuntimeException, executionRequest: ExecutionServiceInput) {
+        TODO("not implemented") //To change body of created functions use File | Settings | File Templates.
+    }
 }
\ No newline at end of file
diff --git a/ms/blueprintsprocessor/functions/resource-resolution/src/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/functions/resource/resolution/ResourceResolutionConstants.kt b/ms/blueprintsprocessor/functions/resource-resolution/src/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/functions/resource/resolution/ResourceResolutionConstants.kt
index ca92e96d..8dd738d0 100644
--- a/ms/blueprintsprocessor/functions/resource-resolution/src/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/functions/resource/resolution/ResourceResolutionConstants.kt
+++ b/ms/blueprintsprocessor/functions/resource-resolution/src/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/functions/resource/resolution/ResourceResolutionConstants.kt
@@ -19,11 +19,12 @@ package org.onap.ccsdk.apps.blueprintsprocessor.functions.resource.resolution
 class ResourceResolutionConstants {
     companion object {
         const val SERVICE_RESOURCE_RESOLUTION = "resource-resolution-service"
-
         const val PREFIX_RESOURCE_RESOLUTION_PROCESSOR = "rr-processor-"
         const val INPUT_ARTIFACT_PREFIX_NAMES = "artifact-prefix-names"
         const val OUTPUT_ASSIGNMENT_PARAMS = "assignment-params"
         const val FILE_NAME_RESOURCE_DEFINITION_TYPES = "resources_definition_types.json"
+        const val RESOURCE_RESOLUTION_INPUT_KEY = "resolution-key";
+        const val RESOURCE_RESOLUTION_INPUT_STORE_RESULT = "store-result";
     }
 
 }
\ No newline at end of file
diff --git a/ms/blueprintsprocessor/functions/resource-resolution/src/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/functions/resource/resolution/ResourceResolutionService.kt b/ms/blueprintsprocessor/functions/resource-resolution/src/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/functions/resource/resolution/ResourceResolutionService.kt
index 48415efa..c1282344 100644
--- a/ms/blueprintsprocessor/functions/resource-resolution/src/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/functions/resource/resolution/ResourceResolutionService.kt
+++ b/ms/blueprintsprocessor/functions/resource-resolution/src/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/functions/resource/resolution/ResourceResolutionService.kt
@@ -1,202 +1,227 @@
-/*

- *  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.blueprintsprocessor.functions.resource.resolution

-

-import org.onap.ccsdk.apps.blueprintsprocessor.functions.resource.resolution.processor.ResourceAssignmentProcessor

-import org.onap.ccsdk.apps.blueprintsprocessor.functions.resource.resolution.utils.ResourceAssignmentUtils

-import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintConstants

-import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintProcessorException

-import org.onap.ccsdk.apps.controllerblueprints.core.checkNotEmptyOrThrow

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

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

-import org.onap.ccsdk.apps.controllerblueprints.core.utils.JacksonUtils

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

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

-import org.onap.ccsdk.apps.controllerblueprints.resource.dict.utils.BulkResourceSequencingUtils

-import org.slf4j.LoggerFactory

-import org.springframework.context.ApplicationContext

-import org.springframework.stereotype.Service

-import java.io.File

-

-interface ResourceResolutionService {

-

-    fun registeredResourceSources(): List<String>

-

-    fun resolveResources(bluePrintRuntimeService: BluePrintRuntimeService<*>, nodeTemplateName: String,

-                         artifactNames: List<String>): MutableMap<String, String>

-

-    fun resolveResources(bluePrintRuntimeService: BluePrintRuntimeService<*>, nodeTemplateName: String,

-                         artifactPrefix: String): String

-

-    fun resolveResources(bluePrintRuntimeService: BluePrintRuntimeService<*>, nodeTemplateName: String,

-                         artifactMapping: String, artifactTemplate: String?): String

-

-    fun resolveResourceAssignments(blueprintRuntimeService: BluePrintRuntimeService<*>,

-                                   resourceDictionaries: MutableMap<String, ResourceDefinition>,

-                                   resourceAssignments: MutableList<ResourceAssignment>,

-                                   identifierName: String)

-}

-

-@Service(ResourceResolutionConstants.SERVICE_RESOURCE_RESOLUTION)

-open class ResourceResolutionServiceImpl(private var applicationContext: ApplicationContext) :

-        ResourceResolutionService {

-

-    private val log = LoggerFactory.getLogger(ResourceResolutionService::class.java)

-

-    override fun registeredResourceSources(): List<String> {

-        return applicationContext.getBeanNamesForType(ResourceAssignmentProcessor::class.java)

-                .filter { it.startsWith(ResourceResolutionConstants.PREFIX_RESOURCE_RESOLUTION_PROCESSOR) }

-                .map { it.substringAfter(ResourceResolutionConstants.PREFIX_RESOURCE_RESOLUTION_PROCESSOR) }

-    }

-

-    override fun resolveResources(bluePrintRuntimeService: BluePrintRuntimeService<*>, nodeTemplateName: String,

-                                  artifactNames: List<String>): MutableMap<String, String> {

-

-        val resolvedParams: MutableMap<String, String> = hashMapOf()

-        artifactNames.forEach { artifactName ->

-            val resolvedContent = resolveResources(bluePrintRuntimeService, nodeTemplateName, artifactName)

-            resolvedParams[artifactName] = resolvedContent

-        }

-        return resolvedParams

-    }

-

-    override fun resolveResources(bluePrintRuntimeService: BluePrintRuntimeService<*>, nodeTemplateName: String,

-                                  artifactPrefix: String): String {

-

-        // Velocity Artifact Definition Name

-        val artifactTemplate = "$artifactPrefix-template"

-        // Resource Assignment Artifact Definition Name

-        val artifactMapping = "$artifactPrefix-mapping"

-

-        return resolveResources(bluePrintRuntimeService, nodeTemplateName, artifactMapping, artifactTemplate)

-    }

-

-

-    override fun resolveResources(bluePrintRuntimeService: BluePrintRuntimeService<*>, nodeTemplateName: String,

-                                  artifactMapping: String, artifactTemplate: String?): String {

-

-        var resolvedContent = ""

-        log.info("Resolving resource for template artifact($artifactTemplate) with resource assignment artifact($artifactMapping)")

-

-        val identifierName = artifactTemplate ?: "no-template"

-

-        val resourceAssignmentContent = bluePrintRuntimeService.resolveNodeTemplateArtifact(nodeTemplateName, artifactMapping)

-

-        val resourceAssignments: MutableList<ResourceAssignment> = JacksonUtils.getListFromJson(resourceAssignmentContent, ResourceAssignment::class.java)

-                as? MutableList<ResourceAssignment>

-                ?: throw BluePrintProcessorException("couldn't get Dictionary Definitions")

-

-        // Get the Resource Dictionary Name

-        val dictionaryFile = bluePrintRuntimeService.bluePrintContext().rootPath.plus(File.separator)

-                .plus(BluePrintConstants.TOSCA_DEFINITIONS_DIR).plus(File.separator)

-                .plus(ResourceResolutionConstants.FILE_NAME_RESOURCE_DEFINITION_TYPES)

-

-        val resourceDictionaries: MutableMap<String, ResourceDefinition> = JacksonUtils.getMapFromFile(dictionaryFile, ResourceDefinition::class.java)

-                ?: throw BluePrintProcessorException("couldn't get Dictionary Definitions")

-

-        // Resolve resources

-        resolveResourceAssignments(bluePrintRuntimeService, resourceDictionaries, resourceAssignments, identifierName)

-

-        val resolvedParamJsonContent = ResourceAssignmentUtils.generateResourceDataForAssignments(resourceAssignments.toList())

-

-        // Check Template is there

-        if (artifactTemplate != null) {

-            val templateContent = bluePrintRuntimeService.resolveNodeTemplateArtifact(nodeTemplateName, artifactTemplate)

-            resolvedContent = BluePrintTemplateService.generateContent(templateContent, resolvedParamJsonContent)

-        } else {

-            resolvedContent = resolvedParamJsonContent

-        }

-        return resolvedContent

-    }

-

-    /**

-     * Iterate the Batch, get the Resource Assignment, dictionary Name, Look for the Resource definition for the

-     * name, then get the type of the Resource Definition, Get the instance for the Resource Type and process the

-     * request.

-     */

-    override fun resolveResourceAssignments(blueprintRuntimeService: BluePrintRuntimeService<*>,

-                                            resourceDictionaries: MutableMap<String, ResourceDefinition>,

-                                            resourceAssignments: MutableList<ResourceAssignment>,

-                                            identifierName: String) {

-

-        val bulkSequenced = BulkResourceSequencingUtils.process(resourceAssignments)

-        val resourceAssignmentRuntimeService = ResourceAssignmentUtils.transformToRARuntimeService(blueprintRuntimeService, identifierName)

-

-        bulkSequenced.map { batchResourceAssignments ->

-            batchResourceAssignments.filter { it.name != "*" && it.name != "start" }

-                    .forEach { resourceAssignment ->

-                        val dictionaryName = resourceAssignment.dictionaryName

-                        val dictionarySource = resourceAssignment.dictionarySource

-                        /**

-                         * Get the Processor name

-                         */

-                        val processorName = processorName(dictionaryName!!, dictionarySource!!,

-                                resourceDictionaries)

-

-                        val resourceAssignmentProcessor = applicationContext.getBean(processorName) as? ResourceAssignmentProcessor

-                                ?: throw BluePrintProcessorException("failed to get resource processor for name($processorName) " +

-                                        "for resource assignment(${resourceAssignment.name})")

-                        try {

-                            // Set BluePrint Runtime Service

-                            resourceAssignmentProcessor.raRuntimeService = resourceAssignmentRuntimeService

-                            // Set Resource Dictionaries

-                            resourceAssignmentProcessor.resourceDictionaries = resourceDictionaries

-                            // Invoke Apply Method

-                            resourceAssignmentProcessor.apply(resourceAssignment)

-                        } catch (e: RuntimeException) {

-                            resourceAssignmentProcessor.recover(e, resourceAssignment)

-                            throw BluePrintProcessorException(e)

-                        }

-                    }

-        }

-    }

-

-

-    /**

-     * If the Source instance is "input", then it is not mandatory to have source Resource Definition, So it can

-     *  derive the default input processor.

-     */

-    private fun processorName(dictionaryName: String, dictionarySource: String,

-                              resourceDictionaries: MutableMap<String, ResourceDefinition>): String {

-        var processorName: String? = null

-        when (dictionarySource) {

-            "input" -> {

-                processorName = "${ResourceResolutionConstants.PREFIX_RESOURCE_RESOLUTION_PROCESSOR}source-input"

-            }

-            "default" -> {

-                processorName = "${ResourceResolutionConstants.PREFIX_RESOURCE_RESOLUTION_PROCESSOR}source-default"

-            }

-            else -> {

-                val resourceDefinition = resourceDictionaries[dictionaryName]

-                        ?: throw BluePrintProcessorException("couldn't get resource dictionary definition for $dictionaryName")

-

-                val resourceSource = resourceDefinition.sources[dictionarySource]

-                        ?: throw BluePrintProcessorException("couldn't get resource definition $dictionaryName source($dictionarySource)")

-

-                processorName = ResourceResolutionConstants.PREFIX_RESOURCE_RESOLUTION_PROCESSOR

-                        .plus(resourceSource.type)

-            }

-        }

-        checkNotEmptyOrThrow(processorName,

-                "couldn't get processor name for resource dictionary definition($dictionaryName) source" +

-                        "($dictionarySource)")

-

-        return processorName

-

-    }

-}

+/*
+ *  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.blueprintsprocessor.functions.resource.resolution
+
+import org.onap.ccsdk.apps.blueprintsprocessor.functions.resource.resolution.db.ResourceResolutionResultService
+import org.onap.ccsdk.apps.blueprintsprocessor.functions.resource.resolution.processor.ResourceAssignmentProcessor
+import org.onap.ccsdk.apps.blueprintsprocessor.functions.resource.resolution.utils.ResourceAssignmentUtils
+import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintConstants
+import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.apps.controllerblueprints.core.checkNotEmptyOrThrow
+import org.onap.ccsdk.apps.controllerblueprints.core.service.BluePrintRuntimeService
+import org.onap.ccsdk.apps.controllerblueprints.core.service.BluePrintTemplateService
+import org.onap.ccsdk.apps.controllerblueprints.core.utils.JacksonUtils
+import org.onap.ccsdk.apps.controllerblueprints.resource.dict.ResourceAssignment
+import org.onap.ccsdk.apps.controllerblueprints.resource.dict.ResourceDefinition
+import org.onap.ccsdk.apps.controllerblueprints.resource.dict.utils.BulkResourceSequencingUtils
+import org.slf4j.LoggerFactory
+import org.springframework.context.ApplicationContext
+import org.springframework.stereotype.Service
+import java.io.File
+
+interface ResourceResolutionService {
+
+    fun registeredResourceSources(): List<String>
+
+    fun resolveFromDatabase(bluePrintRuntimeService: BluePrintRuntimeService<*>, artifactTemplate: String,
+                            resolutionKey: String): String
+
+    fun resolveResources(bluePrintRuntimeService: BluePrintRuntimeService<*>, nodeTemplateName: String,
+                         artifactNames: List<String>, properties: Map<String, Any>): MutableMap<String, String>
+
+    fun resolveResources(bluePrintRuntimeService: BluePrintRuntimeService<*>, nodeTemplateName: String,
+                         artifactPrefix: String, properties: Map<String, Any>): String
+
+    fun resolveResources(bluePrintRuntimeService: BluePrintRuntimeService<*>, nodeTemplateName: String,
+                         artifactMapping: String, artifactTemplate: String?): String
+
+    fun resolveResourceAssignments(blueprintRuntimeService: BluePrintRuntimeService<*>,
+                                   resourceDictionaries: MutableMap<String, ResourceDefinition>,
+                                   resourceAssignments: MutableList<ResourceAssignment>,
+                                   identifierName: String)
+}
+
+@Service(ResourceResolutionConstants.SERVICE_RESOURCE_RESOLUTION)
+open class ResourceResolutionServiceImpl(private var applicationContext: ApplicationContext,
+                                         private var resolutionResultService: ResourceResolutionResultService) :
+    ResourceResolutionService {
+
+    private val log = LoggerFactory.getLogger(ResourceResolutionService::class.java)
+
+    override fun registeredResourceSources(): List<String> {
+        return applicationContext.getBeanNamesForType(ResourceAssignmentProcessor::class.java)
+            .filter { it.startsWith(ResourceResolutionConstants.PREFIX_RESOURCE_RESOLUTION_PROCESSOR) }
+            .map { it.substringAfter(ResourceResolutionConstants.PREFIX_RESOURCE_RESOLUTION_PROCESSOR) }
+    }
+
+    override fun resolveResources(bluePrintRuntimeService: BluePrintRuntimeService<*>, nodeTemplateName: String,
+                                  artifactNames: List<String>,
+                                  properties: Map<String, Any>): MutableMap<String, String> {
+
+        val resolvedParams: MutableMap<String, String> = hashMapOf()
+        artifactNames.forEach { artifactName ->
+            val resolvedContent = resolveResources(bluePrintRuntimeService, nodeTemplateName, artifactName, properties)
+            resolvedParams[artifactName] = resolvedContent
+        }
+        return resolvedParams
+    }
+
+    override fun resolveResources(bluePrintRuntimeService: BluePrintRuntimeService<*>, nodeTemplateName: String,
+                                  artifactPrefix: String, properties: Map<String, Any>): String {
+
+        // Velocity Artifact Definition Name
+        val artifactTemplate = "$artifactPrefix-template"
+        // Resource Assignment Artifact Definition Name
+        val artifactMapping = "$artifactPrefix-mapping"
+
+        val result = resolveResources(bluePrintRuntimeService, nodeTemplateName, artifactMapping, artifactTemplate)
+
+        if (properties.containsKey(ResourceResolutionConstants.RESOURCE_RESOLUTION_INPUT_STORE_RESULT)
+            && properties[ResourceResolutionConstants.RESOURCE_RESOLUTION_INPUT_STORE_RESULT] as Boolean) {
+            resolutionResultService.write(properties, result, bluePrintRuntimeService, artifactPrefix)
+        }
+
+        return result
+    }
+
+    override fun resolveFromDatabase(bluePrintRuntimeService: BluePrintRuntimeService<*>, artifactTemplate: String,
+                                     resolutionKey: String): String {
+        return resolutionResultService.read(bluePrintRuntimeService, artifactTemplate, resolutionKey)
+    }
+
+    override fun resolveResources(bluePrintRuntimeService: BluePrintRuntimeService<*>, nodeTemplateName: String,
+                                  artifactMapping: String, artifactTemplate: String?): String {
+
+        var resolvedContent = ""
+        log.info("Resolving resource for template artifact($artifactTemplate) with resource assignment artifact($artifactMapping)")
+
+        val identifierName = artifactTemplate ?: "no-template"
+
+        val resourceAssignmentContent =
+            bluePrintRuntimeService.resolveNodeTemplateArtifact(nodeTemplateName, artifactMapping)
+
+        val resourceAssignments: MutableList<ResourceAssignment> =
+            JacksonUtils.getListFromJson(resourceAssignmentContent, ResourceAssignment::class.java)
+                    as? MutableList<ResourceAssignment>
+                ?: throw BluePrintProcessorException("couldn't get Dictionary Definitions")
+
+        // Get the Resource Dictionary Name
+        val dictionaryFile = bluePrintRuntimeService.bluePrintContext().rootPath.plus(File.separator)
+            .plus(BluePrintConstants.TOSCA_DEFINITIONS_DIR).plus(File.separator)
+            .plus(ResourceResolutionConstants.FILE_NAME_RESOURCE_DEFINITION_TYPES)
+
+        val resourceDictionaries: MutableMap<String, ResourceDefinition> =
+            JacksonUtils.getMapFromFile(dictionaryFile, ResourceDefinition::class.java)
+                ?: throw BluePrintProcessorException("couldn't get Dictionary Definitions")
+
+        // Resolve resources
+        resolveResourceAssignments(bluePrintRuntimeService, resourceDictionaries, resourceAssignments, identifierName)
+
+        val resolvedParamJsonContent =
+            ResourceAssignmentUtils.generateResourceDataForAssignments(resourceAssignments.toList())
+
+        // Check Template is there
+        if (artifactTemplate != null) {
+            val templateContent =
+                bluePrintRuntimeService.resolveNodeTemplateArtifact(nodeTemplateName, artifactTemplate)
+            resolvedContent = BluePrintTemplateService.generateContent(templateContent, resolvedParamJsonContent)
+        } else {
+            resolvedContent = resolvedParamJsonContent
+        }
+
+        return resolvedContent
+    }
+
+    /**
+     * Iterate the Batch, get the Resource Assignment, dictionary Name, Look for the Resource definition for the
+     * name, then get the type of the Resource Definition, Get the instance for the Resource Type and process the
+     * request.
+     */
+    override fun resolveResourceAssignments(blueprintRuntimeService: BluePrintRuntimeService<*>,
+                                            resourceDictionaries: MutableMap<String, ResourceDefinition>,
+                                            resourceAssignments: MutableList<ResourceAssignment>,
+                                            identifierName: String) {
+
+        val bulkSequenced = BulkResourceSequencingUtils.process(resourceAssignments)
+        val resourceAssignmentRuntimeService =
+            ResourceAssignmentUtils.transformToRARuntimeService(blueprintRuntimeService, identifierName)
+
+        bulkSequenced.map { batchResourceAssignments ->
+            batchResourceAssignments.filter { it.name != "*" && it.name != "start" }
+                .forEach { resourceAssignment ->
+                    val dictionaryName = resourceAssignment.dictionaryName
+                    val dictionarySource = resourceAssignment.dictionarySource
+                    /**
+                     * Get the Processor name
+                     */
+                    val processorName = processorName(dictionaryName!!, dictionarySource!!,
+                        resourceDictionaries)
+
+                    val resourceAssignmentProcessor =
+                        applicationContext.getBean(processorName) as? ResourceAssignmentProcessor
+                            ?: throw BluePrintProcessorException("failed to get resource processor for name($processorName) " +
+                                    "for resource assignment(${resourceAssignment.name})")
+                    try {
+                        // Set BluePrint Runtime Service
+                        resourceAssignmentProcessor.raRuntimeService = resourceAssignmentRuntimeService
+                        // Set Resource Dictionaries
+                        resourceAssignmentProcessor.resourceDictionaries = resourceDictionaries
+                        // Invoke Apply Method
+                        resourceAssignmentProcessor.apply(resourceAssignment)
+                    } catch (e: RuntimeException) {
+                        resourceAssignmentProcessor.recover(e, resourceAssignment)
+                        throw BluePrintProcessorException(e)
+                    }
+                }
+        }
+    }
+
+
+    /**
+     * If the Source instance is "input", then it is not mandatory to have source Resource Definition, So it can
+     *  derive the default input processor.
+     */
+    private fun processorName(dictionaryName: String, dictionarySource: String,
+                              resourceDictionaries: MutableMap<String, ResourceDefinition>): String {
+        var processorName: String? = null
+        when (dictionarySource) {
+            "input" -> {
+                processorName = "${ResourceResolutionConstants.PREFIX_RESOURCE_RESOLUTION_PROCESSOR}source-input"
+            }
+            "default" -> {
+                processorName = "${ResourceResolutionConstants.PREFIX_RESOURCE_RESOLUTION_PROCESSOR}source-default"
+            }
+            else -> {
+                val resourceDefinition = resourceDictionaries[dictionaryName]
+                    ?: throw BluePrintProcessorException("couldn't get resource dictionary definition for $dictionaryName")
+
+                val resourceSource = resourceDefinition.sources[dictionarySource]
+                    ?: throw BluePrintProcessorException("couldn't get resource definition $dictionaryName source($dictionarySource)")
+
+                processorName = ResourceResolutionConstants.PREFIX_RESOURCE_RESOLUTION_PROCESSOR
+                    .plus(resourceSource.type)
+            }
+        }
+        checkNotEmptyOrThrow(processorName,
+            "couldn't get processor name for resource dictionary definition($dictionaryName) source" +
+                    "($dictionarySource)")
+
+        return processorName
+
+    }
+}
diff --git a/ms/blueprintsprocessor/functions/resource-resolution/src/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/functions/resource/resolution/db/ResourceResolutionRepository.kt b/ms/blueprintsprocessor/functions/resource-resolution/src/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/functions/resource/resolution/db/ResourceResolutionRepository.kt
new file mode 100644
index 00000000..e50c578d
--- /dev/null
+++ b/ms/blueprintsprocessor/functions/resource-resolution/src/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/functions/resource/resolution/db/ResourceResolutionRepository.kt
@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2019 Bell Canada.
+ *
+ * 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.blueprintsprocessor.functions.resource.resolution.db
+
+import org.springframework.data.jpa.repository.JpaRepository
+
+interface ResourceResolutionRepository : JpaRepository<ResourceResolutionResult, String> {
+
+    fun findByResolutionKeyAndBlueprintNameAndBlueprintVersionAndArtifactName(key: String, blueprintName: String?,
+                                                                              blueprintVersion: String?,
+                                                                              artifactName: String): ResourceResolutionResult
+}
diff --git a/ms/blueprintsprocessor/functions/resource-resolution/src/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/functions/resource/resolution/db/ResourceResolutionResult.kt b/ms/blueprintsprocessor/functions/resource-resolution/src/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/functions/resource/resolution/db/ResourceResolutionResult.kt
new file mode 100755
index 00000000..814fba5e
--- /dev/null
+++ b/ms/blueprintsprocessor/functions/resource-resolution/src/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/functions/resource/resolution/db/ResourceResolutionResult.kt
@@ -0,0 +1,69 @@
+/*
+ * Copyright © 2019 Bell Canada
+ *
+ * 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.blueprintsprocessor.functions.resource.resolution.db
+
+import com.fasterxml.jackson.annotation.JsonFormat
+import org.hibernate.annotations.Proxy
+import org.springframework.data.annotation.LastModifiedDate
+import org.springframework.data.jpa.domain.support.AuditingEntityListener
+import java.io.Serializable
+import java.util.*
+import javax.persistence.Column
+import javax.persistence.Entity
+import javax.persistence.EntityListeners
+import javax.persistence.Id
+import javax.persistence.Lob
+import javax.persistence.Table
+import javax.persistence.Temporal
+import javax.persistence.TemporalType
+
+@EntityListeners(AuditingEntityListener::class)
+@Entity
+@Table(name = "RESOURCE_RESOLUTION_RESULT")
+@Proxy(lazy = false)
+class ResourceResolutionResult : Serializable {
+
+    @Id
+    @Column(name = "resource_resolution_result_id")
+    var id: String? = null
+
+    @Column(name = "resolution_key", nullable = false)
+    var resolutionKey: String? = null
+
+    @Column(name = "blueprint_name", nullable = false)
+    var blueprintName: String? = null
+
+    @Column(name = "blueprint_version", nullable = false)
+    var blueprintVersion: String? = null
+
+    @Column(name = "artifact_name", nullable = false)
+    var artifactName: String? = null
+
+    @Lob
+    @Column(name = "result", nullable = false)
+    var result: String? = null
+
+    @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd'T'HH:mm:ss.SSS'Z'")
+    @LastModifiedDate
+    @Temporal(TemporalType.TIMESTAMP)
+    @Column(name = "creation_date")
+    var createdDate = Date()
+
+    companion object {
+        private const val serialVersionUID = 1L
+    }
+}
\ No newline at end of file
diff --git a/ms/blueprintsprocessor/functions/resource-resolution/src/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/functions/resource/resolution/db/ResourceResolutionResultService.kt b/ms/blueprintsprocessor/functions/resource-resolution/src/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/functions/resource/resolution/db/ResourceResolutionResultService.kt
new file mode 100644
index 00000000..448782a8
--- /dev/null
+++ b/ms/blueprintsprocessor/functions/resource-resolution/src/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/functions/resource/resolution/db/ResourceResolutionResultService.kt
@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) 2019 Bell Canada.
+ *
+ * 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.blueprintsprocessor.functions.resource.resolution.db
+
+import org.onap.ccsdk.apps.blueprintsprocessor.functions.resource.resolution.ResourceResolutionConstants
+import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintConstants
+import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintException
+import org.onap.ccsdk.apps.controllerblueprints.core.service.BluePrintRuntimeService
+import org.springframework.dao.DataIntegrityViolationException
+import org.springframework.stereotype.Service
+import java.util.*
+
+@Service
+class ResourceResolutionResultService(private val resourceResolutionRepository: ResourceResolutionRepository) {
+
+    fun write(properties: Map<String, Any>, result: String, bluePrintRuntimeService: BluePrintRuntimeService<*>,
+              artifactPrefix: String) {
+
+        val metadata = bluePrintRuntimeService.bluePrintContext().metadata!!
+
+        val resourceResolutionResult = ResourceResolutionResult()
+        resourceResolutionResult.id = UUID.randomUUID().toString()
+        resourceResolutionResult.artifactName = artifactPrefix
+        resourceResolutionResult.blueprintVersion = metadata[BluePrintConstants.METADATA_TEMPLATE_VERSION]
+        resourceResolutionResult.blueprintName = metadata[BluePrintConstants.METADATA_TEMPLATE_NAME]
+        resourceResolutionResult.resolutionKey =
+            properties[ResourceResolutionConstants.RESOURCE_RESOLUTION_INPUT_KEY].toString()
+        resourceResolutionResult.result = result
+
+        try {
+            resourceResolutionRepository.saveAndFlush(resourceResolutionResult)
+        } catch (ex: DataIntegrityViolationException) {
+            throw BluePrintException("Failed to store resource resolution result.", ex)
+        }
+    }
+
+    fun read(bluePrintRuntimeService: BluePrintRuntimeService<*>, artifactPrefix: String,
+             resolutionKey: String): String {
+
+        val metadata = bluePrintRuntimeService.bluePrintContext().metadata!!
+
+        val blueprintVersion = metadata[BluePrintConstants.METADATA_TEMPLATE_VERSION]
+        val blueprintName = metadata[BluePrintConstants.METADATA_TEMPLATE_NAME]
+
+        return resourceResolutionRepository.findByResolutionKeyAndBlueprintNameAndBlueprintVersionAndArtifactName(
+            resolutionKey,
+            blueprintName,
+            blueprintVersion,
+            artifactPrefix).result!!
+    }
+}
\ No newline at end of file
diff --git a/ms/blueprintsprocessor/functions/resource-resolution/src/test/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/functions/resource/resolution/ResourceResolutionServiceTest.kt b/ms/blueprintsprocessor/functions/resource-resolution/src/test/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/functions/resource/resolution/ResourceResolutionServiceTest.kt
index fcf8f46c..fe824ca2 100644
--- a/ms/blueprintsprocessor/functions/resource-resolution/src/test/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/functions/resource/resolution/ResourceResolutionServiceTest.kt
+++ b/ms/blueprintsprocessor/functions/resource-resolution/src/test/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/functions/resource/resolution/ResourceResolutionServiceTest.kt
@@ -26,7 +26,11 @@ import org.onap.ccsdk.apps.blueprintsprocessor.core.api.data.ExecutionServiceInp
 import org.onap.ccsdk.apps.blueprintsprocessor.core.utils.PayloadUtils
 import org.onap.ccsdk.apps.blueprintsprocessor.db.BluePrintDBLibConfiguration
 import org.onap.ccsdk.apps.blueprintsprocessor.db.primary.DBLibGenericService
-import org.onap.ccsdk.apps.blueprintsprocessor.functions.resource.resolution.processor.*
+import org.onap.ccsdk.apps.blueprintsprocessor.functions.resource.resolution.processor.CapabilityResourceResolutionProcessor
+import org.onap.ccsdk.apps.blueprintsprocessor.functions.resource.resolution.processor.DatabaseResourceAssignmentProcessor
+import org.onap.ccsdk.apps.blueprintsprocessor.functions.resource.resolution.processor.DefaultResourceResolutionProcessor
+import org.onap.ccsdk.apps.blueprintsprocessor.functions.resource.resolution.processor.InputResourceResolutionProcessor
+import org.onap.ccsdk.apps.blueprintsprocessor.functions.resource.resolution.processor.RestResourceResolutionProcessor
 import org.onap.ccsdk.apps.controllerblueprints.core.config.BluePrintLoadConfiguration
 import org.onap.ccsdk.apps.controllerblueprints.core.utils.BluePrintMetadataUtils
 import org.onap.ccsdk.apps.controllerblueprints.core.utils.JacksonUtils
@@ -85,7 +89,7 @@ class ResourceResolutionServiceTest {
         // Prepare Inputs
         PayloadUtils.prepareInputsFromWorkflowPayload(bluePrintRuntimeService, executionServiceInput.payload, "resource-assignment")
 
-        resourceResolutionService.resolveResources(bluePrintRuntimeService, "resource-assignment", "baseconfig")
+        resourceResolutionService.resolveResources(bluePrintRuntimeService, "resource-assignment", "baseconfig", mapOf())
 
     }