extend rest5 client builder with more setters

Author: l-trotta

java-client/src/main/java/co/elastic/clients/transport/rest5_client/low_level/Rest5ClientBuilder.java

@@ -20,17 +20,33 @@
 package co.elastic.clients.transport.rest5_client.low_level;
 
 
+import org.apache.hc.client5.http.AuthenticationStrategy;
+import org.apache.hc.client5.http.HttpRequestRetryStrategy;
+import org.apache.hc.client5.http.SchemePortResolver;
+import org.apache.hc.client5.http.UserTokenHandler;
+import org.apache.hc.client5.http.auth.AuthSchemeFactory;
+import org.apache.hc.client5.http.auth.CredentialsProvider;
 import org.apache.hc.client5.http.config.ConnectionConfig;
 import org.apache.hc.client5.http.config.RequestConfig;
 import org.apache.hc.client5.http.impl.DefaultAuthenticationStrategy;
 import org.apache.hc.client5.http.impl.async.CloseableHttpAsyncClient;
 import org.apache.hc.client5.http.impl.async.HttpAsyncClientBuilder;
-import org.apache.hc.client5.http.impl.nio.PoolingAsyncClientConnectionManager;
 import org.apache.hc.client5.http.impl.nio.PoolingAsyncClientConnectionManagerBuilder;
+import org.apache.hc.client5.http.nio.AsyncClientConnectionManager;
 import org.apache.hc.client5.http.routing.HttpRoutePlanner;
+import org.apache.hc.core5.function.Callback;
+import org.apache.hc.core5.function.Decorator;
+import org.apache.hc.core5.http.ConnectionReuseStrategy;
 import org.apache.hc.core5.http.Header;
 import org.apache.hc.core5.http.HttpHost;
+import org.apache.hc.core5.http.config.CharCodingConfig;
+import org.apache.hc.core5.http.config.Http1Config;
+import org.apache.hc.core5.http.config.Lookup;
 import org.apache.hc.core5.http.nio.ssl.BasicClientTlsStrategy;
+import org.apache.hc.core5.http2.config.H2Config;
+import org.apache.hc.core5.reactor.IOReactorConfig;
+import org.apache.hc.core5.reactor.IOSession;
+import org.apache.hc.core5.reactor.IOSessionListener;
 import org.apache.hc.core5.util.Timeout;
 import org.apache.hc.core5.util.VersionInfo;
 
@@ -78,6 +94,25 @@ public final class Rest5ClientBuilder {
     private Header[] defaultHeaders = EMPTY_HEADERS;
     private Rest5Client.FailureListener failureListener;
     private SSLContext sslContext;
+    private Http1Config h1Config;
+    private H2Config h2Config;
+    private IOReactorConfig ioReactorConfig;
+    private IOSessionListener ioSessionListener;
+    private ConnectionReuseStrategy connectionReuseStrategy;
+    private CredentialsProvider credentialsProvider;
+    private Callback<Exception> ioReactorExceptionCallback;
+    private CharCodingConfig charCodingConfig;
+    private UserTokenHandler userTokenHandler;
+    private AuthenticationStrategy authStrategy;
+    private AuthenticationStrategy proxyAuthStrategy;
+    private Decorator<IOSession> ioSessionDecorator;
+    private HttpRequestRetryStrategy retryStrategy;
+    private SchemePortResolver schemePortResolver;
+    private ThreadFactory threadFactory;
+    private Lookup<AuthSchemeFactory> authSchemeRegistry;
+    private RequestConfig customRequestConfig;
+    private ConnectionConfig customConnectionConfig;
+    private AsyncClientConnectionManager customConnectionManager;
     private HttpHost proxy;
     private ProxySelector proxySelector;
     private HttpRoutePlanner routePlanner;
@@ -204,6 +239,142 @@ public Rest5ClientBuilder setRoutePlanner(HttpRoutePlanner routePlanner) {
         return this;
     }
 
+    public Rest5ClientBuilder setHttp1Config(Http1Config h1Config) {
+        Objects.requireNonNull(h1Config, "http1 config must not be null");
+        this.h1Config = h1Config;
+        return this;
+    }
+
+    public Rest5ClientBuilder setH2Config(H2Config h2Config) {
+        Objects.requireNonNull(h2Config, "h2 config must not be null");
+        this.h2Config = h2Config;
+        return this;
+    }
+
+    public Rest5ClientBuilder setIOReactorConfig(IOReactorConfig ioReactorConfig) {
+        Objects.requireNonNull(ioReactorConfig, "io reactor config must not be null");
+        this.ioReactorConfig = ioReactorConfig;
+        return this;
+    }
+
+    public Rest5ClientBuilder setIOSessionListener(IOSessionListener ioSessionListener) {
+        Objects.requireNonNull(ioSessionListener, "io session listener must not be null");
+        this.ioSessionListener = ioSessionListener;
+        return this;
+    }
+
+
+    public Rest5ClientBuilder setConnectionReuseStrategy(ConnectionReuseStrategy connectionReuseStrategy) {
+        Objects.requireNonNull(connectionReuseStrategy, "connection reuse strategy must not be null");
+        this.connectionReuseStrategy = connectionReuseStrategy;
+        return this;
+    }
+
+    /**
+     * Sets the callback that will be invoked when the client's IOReactor encounters an uncaught exception.
+     */
+    public Rest5ClientBuilder setIoReactorExceptionCallback(Callback<Exception> ioReactorExceptionCallback) {
+        Objects.requireNonNull(ioReactorExceptionCallback, "io exception callback must not be null");
+        this.ioReactorExceptionCallback = ioReactorExceptionCallback;
+        return this;
+    }
+
+    public Rest5ClientBuilder setCharCodingConfig(CharCodingConfig charCodingConfig) {
+        Objects.requireNonNull(charCodingConfig, "char coding config must not be null");
+        this.charCodingConfig = charCodingConfig;
+        return this;
+    }
+
+    /**
+     * For user specific contexts, to determine whether to share user specific resources.
+     */
+    public Rest5ClientBuilder setUserTokenHandler(UserTokenHandler userTokenHandler) {
+        Objects.requireNonNull(userTokenHandler, "user token handler must not be null");
+        this.userTokenHandler = userTokenHandler;
+        return this;
+    }
+
+    public Rest5ClientBuilder setTargetAuthenticationStrategy(AuthenticationStrategy authStrategy) {
+        Objects.requireNonNull(authStrategy, "authentication strategy must not be null");
+        this.authStrategy = authStrategy;
+        return this;
+    }
+
+    public Rest5ClientBuilder setProxyAuthenticationStrategy(AuthenticationStrategy proxyAuthStrategy) {
+        Objects.requireNonNull(proxyAuthStrategy, "proxy authentication strategy must not be null");
+        this.proxyAuthStrategy = proxyAuthStrategy;
+        return this;
+    }
+
+    public Rest5ClientBuilder setIoSessionDecorator(Decorator<IOSession> ioSessionDecorator) {
+        Objects.requireNonNull(ioSessionDecorator, "io session decorator must not be null");
+        this.ioSessionDecorator = ioSessionDecorator;
+        return this;
+    }
+
+    public Rest5ClientBuilder setRetryStrategy(HttpRequestRetryStrategy retryStrategy) {
+        Objects.requireNonNull(retryStrategy, "retry strategy must not be null");
+        this.retryStrategy = retryStrategy;
+        return this;
+    }
+
+    public Rest5ClientBuilder setSchemePortResolver(SchemePortResolver schemePortResolver) {
+        Objects.requireNonNull(schemePortResolver, "scheme port resolver must not be null");
+        this.schemePortResolver = schemePortResolver;
+        return this;
+    }
+
+    public Rest5ClientBuilder setThreadFactory(ThreadFactory threadFactory) {
+        Objects.requireNonNull(threadFactory, "thread factory must not be null");
+        this.threadFactory = threadFactory;
+        return this;
+    }
+
+    public Rest5ClientBuilder setDefaultCredentialsProvider(CredentialsProvider credentialsProvider) {
+        Objects.requireNonNull(credentialsProvider, "credentials provider must not be null");
+        this.credentialsProvider = credentialsProvider;
+        return this;
+    }
+
+    public Rest5ClientBuilder setDefaultAuthSchemeRegistry(Lookup<AuthSchemeFactory> authSchemeRegistry) {
+        Objects.requireNonNull(authSchemeRegistry, "auth scheme registry must not be null");
+        this.authSchemeRegistry = authSchemeRegistry;
+        return this;
+    }
+
+    /**
+     * Override default values for request specific settings.
+     * This also overrides default timeouts set by the client configuration.
+     * Avoid using this method unless specific configuration is needed.
+     */
+    public Rest5ClientBuilder setCustomRequestConfig(RequestConfig config) {
+        Objects.requireNonNull(config, "request config must not be null");
+        this.customRequestConfig = config;
+        return this;
+    }
+
+    /**
+     * Override default values for connection specific settings.
+     * This also overrides default timeouts set by the client configuration.
+     * Avoid using this method unless specific configuration is needed.
+     */
+    public Rest5ClientBuilder setCustomConnectionConfig(ConnectionConfig config) {
+        Objects.requireNonNull(config, "connection config must not be null");
+        this.customConnectionConfig = config;
+        return this;
+    }
+
+    /**
+     * Override default connection manager.
+     * This also overrides default timeouts and route settings set by the client configuration.
+     * Avoid using this method unless specific configuration is needed.
+     */
+    public Rest5ClientBuilder setCustomConnectionManager(AsyncClientConnectionManager connectionManager) {
+        Objects.requireNonNull(connectionManager, "connection manager must not be null");
+        this.customConnectionManager = connectionManager;
+        return this;
+    }
+
     /**
      * Sets the default request headers, which will be sent along with each request.
      * <p>
@@ -369,31 +540,50 @@ private CloseableHttpAsyncClient createHttpClient() {
             return this.httpClient;
         }
         // otherwise, creating a default instance of CloseableHttpAsyncClient
-        // default timeouts are all 3 mins
-        RequestConfig requestConfigBuilder = RequestConfig.custom()
-            .setConnectionRequestTimeout(Timeout.of(DEFAULT_SOCKET_TIMEOUT_MILLIS, TimeUnit.MILLISECONDS))
-            .setResponseTimeout(Timeout.of(DEFAULT_RESPONSE_TIMEOUT_MILLIS, TimeUnit.MILLISECONDS))
-            .build();
+
+        // if the user provided a custom RequestConfig, using that one
+        RequestConfig requestConfig;
+        if (this.customRequestConfig != null) {
+            requestConfig = customRequestConfig;
+        } else {
+            // otherwise, building one to override default timeouts, which are all 3 mins
+            requestConfig = RequestConfig.custom()
+                .setConnectionRequestTimeout(Timeout.of(DEFAULT_SOCKET_TIMEOUT_MILLIS, TimeUnit.MILLISECONDS))
+                .setResponseTimeout(Timeout.of(DEFAULT_RESPONSE_TIMEOUT_MILLIS, TimeUnit.MILLISECONDS))
+                .build();
+        }
 
         try {
 
             SSLContext sslContext = this.sslContext != null ? this.sslContext : SSLContext.getDefault();
 
-            ConnectionConfig connectionConfig = ConnectionConfig.custom()
-                .setConnectTimeout(Timeout.of(DEFAULT_CONNECT_TIMEOUT_MILLIS, TimeUnit.MILLISECONDS))
-                .build();
+            // if the user provided a custom ConnectionConfig, using that one
+            ConnectionConfig connectionConfig;
+            if (this.customConnectionConfig != null) {
+                connectionConfig = customConnectionConfig;
+            } else {
+                // otherwise, building one to override default timeout of 3 minutes
+                connectionConfig = ConnectionConfig.custom()
+                    .setConnectTimeout(Timeout.of(DEFAULT_CONNECT_TIMEOUT_MILLIS, TimeUnit.MILLISECONDS))
+                    .build();
+            }
 
-            PoolingAsyncClientConnectionManager defaultConnectionManager =
-                PoolingAsyncClientConnectionManagerBuilder.create()
+            // if the user provided a custom ConnectionManager, using that one
+            AsyncClientConnectionManager connectionManager;
+            if (this.customConnectionManager != null) {
+                connectionManager = customConnectionManager;
+            } else {
+                connectionManager = PoolingAsyncClientConnectionManagerBuilder.create()
                     .setDefaultConnectionConfig(connectionConfig)
                     .setMaxConnPerRoute(DEFAULT_MAX_CONN_PER_ROUTE)
                     .setMaxConnTotal(DEFAULT_MAX_CONN_TOTAL)
                     .setTlsStrategy(new BasicClientTlsStrategy(sslContext))
                     .build();
+            }
 
             HttpAsyncClientBuilder httpClientBuilder = HttpAsyncClientBuilder.create()
-                .setDefaultRequestConfig(requestConfigBuilder)
-                .setConnectionManager(defaultConnectionManager)
+                .setDefaultRequestConfig(requestConfig)
+                .setConnectionManager(connectionManager)
                 .setUserAgent(USER_AGENT_HEADER_VALUE)
                 .setTargetAuthenticationStrategy(new DefaultAuthenticationStrategy())
                 .setThreadFactory(new RestClientThreadFactory());
@@ -407,6 +597,55 @@ private CloseableHttpAsyncClient createHttpClient() {
             if (this.routePlanner != null) {
                 httpClientBuilder.setRoutePlanner(this.routePlanner);
             }
+            if (this.h1Config != null) {
+                httpClientBuilder.setHttp1Config(this.h1Config);
+            }
+            if (this.h2Config != null) {
+                httpClientBuilder.setH2Config(this.h2Config);
+            }
+            if (this.ioReactorConfig != null) {
+                httpClientBuilder.setIOReactorConfig(this.ioReactorConfig);
+            }
+            if (this.ioSessionListener != null) {
+                httpClientBuilder.setIOSessionListener(this.ioSessionListener);
+            }
+            if (this.connectionReuseStrategy != null) {
+                httpClientBuilder.setConnectionReuseStrategy(this.connectionReuseStrategy);
+            }
+            if (this.credentialsProvider != null) {
+                httpClientBuilder.setDefaultCredentialsProvider(this.credentialsProvider);
+            }
+            if (this.ioReactorExceptionCallback != null) {
+                httpClientBuilder.setIoReactorExceptionCallback(this.ioReactorExceptionCallback);
+            }
+            if (this.charCodingConfig != null) {
+                httpClientBuilder.setCharCodingConfig(this.charCodingConfig);
+            }
+            if (this.userTokenHandler != null) {
+                httpClientBuilder.setUserTokenHandler(this.userTokenHandler);
+            }
+            if (this.authStrategy != null) {
+                httpClientBuilder.setTargetAuthenticationStrategy(authStrategy);
+            }
+            if (this.proxyAuthStrategy != null) {
+                httpClientBuilder.setProxyAuthenticationStrategy(proxyAuthStrategy);
+            }
+            if (this.ioSessionDecorator != null) {
+                httpClientBuilder.setIoSessionDecorator(this.ioSessionDecorator);
+            }
+            if (this.retryStrategy != null) {
+                httpClientBuilder.setRetryStrategy(this.retryStrategy);
+            }
+            if (this.schemePortResolver != null) {
+                httpClientBuilder.setSchemePortResolver(this.schemePortResolver);
+            }
+            if (this.threadFactory != null) {
+                httpClientBuilder.setThreadFactory(this.threadFactory);
+            }
+            if (this.authSchemeRegistry != null) {
+                httpClientBuilder.setDefaultAuthSchemeRegistry(this.authSchemeRegistry);
+            }
+
 
             return httpClientBuilder.build();
         } catch (NoSuchAlgorithmException e) {