adapters/mso-vfc-adapter/src/main/java/org/onap/so/adapters/vfc/rest/VfcManager.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ONAP - SO
   4  * ================================================================================
   5  * Copyright (C) 2017 Huawei Technologies Co., Ltd. All rights reserved.
   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.adapters.vfc.rest;
  22
  23 import java.util.HashMap;
  24 import java.util.Map;
  25
  26 import org.onap.so.adapters.vfc.constant.CommonConstant;
  27 import org.onap.so.adapters.vfc.constant.CommonConstant.Step;
  28 import org.onap.so.adapters.vfc.constant.DriverExceptionID;
  29 import org.onap.so.adapters.vfc.constant.HttpCode;
  30 import org.onap.so.adapters.vfc.exceptions.ApplicationException;
  31 import org.onap.so.adapters.vfc.model.CustomerModel;
  32 import org.onap.so.adapters.vfc.model.NSResourceInputParameter;
  33 import org.onap.so.adapters.vfc.model.NsCreateReq;
  34 import org.onap.so.adapters.vfc.model.NsInstantiateReq;
  35 import org.onap.so.adapters.vfc.model.NsOperationKey;
  36 import org.onap.so.adapters.vfc.model.NsParameters;
  37 import org.onap.so.adapters.vfc.model.NsProgressStatus;
  38 import org.onap.so.adapters.vfc.model.NsScaleParameters;
  39 import org.onap.so.adapters.vfc.model.ResponseDescriptor;
  40 import org.onap.so.adapters.vfc.model.RestfulResponse;
  41 import org.onap.so.adapters.vfc.model.VFCScaleData;
  42 import org.onap.so.adapters.vfc.util.JsonUtil;
  43 import org.onap.so.adapters.vfc.util.RestfulUtil;
  44 import org.onap.so.adapters.vfc.util.ValidateUtil;
  45 import org.onap.so.db.request.beans.ResourceOperationStatus;
  46 import org.onap.so.db.request.data.repository.ResourceOperationStatusRepository;
  47 import org.onap.so.requestsdb.RequestsDbConstant;
  48 import org.slf4j.Logger;
  49 import org.slf4j.LoggerFactory;
  50 import org.springframework.beans.factory.annotation.Autowired;
  51 import org.springframework.context.annotation.Primary;
  52 import org.springframework.data.domain.Example;
  53 import org.springframework.stereotype.Component;
  54
  55 /**
  56  * VF-C Manager <br>
  57  * <p>
  58  * </p>
  59  *
  60  * @author
  61  * @version ONAP Amsterdam Release 2017-08-28
  62  */
  63 @Component
  64 @Primary
  65 public class VfcManager {
  66
  67   private static final Logger LOGGER = LoggerFactory.getLogger(VfcManager.class);
  68
  69   /**
  70    * nfvo url map
  71    */
  72   private Map<String, String> nfvoUrlMap;
  73
  74   @Autowired
  75   private ResourceOperationStatusRepository resourceOperationStatusRepository;
  76
  77   @Autowired
  78   private RestfulUtil restfulUtil;
  79
  80
  81   public VfcManager() {
  82           nfvoUrlMap = new HashMap<>();
  83           nfvoUrlMap.put(Step.CREATE, CommonConstant.NFVO_CREATE_URL);
  84           nfvoUrlMap.put(Step.INSTANTIATE, CommonConstant.NFVO_INSTANTIATE_URL);
  85           nfvoUrlMap.put(Step.TERMINATE, CommonConstant.NFVO_TERMINATE_URL);
  86           nfvoUrlMap.put(Step.DELETE, CommonConstant.NFVO_DELETE_URL);
  87           nfvoUrlMap.put(Step.QUERY, CommonConstant.NFVO_QUERY_URL);
  88           nfvoUrlMap.put(Step.SCALE, CommonConstant.NFVO_SCALE_URL);
  89   }
  90
  91   /**
  92    * create network service <br>
  93    *
  94    * @param segInput input parameters for current node from http request
  95    * @return
  96    * @since ONAP Amsterdam Release
  97    */
  98   public RestfulResponse createNs(NSResourceInputParameter segInput) throws ApplicationException {
  99
 100     // Step1: get service template by node type
 101     String csarId = segInput.getNsServiceModelUUID();
 102     // nsdId for NFVO is "id" in the response, while for SDNO is "servcice template id"
 103     LOGGER.info("serviceTemplateId is {}, id is {}", csarId, csarId);
 104
 105     LOGGER.info("create ns -> begin");
 106     // Step2: Prepare url and method type
 107     String url = getUrl(null, CommonConstant.Step.CREATE);
 108     String methodType = CommonConstant.MethodType.POST;
 109
 110     // Step3: Prepare restful parameters and options
 111     NsCreateReq oRequest = new NsCreateReq();
 112     oRequest.setCsarId(csarId);
 113     oRequest.setNsName(segInput.getNsServiceName());
 114     oRequest.setDescription(segInput.getNsServiceDescription());
 115     CustomerModel context = new CustomerModel();
 116     context.setGlobalCustomerId(segInput.getNsOperationKey().getGlobalSubscriberId());
 117     context.setServiceType(segInput.getNsOperationKey().getServiceType());
 118     oRequest.setContext(context);
 119     String createReq = JsonUtil.marshal(oRequest);
 120
 121     // Step4: Call NFVO or SDNO lcm to create ns
 122     RestfulResponse createRsp = restfulUtil.send(url, methodType, createReq);
 123     ValidateUtil.assertObjectNotNull(createRsp);
 124     LOGGER.info("create ns response status is : {}", createRsp.getStatus());
 125     LOGGER.info("create ns response content is : {}", createRsp.getResponseContent());
 126
 127     // Step 5: save resource operation information
 128     ResourceOperationStatus status = new ResourceOperationStatus(segInput.getNsOperationKey().getServiceId(), segInput.getNsOperationKey().getOperationId(), segInput.getNsOperationKey().getNodeTemplateUUID());
 129     status.setStatus(RequestsDbConstant.Status.PROCESSING);
 130     status = resourceOperationStatusRepository.save(status);
 131     if (!HttpCode.isSucess(createRsp.getStatus())) {
 132       LOGGER.error("update segment operation status : fail to create ns");
 133       status.setProgress("40");
 134       status.setStatusDescription("NS is created");
 135       status.setStatus(RequestsDbConstant.Status.ERROR);
 136       status.setErrorCode(String.valueOf(createRsp.getStatus()));
 137       resourceOperationStatusRepository.save(status);
 138       throw new ApplicationException(HttpCode.INTERNAL_SERVER_ERROR,
 139           DriverExceptionID.FAIL_TO_CREATE_NS);
 140     }
 141     @SuppressWarnings("unchecked")
 142     Map<String, String> rsp = JsonUtil.unMarshal(createRsp.getResponseContent(), Map.class);
 143     String nsInstanceId = rsp.get(CommonConstant.NS_INSTANCE_ID);
 144     if (ValidateUtil.isStrEmpty(nsInstanceId)) {
 145       LOGGER.error("Invalid instanceId from create operation");
 146       throw new ApplicationException(HttpCode.INTERNAL_SERVER_ERROR,
 147           DriverExceptionID.INVALID_RESPONSEE_FROM_CREATE_OPERATION);
 148     }
 149     LOGGER.info("create ns -> end");
 150     LOGGER.info("save segment and operaton info -> begin");
 151     // Step 6: add relation between service and NS
 152     AaiUtil.addRelation(segInput.getNsOperationKey().getGlobalSubscriberId(),
 153         segInput.getNsOperationKey().getServiceType(), segInput.getNsOperationKey().getServiceId(),
 154         nsInstanceId);
 155     LOGGER.info("save segment and operation info -> end");
 156     return createRsp;
 157   }
 158
 159   /**
 160    * delete network service <br>
 161    *
 162    * @param nsOperationKey The operation key of the NS resource
 163    * @param nsInstanceId The NS instance id
 164    * @return
 165    * @since ONAP Amsterdam Release
 166    */
 167   public RestfulResponse deleteNs(NsOperationKey nsOperationKey, String nsInstanceId)
 168       throws ApplicationException {
 169     LOGGER.info("delete ns -> begin");
 170     // Step1: prepare url and methodType
 171     String url = getUrl(nsInstanceId, CommonConstant.Step.DELETE);
 172     String methodType = CommonConstant.MethodType.DELETE;
 173
 174     // Step2: prepare restful parameters and options
 175     RestfulResponse deleteRsp = restfulUtil.send(url, methodType, "");
 176     ValidateUtil.assertObjectNotNull(deleteRsp);
 177     LOGGER.info("delete ns response status is : {}", deleteRsp.getStatus());
 178     LOGGER.info("delete ns response content is : {}", deleteRsp.getResponseContent());
 179     LOGGER.info("delete ns -> end");
 180
 181     ResourceOperationStatus status = new ResourceOperationStatus(nsOperationKey.getServiceId(), nsOperationKey.getOperationId(), nsOperationKey.getNodeTemplateUUID());
 182     if (!HttpCode.isSucess(deleteRsp.getStatus())) {
 183       LOGGER.error("fail to delete ns");
 184
 185       status.setStatus(RequestsDbConstant.Status.ERROR);
 186       status.setErrorCode(String.valueOf(deleteRsp.getStatus()));
 187       status.setStatusDescription(CommonConstant.StatusDesc.TERMINATE_NS_FAILED);
 188       resourceOperationStatusRepository.save(status);
 189       throw new ApplicationException(HttpCode.INTERNAL_SERVER_ERROR,
 190           DriverExceptionID.FAIL_TO_DELETE_NS);
 191     }
 192
 193     // Step3: remove relation info between service and ns
 194     AaiUtil.removeRelation(nsOperationKey.getGlobalSubscriberId(), nsOperationKey.getServiceType(),
 195         nsOperationKey.getServiceId(), nsInstanceId);
 196     LOGGER.info("delete segment information -> end");
 197
 198     // Step4: update service segment operation status
 199     status.setStatus(RequestsDbConstant.Status.FINISHED);
 200     status.setErrorCode(String.valueOf(deleteRsp.getStatus()));
 201     status.setProgress("100");
 202     status.setStatusDescription("VFC resource deletion finished");
 203     resourceOperationStatusRepository.save(status);
 204     LOGGER.info("update segment operaton status for delete -> end");
 205
 206     return deleteRsp;
 207
 208   }
 209
 210   /**
 211    * instantiate network service <br>
 212    *
 213    * @param nsInstanceId The NS instance id
 214    * @param segInput input parameters for current node from http request
 215    * @return
 216    * @since ONAP Amsterdam Release
 217    */
 218   public RestfulResponse instantiateNs(String nsInstanceId, NSResourceInputParameter segInput)
 219       throws ApplicationException {
 220     // Call the NFVO or SDNO service to instantiate service
 221     LOGGER.info("instantiate ns -> begin");
 222
 223     // Step1: Prepare restful parameters and options
 224     NsInstantiateReq oRequest = new NsInstantiateReq();
 225     oRequest.setNsInstanceId(nsInstanceId);
 226     NsParameters nsParameters = segInput.getNsParameters();
 227     oRequest.setLocationConstraints(nsParameters.getLocationConstraints());
 228     oRequest.setAdditionalParamForNs(nsParameters.getAdditionalParamForNs());
 229     String instReq = JsonUtil.marshal(oRequest);
 230     // Step2: prepare url and
 231     String url = getUrl(nsInstanceId, CommonConstant.Step.INSTANTIATE);
 232     String methodType = CommonConstant.MethodType.POST;
 233
 234     RestfulResponse instRsp = restfulUtil.send(url, methodType, instReq);
 235     ResourceOperationStatus status = new ResourceOperationStatus(segInput.getNsOperationKey().getServiceId(), segInput.getNsOperationKey().getOperationId(), segInput.getNsOperationKey().getNodeTemplateUUID());
 236     ValidateUtil.assertObjectNotNull(instRsp);
 237     if (!HttpCode.isSucess(instRsp.getStatus())) {
 238         LOGGER.error("update segment operation status : fail to instantiate ns");
 239         status.setStatus(RequestsDbConstant.Status.ERROR);
 240         status.setErrorCode(String.valueOf(instRsp.getStatus()));
 241         status.setStatusDescription(CommonConstant.StatusDesc.INSTANTIATE_NS_FAILED);
 242         resourceOperationStatusRepository.save(status);
 243         throw new ApplicationException(HttpCode.INTERNAL_SERVER_ERROR,
 244             DriverExceptionID.FAIL_TO_INSTANTIATE_NS);
 245       }
 246     LOGGER.info("instantiate ns response status is : {}", instRsp.getStatus());
 247     LOGGER.info("instantiate ns response content is : {}", instRsp.getResponseContent());
 248     ValidateUtil.assertObjectNotNull(instRsp.getResponseContent());
 249     @SuppressWarnings("unchecked")
 250     Map<String, String> rsp = JsonUtil.unMarshal(instRsp.getResponseContent(), Map.class);
 251     String jobId = rsp.get(CommonConstant.JOB_ID);
 252     if (ValidateUtil.isStrEmpty(jobId)) {
 253       LOGGER.error("Invalid jobId from instantiate operation");
 254       status.setStatus(RequestsDbConstant.Status.ERROR);
 255       status.setErrorCode(String.valueOf(instRsp.getStatus()));
 256       status.setStatusDescription(CommonConstant.StatusDesc.INSTANTIATE_NS_FAILED);
 257       resourceOperationStatusRepository.save(status);
 258       throw new ApplicationException(HttpCode.INTERNAL_SERVER_ERROR,
 259           DriverExceptionID.INVALID_RESPONSE_FROM_INSTANTIATE_OPERATION);
 260     }
 261     LOGGER.info("instantiate ns -> end");
 262     // Step 3: update segment operation job id
 263     LOGGER.info("update resource operation status job id -> begin");
 264     status.setJobId(jobId);
 265     status.setProgress("100");
 266     status.setStatusDescription("NS initiation completed.");
 267     resourceOperationStatusRepository.save(status);
 268     LOGGER.info("update segment operation job id -> end");
 269
 270     return instRsp;
 271   }
 272
 273   /**
 274    * terminate network service <br>
 275    *
 276    * @param nsOperationKey The operation key for NS resource
 277    * @param nsInstanceId The NS instance id
 278    * @return
 279    * @since ONAP Amsterdam Release
 280    */
 281   public RestfulResponse terminateNs(NsOperationKey nsOperationKey, String nsInstanceId)
 282       throws ApplicationException {
 283     // Step1: save segment operation info for delete process
 284     LOGGER.info("save segment operation for delete process");
 285     ResourceOperationStatus status = new ResourceOperationStatus(nsOperationKey.getServiceId(), nsOperationKey.getOperationId(), nsOperationKey.getNodeTemplateUUID());
 286     status.setStatus(RequestsDbConstant.Status.PROCESSING);
 287     resourceOperationStatusRepository.save(status);
 288
 289     LOGGER.info("terminate ns -> begin");
 290     // Step2: prepare url and method type
 291     String url = getUrl(nsInstanceId, CommonConstant.Step.TERMINATE);
 292     String methodType = CommonConstant.MethodType.POST;
 293
 294     // Step3: prepare restful parameters and options
 295     Map<String, String> reqBody = new HashMap<>();
 296     reqBody.put("nsInstanceId", nsInstanceId);
 297     reqBody.put("terminationType", "graceful");
 298     reqBody.put("gracefulTerminationTimeout", "60");
 299
 300     // Step4: Call the NFVO or SDNO service to terminate service
 301     RestfulResponse terminateRsp = restfulUtil.send(url, methodType, JsonUtil.marshal(reqBody));
 302     ValidateUtil.assertObjectNotNull(terminateRsp);
 303     LOGGER.info("terminate ns response status is : {}", terminateRsp.getStatus());
 304     LOGGER.info("terminate ns response content is : {}", terminateRsp.getResponseContent());
 305     // Step 3: update segment operation
 306     if (!HttpCode.isSucess(terminateRsp.getStatus())) {
 307       LOGGER.error("fail to instantiate ns");
 308       status.setStatus(RequestsDbConstant.Status.ERROR);
 309       status.setErrorCode(String.valueOf(terminateRsp.getStatus()));
 310       status.setStatusDescription(CommonConstant.StatusDesc.TERMINATE_NS_FAILED);
 311       resourceOperationStatusRepository.save(status);
 312
 313       throw new ApplicationException(HttpCode.INTERNAL_SERVER_ERROR,
 314           DriverExceptionID.FAIL_TO_TERMINATE_NS);
 315     }
 316     @SuppressWarnings("unchecked")
 317     Map<String, String> rsp = JsonUtil.unMarshal(terminateRsp.getResponseContent(), Map.class);
 318     String jobId = rsp.get(CommonConstant.JOB_ID);
 319     if (ValidateUtil.isStrEmpty(jobId)) {
 320       LOGGER.error("Invalid jobId from terminate operation");
 321       status.setStatus(RequestsDbConstant.Status.ERROR);
 322       status.setErrorCode(String.valueOf(terminateRsp.getStatus()));
 323       status.setStatusDescription(CommonConstant.StatusDesc.TERMINATE_NS_FAILED);
 324       resourceOperationStatusRepository.save(status);
 325       throw new ApplicationException(HttpCode.INTERNAL_SERVER_ERROR,
 326           DriverExceptionID.INVALID_RESPONSE_FROM_TERMINATE_OPERATION);
 327     }
 328     LOGGER.info("terminate ns -> end");
 329
 330     LOGGER.info("update segment job id -> begin");
 331     status.setProgress("60");
 332     status.setStatusDescription("NS is termination completed");
 333     status.setJobId(jobId);
 334     resourceOperationStatusRepository.save(status);
 335     LOGGER.info("update segment job id -> end");
 336
 337     return terminateRsp;
 338   }
 339
 340   /**
 341    * get ns progress by job Id <br>
 342    *
 343    * @param nsOperationKey The OperationKey for NS resource
 344    * @param jobId the job id
 345    * @return
 346    * @since ONAP Amsterdam Release
 347    */
 348   public RestfulResponse getNsProgress(NsOperationKey nsOperationKey, String jobId)
 349       throws ApplicationException {
 350
 351     ValidateUtil.assertObjectNotNull(jobId);
 352     // Step 1: query the current resource operation status
 353     ResourceOperationStatus status = new ResourceOperationStatus(nsOperationKey.getServiceId(), nsOperationKey.getOperationId(), nsOperationKey.getNodeTemplateUUID());
 354     status = resourceOperationStatusRepository.findOne(Example.of(status))
 355                 .orElseThrow( () -> new ApplicationException(404,"Cannot Find Operation Status"));
 356     // Step 2: start query
 357     LOGGER.info("query ns status -> begin");
 358     String url = getUrl(jobId, CommonConstant.Step.QUERY);
 359     String methodType = CommonConstant.MethodType.GET;
 360     // prepare restful parameters and options
 361     RestfulResponse rsp = restfulUtil.send(url, methodType, "");
 362     ValidateUtil.assertObjectNotNull(rsp);
 363     LOGGER.info("query ns progress response status is : {}", rsp.getStatus());
 364     LOGGER.info("query ns progress response content is : {}", rsp.getResponseContent());
 365     // Step 3:check the response staus
 366     if (!HttpCode.isSucess(rsp.getStatus())) {
 367       LOGGER.info("fail to query job status");
 368       status.setErrorCode(String.valueOf(rsp.getStatus()));
 369       status.setStatus(RequestsDbConstant.Status.ERROR);
 370       status.setStatusDescription(CommonConstant.StatusDesc.QUERY_JOB_STATUS_FAILED);
 371       resourceOperationStatusRepository.save(status);
 372       throw new ApplicationException(HttpCode.INTERNAL_SERVER_ERROR,
 373           DriverExceptionID.FAIL_TO_QUERY_JOB_STATUS);
 374     }
 375     // Step 4: Process Network Service Instantiate Response
 376     NsProgressStatus nsProgress =
 377         JsonUtil.unMarshal(rsp.getResponseContent(), NsProgressStatus.class);
 378     ResponseDescriptor rspDesc = nsProgress.getResponseDescriptor();
 379     // Step 5: update segment operation progress
 380
 381     status.setProgress(rspDesc.getProgress());
 382     status.setStatusDescription(rspDesc.getStatusDescription());
 383     resourceOperationStatusRepository.save(status);
 384
 385     // Step 6: update segment operation status
 386     if (RequestsDbConstant.Progress.ONE_HUNDRED.equals(rspDesc.getProgress())
 387         && RequestsDbConstant.Status.FINISHED.equals(rspDesc.getStatus())) {
 388       LOGGER.info("job result is succeeded, operType is {}", status.getOperType());
 389       status.setErrorCode(String.valueOf(rsp.getStatus()));
 390       status.setStatusDescription(CommonConstant.StatusDesc.QUERY_JOB_STATUS_FAILED);
 391
 392       if(RequestsDbConstant.OperationType.CREATE.equalsIgnoreCase(status.getOperType()) || "createInstance".equalsIgnoreCase (status.getOperType())) {
 393         status.setStatus(RequestsDbConstant.Status.FINISHED);
 394       }
 395       resourceOperationStatusRepository.save(status);
 396     } else if (RequestsDbConstant.Status.ERROR.equals(rspDesc.getStatus())) {
 397       LOGGER.error("job result is failed, operType is {}", status.getOperType());
 398       status.setErrorCode(String.valueOf(rsp.getStatus()));
 399       status.setStatusDescription(CommonConstant.StatusDesc.QUERY_JOB_STATUS_FAILED);
 400       status.setStatus(RequestsDbConstant.Status.ERROR);
 401       resourceOperationStatusRepository.save(status);
 402       throw new ApplicationException(HttpCode.INTERNAL_SERVER_ERROR,
 403           DriverExceptionID.JOB_STATUS_ERROR);
 404     } else {
 405       LOGGER.error("unexcepted response status");
 406     }
 407     LOGGER.info("query ns status -> end");
 408
 409     return rsp;
 410   }
 411
 412     /**
 413      * Scale NS instance
 414      * <br>
 415      *
 416      * @param nsInstanceId The NS instance id
 417      * @param segInput input parameters for current node from http request
 418      * @return
 419      * @since ONAP Amsterdam Release
 420      */
 421     public RestfulResponse scaleNs(String nsInstanceId, NSResourceInputParameter segInput)
 422                 throws ApplicationException {
 423         // Call the NFVO to scale service
 424         LOGGER.info("scale ns -> begin");
 425
 426         // Step1: Prepare restful parameters and options
 427         VFCScaleData oRequest = new VFCScaleData();
 428         oRequest.setNsInstanceId(nsInstanceId);
 429         NsScaleParameters nsScaleParameters = segInput.getNsScaleParameters();
 430         oRequest.setScaleType(nsScaleParameters.getScaleType());
 431         oRequest.setScaleNsData(nsScaleParameters.getScaleNsByStepsData());
 432         String scaleReq = JsonUtil.marshal(oRequest);
 433
 434         // Step2: prepare url and method type
 435         String url = getUrl(nsInstanceId, CommonConstant.Step.SCALE);
 436         String methodType = CommonConstant.MethodType.POST;
 437         LOGGER.info("scale ns request is {}", scaleReq);
 438         // Step3: Call NFVO lcm to scale ns
 439         RestfulResponse scaleRsp = restfulUtil.send(url, methodType, scaleReq);
 440
 441         ResourceOperationStatus status = new ResourceOperationStatus(segInput.getNsOperationKey().getServiceId(), segInput.getNsOperationKey().getOperationId(), segInput.getNsOperationKey().getNodeTemplateUUID());
 442         ResourceOperationStatus nsOperInfo = resourceOperationStatusRepository.findOne(Example.of(status))
 443                         .orElseThrow( () -> new ApplicationException(404,"Cannot Find Operation Status"));
 444         ValidateUtil.assertObjectNotNull(scaleRsp);
 445         if(!HttpCode.isSucess(scaleRsp.getStatus())) {
 446             LOGGER.error("update segment operation status : fail to scale ns");
 447             nsOperInfo.setStatus(RequestsDbConstant.Status.ERROR);
 448             nsOperInfo.setErrorCode(String.valueOf(scaleRsp.getStatus()));
 449             nsOperInfo.setStatusDescription(CommonConstant.StatusDesc.SCALE_NS_FAILED);
 450             resourceOperationStatusRepository.save(nsOperInfo);
 451             throw new ApplicationException(HttpCode.INTERNAL_SERVER_ERROR, DriverExceptionID.FAIL_TO_SCALE_NS);
 452         }
 453         LOGGER.info("scale ns response status is {}", scaleRsp.getStatus());
 454         LOGGER.info("scale ns response content is {}", scaleRsp.getResponseContent());
 455
 456         ValidateUtil.assertObjectNotNull(scaleRsp.getResponseContent());
 457         @SuppressWarnings("unchecked")
 458         Map<String, String> rsp = JsonUtil.unMarshal(scaleRsp.getResponseContent(), Map.class);
 459         String jobId = rsp.get(CommonConstant.JOB_ID);
 460         if(ValidateUtil.isStrEmpty(jobId)) {
 461             LOGGER.error("Invalid jobId from scale operation");
 462             nsOperInfo.setStatus(RequestsDbConstant.Status.ERROR);
 463             nsOperInfo.setErrorCode(String.valueOf(scaleRsp.getStatus()));
 464             nsOperInfo.setStatusDescription(CommonConstant.StatusDesc.SCALE_NS_FAILED);
 465             resourceOperationStatusRepository.save(nsOperInfo);
 466             throw new ApplicationException(HttpCode.INTERNAL_SERVER_ERROR,
 467                     DriverExceptionID.INVALID_RESPONSE_FROM_SCALE_OPERATION);
 468         }
 469
 470         LOGGER.info("update resource operation status job id -> begin");
 471         // Step 4: update segment operation job id
 472         nsOperInfo.setJobId(jobId);
 473         resourceOperationStatusRepository.save(nsOperInfo);
 474         LOGGER.info("update segment operation job id -> end");
 475         LOGGER.info("scale ns -> end");
 476
 477         return scaleRsp;
 478     }
 479
 480   /**
 481    * get url for the operation <br>
 482    *
 483    * @param variable variable should be put in the url
 484    * @param step step of the operation (terminate,query,delete)
 485    * @return
 486    * @since ONAP Amsterdam Release
 487    */
 488   private String getUrl(String variable, String step) {
 489
 490     String url;
 491     String originalUrl;
 492     originalUrl = nfvoUrlMap.get(step);
 493     url = String.format(originalUrl, variable);
 494     return url;
 495
 496   }
 497
 498 }