2 * Copyright (c) 2018 Orange
4 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
5 * the License. You may obtain a copy of the License at
7 * http://www.apache.org/licenses/LICENSE-2.0
9 * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
10 * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
11 * specific language governing permissions and limitations under the License.
13 package org.onap.nbi.apis.serviceorder.workflow;
15 import java.io.IOException;
16 import java.util.ArrayList;
17 import java.util.Arrays;
18 import java.util.Date;
19 import java.util.List;
21 import org.onap.nbi.apis.serviceorder.SoClient;
22 import org.onap.nbi.apis.serviceorder.model.ServiceCharacteristic;
23 import org.onap.nbi.apis.serviceorder.model.ServiceOrder;
24 import org.onap.nbi.apis.serviceorder.model.ServiceOrderItem;
25 import org.onap.nbi.apis.serviceorder.model.StateType;
26 import org.onap.nbi.apis.serviceorder.model.consumer.CloudConfiguration;
27 import org.onap.nbi.apis.serviceorder.model.consumer.CreateServiceInstanceResponse;
28 import org.onap.nbi.apis.serviceorder.model.consumer.GetRequestStatusResponse;
29 import org.onap.nbi.apis.serviceorder.model.consumer.MSOPayload;
30 import org.onap.nbi.apis.serviceorder.model.consumer.ModelInfo;
31 import org.onap.nbi.apis.serviceorder.model.consumer.RequestDetails;
32 import org.onap.nbi.apis.serviceorder.model.consumer.RequestInfo;
33 import org.onap.nbi.apis.serviceorder.model.consumer.RequestParameters;
34 import org.onap.nbi.apis.serviceorder.model.consumer.RequestState;
35 import org.onap.nbi.apis.serviceorder.model.consumer.SubscriberInfo;
36 import org.onap.nbi.apis.serviceorder.model.consumer.UserParams;
37 import org.onap.nbi.apis.serviceorder.model.orchestrator.ExecutionTask;
38 import org.onap.nbi.apis.serviceorder.model.orchestrator.ServiceOrderInfo;
39 import org.onap.nbi.apis.serviceorder.repositories.ExecutionTaskRepository;
40 import org.onap.nbi.apis.serviceorder.service.ServiceOrderService;
41 import org.onap.nbi.apis.serviceorder.utils.JsonEntityConverter;
42 import org.onap.nbi.exceptions.TechnicalException;
43 import org.slf4j.Logger;
44 import org.slf4j.LoggerFactory;
45 import org.springframework.beans.factory.annotation.Autowired;
46 import org.springframework.beans.factory.annotation.Value;
47 import org.springframework.http.ResponseEntity;
48 import org.springframework.stereotype.Service;
49 import org.springframework.util.CollectionUtils;
52 public class SOTaskProcessor {
54 @Value("${nbi.callForVNF}")
55 private boolean enableCallForVNF;
57 @Value("${onap.lcpCloudRegionId}")
58 private String lcpCloudRegionId;
60 @Value("${onap.tenantId}")
61 private String tenantId;
65 private ServiceOrderService serviceOrderService;
68 private ExecutionTaskRepository executionTaskRepository;
71 private SoClient soClient;
74 private static final Logger LOGGER = LoggerFactory.getLogger(SOTaskProcessor.class);
77 * Run the ServiceOrchestrator processing for a serviceOrderItem which with any sub relations
79 * @throws InterruptedException
81 public void processOrderItem(ExecutionTask executionTask) throws InterruptedException {
83 ServiceOrderInfo serviceOrderInfo = getServiceOrderInfo(executionTask);
85 ServiceOrder serviceOrder = serviceOrderService.findServiceOrderById(serviceOrderInfo.getServiceOrderId());
86 ServiceOrderItem serviceOrderItem = getServiceOrderItem(executionTask, serviceOrder);
88 if (StateType.ACKNOWLEDGED == serviceOrderItem.getState()) {
90 ResponseEntity<CreateServiceInstanceResponse> response = postServiceOrderItem(serviceOrderInfo,
92 updateServiceOrderItem(response, serviceOrderItem,serviceOrder);
95 if (executionTask.getNbRetries() > 0 && StateType.FAILED != serviceOrderItem.getState()
97 // TODO lancer en asynchrone
98 pollSoRequestStatus(serviceOrder,serviceOrderItem);
99 if (serviceOrderItem.getState().equals(StateType.COMPLETED)) {
100 updateSuccessTask(executionTask);
102 int nbRetries = executionTask.getNbRetries();
103 executionTask.setNbRetries(--nbRetries);
104 executionTask.setLastAttemptDate(new Date());
105 executionTaskRepository.save(executionTask);
108 updateFailedTask(executionTask, serviceOrder);
111 updateServiceOrder(serviceOrder);
114 private ResponseEntity<CreateServiceInstanceResponse> postServiceOrderItem(ServiceOrderInfo serviceOrderInfo,
115 ServiceOrderItem serviceOrderItem) {
116 ResponseEntity<CreateServiceInstanceResponse> response = null;
118 response = postSORequest(serviceOrderItem, serviceOrderInfo);
119 } catch (NullPointerException e) {
120 LOGGER.error("Unable to create service instance for serviceOrderItem.id=" + serviceOrderItem.getId(), e);
126 private ServiceOrderItem getServiceOrderItem(ExecutionTask executionTask, ServiceOrder serviceOrder) {
127 for (ServiceOrderItem item : serviceOrder.getOrderItem()) {
128 if (item.getId().equals(executionTask.getOrderItemId())) {
132 throw new TechnicalException(
133 "Unable to retrieve serviceOrderItem forexecutionTaskId " + executionTask.getInternalId());
136 private ServiceOrderInfo getServiceOrderInfo(ExecutionTask executionTask) {
137 String serviceOrderInfoJson = executionTask.getServiceOrderInfoJson();
138 ServiceOrderInfo serviceOrderInfo = null;
141 JsonEntityConverter.convertJsonToServiceOrderInfo(serviceOrderInfoJson);
142 } catch (IOException e) {
144 .error("Unable to read ServiceOrderInfo Json for executionTaskId " + executionTask.getInternalId(), e);
145 throw new TechnicalException(
146 "Unable to read ServiceOrderInfo Json for executionTaskId " + executionTask.getInternalId());
148 return serviceOrderInfo;
151 private ResponseEntity<CreateServiceInstanceResponse> postSORequest(ServiceOrderItem serviceOrderItem,
152 ServiceOrderInfo serviceOrderInfo) {
153 RequestDetails requestDetails = buildSoRequest(serviceOrderItem,
154 serviceOrderInfo.getServiceOrderItemInfos().get(serviceOrderItem.getId()).getCatalogResponse(),
155 serviceOrderInfo.getSubscriberInfo());
156 MSOPayload msoPayload = new MSOPayload(requestDetails);
157 ResponseEntity<CreateServiceInstanceResponse> response = null;
159 switch (serviceOrderItem.getAction()) {
161 response = soClient.callCreateServiceInstance(msoPayload);
164 response = soClient.callDeleteServiceInstance(msoPayload, serviceOrderItem.getService().getId());
172 private void updateServiceOrder(ServiceOrder serviceOrder) {
173 boolean atLeastOneCompleted = false;
174 boolean atLeastOneNotFinished = false;
175 boolean atLeastOneFailed = false;
177 for (ServiceOrderItem serviceOrderItem : serviceOrder.getOrderItem()) {
178 switch (serviceOrderItem.getState()) {
180 atLeastOneCompleted = true;
184 atLeastOneNotFinished = true;
187 atLeastOneFailed = true;
195 if (atLeastOneNotFinished) {
196 serviceOrderService.updateOrderState(serviceOrder,StateType.INPROGRESS);
198 StateType finalState;
199 if (atLeastOneFailed) {
200 if (!atLeastOneCompleted) {
201 finalState=StateType.FAILED;
203 finalState=StateType.PARTIAL;
206 finalState=StateType.COMPLETED;
208 serviceOrderService.updateOrderFinalState(serviceOrder,finalState);
216 private void pollSoRequestStatus(ServiceOrder serviceOrder,
217 ServiceOrderItem orderItem) throws InterruptedException {
218 boolean stopPolling = false;
219 String requestId = orderItem.getRequestId();
220 GetRequestStatusResponse response = null;
223 while (!stopPolling) {
224 response = soClient.callGetRequestStatus(requestId);
225 if (response != null) {
226 if (response.getRequest().getRequestStatus().getPercentProgress() != 100) {
228 serviceOrderService.updateOrderItemState(serviceOrder,orderItem,StateType.INPROGRESS);
230 LOGGER.debug("orderitem id {} still in progress from so",orderItem.getId());
231 } else if (RequestState.COMPLETE != response.getRequest().getRequestStatus().getRequestState()) {
232 serviceOrderService.updateOrderItemState(serviceOrder,orderItem,StateType.FAILED);
234 LOGGER.debug("orderitem id {} failed, response from request status {}",orderItem.getId(),response.getRequest().getRequestStatus().getRequestState());
236 serviceOrderService.updateOrderItemState(serviceOrder,orderItem,StateType.COMPLETED);
238 LOGGER.debug("orderitem id {} completed");
241 serviceOrderService.updateOrderItemState(serviceOrder,orderItem,StateType.INPROGRESS);
243 LOGGER.debug("orderitem id {} still in progress from so",orderItem.getId());
245 if (nbRetries == 3) {
247 LOGGER.debug("orderitem id {} stop polling from getrequeststatus, 3 retries done",orderItem.getId());
254 * Build SO CREATE request from the ServiceOrder and catalog informations from SDC
258 * @param subscriberInfo
261 private RequestDetails buildSoRequest(ServiceOrderItem orderItem, Map<String, Object> sdcInfos,
262 SubscriberInfo subscriberInfo) {
263 RequestDetails requestDetails = new RequestDetails();
265 requestDetails.setSubscriberInfo(subscriberInfo);
267 ModelInfo modelInfo = new ModelInfo();
268 modelInfo.setModelType("service");
269 modelInfo.setModelInvariantId((String) sdcInfos.get("invariantUUID"));
270 modelInfo.setModelNameVersionId(orderItem.getService().getServiceSpecification().getId());
271 modelInfo.setModelVersionId(orderItem.getService().getServiceSpecification().getId());
272 modelInfo.setModelName((String) sdcInfos.get("name"));
273 modelInfo.setModelVersion((String) sdcInfos.get("version"));
274 requestDetails.setModelInfo(modelInfo);
276 RequestInfo requestInfo = new RequestInfo();
277 requestInfo.setInstanceName(orderItem.getService().getName());
278 requestInfo.setSource("VID");
279 requestInfo.setSuppressRollback(false);
280 requestInfo.setRequestorId("NBI");
281 requestDetails.setRequestInfo(requestInfo);
283 RequestParameters requestParameters = new RequestParameters();
284 requestParameters.setSubscriptionServiceType((String) sdcInfos.get("name"));
285 requestParameters.setUserParams(
286 retrieveUserParamsFromServiceCharacteristics(orderItem.getService().getServiceCharacteristic()));
287 requestParameters.setaLaCarte(true);
288 requestDetails.setRequestParameters(requestParameters);
290 CloudConfiguration cloudConfiguration = new CloudConfiguration(lcpCloudRegionId, tenantId);
291 requestDetails.setCloudConfiguration(cloudConfiguration);
292 return requestDetails;
296 * Build a list of UserParams for the SO request by browsing a list of ServiceCharacteristics from SDC
298 private List<UserParams> retrieveUserParamsFromServiceCharacteristics(List<ServiceCharacteristic> characteristics) {
299 List<UserParams> userParams = new ArrayList<UserParams>();
301 if (!CollectionUtils.isEmpty(characteristics)) {
302 for (ServiceCharacteristic characteristic : characteristics) {
303 UserParams userParam = new UserParams(characteristic.getName(),
304 characteristic.getValue().getServiceCharacteristicValue());
305 userParams.add(userParam);
314 * Update ServiceOrderItem with SO response by using serviceOrderRepository with the serviceOrderId
317 * @param serviceOrder
319 private void updateServiceOrderItem(ResponseEntity<CreateServiceInstanceResponse> response,
320 ServiceOrderItem orderItem, ServiceOrder serviceOrder) {
322 if (response == null) {
323 LOGGER.warn("response=null for serviceOrderItem.id=" + orderItem.getId());
324 serviceOrderService.updateOrderItemState(serviceOrder,orderItem,StateType.FAILED);
327 CreateServiceInstanceResponse createServiceInstanceResponse = response.getBody();
328 if (createServiceInstanceResponse != null && !orderItem.getState().equals(StateType.FAILED)) {
329 orderItem.getService().setId(createServiceInstanceResponse.getRequestReferences().getInstanceId());
330 orderItem.setRequestId(createServiceInstanceResponse.getRequestReferences().getRequestId());
333 if (!response.getStatusCode().is2xxSuccessful() || response.getBody() == null
334 || response.getBody().getRequestReferences() == null) {
335 serviceOrderService.updateOrderItemState(serviceOrder,orderItem,StateType.FAILED);
336 LOGGER.warn("order item {} failed , status {} , response {}",orderItem.getId(),response.getStatusCode(),response.getBody());
338 serviceOrderService.updateOrderItemState(serviceOrder,orderItem,StateType.INPROGRESS);
344 * Update an executionTask in database when it's process with a success
346 * @param executionTask
348 private void updateSuccessTask(ExecutionTask executionTask) {
349 executionTaskRepository.delete(executionTask.getInternalId());
350 executionTaskRepository.updateReliedTaskAfterDelete(executionTask.getInternalId());
355 * @param executionTask
356 * @param serviceOrder
358 private void updateFailedTask(ExecutionTask executionTask, ServiceOrder serviceOrder) {
359 List<ExecutionTask> executionTasksToDelete = findExecutionTasksRecursively(executionTask);
360 for (ExecutionTask taskId : executionTasksToDelete) {
361 executionTaskRepository.delete(taskId);
362 LOGGER.warn("task {} with orderitem id {} deleted cause orderitem id {} failed ",taskId.getInternalId(),taskId.getOrderItemId(),executionTask.getOrderItemId());
364 for (ServiceOrderItem item : serviceOrder.getOrderItem()) {
365 for (ExecutionTask taskToDelete : executionTasksToDelete) {
366 if (taskToDelete.getOrderItemId().equals(item.getId())) {
367 serviceOrderService.updateOrderItemState(serviceOrder,item,StateType.FAILED);
368 LOGGER.warn("task {} with orderitem id {} to failed cause orderitem id {} failed ",taskToDelete.getInternalId(),taskToDelete.getOrderItemId(),executionTask.getOrderItemId());
376 * @param executionTask
379 private List<ExecutionTask> findExecutionTasksRecursively(ExecutionTask executionTask) {
381 List<ExecutionTask> executionTasks = new ArrayList<>();
383 List<ExecutionTask> tasksReliedToAnOrderItemId =
384 executionTaskRepository.findTasksReliedToAnOrderItemId(executionTask.getInternalId());
386 if (CollectionUtils.isEmpty(tasksReliedToAnOrderItemId)) {
387 return Arrays.asList(executionTask);
389 for (ExecutionTask task : tasksReliedToAnOrderItemId) {
390 executionTasks.addAll(findExecutionTasksRecursively(task));
393 executionTasks.add(executionTask);
394 return executionTasks;