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