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