Package org.apache.hadoop.hbase.master.assignment

Class AssignmentManager

java.lang.Object

org.apache.hadoop.hbase.master.assignment.AssignmentManager

@Private
public class AssignmentManager
extends Object

The AssignmentManager is the coordinator for region assign/unassign operations.

• In-memory states of regions and servers are stored in RegionStates.
• hbase:meta state updates are handled by RegionStateStore.

Regions are created by CreateTable, Split, Merge. Regions are deleted by DeleteTable, Split, Merge. Assigns are triggered by CreateTable, EnableTable, Split, Merge, ServerCrash. Unassigns are triggered by DisableTable, Split, Merge

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
private static class	AssignmentManager.DeadServerMetricRegionChore
private static class	AssignmentManager.RegionInTransitionChore
static class	AssignmentManager.RegionInTransitionStat
private class	AssignmentManager.RegionMetaLoadingVisitor

Field Summary

Fields

Modifier and Type	Field	Description
static final String	ASSIGN_DISPATCH_WAIT_MSEC_CONF_KEY
static final String	ASSIGN_DISPATCH_WAITQ_MAX_CONF_KEY
static final String	ASSIGN_MAX_ATTEMPTS
static final String	ASSIGN_RETRY_IMMEDIATELY_MAX_ATTEMPTS
private final int	assignDispatchWaitMillis
private final int	assignDispatchWaitQueueMaxSize
private final int	assignMaxAttempts
private final Condition	assignQueueFullCond
private final ReentrantLock	assignQueueLock
private final int	assignRetryImmediatelyMaxAttempts
private Thread	assignThread
static final String	BOOTSTRAP_THREAD_POOL_SIZE_CONF_KEY
private final Object	checkIfShouldMoveSystemRegionLock
static final String	DEAD_REGION_METRIC_CHORE_INTERVAL_MSEC_CONF_KEY
private final AssignmentManager.DeadServerMetricRegionChore	deadMetricChore
private static final int	DEFAULT_ASSIGN_DISPATCH_WAIT_MSEC
private static final int	DEFAULT_ASSIGN_DISPATCH_WAITQ_MAX
private static final int	DEFAULT_ASSIGN_MAX_ATTEMPTS
private static final int	DEFAULT_ASSIGN_RETRY_IMMEDIATELY_MAX_ATTEMPTS
private static final int	DEFAULT_DEAD_REGION_METRIC_CHORE_INTERVAL_MSEC
static final boolean	DEFAULT_FORCE_REGION_RETAINMENT
static final int	DEFAULT_FORCE_REGION_RETAINMENT_RETRIES
static final long	DEFAULT_FORCE_REGION_RETAINMENT_WAIT_INTERVAL
private static final String	DEFAULT_MIN_VERSION_MOVE_SYS_TABLES_CONFIG
private static final int	DEFAULT_RIT_CHORE_INTERVAL_MSEC
private static final int	DEFAULT_RIT_STUCK_WARNING_THRESHOLD
static final String	FORCE_REGION_RETAINMENT
static final String	FORCE_REGION_RETAINMENT_RETRIES	The number of times to check if the region's previous RS is back online, before giving up and proceeding with assignment on a new RS
static final String	FORCE_REGION_RETAINMENT_WAIT_INTERVAL	The wait time in millis before checking again if the region's previous RS is back online
private final boolean	forceRegionRetainment
private final int	forceRegionRetainmentRetries
private final long	forceRegionRetainmentWaitInterval
private static final org.slf4j.Logger	LOG
private final MasterServices	master
private final MasterRegion	masterRegion
private static final Set<RegionInfo>	META_REGION_SET
private final ProcedureEvent<?>	metaAssignEvent
private final ProcedureEvent<?>	metaLoadEvent
private final MetricsAssignmentManager	metrics
static final String	METRICS_RIT_STUCK_WARNING_THRESHOLD	Region in Transition metrics threshold time
private static final String	MIN_VERSION_MOVE_SYS_TABLES_CONFIG
private final String	minVersionToMoveSysTables	When the operator uses this configuration option, any version between the current cluster version and the value of "hbase.min.version.move.system.tables" does not trigger any auto-region movement.
private final ArrayList<RegionStateNode>	pendingAssignQueue
private final RegionStates	regionStates
private final RegionStateStore	regionStateStore
static final String	RIT_CHORE_INTERVAL_MSEC_CONF_KEY
private final AssignmentManager.RegionInTransitionChore	ritChore
private final Map<ServerName,Set<byte[]>>	rsReports
private final AtomicBoolean	running
private final boolean	shouldAssignRegionsWithFavoredNodes
private static final RegionState.State[]	STATES_EXPECTED_ON_ASSIGN
private static final RegionState.State[]	STATES_EXPECTED_ON_CLOSED
private static final RegionState.State[]	STATES_EXPECTED_ON_CLOSING
private static final RegionState.State[]	STATES_EXPECTED_ON_OPEN
private static final RegionState.State[]	STATES_EXPECTED_ON_UNASSIGN_OR_MOVE
static final String	UNEXPECTED_STATE_REGION

Constructor Summary

Constructors

Constructor	Description
AssignmentManager(MasterServices master, MasterRegion masterRegion)
AssignmentManager(MasterServices master, MasterRegion masterRegion, RegionStateStore stateStore)

Method Summary

Modifier and Type	Method	Description
private void	acceptPlan(HashMap<RegionInfo,RegionStateNode> regions, Map<ServerName,List<RegionInfo>> plan)
private void	addToPendingAssignment(HashMap<RegionInfo,RegionStateNode> regions, Collection<RegionInfo> pendingRegions)
long	assign(RegionInfo regionInfo)
long	assign(RegionInfo regionInfo, ServerName sn)
Future<byte[]>	assignAsync(RegionInfo regionInfo)	Submits a procedure that assigns a region without waiting for it to finish
Future<byte[]>	assignAsync(RegionInfo regionInfo, ServerName sn)	Submits a procedure that assigns a region to a target server without waiting for it to finish
private void	assignQueueSignal()
Future<byte[]>	balance(RegionPlan regionPlan)
void	checkIfShouldMoveSystemRegionAsync()	Start a new thread to check if there are region servers whose versions are higher than others.
private void	checkMetaLoaded(RegionInfo hri)	Used to check if the meta loading is done.
private void	checkOnlineRegionsReport(ServerStateNode serverNode, Set<byte[]> regionNames)	Check that what the RegionServer reports aligns with the Master's image.
private void	closeRegionSilently(ServerName sn, byte[] regionName)	Close regionName on sn silently and immediately without using a Procedure or going via hbase:meta.
(package private) static int	compare(TransitRegionStateProcedure left, TransitRegionStateProcedure right)
AssignmentManager.RegionInTransitionStat	computeRegionInTransitionStat()
private boolean	containsBogusAssignments(Map<RegionInfo,RegionStateNode> regions, List<RegionInfo> hirs)
private TransitRegionStateProcedure	createAssignProcedure(RegionInfo regionInfo, ServerName sn, boolean override, boolean force)	Create an assign TransitRegionStateProcedure.
private TransitRegionStateProcedure	createAssignProcedure(RegionStateNode regionNode, ServerName targetServer)	Create an assign TransitRegionStateProcedure.
TransitRegionStateProcedure[]	createAssignProcedures(List<RegionInfo> hris)	Create an array of TransitRegionStateProcedure w/o specifying a target server.
private TransitRegionStateProcedure[]	createAssignProcedures(Map<ServerName,List<RegionInfo>> assignments)	Tied to createAssignProcedures(List) in that it is called if caller is unable to run this method.
MergeTableRegionsProcedure	createMergeProcedure(RegionInfo... ris)
TransitRegionStateProcedure	createMoveRegionProcedure(RegionInfo regionInfo, ServerName targetServer)
TransitRegionStateProcedure	createOneAssignProcedure(RegionInfo ri, boolean override, boolean force)	Create one TransitRegionStateProcedure to assign a region w/o specifying a target server.
TransitRegionStateProcedure	createOneUnassignProcedure(RegionInfo ri, boolean override, boolean force)	Create one TransitRegionStateProcedure to unassign a region.
TransitRegionStateProcedure[]	createRoundRobinAssignProcedures(List<RegionInfo> hris)	Create round-robin assigns.
TransitRegionStateProcedure[]	createRoundRobinAssignProcedures(List<RegionInfo> hris, List<ServerName> serversToExclude)	Create round-robin assigns.
SplitTableRegionProcedure	createSplitProcedure(RegionInfo regionToSplit, byte[] splitKey)
TruncateRegionProcedure	createTruncateRegionProcedure(RegionInfo regionToTruncate)
TransitRegionStateProcedure[]	createUnassignProceduresForDisabling(TableName tableName)	Called by DisableTableProcedure to unassign all the regions for a table.
void	deleteTable(TableName tableName)	Delete the region states.
private TransitRegionStateProcedure	forceCreateUnssignProcedure(RegionStateNode regionNode)
List<RegionInfo>	getAssignedRegions()
(package private) int	getAssignMaxAttempts()
MetricsAssignmentManager	getAssignmentManagerMetrics()
(package private) int	getAssignRetryImmediatelyMaxAttempts()
private LoadBalancer	getBalancer()
org.apache.hadoop.conf.Configuration	getConfiguration()
List<ServerName>	getExcludedServersForSystemTable()	For a given cluster with mixed versions of servers, get a list of servers with lower versions, where system table regions should not be assigned to.
private FavoredNodesPromoter	getFavoredNodePromoter()
List<ServerName>	getFavoredNodes(RegionInfo regionInfo)
int	getForceRegionRetainmentRetries()
long	getForceRegionRetainmentWaitInterval()
(package private) MasterServices	getMaster()
private ProcedureEvent<?>	getMetaAssignEvent(RegionInfo metaRegionInfo)
private RegionInfo	getMetaForRegion(RegionInfo regionInfo)
RegionInfo	getMetaRegionFromName(byte[] regionName)
Set<RegionInfo>	getMetaRegionSet()
int	getNumRegionsOpened()
private MasterProcedureEnv	getProcedureEnvironment()
private MasterProcedureScheduler	getProcedureScheduler()
RegionInfo	getRegionInfo(byte[] regionName)	Resolve a cached RegionInfo from the region name as a byte[].
RegionInfo	getRegionInfo(String encodedRegionName)	Resolve a cached RegionInfo from the encoded region name as a String.
private RegionInfo	getRegionInfo(RegionStateNode rsn)
List<RegionStateNode>	getRegionsInTransition()
List<RegionInfo>	getRegionsOnServer(ServerName serverName)	Returns the regions hosted by the specified server.
private Stream<RegionStateNode>	getRegionStateNodes(TableName tableName, boolean excludeOfflinedSplitParents)
RegionStates	getRegionStates()
RegionStatesCount	getRegionStatesCount(TableName tableName)	Provide regions state count for given table.
RegionStateStore	getRegionStateStore()
Pair<Integer,Integer>	getReopenStatus(TableName tableName)	Used by the client (via master) to identify if all regions have the schema updates
Map<ServerName,Set<byte[]>>	getRSReports()	Returns a snapshot of rsReports
Map<ServerName,List<RegionInfo>>	getSnapShotOfAssignment(Collection<RegionInfo> regions)
private List<RegionInfo>	getSystemTables(ServerName serverName)
List<RegionInfo>	getTableRegions(TableName tableName, boolean excludeOfflinedSplitParents)
List<Pair<RegionInfo,ServerName>>	getTableRegionsAndLocations(TableName tableName, boolean excludeOfflinedSplitParents)
private TableStateManager	getTableStateManager()
private void	handleRegionOverStuckWarningThreshold(RegionInfo regionInfo)
boolean	hasRegionsInTransition()
boolean	isCarryingMeta(ServerName serverName)
private boolean	isCarryingRegion(ServerName serverName, RegionInfo regionInfo)
boolean	isForceRegionRetainment()
boolean	isMetaAssigned()	Notice that, this only means the meta region is available on a RS, but the AM may still be loading the region states from meta, so usually you need to check isMetaLoaded() first before checking this method, unless you can make sure that your piece of code can only be executed after AM builds the region states.
boolean	isMetaLoaded()	Return whether AM finishes the meta loading, i.e, the region states rebuilding.
boolean	isMetaRegion(byte[] regionName)
private boolean	isMetaRegion(RegionInfo regionInfo)
boolean	isMetaRegionInTransition()
boolean	isRunning()
private boolean	isTableDisabled(TableName tableName)
private boolean	isTableEnabled(TableName tableName)
void	joinCluster()
private void	loadMeta()
void	markRegionAsMerged(RegionInfo child, ServerName serverName, RegionInfo[] mergeParents)	When called here, the merge has happened.
void	markRegionAsSplit(RegionInfo parent, ServerName serverName, RegionInfo daughterA, RegionInfo daughterB)
private void	mirrorMetaLocations()
void	move(RegionInfo regionInfo)
Future<byte[]>	moveAsync(RegionPlan regionPlan)
int	numberOfUnclosedExcessRegionReplicas(TableName tableName, int newReplicaCount)
void	offlineRegion(RegionInfo regionInfo)
void	onlineRegion(RegionInfo regionInfo, ServerName serverName)
(package private) CompletableFuture<Void>	persistToMeta(RegionStateNode regionNode)
void	populateRegionStatesFromMeta(String regionEncodedName)	Attempt to load regionEncodedName from META, adding any results to the regionStateStore Is NOT aware of replica regions.
void	populateRegionStatesFromMeta(RegionInfo regionInfo)	Attempt to load regionInfo from META, adding any results to the regionStateStore Is NOT aware of replica regions.
private void	preTransitCheck(RegionStateNode regionNode, RegionState.State[] expectedStates)
private void	processAssignmentPlans(HashMap<RegionInfo,RegionStateNode> regions, HashMap<RegionInfo,ServerName> retainMap, List<RegionInfo> hris, List<ServerName> servers)
private void	processAssignQueue()
void	processOfflineRegions()	Create assign procedure for offline regions.
protected void	queueAssign(RegionStateNode regionNode)	Add the assign operation to the assignment queue.
CompletableFuture<Void>	regionClosedAbnormally(RegionStateNode regionNode)
(package private) void	regionClosedWithoutPersistingToMeta(RegionStateNode regionNode)
(package private) CompletableFuture<Void>	regionClosing(RegionStateNode regionNode)
(package private) CompletableFuture<Void>	regionFailedOpen(RegionStateNode regionNode, boolean giveUp)
(package private) void	regionOpenedWithoutPersistingToMeta(RegionStateNode regionNode)
(package private) CompletableFuture<Void>	regionOpening(RegionStateNode regionNode)
void	reportOnlineRegions(ServerName serverName, Set<byte[]> regionNames)	The master will call this method when the RS send the regionServerReport().
org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.ReportRegionStateTransitionResponse	reportRegionStateTransition(org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.ReportRegionStateTransitionRequest req)
private void	reportRegionStateTransition(org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.ReportRegionStateTransitionResponse.Builder builder, ServerStateNode serverNode, List<org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.RegionStateTransition> transitionList)
private boolean	reportTransition(RegionStateNode regionNode, ServerStateNode serverNode, org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.RegionStateTransition.TransitionCode state, long seqId, long procId)
private void	setMetaAssigned(RegionInfo metaRegionInfo, boolean assigned)
void	setupRIT(List<TransitRegionStateProcedure> procs)	Create RegionStateNode based on the TRSP list, and attach the TRSP to the RegionStateNode.
private boolean	shouldAssignFavoredNodes(RegionInfo region)
void	start()
private void	startAssignmentThread()
void	stop()
private void	stopAssignmentThread()
long	submitServerCrash(ServerName serverName, boolean shouldSplitWal, boolean force)	Usually run by the Master in reaction to server crash during normal processing.
int	submitUnassignProcedureForClosingExcessRegionReplicas(TableName tableName, int newReplicaCount, Consumer<TransitRegionStateProcedure> submit)	Called by ModifyTableProcedure to unassign all the excess region replicas for a table.
private CompletableFuture<Void>	transitStateAndUpdate(RegionStateNode regionNode, RegionState.State newState, RegionState.State... expectedStates)
long	unassign(RegionInfo regionInfo)
private void	updateDeadServerRegionMetrics(int deadRegions, int unknownRegions)
private void	updateRegionMergeTransition(ServerStateNode serverNode, org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.RegionStateTransition.TransitionCode state, RegionInfo merged, RegionInfo hriA, RegionInfo hriB)
private void	updateRegionsInTransitionMetrics(AssignmentManager.RegionInTransitionStat ritStat)
private void	updateRegionSplitTransition(ServerStateNode serverNode, org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.RegionStateTransition.TransitionCode state, RegionInfo parent, RegionInfo hriA, RegionInfo hriB)
private void	updateRegionTransition(ServerStateNode serverNode, org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.RegionStateTransition.TransitionCode state, RegionInfo regionInfo, long seqId, long procId)
boolean	waitMetaAssigned(Procedure<?> proc, RegionInfo regionInfo)	Notice that this event does not mean the AM has already finished region state rebuilding.
boolean	waitMetaLoaded(Procedure<?> proc)	Wait until AM finishes the meta loading, i.e, the region states rebuilding.
private HashMap<RegionInfo,RegionStateNode>	waitOnAssignQueue()
void	wakeMetaLoadedEvent()	This method will be called in master initialization method after calling processOfflineRegions(), as in processOfflineRegions we will generate assign procedures for offline regions, which may be conflict with creating table.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Details

LOG

private static final org.slf4j.Logger LOG

BOOTSTRAP_THREAD_POOL_SIZE_CONF_KEY

public static final String BOOTSTRAP_THREAD_POOL_SIZE_CONF_KEY

See Also:

• Constant Field Values

ASSIGN_DISPATCH_WAIT_MSEC_CONF_KEY

public static final String ASSIGN_DISPATCH_WAIT_MSEC_CONF_KEY

See Also:

• Constant Field Values

DEFAULT_ASSIGN_DISPATCH_WAIT_MSEC

private static final int DEFAULT_ASSIGN_DISPATCH_WAIT_MSEC

See Also:

• Constant Field Values

ASSIGN_DISPATCH_WAITQ_MAX_CONF_KEY

public static final String ASSIGN_DISPATCH_WAITQ_MAX_CONF_KEY

See Also:

• Constant Field Values

DEFAULT_ASSIGN_DISPATCH_WAITQ_MAX

private static final int DEFAULT_ASSIGN_DISPATCH_WAITQ_MAX

See Also:

• Constant Field Values

RIT_CHORE_INTERVAL_MSEC_CONF_KEY

public static final String RIT_CHORE_INTERVAL_MSEC_CONF_KEY

See Also:

• Constant Field Values

DEFAULT_RIT_CHORE_INTERVAL_MSEC

private static final int DEFAULT_RIT_CHORE_INTERVAL_MSEC

See Also:

• Constant Field Values

DEAD_REGION_METRIC_CHORE_INTERVAL_MSEC_CONF_KEY

public static final String DEAD_REGION_METRIC_CHORE_INTERVAL_MSEC_CONF_KEY

See Also:

• Constant Field Values

DEFAULT_DEAD_REGION_METRIC_CHORE_INTERVAL_MSEC

private static final int DEFAULT_DEAD_REGION_METRIC_CHORE_INTERVAL_MSEC

See Also:

• Constant Field Values

ASSIGN_MAX_ATTEMPTS

public static final String ASSIGN_MAX_ATTEMPTS

See Also:

• Constant Field Values

DEFAULT_ASSIGN_MAX_ATTEMPTS

private static final int DEFAULT_ASSIGN_MAX_ATTEMPTS

See Also:

• Constant Field Values

ASSIGN_RETRY_IMMEDIATELY_MAX_ATTEMPTS

public static final String ASSIGN_RETRY_IMMEDIATELY_MAX_ATTEMPTS

See Also:

• Constant Field Values

DEFAULT_ASSIGN_RETRY_IMMEDIATELY_MAX_ATTEMPTS

private static final int DEFAULT_ASSIGN_RETRY_IMMEDIATELY_MAX_ATTEMPTS

See Also:

• Constant Field Values

METRICS_RIT_STUCK_WARNING_THRESHOLD

public static final String METRICS_RIT_STUCK_WARNING_THRESHOLD

Region in Transition metrics threshold time

See Also:

• Constant Field Values

DEFAULT_RIT_STUCK_WARNING_THRESHOLD

private static final int DEFAULT_RIT_STUCK_WARNING_THRESHOLD

See Also:

• Constant Field Values

UNEXPECTED_STATE_REGION

public static final String UNEXPECTED_STATE_REGION

See Also:

• Constant Field Values

FORCE_REGION_RETAINMENT

public static final String FORCE_REGION_RETAINMENT

See Also:

• Constant Field Values

DEFAULT_FORCE_REGION_RETAINMENT

public static final boolean DEFAULT_FORCE_REGION_RETAINMENT

See Also:

• Constant Field Values

FORCE_REGION_RETAINMENT_WAIT_INTERVAL

public static final String FORCE_REGION_RETAINMENT_WAIT_INTERVAL

The wait time in millis before checking again if the region's previous RS is back online

See Also:

• Constant Field Values

DEFAULT_FORCE_REGION_RETAINMENT_WAIT_INTERVAL

public static final long DEFAULT_FORCE_REGION_RETAINMENT_WAIT_INTERVAL

See Also:

• Constant Field Values

FORCE_REGION_RETAINMENT_RETRIES

public static final String FORCE_REGION_RETAINMENT_RETRIES

The number of times to check if the region's previous RS is back online, before giving up and proceeding with assignment on a new RS

See Also:

• Constant Field Values

DEFAULT_FORCE_REGION_RETAINMENT_RETRIES

public static final int DEFAULT_FORCE_REGION_RETAINMENT_RETRIES

See Also:

• Constant Field Values

metaAssignEvent

private final ProcedureEvent<?> metaAssignEvent

metaLoadEvent

private final ProcedureEvent<?> metaLoadEvent

metrics

private final MetricsAssignmentManager metrics

ritChore

private final AssignmentManager.RegionInTransitionChore ritChore

deadMetricChore

private final AssignmentManager.DeadServerMetricRegionChore deadMetricChore

master

private final MasterServices master

running

private final AtomicBoolean running

regionStates

private final RegionStates regionStates

regionStateStore

private final RegionStateStore regionStateStore

minVersionToMoveSysTables

private final String minVersionToMoveSysTables

When the operator uses this configuration option, any version between the current cluster version and the value of "hbase.min.version.move.system.tables" does not trigger any auto-region movement. Auto-region movement here refers to auto-migration of system table regions to newer server versions. It is assumed that the configured range of versions does not require special handling of moving system table regions to higher versioned RegionServer. This auto-migration is done by checkIfShouldMoveSystemRegionAsync(). Example: Let's assume the cluster is on version 1.4.0 and we have set "hbase.min.version.move.system.tables" as "2.0.0". Now if we upgrade one RegionServer on 1.4.0 cluster to 1.6.0 (< 2.0.0), then AssignmentManager will not move hbase:meta, hbase:namespace and other system table regions to newly brought up RegionServer 1.6.0 as part of auto-migration. However, if we upgrade one RegionServer on 1.4.0 cluster to 2.2.0 (> 2.0.0), then AssignmentManager will move all system table regions to newly brought up RegionServer 2.2.0 as part of auto-migration done by checkIfShouldMoveSystemRegionAsync(). "hbase.min.version.move.system.tables" is introduced as part of HBASE-22923.

MIN_VERSION_MOVE_SYS_TABLES_CONFIG

private static final String MIN_VERSION_MOVE_SYS_TABLES_CONFIG

See Also:

• Constant Field Values

DEFAULT_MIN_VERSION_MOVE_SYS_TABLES_CONFIG

private static final String DEFAULT_MIN_VERSION_MOVE_SYS_TABLES_CONFIG

See Also:

• Constant Field Values

rsReports

private final Map<ServerName,Set<byte[]>> rsReports

shouldAssignRegionsWithFavoredNodes

private final boolean shouldAssignRegionsWithFavoredNodes

assignDispatchWaitQueueMaxSize

private final int assignDispatchWaitQueueMaxSize

assignDispatchWaitMillis

private final int assignDispatchWaitMillis

assignMaxAttempts

private final int assignMaxAttempts

assignRetryImmediatelyMaxAttempts

private final int assignRetryImmediatelyMaxAttempts

masterRegion

private final MasterRegion masterRegion

checkIfShouldMoveSystemRegionLock

private final Object checkIfShouldMoveSystemRegionLock

assignThread

private Thread assignThread

forceRegionRetainment

private final boolean forceRegionRetainment

forceRegionRetainmentWaitInterval

private final long forceRegionRetainmentWaitInterval

forceRegionRetainmentRetries

private final int forceRegionRetainmentRetries

META_REGION_SET

private static final Set<RegionInfo> META_REGION_SET

STATES_EXPECTED_ON_OPEN

private static final RegionState.State[] STATES_EXPECTED_ON_OPEN

STATES_EXPECTED_ON_CLOSING

private static final RegionState.State[] STATES_EXPECTED_ON_CLOSING

STATES_EXPECTED_ON_CLOSED

private static final RegionState.State[] STATES_EXPECTED_ON_CLOSED

STATES_EXPECTED_ON_ASSIGN

private static final RegionState.State[] STATES_EXPECTED_ON_ASSIGN

STATES_EXPECTED_ON_UNASSIGN_OR_MOVE

private static final RegionState.State[] STATES_EXPECTED_ON_UNASSIGN_OR_MOVE

pendingAssignQueue

private final ArrayList<RegionStateNode> pendingAssignQueue

assignQueueLock

private final ReentrantLock assignQueueLock

assignQueueFullCond

private final Condition assignQueueFullCond

Constructor Details

AssignmentManager

public AssignmentManager(MasterServices master,
 MasterRegion masterRegion)

AssignmentManager

AssignmentManager(MasterServices master,
 MasterRegion masterRegion,
 RegionStateStore stateStore)

Method Details

mirrorMetaLocations

private void mirrorMetaLocations()
                          throws IOException,
org.apache.zookeeper.KeeperException

Throws:

IOException

org.apache.zookeeper.KeeperException

start

public void start()
           throws IOException,
org.apache.zookeeper.KeeperException

Throws:

IOException

org.apache.zookeeper.KeeperException

setupRIT

public void setupRIT(List<TransitRegionStateProcedure> procs)

Create RegionStateNode based on the TRSP list, and attach the TRSP to the RegionStateNode.

This is used to restore the RIT region list, so we do not need to restore it in the loadingMeta method below. And it is also very important as now before submitting a TRSP, we need to attach it to the RegionStateNode, which acts like a guard, so we need to restore this information at the very beginning, before we start processing any procedures.

stop

public void stop()

isRunning

public boolean isRunning()

getConfiguration

public org.apache.hadoop.conf.Configuration getConfiguration()

getAssignmentManagerMetrics

public MetricsAssignmentManager getAssignmentManagerMetrics()

getBalancer

private LoadBalancer getBalancer()

getFavoredNodePromoter

private FavoredNodesPromoter getFavoredNodePromoter()

getProcedureEnvironment

private MasterProcedureEnv getProcedureEnvironment()

getProcedureScheduler

private MasterProcedureScheduler getProcedureScheduler()

getAssignMaxAttempts

int getAssignMaxAttempts()

isForceRegionRetainment

public boolean isForceRegionRetainment()

getForceRegionRetainmentWaitInterval

public long getForceRegionRetainmentWaitInterval()

getForceRegionRetainmentRetries

public int getForceRegionRetainmentRetries()

getAssignRetryImmediatelyMaxAttempts

int getAssignRetryImmediatelyMaxAttempts()

getRegionStates

public RegionStates getRegionStates()

getRegionsOnServer

public List<RegionInfo> getRegionsOnServer(ServerName serverName)

Returns the regions hosted by the specified server.

Notice that, for SCP, after we submit the SCP, no one can change the region list for the ServerStateNode so we do not need any locks here. And for other usage, this can only give you a snapshot of the current region list for this server, which means, right after you get the region list, new regions may be moved to this server or some regions may be moved out from this server, so you should not use it critically if you need strong consistency.

getRegionInfo

private RegionInfo getRegionInfo(RegionStateNode rsn)

getRegionStateNodes

private Stream<RegionStateNode> getRegionStateNodes(TableName tableName,
 boolean excludeOfflinedSplitParents)

getTableRegions

public List<RegionInfo> getTableRegions(TableName tableName,
 boolean excludeOfflinedSplitParents)

getTableRegionsAndLocations

public List<Pair<RegionInfo,ServerName>> getTableRegionsAndLocations(TableName tableName,
 boolean excludeOfflinedSplitParents)

getRegionStateStore

public RegionStateStore getRegionStateStore()

getFavoredNodes

public List<ServerName> getFavoredNodes(RegionInfo regionInfo)

getTableStateManager

private TableStateManager getTableStateManager()

isTableEnabled

private boolean isTableEnabled(TableName tableName)

isTableDisabled

private boolean isTableDisabled(TableName tableName)

isMetaRegion

private boolean isMetaRegion(RegionInfo regionInfo)

isMetaRegion

public boolean isMetaRegion(byte[] regionName)

getMetaRegionFromName

public RegionInfo getMetaRegionFromName(byte[] regionName)

isCarryingMeta

public boolean isCarryingMeta(ServerName serverName)

isCarryingRegion

private boolean isCarryingRegion(ServerName serverName,
 RegionInfo regionInfo)

getMetaForRegion

private RegionInfo getMetaForRegion(RegionInfo regionInfo)

getMetaRegionSet

public Set<RegionInfo> getMetaRegionSet()

isMetaAssigned

public boolean isMetaAssigned()

Notice that, this only means the meta region is available on a RS, but the AM may still be loading the region states from meta, so usually you need to check isMetaLoaded() first before checking this method, unless you can make sure that your piece of code can only be executed after AM builds the region states.

See Also:

• isMetaLoaded()

isMetaRegionInTransition

public boolean isMetaRegionInTransition()

waitMetaAssigned

public boolean waitMetaAssigned(Procedure<?> proc,
 RegionInfo regionInfo)

Notice that this event does not mean the AM has already finished region state rebuilding. See the comment of isMetaAssigned() for more details.

See Also:

• isMetaAssigned()

setMetaAssigned

private void setMetaAssigned(RegionInfo metaRegionInfo,
 boolean assigned)

getMetaAssignEvent

private ProcedureEvent<?> getMetaAssignEvent(RegionInfo metaRegionInfo)

waitMetaLoaded

public boolean waitMetaLoaded(Procedure<?> proc)

Wait until AM finishes the meta loading, i.e, the region states rebuilding.

See Also:

• isMetaLoaded()
• waitMetaAssigned(Procedure, RegionInfo)

wakeMetaLoadedEvent

public void wakeMetaLoadedEvent()

This method will be called in master initialization method after calling processOfflineRegions(), as in processOfflineRegions we will generate assign procedures for offline regions, which may be conflict with creating table.

This is a bit dirty, should be reconsidered after we decide whether to keep the processOfflineRegions() method.

isMetaLoaded

public boolean isMetaLoaded()

Return whether AM finishes the meta loading, i.e, the region states rebuilding.

See Also:

• isMetaAssigned()
• waitMetaLoaded(Procedure)

checkIfShouldMoveSystemRegionAsync

public void checkIfShouldMoveSystemRegionAsync()

Start a new thread to check if there are region servers whose versions are higher than others. If so, move all system table regions to RS with the highest version to keep compatibility. The reason is, RS in new version may not be able to access RS in old version when there are some incompatible changes.

This method is called when a new RegionServer is added to cluster only.

getSystemTables

private List<RegionInfo> getSystemTables(ServerName serverName)

preTransitCheck

private void preTransitCheck(RegionStateNode regionNode,
 RegionState.State[] expectedStates)
                      throws HBaseIOException

Throws:

HBaseIOException

createAssignProcedure

private TransitRegionStateProcedure createAssignProcedure(RegionInfo regionInfo,
 ServerName sn,
 boolean override,
 boolean force)
                                                   throws IOException

Create an assign TransitRegionStateProcedure. Makes sure of RegionState. Throws exception if not appropriate UNLESS override is set. Used by hbck2 but also by straightline assign(RegionInfo, ServerName) and assignAsync(RegionInfo, ServerName).

Parameters:

override - If false, check RegionState is appropriate for assign; if not throw exception.

Throws:

IOException

See Also:

• for a version that does NO checking used when only when no checking needed.

createAssignProcedure

private TransitRegionStateProcedure createAssignProcedure(RegionStateNode regionNode,
 ServerName targetServer)

Create an assign TransitRegionStateProcedure. Does NO checking of RegionState. Presumes appriopriate state ripe for assign.

See Also:

• createAssignProcedure(RegionInfo, ServerName, boolean, boolean)

assign

public long assign(RegionInfo regionInfo,
 ServerName sn)
            throws IOException

Throws:

IOException

assign

public long assign(RegionInfo regionInfo)
            throws IOException

Throws:

IOException

assignAsync

public Future<byte[]> assignAsync(RegionInfo regionInfo,
 ServerName sn)
                           throws IOException

Submits a procedure that assigns a region to a target server without waiting for it to finish

Parameters:

regionInfo - the region we would like to assign

sn - target server name

Throws:

IOException

assignAsync

public Future<byte[]> assignAsync(RegionInfo regionInfo)
                           throws IOException

Submits a procedure that assigns a region without waiting for it to finish

Parameters:

regionInfo - the region we would like to assign

Throws:

IOException

unassign

public long unassign(RegionInfo regionInfo)
              throws IOException

Throws:

IOException

createMoveRegionProcedure

public TransitRegionStateProcedure createMoveRegionProcedure(RegionInfo regionInfo,
 ServerName targetServer)
                                                      throws HBaseIOException

Throws:

HBaseIOException

move

public void move(RegionInfo regionInfo)
          throws IOException

Throws:

IOException

moveAsync

public Future<byte[]> moveAsync(RegionPlan regionPlan)
                         throws HBaseIOException

Throws:

HBaseIOException

balance

public Future<byte[]> balance(RegionPlan regionPlan)
                       throws HBaseIOException

Throws:

HBaseIOException

createRoundRobinAssignProcedures

public TransitRegionStateProcedure[] createRoundRobinAssignProcedures(List<RegionInfo> hris,
 List<ServerName> serversToExclude)

Create round-robin assigns. Use on table creation to distribute out regions across cluster.

Returns:

AssignProcedures made out of the passed in hris and a call to the balancer to populate the assigns with targets chosen using round-robin (default balancer scheme). If at assign-time, the target chosen is no longer up, thats fine, the AssignProcedure will ask the balancer for a new target, and so on.

createRoundRobinAssignProcedures

public TransitRegionStateProcedure[] createRoundRobinAssignProcedures(List<RegionInfo> hris)

Create round-robin assigns. Use on table creation to distribute out regions across cluster.

Returns:

AssignProcedures made out of the passed in hris and a call to the balancer to populate the assigns with targets chosen using round-robin (default balancer scheme). If at assign-time, the target chosen is no longer up, thats fine, the AssignProcedure will ask the balancer for a new target, and so on.

compare

static int compare(TransitRegionStateProcedure left,
 TransitRegionStateProcedure right)

createOneAssignProcedure

public TransitRegionStateProcedure createOneAssignProcedure(RegionInfo ri,
 boolean override,
 boolean force)

Create one TransitRegionStateProcedure to assign a region w/o specifying a target server. This method is called from HBCK2.

Returns:

an assign or null

createOneUnassignProcedure

public TransitRegionStateProcedure createOneUnassignProcedure(RegionInfo ri,
 boolean override,
 boolean force)

Create one TransitRegionStateProcedure to unassign a region. This method is called from HBCK2.

Returns:

an unassign or null

createAssignProcedures

public TransitRegionStateProcedure[] createAssignProcedures(List<RegionInfo> hris)

Create an array of TransitRegionStateProcedure w/o specifying a target server. Used as fallback of caller is unable to do createAssignProcedures(Map).

If no target server, at assign time, we will try to use the former location of the region if one exists. This is how we 'retain' the old location across a server restart.

Should only be called when you can make sure that no one can touch these regions other than you. For example, when you are creating or enabling table. Presumes all Regions are in appropriate state ripe for assign; no checking of Region state is done in here.

See Also:

• createAssignProcedures(Map)

createAssignProcedures

private TransitRegionStateProcedure[] createAssignProcedures(Map<ServerName,List<RegionInfo>> assignments)

Tied to createAssignProcedures(List) in that it is called if caller is unable to run this method. Presumes all Regions are in appropriate state ripe for assign; no checking of Region state is done in here.

Parameters:

assignments - Map of assignments from which we produce an array of AssignProcedures.

Returns:

Assignments made from the passed in assignments

See Also:

• createAssignProcedures(List)

forceCreateUnssignProcedure

private TransitRegionStateProcedure forceCreateUnssignProcedure(RegionStateNode regionNode)

createUnassignProceduresForDisabling

public TransitRegionStateProcedure[] createUnassignProceduresForDisabling(TableName tableName)

Called by DisableTableProcedure to unassign all the regions for a table.

submitUnassignProcedureForClosingExcessRegionReplicas

public int submitUnassignProcedureForClosingExcessRegionReplicas(TableName tableName,
 int newReplicaCount,
 Consumer<TransitRegionStateProcedure> submit)

Called by ModifyTableProcedure to unassign all the excess region replicas for a table. Will skip submit unassign procedure if the region is in transition, so you may need to call this method multiple times.

Parameters:

tableName - the table for closing excess region replicas

newReplicaCount - the new replica count, should be less than current replica count

submit - for submitting procedure

Returns:

the number of regions in transition that we can not schedule unassign procedures

numberOfUnclosedExcessRegionReplicas

public int numberOfUnclosedExcessRegionReplicas(TableName tableName,
 int newReplicaCount)

createSplitProcedure

public SplitTableRegionProcedure createSplitProcedure(RegionInfo regionToSplit,
 byte[] splitKey)
                                               throws IOException

Throws:

IOException

createTruncateRegionProcedure

public TruncateRegionProcedure createTruncateRegionProcedure(RegionInfo regionToTruncate)
                                                      throws IOException

Throws:

IOException

createMergeProcedure

public MergeTableRegionsProcedure createMergeProcedure(RegionInfo... ris)
                                                throws IOException

Throws:

IOException

deleteTable

public void deleteTable(TableName tableName)
                 throws IOException

Delete the region states. This is called by "DeleteTable"

Throws:

IOException

reportRegionStateTransition

private void reportRegionStateTransition(org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.ReportRegionStateTransitionResponse.Builder builder,
 ServerStateNode serverNode,
 List<org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.RegionStateTransition> transitionList)
                                  throws IOException

Throws:

IOException

reportRegionStateTransition

public org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.ReportRegionStateTransitionResponse reportRegionStateTransition(org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.ReportRegionStateTransitionRequest req)
                                                                                                                                           throws PleaseHoldException

Throws:

PleaseHoldException

updateRegionTransition

private void updateRegionTransition(ServerStateNode serverNode,
 org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.RegionStateTransition.TransitionCode state,
 RegionInfo regionInfo,
 long seqId,
 long procId)
                             throws IOException

Throws:

IOException

reportTransition

private boolean reportTransition(RegionStateNode regionNode,
 ServerStateNode serverNode,
 org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.RegionStateTransition.TransitionCode state,
 long seqId,
 long procId)
                          throws IOException

Throws:

IOException

updateRegionSplitTransition

private void updateRegionSplitTransition(ServerStateNode serverNode,
 org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.RegionStateTransition.TransitionCode state,
 RegionInfo parent,
 RegionInfo hriA,
 RegionInfo hriB)
                                  throws IOException

Throws:

IOException

updateRegionMergeTransition

private void updateRegionMergeTransition(ServerStateNode serverNode,
 org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.RegionStateTransition.TransitionCode state,
 RegionInfo merged,
 RegionInfo hriA,
 RegionInfo hriB)
                                  throws IOException

Throws:

IOException

reportOnlineRegions

public void reportOnlineRegions(ServerName serverName,
 Set<byte[]> regionNames)

The master will call this method when the RS send the regionServerReport(). The report will contains the "online regions". This method will check the the online regions against the in-memory state of the AM, and we will log a warn message if there is a mismatch. This is because that there is no fencing between the reportRegionStateTransition method and regionServerReport method, so there could be race and introduce inconsistency here, but actually there is no problem.

Please see HBASE-21421 and HBASE-21463 for more details.

closeRegionSilently

private void closeRegionSilently(ServerName sn,
 byte[] regionName)

Close regionName on sn silently and immediately without using a Procedure or going via hbase:meta. For case where a RegionServer's hosting of a Region is not aligned w/ the Master's accounting of Region state. This is for cleaning up an error in accounting.

checkOnlineRegionsReport

private void checkOnlineRegionsReport(ServerStateNode serverNode,
 Set<byte[]> regionNames)

Check that what the RegionServer reports aligns with the Master's image. If disagreement, we will tell the RegionServer to expediently close a Region we do not think it should have.

computeRegionInTransitionStat

public AssignmentManager.RegionInTransitionStat computeRegionInTransitionStat()

updateRegionsInTransitionMetrics

private void updateRegionsInTransitionMetrics(AssignmentManager.RegionInTransitionStat ritStat)

updateDeadServerRegionMetrics

private void updateDeadServerRegionMetrics(int deadRegions,
 int unknownRegions)

handleRegionOverStuckWarningThreshold

private void handleRegionOverStuckWarningThreshold(RegionInfo regionInfo)

joinCluster

public void joinCluster()
                 throws IOException

Throws:

IOException

processOfflineRegions

public void processOfflineRegions()

Create assign procedure for offline regions. Just follow the old processofflineServersWithOnlineRegions method. Since now we do not need to deal with dead server any more, we only deal with the regions in OFFLINE state in this method. And this is a bit strange, that for new regions, we will add it in CLOSED state instead of OFFLINE state, and usually there will be a procedure to track them. The processofflineServersWithOnlineRegions is a legacy from long ago, as things are going really different now, maybe we do not need this method any more. Need to revisit later.

populateRegionStatesFromMeta

public void populateRegionStatesFromMeta(@NonNull
 RegionInfo regionInfo)
                                  throws IOException

Attempt to load regionInfo from META, adding any results to the regionStateStore Is NOT aware of replica regions.

Parameters:

regionInfo - the region to be loaded from META.

Throws:

IOException - If some error occurs while querying META or parsing results.

populateRegionStatesFromMeta

public void populateRegionStatesFromMeta(@NonNull
 String regionEncodedName)
                                  throws IOException

Attempt to load regionEncodedName from META, adding any results to the regionStateStore Is NOT aware of replica regions.

Parameters:

regionEncodedName - encoded name for the region to be loaded from META.

Throws:

IOException - If some error occurs while querying META or parsing results.

loadMeta

private void loadMeta()
               throws IOException

Throws:

IOException

checkMetaLoaded

private void checkMetaLoaded(RegionInfo hri)
                      throws PleaseHoldException

Used to check if the meta loading is done.

if not we throw PleaseHoldException since we are rebuilding the RegionStates

Parameters:

hri - region to check if it is already rebuild

Throws:

PleaseHoldException - if meta has not been loaded yet

getNumRegionsOpened

public int getNumRegionsOpened()

submitServerCrash

public long submitServerCrash(ServerName serverName,
 boolean shouldSplitWal,
 boolean force)

Usually run by the Master in reaction to server crash during normal processing. Can also be invoked via external RPC to effect repair; in the latter case, the 'force' flag is set so we push through the SCP though context may indicate already-running-SCP (An old SCP may have exited abnormally, or damaged cluster may still have references in hbase:meta to 'Unknown Servers' -- servers that are not online or in dead servers list, etc.)

Parameters:

force - Set if the request came in externally over RPC (via hbck2). Force means run the SCP even if it seems as though there might be an outstanding SCP running.

Returns:

pid of scheduled SCP or Procedure.NO_PROC_ID if none scheduled.

offlineRegion

public void offlineRegion(RegionInfo regionInfo)

onlineRegion

public void onlineRegion(RegionInfo regionInfo,
 ServerName serverName)

getSnapShotOfAssignment

public Map<ServerName,List<RegionInfo>> getSnapShotOfAssignment(Collection<RegionInfo> regions)

getReopenStatus

public Pair<Integer,Integer> getReopenStatus(TableName tableName)

Used by the client (via master) to identify if all regions have the schema updates

Returns:

Pair indicating the status of the alter command (pending/total)

hasRegionsInTransition

public boolean hasRegionsInTransition()

getRegionsInTransition

public List<RegionStateNode> getRegionsInTransition()

getAssignedRegions

public List<RegionInfo> getAssignedRegions()

getRegionInfo

public RegionInfo getRegionInfo(byte[] regionName)

Resolve a cached RegionInfo from the region name as a byte[].

getRegionInfo

public RegionInfo getRegionInfo(String encodedRegionName)

Resolve a cached RegionInfo from the encoded region name as a String.

transitStateAndUpdate

private CompletableFuture<Void> transitStateAndUpdate(RegionStateNode regionNode,
 RegionState.State newState,
 RegionState.State... expectedStates)

regionOpening

CompletableFuture<Void> regionOpening(RegionStateNode regionNode)

regionFailedOpen

CompletableFuture<Void> regionFailedOpen(RegionStateNode regionNode,
 boolean giveUp)

regionClosing

CompletableFuture<Void> regionClosing(RegionStateNode regionNode)

regionOpenedWithoutPersistingToMeta

void regionOpenedWithoutPersistingToMeta(RegionStateNode regionNode)
                                  throws UnexpectedStateException

Throws:

UnexpectedStateException

regionClosedWithoutPersistingToMeta

void regionClosedWithoutPersistingToMeta(RegionStateNode regionNode)
                                  throws UnexpectedStateException

Throws:

UnexpectedStateException

persistToMeta

CompletableFuture<Void> persistToMeta(RegionStateNode regionNode)

regionClosedAbnormally

public CompletableFuture<Void> regionClosedAbnormally(RegionStateNode regionNode)

markRegionAsSplit

public void markRegionAsSplit(RegionInfo parent,
 ServerName serverName,
 RegionInfo daughterA,
 RegionInfo daughterB)
                       throws IOException

Throws:

IOException

markRegionAsMerged

public void markRegionAsMerged(RegionInfo child,
 ServerName serverName,
 RegionInfo[] mergeParents)
                        throws IOException

When called here, the merge has happened. The merged regions have been unassigned and the above markRegionClosed has been called on each so they have been disassociated from a hosting Server. The merged region will be open after this call. The merged regions are removed from hbase:meta below. Later they are deleted from the filesystem by the catalog janitor running against hbase:meta. It notices when the merged region no longer holds references to the old regions (References are deleted after a compaction rewrites what the Reference points at but not until the archiver chore runs, are the References removed).

Throws:

IOException

shouldAssignFavoredNodes

private boolean shouldAssignFavoredNodes(RegionInfo region)

queueAssign

protected void queueAssign(RegionStateNode regionNode)

Add the assign operation to the assignment queue. The pending assignment operation will be processed, and each region will be assigned by a server using the balancer.

startAssignmentThread

private void startAssignmentThread()

stopAssignmentThread

private void stopAssignmentThread()

assignQueueSignal

private void assignQueueSignal()

waitOnAssignQueue

private HashMap<RegionInfo,RegionStateNode> waitOnAssignQueue()

processAssignQueue

private void processAssignQueue()

containsBogusAssignments

private boolean containsBogusAssignments(Map<RegionInfo,RegionStateNode> regions,
 List<RegionInfo> hirs)

processAssignmentPlans

private void processAssignmentPlans(HashMap<RegionInfo,RegionStateNode> regions,
 HashMap<RegionInfo,ServerName> retainMap,
 List<RegionInfo> hris,
 List<ServerName> servers)

acceptPlan

private void acceptPlan(HashMap<RegionInfo,RegionStateNode> regions,
 Map<ServerName,List<RegionInfo>> plan)
                 throws HBaseIOException

Throws:

HBaseIOException

addToPendingAssignment

private void addToPendingAssignment(HashMap<RegionInfo,RegionStateNode> regions,
 Collection<RegionInfo> pendingRegions)

getExcludedServersForSystemTable

public List<ServerName> getExcludedServersForSystemTable()

For a given cluster with mixed versions of servers, get a list of servers with lower versions, where system table regions should not be assigned to. For system table, we must assign regions to a server with highest version. However, we can disable this exclusion using config: "hbase.min.version.move.system.tables" if checkForMinVersion is true. Detailed explanation available with definition of minVersionToMoveSysTables.

Returns:

List of Excluded servers for System table regions.

getMaster

MasterServices getMaster()

getRSReports

public Map<ServerName,Set<byte[]>> getRSReports()

Returns a snapshot of rsReports

getRegionStatesCount

public RegionStatesCount getRegionStatesCount(TableName tableName)

Provide regions state count for given table. e.g howmany regions of give table are opened/closed/rit etc

Parameters:

tableName - TableName

Returns:

region states count