HBaseFsck (Apache HBase 2.0.6 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. This tool was written for hbase-1.x. It does not work with hbase-2.x; it can read state but is not allowed to change state; i.e. effect 'repair'. See hbck2 (HBASE-19121) for a hbck tool for hbase2.
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`
`private static class`	`HBaseFsck.FileLockCallable`
`(package private) static class`	`HBaseFsck.HBaseFsckTool` This is a Tool wrapper that gathers -Dxxx=yyy configuration settings from the command line.
`(package private) static class`	`HBaseFsck.PrintingErrorReporter`
`private static class`	`HBaseFsck.RegionBoundariesInformation`
`(package private) 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`
`private ClusterConnection`	`connection`
`private RetryCounterFactory`	`createZNodeRetryCounterFactory`
`private static int`	`DEFAULT_CREATE_ZNODE_ATTEMPT_MAX_SLEEP_TIME`
`private static int`	`DEFAULT_CREATE_ZNODE_ATTEMPT_SLEEP_INTERVAL`
`private static int`	`DEFAULT_LOCK_FILE_ATTEMPT_MAX_SLEEP_TIME`
`private static int`	`DEFAULT_LOCK_FILE_ATTEMPT_SLEEP_INTERVAL`
`private static int`	`DEFAULT_MAX_CREATE_ZNODE_ATTEMPTS`
`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 Set<Result>`	`emptyRegionInfoQualifiers`
`private HbckErrorReporter`	`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`	`fixHFileLinks`
`private boolean`	`fixMeta`
`private boolean`	`fixReferenceFiles`
`private boolean`	`fixReplication`
`private boolean`	`fixSplitParents`
`private boolean`	`fixTableOrphans`
`private boolean`	`fixVersionFile`
`private static boolean`	`forceExclusive`
`static String`	`HBCK_LOCK_FILE` Here is where hbase-1.x used to default the lock for hbck1.
`private org.apache.hadoop.fs.Path`	`HBCK_LOCK_PATH`
`private String`	`hbckEphemeralNodePath`
`private AtomicBoolean`	`hbckLockCleanup`
`private org.apache.hadoop.fs.FSDataOutputStream`	`hbckOutFd`
`private boolean`	`hbckZodeCreated`
`private HFileCorruptionChecker`	`hfcc`
`private boolean`	`ignorePreCheckPermission`
`private RetryCounterFactory`	`lockFileRetryCounterFactory`
`private static org.slf4j.Logger`	`LOG` Internal resources
`private static int`	`MAX_NUM_THREADS`
`private int`	`maxMerge`
`private int`	`maxOverlapsToSideline`
`private Table`	`meta`
`private List<HbckRegionInfo>`	`orphanHdfsDirs` When initially looking at HDFS, we attempt to find any orphaned data.
`private Map<TableName,Set<String>>`	`orphanTableDirs`
`private TreeMap<String,HbckRegionInfo>`	`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 ClusterMetrics`	`status`
`private static boolean`	`summary`
`private Set<TableName>`	`tablesIncluded`
`private SortedMap<TableName,HbckTableInfo>`	`tablesInfo` This map from Tablename -> TableInfo contains the structures necessary to detect table consistency problems (holes, dupes, overlaps).
`private Map<TableName,TableState>`	`tableStates`
`private long`	`timelag`
`private static Set<String>`	`unsupportedOptionsInV2`
`private ZKWatcher`	`zkw`

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

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`private void`	`addSkippedRegion(HbckRegionInfo hbi)`
`private void`	`adoptHdfsOrphan(HbckRegionInfo hi)` Orphaned regions are regions without a .regioninfo file in them.
`private void`	`adoptHdfsOrphans(Collection<HbckRegionInfo> 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`	`checkAndFixReplication()`
`private void`	`checkAndFixTableStates()` Check and fix table states, assumes full info available: - tableInfos - empty tables loaded
`static Pair<org.apache.hadoop.fs.Path,org.apache.hadoop.fs.FSDataOutputStream>`	`checkAndMarkRunningHbck(org.apache.hadoop.conf.Configuration conf, RetryCounter retryCounter)` This method maintains a lock using a file.
`private SortedMap<TableName,HbckTableInfo>`	`checkHdfsIntegrity(boolean fixHoles, boolean fixOverlaps)`
`(package private) SortedMap<TableName,HbckTableInfo>`	`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, HbckRegionInfo 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`	`cleanupHbckZnode()`
`private void`	`clearState()` Clear the current state of hbck.
`void`	`close()`
`(package private) void`	`closeRegion(HbckRegionInfo 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)`
`static RetryCounterFactory`	`createLockRetryCounterFactory(org.apache.hadoop.conf.Configuration conf)`
`private static ExecutorService`	`createThreadPool(org.apache.hadoop.conf.Configuration conf)`
`private static RetryCounterFactory`	`createZnodeRetryCounterFactory(org.apache.hadoop.conf.Configuration conf)`
`private ZKWatcher`	`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, HbckErrorReporter 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(HbckRegionInfo hi)` Deletes region from meta table
`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 Set<String>`	`getColumnFamilyList(Set<String> columns, HbckRegionInfo hbi)` To get the column family list according to the column family dirs
`(package private) static HbckErrorReporter`	`getErrorReporter(org.apache.hadoop.conf.Configuration conf)`
`HbckErrorReporter`	`getErrors()`
`HFileCorruptionChecker`	`getHFilecorruptionChecker()`
`(package private) Set<TableName>`	`getIncludedTables()`
`int`	`getMaxMerge()`
`int`	`getMaxOverlapsToSideline()`
`private ServerName`	`getMetaRegionServerName(int replicaId)`
`private HbckRegionInfo`	`getOrCreateInfo(String name)` Gets the entry in regionInfo corresponding to the the given encoded region name.
`int`	`getRetCode()`
`(package private) org.apache.hadoop.fs.Path`	`getSidelineDir()`
`(package private) TableDescriptor[]`	`getTableDescriptors(List<TableName> tableNames)`
`(package private) TableDescriptor[]`	`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.
`static org.apache.hadoop.fs.Path`	`getTmpDir(org.apache.hadoop.conf.Configuration conf)`
`void`	`includeTable(TableName table)`
`boolean`	`isExclusive()` Only one instance of hbck can modify HBase at a time.
`private boolean`	`isOptionsSupported(String[] args)`
`(package private) boolean`	`isTableDisabled(TableName tableName)` 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.
`void`	`loadHdfsRegionDirs()` Scan HDFS for all regions, recording their information into regionInfoMap
`private SortedMap<TableName,HbckTableInfo>`	`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`	`loadTableStates()` Load the list of disabled tables in ZK into local set.
`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, HbckRegionInfo contained)` Merge hdfs data by moving from contained HbckRegionInfo into targetRegionDir.
`(package 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`	`offlineHLinkFileRepair()` Scan all the store file names to find any lingering HFileLink files, which refer to some none-exiting files.
`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,HbckTableInfo> 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.
`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(HbckRegionInfo 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`	`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`	`setFixHFileLinks(boolean shouldFix)`
`void`	`setFixMeta(boolean shouldFix)`
`void`	`setFixReferenceFiles(boolean shouldFix)`
`void`	`setFixReplication(boolean shouldFix)` Set replication fix mode.
`void`	`setFixSplitParents(boolean shouldFix)`
`void`	`setFixTableOrphans(boolean shouldFix)`
`void`	`setFixVersionFile(boolean shouldFix)`
`static void`	`setForceExclusive()` Set exclusive mode.
`void`	`setHFileCorruptionChecker(HFileCorruptionChecker hfcc)`
`void`	`setIgnorePreCheckPermission(boolean ignorePreCheckPermission)`
`private boolean`	`setMasterInMaintenanceMode()` This method maintains an ephemeral znode.
`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()`
`static boolean`	`shouldDisplayFullReport()`
`(package private) boolean`	`shouldFixAssignments()`
`(package private) boolean`	`shouldFixEmptyMetaCells()`
`(package private) boolean`	`shouldFixHdfsHoles()`
`(package private) boolean`	`shouldFixHdfsOrphans()`
`(package private) boolean`	`shouldFixHdfsOverlaps()`
`(package private) boolean`	`shouldFixHFileLinks()`
`(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()`
`private boolean`	`sidelineFile(org.apache.hadoop.fs.FileSystem fs, org.apache.hadoop.fs.Path hbaseRoot, org.apache.hadoop.fs.Path path)`
`(package private) org.apache.hadoop.fs.Path`	`sidelineRegionDir(org.apache.hadoop.fs.FileSystem fs, HbckRegionInfo 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, HbckRegionInfo hi)` Sideline a region dir (instead of deleting it)
`private void`	`tryAssignmentRepair(HbckRegionInfo hbi, String msg)`
`private void`	`unassignMetaReplica(HbckRegionInfo hi)`
`private void`	`undeployRegions(HbckRegionInfo hi)`
`private void`	`undeployRegionsForHbi(HbckRegionInfo 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

HBCK_LOCK_FILE
```
public static final String HBCK_LOCK_FILE
```
Here is where hbase-1.x used to default the lock for hbck1. It puts in place a lock when it goes to write/make changes.

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

DEFAULT_MAX_CREATE_ZNODE_ATTEMPTS
```
private static final int DEFAULT_MAX_CREATE_ZNODE_ATTEMPTS
```
See Also:

Constant Field Values

DEFAULT_CREATE_ZNODE_ATTEMPT_SLEEP_INTERVAL
```
private static final int DEFAULT_CREATE_ZNODE_ATTEMPT_SLEEP_INTERVAL
```
See Also:

Constant Field Values

DEFAULT_CREATE_ZNODE_ATTEMPT_MAX_SLEEP_TIME
```
private static final int DEFAULT_CREATE_ZNODE_ATTEMPT_MAX_SLEEP_TIME
```
See Also:

Constant Field Values

LOG

private static final org.slf4j.Logger LOG

Internal resources

status
```
private ClusterMetrics 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

unsupportedOptionsInV2

private static final Set<String> unsupportedOptionsInV2

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

timelag
```
private long timelag
```

forceExclusive
```
private static boolean forceExclusive
```

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
```

fixHFileLinks
```
private boolean fixHFileLinks
```

fixEmptyMetaCells
```
private boolean fixEmptyMetaCells
```

fixReplication
```
private boolean fixReplication
```

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 HbckErrorReporter errors
```
State

fixes
```
int fixes
```

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

emptyRegionInfoQualifiers

private Set<Result> emptyRegionInfoQualifiers

tablesInfo
```
private SortedMap<TableName,HbckTableInfo> 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<HbckRegionInfo> orphanHdfsDirs
```
When initially looking at HDFS, we attempt to find any orphaned data.

orphanTableDirs

private Map<TableName,Set<String>> orphanTableDirs

tableStates

private Map<TableName,TableState> tableStates

lockFileRetryCounterFactory

private final RetryCounterFactory lockFileRetryCounterFactory

createZNodeRetryCounterFactory

private final RetryCounterFactory createZNodeRetryCounterFactory

skippedRegions

private Map<TableName,Set<String>> skippedRegions

zkw
```
private ZKWatcher zkw
```

hbckEphemeralNodePath
```
private String hbckEphemeralNodePath
```

hbckZodeCreated
```
private boolean hbckZodeCreated
```

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)

createLockRetryCounterFactory

public static RetryCounterFactory createLockRetryCounterFactory(org.apache.hadoop.conf.Configuration conf)

Returns:: A retry counter factory configured for retrying lock file creation.

createZnodeRetryCounterFactory

private static RetryCounterFactory createZnodeRetryCounterFactory(org.apache.hadoop.conf.Configuration conf)

Returns:: A retry counter factory configured for retrying znode creation.

getTmpDir

public static org.apache.hadoop.fs.Path getTmpDir(org.apache.hadoop.conf.Configuration conf)
                                           throws IOException

Returns:: Return the tmp dir this tool writes too.
Throws:: IOException

checkAndMarkRunningHbck

public static Pair<org.apache.hadoop.fs.Path,org.apache.hadoop.fs.FSDataOutputStream> checkAndMarkRunningHbck(org.apache.hadoop.conf.Configuration conf,
                                                                                                              RetryCounter retryCounter)
                                                                                                       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 - if IO failure occurs

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

setMasterInMaintenanceMode
```
private boolean setMasterInMaintenanceMode()
                                    throws IOException
```
This method maintains an ephemeral znode. If the creation fails we return false or throw exception

Returns:

true if creating znode succeeds; false otherwise

Throws:

IOException - if IO failure occurs

cleanupHbckZnode
```
private void cleanupHbckZnode()
```

onlineHbck

public int onlineHbck()
               throws IOException,
                      org.apache.zookeeper.KeeperException,
                      InterruptedException

Contacts the master and prints out cluster-wide information

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

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<HbckRegionInfo> orphanHdfsDirs)
                       throws IOException

Iterates through the list of all orphan/invalid regiondirs.

Throws:: IOException

adoptHdfsOrphan
```
private void adoptHdfsOrphan(HbckRegionInfo 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,
                                        InterruptedException
```
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

InterruptedException

offlineHLinkFileRepair
```
private void offlineHLinkFileRepair()
                             throws IOException,
                                    InterruptedException
```
Scan all the store file names to find any lingering HFileLink files, which refer to some none-exiting files. If "fix" option is enabled, any lingering HFileLink file will be sidelined if found.

Throws:

IOException

InterruptedException

sidelineFile

private boolean sidelineFile(org.apache.hadoop.fs.FileSystem fs,
                             org.apache.hadoop.fs.Path hbaseRoot,
                             org.apache.hadoop.fs.Path path)
                      throws IOException

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 HbckErrorReporter getErrors()
```

loadHdfsRegionInfos

private SortedMap<TableName,HbckTableInfo> loadHdfsRegionInfos()
                                                        throws IOException,
                                                               InterruptedException

Populate hbi's from regionInfos loaded from file system.

Throws:: IOException; InterruptedException

getColumnFamilyList

private Set<String> getColumnFamilyList(Set<String> columns,
                                        HbckRegionInfo 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 TableDescriptor and ColumnFamilyDescriptor

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 TableDescriptor and ColumnFamilyDescriptor

Throws:

IOException

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

checkHdfsIntegrity

private SortedMap<TableName,HbckTableInfo> checkHdfsIntegrity(boolean fixHoles,
                                                              boolean fixOverlaps)
                                                       throws IOException

Throws:: IOException

getSidelineDir

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

Throws:: IOException

sidelineRegionDir

org.apache.hadoop.fs.Path sidelineRegionDir(org.apache.hadoop.fs.FileSystem fs,
                                            HbckRegionInfo 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,
                                            HbckRegionInfo hi)
                                     throws IOException
```
Sideline a region dir (instead of deleting it)

Parameters:

parentDir - if specified, the region will be sidelined to folder like .../parentDir/<table name>/<region name>. 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

loadTableStates
```
private void loadTableStates()
                      throws IOException
```
Load the list of disabled tables in ZK into local set.

Throws:

ZooKeeperConnectionException

IOException

isTableDisabled
```
boolean isTableDisabled(TableName tableName)
```
Check if the specified region's table is disabled.

Parameters:

tableName - table to check status of

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 ZKWatcher 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(HbckRegionInfo hbi)

checkAndFixTableStates
```
private void checkAndFixTableStates()
                             throws IOException
```
Check and fix table states, assumes full info available: - tableInfos - empty tables loaded

Throws:

IOException

preCheckPermission

private void preCheckPermission()
                         throws IOException,
                                AccessDeniedException

Throws:: IOException; AccessDeniedException

deleteMetaRegion

private void deleteMetaRegion(HbckRegionInfo 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(HbckRegionInfo hi)
                       throws IOException

Reset the split parent region info in meta table

Throws:: IOException

offline
```
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

closeRegion
```
void closeRegion(HbckRegionInfo 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

undeployRegions

private void undeployRegions(HbckRegionInfo hi)
                      throws IOException,
                             InterruptedException

Throws:: IOException; InterruptedException

undeployRegionsForHbi

private void undeployRegionsForHbi(HbckRegionInfo hi)
                            throws IOException,
                                   InterruptedException

Throws:: IOException; InterruptedException

tryAssignmentRepair

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

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

checkRegionConsistency

private void checkRegionConsistency(String key,
                                    HbckRegionInfo 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,HbckTableInfo> 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,
                           HbckRegionInfo contained)
                    throws IOException

Merge hdfs data by moving from contained HbckRegionInfo into targetRegionDir.

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

getTables
```
TableDescriptor[] 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

getTableDescriptors

TableDescriptor[] getTableDescriptors(List<TableName> tableNames)

getOrCreateInfo
```
private HbckRegionInfo 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.

checkAndFixReplication

private void checkAndFixReplication()
                             throws IOException

Throws:: IOException

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(HbckRegionInfo 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,HbckTableInfo> tablesInfo)

Prints summary of all tables found on the system.

getErrorReporter

static HbckErrorReporter 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.

shouldDisplayFullReport

public static boolean shouldDisplayFullReport()

setForceExclusive

public static void setForceExclusive()

Set exclusive mode.

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

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.

setFixReplication

public void setFixReplication(boolean shouldFix)

Set replication fix mode.

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()
```

setFixHFileLinks

public void setFixHFileLinks(boolean shouldFix)

shouldFixHFileLinks
```
boolean shouldFixHFileLinks()
```

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,
                      InterruptedException

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

isOptionsSupported

private boolean isOptionsSupported(String[] args)

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,
                            HbckErrorReporter errors)
                     throws IOException

ls -r for debugging purposes

Throws:: IOException

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

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

DEFAULT_MAX_CREATE_ZNODE_ATTEMPTS

DEFAULT_CREATE_ZNODE_ATTEMPT_SLEEP_INTERVAL

DEFAULT_CREATE_ZNODE_ATTEMPT_MAX_SLEEP_TIME

LOG

status

connection

admin

meta

executor

startMillis

hfcc

retcode

HBCK_LOCK_PATH

hbckOutFd

hbckLockCleanup

unsupportedOptionsInV2

details

timelag

forceExclusive

fixAssignments

fixMeta

checkHdfs

fixHdfsHoles

fixHdfsOverlaps

fixHdfsOrphans

fixTableOrphans

fixVersionFile

fixSplitParents

removeParents

fixReferenceFiles

fixHFileLinks

fixEmptyMetaCells

fixReplication

fixAny

tablesIncluded

maxMerge

maxOverlapsToSideline

sidelineBigOverlaps

sidelineDir

rerun

summary

checkMetaOnly

checkRegionBoundaries

ignorePreCheckPermission

errors

fixes

regionInfoMap

emptyRegionInfoQualifiers

tablesInfo

orphanHdfsDirs

orphanTableDirs

tableStates

lockFileRetryCounterFactory

createZNodeRetryCounterFactory

skippedRegions

zkw

hbckEphemeralNodePath

hbckZodeCreated

Constructor Detail

HBaseFsck

HBaseFsck