+/**
+ * Copyright (c) 2018 Orange
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
package org.onap.nbi.apis.serviceorder.workflow;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
-import java.util.LinkedHashMap;
import java.util.List;
+import java.util.Map;
import org.onap.nbi.apis.serviceorder.SoClient;
import org.onap.nbi.apis.serviceorder.model.ServiceCharacteristic;
import org.onap.nbi.apis.serviceorder.model.ServiceOrder;
import org.onap.nbi.apis.serviceorder.model.consumer.CloudConfiguration;
import org.onap.nbi.apis.serviceorder.model.consumer.CreateServiceInstanceResponse;
import org.onap.nbi.apis.serviceorder.model.consumer.GetRequestStatusResponse;
+import org.onap.nbi.apis.serviceorder.model.consumer.MSOPayload;
import org.onap.nbi.apis.serviceorder.model.consumer.ModelInfo;
import org.onap.nbi.apis.serviceorder.model.consumer.RequestDetails;
import org.onap.nbi.apis.serviceorder.model.consumer.RequestInfo;
import org.onap.nbi.apis.serviceorder.model.consumer.UserParams;
import org.onap.nbi.apis.serviceorder.model.orchestrator.ExecutionTask;
import org.onap.nbi.apis.serviceorder.model.orchestrator.ServiceOrderInfo;
-import org.onap.nbi.apis.serviceorder.model.orchestrator.ServiceOrderInfoJson;
import org.onap.nbi.apis.serviceorder.repositories.ExecutionTaskRepository;
-import org.onap.nbi.apis.serviceorder.repositories.ServiceOrderRepository;
+import org.onap.nbi.apis.serviceorder.service.ServiceOrderService;
import org.onap.nbi.apis.serviceorder.utils.JsonEntityConverter;
+import org.onap.nbi.exceptions.TechnicalException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
-import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
@Value("${onap.tenantId}")
private String tenantId;
+
@Autowired
- private ServiceOrderRepository serviceOrderRepository;
+ private ServiceOrderService serviceOrderService;
@Autowired
private ExecutionTaskRepository executionTaskRepository;
/**
* Run the ServiceOrchestrator processing for a serviceOrderItem which with any sub relations
+ *
+ * @throws InterruptedException
*/
- public void processOrderItem(ExecutionTask executionTask) {
+ public void processOrderItem(ExecutionTask executionTask) throws InterruptedException {
+ ServiceOrderInfo serviceOrderInfo = getServiceOrderInfo(executionTask);
- ServiceOrderInfoJson serviceOrderInfoJson = executionTask.getServiceOrderInfoJson();
- ServiceOrder serviceOrder = serviceOrderRepository.findOne(serviceOrderInfoJson.getServiceOrderId());
- ServiceOrderItem serviceOrderItem = null;
- for (ServiceOrderItem item : serviceOrder.getOrderItem()) {
- if (item.getId().equals(executionTask.getOrderItemId())) {
- serviceOrderItem = item;
- }
- }
-
- ServiceOrderInfo serviceOrderInfo = null;
- try {
- serviceOrderInfo =
- JsonEntityConverter.convertJsonToServiceOrderInfo(serviceOrderInfoJson.getServiceOrderInfoJson());
- } catch (IOException e) {
- LOGGER.error("Unable to read ServiceOrderInfo Json for serviceOrderId " + serviceOrder.getId() + ", "
- + e.getMessage());
- }
+ ServiceOrder serviceOrder = serviceOrderService.findServiceOrderById(serviceOrderInfo.getServiceOrderId());
+ ServiceOrderItem serviceOrderItem = getServiceOrderItem(executionTask, serviceOrder);
if (StateType.ACKNOWLEDGED == serviceOrderItem.getState()) {
- ResponseEntity<CreateServiceInstanceResponse> response = postSORequest(serviceOrderItem, serviceOrderInfo);
-
- updateServiceOrderItem(response.getBody(), serviceOrderItem);
-
- if (response.getStatusCode() != HttpStatus.CREATED || response.getBody() == null
- || response.getBody().getRequestReference() == null) {
- serviceOrderItem.setState(StateType.FAILED);
- } else {
- serviceOrderItem.setState(StateType.INPROGRESS);
- }
+ ResponseEntity<CreateServiceInstanceResponse> response = postServiceOrderItem(serviceOrderInfo,
+ serviceOrderItem);
+ updateServiceOrderItem(response, serviceOrderItem,serviceOrder);
}
- if (executionTask.getNbRetries() > 0) {
+ if (executionTask.getNbRetries() > 0 && StateType.FAILED != serviceOrderItem.getState()
+ ) {
// TODO lancer en asynchrone
- pollSoRequestStatus(serviceOrderItem);
+ pollSoRequestStatus(serviceOrder,serviceOrderItem);
if (serviceOrderItem.getState().equals(StateType.COMPLETED)) {
updateSuccessTask(executionTask);
} else {
updateFailedTask(executionTask, serviceOrder);
}
-
updateServiceOrder(serviceOrder);
}
+ private ResponseEntity<CreateServiceInstanceResponse> postServiceOrderItem(ServiceOrderInfo serviceOrderInfo,
+ ServiceOrderItem serviceOrderItem) {
+ ResponseEntity<CreateServiceInstanceResponse> response = null;
+ try {
+ response = postSORequest(serviceOrderItem, serviceOrderInfo);
+ } catch (NullPointerException e) {
+ LOGGER.error("Unable to create service instance for serviceOrderItem.id=" + serviceOrderItem.getId(), e);
+ response = null;
+ }
+ return response;
+ }
+
+ private ServiceOrderItem getServiceOrderItem(ExecutionTask executionTask, ServiceOrder serviceOrder) {
+ for (ServiceOrderItem item : serviceOrder.getOrderItem()) {
+ if (item.getId().equals(executionTask.getOrderItemId())) {
+ return item;
+ }
+ }
+ throw new TechnicalException(
+ "Unable to retrieve serviceOrderItem forexecutionTaskId " + executionTask.getInternalId());
+ }
+
+ private ServiceOrderInfo getServiceOrderInfo(ExecutionTask executionTask) {
+ String serviceOrderInfoJson = executionTask.getServiceOrderInfoJson();
+ ServiceOrderInfo serviceOrderInfo = null;
+ try {
+ serviceOrderInfo =
+ JsonEntityConverter.convertJsonToServiceOrderInfo(serviceOrderInfoJson);
+ } catch (IOException e) {
+ LOGGER
+ .error("Unable to read ServiceOrderInfo Json for executionTaskId " + executionTask.getInternalId(), e);
+ throw new TechnicalException(
+ "Unable to read ServiceOrderInfo Json for executionTaskId " + executionTask.getInternalId());
+ }
+ return serviceOrderInfo;
+ }
+
private ResponseEntity<CreateServiceInstanceResponse> postSORequest(ServiceOrderItem serviceOrderItem,
- ServiceOrderInfo serviceOrderInfo) {
+ ServiceOrderInfo serviceOrderInfo) {
RequestDetails requestDetails = buildSoRequest(serviceOrderItem,
- serviceOrderInfo.getServiceOrderItemInfos().get(serviceOrderItem.getId()).getCatalogResponse(),
- serviceOrderInfo.getSubscriberInfo());
+ serviceOrderInfo.getServiceOrderItemInfos().get(serviceOrderItem.getId()).getCatalogResponse(),
+ serviceOrderInfo.getSubscriberInfo());
+ MSOPayload msoPayload = new MSOPayload(requestDetails);
ResponseEntity<CreateServiceInstanceResponse> response = null;
switch (serviceOrderItem.getAction()) {
case ADD:
- response = soClient.callCreateServiceInstance(requestDetails);
+ response = soClient.callCreateServiceInstance(msoPayload);
break;
case DELETE:
- response = soClient.callDeleteServiceInstance(requestDetails, serviceOrderItem.getService().getId());
+ response = soClient.callDeleteServiceInstance(msoPayload, serviceOrderItem.getService().getId());
break;
default:
break;
boolean atLeastOneNotFinished = false;
boolean atLeastOneFailed = false;
-
for (ServiceOrderItem serviceOrderItem : serviceOrder.getOrderItem()) {
switch (serviceOrderItem.getState()) {
case COMPLETED:
}
if (atLeastOneNotFinished) {
- serviceOrder.setState(StateType.INPROGRESS);
+ serviceOrderService.updateOrderState(serviceOrder,StateType.INPROGRESS);
} else {
- serviceOrder.setCompletionDateTime(new Date());
+ StateType finalState;
if (atLeastOneFailed) {
if (!atLeastOneCompleted) {
- serviceOrder.setState(StateType.FAILED);
+ finalState=StateType.FAILED;
} else {
- serviceOrder.setState(StateType.PARTIAL);
+ finalState=StateType.PARTIAL;
}
} else {
- serviceOrder.setState(StateType.COMPLETED);
+ finalState=StateType.COMPLETED;
}
+ serviceOrderService.updateOrderFinalState(serviceOrder,finalState);
}
- serviceOrderRepository.save(serviceOrder);
}
/**
* * @param orderItem
*/
- private void pollSoRequestStatus(ServiceOrderItem orderItem) {
+ private void pollSoRequestStatus(ServiceOrder serviceOrder,
+ ServiceOrderItem orderItem) throws InterruptedException {
boolean stopPolling = false;
String requestId = orderItem.getRequestId();
GetRequestStatusResponse response = null;
if (response != null) {
if (response.getRequest().getRequestStatus().getPercentProgress() != 100) {
nbRetries++;
- orderItem.setState(StateType.INPROGRESS);
- try {
- Thread.sleep(1000);
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
+ serviceOrderService.updateOrderItemState(serviceOrder,orderItem,StateType.INPROGRESS);
+ Thread.sleep(1000);
+ LOGGER.debug("orderitem id {} still in progress from so",orderItem.getId());
} else if (RequestState.COMPLETE != response.getRequest().getRequestStatus().getRequestState()) {
- orderItem.setState(StateType.FAILED);
+ serviceOrderService.updateOrderItemState(serviceOrder,orderItem,StateType.FAILED);
stopPolling = true;
+ LOGGER.debug("orderitem id {} failed, response from request status {}",orderItem.getId(),response.getRequest().getRequestStatus().getRequestState());
} else {
- orderItem.setState(StateType.COMPLETED);
+ serviceOrderService.updateOrderItemState(serviceOrder,orderItem,StateType.COMPLETED);
stopPolling = true;
+ LOGGER.debug("orderitem id {} completed");
}
} else {
- orderItem.setState(StateType.INPROGRESS);
+ serviceOrderService.updateOrderItemState(serviceOrder,orderItem,StateType.INPROGRESS);
stopPolling = true;
+ LOGGER.debug("orderitem id {} still in progress from so",orderItem.getId());
}
if (nbRetries == 3) {
stopPolling = true;
+ LOGGER.debug("orderitem id {} stop polling from getrequeststatus, 3 retries done",orderItem.getId());
+
}
}
}
* @param subscriberInfo
* @return
*/
- private RequestDetails buildSoRequest(ServiceOrderItem orderItem, LinkedHashMap<String, Object> sdcInfos,
- SubscriberInfo subscriberInfo) {
+ private RequestDetails buildSoRequest(ServiceOrderItem orderItem, Map<String, Object> sdcInfos,
+ SubscriberInfo subscriberInfo) {
RequestDetails requestDetails = new RequestDetails();
requestDetails.setSubscriberInfo(subscriberInfo);
modelInfo.setModelType("service");
modelInfo.setModelInvariantId((String) sdcInfos.get("invariantUUID"));
modelInfo.setModelNameVersionId(orderItem.getService().getServiceSpecification().getId());
+ modelInfo.setModelVersionId(orderItem.getService().getServiceSpecification().getId());
modelInfo.setModelName((String) sdcInfos.get("name"));
modelInfo.setModelVersion((String) sdcInfos.get("version"));
requestDetails.setModelInfo(modelInfo);
requestInfo.setInstanceName(orderItem.getService().getName());
requestInfo.setSource("VID");
requestInfo.setSuppressRollback(false);
+ requestInfo.setRequestorId("NBI");
requestDetails.setRequestInfo(requestInfo);
RequestParameters requestParameters = new RequestParameters();
requestParameters.setSubscriptionServiceType((String) sdcInfos.get("name"));
requestParameters.setUserParams(
- retrieveUserParamsFromServiceCharacteristics(orderItem.getService().getServiceCharacteristic()));
+ retrieveUserParamsFromServiceCharacteristics(orderItem.getService().getServiceCharacteristic()));
requestParameters.setaLaCarte(true);
requestDetails.setRequestParameters(requestParameters);
}
/**
- * Build a list of UserParams for the SO request by browsing a list of ServiceCharacteristics
- * from SDC
- *
- * @param characteristics
- * @return
+ * Build a list of UserParams for the SO request by browsing a list of ServiceCharacteristics from SDC
*/
private List<UserParams> retrieveUserParamsFromServiceCharacteristics(List<ServiceCharacteristic> characteristics) {
- List<UserParams> userParams = new ArrayList<UserParams>();
+ List<UserParams> userParams = new ArrayList<>();
if (!CollectionUtils.isEmpty(characteristics)) {
for (ServiceCharacteristic characteristic : characteristics) {
UserParams userParam = new UserParams(characteristic.getName(),
- characteristic.getValue().getServiceCharacteristicValue());
+ characteristic.getValue().getServiceCharacteristicValue());
userParams.add(userParam);
}
}
/**
- * Update ServiceOrderItem with SO response by using serviceOrderRepository with the
- * serviceOrderId
- *
- * @param createServiceInstanceResponse
+ * Update ServiceOrderItem with SO response by using serviceOrderRepository with the serviceOrderId
+ * @param response
* @param orderItem
+ * @param serviceOrder
*/
- private void updateServiceOrderItem(CreateServiceInstanceResponse createServiceInstanceResponse,
- ServiceOrderItem orderItem) {
+ private void updateServiceOrderItem(ResponseEntity<CreateServiceInstanceResponse> response,
+ ServiceOrderItem orderItem, ServiceOrder serviceOrder) {
+
+ if (response == null) {
+ LOGGER.warn("response=null for serviceOrderItem.id=" + orderItem.getId());
+ serviceOrderService.updateOrderItemState(serviceOrder,orderItem,StateType.FAILED);
+ }
+ else {
+ CreateServiceInstanceResponse createServiceInstanceResponse = response.getBody();
+ if (createServiceInstanceResponse != null && !orderItem.getState().equals(StateType.FAILED)) {
+ orderItem.getService().setId(createServiceInstanceResponse.getRequestReferences().getInstanceId());
+ orderItem.setRequestId(createServiceInstanceResponse.getRequestReferences().getRequestId());
+ }
- if (createServiceInstanceResponse != null && !orderItem.getState().equals(StateType.FAILED)) {
- orderItem.getService().setId(createServiceInstanceResponse.getRequestReference().getInstanceId());
- orderItem.setRequestId(createServiceInstanceResponse.getRequestReference().getRequestId());
+ if (!response.getStatusCode().is2xxSuccessful() || response.getBody() == null
+ || response.getBody().getRequestReferences() == null) {
+ serviceOrderService.updateOrderItemState(serviceOrder,orderItem,StateType.FAILED);
+ LOGGER.warn("order item {} failed , status {} , response {}",orderItem.getId(),response.getStatusCode(),response.getBody());
+ } else {
+ serviceOrderService.updateOrderItemState(serviceOrder,orderItem,StateType.INPROGRESS);
+ }
}
}
private void updateSuccessTask(ExecutionTask executionTask) {
executionTaskRepository.delete(executionTask.getInternalId());
executionTaskRepository.updateReliedTaskAfterDelete(executionTask.getInternalId());
+
}
/**
List<ExecutionTask> executionTasksToDelete = findExecutionTasksRecursively(executionTask);
for (ExecutionTask taskId : executionTasksToDelete) {
executionTaskRepository.delete(taskId);
+ LOGGER.warn("task {} with orderitem id {} deleted cause orderitem id {} failed ",taskId.getInternalId(),taskId.getOrderItemId(),executionTask.getOrderItemId());
}
-
for (ServiceOrderItem item : serviceOrder.getOrderItem()) {
for (ExecutionTask taskToDelete : executionTasksToDelete) {
if (taskToDelete.getOrderItemId().equals(item.getId())) {
- item.setState(StateType.FAILED);
+ serviceOrderService.updateOrderItemState(serviceOrder,item,StateType.FAILED);
+ LOGGER.warn("task {} with orderitem id {} to failed cause orderitem id {} failed ",taskToDelete.getInternalId(),taskToDelete.getOrderItemId(),executionTask.getOrderItemId());
+
}
}
}
List<ExecutionTask> executionTasks = new ArrayList<>();
List<ExecutionTask> tasksReliedToAnOrderItemId =
- executionTaskRepository.findTasksReliedToAnOrderItemId(executionTask.getInternalId());
+ executionTaskRepository.findTasksReliedToAnOrderItemId(executionTask.getInternalId());
if (CollectionUtils.isEmpty(tasksReliedToAnOrderItemId)) {
return Arrays.asList(executionTask);