RegionStates (Apache HBase - Server 2.2.2 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
`ServerStateNode`	`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()`
`void`	`deleteRegion(RegionInfo regionInfo)`
`void`	`deleteRegions(List<RegionInfo> regionInfos)`
`List<RegionInfo>`	`getAssignedRegions()`
`Map<TableName,Map<ServerName,List<RegionInfo>>>`	`getAssignmentsForBalancer(boolean isByTable)` This is an EXPENSIVE clone.
`double`	`getAverageLoad()`
`RegionStates.RegionFailedOpen`	`getFailedOpen(RegionInfo regionInfo)`
`RegionStateNode`	`getOrCreateRegionStateNode(RegionInfo regionInfo)`
`ServerStateNode`	`getOrCreateServer(ServerName serverName)` Be judicious calling this method.
`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)`
`List<RegionInfo>`	`getRegionsOfTable(TableName table, boolean offline)`
`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)`
`Collection<RegionStateNode>`	`getRegionStateNodes()`
`ArrayList<RegionState>`	`getRegionStates()`
`RegionState`	`getRegionTransitionState(RegionInfo hri)`
`ServerStateNode`	`getServerNode(ServerName serverName)`
`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)`
`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`	`removeFromOfflineRegions(RegionInfo regionInfo)`
`ServerStateNode`	`removeRegionFromServer(ServerName serverName, RegionStateNode regionNode)`
`void`	`removeServer(ServerName serverName)`
`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()
```
  - isRegionInRegionStates
```
public boolean isRegionInRegionStates(RegionInfo hri)
```
  - getOrCreateRegionStateNode
```
public RegionStateNode getOrCreateRegionStateNode(RegionInfo regionInfo)
```
  - 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)
  - getRegionsOfTable
```
public List<RegionInfo> getRegionsOfTable(TableName table,
                                          boolean offline)
```
    Returns:
    
    Return online regions of table; does not include OFFLINE or SPLITTING 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(boolean isByTable)
```
    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.
    
    Parameters:
    
    isByTable - If true, return the assignments by table. If false, return the assignments which aggregate the server-load to the cluster level.
    
    Returns:
    
    A clone of current 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)
```
  - removeFromOfflineRegions
```
public void removeFromOfflineRegions(RegionInfo regionInfo)
```
  - 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()
```
  - getOrCreateServer
```
public ServerStateNode getOrCreateServer(ServerName serverName)
```
    Be judicious calling this method. Do it on server register ONLY otherwise you could mess up online server accounting. TOOD: Review usage and convert to getServerNode(ServerName) where we can.
  - removeServer
```
public void removeServer(ServerName serverName)
```
  - getServerNode
```
public ServerStateNode getServerNode(ServerName serverName)
```
  - getAverageLoad
```
public double getAverageLoad()
```
  - addRegionToServer
```
public ServerStateNode addRegionToServer(RegionStateNode regionNode)
```
  - removeRegionFromServer
```
public ServerStateNode 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

getRegionStateNode

deleteRegion

deleteRegions

getRegionStateNodes

getRegionStates

getRegionState

getRegionState

hasTableRegionStates

getRegionsOfTable

getRegionsOfTableForReopen

checkReopened

getRegionsOfTable

metaLogSplitting

metaLogSplit

logSplitting

logSplit

updateRegionState

getAssignedRegions

isRegionInState

isRegionOnline

isRegionOffline

getSnapShotOfAssignment

getRegionAssignments

getRegionByStateOfTable

getRegionServerOfRegion

getAssignmentsForBalancer

hasRegionsInTransition

isRegionInTransition

getRegionTransitionState

getRegionsInTransition

getRegionsInTransitionCount

getRegionsStateInTransition

getRegionsInTransitionOrderedByTimestamp

addToOfflineRegions

removeFromOfflineRegions

addToFailedOpen

getFailedOpen

removeFromFailedOpen

getRegionFailedOpen

getOrCreateServer

removeServer

getServerNode

getAverageLoad

addRegionToServer

removeRegionFromServer

regionNamesToString