gerrit.onap Code Review - so.git/blob

   1 package org.onap.so.bpmn.infrastructure.adapter.network.tasks;
   2
   3 import java.io.StringReader;
   4 import java.util.Optional;
   5
   6 import javax.ws.rs.core.Response;
   7 import javax.xml.bind.JAXBContext;
   8 import javax.xml.bind.JAXBException;
   9 import javax.xml.bind.Unmarshaller;
  10
  11 import org.camunda.bpm.engine.delegate.DelegateExecution;
  12 import org.onap.so.adapters.nwrest.CreateNetworkError;
  13 import org.onap.so.adapters.nwrest.CreateNetworkRequest;
  14 import org.onap.so.adapters.nwrest.CreateNetworkResponse;
  15 import org.onap.so.adapters.nwrest.DeleteNetworkError;
  16 import org.onap.so.adapters.nwrest.DeleteNetworkRequest;
  17 import org.onap.so.adapters.nwrest.DeleteNetworkResponse;
  18 import org.onap.so.client.exception.ExceptionBuilder;
  19 import org.onap.so.client.orchestration.NetworkAdapterResources;
  20 import org.slf4j.Logger;
  21 import org.slf4j.LoggerFactory;
  22 import org.springframework.beans.factory.annotation.Autowired;
  23 import org.springframework.stereotype.Component;
  24
  25 @Component
  26 public class NetworkAdapterRestV1 {
  27
  28         private static final Logger logger = LoggerFactory.getLogger(NetworkAdapterRestV1.class);
  29
  30         private static final String NETWORK_REQUEST = "networkAdapterRequest";
  31         private static final String NETWORK_MESSAGE = "NetworkAResponse_MESSAGE";
  32         private static final String NETWORK_SYNC_CODE = "NETWORKREST_networkAdapterStatusCode";
  33         private static final String NETWORK_SYNC_RESPONSE = "NETWORKREST_networkAdapterResponse";
  34         private static final String NETWORK_CORRELATOR = "NetworkAResponse_CORRELATOR";
  35
  36         @Autowired
  37         private ExceptionBuilder exceptionBuilder;
  38
  39         @Autowired
  40         private NetworkAdapterResources networkAdapterResources;
  41
  42         public void callNetworkAdapter (DelegateExecution execution) {
  43                 try {
  44                         Object networkAdapterRequest = execution.getVariable(NETWORK_REQUEST);
  45                         if (networkAdapterRequest != null) {
  46                                 Optional<Response> response = Optional.empty();
  47                                 if (networkAdapterRequest instanceof CreateNetworkRequest) {
  48                                         CreateNetworkRequest createNetworkRequest = (CreateNetworkRequest) networkAdapterRequest;
  49                                         execution.setVariable(NETWORK_CORRELATOR, createNetworkRequest.getMessageId());
  50                                         response = networkAdapterResources.createNetworkAsync(createNetworkRequest);
  51                                 } else if (networkAdapterRequest instanceof DeleteNetworkRequest) {
  52                                         DeleteNetworkRequest deleteNetworkRequest = (DeleteNetworkRequest) networkAdapterRequest;
  53                                         execution.setVariable(NETWORK_CORRELATOR, deleteNetworkRequest.getMessageId());
  54                                         response = networkAdapterResources.deleteNetworkAsync(deleteNetworkRequest);
  55                                 }
  56                                 if(response.isPresent()) {
  57                                         String statusCode = Integer.toString(response.get().getStatus());
  58                                         String responseString = "";
  59                                         if(response.get().getEntity() != null) {
  60                                                 responseString = (String) response.get().getEntity();
  61                                         }
  62                                         execution.setVariable(NETWORK_SYNC_CODE, statusCode);
  63                                         execution.setVariable(NETWORK_SYNC_RESPONSE, responseString);
  64                                 } else {
  65                                         throw new Exception("No Ack response from Openstack Adapter");
  66                                 }
  67                         } else {
  68                                 throw new Exception("No Network Request was created. networkAdapterRequest was null.");
  69                         }
  70                 } catch (Exception ex) {
  71                         exceptionBuilder.buildAndThrowWorkflowException(execution, 7000, ex);
  72                 }
  73         }
  74
  75         public void processCallback (DelegateExecution execution) {
  76                 try {
  77                         Object networkAdapterRequest = execution.getVariable(NETWORK_REQUEST);
  78                         String callback = (String) execution.getVariable(NETWORK_MESSAGE);
  79                         String logCallbackMessage = "Callback from OpenstackAdapter: " + callback;
  80                         logger.debug(logCallbackMessage);
  81                         if (networkAdapterRequest != null) {
  82                                 if (networkAdapterRequest instanceof CreateNetworkRequest) {
  83                                         if(callback.contains("createNetworkError")) {
  84                                                 CreateNetworkError createNetworkError = (CreateNetworkError) unmarshalXml(callback, CreateNetworkError.class);
  85                                                 throw new Exception(createNetworkError.getMessage());
  86                                         } else {
  87                                                 CreateNetworkResponse createNetworkResponse = (CreateNetworkResponse) unmarshalXml(callback, CreateNetworkResponse.class);
  88                                                 execution.setVariable("createNetworkResponse", createNetworkResponse);
  89                                         }
  90                                 } else if (networkAdapterRequest instanceof DeleteNetworkRequest) {
  91                                         if(callback.contains("deleteNetworkError")) {
  92                                                 DeleteNetworkError deleteNetworkError = (DeleteNetworkError) unmarshalXml(callback, DeleteNetworkError.class);
  93                                                 throw new Exception(deleteNetworkError.getMessage());
  94                                         } else {
  95                                                 DeleteNetworkResponse deleteNetworkResponse = (DeleteNetworkResponse) unmarshalXml(callback, DeleteNetworkResponse.class);
  96                                                 execution.setVariable("deleteNetworkResponse", deleteNetworkResponse);
  97                                         }
  98                                 }
  99                         }
 100                 } catch (Exception e) {
 101                         logger.error("Error in Openstack Adapter callback", e);
 102                         exceptionBuilder.buildAndThrowWorkflowException(execution, 7000, e.getMessage());
 103                 }
 104         }
 105
 106         protected <T> Object unmarshalXml(String xmlString, Class<T> resultClass) throws JAXBException {
 107                 StringReader reader = new StringReader(xmlString);
 108                 JAXBContext context = JAXBContext.newInstance(resultClass);
 109                 Unmarshaller unmarshaller = context.createUnmarshaller();
 110                 return unmarshaller.unmarshal(reader);
 111         }
 112
 113         public void handleTimeOutException (DelegateExecution execution) {
 114                 exceptionBuilder.buildAndThrowWorkflowException(execution, 7000, "Error timed out waiting on Openstack Async-Response");
 115         }
 116
 117         public void handleSyncError (DelegateExecution execution) {
 118                 String statusCode = (String) execution.getVariable(NETWORK_SYNC_CODE);
 119                 String responseString = (String) execution.getVariable(NETWORK_SYNC_RESPONSE);
 120                 String errorMessage = "Error with Openstack Adapter Sync Request: StatusCode = " + statusCode + " Response = " + responseString;
 121                 exceptionBuilder.buildAndThrowWorkflowException(execution, 7000, errorMessage);
 122         }
 123 }