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