openwebbeans-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From rmannibu...@apache.org
Subject svn commit: r1860782 - in /openwebbeans/meecrowave/trunk/meecrowave-proxy/src/main/java/org/apache/meecrowave/proxy/servlet: configuration/Routes.java front/ProxyServlet.java meecrowave/ProxyServletSetup.java service/ConfigurationLoader.java
Date Fri, 07 Jun 2019 16:50:44 GMT
Author: rmannibucau
Date: Fri Jun  7 16:50:44 2019
New Revision: 1860782

URL: http://svn.apache.org/viewvc?rev=1860782&view=rev
Log:
MEECROWAVE-197 minor fixes about the proxy config

Modified:
    openwebbeans/meecrowave/trunk/meecrowave-proxy/src/main/java/org/apache/meecrowave/proxy/servlet/configuration/Routes.java
    openwebbeans/meecrowave/trunk/meecrowave-proxy/src/main/java/org/apache/meecrowave/proxy/servlet/front/ProxyServlet.java
    openwebbeans/meecrowave/trunk/meecrowave-proxy/src/main/java/org/apache/meecrowave/proxy/servlet/meecrowave/ProxyServletSetup.java
    openwebbeans/meecrowave/trunk/meecrowave-proxy/src/main/java/org/apache/meecrowave/proxy/servlet/service/ConfigurationLoader.java

Modified: openwebbeans/meecrowave/trunk/meecrowave-proxy/src/main/java/org/apache/meecrowave/proxy/servlet/configuration/Routes.java
URL: http://svn.apache.org/viewvc/openwebbeans/meecrowave/trunk/meecrowave-proxy/src/main/java/org/apache/meecrowave/proxy/servlet/configuration/Routes.java?rev=1860782&r1=1860781&r2=1860782&view=diff
==============================================================================
--- openwebbeans/meecrowave/trunk/meecrowave-proxy/src/main/java/org/apache/meecrowave/proxy/servlet/configuration/Routes.java
(original)
+++ openwebbeans/meecrowave/trunk/meecrowave-proxy/src/main/java/org/apache/meecrowave/proxy/servlet/configuration/Routes.java
Fri Jun  7 16:50:44 2019
@@ -19,6 +19,10 @@
 package org.apache.meecrowave.proxy.servlet.configuration;
 
 import java.util.Collection;
+import java.util.concurrent.ExecutorService;
+
+import javax.json.bind.annotation.JsonbTransient;
+import javax.ws.rs.client.Client;
 
 public class Routes {
     public Route defaultRoute;
@@ -33,6 +37,13 @@ public class Routes {
         public String id;
         public RequestConfiguration requestConfiguration;
         public ResponseConfiguration responseConfiguration;
+        public ClientConfiguration clientConfiguration;
+
+        @JsonbTransient
+        public Client client;
+
+        @JsonbTransient
+        public ExecutorService executor;
 
         @Override
         public String toString() {
@@ -40,6 +51,72 @@ public class Routes {
         }
     }
 
+    public static class ExecutorConfiguration {
+        public int core = 8;
+        public int max = 512;
+        public long keepAlive = 60000;
+        public long shutdownTimeout = 1;
+
+        @Override
+        public String toString() {
+            return "ExecutorConfiguration{" +
+                    "core=" + core +
+                    ", max=" + max +
+                    ", keepAlive=" + keepAlive +
+                    ", shutdownTimeout=" + shutdownTimeout +
+                    '}';
+        }
+    }
+
+    public static class TimeoutConfiguration {
+        public long read = 30000;
+        public long connect = 30000;
+        public long execution = 60000;
+
+        @Override
+        public String toString() {
+            return "TimeoutConfiguration{" +
+                    "read=" + read +
+                    ", connect=" + connect +
+                    '}';
+        }
+    }
+
+    public static class ClientConfiguration {
+        public TimeoutConfiguration timeouts;
+        public ExecutorConfiguration executor;
+        public SslConfiguration sslConfiguration;
+
+        @Override
+        public String toString() {
+            return "ClientConfiguration{" +
+                    "timeouts=" + timeouts +
+                    ", executor=" + executor +
+                    '}';
+        }
+    }
+
+    public static class SslConfiguration {
+        public boolean acceptAnyCertificate;
+        public String keystoreLocation;
+        public String keystoreType;
+        public String keystorePassword;
+        public String truststoreType;
+        public Collection<String> verifiedHostnames;
+
+        @Override
+        public String toString() {
+            return "SslConfiguration{" +
+                    "acceptAnyCertificate=" + acceptAnyCertificate +
+                    ", keystoreLocation='" + keystoreLocation + '\'' +
+                    ", keystoreType='" + keystoreType + '\'' +
+                    ", keystorePassword='" + keystorePassword + '\'' +
+                    ", truststoreType='" + truststoreType + '\'' +
+                    ", verifiedHostnames=" + verifiedHostnames +
+                    '}';
+        }
+    }
+
     public static class ResponseConfiguration {
         public String target;
         public Collection<String> skippedHeaders;

Modified: openwebbeans/meecrowave/trunk/meecrowave-proxy/src/main/java/org/apache/meecrowave/proxy/servlet/front/ProxyServlet.java
URL: http://svn.apache.org/viewvc/openwebbeans/meecrowave/trunk/meecrowave-proxy/src/main/java/org/apache/meecrowave/proxy/servlet/front/ProxyServlet.java?rev=1860782&r1=1860781&r2=1860782&view=diff
==============================================================================
--- openwebbeans/meecrowave/trunk/meecrowave-proxy/src/main/java/org/apache/meecrowave/proxy/servlet/front/ProxyServlet.java
(original)
+++ openwebbeans/meecrowave/trunk/meecrowave-proxy/src/main/java/org/apache/meecrowave/proxy/servlet/front/ProxyServlet.java
Fri Jun  7 16:50:44 2019
@@ -34,10 +34,6 @@ import java.util.Enumeration;
 import java.util.Map;
 import java.util.Optional;
 import java.util.concurrent.CompletionStage;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.LinkedBlockingQueue;
-import java.util.concurrent.ThreadFactory;
-import java.util.concurrent.ThreadPoolExecutor;
 import java.util.stream.Stream;
 
 import javax.servlet.AsyncContext;
@@ -50,8 +46,6 @@ import javax.servlet.http.HttpServletReq
 import javax.servlet.http.HttpServletResponse;
 import javax.ws.rs.HttpMethod;
 import javax.ws.rs.WebApplicationException;
-import javax.ws.rs.client.Client;
-import javax.ws.rs.client.ClientBuilder;
 import javax.ws.rs.client.CompletionStageRxInvoker;
 import javax.ws.rs.client.Entity;
 import javax.ws.rs.client.Invocation;
@@ -67,10 +61,6 @@ import org.apache.meecrowave.proxy.servl
 // IMPORTANT: don't make this class depending on meecrowave, cxf or our internals, use setup
class
 public class ProxyServlet extends HttpServlet {
     protected Routes routes;
-    protected Client client;
-    protected ExecutorService executor;
-    protected long awaitTimeout;
-    protected long asyncTimeout;
     protected int prefixLength;
 
     @Override
@@ -87,9 +77,9 @@ public class ProxyServlet extends HttpSe
     protected CompletionStage<HttpServletResponse> doExecute(final Routes.Route route,
final HttpServletRequest req, final HttpServletResponse resp,
                                                              final String prefix) throws
IOException {
         final AsyncContext asyncContext = req.startAsync();
-        asyncContext.setTimeout(asyncTimeout);
+        asyncContext.setTimeout(route.clientConfiguration.timeouts.execution);
 
-        WebTarget target = client.target(route.responseConfiguration.target);
+        WebTarget target = route.client.target(route.responseConfiguration.target);
         target = target.path(prefix); // todo: query params, multipart, etc
 
         final Map<String, String> queryParams = ofNullable(req.getQueryString())
@@ -187,7 +177,7 @@ public class ProxyServlet extends HttpSe
 
     protected void forwardCookies(final Routes.Route route, final Response response, final
HttpServletResponse resp) {
         response.getCookies().entrySet().stream()
-                .filter(cookie -> filterCookie(route.requestConfiguration.skippedCookies,
cookie.getKey(), cookie.getValue().getValue()))
+                .filter(cookie -> filterCookie(route.responseConfiguration.skippedCookies,
cookie.getKey(), cookie.getValue().getValue()))
                 .forEach(cookie -> addCookie(resp, cookie));
     }
 
@@ -206,7 +196,7 @@ public class ProxyServlet extends HttpSe
 
     protected void forwardHeaders(final Routes.Route route, final Response response, final
HttpServletResponse resp) {
         response.getHeaders().entrySet().stream()
-                .filter(header -> filterHeader(route.requestConfiguration.skippedHeaders,
header.getKey()))
+                .filter(header -> filterHeader(route.responseConfiguration.skippedHeaders,
header.getKey()))
                 .flatMap(entry -> entry.getValue().stream().map(value -> new AbstractMap.SimpleEntry<>(entry.getKey(),
String.valueOf(value))))
                 .forEach(header -> resp.addHeader(header.getKey(), header.getValue()));
     }
@@ -239,7 +229,12 @@ public class ProxyServlet extends HttpSe
     }
 
     protected Optional<Routes> loadConfiguration() {
-        return get("configuration").flatMap(path -> new ConfigurationLoader(path).load());
+        return get("configuration").flatMap(path -> new ConfigurationLoader(path) {
+            @Override
+            protected void log(final String message) {
+                getServletContext().log(message);
+            }
+        }.load());
     }
 
     @Override
@@ -250,11 +245,6 @@ public class ProxyServlet extends HttpSe
                 .map(it -> it.endsWith("/*") ? it.substring(0, it.length() - "/*".length())
: it)
                 .orElse("").length() + config.getServletContext().getContextPath().length();
 
-        awaitTimeout = getLong("shutdown.timeout").orElse(1L);
-        asyncTimeout = getLong("async.timeout").orElse(30000L);
-
-        setupClient();
-
         final Optional<Routes> configuration = loadConfiguration();
         if (!configuration.isPresent()) {
             return;
@@ -264,59 +254,26 @@ public class ProxyServlet extends HttpSe
 
     @Override
     public void destroy() {
-        if (executor != null) {
-            executor.shutdown();
-            try {
-                if (!executor.awaitTermination(awaitTimeout, MILLISECONDS)) {
-                    getServletContext().log("Can't shutdown the client executor in " + awaitTimeout
+ "ms");
+        if (routes != null && routes.routes != null) {
+            routes.routes.forEach(it -> {
+                if (it.executor != null) {
+                    it.executor.shutdown();
+                    try {
+                        if (!it.executor.awaitTermination(it.clientConfiguration.executor.shutdownTimeout,
MILLISECONDS)) {
+                            getServletContext().log("Can't shutdown the client executor in
" + it.clientConfiguration.executor.shutdownTimeout + "ms");
+                        }
+                    } catch (final InterruptedException e) {
+                        Thread.currentThread().interrupt();
+                    }
                 }
-            } catch (final InterruptedException e) {
-                Thread.currentThread().interrupt();
-            }
+                if (it.client != null) {
+                    it.client.close();
+                }
+            });
         }
-        client.close();
         super.destroy();
     }
 
-    protected void setupClient() {
-        executor = new ThreadPoolExecutor(
-                getInt("executor.core").orElse(64),
-                getInt("executor.max").orElse(512),
-                getLong("executor.keepAlive").orElse(60000L),
-                MILLISECONDS,
-                new LinkedBlockingQueue<>(),
-                new ThreadFactory() {
-                    private final SecurityManager sm = System.getSecurityManager();
-                    private final ThreadGroup group = (sm != null) ? sm.getThreadGroup()
: Thread.currentThread().getThreadGroup();
-
-                    @Override
-                    public Thread newThread(final Runnable r) {
-                        final Thread newThread = new Thread(group, r, ProxyServlet.class.getName()
+ "_" + hashCode());
-                        newThread.setDaemon(false);
-                        newThread.setPriority(Thread.NORM_PRIORITY);
-                        newThread.setContextClassLoader(getClass().getClassLoader());
-                        return newThread;
-                    }
-                },
-                (r, executor) -> getServletContext().log("Proxy rejected task: " + r));
-
-        final ClientBuilder clientBuilder = ClientBuilder.newBuilder();
-        clientBuilder.executorService(executor);
-        clientBuilder.readTimeout(getLong("read.timeout").orElse(30000L), MILLISECONDS);
-        clientBuilder.connectTimeout(getLong("connect.timeout").orElse(30000L), MILLISECONDS);
-        // todo: configure ssl
-        // clientBuilder.scheduledExecutorService(); // not used by cxf for instance so no
need to overkill the conf
-        client = clientBuilder.build();
-    }
-
-    private Optional<Long> getLong(final String key) {
-        return get(key).map(Long::parseLong);
-    }
-
-    private Optional<Integer> getInt(final String key) {
-        return get(key).map(Integer::parseInt);
-    }
-
     private Optional<String> get(final String key) {
         return ofNullable(getServletConfig().getInitParameter(key));
     }

Modified: openwebbeans/meecrowave/trunk/meecrowave-proxy/src/main/java/org/apache/meecrowave/proxy/servlet/meecrowave/ProxyServletSetup.java
URL: http://svn.apache.org/viewvc/openwebbeans/meecrowave/trunk/meecrowave-proxy/src/main/java/org/apache/meecrowave/proxy/servlet/meecrowave/ProxyServletSetup.java?rev=1860782&r1=1860781&r2=1860782&view=diff
==============================================================================
--- openwebbeans/meecrowave/trunk/meecrowave-proxy/src/main/java/org/apache/meecrowave/proxy/servlet/meecrowave/ProxyServletSetup.java
(original)
+++ openwebbeans/meecrowave/trunk/meecrowave-proxy/src/main/java/org/apache/meecrowave/proxy/servlet/meecrowave/ProxyServletSetup.java
Fri Jun  7 16:50:44 2019
@@ -51,13 +51,6 @@ public class ProxyServletSetup implement
             }
             servlet.setInitParameter("mapping", config.mapping);
             servlet.setInitParameter("configuration", config.configuration);
-            servlet.setInitParameter("read.timeout", config.readTimeout);
-            servlet.setInitParameter("connect.timeout", config.connectTimeout);
-            servlet.setInitParameter("executor.core", config.threadPoolCoreSize);
-            servlet.setInitParameter("executor.max", config.threadPoolMaxSize);
-            servlet.setInitParameter("executor.keepAlive", config.threadPoolKeepAlive);
-            servlet.setInitParameter("shutdown.timeout", config.shutdownTimeout);
-            servlet.setInitParameter("async.timeout", config.asyncTimeout);
         }, null);
     }
 
@@ -91,24 +84,6 @@ public class ProxyServletSetup implement
         @CliOption(name = "proxy-configuration", description = "The route file.")
         private String configuration = "conf/proxy.json";
 
-        @CliOption(name = "proxy-shutdown-timeout", description = "How long the shutdown
will wait for in progress tasks (executor).")
-        private String shutdownTimeout = "30000";
-
-        @CliOption(name = "proxy-executor-core", description = "HTTP client thread pool core
size.")
-        private String threadPoolCoreSize = "64";
-
-        @CliOption(name = "proxy-executor-max", description = "HTTP client thread pool max
size.")
-        private String threadPoolMaxSize = "512";
-
-        @CliOption(name = "proxy-executor-max", description = "HTTP client thread pool keep
alive duration (in ms).")
-        private String threadPoolKeepAlive = "60000";
-
-        @CliOption(name = "proxy-read-timeout", description = "HTTP client read timeout.")
-        private String readTimeout = "30000";
-
-        @CliOption(name = "proxy-connect-timeout", description = "HTTP client connect timeout.")
-        private String connectTimeout = "30000";
-
         @CliOption(name = "proxy-async-timeout", description = "Asynchronous execution timeout.")
         private String asyncTimeout = "30000";
     }

Modified: openwebbeans/meecrowave/trunk/meecrowave-proxy/src/main/java/org/apache/meecrowave/proxy/servlet/service/ConfigurationLoader.java
URL: http://svn.apache.org/viewvc/openwebbeans/meecrowave/trunk/meecrowave-proxy/src/main/java/org/apache/meecrowave/proxy/servlet/service/ConfigurationLoader.java?rev=1860782&r1=1860781&r2=1860782&view=diff
==============================================================================
--- openwebbeans/meecrowave/trunk/meecrowave-proxy/src/main/java/org/apache/meecrowave/proxy/servlet/service/ConfigurationLoader.java
(original)
+++ openwebbeans/meecrowave/trunk/meecrowave-proxy/src/main/java/org/apache/meecrowave/proxy/servlet/service/ConfigurationLoader.java
Fri Jun  7 16:50:44 2019
@@ -19,24 +19,46 @@
 package org.apache.meecrowave.proxy.servlet.service;
 
 import static java.util.Collections.singletonList;
+import static java.util.Optional.ofNullable;
+import static java.util.concurrent.TimeUnit.MILLISECONDS;
 import static java.util.function.Function.identity;
 import static java.util.stream.Collectors.toMap;
 
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
 import java.io.InputStream;
 import java.lang.reflect.InvocationTargetException;
+import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
+import java.security.KeyManagementException;
+import java.security.KeyStore;
+import java.security.KeyStoreException;
+import java.security.NoSuchAlgorithmException;
+import java.security.cert.CertificateException;
+import java.security.cert.X509Certificate;
 import java.util.Optional;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.ThreadPoolExecutor;
 
 import javax.json.bind.Jsonb;
 import javax.json.bind.JsonbBuilder;
 import javax.json.bind.JsonbConfig;
 import javax.json.spi.JsonProvider;
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.TrustManager;
+import javax.net.ssl.TrustManagerFactory;
+import javax.net.ssl.X509TrustManager;
+import javax.ws.rs.client.ClientBuilder;
 
 import org.apache.meecrowave.proxy.servlet.configuration.Routes;
 
-public class ConfigurationLoader {
+public abstract class ConfigurationLoader {
     private final String path;
 
     private Routes routes;
@@ -45,20 +67,39 @@ public class ConfigurationLoader {
         this.path = path;
     }
 
+    protected abstract void log(String message);
+
     public Optional<Routes> load() {
         final SimpleSubstitutor simpleSubstitutor = new SimpleSubstitutor(
                 System.getProperties().stringPropertyNames().stream().collect(toMap(identity(),
System::getProperty)));
-        final Path routeFile = Paths.get(simpleSubstitutor.replace(path));
-        if (!Files.exists(routeFile)) {
+        final String resource = simpleSubstitutor.replace(path);
+        final Path routeFile = Paths.get(resource);
+        final InputStream stream;
+        if (Files.exists(routeFile)) {
+            try {
+                stream = Files.newInputStream(routeFile);
+            } catch (final IOException e) {
+                throw new IllegalStateException(e);
+            }
+        } else {
+            stream = Thread.currentThread().getContextClassLoader().getResourceAsStream(resource);
+        }
+        if (stream == null) {
             throw new IllegalArgumentException("No routes configuration for the proxy servlet");
         }
 
-        try (final InputStream stream = Files.newInputStream(routeFile);
-             final Jsonb jsonb = JsonbBuilder.newBuilder()
+        final String content;
+        try {
+            content = simpleSubstitutor.replace(load(stream));
+        } catch (final IOException e) {
+            throw new IllegalArgumentException(e);
+        }
+
+        try (final Jsonb jsonb = JsonbBuilder.newBuilder()
                      .withProvider(loadJsonpProvider())
                      .withConfig(new JsonbConfig().setProperty("org.apache.johnzon.supports-comments",
true))
                      .build()) {
-            routes = jsonb.fromJson(stream, Routes.class);
+            routes = jsonb.fromJson(content, Routes.class);
         } catch (final Exception e) {
             throw new IllegalArgumentException(e);
         }
@@ -67,7 +108,6 @@ public class ConfigurationLoader {
             return Optional.empty();
         }
         if (routes.defaultRoute != null) {
-            onLoad(simpleSubstitutor, routes.defaultRoute);
             if (routes.routes == null) { // no route were defined, consider it is the default
route, /!\ empty means no route, don't default
                 routes.routes = singletonList(routes.defaultRoute);
             }
@@ -75,13 +115,80 @@ public class ConfigurationLoader {
                 routes.routes.forEach(r -> merge(routes.defaultRoute, r));
             }
         }
-        if (hasRoutes) {
-            routes.routes.forEach(it -> onLoad(simpleSubstitutor, it));
-        }
+        routes.routes.forEach(this::loadClient);
         return Optional.of(routes);
     }
 
+    private String load(final InputStream stream) throws IOException {
+        final ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        byte[] buffer = new byte[1024];
+        int count;
+        while (-1 != (count = stream.read(buffer))) {
+            baos.write(buffer, 0, count);
+        }
+        return new String(baos.toByteArray(), StandardCharsets.UTF_8);
+    }
+
+    private void loadClient(final Routes.Route route) {
+        if (route.clientConfiguration == null) {
+            route.clientConfiguration = new Routes.ClientConfiguration();
+        }
+        if (route.clientConfiguration.executor == null) {
+            route.clientConfiguration.executor = new Routes.ExecutorConfiguration();
+        }
+        if (route.clientConfiguration.timeouts == null) {
+            route.clientConfiguration.timeouts = new Routes.TimeoutConfiguration();
+        }
+        if (route.clientConfiguration.sslConfiguration == null) {
+            route.clientConfiguration.sslConfiguration = new Routes.SslConfiguration();
+        }
+
+        final ExecutorService executor = new ThreadPoolExecutor(
+                route.clientConfiguration.executor.core,
+                route.clientConfiguration.executor.max,
+                route.clientConfiguration.executor.keepAlive,
+                MILLISECONDS,
+                new LinkedBlockingQueue<>(),
+                new ThreadFactory() {
+                    private final SecurityManager sm = System.getSecurityManager();
+                    private final ThreadGroup group = (sm != null) ? sm.getThreadGroup()
: Thread.currentThread().getThreadGroup();
+
+                    @Override
+                    public Thread newThread(final Runnable r) {
+                        final Thread newThread = new Thread(group, r, "meecrowave-proxy#"
+ ofNullable(route.id).orElse("[noid]"));
+                        newThread.setDaemon(false);
+                        newThread.setPriority(Thread.NORM_PRIORITY);
+                        newThread.setContextClassLoader(getClass().getClassLoader());
+                        return newThread;
+                    }
+                },
+                (run, ex) -> log("Proxy rejected task: " + run + ", in " + ex));
+
+        final ClientBuilder clientBuilder = ClientBuilder.newBuilder();
+        clientBuilder.executorService(executor);
+        clientBuilder.readTimeout(route.clientConfiguration.timeouts.read, MILLISECONDS);
+        clientBuilder.connectTimeout(route.clientConfiguration.timeouts.connect, MILLISECONDS);
+        // clientBuilder.scheduledExecutorService(); // not used by cxf for instance so no
need to overkill the conf
+
+        if (route.clientConfiguration.sslConfiguration.acceptAnyCertificate) {
+            clientBuilder.hostnameVerifier((host, session) -> true);
+            clientBuilder.sslContext(createUnsafeSSLContext());
+        } else if (route.clientConfiguration.sslConfiguration.keystoreLocation != null) {
+            if (route.clientConfiguration.sslConfiguration.verifiedHostnames != null) {
+                clientBuilder.hostnameVerifier((host, session) -> route.clientConfiguration.sslConfiguration.verifiedHostnames.contains(host));
+            }
+            clientBuilder.sslContext(createSSLContext(
+                    route.clientConfiguration.sslConfiguration.keystoreLocation,
+                    route.clientConfiguration.sslConfiguration.keystoreType,
+                    route.clientConfiguration.sslConfiguration.keystorePassword,
+                    route.clientConfiguration.sslConfiguration.truststoreType));
+        }
+
+        route.client = clientBuilder.build();
+    }
+
     private void merge(final Routes.Route defaultRoute, final Routes.Route route) {
+        // request matching
         if (route.requestConfiguration == null) {
             route.requestConfiguration = defaultRoute.requestConfiguration;
         } else if (defaultRoute.requestConfiguration != null) {
@@ -99,6 +206,7 @@ public class ConfigurationLoader {
             }
         }
 
+        // response processing
         if (route.responseConfiguration == null) {
             route.responseConfiguration = defaultRoute.responseConfiguration;
         } else if (defaultRoute.responseConfiguration != null) {
@@ -112,6 +220,91 @@ public class ConfigurationLoader {
                 route.responseConfiguration.skippedHeaders = defaultRoute.responseConfiguration.skippedHeaders;
             }
         }
+
+        // client setup
+        if (route.clientConfiguration == null) {
+            route.clientConfiguration = defaultRoute.clientConfiguration;
+        } else if (defaultRoute.clientConfiguration != null) {
+            if (route.clientConfiguration.sslConfiguration == null) {
+                route.clientConfiguration.sslConfiguration = defaultRoute.clientConfiguration.sslConfiguration;
+            } else if (defaultRoute.clientConfiguration.sslConfiguration != null) {
+                if (route.clientConfiguration.sslConfiguration.verifiedHostnames == null)
{
+                    route.clientConfiguration.sslConfiguration.verifiedHostnames = defaultRoute.clientConfiguration.sslConfiguration.verifiedHostnames;
+                }
+                if (route.clientConfiguration.sslConfiguration.keystoreLocation == null)
{
+                    route.clientConfiguration.sslConfiguration.keystoreLocation = defaultRoute.clientConfiguration.sslConfiguration.keystoreLocation;
+                }
+                if (route.clientConfiguration.sslConfiguration.keystorePassword == null)
{
+                    route.clientConfiguration.sslConfiguration.keystorePassword = defaultRoute.clientConfiguration.sslConfiguration.keystorePassword;
+                }
+                if (route.clientConfiguration.sslConfiguration.keystoreType == null) {
+                    route.clientConfiguration.sslConfiguration.keystoreType = defaultRoute.clientConfiguration.sslConfiguration.keystoreType;
+                }
+                if (route.clientConfiguration.sslConfiguration.truststoreType == null) {
+                    route.clientConfiguration.sslConfiguration.truststoreType = defaultRoute.clientConfiguration.sslConfiguration.truststoreType;
+                }
+            }
+            if (route.clientConfiguration.executor == null) {
+                route.clientConfiguration.executor = defaultRoute.clientConfiguration.executor;
+            }
+            if (route.clientConfiguration.timeouts == null) {
+                route.clientConfiguration.timeouts = defaultRoute.clientConfiguration.timeouts;
+            }
+        }
+    }
+
+    private SSLContext createSSLContext(final String keystoreLocation, final String keystoreType,
+                                        final String keystorePassword, final String truststoreType)
{
+        final File source = new File(keystoreLocation);
+        if (!source.exists()) {
+            throw new IllegalArgumentException(source + " does not exist");
+        }
+        final KeyStore keyStore;
+        try (final FileInputStream stream = new FileInputStream(source)) {
+            keyStore = KeyStore.getInstance(keystoreType == null ? KeyStore.getDefaultType()
: keystoreType);
+            keyStore.load(stream, keystorePassword.toCharArray());
+        } catch (final KeyStoreException | NoSuchAlgorithmException e) {
+            throw new IllegalStateException(e);
+        } catch (final CertificateException | IOException e) {
+            throw new IllegalArgumentException(e);
+        }
+        try {
+            final TrustManagerFactory trustManagerFactory =
+                    TrustManagerFactory.getInstance(truststoreType == null ? TrustManagerFactory.getDefaultAlgorithm()
: truststoreType);
+            trustManagerFactory.init(keyStore);
+            final SSLContext sslContext = SSLContext.getInstance("TLS");
+            sslContext.init(null, trustManagerFactory.getTrustManagers(), new java.security.SecureRandom());
+            return sslContext;
+        } catch (final KeyStoreException | NoSuchAlgorithmException | KeyManagementException
e) {
+            throw new IllegalStateException(e);
+        }
+    }
+
+    private SSLContext createUnsafeSSLContext() {
+        final TrustManager[] trustManagers = { new X509TrustManager() {
+
+            @Override
+            public void checkClientTrusted(final X509Certificate[] x509Certificates, final
String s) {
+                // no-op
+            }
+
+            @Override
+            public void checkServerTrusted(final X509Certificate[] x509Certificates, final
String s) {
+                // no-op
+            }
+
+            @Override
+            public X509Certificate[] getAcceptedIssuers() {
+                return null;
+            }
+        } };
+        try {
+            final SSLContext sslContext = SSLContext.getInstance("SSL");
+            sslContext.init(null, trustManagers, new java.security.SecureRandom());
+            return sslContext;
+        } catch (final NoSuchAlgorithmException | KeyManagementException e) {
+            throw new IllegalStateException(e);
+        }
     }
 
     private JsonProvider loadJsonpProvider() {
@@ -123,17 +316,4 @@ public class ConfigurationLoader {
             return JsonProvider.provider();
         }
     }
-
-    // filter
-    private void onLoad(final SimpleSubstitutor simpleSubstitutor, final Routes.Route route)
{
-        if (route.requestConfiguration != null && route.requestConfiguration.prefix
!= null) {
-            route.requestConfiguration.prefix = simpleSubstitutor.replace(route.requestConfiguration.prefix);
-        }
-        if (route.requestConfiguration != null && route.requestConfiguration.method
!= null) {
-            route.requestConfiguration.method = simpleSubstitutor.replace(route.requestConfiguration.method);
-        }
-        if (route.responseConfiguration != null && route.responseConfiguration.target
!= null) {
-            route.responseConfiguration.target = simpleSubstitutor.replace(route.responseConfiguration.target);
-        }
-    }
 }



Mime
View raw message