TestHBaseFsck (Hortonworks Data Platform Apache HBase Java API Reference)

java.lang.Object
- org.apache.hadoop.hbase.util.TestHBaseFsck

```
public class TestHBaseFsck
extends Object
```
This tests HBaseFsck's ability to detect reasons for inconsistent tables.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class TestHBaseFsck.MasterSyncObserver

Nested Classes
Modifier and Type	Class and Description
`static class`	`TestHBaseFsck.MasterSyncObserver`

Field Summary

Fields
Modifier and Type Field and Description

TestName name

Fields
Modifier and Type	Field and Description
`TestName`	`name`

Constructor Summary

Constructors
Constructor and Description

TestHBaseFsck()

Constructors
Constructor and Description
`TestHBaseFsck()`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`static void`	`createTable(HBaseTestingUtility testUtil, HTableDescriptor htd, byte[][] splitKeys)`
`static void`	`deleteTable(HBaseTestingUtility testUtil, TableName tableName)`
`void`	`deleteTableDir(TableName table)`
`void`	`setUp()`
`static void`	`setUpBeforeClass()`
`static void`	`tearDownAfterClass()`
`void`	`testCheckTableLocks()`
`void`	`testCleanUpDaughtersNotInMetaAfterFailedSplit()`
`void`	`testContainedRegionOverlap()` This creates and fixes a bad table where a region is completely contained by another region.
`void`	`testCoveredStartKey()` This creates and fixes a bad table where a region overlaps two regions -- a start key contained in another region and its end key is contained in yet another region.
`void`	`testDegenerateRegions()` This creates and fixes a bad table with regions that has startkey == endkey
`void`	`testDupeRegion()` This create and fixes a bad table with regions that have a duplicate start key
`void`	`testDupeStartKey()` This create and fixes a bad table with regions that have a duplicate start key
`void`	`testErrorReporter()` Test pluggable error reporter.
`void`	`testFixAssignmentsAndNoHdfsChecking()` Test -noHdfsChecking option can detect and fix assignments issue.
`void`	`testFixAssignmentsWhenMETAinTransition()`
`void`	`testFixByTable()` This creates two tables and mess both of them and fix them one by one
`void`	`testFixHdfsHolesNotWorkingWithNoHdfsChecking()` Test -fixHdfsHoles doesn't work with -noHdfsChecking option, and -noHdfsChecking can't detect orphan Hdfs region.
`void`	`testFixMetaNotWorkingWithNoHdfsChecking()` Test -noHdfsChecking option can detect region is not in meta but deployed.
`void`	`testHBaseFsck()`
`void`	`testHBaseFsckClean()` This creates a clean table and confirms that the table is clean.
`void`	`testHbckAfterRegionMerge()`
`void`	`testHbckFixOrphanTable()`
`void`	`testHbckThreadpooling()` Test thread pooling in the case where there are more regions than threads
`void`	`testHbckWithExcessReplica()`
`void`	`testHbckWithFewerReplica()`
`void`	`testHbckWithRegionReplica()`
`void`	`testHDFSRegioninfoMissing()` This creates and fixes a bad table with a missing region -- hole in meta and data present but .regioinfino missing (an orphan hdfs region)in the fs.
`void`	`testLingeringReferenceFile()` Test fixing lingering reference file.
`void`	`testLingeringSplitParent()` A split parent in meta, in hdfs, and not deployed
`void`	`testMetaOffline()`
`void`	`testMissingFirstRegion()` This creates and fixes a bad table with a missing region which is the 1st region -- hole in meta and data missing in the fs.
`void`	`testMissingLastRegion()` This creates and fixes a bad table with missing last region -- hole in meta and data missing in the fs.
`void`	`testMissingRegionInfoQualifier()` Test mission REGIONINFO_QUALIFIER in hbase:meta
`void`	`testNoHdfsTable()` This creates entries in hbase:meta with no hdfs data.
`void`	`testNotInHdfs()` This creates and fixes a bad table with a region that is in meta but has no deployment or data hdfs
`void`	`testNotInHdfsWithReplicas()` This creates and fixes a bad table with a region that is in meta but has no deployment or data hdfs.
`void`	`testNotInMetaHole()` This creates fixes a bad table with a hole in meta.
`void`	`testNotInMetaOrDeployedHole()` This creates and fixes a bad table with a region that is missing meta and not assigned to a region server.
`void`	`testNoVersionFile()` when the hbase.version file missing, It is fix the fault.
`void`	`testOrphanedTableZNode()` Test orphaned table ZNode (for table states)
`void`	`testOverlapAndOrphan()` This creates and fixes a bad table where a region is completely contained by another region, and there is a hole (sort of like a bad split)
`void`	`testParallelHbck()` This test makes sure that parallel instances of Hbck is disabled.
`void`	`testParallelWithRetriesHbck()` This test makes sure that with enough retries both parallel instances of hbck will be completed successfully.
`void`	`testQuarantineCorruptHFile()` This creates a table and then corrupts an hfile.
`void`	`testQuarantineMissingFamdir()` This creates a table and simulates the race situation where a concurrent compaction or split has removed an colfam dir before the corruption checker got to it.
`void`	`testQuarantineMissingHFile()` This creates a table and simulates the race situation where a concurrent compaction or split has removed an hfile after the corruption checker learned about it.
`void`	`testQuarantineMissingRegionDir()` This creates a table and simulates the race situation where a concurrent compaction or split has removed a region dir before the corruption checker got to it.
`void`	`testReadOnlyProperty()`
`void`	`testRegionBoundariesCheck()`
`void`	`testRegionDeployedNotInHdfs()` This creates and fixes a bad table with a missing region which is the 1st region -- hole in meta and data missing in the fs.
`void`	`testRegionHole()` This creates and fixes a bad table with a missing region -- hole in meta and data missing in the fs.
`void`	`testRegionShouldNotBeDeployed()` The region is not deployed when the table is disabled.
`void`	`testSidelineOverlapRegion()` This creates and fixes a bad table where an overlap group of 3 regions.
`void`	`testSplitDaughtersNotInMeta()` Split crashed after write to hbase:meta finished for the parent region, but failed to write daughters (pre HBASE-7721 codebase)
`void`	`testTableWithNoRegions()`
`void`	`testValidLingeringSplitParent()` Tests that LINGERING_SPLIT_PARENT is not erroneously reported for valid cases where the daughters are there.

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

- Field Detail
  - name
```
public TestName name
```
- Constructor Detail
  - TestHBaseFsck
```
public TestHBaseFsck()
```
- Method Detail
  - setUpBeforeClass
```
public static void setUpBeforeClass()
                             throws Exception
```
    Throws:
    
    Exception
  - tearDownAfterClass
```
public static void tearDownAfterClass()
                               throws Exception
```
    Throws:
    
    Exception
  - setUp
```
public void setUp()
```
  - testHBaseFsck
```
public void testHBaseFsck()
                   throws Exception
```
    Throws:
    
    Exception
  - testFixAssignmentsWhenMETAinTransition
```
public void testFixAssignmentsWhenMETAinTransition()
                                            throws Exception
```
    Throws:
    
    Exception
  - testHBaseFsckClean
```
public void testHBaseFsckClean()
                        throws Exception
```
    This creates a clean table and confirms that the table is clean.
    
    Throws:
    
    Exception
  - testHbckThreadpooling
```
public void testHbckThreadpooling()
                           throws Exception
```
    Test thread pooling in the case where there are more regions than threads
    
    Throws:
    
    Exception
  - testHbckFixOrphanTable
```
public void testHbckFixOrphanTable()
                            throws Exception
```
    Throws:
    
    Exception
  - testParallelHbck
```
public void testParallelHbck()
                      throws Exception
```
    This test makes sure that parallel instances of Hbck is disabled.
    
    Throws:
    
    Exception
  - testParallelWithRetriesHbck
```
public void testParallelWithRetriesHbck()
                                 throws Exception
```
    This test makes sure that with enough retries both parallel instances of hbck will be completed successfully.
    
    Throws:
    
    Exception
  - testDupeStartKey
```
public void testDupeStartKey()
                      throws Exception
```
    This create and fixes a bad table with regions that have a duplicate start key
    
    Throws:
    
    Exception
  - testHbckWithRegionReplica
```
public void testHbckWithRegionReplica()
                               throws Exception
```
    Throws:
    
    Exception
  - testHbckWithFewerReplica
```
public void testHbckWithFewerReplica()
                              throws Exception
```
    Throws:
    
    Exception
  - testHbckWithExcessReplica
```
public void testHbckWithExcessReplica()
                               throws Exception
```
    Throws:
    
    Exception
  - testDupeRegion
```
public void testDupeRegion()
                    throws Exception
```
    This create and fixes a bad table with regions that have a duplicate start key
    
    Throws:
    
    Exception
  - testDegenerateRegions
```
public void testDegenerateRegions()
                           throws Exception
```
    This creates and fixes a bad table with regions that has startkey == endkey
    
    Throws:
    
    Exception
  - testContainedRegionOverlap
```
public void testContainedRegionOverlap()
                                throws Exception
```
    This creates and fixes a bad table where a region is completely contained by another region.
    
    Throws:
    
    Exception
  - testSidelineOverlapRegion
```
public void testSidelineOverlapRegion()
                               throws Exception
```
    This creates and fixes a bad table where an overlap group of 3 regions. Set HBaseFsck.maxMerge to 2 to trigger sideline overlapped region. Mess around the meta data so that closeRegion/offlineRegion throws exceptions.
    
    Throws:
    
    Exception
  - testOverlapAndOrphan
```
public void testOverlapAndOrphan()
                          throws Exception
```
    This creates and fixes a bad table where a region is completely contained by another region, and there is a hole (sort of like a bad split)
    
    Throws:
    
    Exception
  - testCoveredStartKey
```
public void testCoveredStartKey()
                         throws Exception
```
    This creates and fixes a bad table where a region overlaps two regions -- a start key contained in another region and its end key is contained in yet another region.
    
    Throws:
    
    Exception
  - testRegionHole
```
public void testRegionHole()
                    throws Exception
```
    This creates and fixes a bad table with a missing region -- hole in meta and data missing in the fs.
    
    Throws:
    
    Exception
  - testHDFSRegioninfoMissing
```
public void testHDFSRegioninfoMissing()
                               throws Exception
```
    This creates and fixes a bad table with a missing region -- hole in meta and data present but .regioinfino missing (an orphan hdfs region)in the fs.
    
    Throws:
    
    Exception
  - testNotInMetaOrDeployedHole
```
public void testNotInMetaOrDeployedHole()
                                 throws Exception
```
    This creates and fixes a bad table with a region that is missing meta and not assigned to a region server.
    
    Throws:
    
    Exception
  - testNotInMetaHole
```
public void testNotInMetaHole()
                       throws Exception
```
    This creates fixes a bad table with a hole in meta.
    
    Throws:
    
    Exception
  - testNotInHdfs
```
public void testNotInHdfs()
                   throws Exception
```
    This creates and fixes a bad table with a region that is in meta but has no deployment or data hdfs
    
    Throws:
    
    Exception
  - testNotInHdfsWithReplicas
```
public void testNotInHdfsWithReplicas()
                               throws Exception
```
    This creates and fixes a bad table with a region that is in meta but has no deployment or data hdfs. The table has region_replication set to 2.
    
    Throws:
    
    Exception
  - testNoHdfsTable
```
public void testNoHdfsTable()
                     throws Exception
```
    This creates entries in hbase:meta with no hdfs data. This should cleanly remove the table.
    
    Throws:
    
    Exception
  - deleteTableDir
```
public void deleteTableDir(TableName table)
                    throws IOException
```
    Throws:
    
    IOException
  - testNoVersionFile
```
public void testNoVersionFile()
                       throws Exception
```
    when the hbase.version file missing, It is fix the fault.
    
    Throws:
    
    Exception
  - testRegionShouldNotBeDeployed
```
public void testRegionShouldNotBeDeployed()
                                   throws Exception
```
    The region is not deployed when the table is disabled.
    
    Throws:
    
    Exception
  - testFixByTable
```
public void testFixByTable()
                    throws Exception
```
    This creates two tables and mess both of them and fix them one by one
    
    Throws:
    
    Exception
  - testLingeringSplitParent
```
public void testLingeringSplitParent()
                              throws Exception
```
    A split parent in meta, in hdfs, and not deployed
    
    Throws:
    
    Exception
  - testValidLingeringSplitParent
```
public void testValidLingeringSplitParent()
                                   throws Exception
```
    Tests that LINGERING_SPLIT_PARENT is not erroneously reported for valid cases where the daughters are there.
    
    Throws:
    
    Exception
  - testSplitDaughtersNotInMeta
```
public void testSplitDaughtersNotInMeta()
                                 throws Exception
```
    Split crashed after write to hbase:meta finished for the parent region, but failed to write daughters (pre HBASE-7721 codebase)
    
    Throws:
    
    Exception
  - testMissingFirstRegion
```
public void testMissingFirstRegion()
                            throws Exception
```
    This creates and fixes a bad table with a missing region which is the 1st region -- hole in meta and data missing in the fs.
    
    Throws:
    
    Exception
  - testRegionDeployedNotInHdfs
```
public void testRegionDeployedNotInHdfs()
                                 throws Exception
```
    This creates and fixes a bad table with a missing region which is the 1st region -- hole in meta and data missing in the fs.
    
    Throws:
    
    Exception
  - testMissingLastRegion
```
public void testMissingLastRegion()
                           throws Exception
```
    This creates and fixes a bad table with missing last region -- hole in meta and data missing in the fs.
    
    Throws:
    
    Exception
  - testFixAssignmentsAndNoHdfsChecking
```
public void testFixAssignmentsAndNoHdfsChecking()
                                         throws Exception
```
    Test -noHdfsChecking option can detect and fix assignments issue.
    
    Throws:
    
    Exception
  - testFixMetaNotWorkingWithNoHdfsChecking
```
public void testFixMetaNotWorkingWithNoHdfsChecking()
                                             throws Exception
```
    Test -noHdfsChecking option can detect region is not in meta but deployed. However, it can not fix it without checking Hdfs because we need to get the region info from Hdfs in this case, then to patch the meta.
    
    Throws:
    
    Exception
  - testFixHdfsHolesNotWorkingWithNoHdfsChecking
```
public void testFixHdfsHolesNotWorkingWithNoHdfsChecking()
                                                  throws Exception
```
    Test -fixHdfsHoles doesn't work with -noHdfsChecking option, and -noHdfsChecking can't detect orphan Hdfs region.
    
    Throws:
    
    Exception
  - testQuarantineCorruptHFile
```
public void testQuarantineCorruptHFile()
                                throws Exception
```
    This creates a table and then corrupts an hfile. Hbck should quarantine the file.
    
    Throws:
    
    Exception
  - testQuarantineMissingHFile
```
public void testQuarantineMissingHFile()
                                throws Exception
```
    This creates a table and simulates the race situation where a concurrent compaction or split has removed an hfile after the corruption checker learned about it.
    
    Throws:
    
    Exception
  - testQuarantineMissingFamdir
```
public void testQuarantineMissingFamdir()
                                 throws Exception
```
    This creates a table and simulates the race situation where a concurrent compaction or split has removed an colfam dir before the corruption checker got to it.
    
    Throws:
    
    Exception
  - testQuarantineMissingRegionDir
```
public void testQuarantineMissingRegionDir()
                                    throws Exception
```
    This creates a table and simulates the race situation where a concurrent compaction or split has removed a region dir before the corruption checker got to it.
    
    Throws:
    
    Exception
  - testLingeringReferenceFile
```
public void testLingeringReferenceFile()
                                throws Exception
```
    Test fixing lingering reference file.
    
    Throws:
    
    Exception
  - testMissingRegionInfoQualifier
```
public void testMissingRegionInfoQualifier()
                                    throws Exception
```
    Test mission REGIONINFO_QUALIFIER in hbase:meta
    
    Throws:
    
    Exception
  - testErrorReporter
```
public void testErrorReporter()
                       throws Exception
```
    Test pluggable error reporter. It can be plugged in from system property or configuration.
    
    Throws:
    
    Exception
  - testCheckTableLocks
```
public void testCheckTableLocks()
                         throws Exception
```
    Throws:
    
    Exception
  - testOrphanedTableZNode
```
public void testOrphanedTableZNode()
                            throws Exception
```
    Test orphaned table ZNode (for table states)
    
    Throws:
    
    Exception
  - testMetaOffline
```
public void testMetaOffline()
                     throws Exception
```
    Throws:
    
    Exception
  - testTableWithNoRegions
```
public void testTableWithNoRegions()
                            throws Exception
```
    Throws:
    
    Exception
  - testHbckAfterRegionMerge
```
public void testHbckAfterRegionMerge()
                              throws Exception
```
    Throws:
    
    Exception
  - testRegionBoundariesCheck
```
public void testRegionBoundariesCheck()
                               throws Exception
```
    Throws:
    
    Exception
  - testReadOnlyProperty
```
public void testReadOnlyProperty()
                          throws Exception
```
    Throws:
    
    Exception
  - testCleanUpDaughtersNotInMetaAfterFailedSplit
```
public void testCleanUpDaughtersNotInMetaAfterFailedSplit()
                                                   throws Exception
```
    Throws:
    
    Exception
  - createTable
```
public static void createTable(HBaseTestingUtility testUtil,
                               HTableDescriptor htd,
                               byte[][] splitKeys)
                        throws Exception
```
    Throws:
    
    Exception
  - deleteTable
```
public static void deleteTable(HBaseTestingUtility testUtil,
                               TableName tableName)
                        throws Exception
```
    Throws:
    
    Exception

Class TestHBaseFsck

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

name

Constructor Detail

TestHBaseFsck

Method Detail

setUpBeforeClass

tearDownAfterClass

setUp

testHBaseFsck

testFixAssignmentsWhenMETAinTransition

testHBaseFsckClean

testHbckThreadpooling

testHbckFixOrphanTable

testParallelHbck

testParallelWithRetriesHbck

testDupeStartKey

testHbckWithRegionReplica

testHbckWithFewerReplica

testHbckWithExcessReplica

testDupeRegion

testDegenerateRegions

testContainedRegionOverlap

testSidelineOverlapRegion

testOverlapAndOrphan

testCoveredStartKey

testRegionHole

testHDFSRegioninfoMissing

testNotInMetaOrDeployedHole

testNotInMetaHole

testNotInHdfs

testNotInHdfsWithReplicas

testNoHdfsTable

deleteTableDir

testNoVersionFile

testRegionShouldNotBeDeployed

testFixByTable

testLingeringSplitParent

testValidLingeringSplitParent

testSplitDaughtersNotInMeta

testMissingFirstRegion

testRegionDeployedNotInHdfs

testMissingLastRegion

testFixAssignmentsAndNoHdfsChecking

testFixMetaNotWorkingWithNoHdfsChecking

testFixHdfsHolesNotWorkingWithNoHdfsChecking

testQuarantineCorruptHFile

testQuarantineMissingHFile

testQuarantineMissingFamdir

testQuarantineMissingRegionDir

testLingeringReferenceFile

testMissingRegionInfoQualifier

testErrorReporter

testCheckTableLocks

testOrphanedTableZNode

testMetaOffline

testTableWithNoRegions

testHbckAfterRegionMerge

testRegionBoundariesCheck

testReadOnlyProperty

testCleanUpDaughtersNotInMetaAfterFailedSplit

createTable

deleteTable