HBASE-26989 TestStochasticLoadBalancer fixes for performance and consistency

Author: d-c-manning

hbase-balancer/src/test/java/org/apache/hadoop/hbase/master/balancer/TestStochasticLoadBalancer.java

@@ -240,6 +240,7 @@ public void testUpdateBalancerLoadInfo(){
     BalancerClusterState clusterState = mockCluster(cluster);
     Map<TableName, Map<ServerName, List<RegionInfo>>> LoadOfAllTable =
       (Map) mockClusterServersWithTables(servers);
+    boolean oldIsByTable = conf.getBoolean(HConstants.HBASE_MASTER_LOADBALANCE_BYTABLE, false);
     try {
       boolean[] perTableBalancerConfigs = { true, false };
       for (boolean isByTable : perTableBalancerConfigs) {
@@ -262,14 +263,15 @@ public void testUpdateBalancerLoadInfo(){
         assertEquals(curOverallCost, curOverallCostInMetrics, 0.001);
       }
     }finally {
-      conf.unset(HConstants.HBASE_MASTER_LOADBALANCE_BYTABLE);
+      conf.setBoolean(HConstants.HBASE_MASTER_LOADBALANCE_BYTABLE, oldIsByTable);
       loadBalancer.onConfigurationChange(conf);
     }
   }
 
   @Test
   public void testUpdateStochasticCosts() {
     float minCost = conf.getFloat("hbase.master.balancer.stochastic.minCostNeedBalance", 0.05f);
+    boolean oldIsByTable = conf.getBoolean(HConstants.HBASE_MASTER_LOADBALANCE_BYTABLE, false);
     try {
       int[] cluster = new int[] { 10, 0 };
       Map<ServerName, List<RegionInfo>> servers = mockClusterServers(cluster);
@@ -291,14 +293,15 @@ public void testUpdateStochasticCosts() {
     } finally {
       //reset config
       conf.setFloat("hbase.master.balancer.stochastic.minCostNeedBalance", minCost);
-      conf.unset(HConstants.HBASE_MASTER_LOADBALANCE_BYTABLE);
+      conf.setBoolean(HConstants.HBASE_MASTER_LOADBALANCE_BYTABLE, oldIsByTable);
       loadBalancer.onConfigurationChange(conf);
     }
   }
 
   @Test
   public void testUpdateStochasticCostsIfBalanceNotRan() {
     float minCost = conf.getFloat("hbase.master.balancer.stochastic.minCostNeedBalance", 0.05f);
+    boolean oldIsByTable = conf.getBoolean(HConstants.HBASE_MASTER_LOADBALANCE_BYTABLE, false);
     try {
       int[] cluster = new int[] { 10, 10 };
       Map<ServerName, List<RegionInfo>> servers = mockClusterServers(cluster);
@@ -320,17 +323,22 @@ public void testUpdateStochasticCostsIfBalanceNotRan() {
     } finally {
       //reset config
       conf.setFloat("hbase.master.balancer.stochastic.minCostNeedBalance", minCost);
-      conf.unset(HConstants.HBASE_MASTER_LOADBALANCE_BYTABLE);
+      conf.setBoolean(HConstants.HBASE_MASTER_LOADBALANCE_BYTABLE, oldIsByTable);
       loadBalancer.onConfigurationChange(conf);
     }
   }
 
   @Test
   public void testNeedBalance() {
+    boolean oldIsByTable = conf.getBoolean(HConstants.HBASE_MASTER_LOADBALANCE_BYTABLE, false);
     float minCost = conf.getFloat("hbase.master.balancer.stochastic.minCostNeedBalance", 0.05f);
     float slop = conf.getFloat(HConstants.LOAD_BALANCER_SLOP_KEY, 0.2f);
+    boolean runMaxSteps = conf.getBoolean("hbase.master.balancer.stochastic.runMaxSteps", false);
+    long maxSteps = conf.getLong("hbase.master.balancer.stochastic.maxSteps", 1000000);
     conf.setFloat("hbase.master.balancer.stochastic.minCostNeedBalance", 1.0f);
     conf.setFloat(HConstants.LOAD_BALANCER_SLOP_KEY, -1f);
+    conf.setBoolean("hbase.master.balancer.stochastic.runMaxSteps", false);
+    conf.setLong("hbase.master.balancer.stochastic.maxSteps", 5000L);
     try {
       // Test with/without per table balancer.
       boolean[] perTableBalancerConfigs = {true, false};
@@ -343,23 +351,29 @@ public void testNeedBalance() {
       }
     } finally {
       // reset config
-      conf.unset(HConstants.HBASE_MASTER_LOADBALANCE_BYTABLE);
+      conf.setBoolean(HConstants.HBASE_MASTER_LOADBALANCE_BYTABLE, oldIsByTable);
       conf.setFloat("hbase.master.balancer.stochastic.minCostNeedBalance", minCost);
       conf.setFloat(HConstants.LOAD_BALANCER_SLOP_KEY, slop);
+      conf.setBoolean("hbase.master.balancer.stochastic.runMaxSteps", runMaxSteps);
+      conf.setLong("hbase.master.balancer.stochastic.maxSteps", maxSteps);
       loadBalancer.onConfigurationChange(conf);
     }
   }
 
   @Test
   public void testBalanceOfSloppyServers() {
     float minCost = conf.getFloat("hbase.master.balancer.stochastic.minCostNeedBalance", 0.025f);
+    boolean runMaxSteps = conf.getBoolean("hbase.master.balancer.stochastic.runMaxSteps", false);
+    long maxSteps = conf.getLong("hbase.master.balancer.stochastic.maxSteps", 1000000);
     try {
       // We are testing slop checks, so don't "accidentally" balance due to a minCost calculation.
       // During development, imbalance of a 100 server cluster, with one node having 10 regions
       // and the rest having 5, is 0.0048. With minCostNeedBalance default of 0.025, test should
       // validate slop checks without this override. We override just to ensure we will always
       // validate slop check here, and for small clusters as well.
       conf.setFloat("hbase.master.balancer.stochastic.minCostNeedBalance", 1.0f);
+      conf.setBoolean("hbase.master.balancer.stochastic.runMaxSteps", false);
+      conf.setLong("hbase.master.balancer.stochastic.maxSteps", 5000L);
       loadBalancer.onConfigurationChange(conf);
       for (int[] mockCluster : clusterStateMocksWithNoSlop) {
         assertTrue(hasEmptyBalancerPlans(mockCluster));
@@ -370,6 +384,8 @@ public void testBalanceOfSloppyServers() {
     } finally {
       // reset config
       conf.setFloat("hbase.master.balancer.stochastic.minCostNeedBalance", minCost);
+      conf.setBoolean("hbase.master.balancer.stochastic.runMaxSteps", runMaxSteps);
+      conf.setLong("hbase.master.balancer.stochastic.maxSteps", maxSteps);
       loadBalancer.onConfigurationChange(conf);
     }
   }
@@ -383,14 +399,21 @@ public void testSloppyTablesLoadBalanceByTable() {
         , 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5},
     };
     float minCost = conf.getFloat("hbase.master.balancer.stochastic.minCostNeedBalance", 0.025f);
+    boolean runMaxSteps = conf.getBoolean("hbase.master.balancer.stochastic.runMaxSteps", false);
+    long maxSteps = conf.getLong("hbase.master.balancer.stochastic.maxSteps", 1000000);
+    boolean oldIsByTable = conf.getBoolean(HConstants.HBASE_MASTER_LOADBALANCE_BYTABLE, false);
     try {
       conf.setFloat("hbase.master.balancer.stochastic.minCostNeedBalance", 1.0f);
+      conf.setBoolean("hbase.master.balancer.stochastic.runMaxSteps", false);
+      conf.setLong("hbase.master.balancer.stochastic.maxSteps", 5000L);
       conf.setBoolean(HConstants.HBASE_MASTER_LOADBALANCE_BYTABLE, true);
       loadBalancer.onConfigurationChange(conf);
       assertFalse(hasEmptyBalancerPlans(regionsPerServerPerTable));
     } finally {
       conf.setFloat("hbase.master.balancer.stochastic.minCostNeedBalance", minCost);
-      conf.unset(HConstants.HBASE_MASTER_LOADBALANCE_BYTABLE);
+      conf.setBoolean("hbase.master.balancer.stochastic.runMaxSteps", runMaxSteps);
+      conf.setLong("hbase.master.balancer.stochastic.maxSteps", maxSteps);
+      conf.setBoolean(HConstants.HBASE_MASTER_LOADBALANCE_BYTABLE, oldIsByTable);
       loadBalancer.onConfigurationChange(conf);
     }
   }