Review Board 1.7.22


HBASE-5719 Enhance hbck to sideline overlapped mega regions

Review Request #4649 - Created April 4, 2012 and submitted

Jimmy Xiang
trunk
HBASE-5719
Reviewers
hbase
jmhsieh
hbase-git
Make it configurable to sideline some regions in big overlapped groups which hbck doesn't handle currently.

The regions chose to sideline are those which overlap with most other regions.
mvn -PlocalTests -Dtest=TestHBaseFsck* clean test

Also tested in real system to fix inconsistencies.
src/main/java/org/apache/hadoop/hbase/util/HBaseFsck.java
Diff Revision 1 Diff Revision 2
[20] 135 lines
[+20]
136
@InterfaceAudience.Public
136
@InterfaceAudience.Public
137
@InterfaceStability.Evolving
137
@InterfaceStability.Evolving
138
public class HBaseFsck {
138
public class HBaseFsck {
139
  public static final long DEFAULT_TIME_LAG = 60000; // default value of 1 minute
139
  public static final long DEFAULT_TIME_LAG = 60000; // default value of 1 minute
140
  public static final long DEFAULT_SLEEP_BEFORE_RERUN = 10000;
140
  public static final long DEFAULT_SLEEP_BEFORE_RERUN = 10000;
141
//  private static final int MAX_NUM_THREADS = 50; // #threads to contact regions
141
  private static final int MAX_NUM_THREADS = 50; // #threads to contact regions
142
  private static final long THREADS_KEEP_ALIVE_SECONDS = 60;
142
  private static final long THREADS_KEEP_ALIVE_SECONDS = 60;
143
  private static boolean rsSupportsOffline = true;
143
  private static boolean rsSupportsOffline = true;

    
   
144
  private static final int DEFAULT_OVERLAPS_TO_SIDELINE = 2;
144
  private static final int DEFAULT_MAX_MERGE = 5;
145
  private static final int DEFAULT_MAX_MERGE = 5;
145

    
   
146

   
146
  /**********************
147
  /**********************
147
   * Internal resources
148
   * Internal resources
148
   **********************/
149
   **********************/
149
  private static final Log LOG = LogFactory.getLog(HBaseFsck.class.getName());
150
  private static final Log LOG = LogFactory.getLog(HBaseFsck.class.getName());
150
  private Configuration conf;
151
  private Configuration conf;
151
  private ClusterStatus status;
152
  private ClusterStatus status;
152
  private HConnection connection;
153
  private HConnection connection;
153
  private HBaseAdmin admin;
154
  private HBaseAdmin admin;
154
  private HTable meta;
155
  private HTable meta;
155
  private ThreadPoolExecutor executor; // threads to retrieve data from regionservers
156
  private ThreadPoolExecutor executor; // threads to retrieve data from regionservers
156
//  private int numThreads = MAX_NUM_THREADS;

   
157
  private long startMillis = System.currentTimeMillis();
157
  private long startMillis = System.currentTimeMillis();
158

    
   
158

   
159
  /***********
159
  /***********
160
   * Options
160
   * Options
161
   ***********/
161
   ***********/
[+20] [20] 6 lines
[+20] public class HBaseFsck {
168
  private boolean fixHdfsOrphans = false; // fix fs holes (missing .regioninfo)
168
  private boolean fixHdfsOrphans = false; // fix fs holes (missing .regioninfo)
169

    
   
169

   
170
  // limit fixes to listed tables, if empty atttempt to fix all
170
  // limit fixes to listed tables, if empty atttempt to fix all
171
  private List<byte[]> tablesToFix = new ArrayList<byte[]>();
171
  private List<byte[]> tablesToFix = new ArrayList<byte[]>();
172
  private int maxMerge = DEFAULT_MAX_MERGE; // maximum number of overlapping regions to merge
172
  private int maxMerge = DEFAULT_MAX_MERGE; // maximum number of overlapping regions to merge
173
  private int maxOverlapsToBreak = 2; // maximum number of overlapping regions to break
173
  private int maxOverlapsToSideline = DEFAULT_OVERLAPS_TO_SIDELINE; // maximum number of overlapping regions to sideline
174
  private boolean breakMegaOverlaps = false; // break overlaps with >maxMerge regions?
174
  private boolean sidelineBigOverlaps = false; // sideline overlaps with >maxMerge regions
175

    
   
175

   
176
  private boolean rerun = false; // if we tried to fix something, rerun hbck
176
  private boolean rerun = false; // if we tried to fix something, rerun hbck
177
  private static boolean summary = false; // if we want to print less output
177
  private static boolean summary = false; // if we want to print less output
178
  private boolean checkMetaOnly = false;
178
  private boolean checkMetaOnly = false;
179

    
   
179

   
[+20] [20] 35 lines
[+20] public class HBaseFsck {
215
   */
215
   */
216
  public HBaseFsck(Configuration conf) throws MasterNotRunningException,
216
  public HBaseFsck(Configuration conf) throws MasterNotRunningException,
217
      ZooKeeperConnectionException, IOException {
217
      ZooKeeperConnectionException, IOException {
218
    this.conf = conf;
218
    this.conf = conf;
219

    
   
219

   
220
    int numThreads = conf.getInt("hbasefsck.numthreads", Integer.MAX_VALUE);
220
    int numThreads = conf.getInt("hbasefsck.numthreads", MAX_NUM_THREADS);
221
    executor = new ThreadPoolExecutor(1, numThreads,
221
    executor = new ThreadPoolExecutor(1, numThreads,
222
        THREADS_KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
222
        THREADS_KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
223
        new SynchronousQueue<Runnable>());
223
        new SynchronousQueue<Runnable>());
224
    executor.allowCoreThreadTimeOut(true);
224
    executor.allowCoreThreadTimeOut(true);
225
  }
225
  }
[+20] [20] 1316 lines
[+20] [+] public class TableInfo {
1542
    TreeSet <ServerName> deployedOn;
1542
    TreeSet <ServerName> deployedOn;
1543

    
   
1543

   
1544
    // backwards regions
1544
    // backwards regions
1545
    final List<HbckInfo> backwards = new ArrayList<HbckInfo>();
1545
    final List<HbckInfo> backwards = new ArrayList<HbckInfo>();
1546

    
   
1546

   
1547
    // sidelined mega regions
1547
    // sidelined big overlapped regions
1548
    final Map<Path, HbckInfo> sidelinedMegaRegions = new HashMap<Path, HbckInfo>();
1548
    final Map<Path, HbckInfo> sidelinedRegions = new HashMap<Path, HbckInfo>();
1549

    
   
1549

   
1550
    // region split calculator
1550
    // region split calculator
1551
    final RegionSplitCalculator<HbckInfo> sc = new RegionSplitCalculator<HbckInfo>(cmp);
1551
    final RegionSplitCalculator<HbckInfo> sc = new RegionSplitCalculator<HbckInfo>(cmp);
1552

    
   
1552

   
1553
    // Histogram of different HTableDescriptors found.  Ideally there is only one!
1553
    // Histogram of different HTableDescriptors found.  Ideally there is only one!
[+20] [20] 195 lines
[+20] [+] public void handleOverlapGroup(Collection<HbckInfo> overlap)
1749
          return;
1749
          return;
1750
        }
1750
        }
1751

    
   
1751

   
1752
        if (overlap.size() > maxMerge) {
1752
        if (overlap.size() > maxMerge) {
1753
          LOG.warn("Overlap group has " + overlap.size() + " overlapping " +
1753
          LOG.warn("Overlap group has " + overlap.size() + " overlapping " +
1754
            "regions which is greater than the max number of regions to merge");
1754
            "regions which is greater than " + maxMerge + ", the max number of regions to merge");
1755
          if (breakMegaOverlaps) {
1755
          if (sidelineBigOverlaps) {
1756
            breakMegaOverlaps(overlap);
1756
            // we only sideline big overlapped groups that exceeds the max number of regions to merge

    
   
1757
            sidelineBigOverlaps(overlap);
1757
          }
1758
          }
1758
          return;
1759
          return;
1759
        }
1760
        }
1760

    
   
1761

   
1761
        mergeOverlaps(overlap);
1762
        mergeOverlaps(overlap);
[+20] [20] 65 lines
[+20] public void handleOverlapGroup(Collection<HbckInfo> overlap)
1827
        if (didFix) {
1828
        if (didFix) {
1828
          fixes++;
1829
          fixes++;
1829
        }
1830
        }
1830
      }
1831
      }
1831

    
   
1832

   
1832
      void breakMegaOverlaps(
1833
      /**
1833
          Collection<HbckInfo> megaOverlap) throws IOException {
1834
       * Sideline some regions in a big overlap group so that it
1834
        int overlapsToBreak = megaOverlap.size() - maxMerge;
1835
       * will have fewer regions, and it is easier to merge them later on.
1835
        if (overlapsToBreak > maxOverlapsToBreak) {
1836
       *
1836
          overlapsToBreak = maxOverlapsToBreak;
1837
       * @param bigOverlap the overlapped group with regions more than maxMerge
1837
        }
1838
       * @throws IOException
1838
        List<HbckInfo> megaRegions =
1839
       */
1839
          RegionSplitCalculator.findMegaRanges(megaOverlap, overlapsToBreak);
1840
      void sidelineBigOverlaps(
1840
        if (megaRegions.isEmpty()) {
1841
          Collection<HbckInfo> bigOverlap) throws IOException {
1841
          LOG.error("Failed to find the overlap mega region");
1842
        int overlapsToSideline = bigOverlap.size() - maxMerge;
1842
          System.out.println("Total number of regions: " + megaOverlap.size());
1843
        if (overlapsToSideline > maxOverlapsToSideline) {
1843
          for (HbckInfo r : megaOverlap) {
1844
          overlapsToSideline = maxOverlapsToSideline;
1844
            System.out.print("[ " + r.toString() + ", "

   
1845
              + Bytes.toStringBinary(r.getEndKey()) + "]\n");

   
1846
          }

   
1847
          return;

   
1848
        }
1845
        }

    
   
1846
        List<HbckInfo> regionsToSideline =

    
   
1847
          RegionSplitCalculator.findBigRanges(bigOverlap, overlapsToSideline);
1849
        FileSystem fs = FileSystem.get(conf);
1848
        FileSystem fs = FileSystem.get(conf);
1850
        for (HbckInfo megaRegion: megaRegions) {
1849
        for (HbckInfo regionToSideline: regionsToSideline) {
1851
          try {
1850
          try {
1852
            closeRegion(megaRegion);
1851
            LOG.info("Closing region: " + regionToSideline);
1853
          } catch (IOException ioe) {
1852
            closeRegion(regionToSideline);
1854
            // TODO exercise this

   
1855
            LOG.warn("Was unable to close region " + megaRegion.getRegionNameAsString()

   
1856
              + ".  Just continuing... ");

   
1857
          } catch (InterruptedException ie) {
1853
          } catch (InterruptedException ie) {
1858
            LOG.warn("Was unable to close region " + megaRegion.getRegionNameAsString()
1854
            LOG.warn("Was unable to close region " + regionToSideline.getRegionNameAsString()
1859
              + ".  Interrupted.");
1855
              + ".  Interrupted.");
1860
            throw new IOException(ie);
1856
            throw new IOException(ie);
1861
          }
1857
          }
1862
  

   
1863
          try {

   
1864
            LOG.info("Offlining region: " + megaRegion);

   
1865
            offline(megaRegion.getRegionName());

   
1866
          } catch (IOException ioe) {

   
1867
            LOG.warn("Unable to offline region from master: " + megaRegion, ioe);

   
1868
          }

   
1869

    
   
1858

   
1870
          System.out.println("Before sideline mega region: " + megaRegion.toString());
1859
          LOG.info("Offlining region: " + regionToSideline);
1871
          Path sidelineRegionDir = sidelineRegionDir(fs, megaRegion);
1860
          offline(regionToSideline.getRegionName());

    
   
1861

   

    
   
1862
          LOG.debug("Before sideline big overlapped region: " + regionToSideline.toString());

    
   
1863
          Path sidelineRegionDir = sidelineRegionDir(fs, regionToSideline);
1872
          if (sidelineRegionDir != null) {
1864
          if (sidelineRegionDir != null) {
1873
            sidelinedMegaRegions.put(sidelineRegionDir, megaRegion);
1865
            sidelinedRegions.put(sidelineRegionDir, regionToSideline);
1874
            System.out.println("After sidelined mega region: "
1866
            LOG.debug("After sidelined big overlapped region: "
1875
              + megaRegion.getRegionNameAsString()
1867
              + regionToSideline.getRegionNameAsString()
1876
              + " to " + sidelineRegionDir.toString());
1868
              + " to " + sidelineRegionDir.toString());
1877
            fixes++;
1869
            fixes++;
1878
          }
1870
          }
1879
        }
1871
        }
1880
      }
1872
      }
[+20] [20] 91 lines
[+20] [+] public boolean checkRegionChain(TableIntegrityErrorHandler handler) throws IOException {
1972
        dumpOverlapProblems(overlapGroups);
1964
        dumpOverlapProblems(overlapGroups);
1973
        System.out.println("There are " + overlapGroups.keySet().size()
1965
        System.out.println("There are " + overlapGroups.keySet().size()
1974
            + " overlap groups with " + overlapGroups.size()
1966
            + " overlap groups with " + overlapGroups.size()
1975
            + " overlapping regions");
1967
            + " overlapping regions");
1976
      }
1968
      }
1977
      if (!sidelinedMegaRegions.isEmpty()) {
1969
      if (!sidelinedRegions.isEmpty()) {
1978
        LOG.warn("Sidelined mega regions, please bulk load them!");
1970
        LOG.warn("Sidelined big overlapped regions, please bulk load them!");
1979
        System.out.println("---- Table '"  +  this.tableName
1971
        System.out.println("---- Table '"  +  this.tableName
1980
            + "': sidelined mega regions");
1972
            + "': sidelined big overlapped regions");
1981
        dumpSidelinedMegaRegions(sidelinedMegaRegions);
1973
        dumpSidelinedRegions(sidelinedRegions);
1982
      }
1974
      }
1983
      return errors.getErrorList().size() == originalErrorsCount;
1975
      return errors.getErrorList().size() == originalErrorsCount;
1984
    }
1976
    }
1985

    
   
1977

   
1986
    /**
1978
    /**
[+20] [20] 26 lines
[+20] [+] public void dumpOverlapProblems(Multimap<byte[], HbckInfo> regions) {
2013
      }
2005
      }
2014
      System.out.println("----");
2006
      System.out.println("----");
2015
    }
2007
    }
2016
  }
2008
  }
2017

    
   
2009

   
2018
  public void dumpSidelinedMegaRegions(Map<Path, HbckInfo> regions) {
2010
  public void dumpSidelinedRegions(Map<Path, HbckInfo> regions) {
2019
    for (Path k : regions.keySet()) {
2011
    for (Path k : regions.keySet()) {
2020
      System.out.println("To be bulk loaded sidelined mega region dir: "
2012
      System.out.println("To be bulk loaded sidelined region dir: "
2021
        + k.toString());
2013
        + k.toString());
2022
    }
2014
    }
2023
  }
2015
  }
2024

    
   
2016

   
2025
  public Multimap<byte[], HbckInfo> getOverlapGroups(
2017
  public Multimap<byte[], HbckInfo> getOverlapGroups(
[+20] [20] 793 lines
[+20] [+] public void setFixHdfsOrphans(boolean shouldFix) {
2819

    
   
2811

   
2820
  boolean shouldFixHdfsOrphans() {
2812
  boolean shouldFixHdfsOrphans() {
2821
    return fixHdfsOrphans;
2813
    return fixHdfsOrphans;
2822
  }
2814
  }
2823

    
   
2815

   
2824
  /**
2816
  public void setSidelineBigOverlaps(boolean sbo) {
2825
   * @param mm maximum number of regions to merge into a single region.
2817
    this.sidelineBigOverlaps = sbo;
2826
   */

   
2827
  public void setBreakMegaOverlaps(boolean bmo) {

   
2828
    this.breakMegaOverlaps = bmo;

   
2829
  }
2818
  }
2830

    
   
2819

   
2831
  public boolean shouldBreakMegaOverlaps() {
2820
  public boolean shouldSidelineBigOverlaps() {
2832
    return breakMegaOverlaps;
2821
    return sidelineBigOverlaps;
2833
  }
2822
  }
2834

    
   
2823

   
2835
  /**
2824
  /**
2836
   * @param mm maximun number of regions to merge into a single region.
2825
   * @param mm maximun number of regions to merge into a single region.
2837
   */
2826
   */
2838
  public void setMaxMerge(int mm) {
2827
  public void setMaxMerge(int mm) {
2839
    this.maxMerge = mm;
2828
    this.maxMerge = mm;
2840
  }
2829
  }
2841

    
   
2830

   
2842
  public int getMaxMerge() {
2831
  public int getMaxMerge() {
2843
    return maxMerge;
2832
    return maxMerge;
2844
  }
2833
  }
2845

    
   
2834

   
2846
  public void setMaxOverlapsToBreak(int mo) {
2835
  public void setMaxOverlapsToSideline(int mo) {
2847
    this.maxOverlapsToBreak = mo;
2836
    this.maxOverlapsToSideline = mo;
2848
  }
2837
  }
2849

    
   
2838

   
2850
  public int getMaxOverlapsToBreak() {
2839
  public int getMaxOverlapsToSideline() {
2851
    return maxOverlapsToBreak;
2840
    return maxOverlapsToSideline;
2852
  }
2841
  }
2853

    
   
2842

   
2854
  /**
2843
  /**
2855
   * Only fix tables specified by the list
2844
   * Only fix tables specified by the list
2856
   */
2845
   */
[+20] [20] 40 lines
[+20] [+] protected static void printUsageAndExit() {
2897
    System.err.println("   -fixMeta          Try to fix meta problems.  This assumes HDFS region info is good.");
2886
    System.err.println("   -fixMeta          Try to fix meta problems.  This assumes HDFS region info is good.");
2898
    System.err.println("   -fixHdfsHoles     Try to fix region holes in hdfs.");
2887
    System.err.println("   -fixHdfsHoles     Try to fix region holes in hdfs.");
2899
    System.err.println("   -fixHdfsOrphans   Try to fix region dirs with no .regioninfo file in hdfs");
2888
    System.err.println("   -fixHdfsOrphans   Try to fix region dirs with no .regioninfo file in hdfs");
2900
    System.err.println("   -fixHdfsOverlaps  Try to fix region overlaps in hdfs.");
2889
    System.err.println("   -fixHdfsOverlaps  Try to fix region overlaps in hdfs.");
2901
    System.err.println("   -maxMerge <n>     When fixing region overlaps, allow at most <n> regions to merge. (n=" + DEFAULT_MAX_MERGE +" by default)");
2890
    System.err.println("   -maxMerge <n>     When fixing region overlaps, allow at most <n> regions to merge. (n=" + DEFAULT_MAX_MERGE +" by default)");

    
   
2891
    System.err.println("   -sidelineBigOverlaps  When fixing region overlaps, allow to sideline big overlaps");

    
   
2892
    System.err.println("   -maxOverlapsToSideline <n>  When fixing region overlaps, allow at most <n> regions to sideline. (n=" + DEFAULT_OVERLAPS_TO_SIDELINE +" by default)");
2902
    System.err.println("");
2893
    System.err.println("");
2903
    System.err.println("   -repair           Shortcut for -fixAssignments -fixMeta -fixHdfsHoles -fixHdfsOrphans -fixHdfsOverlaps");
2894
    System.err.println("   -repair           Shortcut for -fixAssignments -fixMeta -fixHdfsHoles -fixHdfsOrphans -fixHdfsOverlaps -sidelineBigOverlaps");
2904
    System.err.println("   -repairHoles      Shortcut for -fixAssignments -fixMeta -fixHdfsHoles -fixHdfsOrphans");
2895
    System.err.println("   -repairHoles      Shortcut for -fixAssignments -fixMeta -fixHdfsHoles -fixHdfsOrphans");
2905

    
   
2896

   
2906
    Runtime.getRuntime().exit(-2);
2897
    Runtime.getRuntime().exit(-2);
2907
  }
2898
  }
2908

    
   
2899

   
[+20] [20] 52 lines
[+20] [+] public static void main(String[] args) throws Exception {
2961
        fsck.setFixHdfsHoles(true);
2952
        fsck.setFixHdfsHoles(true);
2962
      } else if (cmd.equals("-fixHdfsOrphans")) {
2953
      } else if (cmd.equals("-fixHdfsOrphans")) {
2963
        fsck.setFixHdfsOrphans(true);
2954
        fsck.setFixHdfsOrphans(true);
2964
      } else if (cmd.equals("-fixHdfsOverlaps")) {
2955
      } else if (cmd.equals("-fixHdfsOverlaps")) {
2965
        fsck.setFixHdfsOverlaps(true);
2956
        fsck.setFixHdfsOverlaps(true);
2966
      } else if (cmd.equals("-breakMegaOverlaps")) {
2957
      } else if (cmd.equals("-sidelineBigOverlaps")) {
2967
        fsck.setBreakMegaOverlaps(true);
2958
        fsck.setSidelineBigOverlaps(true);
2968
      } else if (cmd.equals("-repair")) {
2959
      } else if (cmd.equals("-repair")) {
2969
        // this attempts to merge overlapping hdfs regions, needs testing
2960
        // this attempts to merge overlapping hdfs regions, needs testing
2970
        // under load
2961
        // under load
2971
        fsck.setFixHdfsHoles(true);
2962
        fsck.setFixHdfsHoles(true);
2972
        fsck.setFixHdfsOrphans(true);
2963
        fsck.setFixHdfsOrphans(true);
2973
        fsck.setFixMeta(true);
2964
        fsck.setFixMeta(true);
2974
        fsck.setFixAssignments(true);
2965
        fsck.setFixAssignments(true);
2975
        fsck.setFixHdfsOverlaps(true);
2966
        fsck.setFixHdfsOverlaps(true);
2976
        fsck.setBreakMegaOverlaps(true);
2967
        fsck.setSidelineBigOverlaps(true);
2977
      } else if (cmd.equals("-repairHoles")) {
2968
      } else if (cmd.equals("-repairHoles")) {
2978
        // this will make all missing hdfs regions available but may lose data
2969
        // this will make all missing hdfs regions available but may lose data
2979
        fsck.setFixHdfsHoles(true);
2970
        fsck.setFixHdfsHoles(true);
2980
        fsck.setFixHdfsOrphans(false);
2971
        fsck.setFixHdfsOrphans(false);
2981
        fsck.setFixMeta(true);
2972
        fsck.setFixMeta(true);
2982
        fsck.setFixAssignments(true);
2973
        fsck.setFixAssignments(true);
2983
        fsck.setFixHdfsOverlaps(false);
2974
        fsck.setFixHdfsOverlaps(false);
2984
        fsck.setBreakMegaOverlaps(false);
2975
        fsck.setSidelineBigOverlaps(false);
2985
      } else if (cmd.equals("-maxOverlapsToBreak")) {
2976
      } else if (cmd.equals("-maxOverlapsToSideline")) {
2986
        if (i == args.length - 1) {
2977
        if (i == args.length - 1) {
2987
          System.err.println("HBaseFsck: -maxOverlapsToBreak needs a value.");
2978
          System.err.println("HBaseFsck: -maxOverlapsToSideline needs a value.");
2988
          printUsageAndExit();
2979
          printUsageAndExit();
2989
        }
2980
        }
2990
        try {
2981
        try {
2991
          int maxOverlapsToBreak = Integer.parseInt(args[i+1]);
2982
          int maxOverlapsToSideline = Integer.parseInt(args[i+1]);
2992
          fsck.setMaxOverlapsToBreak(maxOverlapsToBreak);
2983
          fsck.setMaxOverlapsToSideline(maxOverlapsToSideline);
2993
        } catch (NumberFormatException e) {
2984
        } catch (NumberFormatException e) {
2994
          System.err.println("-maxOverlapsToBreak needs a numeric value.");
2985
          System.err.println("-maxOverlapsToSideline needs a numeric value.");
2995
          printUsageAndExit();
2986
          printUsageAndExit();
2996
        }
2987
        }
2997
        i++;
2988
        i++;
2998
      } else if (cmd.equals("-maxMerge")) {
2989
      } else if (cmd.equals("-maxMerge")) {
2999
        if (i == args.length - 1) {
2990
        if (i == args.length - 1) {
[+20] [20] 81 lines
src/main/java/org/apache/hadoop/hbase/util/RegionSplitCalculator.java
Diff Revision 1 Diff Revision 2
 
src/test/java/org/apache/hadoop/hbase/util/TestRegionSplitCalculator.java
Diff Revision 1 Diff Revision 2
 
  1. src/main/java/org/apache/hadoop/hbase/util/HBaseFsck.java: Loading...
  2. src/main/java/org/apache/hadoop/hbase/util/RegionSplitCalculator.java: Loading...
  3. src/test/java/org/apache/hadoop/hbase/util/TestRegionSplitCalculator.java: Loading...