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