HBASE-22903 : Table to RegionStatesCount metrics - Use for broken alter_status command

hbase-client/src/main/java/org/apache/hadoop/hbase/ClusterMetrics.java

@@ -23,6 +23,7 @@
 import java.util.List;
 import java.util.Map;
 import org.apache.hadoop.hbase.client.RegionInfo;
+import org.apache.hadoop.hbase.client.RegionStatesCount;
 import org.apache.hadoop.hbase.master.RegionState;
 import org.apache.yetus.audience.InterfaceAudience;
 
@@ -152,6 +153,14 @@ default double getAverageLoad() {
     return (double)getRegionCount() / (double)serverSize;
   }
 
+  /**
+   * Provide region states count for given table.
+   * e.g howmany regions of give table are opened/closed/rit etc
+   *
+   * @return map of table to region states count
+   */
+  Map<TableName, RegionStatesCount> getTableRegionStatesCount();
+
   /**
    * Kinds of ClusterMetrics
    */
@@ -199,6 +208,10 @@ enum Option {
     /**
      * metrics about live region servers name
      */
-    SERVERS_NAME
+    SERVERS_NAME,
+    /**
+     * metrics about table to no of regions status count
+     */
+    TABLE_TO_REGIONS_COUNT,
   }
 }

hbase-client/src/main/java/org/apache/hadoop/hbase/ClusterMetricsBuilder.java

@@ -26,6 +26,8 @@
 import java.util.Map;
 import java.util.TreeMap;
 import java.util.stream.Collectors;
+
+import org.apache.hadoop.hbase.client.RegionStatesCount;
 import org.apache.hadoop.hbase.master.RegionState;
 import org.apache.yetus.audience.InterfaceAudience;
 
@@ -70,7 +72,14 @@ public static ClusterStatusProtos.ClusterStatus toClusterStatus(ClusterMetrics m
             .collect(Collectors.toList()))
         .setMasterInfoPort(metrics.getMasterInfoPort())
         .addAllServersName(metrics.getServersName().stream().map(ProtobufUtil::toServerName)
-            .collect(Collectors.toList()));
+          .collect(Collectors.toList()))
+        .addAllTableRegionStatesCount(metrics.getTableRegionStatesCount().entrySet().stream()
+          .map(status ->
+            ClusterStatusProtos.TableRegionStatesCount.newBuilder()
+              .setTableName(ProtobufUtil.toProtoTableName((status.getKey())))
+              .setRegionStatesCount(ProtobufUtil.toTableRegionStatesCount(status.getValue()))
+              .build())
+          .collect(Collectors.toList()));
     if (metrics.getMasterName() != null) {
       builder.setMaster(ProtobufUtil.toServerName((metrics.getMasterName())));
     }
@@ -108,7 +117,12 @@ public static ClusterMetrics toClusterMetrics(
             .map(HBaseProtos.Coprocessor::getName)
             .collect(Collectors.toList()))
         .setServerNames(proto.getServersNameList().stream().map(ProtobufUtil::toServerName)
-            .collect(Collectors.toList()));
+            .collect(Collectors.toList()))
+        .setTableRegionStatesCount(
+          proto.getTableRegionStatesCountList().stream()
+          .collect(Collectors.toMap(
+            e -> ProtobufUtil.toTableName(e.getTableName()),
+            e -> ProtobufUtil.toTableRegionStatesCount(e.getRegionStatesCount()))));
     if (proto.hasClusterId()) {
       builder.setClusterId(ClusterId.convert(proto.getClusterId()).toString());
     }
@@ -149,6 +163,7 @@ public static ClusterMetrics.Option toOption(ClusterStatusProtos.Option option)
       case BALANCER_ON: return ClusterMetrics.Option.BALANCER_ON;
       case SERVERS_NAME: return ClusterMetrics.Option.SERVERS_NAME;
       case MASTER_INFO_PORT: return ClusterMetrics.Option.MASTER_INFO_PORT;
+      case TABLE_TO_REGIONS_COUNT: return ClusterMetrics.Option.TABLE_TO_REGIONS_COUNT;
       // should not reach here
       default: throw new IllegalArgumentException("Invalid option: " + option);
     }
@@ -172,6 +187,7 @@ public static ClusterStatusProtos.Option toOption(ClusterMetrics.Option option)
       case BALANCER_ON: return ClusterStatusProtos.Option.BALANCER_ON;
       case SERVERS_NAME: return Option.SERVERS_NAME;
       case MASTER_INFO_PORT: return ClusterStatusProtos.Option.MASTER_INFO_PORT;
+      case TABLE_TO_REGIONS_COUNT: return ClusterStatusProtos.Option.TABLE_TO_REGIONS_COUNT;
       // should not reach here
       default: throw new IllegalArgumentException("Invalid option: " + option);
     }
@@ -214,6 +230,7 @@ public static ClusterMetricsBuilder newBuilder() {
   private Boolean balancerOn;
   private int masterInfoPort;
   private List<ServerName> serversName = Collections.emptyList();
+  private Map<TableName, RegionStatesCount> tableRegionStatesCount = Collections.emptyMap();
 
   private ClusterMetricsBuilder() {
   }
@@ -263,6 +280,13 @@ public ClusterMetricsBuilder setServerNames(List<ServerName> serversName) {
     this.serversName = serversName;
     return this;
   }
+
+  public ClusterMetricsBuilder setTableRegionStatesCount(
+      Map<TableName, RegionStatesCount> tableRegionStatesCount) {
+    this.tableRegionStatesCount = tableRegionStatesCount;
+    return this;
+  }
+
   public ClusterMetrics build() {
     return new ClusterMetricsImpl(
         hbaseVersion,
@@ -275,7 +299,9 @@ public ClusterMetrics build() {
         masterCoprocessorNames,
         balancerOn,
         masterInfoPort,
-        serversName);
+        serversName,
+        tableRegionStatesCount
+    );
   }
   private static class ClusterMetricsImpl implements ClusterMetrics {
     @Nullable
@@ -293,6 +319,7 @@ private static class ClusterMetricsImpl implements ClusterMetrics {
     private final Boolean balancerOn;
     private final int masterInfoPort;
     private final List<ServerName> serversName;
+    private final Map<TableName, RegionStatesCount> tableRegionStatesCount;
 
     ClusterMetricsImpl(String hbaseVersion, List<ServerName> deadServerNames,
         Map<ServerName, ServerMetrics> liveServerMetrics,
@@ -303,7 +330,8 @@ private static class ClusterMetricsImpl implements ClusterMetrics {
         List<String> masterCoprocessorNames,
         Boolean balancerOn,
         int masterInfoPort,
-        List<ServerName> serversName) {
+        List<ServerName> serversName,
+        Map<TableName, RegionStatesCount> tableRegionStatesCount) {
       this.hbaseVersion = hbaseVersion;
       this.deadServerNames = Preconditions.checkNotNull(deadServerNames);
       this.liveServerMetrics = Preconditions.checkNotNull(liveServerMetrics);
@@ -315,6 +343,7 @@ private static class ClusterMetricsImpl implements ClusterMetrics {
       this.balancerOn = balancerOn;
       this.masterInfoPort = masterInfoPort;
       this.serversName = serversName;
+      this.tableRegionStatesCount = Preconditions.checkNotNull(tableRegionStatesCount);
     }
 
     @Override
@@ -372,6 +401,11 @@ public List<ServerName> getServersName() {
       return Collections.unmodifiableList(serversName);
     }
 
+    @Override
+    public Map<TableName, RegionStatesCount> getTableRegionStatesCount() {
+      return Collections.unmodifiableMap(tableRegionStatesCount);
+    }
+
     @Override
     public String toString() {
       StringBuilder sb = new StringBuilder(1024);

hbase-client/src/main/java/org/apache/hadoop/hbase/client/RegionStatesCount.java

@@ -0,0 +1,167 @@
+/*
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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 org.apache.hadoop.hbase.client;
+
+import org.apache.yetus.audience.InterfaceAudience;
+
+@InterfaceAudience.Private
+public final class RegionStatesCount {
+
+  private int openRegions;
+  private int splitRegions;
+  private int closedRegions;
+  private int regionsInTransition;
+  private int totalRegions;
+
+  private RegionStatesCount() {
+  }
+
+  public int getClosedRegions() {
+    return closedRegions;
+  }
+
+  public int getOpenRegions() {
+    return openRegions;
+  }
+
+  public int getSplitRegions() {
+    return splitRegions;
+  }
+
+  public int getRegionsInTransition() {
+    return regionsInTransition;
+  }
+
+  public int getTotalRegions() {
+    return totalRegions;
+  }
+
+  private void setClosedRegions(int closedRegions) {
+    this.closedRegions = closedRegions;
+  }
+
+  private void setOpenRegions(int openRegions) {
+    this.openRegions = openRegions;
+  }
+
+  private void setSplitRegions(int splitRegions) {
+    this.splitRegions = splitRegions;
+  }
+
+  private void setRegionsInTransition(int regionsInTransition) {
+    this.regionsInTransition = regionsInTransition;
+  }
+
+  private void setTotalRegions(int totalRegions) {
+    this.totalRegions = totalRegions;
+  }
+
+  public static class RegionStatesCountBuilder {
+    private int openRegions;
+    private int splitRegions;
+    private int closedRegions;
+    private int regionsInTransition;
+    private int totalRegions;
+
+    public RegionStatesCountBuilder setOpenRegions(int openRegions) {
+      this.openRegions = openRegions;
+      return this;
+    }
+
+    public RegionStatesCountBuilder setSplitRegions(int splitRegions) {
+      this.splitRegions = splitRegions;
+      return this;
+    }
+
+    public RegionStatesCountBuilder setClosedRegions(int closedRegions) {
+      this.closedRegions = closedRegions;
+      return this;
+    }
+
+    public RegionStatesCountBuilder setRegionsInTransition(int regionsInTransition) {
+      this.regionsInTransition = regionsInTransition;
+      return this;
+    }
+
+    public RegionStatesCountBuilder setTotalRegions(int totalRegions) {
+      this.totalRegions = totalRegions;
+      return this;
+    }
+
+    public RegionStatesCount build() {
+      RegionStatesCount regionStatesCount=new RegionStatesCount();
+      regionStatesCount.setOpenRegions(openRegions);
+      regionStatesCount.setClosedRegions(closedRegions);
+      regionStatesCount.setRegionsInTransition(regionsInTransition);
+      regionStatesCount.setSplitRegions(splitRegions);
+      regionStatesCount.setTotalRegions(totalRegions);
+      return regionStatesCount;
+    }
+  }
+
+  @Override
+  public String toString() {
+    final StringBuilder sb = new StringBuilder("RegionStatesCount{");
+    sb.append("openRegions=").append(openRegions);
+    sb.append(", splitRegions=").append(splitRegions);
+    sb.append(", closedRegions=").append(closedRegions);
+    sb.append(", regionsInTransition=").append(regionsInTransition);
+    sb.append(", totalRegions=").append(totalRegions);
+    sb.append('}');
+    return sb.toString();
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) {
+      return true;
+    }
+    if (o == null || getClass() != o.getClass()) {
+      return false;
+    }
+
+    RegionStatesCount that = (RegionStatesCount) o;
+
+    if (openRegions != that.openRegions) {
+      return false;
+    }
+    if (splitRegions != that.splitRegions) {
+      return false;
+    }
+    if (closedRegions != that.closedRegions) {
+      return false;
+    }
+    if (regionsInTransition != that.regionsInTransition) {
+      return false;
+    }
+    return totalRegions == that.totalRegions;
+  }
+
+  @Override
+  public int hashCode() {
+    int result = openRegions;
+    result = 31 * result + splitRegions;
+    result = 31 * result + closedRegions;
+    result = 31 * result + regionsInTransition;
+    result = 31 * result + totalRegions;
+    return result;
+  }
+
+}

hbase-client/src/main/java/org/apache/hadoop/hbase/shaded/protobuf/ProtobufUtil.java

@@ -79,6 +79,7 @@
 import org.apache.hadoop.hbase.client.Put;
 import org.apache.hadoop.hbase.client.RegionInfoBuilder;
 import org.apache.hadoop.hbase.client.RegionLoadStats;
+import org.apache.hadoop.hbase.client.RegionStatesCount;
 import org.apache.hadoop.hbase.client.Result;
 import org.apache.hadoop.hbase.client.Scan;
 import org.apache.hadoop.hbase.client.SnapshotDescription;
@@ -3297,4 +3298,51 @@ public static Set<String> toCompactedStoreFiles(byte[] bytes) throws IOException
     }
     return Collections.emptySet();
   }
+
+  public static ClusterStatusProtos.RegionStatesCount toTableRegionStatesCount(
+      RegionStatesCount regionStatesCount) {
+    int openRegions = 0;
+    int splitRegions = 0;
+    int closedRegions = 0;
+    int regionsInTransition = 0;
+    int totalRegions = 0;
+    if (regionStatesCount != null) {
+      openRegions = regionStatesCount.getOpenRegions();
+      splitRegions = regionStatesCount.getSplitRegions();
+      closedRegions = regionStatesCount.getClosedRegions();
+      regionsInTransition = regionStatesCount.getRegionsInTransition();
+      totalRegions = regionStatesCount.getTotalRegions();
+    }
+    return ClusterStatusProtos.RegionStatesCount.newBuilder()
+      .setOpenRegions(openRegions)
+      .setSplitRegions(splitRegions)
+      .setClosedRegions(closedRegions)
+      .setRegionsInTransition(regionsInTransition)
+      .setTotalRegions(totalRegions)
+      .build();
+  }
+
+  public static RegionStatesCount toTableRegionStatesCount(
+    ClusterStatusProtos.RegionStatesCount regionStatesCount) {
+    int openRegions = 0;
+    int splitRegions = 0;
+    int closedRegions = 0;
+    int regionsInTransition = 0;
+    int totalRegions = 0;
+    if (regionStatesCount != null) {
+      closedRegions = regionStatesCount.getClosedRegions();
+      regionsInTransition = regionStatesCount.getRegionsInTransition();
+      openRegions = regionStatesCount.getOpenRegions();
+      splitRegions = regionStatesCount.getSplitRegions();
+      totalRegions = regionStatesCount.getTotalRegions();
+    }
+    return new RegionStatesCount.RegionStatesCountBuilder()
+      .setOpenRegions(openRegions)
+      .setSplitRegions(splitRegions)
+      .setClosedRegions(closedRegions)
+      .setRegionsInTransition(regionsInTransition)
+      .setTotalRegions(totalRegions)
+      .build();
+  }
+
 }