chore: cleanup SessionPoolOptions (#3171)

Remove some unused options and make some fields final.

Author: olavloite

google-cloud-spanner/src/main/java/com/google/cloud/spanner/SessionPoolOptions.java

@@ -74,8 +74,6 @@ public class SessionPoolOptions {
 
   private final boolean useMultiplexedSession;
 
-  private final boolean useRandomChannelHint;
-
   // TODO: Change to use java.time.Duration.
   private final Duration multiplexedSessionMaintenanceDuration;
 
@@ -110,7 +108,6 @@ private SessionPoolOptions(Builder builder) {
         builder.useMultiplexedSession
             && !Boolean.parseBoolean(
                 System.getenv("GOOGLE_CLOUD_SPANNER_FORCE_DISABLE_MULTIPLEXED_SESSIONS"));
-    this.useRandomChannelHint = builder.useRandomChannelHint;
     this.multiplexedSessionMaintenanceDuration = builder.multiplexedSessionMaintenanceDuration;
   }
 
@@ -147,7 +144,6 @@ public boolean equals(Object o) {
             this.inactiveTransactionRemovalOptions, other.inactiveTransactionRemovalOptions)
         && Objects.equals(this.poolMaintainerClock, other.poolMaintainerClock)
         && Objects.equals(this.useMultiplexedSession, other.useMultiplexedSession)
-        && Objects.equals(this.useRandomChannelHint, other.useRandomChannelHint)
         && Objects.equals(
             this.multiplexedSessionMaintenanceDuration,
             other.multiplexedSessionMaintenanceDuration);
@@ -178,7 +174,6 @@ public int hashCode() {
         this.inactiveTransactionRemovalOptions,
         this.poolMaintainerClock,
         this.useMultiplexedSession,
-        this.useRandomChannelHint,
         this.multiplexedSessionMaintenanceDuration);
   }
 
@@ -312,10 +307,6 @@ public boolean getUseMultiplexedSession() {
     return useMultiplexedSession;
   }
 
-  boolean isUseRandomChannelHint() {
-    return useRandomChannelHint;
-  }
-
   Duration getMultiplexedSessionMaintenanceDuration() {
     return multiplexedSessionMaintenanceDuration;
   }
@@ -350,24 +341,24 @@ enum ActionOnInactiveTransaction {
   static class InactiveTransactionRemovalOptions {
 
     /** Option to set the behaviour when there are inactive transactions. */
-    private ActionOnInactiveTransaction actionOnInactiveTransaction;
+    private final ActionOnInactiveTransaction actionOnInactiveTransaction;
 
     /**
      * Frequency for closing inactive transactions. Between two consecutive task executions, it's
      * ensured that the duration is greater or equal to this duration.
      */
-    private Duration executionFrequency;
+    private final Duration executionFrequency;
 
     /**
      * Long-running transactions will be cleaned up if utilisation is greater than the below value.
      */
-    private double usedSessionsRatioThreshold;
+    private final double usedSessionsRatioThreshold;
 
     /**
      * A transaction is considered to be idle if it has not been used for a duration greater than
      * the below value.
      */
-    private Duration idleTimeThreshold;
+    private final Duration idleTimeThreshold;
 
     InactiveTransactionRemovalOptions(final Builder builder) {
       this.actionOnInactiveTransaction = builder.actionOnInactiveTransaction;
@@ -509,7 +500,7 @@ public static class Builder {
     private boolean autoDetectDialect = false;
     private Duration waitForMinSessions = Duration.ZERO;
     private Duration acquireSessionTimeout = Duration.ofSeconds(60);
-    private Position releaseToPosition = getReleaseToPositionFromSystemProperty();
+    private final Position releaseToPosition = getReleaseToPositionFromSystemProperty();
     /**
      * The session pool will randomize the position of a session that is being returned when this
      * threshold is exceeded. That is: If the transactions per second exceeds this threshold, then
@@ -520,8 +511,6 @@ public static class Builder {
 
     private boolean useMultiplexedSession = getUseMultiplexedSessionFromEnvVariable();
 
-    private boolean useRandomChannelHint;
-
     private Duration multiplexedSessionMaintenanceDuration = Duration.ofDays(7);
     private Clock poolMaintainerClock = Clock.INSTANCE;
 
@@ -760,11 +749,6 @@ Builder setUseMultiplexedSession(boolean useMultiplexedSession) {
       return this;
     }
 
-    Builder setUseRandomChannelHint(boolean useRandomChannelHint) {
-      this.useRandomChannelHint = useRandomChannelHint;
-      return this;
-    }
-
     @VisibleForTesting
     Builder setMultiplexedSessionMaintenanceDuration(
         Duration multiplexedSessionMaintenanceDuration) {
@@ -878,11 +862,6 @@ public Builder setAcquireSessionTimeout(Duration acquireSessionTimeout) {
       return this;
     }
 
-    Builder setReleaseToPosition(Position releaseToPosition) {
-      this.releaseToPosition = Preconditions.checkNotNull(releaseToPosition);
-      return this;
-    }
-
     Builder setRandomizePositionQPSThreshold(long randomizePositionQPSThreshold) {
       Preconditions.checkArgument(
           randomizePositionQPSThreshold >= 0L, "randomizePositionQPSThreshold must be >= 0");

google-cloud-spanner/src/test/java/com/google/cloud/spanner/SessionPoolOptionsTest.java

@@ -28,6 +28,7 @@
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
+import java.util.concurrent.ThreadLocalRandom;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
@@ -169,6 +170,36 @@ public void setCloseIfInactiveTransactions() {
     assertTrue(sessionPoolOptions.closeInactiveTransactions());
   }
 
+  @Test
+  public void testSetUsedSessionsRatioThreshold() {
+    double threshold = ThreadLocalRandom.current().nextDouble();
+    InactiveTransactionRemovalOptions inactiveTransactionRemovalOptions =
+        InactiveTransactionRemovalOptions.newBuilder()
+            .setUsedSessionsRatioThreshold(threshold)
+            .build();
+    assertEquals(
+        threshold, inactiveTransactionRemovalOptions.getUsedSessionsRatioThreshold(), 0.0d);
+  }
+
+  @Test
+  public void testBlockIfPoolExhausted() {
+    assertTrue(SessionPoolOptions.newBuilder().build().isBlockIfPoolExhausted());
+    assertTrue(
+        SessionPoolOptions.newBuilder().setBlockIfPoolExhausted().build().isBlockIfPoolExhausted());
+    assertFalse(
+        SessionPoolOptions.newBuilder().setFailIfPoolExhausted().build().isBlockIfPoolExhausted());
+  }
+
+  @Test
+  public void testFailIfSessionNotFound() {
+    assertFalse(SessionPoolOptions.newBuilder().build().isFailIfSessionNotFound());
+    assertTrue(
+        SessionPoolOptions.newBuilder()
+            .setFailIfSessionNotFound()
+            .build()
+            .isFailIfSessionNotFound());
+  }
+
   @Test(expected = IllegalArgumentException.class)
   public void setNegativeExecutionFrequency() {
     InactiveTransactionRemovalOptions inactiveTransactionRemovalOptions =