From 7d05e51e3c9d1eeb799c4255f3dea2533e2002d8 Mon Sep 17 00:00:00 2001 From: "Singal, Kapil (ks220y)" Date: Tue, 4 Sep 2018 13:22:52 -0400 Subject: SDN Controller Blueprints Rest Adaptor Creating SDN Controller Blueprints Rest Adaptor Component Change-Id: Ic53f91f0ea47808b486e64a5d7f2c763b67dbf31 Issue-ID: CCSDK-496 Signed-off-by: Singal, Kapil (ks220y) --- .../rest/adaptor/ConfigRestAdaptorConstants.java | 66 +++++ .../rest/adaptor/ConfigRestAdaptorException.java | 47 ++++ .../config/rest/adaptor/data/RestResponse.java | 73 ++++++ .../service/AbstractConfigRestClientAdapter.java | 274 +++++++++++++++++++++ .../adaptor/service/ConfigRestAdaptorService.java | 89 +++++++ .../service/ConfigRestAdaptorServiceImpl.java | 142 +++++++++++ .../service/ConfigRestClientServiceAdapter.java | 35 +++ .../service/GenericRestClientAdapterImpl.java | 136 ++++++++++ .../adaptor/service/SSLRestClientAdapterImpl.java | 127 ++++++++++ .../utils/BasicAuthorizationInterceptor.java | 53 ++++ .../adaptor/utils/LoggingRequestInterceptor.java | 68 +++++ .../org/opendaylight/blueprint/impl-blueprint.xml | 32 +++ 12 files changed, 1142 insertions(+) create mode 100644 blueprints-processor/adaptors/rest-adaptor-provider/src/main/java/org/onap/ccsdk/config/rest/adaptor/ConfigRestAdaptorConstants.java create mode 100644 blueprints-processor/adaptors/rest-adaptor-provider/src/main/java/org/onap/ccsdk/config/rest/adaptor/ConfigRestAdaptorException.java create mode 100644 blueprints-processor/adaptors/rest-adaptor-provider/src/main/java/org/onap/ccsdk/config/rest/adaptor/data/RestResponse.java create mode 100644 blueprints-processor/adaptors/rest-adaptor-provider/src/main/java/org/onap/ccsdk/config/rest/adaptor/service/AbstractConfigRestClientAdapter.java create mode 100644 blueprints-processor/adaptors/rest-adaptor-provider/src/main/java/org/onap/ccsdk/config/rest/adaptor/service/ConfigRestAdaptorService.java create mode 100644 blueprints-processor/adaptors/rest-adaptor-provider/src/main/java/org/onap/ccsdk/config/rest/adaptor/service/ConfigRestAdaptorServiceImpl.java create mode 100644 blueprints-processor/adaptors/rest-adaptor-provider/src/main/java/org/onap/ccsdk/config/rest/adaptor/service/ConfigRestClientServiceAdapter.java create mode 100644 blueprints-processor/adaptors/rest-adaptor-provider/src/main/java/org/onap/ccsdk/config/rest/adaptor/service/GenericRestClientAdapterImpl.java create mode 100644 blueprints-processor/adaptors/rest-adaptor-provider/src/main/java/org/onap/ccsdk/config/rest/adaptor/service/SSLRestClientAdapterImpl.java create mode 100644 blueprints-processor/adaptors/rest-adaptor-provider/src/main/java/org/onap/ccsdk/config/rest/adaptor/utils/BasicAuthorizationInterceptor.java create mode 100644 blueprints-processor/adaptors/rest-adaptor-provider/src/main/java/org/onap/ccsdk/config/rest/adaptor/utils/LoggingRequestInterceptor.java create mode 100644 blueprints-processor/adaptors/rest-adaptor-provider/src/main/resources/org/opendaylight/blueprint/impl-blueprint.xml (limited to 'blueprints-processor/adaptors') diff --git a/blueprints-processor/adaptors/rest-adaptor-provider/src/main/java/org/onap/ccsdk/config/rest/adaptor/ConfigRestAdaptorConstants.java b/blueprints-processor/adaptors/rest-adaptor-provider/src/main/java/org/onap/ccsdk/config/rest/adaptor/ConfigRestAdaptorConstants.java new file mode 100644 index 000000000..4b0941652 --- /dev/null +++ b/blueprints-processor/adaptors/rest-adaptor-provider/src/main/java/org/onap/ccsdk/config/rest/adaptor/ConfigRestAdaptorConstants.java @@ -0,0 +1,66 @@ +/* + * Copyright © 2017-2018 AT&T Intellectual Property. + * + * 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.ccsdk.config.rest.adaptor; + +public class ConfigRestAdaptorConstants { + private ConfigRestAdaptorConstants() { + + } + + public static final String SDNC_ROOT_DIR_ENV_VAR_KEY = "SDNC_CONFIG_DIR"; + public static final String REST_ADAPTOR_PROPERTIES_FILE_NAME = "config-rest-adaptor.properties"; + public static final String PROXY_URL_KEY = "proxyUrl"; + public static final String PROXY_URLS_VALUE_SEPARATOR = ","; + public static final String AAF_USERNAME_KEY = "aafUserName"; + public static final String AAF_PSSWD_KEY = "aafPassword"; + public static final String COMMON_SERVICE_VERSION_KEY = "commonServiceVersion"; + + public static final String PROPERTY_ENV_PROD = "field"; + public static final String PROPERTY_ENV_SOLO = "solo"; + + public static final String REST_ADAPTOR_BASE_PROPERTY = "org.onap.ccsdk.config.rest.adaptors."; + public static final String REST_ADAPTOR_ENV_TYPE = "envtype"; + public static final String REST_ADAPTOR_TYPE_GENERIC = "generic"; + public static final String REST_ADAPTOR_TYPE_SSL = "ssl"; + + public static final String SSL_SERVICE_BASEURL = ".url"; + public static final String SSL_SERVICE_APP = ".application"; + public static final String SSL_SERVICE_TRUST = ".ssl.trust"; + public static final String SSL_SERVICE_TRUST_PSSWD = ".ssl.trust.psswd"; + public static final String SSL_SERVICE_KEY = ".ssl.key"; + public static final String SSL_SERVICE_KEY_PSSWD = ".ssl.key.psswd"; + + public static final String SERVICE_TYPE_PROPERTY = ".type"; + public static final String SERVICE_EANABLED_PROPERTY = ".enable"; + public static final String SERVICE_ENV_PROPERTY = ".env"; + public static final String SERVICE_BASEURL_PROPERTY = ".url"; + public static final String SERVICE_PROPERTYFILE = ".propertyfile"; + public static final String SERVICE_USER_PROPERTY = ".user"; + public static final String SERVICE_APPID_PROPERTY = ".appId"; + public static final String SERVICE_PSSWD_PROPERTY = ".passwd"; + public static final String SERVICE_CLIENTAUTH_PROPERTY = ".clientAuth"; + public static final String SERVICE_AUTHORIZATION_PROPERTY = ".authorization"; + + public static final String SELECTOR_AAI = "aai"; + public static final String SELECTOR_ALTS = "alts"; + public static final String SELECTOR_EIPAM = "eipam"; + public static final String SELECTOR_COSMS = "cosms"; + public static final String SELECTOR_RESTCONF = "restconf"; + public static final String SELECTOR_MODEL_SERVICE = "modelservice"; + public static final String SELECTOR_POLICY_MANAGER = "policymanager"; + public static final String SELECTOR_NRD = "networkresourcediscovery"; + public static final String SELECTOR_NSM = "nsm"; + +} diff --git a/blueprints-processor/adaptors/rest-adaptor-provider/src/main/java/org/onap/ccsdk/config/rest/adaptor/ConfigRestAdaptorException.java b/blueprints-processor/adaptors/rest-adaptor-provider/src/main/java/org/onap/ccsdk/config/rest/adaptor/ConfigRestAdaptorException.java new file mode 100644 index 000000000..3bb04a207 --- /dev/null +++ b/blueprints-processor/adaptors/rest-adaptor-provider/src/main/java/org/onap/ccsdk/config/rest/adaptor/ConfigRestAdaptorException.java @@ -0,0 +1,47 @@ +/* + * Copyright © 2017-2018 AT&T Intellectual Property. + * + * 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.ccsdk.config.rest.adaptor; + +/** + * ConfigRestAdaptorException.java Purpose: Provide Configuration Rest Adaptor Exception + * + * @version 1.0 + */ +public class ConfigRestAdaptorException extends Exception { + + /** + * + */ + private static final long serialVersionUID = 1L; + + /** + * This is a ConfigRestAdaptorException constructor + * + * @param message + */ + public ConfigRestAdaptorException(String message) { + super(message); + } + + /** + * This is a ConfigRestAdaptorException constructor + * + * @param message + */ + public ConfigRestAdaptorException(String message, Throwable cause) { + super(message, cause); + } + +} diff --git a/blueprints-processor/adaptors/rest-adaptor-provider/src/main/java/org/onap/ccsdk/config/rest/adaptor/data/RestResponse.java b/blueprints-processor/adaptors/rest-adaptor-provider/src/main/java/org/onap/ccsdk/config/rest/adaptor/data/RestResponse.java new file mode 100644 index 000000000..ed39ea925 --- /dev/null +++ b/blueprints-processor/adaptors/rest-adaptor-provider/src/main/java/org/onap/ccsdk/config/rest/adaptor/data/RestResponse.java @@ -0,0 +1,73 @@ +/* + * Copyright © 2017-2018 AT&T Intellectual Property. + * + * 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.ccsdk.config.rest.adaptor.data; + +import java.util.Map; + +public class RestResponse { + + private String statusCode; + private String body; + private Map parameters; + private Map responseHeaders; + private Map requestHeaders; + + public String getStatusCode() { + return statusCode; + } + + public void setStatusCode(String statusCode) { + this.statusCode = statusCode; + } + + public String getBody() { + return body; + } + + public void setBody(String body) { + this.body = body; + } + + public Map getParameters() { + return parameters; + } + + public void setParameters(Map parameters) { + this.parameters = parameters; + } + + public Map getResponseHeaders() { + return responseHeaders; + } + + public void setResponseHeaders(Map responseHeaders) { + this.responseHeaders = responseHeaders; + } + + public Map getRequestHeaders() { + return requestHeaders; + } + + public void setRequestHeaders(Map requestHeaders) { + this.requestHeaders = requestHeaders; + } + + @Override + public String toString() { + return "RestResponse [statusCode=" + statusCode + ", body=" + body + ", parameters=" + parameters + + ", responseHeaders=" + responseHeaders + ", requestHeaders=" + requestHeaders + "]"; + } + +} diff --git a/blueprints-processor/adaptors/rest-adaptor-provider/src/main/java/org/onap/ccsdk/config/rest/adaptor/service/AbstractConfigRestClientAdapter.java b/blueprints-processor/adaptors/rest-adaptor-provider/src/main/java/org/onap/ccsdk/config/rest/adaptor/service/AbstractConfigRestClientAdapter.java new file mode 100644 index 000000000..7ccb6274d --- /dev/null +++ b/blueprints-processor/adaptors/rest-adaptor-provider/src/main/java/org/onap/ccsdk/config/rest/adaptor/service/AbstractConfigRestClientAdapter.java @@ -0,0 +1,274 @@ +/* + * Copyright © 2017-2018 AT&T Intellectual Property. + * + * 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.ccsdk.config.rest.adaptor.service; + +import java.io.FileInputStream; +import java.io.InputStream; +import java.security.KeyStore; +import java.security.cert.X509Certificate; +import java.util.ArrayList; +import java.util.List; +import java.util.Map; +import java.util.concurrent.ConcurrentHashMap; +import javax.net.ssl.SSLContext; +import org.apache.commons.lang3.StringUtils; +import org.apache.http.conn.ssl.NoopHostnameVerifier; +import org.apache.http.conn.ssl.SSLConnectionSocketFactory; +import org.apache.http.impl.client.CloseableHttpClient; +import org.apache.http.impl.client.HttpClients; +import org.apache.http.ssl.SSLContextBuilder; +import org.apache.http.ssl.TrustStrategy; +import org.onap.ccsdk.config.rest.adaptor.ConfigRestAdaptorConstants; +import org.onap.ccsdk.config.rest.adaptor.ConfigRestAdaptorException; +import org.onap.ccsdk.config.rest.adaptor.data.RestResponse; +import org.onap.ccsdk.config.rest.adaptor.utils.BasicAuthorizationInterceptor; +import org.springframework.http.HttpEntity; +import org.springframework.http.HttpHeaders; +import org.springframework.http.HttpMethod; +import org.springframework.http.HttpStatus; +import org.springframework.http.ResponseEntity; +import org.springframework.http.client.HttpComponentsClientHttpRequestFactory; +import org.springframework.http.converter.ByteArrayHttpMessageConverter; +import org.springframework.http.converter.HttpMessageConverter; +import org.springframework.http.converter.ResourceHttpMessageConverter; +import org.springframework.http.converter.StringHttpMessageConverter; +import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter; +import org.springframework.http.converter.xml.SourceHttpMessageConverter; +import org.springframework.util.ResourceUtils; +import org.springframework.web.client.HttpClientErrorException; +import org.springframework.web.client.RestTemplate; +import com.att.eelf.configuration.EELFLogger; +import com.att.eelf.configuration.EELFManager; + +abstract class AbstractConfigRestClientAdapter implements ConfigRestClientServiceAdapter { + + private static EELFLogger logger = EELFManager.getInstance().getLogger(AbstractConfigRestClientAdapter.class); + private static final String MS_INIT_FAIL = "Failed to initialise microservice client restTemplate."; + + protected boolean isRestClientServiceAdapaterEnabled = false; + protected boolean isSSLServiceAdapaterEnabled = true; + + protected Map properties = new ConcurrentHashMap<>(); + protected String serviceSelector; + + protected RestTemplate restTemplate; + + protected AbstractConfigRestClientAdapter(Map properties, String serviceSelector) { + this.properties = properties; + this.serviceSelector = serviceSelector; + setRestClientServiceAdapaterEnabled(); + } + + private void setRestClientServiceAdapaterEnabled() { + String isEnabledProperty = ConfigRestAdaptorConstants.REST_ADAPTOR_BASE_PROPERTY + serviceSelector + + ConfigRestAdaptorConstants.SERVICE_EANABLED_PROPERTY; + String isRestClientServiceAdapaterEnabledStr = properties.get(isEnabledProperty); + logger.info("Service selector ({}) enable status ({}) ", serviceSelector, + isRestClientServiceAdapaterEnabledStr); + if (StringUtils.isNotBlank(isRestClientServiceAdapaterEnabledStr) + && Boolean.parseBoolean(isRestClientServiceAdapaterEnabledStr)) { + isRestClientServiceAdapaterEnabled = true; + } + } + + private List> getMessageConverters() { + List> converters = new ArrayList<>(); + converters.add(new ByteArrayHttpMessageConverter()); + converters.add(new StringHttpMessageConverter()); + converters.add(new ResourceHttpMessageConverter()); + converters.add(new SourceHttpMessageConverter()); + converters.add(new MappingJackson2HttpMessageConverter()); + return converters; + } + + public void initialise(String user, String pass) { + logger.trace("Config rest template factory user ({}) ", user); + + CloseableHttpClient httpClient = + HttpClients.custom().setSSLHostnameVerifier(new NoopHostnameVerifier()).build(); + HttpComponentsClientHttpRequestFactory requestFactory = new HttpComponentsClientHttpRequestFactory(); + requestFactory.setHttpClient(httpClient); + + restTemplate = new RestTemplate(getMessageConverters()); + restTemplate.setRequestFactory(requestFactory); + if (StringUtils.isNotBlank(user) && StringUtils.isNotBlank(pass)) { + restTemplate.getInterceptors().add(new BasicAuthorizationInterceptor(user, pass)); + } + } + + public void initialiseSSL(String keyStorePath, String trustStorePath, String keyPass, String trustPass) + throws ConfigRestAdaptorException { + logger.trace("SSL rest template factory"); + + TrustStrategy acceptingTrustStrategy = (X509Certificate[] chain, String authType) -> true; + SSLContext sslContext = null; + + try (InputStream keyInput = new FileInputStream(keyStorePath)) { + KeyStore keyStore = KeyStore.getInstance("PKCS12"); + keyStore.load(keyInput, keyPass.toCharArray()); + + logger.info("key loaded successfully"); + sslContext = SSLContextBuilder.create().loadKeyMaterial(keyStore, keyPass.toCharArray()).loadTrustMaterial( + ResourceUtils.getFile(trustStorePath), trustPass.toCharArray(), acceptingTrustStrategy).build(); + } catch (Exception e) { + throw new ConfigRestAdaptorException(e.getMessage()); + } + + SSLConnectionSocketFactory csf = new SSLConnectionSocketFactory(sslContext); + CloseableHttpClient httpClient = HttpClients.custom().setSSLSocketFactory(csf).build(); + HttpComponentsClientHttpRequestFactory requestFactory = new HttpComponentsClientHttpRequestFactory(httpClient); + + restTemplate = new RestTemplate(getMessageConverters()); + restTemplate.setRequestFactory(requestFactory); + } + + public T getResource(HttpHeaders headers, String url, Class responseType) throws ConfigRestAdaptorException { + ResponseEntity response = exchangeForEntity(headers, url, HttpMethod.GET, null, responseType); + return processResponse(response, url, HttpMethod.GET); + } + + public T postResource(HttpHeaders headers, String url, Object request, Class responseType) + throws ConfigRestAdaptorException { + ResponseEntity response = exchangeForEntity(headers, url, HttpMethod.POST, request, responseType); + return processResponse(response, url, HttpMethod.POST); + } + + public T exchangeResource(HttpHeaders headers, String url, Object request, Class responseType, String method) + throws ConfigRestAdaptorException { + ResponseEntity response = exchangeForEntity(headers, url, HttpMethod.resolve(method), request, responseType); + return processResponse(response, url, HttpMethod.resolve(method)); + } + + public RestResponse getResource(HttpHeaders headers, String url) throws ConfigRestAdaptorException { + return exchangeForEntity(headers, url, HttpMethod.GET, null); + } + + public RestResponse postResource(HttpHeaders headers, String url, Object request) + throws ConfigRestAdaptorException { + return exchangeForEntity(headers, url, HttpMethod.POST, request); + } + + public RestResponse exchangeResource(HttpHeaders headers, String url, Object request, String method) + throws ConfigRestAdaptorException { + return exchangeForEntity(headers, url, HttpMethod.resolve(method), request); + } + + private RestResponse exchangeForEntity(HttpHeaders headers, String url, HttpMethod httpMethod, Object request) + throws ConfigRestAdaptorException { + RestResponse restResponse = new RestResponse(); + restResponse.setRequestHeaders(headers.toSingleValueMap()); + ResponseEntity response = null; + + try { + if (restTemplate == null) { + logger.error(MS_INIT_FAIL); + } else { + logger.debug("Rest Operation: {}", httpMethod); + logger.debug("url : ({})", url); + logger.debug("headers: ({})", headers); + logger.debug("request: ({})", request); + + if (HttpMethod.GET == httpMethod) { + HttpEntity entity = new HttpEntity<>("parameters", headers); + response = restTemplate.exchange(url, httpMethod, entity, String.class); + } else { + HttpEntity entity = new HttpEntity<>(request, headers); + response = restTemplate.exchange(url, httpMethod, entity, String.class); + } + logger.debug("response: ({})", response); + + if (response != null) { + logger.debug("response status code: ({})", response.getStatusCode()); + restResponse.setBody(response.getBody()); + restResponse.setStatusCode(response.getStatusCode().toString()); + restResponse.setResponseHeaders( + response.getHeaders() != null ? response.getHeaders().toSingleValueMap() : null); + return restResponse; + } + throw new ConfigRestAdaptorException("Rest exchangeForEntity failed to perform "); + } + } catch (HttpClientErrorException clientError) { + logger.debug("clientError: ({})", clientError); + restResponse.setBody(StringUtils.isBlank(clientError.getResponseBodyAsString()) ? clientError.getMessage() + : clientError.getResponseBodyAsString()); + restResponse.setStatusCode(clientError.getStatusCode().toString()); + } catch (Exception e) { + throw new ConfigRestAdaptorException( + String.format("httpMethod (%s) for url (%s) resulted in Exception (%s)", httpMethod, url, e)); + } + return restResponse; + } + + private ResponseEntity exchangeForEntity(HttpHeaders headers, String url, HttpMethod httpMethod, + Object request, Class responseType) throws ConfigRestAdaptorException { + ResponseEntity response = null; + + try { + if (restTemplate == null) { + logger.error(MS_INIT_FAIL); + } else { + logger.debug("Rest Operation: {}", httpMethod); + logger.debug("url : ({})", url); + logger.debug("headers: ({})", headers); + logger.debug("request: ({})", request); + + if (HttpMethod.GET == httpMethod) { + HttpEntity entity = new HttpEntity<>("parameters", headers); + response = restTemplate.exchange(url, httpMethod, entity, responseType); + } else { + HttpEntity entity = new HttpEntity<>(request, headers); + response = restTemplate.exchange(url, httpMethod, entity, responseType); + } + logger.debug("response: ({})", response); + + if (response != null) { + logger.debug("response status code: ({})", response.getStatusCode()); + } else { + throw new ConfigRestAdaptorException("exchangeForEntity failed to perform "); + } + } + } catch (Exception e) { + throw new ConfigRestAdaptorException( + String.format("httpMethod (%s) for url (%s) resulted in Exception (%s)", httpMethod, url, e)); + } + return response; + } + + protected synchronized T processResponse(ResponseEntity response, String url, HttpMethod httpMethod) + throws ConfigRestAdaptorException { + if (response != null) { + if ((HttpMethod.DELETE == httpMethod && (response.getStatusCode() == HttpStatus.NO_CONTENT + || response.getStatusCode() == HttpStatus.NOT_FOUND)) + || ((HttpMethod.GET == httpMethod || HttpMethod.PUT == httpMethod || HttpMethod.POST == httpMethod) + && (response.getStatusCode() == HttpStatus.OK + || response.getStatusCode() == HttpStatus.CREATED))) { + return response.getBody(); + } + throw new ConfigRestAdaptorException( + String.format("Rest Operation is failed with response-code (%s) for the URL (%s)", + response.getStatusCode(), url)); + } + throw new ConfigRestAdaptorException(String.format("Rest Operation is failed for the URL (%s)", url)); + } + + protected synchronized String constructUrl(String baseUrl, String path) { + if (StringUtils.isNotBlank(path)) { + return baseUrl + path; + } else { + return baseUrl; + } + } + +} diff --git a/blueprints-processor/adaptors/rest-adaptor-provider/src/main/java/org/onap/ccsdk/config/rest/adaptor/service/ConfigRestAdaptorService.java b/blueprints-processor/adaptors/rest-adaptor-provider/src/main/java/org/onap/ccsdk/config/rest/adaptor/service/ConfigRestAdaptorService.java new file mode 100644 index 000000000..e15f4ae71 --- /dev/null +++ b/blueprints-processor/adaptors/rest-adaptor-provider/src/main/java/org/onap/ccsdk/config/rest/adaptor/service/ConfigRestAdaptorService.java @@ -0,0 +1,89 @@ +/* + * Copyright © 2017-2018 AT&T Intellectual Property. + * + * 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.ccsdk.config.rest.adaptor.service; + +import org.onap.ccsdk.config.rest.adaptor.ConfigRestAdaptorException; +import org.onap.ccsdk.config.rest.adaptor.data.RestResponse; + +public interface ConfigRestAdaptorService { + + /** + * Retrieve an entity by doing a GET on the specified URL. The response is converted and stored in + * defined responseType. + * + * @param selectorName the property selector + * @param path the URI path which will append in baseURL mentioned in selector property + * @param responseType the type of the return value + */ + public T getResource(String selectorName, String path, Class responseType) throws ConfigRestAdaptorException; + + /** + * Create a new resource by POSTing the given object to the URI template, and returns the response + * as defined responseType + * + * @param selectorName the property selector + * @param path the URI path which will append in baseURL mentioned in selector property + * @param request the Object to be POSTed, may be {@code null} + * @param responseType the type of the return value + */ + public T postResource(String selectorName, String path, Object request, Class responseType) + throws ConfigRestAdaptorException; + + /** + * Execute the HTTP method to the given URI template, writing the given request entity to the + * request, and returns the response as defined responseType + * + * @param selectorName the property selector + * @param path the URI path which will append in baseURL mentioned in selector property + * @param request the Object to be POSTed, may be {@code null} + * @param responseType the type of the return value + * @param method the HTTP method (GET, POST, etc) + */ + public T exchangeResource(String selectorName, String path, Object request, Class responseType, + String method) throws ConfigRestAdaptorException; + + /** + * Retrieve an entity by doing a GET on the specified URL. The response is converted and stored in + * defined responseType. + * + * @param selectorName the property selector + * @param path the URI path which will append in baseURL mentioned in selector property + */ + public RestResponse getResource(String selectorName, String path) throws ConfigRestAdaptorException; + + /** + * Create a new resource by POSTing the given object to the URI template, and returns the response + * as defined responseType + * + * @param selectorName the property selector + * @param path the URI path which will append in baseURL mentioned in selector property + * @param request the Object to be POSTed, may be {@code null} + */ + public RestResponse postResource(String selectorName, String path, Object request) + throws ConfigRestAdaptorException; + + /** + * Execute the HTTP method to the given URI template, writing the given request entity to the + * request, and returns the response as defined responseType + * + * @param selectorName the property selector + * @param path the URI path which will append in baseURL mentioned in selector property + * @param request the Object to be POSTed, may be {@code null} + * @param method the HTTP method (GET, POST, etc) + */ + public RestResponse exchangeResource(String selectorName, String path, Object request, String method) + throws ConfigRestAdaptorException; + +} diff --git a/blueprints-processor/adaptors/rest-adaptor-provider/src/main/java/org/onap/ccsdk/config/rest/adaptor/service/ConfigRestAdaptorServiceImpl.java b/blueprints-processor/adaptors/rest-adaptor-provider/src/main/java/org/onap/ccsdk/config/rest/adaptor/service/ConfigRestAdaptorServiceImpl.java new file mode 100644 index 000000000..b17ed2262 --- /dev/null +++ b/blueprints-processor/adaptors/rest-adaptor-provider/src/main/java/org/onap/ccsdk/config/rest/adaptor/service/ConfigRestAdaptorServiceImpl.java @@ -0,0 +1,142 @@ +/* + * Copyright © 2017-2018 AT&T Intellectual Property. + * + * 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.ccsdk.config.rest.adaptor.service; + +import java.io.File; +import java.io.FileInputStream; +import java.util.Map; +import java.util.Properties; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.Executors; +import java.util.concurrent.ScheduledExecutorService; +import java.util.concurrent.TimeUnit; +import java.util.stream.Collectors; +import org.apache.commons.lang3.StringUtils; +import org.onap.ccsdk.config.rest.adaptor.ConfigRestAdaptorConstants; +import org.onap.ccsdk.config.rest.adaptor.ConfigRestAdaptorException; +import org.onap.ccsdk.config.rest.adaptor.data.RestResponse; +import com.att.eelf.configuration.EELFLogger; +import com.att.eelf.configuration.EELFManager; + +public class ConfigRestAdaptorServiceImpl implements ConfigRestAdaptorService { + + private static EELFLogger logger = EELFManager.getInstance().getLogger(ConfigRestAdaptorServiceImpl.class); + private Map restProperties = new ConcurrentHashMap<>(); + + public ConfigRestAdaptorServiceImpl(String propertyPath) { + initializeProperties(propertyPath); + try { + String envType = restProperties.get(ConfigRestAdaptorConstants.REST_ADAPTOR_BASE_PROPERTY + + ConfigRestAdaptorConstants.REST_ADAPTOR_ENV_TYPE); + + if (!(ConfigRestAdaptorConstants.PROPERTY_ENV_PROD.equalsIgnoreCase(envType) + || ConfigRestAdaptorConstants.PROPERTY_ENV_SOLO.equalsIgnoreCase(envType))) { + ScheduledExecutorService executor = Executors.newScheduledThreadPool(1); + Runnable task = () -> { + initializeProperties(propertyPath); + }; + executor.scheduleWithFixedDelay(task, 60, 15, TimeUnit.MINUTES); + } + } catch (Exception e) { + logger.error(e.getMessage(), e); + } + } + + private void initializeProperties(String propertyPath) { + logger.trace("Initialising Config rest adaptor Service with property directory ({})", propertyPath); + try { + if (StringUtils.isBlank(propertyPath)) { + propertyPath = System.getProperty(ConfigRestAdaptorConstants.SDNC_ROOT_DIR_ENV_VAR_KEY); + } + + if (StringUtils.isBlank(propertyPath)) { + throw new ConfigRestAdaptorException( + String.format("Failed to get the property directory (%s)", propertyPath)); + } + + // Loading Default config-rest-adaptor.properties + String propertyFile = + propertyPath + File.separator + ConfigRestAdaptorConstants.REST_ADAPTOR_PROPERTIES_FILE_NAME; + + Properties properties = new Properties(); + properties.load(new FileInputStream(propertyFile)); + + logger.trace("Initializing properties details for property file ({}) properties ({})", propertyFile, + properties); + restProperties.putAll(properties.entrySet().stream() + .collect(Collectors.toMap(e -> e.getKey().toString(), e -> e.getValue().toString()))); + + } catch (Exception e) { + logger.error(e.getMessage(), e); + } + } + + @Override + public T getResource(String serviceSelector, String path, Class responseType) + throws ConfigRestAdaptorException { + return getRestClientAdapterBySelectorName(serviceSelector).getResource(path, responseType); + } + + @Override + public T postResource(String serviceSelector, String path, Object request, Class responseType) + throws ConfigRestAdaptorException { + return getRestClientAdapterBySelectorName(serviceSelector).postResource(path, request, responseType); + } + + @Override + public T exchangeResource(String serviceSelector, String path, Object request, Class responseType, + String method) throws ConfigRestAdaptorException { + return getRestClientAdapterBySelectorName(serviceSelector).exchangeResource(path, request, responseType, + method); + } + + @Override + public RestResponse getResource(String serviceSelector, String path) throws ConfigRestAdaptorException { + return getRestClientAdapterBySelectorName(serviceSelector).getResource(path); + } + + @Override + public RestResponse postResource(String serviceSelector, String path, Object request) + throws ConfigRestAdaptorException { + return getRestClientAdapterBySelectorName(serviceSelector).postResource(path, request); + } + + @Override + public RestResponse exchangeResource(String serviceSelector, String path, Object request, String method) + throws ConfigRestAdaptorException { + return getRestClientAdapterBySelectorName(serviceSelector).exchangeResource(path, request, method); + } + + private ConfigRestClientServiceAdapter getRestClientAdapterBySelectorName(String serviceSelector) + throws ConfigRestAdaptorException { + String adoptorType = restProperties.get(ConfigRestAdaptorConstants.REST_ADAPTOR_BASE_PROPERTY + serviceSelector + + ConfigRestAdaptorConstants.SERVICE_TYPE_PROPERTY); + if (StringUtils.isNotBlank(adoptorType)) { + if (ConfigRestAdaptorConstants.REST_ADAPTOR_TYPE_GENERIC.equalsIgnoreCase(adoptorType)) { + return new GenericRestClientAdapterImpl(restProperties, serviceSelector); + } else if (ConfigRestAdaptorConstants.REST_ADAPTOR_TYPE_SSL.equalsIgnoreCase(adoptorType)) { + return new SSLRestClientAdapterImpl(restProperties, serviceSelector); + } else { + throw new ConfigRestAdaptorException( + String.format("no implementation for rest adoptor type (%s) for the selector (%s).", + adoptorType, serviceSelector)); + } + } else { + throw new ConfigRestAdaptorException( + String.format("couldn't get rest adoptor type for the selector (%s)", serviceSelector)); + } + } + +} diff --git a/blueprints-processor/adaptors/rest-adaptor-provider/src/main/java/org/onap/ccsdk/config/rest/adaptor/service/ConfigRestClientServiceAdapter.java b/blueprints-processor/adaptors/rest-adaptor-provider/src/main/java/org/onap/ccsdk/config/rest/adaptor/service/ConfigRestClientServiceAdapter.java new file mode 100644 index 000000000..e1adb3814 --- /dev/null +++ b/blueprints-processor/adaptors/rest-adaptor-provider/src/main/java/org/onap/ccsdk/config/rest/adaptor/service/ConfigRestClientServiceAdapter.java @@ -0,0 +1,35 @@ +/* + * Copyright © 2017-2018 AT&T Intellectual Property. + * + * 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.ccsdk.config.rest.adaptor.service; + +import org.onap.ccsdk.config.rest.adaptor.ConfigRestAdaptorException; +import org.onap.ccsdk.config.rest.adaptor.data.RestResponse; + +interface ConfigRestClientServiceAdapter { + + public T getResource(String path, Class responseType) throws ConfigRestAdaptorException; + + public T postResource(String path, Object request, Class responseType) throws ConfigRestAdaptorException; + + public T exchangeResource(String path, Object request, Class responseType, String method) + throws ConfigRestAdaptorException; + + public RestResponse getResource(String path) throws ConfigRestAdaptorException; + + public RestResponse postResource(String path, Object request) throws ConfigRestAdaptorException; + + public RestResponse exchangeResource(String path, Object request, String method) throws ConfigRestAdaptorException; + +} diff --git a/blueprints-processor/adaptors/rest-adaptor-provider/src/main/java/org/onap/ccsdk/config/rest/adaptor/service/GenericRestClientAdapterImpl.java b/blueprints-processor/adaptors/rest-adaptor-provider/src/main/java/org/onap/ccsdk/config/rest/adaptor/service/GenericRestClientAdapterImpl.java new file mode 100644 index 000000000..55cdca40b --- /dev/null +++ b/blueprints-processor/adaptors/rest-adaptor-provider/src/main/java/org/onap/ccsdk/config/rest/adaptor/service/GenericRestClientAdapterImpl.java @@ -0,0 +1,136 @@ +/* + * Copyright © 2017-2018 AT&T Intellectual Property. + * + * 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.ccsdk.config.rest.adaptor.service; + +import java.util.Map; +import java.util.UUID; +import org.apache.commons.lang3.StringUtils; +import org.onap.ccsdk.config.rest.adaptor.ConfigRestAdaptorConstants; +import org.onap.ccsdk.config.rest.adaptor.ConfigRestAdaptorException; +import org.onap.ccsdk.config.rest.adaptor.data.RestResponse; +import org.springframework.http.HttpHeaders; +import org.springframework.http.MediaType; +import com.att.eelf.configuration.EELFLogger; +import com.att.eelf.configuration.EELFManager; + +public class GenericRestClientAdapterImpl extends AbstractConfigRestClientAdapter { + + private static EELFLogger logger = EELFManager.getInstance().getLogger(GenericRestClientAdapterImpl.class); + private String baseUrl = ""; + + public GenericRestClientAdapterImpl(Map properties, String serviceSelector) + throws ConfigRestAdaptorException { + super(properties, serviceSelector); + init(serviceSelector); + } + + private void init(String serviceSelector) throws ConfigRestAdaptorException { + try { + if (isRestClientServiceAdapaterEnabled) { + String baseUrlProperty = ConfigRestAdaptorConstants.REST_ADAPTOR_BASE_PROPERTY + serviceSelector + + ConfigRestAdaptorConstants.SERVICE_BASEURL_PROPERTY; + String userProperty = ConfigRestAdaptorConstants.REST_ADAPTOR_BASE_PROPERTY + serviceSelector + + ConfigRestAdaptorConstants.SERVICE_USER_PROPERTY; + String passProperty = ConfigRestAdaptorConstants.REST_ADAPTOR_BASE_PROPERTY + serviceSelector + + ConfigRestAdaptorConstants.SERVICE_PSSWD_PROPERTY; + + baseUrl = properties.get(baseUrlProperty); + String userId = properties.get(userProperty); + String pass = properties.get(passProperty); + + initialise(userId, pass); + logger.info("Initialised restconf adaptor service for selector ({})", serviceSelector); + if (restTemplate == null) { + throw new ConfigRestAdaptorException("couldn't initialise rest selector (" + serviceSelector + ")"); + } + } else { + throw new ConfigRestAdaptorException("rest selector (" + serviceSelector + ") is not enabled"); + } + + } catch (Exception e) { + throw new ConfigRestAdaptorException("GenericRestClientServiceAdapter : " + e.getMessage(), e); + } + } + + @Override + public T getResource(String path, Class responseType) throws ConfigRestAdaptorException { + return super.getResource(formHttpHeaders(), constructUrl(baseUrl, path), responseType); + } + + @Override + public T postResource(String path, Object request, Class responseType) throws ConfigRestAdaptorException { + return super.postResource(formHttpHeaders(), constructUrl(baseUrl, path), request, responseType); + } + + @Override + public T exchangeResource(String path, Object request, Class responseType, String method) + throws ConfigRestAdaptorException { + return super.exchangeResource(formHttpHeaders(), constructUrl(baseUrl, path), request, responseType, method); + } + + @Override + public RestResponse getResource(String path) throws ConfigRestAdaptorException { + return super.getResource(formHttpHeaders(), constructUrl(baseUrl, path)); + } + + @Override + public RestResponse postResource(String path, Object request) throws ConfigRestAdaptorException { + return super.postResource(formHttpHeaders(), constructUrl(baseUrl, path), request); + } + + @Override + public RestResponse exchangeResource(String path, Object request, String method) throws ConfigRestAdaptorException { + return super.exchangeResource(formHttpHeaders(), constructUrl(baseUrl, path), request, method); + } + + private HttpHeaders formHttpHeaders() { + + HttpHeaders headers = new HttpHeaders(); + + headers.setContentType(MediaType.APPLICATION_JSON); + headers.add("Accept", MediaType.APPLICATION_JSON_VALUE); + headers.add("X-TransactionId", generateUUID()); + headers.add("X-ECOMP-RequestID", headers.getFirst("X-TransactionId")); + + String appIDPath = ConfigRestAdaptorConstants.REST_ADAPTOR_BASE_PROPERTY + serviceSelector + + ConfigRestAdaptorConstants.SERVICE_APPID_PROPERTY; + String environmentPath = ConfigRestAdaptorConstants.REST_ADAPTOR_BASE_PROPERTY + serviceSelector + + ConfigRestAdaptorConstants.SERVICE_ENV_PROPERTY; + String clientAuthPath = ConfigRestAdaptorConstants.REST_ADAPTOR_BASE_PROPERTY + serviceSelector + + ConfigRestAdaptorConstants.SERVICE_CLIENTAUTH_PROPERTY; + String authorizationPath = ConfigRestAdaptorConstants.REST_ADAPTOR_BASE_PROPERTY + serviceSelector + + ConfigRestAdaptorConstants.SERVICE_AUTHORIZATION_PROPERTY; + + if (StringUtils.isNotBlank(properties.get(appIDPath))) { + headers.add("X-FromAppId", properties.get(appIDPath)); + } + if (StringUtils.isNotBlank(properties.get(clientAuthPath))) { + headers.add("ClientAuth", properties.get(clientAuthPath)); + } + if (StringUtils.isNotBlank(properties.get(authorizationPath))) { + headers.add("Authorization", properties.get(authorizationPath)); + } + if (StringUtils.isNotBlank(properties.get(environmentPath))) { + headers.add("Environment", properties.get(environmentPath)); + } + + return headers; + } + + private synchronized String generateUUID() { + return UUID.randomUUID().toString(); + } + +} diff --git a/blueprints-processor/adaptors/rest-adaptor-provider/src/main/java/org/onap/ccsdk/config/rest/adaptor/service/SSLRestClientAdapterImpl.java b/blueprints-processor/adaptors/rest-adaptor-provider/src/main/java/org/onap/ccsdk/config/rest/adaptor/service/SSLRestClientAdapterImpl.java new file mode 100644 index 000000000..7d31b812e --- /dev/null +++ b/blueprints-processor/adaptors/rest-adaptor-provider/src/main/java/org/onap/ccsdk/config/rest/adaptor/service/SSLRestClientAdapterImpl.java @@ -0,0 +1,127 @@ +/* + * Copyright © 2017-2018 AT&T Intellectual Property. + * + * 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.ccsdk.config.rest.adaptor.service; + +import java.util.Map; +import java.util.UUID; +import org.onap.ccsdk.config.rest.adaptor.ConfigRestAdaptorConstants; +import org.onap.ccsdk.config.rest.adaptor.ConfigRestAdaptorException; +import org.onap.ccsdk.config.rest.adaptor.data.RestResponse; +import org.springframework.http.HttpHeaders; +import org.springframework.http.MediaType; +import com.att.eelf.configuration.EELFLogger; +import com.att.eelf.configuration.EELFManager; + +public class SSLRestClientAdapterImpl extends AbstractConfigRestClientAdapter { + + private static EELFLogger logger = EELFManager.getInstance().getLogger(SSLRestClientAdapterImpl.class); + private String baseUrl = ""; + private String application = ""; + + public SSLRestClientAdapterImpl(Map properties, String serviceSelector) + throws ConfigRestAdaptorException { + super(properties, serviceSelector); + init(serviceSelector); + } + + private void init(String serviceSelector) throws ConfigRestAdaptorException { + try { + if (isSSLServiceAdapaterEnabled) { + + logger.info("Initializing SSL client for selector ({}), properties ({})", serviceSelector, properties); + + String baseUrlProp = ConfigRestAdaptorConstants.REST_ADAPTOR_BASE_PROPERTY + serviceSelector + + ConfigRestAdaptorConstants.SSL_SERVICE_BASEURL; + String applicationProp = ConfigRestAdaptorConstants.REST_ADAPTOR_BASE_PROPERTY + serviceSelector + + ConfigRestAdaptorConstants.SSL_SERVICE_APP; + String keyStorePathProp = ConfigRestAdaptorConstants.REST_ADAPTOR_BASE_PROPERTY + serviceSelector + + ConfigRestAdaptorConstants.SSL_SERVICE_KEY; + String keyStorePassProp = ConfigRestAdaptorConstants.REST_ADAPTOR_BASE_PROPERTY + serviceSelector + + ConfigRestAdaptorConstants.SSL_SERVICE_KEY_PSSWD; + String trustStorePathProp = ConfigRestAdaptorConstants.REST_ADAPTOR_BASE_PROPERTY + serviceSelector + + ConfigRestAdaptorConstants.SSL_SERVICE_TRUST; + String trustStorePassProp = ConfigRestAdaptorConstants.REST_ADAPTOR_BASE_PROPERTY + serviceSelector + + ConfigRestAdaptorConstants.SSL_SERVICE_TRUST_PSSWD; + + baseUrl = properties.get(baseUrlProp); + application = properties.get(applicationProp); + + String keyStorePath = properties.get(keyStorePathProp); + String trustStorePath = properties.get(trustStorePathProp); + String keyStorePass = properties.get(keyStorePassProp); + String trustStorePass = properties.get(trustStorePassProp); + + initialiseSSL(keyStorePath, trustStorePath, keyStorePass, trustStorePass); + logger.info("Initialised SSL Client Service adaptor service for selector ({})", serviceSelector); + if (restTemplate == null) { + throw new ConfigRestAdaptorException( + "couldn't initialise SSL Client selector (" + serviceSelector + ")"); + } + } else { + throw new ConfigRestAdaptorException("SSL Client selector (" + serviceSelector + ") is not enabled"); + } + + } catch (Exception e) { + throw new ConfigRestAdaptorException("SSLRestClientAdapterImpl : " + e.getMessage(), e); + } + } + + @Override + public T getResource(String path, Class responseType) throws ConfigRestAdaptorException { + return super.getResource(formHttpHeaders(), constructUrl(baseUrl, path), responseType); + } + + @Override + public T postResource(String path, Object request, Class responseType) throws ConfigRestAdaptorException { + return super.postResource(formHttpHeaders(), constructUrl(baseUrl, path), request, responseType); + } + + @Override + public T exchangeResource(String path, Object request, Class responseType, String method) + throws ConfigRestAdaptorException { + return super.exchangeResource(formHttpHeaders(), constructUrl(baseUrl, path), request, responseType, method); + } + + @Override + public RestResponse getResource(String path) throws ConfigRestAdaptorException { + return super.getResource(formHttpHeaders(), constructUrl(baseUrl, path)); + } + + @Override + public RestResponse postResource(String path, Object request) throws ConfigRestAdaptorException { + return super.postResource(formHttpHeaders(), constructUrl(baseUrl, path), request); + } + + @Override + public RestResponse exchangeResource(String path, Object request, String method) throws ConfigRestAdaptorException { + return super.exchangeResource(formHttpHeaders(), constructUrl(baseUrl, path), request, method); + } + + private HttpHeaders formHttpHeaders() { + + HttpHeaders headers = new HttpHeaders(); + + headers.setContentType(MediaType.APPLICATION_JSON); + headers.add("Accept", MediaType.APPLICATION_JSON_VALUE); + headers.add("X-FromAppId", application); + headers.add("X-TransactionId", generateUUID()); + + return headers; + } + + private synchronized String generateUUID() { + return UUID.randomUUID().toString(); + } +} diff --git a/blueprints-processor/adaptors/rest-adaptor-provider/src/main/java/org/onap/ccsdk/config/rest/adaptor/utils/BasicAuthorizationInterceptor.java b/blueprints-processor/adaptors/rest-adaptor-provider/src/main/java/org/onap/ccsdk/config/rest/adaptor/utils/BasicAuthorizationInterceptor.java new file mode 100644 index 000000000..bc486f4de --- /dev/null +++ b/blueprints-processor/adaptors/rest-adaptor-provider/src/main/java/org/onap/ccsdk/config/rest/adaptor/utils/BasicAuthorizationInterceptor.java @@ -0,0 +1,53 @@ +/* + * Copyright © 2017-2018 AT&T Intellectual Property. + * + * 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.ccsdk.config.rest.adaptor.utils; + +import java.io.IOException; +import java.nio.charset.Charset; +import org.springframework.http.HttpRequest; +import org.springframework.http.client.ClientHttpRequestExecution; +import org.springframework.http.client.ClientHttpRequestInterceptor; +import org.springframework.http.client.ClientHttpResponse; +import org.springframework.util.Assert; +import org.springframework.util.Base64Utils; + +public class BasicAuthorizationInterceptor implements ClientHttpRequestInterceptor { + private static final Charset UTF_8 = Charset.forName("UTF-8"); + + private final String username; + + private final String pass; + + /** + * Create a new interceptor which adds a BASIC authorization header for the given username and pass. + * + * @param username the username to use + * @param pass the password to use + */ + public BasicAuthorizationInterceptor(String username, String pass) { + Assert.hasLength(username, "Username must not be empty"); + this.username = username; + this.pass = (pass != null ? pass : ""); + } + + @Override + public ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution) + throws IOException { + + String token = Base64Utils.encodeToString((this.username + ":" + this.pass).getBytes(UTF_8)); + request.getHeaders().add("Authorization", "Basic " + token); + return execution.execute(request, body); + } +} diff --git a/blueprints-processor/adaptors/rest-adaptor-provider/src/main/java/org/onap/ccsdk/config/rest/adaptor/utils/LoggingRequestInterceptor.java b/blueprints-processor/adaptors/rest-adaptor-provider/src/main/java/org/onap/ccsdk/config/rest/adaptor/utils/LoggingRequestInterceptor.java new file mode 100644 index 000000000..0fcc4654e --- /dev/null +++ b/blueprints-processor/adaptors/rest-adaptor-provider/src/main/java/org/onap/ccsdk/config/rest/adaptor/utils/LoggingRequestInterceptor.java @@ -0,0 +1,68 @@ +/* + * Copyright © 2017-2018 AT&T Intellectual Property. + * + * 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.ccsdk.config.rest.adaptor.utils; + +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; +import org.springframework.http.HttpRequest; +import org.springframework.http.client.ClientHttpRequestExecution; +import org.springframework.http.client.ClientHttpRequestInterceptor; +import org.springframework.http.client.ClientHttpResponse; +import com.att.eelf.configuration.EELFLogger; +import com.att.eelf.configuration.EELFManager; + +public class LoggingRequestInterceptor implements ClientHttpRequestInterceptor { + + private static EELFLogger logger = EELFManager.getInstance().getLogger(LoggingRequestInterceptor.class); + + @Override + public ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution) + throws IOException { + traceRequest(request, body); + ClientHttpResponse response = execution.execute(request, body); + traceResponse(response); + return response; + } + + @SuppressWarnings({"squid:S2629", "squid:S3457"}) + private void traceRequest(HttpRequest request, byte[] body) throws IOException { + logger.info("===========================request begin================================================"); + logger.info("URI : {}", request.getURI()); + logger.info("Method : {}", request.getMethod()); + logger.info("Headers : {}", request.getHeaders()); + logger.info("Request body: {}", new String(body, "UTF-8")); + logger.debug("==========================request end================================================"); + } + + @SuppressWarnings({"squid:S2629", "squid:S3457"}) + private void traceResponse(ClientHttpResponse response) throws IOException { + StringBuilder inputStringBuilder = new StringBuilder(); + BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(response.getBody(), "UTF-8")); + String line = bufferedReader.readLine(); + while (line != null) { + inputStringBuilder.append(line); + inputStringBuilder.append('\n'); + line = bufferedReader.readLine(); + } + logger.info("============================response begin=========================================="); + logger.info("Status code : {}", response.getStatusCode()); + logger.info("Status text : {}", response.getStatusText()); + logger.info("Headers : {}", response.getHeaders()); + logger.debug("Response body: {}", inputStringBuilder.toString()); + logger.debug("=======================response end================================================="); + } + +} diff --git a/blueprints-processor/adaptors/rest-adaptor-provider/src/main/resources/org/opendaylight/blueprint/impl-blueprint.xml b/blueprints-processor/adaptors/rest-adaptor-provider/src/main/resources/org/opendaylight/blueprint/impl-blueprint.xml new file mode 100644 index 000000000..e6b26944d --- /dev/null +++ b/blueprints-processor/adaptors/rest-adaptor-provider/src/main/resources/org/opendaylight/blueprint/impl-blueprint.xml @@ -0,0 +1,32 @@ + + + + + + + + + + + + + + -- cgit 1.2.3-korg