ms/blueprintsprocessor/functions/resource-resolution/src/main/kotlin/org/onap/ccsdk/cds/blueprintsprocessor/functions/resource/resolution/capabilities/IpAssignResolutionCapability.kt

   1 /*
   2  * Copyright © 2019 AT&T.
   3  *
   4  *  Licensed under the Apache License, Version 2.0 (the "License");
   5  *  you may not use this file except in compliance with the License.
   6  *  You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  *  Unless required by applicable law or agreed to in writing, software
  11  *  distributed under the License is distributed on an "AS IS" BASIS,
  12  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  *  See the License for the specific language governing permissions and
  14  *  limitations under the License.
  15  */
  16
  17 package org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.capabilities
  18
  19 import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.ResourceResolutionConstants
  20 import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.processor.ResourceAssignmentProcessor
  21 import org.onap.ccsdk.cds.blueprintsprocessor.functions.resource.resolution.utils.ResourceAssignmentUtils
  22 import org.onap.ccsdk.cds.blueprintsprocessor.rest.restClientService
  23 import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
  24 import org.onap.ccsdk.cds.controllerblueprints.core.asJsonType
  25 import org.onap.ccsdk.cds.controllerblueprints.core.logger
  26 import org.onap.ccsdk.cds.controllerblueprints.core.service.BluePrintDependencyService
  27 import org.onap.ccsdk.cds.controllerblueprints.core.utils.JacksonUtils
  28 import org.onap.ccsdk.cds.controllerblueprints.resource.dict.KeyIdentifier
  29 import org.onap.ccsdk.cds.controllerblueprints.resource.dict.ResourceAssignment
  30 import org.springframework.http.HttpMethod
  31
  32 /**
  33  * @author saurav.paira
  34  */
  35
  36 open class IpAssignResolutionCapability : ResourceAssignmentProcessor() {
  37
  38     val log = logger(IpAssignResolutionCapability::class)
  39
  40     override fun getName(): String {
  41         return "${ResourceResolutionConstants.PREFIX_RESOURCE_RESOLUTION_PROCESSOR}ipassignment-capability"
  42     }
  43
  44     override suspend fun processNB(resourceAssignment: ResourceAssignment) {
  45         try {
  46             if (!setFromInput(resourceAssignment) && isTemplateKeyValueNull(resourceAssignment)) {
  47                 val dName = resourceAssignment.dictionaryName!!
  48                 val dSource = resourceAssignment.dictionarySource!!
  49                 val resourceDefinition = resourceDefinition(dName)
  50
  51                 /** Check Resource Assignment has the source definitions, If not get from Resource Definitions **/
  52                 val resourceSource = resourceAssignment.dictionarySourceDefinition
  53                     ?: resourceDefinition?.sources?.get(dSource)
  54                     ?: throw BluePrintProcessorException("couldn't get resource definition $dName source($dSource)")
  55
  56                 val resourceSourceProperties =
  57                     checkNotNull(resourceSource.properties) { "failed to get source properties for $dName " }
  58
  59                 // Get all matching resources assignments to process
  60                 val groupResourceAssignments =
  61                     resourceAssignments.filter {
  62                         it.dictionarySource == dSource
  63                     }.toMutableList()
  64
  65                 // inputKeyMapping is dynamic based on dependencies
  66                 val inputKeyMapping: MutableMap<String, String> =
  67                     resourceAssignment.dependencies?.map { it to it }?.toMap()
  68                         as MutableMap<String, String>
  69
  70                 // Get the values from runtime store
  71                 val resolvedKeyValues = resolveInputKeyMappingVariables(inputKeyMapping)
  72                 log.info("\nResolved Input Key mappings: \n{}", resolvedKeyValues)
  73
  74                 resolvedKeyValues?.map { KeyIdentifier(it.key, it.value) }
  75                     ?.let { resourceAssignment.keyIdentifiers.addAll(it) }
  76
  77                 // Generate the payload using already resolved value
  78                 val generatedPayload = generatePayload(resolvedKeyValues, groupResourceAssignments)
  79                 log.info("\nIP Assign mS Request Payload: \n{}", generatedPayload.asJsonType().toPrettyString())
  80
  81                 resourceSourceProperties["resolved-payload"] = JacksonUtils.jsonNode(generatedPayload)
  82
  83                 // Get the Rest Client service, selector will be included in application.properties
  84                 val restClientService = BluePrintDependencyService.restClientService(
  85                     "ipassign-ms"
  86                 )
  87
  88                 // Get the Rest Response
  89                 val response = restClientService.exchangeResource(
  90                     HttpMethod.POST.name,
  91                     "/web/service/v1/assign", generatedPayload
  92                 )
  93                 val responseStatusCode = response.status
  94                 val responseBody = response.body
  95                 log.info("\nIP Assign mS Response : \n{}", responseBody.asJsonType().toPrettyString())
  96                 if (responseStatusCode in 200..299 && !responseBody.isBlank()) {
  97                     populateResource(groupResourceAssignments, responseBody)
  98                 } else {
  99                     val errMsg =
 100                         "Failed to dictionary name ($dName), dictionary source($($dName) " +
 101                             "response_code: ($responseStatusCode)"
 102                     log.warn(errMsg)
 103                     throw BluePrintProcessorException(errMsg)
 104                 }
 105                 // Parse the error Body and assign the property value
 106             }
 107             // Check the value has populated for mandatory case
 108             ResourceAssignmentUtils.assertTemplateKeyValueNotNull(resourceAssignment)
 109         } catch (e: Exception) {
 110             ResourceAssignmentUtils.setFailedResourceDataValue(resourceAssignment, e.message)
 111             throw BluePrintProcessorException(
 112                 "Failed in template key ($resourceAssignment) assignments with: ${e.message}",
 113                 e
 114             )
 115         }
 116     }
 117
 118     override suspend fun recoverNB(runtimeException: RuntimeException, executionRequest: ResourceAssignment) {
 119         addError(runtimeException.message!!)
 120     }
 121
 122     /** Generates aggregated request payload for Ip Assign mS. Parses the resourceassignments of
 123      * sourceCapability "ipassign-ms". It generates below sample payload
 124      * {
 125      "requests": [{
 126      "name": "fixed_ipv4_Address_01",
 127      "property": {
 128      "CloudRegionId": "abcd123",
 129      "IpServiceName": "MobilityPlan",
 130      }
 131      }, {
 132      "name": "fixed_ipv4_Address_02",
 133      "property": {
 134      "CloudRegionId": "abcd123",
 135      "IpServiceName": "MobilityPlan",
 136      }
 137      }
 138      ]
 139      } */
 140     private fun generatePayload(
 141         input: Map<String, Any>,
 142         groupResourceAssignments: MutableList<ResourceAssignment>
 143     ): String {
 144         data class IpRequest(val name: String = "", val property: Map<String, String> = mutableMapOf<String, String>())
 145         data class IpAssignRequest(val requests: MutableList<IpRequest> = mutableListOf())
 146
 147         val ipAssignRequests = IpAssignRequest()
 148         groupResourceAssignments.forEach {
 149             val ipRequest = IpRequest(it.name, input.mapValues { it.value.toString().removeSurrounding("\"") })
 150             ipAssignRequests.requests.add(ipRequest)
 151         }
 152         return ipAssignRequests.asJsonType().toString()
 153     }
 154
 155     private fun populateResource(
 156         resourceAssignments: MutableList<ResourceAssignment>,
 157         restResponse: String
 158     ) {
 159         /** Parse all the resource assignment fields and set the corresponding value */
 160         resourceAssignments.forEach { resourceAssignment ->
 161             // Set the List of Complex Values
 162             val parsedResourceAssignmentValue = checkNotNull(
 163                 JacksonUtils.jsonNode(restResponse).path(resourceAssignment.name).textValue()
 164             ) {
 165                 "Failed to find path ($resourceAssignment.name) in response ($restResponse)"
 166             }
 167
 168             ResourceAssignmentUtils.setResourceDataValue(
 169                 resourceAssignment,
 170                 raRuntimeService,
 171                 parsedResourceAssignmentValue
 172             )
 173         }
 174     }
 175 }