RegionStates (Apache HBase - Server 2.6.1 API)

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

```
@InterfaceAudience.Private
public class RegionStates
extends Object
```
RegionStates contains a set of Maps that describes the in-memory state of the AM, with the regions available in the system, the region in transition, the offline regions and the servers holding regions.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class RegionStates.RegionFailedOpen

Nested Classes
Modifier and Type	Class and Description
`static class`	`RegionStates.RegionFailedOpen`

Field Summary

Fields
Modifier and Type Field and Description

static org.apache.hadoop.hbase.master.assignment.RegionStates.RegionStateStampComparator REGION_STATE_STAMP_COMPARATOR

Fields
Modifier and Type	Field and Description
`static org.apache.hadoop.hbase.master.assignment.RegionStates.RegionStateStampComparator`	`REGION_STATE_STAMP_COMPARATOR`

Constructor Summary

Constructors
Constructor and Description

RegionStates()

Constructors
Constructor and Description
`RegionStates()`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addRegionToServer(RegionStateNode regionNode)`
`RegionStates.RegionFailedOpen`	`addToFailedOpen(RegionStateNode regionNode)`
`void`	`addToOfflineRegions(RegionStateNode regionNode)`
`HRegionLocation`	`checkReopened(HRegionLocation oldLoc)` Check whether the region has been reopened.
`void`	`clear()` Called on stop of AssignmentManager.
`void`	`createServer(ServerName serverName)` Create the ServerStateNode when registering a new region server
`void`	`deleteRegion(RegionInfo regionInfo)`
`void`	`deleteRegions(List<RegionInfo> regionInfos)`
`List<RegionInfo>`	`getAssignedRegions()`
`Map<TableName,Map<ServerName,List<RegionInfo>>>`	`getAssignmentsForBalancer(TableStateManager tableStateManager, List<ServerName> onlineServers)` This is an EXPENSIVE clone.
`double`	`getAverageLoad()`
`RegionStates.RegionFailedOpen`	`getFailedOpen(RegionInfo regionInfo)`
`RegionStateNode`	`getOrCreateRegionStateNode(RegionInfo regionInfo)`
`Map<RegionInfo,ServerName>`	`getRegionAssignments()`
`Map<RegionState.State,List<RegionInfo>>`	`getRegionByStateOfTable(TableName tableName)`
`List<RegionState>`	`getRegionFailedOpen()`
`ServerName`	`getRegionServerOfRegion(RegionInfo regionInfo)`
`List<RegionStateNode>`	`getRegionsInTransition()`
`int`	`getRegionsInTransitionCount()` Get the number of regions in transition.
`SortedSet<RegionState>`	`getRegionsInTransitionOrderedByTimestamp()`
`List<RegionInfo>`	`getRegionsOfTable(TableName table)` Returns Return online regions of table; does not include OFFLINE or SPLITTING regions.
`List<RegionInfo>`	`getRegionsOfTableForDeleting(TableName table)` Get the regions for deleting a table.
`List<RegionInfo>`	`getRegionsOfTableForEnabling(TableName table)` Get the regions for enabling a table.
`List<HRegionLocation>`	`getRegionsOfTableForReopen(TableName tableName)` Get the regions to be reopened when modifying a table.
`List<RegionState>`	`getRegionsStateInTransition()`
`RegionState`	`getRegionState(RegionInfo regionInfo)`
`RegionState`	`getRegionState(String encodedRegionName)`
`RegionStateNode`	`getRegionStateNode(RegionInfo regionInfo)`
`RegionStateNode`	`getRegionStateNodeFromEncodedRegionName(String encodedRegionName)`
`RegionStateNode`	`getRegionStateNodeFromName(byte[] regionName)`
`Collection<RegionStateNode>`	`getRegionStateNodes()` Returns A view of region state nodes for all the regions.
`ArrayList<RegionState>`	`getRegionStates()` Returns A snapshot of region state nodes for all the regions.
`RegionState`	`getRegionTransitionState(RegionInfo hri)`
`ServerStateNode`	`getServerNode(ServerName serverName)` Returns Pertinent ServerStateNode or NULL if none found (Do not make modifications).
`Map<ServerName,List<RegionInfo>>`	`getSnapShotOfAssignment(Collection<RegionInfo> regions)`
`boolean`	`hasRegionsInTransition()`
`boolean`	`hasTableRegionStates(TableName tableName)`
`boolean`	`isRegionInRegionStates(RegionInfo hri)`
`boolean`	`isRegionInState(RegionInfo regionInfo, RegionState.State... state)`
`boolean`	`isRegionInTransition(RegionInfo regionInfo)`
`boolean`	`isRegionOffline(RegionInfo regionInfo)` Returns True if region is offline (In OFFLINE or CLOSED state).
`boolean`	`isRegionOnline(RegionInfo regionInfo)`
`void`	`logSplit(ServerName serverName)` Called after we've split all logs on a crashed Server.
`void`	`logSplitting(ServerName serverName)` Call this when we start log splitting for a crashed Server.
`void`	`metaLogSplit(ServerName serverName)` Called after we've split the meta logs on a crashed Server.
`void`	`metaLogSplitting(ServerName serverName)` Call this when we start meta log splitting a crashed Server.
`static String`	`regionNamesToString(Collection<byte[]> regions)`
`void`	`removeFromFailedOpen(RegionInfo regionInfo)`
`void`	`removeRegionFromServer(ServerName serverName, RegionStateNode regionNode)`
`void`	`removeServer(ServerName serverName)` Called by SCP at end of successful processing.
`void`	`updateRegionState(RegionInfo regionInfo, RegionState.State state)`

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

- Field Detail
  - REGION_STATE_STAMP_COMPARATOR
```
public static final org.apache.hadoop.hbase.master.assignment.RegionStates.RegionStateStampComparator REGION_STATE_STAMP_COMPARATOR
```
- Constructor Detail
  - RegionStates
```
public RegionStates()
```
- Method Detail
  - clear
```
public void clear()
```
    Called on stop of AssignmentManager.
  - isRegionInRegionStates
```
public boolean isRegionInRegionStates(RegionInfo hri)
```
  - getOrCreateRegionStateNode
```
public RegionStateNode getOrCreateRegionStateNode(RegionInfo regionInfo)
```
  - getRegionStateNodeFromName
```
public RegionStateNode getRegionStateNodeFromName(byte[] regionName)
```
  - getRegionStateNodeFromEncodedRegionName
```
public RegionStateNode getRegionStateNodeFromEncodedRegionName(String encodedRegionName)
```
  - getRegionStateNode
```
public RegionStateNode getRegionStateNode(RegionInfo regionInfo)
```
  - deleteRegion
```
public void deleteRegion(RegionInfo regionInfo)
```
  - deleteRegions
```
public void deleteRegions(List<RegionInfo> regionInfos)
```
  - getRegionStateNodes
```
public Collection<RegionStateNode> getRegionStateNodes()
```
    Returns A view of region state nodes for all the regions.
  - getRegionStates
```
public ArrayList<RegionState> getRegionStates()
```
    Returns A snapshot of region state nodes for all the regions.
  - getRegionState
```
public RegionState getRegionState(RegionInfo regionInfo)
```
  - getRegionState
```
public RegionState getRegionState(String encodedRegionName)
```
  - hasTableRegionStates
```
public boolean hasTableRegionStates(TableName tableName)
```
  - getRegionsOfTable
```
public List<RegionInfo> getRegionsOfTable(TableName table)
```
    Returns Return online regions of table; does not include OFFLINE or SPLITTING regions.
  - getRegionsOfTableForReopen
```
public List<HRegionLocation> getRegionsOfTableForReopen(TableName tableName)
```
    Get the regions to be reopened when modifying a table.
    Notice that the openSeqNum in the returned HRegionLocation is also used to indicate the state of this region, positive means the region is in RegionState.State.OPEN, -1 means RegionState.State.OPENING. And for regions in other states we do not need reopen them.
  - checkReopened
```
public HRegionLocation checkReopened(HRegionLocation oldLoc)
```
    Check whether the region has been reopened. The meaning of the HRegionLocation is the same with getRegionsOfTableForReopen(TableName).
    For a region which is in RegionState.State.OPEN before, if the region state is changed or the open seq num is changed, we can confirm that it has been reopened.
    For a region which is in RegionState.State.OPENING before, usually it will be in RegionState.State.OPEN now and we will schedule a MRP to reopen it. But there are several exceptions:
    - The region is in state other than RegionState.State.OPEN or RegionState.State.OPENING.
    - The location of the region has been changed
    Of course the region could still be in RegionState.State.OPENING state and still on the same server, then here we will still return a HRegionLocation for it, just like getRegionsOfTableForReopen(TableName).
    Parameters:
    
    oldLoc - the previous state/location of this region
    
    Returns:
    
    null if the region has been reopened, otherwise a new HRegionLocation which means we still need to reopen the region.
    
    See Also:
    
    getRegionsOfTableForReopen(TableName)
  - getRegionsOfTableForEnabling
```
public List<RegionInfo> getRegionsOfTableForEnabling(TableName table)
```
    Get the regions for enabling a table.
    Here we want the EnableTableProcedure to be more robust and can be used to fix some nasty states, so the checks in this method will be a bit strange. In general, a region can only be offline when it is split, for merging we will just delete the parent regions, but with HBCK we may force update the state of a region to fix some nasty bugs, so in this method we will try to bring the offline regions back if it is not split. That's why we only check for split state here.
  - getRegionsOfTableForDeleting
```
public List<RegionInfo> getRegionsOfTableForDeleting(TableName table)
```
    Get the regions for deleting a table.
    Here we need to return all the regions irrespective of the states in order to archive them all. This is because if we don't archive OFFLINE/SPLIT regions and if a snapshot or a cloned table references to the regions, we will lose the data of the regions.
  - metaLogSplitting
```
public void metaLogSplitting(ServerName serverName)
```
    Call this when we start meta log splitting a crashed Server.
    
    See Also:
    
    metaLogSplit(ServerName)
  - metaLogSplit
```
public void metaLogSplit(ServerName serverName)
```
    Called after we've split the meta logs on a crashed Server.
    
    See Also:
    
    metaLogSplitting(ServerName)
  - logSplitting
```
public void logSplitting(ServerName serverName)
```
    Call this when we start log splitting for a crashed Server.
    
    See Also:
    
    logSplit(ServerName)
  - logSplit
```
public void logSplit(ServerName serverName)
```
    Called after we've split all logs on a crashed Server.
    
    See Also:
    
    logSplitting(ServerName)
  - updateRegionState
```
public void updateRegionState(RegionInfo regionInfo,
                              RegionState.State state)
```
  - getAssignedRegions
```
public List<RegionInfo> getAssignedRegions()
```
  - isRegionInState
```
public boolean isRegionInState(RegionInfo regionInfo,
                               RegionState.State... state)
```
  - isRegionOnline
```
public boolean isRegionOnline(RegionInfo regionInfo)
```
  - isRegionOffline
```
public boolean isRegionOffline(RegionInfo regionInfo)
```
    Returns True if region is offline (In OFFLINE or CLOSED state).
  - getSnapShotOfAssignment
```
public Map<ServerName,List<RegionInfo>> getSnapShotOfAssignment(Collection<RegionInfo> regions)
```
  - getRegionAssignments
```
public Map<RegionInfo,ServerName> getRegionAssignments()
```
  - getRegionByStateOfTable
```
public Map<RegionState.State,List<RegionInfo>> getRegionByStateOfTable(TableName tableName)
```
  - getRegionServerOfRegion
```
public ServerName getRegionServerOfRegion(RegionInfo regionInfo)
```
  - getAssignmentsForBalancer
```
public Map<TableName,Map<ServerName,List<RegionInfo>>> getAssignmentsForBalancer(TableStateManager tableStateManager,
                                                                                 List<ServerName> onlineServers)
```
    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 open or opening assignments.
  - hasRegionsInTransition
```
public boolean hasRegionsInTransition()
```
  - isRegionInTransition
```
public boolean isRegionInTransition(RegionInfo regionInfo)
```
  - getRegionTransitionState
```
public RegionState getRegionTransitionState(RegionInfo hri)
```
  - getRegionsInTransition
```
public List<RegionStateNode> getRegionsInTransition()
```
  - getRegionsInTransitionCount
```
public int getRegionsInTransitionCount()
```
    Get the number of regions in transition.
  - getRegionsStateInTransition
```
public List<RegionState> getRegionsStateInTransition()
```
  - getRegionsInTransitionOrderedByTimestamp
```
public SortedSet<RegionState> getRegionsInTransitionOrderedByTimestamp()
```
  - addToOfflineRegions
```
public void addToOfflineRegions(RegionStateNode regionNode)
```
  - addToFailedOpen
```
public RegionStates.RegionFailedOpen addToFailedOpen(RegionStateNode regionNode)
```
  - getFailedOpen
```
public RegionStates.RegionFailedOpen getFailedOpen(RegionInfo regionInfo)
```
  - removeFromFailedOpen
```
public void removeFromFailedOpen(RegionInfo regionInfo)
```
  - getRegionFailedOpen
```
public List<RegionState> getRegionFailedOpen()
```
  - createServer
```
public void createServer(ServerName serverName)
```
    Create the ServerStateNode when registering a new region server
  - removeServer
```
public void removeServer(ServerName serverName)
```
    Called by SCP at end of successful processing.
  - getServerNode
```
public ServerStateNode getServerNode(ServerName serverName)
```
    Returns Pertinent ServerStateNode or NULL if none found (Do not make modifications).
  - getAverageLoad
```
public double getAverageLoad()
```
  - addRegionToServer
```
public void addRegionToServer(RegionStateNode regionNode)
```
  - removeRegionFromServer
```
public void removeRegionFromServer(ServerName serverName,
                                   RegionStateNode regionNode)
```
  - regionNamesToString
```
public static String regionNamesToString(Collection<byte[]> regions)
```

Class RegionStates

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

REGION_STATE_STAMP_COMPARATOR

Constructor Detail

RegionStates

Method Detail

clear

isRegionInRegionStates

getOrCreateRegionStateNode

getRegionStateNodeFromName

getRegionStateNodeFromEncodedRegionName

getRegionStateNode

deleteRegion

deleteRegions

getRegionStateNodes

getRegionStates

getRegionState

getRegionState

hasTableRegionStates

getRegionsOfTable

getRegionsOfTableForReopen

checkReopened

getRegionsOfTableForEnabling

getRegionsOfTableForDeleting

metaLogSplitting

metaLogSplit

logSplitting

logSplit

updateRegionState

getAssignedRegions

isRegionInState

isRegionOnline

isRegionOffline

getSnapShotOfAssignment

getRegionAssignments

getRegionByStateOfTable

getRegionServerOfRegion

getAssignmentsForBalancer

hasRegionsInTransition

isRegionInTransition

getRegionTransitionState

getRegionsInTransition

getRegionsInTransitionCount

getRegionsStateInTransition

getRegionsInTransitionOrderedByTimestamp

addToOfflineRegions

addToFailedOpen

getFailedOpen

removeFromFailedOpen

getRegionFailedOpen

createServer

removeServer

getServerNode

getAverageLoad

addRegionToServer

removeRegionFromServer

regionNamesToString