server/src/main/java/org/onap/usecaseui/server/service/csmf/impl/SlicingServiceImpl.java

   1 /*
   2  * Copyright (C) 2020 CMCC, Inc. and others. All rights reserved.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package org.onap.usecaseui.server.service.csmf.impl;
  17
  18 import com.alibaba.fastjson.JSON;
  19 import com.alibaba.fastjson.JSONArray;
  20 import com.alibaba.fastjson.JSONObject;
  21 import com.google.gson.Gson;
  22 import com.google.gson.reflect.TypeToken;
  23 import java.io.File;
  24 import java.io.FileInputStream;
  25 import java.io.IOException;
  26 import java.io.InputStream;
  27 import java.lang.reflect.Type;
  28 import java.text.ParseException;
  29 import java.util.ArrayList;
  30 import java.util.List;
  31 import java.util.Properties;
  32 import java.util.stream.Collectors;
  33 import javax.annotation.Resource;
  34 import okhttp3.MediaType;
  35 import okhttp3.RequestBody;
  36 import org.onap.usecaseui.server.bean.ServiceInstanceOperations;
  37 import org.onap.usecaseui.server.bean.csmf.CreateResponse;
  38 import org.onap.usecaseui.server.bean.csmf.CreationParameters;
  39 import org.onap.usecaseui.server.bean.csmf.CreationRequest;
  40 import org.onap.usecaseui.server.bean.csmf.CreationRequestInputs;
  41 import org.onap.usecaseui.server.bean.csmf.CreationService;
  42 import org.onap.usecaseui.server.bean.csmf.OrderInfo;
  43 import org.onap.usecaseui.server.bean.csmf.OrderList;
  44 import org.onap.usecaseui.server.bean.csmf.ServiceCreateResult;
  45 import org.onap.usecaseui.server.bean.csmf.SlicingOrder;
  46 import org.onap.usecaseui.server.bean.nsmf.common.PagedResult;
  47 import org.onap.usecaseui.server.bean.nsmf.common.ResultHeader;
  48 import org.onap.usecaseui.server.bean.nsmf.common.ServiceResult;
  49 import org.onap.usecaseui.server.constant.CommonConstant;
  50 import org.onap.usecaseui.server.constant.csmf.CsmfParamConstant;
  51 import org.onap.usecaseui.server.constant.nsmf.NsmfCodeConstant;
  52 import org.onap.usecaseui.server.constant.nsmf.NsmfParamConstant;
  53 import org.onap.usecaseui.server.service.csmf.SlicingService;
  54 import org.onap.usecaseui.server.service.lcm.ServiceLcmService;
  55 import org.onap.usecaseui.server.service.slicingdomain.aai.AAISliceService;
  56 import org.onap.usecaseui.server.service.slicingdomain.aai.bean.AAIServiceInstance;
  57 import org.onap.usecaseui.server.service.slicingdomain.so.SOSliceService;
  58 import org.onap.usecaseui.server.service.slicingdomain.so.bean.SOOperation;
  59 import org.onap.usecaseui.server.util.RestfulServices;
  60 import org.onap.usecaseui.server.util.nsmf.NsmfCommonUtil;
  61 import org.slf4j.Logger;
  62 import org.slf4j.LoggerFactory;
  63 import org.springframework.context.annotation.EnableAspectJAutoProxy;
  64 import org.springframework.stereotype.Service;
  65 import retrofit2.Response;
  66
  67 @Service("SlicingService")
  68 @org.springframework.context.annotation.Configuration
  69 @EnableAspectJAutoProxy
  70 public class SlicingServiceImpl implements SlicingService {
  71
  72     private final static Logger logger = LoggerFactory.getLogger(SlicingServiceImpl.class);
  73
  74     @Resource(name = "ServiceLcmService")
  75     private ServiceLcmService serviceLcmService;
  76
  77     private AAISliceService aaiSliceService;
  78
  79     private SOSliceService soSliceService;
  80
  81     public SlicingServiceImpl() {
  82         this(RestfulServices.create(AAISliceService.class), RestfulServices.create(SOSliceService.class));
  83     }
  84
  85     public SlicingServiceImpl(AAISliceService aaiSliceService, SOSliceService soSliceService) {
  86         this.aaiSliceService = aaiSliceService;
  87         this.soSliceService = soSliceService;
  88     }
  89
  90     @Override
  91     public ServiceResult createSlicingService(SlicingOrder slicingOrder) {
  92
  93         ServiceCreateResult createResult = new ServiceCreateResult();
  94         String resultCode;
  95         String resultMsg;
  96         Gson gson = new Gson();
  97         ResultHeader resultHeader = new ResultHeader();
  98         try {
  99             // request bean for create slicing service
 100             CreationRequestInputs requestInputs = new CreationRequestInputs();
 101             requestInputs.setExpDataRateDL(slicingOrder.getSlicing_order_info().getExpDataRateDL());
 102             requestInputs.setExpDataRateUL(slicingOrder.getSlicing_order_info().getExpDataRateUL());
 103             requestInputs.setLatency(slicingOrder.getSlicing_order_info().getLatency());
 104             requestInputs.setMaxNumberofUEs(slicingOrder.getSlicing_order_info().getMaxNumberofUEs());
 105             requestInputs.setUEMobilityLevel(slicingOrder.getSlicing_order_info().getUEMobilityLevel());
 106             requestInputs.setResourceSharingLevel(slicingOrder.getSlicing_order_info().getResourceSharingLevel());
 107             requestInputs.setCoverageAreaList(slicingOrder.getSlicing_order_info().getCoverageArea());
 108             //use default value
 109             requestInputs.setUseInterval("20");
 110             CreationParameters parameters = new CreationParameters();
 111             parameters.setRequestInputs(requestInputs);
 112             CreationService creationService = new CreationService();
 113             creationService.setName(slicingOrder.getSlicing_order_info().getName());
 114             creationService.setDescription(CommonConstant.BLANK);
 115             String slicingPath = System.getProperty("user.dir") + File.separator + "config" + File.separator + "slicing.properties";
 116             InputStream inputStream = new FileInputStream(new File(slicingPath));
 117             Properties environment = new Properties();
 118             environment.load(inputStream);
 119             String serviceInvariantUuid = environment.getProperty("slicing.serviceInvariantUuid");
 120             creationService.setServiceInvariantUuid(serviceInvariantUuid);
 121             String serviceUuid = environment.getProperty("slicing.serviceUuid");
 122             creationService.setServiceUuid(serviceUuid);
 123             logger.info("serviceInvariantUuid is {}, serviceUuid is {}.", serviceInvariantUuid, serviceUuid);
 124
 125             creationService.setGlobalSubscriberId(environment.getProperty("slicing.globalSubscriberId"));
 126             creationService.setServiceType(environment.getProperty("slicing.serviceType"));
 127             creationService.setParameters(parameters);
 128
 129             CreationRequest creationRequest = new CreationRequest();
 130             creationRequest.setService(creationService);
 131
 132             String jsonstr = gson.toJson(creationRequest);
 133             logger.info("createSlicingService:creationRequest request is:{}", jsonstr);
 134             RequestBody requestBody = RequestBody.create(MediaType.parse("application/json"), jsonstr.toString());
 135             Response<CreateResponse> updateResponse = soSliceService
 136                 .submitOrders(requestBody).execute();
 137
 138             if (updateResponse.isSuccessful()) {
 139                 CreateResponse createResponse = updateResponse.body();
 140                 logger.info("createSlicingService: submitOrders reponse is:{}",
 141                     gson.toJson(createResponse).toString());
 142
 143                 // set create operation result
 144                 createResult.setService_id(createResponse.getService().getServiceId());
 145                 createResult.setOperation_id(createResponse.getService().getOperationId());
 146
 147                 resultMsg = "5G slicing order created normally.";
 148                 resultHeader.setResult_code(NsmfCodeConstant.SUCCESS_CODE);
 149             } else {
 150                 logger.error(String
 151                     .format("createSlicingService: Can not submitOrders [code={}, message={}]", updateResponse.code(),
 152                         updateResponse.message()));
 153                 resultMsg = "5G slicing order created failed.";
 154                 resultHeader.setResult_code(NsmfCodeConstant.ERROR_CODE_UNKNOWN);
 155             }
 156         } catch (Exception e) {
 157             resultMsg = "5G slicing order created failed. Unknown exception occurred!";
 158             resultHeader.setResult_code(NsmfCodeConstant.ERROR_CODE_UNKNOWN);
 159             logger.error(e.getMessage());
 160         }
 161
 162         logger.info(resultMsg);
 163         logger.info("createSlicingService: 5G slicing order creation has been finished.");
 164         resultHeader.setResult_message(resultMsg);
 165         ServiceResult serviceResult = new ServiceResult(resultHeader, createResult);
 166         return serviceResult;
 167     }
 168
 169     @Override
 170     public ServiceResult querySlicingOrderList(String status, String pageNo, String pageSize) {
 171
 172         ServiceResult serviceResult = new ServiceResult();
 173         ResultHeader resultHeader = new ResultHeader();
 174         List<OrderInfo> orderList = new ArrayList<OrderInfo>();
 175         String resultMsg;
 176
 177         try {
 178             // TODO
 179             Response<JSONObject> response = this.aaiSliceService
 180                 .listOrders(NsmfParamConstant.CUSTOM_5G, NsmfParamConstant.SERVICE_TYPE_5G).execute();
 181             if (response.isSuccessful()) {
 182                 logger.info("querySlicingOrderList: listService reponse is:{}", response.body());
 183                 Type type = new TypeToken<List<AAIServiceInstance>>() {
 184                 }.getType();
 185
 186                 JSONArray array = response.body().getJSONArray("service-instance");
 187                 buildOrderList(orderList, array);
 188
 189                 // return normal result code
 190                 resultMsg = "5G slicing order query result.";
 191                 resultHeader.setResult_code(NsmfCodeConstant.SUCCESS_CODE);
 192             } else {
 193                 logger.error(String.format("querySlicingOrderList: Can not get listOrders[code={}, message={}]",
 194                     response.code(),
 195                     response.message()));
 196                 resultMsg = "\"5G slicing order query failed!";
 197                 if (response.code() == NsmfCodeConstant.RESOURCE_NOT_FOUND_CODE) {
 198                     resultHeader.setResult_code(NsmfCodeConstant.SUCCESS_CODE);
 199                 } else {
 200                     resultHeader.setResult_code(NsmfCodeConstant.ERROR_CODE_UNKNOWN);
 201                 }
 202             }
 203         } catch (
 204             Exception e) {
 205             resultMsg = "5G slicing order query failed. Unknown exception occurred!";
 206             resultHeader.setResult_code(NsmfCodeConstant.ERROR_CODE_UNKNOWN);
 207             logger.error(e.getMessage());
 208         }
 209
 210         // Filter by status and paginate
 211         List<Object> filterOrderList = new ArrayList<Object>();
 212         if (!CsmfParamConstant.ALL.equals(status)) {
 213             filterOrderList = orderList.stream().filter(a -> a.getOrder_status().equals(status))
 214                 .collect(Collectors.toList());
 215         } else {
 216             filterOrderList.addAll(orderList);
 217         }
 218         PagedResult pagedOrderList = NsmfCommonUtil
 219             .getPagedList(filterOrderList, Integer.parseInt(pageNo), Integer.parseInt(pageSize));
 220
 221         // return API result for calling [Query Slicing Order List]
 222         OrderList responseOrderList = new OrderList(orderList.size(), pagedOrderList.getPagedList());
 223         addProgressToOrder(responseOrderList);
 224         logger.info(resultMsg);
 225         logger.info("querySlicingOrderList: 5G slicing order query has been finished.");
 226         resultHeader.setResult_message(resultMsg);
 227         serviceResult.setResult_header(resultHeader);
 228         serviceResult.setResult_body(responseOrderList);
 229         return serviceResult;
 230     }
 231
 232     void buildOrderList(List<OrderInfo> orderList, JSONArray array) throws ParseException {
 233         for (int i = 0; i < array.size(); i++) {
 234             JSONObject object = array.getJSONObject(i);
 235             OrderInfo order = new OrderInfo();
 236             order.setOrder_id(object.getString("service-instance-id"));
 237             order.setOrder_name(object.getString("service-instance-name"));
 238             order.setOrder_creation_time(NsmfCommonUtil.timestamp2Time(object.getString("created-at")));
 239             order.setOrder_status(object.getString("service-type"));
 240             order.setService_snssai(object.getString("environment-context"));
 241             order.setOrder_status(object.getString("orchestration-status"));
 242             orderList.add(order);
 243         }
 244     }
 245
 246     public void addProgressToOrder(OrderList responseOrderList)  {
 247         if (responseOrderList.getSlicing_order_list() == null
 248             || responseOrderList.getSlicing_order_list().size() == 0) {
 249             logger.error(
 250                 "addProgressToOrder: responseOrderList.getSlicing_order_list() is null or responseOrderList.getSlicing_order_list() size is 0.");
 251             return;
 252         }
 253
 254         int i = 0;
 255         for (OrderInfo orderInfo : responseOrderList.getSlicing_order_list()) {
 256             i++;
 257             orderInfo.setOrder_index(String.valueOf(i));
 258             String businessId = orderInfo.getOrder_id();
 259             ServiceInstanceOperations serviceInstanceOperations = serviceLcmService
 260                 .getServiceInstanceOperationById(businessId);
 261             if (null == serviceInstanceOperations || serviceInstanceOperations.getOperationId() == null) {
 262                 logger.error(
 263                     "addProgressToOrder: null == serviceInstanceOperations for businessId:{}.",
 264                     businessId);
 265                 continue;
 266             }
 267             String operationId = serviceInstanceOperations.getOperationId();
 268             Response<SOOperation> response = null;
 269             try {
 270                 response = this.soSliceService.queryOperationProgress(businessId, operationId)
 271                     .execute();
 272                 if (response.isSuccessful()) {
 273                     SOOperation soOperation = response.body();
 274                     Gson gson = new Gson();
 275                     logger.info("addProgressToOrder: queryOperationProgress reponse is:{}",
 276                         gson.toJson(soOperation).toString());
 277                     if (soOperation == null || soOperation.getOperation() == null) {
 278                         logger.error("addProgressToOrder: soOperation is null or getOperation() is null for businessId {}!", businessId);
 279                         continue;
 280                     }
 281                     String operationResult = soOperation.getOperation().getResult();
 282                     String operationType = soOperation.getOperation().getOperation();
 283                     int progress = soOperation.getOperation().getProgress();
 284                     logger.info("addProgressToOrder: operationResult is:{}, operationType is {}, progress is {}",
 285                         operationResult, operationType, progress);
 286                     if (operationResult.equals(NsmfCodeConstant.OPERATION_ERROR_STATUS)) {
 287                         logger.error("addProgressToOrder: progress is ok, but operationResult is error for businessId {}!", businessId);
 288                         continue;
 289                     }
 290                     orderInfo.setLast_operation_type(operationType);
 291                     orderInfo.setLast_operation_progress(String.valueOf(progress));
 292                 }
 293             } catch (IOException e) {
 294                 logger.error(e.getMessage());
 295                 logger.error("addProgressToOrder: catch an IOException for businessId {}!", businessId);
 296                 continue;
 297             }
 298         }
 299     }
 300 }