gerrit.onap Code Review - so.git/blob

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ONAP - SO
   4  * ================================================================================
   5  # Copyright (c) 2020, CMCC Technologies Co., Ltd.
   6  #
   7  # Licensed under the Apache License, Version 2.0 (the "License")
   8  # you may not use this file except in compliance with the License.
   9  # You may obtain a copy of the License at
  10  #
  11  #       http://www.apache.org/licenses/LICENSE-2.0
  12  #
  13  # Unless required by applicable law or agreed to in writing, software
  14  # distributed under the License is distributed on an "AS IS" BASIS,
  15  # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  # See the License for the specific language governing permissions and
  17  # limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.onap.so.bpmn.infrastructure.scripts
  22
  23 import com.fasterxml.jackson.databind.ObjectMapper
  24 import org.camunda.bpm.engine.delegate.DelegateExecution
  25 import org.onap.so.beans.nsmf.AnSliceProfile
  26 import org.onap.so.beans.nsmf.CnSliceProfile
  27 import org.onap.so.beans.nsmf.EsrInfo
  28 import org.onap.so.beans.nsmf.NetworkType
  29 import org.onap.so.beans.nsmf.NssmfAdapterNBIRequest
  30 import org.onap.so.beans.nsmf.SliceTaskParams
  31 import org.onap.so.beans.nsmf.SliceTaskParamsAdapter
  32 import org.onap.so.beans.nsmf.TnSliceProfile
  33 import org.onap.so.beans.nsmf.oof.SubnetCapability
  34 import org.onap.so.beans.nsmf.oof.SubnetType
  35 import org.onap.so.beans.nsmf.oof.TemplateInfo
  36 import org.onap.so.bpmn.common.scripts.AbstractServiceTaskProcessor
  37 import org.onap.so.bpmn.common.scripts.ExceptionUtil
  38 import org.onap.so.bpmn.common.scripts.NssmfAdapterUtils
  39 import org.onap.so.bpmn.common.scripts.OofUtils
  40 import org.onap.so.bpmn.core.UrnPropertiesReader
  41 import org.onap.so.bpmn.core.domain.AllottedResource
  42 import org.onap.so.bpmn.core.domain.ModelInfo
  43 import org.onap.so.bpmn.core.domain.ServiceDecomposition
  44 import org.onap.so.bpmn.core.json.JsonUtils
  45 import org.onap.so.client.HttpClient
  46 import org.onap.so.client.HttpClientFactory
  47 import org.onap.aaiclient.client.aai.AAIObjectType
  48 import org.onap.aaiclient.client.aai.AAIResourcesClient
  49 import org.onap.aaiclient.client.aai.entities.AAIResultWrapper
  50 import org.onap.aaiclient.client.aai.entities.uri.AAIResourceUri
  51 import org.onap.aaiclient.client.aai.entities.uri.AAIUriFactory
  52 import org.onap.aaiclient.client.generated.fluentbuilders.AAIFluentTypeBuilder
  53 import org.onap.aaiclient.client.generated.fluentbuilders.AAIFluentTypeBuilder.Types
  54 import org.slf4j.Logger
  55 import org.slf4j.LoggerFactory
  56 import org.springframework.http.ResponseEntity
  57
  58 class DoCreateSliceServiceOption extends AbstractServiceTaskProcessor{
  59
  60     private static final Logger logger = LoggerFactory.getLogger(DoCreateSliceServiceOption.class)
  61
  62     ExceptionUtil exceptionUtil = new ExceptionUtil()
  63
  64     JsonUtils jsonUtil = new JsonUtils()
  65
  66     OofUtils oofUtils = new OofUtils()
  67
  68     private static final ObjectMapper objectMapper = new ObjectMapper()
  69
  70     private NssmfAdapterUtils nssmfAdapterUtils = new NssmfAdapterUtils(httpClientFactory, jsonUtil)
  71
  72     private static final String QUERY_SUB_NET_CAPABILITY = "/api/rest/provMns/v1/NSS/subnetCapabilityQuery"
  73
  74     private static final String QUERY_NSSI_SELECTION_CAPABILITY = "/api/rest/provMns/v1/NSS/NSSISelectionCapability"
  75
  76     void preProcessRequest (DelegateExecution execution) {
  77     }
  78
  79     /**
  80      * prepare the params for decompose nst
  81      * @param execution
  82      */
  83     public void prepareDecomposeNST(DelegateExecution execution) {
  84
  85         SliceTaskParamsAdapter sliceTaskParams =
  86                 execution.getVariable("sliceTaskParams") as SliceTaskParamsAdapter
  87
  88         String modelUuid = sliceTaskParams.getNSTInfo().getUUID()
  89         String modelInvariantUuid = sliceTaskParams.getNSTInfo().getInvariantUUID()
  90
  91         String serviceModelInfo = """{
  92             "modelInvariantUuid":"${modelInvariantUuid}",
  93             "modelUuid":"${modelUuid}",
  94             "modelVersion":""
  95              }"""
  96         execution.setVariable("nstServiceModelInfo", serviceModelInfo)
  97     }
  98
  99     /**
 100      * process the result of NST Decomposition
 101      * @param execution
 102      */
 103     public void processDecompositionNST(DelegateExecution execution) {
 104
 105         List<TemplateInfo> nsstInfos = new ArrayList<>()
 106         ServiceDecomposition nstServiceDecomposition =
 107                 execution.getVariable("nstServiceDecomposition") as ServiceDecomposition
 108         //todo:
 109         List<AllottedResource> allottedResources = nstServiceDecomposition.getAllottedResources()
 110         for (AllottedResource allottedResource : allottedResources) {
 111             TemplateInfo nsstInfo = new TemplateInfo()
 112             nsstInfo.setUUID(allottedResource.getProvidingServiceModelUuid())
 113             nsstInfo.setInvariantUUID(allottedResource.getProvidingServiceModelInvariantUuid())
 114             nsstInfo.setName(allottedResource.getProvidingServiceModelName())
 115             nsstInfos.add(nsstInfo)
 116         }
 117         execution.setVariable("nsstInfos", nsstInfos)
 118
 119         execution.setVariable("maxNsstIndex", allottedResources.size() - 1)
 120         execution.setVariable("currentNsstIndex", 0)
 121
 122         List<ServiceDecomposition> nsstServiceDecompositions = new ArrayList<>()
 123         execution.setVariable("nsstServiceDecompositions", nsstServiceDecompositions)
 124     }
 125
 126     /**
 127      * prepare the params for decompose nsst
 128      * @param execution
 129      */
 130     public void prepareDecomposeNSST(DelegateExecution execution) {
 131
 132         List<TemplateInfo> nsstInfos = execution.getVariable("nsstInfos") as List<TemplateInfo>
 133         int index = execution.getVariable("currentNsstIndex") as Integer
 134
 135         String modelUuid = nsstInfos.get(index).getUUID()
 136         String modelInvariantUuid = nsstInfos.get(index).getInvariantUUID()
 137
 138         String serviceModelInfo = """{
 139             "modelInvariantUuid":"${modelInvariantUuid}",
 140             "modelUuid":"${modelUuid}",
 141             "modelVersion":""
 142              }"""
 143         execution.setVariable("nsstServiceModelInfo", serviceModelInfo)
 144
 145     }
 146
 147     /**
 148      * process the result of NSST Decomposition
 149      * @param execution
 150      */
 151     public void processDecompositionNSST(DelegateExecution execution) {
 152
 153         List<ServiceDecomposition> nsstServiceDecompositions =
 154                 execution.getVariable("nsstServiceDecompositions") as List<ServiceDecomposition>
 155
 156         ServiceDecomposition nsstServiceDecomposition =
 157                 execution.getVariable("nsstServiceDecomposition") as ServiceDecomposition
 158
 159         nsstServiceDecompositions.add(nsstServiceDecomposition)
 160
 161         execution.setVariable("nsstServiceDecompositions", nsstServiceDecompositions)
 162
 163
 164
 165
 166         int num = execution.getVariable("maxNsstIndex") as Integer
 167         int index = execution.getVariable("currentNsstIndex") as Integer
 168
 169         execution.setVariable("currentNsstIndex", index + 1)
 170
 171         if (index >= num) {
 172             execution.setVariable("nsstHandleContinue", false)
 173         } else {
 174             execution.setVariable("nsstHandleContinue", true)
 175         }
 176
 177     }
 178
 179     /**
 180      * set nsst info to sliceTaskParams by type
 181      * @param execution
 182      */
 183     public void handleNsstByType(DelegateExecution execution) {
 184         //todo: set to sliceTaskParams by type
 185
 186         SliceTaskParamsAdapter sliceParams =
 187                 execution.getVariable("sliceTaskParams") as SliceTaskParamsAdapter
 188
 189         List<ServiceDecomposition> nsstServiceDecompositions =
 190                 execution.getVariable("nsstServiceDecompositions") as List<ServiceDecomposition>
 191
 192         List<SubnetCapability> subnetCapabilities = new ArrayList<>()
 193
 194
 195
 196         for (ServiceDecomposition serviceDecomposition : nsstServiceDecompositions) {
 197             //todo:
 198             SubnetCapability subnetCapability = new SubnetCapability()
 199
 200             handleByType(execution, serviceDecomposition, sliceParams, subnetCapability)
 201
 202             subnetCapabilities.add(subnetCapability)
 203         }
 204
 205         execution.setVariable("sliceTaskParams", sliceParams)
 206         execution.setVariable("subnetCapabilities", subnetCapabilities)
 207     }
 208
 209     private void handleByType(DelegateExecution execution, ServiceDecomposition serviceDecomposition,
 210                               SliceTaskParamsAdapter sliceParams, SubnetCapability subnetCapability) {
 211         //todo:
 212         String domainType = ""
 213         ModelInfo modelInfo = serviceDecomposition.getModelInfo()
 214         String vendor = serviceDecomposition.getServiceRole()
 215         SubnetType subnetType
 216
 217         switch (domainType) {
 218             case "tn_bh":
 219                 subnetType = SubnetType.TN_BH
 220                 sliceParams.tnBHSliceTaskInfo.vendor = vendor
 221                 sliceParams.tnBHSliceTaskInfo.subnetType = subnetType
 222                 sliceParams.tnBHSliceTaskInfo.networkType = subnetType.networkType
 223                 sliceParams.tnBHSliceTaskInfo.NSSTInfo.UUID = modelInfo.getModelUuid()
 224                 sliceParams.tnBHSliceTaskInfo.NSSTInfo.invariantUUID = modelInfo.getModelInvariantUuid()
 225                 sliceParams.tnBHSliceTaskInfo.NSSTInfo.name = modelInfo.getModelName()
 226
 227                 break
 228             case "tn_mh":
 229                 subnetType = SubnetType.TN_MH
 230                 sliceParams.tnMHSliceTaskInfo.vendor = vendor
 231                 sliceParams.tnMHSliceTaskInfo.subnetType = subnetType
 232                 sliceParams.tnMHSliceTaskInfo.networkType = subnetType.networkType
 233                 sliceParams.tnMHSliceTaskInfo.NSSTInfo.UUID = modelInfo.getModelUuid()
 234                 sliceParams.tnMHSliceTaskInfo.NSSTInfo.invariantUUID = modelInfo.getModelInvariantUuid()
 235                 sliceParams.tnMHSliceTaskInfo.NSSTInfo.name = modelInfo.getModelName()
 236
 237                 break
 238             case "an_nf":
 239                 subnetType = SubnetType.AN_NF
 240                 sliceParams.anSliceTaskInfo.vendor = vendor
 241                 sliceParams.anSliceTaskInfo.subnetType = subnetType
 242                 sliceParams.anSliceTaskInfo.networkType = subnetType.networkType
 243                 sliceParams.anSliceTaskInfo.NSSTInfo.UUID = modelInfo.getModelUuid()
 244                 sliceParams.anSliceTaskInfo.NSSTInfo.invariantUUID = modelInfo.getModelInvariantUuid()
 245                 sliceParams.anSliceTaskInfo.NSSTInfo.name = modelInfo.getModelName()
 246                 break
 247             case "cn":
 248                 subnetType = SubnetType.CN
 249                 sliceParams.cnSliceTaskInfo.vendor = vendor
 250                 sliceParams.cnSliceTaskInfo.subnetType = subnetType
 251                 sliceParams.cnSliceTaskInfo.networkType = subnetType.networkType
 252                 sliceParams.cnSliceTaskInfo.NSSTInfo.UUID = modelInfo.getModelUuid()
 253                 sliceParams.cnSliceTaskInfo.NSSTInfo.invariantUUID = modelInfo.getModelInvariantUuid()
 254                 sliceParams.cnSliceTaskInfo.NSSTInfo.name = modelInfo.getModelName()
 255                 break
 256             default:
 257                 subnetType = null
 258                 break
 259
 260         //todo
 261
 262         }
 263         if (subnetType == null) {
 264             //todo: throw error
 265             return
 266         }
 267         String response = querySubnetCapability(execution, vendor, subnetType)
 268         ResponseEntity responseEntity = objectMapper.readValue(response, ResponseEntity.class)
 269
 270         Map<String, Object> result = responseEntity.getBody() as Map
 271         for (Map.Entry<String, Object> entry : result.entrySet()) {
 272             subnetCapability.setDomainType(entry.getKey())
 273             subnetCapability.setCapabilityDetails(entry.getValue())
 274         }
 275     }
 276
 277     /**
 278      * query Subnet Capability of TN AN CN
 279      * @param execution
 280      */
 281     private String querySubnetCapability(DelegateExecution execution, String vendor, SubnetType subnetType) {
 282
 283         String strRequest = objectMapper.writeValueAsString(buildQuerySubnetCapRequest(vendor, subnetType))
 284
 285         String response = nssmfAdapterUtils.sendPostRequestNSSMF(execution, QUERY_SUB_NET_CAPABILITY, strRequest)
 286         return response
 287     }
 288
 289     /**
 290      * build request body for querying Subnet Capability
 291      * @param vendor
 292      * @param subnetTypes
 293      * @param networkType
 294      * @return
 295      */
 296     private static String buildQuerySubnetCapRequest(String vendor, SubnetType subnetType) {
 297         NssmfAdapterNBIRequest request = new NssmfAdapterNBIRequest()
 298
 299         List<String> subnetTypes =  new ArrayList<>()
 300         subnetTypes.add(subnetType.subnetType)
 301         Map<String, Object> paramMap = new HashMap()
 302         paramMap.put("subnetTypes", subnetTypes)
 303
 304         request.setSubnetCapabilityQuery(objectMapper.writeValueAsString(paramMap))
 305
 306         EsrInfo esrInfo = new EsrInfo()
 307         esrInfo.setVendor(vendor)
 308         esrInfo.setNetworkType(subnetType.networkType)
 309
 310         request.setEsrInfo(esrInfo)
 311
 312         String strRequest = objectMapper.writeValueAsString(request)
 313
 314         return strRequest
 315     }
 316
 317     /**
 318      * todo: need rewrite
 319      * prepare select nsi request
 320      * @param execution
 321      */
 322     public void preNSIRequest(DelegateExecution execution) {
 323
 324         String urlString = UrnPropertiesReader.getVariable("mso.oof.endpoint", execution)
 325         logger.debug( "get NSI option OOF Url: " + urlString)
 326
 327
 328         String requestId = execution.getVariable("msoRequestId")
 329         String messageType = "NSISelectionResponse"
 330
 331         execution.setVariable("nsiSelectionUrl", "/api/oof/selection/nsi/v1")
 332         execution.setVariable("nsiSelection_messageType", messageType)
 333         execution.setVariable("nsiSelection_correlator", requestId)
 334         String timeout = UrnPropertiesReader.getVariable("mso.adapters.oof.timeout", execution)
 335         execution.setVariable("nsiSelection_timeout", timeout)
 336
 337         SliceTaskParamsAdapter sliceParams =
 338                 execution.getVariable("sliceTaskParams") as SliceTaskParamsAdapter
 339
 340         Map<String, Object> profileInfo = sliceParams.getServiceProfile()
 341         TemplateInfo nstInfo = sliceParams.getNSTInfo()
 342
 343         List<TemplateInfo> nsstInfos = execution.getVariable("nsstInfos") as List<TemplateInfo>
 344
 345         List<SubnetCapability> subnetCapabilities =
 346                 execution.getVariable("subnetCapabilities") as List<SubnetCapability>
 347
 348         String oofRequest = oofUtils.buildSelectNSIRequest(requestId, nstInfo, nsstInfos,
 349                 messageType, profileInfo, subnetCapabilities, timeout as Integer)
 350
 351         execution.setVariable("nsiSelection_oofRequest", oofRequest)
 352         logger.debug("Sending request to OOF: " + oofRequest)
 353     }
 354
 355     /**
 356      * todo: need rewrite
 357      * process select nsi response
 358      * @param execution
 359      */
 360     public void processNSIResp(DelegateExecution execution) {
 361
 362         SliceTaskParamsAdapter sliceTaskParams =
 363                 execution.getVariable("sliceTaskParams") as SliceTaskParamsAdapter
 364
 365         String OOFResponse = execution.getVariable("nsiSelection_oofResponse")
 366         logger.debug("NSI OOFResponse is: " + OOFResponse)
 367         execution.setVariable("OOFResponse", OOFResponse)
 368         //This needs to be changed to derive a value when we add policy to decide the solution options.
 369
 370         Map<String, Object> resMap = objectMapper.readValue(OOFResponse, Map.class)
 371         List<Map<String, Object>> nsiSolutions = (List<Map<String, Object>>) resMap.get("solutions")
 372         Map<String, Object> solution = nsiSolutions.get(0)
 373
 374         String resourceSharingLevel = execution.getVariable("resourceSharingLevel")
 375         Boolean isSharable = resourceSharingLevel == "shared"
 376
 377         if (solution != null) {
 378             if (isSharable && solution.get("existingNSI")) {
 379                 //sharedNSISolution
 380                 processSharedNSI(solution, sliceTaskParams)
 381             }
 382             else if(solution.containsKey("newNSISolution")) {
 383                 processNewNSI(solution, sliceTaskParams)
 384             }
 385         }
 386         execution.setVariable("sliceTaskParams", sliceTaskParams)
 387         //logger.debug("sliceTaskParams: " + sliceTaskParams.convertToJson())
 388         logger.debug("*** Completed options Call to OOF ***")
 389     }
 390
 391     private void processSharedNSI(Map<String, Object> solution, SliceTaskParamsAdapter sliceParams) {
 392         Map<String, Object> sharedNSISolution = solution.get("sharedNSISolution") as Map
 393
 394         String nsiId = sharedNSISolution.get("NSIId")
 395         String nsiName = sharedNSISolution.get("NSIName")
 396         sliceParams.setSuggestNsiId(nsiId)
 397         sliceParams.setSuggestNsiName(nsiName)
 398     }
 399
 400     private void processNewNSI(Map<String, Object> solution, SliceTaskParamsAdapter sliceParams) {
 401         Map<String, Object> newNSISolution = solution.get("newNSISolution") as Map
 402         List<Map> sliceProfiles = newNSISolution.get("sliceProfiles") as List<Map>
 403         for (Map sliceProfile : sliceProfiles) {
 404             String domainType = sliceProfile.get("domainType")
 405             switch (domainType.toLowerCase()) {
 406                 case "tn-bh":
 407                     sliceParams.tnBHSliceTaskInfo.sliceProfile = sliceProfile as TnSliceProfile
 408                     break
 409                 case "an-nf":
 410                     sliceParams.anSliceTaskInfo.sliceProfile = sliceProfile as AnSliceProfile
 411                     break
 412                 case "cn":
 413                     sliceParams.cnSliceTaskInfo.sliceProfile = sliceProfile as CnSliceProfile
 414                     break
 415                 default:
 416                     break
 417             }
 418
 419             //todo
 420
 421         }
 422     }
 423
 424     /**
 425      * get NSSI Selection Capability for AN
 426      * @param execution
 427      */
 428     public void getNSSISelectionCap4AN(DelegateExecution execution) {
 429
 430         def vendor = execution.getVariable("vendor") as String
 431
 432         String strRequest = buildNSSISelectionReq(vendor, NetworkType.ACCESS)
 433
 434         String response = nssmfAdapterUtils.sendPostRequestNSSMF(execution, QUERY_NSSI_SELECTION_CAPABILITY, strRequest)
 435
 436         Map<String, Object> resMap = objectMapper.readValue(response, Map.class)
 437
 438         String selection = resMap.get("selection")
 439
 440
 441         if ("NSMF".equalsIgnoreCase(selection)) {
 442             execution.setVariable("NEED_AN_NSSI_SELECTION", true)
 443         }
 444     }
 445
 446     /**
 447      * get NSSI Selection Capability for TN
 448      * @param execution
 449      */
 450     public void getNSSISelectionCap4TN(DelegateExecution execution) {
 451
 452         def vendor = execution.getVariable("vendor") as String
 453
 454         String strRequest = buildNSSISelectionReq(vendor, NetworkType.TRANSPORT)
 455
 456         String response = nssmfAdapterUtils.sendPostRequestNSSMF(execution, QUERY_NSSI_SELECTION_CAPABILITY, strRequest)
 457
 458         Map<String, Object> resMap = objectMapper.readValue(response, Map.class)
 459
 460         String selection = resMap.get("selection")
 461
 462         if ("NSMF".equalsIgnoreCase(selection)) {
 463             execution.setVariable("NEED_TN_NSSI_SELECTION", true)
 464         }
 465     }
 466
 467     /**
 468      * get NSSI Selection Capability for CN
 469      * @param execution
 470      */
 471     public void getNSSISelectionCap4CN(DelegateExecution execution) {
 472
 473         def vendor = execution.getVariable("vendor") as String
 474
 475         String strRequest = buildNSSISelectionReq(vendor, NetworkType.CORE)
 476
 477         String response = nssmfAdapterUtils.sendPostRequestNSSMF(execution, QUERY_NSSI_SELECTION_CAPABILITY, strRequest)
 478
 479         Map<String, Object> resMap = objectMapper.readValue(response, Map.class)
 480
 481         String selection = resMap.get("selection")
 482
 483         if ("NSMF".equalsIgnoreCase(selection)) {
 484             execution.setVariable("NEED_CN_NSSI_SELECTION", true)
 485         }
 486     }
 487
 488     /**
 489      * build NSSI Selection Capability Request body to nssmf adapter
 490      * @param vendor
 491      * @param networkType
 492      * @return
 493      */
 494     private static String buildNSSISelectionReq(String vendor, NetworkType networkType) {
 495         NssmfAdapterNBIRequest request = new NssmfAdapterNBIRequest()
 496         EsrInfo esrInfo = new EsrInfo()
 497         esrInfo.setVendor(vendor)
 498         esrInfo.setNetworkType(networkType)
 499         request.setEsrInfo(esrInfo)
 500
 501         return objectMapper.writeValueAsString(request)
 502     }
 503
 504     /**
 505      * if exist nssi need to select?
 506      * @param execution
 507      */
 508     public void handleNssiSelect(DelegateExecution execution) {
 509
 510         SliceTaskParamsAdapter sliceTaskParams =
 511                 execution.getVariable("sliceTaskParams") as SliceTaskParamsAdapter
 512
 513         //todo
 514     }
 515
 516     /**
 517      * todo: need rewrite
 518      * prepare select nssi request
 519      * @param execution
 520      */
 521     public void preNSSIRequest(DelegateExecution execution) {
 522
 523         String urlString = UrnPropertiesReader.getVariable("mso.oof.endpoint", execution)
 524         logger.debug( "get NSI option OOF Url: " + urlString)
 525
 526         boolean isNSISuggested = true
 527         execution.setVariable("isNSISuggested", isNSISuggested)
 528         String requestId = execution.getVariable("msoRequestId")
 529         String messageType = "NSISelectionResponse"
 530
 531         Map<String, Object> profileInfo = execution.getVariable("serviceProfile") as Map
 532         Map<String, Object> nstSolution = execution.getVariable("nstSolution") as Map
 533         logger.debug("Get NST selection from OOF: " + nstSolution.toString())
 534         String nstInfo = """{
 535             "modelInvariantId":"${nstSolution.invariantUUID}",
 536             "modelVersionId":"${nstSolution.UUID}",
 537             "modelName":"${nstSolution.NSTName}"
 538          }"""
 539
 540         execution.setVariable("nsiSelectionUrl", "/api/oof/selection/nsi/v1")
 541         execution.setVariable("nsiSelection_messageType", messageType)
 542         execution.setVariable("nsiSelection_correlator", requestId)
 543         String timeout = UrnPropertiesReader.getVariable("mso.adapters.oof.timeout", execution)
 544         execution.setVariable("nsiSelection_timeout", timeout)
 545
 546         //todo
 547         String oofRequest = oofUtils.buildSelectNSIRequest(requestId, nstInfo, messageType, profileInfo)
 548
 549         execution.setVariable("nsiSelection_oofRequest", oofRequest)
 550         logger.debug("Sending request to OOF: " + oofRequest)
 551     }
 552
 553     /**
 554      * process select nssi response
 555      * todo: unfinished
 556      * @param execution
 557      */
 558     public void processNSSIResp(DelegateExecution execution) {
 559
 560         SliceTaskParams sliceTaskParams = execution.getVariable("sliceTaskParams") as SliceTaskParams
 561         String OOFResponse = execution.getVariable("nsiSelection_oofResponse")
 562         logger.debug("NSI OOFResponse is: " + OOFResponse)
 563         execution.setVariable("OOFResponse", OOFResponse)
 564         //This needs to be changed to derive a value when we add policy to decide the solution options.
 565
 566         Map<String, Object> resMap = objectMapper.readValue(OOFResponse, Map.class)
 567         List<Map<String, Object>> nsiSolutions = (List<Map<String, Object>>) resMap.get("solutions")
 568         Map<String, Object> solutions = nsiSolutions.get(0)
 569
 570         String resourceSharingLevel = execution.getVariable("resourceSharingLevel")
 571         Boolean isSharable = resourceSharingLevel == "shared"
 572
 573         if (solutions != null) {
 574             if (isSharable && solutions.get("existingNSI")) {
 575                 //sharedNSISolution
 576                 //processSharedNSISolutions(solutions, execution)
 577             }
 578             else if(solutions.containsKey("newNSISolution")) {
 579                 //processNewNSISolutions(solutions, execution)
 580             }
 581         }
 582         execution.setVariable("sliceTaskParams", sliceTaskParams)
 583         logger.debug("sliceTaskParams: "+sliceTaskParams.convertToJson())
 584         logger.debug("*** Completed options Call to OOF ***")
 585
 586         logger.debug("start parseServiceProfile")
 587         //parseServiceProfile(execution)
 588         logger.debug("end parseServiceProfile")
 589     }
 590
 591
 592 }