add stubs and make changes to BigtableChannelPool to allow for integration

Change-Id: I19dc8fa9d6b64f2f97b0784ec7ca8456b6b7442f

Author: nicholsl

google-cloud-bigtable/src/main/java/com/google/cloud/bigtable/gaxx/grpc/BigtableChannelPool.java

@@ -65,6 +65,7 @@ class BigtableChannelPool extends ManagedChannel {
 
   private final Object entryWriteLock = new Object();
   @VisibleForTesting final AtomicReference<ImmutableList<Entry>> entries = new AtomicReference<>();
+  private final ChannelPoolHealthChecker channelPoolHealthChecker = new ChannelPoolHealthChecker(() -> entries.get());
   private final AtomicInteger indexTicker = new AtomicInteger();
   private final String authority;
 
@@ -441,6 +442,10 @@ private Entry(ManagedChannel channel) {
       this.channel = channel;
     }
 
+    ManagedChannel getManagedChannel() {
+      return this.channel;
+    }
+
     int getAndResetMaxOutstanding() {
       return maxOutstanding.getAndSet(outstandingRpcs.get());
     }

google-cloud-bigtable/src/main/java/com/google/cloud/bigtable/gaxx/grpc/ChannelHealthChecker.java

@@ -0,0 +1,105 @@
+package com.google.cloud.bigtable.gaxx.grpc;
+
+import com.google.cloud.bigtable.gaxx.grpc.BigtableChannelPool.Entry;
+import com.google.common.collect.EvictingQueue;
+import java.time.Instant;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.locks.ReadWriteLock;
+import java.util.concurrent.locks.ReentrantReadWriteLock;
+
+/**
+ * A class with harmless method stubs for health checking a channel.
+ * The core implementation logic has been removed.
+ */
+public class ChannelHealthChecker {
+
+  // Configuration constants
+  private static final int WINDOW_DURATION_MINUTES = 5;
+  private static final int PROBE_RATE_SECONDS = 30;
+  private static final int PROBE_DEADLINE_MILLISECONDS = 500;
+  private static final int MIN_PROBES_FOR_EVALUATION = 4;
+  private static final int FAILURE_PERCENT_THRESHOLD = 60;
+
+  // Class fields
+  final Entry entry;
+  private final ScheduledExecutorService probeExecutor;
+  private volatile ScheduledFuture<?> scheduledProbeFuture;
+  private final ReadWriteLock probeResultsLock = new ReentrantReadWriteLock();
+  private final EvictingQueue<ProbeResult> probeResults;
+  private final AtomicInteger probesInFlight = new AtomicInteger(0);
+
+  /**
+   * Inner class to represent the result of a single probe.
+   */
+  class ProbeResult {
+    final Instant startTime;
+    final boolean success;
+
+    ProbeResult(Instant startTime, boolean success) {
+      this.startTime = startTime;
+      this.success = success;
+    }
+
+    public boolean isSuccessful() {
+      return success;
+    }
+  }
+
+  /**
+   * Constructor for the health checker.
+   */
+  public ChannelHealthChecker(Entry entry, ScheduledExecutorService executor) {
+    int queueCapacity = (WINDOW_DURATION_MINUTES * 60) / PROBE_RATE_SECONDS;
+    this.probeResults = EvictingQueue.create(queueCapacity);
+    this.entry = entry;
+    this.probeExecutor = executor;
+    // Scheduling runProbe will go here
+  }
+
+  /**
+   * Stops the health checking process. (No-op stub)
+   */
+  public void stop() {
+    // Method stub, no operation.
+  }
+
+  /**
+   * Runs a single health probe. (No-op stub)
+   */
+  private void runProbe() {
+    // Method stub, no operation.
+  }
+
+  /**
+   * Callback for when a probe finishes. (No-op stub)
+   */
+  void probeFinished(Instant startTime, boolean success) {
+    // Method stub, no operation.
+  }
+
+  /**
+   * Returns the number of recent probes sent. (No-op stub)
+   * @return A default value of 0.
+   */
+  private int recentProbesSent() {
+    return 0;
+  }
+
+  /**
+   * Returns the number of recently failed probes. (No-op stub)
+   * @return A default value of 0.
+   */
+  public int recentlyFailedProbes() {
+    return 0;
+  }
+
+  /**
+   * Determines if the channel is healthy. (No-op stub)
+   * @return A default value of true.
+   */
+  public boolean healthy() {
+    return true;
+  }
+}

google-cloud-bigtable/src/main/java/com/google/cloud/bigtable/gaxx/grpc/ChannelPoolHealthChecker.java

@@ -0,0 +1,52 @@
+package com.google.cloud.bigtable.gaxx.grpc;
+
+import com.google.cloud.bigtable.gaxx.grpc.BigtableChannelPool.Entry;
+import com.google.common.collect.ImmutableList;
+import java.time.Duration;
+import java.time.Instant;
+import java.util.Collections;
+import java.util.Map;
+import java.util.WeakHashMap;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.function.Supplier;
+import javax.annotation.Nullable;
+
+/**
+ * Stub for a class that will manage the health checking in the BigtableChannelPool
+ */
+public class ChannelPoolHealthChecker {
+
+  // Class fields
+  private final Supplier<ImmutableList<Entry>> entrySupplier;
+  private Map<Entry, ChannelHealthChecker> healthCheckers;
+  private Instant lastEviction;
+  private ScheduledExecutorService executor;
+
+  /**
+   * Constructor for the pool health checker.
+   */
+  public ChannelPoolHealthChecker(Supplier<ImmutableList<Entry>> entrySupplier) {
+    this.healthCheckers = Collections.synchronizedMap(new WeakHashMap<>());
+    this.entrySupplier = entrySupplier;
+    this.lastEviction = Instant.MIN;
+    this.executor = Executors.newSingleThreadScheduledExecutor();
+    // Scheduling for detectAndRemoveOutlierChannels goes here
+  }
+
+  /**
+   * Finds a channel that is an outlier in terms of health. (No-op stub)
+   * @return A default value of null.
+   */
+  @Nullable
+  private Entry findOutlierEntry() {
+    return null;
+  }
+
+  /**
+   * Periodically detects and removes outlier channels from the pool. (No-op stub)
+   */
+  private void detectAndRemoveOutlierEntries() {
+    // Method stub, no operation.
+  }
+}