34 files changed, 880 insertions, 469 deletions

diff --git a/ms/blueprintsprocessor/functions/netconf-executor/pom.xml b/ms/blueprintsprocessor/functions/netconf-executor/pom.xml
index df566de44..e77a6e3bb 100644
--- a/ms/blueprintsprocessor/functions/netconf-executor/pom.xml
+++ b/ms/blueprintsprocessor/functions/netconf-executor/pom.xml
@@ -14,7 +14,8 @@
   ~ See the License for the specific language governing permissions and
   ~ limitations under the License.
   -->
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <parent>
         <groupId>org.onap.ccsdk.apps.blueprintsprocessor</groupId>
         <artifactId>functions</artifactId>
@@ -47,5 +48,10 @@
             <artifactId>jsch</artifactId>
             <version>0.1.54</version>
         </dependency>
-      </dependencies>
+        <dependency>
+            <groupId>com.h2database</groupId>
+            <artifactId>h2</artifactId>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
 </project>
diff --git a/ms/blueprintsprocessor/functions/netconf-executor/src/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/functions/netconf/executor/NetconfComponentFunction.kt b/ms/blueprintsprocessor/functions/netconf-executor/src/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/functions/netconf/executor/NetconfComponentFunction.kt
index 26e51ec09..05a97c393 100644
--- a/ms/blueprintsprocessor/functions/netconf-executor/src/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/functions/netconf/executor/NetconfComponentFunction.kt
+++ b/ms/blueprintsprocessor/functions/netconf-executor/src/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/functions/netconf/executor/NetconfComponentFunction.kt
@@ -25,9 +25,8 @@ import org.onap.ccsdk.apps.controllerblueprints.core.utils.JacksonUtils
 
 abstract class NetconfComponentFunction : AbstractComponentFunction() {
 
-
     open fun resourceResolutionService(): ResourceResolutionService =
-            functionDependencyInstanceAsType(ResourceResolutionConstants.SERVICE_RESOURCE_RESOLUTION)
+        functionDependencyInstanceAsType(ResourceResolutionConstants.SERVICE_RESOURCE_RESOLUTION)
 
     // Called from python script
     fun initializeNetconfConnection(requirementName: String): NetconfDevice {
@@ -39,6 +38,14 @@ abstract class NetconfComponentFunction : AbstractComponentFunction() {
         return bluePrintRuntimeService.resolveNodeTemplateArtifact(nodeTemplateName, artifactName)
     }
 
+    fun getDynamicProperties(key: String): JsonNode {
+        return operationInputs["dynamic-properties"]!!.get(key)
+    }
+
+    fun resolveFromDatabase(resolutionKey: String, artifactName: String): String {
+        return resourceResolutionService().resolveFromDatabase(bluePrintRuntimeService, artifactName, resolutionKey)
+    }
+
     fun resolveAndGenerateMessage(artifactMapping: String, artifactTemplate: String): String {
         return resourceResolutionService().resolveResources(bluePrintRuntimeService, nodeTemplateName,
             artifactMapping, artifactTemplate)
@@ -46,7 +53,7 @@ abstract class NetconfComponentFunction : AbstractComponentFunction() {
 
     fun resolveAndGenerateMessage(artifactPrefix: String): String {
         return resourceResolutionService().resolveResources(bluePrintRuntimeService, nodeTemplateName,
-            artifactPrefix)
+            artifactPrefix, mapOf())
     }
 
     private fun deviceProperties(requirementName: String): DeviceInfo {
diff --git a/ms/blueprintsprocessor/functions/netconf-executor/src/test/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/functions/netconf/executor/ComponentNetconfExecutorTest.kt b/ms/blueprintsprocessor/functions/netconf-executor/src/test/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/functions/netconf/executor/ComponentNetconfExecutorTest.kt
index 6ed3a6d9e..e2b901998 100644
--- a/ms/blueprintsprocessor/functions/netconf-executor/src/test/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/functions/netconf/executor/ComponentNetconfExecutorTest.kt
+++ b/ms/blueprintsprocessor/functions/netconf-executor/src/test/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/functions/netconf/executor/ComponentNetconfExecutorTest.kt
@@ -22,28 +22,26 @@ import com.fasterxml.jackson.databind.JsonNode
 import org.junit.Test
 import org.junit.runner.RunWith
 import org.onap.ccsdk.apps.blueprintsprocessor.core.api.data.ExecutionServiceInput
-import org.onap.ccsdk.apps.blueprintsprocessor.functions.resource.resolution.ResourceResolutionServiceImpl
-import org.onap.ccsdk.apps.blueprintsprocessor.services.execution.ComponentFunctionScriptingService
-import org.onap.ccsdk.apps.blueprintsprocessor.services.execution.scripts.BlueprintJythonService
-import org.onap.ccsdk.apps.blueprintsprocessor.services.execution.scripts.PythonExecutorProperty
 import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintConstants
 import org.onap.ccsdk.apps.controllerblueprints.core.asJsonNode
 import org.onap.ccsdk.apps.controllerblueprints.core.putJsonElement
 import org.onap.ccsdk.apps.controllerblueprints.core.utils.BluePrintMetadataUtils
 import org.onap.ccsdk.apps.controllerblueprints.core.utils.JacksonUtils
-import org.onap.ccsdk.apps.controllerblueprints.scripts.BluePrintScriptsServiceImpl
 import org.springframework.beans.factory.annotation.Autowired
-import org.springframework.test.context.ContextConfiguration
+import org.springframework.boot.autoconfigure.EnableAutoConfiguration
+import org.springframework.context.annotation.ComponentScan
+import org.springframework.test.annotation.DirtiesContext
 import org.springframework.test.context.TestPropertySource
 import org.springframework.test.context.junit4.SpringRunner
 
 @RunWith(SpringRunner::class)
-@ContextConfiguration(classes = [BlueprintJythonService::class, PythonExecutorProperty::class,
-    BluePrintScriptsServiceImpl::class, ComponentFunctionScriptingService::class,
-    ComponentNetconfExecutor::class, JsonParserService::class, ResourceResolutionServiceImpl::class])
+@EnableAutoConfiguration
+@ComponentScan(basePackages = ["org.onap.ccsdk.apps.blueprintsprocessor", "org.onap.ccsdk.apps.controllerblueprints"])
+@DirtiesContext
 @TestPropertySource(properties =
 ["blueprints.processor.functions.python.executor.modulePaths=./../../../../components/scripts/python/ccsdk_netconf,./../../../../components/scripts/python/ccsdk_blueprints",
-    "blueprints.processor.functions.python.executor.executionPath=./../../../../components/scripts/python/ccsdk_netconf"])
+    "blueprints.processor.functions.python.executor.executionPath=./../../../../components/scripts/python/ccsdk_netconf"],
+    locations = ["classpath:application-test.properties"])
 class ComponentNetconfExecutorTest {
 
     @Autowired
@@ -54,10 +52,10 @@ class ComponentNetconfExecutorTest {
     fun testComponentNetconfExecutor() {
 
         val executionServiceInput = JacksonUtils.readValueFromClassPathFile("requests/sample-activate-request.json",
-                ExecutionServiceInput::class.java)!!
+            ExecutionServiceInput::class.java)!!
 
         val bluePrintRuntimeService = BluePrintMetadataUtils.getBluePrintRuntime("1234",
-                "./../../../../components/model-catalog/blueprint-model/test-blueprint/baseconfiguration")
+            "./../../../../components/model-catalog/blueprint-model/test-blueprint/baseconfiguration")
 
         val executionContext = bluePrintRuntimeService.getExecutionContext()
 
diff --git a/ms/blueprintsprocessor/functions/netconf-executor/src/test/resources/application-test.properties b/ms/blueprintsprocessor/functions/netconf-executor/src/test/resources/application-test.properties
new file mode 100644
index 000000000..6d8b62ff9
--- /dev/null
+++ b/ms/blueprintsprocessor/functions/netconf-executor/src/test/resources/application-test.properties
@@ -0,0 +1,32 @@
+#
+# Copyright © 2017-2018 AT&T Intellectual Property.
+#
+# Modifications Copyright © 2019 IBM, 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.
+#
+blueprintsprocessor.db.primary.url=jdbc:h2:mem:testdb;DB_CLOSE_DELAY=-1
+blueprintsprocessor.db.primary.username=sa
+blueprintsprocessor.db.primary.password=
+blueprintsprocessor.db.primary.driverClassName=org.h2.Driver
+blueprintsprocessor.db.primary.hibernateHbm2ddlAuto=create-drop
+blueprintsprocessor.db.primary.hibernateDDLAuto=update
+blueprintsprocessor.db.primary.hibernateNamingStrategy=org.hibernate.cfg.ImprovedNamingStrategy
+blueprintsprocessor.db.primary.hibernateDialect=org.hibernate.dialect.H2Dialect
+# Controller Blueprints Core Configuration
+blueprintsprocessor.blueprintDeployPath=./target/blueprints/deploy
+blueprintsprocessor.blueprintArchivePath=./target/blueprints/archive
+
+# Python executor
+blueprints.processor.functions.python.executor.executionPath=./../../../../components/scripts/python/ccsdk_blueprints
+blueprints.processor.functions.python.executor.modulePaths=./../../../../components/scripts/python/ccsdk_blueprints
diff --git a/ms/blueprintsprocessor/functions/resource-resolution/pom.xml b/ms/blueprintsprocessor/functions/resource-resolution/pom.xml
index c9f4c5885..9d56829a6 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 53a2153ad..819fe3f87 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 ca92e96dc..b57b88b7b 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
@@ -1,5 +1,6 @@
 /*
  * Copyright © 2017-2018 AT&T Intellectual Property.
+ * Modifications Copyright © 2019 IBM.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,14 +17,15 @@
 
 package org.onap.ccsdk.apps.blueprintsprocessor.functions.resource.resolution
 
-class ResourceResolutionConstants {
-    companion object {
-        const val SERVICE_RESOURCE_RESOLUTION = "resource-resolution-service"
+object ResourceResolutionConstants {
 
+        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 48415efa4..c12823442 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 000000000..e50c578d8
--- /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 000000000..814fba5ea
--- /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 000000000..448782a80
--- /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/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/functions/resource/resolution/processor/CapabilityResourceResolutionProcessor.kt b/ms/blueprintsprocessor/functions/resource-resolution/src/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/functions/resource/resolution/processor/CapabilityResourceResolutionProcessor.kt
index c6b7d77e5..c2dbd7312 100644
--- a/ms/blueprintsprocessor/functions/resource-resolution/src/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/functions/resource/resolution/processor/CapabilityResourceResolutionProcessor.kt
+++ b/ms/blueprintsprocessor/functions/resource-resolution/src/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/functions/resource/resolution/processor/CapabilityResourceResolutionProcessor.kt
@@ -19,6 +19,7 @@
 package org.onap.ccsdk.apps.blueprintsprocessor.functions.resource.resolution.processor
 
 import org.onap.ccsdk.apps.blueprintsprocessor.functions.resource.resolution.CapabilityResourceSource
+import org.onap.ccsdk.apps.blueprintsprocessor.functions.resource.resolution.ResourceResolutionConstants.PREFIX_RESOURCE_RESOLUTION_PROCESSOR
 import org.onap.ccsdk.apps.blueprintsprocessor.services.execution.scripts.BlueprintJythonService
 import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintConstants
 import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintProcessorException
@@ -32,7 +33,7 @@ import org.springframework.context.annotation.Scope
 import org.springframework.stereotype.Service
 import java.io.File
 
-@Service("rr-processor-source-capability")
+@Service("${PREFIX_RESOURCE_RESOLUTION_PROCESSOR}source-capability")
 @Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
 open class CapabilityResourceResolutionProcessor(private var applicationContext: ApplicationContext,
                                                  private val bluePrintScriptsService: BluePrintScriptsService,
@@ -40,7 +41,7 @@ open class CapabilityResourceResolutionProcessor(private var applicationContext:
         ResourceAssignmentProcessor() {
 
     override fun getName(): String {
-        return "resource-assignment-processor-capability"
+        return "${PREFIX_RESOURCE_RESOLUTION_PROCESSOR}source-capability"
     }
 
     override fun process(resourceAssignment: ResourceAssignment) {
diff --git a/ms/blueprintsprocessor/functions/resource-resolution/src/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/functions/resource/resolution/processor/PrimaryDataResourceResolutionProcessor.kt b/ms/blueprintsprocessor/functions/resource-resolution/src/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/functions/resource/resolution/processor/DatabaseResourceAssignmentProcessor.kt
index 3922c3760..39be14c93 100644
--- a/ms/blueprintsprocessor/functions/resource-resolution/src/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/functions/resource/resolution/processor/PrimaryDataResourceResolutionProcessor.kt
+++ b/ms/blueprintsprocessor/functions/resource-resolution/src/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/functions/resource/resolution/processor/DatabaseResourceAssignmentProcessor.kt
@@ -18,38 +18,35 @@
 package org.onap.ccsdk.apps.blueprintsprocessor.functions.resource.resolution.processor
 
 import com.fasterxml.jackson.databind.node.JsonNodeFactory
-import org.onap.ccsdk.apps.blueprintsprocessor.db.primary.PrimaryDBLibGenericService
+import org.onap.ccsdk.apps.blueprintsprocessor.db.primary.DBLibGenericService
 import org.onap.ccsdk.apps.blueprintsprocessor.functions.resource.resolution.DatabaseResourceSource
+import org.onap.ccsdk.apps.blueprintsprocessor.functions.resource.resolution.ResourceResolutionConstants.PREFIX_RESOURCE_RESOLUTION_PROCESSOR
 import org.onap.ccsdk.apps.blueprintsprocessor.functions.resource.resolution.utils.ResourceAssignmentUtils
-import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintProcessorException
-import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintTypes
-import org.onap.ccsdk.apps.controllerblueprints.core.checkEqualsOrThrow
-import org.onap.ccsdk.apps.controllerblueprints.core.checkNotEmptyOrThrow
-import org.onap.ccsdk.apps.controllerblueprints.core.nullToEmpty
-import org.onap.ccsdk.apps.controllerblueprints.core.returnNotEmptyOrThrow
+import org.onap.ccsdk.apps.controllerblueprints.core.*
 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.ResourceDictionaryConstants
 import org.slf4j.LoggerFactory
 import org.springframework.beans.factory.config.ConfigurableBeanFactory
 import org.springframework.context.annotation.Scope
+import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate
 import org.springframework.stereotype.Service
 import java.util.*
 
 /**
- * PrimaryDataResourceResolutionProcessor
+ * DatabaseResourceAssignmentProcessor
  *
  * @author Kapil Singal
  */
-@Service("rr-processor-source-primary-db")
+@Service("${PREFIX_RESOURCE_RESOLUTION_PROCESSOR}source-primary-db")
 @Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
-open class PrimaryDataResourceResolutionProcessor(private val primaryDBLibGenericService: PrimaryDBLibGenericService)
+open class DatabaseResourceAssignmentProcessor(private val dBLibGenericService: DBLibGenericService)
     : ResourceAssignmentProcessor() {
 
-    private val logger = LoggerFactory.getLogger(PrimaryDataResourceResolutionProcessor::class.java)
+    private val logger = LoggerFactory.getLogger(DatabaseResourceAssignmentProcessor::class.java)
 
     override fun getName(): String {
-        return "rr-processor-source-primary-db"
+        return "${PREFIX_RESOURCE_RESOLUTION_PROCESSOR}source-primary-db"
     }
 
     override fun process(resourceAssignment: ResourceAssignment) {
@@ -62,26 +59,22 @@ open class PrimaryDataResourceResolutionProcessor(private val primaryDBLibGeneri
                 logger.info("primary-db source template key (${resourceAssignment.name}) found from input and value is ($value)")
                 ResourceAssignmentUtils.setResourceDataValue(resourceAssignment, raRuntimeService, value)
             } catch (e: BluePrintProcessorException) {
-                // Else, get from DB
                 val dName = resourceAssignment.dictionaryName
                 val dSource = resourceAssignment.dictionarySource
                 val resourceDefinition = resourceDictionaries[dName]
-                    ?: throw BluePrintProcessorException("couldn't get resource dictionary definition for $dName")
+                        ?: throw BluePrintProcessorException("couldn't get resource dictionary definition for $dName")
                 val resourceSource = resourceDefinition.sources[dSource]
-                    ?: throw BluePrintProcessorException("couldn't get resource definition $dName source($dSource)")
-                val resourceSourceProperties =
-                    checkNotNull(resourceSource.properties) { "failed to get source properties for $dName " }
-                val sourceProperties =
-                    JacksonUtils.getInstanceFromMap(resourceSourceProperties, DatabaseResourceSource::class.java)
+                        ?: throw BluePrintProcessorException("couldn't get resource definition $dName source($dSource)")
+                val resourceSourceProperties = checkNotNull(resourceSource.properties) { "failed to get source properties for $dName " }
+                val sourceProperties = JacksonUtils.getInstanceFromMap(resourceSourceProperties, DatabaseResourceSource::class.java)
 
-                val sql =
-                    checkNotNull(sourceProperties.query) { "failed to get request query for $dName under $dSource properties" }
-                val inputKeyMapping =
-                    checkNotNull(sourceProperties.inputKeyMapping) { "failed to get input-key-mappings for $dName under $dSource properties" }
+                val sql = checkNotNull(sourceProperties.query) { "failed to get request query for $dName under $dSource properties" }
+                val inputKeyMapping = checkNotNull(sourceProperties.inputKeyMapping) { "failed to get input-key-mappings for $dName under $dSource properties" }
 
                 logger.info("$dSource dictionary information : ($sql), ($inputKeyMapping), (${sourceProperties.outputKeyMapping})")
+                val jdbcTemplate = blueprintDBLibService(sourceProperties)
 
-                val rows = primaryDBLibGenericService.query(sql, populateNamedParameter(inputKeyMapping))
+                val rows = jdbcTemplate.queryForList(sql, populateNamedParameter(inputKeyMapping))
                 if (rows.isNullOrEmpty()) {
                     logger.warn("Failed to get $dSource result for dictionary name ($dName) the query ($sql)")
                 } else {
@@ -93,16 +86,24 @@ open class PrimaryDataResourceResolutionProcessor(private val primaryDBLibGeneri
             ResourceAssignmentUtils.assertTemplateKeyValueNotNull(resourceAssignment)
         } catch (e: Exception) {
             ResourceAssignmentUtils.setFailedResourceDataValue(resourceAssignment, e.message)
-            throw BluePrintProcessorException("Failed in template key ($resourceAssignment) assignments with: ${e.message}",
-                e)
+            throw BluePrintProcessorException("Failed in template key ($resourceAssignment) assignments with: ${e.message}", e)
         }
     }
 
+    private fun blueprintDBLibService(sourceProperties: DatabaseResourceSource): NamedParameterJdbcTemplate {
+        return if (checkNotEmpty(sourceProperties.endpointSelector!!)) {
+            val dbPropertiesJson = raRuntimeService.resolveDSLExpression(sourceProperties.endpointSelector!!)
+            dBLibGenericService.remoteJdbcTemplate(dbPropertiesJson)
+        } else {
+            dBLibGenericService.primaryJdbcTemplate()
+        }
+
+    }
+
     @Throws(BluePrintProcessorException::class)
     private fun validate(resourceAssignment: ResourceAssignment) {
         checkNotEmptyOrThrow(resourceAssignment.name, "resource assignment template key is not defined")
-        checkNotEmptyOrThrow(resourceAssignment.dictionaryName,
-            "resource assignment dictionary name is not defined for template key (${resourceAssignment.name})")
+        checkNotEmptyOrThrow(resourceAssignment.dictionaryName, "resource assignment dictionary name is not defined for template key (${resourceAssignment.name})")
         checkEqualsOrThrow(ResourceDictionaryConstants.SOURCE_PRIMARY_DB, resourceAssignment.dictionarySource) {
             "resource assignment source is not ${ResourceDictionaryConstants.SOURCE_PRIMARY_DB} but it is ${resourceAssignment.dictionarySource}"
         }
@@ -111,35 +112,32 @@ open class PrimaryDataResourceResolutionProcessor(private val primaryDBLibGeneri
     private fun populateNamedParameter(inputKeyMapping: Map<String, String>): Map<String, Any> {
         val namedParameters = HashMap<String, Any>()
         inputKeyMapping.forEach {
-            val expressionValue = raRuntimeService.getDictionaryStore(it.value)
+            val expressionValue = raRuntimeService.getDictionaryStore(it.value).textValue()
             logger.trace("Reference dictionary key (${it.key}) resulted in value ($expressionValue)")
-            namedParameters[it.key] = expressionValue.asText()
+            namedParameters[it.key] = expressionValue
         }
         logger.info("Parameter information : ({})", namedParameters)
         return namedParameters
     }
 
     @Throws(BluePrintProcessorException::class)
-    private fun populateResource(resourceAssignment: ResourceAssignment, sourceProperties: DatabaseResourceSource,
-                                 rows: List<Map<String, Any>>) {
+    private fun populateResource(resourceAssignment: ResourceAssignment, sourceProperties: DatabaseResourceSource, rows: List<Map<String, Any>>) {
         val dName = resourceAssignment.dictionaryName
         val dSource = resourceAssignment.dictionarySource
         val type = nullToEmpty(resourceAssignment.property?.type)
 
-        val outputKeyMapping =
-            checkNotNull(sourceProperties.outputKeyMapping) { "failed to get output-key-mappings for $dName under $dSource properties" }
+        val outputKeyMapping = checkNotNull(sourceProperties.outputKeyMapping) { "failed to get output-key-mappings for $dName under $dSource properties" }
         logger.info("Response processing type($type)")
 
         // Primitive Types
-        when (type) {
+        when(type) {
             in BluePrintTypes.validPrimitiveTypes() -> {
                 val dbColumnValue = rows[0][outputKeyMapping[dName]]
                 logger.info("For template key (${resourceAssignment.name}) setting value as ($dbColumnValue)")
                 ResourceAssignmentUtils.setResourceDataValue(resourceAssignment, raRuntimeService, dbColumnValue)
             }
             in BluePrintTypes.validCollectionTypes() -> {
-                val entrySchemaType =
-                    returnNotEmptyOrThrow(resourceAssignment.property?.entrySchema?.type) { "Entry schema is not defined for dictionary ($dName) info" }
+                val entrySchemaType = returnNotEmptyOrThrow(resourceAssignment.property?.entrySchema?.type) { "Entry schema is not defined for dictionary ($dName) info" }
                 var arrayNode = JsonNodeFactory.instance.arrayNode()
                 rows.forEach {
                     if (entrySchemaType in BluePrintTypes.validPrimitiveTypes()) {
@@ -150,12 +148,8 @@ open class PrimaryDataResourceResolutionProcessor(private val primaryDBLibGeneri
                         val arrayChildNode = JsonNodeFactory.instance.objectNode()
                         for (mapping in outputKeyMapping.entries) {
                             val dbColumnValue = checkNotNull(it[mapping.key])
-                            val propertyTypeForDataType =
-                                ResourceAssignmentUtils.getPropertyType(raRuntimeService, entrySchemaType, mapping.key)
-                            JacksonUtils.populatePrimitiveValues(mapping.key,
-                                dbColumnValue,
-                                propertyTypeForDataType,
-                                arrayChildNode)
+                            val propertyTypeForDataType = ResourceAssignmentUtils.getPropertyType(raRuntimeService, entrySchemaType, mapping.key)
+                            JacksonUtils.populatePrimitiveValues(mapping.key, dbColumnValue, propertyTypeForDataType, arrayChildNode)
                         }
                         arrayNode.add(arrayChildNode)
                     }
@@ -170,12 +164,8 @@ open class PrimaryDataResourceResolutionProcessor(private val primaryDBLibGeneri
                 var objectNode = JsonNodeFactory.instance.objectNode()
                 for (mapping in outputKeyMapping.entries) {
                     val dbColumnValue = checkNotNull(row[mapping.key])
-                    val propertyTypeForDataType =
-                        ResourceAssignmentUtils.getPropertyType(raRuntimeService, type, mapping.key)
-                    JacksonUtils.populatePrimitiveValues(mapping.key,
-                        dbColumnValue,
-                        propertyTypeForDataType,
-                        objectNode)
+                    val propertyTypeForDataType = ResourceAssignmentUtils.getPropertyType(raRuntimeService, type, mapping.key)
+                    JacksonUtils.populatePrimitiveValues(mapping.key, dbColumnValue, propertyTypeForDataType, objectNode)
                 }
                 logger.info("For template key (${resourceAssignment.name}) setting value as ($objectNode)")
                 ResourceAssignmentUtils.setResourceDataValue(resourceAssignment, raRuntimeService, objectNode)
diff --git a/ms/blueprintsprocessor/functions/resource-resolution/src/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/functions/resource/resolution/processor/DefaultResourceResolutionProcessor.kt b/ms/blueprintsprocessor/functions/resource-resolution/src/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/functions/resource/resolution/processor/DefaultResourceResolutionProcessor.kt
index a8e0ad80e..528705f1b 100644
--- a/ms/blueprintsprocessor/functions/resource-resolution/src/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/functions/resource/resolution/processor/DefaultResourceResolutionProcessor.kt
+++ b/ms/blueprintsprocessor/functions/resource-resolution/src/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/functions/resource/resolution/processor/DefaultResourceResolutionProcessor.kt
@@ -17,6 +17,8 @@
 
 package org.onap.ccsdk.apps.blueprintsprocessor.functions.resource.resolution.processor
 
+import com.fasterxml.jackson.databind.JsonNode
+import org.onap.ccsdk.apps.blueprintsprocessor.functions.resource.resolution.ResourceResolutionConstants.PREFIX_RESOURCE_RESOLUTION_PROCESSOR
 import org.onap.ccsdk.apps.blueprintsprocessor.functions.resource.resolution.utils.ResourceAssignmentUtils
 import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintProcessorException
 import org.onap.ccsdk.apps.controllerblueprints.resource.dict.ResourceAssignment
@@ -30,20 +32,20 @@ import org.springframework.stereotype.Service
  *
  * @author Kapil Singal
  */
-@Service("rr-processor-source-default")
+@Service("${PREFIX_RESOURCE_RESOLUTION_PROCESSOR}source-default")
 @Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
 open class DefaultResourceResolutionProcessor : ResourceAssignmentProcessor() {
 
     private val logger = LoggerFactory.getLogger(DefaultResourceResolutionProcessor::class.java)
 
     override fun getName(): String {
-        return "rr-processor-source-default"
+        return "${PREFIX_RESOURCE_RESOLUTION_PROCESSOR}source-default"
     }
 
     override fun process(resourceAssignment: ResourceAssignment) {
         try {
             // Check if It has Input
-            var value: Any?
+            var value: JsonNode?
             try {
                 value = raRuntimeService.getInputValue(resourceAssignment.name)
             } catch (e: BluePrintProcessorException) {
@@ -60,7 +62,7 @@ open class DefaultResourceResolutionProcessor : ResourceAssignmentProcessor() {
         } catch (e: Exception) {
             ResourceAssignmentUtils.setFailedResourceDataValue(resourceAssignment, e.message)
             throw BluePrintProcessorException("Failed in template key ($resourceAssignment) assignments with: ${e.message}",
-                e)
+                    e)
         }
 
     }
diff --git a/ms/blueprintsprocessor/functions/resource-resolution/src/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/functions/resource/resolution/processor/InputResourceResolutionProcessor.kt b/ms/blueprintsprocessor/functions/resource-resolution/src/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/functions/resource/resolution/processor/InputResourceResolutionProcessor.kt
index ed6b09fcd..a66222281 100644
--- a/ms/blueprintsprocessor/functions/resource-resolution/src/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/functions/resource/resolution/processor/InputResourceResolutionProcessor.kt
+++ b/ms/blueprintsprocessor/functions/resource-resolution/src/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/functions/resource/resolution/processor/InputResourceResolutionProcessor.kt
@@ -17,7 +17,9 @@
 
 package org.onap.ccsdk.apps.blueprintsprocessor.functions.resource.resolution.processor
 
+import com.fasterxml.jackson.databind.node.MissingNode
 import com.fasterxml.jackson.databind.node.NullNode
+import org.onap.ccsdk.apps.blueprintsprocessor.functions.resource.resolution.ResourceResolutionConstants.PREFIX_RESOURCE_RESOLUTION_PROCESSOR
 import org.onap.ccsdk.apps.blueprintsprocessor.functions.resource.resolution.utils.ResourceAssignmentUtils
 import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintProcessorException
 import org.onap.ccsdk.apps.controllerblueprints.core.checkNotEmpty
@@ -32,14 +34,14 @@ import org.springframework.stereotype.Service
  *
  * @author Kapil Singal
  */
-@Service("rr-processor-source-input")
+@Service("${PREFIX_RESOURCE_RESOLUTION_PROCESSOR}source-input")
 @Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
 open class InputResourceResolutionProcessor : ResourceAssignmentProcessor() {
 
     private val logger = LoggerFactory.getLogger(InputResourceResolutionProcessor::class.java)
 
     override fun getName(): String {
-        return "rr-processor-source-input"
+        return "${PREFIX_RESOURCE_RESOLUTION_PROCESSOR}source-input"
     }
 
     override fun process(resourceAssignment: ResourceAssignment) {
@@ -47,7 +49,7 @@ open class InputResourceResolutionProcessor : ResourceAssignmentProcessor() {
             if (checkNotEmpty(resourceAssignment.name)) {
                 val value = raRuntimeService.getInputValue(resourceAssignment.name)
                 // if value is null don't call setResourceDataValue to populate the value
-                if (value != null && value !is NullNode) {
+                if (value !is MissingNode && value !is NullNode) {
                     logger.info("input source template key (${resourceAssignment.name}) found from input and value is ($value)")
                     ResourceAssignmentUtils.setResourceDataValue(resourceAssignment, raRuntimeService, value)
                 }
diff --git a/ms/blueprintsprocessor/functions/resource-resolution/src/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/functions/resource/resolution/processor/RestResourceResolutionProcessor.kt b/ms/blueprintsprocessor/functions/resource-resolution/src/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/functions/resource/resolution/processor/RestResourceResolutionProcessor.kt
index 4daa46e52..37b4774a7 100644
--- a/ms/blueprintsprocessor/functions/resource-resolution/src/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/functions/resource/resolution/processor/RestResourceResolutionProcessor.kt
+++ b/ms/blueprintsprocessor/functions/resource-resolution/src/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/functions/resource/resolution/processor/RestResourceResolutionProcessor.kt
@@ -19,13 +19,21 @@ package org.onap.ccsdk.apps.blueprintsprocessor.functions.resource.resolution.pr
 
 import com.fasterxml.jackson.databind.node.ArrayNode
 import com.fasterxml.jackson.databind.node.JsonNodeFactory
+import com.fasterxml.jackson.databind.node.MissingNode
 import com.fasterxml.jackson.databind.node.NullNode
 import com.fasterxml.jackson.databind.node.ObjectNode
+import org.onap.ccsdk.apps.blueprintsprocessor.functions.resource.resolution.ResourceResolutionConstants.PREFIX_RESOURCE_RESOLUTION_PROCESSOR
 import org.onap.ccsdk.apps.blueprintsprocessor.functions.resource.resolution.RestResourceSource
 import org.onap.ccsdk.apps.blueprintsprocessor.functions.resource.resolution.utils.ResourceAssignmentUtils
 import org.onap.ccsdk.apps.blueprintsprocessor.rest.service.BluePrintRestLibPropertyService
 import org.onap.ccsdk.apps.blueprintsprocessor.rest.service.BlueprintWebClientService
-import org.onap.ccsdk.apps.controllerblueprints.core.*
+import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintProcessorException
+import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintTypes
+import org.onap.ccsdk.apps.controllerblueprints.core.checkEqualsOrThrow
+import org.onap.ccsdk.apps.controllerblueprints.core.checkNotEmpty
+import org.onap.ccsdk.apps.controllerblueprints.core.checkNotEmptyOrThrow
+import org.onap.ccsdk.apps.controllerblueprints.core.nullToEmpty
+import org.onap.ccsdk.apps.controllerblueprints.core.returnNotEmptyOrThrow
 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.ResourceDictionaryConstants
@@ -39,7 +47,7 @@ import org.springframework.stereotype.Service
  *
  * @author Kapil Singal
  */
-@Service("rr-processor-source-rest")
+@Service("${PREFIX_RESOURCE_RESOLUTION_PROCESSOR}source-rest")
 @Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
 open class RestResourceResolutionProcessor(private val blueprintRestLibPropertyService: BluePrintRestLibPropertyService)
     : ResourceAssignmentProcessor() {
@@ -47,7 +55,7 @@ open class RestResourceResolutionProcessor(private val blueprintRestLibPropertyS
     private val logger = LoggerFactory.getLogger(RestResourceResolutionProcessor::class.java)
 
     override fun getName(): String {
-        return "rr-processor-source-rest"
+        return "${PREFIX_RESOURCE_RESOLUTION_PROCESSOR}source-rest"
     }
 
     override fun process(resourceAssignment: ResourceAssignment) {
@@ -56,28 +64,32 @@ open class RestResourceResolutionProcessor(private val blueprintRestLibPropertyS
 
             // Check if It has Input
             val value = raRuntimeService.getInputValue(resourceAssignment.name)
-            if (value != null && value !is NullNode) {
+            if (value !is MissingNode && value !is NullNode) {
                 logger.info("primary-db source template key (${resourceAssignment.name}) found from input and value is ($value)")
                 ResourceAssignmentUtils.setResourceDataValue(resourceAssignment, raRuntimeService, value)
             } else {
                 val dName = resourceAssignment.dictionaryName
                 val dSource = resourceAssignment.dictionarySource
                 val resourceDefinition = resourceDictionaries[dName]
-                        ?: throw BluePrintProcessorException("couldn't get resource dictionary definition for $dName")
+                    ?: throw BluePrintProcessorException("couldn't get resource dictionary definition for $dName")
                 val resourceSource = resourceDefinition.sources[dSource]
-                        ?: throw BluePrintProcessorException("couldn't get resource definition $dName source($dSource)")
-                val resourceSourceProperties = checkNotNull(resourceSource.properties) { "failed to get source properties for $dName " }
-                val sourceProperties = JacksonUtils.getInstanceFromMap(resourceSourceProperties, RestResourceSource::class.java)
-
-                val urlPath = checkNotNull(sourceProperties.urlPath) { "failed to get request urlPath for $dName under $dSource properties" }
+                    ?: throw BluePrintProcessorException("couldn't get resource definition $dName source($dSource)")
+                val resourceSourceProperties =
+                    checkNotNull(resourceSource.properties) { "failed to get source properties for $dName " }
+                val sourceProperties =
+                    JacksonUtils.getInstanceFromMap(resourceSourceProperties, RestResourceSource::class.java)
+
+                val urlPath =
+                    checkNotNull(sourceProperties.urlPath) { "failed to get request urlPath for $dName under $dSource properties" }
                 val path = nullToEmpty(sourceProperties.path)
-                val inputKeyMapping = checkNotNull(sourceProperties.inputKeyMapping) { "failed to get input-key-mappings for $dName under $dSource properties" }
+                val inputKeyMapping =
+                    checkNotNull(sourceProperties.inputKeyMapping) { "failed to get input-key-mappings for $dName under $dSource properties" }
 
                 logger.info("$dSource dictionary information : ($urlPath), ($inputKeyMapping), (${sourceProperties.outputKeyMapping})")
                 // Get the Rest Client Service
                 val restClientService = blueprintWebClientService(resourceAssignment, sourceProperties)
                 val response = restClientService.getResource(urlPath, String::class.java)
-                if (response.isNotBlank()) {
+                if (response.isBlank()) {
                     logger.warn("Failed to get $dSource result for dictionary name ($dName) using urlPath ($urlPath)")
                 } else {
                     populateResource(resourceAssignment, sourceProperties, response, path)
@@ -87,7 +99,8 @@ open class RestResourceResolutionProcessor(private val blueprintRestLibPropertyS
             ResourceAssignmentUtils.assertTemplateKeyValueNotNull(resourceAssignment)
         } catch (e: Exception) {
             ResourceAssignmentUtils.setFailedResourceDataValue(resourceAssignment, e.message)
-            throw BluePrintProcessorException("Failed in template key ($resourceAssignment) assignments with: ${e.message}", e)
+            throw BluePrintProcessorException("Failed in template key ($resourceAssignment) assignments with: ${e.message}",
+                e)
         }
     }
 
@@ -102,16 +115,19 @@ open class RestResourceResolutionProcessor(private val blueprintRestLibPropertyS
     }
 
     @Throws(BluePrintProcessorException::class)
-    private fun populateResource(resourceAssignment: ResourceAssignment, sourceProperties: RestResourceSource, restResponse: String, path: String) {
+    private fun populateResource(resourceAssignment: ResourceAssignment, sourceProperties: RestResourceSource,
+                                 restResponse: String, path: String) {
         val dName = resourceAssignment.dictionaryName
         val dSource = resourceAssignment.dictionarySource
         val type = nullToEmpty(resourceAssignment.property?.type)
         lateinit var entrySchemaType: String
 
-        val outputKeyMapping = checkNotNull(sourceProperties.outputKeyMapping) { "failed to get output-key-mappings for $dName under $dSource properties" }
+        val outputKeyMapping =
+            checkNotNull(sourceProperties.outputKeyMapping) { "failed to get output-key-mappings for $dName under $dSource properties" }
         logger.info("Response processing type($type)")
 
-        val responseNode = checkNotNull(JacksonUtils.jsonNode(restResponse).at(path)) { "Failed to find path ($path) in response ($restResponse)" }
+        val responseNode =
+            checkNotNull(JacksonUtils.jsonNode(restResponse).at(path)) { "Failed to find path ($path) in response ($restResponse)" }
         logger.info("populating value for output mapping ($outputKeyMapping), from json ($responseNode)")
 
 
@@ -122,7 +138,8 @@ open class RestResourceResolutionProcessor(private val blueprintRestLibPropertyS
             }
             in BluePrintTypes.validCollectionTypes() -> {
                 // Array Types
-                entrySchemaType = returnNotEmptyOrThrow(resourceAssignment.property?.entrySchema?.type) { "Entry schema is not defined for dictionary ($dName) info" }
+                entrySchemaType =
+                    returnNotEmptyOrThrow(resourceAssignment.property?.entrySchema?.type) { "Entry schema is not defined for dictionary ($dName) info" }
                 val arrayNode = responseNode as ArrayNode
 
                 if (entrySchemaType !in BluePrintTypes.validPrimitiveTypes()) {
@@ -131,9 +148,13 @@ open class RestResourceResolutionProcessor(private val blueprintRestLibPropertyS
                         val arrayChildNode = JsonNodeFactory.instance.objectNode()
                         outputKeyMapping.map {
                             val responseKeyValue = responseSingleJsonNode.get(it.key)
-                            val propertyTypeForDataType = ResourceAssignmentUtils.getPropertyType(raRuntimeService, entrySchemaType, it.key)
+                            val propertyTypeForDataType =
+                                ResourceAssignmentUtils.getPropertyType(raRuntimeService, entrySchemaType, it.key)
                             logger.info("For List Type Resource: key (${it.key}), value ($responseKeyValue), type  ({$propertyTypeForDataType})")
-                            JacksonUtils.populateJsonNodeValues(it.value, responseKeyValue, propertyTypeForDataType, arrayChildNode)
+                            JacksonUtils.populateJsonNodeValues(it.value,
+                                responseKeyValue,
+                                propertyTypeForDataType,
+                                arrayChildNode)
                         }
                         arrayNode.add(arrayChildNode)
                     }
@@ -147,7 +168,8 @@ open class RestResourceResolutionProcessor(private val blueprintRestLibPropertyS
                 val objectNode = responseNode as ObjectNode
                 outputKeyMapping.map {
                     val responseKeyValue = responseNode.get(it.key)
-                    val propertyTypeForDataType = ResourceAssignmentUtils.getPropertyType(raRuntimeService, entrySchemaType, it.key)
+                    val propertyTypeForDataType =
+                        ResourceAssignmentUtils.getPropertyType(raRuntimeService, entrySchemaType, it.key)
                     logger.info("For List Type Resource: key (${it.key}), value ($responseKeyValue), type  ({$propertyTypeForDataType})")
                     JacksonUtils.populateJsonNodeValues(it.value, responseKeyValue, propertyTypeForDataType, objectNode)
                 }
@@ -162,11 +184,14 @@ open class RestResourceResolutionProcessor(private val blueprintRestLibPropertyS
     @Throws(BluePrintProcessorException::class)
     private fun validate(resourceAssignment: ResourceAssignment) {
         checkNotEmptyOrThrow(resourceAssignment.name, "resource assignment template key is not defined")
-        checkNotEmptyOrThrow(resourceAssignment.dictionaryName, "resource assignment dictionary name is not defined for template key (${resourceAssignment.name})")
-        checkEqualsOrThrow(ResourceDictionaryConstants.SOURCE_PRIMARY_CONFIG_DATA, resourceAssignment.dictionarySource) {
+        checkNotEmptyOrThrow(resourceAssignment.dictionaryName,
+            "resource assignment dictionary name is not defined for template key (${resourceAssignment.name})")
+        checkEqualsOrThrow(ResourceDictionaryConstants.SOURCE_PRIMARY_CONFIG_DATA,
+            resourceAssignment.dictionarySource) {
             "resource assignment source is not ${ResourceDictionaryConstants.SOURCE_PRIMARY_CONFIG_DATA} but it is ${resourceAssignment.dictionarySource}"
         }
-        checkNotEmptyOrThrow(resourceAssignment.dictionaryName, "resource assignment dictionary name is not defined for template key (${resourceAssignment.name})")
+        checkNotEmptyOrThrow(resourceAssignment.dictionaryName,
+            "resource assignment dictionary name is not defined for template key (${resourceAssignment.name})")
     }
 
     override fun recover(runtimeException: RuntimeException, resourceAssignment: ResourceAssignment) {
diff --git a/ms/blueprintsprocessor/functions/resource-resolution/src/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/functions/resource/resolution/utils/ResourceAssignmentUtils.kt b/ms/blueprintsprocessor/functions/resource-resolution/src/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/functions/resource/resolution/utils/ResourceAssignmentUtils.kt
index 1c9a905fd..b5b126ab6 100644
--- a/ms/blueprintsprocessor/functions/resource-resolution/src/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/functions/resource/resolution/utils/ResourceAssignmentUtils.kt
+++ b/ms/blueprintsprocessor/functions/resource-resolution/src/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/functions/resource/resolution/utils/ResourceAssignmentUtils.kt
@@ -1,5 +1,6 @@
 /*
  * Copyright © 2017-2018 AT&T Intellectual Property.
+ * Modifications Copyright © 2019 IBM.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -23,13 +24,7 @@ import com.fasterxml.jackson.databind.ObjectMapper
 import com.fasterxml.jackson.databind.node.NullNode
 import com.fasterxml.jackson.databind.node.ObjectNode
 import org.onap.ccsdk.apps.blueprintsprocessor.functions.resource.resolution.ResourceAssignmentRuntimeService
-import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintConstants
-import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintProcessorException
-import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintTypes
-import org.onap.ccsdk.apps.controllerblueprints.core.checkNotEmpty
-import org.onap.ccsdk.apps.controllerblueprints.core.checkNotEmptyOrThrow
-import org.onap.ccsdk.apps.controllerblueprints.core.nullToEmpty
-import org.onap.ccsdk.apps.controllerblueprints.core.returnNotEmptyOrThrow
+import org.onap.ccsdk.apps.controllerblueprints.core.*
 import org.onap.ccsdk.apps.controllerblueprints.core.service.BluePrintRuntimeService
 import org.onap.ccsdk.apps.controllerblueprints.core.utils.JacksonUtils
 import org.onap.ccsdk.apps.controllerblueprints.resource.dict.ResourceAssignment
@@ -40,9 +35,11 @@ class ResourceAssignmentUtils {
 
         private val logger: EELFLogger = EELFManager.getInstance().getLogger(ResourceAssignmentUtils::class.toString())
 
+        // TODO("Modify Value type from Any to JsonNode")
         @Synchronized
         @Throws(BluePrintProcessorException::class)
-        fun setResourceDataValue(resourceAssignment: ResourceAssignment, raRuntimeService: ResourceAssignmentRuntimeService, value: Any?) {
+        fun setResourceDataValue(resourceAssignment: ResourceAssignment,
+                                 raRuntimeService: ResourceAssignmentRuntimeService, value: Any?) {
 
             val resourceProp = checkNotNull(resourceAssignment.property) { "Failed in setting resource value for resource mapping $resourceAssignment" }
             checkNotEmptyOrThrow(resourceAssignment.name, "Failed in setting resource value for resource mapping $resourceAssignment")
@@ -111,10 +108,10 @@ class ResourceAssignmentUtils {
         @Synchronized
         @Throws(BluePrintProcessorException::class)
         fun generateResourceDataForAssignments(assignments: List<ResourceAssignment>): String {
-            var result = "{}"
+            val result: String
             try {
                 val mapper = ObjectMapper()
-                val root = mapper.readTree(result)
+                val root: ObjectNode = mapper.createObjectNode()
 
                 assignments.forEach {
                     if (checkNotEmpty(it.name) && it.property != null) {
@@ -122,23 +119,7 @@ class ResourceAssignmentUtils {
                         val type = nullToEmpty(it.property?.type).toLowerCase()
                         val value = it.property?.value
                         logger.info("Generating Resource name ($rName), type ($type), value ($value)")
-
-                        when (value) {
-                            null -> (root as ObjectNode).set(rName, null)
-                            is JsonNode -> (root as ObjectNode).set(rName, value)
-                            else -> {
-                                when (type) {
-                                    BluePrintConstants.DATA_TYPE_TIMESTAMP -> (root as ObjectNode).put(rName, value as String)
-                                    BluePrintConstants.DATA_TYPE_STRING -> (root as ObjectNode).put(rName, value as String)
-                                    BluePrintConstants.DATA_TYPE_BOOLEAN -> (root as ObjectNode).put(rName, value as Boolean)
-                                    BluePrintConstants.DATA_TYPE_INTEGER -> (root as ObjectNode).put(rName, value as Int)
-                                    BluePrintConstants.DATA_TYPE_FLOAT -> (root as ObjectNode).put(rName, value as Float)
-                                    else -> {
-                                        (root as ObjectNode).set(rName, JacksonUtils.getJsonNode(value))
-                                    }
-                                }
-                            }
-                        }
+                        root.set(rName, value)
                     }
                 }
                 result = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(root)
diff --git a/ms/blueprintsprocessor/functions/resource-resolution/src/test/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/functions/resource/resolution/ResourceResolutionComponentTest.kt b/ms/blueprintsprocessor/functions/resource-resolution/src/test/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/functions/resource/resolution/ResourceResolutionComponentTest.kt
index c3b101840..b3e3e4ed3 100644
--- a/ms/blueprintsprocessor/functions/resource-resolution/src/test/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/functions/resource/resolution/ResourceResolutionComponentTest.kt
+++ b/ms/blueprintsprocessor/functions/resource-resolution/src/test/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/functions/resource/resolution/ResourceResolutionComponentTest.kt
@@ -25,7 +25,7 @@ import org.onap.ccsdk.apps.blueprintsprocessor.core.BlueprintPropertyConfigurati
 import org.onap.ccsdk.apps.blueprintsprocessor.core.api.data.ExecutionServiceInput
 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.PrimaryDBLibGenericService
+import org.onap.ccsdk.apps.blueprintsprocessor.db.primary.DBLibGenericService
 import org.onap.ccsdk.apps.blueprintsprocessor.functions.resource.resolution.processor.*
 import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintConstants
 import org.onap.ccsdk.apps.controllerblueprints.core.asJsonNode
@@ -43,8 +43,8 @@ import org.springframework.test.context.junit4.SpringRunner
 @RunWith(SpringRunner::class)
 @ContextConfiguration(classes = [ResourceResolutionServiceImpl::class,
     InputResourceResolutionProcessor::class, DefaultResourceResolutionProcessor::class,
-    PrimaryDataResourceResolutionProcessor::class, RestResourceResolutionProcessor::class,
-    CapabilityResourceResolutionProcessor::class, PrimaryDBLibGenericService::class,
+    DatabaseResourceAssignmentProcessor::class, RestResourceResolutionProcessor::class,
+    CapabilityResourceResolutionProcessor::class, DBLibGenericService::class,
     BlueprintPropertyConfiguration::class, BluePrintProperties::class,
     BluePrintDBLibConfiguration::class, BluePrintLoadConfiguration::class])
 @TestPropertySource(locations = ["classpath:application-test.properties"])
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 6d2d3f2df..905c8e0b3 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
@@ -25,8 +25,12 @@ import org.onap.ccsdk.apps.blueprintsprocessor.core.BlueprintPropertyConfigurati
 import org.onap.ccsdk.apps.blueprintsprocessor.core.api.data.ExecutionServiceInput
 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.PrimaryDBLibGenericService
-import org.onap.ccsdk.apps.blueprintsprocessor.functions.resource.resolution.processor.*
+import org.onap.ccsdk.apps.blueprintsprocessor.db.primary.DBLibGenericService
+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
@@ -48,8 +52,8 @@ import kotlin.test.assertTrue
 @RunWith(SpringRunner::class)
 @ContextConfiguration(classes = [ResourceResolutionServiceImpl::class,
     InputResourceResolutionProcessor::class, DefaultResourceResolutionProcessor::class,
-    PrimaryDataResourceResolutionProcessor::class, RestResourceResolutionProcessor::class,
-    CapabilityResourceResolutionProcessor::class, PrimaryDBLibGenericService::class,
+    DatabaseResourceAssignmentProcessor::class, RestResourceResolutionProcessor::class,
+    CapabilityResourceResolutionProcessor::class, DBLibGenericService::class,
     BlueprintPropertyConfiguration::class, BluePrintProperties::class,
     BluePrintDBLibConfiguration::class, BluePrintLoadConfiguration::class])
 @TestPropertySource(locations = ["classpath:application-test.properties"])
@@ -67,7 +71,7 @@ class ResourceResolutionServiceTest {
         val sources = resourceResolutionService.registeredResourceSources()
         assertNotNull(sources, "failed to get registered sources")
         assertTrue(sources.containsAll(arrayListOf("source-input", "source-default", "source-primary-db",
-                "source-rest")), "failed to get registered sources")
+                "source-rest")), "failed to get registered sources : $sources")
     }
 
     @Test
@@ -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())
 
     }
 
diff --git a/ms/blueprintsprocessor/functions/resource-resolution/src/test/resources/application-test.properties b/ms/blueprintsprocessor/functions/resource-resolution/src/test/resources/application-test.properties
index e2785c8a3..3f37d1b9e 100644
--- a/ms/blueprintsprocessor/functions/resource-resolution/src/test/resources/application-test.properties
+++ b/ms/blueprintsprocessor/functions/resource-resolution/src/test/resources/application-test.properties
@@ -35,4 +35,9 @@ blueprintsprocessor.restclient.primary-config-data.token=sampletoken
 
 # Python executor
 blueprints.processor.functions.python.executor.executionPath=./../../../../components/scripts/python/ccsdk_blueprints
-blueprints.processor.functions.python.executor.modulePaths=./../../../../components/scripts/python/ccsdk_blueprints
\ No newline at end of file
+blueprints.processor.functions.python.executor.modulePaths=./../../../../components/scripts/python/ccsdk_blueprints
+
+
+# CBA examples for tests cases
+controllerblueprints.loadBlueprintsExamplesPath=./../../../../components/model-catalog/blueprint-model/test-blueprint
+controllerblueprints.loadBluePrintPaths=./../../../../components/model-catalog/blueprint-model/test-blueprint
\ No newline at end of file
diff --git a/ms/blueprintsprocessor/functions/resource-resolution/src/test/resources/payload/requests/sample-resourceresolution-request.json b/ms/blueprintsprocessor/functions/resource-resolution/src/test/resources/payload/requests/sample-resourceresolution-request.json
index c4fe4eab5..6a7b4c2a2 100644
--- a/ms/blueprintsprocessor/functions/resource-resolution/src/test/resources/payload/requests/sample-resourceresolution-request.json
+++ b/ms/blueprintsprocessor/functions/resource-resolution/src/test/resources/payload/requests/sample-resourceresolution-request.json
@@ -19,6 +19,7 @@
     "resource-assignment-request": {

       "resource-assignment-properties": {

         "request-id": "1234",

+        "profile_name": "1.0.0",

         "service-instance-id": "siid_1234",

         "vnf-id": "vnf_1234",

         "action-name": "assign-activate",

diff --git a/ms/blueprintsprocessor/functions/restconf-executor/pom.xml b/ms/blueprintsprocessor/functions/restconf-executor/pom.xml
index cee90b6e6..b87b29485 100644
--- a/ms/blueprintsprocessor/functions/restconf-executor/pom.xml
+++ b/ms/blueprintsprocessor/functions/restconf-executor/pom.xml
@@ -34,6 +34,11 @@
             <groupId>org.onap.ccsdk.apps.blueprintsprocessor.functions</groupId>
             <artifactId>resource-resolution</artifactId>
         </dependency>
+        <dependency>
+            <groupId>com.h2database</groupId>
+            <artifactId>h2</artifactId>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
 
 
diff --git a/ms/blueprintsprocessor/functions/restconf-executor/src/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/functions/restconf/executor/RestconfComponentFunction.kt b/ms/blueprintsprocessor/functions/restconf-executor/src/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/functions/restconf/executor/RestconfComponentFunction.kt
index c6afc3b87..c3f2253af 100644
--- a/ms/blueprintsprocessor/functions/restconf-executor/src/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/functions/restconf/executor/RestconfComponentFunction.kt
+++ b/ms/blueprintsprocessor/functions/restconf-executor/src/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/functions/restconf/executor/RestconfComponentFunction.kt
@@ -17,6 +17,7 @@
 
 package org.onap.ccsdk.apps.blueprintsprocessor.functions.restconf.executor
 
+import com.fasterxml.jackson.databind.JsonNode
 import org.onap.ccsdk.apps.blueprintsprocessor.functions.resource.resolution.ResourceResolutionConstants
 import org.onap.ccsdk.apps.blueprintsprocessor.functions.resource.resolution.ResourceResolutionService
 import org.onap.ccsdk.apps.blueprintsprocessor.rest.RestLibConstants
@@ -38,6 +39,14 @@ abstract class RestconfComponentFunction : AbstractComponentFunction() {
         return bluePrintRestLibPropertyService().blueprintWebClientService(selector)
     }
 
+    fun getDynamicProperties(key: String): JsonNode {
+        return operationInputs["dynamic-properties"]!!.get(key)
+    }
+
+    fun resolveFromDatabase(resolutionKey: String, artifactName: String): String {
+        return resourceResolutionService().resolveFromDatabase(bluePrintRuntimeService, artifactName, resolutionKey)
+    }
+
     fun generateMessage(artifactName: String): String {
         return bluePrintRuntimeService.resolveNodeTemplateArtifact(nodeTemplateName, artifactName)
     }
@@ -49,6 +58,6 @@ abstract class RestconfComponentFunction : AbstractComponentFunction() {
 
     fun resolveAndGenerateMessage(artifactPrefix: String): String {
         return resourceResolutionService().resolveResources(bluePrintRuntimeService, nodeTemplateName,
-                artifactPrefix)
+                artifactPrefix, mapOf())
     }
 }
\ No newline at end of file
diff --git a/ms/blueprintsprocessor/functions/restconf-executor/src/test/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/functions/restconf/executor/ComponentRestconfExecutorTest.kt b/ms/blueprintsprocessor/functions/restconf-executor/src/test/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/functions/restconf/executor/ComponentRestconfExecutorTest.kt
index c8a2090b1..5d903bc72 100644
--- a/ms/blueprintsprocessor/functions/restconf-executor/src/test/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/functions/restconf/executor/ComponentRestconfExecutorTest.kt
+++ b/ms/blueprintsprocessor/functions/restconf-executor/src/test/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/functions/restconf/executor/ComponentRestconfExecutorTest.kt
@@ -23,42 +23,35 @@ import io.mockk.every
 import io.mockk.mockk
 import org.junit.Test
 import org.junit.runner.RunWith
-import org.onap.ccsdk.apps.blueprintsprocessor.core.BluePrintProperties
-import org.onap.ccsdk.apps.blueprintsprocessor.core.BlueprintPropertyConfiguration
 import org.onap.ccsdk.apps.blueprintsprocessor.core.api.data.ActionIdentifiers
 import org.onap.ccsdk.apps.blueprintsprocessor.core.api.data.CommonHeader
 import org.onap.ccsdk.apps.blueprintsprocessor.core.api.data.ExecutionServiceInput
-import org.onap.ccsdk.apps.blueprintsprocessor.functions.resource.resolution.ResourceResolutionServiceImpl
-import org.onap.ccsdk.apps.blueprintsprocessor.rest.service.BluePrintRestLibPropertyService
-import org.onap.ccsdk.apps.blueprintsprocessor.services.execution.ComponentFunctionScriptingService
-import org.onap.ccsdk.apps.blueprintsprocessor.services.execution.scripts.BlueprintJythonService
-import org.onap.ccsdk.apps.blueprintsprocessor.services.execution.scripts.PythonExecutorProperty
 import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintConstants
 import org.onap.ccsdk.apps.controllerblueprints.core.asJsonNode
 import org.onap.ccsdk.apps.controllerblueprints.core.asJsonPrimitive
 import org.onap.ccsdk.apps.controllerblueprints.core.service.BluePrintContext
 import org.onap.ccsdk.apps.controllerblueprints.core.service.DefaultBluePrintRuntimeService
 import org.onap.ccsdk.apps.controllerblueprints.core.utils.JacksonUtils
-import org.onap.ccsdk.apps.controllerblueprints.scripts.BluePrintScriptsServiceImpl
 import org.springframework.beans.factory.annotation.Autowired
-import org.springframework.test.context.ContextConfiguration
+import org.springframework.boot.autoconfigure.EnableAutoConfiguration
+import org.springframework.context.annotation.ComponentScan
+import org.springframework.test.annotation.DirtiesContext
 import org.springframework.test.context.TestPropertySource
 import org.springframework.test.context.junit4.SpringRunner
 import kotlin.test.assertNotNull
 
-
 @RunWith(SpringRunner::class)
-@ContextConfiguration(classes = [RestconfExecutorConfiguration::class, ComponentRestconfExecutor::class,
-    BlueprintJythonService::class, PythonExecutorProperty::class, BluePrintRestLibPropertyService::class,
-    BlueprintPropertyConfiguration::class, BluePrintProperties::class, BluePrintScriptsServiceImpl::class,
-    ResourceResolutionServiceImpl::class, ComponentFunctionScriptingService::class])
+@EnableAutoConfiguration
+@ComponentScan(basePackages = ["org.onap.ccsdk.apps.blueprintsprocessor", "org.onap.ccsdk.apps.controllerblueprints"])
+@DirtiesContext
 @TestPropertySource(properties =
 ["server.port=9111",
     "blueprintsprocessor.restconfEnabled=true",
     "blueprintsprocessor.restclient.odlPrimary.type=basic-auth",
     "blueprintsprocessor.restclient.odlPrimary.url=http://127.0.0.1:9111",
     "blueprintsprocessor.restclient.odlPrimary.userId=sampleuser",
-    "blueprintsprocessor.restclient.odlPrimary.token=sampletoken"])
+    "blueprintsprocessor.restclient.odlPrimary.token=sampletoken"],
+    locations = ["classpath:application-test.properties"])
 class ComponentRestconfExecutorTest {
 
     @Autowired
@@ -85,7 +78,8 @@ class ComponentRestconfExecutorTest {
         operationInputs[BluePrintConstants.PROPERTY_CURRENT_INTERFACE] = "interfaceName".asJsonPrimitive()
         operationInputs[BluePrintConstants.PROPERTY_CURRENT_OPERATION] = "operationName".asJsonPrimitive()
         operationInputs[ComponentRestconfExecutor.SCRIPT_TYPE] = BluePrintConstants.SCRIPT_INTERNAL.asJsonPrimitive()
-        operationInputs[ComponentRestconfExecutor.SCRIPT_CLASS_REFERENCE] = "InternalSimpleRestconf_cba\$TestRestconfConfigure".asJsonPrimitive()
+        operationInputs[ComponentRestconfExecutor.SCRIPT_CLASS_REFERENCE] =
+            "InternalSimpleRestconf_cba\$TestRestconfConfigure".asJsonPrimitive()
         operationInputs[ComponentRestconfExecutor.INSTANCE_DEPENDENCIES] = JacksonUtils.jsonNode("[]") as ArrayNode
 
         val blueprintContext = mockk<BluePrintContext>()
@@ -93,13 +87,13 @@ class ComponentRestconfExecutorTest {
         every { bluePrintRuntime.get("sample-step-step-inputs") } returns operationInputs.asJsonNode()
         every {
             bluePrintRuntime.resolveNodeTemplateInterfaceOperationInputs("activate-restconf",
-                    "interfaceName", "operationName")
+                "interfaceName", "operationName")
         } returns operationInputs
 
         val operationOutputs = hashMapOf<String, JsonNode>()
         every {
             bluePrintRuntime.resolveNodeTemplateInterfaceOperationOutputs("activate-restconf",
-                    "interfaceName", "operationName")
+                "interfaceName", "operationName")
         } returns operationOutputs
         every { bluePrintRuntime.put("sample-step-step-outputs", any()) } returns Unit
 
diff --git a/ms/blueprintsprocessor/functions/restconf-executor/src/test/resources/application-test.properties b/ms/blueprintsprocessor/functions/restconf-executor/src/test/resources/application-test.properties
new file mode 100644
index 000000000..6d8b62ff9
--- /dev/null
+++ b/ms/blueprintsprocessor/functions/restconf-executor/src/test/resources/application-test.properties
@@ -0,0 +1,32 @@
+#
+# Copyright © 2017-2018 AT&T Intellectual Property.
+#
+# Modifications Copyright © 2019 IBM, 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.
+#
+blueprintsprocessor.db.primary.url=jdbc:h2:mem:testdb;DB_CLOSE_DELAY=-1
+blueprintsprocessor.db.primary.username=sa
+blueprintsprocessor.db.primary.password=
+blueprintsprocessor.db.primary.driverClassName=org.h2.Driver
+blueprintsprocessor.db.primary.hibernateHbm2ddlAuto=create-drop
+blueprintsprocessor.db.primary.hibernateDDLAuto=update
+blueprintsprocessor.db.primary.hibernateNamingStrategy=org.hibernate.cfg.ImprovedNamingStrategy
+blueprintsprocessor.db.primary.hibernateDialect=org.hibernate.dialect.H2Dialect
+# Controller Blueprints Core Configuration
+blueprintsprocessor.blueprintDeployPath=./target/blueprints/deploy
+blueprintsprocessor.blueprintArchivePath=./target/blueprints/archive
+
+# Python executor
+blueprints.processor.functions.python.executor.executionPath=./../../../../components/scripts/python/ccsdk_blueprints
+blueprints.processor.functions.python.executor.modulePaths=./../../../../components/scripts/python/ccsdk_blueprints
diff --git a/ms/blueprintsprocessor/modules/commons/db-lib/src/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/db/BluePrintDBLibConfiguration.kt b/ms/blueprintsprocessor/modules/commons/db-lib/src/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/db/BluePrintDBLibConfiguration.kt
index 0bdee9be5..276ece139 100644
--- a/ms/blueprintsprocessor/modules/commons/db-lib/src/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/db/BluePrintDBLibConfiguration.kt
+++ b/ms/blueprintsprocessor/modules/commons/db-lib/src/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/db/BluePrintDBLibConfiguration.kt
@@ -37,5 +37,19 @@ open class BluePrintDBLibConfiguration(private var bluePrintProperties: BluePrin
 class DBLibConstants {
     companion object {
         const val PREFIX_DB_PRIMARY: String = "blueprintsprocessor.db.primary"
+
+        //list of database
+        const val MARIA_DB: String = "maria-db"
+        const val MYSQL_DB: String = "mysql-db"
+        const val ORACLE_DB: String = "oracle-db"
+        const val POSTGRES_DB: String = "postgres-db"
+
+        //List of database drivers
+        const val DRIVER_MARIA_DB = "org.mariadb.jdbc.Driver"
+        const val DRIVER_MYSQL_DB = "com.mysql.jdbc.Driver"
+        const val DRIVER_ORACLE_DB = "oracle.jdbc.driver.OracleDriver"
+        const val DRIVER_POSTGRES_DB = "org.postgresql.Driver"
+
+
     }
 }
\ No newline at end of file
diff --git a/ms/blueprintsprocessor/modules/commons/db-lib/src/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/db/primary/DBLibGenericService.kt b/ms/blueprintsprocessor/modules/commons/db-lib/src/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/db/primary/DBLibGenericService.kt
new file mode 100644
index 000000000..af7ab0547
--- /dev/null
+++ b/ms/blueprintsprocessor/modules/commons/db-lib/src/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/db/primary/DBLibGenericService.kt
@@ -0,0 +1,72 @@
+/*
+ * 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.db.primary
+
+import com.fasterxml.jackson.databind.JsonNode
+import org.onap.ccsdk.apps.blueprintsprocessor.db.AbstractDBLibGenericService
+import org.onap.ccsdk.apps.blueprintsprocessor.db.DBLibConstants
+import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintProcessorException
+import org.springframework.boot.jdbc.DataSourceBuilder
+import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate
+import org.springframework.stereotype.Service
+
+@Service
+open class DBLibGenericService(primaryNamedParameterJdbcTemplate: NamedParameterJdbcTemplate)
+    : AbstractDBLibGenericService(primaryNamedParameterJdbcTemplate) {
+
+    fun primaryJdbcTemplate():NamedParameterJdbcTemplate{
+        return namedParameterJdbcTemplate()
+    }
+
+    fun remoteJdbcTemplate(jsonNode: JsonNode): NamedParameterJdbcTemplate {
+        val type = jsonNode.get("type").textValue()
+        val driverDB: String
+
+        return when (type) {
+            DBLibConstants.MARIA_DB -> {
+                driverDB = DBLibConstants.DRIVER_MARIA_DB
+                jdbcTemplate(jsonNode, driverDB)
+            }
+            DBLibConstants.MYSQL_DB -> {
+                driverDB = DBLibConstants.DRIVER_MYSQL_DB
+                jdbcTemplate(jsonNode, driverDB)
+            }
+            DBLibConstants.ORACLE_DB -> {
+                driverDB = DBLibConstants.DRIVER_ORACLE_DB
+                jdbcTemplate(jsonNode, driverDB)
+            }
+            DBLibConstants.POSTGRES_DB -> {
+                driverDB = DBLibConstants.DRIVER_POSTGRES_DB
+                jdbcTemplate(jsonNode, driverDB)
+            }
+            else -> {
+                throw BluePrintProcessorException("Rest adaptor($type) is not supported")
+            }
+        }
+    }
+
+    fun jdbcTemplate(jsonNode: JsonNode, driver: String): NamedParameterJdbcTemplate {
+        val dataSourceBuilder = DataSourceBuilder
+                .create()
+                .username(jsonNode.get("username").textValue())
+                .password(jsonNode.get("password").textValue())
+                .url(jsonNode.get("url").textValue())
+                .driverClassName(driver)
+                .build()
+        return NamedParameterJdbcTemplate(dataSourceBuilder)
+    }
+}
\ No newline at end of file
diff --git a/ms/blueprintsprocessor/modules/commons/db-lib/src/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/db/primary/PrimaryDBLibGenericService.kt b/ms/blueprintsprocessor/modules/commons/db-lib/src/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/db/primary/PrimaryDBLibGenericService.kt
deleted file mode 100644
index 0e0f1e9c1..000000000
--- a/ms/blueprintsprocessor/modules/commons/db-lib/src/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/db/primary/PrimaryDBLibGenericService.kt
+++ /dev/null
@@ -1,28 +0,0 @@
-/*
- * 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.db.primary
-
-import org.onap.ccsdk.apps.blueprintsprocessor.db.AbstractDBLibGenericService
-import org.onap.ccsdk.apps.blueprintsprocessor.db.BluePrintDBLibGenericService
-import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate
-import org.springframework.stereotype.Service
-
-@Service
-open class PrimaryDBLibGenericService(private val primaryNamedParameterJdbcTemplate: NamedParameterJdbcTemplate)
-    : AbstractDBLibGenericService(primaryNamedParameterJdbcTemplate) {
-
-}
\ No newline at end of file
diff --git a/ms/blueprintsprocessor/modules/commons/db-lib/src/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/db/primary/PrimaryDatabaseConfiguration.kt b/ms/blueprintsprocessor/modules/commons/db-lib/src/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/db/primary/PrimaryDatabaseConfiguration.kt
index 98b6221d6..4039b053b 100644
--- a/ms/blueprintsprocessor/modules/commons/db-lib/src/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/db/primary/PrimaryDatabaseConfiguration.kt
+++ b/ms/blueprintsprocessor/modules/commons/db-lib/src/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/db/primary/PrimaryDatabaseConfiguration.kt
@@ -33,9 +33,9 @@ import javax.sql.DataSource
 
 @Configuration
 @EnableJpaRepositories(
-        basePackages = ["org.onap.ccsdk.apps.blueprintsprocessor.db.primary"],
-        entityManagerFactoryRef = "primaryEntityManager",
-        transactionManagerRef = "primaryTransactionManager"
+    basePackages = ["org.onap.ccsdk.apps.blueprintsprocessor.*"],
+    entityManagerFactoryRef = "primaryEntityManager",
+    transactionManagerRef = "primaryTransactionManager"
 )
 open class PrimaryDatabaseConfiguration(private val primaryDataSourceProperties: PrimaryDataSourceProperties) {
     val log = LoggerFactory.getLogger(PrimaryDatabaseConfiguration::class.java)!!
@@ -45,10 +45,8 @@ open class PrimaryDatabaseConfiguration(private val primaryDataSourceProperties:
     open fun primaryEntityManager(): LocalContainerEntityManagerFactoryBean {
         val em = LocalContainerEntityManagerFactoryBean()
         em.dataSource = primaryDataSource()
-        em.setPackagesToScan("org.onap.ccsdk.apps.blueprintsprocessor.db.primary")
-
-        val vendorAdapter = HibernateJpaVendorAdapter()
-        em.jpaVendorAdapter = vendorAdapter
+        em.setPackagesToScan("org.onap.ccsdk.apps.blueprintsprocessor.*")
+        em.jpaVendorAdapter = HibernateJpaVendorAdapter()
         val properties = HashMap<String, Any>()
         properties["hibernate.hbm2ddl.auto"] = primaryDataSourceProperties.hibernateHbm2ddlAuto
         properties["hibernate.dialect"] = primaryDataSourceProperties.hibernateDialect
diff --git a/ms/blueprintsprocessor/modules/inbounds/pom.xml b/ms/blueprintsprocessor/modules/inbounds/pom.xml
index 1384b8a10..d7c0cc4f3 100644
--- a/ms/blueprintsprocessor/modules/inbounds/pom.xml
+++ b/ms/blueprintsprocessor/modules/inbounds/pom.xml
@@ -45,6 +45,17 @@
             <artifactId>spring-boot-starter-actuator</artifactId>
         </dependency>
 
+        <!-- Test Dependencies -->
+        <dependency>
+            <groupId>io.mockk</groupId>
+            <artifactId>mockk</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.powermock</groupId>
+            <artifactId>powermock-api-mockito2</artifactId>
+            <scope>test</scope>
+        </dependency>
         <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-test</artifactId>
@@ -55,8 +66,14 @@
             <artifactId>kotlin-test-junit</artifactId>
         </dependency>
         <dependency>
-            <groupId>org.powermock</groupId>
-            <artifactId>powermock-api-mockito2</artifactId>
+            <groupId>org.jetbrains.kotlinx</groupId>
+            <artifactId>kotlinx-coroutines-test</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>io.projectreactor</groupId>
+            <artifactId>reactor-test</artifactId>
+            <scope>test</scope>
         </dependency>
     </dependencies>
 </project>
diff --git a/ms/blueprintsprocessor/modules/inbounds/selfservice-api/src/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/selfservice/api/validation/BluePrintDesignTimeRuntimeValidatorService.kt b/ms/blueprintsprocessor/modules/inbounds/selfservice-api/src/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/selfservice/api/validation/BluePrintRuntimeValidatorService.kt
index 08d2c3b5b..100bd320b 100644
--- a/ms/blueprintsprocessor/modules/inbounds/selfservice-api/src/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/selfservice/api/validation/BluePrintDesignTimeRuntimeValidatorService.kt
+++ b/ms/blueprintsprocessor/modules/inbounds/selfservice-api/src/main/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/selfservice/api/validation/BluePrintRuntimeValidatorService.kt
@@ -16,23 +16,12 @@
 
 package org.onap.ccsdk.apps.blueprintsprocessor.selfservice.api.validation
 
-import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintException
 import org.onap.ccsdk.apps.controllerblueprints.core.interfaces.BluePrintTypeValidatorService
-import org.onap.ccsdk.apps.controllerblueprints.core.service.BluePrintRuntimeService
 import org.onap.ccsdk.apps.controllerblueprints.validation.BluePrintDesignTimeValidatorService
+import org.onap.ccsdk.apps.controllerblueprints.validation.extension.ResourceDefinitionValidator
 import org.springframework.stereotype.Service
 
 @Service
-open class BluePrintRuntimeValidatorService(
-        private val bluePrintTypeValidatorService: BluePrintTypeValidatorService) : BluePrintDesignTimeValidatorService(bluePrintTypeValidatorService) {
-
-    override fun validateBluePrints(bluePrintRuntimeService: BluePrintRuntimeService<*>): Boolean {
-
-        bluePrintTypeValidatorService.validateServiceTemplate(bluePrintRuntimeService, "service_template",
-                bluePrintRuntimeService.bluePrintContext().serviceTemplate)
-        if (bluePrintRuntimeService.getBluePrintError().errors.size > 0) {
-            throw BluePrintException("failed in blueprint validation : ${bluePrintRuntimeService.getBluePrintError().errors.joinToString("\n")}")
-        }
-        return true
-    }
-}
\ No newline at end of file
+open class BluePrintRuntimeValidatorService(bluePrintTypeValidatorService: BluePrintTypeValidatorService,
+                                            resourceDefinitionValidator: ResourceDefinitionValidator)
+    : BluePrintDesignTimeValidatorService(bluePrintTypeValidatorService, resourceDefinitionValidator)
diff --git a/ms/blueprintsprocessor/modules/inbounds/selfservice-api/src/test/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/selfservice/api/mock/Mock.kt b/ms/blueprintsprocessor/modules/inbounds/selfservice-api/src/test/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/selfservice/api/mock/Mock.kt
index c54e61769..19c624bc0 100644
--- a/ms/blueprintsprocessor/modules/inbounds/selfservice-api/src/test/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/selfservice/api/mock/Mock.kt
+++ b/ms/blueprintsprocessor/modules/inbounds/selfservice-api/src/test/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/selfservice/api/mock/Mock.kt
@@ -15,7 +15,9 @@
  */
 package org.onap.ccsdk.apps.blueprintsprocessor.selfservice.api.mock
 
+import io.mockk.mockk
 import org.onap.ccsdk.apps.blueprintsprocessor.core.api.data.ExecutionServiceInput
+import org.onap.ccsdk.apps.blueprintsprocessor.functions.resource.resolution.processor.ResourceAssignmentProcessor
 import org.onap.ccsdk.apps.blueprintsprocessor.services.execution.AbstractComponentFunction
 import org.onap.ccsdk.apps.controllerblueprints.core.asJsonPrimitive
 import org.slf4j.LoggerFactory
@@ -45,4 +47,16 @@ class MockComponentFunction : AbstractComponentFunction() {
     override fun recover(runtimeException: RuntimeException, executionRequest: ExecutionServiceInput) {
         log.info("Recovering component..")
     }
+}
+
+open class MockResourceSource {
+    @Bean(name = [
+        "rr-processor-source-input",
+        "rr-processor-source-default",
+        "rr-processor-source-primary-db",
+        "rr-processor-source-rest"])
+    open fun sourceInstance(): ResourceAssignmentProcessor {
+        return mockk<ResourceAssignmentProcessor>()
+    }
+
 }
\ No newline at end of file
diff --git a/ms/blueprintsprocessor/modules/inbounds/selfservice-api/src/test/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/selfservice/api/validation/BluePrintRuntimeValidatorServiceTest.kt b/ms/blueprintsprocessor/modules/inbounds/selfservice-api/src/test/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/selfservice/api/validation/BluePrintRuntimeValidatorServiceTest.kt
new file mode 100644
index 000000000..1cafead7f
--- /dev/null
+++ b/ms/blueprintsprocessor/modules/inbounds/selfservice-api/src/test/kotlin/org/onap/ccsdk/apps/blueprintsprocessor/selfservice/api/validation/BluePrintRuntimeValidatorServiceTest.kt
@@ -0,0 +1,44 @@
+/*
+ *  Copyright © 2019 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.selfservice.api.validation
+
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.onap.ccsdk.apps.blueprintsprocessor.selfservice.api.mock.MockResourceSource
+import org.onap.ccsdk.apps.controllerblueprints.validation.BluePrintValidationConfiguration
+import org.springframework.beans.factory.annotation.Autowired
+import org.springframework.test.context.ContextConfiguration
+import org.springframework.test.context.junit4.SpringRunner
+import kotlin.test.assertNotNull
+
+@RunWith(SpringRunner::class)
+@ContextConfiguration(classes = [BluePrintRuntimeValidatorService::class,
+    BluePrintValidationConfiguration::class, MockResourceSource::class])
+class BluePrintRuntimeValidatorServiceTest {
+
+    @Autowired
+    lateinit var bluePrintRuntimeValidatorService: BluePrintRuntimeValidatorService
+
+    @Test
+    fun testBlueprintRuntimeValidation() {
+        val blueprintBasePath = "./../../../../../components/model-catalog/blueprint-model/test-blueprint/baseconfiguration"
+        assertNotNull(bluePrintRuntimeValidatorService, " failed to initilize bluePrintRuntimeValidatorService")
+
+        bluePrintRuntimeValidatorService.validateBluePrints(blueprintBasePath)
+
+    }
+}
\ No newline at end of file
diff --git a/ms/blueprintsprocessor/parent/pom.xml b/ms/blueprintsprocessor/parent/pom.xml
index cad5a4b36..045ce7119 100755
--- a/ms/blueprintsprocessor/parent/pom.xml
+++ b/ms/blueprintsprocessor/parent/pom.xml
@@ -32,10 +32,10 @@
     <description>Blueprints Processor Parent</description>
     <properties>
         <kotlin.compiler.jvmTarget>1.8</kotlin.compiler.jvmTarget>
-        <spring.boot.version>2.1.2.RELEASE</spring.boot.version>
-        <spring.version>5.1.4.RELEASE</spring.version>
-        <kotlin.version>1.3.20</kotlin.version>
-        <kotlin.maven.version>1.3.20</kotlin.maven.version>
+        <spring.boot.version>2.1.3.RELEASE</spring.boot.version>
+        <spring.version>5.1.5.RELEASE</spring.version>
+        <kotlin.version>1.3.21</kotlin.version>
+        <kotlin.maven.version>1.3.21</kotlin.maven.version>
         <kotlin.couroutines.version>1.1.1</kotlin.couroutines.version>
         <grpc.version>1.18.0</grpc.version>
         <protobuff.java.utils.version>3.6.1</protobuff.java.utils.version>