gerrit.onap Code Review - so.git/blob

   1 package org.onap.so.apihandlerinfra;
   2
   3 import java.security.GeneralSecurityException;
   4 import java.util.ArrayList;
   5 import java.util.Collections;
   6 import java.util.HashMap;
   7 import java.util.List;
   8 import java.util.Map;
   9 import javax.xml.bind.DatatypeConverter;
  10 import org.camunda.bpm.engine.impl.persistence.entity.HistoricActivityInstanceEntity;
  11 import org.camunda.bpm.engine.impl.persistence.entity.HistoricProcessInstanceEntity;
  12 import org.onap.logging.filter.spring.SpringClientPayloadFilter;
  13 import org.onap.so.logging.jaxrs.filter.SOSpringClientFilter;
  14 import org.onap.so.utils.CryptoUtils;
  15 import org.slf4j.Logger;
  16 import org.slf4j.LoggerFactory;
  17 import org.springframework.beans.factory.annotation.Autowired;
  18 import org.springframework.core.ParameterizedTypeReference;
  19 import org.springframework.core.env.Environment;
  20 import org.springframework.http.HttpEntity;
  21 import org.springframework.http.HttpHeaders;
  22 import org.springframework.http.HttpMethod;
  23 import org.springframework.http.ResponseEntity;
  24 import org.springframework.http.client.BufferingClientHttpRequestFactory;
  25 import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
  26 import org.springframework.retry.policy.SimpleRetryPolicy;
  27 import org.springframework.retry.support.RetryTemplate;
  28 import org.springframework.stereotype.Component;
  29 import org.springframework.web.client.ResourceAccessException;
  30 import org.springframework.web.client.RestClientException;
  31 import org.springframework.web.client.RestTemplate;
  32
  33 @Component
  34 public class CamundaRequestHandler {
  35
  36     private static Logger logger = LoggerFactory.getLogger(CamundaRequestHandler.class);
  37     private static final String TIMEOUT = "30000";
  38     private static final String RETRY_TIMEOUT = "15000";
  39     private static final String TIMEOUT_PROPERTY = "mso.camunda.request.timeout";
  40     private static final String RETRY_TIMEOUT_PROPERTY = "mso.camunda.request.timeout.retry";
  41
  42     @Autowired
  43     private Environment env;
  44
  45     public ResponseEntity<List<HistoricProcessInstanceEntity>> getCamundaProcessInstanceHistory(String requestId,
  46             boolean retry) {
  47         String path = env.getProperty("mso.camunda.rest.history.uri") + requestId;
  48         String targetUrl = env.getProperty("mso.camundaURL") + path;
  49         HttpHeaders headers =
  50                 setCamundaHeaders(env.getRequiredProperty("mso.camundaAuth"), env.getRequiredProperty("mso.msoKey"));
  51
  52         HttpEntity<?> requestEntity = new HttpEntity<>(headers);
  53
  54         if (retry) {
  55             RestTemplate restTemplate = getRestTemplate(retry);
  56             RetryTemplate retryTemplate = getRetryTemplate();
  57             return retryTemplate.execute(context -> {
  58                 if (context.getLastThrowable() != null) {
  59                     logger.error("Retrying: Last call resulted in exception: ", context.getLastThrowable());
  60                 }
  61                 if (context.getRetryCount() == 0) {
  62                     logger.info("Querying Camunda for process-instance history for requestId: {}", requestId);
  63                 } else {
  64                     logger.info("Retry: Querying Camunda for process-instance history for requestId: {}",
  65                             context.getRetryCount(), requestId);
  66                 }
  67                 return restTemplate.exchange(targetUrl, HttpMethod.GET, requestEntity,
  68                         new ParameterizedTypeReference<List<HistoricProcessInstanceEntity>>() {});
  69             });
  70         } else {
  71             RestTemplate restTemplate = getRestTemplate(retry);
  72             return restTemplate.exchange(targetUrl, HttpMethod.GET, requestEntity,
  73                     new ParameterizedTypeReference<List<HistoricProcessInstanceEntity>>() {});
  74         }
  75     }
  76
  77     protected ResponseEntity<List<HistoricActivityInstanceEntity>> getCamundaActivityHistory(String processInstanceId) {
  78         RestTemplate restTemplate = getRestTemplate(false);
  79         String path = env.getProperty("mso.camunda.rest.activity.uri") + processInstanceId;
  80         String targetUrl = env.getProperty("mso.camundaURL") + path;
  81         HttpHeaders headers =
  82                 setCamundaHeaders(env.getRequiredProperty("mso.camundaAuth"), env.getRequiredProperty("mso.msoKey"));
  83         HttpEntity<?> requestEntity = new HttpEntity<>(headers);
  84
  85         return restTemplate.exchange(targetUrl, HttpMethod.GET, requestEntity,
  86                 new ParameterizedTypeReference<List<HistoricActivityInstanceEntity>>() {});
  87     }
  88
  89     protected String getTaskName(String requestId) {
  90         ResponseEntity<List<HistoricProcessInstanceEntity>> response = null;
  91
  92         String taskInformation = null;
  93         try {
  94             response = getCamundaProcessInstanceHistory(requestId, false);
  95         } catch (RestClientException e) {
  96             logger.warn("Error querying Camunda for process-instance history for requestId: {}, exception: {}",
  97                     requestId, e.getMessage());
  98         }
  99
 100         if (response != null) {
 101             taskInformation = getTaskInformation(response, requestId);
 102         }
 103         return taskInformation;
 104     }
 105
 106     protected String getTaskInformation(ResponseEntity<List<HistoricProcessInstanceEntity>> response,
 107             String requestId) {
 108         List<HistoricProcessInstanceEntity> historicProcessInstanceList = response.getBody();
 109         ResponseEntity<List<HistoricActivityInstanceEntity>> activityResponse = null;
 110         String processInstanceId = null;
 111         String taskInformation = null;
 112
 113         if (historicProcessInstanceList != null && !historicProcessInstanceList.isEmpty()) {
 114             Collections.reverse(historicProcessInstanceList);
 115             processInstanceId = historicProcessInstanceList.get(0).getId();
 116         } else {
 117             logger.warn("No processInstances returned for requestId: {} to get TaskInformation", requestId);
 118         }
 119
 120         if (processInstanceId != null) {
 121             try {
 122                 activityResponse = getCamundaActivityHistory(processInstanceId);
 123             } catch (RestClientException e) {
 124                 logger.warn(
 125                         "Error querying Camunda for activity-instance history for processInstanceId: {}, for requestId: {}, exception: {}",
 126                         processInstanceId, requestId, e.getMessage());
 127             }
 128         } else {
 129             logger.warn("No processInstanceId returned for requestId: {} to get TaskInformation", requestId);
 130         }
 131
 132         if (activityResponse != null) {
 133             taskInformation = getActivityName(activityResponse.getBody());
 134         } else {
 135             logger.warn("No activity history information returned for requestId: {} to get TaskInformation", requestId);
 136         }
 137         return taskInformation;
 138     }
 139
 140     protected String getActivityName(List<HistoricActivityInstanceEntity> activityInstanceList) {
 141         String activityName = null;
 142         HistoricActivityInstanceEntity activityInstance = null;
 143         String result = null;
 144
 145         if (activityInstanceList == null || activityInstanceList.isEmpty()) {
 146             result = "No results returned on activityInstance history lookup.";
 147         } else {
 148             activityInstance = activityInstanceList.get(0);
 149             activityName = activityInstance.getActivityName();
 150
 151             if (activityName == null) {
 152                 result = "Task name is null.";
 153             } else {
 154                 result = "Last task executed: " + activityName;
 155             }
 156         }
 157
 158         return result;
 159     }
 160
 161     protected HttpHeaders setCamundaHeaders(String auth, String msoKey) {
 162         HttpHeaders headers = new HttpHeaders();
 163         List<org.springframework.http.MediaType> acceptableMediaTypes = new ArrayList<>();
 164         acceptableMediaTypes.add(org.springframework.http.MediaType.APPLICATION_JSON);
 165         headers.setAccept(acceptableMediaTypes);
 166         try {
 167             String userCredentials = CryptoUtils.decrypt(auth, msoKey);
 168             if (userCredentials != null) {
 169                 headers.add(HttpHeaders.AUTHORIZATION,
 170                         "Basic " + DatatypeConverter.printBase64Binary(userCredentials.getBytes()));
 171             }
 172         } catch (GeneralSecurityException e) {
 173             logger.error("Security exception", e);
 174         }
 175         return headers;
 176     }
 177
 178     protected RetryTemplate getRetryTemplate() {
 179         RetryTemplate retryTemplate = new RetryTemplate();
 180         Map<Class<? extends Throwable>, Boolean> retryableExceptions = new HashMap<>();
 181         retryableExceptions.put(ResourceAccessException.class, true);
 182         SimpleRetryPolicy policy = new SimpleRetryPolicy(2, retryableExceptions);
 183         retryTemplate.setRetryPolicy(policy);
 184         return retryTemplate;
 185     }
 186
 187     protected RestTemplate getRestTemplate(boolean retry) {
 188         int timeout;
 189         if (retry) {
 190             timeout = Integer.parseInt(env.getProperty(RETRY_TIMEOUT_PROPERTY, RETRY_TIMEOUT));
 191         } else {
 192             timeout = Integer.parseInt(env.getProperty(TIMEOUT_PROPERTY, TIMEOUT));
 193         }
 194
 195         RestTemplate restTemplate = new RestTemplate();
 196         HttpComponentsClientHttpRequestFactory factory = new HttpComponentsClientHttpRequestFactory();
 197         factory.setConnectionRequestTimeout(timeout);
 198         factory.setReadTimeout(timeout);
 199         factory.setConnectTimeout(timeout);
 200         restTemplate.setRequestFactory(new BufferingClientHttpRequestFactory(factory));
 201         restTemplate.getInterceptors().add(new SOSpringClientFilter());
 202         restTemplate.getInterceptors().add((new SpringClientPayloadFilter()));
 203         return restTemplate;
 204     }
 205 }