TestAssignmentManager (Hortonworks Data Platform Apache HBase Java API Reference)

java.lang.Object
- org.apache.hadoop.hbase.master.TestAssignmentManager

public class TestAssignmentManager
extends Object

Test AssignmentManager

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`TestAssignmentManager.MockedLoadBalancer` Mocked load balancer class used in the testcase to make sure that the testcase waits until random assignment is called and the gate variable is set to true.

Constructor Summary

Constructors
Constructor and Description

TestAssignmentManager()

Constructors
Constructor and Description
`TestAssignmentManager()`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`after()`
`static void`	`afterClass()`
`void`	`before()`
`static void`	`beforeClass()`
`void`	`testAssignmentEventIgnoredIfNotExpected()` Test assignment related ZK events are ignored by AM if the region is not known by AM to be in transition.
`void`	`testAssignmentOfRegionInSSHAndInFailedOpenState()`
`void`	`testBalance()` Tests AssignmentManager balance function.
`void`	`testBalanceOnMasterFailoverScenarioWithClosedNode()`
`void`	`testBalanceOnMasterFailoverScenarioWithOfflineNode()`
`void`	`testBalanceOnMasterFailoverScenarioWithOpenedNode()` Test a balance going on at same time as a master failover
`void`	`testBalanceRegionOfDeletedTable()` If a table is deleted, we should not be able to balance it anymore.
`void`	`testCloseRegionOnAbortingRS()` Tests close region call on a region server that is aborting
`void`	`testCloseRegionOnServerNotOnline()` Tests close region call on a region server that is not in onlineServer list
`void`	`testClosingFailureDuringRecovery()` Scenario: master starts a close, and creates a znode it fails just at this moment, before contacting the RS while the second master is coming up, the targeted RS dies.
`void`	`testDisablingTableRegionsAssignmentDuringCleanClusterStartup()` Test verifies whether assignment is skipped for regions of tables in DISABLING state during clean cluster startup.
`void`	`testForceAssignMergingRegion()`
`void`	`testMasterRestartShouldRemoveStaleZnodesOfUnknownTableAsForMeta()` Test verifies whether stale znodes of unknown tables as for the hbase:meta will be removed or not.
`void`	`testMasterRestartWhenTableInEnabling()` Test verifies whether all the enabling table regions assigned only once during master startup.
`void`	`testOpenCloseRegionRPCIntendedForPreviousServer()` Tests an on-the-fly RPC that was scheduled for the earlier RS on the same port for openRegion.
`void`	`testProcessDeadServersAndRegionsInTransitionShouldNotFailWithNPE()` Tests the processDeadServersAndRegionsInTransition should not fail with NPE when it failed to get the children.
`void`	`testRegionInOpeningStateOnDeadRSWhileMasterFailover()` Test the scenario when the master is in failover and trying to process a region which is in Opening state on a dead RS.
`void`	`testRegionPlanIsUpdatedWhenRegionFailsToOpen()` TestCase verifies that the regionPlan is updated whenever a region fails to open and the master tries to process RS_ZK_FAILED_OPEN state.(HBASE-5546).
`void`	`testShutdownHandler()` Run a simple server shutdown handler.
`void`	`testSSHTimesOutOpeningRegionTransition()` When a region is in transition, if the region server opening the region goes down, the region assignment takes a long time normally (waiting for timeout monitor to trigger assign).
`void`	`testSSHWhenDisableTableInProgress()` To test closed region handler to remove rit and delete corresponding znode if region in pending close or closing while processing shutdown of a region server.(HBASE-5927).
`void`	`testSSHWhenSplitRegionInProgress()` To test if the split region is removed from RIT if the region was in SPLITTING state but the RS has actually completed the splitting in hbase:meta but went down.
`void`	`testUnassignWithSplitAtSameTime()`

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

Constructor Detail
- TestAssignmentManager
```
public TestAssignmentManager()
```

Method Detail

beforeClass

public static void beforeClass()
                        throws Exception

Throws:: Exception

afterClass

public static void afterClass()
                       throws IOException

Throws:: IOException

before

public void before()
            throws ZooKeeperConnectionException,
                   IOException

Throws:: ZooKeeperConnectionException; IOException

after

public void after()
           throws KeeperException,
                  IOException

Throws:: KeeperException; IOException

testBalanceOnMasterFailoverScenarioWithOpenedNode

public void testBalanceOnMasterFailoverScenarioWithOpenedNode()
                                                       throws IOException,
                                                              KeeperException,
                                                              InterruptedException,
                                                              ServiceException,
                                                              DeserializationException,
                                                              CoordinatedStateException

Test a balance going on at same time as a master failover

Throws:: IOException; KeeperException; InterruptedException; DeserializationException; ServiceException; CoordinatedStateException

testBalanceOnMasterFailoverScenarioWithClosedNode

public void testBalanceOnMasterFailoverScenarioWithClosedNode()
                                                       throws IOException,
                                                              KeeperException,
                                                              InterruptedException,
                                                              ServiceException,
                                                              DeserializationException,
                                                              CoordinatedStateException

Throws:: IOException; KeeperException; InterruptedException; ServiceException; DeserializationException; CoordinatedStateException

testBalanceOnMasterFailoverScenarioWithOfflineNode

public void testBalanceOnMasterFailoverScenarioWithOfflineNode()
                                                        throws IOException,
                                                               KeeperException,
                                                               InterruptedException,
                                                               ServiceException,
                                                               DeserializationException,
                                                               CoordinatedStateException

Throws:: IOException; KeeperException; InterruptedException; ServiceException; DeserializationException; CoordinatedStateException

testBalance

public void testBalance()
                 throws IOException,
                        KeeperException,
                        DeserializationException,
                        InterruptedException,
                        CoordinatedStateException

Tests AssignmentManager balance function. Runs a balance moving a region from one server to another mocking regionserver responding over zk.

Throws:: IOException; KeeperException; DeserializationException; InterruptedException; CoordinatedStateException

testShutdownHandler

public void testShutdownHandler()
                         throws KeeperException,
                                IOException,
                                CoordinatedStateException,
                                ServiceException

Run a simple server shutdown handler.

Throws:: KeeperException; IOException; CoordinatedStateException; ServiceException

testSSHWhenDisableTableInProgress

public void testSSHWhenDisableTableInProgress()
                                       throws KeeperException,
                                              IOException,
                                              CoordinatedStateException,
                                              ServiceException

To test closed region handler to remove rit and delete corresponding znode if region in pending close or closing while processing shutdown of a region server.(HBASE-5927).

Throws:: KeeperException; IOException; ServiceException; CoordinatedStateException

testSSHWhenSplitRegionInProgress

public void testSSHWhenSplitRegionInProgress()
                                      throws KeeperException,
                                             IOException,
                                             Exception

To test if the split region is removed from RIT if the region was in SPLITTING state but the RS has actually completed the splitting in hbase:meta but went down. See HBASE-6070 and also HBASE-5806

Throws:: KeeperException; IOException; Exception

testUnassignWithSplitAtSameTime

public void testUnassignWithSplitAtSameTime()
                                     throws KeeperException,
                                            IOException,
                                            CoordinatedStateException

Throws:: KeeperException; IOException; CoordinatedStateException

testProcessDeadServersAndRegionsInTransitionShouldNotFailWithNPE

public void testProcessDeadServersAndRegionsInTransitionShouldNotFailWithNPE()
                                                                      throws IOException,
                                                                             KeeperException,
                                                                             CoordinatedStateException,
                                                                             InterruptedException,
                                                                             ServiceException

Tests the processDeadServersAndRegionsInTransition should not fail with NPE when it failed to get the children. Let's abort the system in this situation

Throws:: ServiceException; IOException; KeeperException; CoordinatedStateException; InterruptedException

testRegionPlanIsUpdatedWhenRegionFailsToOpen

public void testRegionPlanIsUpdatedWhenRegionFailsToOpen()
                                                  throws IOException,
                                                         KeeperException,
                                                         ServiceException,
                                                         InterruptedException,
                                                         CoordinatedStateException

TestCase verifies that the regionPlan is updated whenever a region fails to open and the master tries to process RS_ZK_FAILED_OPEN state.(HBASE-5546).

Throws:: IOException; KeeperException; ServiceException; InterruptedException; CoordinatedStateException

testAssignmentOfRegionInSSHAndInFailedOpenState

public void testAssignmentOfRegionInSSHAndInFailedOpenState()
                                                     throws IOException,
                                                            KeeperException,
                                                            ServiceException,
                                                            CoordinatedStateException,
                                                            InterruptedException

Throws:: IOException; KeeperException; ServiceException; CoordinatedStateException; InterruptedException

testRegionInOpeningStateOnDeadRSWhileMasterFailover

public void testRegionInOpeningStateOnDeadRSWhileMasterFailover()
                                                         throws IOException,
                                                                KeeperException,
                                                                ServiceException,
                                                                CoordinatedStateException,
                                                                InterruptedException

Test the scenario when the master is in failover and trying to process a region which is in Opening state on a dead RS. Master will force offline the region and put it in transition. AM relies on SSH to reassign it.

Throws:: IOException; KeeperException; ServiceException; CoordinatedStateException; InterruptedException

testDisablingTableRegionsAssignmentDuringCleanClusterStartup

public void testDisablingTableRegionsAssignmentDuringCleanClusterStartup()
                                                                  throws KeeperException,
                                                                         IOException,
                                                                         Exception

Test verifies whether assignment is skipped for regions of tables in DISABLING state during clean cluster startup. See HBASE-6281.

Throws:: KeeperException; IOException; Exception

testMasterRestartWhenTableInEnabling

public void testMasterRestartWhenTableInEnabling()
                                          throws KeeperException,
                                                 IOException,
                                                 Exception

Test verifies whether all the enabling table regions assigned only once during master startup.

Throws:: KeeperException; IOException; Exception

testMasterRestartShouldRemoveStaleZnodesOfUnknownTableAsForMeta
```
public void testMasterRestartShouldRemoveStaleZnodesOfUnknownTableAsForMeta()
                                                                     throws Exception
```
Test verifies whether stale znodes of unknown tables as for the hbase:meta will be removed or not.

Throws:

KeeperException

IOException

Exception

testSSHTimesOutOpeningRegionTransition

public void testSSHTimesOutOpeningRegionTransition()
                                            throws KeeperException,
                                                   IOException,
                                                   CoordinatedStateException,
                                                   ServiceException

When a region is in transition, if the region server opening the region goes down, the region assignment takes a long time normally (waiting for timeout monitor to trigger assign). This test is to make sure SSH reassigns it right away.

Throws:: KeeperException; IOException; CoordinatedStateException; ServiceException

testClosingFailureDuringRecovery
```
public void testClosingFailureDuringRecovery()
                                      throws Exception
```
Scenario:
- master starts a close, and creates a znode
- it fails just at this moment, before contacting the RS
- while the second master is coming up, the targeted RS dies. But it's before ZK timeout so we don't know, and we have an exception.
- the master must handle this nicely and reassign.
Throws:

Exception

testForceAssignMergingRegion

public void testForceAssignMergingRegion()
                                  throws Exception

Throws:: Exception

testAssignmentEventIgnoredIfNotExpected
```
public void testAssignmentEventIgnoredIfNotExpected()
                                             throws KeeperException,
                                                    IOException,
                                                    CoordinatedStateException
```
Test assignment related ZK events are ignored by AM if the region is not known by AM to be in transition. During normal operation, all assignments are started by AM (not considering split/merge), if an event is received but the region is not in transition, the event must be a very late one. So it can be ignored. During master failover, since AM watches assignment znodes after failover cleanup is completed, when an event comes in, AM should already have the region in transition if ZK is used during the assignment action (only hbck doesn't use ZK for region assignment). So during master failover, we can ignored such events too.

Throws:

KeeperException

IOException

CoordinatedStateException

testBalanceRegionOfDeletedTable
```
public void testBalanceRegionOfDeletedTable()
                                     throws Exception
```
If a table is deleted, we should not be able to balance it anymore. Otherwise, the region will be brought back.

Throws:

Exception

testOpenCloseRegionRPCIntendedForPreviousServer
```
public void testOpenCloseRegionRPCIntendedForPreviousServer()
                                                     throws Exception
```
Tests an on-the-fly RPC that was scheduled for the earlier RS on the same port for openRegion. AM should assign this somewhere else. (HBASE-9721)

Throws:

Exception

testCloseRegionOnAbortingRS
```
public void testCloseRegionOnAbortingRS()
                                 throws Exception
```
Tests close region call on a region server that is aborting

Throws:

Exception

testCloseRegionOnServerNotOnline
```
public void testCloseRegionOnServerNotOnline()
                                      throws Exception
```
Tests close region call on a region server that is not in onlineServer list

Throws:

Exception

Class TestAssignmentManager

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

TestAssignmentManager