src/main/java/org/onap/nbi/apis/serviceorder/SoClient.java

   1 /**
   2  * Copyright (c) 2018 Orange
   3  *
   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
   6  *
   7  * http://www.apache.org/licenses/LICENSE-2.0
   8  *
   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.
  12  */
  13 package org.onap.nbi.apis.serviceorder;
  14
  15 import javax.annotation.PostConstruct;
  16 import org.onap.nbi.OnapComponentsUrlPaths;
  17 import org.onap.nbi.apis.serviceorder.model.consumer.CreateE2EServiceInstanceResponse;
  18 import org.onap.nbi.apis.serviceorder.model.consumer.CreateServiceInstanceResponse;
  19 import org.onap.nbi.apis.serviceorder.model.consumer.DeleteE2EServiceInstanceResponse;
  20 import org.onap.nbi.apis.serviceorder.model.consumer.GetE2ERequestStatusResponse;
  21 import org.onap.nbi.apis.serviceorder.model.consumer.GetRequestStatusResponse;
  22 import org.onap.nbi.apis.serviceorder.model.consumer.MSODeleteE2EPayload;
  23 import org.onap.nbi.apis.serviceorder.model.consumer.MSOE2EPayload;
  24 import org.onap.nbi.apis.serviceorder.model.consumer.MSOPayload;
  25 import org.onap.nbi.apis.serviceorder.model.consumer.ServiceResponse;
  26 import org.onap.nbi.exceptions.BackendFunctionalException;
  27 import org.slf4j.Logger;
  28 import org.slf4j.LoggerFactory;
  29 import org.springframework.beans.factory.annotation.Autowired;
  30 import org.springframework.beans.factory.annotation.Value;
  31 import org.springframework.http.HttpEntity;
  32 import org.springframework.http.HttpHeaders;
  33 import org.springframework.http.HttpMethod;
  34 import org.springframework.http.HttpStatus;
  35 import org.springframework.http.ResponseEntity;
  36 import org.springframework.stereotype.Service;
  37 import org.springframework.web.client.ResourceAccessException;
  38 import org.springframework.web.client.RestTemplate;
  39
  40 @Service
  41 public class SoClient {
  42
  43     public static final String RESPONSE_STATUS = "response status : ";
  44     public static final String RETURNS = " returns ";
  45     public static final String ERROR_ON_CALLING = "error on calling ";
  46     @Autowired
  47     private RestTemplate restTemplate;
  48
  49     @Value("${so.host}")
  50     private String soHostname;
  51
  52     @Value("${so.api.id}")
  53     private String soApiId;
  54
  55     @Value("${so.header.authorization}")
  56     private String soHeaderAuthorization;
  57
  58     private static final String HEADER_AUTHORIZATION = "Authorization";
  59     private static final String X_FROM_APP_ID = "X-FromAppId";
  60
  61     private static final Logger LOGGER = LoggerFactory.getLogger(SoClient.class);
  62
  63     private String createSoUrl;
  64     private String createE2ESoUrl;
  65     private String getSoStatus;
  66     private String getE2ESoStatus;
  67     private String deleteE2ESoUrl;
  68     private String deleteSoUrl;
  69
  70
  71     @PostConstruct
  72     private void setUpAndLogSOUrl() {
  73         createSoUrl = new StringBuilder().append(soHostname)
  74             .append(OnapComponentsUrlPaths.MSO_CREATE_SERVICE_INSTANCE_PATH).toString();
  75         createE2ESoUrl = new StringBuilder().append(soHostname)
  76             .append(OnapComponentsUrlPaths.MSO_CREATE_E2ESERVICE_INSTANCE_PATH).toString();
  77         deleteSoUrl = new StringBuilder().append(soHostname)
  78             .append(OnapComponentsUrlPaths.MSO_DELETE_REQUEST_STATUS_PATH).toString();
  79         deleteE2ESoUrl = new StringBuilder().append(soHostname)
  80             .append(OnapComponentsUrlPaths.MSO_DELETE_E2ESERVICE_INSTANCE_PATH).toString();
  81         getSoStatus = new StringBuilder().append(soHostname).append(OnapComponentsUrlPaths.MSO_GET_REQUEST_STATUS_PATH)
  82             .toString();
  83         getE2ESoStatus = new StringBuilder().append(soHostname)
  84             .append(OnapComponentsUrlPaths.MSO_GET_E2EREQUEST_STATUS_PATH).toString();
  85
  86         LOGGER.info("SO create service url :  " + createSoUrl);
  87         LOGGER.info("SO create e2e service url :  " + createE2ESoUrl);
  88         LOGGER.info("SO delete service url :  " + deleteSoUrl);
  89         LOGGER.info("SO delete e2e service url :  " + deleteE2ESoUrl);
  90         LOGGER.info("SO get so status url :  " + getSoStatus);
  91         LOGGER.info("SO get e2e so status url :  " + getE2ESoStatus);
  92
  93     }
  94
  95
  96     public ResponseEntity<CreateServiceInstanceResponse> callCreateServiceInstance(MSOPayload msoPayload) {
  97
  98         if (LOGGER.isDebugEnabled()) {
  99             LOGGER.debug("Calling SO CreateServiceInstance with msoPayload : " + msoPayload.toString());
 100         }
 101
 102         try {
 103             ResponseEntity<CreateServiceInstanceResponse> response = restTemplate.exchange(createSoUrl, HttpMethod.POST,
 104                 new HttpEntity<>(msoPayload, buildRequestHeader()), CreateServiceInstanceResponse.class);
 105
 106             logResponsePost(createSoUrl, response);
 107             return response;
 108
 109         } catch (BackendFunctionalException e) {
 110             LOGGER.error(ERROR_ON_CALLING + createSoUrl + " ," + e.getHttpStatus() + " , " + e.getBodyResponse());
 111             return new ResponseEntity(e.getBodyResponse(), e.getHttpStatus());
 112         } catch (ResourceAccessException e) {
 113             LOGGER.error(ERROR_ON_CALLING + createSoUrl + " ," + e.getMessage());
 114             return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
 115         }
 116     }
 117
 118     public ResponseEntity<CreateE2EServiceInstanceResponse> callE2ECreateServiceInstance(MSOE2EPayload msoPayloadE2E) {
 119
 120         if (LOGGER.isDebugEnabled()) {
 121             LOGGER.debug("Calling SO CreateServiceInstanceE2E with msoPayload : " + msoPayloadE2E.toString());
 122         }
 123
 124         try {
 125             ResponseEntity<CreateE2EServiceInstanceResponse> response = restTemplate
 126                 .exchange(createE2ESoUrl, HttpMethod.POST,
 127                     new HttpEntity<>(msoPayloadE2E, buildRequestHeader()), CreateE2EServiceInstanceResponse.class);
 128
 129             logE2EResponsePost(createE2ESoUrl, response);
 130             return response;
 131
 132         } catch (BackendFunctionalException e) {
 133             LOGGER.error(ERROR_ON_CALLING + createSoUrl + " ," + e.getHttpStatus() + " , " + e.getBodyResponse());
 134             return new ResponseEntity(e.getBodyResponse(), e.getHttpStatus());
 135         } catch (ResourceAccessException e) {
 136             LOGGER.error(ERROR_ON_CALLING + createE2ESoUrl + " ," + e.getMessage());
 137             return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
 138         }
 139     }
 140
 141     public ResponseEntity<CreateServiceInstanceResponse> callDeleteServiceInstance(MSOPayload msoPayload,
 142         String serviceId) {
 143
 144         if (LOGGER.isDebugEnabled()) {
 145             LOGGER.debug("Calling SO DeleteServiceInstance with msoPayload : " + msoPayload.toString());
 146         }
 147
 148         String url = deleteSoUrl + serviceId;
 149
 150         try {
 151             ResponseEntity<CreateServiceInstanceResponse> response = restTemplate.exchange(url, HttpMethod.DELETE,
 152                 new HttpEntity<>(msoPayload, buildRequestHeader()), CreateServiceInstanceResponse.class);
 153
 154             logResponsePost(url, response);
 155             return response;
 156
 157         } catch (BackendFunctionalException e) {
 158             LOGGER.error(ERROR_ON_CALLING + url + " ," + e);
 159             return new ResponseEntity<>(e.getHttpStatus());
 160         } catch (ResourceAccessException e) {
 161             LOGGER.error(ERROR_ON_CALLING + url + " ," + e);
 162             return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
 163         }
 164
 165     }
 166
 167     public ResponseEntity<CreateE2EServiceInstanceResponse> callE2EDeleteServiceInstance(String globalSubscriberId,
 168         String serviceType,
 169         String serviceInstanceId) {
 170
 171         String url = deleteE2ESoUrl + serviceInstanceId;
 172         MSODeleteE2EPayload msoDeleteE2EPayload = new MSODeleteE2EPayload();
 173         msoDeleteE2EPayload.setGlobalSubscriberId(globalSubscriberId);
 174         msoDeleteE2EPayload.setServiceType(serviceType);
 175
 176         if (LOGGER.isDebugEnabled()) {
 177             LOGGER.debug("Calling SO DeleteE2EServiceInstance with url : " + url + " MSODeleteE2EPayload : "
 178                 + msoDeleteE2EPayload.toString());
 179         }
 180
 181         try {
 182             ResponseEntity<DeleteE2EServiceInstanceResponse> deleteresponse = restTemplate
 183                 .exchange(url, HttpMethod.DELETE,
 184                     new HttpEntity<>(msoDeleteE2EPayload, buildRequestHeader()),
 185                     DeleteE2EServiceInstanceResponse.class);
 186
 187             // For E2E Services , Create and Delete Service responses are different, to maintain consistentcy with ServiceInstances
 188             // Copy contents of DeleteE2EServiceInstanceResponse to CreateE2EServiceInstanceResponse
 189             CreateE2EServiceInstanceResponse dummyresponse = new CreateE2EServiceInstanceResponse();
 190             ServiceResponse serviceResponse = new ServiceResponse();
 191             dummyresponse.setService(serviceResponse);
 192             dummyresponse.getService().setOperationId(deleteresponse.getBody().getOperationId());
 193             dummyresponse.getService().setServiceId(serviceInstanceId);
 194
 195             ResponseEntity<CreateE2EServiceInstanceResponse> response = new ResponseEntity(dummyresponse,
 196                 deleteresponse.getStatusCode());
 197             logE2EResponsePost(url, response);
 198             return response;
 199
 200         } catch (BackendFunctionalException e) {
 201             LOGGER.error(ERROR_ON_CALLING + url + " ," + e);
 202             return new ResponseEntity<>(e.getHttpStatus());
 203         } catch (ResourceAccessException e) {
 204             LOGGER.error(ERROR_ON_CALLING + url + " ," + e);
 205             return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
 206         }
 207     }
 208
 209     private void logResponsePost(String url, ResponseEntity<CreateServiceInstanceResponse> response) {
 210         LOGGER.info(RESPONSE_STATUS + response.getStatusCodeValue());
 211         if (LOGGER.isDebugEnabled()) {
 212             LOGGER.debug("response body : {}", response.getBody().toString());
 213         }
 214
 215         if (LOGGER.isWarnEnabled() && !response.getStatusCode().equals(HttpStatus.CREATED)) {
 216             LOGGER.warn("HTTP call SO on {} returns {} , {}", url, response.getStatusCodeValue(),
 217                 response.getBody().toString());
 218         }
 219     }
 220
 221     private void logE2EResponsePost(String url, ResponseEntity<CreateE2EServiceInstanceResponse> response) {
 222         LOGGER.info(RESPONSE_STATUS + response.getStatusCodeValue());
 223         if (LOGGER.isDebugEnabled()) {
 224             LOGGER.debug("response body : {}", response.getBody().toString());
 225         }
 226
 227         if (LOGGER.isWarnEnabled() && !response.getStatusCode().equals(HttpStatus.CREATED)) {
 228             LOGGER.warn("HTTP call SO on {} returns {} , {}", url, response.getStatusCodeValue(),
 229                 response.getBody().toString());
 230         }
 231     }
 232
 233     public GetRequestStatusResponse callGetRequestStatus(String requestId) {
 234         String url = getSoStatus + requestId;
 235
 236         try {
 237
 238             ResponseEntity<GetRequestStatusResponse> response = restTemplate.exchange(url, HttpMethod.GET,
 239                 new HttpEntity<>(buildRequestHeader()), GetRequestStatusResponse.class);
 240             logResponseGet(url, response);
 241             if (null == response) {
 242                 return null;
 243             } else {
 244                 return response.getBody();
 245             }
 246
 247         } catch (BackendFunctionalException | ResourceAccessException e) {
 248             LOGGER.error(ERROR_ON_CALLING + url + " ," + e);
 249             return null;
 250         }
 251     }
 252
 253     public GetE2ERequestStatusResponse callE2EGetRequestStatus(String operationId, String serviceId) {
 254
 255         String callUrlFormated = getE2ESoStatus.replace("$serviceId", serviceId);
 256         callUrlFormated = callUrlFormated.replace("$operationId", operationId);
 257
 258         if (LOGGER.isDebugEnabled()) {
 259             LOGGER.debug("Calling SO callE2EGetRequestStatus with url : " + callUrlFormated);
 260         }
 261
 262         try {
 263
 264             ResponseEntity<GetE2ERequestStatusResponse> response = restTemplate
 265                 .exchange(callUrlFormated, HttpMethod.GET,
 266                     new HttpEntity<>(buildRequestHeader()), GetE2ERequestStatusResponse.class);
 267             logE2EResponseGet(callUrlFormated, response);
 268             if (null == response) {
 269                 return null;
 270             } else {
 271                 return response.getBody();
 272             }
 273
 274         } catch (BackendFunctionalException | ResourceAccessException e) {
 275             LOGGER.error(ERROR_ON_CALLING + callUrlFormated + " ," + e);
 276             return null;
 277         }
 278     }
 279
 280     private void logResponseGet(String url, ResponseEntity<GetRequestStatusResponse> response) {
 281         if (response != null) {
 282             if (LOGGER.isDebugEnabled()) {
 283                 LOGGER.debug("response body : {}", response.getBody().toString());
 284             }
 285             LOGGER.info("response status : {}", response.getStatusCodeValue());
 286             if (LOGGER.isWarnEnabled() && !response.getStatusCode().equals(HttpStatus.OK)) {
 287                 LOGGER.warn("HTTP call SO on {} returns {} , {}", url, response.getStatusCodeValue(),
 288                     response.getBody().toString());
 289             }
 290         } else {
 291             LOGGER.info("no response calling url {}", url);
 292         }
 293     }
 294
 295     private void logE2EResponseGet(String url, ResponseEntity<GetE2ERequestStatusResponse> response) {
 296         if (response != null) {
 297             if (LOGGER.isDebugEnabled()) {
 298                 LOGGER.debug("response body : {}", response.getBody().toString());
 299             }
 300             LOGGER.info("response status : {}", response.getStatusCodeValue());
 301             if (LOGGER.isWarnEnabled() && !response.getStatusCode().equals(HttpStatus.OK)) {
 302                 LOGGER.warn("HTTP call SO on {} returns {} , {}", url, response.getStatusCodeValue(),
 303                     response.getBody().toString());
 304             }
 305         } else {
 306             LOGGER.info("no response calling url {}", url);
 307         }
 308     }
 309
 310     private HttpHeaders buildRequestHeader() {
 311         HttpHeaders httpHeaders = new HttpHeaders();
 312         httpHeaders.add(HEADER_AUTHORIZATION, soHeaderAuthorization);
 313         httpHeaders.add(X_FROM_APP_ID, soApiId);
 314         httpHeaders.add("Accept", "application/json");
 315         httpHeaders.add("Content-Type", "application/json");
 316         return httpHeaders;
 317     }
 318
 319 }