TestHBaseFsck (Hortonworks Data Platform Apache HBase Java API Reference)

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

```
public class TestHBaseFsck
extends java.lang.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`	`testCorruptLinkDirectory()`
`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`	`testHDFSRegioninfoMissingAndCheckRegionBoundary()` This creates and fixes a bad table with a missing region -- hole in meta and data present but .regioninfo missing (an orphan hdfs region)in the fs.
`void`	`testLingeringHFileLinks()` Test fixing lingering HFileLinks.
`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`	`testQuarantineCorruptMobFile()` This creates a table and then corrupts a mob file.
`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 java.lang.Exception
```
    Throws:
    
    java.lang.Exception
  - tearDownAfterClass
```
public static void tearDownAfterClass()
                               throws java.lang.Exception
```
    Throws:
    
    java.lang.Exception
  - setUp
```
public void setUp()
```
  - testHBaseFsck
```
public void testHBaseFsck()
                   throws java.lang.Exception
```
    Throws:
    
    java.lang.Exception
  - testFixAssignmentsWhenMETAinTransition
```
public void testFixAssignmentsWhenMETAinTransition()
                                            throws java.lang.Exception
```
    Throws:
    
    java.lang.Exception
  - testHBaseFsckClean
```
public void testHBaseFsckClean()
                        throws java.lang.Exception
```
    This creates a clean table and confirms that the table is clean.
    
    Throws:
    
    java.lang.Exception
  - testHbckThreadpooling
```
public void testHbckThreadpooling()
                           throws java.lang.Exception
```
    Test thread pooling in the case where there are more regions than threads
    
    Throws:
    
    java.lang.Exception
  - testHbckFixOrphanTable
```
public void testHbckFixOrphanTable()
                            throws java.lang.Exception
```
    Throws:
    
    java.lang.Exception
  - testParallelHbck
```
public void testParallelHbck()
                      throws java.lang.Exception
```
    This test makes sure that parallel instances of Hbck is disabled.
    
    Throws:
    
    java.lang.Exception
  - testParallelWithRetriesHbck
```
public void testParallelWithRetriesHbck()
                                 throws java.lang.Exception
```
    This test makes sure that with enough retries both parallel instances of hbck will be completed successfully.
    
    Throws:
    
    java.lang.Exception
  - testDupeStartKey
```
public void testDupeStartKey()
                      throws java.lang.Exception
```
    This create and fixes a bad table with regions that have a duplicate start key
    
    Throws:
    
    java.lang.Exception
  - testHbckWithRegionReplica
```
public void testHbckWithRegionReplica()
                               throws java.lang.Exception
```
    Throws:
    
    java.lang.Exception
  - testHbckWithFewerReplica
```
public void testHbckWithFewerReplica()
                              throws java.lang.Exception
```
    Throws:
    
    java.lang.Exception
  - testHbckWithExcessReplica
```
public void testHbckWithExcessReplica()
                               throws java.lang.Exception
```
    Throws:
    
    java.lang.Exception
  - testDupeRegion
```
public void testDupeRegion()
                    throws java.lang.Exception
```
    This create and fixes a bad table with regions that have a duplicate start key
    
    Throws:
    
    java.lang.Exception
  - testDegenerateRegions
```
public void testDegenerateRegions()
                           throws java.lang.Exception
```
    This creates and fixes a bad table with regions that has startkey == endkey
    
    Throws:
    
    java.lang.Exception
  - testContainedRegionOverlap
```
public void testContainedRegionOverlap()
                                throws java.lang.Exception
```
    This creates and fixes a bad table where a region is completely contained by another region.
    
    Throws:
    
    java.lang.Exception
  - testSidelineOverlapRegion
```
public void testSidelineOverlapRegion()
                               throws java.lang.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:
    
    java.lang.Exception
  - testOverlapAndOrphan
```
public void testOverlapAndOrphan()
                          throws java.lang.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:
    
    java.lang.Exception
  - testCoveredStartKey
```
public void testCoveredStartKey()
                         throws java.lang.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:
    
    java.lang.Exception
  - testRegionHole
```
public void testRegionHole()
                    throws java.lang.Exception
```
    This creates and fixes a bad table with a missing region -- hole in meta and data missing in the fs.
    
    Throws:
    
    java.lang.Exception
  - testHDFSRegioninfoMissing
```
public void testHDFSRegioninfoMissing()
                               throws java.lang.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:
    
    java.lang.Exception
  - testHDFSRegioninfoMissingAndCheckRegionBoundary
```
public void testHDFSRegioninfoMissingAndCheckRegionBoundary()
                                                     throws java.lang.Exception
```
    This creates and fixes a bad table with a missing region -- hole in meta and data present but .regioninfo missing (an orphan hdfs region)in the fs. At last we check every row was present at the correct region.
    
    Throws:
    
    java.lang.Exception
  - testNotInMetaOrDeployedHole
```
public void testNotInMetaOrDeployedHole()
                                 throws java.lang.Exception
```
    This creates and fixes a bad table with a region that is missing meta and not assigned to a region server.
    
    Throws:
    
    java.lang.Exception
  - testNotInMetaHole
```
public void testNotInMetaHole()
                       throws java.lang.Exception
```
    This creates fixes a bad table with a hole in meta.
    
    Throws:
    
    java.lang.Exception
  - testNotInHdfs
```
public void testNotInHdfs()
                   throws java.lang.Exception
```
    This creates and fixes a bad table with a region that is in meta but has no deployment or data hdfs
    
    Throws:
    
    java.lang.Exception
  - testNotInHdfsWithReplicas
```
public void testNotInHdfsWithReplicas()
                               throws java.lang.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:
    
    java.lang.Exception
  - testNoHdfsTable
```
public void testNoHdfsTable()
                     throws java.lang.Exception
```
    This creates entries in hbase:meta with no hdfs data. This should cleanly remove the table.
    
    Throws:
    
    java.lang.Exception
  - deleteTableDir
```
public void deleteTableDir(TableName table)
                    throws java.io.IOException
```
    Throws:
    
    java.io.IOException
  - testNoVersionFile
```
public void testNoVersionFile()
                       throws java.lang.Exception
```
    when the hbase.version file missing, It is fix the fault.
    
    Throws:
    
    java.lang.Exception
  - testRegionShouldNotBeDeployed
```
public void testRegionShouldNotBeDeployed()
                                   throws java.lang.Exception
```
    The region is not deployed when the table is disabled.
    
    Throws:
    
    java.lang.Exception
  - testFixByTable
```
public void testFixByTable()
                    throws java.lang.Exception
```
    This creates two tables and mess both of them and fix them one by one
    
    Throws:
    
    java.lang.Exception
  - testLingeringSplitParent
```
public void testLingeringSplitParent()
                              throws java.lang.Exception
```
    A split parent in meta, in hdfs, and not deployed
    
    Throws:
    
    java.lang.Exception
  - testValidLingeringSplitParent
```
public void testValidLingeringSplitParent()
                                   throws java.lang.Exception
```
    Tests that LINGERING_SPLIT_PARENT is not erroneously reported for valid cases where the daughters are there.
    
    Throws:
    
    java.lang.Exception
  - testSplitDaughtersNotInMeta
```
public void testSplitDaughtersNotInMeta()
                                 throws java.lang.Exception
```
    Split crashed after write to hbase:meta finished for the parent region, but failed to write daughters (pre HBASE-7721 codebase)
    
    Throws:
    
    java.lang.Exception
  - testMissingFirstRegion
```
public void testMissingFirstRegion()
                            throws java.lang.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:
    
    java.lang.Exception
  - testRegionDeployedNotInHdfs
```
public void testRegionDeployedNotInHdfs()
                                 throws java.lang.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:
    
    java.lang.Exception
  - testMissingLastRegion
```
public void testMissingLastRegion()
                           throws java.lang.Exception
```
    This creates and fixes a bad table with missing last region -- hole in meta and data missing in the fs.
    
    Throws:
    
    java.lang.Exception
  - testFixAssignmentsAndNoHdfsChecking
```
public void testFixAssignmentsAndNoHdfsChecking()
                                         throws java.lang.Exception
```
    Test -noHdfsChecking option can detect and fix assignments issue.
    
    Throws:
    
    java.lang.Exception
  - testFixMetaNotWorkingWithNoHdfsChecking
```
public void testFixMetaNotWorkingWithNoHdfsChecking()
                                             throws java.lang.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:
    
    java.lang.Exception
  - testFixHdfsHolesNotWorkingWithNoHdfsChecking
```
public void testFixHdfsHolesNotWorkingWithNoHdfsChecking()
                                                  throws java.lang.Exception
```
    Test -fixHdfsHoles doesn't work with -noHdfsChecking option, and -noHdfsChecking can't detect orphan Hdfs region.
    
    Throws:
    
    java.lang.Exception
  - testQuarantineCorruptHFile
```
public void testQuarantineCorruptHFile()
                                throws java.lang.Exception
```
    This creates a table and then corrupts an hfile. Hbck should quarantine the file.
    
    Throws:
    
    java.lang.Exception
  - testQuarantineCorruptMobFile
```
public void testQuarantineCorruptMobFile()
                                  throws java.lang.Exception
```
    This creates a table and then corrupts a mob file. Hbck should quarantine the file.
    
    Throws:
    
    java.lang.Exception
  - testQuarantineMissingHFile
```
public void testQuarantineMissingHFile()
                                throws java.lang.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:
    
    java.lang.Exception
  - testQuarantineMissingFamdir
```
public void testQuarantineMissingFamdir()
                                 throws java.lang.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:
    
    java.lang.Exception
  - testQuarantineMissingRegionDir
```
public void testQuarantineMissingRegionDir()
                                    throws java.lang.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:
    
    java.lang.Exception
  - testLingeringReferenceFile
```
public void testLingeringReferenceFile()
                                throws java.lang.Exception
```
    Test fixing lingering reference file.
    
    Throws:
    
    java.lang.Exception
  - testLingeringHFileLinks
```
public void testLingeringHFileLinks()
                             throws java.lang.Exception
```
    Test fixing lingering HFileLinks.
    
    Throws:
    
    java.lang.Exception
  - testCorruptLinkDirectory
```
public void testCorruptLinkDirectory()
                              throws java.lang.Exception
```
    Throws:
    
    java.lang.Exception
  - testMissingRegionInfoQualifier
```
public void testMissingRegionInfoQualifier()
                                    throws java.lang.Exception
```
    Test mission REGIONINFO_QUALIFIER in hbase:meta
    
    Throws:
    
    java.lang.Exception
  - testErrorReporter
```
public void testErrorReporter()
                       throws java.lang.Exception
```
    Test pluggable error reporter. It can be plugged in from system property or configuration.
    
    Throws:
    
    java.lang.Exception
  - testCheckTableLocks
```
public void testCheckTableLocks()
                         throws java.lang.Exception
```
    Throws:
    
    java.lang.Exception
  - testOrphanedTableZNode
```
public void testOrphanedTableZNode()
                            throws java.lang.Exception
```
    Test orphaned table ZNode (for table states)
    
    Throws:
    
    java.lang.Exception
  - testMetaOffline
```
public void testMetaOffline()
                     throws java.lang.Exception
```
    Throws:
    
    java.lang.Exception
  - testTableWithNoRegions
```
public void testTableWithNoRegions()
                            throws java.lang.Exception
```
    Throws:
    
    java.lang.Exception
  - testHbckAfterRegionMerge
```
public void testHbckAfterRegionMerge()
                              throws java.lang.Exception
```
    Throws:
    
    java.lang.Exception
  - testRegionBoundariesCheck
```
public void testRegionBoundariesCheck()
                               throws java.lang.Exception
```
    Throws:
    
    java.lang.Exception
  - testReadOnlyProperty
```
public void testReadOnlyProperty()
                          throws java.lang.Exception
```
    Throws:
    
    java.lang.Exception
  - testCleanUpDaughtersNotInMetaAfterFailedSplit
```
public void testCleanUpDaughtersNotInMetaAfterFailedSplit()
                                                   throws java.lang.Exception
```
    Throws:
    
    java.lang.Exception
  - createTable
```
public static void createTable(HBaseTestingUtility testUtil,
                               HTableDescriptor htd,
                               byte[][] splitKeys)
                        throws java.lang.Exception
```
    Throws:
    
    java.lang.Exception
  - deleteTable
```
public static void deleteTable(HBaseTestingUtility testUtil,
                               TableName tableName)
                        throws java.lang.Exception
```
    Throws:
    
    java.lang.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

testHDFSRegioninfoMissingAndCheckRegionBoundary

testNotInMetaOrDeployedHole

testNotInMetaHole

testNotInHdfs

testNotInHdfsWithReplicas

testNoHdfsTable

deleteTableDir

testNoVersionFile

testRegionShouldNotBeDeployed

testFixByTable

testLingeringSplitParent

testValidLingeringSplitParent

testSplitDaughtersNotInMeta

testMissingFirstRegion

testRegionDeployedNotInHdfs

testMissingLastRegion

testFixAssignmentsAndNoHdfsChecking

testFixMetaNotWorkingWithNoHdfsChecking

testFixHdfsHolesNotWorkingWithNoHdfsChecking

testQuarantineCorruptHFile

testQuarantineCorruptMobFile

testQuarantineMissingHFile

testQuarantineMissingFamdir

testQuarantineMissingRegionDir

testLingeringReferenceFile

testLingeringHFileLinks

testCorruptLinkDirectory

testMissingRegionInfoQualifier

testErrorReporter

testCheckTableLocks

testOrphanedTableZNode

testMetaOffline

testTableWithNoRegions

testHbckAfterRegionMerge

testRegionBoundariesCheck

testReadOnlyProperty

testCleanUpDaughtersNotInMetaAfterFailedSplit

createTable

deleteTable