AssignmentManager (Apache HBase 1.2.12 API)

java.lang.Object
- org.apache.hadoop.hbase.zookeeper.ZooKeeperListener
- - org.apache.hadoop.hbase.master.AssignmentManager

```
@InterfaceAudience.Private
public class AssignmentManager
extends ZooKeeperListener
```
Manages and performs region assignment.
Monitors ZooKeeper for events related to regions in transition.
Handles existing regions in transition during master failover.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`private static interface`	`AssignmentManager.RegionRunnable` A specific runnable that works only on a region.
`static class`	`AssignmentManager.ServerHostRegion`

Field Summary

Fields
Modifier and Type	Field and Description
`(package private) static String`	`ALREADY_IN_TRANSITION_WAITTIME`
`private LoadBalancer`	`balancer`
`private int`	`bulkAssignThresholdRegions`
`private int`	`bulkAssignThresholdServers`
`private boolean`	`bulkAssignWaitTillAllAssigned`
`private int`	`bulkPerRegionOpenTimeGuesstimate`
`private Map<HRegionInfo,AtomicBoolean>`	`closedRegionHandlerCalled`
`(package private) static int`	`DEFAULT_ALREADY_IN_TRANSITION_WAITTIME`
`private ExecutorService`	`executorService`
`private ConcurrentHashMap<String,AtomicInteger>`	`failedOpenTracker` A map to track the count a region fails to open in a row.
`protected AtomicBoolean`	`failoverCleanupDone` Indicator that AssignmentManager has recovered the region states so that ServerShutdownHandler can be fully enabled and re-assign regions of dead servers.
`static ServerName`	`HBCK_CODE_SERVERNAME`
`private List<EventType>`	`ignoreStatesRSOffline`
`private List<AssignmentListener>`	`listeners` Listeners that are called on assignment events.
`private KeyLocker<String>`	`locker`
`private static org.apache.commons.logging.Log`	`LOG`
`private int`	`maximumAttempts`
`private Map<String,PairOfSameType<HRegionInfo>>`	`mergingRegions` Map of two merging regions from the region to be created.
`private MetricsAssignmentManager`	`metricsAssignmentManager`
`private AtomicInteger`	`numRegionsOpened`
`private Map<HRegionInfo,AtomicBoolean>`	`openedRegionHandlerCalled`
`(package private) NavigableMap<String,RegionPlan>`	`regionPlans` Plans for region movement.
`private Set<String>`	`regionsInProgress`
`private RegionStateListener`	`regionStateListener`
`private RegionStates`	`regionStates`
`private RegionStateStore`	`regionStateStore`
`private Map<String,HRegionInfo>`	`regionsToReopen` Map of regions to reopen after the schema of a table is changed.
`(package private) Set<HRegionInfo>`	`replicasToClose`
`protected MasterServices`	`server`
`private ServerManager`	`serverManager`
`private boolean`	`shouldAssignRegionsWithFavoredNodes`
`private long`	`sleepTimeBeforeRetryingMetaAssignment` The sleep time for which the assignment will wait before retrying in case of hbase:meta assignment failure due to lack of availability of region plan or bad region plan
`private Map<HRegionInfo,PairOfSameType<HRegionInfo>>`	`splitRegions`
`private TableLockManager`	`tableLockManager`
`private TableStateManager`	`tableStateManager`
`private static boolean`	`TEST_SKIP_MERGE_HANDLING`
`private static boolean`	`TEST_SKIP_SPLIT_HANDLING` For testing only! Set to true to skip handling of split and merge.
`private ExecutorService`	`threadPoolExecutorService`
`private boolean`	`useZKForAssignment`
`private ExecutorService`	`zkEventWorkers`
`private com.google.common.collect.LinkedHashMultimap<String,AssignmentManager.RegionRunnable>`	`zkEventWorkerWaitingList`

Fields inherited from class org.apache.hadoop.hbase.zookeeper.ZooKeeperListener
watcher

Constructor Summary

Constructors
Constructor and Description
`AssignmentManager(MasterServices server, ServerManager serverManager, LoadBalancer balancer, ExecutorService service, MetricsMaster metricsMaster, TableLockManager tableLockManager)` Constructs a new assignment manager.

Method Summary

Methods
Modifier and Type	Method and Description
`Lock`	`acquireRegionLock(String encodedName)` To avoid racing with AM, external entities may need to lock a region, for example, when SSH checks what regions to skip re-assigning.
`void`	`addPlan(String encodedName, RegionPlan plan)` Add a regionPlan for the specified region.
`void`	`addPlans(Map<String,RegionPlan> plans)` Add a map of region plans.
`void`	`assign(HRegionInfo region, boolean setOfflineInZK)` Assigns the specified region.
`void`	`assign(HRegionInfo region, boolean setOfflineInZK, boolean forceNewPlan)` Use care with forceNewPlan.
`private void`	`assign(int regions, int totalServers, String message, Map<ServerName,List<HRegionInfo>> bulkPlan)`
`void`	`assign(List<HRegionInfo> regions)` Assigns specified regions round robin, if any.
`void`	`assign(Map<HRegionInfo,ServerName> regions)` Assigns specified regions retaining assignments, if any.
`void`	`assign(RegionState state, boolean setOfflineInZK, boolean forceNewPlan)` Caller must hold lock on the passed `state` object.
`(package private) boolean`	`assign(ServerName destination, List<HRegionInfo> regions)` Bulk assign regions to `destination`.
`private void`	`assignAllUserRegions(Map<HRegionInfo,ServerName> allRegions)` Assigns all user regions, if any exist.
`void`	`assignMeta(HRegionInfo hri)` Assigns the hbase:meta region or a replica.
`private boolean`	`asyncSetOfflineInZooKeeper(RegionState state, org.apache.zookeeper.AsyncCallback.StringCallback cb, ServerName destination)` Set region as OFFLINED up in zookeeper asynchronously.
`void`	`balance(RegionPlan plan)`
`private String`	`checkInStateForSplit(ServerName sn, HRegionInfo p, HRegionInfo a, HRegionInfo b)`
`List<HRegionInfo>`	`cleanOutCrashedServerReferences(ServerName sn)` Clean out crashed server removing any assignments.
`(package private) void`	`clearRegionPlan(HRegionInfo region)`
`void`	`deleteClosingOrClosedNode(HRegionInfo region, ServerName sn)`
`private void`	`deleteMergingNode(String encodedName, ServerName sn)`
`private boolean`	`deleteNodeInStates(String encodedName, String desc, ServerName sn, EventType... types)`
`private void`	`deleteSplittingNode(String encodedName, ServerName sn)`
`private void`	`doMergingOfReplicas(HRegionInfo mergedHri, HRegionInfo hri_a, HRegionInfo hri_b)`
`private void`	`doSplittingOfReplicas(HRegionInfo parentHri, HRegionInfo hri_a, HRegionInfo hri_b)`
`(package private) void`	`failoverCleanupDone()` Now, failover cleanup is completed.
`private RegionState`	`forceRegionStateToOffline(HRegionInfo region, boolean forceNewPlan)` Set region to OFFLINE unless it is opening and forceNewPlan is false.
`(package private) MetricsAssignmentManager`	`getAssignmentManagerMetrics()`
`LoadBalancer`	`getBalancer()`
`int`	`getNumRegionsOpened()` Used by unit tests.
`private RegionPlan`	`getRegionPlan(HRegionInfo region, boolean forceNewPlan)`
`private RegionPlan`	`getRegionPlan(HRegionInfo region, ServerName serverToExclude, boolean forceNewPlan)`
`RegionPlan`	`getRegionReopenPlan(HRegionInfo hri)`
`RegionStates`	`getRegionStates()` This SHOULD not be public.
`(package private) RegionStateStore`	`getRegionStateStore()` Used in some tests to mock up region state in meta
`Pair<Integer,Integer>`	`getReopenStatus(TableName tableName)` Used by the client to identify if all regions have the schema updates
`Set<HRegionInfo>`	`getReplicasToClose()`
`Map<ServerName,List<HRegionInfo>>`	`getSnapShotOfAssignment(Collection<HRegionInfo> infos)`
`TableStateManager`	`getTableStateManager()`
`private void`	`handleAssignmentEvent(String path)` Pass the assignment event to a worker for processing.
`private void`	`handleHBCK(RegionTransition rt)` Handle a ZK unassigned node transition triggered by HBCK repair tool.
`(package private) void`	`handleRegion(RegionTransition rt, OpenRegionCoordination coordination, OpenRegionCoordination.OpenRegionDetails ord)` Handles various states an unassigned node can be in.
`private boolean`	`handleRegionMerging(RegionTransition rt, String encodedName, String prettyPrintedRegionName, ServerName sn)` A helper to handle region merging transition event.
`private boolean`	`handleRegionSplitting(RegionTransition rt, String encodedName, String prettyPrintedRegionName, ServerName sn)` A helper to handle region splitting transition event.
`(package private) void`	`initializeHandlerTrackers()`
`(package private) void`	`invokeAssign(HRegionInfo regionInfo)`
`(package private) void`	`invokeAssign(HRegionInfo regionInfo, boolean newPlan)`
`(package private) void`	`invokeUnAssign(HRegionInfo regionInfo)`
`AssignmentManager.ServerHostRegion`	`isCarryingMeta(ServerName serverName)`
`AssignmentManager.ServerHostRegion`	`isCarryingMetaReplica(ServerName serverName, HRegionInfo metaHri)`
`AssignmentManager.ServerHostRegion`	`isCarryingMetaReplica(ServerName serverName, int replicaId)`
`private AssignmentManager.ServerHostRegion`	`isCarryingRegion(ServerName serverName, HRegionInfo hri)` Check if the shutdown server carries the specific region.
`private boolean`	`isDisabledorDisablingRegionInRIT(HRegionInfo region)`
`boolean`	`isFailoverCleanupDone()` Used by ServerShutdownHandler to make sure AssignmentManager has completed the failover cleanup before re-assigning regions of dead servers.
`private boolean`	`isSplitOrSplittingOrMergedOrMerging(String path)`
`(package private) void`	`joinCluster()` Called on startup.
`void`	`nodeChildrenChanged(String path)` New unassigned node has been created.
`void`	`nodeCreated(String path)` New unassigned node has been created.
`void`	`nodeDataChanged(String path)` Existing unassigned node has had data changed.
`void`	`nodeDeleted(String path)` Called when a node has been deleted
`void`	`offlineDisabledRegion(HRegionInfo regionInfo)`
`private void`	`onRegionClosed(HRegionInfo hri)`
`private void`	`onRegionFailedOpen(HRegionInfo hri, ServerName sn)`
`private String`	`onRegionMerge(ServerName sn, org.apache.hadoop.hbase.protobuf.generated.RegionServerStatusProtos.RegionStateTransition.TransitionCode code, HRegionInfo p, HRegionInfo a, HRegionInfo b)`
`private String`	`onRegionMergeReverted(ServerName sn, org.apache.hadoop.hbase.protobuf.generated.RegionServerStatusProtos.RegionStateTransition.TransitionCode code, HRegionInfo p, HRegionInfo a, HRegionInfo b)`
`private void`	`onRegionOpen(HRegionInfo hri, ServerName sn, long openSeqNum)`
`private String`	`onRegionSplit(ServerName sn, org.apache.hadoop.hbase.protobuf.generated.RegionServerStatusProtos.RegionStateTransition.TransitionCode code, HRegionInfo p, HRegionInfo a, HRegionInfo b)`
`private String`	`onRegionSplitReverted(ServerName sn, HRegionInfo p, HRegionInfo a, HRegionInfo b)`
`protected String`	`onRegionTransition(ServerName serverName, org.apache.hadoop.hbase.protobuf.generated.RegionServerStatusProtos.RegionStateTransition transition)` Try to update some region states.
`private void`	`prepareDaughterReplicaForAssignment(HRegionInfo daughterHri, HRegionInfo parentHri, int replicaId, Map<HRegionInfo,ServerName> map)`
`private void`	`processAlreadyOpenedRegion(HRegionInfo region, ServerName sn)`
`private void`	`processDeadServersAndRecoverLostRegions(Set<ServerName> deadServers)` Processes list of dead servers from result of hbase:meta scan and regions in RIT.
`(package private) boolean`	`processDeadServersAndRegionsInTransition(Set<ServerName> deadServers)` Process all regions that are in transition in zookeeper and also processes the list of dead servers.
`(package private) void`	`processFavoredNodes(List<HRegionInfo> regions)`
`(package private) boolean`	`processRegionInTransition(String encodedRegionName, HRegionInfo regionInfo)` Process failover of new master for region `encodedRegionName` up in zookeeper.
`(package private) boolean`	`processRegionInTransitionAndBlockUntilAssigned(HRegionInfo hri)` If region is up in zk in transition, then do fixup and block and wait until the region is assigned and out of transition.
`(package private) void`	`processRegionInTransitionZkLess()`
`(package private) boolean`	`processRegionsInTransition(RegionTransition rt, HRegionInfo regionInfo, OpenRegionCoordination coordination, OpenRegionCoordination.OpenRegionDetails ord)` This call is invoked only (1) master assign meta; (2) during failover mode startup, zk assignment node processing.
`(package private) Set<ServerName>`	`rebuildUserRegions()` Rebuild the list of user regions and assignment information.
`private void`	`recoverTableInDisablingState()` Recover the tables that were not fully moved to DISABLED state.
`private void`	`recoverTableInEnablingState()` Recover the tables that are not fully moved to ENABLED state.
`void`	`regionOffline(HRegionInfo regionInfo)` Marks the region as offline.
`private void`	`regionOffline(HRegionInfo regionInfo, RegionState.State state)` A region is offline.
`(package private) void`	`regionOnline(HRegionInfo regionInfo, ServerName sn)` Marks the region as online.
`(package private) void`	`regionOnline(HRegionInfo regionInfo, ServerName sn, long openSeqNum)`
`void`	`registerListener(AssignmentListener listener)` Add the listener to the notification list.
`void`	`removeClosedRegion(HRegionInfo hri)` When a region is closed, it should be removed from the regionsToReopen
`static List<HRegionInfo>`	`replicaRegionsNotRecordedInMeta(Set<HRegionInfo> regionsRecordedInMeta, MasterServices master)` Get a list of replica regions that are: not recorded in meta yet.
`private void`	`retrySendRegionClose(RegionState regionState)` At master failover, for pending_close region, make sure sendRegionClose RPC call is sent to the target regionserver
`private void`	`retrySendRegionOpen(RegionState regionState)` At master failover, for pending_open region, make sure sendRegionOpen RPC call is sent to the target regionserver
`private void`	`sendRegionClosedNotification(HRegionInfo regionInfo)`
`private void`	`sendRegionOpenedNotification(HRegionInfo regionInfo, ServerName serverName)`
`protected void`	`setEnabledTable(TableName tableName)`
`private int`	`setOfflineInZooKeeper(RegionState state, ServerName destination)` Set region as OFFLINED up in zookeeper
`(package private) void`	`setRegionStateListener(RegionStateListener listener)`
`void`	`setRegionsToReopen(List<HRegionInfo> regions)` Set the list of regions that will be reopened because of an update in table schema
`static void`	`setTestSkipMergeHandling(boolean skipMergeHandling)`
`static void`	`setTestSkipSplitHandling(boolean skipSplitHandling)`
`void`	`shutdown()` Shutdown the threadpool executor service
`void`	`stop()`
`void`	`unassign(HRegionInfo region)` Unassigns the specified region.
`void`	`unassign(HRegionInfo region, boolean force)`
`void`	`unassign(HRegionInfo region, boolean force, ServerName dest)` Unassigns the specified region.
`private void`	`unassign(HRegionInfo region, RegionState state, int versionOfClosingNode, ServerName dest, boolean transitionInZK, ServerName src)` Send CLOSE RPC if the server is online, otherwise, offline the region.
`boolean`	`unregisterListener(AssignmentListener listener)` Remove the listener from the notification list.
`(package private) void`	`updateClosedRegionHandlerTracker(HRegionInfo hri)`
`(package private) void`	`updateOpenedRegionHandlerTracker(HRegionInfo hri)`
`void`	`updateRegionsInTransitionMetrics()` Set Regions in transitions metrics.
`protected boolean`	`waitForAssignment(Collection<HRegionInfo> regionSet, boolean waitTillAllAssigned, int reassigningRegions, long minEndTime)` Waits until the specified region has completed assignment, or the deadline is reached.
`protected boolean`	`waitForAssignment(Collection<HRegionInfo> regionSet, boolean waitTillAllAssigned, long deadline)` Waits until the specified region has completed assignment, or the deadline is reached.
`boolean`	`waitForAssignment(HRegionInfo regionInfo)` Waits until the specified region has completed assignment.
`private void`	`waitForRetryingMetaAssignment()` Wait for some time before retrying meta table region assignment
`void`	`waitOnRegionToClearRegionsInTransition(HRegionInfo hri)` Wait on region to clear regions-in-transition.
`boolean`	`waitOnRegionToClearRegionsInTransition(HRegionInfo hri, long timeOut)` Wait on region to clear regions-in-transition or time out
`(package private) boolean`	`waitUntilNoRegionsInTransition(long timeout)` Wait until no regions in transition.
`(package private) boolean`	`wasClosedHandlerCalled(HRegionInfo hri)`
`(package private) boolean`	`wasOpenedHandlerCalled(HRegionInfo hri)`
`protected boolean`	`wasRegionOnDeadServerByMeta(HRegionInfo region, ServerName sn)`
`protected void`	`zkEventWorkersSubmit(AssignmentManager.RegionRunnable regRunnable)` Submit a task, ensuring that there is only one task at a time that working on a given region.

Methods inherited from class org.apache.hadoop.hbase.zookeeper.ZooKeeperListener
getWatcher

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

- Field Detail
  - LOG
```
private static final org.apache.commons.logging.Log LOG
```
  - HBCK_CODE_SERVERNAME
```
public static final ServerName HBCK_CODE_SERVERNAME
```
  - ALREADY_IN_TRANSITION_WAITTIME
```
static final String ALREADY_IN_TRANSITION_WAITTIME
```
    See Also:
    Constant Field Values
  - DEFAULT_ALREADY_IN_TRANSITION_WAITTIME
```
static final int DEFAULT_ALREADY_IN_TRANSITION_WAITTIME
```
    See Also:
    Constant Field Values
  - server
```
protected final MasterServices server
```
  - serverManager
```
private ServerManager serverManager
```
  - shouldAssignRegionsWithFavoredNodes
```
private boolean shouldAssignRegionsWithFavoredNodes
```
  - balancer
```
private LoadBalancer balancer
```
  - metricsAssignmentManager
```
private final MetricsAssignmentManager metricsAssignmentManager
```
  - tableLockManager
```
private final TableLockManager tableLockManager
```
  - numRegionsOpened
```
private AtomicInteger numRegionsOpened
```
  - locker
```
private final KeyLocker<String> locker
```
  - replicasToClose
```
Set<HRegionInfo> replicasToClose
```
  - regionsToReopen
```
private final Map<String,HRegionInfo> regionsToReopen
```
    Map of regions to reopen after the schema of a table is changed. Key - encoded region name, value - HRegionInfo
  - maximumAttempts
```
private final int maximumAttempts
```
  - mergingRegions
```
private final Map<String,PairOfSameType<HRegionInfo>> mergingRegions
```
    Map of two merging regions from the region to be created.
  - splitRegions
```
private final Map<HRegionInfo,PairOfSameType<HRegionInfo>> splitRegions
```
  - sleepTimeBeforeRetryingMetaAssignment
```
private final long sleepTimeBeforeRetryingMetaAssignment
```
    The sleep time for which the assignment will wait before retrying in case of hbase:meta assignment failure due to lack of availability of region plan or bad region plan
  - regionPlans
```
final NavigableMap<String,RegionPlan> regionPlans
```
    Plans for region movement. Key is the encoded version of a region name
  - tableStateManager
```
private final TableStateManager tableStateManager
```
  - executorService
```
private final ExecutorService executorService
```
  - closedRegionHandlerCalled
```
private Map<HRegionInfo,AtomicBoolean> closedRegionHandlerCalled
```
  - openedRegionHandlerCalled
```
private Map<HRegionInfo,AtomicBoolean> openedRegionHandlerCalled
```
  - threadPoolExecutorService
```
private ExecutorService threadPoolExecutorService
```
  - zkEventWorkers
```
private final ExecutorService zkEventWorkers
```
  - ignoreStatesRSOffline
```
private List<EventType> ignoreStatesRSOffline
```
  - regionStates
```
private final RegionStates regionStates
```
  - bulkAssignThresholdRegions
```
private final int bulkAssignThresholdRegions
```
  - bulkAssignThresholdServers
```
private final int bulkAssignThresholdServers
```
  - bulkPerRegionOpenTimeGuesstimate
```
private final int bulkPerRegionOpenTimeGuesstimate
```
  - bulkAssignWaitTillAllAssigned
```
private final boolean bulkAssignWaitTillAllAssigned
```
  - failoverCleanupDone
```
protected final AtomicBoolean failoverCleanupDone
```
    Indicator that AssignmentManager has recovered the region states so that ServerShutdownHandler can be fully enabled and re-assign regions of dead servers. So that when re-assignment happens, AssignmentManager has proper region states. Protected to ease testing.
  - failedOpenTracker
```
private final ConcurrentHashMap<String,AtomicInteger> failedOpenTracker
```
    A map to track the count a region fails to open in a row. So that we don't try to open a region forever if the failure is unrecoverable. We don't put this information in region states because we don't expect this to happen frequently; we don't want to copy this information over during each state transition either.
  - useZKForAssignment
```
private final boolean useZKForAssignment
```
  - regionStateStore
```
private final RegionStateStore regionStateStore
```
  - TEST_SKIP_SPLIT_HANDLING
```
private static boolean TEST_SKIP_SPLIT_HANDLING
```
    For testing only! Set to true to skip handling of split and merge.
  - TEST_SKIP_MERGE_HANDLING
```
private static boolean TEST_SKIP_MERGE_HANDLING
```
  - listeners
```
private List<AssignmentListener> listeners
```
    Listeners that are called on assignment events.
  - regionStateListener
```
private RegionStateListener regionStateListener
```
  - regionsInProgress
```
private final Set<String> regionsInProgress
```
  - zkEventWorkerWaitingList
```
private final com.google.common.collect.LinkedHashMultimap<String,AssignmentManager.RegionRunnable> zkEventWorkerWaitingList
```
- Constructor Detail
  - AssignmentManager
```
public AssignmentManager(MasterServices server,
                 ServerManager serverManager,
                 LoadBalancer balancer,
                 ExecutorService service,
                 MetricsMaster metricsMaster,
                 TableLockManager tableLockManager)
                  throws org.apache.zookeeper.KeeperException,
                         IOException,
                         CoordinatedStateException
```
    Constructs a new assignment manager.
    
    Parameters:
    server - instance of HMaster this AM running inside
    serverManager - serverManager for associated HMaster
    balancer - implementation of LoadBalancer
    service - Executor service
    metricsMaster - metrics manager
    tableLockManager - TableLock manager
    
    Throws:
    
    org.apache.zookeeper.KeeperException
    
    IOException
    
    CoordinatedStateException
- Method Detail
  - getAssignmentManagerMetrics
```
MetricsAssignmentManager getAssignmentManagerMetrics()
```
  - registerListener
```
public void registerListener(AssignmentListener listener)
```
    Add the listener to the notification list.
    
    Parameters:
    listener - The AssignmentListener to register
  - unregisterListener
```
public boolean unregisterListener(AssignmentListener listener)
```
    Remove the listener from the notification list.
    
    Parameters:
    listener - The AssignmentListener to unregister
  - getTableStateManager
```
public TableStateManager getTableStateManager()
```
    Returns:
    Instance of ZKTableStateManager.
  - getRegionStates
```
public RegionStates getRegionStates()
```
    This SHOULD not be public. It is public now because of some unit tests. TODO: make it package private and keep RegionStates in the master package
  - getRegionStateStore
```
RegionStateStore getRegionStateStore()
```
    Used in some tests to mock up region state in meta
  - getRegionReopenPlan
```
public RegionPlan getRegionReopenPlan(HRegionInfo hri)
```
  - addPlan
```
public void addPlan(String encodedName,
           RegionPlan plan)
```
    Add a regionPlan for the specified region.
    
    Parameters:
    encodedName -
    plan -
  - addPlans
```
public void addPlans(Map<String,RegionPlan> plans)
```
    Add a map of region plans.
  - setRegionsToReopen
```
public void setRegionsToReopen(List<HRegionInfo> regions)
```
    Set the list of regions that will be reopened because of an update in table schema
    
    Parameters:
    regions - list of regions that should be tracked for reopen
  - getReopenStatus
```
public Pair<Integer,Integer> getReopenStatus(TableName tableName)
                                      throws IOException
```
    Used by the client to identify if all regions have the schema updates
    
    Parameters:
    tableName -
    
    Returns:
    Pair indicating the status of the alter command
    
    Throws:
    
    IOException
  - isFailoverCleanupDone
```
public boolean isFailoverCleanupDone()
```
    Used by ServerShutdownHandler to make sure AssignmentManager has completed the failover cleanup before re-assigning regions of dead servers. So that when re-assignment happens, AssignmentManager has proper region states.
  - acquireRegionLock
```
public Lock acquireRegionLock(String encodedName)
```
    To avoid racing with AM, external entities may need to lock a region, for example, when SSH checks what regions to skip re-assigning.
  - failoverCleanupDone
```
void failoverCleanupDone()
```
    Now, failover cleanup is completed. Notify server manager to process queued up dead servers processing, if any.
  - joinCluster
```
void joinCluster()
           throws IOException,
                  org.apache.zookeeper.KeeperException,
                  InterruptedException,
                  CoordinatedStateException
```
    Called on startup. Figures whether a fresh cluster start of we are joining extant running cluster.
    
    Throws:
    
    IOException
    
    org.apache.zookeeper.KeeperException
    
    InterruptedException
    
    CoordinatedStateException
  - processDeadServersAndRegionsInTransition
```
boolean processDeadServersAndRegionsInTransition(Set<ServerName> deadServers)
                                           throws org.apache.zookeeper.KeeperException,
                                                  IOException,
                                                  InterruptedException,
                                                  CoordinatedStateException
```
    Process all regions that are in transition in zookeeper and also processes the list of dead servers. Used by master joining an cluster. If we figure this is a clean cluster startup, will assign all user regions.
    
    Parameters:
    deadServers - Set of servers that are offline probably legitimately that were carrying regions according to a scan of hbase:meta. Can be null.
    
    Throws:
    
    org.apache.zookeeper.KeeperException
    
    IOException
    
    InterruptedException
    
    CoordinatedStateException
  - processRegionInTransitionAndBlockUntilAssigned
```
boolean processRegionInTransitionAndBlockUntilAssigned(HRegionInfo hri)
                                                 throws InterruptedException,
                                                        org.apache.zookeeper.KeeperException,
                                                        IOException
```
    If region is up in zk in transition, then do fixup and block and wait until the region is assigned and out of transition. Used on startup for catalog regions.
    
    Parameters:
    hri - Region to look for.
    
    Returns:
    True if we processed a region in transition else false if region was not up in zk in transition.
    
    Throws:
    
    InterruptedException
    
    org.apache.zookeeper.KeeperException
    
    IOException
  - processRegionInTransition
```
boolean processRegionInTransition(String encodedRegionName,
                                HRegionInfo regionInfo)
                            throws org.apache.zookeeper.KeeperException,
                                   IOException
```
    Process failover of new master for region encodedRegionName up in zookeeper.
    
    Parameters:
    encodedRegionName - Region to process failover for.
    regionInfo - If null we'll go get it from meta table.
    
    Returns:
    True if we processed regionInfo as a RIT.
    
    Throws:
    
    org.apache.zookeeper.KeeperException
    
    IOException
  - processRegionsInTransition
```
boolean processRegionsInTransition(RegionTransition rt,
                                 HRegionInfo regionInfo,
                                 OpenRegionCoordination coordination,
                                 OpenRegionCoordination.OpenRegionDetails ord)
                             throws org.apache.zookeeper.KeeperException
```
    This call is invoked only (1) master assign meta; (2) during failover mode startup, zk assignment node processing. The locker is set in the caller. It returns true if the region is in transition for sure, false otherwise. It should be private but it is used by some test too.
    
    Throws:
    
    org.apache.zookeeper.KeeperException
  - removeClosedRegion
```
public void removeClosedRegion(HRegionInfo hri)
```
    When a region is closed, it should be removed from the regionsToReopen
    
    Parameters:
    hri - HRegionInfo of the region which was closed
  - handleRegion
```
void handleRegion(RegionTransition rt,
                OpenRegionCoordination coordination,
                OpenRegionCoordination.OpenRegionDetails ord)
```
    Handles various states an unassigned node can be in.
    Method is called when a state change is suspected for an unassigned node.
    This deals with skipped transitions (we got a CLOSED but didn't see CLOSING yet).
    
    Parameters:
    rt - region transition
    coordination - coordination for opening region
    ord - details about opening region
  - wasClosedHandlerCalled
```
boolean wasClosedHandlerCalled(HRegionInfo hri)
```
  - wasOpenedHandlerCalled
```
boolean wasOpenedHandlerCalled(HRegionInfo hri)
```
  - initializeHandlerTrackers
```
void initializeHandlerTrackers()
```
  - updateClosedRegionHandlerTracker
```
void updateClosedRegionHandlerTracker(HRegionInfo hri)
```
  - updateOpenedRegionHandlerTracker
```
void updateOpenedRegionHandlerTracker(HRegionInfo hri)
```
  - processFavoredNodes
```
void processFavoredNodes(List<HRegionInfo> regions)
                   throws IOException
```
    Throws:
    
    IOException
  - handleHBCK
```
private void handleHBCK(RegionTransition rt)
```
    Handle a ZK unassigned node transition triggered by HBCK repair tool.
    This is handled in a separate code path because it breaks the normal rules.
    
    Parameters:
    rt -
  - nodeCreated
```
public void nodeCreated(String path)
```
    New unassigned node has been created.
    This happens when an RS begins the OPENING or CLOSING of a region by creating an unassigned node.
    When this happens we must:
    1. Watch the node for further events
    2. Read and handle the state in the node
    Overrides:
    
    nodeCreated in class ZooKeeperListener
    
    Parameters:
    path - full path of the new node
  - nodeDataChanged
```
public void nodeDataChanged(String path)
```
    Existing unassigned node has had data changed.
    This happens when an RS transitions from OFFLINE to OPENING, or between OPENING/OPENED and CLOSING/CLOSED.
    When this happens we must:
    1. Watch the node for further events
    2. Read and handle the state in the node
    Overrides:
    
    nodeDataChanged in class ZooKeeperListener
    
    Parameters:
    path - full path of the updated node
  - zkEventWorkersSubmit
```
protected void zkEventWorkersSubmit(AssignmentManager.RegionRunnable regRunnable)
```
    Submit a task, ensuring that there is only one task at a time that working on a given region. Order is respected.
  - nodeDeleted
```
public void nodeDeleted(String path)
```
    Description copied from class: ZooKeeperListener
    
    Called when a node has been deleted
    
    Overrides:
    
    nodeDeleted in class ZooKeeperListener
    
    Parameters:
    path - full path of the deleted node
  - nodeChildrenChanged
```
public void nodeChildrenChanged(String path)
```
    New unassigned node has been created.
    This happens when an RS begins the OPENING, SPLITTING or CLOSING of a region by creating a znode.
    When this happens we must:
    1. Watch the node for further children changed events
    2. Watch all new children for changed events
    Overrides:
    
    nodeChildrenChanged in class ZooKeeperListener
    
    Parameters:
    path - full path of the node whose children have changed
  - regionOnline
```
void regionOnline(HRegionInfo regionInfo,
                ServerName sn)
```
    Marks the region as online. Removes it from regions in transition and updates the in-memory assignment information.
    Used when a region has been successfully opened on a region server.
    
    Parameters:
    regionInfo -
    sn -
  - regionOnline
```
void regionOnline(HRegionInfo regionInfo,
                ServerName sn,
                long openSeqNum)
```
  - handleAssignmentEvent
```
private void handleAssignmentEvent(String path)
```
    Pass the assignment event to a worker for processing. Each worker is a single thread executor service. The reason for just one thread is to make sure all events for a given region are processed in order.
    
    Parameters:
    path -
  - regionOffline
```
public void regionOffline(HRegionInfo regionInfo)
```
    Marks the region as offline. Removes it from regions in transition and removes in-memory assignment information.
    Used when a region has been closed and should remain closed.
    
    Parameters:
    regionInfo -
  - offlineDisabledRegion
```
public void offlineDisabledRegion(HRegionInfo regionInfo)
```
  - assign
```
public void assign(HRegionInfo region,
          boolean setOfflineInZK)
```
    Assigns the specified region.
    If a RegionPlan is available with a valid destination then it will be used to determine what server region is assigned to. If no RegionPlan is available, region will be assigned to a random available server.
    Updates the RegionState and sends the OPEN RPC.
    This will only succeed if the region is in transition and in a CLOSED or OFFLINE state or not in transition (in-memory not zk), and of course, the chosen server is up and running (It may have just crashed!). If the in-memory checks pass, the zk node is forced to OFFLINE before assigning.
    
    Parameters:
    region - server to be assigned
    setOfflineInZK - whether ZK node should be created/transitioned to an OFFLINE state before assigning the region
  - assign
```
public void assign(HRegionInfo region,
          boolean setOfflineInZK,
          boolean forceNewPlan)
```
    Use care with forceNewPlan. It could cause double assignment.
  - assign
```
boolean assign(ServerName destination,
             List<HRegionInfo> regions)
         throws InterruptedException
```
    Bulk assign regions to destination.
    
    Parameters:
    destination -
    regions - Regions to assign.
    
    Returns:
    true if successful
    
    Throws:
    
    InterruptedException
  - unassign
```
private void unassign(HRegionInfo region,
            RegionState state,
            int versionOfClosingNode,
            ServerName dest,
            boolean transitionInZK,
            ServerName src)
```
    Send CLOSE RPC if the server is online, otherwise, offline the region. The RPC will be sent only to the region sever found in the region state if it is passed in, otherwise, to the src server specified. If region state is not specified, we don't update region state at all, instead we just send the RPC call. This is useful for some cleanup without messing around the region states (see handleRegion, on region opened on an unexpected server scenario, for an example)
  - forceRegionStateToOffline
```
private RegionState forceRegionStateToOffline(HRegionInfo region,
                                    boolean forceNewPlan)
```
    Set region to OFFLINE unless it is opening and forceNewPlan is false.
  - wasRegionOnDeadServerByMeta
```
protected boolean wasRegionOnDeadServerByMeta(HRegionInfo region,
                                  ServerName sn)
```
  - assign
```
public void assign(RegionState state,
          boolean setOfflineInZK,
          boolean forceNewPlan)
```
    Caller must hold lock on the passed state object.
    
    Parameters:
    state -
    setOfflineInZK -
    forceNewPlan -
  - processAlreadyOpenedRegion
```
private void processAlreadyOpenedRegion(HRegionInfo region,
                              ServerName sn)
```
  - isDisabledorDisablingRegionInRIT
```
private boolean isDisabledorDisablingRegionInRIT(HRegionInfo region)
```
  - setOfflineInZooKeeper
```
private int setOfflineInZooKeeper(RegionState state,
                        ServerName destination)
```
    Set region as OFFLINED up in zookeeper
    
    Parameters:
    state -
    
    Returns:
    the version of the offline node if setting of the OFFLINE node was successful, -1 otherwise.
  - getRegionPlan
```
private RegionPlan getRegionPlan(HRegionInfo region,
                       boolean forceNewPlan)
                          throws HBaseIOException
```
    Parameters:
    region - the region to assign
    
    Returns:
    Plan for passed region (If none currently, it creates one or if no servers to assign, it returns null).
    
    Throws:
    
    HBaseIOException
  - getRegionPlan
```
private RegionPlan getRegionPlan(HRegionInfo region,
                       ServerName serverToExclude,
                       boolean forceNewPlan)
                          throws HBaseIOException
```
    Parameters:
    region - the region to assign
    serverToExclude - Server to exclude (we know its bad). Pass null if all servers are thought to be assignable.
    forceNewPlan - If true, then if an existing plan exists, a new plan will be generated.
    
    Returns:
    Plan for passed region (If none currently, it creates one or if no servers to assign, it returns null).
    
    Throws:
    
    HBaseIOException
  - waitForRetryingMetaAssignment
```
private void waitForRetryingMetaAssignment()
```
    Wait for some time before retrying meta table region assignment
  - unassign
```
public void unassign(HRegionInfo region)
```
    Unassigns the specified region.
    Updates the RegionState and sends the CLOSE RPC unless region is being split by regionserver; then the unassign fails (silently) because we presume the region being unassigned no longer exists (its been split out of existence). TODO: What to do if split fails and is rolled back and parent is revivified?
    If a RegionPlan is already set, it will remain.
    
    Parameters:
    region - server to be unassigned
  - unassign
```
public void unassign(HRegionInfo region,
            boolean force,
            ServerName dest)
```
    Unassigns the specified region.
    Updates the RegionState and sends the CLOSE RPC unless region is being split by regionserver; then the unassign fails (silently) because we presume the region being unassigned no longer exists (its been split out of existence). TODO: What to do if split fails and is rolled back and parent is revivified?
    If a RegionPlan is already set, it will remain.
    
    Parameters:
    region - server to be unassigned
    force - if region should be closed even if already closing
  - unassign
```
public void unassign(HRegionInfo region,
            boolean force)
```
  - deleteClosingOrClosedNode
```
public void deleteClosingOrClosedNode(HRegionInfo region,
                             ServerName sn)
```
    Parameters:
    region - regioninfo of znode to be deleted.
  - isSplitOrSplittingOrMergedOrMerging
```
private boolean isSplitOrSplittingOrMergedOrMerging(String path)
                                             throws org.apache.zookeeper.KeeperException,
                                                    DeserializationException
```
    Parameters:
    path -
    
    Returns:
    True if znode is in SPLIT or SPLITTING or MERGED or MERGING state.
    
    Throws:
    
    org.apache.zookeeper.KeeperException - Can happen if the znode went away in meantime.
    
    DeserializationException
  - getNumRegionsOpened
```
public int getNumRegionsOpened()
```
    Used by unit tests. Return the number of regions opened so far in the life of the master. Increases by one every time the master opens a region
    
    Returns:
    the counter value of the number of regions opened so far
  - waitForAssignment
```
public boolean waitForAssignment(HRegionInfo regionInfo)
                          throws InterruptedException
```
    Waits until the specified region has completed assignment.
    If the region is already assigned, returns immediately. Otherwise, method blocks until the region is assigned.
    
    Parameters:
    regionInfo - region to wait on assignment for
    
    Returns:
    true if the region is assigned false otherwise.
    
    Throws:
    
    InterruptedException
  - waitForAssignment
```
protected boolean waitForAssignment(Collection<HRegionInfo> regionSet,
                        boolean waitTillAllAssigned,
                        int reassigningRegions,
                        long minEndTime)
                             throws InterruptedException
```
    Waits until the specified region has completed assignment, or the deadline is reached.
    
    Throws:
    
    InterruptedException
  - waitForAssignment
```
protected boolean waitForAssignment(Collection<HRegionInfo> regionSet,
                        boolean waitTillAllAssigned,
                        long deadline)
                             throws InterruptedException
```
    Waits until the specified region has completed assignment, or the deadline is reached.
    
    Parameters:
    regionSet - set of region to wait on. the set is modified and the assigned regions removed
    waitTillAllAssigned - true if we should wait all the regions to be assigned
    deadline - the timestamp after which the wait is aborted
    
    Returns:
    true if all the regions are assigned false otherwise.
    
    Throws:
    
    InterruptedException
  - assignMeta
```
public void assignMeta(HRegionInfo hri)
                throws org.apache.zookeeper.KeeperException
```
    Assigns the hbase:meta region or a replica.
    Assumes that hbase:meta is currently closed and is not being actively served by any RegionServer.
    Forcibly unsets the current meta region location in ZooKeeper and assigns hbase:meta to a random RegionServer.
    
    Parameters:
    hri - TODO
    
    Throws:
    
    org.apache.zookeeper.KeeperException
  - assign
```
public void assign(Map<HRegionInfo,ServerName> regions)
            throws IOException,
                   InterruptedException
```
    Assigns specified regions retaining assignments, if any.
    This is a synchronous call and will return once every region has been assigned. If anything fails, an exception is thrown
    
    Throws:
    
    InterruptedException
    
    IOException
  - assign
```
public void assign(List<HRegionInfo> regions)
            throws IOException,
                   InterruptedException
```
    Assigns specified regions round robin, if any.
    This is a synchronous call and will return once every region has been assigned. If anything fails, an exception is thrown
    
    Throws:
    
    InterruptedException
    
    IOException
  - assign
```
private void assign(int regions,
          int totalServers,
          String message,
          Map<ServerName,List<HRegionInfo>> bulkPlan)
             throws InterruptedException,
                    IOException
```
    Throws:
    
    InterruptedException
    
    IOException
  - assignAllUserRegions
```
private void assignAllUserRegions(Map<HRegionInfo,ServerName> allRegions)
                           throws IOException,
                                  InterruptedException
```
    Assigns all user regions, if any exist. Used during cluster startup.
    This is a synchronous call and will return once every region has been assigned. If anything fails, an exception is thrown and the cluster should be shutdown.
    
    Throws:
    
    InterruptedException
    
    IOException
  - replicaRegionsNotRecordedInMeta
```
public static List<HRegionInfo> replicaRegionsNotRecordedInMeta(Set<HRegionInfo> regionsRecordedInMeta,
                                                MasterServices master)
                                                         throws IOException
```
    Get a list of replica regions that are: not recorded in meta yet. We might not have recorded the locations for the replicas since the replicas may not have been online yet, master restarted in the middle of assigning, ZK erased, etc.
    
    Parameters:
    regionsRecordedInMeta - the list of regions we know are recorded in meta either as a default, or, as the location of a replica
    master -
    
    Returns:
    list of replica regions
    
    Throws:
    
    IOException
  - waitUntilNoRegionsInTransition
```
boolean waitUntilNoRegionsInTransition(long timeout)
                                 throws InterruptedException
```
    Wait until no regions in transition.
    
    Parameters:
    timeout - How long to wait.
    
    Returns:
    True if nothing in regions in transition.
    
    Throws:
    
    InterruptedException
  - rebuildUserRegions
```
Set<ServerName> rebuildUserRegions()
                             throws IOException,
                                    org.apache.zookeeper.KeeperException,
                                    CoordinatedStateException
```
    Rebuild the list of user regions and assignment information. Updates regionstates with findings as we go through list of regions.
    
    Returns:
    set of servers not online that hosted some regions according to a scan of hbase:meta
    
    Throws:
    
    IOException
    
    org.apache.zookeeper.KeeperException
    
    CoordinatedStateException
  - recoverTableInDisablingState
```
private void recoverTableInDisablingState()
                                   throws org.apache.zookeeper.KeeperException,
                                          IOException,
                                          CoordinatedStateException
```
    Recover the tables that were not fully moved to DISABLED state. These tables are in DISABLING state when the master restarted/switched.
    
    Throws:
    
    org.apache.zookeeper.KeeperException
    
    TableNotFoundException
    
    IOException
    
    CoordinatedStateException
  - recoverTableInEnablingState
```
private void recoverTableInEnablingState()
                                  throws org.apache.zookeeper.KeeperException,
                                         IOException,
                                         CoordinatedStateException
```
    Recover the tables that are not fully moved to ENABLED state. These tables are in ENABLING state when the master restarted/switched
    
    Throws:
    
    org.apache.zookeeper.KeeperException
    
    TableNotFoundException
    
    IOException
    
    CoordinatedStateException
  - processDeadServersAndRecoverLostRegions
```
private void processDeadServersAndRecoverLostRegions(Set<ServerName> deadServers)
                                              throws IOException,
                                                     org.apache.zookeeper.KeeperException
```
    Processes list of dead servers from result of hbase:meta scan and regions in RIT. This is used for failover to recover the lost regions that belonged to RegionServers which failed while there was no active master or are offline for whatever reason and for regions that were in RIT.
    
    Parameters:
    deadServers - The list of dead servers which failed while there was no active master. Can be null.
    
    Throws:
    
    IOException
    
    org.apache.zookeeper.KeeperException
  - processRegionInTransitionZkLess
```
void processRegionInTransitionZkLess()
```
  - retrySendRegionOpen
```
private void retrySendRegionOpen(RegionState regionState)
```
    At master failover, for pending_open region, make sure sendRegionOpen RPC call is sent to the target regionserver
  - retrySendRegionClose
```
private void retrySendRegionClose(RegionState regionState)
```
    At master failover, for pending_close region, make sure sendRegionClose RPC call is sent to the target regionserver
  - updateRegionsInTransitionMetrics
```
public void updateRegionsInTransitionMetrics()
```
    Set Regions in transitions metrics. This takes an iterator on the RegionInTransition map (CLSM), and is not synchronized. This iterator is not fail fast, which may lead to stale read; but that's better than creating a copy of the map for metrics computation, as this method will be invoked on a frequent interval.
  - clearRegionPlan
```
void clearRegionPlan(HRegionInfo region)
```
    Parameters:
    region - Region whose plan we are to clear.
  - waitOnRegionToClearRegionsInTransition
```
public void waitOnRegionToClearRegionsInTransition(HRegionInfo hri)
                                            throws IOException,
                                                   InterruptedException
```
    Wait on region to clear regions-in-transition.
    
    Parameters:
    hri - Region to wait on.
    
    Throws:
    
    IOException
    
    InterruptedException
  - waitOnRegionToClearRegionsInTransition
```
public boolean waitOnRegionToClearRegionsInTransition(HRegionInfo hri,
                                             long timeOut)
                                               throws InterruptedException
```
    Wait on region to clear regions-in-transition or time out
    
    Parameters:
    hri -
    timeOut - Milliseconds to wait for current region to be out of transition state.
    
    Returns:
    True when a region clears regions-in-transition before timeout otherwise false
    
    Throws:
    
    InterruptedException
  - invokeAssign
```
void invokeAssign(HRegionInfo regionInfo)
```
  - invokeAssign
```
void invokeAssign(HRegionInfo regionInfo,
                boolean newPlan)
```
  - invokeUnAssign
```
void invokeUnAssign(HRegionInfo regionInfo)
```
  - isCarryingMeta
```
public AssignmentManager.ServerHostRegion isCarryingMeta(ServerName serverName)
```
  - isCarryingMetaReplica
```
public AssignmentManager.ServerHostRegion isCarryingMetaReplica(ServerName serverName,
                                                       int replicaId)
```
  - isCarryingMetaReplica
```
public AssignmentManager.ServerHostRegion isCarryingMetaReplica(ServerName serverName,
                                                       HRegionInfo metaHri)
```
  - isCarryingRegion
```
private AssignmentManager.ServerHostRegion isCarryingRegion(ServerName serverName,
                                                  HRegionInfo hri)
```
    Check if the shutdown server carries the specific region. We have a bunch of places that store region location Those values aren't consistent. There is a delay of notification. The location from zookeeper unassigned node has the most recent data; but the node could be deleted after the region is opened by AM. The AM's info could be old when OpenedRegionHandler processing hasn't finished yet when server shutdown occurs.
    
    Returns:
    whether the serverName currently hosts the region
  - cleanOutCrashedServerReferences
```
public List<HRegionInfo> cleanOutCrashedServerReferences(ServerName sn)
```
    Clean out crashed server removing any assignments.
    
    Parameters:
    sn - Server that went down.
    
    Returns:
    list of regions in transition on this server
  - balance
```
public void balance(RegionPlan plan)
```
    Parameters:
    plan - Plan to execute.
  - stop
```
public void stop()
```
  - shutdown
```
public void shutdown()
```
    Shutdown the threadpool executor service
  - setEnabledTable
```
protected void setEnabledTable(TableName tableName)
```
  - asyncSetOfflineInZooKeeper
```
private boolean asyncSetOfflineInZooKeeper(RegionState state,
                                 org.apache.zookeeper.AsyncCallback.StringCallback cb,
                                 ServerName destination)
```
    Set region as OFFLINED up in zookeeper asynchronously.
    
    Parameters:
    state -
    
    Returns:
    True if we succeeded, false otherwise (State was incorrect or failed updating zk).
  - deleteNodeInStates
```
private boolean deleteNodeInStates(String encodedName,
                         String desc,
                         ServerName sn,
                         EventType... types)
```
  - deleteMergingNode
```
private void deleteMergingNode(String encodedName,
                     ServerName sn)
```
  - deleteSplittingNode
```
private void deleteSplittingNode(String encodedName,
                       ServerName sn)
```
  - onRegionFailedOpen
```
private void onRegionFailedOpen(HRegionInfo hri,
                      ServerName sn)
```
  - onRegionOpen
```
private void onRegionOpen(HRegionInfo hri,
                ServerName sn,
                long openSeqNum)
```
  - onRegionClosed
```
private void onRegionClosed(HRegionInfo hri)
```
  - checkInStateForSplit
```
private String checkInStateForSplit(ServerName sn,
                          HRegionInfo p,
                          HRegionInfo a,
                          HRegionInfo b)
```
  - onRegionSplitReverted
```
private String onRegionSplitReverted(ServerName sn,
                           HRegionInfo p,
                           HRegionInfo a,
                           HRegionInfo b)
```
  - onRegionSplit
```
private String onRegionSplit(ServerName sn,
                   org.apache.hadoop.hbase.protobuf.generated.RegionServerStatusProtos.RegionStateTransition.TransitionCode code,
                   HRegionInfo p,
                   HRegionInfo a,
                   HRegionInfo b)
```
  - onRegionMerge
```
private String onRegionMerge(ServerName sn,
                   org.apache.hadoop.hbase.protobuf.generated.RegionServerStatusProtos.RegionStateTransition.TransitionCode code,
                   HRegionInfo p,
                   HRegionInfo a,
                   HRegionInfo b)
```
  - onRegionMergeReverted
```
private String onRegionMergeReverted(ServerName sn,
                           org.apache.hadoop.hbase.protobuf.generated.RegionServerStatusProtos.RegionStateTransition.TransitionCode code,
                           HRegionInfo p,
                           HRegionInfo a,
                           HRegionInfo b)
```
  - handleRegionMerging
```
private boolean handleRegionMerging(RegionTransition rt,
                          String encodedName,
                          String prettyPrintedRegionName,
                          ServerName sn)
```
    A helper to handle region merging transition event. It transitions merging regions to MERGING state.
  - handleRegionSplitting
```
private boolean handleRegionSplitting(RegionTransition rt,
                            String encodedName,
                            String prettyPrintedRegionName,
                            ServerName sn)
```
    A helper to handle region splitting transition event.
  - doMergingOfReplicas
```
private void doMergingOfReplicas(HRegionInfo mergedHri,
                       HRegionInfo hri_a,
                       HRegionInfo hri_b)
```
  - doSplittingOfReplicas
```
private void doSplittingOfReplicas(HRegionInfo parentHri,
                         HRegionInfo hri_a,
                         HRegionInfo hri_b)
```
  - prepareDaughterReplicaForAssignment
```
private void prepareDaughterReplicaForAssignment(HRegionInfo daughterHri,
                                       HRegionInfo parentHri,
                                       int replicaId,
                                       Map<HRegionInfo,ServerName> map)
```
  - getReplicasToClose
```
public Set<HRegionInfo> getReplicasToClose()
```
  - regionOffline
```
private void regionOffline(HRegionInfo regionInfo,
                 RegionState.State state)
```
    A region is offline. The new state should be the specified one, if not null. If the specified state is null, the new state is Offline. The specified state can be Split/Merged/Offline/null only.
  - sendRegionOpenedNotification
```
private void sendRegionOpenedNotification(HRegionInfo regionInfo,
                                ServerName serverName)
```
  - sendRegionClosedNotification
```
private void sendRegionClosedNotification(HRegionInfo regionInfo)
```
  - onRegionTransition
```
protected String onRegionTransition(ServerName serverName,
                        org.apache.hadoop.hbase.protobuf.generated.RegionServerStatusProtos.RegionStateTransition transition)
```
    Try to update some region states. If the state machine prevents such update, an error message is returned to explain the reason. It's expected that in each transition there should have just one region for opening/closing, 3 regions for splitting/merging. These regions should be on the server that requested the change. Region state machine. Only these transitions are expected to be triggered by a region server. On the state transition: (1) Open/Close should be initiated by master (a) Master sets the region to pending_open/pending_close in memory and hbase:meta after sending the request to the region server (b) Region server reports back to the master after open/close is done (either success/failure) (c) If region server has problem to report the status to master, it must be because the master is down or some temporary network issue. Otherwise, the region server should abort since it must be a bug. If the master is not accessible, the region server should keep trying until the server is stopped or till the status is reported to the (new) master (d) If region server dies in the middle of opening/closing a region, SSH picks it up and finishes it (e) If master dies in the middle, the new master recovers the state during initialization from hbase:meta. Region server can report any transition that has not been reported to the previous active master yet (2) Split/merge is initiated by region servers (a) To split a region, a region server sends a request to master to try to set a region to splitting, together with two daughters (to be created) to splitting new. If approved by the master, the splitting can then move ahead (b) To merge two regions, a region server sends a request to master to try to set the new merged region (to be created) to merging_new, together with two regions (to be merged) to merging. If it is ok with the master, the merge can then move ahead (c) Once the splitting/merging is done, the region server reports the status back to the master either success/failure. (d) Other scenarios should be handled similarly as for region open/close
  - getBalancer
```
public LoadBalancer getBalancer()
```
    Returns:
    Instance of load balancer
  - getSnapShotOfAssignment
```
public Map<ServerName,List<HRegionInfo>> getSnapShotOfAssignment(Collection<HRegionInfo> infos)
```
  - setRegionStateListener
```
void setRegionStateListener(RegionStateListener listener)
```
  - setTestSkipSplitHandling
```
public static void setTestSkipSplitHandling(boolean skipSplitHandling)
```
  - setTestSkipMergeHandling
```
public static void setTestSkipMergeHandling(boolean skipMergeHandling)
```

Class AssignmentManager

Nested Class Summary

Field Summary

Fields inherited from class org.apache.hadoop.hbase.zookeeper.ZooKeeperListener

Constructor Summary

Method Summary

Methods inherited from class org.apache.hadoop.hbase.zookeeper.ZooKeeperListener

Methods inherited from class java.lang.Object

Field Detail

LOG

HBCK_CODE_SERVERNAME

ALREADY_IN_TRANSITION_WAITTIME

DEFAULT_ALREADY_IN_TRANSITION_WAITTIME

server

serverManager

shouldAssignRegionsWithFavoredNodes

balancer

metricsAssignmentManager

tableLockManager

numRegionsOpened

locker

replicasToClose

regionsToReopen

maximumAttempts

mergingRegions

splitRegions

sleepTimeBeforeRetryingMetaAssignment

regionPlans

tableStateManager

executorService

closedRegionHandlerCalled

openedRegionHandlerCalled

threadPoolExecutorService

zkEventWorkers

ignoreStatesRSOffline

regionStates

bulkAssignThresholdRegions

bulkAssignThresholdServers

bulkPerRegionOpenTimeGuesstimate

bulkAssignWaitTillAllAssigned

failoverCleanupDone

failedOpenTracker

useZKForAssignment

regionStateStore

TEST_SKIP_SPLIT_HANDLING

TEST_SKIP_MERGE_HANDLING

listeners

regionStateListener

regionsInProgress

zkEventWorkerWaitingList

Constructor Detail

AssignmentManager

Method Detail

getAssignmentManagerMetrics

registerListener

unregisterListener

getTableStateManager

getRegionStates

getRegionStateStore

getRegionReopenPlan

addPlan

addPlans

setRegionsToReopen

getReopenStatus

isFailoverCleanupDone

acquireRegionLock

failoverCleanupDone

joinCluster

processDeadServersAndRegionsInTransition

processRegionInTransitionAndBlockUntilAssigned

processRegionInTransition

processRegionsInTransition

removeClosedRegion

handleRegion

wasClosedHandlerCalled

wasOpenedHandlerCalled

initializeHandlerTrackers

updateClosedRegionHandlerTracker

updateOpenedRegionHandlerTracker

processFavoredNodes