AssignmentManager (Apache HBase

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

```
@InterfaceAudience.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 and Description

static class AssignmentManager.RegionInTransitionStat

Nested Classes
Modifier and Type	Class and Description
`static class`	`AssignmentManager.RegionInTransitionStat`

Field Summary

Fields
Modifier and Type	Field and Description
`static String`	`ASSIGN_DISPATCH_WAIT_MSEC_CONF_KEY`
`static String`	`ASSIGN_DISPATCH_WAITQ_MAX_CONF_KEY`
`static String`	`ASSIGN_MAX_ATTEMPTS`
`static String`	`ASSIGN_RETRY_IMMEDIATELY_MAX_ATTEMPTS`
`static String`	`BOOTSTRAP_THREAD_POOL_SIZE_CONF_KEY`
`static String`	`DEAD_REGION_METRIC_CHORE_INTERVAL_MSEC_CONF_KEY`
`static String`	`METRICS_RIT_STUCK_WARNING_THRESHOLD` Region in Transition metrics threshold time
`static String`	`RIT_CHORE_INTERVAL_MSEC_CONF_KEY`
`static String`	`UNEXPECTED_STATE_REGION`

Constructor Summary

Constructors
Constructor and Description

AssignmentManager(MasterServices master, MasterRegion masterRegion)

Constructors
Constructor and Description
`AssignmentManager(MasterServices master, MasterRegion masterRegion)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`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
`Future<byte[]>`	`balance(RegionPlan regionPlan)`
`void`	`checkIfShouldMoveSystemRegionAsync()` Start a new thread to check if there are region servers whose versions are higher than others.
`AssignmentManager.RegionInTransitionStat`	`computeRegionInTransitionStat()`
`TransitRegionStateProcedure[]`	`createAssignProcedures(List<RegionInfo> hris)` Create an array of TransitRegionStateProcedure w/o specifying a target server.
`MergeTableRegionsProcedure`	`createMergeProcedure(RegionInfo... ris)`
`TransitRegionStateProcedure`	`createMoveRegionProcedure(RegionInfo regionInfo, ServerName targetServer)`
`TransitRegionStateProcedure`	`createOneAssignProcedure(RegionInfo ri, boolean override)` Create one TransitRegionStateProcedure to assign a region w/o specifying a target server.
`TransitRegionStateProcedure`	`createOneUnassignProcedure(RegionInfo ri, boolean override)` 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)`
`TransitRegionStateProcedure[]`	`createUnassignProceduresForClosingExcessRegionReplicas(TableName tableName, int newReplicaCount)` Called by ModifyTableProcedures to unassign all the excess region replicas for a table.
`TransitRegionStateProcedure[]`	`createUnassignProceduresForDisabling(TableName tableName)` Called by DisableTableProcedure to unassign all the regions for a table.
`void`	`deleteTable(TableName tableName)` Delete the region states.
`List<RegionInfo>`	`getAssignedRegions()`
`MetricsAssignmentManager`	`getAssignmentManagerMetrics()`
`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.
`List<ServerName>`	`getFavoredNodes(RegionInfo regionInfo)`
`RegionInfo`	`getMetaRegionFromName(byte[] regionName)`
`Set<RegionInfo>`	`getMetaRegionSet()`
`int`	`getNumRegionsOpened()`
`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`.
`List<RegionStateNode>`	`getRegionsInTransition()`
`List<RegionInfo>`	`getRegionsOnServer(ServerName serverName)` Returns the regions hosted by the specified server.
`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)`
`List<RegionInfo>`	`getTableRegions(TableName tableName, boolean excludeOfflinedSplitParents)`
`List<Pair<RegionInfo,ServerName>>`	`getTableRegionsAndLocations(TableName tableName, boolean excludeOfflinedSplitParents)`
`boolean`	`hasRegionsInTransition()`
`boolean`	`isCarryingMeta(ServerName serverName)`
`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)`
`boolean`	`isMetaRegionInTransition()`
`boolean`	`isRunning()`
`void`	`joinCluster()`
`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)`
`void`	`move(RegionInfo regionInfo)`
`Future<byte[]>`	`moveAsync(RegionPlan regionPlan)`
`void`	`offlineRegion(RegionInfo regionInfo)`
`void`	`onlineRegion(RegionInfo regionInfo, ServerName serverName)`
`void`	`populateRegionStatesFromMeta(RegionInfo regionInfo)` Attempt to load `regionInfo` from META, adding any results to the `regionStateStore` Is NOT aware of replica regions.
`void`	`populateRegionStatesFromMeta(String regionEncodedName)` Attempt to load `regionEncodedName` from META, adding any results to the `regionStateStore` Is NOT aware of replica regions.
`void`	`processOfflineRegions()` Create assign procedure for offline regions.
`protected void`	`queueAssign(RegionStateNode regionNode)` Add the assign operation to the assignment queue.
`void`	`regionClosedAbnormally(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)`
`void`	`setupRIT(List<TransitRegionStateProcedure> procs)` Create RegionStateNode based on the TRSP list, and attach the TRSP to the RegionStateNode.
`void`	`start()`
`void`	`stop()`
`long`	`submitServerCrash(ServerName serverName, boolean shouldSplitWal, boolean force)` Usually run by the Master in reaction to server crash during normal processing.
`long`	`unassign(RegionInfo regionInfo)`
`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.
`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 Detail
  - 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
  - ASSIGN_DISPATCH_WAITQ_MAX_CONF_KEY
```
public static final String ASSIGN_DISPATCH_WAITQ_MAX_CONF_KEY
```
    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
  - 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
  - ASSIGN_MAX_ATTEMPTS
```
public static final String 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
  - 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
  - UNEXPECTED_STATE_REGION
```
public static final String UNEXPECTED_STATE_REGION
```
    See Also:
    
    Constant Field Values
- Constructor Detail
  - AssignmentManager
```
public AssignmentManager(MasterServices master,
                         MasterRegion masterRegion)
```
- Method Detail
  - 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()
```
  - 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.
  - 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)
```
  - isMetaRegion
```
public boolean isMetaRegion(byte[] regionName)
```
  - getMetaRegionFromName
```
public RegionInfo getMetaRegionFromName(byte[] regionName)
```
  - isCarryingMeta
```
public boolean isCarryingMeta(ServerName serverName)
```
  - 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()
  - 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.
  - 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.
  - createOneAssignProcedure
```
public TransitRegionStateProcedure createOneAssignProcedure(RegionInfo ri,
                                                            boolean override)
```
    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)
```
    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)
  - createUnassignProceduresForDisabling
```
public TransitRegionStateProcedure[] createUnassignProceduresForDisabling(TableName tableName)
```
    Called by DisableTableProcedure to unassign all the regions for a table.
  - createUnassignProceduresForClosingExcessRegionReplicas
```
public TransitRegionStateProcedure[] createUnassignProceduresForClosingExcessRegionReplicas(TableName tableName,
                                                                                            int newReplicaCount)
```
    Called by ModifyTableProcedures to unassign all the excess region replicas for a table.
  - createSplitProcedure
```
public SplitTableRegionProcedure createSplitProcedure(RegionInfo regionToSplit,
                                                      byte[] splitKey)
                                               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
```
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
  - 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.
  - computeRegionInTransitionStat
```
public AssignmentManager.RegionInTransitionStat computeRegionInTransitionStat()
```
  - 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.
  - 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.
  - regionClosedAbnormally
```
public void regionClosedAbnormally(RegionStateNode regionNode)
                            throws IOException
```
    Throws:
    
    IOException
  - 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
  - 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.
  - 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.
  - 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

Class AssignmentManager

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

BOOTSTRAP_THREAD_POOL_SIZE_CONF_KEY

ASSIGN_DISPATCH_WAIT_MSEC_CONF_KEY

ASSIGN_DISPATCH_WAITQ_MAX_CONF_KEY

RIT_CHORE_INTERVAL_MSEC_CONF_KEY

DEAD_REGION_METRIC_CHORE_INTERVAL_MSEC_CONF_KEY

ASSIGN_MAX_ATTEMPTS

ASSIGN_RETRY_IMMEDIATELY_MAX_ATTEMPTS

METRICS_RIT_STUCK_WARNING_THRESHOLD

UNEXPECTED_STATE_REGION

Constructor Detail

AssignmentManager

Method Detail

start

setupRIT

stop

isRunning

getConfiguration

getAssignmentManagerMetrics

getRegionStates

getRegionsOnServer

getTableRegions

getTableRegionsAndLocations

getRegionStateStore

getFavoredNodes

isMetaRegion

getMetaRegionFromName

isCarryingMeta

getMetaRegionSet

isMetaAssigned

isMetaRegionInTransition

waitMetaAssigned

waitMetaLoaded

wakeMetaLoadedEvent

isMetaLoaded

checkIfShouldMoveSystemRegionAsync

assign

assign

assignAsync

assignAsync

unassign

createMoveRegionProcedure

move

moveAsync

balance

createRoundRobinAssignProcedures

createRoundRobinAssignProcedures

createOneAssignProcedure

createOneUnassignProcedure

createAssignProcedures

createUnassignProceduresForDisabling

createUnassignProceduresForClosingExcessRegionReplicas

createSplitProcedure

createMergeProcedure

deleteTable

reportRegionStateTransition

reportOnlineRegions

computeRegionInTransitionStat

joinCluster

processOfflineRegions

populateRegionStatesFromMeta

populateRegionStatesFromMeta

getNumRegionsOpened

submitServerCrash

offlineRegion

onlineRegion

getSnapShotOfAssignment

getReopenStatus

hasRegionsInTransition

getRegionsInTransition

getAssignedRegions

getRegionInfo

getRegionInfo

regionClosedAbnormally