Merge "Removed dependency from lombok"

6 files changed, 113 insertions, 88 deletions

diff --git a/vid-app-common/pom.xml b/vid-app-common/pom.xml
index 72f50ac47..ddb4bb940 100755
--- a/vid-app-common/pom.xml
+++ b/vid-app-common/pom.xml
@@ -307,12 +307,6 @@
 

 		<!-- Helpers -->

 		<dependency>

-			<groupId>org.projectlombok</groupId>

-			<artifactId>lombok</artifactId>

-			<version>1.18.2</version>

-			<scope>provided</scope>

-		</dependency>

-		<dependency>

 			<groupId>io.vavr</groupId>

 			<artifactId>vavr</artifactId>

 			<version>0.9.2</version>

diff --git a/vid-app-common/src/main/java/org/onap/vid/aai/AaiOverTLSClient.java b/vid-app-common/src/main/java/org/onap/vid/aai/AaiOverTLSClient.java
index 4f98bd37c..6e25e2715 100644
--- a/vid-app-common/src/main/java/org/onap/vid/aai/AaiOverTLSClient.java
+++ b/vid-app-common/src/main/java/org/onap/vid/aai/AaiOverTLSClient.java
@@ -33,7 +33,6 @@ import java.util.Base64;
 import java.util.Collections;
 import java.util.Map;
 import javax.ws.rs.core.MediaType;
-import lombok.val;
 import org.onap.portalsdk.core.util.SystemProperties;
 import org.onap.vid.aai.model.AaiNodeQueryResponse;
 import org.onap.vid.aai.model.ResourceType;
@@ -46,7 +45,7 @@ public class AaiOverTLSClient implements AaiOverTLSClientInterface {
     private final AaiOverTLSPropertySupplier propertySupplier;
     private SyncRestClientInterface syncRestClient;
     private boolean useClientCert;
-    private static String CALLER_APP_ID = "VidAaiController";
+    private static final String CALLER_APP_ID = "VidAaiController";
     private String urlBase;
 
     public AaiOverTLSClient(SyncRestClientInterface syncRestClient, AaiOverTLSPropertySupplier propertySupplier) {
@@ -66,34 +65,34 @@ public class AaiOverTLSClient implements AaiOverTLSClientInterface {
 
     @Override
     public HttpResponse<AaiNodeQueryResponse> searchNodeTypeByName(String name, ResourceType type) {
-        val uri = urlBase + String.format(URIS.NODE_TYPE_BY_NAME, type.getAaiFormat(), type.getNameFilter(), name);
+        String uri = urlBase + String.format(URIS.NODE_TYPE_BY_NAME, type.getAaiFormat(), type.getNameFilter(), name);
         return syncRestClient.get(uri, getRequestHeaders(), Collections.emptyMap(), AaiNodeQueryResponse.class);
     }
 
     @Override
     public HttpResponse<SubscriberList> getAllSubscribers() {
-        val uri = urlBase + String.format(URIS.SUBSCRIBERS, 0);
+        String uri = urlBase + String.format(URIS.SUBSCRIBERS, 0);
         return syncRestClient.get(uri, getRequestHeaders(), Collections.emptyMap(), SubscriberList.class);
     }
 
     private Map<String, String> getRequestHeaders() {
-        val result = HashMap.of(
-            TRANSACTION_ID_HEADER, propertySupplier.getRandomUUID(),
-            FROM_APP_ID_HEADER, CALLER_APP_ID,
-            CONTENT_TYPE, MediaType.APPLICATION_JSON,
-            REQUEST_ID, propertySupplier.getRequestId(),
-            ACCEPT, MediaType.APPLICATION_JSON)
-            .toJavaMap();
+        Map<String, String> result = HashMap.of(
+                TRANSACTION_ID_HEADER, propertySupplier.getRandomUUID(),
+                FROM_APP_ID_HEADER, CALLER_APP_ID,
+                CONTENT_TYPE, MediaType.APPLICATION_JSON,
+                REQUEST_ID, propertySupplier.getRequestId(),
+                ACCEPT, MediaType.APPLICATION_JSON)
+                .toJavaMap();
         result.putAll(getAuthorizationHeader());
         return result;
     }
 
     private Map<String, String> getAuthorizationHeader() {
         if (!useClientCert) {
-            val vidUsername = propertySupplier.getUsername();
-            val vidPassword = propertySupplier.getPassword();
-            val encoded = Base64.getEncoder()
-                .encodeToString((vidUsername + ":" + vidPassword).getBytes(StandardCharsets.UTF_8));
+            String vidUsername = propertySupplier.getUsername();
+            String vidPassword = propertySupplier.getPassword();
+            String encoded = Base64.getEncoder()
+                    .encodeToString((vidUsername + ":" + vidPassword).getBytes(StandardCharsets.UTF_8));
             return HashMap.of("Authorization", "Basic " + encoded).toJavaMap();
         }
         return HashMap.<String, String>empty().toJavaMap();
diff --git a/vid-app-common/src/main/java/org/onap/vid/client/SyncRestClient.java b/vid-app-common/src/main/java/org/onap/vid/client/SyncRestClient.java
index a3ff5f923..9e50c4456 100644
--- a/vid-app-common/src/main/java/org/onap/vid/client/SyncRestClient.java
+++ b/vid-app-common/src/main/java/org/onap/vid/client/SyncRestClient.java
@@ -25,42 +25,33 @@ import io.joshworks.restclient.http.JsonNode;
 import io.joshworks.restclient.http.RestClient;
 import io.joshworks.restclient.http.exceptions.RestClientException;
 import io.joshworks.restclient.http.mapper.ObjectMapper;
-import org.apache.http.impl.client.CloseableHttpClient;
-import org.onap.portalsdk.core.logging.logic.EELFLoggerDelegate;
+import io.joshworks.restclient.request.GetRequest;
 import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
+import org.apache.http.conn.ssl.SSLContexts;
 import org.apache.http.conn.ssl.TrustSelfSignedStrategy;
-import org.eclipse.jetty.util.security.Password;
+import org.apache.http.impl.client.CloseableHttpClient;
 import org.apache.http.impl.client.HttpClients;
-import org.apache.http.conn.ssl.SSLContexts;
-import io.vavr.CheckedFunction1;
-import lombok.SneakyThrows;
-import lombok.val;
+import org.eclipse.jetty.util.security.Password;
+import org.onap.portalsdk.core.logging.logic.EELFLoggerDelegate;
+import org.onap.portalsdk.core.util.SystemProperties;
+import org.onap.vid.properties.VidProperties;
 
-import java.security.UnrecoverableKeyException;
-import java.security.NoSuchAlgorithmException;
-import java.security.KeyManagementException;
-import java.security.cert.CertificateException;
-import javax.net.ssl.SSLException;
-import java.security.KeyStoreException;
-import java.text.SimpleDateFormat;
 import javax.net.ssl.SSLContext;
+import javax.net.ssl.SSLException;
+import java.io.File;
 import java.io.FileInputStream;
-import java.security.KeyStore;
-import java.text.DateFormat;
-import java.io.InputStream;
 import java.io.IOException;
-import java.util.Date;
+import java.io.InputStream;
+import java.security.KeyManagementException;
+import java.security.KeyStore;
+import java.security.KeyStoreException;
+import java.security.NoSuchAlgorithmException;
+import java.security.UnrecoverableKeyException;
+import java.security.cert.CertificateException;
 import java.util.Map;
-import java.io.File;
-import org.onap.portalsdk.core.util.SystemProperties;
-import org.onap.vid.properties.VidProperties;
 
 public class SyncRestClient implements SyncRestClientInterface {
-
-    private static final String CANNOT_INITIALIZE_CUSTOM_HTTP_CLIENT = "Cannot initialize custom http client from current configuration. Using default one.";
-    private static final String TRY_TO_CALL_OVER_HTTP = "SSL Handshake problem occured. Will try to retry over Http.";
     private static final EELFLoggerDelegate logger = EELFLoggerDelegate.getLogger(SyncRestClient.class);
-    private static final DateFormat DATE_FORMAT = new SimpleDateFormat("HH:mm:ss:SSSS");
     private static final String[] SUPPORTED_SSL_VERSIONS = {"TLSv1", "TLSv1.2"};
     private static final String HTTPS_SCHEMA = "https://";
     private static final String HTTP_SCHEMA = "http://";
@@ -91,13 +82,13 @@ public class SyncRestClient implements SyncRestClientInterface {
     @Override
     public <T> HttpResponse<T> post(String url, Map<String, String> headers, Object body, Class<T> responseClass) {
         return callWithRetryOverHttp(url,
-            url2 -> restClient.post(url2).headers(headers).body(body).asObject(responseClass));
+                url2 -> restClient.post(url2).headers(headers).body(body).asObject(responseClass));
     }
 
     @Override
     public HttpResponse<JsonNode> get(String url, Map<String, String> headers, Map<String, String> routeParams) {
         return callWithRetryOverHttp(url, url2 -> {
-            val getRequest = restClient.get(url2).headers(headers);
+            GetRequest getRequest = restClient.get(url2).headers(headers);
             routeParams.forEach(getRequest::routeParam);
             return getRequest.asJson();
         });
@@ -105,9 +96,9 @@ public class SyncRestClient implements SyncRestClientInterface {
 
     @Override
     public <T> HttpResponse<T> get(String url, Map<String, String> headers, Map<String, String> routeParams,
-        Class<T> responseClass) {
+                                   Class<T> responseClass) {
         return callWithRetryOverHttp(url, url2 -> {
-            val getRequest = restClient.get(url2).headers(headers);
+            GetRequest getRequest = restClient.get(url2).headers(headers);
             routeParams.forEach(getRequest::routeParam);
             return getRequest.asObject(responseClass);
         });
@@ -115,9 +106,9 @@ public class SyncRestClient implements SyncRestClientInterface {
 
     @Override
     public HttpResponse<InputStream> getStream(String url, Map<String, String> headers,
-        Map<String, String> routeParams) {
+                                               Map<String, String> routeParams) {
         return callWithRetryOverHttp(url, url2 -> {
-            val getRequest = restClient.get(url2).headers(headers);
+            GetRequest getRequest = restClient.get(url2).headers(headers);
             routeParams.forEach(getRequest::routeParam);
             return getRequest.asBinary();
         });
@@ -131,7 +122,7 @@ public class SyncRestClient implements SyncRestClientInterface {
     @Override
     public <T> HttpResponse<T> put(String url, Map<String, String> headers, Object body, Class<T> responseClass) {
         return callWithRetryOverHttp(url,
-            url2 -> restClient.put(url2).headers(headers).body(body).asObject(responseClass));
+                url2 -> restClient.put(url2).headers(headers).body(body).asObject(responseClass));
     }
 
     @Override
@@ -154,81 +145,100 @@ public class SyncRestClient implements SyncRestClientInterface {
         restClient.shutdown();
     }
 
-    @SneakyThrows
-    private <T> HttpResponse<T> callWithRetryOverHttp(String url,
-                                                      CheckedFunction1<String, HttpResponse<T>> httpRequest) {
+    private <T> HttpResponse<T> callWithRetryOverHttp(String url, HttpRequest<T> httpRequest) {
+        try {
+            return callWithRetryOverHttpThrows(url, httpRequest);
+        } catch (IOException e) {
+            throw new SyncRestClientException("IOException while calling rest service", e);
+        }
+    }
+
+    private <T> HttpResponse<T> callWithRetryOverHttpThrows(String url, HttpRequest<T> httpRequest) throws IOException {
         try {
             return httpRequest.apply(url);
         } catch (RestClientException e) {
-            if (e.getCause() instanceof SSLException) {
-                logger.warn(EELFLoggerDelegate.debugLogger,
-                        DATE_FORMAT.format(new Date()) + TRY_TO_CALL_OVER_HTTP, e);
+            if (causedBySslHandshakeError(e)) {
+                logger.warn(EELFLoggerDelegate.debugLogger, "SSL Handshake problem occured. Will try to retry over Http.", e);
                 return httpRequest.apply(url.replaceFirst(HTTPS_SCHEMA, HTTP_SCHEMA));
             }
             throw e;
         }
     }
 
+    private boolean causedBySslHandshakeError(RestClientException exception) {
+        return exception.getCause() instanceof SSLException;
+    }
+
     private ObjectMapper defaultObjectMapper() {
-        val objectMapper = new org.codehaus.jackson.map.ObjectMapper();
+        org.codehaus.jackson.map.ObjectMapper objectMapper = new org.codehaus.jackson.map.ObjectMapper();
 
         return new ObjectMapper() {
             @Override
-            @SneakyThrows
             public <T> T readValue(String value, Class<T> aClass) {
-                return objectMapper.readValue(value, aClass);
+                try {
+                    return objectMapper.readValue(value, aClass);
+                } catch (IOException e) {
+                    throw new SyncRestClientException("IOException while reading value", e);
+                }
             }
 
             @Override
-            @SneakyThrows
             public String writeValue(Object value) {
-                return objectMapper.writeValueAsString(value);
+                try {
+                    return objectMapper.writeValueAsString(value);
+                } catch (IOException e) {
+                    throw new SyncRestClientException("IOException while writing value", e);
+                }
             }
         };
     }
 
     private CloseableHttpClient defaultHttpClient() {
         try {
-            val trustStorePath = SystemProperties.getProperty(VidProperties.VID_TRUSTSTORE_FILENAME);
-            val trustStorePass = SystemProperties.getProperty(VidProperties.VID_TRUSTSTORE_PASSWD_X);
-            val decryptedTrustStorePass = Password.deobfuscate(trustStorePass);
+            String trustStorePath = SystemProperties.getProperty(VidProperties.VID_TRUSTSTORE_FILENAME);
+            String trustStorePass = SystemProperties.getProperty(VidProperties.VID_TRUSTSTORE_PASSWD_X);
+            String decryptedTrustStorePass = Password.deobfuscate(trustStorePass);
 
-            val trustStore = loadTruststore(trustStorePath, decryptedTrustStorePass);
-            val sslContext = trustOwnCACerts(decryptedTrustStorePass, trustStore);
-            val sslSf = allowTLSProtocols(sslContext);
+            KeyStore trustStore = loadTruststore(trustStorePath, decryptedTrustStorePass);
+            SSLContext sslContext = trustOwnCACerts(decryptedTrustStorePass, trustStore);
+            SSLConnectionSocketFactory sslSf = allowTLSProtocols(sslContext);
 
             return HttpClients.custom().setSSLSocketFactory(sslSf).build();
         } catch (IOException | CertificateException | UnrecoverableKeyException | NoSuchAlgorithmException | KeyStoreException | KeyManagementException e) {
-            logger.warn(EELFLoggerDelegate.debugLogger,
-                DATE_FORMAT.format(new Date()) + CANNOT_INITIALIZE_CUSTOM_HTTP_CLIENT, e);
+            logger.warn(EELFLoggerDelegate.debugLogger, "Cannot initialize custom http client from current configuration. Using default one.", e);
             return HttpClients.createDefault();
         }
     }
 
     private SSLConnectionSocketFactory allowTLSProtocols(SSLContext sslcontext) {
         return new SSLConnectionSocketFactory(
-            sslcontext,
-            SUPPORTED_SSL_VERSIONS,
-            null,
-            SSLConnectionSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
+                sslcontext,
+                SUPPORTED_SSL_VERSIONS,
+                null,
+                SSLConnectionSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
     }
 
     private SSLContext trustOwnCACerts(String trustStorePass, KeyStore trustStore)
-        throws NoSuchAlgorithmException, KeyManagementException, KeyStoreException, UnrecoverableKeyException {
+            throws NoSuchAlgorithmException, KeyManagementException, KeyStoreException, UnrecoverableKeyException {
         return SSLContexts.custom()
-            .useTLS()
-            .loadKeyMaterial(trustStore, trustStorePass.toCharArray())
-            .loadTrustMaterial(trustStore, new TrustSelfSignedStrategy())
-            .build();
+                .useTLS()
+                .loadKeyMaterial(trustStore, trustStorePass.toCharArray())
+                .loadTrustMaterial(trustStore, new TrustSelfSignedStrategy())
+                .build();
     }
 
     private KeyStore loadTruststore(String trustStorePath, String trustStorePass)
-        throws KeyStoreException, IOException, NoSuchAlgorithmException, CertificateException {
-        val trustStore = KeyStore.getInstance(KeyStore.getDefaultType());
+            throws KeyStoreException, IOException, NoSuchAlgorithmException, CertificateException {
+        KeyStore trustStore = KeyStore.getInstance(KeyStore.getDefaultType());
         try (FileInputStream instream = new FileInputStream(new File(trustStorePath))) {
             trustStore.load(instream, trustStorePass.toCharArray());
         }
         return trustStore;
     }
 
+    @FunctionalInterface
+    private interface HttpRequest<T> {
+        HttpResponse<T> apply(String url) throws IOException;
+    }
+
 }
diff --git a/vid-app-common/src/main/java/org/onap/vid/client/SyncRestClientException.java b/vid-app-common/src/main/java/org/onap/vid/client/SyncRestClientException.java
new file mode 100644
index 000000000..2a4f093b1
--- /dev/null
+++ b/vid-app-common/src/main/java/org/onap/vid/client/SyncRestClientException.java
@@ -0,0 +1,7 @@
+package org.onap.vid.client;
+
+public class SyncRestClientException extends RuntimeException {
+    public SyncRestClientException(String message, Throwable cause) {
+        super(message, cause);
+    }
+}
diff --git a/vid-app-common/src/main/java/org/onap/vid/mso/MsoException.java b/vid-app-common/src/main/java/org/onap/vid/mso/MsoException.java
new file mode 100644
index 000000000..02d54c354
--- /dev/null
+++ b/vid-app-common/src/main/java/org/onap/vid/mso/MsoException.java
@@ -0,0 +1,7 @@
+package org.onap.vid.mso;
+
+public class MsoException extends RuntimeException {
+    public MsoException(Throwable cause) {
+        super(cause);
+    }
+}
diff --git a/vid-app-common/src/main/java/org/onap/vid/mso/MsoInterface.java b/vid-app-common/src/main/java/org/onap/vid/mso/MsoInterface.java
index 834f80885..7c8ab89c1 100644
--- a/vid-app-common/src/main/java/org/onap/vid/mso/MsoInterface.java
+++ b/vid-app-common/src/main/java/org/onap/vid/mso/MsoInterface.java
@@ -20,13 +20,15 @@
  */
 package org.onap.vid.mso;
 
+import com.fasterxml.jackson.core.JsonProcessingException;
 import io.joshworks.restclient.http.HttpResponse;
 import io.joshworks.restclient.http.mapper.ObjectMapper;
-import lombok.SneakyThrows;
 import org.onap.vid.aai.util.CustomJacksonJaxBJsonProvider;
 import org.onap.vid.changeManagement.RequestDetailsWrapper;
 import org.onap.vid.mso.rest.RequestDetails;
 
+import java.io.IOException;
+
 /**
  * Created by pickjonathan on 21/06/2017.
  */
@@ -123,16 +125,22 @@ public interface MsoInterface {
       return new ObjectMapper() {
         CustomJacksonJaxBJsonProvider mapper = new CustomJacksonJaxBJsonProvider();
 
-        @SneakyThrows
         @Override
         public <T> T readValue(String s, Class<T> aClass) {
-          return mapper.getMapper().readValue(s, aClass);
+            try {
+                return mapper.getMapper().readValue(s, aClass);
+            } catch (IOException e) {
+                throw new MsoException(e);
+            }
         }
 
-        @SneakyThrows
         @Override
         public String writeValue(Object o) {
-          return mapper.getMapper().writeValueAsString(o);
+            try {
+                return mapper.getMapper().writeValueAsString(o);
+            } catch (JsonProcessingException e) {
+                throw new MsoException(e);
+            }
         }
       };
     }