Allow extensions of ElasticsearchTransportConfig

Author: swallez

java-client/src/main/java/co/elastic/clients/transport/ElasticsearchTransportConfig.java

@@ -32,17 +32,17 @@
 import java.util.List;
 import java.util.function.Function;
 
-public class ElasticsearchTransportConfig {
-    private List<URI> hosts;
-    private String username;
-    private String password;
-    private String token;
-    private String apiKey;
-    private SSLContext sslContext;
-    private JsonpMapper mapper;
-    private TransportOptions transportOptions;
-    private Instrumentation instrumentation;
-    private Function<ElasticsearchTransportConfig, ElasticsearchTransport> transportFactory;
+public abstract class ElasticsearchTransportConfig {
+    protected List<URI> hosts;
+    protected String username;
+    protected String password;
+    protected String token;
+    protected String apiKey;
+    protected boolean useCompression = false;
+    protected SSLContext sslContext;
+    protected JsonpMapper mapper;
+    protected TransportOptions transportOptions;
+    protected Instrumentation instrumentation;
 
     public List<URI> hosts() {
         return hosts;
@@ -68,6 +68,10 @@ public String apiKey() {
         return apiKey;
     }
 
+    public boolean useCompression() {
+        return useCompression;
+    }
+
     @Nullable
     public SSLContext sslContext() {
         return sslContext;
@@ -86,150 +90,245 @@ public Instrumentation instrumentation() {
         return instrumentation;
     }
 
-    public Function<ElasticsearchTransportConfig, ElasticsearchTransport> transportFactory() {
-        return transportFactory;
+    public abstract ElasticsearchTransport buildTransport();
+
+    //---------------------------------------------------------------------------------------------
+
+    /**
+     * Default configuration that can be used with any transport implementation. If no transport
+     * factory is defined with {@link #transportFactory}, a {@link Rest5ClientTransport} is used.
+     */
+    public static class Default extends ElasticsearchTransportConfig {
+
+        protected Function<ElasticsearchTransportConfig, ElasticsearchTransport> transportFactory;
+
+        public Function<ElasticsearchTransportConfig, ElasticsearchTransport> transportFactory() {
+            return transportFactory;
+        }
+
+        public ElasticsearchTransport buildTransport() {
+            return this.transportFactory.apply(this);
+        }
     }
 
-    public ElasticsearchTransport buildTransport() {
-        return this.transportFactory.apply(this);
+    /**
+     * Builder for {@link Default} transport configurations.
+     */
+    public static class Builder extends ElasticsearchTransportConfig.AbstractBuilder<Builder> {
+        private final Default dconfig;
+
+        public Builder() {
+            this(new Default());
+        }
+
+        private Builder(Default dconfig) {
+            super(dconfig);
+            // Typed accessor to this.config
+            this.dconfig = dconfig;
+        }
+
+        @Override
+        protected Builder self() {
+            return this;
+        }
+
+        /**
+         * Should we use the legacy http implementation based on Elasticsearch's Low Level Rest Client?
+         * <p>
+         * Shortcut for {@code transportFactory(RestClientTransport::new)}.
+         *
+         * @see RestClientTransport
+         */
+        public Builder useLegacyTransport(boolean useLegacyTransport) {
+            if (useLegacyTransport) {
+                dconfig.transportFactory = RestClientTransport::new;
+            } else {
+                dconfig.transportFactory = null;
+            }
+            return this;
+        }
+
+        /**
+         * Defines the factory function to create a transport with this configuration.
+         *
+         * @see #buildTransport()
+         */
+        public Builder transportFactory(Function<ElasticsearchTransportConfig, ElasticsearchTransport> factory) {
+            dconfig.transportFactory = factory;
+            return this;
+        }
+
+        @Override
+        public Default build() {
+            Default config = (Default) super.build();
+
+            // Default transport implementation
+            if (config.transportFactory == null) {
+                config.transportFactory = Rest5ClientTransport::new;
+            }
+
+            return config;
+        }
     }
 
     //---------------------------------------------------------------------------------------------
 
-    public static class Builder {
+    public abstract static class AbstractBuilder<BuilderT extends AbstractBuilder<BuilderT>> {
+        protected final ElasticsearchTransportConfig config;
+
+        public AbstractBuilder(ElasticsearchTransportConfig config) {
+            this.config = config;
+        }
+
+        protected abstract BuilderT self();
+
+        protected ElasticsearchTransportConfig build() {
+
+            //---- Validate credentials
+
+            if (config.username != null) {
+                checkNull(config.token, "token", "username/password");
+                checkNull(config.apiKey, "API key", "username/password");
+                if (config.password == null) {
+                    throw new IllegalArgumentException("password required with username");
+                }
+            } else if (config.password != null) {
+                throw new IllegalArgumentException("username required with password");
+            }
+
+            if (config.token != null) {
+                checkNull(config.apiKey, "API key", "token");
+                checkNull(config.username, "username", "token");
+            }
+
+            if (config.apiKey != null) {
+                checkNull(config.token, "token", "API key");
+                checkNull(config.username, "username", "API key");
+            }
 
-        public final ElasticsearchTransportConfig config = new ElasticsearchTransportConfig();
+            //---- Validate other settings
 
-        public ElasticsearchTransportConfig build() {
             if (config.hosts() == null || config.hosts.isEmpty()) {
-                throw new IllegalStateException("hosts cannot be empty");
+                throw new IllegalArgumentException("hosts cannot be empty");
             }
 
             if (config.mapper == null) {
                 config.mapper = new JacksonJsonpMapper();
             }
 
-            if (config.transportFactory == null) {
-                config.transportFactory = Rest5ClientTransport::new;
-            }
-
             return config;
-        }
+        };
 
-        public Builder host(String url) {
+        /**
+         * Elasticsearch host location
+         */
+        public BuilderT host(String url) {
             try {
                 config.hosts = List.of(new URI(url));
             } catch (URISyntaxException e) {
                 // Avoid requiring a checked exception in the builder
                 throw new RuntimeException(e);
             }
-            return this;
+            return self();
         }
 
-        public Builder host(URI url) {
+        /**
+         * Elasticsearch host location
+         */
+        public BuilderT host(URI url) {
             config.hosts = List.of(url);
-            return this;
+            return self();
         }
 
-        public Builder hosts(List<URI> hosts) {
+        /**
+         * Elasticsearch hosts locations
+         */
+        public BuilderT hosts(List<URI> hosts) {
             config.hosts = hosts;
-            return this;
+            return self();
         }
 
         /**
          * Set the username and password to use to connect to Elasticsearch.
          */
-        public Builder usernameAndPassword(String username, String password) {
-            checkNull(config.token, "token", "username/password");
-            checkNull(config.apiKey, "API key", "username/password");
+        public BuilderT usernameAndPassword(String username, String password) {
             config.username = username;
             config.password = password;
-            return this;
+            return self();
         }
 
         /**
          * Set the bearer token to use to authenticate to Elasticsearch.
          */
-        public Builder token(String token) {
-            checkNull(config.apiKey, "API key", "token");
-            checkNull(config.username, "username", "token");
+        public BuilderT token(String token) {
             config.token = token;
-            return this;
+            return self();
         }
 
         /**
          * Set the API key to use to authenticate to Elasticsearch.
          */
-        public Builder apiKey(String apiKey) {
-            checkNull(config.token, "token", "API key");
-            checkNull(config.username, "username", "API key");
+        public BuilderT apiKey(String apiKey) {
             config.apiKey = apiKey;
-            return this;
+            return self();
         }
 
         /**
-         * Set the SSL context. See {@link co.elastic.clients.transport.TransportUtils} to create it
-         * from certificate files or a certificate fingerprint.
+         * Should request and response body compression be used?
+         */
+        public BuilderT useCompression(boolean useCompression) {
+            this.config.useCompression = useCompression;
+            return self();
+        }
+
+        /**
+         * SSL context to use for https connections. See {@link co.elastic.clients.transport.TransportUtils} to create it
+         * from a certificate file or a certificate fingerprint.
          *
          * @see co.elastic.clients.transport.TransportUtils
          */
-        public Builder sslContext(SSLContext sslContext) {
+        public BuilderT sslContext(SSLContext sslContext) {
             config.sslContext = sslContext;
-            return this;
-        }
-
-        public Builder setHosts(List<URI> hosts) {
-            config.hosts = hosts;
-            return this;
+            return self();
         }
 
         /**
-         * Set the JSON mapper.
+         * The JSON mapper to use. Defaults to {@link JacksonJsonpMapper}.
          */
-        public Builder jsonMapper(JsonpMapper mapper) {
+        public BuilderT jsonMapper(JsonpMapper mapper) {
             config.mapper = mapper;
-            return this;
+            return self();
         }
 
-        public Builder instrumentation(Instrumentation instrumentation) {
+        /**
+         * Transport instrumentation to log client traffic. See
+         * {@link co.elastic.clients.transport.instrumentation.OpenTelemetryForElasticsearch} for OpenTelemetry integration.
+         */
+        public BuilderT instrumentation(Instrumentation instrumentation) {
             config.instrumentation = instrumentation;
-            return this;
+            return self();
         }
 
-        public Builder transportOptions(TransportOptions transportOptions) {
+        /**
+         * Lower level transport options.
+         */
+        public BuilderT transportOptions(TransportOptions transportOptions) {
             config.transportOptions = transportOptions;
-            return this;
+            return self();
         }
 
         /**
-         * Sets lower level transport options. This method <em>adds</em> options to the ones already set, if any.
+         * Lower level transport options. This method <em>adds</em> options to the ones already set, if any.
          */
-        public Builder transportOptions(Function<TransportOptions.Builder, TransportOptions.Builder> fn) {
+        public BuilderT transportOptions(Function<TransportOptions.Builder, TransportOptions.Builder> fn) {
             var builder = config.transportOptions == null ? new DefaultTransportOptions.Builder() : config.transportOptions.toBuilder();
             config.transportOptions = fn.apply(builder).build();
-            return this;
-        }
-
-        public Builder transportFactory(Function<ElasticsearchTransportConfig, ElasticsearchTransport> factory) {
-            config.transportFactory = factory;
-            return this;
-        }
-
-        /**
-         * Should we use the legacy http implementation based on Elasticsearch's Low Level Rest Client?
-         */
-        public Builder useLegacyTransport(boolean useLegacyTransport) {
-            if (useLegacyTransport) {
-                config.transportFactory = RestClientTransport.FACTORY;
-            } else {
-                config.transportFactory = null;
-            }
-            return this;
+            return self();
         }
 
-        private void checkNull(Object value, String name, String other) {
+        protected void checkNull(Object value, String name, String other) {
             if (value != null) {
-                throw new IllegalStateException("Cannot set both " + other + " and " + name + ".");
+                throw new IllegalArgumentException("Cannot set both " + other + " and " + name + ".");
             }
         }
     }

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

@@ -20,7 +20,6 @@
 package co.elastic.clients.transport.rest5_client;
 
 import co.elastic.clients.json.JsonpMapper;
-import co.elastic.clients.transport.ElasticsearchTransport;
 import co.elastic.clients.transport.ElasticsearchTransportBase;
 import co.elastic.clients.transport.Transport;
 import co.elastic.clients.transport.ElasticsearchTransportConfig;
@@ -33,15 +32,9 @@
 
 import javax.annotation.Nullable;
 import java.util.Base64;
-import java.util.function.Function;
 
 public class Rest5ClientTransport extends ElasticsearchTransportBase {
 
-    /**
-     * Factory function to be used for {@link ElasticsearchTransportConfig#transportFactory()}.
-     */
-    public static final Function<ElasticsearchTransportConfig, ElasticsearchTransport> FACTORY = Rest5ClientTransport::new;
-
     private final Rest5Client restClient;
 
     public Rest5ClientTransport(ElasticsearchTransportConfig config) {
@@ -90,6 +83,8 @@ private static Rest5Client buildRest5Client(ElasticsearchTransportConfig config)
             restClientBuilder.setSSLContext(config.sslContext());
         }
 
+        restClientBuilder.setCompressionEnabled(config.useCompression());
+
         return restClientBuilder.build();
     }