RegionStates (Apache HBase 1.2.12 API)

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

```
@InterfaceAudience.Private
public class RegionStates
extends Object
```
Region state accountant. It holds the states of all regions in the memory. In normal scenario, it should match the meta table and the true region states. This map is used by AssignmentManager to track region states.

Field Summary

Fields
Modifier and Type	Field and Description
`private HashMap<String,Long>`	`deadServers` Map a host port pair string to the latest start code of a region server which is known to be dead.
`(package private) static long`	`DEFAULT_LOG_SPLIT_TIME`
`private Map<HRegionInfo,Set<HRegionInfo>>`	`defaultReplicaToOtherReplicas` Maintains the mapping from the default region to the replica regions.
`private HashMap<String,ServerName>`	`lastAssignments` Encoded region name to server assignment map for re-assignment purpose.
`private long`	`lastProcessedServerCleanTime`
`private static org.apache.commons.logging.Log`	`LOG`
`(package private) static String`	`LOG_SPLIT_TIME`
`private HashMap<String,ServerName>`	`oldAssignments` Encoded region name to server assignment map for the purpose to clean up serverHoldings when a region is online on a new server.
`private HashMap<ServerName,Long>`	`processedServers` Map a dead servers to the time when log split is done.
`private TreeMap<HRegionInfo,ServerName>`	`regionAssignments` Region to server assignment map.
`(package private) HashMap<String,RegionState>`	`regionsInTransition` Regions currently in transition.
`private Map<String,RegionState>`	`regionStates` Region encoded name to state map.
`private Map<TableName,Map<String,RegionState>>`	`regionStatesTableIndex` Holds mapping of table -> region state
`private RegionStateStore`	`regionStateStore`
`private Server`	`server`
`private Map<ServerName,Set<HRegionInfo>>`	`serverHoldings` Server to regions assignment map.
`private ServerManager`	`serverManager`
`private TableStateManager`	`tableStateManager`
`private boolean`	`useZK`

Constructor Summary

Constructors
Constructor and Description
`RegionStates(Server master, TableStateManager tableStateManager, ServerManager serverManager, RegionStateStore regionStateStore)`

Method Summary

Methods
Modifier and Type	Method and Description
`private void`	`addToReplicaMapping(HRegionInfo hri)`
`private void`	`addToServerHoldings(ServerName serverName, HRegionInfo hri)`
`private void`	`cleanFailedSplitMergeRegions(Set<HRegionInfo> hris)` This method does an RPC to hbase:meta.
`void`	`clearLastAssignment(HRegionInfo region)`
`(package private) Map<HRegionInfo,ServerName>`	`closeAllUserRegions(Set<TableName> excludedTables)` At cluster clean re/start, mark all user regions closed except those of tables that are excluded, such as disabled/disabling/enabling tables.
`RegionState`	`createRegionState(HRegionInfo hri)` Add a region to RegionStates.
`RegionState`	`createRegionState(HRegionInfo hri, RegionState.State newState, ServerName serverName, ServerName lastHost)` Add a region to RegionStates with the specified state.
`void`	`createRegionStates(List<HRegionInfo> hris)` Add a list of regions to RegionStates.
`void`	`deleteRegion(HRegionInfo hri)` Remove a region from all state maps.
`(package private) boolean`	`existsInServerHoldings(ServerName serverName, HRegionInfo hri)` Used in some unit tests
`protected Map<TableName,Map<ServerName,List<HRegionInfo>>>`	`getAssignmentsByTable()` This is an EXPENSIVE clone.
`protected double`	`getAverageLoad()` Compute the average load across all region servers.
`(package private) ServerName`	`getLastRegionServerOfRegion(String encodedName)` Get the last region server a region was on for purpose of re-assignment, i.e.
`Map<HRegionInfo,ServerName>`	`getRegionAssignments()`
`(package private) Map<ServerName,List<HRegionInfo>>`	`getRegionAssignments(Collection<HRegionInfo> regions)` Return the replicas (including default) for the regions grouped by ServerName
`protected Map<ServerName,List<HRegionInfo>>`	`getRegionAssignmentsByServer()` Returns a clone of region assignments per server
`Map<RegionState.State,List<HRegionInfo>>`	`getRegionByStateOfTable(TableName tableName)` Gets current state of all regions of the table.
`protected HRegionInfo`	`getRegionInfo(byte[] regionName)` Get the HRegionInfo from cache, if not there, from the hbase:meta table
`private int`	`getRegionReplication(HRegionInfo r)`
`ServerName`	`getRegionServerOfRegion(HRegionInfo hri)`
`Map<String,RegionState>`	`getRegionsInTransition()` Get regions in transition and their states
`List<HRegionInfo>`	`getRegionsOfTable(TableName tableName)` Gets the online regions of the specified table.
`protected RegionState`	`getRegionState(HRegionInfo hri)`
`protected RegionState`	`getRegionState(String encodedName)`
`RegionState`	`getRegionTransitionState(HRegionInfo hri)` Get region transition state
`RegionState`	`getRegionTransitionState(String encodedName)` Get region transition state
`Set<HRegionInfo>`	`getServerRegions(ServerName serverName)` Get a copy of all regions assigned to a server
`(package private) static boolean`	`isOneOfStates(RegionState regionState, RegionState.State... states)`
`boolean`	`isRegionInRegionStates(HRegionInfo hri)`
`boolean`	`isRegionInState(HRegionInfo hri, RegionState.State... states)`
`boolean`	`isRegionInState(String encodedName, RegionState.State... states)`
`boolean`	`isRegionInTransition(HRegionInfo hri)`
`boolean`	`isRegionInTransition(String encodedName)`
`boolean`	`isRegionOffline(HRegionInfo hri)`
`boolean`	`isRegionOnline(HRegionInfo hri)`
`boolean`	`isRegionsInTransition()`
`(package private) boolean`	`isServerDeadAndNotProcessed(ServerName server)`
`void`	`logSplit(HRegionInfo region)` Log split is done for a given region, so it is assignable now.
`void`	`logSplit(ServerName serverName)` A dead server's wals have been split so that all the regions used to be open on it can be safely assigned now.
`(package private) void`	`mergeRegions(HRegionInfo p, HRegionInfo a, HRegionInfo b, ServerName sn)`
`private RegionState`	`putRegionState(RegionState regionState)`
`void`	`regionOffline(HRegionInfo hri)` A region is offline, won't be in transition any more.
`void`	`regionOffline(HRegionInfo hri, RegionState.State expectedState)` A region is offline, won't be in transition any more.
`void`	`regionOnline(HRegionInfo hri, ServerName serverName)`
`void`	`regionOnline(HRegionInfo hri, ServerName serverName, long openSeqNum)` A region is online, won't be in transition any more.
`private void`	`removeFromReplicaMapping(HRegionInfo hri)`
`private void`	`removeFromServerHoldings(ServerName serverName, HRegionInfo hri)`
`List<HRegionInfo>`	`serverOffline(ZooKeeperWatcher watcher, ServerName sn)` A server is offline, all regions on it are dead.
`(package private) void`	`setLastRegionServerOfRegion(ServerName serverName, String encodedName)`
`(package private) void`	`setLastRegionServerOfRegions(ServerName serverName, List<HRegionInfo> regionInfos)`
`RegionState`	`setRegionStateTOCLOSED(byte[] regionName, ServerName serverName)` Set the region state to CLOSED
`RegionState`	`setRegionStateTOCLOSED(HRegionInfo regionInfo, ServerName serverName)` Set the region state to CLOSED
`(package private) void`	`splitRegion(HRegionInfo p, HRegionInfo a, HRegionInfo b, ServerName sn)`
`void`	`tableDeleted(TableName tableName)` A table is deleted.
`RegionState`	`transitionOpenFromPendingOpenOrOpeningOnServer(RegionTransition transition, RegionState fromState, ServerName sn)` Transition a region state to OPEN from OPENING/PENDING_OPEN
`RegionState`	`updateRegionState(HRegionInfo hri, RegionState.State state)` Update a region state.
`RegionState`	`updateRegionState(HRegionInfo hri, RegionState.State state, ServerName serverName)` Update a region state.
`private RegionState`	`updateRegionState(HRegionInfo hri, RegionState.State state, ServerName serverName, long openSeqNum)` Update a region state.
`RegionState`	`updateRegionState(RegionTransition transition, RegionState.State state)` Update a region state.
`void`	`waitForUpdate(long timeout)` Wait for the state map to be updated by assignment manager.
`void`	`waitOnRegionToClearRegionsInTransition(HRegionInfo hri)` Wait on region to clear regions-in-transition.
`(package private) boolean`	`wasRegionOnDeadServer(String encodedName)` Checking if a region was assigned to a server which is not online now.

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
```
  - regionsInTransition
```
final HashMap<String,RegionState> regionsInTransition
```
    Regions currently in transition.
  - regionStates
```
private final Map<String,RegionState> regionStates
```
    Region encoded name to state map. All the regions should be in this map.
  - regionStatesTableIndex
```
private final Map<TableName,Map<String,RegionState>> regionStatesTableIndex
```
    Holds mapping of table -> region state
  - serverHoldings
```
private final Map<ServerName,Set<HRegionInfo>> serverHoldings
```
    Server to regions assignment map. Contains the set of regions currently assigned to a given server.
  - defaultReplicaToOtherReplicas
```
private final Map<HRegionInfo,Set<HRegionInfo>> defaultReplicaToOtherReplicas
```
    Maintains the mapping from the default region to the replica regions.
  - regionAssignments
```
private final TreeMap<HRegionInfo,ServerName> regionAssignments
```
    Region to server assignment map. Contains the server a given region is currently assigned to.
  - lastAssignments
```
private final HashMap<String,ServerName> lastAssignments
```
    Encoded region name to server assignment map for re-assignment purpose. Contains the server a given region is last known assigned to, which has not completed log splitting, so not assignable. If a region is currently assigned, this server info in this map should be the same as that in regionAssignments. However the info in regionAssignments is cleared when the region is offline while the info in lastAssignments is cleared when the region is closed or the server is dead and processed.
  - oldAssignments
```
private final HashMap<String,ServerName> oldAssignments
```
    Encoded region name to server assignment map for the purpose to clean up serverHoldings when a region is online on a new server. When the region is offline from the previous server, we cleaned up regionAssignments so that it has the latest assignment map. But we didn't clean up serverHoldings to match the meta. We need this map to find out the old server whose serverHoldings needs cleanup, given a moved region.
  - deadServers
```
private final HashMap<String,Long> deadServers
```
    Map a host port pair string to the latest start code of a region server which is known to be dead. It is dead to us, but server manager may not know it yet.
  - processedServers
```
private final HashMap<ServerName,Long> processedServers
```
    Map a dead servers to the time when log split is done. Since log splitting is not ordered, we have to remember all processed instances. The map is cleaned up based on a configured time. By default, we assume a dead server should be done with log splitting in two hours.
  - lastProcessedServerCleanTime
```
private long lastProcessedServerCleanTime
```
  - tableStateManager
```
private final TableStateManager tableStateManager
```
  - regionStateStore
```
private final RegionStateStore regionStateStore
```
  - serverManager
```
private final ServerManager serverManager
```
  - server
```
private final Server server
```
  - useZK
```
private final boolean useZK
```
  - LOG_SPLIT_TIME
```
static final String LOG_SPLIT_TIME
```
    See Also:
    Constant Field Values
  - DEFAULT_LOG_SPLIT_TIME
```
static final long DEFAULT_LOG_SPLIT_TIME
```
    See Also:
    Constant Field Values
- Constructor Detail
  - RegionStates
```
RegionStates(Server master,
            TableStateManager tableStateManager,
            ServerManager serverManager,
            RegionStateStore regionStateStore)
```
- Method Detail
  - getRegionAssignments
```
public Map<HRegionInfo,ServerName> getRegionAssignments()
```
    Returns:
    a copy of the region assignment map
  - getRegionAssignments
```
Map<ServerName,List<HRegionInfo>> getRegionAssignments(Collection<HRegionInfo> regions)
```
    Return the replicas (including default) for the regions grouped by ServerName
    
    Parameters:
    regions -
    
    Returns:
    a pair containing the groupings as a map
  - getRegionServerOfRegion
```
public ServerName getRegionServerOfRegion(HRegionInfo hri)
```
  - getRegionsInTransition
```
public Map<String,RegionState> getRegionsInTransition()
```
    Get regions in transition and their states
  - isRegionInTransition
```
public boolean isRegionInTransition(HRegionInfo hri)
```
    Returns:
    True if specified region in transition.
  - isRegionInTransition
```
public boolean isRegionInTransition(String encodedName)
```
    Returns:
    True if specified region in transition.
  - isRegionsInTransition
```
public boolean isRegionsInTransition()
```
    Returns:
    True if any region in transition.
  - isRegionOnline
```
public boolean isRegionOnline(HRegionInfo hri)
```
    Returns:
    True if specified region assigned, and not in transition.
  - isRegionOffline
```
public boolean isRegionOffline(HRegionInfo hri)
```
    Returns:
    True if specified region offline/closed, but not in transition. If the region is not in the map, it is offline to us too.
  - isRegionInState
```
public boolean isRegionInState(HRegionInfo hri,
                      RegionState.State... states)
```
    Returns:
    True if specified region is in one of the specified states.
  - isRegionInState
```
public boolean isRegionInState(String encodedName,
                      RegionState.State... states)
```
    Returns:
    True if specified region is in one of the specified states.
  - waitForUpdate
```
public void waitForUpdate(long timeout)
                   throws InterruptedException
```
    Wait for the state map to be updated by assignment manager.
    
    Throws:
    
    InterruptedException
  - getRegionTransitionState
```
public RegionState getRegionTransitionState(HRegionInfo hri)
```
    Get region transition state
  - getRegionTransitionState
```
public RegionState getRegionTransitionState(String encodedName)
```
    Get region transition state
  - createRegionStates
```
public void createRegionStates(List<HRegionInfo> hris)
```
    Add a list of regions to RegionStates. If a region is split and offline, its state will be SPLIT. Otherwise, its state will be OFFLINE. Region already in RegionStates will be skipped.
  - createRegionState
```
public RegionState createRegionState(HRegionInfo hri)
```
    Add a region to RegionStates. If the region is split and offline, its state will be SPLIT. Otherwise, its state will be OFFLINE. If it is already in RegionStates, this call has no effect, and the original state is returned.
  - createRegionState
```
public RegionState createRegionState(HRegionInfo hri,
                            RegionState.State newState,
                            ServerName serverName,
                            ServerName lastHost)
```
    Add a region to RegionStates with the specified state. If the region is already in RegionStates, this call has no effect, and the original state is returned.
    
    Parameters:
    hri - the region info to create a state for
    newState - the state to the region in set to
    serverName - the server the region is transitioning on
    lastHost - the last server that hosts the region
    
    Returns:
    the current state
  - putRegionState
```
private RegionState putRegionState(RegionState regionState)
```
  - setRegionStateTOCLOSED
```
public RegionState setRegionStateTOCLOSED(byte[] regionName,
                                 ServerName serverName)
```
    Set the region state to CLOSED
  - setRegionStateTOCLOSED
```
public RegionState setRegionStateTOCLOSED(HRegionInfo regionInfo,
                                 ServerName serverName)
```
    Set the region state to CLOSED
  - updateRegionState
```
public RegionState updateRegionState(HRegionInfo hri,
                            RegionState.State state)
```
    Update a region state. It will be put in transition if not already there.
  - updateRegionState
```
public RegionState updateRegionState(RegionTransition transition,
                            RegionState.State state)
```
    Update a region state. It will be put in transition if not already there. If we can't find the region info based on the region name in the transition, log a warning and return null.
  - transitionOpenFromPendingOpenOrOpeningOnServer
```
public RegionState transitionOpenFromPendingOpenOrOpeningOnServer(RegionTransition transition,
                                                         RegionState fromState,
                                                         ServerName sn)
```
    Transition a region state to OPEN from OPENING/PENDING_OPEN
  - updateRegionState
```
public RegionState updateRegionState(HRegionInfo hri,
                            RegionState.State state,
                            ServerName serverName)
```
    Update a region state. It will be put in transition if not already there.
  - regionOnline
```
public void regionOnline(HRegionInfo hri,
                ServerName serverName)
```
  - regionOnline
```
public void regionOnline(HRegionInfo hri,
                ServerName serverName,
                long openSeqNum)
```
    A region is online, won't be in transition any more. We can't confirm it is really online on specified region server because it hasn't been put in region server's online region list yet.
  - addToServerHoldings
```
private void addToServerHoldings(ServerName serverName,
                       HRegionInfo hri)
```
  - addToReplicaMapping
```
private void addToReplicaMapping(HRegionInfo hri)
```
  - removeFromServerHoldings
```
private void removeFromServerHoldings(ServerName serverName,
                            HRegionInfo hri)
```
  - removeFromReplicaMapping
```
private void removeFromReplicaMapping(HRegionInfo hri)
```
  - existsInServerHoldings
```
boolean existsInServerHoldings(ServerName serverName,
                             HRegionInfo hri)
```
    Used in some unit tests
  - logSplit
```
public void logSplit(ServerName serverName)
```
    A dead server's wals have been split so that all the regions used to be open on it can be safely assigned now. Mark them assignable.
  - logSplit
```
public void logSplit(HRegionInfo region)
```
    Log split is done for a given region, so it is assignable now.
  - clearLastAssignment
```
public void clearLastAssignment(HRegionInfo region)
```
  - regionOffline
```
public void regionOffline(HRegionInfo hri)
```
    A region is offline, won't be in transition any more.
  - regionOffline
```
public void regionOffline(HRegionInfo hri,
                 RegionState.State expectedState)
```
    A region is offline, won't be in transition any more. Its state should be the specified expected state, which can only be Split/Merged/Offline/null(=Offline)/SplittingNew/MergingNew.
  - serverOffline
```
public List<HRegionInfo> serverOffline(ZooKeeperWatcher watcher,
                              ServerName sn)
```
    A server is offline, all regions on it are dead.
  - cleanFailedSplitMergeRegions
```
private void cleanFailedSplitMergeRegions(Set<HRegionInfo> hris)
```
    This method does an RPC to hbase:meta. Do not call this method with a lock/synchronize held. In ZK mode we rollback and hence cleanup daughters/merged region. We also cleanup if meta doesn't have these regions.
    
    Parameters:
    hris - The hris to check if empty in hbase:meta and if so, clean them up.
  - getRegionsOfTable
```
public List<HRegionInfo> getRegionsOfTable(TableName tableName)
```
    Gets the online regions of the specified table. This method looks at the in-memory state. It does not go to hbase:meta. Only returns online regions. If a region on this table has been closed during a disable, etc., it will be included in the returned list. So, the returned list may not necessarily be ALL regions in this table, its all the ONLINE regions in the table.
    
    Parameters:
    tableName -
    
    Returns:
    Online regions from tableName
  - getRegionByStateOfTable
```
public Map<RegionState.State,List<HRegionInfo>> getRegionByStateOfTable(TableName tableName)
```
    Gets current state of all regions of the table. This method looks at the in-memory state. It does not go to hbase:meta. Method guaranteed to return keys for all states in RegionState.State
    
    Parameters:
    tableName -
    
    Returns:
    Online regions from tableName
  - waitOnRegionToClearRegionsInTransition
```
public void waitOnRegionToClearRegionsInTransition(HRegionInfo hri)
                                            throws InterruptedException
```
    Wait on region to clear regions-in-transition.
    If the region isn't in transition, returns immediately. Otherwise, method blocks until the region is out of transition.
    
    Throws:
    
    InterruptedException
  - tableDeleted
```
public void tableDeleted(TableName tableName)
```
    A table is deleted. Remove its regions from all internal maps. We loop through all regions assuming we don't delete tables too much.
  - getServerRegions
```
public Set<HRegionInfo> getServerRegions(ServerName serverName)
```
    Get a copy of all regions assigned to a server
  - deleteRegion
```
public void deleteRegion(HRegionInfo hri)
```
    Remove a region from all state maps.
  - isRegionInRegionStates
```
public boolean isRegionInRegionStates(HRegionInfo hri)
```
  - wasRegionOnDeadServer
```
boolean wasRegionOnDeadServer(String encodedName)
```
    Checking if a region was assigned to a server which is not online now. If so, we should hold re-assign this region till SSH has split its wals. Once logs are split, the last assignment of this region will be reset, which means a null last assignment server is ok for re-assigning. A region server could be dead but we don't know it yet. We may think it's online falsely. Therefore if a server is online, we still need to confirm it reachable and having the expected start code.
  - isServerDeadAndNotProcessed
```
boolean isServerDeadAndNotProcessed(ServerName server)
```
  - getLastRegionServerOfRegion
```
ServerName getLastRegionServerOfRegion(String encodedName)
```
    Get the last region server a region was on for purpose of re-assignment, i.e. should the re-assignment be held back till log split is done?
  - setLastRegionServerOfRegions
```
void setLastRegionServerOfRegions(ServerName serverName,
                                List<HRegionInfo> regionInfos)
```
  - setLastRegionServerOfRegion
```
void setLastRegionServerOfRegion(ServerName serverName,
                               String encodedName)
```
  - splitRegion
```
void splitRegion(HRegionInfo p,
               HRegionInfo a,
               HRegionInfo b,
               ServerName sn)
           throws IOException
```
    Throws:
    
    IOException
  - mergeRegions
```
void mergeRegions(HRegionInfo p,
                HRegionInfo a,
                HRegionInfo b,
                ServerName sn)
            throws IOException
```
    Throws:
    
    IOException
  - getRegionReplication
```
private int getRegionReplication(HRegionInfo r)
                          throws IOException
```
    Throws:
    
    IOException
  - closeAllUserRegions
```
Map<HRegionInfo,ServerName> closeAllUserRegions(Set<TableName> excludedTables)
```
    At cluster clean re/start, mark all user regions closed except those of tables that are excluded, such as disabled/disabling/enabling tables. All user regions and their previous locations are returned.
  - getAverageLoad
```
protected double getAverageLoad()
```
    Compute the average load across all region servers. Currently, this uses a very naive computation - just uses the number of regions being served, ignoring stats about number of requests.
    
    Returns:
    the average load
  - getAssignmentsByTable
```
protected Map<TableName,Map<ServerName,List<HRegionInfo>>> getAssignmentsByTable()
```
    This is an EXPENSIVE clone. Cloning though is the safest thing to do. Can't let out original since it can change and at least the load balancer wants to iterate this exported list. We need to synchronize on regions since all access to this.servers is under a lock on this.regions.
    
    Returns:
    A clone of current assignments by table.
  - getRegionState
```
protected RegionState getRegionState(HRegionInfo hri)
```
  - getRegionAssignmentsByServer
```
protected Map<ServerName,List<HRegionInfo>> getRegionAssignmentsByServer()
```
    Returns a clone of region assignments per server
    
    Returns:
    a Map of ServerName to a List of HRegionInfo's
  - getRegionState
```
protected RegionState getRegionState(String encodedName)
```
  - getRegionInfo
```
protected HRegionInfo getRegionInfo(byte[] regionName)
```
    Get the HRegionInfo from cache, if not there, from the hbase:meta table
    
    Parameters:
    regionName -
    
    Returns:
    HRegionInfo for the region
  - isOneOfStates
```
static boolean isOneOfStates(RegionState regionState,
                    RegionState.State... states)
```
  - updateRegionState
```
private RegionState updateRegionState(HRegionInfo hri,
                            RegionState.State state,
                            ServerName serverName,
                            long openSeqNum)
```
    Update a region state. It will be put in transition if not already there.

Class RegionStates

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

LOG

regionsInTransition

regionStates

regionStatesTableIndex

serverHoldings

defaultReplicaToOtherReplicas

regionAssignments

lastAssignments

oldAssignments

deadServers

processedServers

lastProcessedServerCleanTime

tableStateManager

regionStateStore

serverManager

server

useZK

LOG_SPLIT_TIME

DEFAULT_LOG_SPLIT_TIME

Constructor Detail

RegionStates

Method Detail

getRegionAssignments

getRegionAssignments

getRegionServerOfRegion

getRegionsInTransition

isRegionInTransition

isRegionInTransition

isRegionsInTransition

isRegionOnline

isRegionOffline

isRegionInState

isRegionInState

waitForUpdate

getRegionTransitionState

getRegionTransitionState

createRegionStates

createRegionState

createRegionState

putRegionState

setRegionStateTOCLOSED

setRegionStateTOCLOSED

updateRegionState

updateRegionState

transitionOpenFromPendingOpenOrOpeningOnServer

updateRegionState

regionOnline

regionOnline

addToServerHoldings

addToReplicaMapping

removeFromServerHoldings

removeFromReplicaMapping

existsInServerHoldings

logSplit

logSplit

clearLastAssignment

regionOffline

regionOffline

serverOffline

cleanFailedSplitMergeRegions

getRegionsOfTable

getRegionByStateOfTable

waitOnRegionToClearRegionsInTransition

tableDeleted

getServerRegions

deleteRegion

isRegionInRegionStates

wasRegionOnDeadServer

isServerDeadAndNotProcessed

getLastRegionServerOfRegion

setLastRegionServerOfRegions

setLastRegionServerOfRegion

splitRegion

mergeRegions