RegionStateNode (Apache HBase 2.5.0 API)

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

All Implemented Interfaces:

Comparable<RegionStateNode>
```
@InterfaceAudience.Private
public class RegionStateNode
extends Object
implements Comparable<RegionStateNode>
```
Current Region State. Most fields are synchronized with meta region, i.e, we will update meta immediately after we modify this RegionStateNode, and usually under the lock. The only exception is lastHost, which should not be used for critical condition.
Typically, the only way to modify this class is through TransitRegionStateProcedure, and we will record the TRSP along with this RegionStateNode to make sure that there could at most one TRSP. For other operations, such as SCP, we will first get the lock, and then try to schedule a TRSP. If there is already one, then the solution will be different:
- For SCP, we will update the region state in meta to tell the TRSP to retry.
- For DisableTableProcedure, as we have the xlock, we can make sure that the TRSP has not been executed yet, so just unset it and attach a new one. The original one will quit immediately when executing.
- For split/merge, we will fail immediately as there is no actual operations yet so no harm.
- For EnableTableProcedure/TruncateTableProcedure, we can make sure that there will be no TRSP attached with the RSNs.
- For other procedures, you'd better use ReopenTableRegionsProcedure. The RTRP will take care of lots of corner cases when reopening regions.
Several fields are declared with volatile, which means you are free to get it without lock, but usually you should not use these fields without locking for critical condition, as it will be easily to introduce inconsistency. For example, you are free to dump the status and show it on web without locking, but if you want to change the state of the RegionStateNode by checking the current state, you'd better have the lock...

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

private static class RegionStateNode.AssignmentProcedureEvent

Nested Classes
Modifier and Type	Class and Description
`private static class`	`RegionStateNode.AssignmentProcedureEvent`

Field Summary

Fields
Modifier and Type	Field and Description
`private ProcedureEvent<?>`	`event`
`private ServerName`	`lastHost`
`private long`	`lastUpdate` Updated whenever a call to `setRegionLocation(ServerName)` or `setState(RegionState.State, RegionState.State...)`.
`(package private) Lock`	`lock`
`private static org.slf4j.Logger`	`LOG`
`private long`	`openSeqNum`
`private TransitRegionStateProcedure`	`procedure`
`private RegionInfo`	`regionInfo`
`private ServerName`	`regionLocation`
`private ConcurrentMap<RegionInfo,RegionStateNode>`	`ritMap`
`private RegionState.State`	`state` A Region-in-Transition (RIT) moves through states.

Constructor Summary

Constructors
Constructor and Description

RegionStateNode(RegionInfo regionInfo, ConcurrentMap<RegionInfo,RegionStateNode> ritMap)

Constructors
Constructor and Description
`RegionStateNode(RegionInfo regionInfo, ConcurrentMap<RegionInfo,RegionStateNode> ritMap)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`checkOnline()`
`int`	`compareTo(RegionStateNode other)`
`boolean`	`equals(Object other)`
`int`	`getFormatVersion()`
`ServerName`	`getLastHost()`
`long`	`getLastUpdate()`
`long`	`getOpenSeqNum()`
`TransitRegionStateProcedure`	`getProcedure()`
`ProcedureEvent<?>`	`getProcedureEvent()`
`RegionInfo`	`getRegionInfo()`
`ServerName`	`getRegionLocation()`
`RegionState.State`	`getState()`
`TableName`	`getTable()`
`int`	`hashCode()`
`boolean`	`isInState(RegionState.State... expected)` Notice that, we will return true if `expected` is empty.
`boolean`	`isInTransition()`
`boolean`	`isSplit()` Return whether the region has been split and not online.
`boolean`	`isStuck()`
`boolean`	`isSystemTable()`
`void`	`lock()`
`ServerName`	`offline()` Put region into OFFLINE mode (set state and clear location).
`void`	`setLastHost(ServerName serverName)`
`void`	`setOpenSeqNum(long seqId)`
`TransitRegionStateProcedure`	`setProcedure(TransitRegionStateProcedure proc)`
`ServerName`	`setRegionLocation(ServerName serverName)`
`boolean`	`setState(RegionState.State update, RegionState.State... expected)`
`String`	`toDescriptiveString()`
`RegionState`	`toRegionState()`
`String`	`toShortString()`
`String`	`toString()`
`void`	`transitionState(RegionState.State update, RegionState.State... expected)` Set new `RegionState.State` but only if currently in `expected` State (if not, throw `UnexpectedStateException`.
`void`	`unlock()`
`void`	`unsetProcedure(TransitRegionStateProcedure proc)`

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

Field Detail

LOG

private static final org.slf4j.Logger LOG

lock
```
final Lock lock
```

regionInfo
```
private final RegionInfo regionInfo
```

event
```
private final ProcedureEvent<?> event
```

ritMap

private final ConcurrentMap<RegionInfo,RegionStateNode> ritMap

procedure

private volatile TransitRegionStateProcedure procedure

regionLocation

private volatile ServerName regionLocation

lastHost
```
private volatile ServerName lastHost
```

state
```
private volatile RegionState.State state
```
A Region-in-Transition (RIT) moves through states. See RegionState.State for complete list. A Region that is opened moves from OFFLINE => OPENING => OPENED.

lastUpdate
```
private volatile long lastUpdate
```
Updated whenever a call to setRegionLocation(ServerName) or setState(RegionState.State, RegionState.State...).

openSeqNum
```
private volatile long openSeqNum
```

Constructor Detail

RegionStateNode

RegionStateNode(RegionInfo regionInfo,
                ConcurrentMap<RegionInfo,RegionStateNode> ritMap)

Method Detail

setState
```
public boolean setState(RegionState.State update,
                        RegionState.State... expected)
```
Parameters:

update - new region state this node should be assigned.

expected - current state should be in this given list of expected states

Returns:

true, if current state is in expected list; otherwise false.

offline
```
public ServerName offline()
```
Put region into OFFLINE mode (set state and clear location).

Returns:

Last recorded server deploy

transitionState

public void transitionState(RegionState.State update,
                            RegionState.State... expected)
                     throws UnexpectedStateException

Set new RegionState.State but only if currently in expected State (if not, throw UnexpectedStateException.

Throws:: UnexpectedStateException

isInState
```
public boolean isInState(RegionState.State... expected)
```
Notice that, we will return true if expected is empty.
This is a bit strange but we need this logic, for example, we can change the state to OPENING from any state, as in SCP we will not change the state to CLOSED before opening the region.

isStuck
```
public boolean isStuck()
```

isInTransition
```
public boolean isInTransition()
```

isSplit
```
public boolean isSplit()
```
Return whether the region has been split and not online.
In this method we will test both region info and state, and will return true if either of the test returns true. Please see the comments in AssignmentManager.markRegionAsSplit(RegionInfo, ServerName, RegionInfo, RegionInfo) for more details on why we need to test two conditions.

getLastUpdate
```
public long getLastUpdate()
```

setLastHost

public void setLastHost(ServerName serverName)

setOpenSeqNum

public void setOpenSeqNum(long seqId)

setRegionLocation

public ServerName setRegionLocation(ServerName serverName)

setProcedure

public TransitRegionStateProcedure setProcedure(TransitRegionStateProcedure proc)

unsetProcedure

public void unsetProcedure(TransitRegionStateProcedure proc)

getProcedure

public TransitRegionStateProcedure getProcedure()

getProcedureEvent

public ProcedureEvent<?> getProcedureEvent()

getRegionInfo
```
public RegionInfo getRegionInfo()
```

getTable
```
public TableName getTable()
```

isSystemTable
```
public boolean isSystemTable()
```

getLastHost
```
public ServerName getLastHost()
```

getRegionLocation
```
public ServerName getRegionLocation()
```

getState
```
public RegionState.State getState()
```

getOpenSeqNum
```
public long getOpenSeqNum()
```

getFormatVersion
```
public int getFormatVersion()
```

toRegionState
```
public RegionState toRegionState()
```

compareTo
```
public int compareTo(RegionStateNode other)
```
Specified by:

compareTo in interface Comparable<RegionStateNode>

hashCode
```
public int hashCode()
```
Overrides:

hashCode in class Object

equals
```
public boolean equals(Object other)
```
Overrides:

equals in class Object

toString
```
public String toString()
```
Overrides:

toString in class Object

toShortString
```
public String toShortString()
```

toDescriptiveString
```
public String toDescriptiveString()
```

checkOnline

public void checkOnline()
                 throws DoNotRetryRegionException

Throws:: DoNotRetryRegionException

lock
```
public void lock()
```

unlock
```
public void unlock()
```

Class RegionStateNode

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

LOG

lock

regionInfo

event

ritMap

procedure

regionLocation

lastHost

state

lastUpdate

openSeqNum

Constructor Detail

RegionStateNode

Method Detail

setState

offline

transitionState

isInState

isStuck

isInTransition

isSplit

getLastUpdate

setLastHost

setOpenSeqNum

setRegionLocation

setProcedure

unsetProcedure

getProcedure

getProcedureEvent

getRegionInfo

getTable

isSystemTable

getLastHost

getRegionLocation

getState

getOpenSeqNum

getFormatVersion

toRegionState

compareTo

hashCode

equals

toString

toShortString

toDescriptiveString

checkOnline

lock

unlock