HBaseFsck (Apache HBase 1.2.12 API)

java.lang.Object
- org.apache.hadoop.conf.Configured
- - org.apache.hadoop.hbase.util.HBaseFsck

All Implemented Interfaces:

Closeable, AutoCloseable, org.apache.hadoop.conf.Configurable
```
@InterfaceAudience.LimitedPrivate(value="Tools")
@InterfaceStability.Evolving
public class HBaseFsck
extends org.apache.hadoop.conf.Configured
implements Closeable
```
HBaseFsck (hbck) is a tool for checking and repairing region consistency and table integrity problems in a corrupted HBase.
Region consistency checks verify that hbase:meta, region deployment on region servers and the state of data in HDFS (.regioninfo files) all are in accordance.
Table integrity checks verify that all possible row keys resolve to exactly one region of a table. This means there are no individual degenerate or backwards regions; no holes between regions; and that there are no overlapping regions.
The general repair strategy works in two phases:
1. Repair Table Integrity on HDFS. (merge or fabricate regions)
2. Repair Region Consistency with hbase:meta and assignments
For table integrity repairs, the tables' region directories are scanned for .regioninfo files. Each table's integrity is then verified. If there are any orphan regions (regions with no .regioninfo files) or holes, new regions are fabricated. Backwards regions are sidelined as well as empty degenerate (endkey==startkey) regions. If there are any overlapping regions, a new region is created and all data is merged into the new region.
Table integrity repairs deal solely with HDFS and could potentially be done offline -- the hbase region servers or master do not need to be running. This phase can eventually be used to completely reconstruct the hbase:meta table in an offline fashion.
Region consistency requires three conditions -- 1) valid .regioninfo file present in an HDFS region dir, 2) valid row with .regioninfo data in META, and 3) a region is deployed only at the regionserver that was assigned to with proper state in the master.
Region consistency repairs require hbase to be online so that hbck can contact the HBase master and region servers. The hbck#connect() method must first be called successfully. Much of the region consistency information is transient and less risky to repair.
If hbck is run from the command line, there are a handful of arguments that can be used to limit the kinds of repairs hbck will do. See the code in printUsageAndExit() for more details.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`(package private) class`	`HBaseFsck.CheckRegionConsistencyWorkItem`
`static interface`	`HBaseFsck.ErrorReporter`
`private class`	`HBaseFsck.FileLockCallable`
`(package private) static class`	`HBaseFsck.HBaseFsckTool` This is a Tool wrapper that gathers -Dxxx=yyy configuration settings from the command line.
`static class`	`HBaseFsck.HbckInfo` Maintain information about a particular region.
`(package private) static class`	`HBaseFsck.HdfsEntry` Stores the regioninfo entries from HDFS
`(package private) static class`	`HBaseFsck.MetaEntry` Stores the regioninfo entries scanned from META
`(package private) static class`	`HBaseFsck.OnlineEntry` Stores the regioninfo retrieved from Online region servers.
`(package private) static class`	`HBaseFsck.PrintingErrorReporter`
`private static class`	`HBaseFsck.RegionBoundariesInformation`
`static class`	`HBaseFsck.RegionRepairException` Exception thrown when a integrity repair operation fails in an unresolvable way.
`class`	`HBaseFsck.TableInfo` Maintain information about a particular table.
`(package private) static class`	`HBaseFsck.WorkItemHdfsDir` Contact hdfs and get all information about specified table directory into regioninfo list.
`(package private) static class`	`HBaseFsck.WorkItemHdfsRegionInfo` Contact hdfs and get all information about specified table directory into regioninfo list.
`(package private) static class`	`HBaseFsck.WorkItemOverlapMerge`
`(package private) static class`	`HBaseFsck.WorkItemRegion` Contact a region server and get all information from it

Field Summary

Fields
Modifier and Type	Field and Description
`private Admin`	`admin`
`private boolean`	`checkHdfs`
`private boolean`	`checkMetaOnly`
`private boolean`	`checkRegionBoundaries`
`(package private) static Comparator<HBaseFsck.HbckInfo>`	`cmp`
`private ClusterConnection`	`connection`
`private static int`	`DEFAULT_LOCK_FILE_ATTEMPT_MAX_SLEEP_TIME`
`private static int`	`DEFAULT_LOCK_FILE_ATTEMPT_SLEEP_INTERVAL`
`private static int`	`DEFAULT_MAX_LOCK_FILE_ATTEMPTS`
`private static int`	`DEFAULT_MAX_MERGE`
`private static int`	`DEFAULT_OVERLAPS_TO_SIDELINE`
`static long`	`DEFAULT_SLEEP_BEFORE_RERUN`
`static long`	`DEFAULT_TIME_LAG`
`private static int`	`DEFAULT_WAIT_FOR_LOCK_TIMEOUT`
`private static boolean`	`details` Options
`private static boolean`	`disableBalancer`
`private TreeSet<TableName>`	`disabledTables`
`private Set<Result>`	`emptyRegionInfoQualifiers`
`private HBaseFsck.ErrorReporter`	`errors` State
`protected ExecutorService`	`executor`
`private boolean`	`fixAny`
`private boolean`	`fixAssignments`
`private boolean`	`fixEmptyMetaCells`
`(package private) int`	`fixes`
`private boolean`	`fixHdfsHoles`
`private boolean`	`fixHdfsOrphans`
`private boolean`	`fixHdfsOverlaps`
`private boolean`	`fixMeta`
`private boolean`	`fixReferenceFiles`
`private boolean`	`fixSplitParents`
`private boolean`	`fixTableLocks`
`private boolean`	`fixTableOrphans`
`private boolean`	`fixTableZNodes`
`private boolean`	`fixVersionFile`
`private static boolean`	`forceExclusive`
`private static String`	`HBCK_LOCK_FILE`
`private org.apache.hadoop.fs.Path`	`HBCK_LOCK_PATH`
`private AtomicBoolean`	`hbckLockCleanup`
`private org.apache.hadoop.fs.FSDataOutputStream`	`hbckOutFd`
`private HFileCorruptionChecker`	`hfcc`
`private boolean`	`ignorePreCheckPermission`
`private RetryCounterFactory`	`lockFileRetryCounterFactory`
`private static org.apache.commons.logging.Log`	`LOG` Internal resources
`private static int`	`MAX_NUM_THREADS`
`private int`	`maxMerge`
`private int`	`maxOverlapsToSideline`
`private Table`	`meta`
`private Set<TableName>`	`orphanedTableZNodes` List of orphaned table ZNodes
`private List<HBaseFsck.HbckInfo>`	`orphanHdfsDirs` When initially looking at HDFS, we attempt to find any orphaned data.
`private Map<TableName,Set<String>>`	`orphanTableDirs`
`private TreeMap<String,HBaseFsck.HbckInfo>`	`regionInfoMap` This map contains the state of all hbck items.
`private boolean`	`removeParents`
`private boolean`	`rerun`
`private int`	`retcode`
`private static boolean`	`rsSupportsOffline`
`private boolean`	`sidelineBigOverlaps`
`private org.apache.hadoop.fs.Path`	`sidelineDir`
`private Map<TableName,Set<String>>`	`skippedRegions`
`private long`	`startMillis`
`private ClusterStatus`	`status`
`private static boolean`	`SUMMARY`
`private Set<TableName>`	`tablesIncluded`
`private SortedMap<TableName,HBaseFsck.TableInfo>`	`tablesInfo` This map from Tablename -> TableInfo contains the structures necessary to detect table consistency problems (holes, dupes, overlaps).
`private long`	`timelag`
`private static String`	`TO_BE_LOADED`

Constructor Summary

Constructors
Constructor and Description
`HBaseFsck(org.apache.hadoop.conf.Configuration conf)` Constructor
`HBaseFsck(org.apache.hadoop.conf.Configuration conf, ExecutorService exec)` Constructor

Method Summary

Methods
Modifier and Type	Method and Description
`private void`	`addSkippedRegion(HBaseFsck.HbckInfo hbi)`
`private void`	`adoptHdfsOrphan(HBaseFsck.HbckInfo hi)` Orphaned regions are regions without a .regioninfo file in them.
`private void`	`adoptHdfsOrphans(Collection<HBaseFsck.HbckInfo> orphanHdfsDirs)` Iterates through the list of all orphan/invalid regiondirs.
`private void`	`assignMetaReplica(int replicaId)`
`private void`	`checkAndFixConsistency()` Check consistency of all regions that have been found in previous phases.
`private void`	`checkAndFixOrphanedTableZNodes()` Check whether a orphaned table ZNode exists and fix it if requested.
`private void`	`checkAndFixTableLocks()`
`private org.apache.hadoop.fs.FSDataOutputStream`	`checkAndMarkRunningHbck()` This method maintains a lock using a file.
`private SortedMap<TableName,HBaseFsck.TableInfo>`	`checkHdfsIntegrity(boolean fixHoles, boolean fixOverlaps)`
`(package private) SortedMap<TableName,HBaseFsck.TableInfo>`	`checkIntegrity()` Checks tables integrity.
`(package private) boolean`	`checkMetaRegion()` Check values in regionInfo for hbase:meta Check if zero or more than one regions with hbase:meta are found.
`void`	`checkRegionBoundaries()`
`private void`	`checkRegionConsistency(String key, HBaseFsck.HbckInfo hbi)` Check a single region for consistency and correct deployment.
`private void`	`checkRegionConsistencyConcurrently(List<HBaseFsck.CheckRegionConsistencyWorkItem> workItems)` Check consistency of all regions using mulitple threads concurrently.
`private void`	`clearState()` Clear the current state of hbck.
`void`	`close()`
`private void`	`closeRegion(HBaseFsck.HbckInfo hi)` Attempts to undeploy a region from a region server based in information in META.
`void`	`connect()` To repair region consistency, one must call connect() in order to repair online state.
`protected HFileCorruptionChecker`	`createHFileCorruptionChecker(boolean sidelineCorruptHFiles)`
`private HRegion`	`createNewMeta()` This borrows code from MasterFileSystem.bootstrap()
`private static ExecutorService`	`createThreadPool(org.apache.hadoop.conf.Configuration conf)`
`private ZooKeeperWatcher`	`createZooKeeperWatcher()`
`static void`	`debugLsr(org.apache.hadoop.conf.Configuration conf, org.apache.hadoop.fs.Path p)` ls -r for debugging purposes
`static void`	`debugLsr(org.apache.hadoop.conf.Configuration conf, org.apache.hadoop.fs.Path p, HBaseFsck.ErrorReporter errors)` ls -r for debugging purposes
`(package private) void`	`debugLsr(org.apache.hadoop.fs.Path p)` ls -r for debugging purposes
`private void`	`deleteMetaRegion(byte[] metaKey)` Deletes region from meta table
`private void`	`deleteMetaRegion(HBaseFsck.HbckInfo hi)` Deletes region from meta table
`void`	`dumpOverlapProblems(com.google.common.collect.Multimap<byte[],HBaseFsck.HbckInfo> regions)`
`void`	`dumpSidelinedRegions(Map<org.apache.hadoop.fs.Path,HBaseFsck.HbckInfo> regions)`
`HBaseFsck`	`exec(ExecutorService exec, String[] args)`
`private boolean`	`fabricateTableInfo(FSTableDescriptors fstd, TableName tableName, Set<String> columns)` To fabricate a .tableinfo file with following contents 1.
`void`	`fixEmptyMetaCells()` To fix the empty REGIONINFO_QUALIFIER rows from hbase:meta
`void`	`fixOrphanTables()` To fix orphan table by creating a .tableinfo file under tableDir 1.
`private ArrayList<Put>`	`generatePuts(SortedMap<TableName,HBaseFsck.TableInfo> tablesInfo)` Generate set of puts to add to new meta.
`private Set<String>`	`getColumnFamilyList(Set<String> columns, HBaseFsck.HbckInfo hbi)` To get the column family list according to the column family dirs
`(package private) static HBaseFsck.ErrorReporter`	`getErrorReporter(org.apache.hadoop.conf.Configuration conf)`
`HBaseFsck.ErrorReporter`	`getErrors()`
`HFileCorruptionChecker`	`getHFilecorruptionChecker()`
`(package private) HTableDescriptor[]`	`getHTableDescriptors(List<TableName> tableNames)`
`(package private) Set<TableName>`	`getIncludedTables()`
`int`	`getMaxMerge()`
`int`	`getMaxOverlapsToSideline()`
`private ServerName`	`getMetaRegionServerName(int replicaId)`
`private HBaseFsck.HbckInfo`	`getOrCreateInfo(String name)` Gets the entry in regionInfo corresponding to the the given encoded region name.
`com.google.common.collect.Multimap<byte[],HBaseFsck.HbckInfo>`	`getOverlapGroups(TableName table)`
`int`	`getRetCode()`
`private org.apache.hadoop.fs.Path`	`getSidelineDir()`
`(package private) HTableDescriptor[]`	`getTables(AtomicInteger numSkipped)` Return a list of user-space table names whose metadata have not been modified in the last few milliseconds specified by timelag if any of the REGIONINFO_QUALIFIER, SERVER_QUALIFIER, STARTCODE_QUALIFIER, SPLITA_QUALIFIER, SPLITB_QUALIFIER have not changed in the last milliseconds specified by timelag, then the table is a candidate to be returned.
`void`	`includeTable(TableName table)`
`boolean`	`isExclusive()` Only one instance of hbck can modify HBase at a time.
`private boolean`	`isTableDisabled(HRegionInfo regionInfo)` Check if the specified region's table is disabled.
`(package private) boolean`	`isTableIncluded(TableName table)` Only check/fix tables specified by the list, Empty list means all tables are included.
`static byte[]`	`keyOnly(byte[] b)`
`private void`	`loadDeployedRegions()` Get deployed regions according to the region servers.
`private void`	`loadDisabledTables()` Load the list of disabled tables in ZK into local set.
`void`	`loadHdfsRegionDirs()` Scan HDFS for all regions, recording their information into regionInfoMap
`private void`	`loadHdfsRegioninfo(HBaseFsck.HbckInfo hbi)` Read the .regioninfo file from the file system.
`private SortedMap<TableName,HBaseFsck.TableInfo>`	`loadHdfsRegionInfos()` Populate hbi's from regionInfos loaded from file system.
`(package private) boolean`	`loadMetaEntries()` Scan hbase:meta, adding all regions found to the regionInfo map.
`private void`	`loadTableInfosForTablesWithNoRegion()` Loads table info's for tables that may not have been included, since there are no regions reported for the table, but table dir is there in hdfs
`private void`	`logParallelMerge()` Log an appropriate message about whether or not overlapping merges are computed in parallel.
`static void`	`main(String[] args)` Main program
`int`	`mergeRegionDirs(org.apache.hadoop.fs.Path targetRegionDir, HBaseFsck.HbckInfo contained)` Merge hdfs data by moving from contained HbckInfo into targetRegionDir.
`private void`	`offline(byte[] regionName)` This backwards-compatibility wrapper for permanently offlining a region that should not be alive.
`void`	`offlineHdfsIntegrityRepair()` This repair method analyzes hbase data in hdfs and repairs it to satisfy the table integrity rules.
`private void`	`offlineReferenceFileRepair()` Scan all the store file names to find any lingering reference files, which refer to some none-exiting files.
`int`	`onlineConsistencyRepair()` This repair method requires the cluster to be online since it contacts region servers and the masters.
`int`	`onlineHbck()` Contacts the master and prints out cluster-wide information
`private void`	`preCheckPermission()`
`private void`	`printTableSummary(SortedMap<TableName,HBaseFsck.TableInfo> tablesInfo)` Prints summary of all tables found on the system.
`protected HBaseFsck`	`printUsageAndExit()`
`(package private) void`	`processRegionServers(Collection<ServerName> regionServerList)` Contacts each regionserver and fetches metadata about regions.
`boolean`	`rebuildMeta(boolean fix)` Rebuilds meta from information in hdfs/fs.
`private boolean`	`recordMetaRegion()` Record the location of the hbase:meta region as found in ZooKeeper.
`private void`	`reportEmptyMetaCells()` TODO -- need to add tests for this.
`private void`	`reportTablesInFlux()` TODO -- need to add tests for this.
`private void`	`resetSplitParent(HBaseFsck.HbckInfo hi)` Reset the split parent region info in meta table
`private int`	`restoreHdfsIntegrity()` This method determines if there are table integrity errors in HDFS.
`void`	`setCheckHdfs(boolean checking)`
`(package private) void`	`setCheckMetaOnly()` Set hbase:meta check mode.
`static void`	`setDisableBalancer()` Disable the load balancer.
`static void`	`setDisplayFullReport()` Display the full report from fsck.
`void`	`setFixAssignments(boolean shouldFix)` Fix inconsistencies found by fsck.
`void`	`setFixEmptyMetaCells(boolean shouldFix)`
`void`	`setFixHdfsHoles(boolean shouldFix)`
`void`	`setFixHdfsOrphans(boolean shouldFix)`
`void`	`setFixHdfsOverlaps(boolean shouldFix)`
`void`	`setFixMeta(boolean shouldFix)`
`void`	`setFixReferenceFiles(boolean shouldFix)`
`void`	`setFixSplitParents(boolean shouldFix)`
`void`	`setFixTableLocks(boolean shouldFix)` Set table locks fix mode.
`void`	`setFixTableOrphans(boolean shouldFix)`
`void`	`setFixTableZNodes(boolean shouldFix)` Set orphaned table ZNodes fix mode.
`void`	`setFixVersionFile(boolean shouldFix)`
`static void`	`setForceExclusive()` Set exclusive mode.
`void`	`setHFileCorruptionChecker(HFileCorruptionChecker hfcc)`
`void`	`setIgnorePreCheckPermission(boolean ignorePreCheckPermission)`
`void`	`setMaxMerge(int mm)`
`void`	`setMaxOverlapsToSideline(int mo)`
`(package private) void`	`setRegionBoundariesCheck()` Set region boundaries check mode.
`void`	`setRemoveParents(boolean shouldFix)`
`void`	`setRetCode(int code)`
`(package private) void`	`setShouldRerun()` Check if we should rerun fsck again.
`void`	`setSidelineBigOverlaps(boolean sbo)`
`void`	`setSidelineDir(String sidelineDir)`
`(package private) static void`	`setSummary()` Set summary mode.
`void`	`setTimeLag(long seconds)` We are interested in only those tables that have not changed their state in hbase:meta during the last few seconds specified by hbase.admin.fsck.timelag
`(package private) boolean`	`shouldCheckHdfs()`
`boolean`	`shouldDisableBalancer()` The balancer should be disabled if we are modifying HBase.
`(package private) boolean`	`shouldFixAssignments()`
`(package private) boolean`	`shouldFixEmptyMetaCells()`
`(package private) boolean`	`shouldFixHdfsHoles()`
`(package private) boolean`	`shouldFixHdfsOrphans()`
`(package private) boolean`	`shouldFixHdfsOverlaps()`
`(package private) boolean`	`shouldFixMeta()`
`(package private) boolean`	`shouldFixReferenceFiles()`
`(package private) boolean`	`shouldFixSplitParents()`
`(package private) boolean`	`shouldFixTableOrphans()`
`boolean`	`shouldFixVersionFile()`
`boolean`	`shouldIgnorePreCheckPermission()`
`(package private) boolean`	`shouldRemoveParents()`
`(package private) boolean`	`shouldRerun()`
`boolean`	`shouldSidelineBigOverlaps()`
`(package private) org.apache.hadoop.fs.Path`	`sidelineOldMeta()`
`(package private) org.apache.hadoop.fs.Path`	`sidelineRegionDir(org.apache.hadoop.fs.FileSystem fs, HBaseFsck.HbckInfo hi)` Sideline a region dir (instead of deleting it)
`(package private) org.apache.hadoop.fs.Path`	`sidelineRegionDir(org.apache.hadoop.fs.FileSystem fs, String parentDir, HBaseFsck.HbckInfo hi)` Sideline a region dir (instead of deleting it)
`(package private) void`	`sidelineTable(org.apache.hadoop.fs.FileSystem fs, TableName tableName, org.apache.hadoop.fs.Path hbaseDir, org.apache.hadoop.fs.Path backupHbaseDir)` Side line an entire table.
`private void`	`suggestFixes(SortedMap<TableName,HBaseFsck.TableInfo> tablesInfo)` Suggest fixes for each table
`private void`	`tryAssignmentRepair(HBaseFsck.HbckInfo hbi, String msg)`
`private void`	`unassignMetaReplica(HBaseFsck.HbckInfo hi)`
`private void`	`undeployRegions(HBaseFsck.HbckInfo hi)`
`private void`	`undeployRegionsForHbi(HBaseFsck.HbckInfo hi)`
`private void`	`unlockHbck()`

Methods inherited from class org.apache.hadoop.conf.Configured
getConf, setConf

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

DEFAULT_TIME_LAG
```
public static final long DEFAULT_TIME_LAG
```
See Also:
Constant Field Values

DEFAULT_SLEEP_BEFORE_RERUN
```
public static final long DEFAULT_SLEEP_BEFORE_RERUN
```
See Also:
Constant Field Values

MAX_NUM_THREADS
```
private static final int MAX_NUM_THREADS
```
See Also:
Constant Field Values

rsSupportsOffline

private static boolean rsSupportsOffline

DEFAULT_OVERLAPS_TO_SIDELINE
```
private static final int DEFAULT_OVERLAPS_TO_SIDELINE
```
See Also:
Constant Field Values

DEFAULT_MAX_MERGE
```
private static final int DEFAULT_MAX_MERGE
```
See Also:
Constant Field Values

TO_BE_LOADED

private static final String TO_BE_LOADED

See Also:: Constant Field Values

HBCK_LOCK_FILE

private static final String HBCK_LOCK_FILE

See Also:: Constant Field Values

DEFAULT_MAX_LOCK_FILE_ATTEMPTS
```
private static final int DEFAULT_MAX_LOCK_FILE_ATTEMPTS
```
See Also:
Constant Field Values

DEFAULT_LOCK_FILE_ATTEMPT_SLEEP_INTERVAL
```
private static final int DEFAULT_LOCK_FILE_ATTEMPT_SLEEP_INTERVAL
```
See Also:
Constant Field Values

DEFAULT_LOCK_FILE_ATTEMPT_MAX_SLEEP_TIME
```
private static final int DEFAULT_LOCK_FILE_ATTEMPT_MAX_SLEEP_TIME
```
See Also:
Constant Field Values

DEFAULT_WAIT_FOR_LOCK_TIMEOUT
```
private static final int DEFAULT_WAIT_FOR_LOCK_TIMEOUT
```
See Also:
Constant Field Values

LOG

private static final org.apache.commons.logging.Log LOG

Internal resources

status
```
private ClusterStatus status
```

connection
```
private ClusterConnection connection
```

admin
```
private Admin admin
```

meta
```
private Table meta
```

executor
```
protected ExecutorService executor
```

startMillis
```
private long startMillis
```

hfcc
```
private HFileCorruptionChecker hfcc
```

retcode
```
private int retcode
```

HBCK_LOCK_PATH

private org.apache.hadoop.fs.Path HBCK_LOCK_PATH

hbckOutFd

private org.apache.hadoop.fs.FSDataOutputStream hbckOutFd

hbckLockCleanup

private final AtomicBoolean hbckLockCleanup

details
```
private static boolean details
```
Options

timelag
```
private long timelag
```

forceExclusive
```
private static boolean forceExclusive
```

disableBalancer
```
private static boolean disableBalancer
```

fixAssignments
```
private boolean fixAssignments
```

fixMeta
```
private boolean fixMeta
```

checkHdfs
```
private boolean checkHdfs
```

fixHdfsHoles
```
private boolean fixHdfsHoles
```

fixHdfsOverlaps
```
private boolean fixHdfsOverlaps
```

fixHdfsOrphans
```
private boolean fixHdfsOrphans
```

fixTableOrphans
```
private boolean fixTableOrphans
```

fixVersionFile
```
private boolean fixVersionFile
```

fixSplitParents
```
private boolean fixSplitParents
```

removeParents
```
private boolean removeParents
```

fixReferenceFiles
```
private boolean fixReferenceFiles
```

fixEmptyMetaCells
```
private boolean fixEmptyMetaCells
```

fixTableLocks
```
private boolean fixTableLocks
```

fixTableZNodes
```
private boolean fixTableZNodes
```

fixAny
```
private boolean fixAny
```

tablesIncluded
```
private Set<TableName> tablesIncluded
```

maxMerge
```
private int maxMerge
```

maxOverlapsToSideline
```
private int maxOverlapsToSideline
```

sidelineBigOverlaps
```
private boolean sidelineBigOverlaps
```

sidelineDir

private org.apache.hadoop.fs.Path sidelineDir

rerun
```
private boolean rerun
```

SUMMARY
```
private static boolean SUMMARY
```

checkMetaOnly
```
private boolean checkMetaOnly
```

checkRegionBoundaries
```
private boolean checkRegionBoundaries
```

ignorePreCheckPermission

private boolean ignorePreCheckPermission

errors

private final HBaseFsck.ErrorReporter errors

State

fixes
```
int fixes
```

regionInfoMap
```
private TreeMap<String,HBaseFsck.HbckInfo> regionInfoMap
```
This map contains the state of all hbck items. It maps from encoded region name to HbckInfo structure. The information contained in HbckInfo is used to detect and correct consistency (hdfs/meta/deployment) problems.

disabledTables

private TreeSet<TableName> disabledTables

emptyRegionInfoQualifiers

private Set<Result> emptyRegionInfoQualifiers

tablesInfo
```
private SortedMap<TableName,HBaseFsck.TableInfo> tablesInfo
```
This map from Tablename -> TableInfo contains the structures necessary to detect table consistency problems (holes, dupes, overlaps). It is sorted to prevent dupes. If tablesIncluded is empty, this map contains all tables. Otherwise, it contains only meta tables and tables in tablesIncluded, unless checkMetaOnly is specified, in which case, it contains only the meta table

orphanHdfsDirs
```
private List<HBaseFsck.HbckInfo> orphanHdfsDirs
```
When initially looking at HDFS, we attempt to find any orphaned data.

orphanTableDirs

private Map<TableName,Set<String>> orphanTableDirs

skippedRegions

private Map<TableName,Set<String>> skippedRegions

orphanedTableZNodes
```
private Set<TableName> orphanedTableZNodes
```
List of orphaned table ZNodes

lockFileRetryCounterFactory

private final RetryCounterFactory lockFileRetryCounterFactory

cmp

static final Comparator<HBaseFsck.HbckInfo> cmp

Constructor Detail

HBaseFsck

public HBaseFsck(org.apache.hadoop.conf.Configuration conf)
          throws MasterNotRunningException,
                 ZooKeeperConnectionException,
                 IOException,
                 ClassNotFoundException

Constructor

Parameters:: conf - Configuration object
Throws:: MasterNotRunningException - if the master is not running; ZooKeeperConnectionException - if unable to connect to ZooKeeper; IOException; ClassNotFoundException

HBaseFsck

public HBaseFsck(org.apache.hadoop.conf.Configuration conf,
         ExecutorService exec)
          throws MasterNotRunningException,
                 ZooKeeperConnectionException,
                 IOException,
                 ClassNotFoundException

Constructor

Parameters:: conf - Configuration object
Throws:: MasterNotRunningException - if the master is not running; ZooKeeperConnectionException - if unable to connect to ZooKeeper; IOException; ClassNotFoundException

Method Detail

createThreadPool

private static ExecutorService createThreadPool(org.apache.hadoop.conf.Configuration conf)

checkAndMarkRunningHbck
```
private org.apache.hadoop.fs.FSDataOutputStream checkAndMarkRunningHbck()
                                                                 throws IOException
```
This method maintains a lock using a file. If the creation fails we return null

Returns:
FSDataOutputStream object corresponding to the newly opened lock file

Throws:

IOException

unlockHbck
```
private void unlockHbck()
```

connect
```
public void connect()
             throws IOException
```
To repair region consistency, one must call connect() in order to repair online state.

Throws:

IOException

loadDeployedRegions

private void loadDeployedRegions()
                          throws IOException,
                                 InterruptedException

Get deployed regions according to the region servers.

Throws:: IOException; InterruptedException

clearState
```
private void clearState()
```
Clear the current state of hbck.

offlineHdfsIntegrityRepair
```
public void offlineHdfsIntegrityRepair()
                                throws IOException,
                                       InterruptedException
```
This repair method analyzes hbase data in hdfs and repairs it to satisfy the table integrity rules. HBase doesn't need to be online for this operation to work.

Throws:

IOException

InterruptedException

onlineConsistencyRepair
```
public int onlineConsistencyRepair()
                            throws IOException,
                                   org.apache.zookeeper.KeeperException,
                                   InterruptedException
```
This repair method requires the cluster to be online since it contacts region servers and the masters. It makes each region's state in HDFS, in hbase:meta, and deployments consistent.

Returns:
If > 0 , number of errors detected, if < 0 there was an unrecoverable error. If 0, we have a clean hbase.

Throws:

IOException

org.apache.zookeeper.KeeperException

InterruptedException

onlineHbck

public int onlineHbck()
               throws IOException,
                      org.apache.zookeeper.KeeperException,
                      InterruptedException,
                      com.google.protobuf.ServiceException

Contacts the master and prints out cluster-wide information

Returns:: 0 on success, non-zero on failure
Throws:: IOException; org.apache.zookeeper.KeeperException; InterruptedException; com.google.protobuf.ServiceException

keyOnly

public static byte[] keyOnly(byte[] b)

close
```
public void close()
           throws IOException
```
Specified by:

close in interface Closeable

Specified by:

close in interface AutoCloseable

Throws:

IOException

checkRegionBoundaries
```
public void checkRegionBoundaries()
```

adoptHdfsOrphans

private void adoptHdfsOrphans(Collection<HBaseFsck.HbckInfo> orphanHdfsDirs)
                       throws IOException

Iterates through the list of all orphan/invalid regiondirs.

Throws:: IOException

adoptHdfsOrphan
```
private void adoptHdfsOrphan(HBaseFsck.HbckInfo hi)
                      throws IOException
```
Orphaned regions are regions without a .regioninfo file in them. We "adopt" these orphans by creating a new region, and moving the column families, recovered edits, WALs, into the new region dir. We determine the region startkey and endkeys by looking at all of the hfiles inside the column families to identify the min and max keys. The resulting region will likely violate table integrity but will be dealt with by merging overlapping regions.

Throws:

IOException

restoreHdfsIntegrity
```
private int restoreHdfsIntegrity()
                          throws IOException,
                                 InterruptedException
```
This method determines if there are table integrity errors in HDFS. If there are errors and the appropriate "fix" options are enabled, the method will first correct orphan regions making them into legit regiondirs, and then reload to merge potentially overlapping regions.

Returns:
number of table integrity errors found

Throws:

IOException

InterruptedException

offlineReferenceFileRepair
```
private void offlineReferenceFileRepair()
                                 throws IOException
```
Scan all the store file names to find any lingering reference files, which refer to some none-exiting files. If "fix" option is enabled, any lingering reference file will be sidelined if found.
Lingering reference file prevents a region from opening. It has to be fixed before a cluster can start properly.

Throws:

IOException

reportEmptyMetaCells
```
private void reportEmptyMetaCells()
```
TODO -- need to add tests for this.

reportTablesInFlux
```
private void reportTablesInFlux()
```
TODO -- need to add tests for this.

getErrors

public HBaseFsck.ErrorReporter getErrors()

loadHdfsRegioninfo
```
private void loadHdfsRegioninfo(HBaseFsck.HbckInfo hbi)
                         throws IOException
```
Read the .regioninfo file from the file system. If there is no .regioninfo, add it to the orphan hdfs region list.

Throws:

IOException

loadHdfsRegionInfos

private SortedMap<TableName,HBaseFsck.TableInfo> loadHdfsRegionInfos()
                                                              throws IOException,
                                                                     InterruptedException

Populate hbi's from regionInfos loaded from file system.

Throws:: IOException; InterruptedException

getColumnFamilyList

private Set<String> getColumnFamilyList(Set<String> columns,
                              HBaseFsck.HbckInfo hbi)
                                 throws IOException

To get the column family list according to the column family dirs

Parameters:: columns -; hbi -
Returns:: a set of column families
Throws:: IOException

fabricateTableInfo

private boolean fabricateTableInfo(FSTableDescriptors fstd,
                         TableName tableName,
                         Set<String> columns)
                            throws IOException

To fabricate a .tableinfo file with following contents
1. the correct tablename
2. the correct colfamily list
3. the default properties for both HTableDescriptor and HColumnDescriptor

Throws:: IOException

fixEmptyMetaCells
```
public void fixEmptyMetaCells()
                       throws IOException
```
To fix the empty REGIONINFO_QUALIFIER rows from hbase:meta

Throws:

IOException

fixOrphanTables
```
public void fixOrphanTables()
                     throws IOException
```
To fix orphan table by creating a .tableinfo file under tableDir
1. if TableInfo is cached, to recover the .tableinfo accordingly
2. else create a default .tableinfo file with following items
2.1 the correct tablename
2.2 the correct colfamily list
2.3 the default properties for both HTableDescriptor and HColumnDescriptor

Throws:

IOException

createNewMeta
```
private HRegion createNewMeta()
                       throws IOException
```
This borrows code from MasterFileSystem.bootstrap()

Returns:
an open hbase:meta HRegion

Throws:

IOException

generatePuts
```
private ArrayList<Put> generatePuts(SortedMap<TableName,HBaseFsck.TableInfo> tablesInfo)
                             throws IOException
```
Generate set of puts to add to new meta. This expects the tables to be clean with no overlaps or holes. If there are any problems it returns null.

Returns:
An array list of puts to do in bulk, null if tables have problems

Throws:

IOException

suggestFixes

private void suggestFixes(SortedMap<TableName,HBaseFsck.TableInfo> tablesInfo)
                   throws IOException

Suggest fixes for each table

Throws:: IOException

rebuildMeta
```
public boolean rebuildMeta(boolean fix)
                    throws IOException,
                           InterruptedException
```
Rebuilds meta from information in hdfs/fs. Depends on configuration settings passed into hbck constructor to point to a particular fs/dir.

Parameters:
fix - flag that determines if method should attempt to fix holes

Returns:
true if successful, false if attempt failed.

Throws:

IOException

InterruptedException

logParallelMerge
```
private void logParallelMerge()
```
Log an appropriate message about whether or not overlapping merges are computed in parallel.

checkHdfsIntegrity

private SortedMap<TableName,HBaseFsck.TableInfo> checkHdfsIntegrity(boolean fixHoles,
                                                          boolean fixOverlaps)
                                                             throws IOException

Throws:: IOException

getSidelineDir

private org.apache.hadoop.fs.Path getSidelineDir()
                                          throws IOException

Throws:: IOException

sidelineRegionDir

org.apache.hadoop.fs.Path sidelineRegionDir(org.apache.hadoop.fs.FileSystem fs,
                                          HBaseFsck.HbckInfo hi)
                                      throws IOException

Sideline a region dir (instead of deleting it)

Throws:: IOException

sidelineRegionDir

org.apache.hadoop.fs.Path sidelineRegionDir(org.apache.hadoop.fs.FileSystem fs,
                                          String parentDir,
                                          HBaseFsck.HbckInfo hi)
                                      throws IOException

Sideline a region dir (instead of deleting it)

Parameters:

parentDir - if specified, the region will be sidelined to folder like .../parentDir//. The purpose is to group together similar regions sidelined, for example, those regions should be bulk loaded back later on. If null, it is ignored.

Throws:

IOException

sidelineTable

void sidelineTable(org.apache.hadoop.fs.FileSystem fs,
                 TableName tableName,
                 org.apache.hadoop.fs.Path hbaseDir,
                 org.apache.hadoop.fs.Path backupHbaseDir)
             throws IOException

Side line an entire table.

Throws:: IOException

sidelineOldMeta

org.apache.hadoop.fs.Path sidelineOldMeta()
                                    throws IOException

Returns:: Path to backup of original directory
Throws:: IOException

loadDisabledTables

private void loadDisabledTables()
                         throws ZooKeeperConnectionException,
                                IOException

Load the list of disabled tables in ZK into local set.

Throws:: ZooKeeperConnectionException; IOException

isTableDisabled
```
private boolean isTableDisabled(HRegionInfo regionInfo)
```
Check if the specified region's table is disabled.

loadHdfsRegionDirs

public void loadHdfsRegionDirs()
                        throws IOException,
                               InterruptedException

Scan HDFS for all regions, recording their information into regionInfoMap

Throws:: IOException; InterruptedException

recordMetaRegion
```
private boolean recordMetaRegion()
                          throws IOException
```
Record the location of the hbase:meta region as found in ZooKeeper.

Throws:

IOException

createZooKeeperWatcher

private ZooKeeperWatcher createZooKeeperWatcher()
                                         throws IOException

Throws:: IOException

getMetaRegionServerName

private ServerName getMetaRegionServerName(int replicaId)
                                    throws IOException,
                                           org.apache.zookeeper.KeeperException

Throws:: IOException; org.apache.zookeeper.KeeperException

processRegionServers
```
void processRegionServers(Collection<ServerName> regionServerList)
                    throws IOException,
                           InterruptedException
```
Contacts each regionserver and fetches metadata about regions.

Parameters:
regionServerList - - the list of region servers to connect to

Throws:

IOException - if a remote or network exception occurs

InterruptedException

checkAndFixConsistency

private void checkAndFixConsistency()
                             throws IOException,
                                    org.apache.zookeeper.KeeperException,
                                    InterruptedException

Check consistency of all regions that have been found in previous phases.

Throws:: IOException; org.apache.zookeeper.KeeperException; InterruptedException

checkRegionConsistencyConcurrently

private void checkRegionConsistencyConcurrently(List<HBaseFsck.CheckRegionConsistencyWorkItem> workItems)
                                         throws IOException,
                                                org.apache.zookeeper.KeeperException,
                                                InterruptedException

Check consistency of all regions using mulitple threads concurrently.

Throws:: IOException; org.apache.zookeeper.KeeperException; InterruptedException

addSkippedRegion

private void addSkippedRegion(HBaseFsck.HbckInfo hbi)

preCheckPermission

private void preCheckPermission()
                         throws IOException,
                                AccessDeniedException

Throws:: IOException; AccessDeniedException

deleteMetaRegion

private void deleteMetaRegion(HBaseFsck.HbckInfo hi)
                       throws IOException

Deletes region from meta table

Throws:: IOException

deleteMetaRegion

private void deleteMetaRegion(byte[] metaKey)
                       throws IOException

Deletes region from meta table

Throws:: IOException

resetSplitParent

private void resetSplitParent(HBaseFsck.HbckInfo hi)
                       throws IOException

Reset the split parent region info in meta table

Throws:: IOException

offline
```
private void offline(byte[] regionName)
              throws IOException
```
This backwards-compatibility wrapper for permanently offlining a region that should not be alive. If the region server does not support the "offline" method, it will use the closest unassign method instead. This will basically work until one attempts to disable or delete the affected table. The problem has to do with in-memory only master state, so restarting the HMaster or failing over to another should fix this.

Throws:

IOException

undeployRegions

private void undeployRegions(HBaseFsck.HbckInfo hi)
                      throws IOException,
                             InterruptedException

Throws:: IOException; InterruptedException

undeployRegionsForHbi

private void undeployRegionsForHbi(HBaseFsck.HbckInfo hi)
                            throws IOException,
                                   InterruptedException

Throws:: IOException; InterruptedException

closeRegion
```
private void closeRegion(HBaseFsck.HbckInfo hi)
                  throws IOException,
                         InterruptedException
```
Attempts to undeploy a region from a region server based in information in META. Any operations that modify the file system should make sure that its corresponding region is not deployed to prevent data races. A separate call is required to update the master in-memory region state kept in the AssignementManager. Because disable uses this state instead of that found in META, we can't seem to cleanly disable/delete tables that have been hbck fixed. When used on a version of HBase that does not have the offline ipc call exposed on the master (<0.90.5, <0.92.0) a master restart or failover may be required.

Throws:

IOException

InterruptedException

tryAssignmentRepair

private void tryAssignmentRepair(HBaseFsck.HbckInfo hbi,
                       String msg)
                          throws IOException,
                                 org.apache.zookeeper.KeeperException,
                                 InterruptedException

Throws:: IOException; org.apache.zookeeper.KeeperException; InterruptedException

checkRegionConsistency

private void checkRegionConsistency(String key,
                          HBaseFsck.HbckInfo hbi)
                             throws IOException,
                                    org.apache.zookeeper.KeeperException,
                                    InterruptedException

Check a single region for consistency and correct deployment.

Throws:: IOException; org.apache.zookeeper.KeeperException; InterruptedException

checkIntegrity
```
SortedMap<TableName,HBaseFsck.TableInfo> checkIntegrity()
                                                  throws IOException
```
Checks tables integrity. Goes over all regions and scans the tables. Collects all the pieces for each table and checks if there are missing, repeated or overlapping ones.

Throws:

IOException

loadTableInfosForTablesWithNoRegion
```
private void loadTableInfosForTablesWithNoRegion()
                                          throws IOException
```
Loads table info's for tables that may not have been included, since there are no regions reported for the table, but table dir is there in hdfs

Throws:

IOException

mergeRegionDirs

public int mergeRegionDirs(org.apache.hadoop.fs.Path targetRegionDir,
                  HBaseFsck.HbckInfo contained)
                    throws IOException

Merge hdfs data by moving from contained HbckInfo into targetRegionDir.

Returns:: number of file move fixes done to merge regions.
Throws:: IOException

dumpOverlapProblems

public void dumpOverlapProblems(com.google.common.collect.Multimap<byte[],HBaseFsck.HbckInfo> regions)

dumpSidelinedRegions

public void dumpSidelinedRegions(Map<org.apache.hadoop.fs.Path,HBaseFsck.HbckInfo> regions)

getOverlapGroups

public com.google.common.collect.Multimap<byte[],HBaseFsck.HbckInfo> getOverlapGroups(TableName table)

getTables
```
HTableDescriptor[] getTables(AtomicInteger numSkipped)
```
Return a list of user-space table names whose metadata have not been modified in the last few milliseconds specified by timelag if any of the REGIONINFO_QUALIFIER, SERVER_QUALIFIER, STARTCODE_QUALIFIER, SPLITA_QUALIFIER, SPLITB_QUALIFIER have not changed in the last milliseconds specified by timelag, then the table is a candidate to be returned.

Returns:
tables that have not been modified recently

Throws:

IOException - if an error is encountered

getHTableDescriptors

HTableDescriptor[] getHTableDescriptors(List<TableName> tableNames)

getOrCreateInfo
```
private HBaseFsck.HbckInfo getOrCreateInfo(String name)
```
Gets the entry in regionInfo corresponding to the the given encoded region name. If the region has not been seen yet, a new entry is added and returned.

checkAndFixTableLocks

private void checkAndFixTableLocks()
                            throws IOException

Throws:: IOException

checkAndFixOrphanedTableZNodes

private void checkAndFixOrphanedTableZNodes()
                                     throws IOException,
                                            org.apache.zookeeper.KeeperException,
                                            InterruptedException

Check whether a orphaned table ZNode exists and fix it if requested.

Throws:: IOException; org.apache.zookeeper.KeeperException; InterruptedException

checkMetaRegion
```
boolean checkMetaRegion()
                  throws IOException,
                         org.apache.zookeeper.KeeperException,
                         InterruptedException
```
Check values in regionInfo for hbase:meta Check if zero or more than one regions with hbase:meta are found. If there are inconsistencies (i.e. zero or more than one regions pretend to be holding the hbase:meta) try to fix that and report an error.

Throws:

IOException - from HBaseFsckRepair functions

org.apache.zookeeper.KeeperException

InterruptedException

unassignMetaReplica

private void unassignMetaReplica(HBaseFsck.HbckInfo hi)
                          throws IOException,
                                 InterruptedException,
                                 org.apache.zookeeper.KeeperException

Throws:: IOException; InterruptedException; org.apache.zookeeper.KeeperException

assignMetaReplica

private void assignMetaReplica(int replicaId)
                        throws IOException,
                               org.apache.zookeeper.KeeperException,
                               InterruptedException

Throws:: IOException; org.apache.zookeeper.KeeperException; InterruptedException

loadMetaEntries
```
boolean loadMetaEntries()
                  throws IOException
```
Scan hbase:meta, adding all regions found to the regionInfo map.

Throws:

IOException - if an error is encountered

printTableSummary

private void printTableSummary(SortedMap<TableName,HBaseFsck.TableInfo> tablesInfo)

Prints summary of all tables found on the system.

getErrorReporter

static HBaseFsck.ErrorReporter getErrorReporter(org.apache.hadoop.conf.Configuration conf)
                                         throws ClassNotFoundException

Throws:: ClassNotFoundException

setDisplayFullReport
```
public static void setDisplayFullReport()
```
Display the full report from fsck. This displays all live and dead region servers, and all known regions.

setForceExclusive

public static void setForceExclusive()

Set exclusive mode.

isExclusive
```
public boolean isExclusive()
```
Only one instance of hbck can modify HBase at a time.

setDisableBalancer
```
public static void setDisableBalancer()
```
Disable the load balancer.

shouldDisableBalancer
```
public boolean shouldDisableBalancer()
```
The balancer should be disabled if we are modifying HBase. It can be disabled if you want to prevent region movement from causing false positives.

setSummary
```
static void setSummary()
```
Set summary mode. Print only summary of the tables and status (OK or INCONSISTENT)

setCheckMetaOnly
```
void setCheckMetaOnly()
```
Set hbase:meta check mode. Print only info about hbase:meta table deployment/state

setRegionBoundariesCheck
```
void setRegionBoundariesCheck()
```
Set region boundaries check mode.

setFixTableLocks
```
public void setFixTableLocks(boolean shouldFix)
```
Set table locks fix mode. Delete table locks held for a long time

setFixTableZNodes
```
public void setFixTableZNodes(boolean shouldFix)
```
Set orphaned table ZNodes fix mode. Set the table state to disable in the orphaned table ZNode.

setShouldRerun
```
void setShouldRerun()
```
Check if we should rerun fsck again. This checks if we've tried to fix something and we should rerun fsck tool again. Display the full report from fsck. This displays all live and dead region servers, and all known regions.

shouldRerun
```
boolean shouldRerun()
```

setFixAssignments
```
public void setFixAssignments(boolean shouldFix)
```
Fix inconsistencies found by fsck. This should try to fix errors (if any) found by fsck utility.

shouldFixAssignments
```
boolean shouldFixAssignments()
```

setFixMeta

public void setFixMeta(boolean shouldFix)

shouldFixMeta
```
boolean shouldFixMeta()
```

setFixEmptyMetaCells

public void setFixEmptyMetaCells(boolean shouldFix)

shouldFixEmptyMetaCells
```
boolean shouldFixEmptyMetaCells()
```

setCheckHdfs

public void setCheckHdfs(boolean checking)

shouldCheckHdfs
```
boolean shouldCheckHdfs()
```

setFixHdfsHoles

public void setFixHdfsHoles(boolean shouldFix)

shouldFixHdfsHoles
```
boolean shouldFixHdfsHoles()
```

setFixTableOrphans

public void setFixTableOrphans(boolean shouldFix)

shouldFixTableOrphans
```
boolean shouldFixTableOrphans()
```

setFixHdfsOverlaps

public void setFixHdfsOverlaps(boolean shouldFix)

shouldFixHdfsOverlaps
```
boolean shouldFixHdfsOverlaps()
```

setFixHdfsOrphans

public void setFixHdfsOrphans(boolean shouldFix)

shouldFixHdfsOrphans
```
boolean shouldFixHdfsOrphans()
```

setFixVersionFile

public void setFixVersionFile(boolean shouldFix)

shouldFixVersionFile
```
public boolean shouldFixVersionFile()
```

setSidelineBigOverlaps

public void setSidelineBigOverlaps(boolean sbo)

shouldSidelineBigOverlaps

public boolean shouldSidelineBigOverlaps()

setFixSplitParents

public void setFixSplitParents(boolean shouldFix)

setRemoveParents

public void setRemoveParents(boolean shouldFix)

shouldFixSplitParents
```
boolean shouldFixSplitParents()
```

shouldRemoveParents
```
boolean shouldRemoveParents()
```

setFixReferenceFiles

public void setFixReferenceFiles(boolean shouldFix)

shouldFixReferenceFiles
```
boolean shouldFixReferenceFiles()
```

shouldIgnorePreCheckPermission

public boolean shouldIgnorePreCheckPermission()

setIgnorePreCheckPermission

public void setIgnorePreCheckPermission(boolean ignorePreCheckPermission)

setMaxMerge
```
public void setMaxMerge(int mm)
```
Parameters:
mm - maximum number of regions to merge into a single region.

getMaxMerge
```
public int getMaxMerge()
```

setMaxOverlapsToSideline

public void setMaxOverlapsToSideline(int mo)

getMaxOverlapsToSideline
```
public int getMaxOverlapsToSideline()
```

isTableIncluded
```
boolean isTableIncluded(TableName table)
```
Only check/fix tables specified by the list, Empty list means all tables are included.

includeTable

public void includeTable(TableName table)

getIncludedTables
```
Set<TableName> getIncludedTables()
```

setTimeLag
```
public void setTimeLag(long seconds)
```
We are interested in only those tables that have not changed their state in hbase:meta during the last few seconds specified by hbase.admin.fsck.timelag

Parameters:
seconds - - the time in seconds

setSidelineDir
```
public void setSidelineDir(String sidelineDir)
```
Parameters:
sidelineDir - - HDFS path to sideline data

createHFileCorruptionChecker

protected HFileCorruptionChecker createHFileCorruptionChecker(boolean sidelineCorruptHFiles)
                                                       throws IOException

Throws:: IOException

getHFilecorruptionChecker

public HFileCorruptionChecker getHFilecorruptionChecker()

setHFileCorruptionChecker

public void setHFileCorruptionChecker(HFileCorruptionChecker hfcc)

setRetCode
```
public void setRetCode(int code)
```

getRetCode
```
public int getRetCode()
```

printUsageAndExit

protected HBaseFsck printUsageAndExit()

main

public static void main(String[] args)
                 throws Exception

Main program

Parameters:: args -
Throws:: Exception

exec

public HBaseFsck exec(ExecutorService exec,
             String[] args)
               throws org.apache.zookeeper.KeeperException,
                      IOException,
                      com.google.protobuf.ServiceException,
                      InterruptedException

Throws:: org.apache.zookeeper.KeeperException; IOException; com.google.protobuf.ServiceException; InterruptedException

debugLsr

void debugLsr(org.apache.hadoop.fs.Path p)
        throws IOException

ls -r for debugging purposes

Throws:: IOException

debugLsr

public static void debugLsr(org.apache.hadoop.conf.Configuration conf,
            org.apache.hadoop.fs.Path p)
                     throws IOException

ls -r for debugging purposes

Throws:: IOException

debugLsr

public static void debugLsr(org.apache.hadoop.conf.Configuration conf,
            org.apache.hadoop.fs.Path p,
            HBaseFsck.ErrorReporter errors)
                     throws IOException

ls -r for debugging purposes

Throws:: IOException

All Classes

Summary:
Nested |
Field |
Constr |
Method

Detail:
Field |
Constr |
Method

Class HBaseFsck

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class org.apache.hadoop.conf.Configured

Methods inherited from class java.lang.Object

Field Detail

DEFAULT_TIME_LAG

DEFAULT_SLEEP_BEFORE_RERUN

MAX_NUM_THREADS

rsSupportsOffline

DEFAULT_OVERLAPS_TO_SIDELINE

DEFAULT_MAX_MERGE

TO_BE_LOADED

HBCK_LOCK_FILE

DEFAULT_MAX_LOCK_FILE_ATTEMPTS

DEFAULT_LOCK_FILE_ATTEMPT_SLEEP_INTERVAL

DEFAULT_LOCK_FILE_ATTEMPT_MAX_SLEEP_TIME

DEFAULT_WAIT_FOR_LOCK_TIMEOUT

LOG

status

connection

admin

meta

executor

startMillis

hfcc

retcode

HBCK_LOCK_PATH

hbckOutFd

hbckLockCleanup

details

timelag

forceExclusive

disableBalancer

fixAssignments

fixMeta

checkHdfs

fixHdfsHoles

fixHdfsOverlaps

fixHdfsOrphans

fixTableOrphans

fixVersionFile

fixSplitParents

removeParents

fixReferenceFiles

fixEmptyMetaCells

fixTableLocks

fixTableZNodes

fixAny

tablesIncluded

maxMerge

maxOverlapsToSideline

sidelineBigOverlaps

sidelineDir

rerun

SUMMARY

checkMetaOnly

checkRegionBoundaries

ignorePreCheckPermission

errors

fixes

regionInfoMap

disabledTables

emptyRegionInfoQualifiers

tablesInfo

orphanHdfsDirs

orphanTableDirs

skippedRegions

orphanedTableZNodes

lockFileRetryCounterFactory

cmp

Constructor Detail

HBaseFsck

HBaseFsck

Method Detail

createThreadPool

checkAndMarkRunningHbck

unlockHbck