HBASE-28663 Graceful shutdown of CanaryTool timeouts (branch-2)

hbase-server/src/main/java/org/apache/hadoop/hbase/tool/CanaryTool.java

@@ -198,6 +198,10 @@ public interface Sink {
     long getWriteSuccessCount();
 
     long incWriteSuccessCount();
+
+    void stop();
+
+    boolean isStopped();
   }
 
   /**
@@ -208,6 +212,7 @@ public static class StdOutSink implements Sink {
         readSuccessCount = new AtomicLong(0), writeSuccessCount = new AtomicLong(0);
     private Map<String, String> readFailures = new ConcurrentHashMap<>();
     private Map<String, String> writeFailures = new ConcurrentHashMap<>();
+    private volatile boolean stopped = false;
 
     @Override
     public long getReadFailureCount() {
@@ -268,6 +273,15 @@ public long getWriteSuccessCount() {
     public long incWriteSuccessCount() {
       return writeSuccessCount.incrementAndGet();
     }
+
+    public void stop() {
+      stopped = true;
+    }
+
+    @Override
+    public boolean isStopped() {
+      return stopped;
+    }
   }
 
   /**
@@ -444,6 +458,9 @@ public ZookeeperTask(Connection connection, String host, String znode, int timeo
 
     @Override
     public Void call() throws Exception {
+      if (this.sink.isStopped()) {
+        return null;
+      }
       ZooKeeper zooKeeper = null;
       try {
         zooKeeper = new ZooKeeper(host, timeout, EmptyWatcher.instance);
@@ -498,6 +515,9 @@ public enum TaskType {
 
     @Override
     public Void call() {
+      if (this.sink.isStopped()) {
+        return null;
+      }
       switch (taskType) {
         case READ:
           return read();
@@ -685,6 +705,9 @@ static class RegionServerTask implements Callable<Void> {
 
     @Override
     public Void call() {
+      if (this.sink.isStopped()) {
+        return null;
+      }
       TableName tableName = null;
       Table table = null;
       Get get = null;
@@ -1075,6 +1098,7 @@ private int runMonitor(String[] monitorTargets) throws Exception {
             if (currentTimeLength > timeout) {
               LOG.error("The monitor is running too long (" + currentTimeLength
                 + ") after timeout limit:" + timeout + " will be killed itself !!");
+              monitorThread.interrupt();
               if (monitor.initialized) {
                 return TIMEOUT_ERROR_EXIT_CODE;
               } else {
@@ -1113,6 +1137,15 @@ public Map<String, String> getWriteFailures() {
     return sink.getWriteFailures();
   }
 
+  /**
+   * Return a CanaryTool.Sink object containing the detailed results of the canary run. The Sink may
+   * not have been created if a Monitor thread is not yet running.
+   * @return the active Sink if one exists, null otherwise.
+   */
+  public Sink getActiveSink() {
+    return sink;
+  }
+
   private void printUsageAndExit() {
     System.err.println(
       "Usage: canary [OPTIONS] [<TABLE1> [<TABLE2]...] | [<REGIONSERVER1> [<REGIONSERVER2]..]");
@@ -1159,10 +1192,11 @@ private void printUsageAndExit() {
 
   Sink getSink(Configuration configuration, Class clazz) {
     // In test context, this.sink might be set. Use it if non-null. For testing.
-    return this.sink != null
-      ? this.sink
-      : (Sink) ReflectionUtils
+    if (this.sink == null) {
+      this.sink = (Sink) ReflectionUtils
         .newInstance(configuration.getClass("hbase.canary.sink.class", clazz, Sink.class));
+    }
+    return this.sink;
   }
 
   /**
@@ -1366,6 +1400,7 @@ public boolean finalCheckForErrors() {
 
     @Override
     public void close() throws IOException {
+      this.sink.stop();
       if (this.admin != null) {
         this.admin.close();
       }

hbase-server/src/test/java/org/apache/hadoop/hbase/tool/TestCanaryTool.java

@@ -17,6 +17,7 @@
  */
 package org.apache.hadoop.hbase.tool;
 
+import static org.apache.hadoop.hbase.regionserver.TestRegionServerNoMaster.closeRegion;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotEquals;
@@ -38,17 +39,20 @@
 import java.util.Map;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.ScheduledThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
 import org.apache.hadoop.conf.Configuration;
 import org.apache.hadoop.hbase.HBaseClassTestRule;
 import org.apache.hadoop.hbase.HBaseConfiguration;
 import org.apache.hadoop.hbase.HBaseTestingUtility;
 import org.apache.hadoop.hbase.HConstants;
+import org.apache.hadoop.hbase.HRegionInfo;
 import org.apache.hadoop.hbase.ServerName;
 import org.apache.hadoop.hbase.TableName;
 import org.apache.hadoop.hbase.client.ColumnFamilyDescriptor;
 import org.apache.hadoop.hbase.client.Put;
 import org.apache.hadoop.hbase.client.RegionInfo;
 import org.apache.hadoop.hbase.client.Table;
+import org.apache.hadoop.hbase.regionserver.HRegionServer;
 import org.apache.hadoop.hbase.testclassification.LargeTests;
 import org.apache.hadoop.hbase.util.Bytes;
 import org.apache.hadoop.util.ToolRunner;
@@ -130,6 +134,51 @@ public void testBasicCanaryWorks() throws Exception {
       isA(ColumnFamilyDescriptor.class), anyLong());
   }
 
+  /**
+   * When CanaryTool times out, it should stop scanning and shutdown quickly and gracefully. This
+   * test helps to confirm that threadpools do not continue executing work after the canary
+   * finishes. It also verifies sink behavior and measures correct failure counts in the sink.
+   * @throws Exception if it can't create a table, communicate with minicluster, or run the canary.
+   */
+  @Test
+  public void testCanaryStopsScanningAfterTimeout() throws Exception {
+    // Prepare a table with multiple regions, and close those regions on the regionserver.
+    // Do not notify HMaster or META. CanaryTool will scan and receive NotServingRegionExceptions.
+    final TableName tableName = TableName.valueOf(name.getMethodName());
+    // Close the unused Table reference returned by createMultiRegionTable.
+    testingUtility.createMultiRegionTable(tableName, new byte[][] { FAMILY }).close();
+    List<RegionInfo> regions = testingUtility.getAdmin().getRegions(tableName);
+    assertTrue("verify table has multiple regions", regions.size() > 1);
+    HRegionServer regionserver = testingUtility.getMiniHBaseCluster().getRegionServer(0);
+    for (RegionInfo region : regions) {
+      closeRegion(testingUtility, regionserver, new HRegionInfo(region));
+    }
+
+    // Run CanaryTool with 1 thread. This thread will attempt to scan the first region.
+    // It will use default rpc retries and receive NotServingRegionExceptions for many seconds
+    // according to HConstants.RETRY_BACKOFF. The CanaryTool timeout is set to 4 seconds, so it
+    // will time out before the first region scan is complete.
+    ExecutorService executor = new ScheduledThreadPoolExecutor(1);
+    CanaryTool canary = new CanaryTool(executor);
+    String[] args = { "-t", "4000", tableName.getNameAsString() };
+    int retCode = ToolRunner.run(testingUtility.getConfiguration(), canary, args);
+    executor.shutdown();
+    try {
+      if (!executor.awaitTermination(3, TimeUnit.SECONDS)) {
+        executor.shutdownNow();
+      }
+    } catch (InterruptedException e) {
+      executor.shutdownNow();
+    }
+
+    CanaryTool.Sink sink = canary.getActiveSink();
+    assertEquals("verify canary timed out with TIMEOUT_ERROR_EXIT_CODE", 3, retCode);
+    assertEquals("verify only the first region failed", 1, sink.getReadFailureCount());
+    assertEquals("verify no successful reads", 0, sink.getReadSuccessCount());
+    assertEquals("verify we were attempting to scan all regions", regions.size(),
+      ((CanaryTool.RegionStdOutSink) sink).getTotalExpectedRegions());
+  }
+
   @Test
   public void testCanaryRegionTaskReadAllCF() throws Exception {
     final TableName tableName = TableName.valueOf(name.getMethodName());