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