Issue-ID: CCSDK-3130

1. Change module name to k8s-connection-plugin
2. Move K8sPluginApi.kt and K8sUploadFileRestClientService.kt out of profile.upload package

Signed-off-by: Grzegorz Wielgosinski <g.wielgosins@samsung.com>
Change-Id: I1708428ce986bc97e69dfbef9cf837a8039ccfe8

6 files changed, 711 insertions, 0 deletions

diff --git a/ms/blueprintsprocessor/functions/k8s-connection-plugin/src/main/kotlin/org/onap/ccsdk/cds/blueprintsprocessor/functions/k8s/K8sPluginApi.kt b/ms/blueprintsprocessor/functions/k8s-connection-plugin/src/main/kotlin/org/onap/ccsdk/cds/blueprintsprocessor/functions/k8s/K8sPluginApi.kt
new file mode 100644
index 000000000..eed1be599
--- /dev/null
+++ b/ms/blueprintsprocessor/functions/k8s-connection-plugin/src/main/kotlin/org/onap/ccsdk/cds/blueprintsprocessor/functions/k8s/K8sPluginApi.kt
@@ -0,0 +1,115 @@
+/*
+ * Copyright © 2017-2018 AT&T Intellectual Property.
+ * Modifications Copyright © 2019 IBM.
+ * Modifications Copyright © 2020 Orange.
+ * Modifications Copyright © 2020 Deutsche Telekom AG.
+ *
+ * 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.cds.blueprintsprocessor.functions.k8s
+
+import com.fasterxml.jackson.databind.ObjectMapper
+import org.onap.ccsdk.cds.blueprintsprocessor.functions.k8s.profile.upload.K8sProfile
+import org.onap.ccsdk.cds.blueprintsprocessor.rest.BasicAuthRestClientProperties
+import org.onap.ccsdk.cds.blueprintsprocessor.rest.service.BlueprintWebClientService
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
+import org.slf4j.LoggerFactory
+import org.springframework.http.HttpMethod
+import java.nio.file.Path
+
+class K8sPluginApi(
+    val username: String,
+    val password: String,
+    val baseUrl: String,
+    val definition: String?,
+    val definitionVersion: String?
+) {
+
+    private val service: K8sUploadFileRestClientService // BasicAuthRestClientService
+    private val log = LoggerFactory.getLogger(K8sPluginApi::class.java)!!
+
+    init {
+        var mapOfHeaders = hashMapOf<String, String>()
+        mapOfHeaders.put("Accept", "application/json")
+        mapOfHeaders.put("Content-Type", "application/json")
+        mapOfHeaders.put("cache-control", " no-cache")
+        mapOfHeaders.put("Accept", "application/json")
+        var basicAuthRestClientProperties: BasicAuthRestClientProperties = BasicAuthRestClientProperties()
+        basicAuthRestClientProperties.username = username
+        basicAuthRestClientProperties.password = password
+        basicAuthRestClientProperties.url = "$baseUrl/v1/rb/definition/$definition/$definitionVersion"
+        basicAuthRestClientProperties.additionalHeaders = mapOfHeaders
+
+        this.service = K8sUploadFileRestClientService(basicAuthRestClientProperties)
+    }
+
+    fun hasDefinition(): Boolean {
+        try {
+            val result: BlueprintWebClientService.WebClientResponse<String> = service.exchangeResource(HttpMethod.GET.name, "", "")
+            log.debug(result.toString())
+            return result.status in 200..299
+        } catch (e: Exception) {
+            log.error("Caught exception trying to get k8s rb definition")
+            throw BlueprintProcessorException("${e.message}")
+        }
+    }
+
+    fun hasProfile(profileName: String): Boolean {
+        try {
+            val result: BlueprintWebClientService.WebClientResponse<String> = service.exchangeResource(
+                HttpMethod.GET.name,
+                "/profile/$profileName",
+                ""
+            )
+            log.debug(result.toString())
+            return result.status in 200..299
+        } catch (e: Exception) {
+            log.error("Caught exception trying to get k8s rb profile")
+            throw BlueprintProcessorException("${e.message}")
+        }
+    }
+
+    fun createProfile(profile: K8sProfile) {
+        val objectMapper = ObjectMapper()
+        val profileJsonString: String = objectMapper.writeValueAsString(profile)
+        try {
+            val result: BlueprintWebClientService.WebClientResponse<String> = service.exchangeResource(
+                HttpMethod.POST.name,
+                "/profile",
+                profileJsonString
+            )
+            if (result.status !in 200..299) {
+                throw Exception(result.body)
+            }
+        } catch (e: Exception) {
+            log.error("Caught exception trying to create k8s rb profile ${profile.profileName}")
+            throw BlueprintProcessorException("${e.message}")
+        }
+    }
+
+    fun uploadProfileContent(profile: K8sProfile, filePath: Path) {
+        try {
+            val result: BlueprintWebClientService.WebClientResponse<String> = service.uploadBinaryFile(
+                "/profile/${profile.profileName}/content",
+                filePath
+            )
+            if (result.status !in 200..299) {
+                throw Exception(result.body)
+            }
+        } catch (e: Exception) {
+            log.error("Caught exception trying to upload k8s rb profile ${profile.profileName}")
+            throw BlueprintProcessorException("${e.message}")
+        }
+    }
+}
diff --git a/ms/blueprintsprocessor/functions/k8s-connection-plugin/src/main/kotlin/org/onap/ccsdk/cds/blueprintsprocessor/functions/k8s/K8sUploadFileRestClientService.kt b/ms/blueprintsprocessor/functions/k8s-connection-plugin/src/main/kotlin/org/onap/ccsdk/cds/blueprintsprocessor/functions/k8s/K8sUploadFileRestClientService.kt
new file mode 100644
index 000000000..ce3e164cf
--- /dev/null
+++ b/ms/blueprintsprocessor/functions/k8s-connection-plugin/src/main/kotlin/org/onap/ccsdk/cds/blueprintsprocessor/functions/k8s/K8sUploadFileRestClientService.kt
@@ -0,0 +1,104 @@
+/*
+ * Copyright © 2017-2018 AT&T Intellectual Property.
+ * Modifications Copyright © 2019 IBM.
+ * Modifications Copyright © 2020 Orange.
+ * Modifications Copyright © 2020 Deutsche Telekom AG.
+ *
+ * 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.cds.blueprintsprocessor.functions.k8s
+
+import org.apache.commons.io.IOUtils
+import org.apache.http.client.ClientProtocolException
+import org.apache.http.client.entity.EntityBuilder
+import org.apache.http.client.methods.HttpPost
+import org.apache.http.client.methods.HttpUriRequest
+import org.apache.http.message.BasicHeader
+import org.onap.ccsdk.cds.blueprintsprocessor.rest.BasicAuthRestClientProperties
+import org.onap.ccsdk.cds.blueprintsprocessor.rest.service.BlueprintWebClientService
+import org.onap.ccsdk.cds.blueprintsprocessor.rest.service.RestLoggerService
+import org.springframework.http.HttpHeaders
+import org.springframework.http.MediaType
+import java.io.IOException
+import java.nio.charset.Charset
+import java.nio.file.Files
+import java.nio.file.Path
+import java.util.Base64
+
+class K8sUploadFileRestClientService(
+    private val restClientProperties:
+        BasicAuthRestClientProperties
+) : BlueprintWebClientService {
+
+    override fun defaultHeaders(): Map<String, String> {
+
+        val encodedCredentials = setBasicAuth(
+            restClientProperties.username,
+            restClientProperties.password
+        )
+        return mapOf(
+            HttpHeaders.CONTENT_TYPE to MediaType.APPLICATION_JSON_VALUE,
+            HttpHeaders.ACCEPT to MediaType.APPLICATION_JSON_VALUE,
+            HttpHeaders.AUTHORIZATION to "Basic $encodedCredentials"
+        )
+    }
+
+    override fun host(uri: String): String {
+        return restClientProperties.url + uri
+    }
+
+    override fun convertToBasicHeaders(headers: Map<String, String>):
+        Array<BasicHeader> {
+            val customHeaders: MutableMap<String, String> = headers.toMutableMap()
+            // inject additionalHeaders
+            customHeaders.putAll(verifyAdditionalHeaders(restClientProperties))
+
+            if (!headers.containsKey(HttpHeaders.AUTHORIZATION)) {
+                val encodedCredentials = setBasicAuth(
+                    restClientProperties.username,
+                    restClientProperties.password
+                )
+                customHeaders[HttpHeaders.AUTHORIZATION] =
+                    "Basic $encodedCredentials"
+            }
+            return super.convertToBasicHeaders(customHeaders)
+        }
+
+    private fun setBasicAuth(username: String, password: String): String {
+        val credentialsString = "$username:$password"
+        return Base64.getEncoder().encodeToString(
+            credentialsString.toByteArray(Charset.defaultCharset())
+        )
+    }
+
+    @Throws(IOException::class, ClientProtocolException::class)
+    private fun performHttpCall(httpUriRequest: HttpUriRequest): BlueprintWebClientService.WebClientResponse<String> {
+        val httpResponse = httpClient().execute(httpUriRequest)
+        val statusCode = httpResponse.statusLine.statusCode
+        httpResponse.entity.content.use {
+            val body = IOUtils.toString(it, Charset.defaultCharset())
+            return BlueprintWebClientService.WebClientResponse(statusCode, body)
+        }
+    }
+
+    fun uploadBinaryFile(path: String, filePath: Path): BlueprintWebClientService.WebClientResponse<String> {
+        val convertedHeaders: Array<BasicHeader> = convertToBasicHeaders(defaultHeaders())
+        val httpPost = HttpPost(host(path))
+        val entity = EntityBuilder.create().setBinary(Files.readAllBytes(filePath)).build()
+        httpPost.setEntity(entity)
+        RestLoggerService.httpInvoking(convertedHeaders)
+        httpPost.setHeaders(convertedHeaders)
+        return performHttpCall(httpPost)
+    }
+}
diff --git a/ms/blueprintsprocessor/functions/k8s-connection-plugin/src/main/kotlin/org/onap/ccsdk/cds/blueprintsprocessor/functions/k8s/profile/upload/K8sProfile.kt b/ms/blueprintsprocessor/functions/k8s-connection-plugin/src/main/kotlin/org/onap/ccsdk/cds/blueprintsprocessor/functions/k8s/profile/upload/K8sProfile.kt
new file mode 100644
index 000000000..c9ddf4846
--- /dev/null
+++ b/ms/blueprintsprocessor/functions/k8s-connection-plugin/src/main/kotlin/org/onap/ccsdk/cds/blueprintsprocessor/functions/k8s/profile/upload/K8sProfile.kt
@@ -0,0 +1,51 @@
+/*
+ * Copyright © 2017-2018 AT&T Intellectual Property.
+ * Modifications Copyright © 2019 IBM.
+ * Modifications Copyright © 2020 Orange.
+ * Modifications Copyright © 2020 Deutsche Telekom AG.
+ *
+ * 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.cds.blueprintsprocessor.functions.k8s.profile.upload
+
+import com.fasterxml.jackson.annotation.JsonProperty
+
+class K8sProfile {
+
+    @get:JsonProperty("rb-name")
+    var rbName: String? = null
+
+    @get:JsonProperty("rb-version")
+    var rbVersion: String? = null
+
+    @get:JsonProperty("profile-name")
+    var profileName: String? = null
+
+    @get:JsonProperty("namespace")
+    var namespace: String? = "default"
+
+    override fun toString(): String {
+        return "$rbName:$rbVersion:$profileName"
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (javaClass != other?.javaClass) return false
+        return true
+    }
+
+    override fun hashCode(): Int {
+        return javaClass.hashCode()
+    }
+}
diff --git a/ms/blueprintsprocessor/functions/k8s-connection-plugin/src/main/kotlin/org/onap/ccsdk/cds/blueprintsprocessor/functions/k8s/profile/upload/K8sProfileUploadComponent.kt b/ms/blueprintsprocessor/functions/k8s-connection-plugin/src/main/kotlin/org/onap/ccsdk/cds/blueprintsprocessor/functions/k8s/profile/upload/K8sProfileUploadComponent.kt
new file mode 100644
index 000000000..1f17b2c6e
--- /dev/null
+++ b/ms/blueprintsprocessor/functions/k8s-connection-plugin/src/main/kotlin/org/onap/ccsdk/cds/blueprintsprocessor/functions/k8s/profile/upload/K8sProfileUploadComponent.kt
@@ -0,0 +1,364 @@
+/*
+ * Copyright © 2017-2018 AT&T Intellectual Property.
+ * Modifications Copyright © 2019 IBM.
+ * Modifications Copyright © 2020 Orange.
+ * Modifications Copyright © 2020 Deutsche Telekom AG.
+ *
+ * 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.cds.blueprintsprocessor.functions.k8s.profile.upload
+
+import com.fasterxml.jackson.databind.JsonNode
+import com.fasterxml.jackson.databind.node.ArrayNode
+import com.fasterxml.jackson.databind.node.ObjectNode
+import org.apache.commons.io.FileUtils
+import org.onap.ccsdk.cds.blueprintsprocessor.core.BlueprintPropertiesService
+import org.onap.ccsdk.cds.blueprintsprocessor.core.api.data.ExecutionServiceInput
+import org.onap.ccsdk.cds.blueprintsprocessor.functions.k8s.K8sPluginApi
+import org.onap.ccsdk.cds.controllerblueprints.resource.dict.ResourceAssignment
+import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.ResourceResolutionConstants
+import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.ResourceResolutionService
+import org.onap.ccsdk.cds.blueprintsprocessor.services.execution.AbstractComponentFunction
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintConstants
+import org.onap.ccsdk.cds.controllerblueprints.core.BlueprintProcessorException
+import org.onap.ccsdk.cds.controllerblueprints.core.asJsonNode
+import org.onap.ccsdk.cds.controllerblueprints.core.data.ArtifactDefinition
+import org.onap.ccsdk.cds.controllerblueprints.core.returnNullIfMissing
+import org.onap.ccsdk.cds.controllerblueprints.core.service.BlueprintVelocityTemplateService
+import org.onap.ccsdk.cds.controllerblueprints.core.utils.ArchiveType
+import org.onap.ccsdk.cds.controllerblueprints.core.utils.BlueprintArchiveUtils
+import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
+import org.slf4j.LoggerFactory
+import org.springframework.beans.factory.config.ConfigurableBeanFactory
+import org.springframework.context.annotation.Scope
+import org.springframework.stereotype.Component
+import org.yaml.snakeyaml.Yaml
+import java.io.File
+import java.nio.file.Files
+import java.nio.file.Path
+import java.nio.file.Paths
+
+@Component("component-k8s-profile-upload")
+@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
+open class K8sProfileUploadComponent(
+    private var bluePrintPropertiesService: BlueprintPropertiesService,
+    private val resourceResolutionService: ResourceResolutionService
+) :
+
+    AbstractComponentFunction() {
+
+    companion object {
+
+        const val INPUT_K8S_PROFILE_NAME = "k8s-rb-profile-name"
+        const val INPUT_K8S_DEFINITION_NAME = "k8s-rb-definition-name"
+        const val INPUT_K8S_DEFINITION_VERSION = "k8s-rb-definition-version"
+        const val INPUT_K8S_PROFILE_NAMESPACE = "k8s-rb-profile-namespace"
+        const val INPUT_K8S_PROFILE_SOURCE = "k8s-rb-profile-source"
+        const val INPUT_RESOURCE_ASSIGNMENT_MAP = "resource-assignment-map"
+        const val INPUT_ARTIFACT_PREFIX_NAMES = "artifact-prefix-names"
+
+        const val OUTPUT_STATUSES = "statuses"
+        const val OUTPUT_SKIPPED = "skipped"
+        const val OUTPUT_UPLOADED = "uploaded"
+        const val OUTPUT_ERROR = "error"
+    }
+
+    private val log = LoggerFactory.getLogger(K8sProfileUploadComponent::class.java)!!
+
+    override suspend fun processNB(executionRequest: ExecutionServiceInput) {
+        log.info("Triggering K8s Profile Upload component logic.")
+
+        val inputParameterNames = arrayOf(
+            INPUT_K8S_PROFILE_NAME,
+            INPUT_K8S_DEFINITION_NAME,
+            INPUT_K8S_DEFINITION_VERSION,
+            INPUT_K8S_PROFILE_NAMESPACE,
+            INPUT_K8S_PROFILE_SOURCE,
+            INPUT_ARTIFACT_PREFIX_NAMES
+        )
+        var outputPrefixStatuses = mutableMapOf<String, String>()
+        var inputParamsMap = mutableMapOf<String, JsonNode?>()
+
+        inputParameterNames.forEach {
+            inputParamsMap[it] = getOptionalOperationInput(it)?.returnNullIfMissing()
+        }
+
+        log.info("Getting the template prefixes")
+        val prefixList: ArrayList<String> = getTemplatePrefixList(inputParamsMap[INPUT_ARTIFACT_PREFIX_NAMES])
+
+        log.info("Iterating over prefixes in resource assignment map.")
+        for (prefix in prefixList) {
+            // Prefilling prefix sucess status
+            outputPrefixStatuses.put(prefix, OUTPUT_SKIPPED)
+            // Resource assignment map is organized by prefixes, in each iteraton we work only
+            // on one section of resource assignment map
+            val prefixNode: JsonNode = operationInputs[INPUT_RESOURCE_ASSIGNMENT_MAP]?.get(prefix) ?: continue
+            val assignmentMapPrefix = JacksonUtils.jsonNode(prefixNode.toPrettyString()) as ObjectNode
+
+            // We are copying the map because for each prefix it might be completed with a different data
+            var prefixInputParamsMap = inputParamsMap.toMutableMap()
+            prefixInputParamsMap.forEach { (inputParamName, value) ->
+                if (value == null) {
+                    val mapValue = assignmentMapPrefix?.get(inputParamName)
+                    log.debug("$inputParamName value was $value so we fetch $mapValue")
+                    prefixInputParamsMap[inputParamName] = mapValue
+                }
+            }
+
+            // For clarity we pull out the required fields
+            val profileName: String? = prefixInputParamsMap[INPUT_K8S_PROFILE_NAME]?.returnNullIfMissing()?.asText()
+            val definitionName: String? = prefixInputParamsMap[INPUT_K8S_DEFINITION_NAME]?.returnNullIfMissing()?.asText()
+            val definitionVersion: String? = prefixInputParamsMap[INPUT_K8S_DEFINITION_VERSION]?.returnNullIfMissing()?.asText()
+
+            val k8sProfileUploadConfiguration = K8sProfileUploadConfiguration(bluePrintPropertiesService)
+
+            // Creating API connector
+            var api = K8sPluginApi(
+                k8sProfileUploadConfiguration.getProperties().username,
+                k8sProfileUploadConfiguration.getProperties().password,
+                k8sProfileUploadConfiguration.getProperties().url,
+                definitionName,
+                definitionVersion
+            )
+
+            if ((profileName == null) || (definitionName == null) || (definitionVersion == null)) {
+                log.warn("Prefix $prefix does not have required data for us to continue.")
+            } else if (!api.hasDefinition()) {
+                log.warn("K8s RB Definition ($definitionName/$definitionVersion) not found ")
+            } else if (profileName == "") {
+                log.warn("K8s rb profile name is empty! Either define profile name to use or choose default")
+            } else if (api.hasProfile(profileName)) {
+                log.info("Profile Already Existing - skipping upload")
+            } else {
+                log.info("Uploading K8s Profile..")
+                outputPrefixStatuses.put(prefix, OUTPUT_ERROR)
+                val profileNamespace: String? = prefixInputParamsMap[INPUT_K8S_PROFILE_NAMESPACE]?.returnNullIfMissing()?.asText()
+                var profileSource: String? = prefixInputParamsMap[INPUT_K8S_PROFILE_SOURCE]?.returnNullIfMissing()?.asText()
+                if (profileNamespace == null)
+                    throw BlueprintProcessorException("Profile $profileName namespace is missing")
+                if (profileSource == null) {
+                    profileSource = profileName
+                    log.info("Profile name used instead of profile source")
+                }
+                val bluePrintContext = bluePrintRuntimeService.bluePrintContext()
+                val artifact: ArtifactDefinition = bluePrintContext.nodeTemplateArtifact(nodeTemplateName, profileSource)
+                if (artifact.type != BlueprintConstants.MODEL_TYPE_ARTIFACT_K8S_PROFILE)
+                    throw BlueprintProcessorException(
+                        "Unexpected profile artifact type for profile source " +
+                            "$profileSource. Expecting: $artifact.type"
+                    )
+                var profile = K8sProfile()
+                profile.profileName = profileName
+                profile.rbName = definitionName
+                profile.rbVersion = definitionVersion
+                profile.namespace = profileNamespace
+                val profileFilePath: Path = prepareProfileFile(profileName, profileSource, artifact.file)
+                api.createProfile(profile)
+                api.uploadProfileContent(profile, profileFilePath)
+
+                log.info("K8s Profile Upload Completed")
+                outputPrefixStatuses.put(prefix, OUTPUT_UPLOADED)
+            }
+        }
+        bluePrintRuntimeService.setNodeTemplateAttributeValue(
+            nodeTemplateName,
+            OUTPUT_STATUSES,
+            outputPrefixStatuses.asJsonNode()
+        )
+    }
+
+    override suspend fun recoverNB(runtimeException: RuntimeException, executionRequest: ExecutionServiceInput) {
+        bluePrintRuntimeService.getBlueprintError().addError(runtimeException.message!!)
+    }
+
+    private fun getTemplatePrefixList(node: JsonNode?): ArrayList<String> {
+        var result = ArrayList<String>()
+        when (node) {
+            is ArrayNode -> {
+                val arrayNode = node.toList()
+                for (prefixNode in arrayNode)
+                    result.add(prefixNode.asText())
+            }
+            is ObjectNode -> {
+                result.add(node.asText())
+            }
+        }
+        return result
+    }
+
+    private suspend fun prepareProfileFile(k8sRbProfileName: String, ks8ProfileSource: String, ks8ProfileLocation: String): Path {
+        val bluePrintContext = bluePrintRuntimeService.bluePrintContext()
+        val bluePrintBasePath: String = bluePrintContext.rootPath
+        val profileSourceFileFolderPath: Path = Paths.get(
+            bluePrintBasePath.plus(File.separator).plus(ks8ProfileLocation)
+        )
+
+        if (profileSourceFileFolderPath.toFile().exists() && !profileSourceFileFolderPath.toFile().isDirectory)
+            return profileSourceFileFolderPath
+        else if (profileSourceFileFolderPath.toFile().exists()) {
+            log.info("Profile building started from source $ks8ProfileSource")
+            val properties: MutableMap<String, Any> = mutableMapOf()
+            properties[ResourceResolutionConstants.RESOURCE_RESOLUTION_INPUT_STORE_RESULT] = false
+            properties[ResourceResolutionConstants.RESOURCE_RESOLUTION_INPUT_RESOLUTION_KEY] = ""
+            properties[ResourceResolutionConstants.RESOURCE_RESOLUTION_INPUT_RESOURCE_ID] = ""
+            properties[ResourceResolutionConstants.RESOURCE_RESOLUTION_INPUT_RESOURCE_TYPE] = ""
+            properties[ResourceResolutionConstants.RESOURCE_RESOLUTION_INPUT_OCCURRENCE] = 1
+            properties[ResourceResolutionConstants.RESOURCE_RESOLUTION_INPUT_RESOLUTION_SUMMARY] = false
+            val resolutionResult: Pair<String, MutableList<ResourceAssignment>> = resourceResolutionService.resolveResources(
+                bluePrintRuntimeService,
+                nodeTemplateName,
+                ks8ProfileSource,
+                properties
+            )
+            val tempMainPath: File = createTempDir("k8s-profile-", "")
+            val tempProfilePath: File = createTempDir("content-", "", tempMainPath)
+
+            val resolvedJsonContent = resolutionResult.second
+                .associateBy({ it.name }, { it.property?.value })
+                .asJsonNode()
+
+            try {
+                val manifestFiles: ArrayList<File>? = readManifestFiles(
+                    profileSourceFileFolderPath.toFile(),
+                    tempProfilePath
+                )
+                if (manifestFiles != null) {
+                    templateLocation(
+                        profileSourceFileFolderPath.toFile(), resolvedJsonContent,
+                        tempProfilePath, manifestFiles
+                    )
+                } else
+                    throw BlueprintProcessorException("Manifest file is missing")
+                // Preparation of the final profile content
+                val finalProfileFilePath = Paths.get(
+                    tempMainPath.toString().plus(File.separator).plus(
+                        "$k8sRbProfileName.tar.gz"
+                    )
+                )
+                if (!BlueprintArchiveUtils.compress(
+                        tempProfilePath, finalProfileFilePath.toFile(),
+                        ArchiveType.TarGz
+                    )
+                ) {
+                    throw BlueprintProcessorException("Profile compression has failed")
+                }
+                FileUtils.deleteDirectory(tempProfilePath)
+
+                return finalProfileFilePath
+            } catch (t: Throwable) {
+                FileUtils.deleteDirectory(tempMainPath)
+                throw t
+            }
+        } else
+            throw BlueprintProcessorException("Profile source $ks8ProfileLocation is missing in CBA folder")
+    }
+
+    private fun readManifestFiles(profileSource: File, destinationFolder: File): ArrayList<File>? {
+        val directoryListing: Array<File>? = profileSource.listFiles()
+        var result: ArrayList<File>? = null
+        if (directoryListing != null) {
+            for (child in directoryListing) {
+                if (!child.isDirectory && child.name.toLowerCase() == "manifest.yaml") {
+                    child.bufferedReader().use { inr ->
+                        val manifestYaml = Yaml()
+                        val manifestObject: Map<String, Any> = manifestYaml.load(inr)
+                        val typeObject: MutableMap<String, Any>? = manifestObject["type"] as MutableMap<String, Any>?
+                        if (typeObject != null) {
+                            result = ArrayList<File>()
+                            val valuesObject = typeObject["values"]
+                            if (valuesObject != null) {
+                                result!!.add(File(destinationFolder.toString().plus(File.separator).plus(valuesObject)))
+                                result!!.add(File(destinationFolder.toString().plus(File.separator).plus(child.name)))
+                            }
+                            (typeObject["configresource"] as ArrayList<*>?)?.forEach { item ->
+                                val fileInfo: Map<String, Any> = item as Map<String, Any>
+                                val filePath = fileInfo["filepath"]
+                                val chartPath = fileInfo["chartpath"]
+                                if (filePath == null || chartPath == null)
+                                    log.error("One configresource in manifest was skipped because of the wrong format")
+                                else {
+                                    result!!.add(File(destinationFolder.toString().plus(File.separator).plus(filePath)))
+                                }
+                            }
+                        }
+                    }
+                    break
+                }
+            }
+        }
+        return result
+    }
+
+    private fun templateLocation(
+        location: File,
+        params: JsonNode,
+        destinationFolder: File,
+        manifestFiles: ArrayList<File>
+    ) {
+        val directoryListing: Array<File>? = location.listFiles()
+        if (directoryListing != null) {
+            for (child in directoryListing) {
+                var newDestinationFolder = destinationFolder.toPath()
+                if (child.isDirectory)
+                    newDestinationFolder = Paths.get(destinationFolder.toString().plus(File.separator).plus(child.name))
+
+                templateLocation(child, params, newDestinationFolder.toFile(), manifestFiles)
+            }
+        } else if (!location.isDirectory) {
+            if (location.extension.toLowerCase() == "vtl") {
+                templateFile(location, params, destinationFolder, manifestFiles)
+            } else {
+                val finalFilePath = Paths.get(
+                    destinationFolder.path.plus(File.separator)
+                        .plus(location.name)
+                ).toFile()
+                if (isFileInTheManifestFiles(finalFilePath, manifestFiles)) {
+                    if (!destinationFolder.exists())
+                        Files.createDirectories(destinationFolder.toPath())
+                    FileUtils.copyFile(location, finalFilePath)
+                }
+            }
+        }
+    }
+
+    private fun isFileInTheManifestFiles(file: File, manifestFiles: ArrayList<File>): Boolean {
+        manifestFiles.forEach { fileFromManifest ->
+            if (fileFromManifest.toString().toLowerCase() == file.toString().toLowerCase())
+                return true
+        }
+        return false
+    }
+
+    private fun templateFile(
+        templatedFile: File,
+        params: JsonNode,
+        destinationFolder: File,
+        manifestFiles: ArrayList<File>
+    ) {
+        val finalFile = File(
+            destinationFolder.path.plus(File.separator)
+                .plus(templatedFile.nameWithoutExtension)
+        )
+        if (!isFileInTheManifestFiles(finalFile, manifestFiles))
+            return
+        val fileContent = templatedFile.bufferedReader().readText()
+        val finalFileContent = BlueprintVelocityTemplateService.generateContent(
+            fileContent,
+            params, true
+        )
+        if (!destinationFolder.exists())
+            Files.createDirectories(destinationFolder.toPath())
+        finalFile.bufferedWriter().use { out -> out.write(finalFileContent) }
+    }
+}
diff --git a/ms/blueprintsprocessor/functions/k8s-connection-plugin/src/main/kotlin/org/onap/ccsdk/cds/blueprintsprocessor/functions/k8s/profile/upload/K8sProfileUploadConfiguration.kt b/ms/blueprintsprocessor/functions/k8s-connection-plugin/src/main/kotlin/org/onap/ccsdk/cds/blueprintsprocessor/functions/k8s/profile/upload/K8sProfileUploadConfiguration.kt
new file mode 100644
index 000000000..76e8af910
--- /dev/null
+++ b/ms/blueprintsprocessor/functions/k8s-connection-plugin/src/main/kotlin/org/onap/ccsdk/cds/blueprintsprocessor/functions/k8s/profile/upload/K8sProfileUploadConfiguration.kt
@@ -0,0 +1,51 @@
+/*
+ *  Copyright © 2020 Deutsche Telekom AG.
+ *  Modifications Copyright © 2020 Orange.
+ *
+ *  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.cds.blueprintsprocessor.functions.k8s.profile.upload
+
+import org.onap.ccsdk.cds.blueprintsprocessor.core.BlueprintCoreConfiguration
+import org.onap.ccsdk.cds.blueprintsprocessor.core.BlueprintPropertiesService
+import org.onap.ccsdk.cds.blueprintsprocessor.core.BlueprintPropertyConfiguration
+import org.springframework.boot.context.properties.EnableConfigurationProperties
+import org.springframework.context.annotation.Bean
+import org.springframework.context.annotation.Configuration
+import org.springframework.context.annotation.Import
+
+@Configuration
+@Import(
+    BlueprintPropertyConfiguration::class,
+    BlueprintPropertiesService::class,
+    BlueprintCoreConfiguration::class
+)
+@EnableConfigurationProperties
+open class K8sProfileUploadConfiguration(private var bluePrintPropertiesService: BlueprintPropertiesService) {
+
+    @Bean("k8s-plugin-properties")
+    open fun getProperties(): K8sProfileUploadProperties {
+        return bluePrintPropertiesService.propertyBeanType(
+            K8sProfileUploadConstants.PREFIX_K8S_PLUGIN,
+            K8sProfileUploadProperties::class.java
+        )
+    }
+}
+
+class K8sProfileUploadConstants {
+    companion object {
+
+        const val PREFIX_K8S_PLUGIN: String = "blueprintprocessor.k8s.plugin"
+    }
+}
diff --git a/ms/blueprintsprocessor/functions/k8s-connection-plugin/src/main/kotlin/org/onap/ccsdk/cds/blueprintsprocessor/functions/k8s/profile/upload/K8sProfileUploadProperties.kt b/ms/blueprintsprocessor/functions/k8s-connection-plugin/src/main/kotlin/org/onap/ccsdk/cds/blueprintsprocessor/functions/k8s/profile/upload/K8sProfileUploadProperties.kt
new file mode 100644
index 000000000..ae277e360
--- /dev/null
+++ b/ms/blueprintsprocessor/functions/k8s-connection-plugin/src/main/kotlin/org/onap/ccsdk/cds/blueprintsprocessor/functions/k8s/profile/upload/K8sProfileUploadProperties.kt
@@ -0,0 +1,26 @@
+/*
+ *  Copyright © 2020 Deutsche Telekom AG.
+ *  Modifications Copyright © 2020 Orange.
+ *
+ *  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.cds.blueprintsprocessor.functions.k8s.profile.upload
+
+open class K8sProfileUploadProperties {
+
+    var type: String = K8sProfileUploadConstants.PREFIX_K8S_PLUGIN
+    lateinit var url: String
+    lateinit var username: String
+    lateinit var password: String
+}