[fixup] rename options builder class

Author: emerkle826

core/src/main/java/com/datastax/oss/driver/api/core/session/SessionBuilder.java

@@ -72,7 +72,7 @@ public abstract class SessionBuilder<SelfT extends SessionBuilder, SessionT> {
   private ImmutableMap.Builder<String, Predicate<Node>> nodeFilters = ImmutableMap.builder();
   protected CqlIdentifier keyspace;
   private ClassLoader classLoader = null;
-  protected Map<String, String> startupOptions = new HashMap<>();
+  protected Map<String, String> additionalStartupOptions = new HashMap<>();
 
   /**
    * Sets the configuration loader to use.
@@ -259,6 +259,20 @@ public SelfT withClassLoader(@Nullable ClassLoader classLoader) {
     return self;
   }
 
+  /**
+   * A {@link Map} of custom options to send in the Startup message.
+   *
+   * <p>This is used when a client wants/needs to send additional options in the Startup message
+   * that the driver doesn't already provide. The driver should already provide CQL_VERSION,
+   * COMPRESSION, DRIVER_NAME and DRIVER_VERSION options, so those should NOT be explicitly set via
+   * this method.
+   */
+  @NonNull
+  public SelfT withAdditionalStartupOptions(@Nullable Map<String, String> options) {
+    this.additionalStartupOptions = options;
+    return self;
+  }
+
   /**
    * Creates the session with the options set by this builder.
    *
@@ -343,16 +357,10 @@ protected DriverContext buildContext(
         requestTracker,
         nodeFilters,
         classLoader,
-        startupOptions);
+        additionalStartupOptions);
   }
 
   private static <T> T buildIfNull(T value, Supplier<T> builder) {
     return (value == null) ? builder.get() : value;
   }
-
-  @NonNull
-  public SelfT withStartupOptions(@Nullable Map<String, String> options) {
-    this.startupOptions = options;
-    return self;
-  }
 }

core/src/main/java/com/datastax/oss/driver/internal/core/context/DefaultDriverContext.java

@@ -73,7 +73,6 @@
 import com.datastax.oss.driver.internal.core.util.concurrent.LazyReference;
 import com.datastax.oss.protocol.internal.Compressor;
 import com.datastax.oss.protocol.internal.FrameCodec;
-import com.datastax.oss.protocol.internal.util.collection.NullAllowingImmutableMap;
 import edu.umd.cs.findbugs.annotations.NonNull;
 import edu.umd.cs.findbugs.annotations.Nullable;
 import io.netty.buffer.ByteBuf;
@@ -182,6 +181,7 @@ public class DefaultDriverContext implements InternalDriverContext {
   private final LazyReference<NodeStateListener> nodeStateListenerRef;
   private final LazyReference<SchemaChangeListener> schemaChangeListenerRef;
   private final LazyReference<RequestTracker> requestTrackerRef;
+  private final LazyReference<StartupOptionsBuilder> startupOptionsBuilderRef;
 
   private final DriverConfig config;
   private final DriverConfigLoader configLoader;
@@ -193,7 +193,6 @@ public class DefaultDriverContext implements InternalDriverContext {
   private final RequestTracker requestTrackerFromBuilder;
   private final Map<String, Predicate<Node>> nodeFiltersFromBuilder;
   private final ClassLoader classLoader;
-  private final Map<String, String> startupOptions;
 
   public DefaultDriverContext(
       DriverConfigLoader configLoader,
@@ -203,7 +202,7 @@ public DefaultDriverContext(
       RequestTracker requestTracker,
       Map<String, Predicate<Node>> nodeFilters,
       ClassLoader classLoader,
-      Map<String, String> extraStartupOptions) {
+      Map<String, String> additionalStartupOptions) {
     this.config = configLoader.getInitialConfig();
     this.configLoader = configLoader;
     DriverExecutionProfile defaultProfile = config.getDefaultProfile();
@@ -231,20 +230,23 @@ public DefaultDriverContext(
             "requestTracker", () -> buildRequestTracker(requestTrackerFromBuilder), cycleDetector);
     this.nodeFiltersFromBuilder = nodeFilters;
     this.classLoader = classLoader;
-    this.startupOptions = buildStartupOptions(extraStartupOptions);
+    this.startupOptionsBuilderRef =
+        new LazyReference<>(
+            "startupOptionsBuilder",
+            () -> buildStartupOptions(additionalStartupOptions),
+            cycleDetector);
   }
 
   /**
-   * Builds a map of options to use when sending a Startup message. The options argument passed in
-   * will append to, or overwrite, the Internal default options sent by the driver.
+   * Builds a map of options to send in a Startup message. The map will contain any internal options
+   * built into the driver (i.e. CQL_VERSION, COMPRESSION, DRIVER_NAME and DRIVER_VERSION), as well
+   * as any custom options passed in. This method will typically be called during the session
+   * building process, with the options passed here being set by {@link
+   * com.datastax.oss.driver.api.core.session.SessionBuilder#withCustomStartupOptions(java.util.Map)}
    */
-  protected Map<String, String> buildStartupOptions(Map<String, String> options) {
-    NullAllowingImmutableMap.Builder<String, String> builder = NullAllowingImmutableMap.builder();
-    builder.putAll(new InternalStartupOptions(this).getOptions());
-    if (options != null) {
-      builder.putAll(options);
-    }
-    return builder.build();
+  protected StartupOptionsBuilder buildStartupOptions(
+      Map<String, String> additionalStartupOptions) {
+    return new StartupOptionsBuilder(this).withAdditionalOptions(additionalStartupOptions);
   }
 
   protected Map<String, LoadBalancingPolicy> buildLoadBalancingPolicies() {
@@ -752,6 +754,6 @@ public ProtocolVersion getProtocolVersion() {
   @NonNull
   @Override
   public Map<String, String> getStartupOptions() {
-    return startupOptions;
+    return startupOptionsBuilderRef.get().build();
   }
 }

core/src/main/java/com/datastax/oss/driver/internal/core/context/InternalStartupOptions.java

@@ -0,0 +1,100 @@
+/*
+ * Copyright DataStax, Inc.
+ *
+ * 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 com.datastax.oss.driver.internal.core.context;
+
+import com.datastax.oss.driver.api.core.MavenCoordinates;
+import com.datastax.oss.driver.internal.core.DefaultMavenCoordinates;
+import com.datastax.oss.protocol.internal.request.Startup;
+import com.datastax.oss.protocol.internal.util.collection.NullAllowingImmutableMap;
+import java.util.HashMap;
+import java.util.Map;
+import net.jcip.annotations.Immutable;
+
+@Immutable
+public class StartupOptionsBuilder {
+
+  public static final String DRIVER_NAME_KEY = "DRIVER_NAME";
+  public static final String DRIVER_VERSION_KEY = "DRIVER_VERSION";
+
+  private static final MavenCoordinates MAVEN_COORDINATES =
+      DefaultMavenCoordinates.buildFromResource(
+          StartupOptionsBuilder.class.getResource("/com/datastax/oss/driver/Driver.properties"));
+
+  private final InternalDriverContext context;
+  private final Map<String, String> additionalOptions = new HashMap<>();
+
+  public StartupOptionsBuilder(InternalDriverContext context) {
+    this.context = context;
+  }
+
+  /**
+   * Adds additional startup options to the builder.
+   *
+   * <p>The additional options set here should NOT include DRIVER_NAME, DRIVER_VERSION, CQL_VERSION
+   * or COMPRESSION as those are derived from the driver itself.
+   *
+   * @param additionalOptions Extra options to send in a Startup message.
+   */
+  public StartupOptionsBuilder withAdditionalOptions(Map<String, String> additionalOptions) {
+    if (additionalOptions != null) {
+      additionalOptions
+          .entrySet()
+          .forEach(
+              (entry) -> {
+                String additionalOptionKey = entry.getKey();
+                String additionalOptionValue = entry.getValue();
+                // only add non-internal options
+                if (!DRIVER_NAME_KEY.equals(additionalOptionKey)
+                    && !DRIVER_VERSION_KEY.equals(additionalOptionKey)
+                    && !Startup.COMPRESSION_KEY.equals(additionalOptionKey)
+                    && !Startup.CQL_VERSION_KEY.equals(additionalOptionKey)) {
+                  this.additionalOptions.put(additionalOptionKey, additionalOptionValue);
+                }
+              });
+    }
+    return this;
+  }
+
+  /**
+   * Builds a map of options to send in a Startup message.
+   *
+   * <p>The default set of options are built here and include {@link
+   * com.datastax.oss.protocol.internal.request.Startup#COMPRESSION_KEY} (if the context passed in
+   * has a compressor/algorithm set), and the driver's {@link #DRIVER_NAME_KEY} and {@link
+   * #DRIVER_VERSION_KEY}. The {@link com.datastax.oss.protocol.internal.request.Startup}
+   * constructor will add {@link
+   * com.datastax.oss.protocol.internal.request.Startup#CQL_VERSION_KEY}.
+   *
+   * <p>Additional options can be set via {@link #withAdditionalOptions(java.util.Map)}.
+   *
+   * @return Map of Startup Options.
+   */
+  public Map<String, String> build() {
+    NullAllowingImmutableMap.Builder<String, String> builder =
+        NullAllowingImmutableMap.builder(3 + additionalOptions.size());
+    // add compression option
+    String compressionAlgorithm = context.getCompressor().algorithm();
+    if (compressionAlgorithm != null && !compressionAlgorithm.trim().isEmpty()) {
+      builder.put(Startup.COMPRESSION_KEY, compressionAlgorithm.trim());
+    }
+    // add driver name and version
+    builder
+        .put(DRIVER_NAME_KEY, MAVEN_COORDINATES.getName())
+        .put(DRIVER_VERSION_KEY, MAVEN_COORDINATES.getVersion().toString());
+    // add any additonal options
+    return builder.putAll(additionalOptions).build();
+  }
+}