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