ServerManager (Apache HBase 1.2.12 API)

java.lang.Object
- org.apache.hadoop.hbase.master.ServerManager

```
@InterfaceAudience.Private
public class ServerManager
extends Object
```
The ServerManager class manages info about region servers.
Maintains lists of online and dead servers. Processes the startups, shutdowns, and deaths of region servers.
Servers are distinguished in two different ways. A given server has a location, specified by hostname and port, and of which there can only be one online at any given time. A server instance is specified by the location (hostname and port) as well as the startcode (timestamp from when the server was started). This is used to differentiate a restarted instance of a given server from the original instance.
If a sever is known not to be running any more, it is called dead. The dead server needs to be handled by a ServerShutdownHandler. If the handler is not enabled yet, the server can't be handled right away so it is queued up. After the handler is enabled, the server will be submitted to a handler to handle. However, the handler may be just partially enabled. If so, the server cannot be fully processed, and be queued up for further processing. A server is fully processed only after the handler is fully enabled and has completed the handling.

Field Summary

Fields
Modifier and Type	Field and Description
`private boolean`	`clusterShutdown`
`private ClusterConnection`	`connection`
`private DeadServer`	`deadservers`
`private ArrayList<ServerName>`	`drainingServers` List of region servers that should not get any more new regions.
`private ConcurrentNavigableMap<byte[],Long>`	`flushedSequenceIdByRegion` The last flushed sequence id for a region.
`private List<ServerListener>`	`listeners` Listeners that are called on server events.
`private static org.apache.commons.logging.Log`	`LOG`
`private Server`	`master`
`private long`	`maxSkew`
`private ConcurrentHashMap<ServerName,ServerLoad>`	`onlineServers` Map of registered servers to their current load
`private RetryCounterFactory`	`pingRetryCounterFactory`
`private Set<ServerName>`	`queuedDeadServers` Set of region servers which are dead but not processed immediately.
`private Map<ServerName,Boolean>`	`requeuedDeadServers` Set of region servers which are dead and submitted to ServerShutdownHandler to process but not fully processed immediately.
`private RpcControllerFactory`	`rpcControllerFactory`
`private Map<ServerName,org.apache.hadoop.hbase.protobuf.generated.AdminProtos.AdminService.BlockingInterface>`	`rsAdmins` Map of admin interfaces per registered regionserver; these interfaces we use to control regionservers out on the cluster
`private MasterServices`	`services`
`private ConcurrentNavigableMap<byte[],ConcurrentNavigableMap<byte[],Long>>`	`storeFlushedSequenceIdsByRegion` The last flushed sequence id for a store in a region.
`static String`	`WAIT_ON_REGIONSERVERS_INTERVAL`
`static String`	`WAIT_ON_REGIONSERVERS_MAXTOSTART`
`static String`	`WAIT_ON_REGIONSERVERS_MINTOSTART`
`static String`	`WAIT_ON_REGIONSERVERS_TIMEOUT`
`private long`	`warningSkew`

Constructor Summary

Constructors
Constructor and Description
`ServerManager(Server master, MasterServices services)` Constructor.
`ServerManager(Server master, MasterServices services, boolean connect)`

Method Summary

Methods
Modifier and Type	Method and Description
`boolean`	`addServerToDrainList(ServerName sn)`
`boolean`	`areDeadServersInProgress()` Checks if any dead servers are currently in progress.
`(package private) boolean`	`checkAndRecordNewServer(ServerName serverName, ServerLoad sl)` Check is a server of same host and port already exists, if not, or the existed one got a smaller start code, record it.
`private void`	`checkClockSkew(ServerName serverName, long serverCurrentTime)` Checks if the clock skew between the server and the master.
`private void`	`checkIsDead(ServerName serverName, String what)` If this server is on the dead list, reject it with a YouAreDeadException.
`(package private) void`	`clearDeadServersWithSameHostNameAndPortOfOnlineServer()` To clear any dead server with same host name and port of any online server
`static void`	`closeRegionSilentlyAndWait(ClusterConnection connection, ServerName server, HRegionInfo region, long timeout)` Contacts a region server and waits up to timeout ms to close the region.
`int`	`countOfRegionServers()`
`List<ServerName>`	`createDestinationServersList()` Calls `createDestinationServersList(org.apache.hadoop.hbase.ServerName)` without server to exclude.
`List<ServerName>`	`createDestinationServersList(ServerName serverToExclude)` Creates a list of possible destinations for a region.
`void`	`expireServer(ServerName serverName)`
`private ServerName`	`findServerWithSameHostnamePortWithLock(ServerName serverName)` Assumes onlineServers is locked.
`double`	`getAverageLoad()` Compute the average load across all region servers.
`(package private) Set<ServerName>`	`getDeadNotExpiredServers()`
`DeadServer`	`getDeadServers()`
`List<ServerName>`	`getDrainingServersList()`
`org.apache.hadoop.hbase.protobuf.generated.ClusterStatusProtos.RegionStoreSequenceIds`	`getLastFlushedSequenceId(byte[] encodedRegionName)`
`ServerLoad`	`getLoad(ServerName serverName)`
`Map<ServerName,ServerLoad>`	`getOnlineServers()`
`List<ServerName>`	`getOnlineServersList()`
`private ConcurrentNavigableMap<byte[],Long>`	`getOrCreateStoreFlushedSequenceId(byte[] regionName)`
`(package private) Map<ServerName,Boolean>`	`getRequeuedDeadServers()`
`private org.apache.hadoop.hbase.protobuf.generated.AdminProtos.AdminService.BlockingInterface`	`getRsAdmin(ServerName sn)`
`boolean`	`isClusterShutdown()`
`boolean`	`isRegionInServerManagerStates(HRegionInfo hri)`
`boolean`	`isServerDead(ServerName serverName)` Check if a server is known to be dead.
`boolean`	`isServerOnline(ServerName serverName)`
`boolean`	`isServerReachable(ServerName server)` Check if a region server is reachable and has the expected start code
`boolean`	`isServerWithSameHostnamePortOnline(ServerName serverName)` Check whether a server is online based on hostname and port
`(package private) void`	`letRegionServersShutdown()`
`void`	`moveFromOnelineToDeadServers(ServerName sn)`
`private PayloadCarryingRpcController`	`newRpcController()`
`void`	`processDeadServer(ServerName serverName, boolean shouldSplitWal)`
`(package private) void`	`processQueuedDeadServers()` Process the servers which died during master's initialization.
`(package private) void`	`recordNewServerWithLock(ServerName serverName, ServerLoad sl)` Adds the onlineServers list.
`(package private) void`	`regionServerReport(ServerName sn, ServerLoad sl)`
`(package private) ServerName`	`regionServerStartup(org.apache.hadoop.hbase.protobuf.generated.RegionServerStatusProtos.RegionServerStartupRequest request, InetAddress ia)` Let the server manager know a new regionserver has come online
`void`	`registerListener(ServerListener listener)` Add the listener to the notification list.
`(package private) void`	`removeDeadNotExpiredServers(List<ServerName> servers)` Loop through the deadNotExpired server list and remove them from the servers.
`void`	`removeRegion(HRegionInfo regionInfo)` Called by delete table and similar to notify the ServerManager that a region was removed.
`void`	`removeRegions(List<HRegionInfo> regions)` Called by delete table and similar to notify the ServerManager that a region was removed.
`(package private) void`	`removeRequeuedDeadServers()` During startup, if we figure it is not a failover, i.e.
`boolean`	`removeServerFromDrainList(ServerName sn)`
`boolean`	`sendRegionClose(ServerName server, HRegionInfo region, int versionOfClosingNode)`
`boolean`	`sendRegionClose(ServerName server, HRegionInfo region, int versionOfClosingNode, ServerName dest, boolean transitionInZK)` Sends an CLOSE RPC to the specified server to close the specified region.
`RegionOpeningState`	`sendRegionOpen(ServerName server, HRegionInfo region, int versionOfOfflineNode, List<ServerName> favoredNodes)` Sends an OPEN RPC to the specified server to open the specified region.
`List<RegionOpeningState>`	`sendRegionOpen(ServerName server, List<Triple<HRegionInfo,Integer,List<ServerName>>> regionOpenInfos)` Sends an OPEN RPC to the specified server to open the specified region.
`void`	`sendRegionsMerge(ServerName server, HRegionInfo region_a, HRegionInfo region_b, boolean forcible)` Sends an MERGE REGIONS RPC to the specified server to merge the specified regions.
`void`	`sendRegionWarmup(ServerName server, HRegionInfo region)` Sends a WARMUP RPC to the specified server to warmup the specified region.
`void`	`shutdownCluster()`
`void`	`stop()` Stop the ServerManager.
`boolean`	`unregisterListener(ServerListener listener)` Remove the listener from the notification list.
`private void`	`updateLastFlushedSequenceIds(ServerName sn, ServerLoad hsl)` Updates last flushed sequence Ids for the regions on server sn
`void`	`waitForRegionServers(MonitoredTask status)` Wait for the region servers to report in.

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

- Field Detail
  - WAIT_ON_REGIONSERVERS_MAXTOSTART
```
public static final String WAIT_ON_REGIONSERVERS_MAXTOSTART
```
    See Also:
    Constant Field Values
  - WAIT_ON_REGIONSERVERS_MINTOSTART
```
public static final String WAIT_ON_REGIONSERVERS_MINTOSTART
```
    See Also:
    Constant Field Values
  - WAIT_ON_REGIONSERVERS_TIMEOUT
```
public static final String WAIT_ON_REGIONSERVERS_TIMEOUT
```
    See Also:
    Constant Field Values
  - WAIT_ON_REGIONSERVERS_INTERVAL
```
public static final String WAIT_ON_REGIONSERVERS_INTERVAL
```
    See Also:
    Constant Field Values
  - LOG
```
private static final org.apache.commons.logging.Log LOG
```
  - clusterShutdown
```
private volatile boolean clusterShutdown
```
  - flushedSequenceIdByRegion
```
private final ConcurrentNavigableMap<byte[],Long> flushedSequenceIdByRegion
```
    The last flushed sequence id for a region.
  - storeFlushedSequenceIdsByRegion
```
private final ConcurrentNavigableMap<byte[],ConcurrentNavigableMap<byte[],Long>> storeFlushedSequenceIdsByRegion
```
    The last flushed sequence id for a store in a region.
  - onlineServers
```
private final ConcurrentHashMap<ServerName,ServerLoad> onlineServers
```
    Map of registered servers to their current load
  - rsAdmins
```
private final Map<ServerName,org.apache.hadoop.hbase.protobuf.generated.AdminProtos.AdminService.BlockingInterface> rsAdmins
```
    Map of admin interfaces per registered regionserver; these interfaces we use to control regionservers out on the cluster
  - drainingServers
```
private final ArrayList<ServerName> drainingServers
```
    List of region servers that should not get any more new regions.
  - master
```
private final Server master
```
  - services
```
private final MasterServices services
```
  - connection
```
private final ClusterConnection connection
```
  - deadservers
```
private final DeadServer deadservers
```
  - maxSkew
```
private final long maxSkew
```
  - warningSkew
```
private final long warningSkew
```
  - pingRetryCounterFactory
```
private final RetryCounterFactory pingRetryCounterFactory
```
  - rpcControllerFactory
```
private final RpcControllerFactory rpcControllerFactory
```
  - queuedDeadServers
```
private Set<ServerName> queuedDeadServers
```
    Set of region servers which are dead but not processed immediately. If one server died before master enables ServerShutdownHandler, the server will be added to this set and will be processed through calling processQueuedDeadServers() by master.
    A dead server is a server instance known to be dead, not listed in the /hbase/rs znode any more. It may have not been submitted to ServerShutdownHandler yet because the handler is not enabled.
    A dead server, which has been submitted to ServerShutdownHandler while the handler is not enabled, is queued up.
    So this is a set of region servers known to be dead but not submitted to ServerShutdownHander for processing yet.
  - requeuedDeadServers
```
private Map<ServerName,Boolean> requeuedDeadServers
```
    Set of region servers which are dead and submitted to ServerShutdownHandler to process but not fully processed immediately.
    If one server died before assignment manager finished the failover cleanup, the server will be added to this set and will be processed through calling processQueuedDeadServers() by assignment manager.
    The Boolean value indicates whether log split is needed inside ServerShutdownHandler
    ServerShutdownHandler processes a dead server submitted to the handler after the handler is enabled. It may not be able to complete the processing because meta is not yet online or master is currently in startup mode. In this case, the dead server will be parked in this set temporarily.
  - listeners
```
private List<ServerListener> listeners
```
    Listeners that are called on server events.
- Constructor Detail
  - ServerManager
```
public ServerManager(Server master,
             MasterServices services)
              throws IOException
```
    Constructor.
    
    Parameters:
    master -
    services -
    
    Throws:
    
    ZooKeeperConnectionException
    
    IOException
  - ServerManager
```
ServerManager(Server master,
             MasterServices services,
             boolean connect)
        throws IOException
```
    Throws:
    
    IOException
- Method Detail
  - registerListener
```
public void registerListener(ServerListener listener)
```
    Add the listener to the notification list.
    
    Parameters:
    listener - The ServerListener to register
  - unregisterListener
```
public boolean unregisterListener(ServerListener listener)
```
    Remove the listener from the notification list.
    
    Parameters:
    listener - The ServerListener to unregister
  - regionServerStartup
```
ServerName regionServerStartup(org.apache.hadoop.hbase.protobuf.generated.RegionServerStatusProtos.RegionServerStartupRequest request,
                             InetAddress ia)
                         throws IOException
```
    Let the server manager know a new regionserver has come online
    
    Parameters:
    request - the startup request
    ia - the InetAddress from which request is received
    
    Returns:
    The ServerName we know this server as.
    
    Throws:
    
    IOException
  - getOrCreateStoreFlushedSequenceId
```
private ConcurrentNavigableMap<byte[],Long> getOrCreateStoreFlushedSequenceId(byte[] regionName)
```
  - updateLastFlushedSequenceIds
```
private void updateLastFlushedSequenceIds(ServerName sn,
                                ServerLoad hsl)
```
    Updates last flushed sequence Ids for the regions on server sn
    
    Parameters:
    sn -
    hsl -
  - regionServerReport
```
void regionServerReport(ServerName sn,
                      ServerLoad sl)
                  throws YouAreDeadException
```
    Throws:
    
    YouAreDeadException
  - checkAndRecordNewServer
```
boolean checkAndRecordNewServer(ServerName serverName,
                              ServerLoad sl)
```
    Check is a server of same host and port already exists, if not, or the existed one got a smaller start code, record it.
    
    Parameters:
    sn - the server to check and record
    sl - the server load on the server
    
    Returns:
    true if the server is recorded, otherwise, false
  - checkClockSkew
```
private void checkClockSkew(ServerName serverName,
                  long serverCurrentTime)
                     throws ClockOutOfSyncException
```
    Checks if the clock skew between the server and the master. If the clock skew exceeds the configured max, it will throw an exception; if it exceeds the configured warning threshold, it will log a warning but start normally.
    
    Parameters:
    serverName - Incoming servers's name
    serverCurrentTime -
    
    Throws:
    
    ClockOutOfSyncException - if the skew exceeds the configured max value
  - checkIsDead
```
private void checkIsDead(ServerName serverName,
               String what)
                  throws YouAreDeadException
```
    If this server is on the dead list, reject it with a YouAreDeadException. If it was dead but came back with a new start code, remove the old entry from the dead list.
    
    Parameters:
    serverName -
    what - START or REPORT
    
    Throws:
    
    YouAreDeadException
  - findServerWithSameHostnamePortWithLock
```
private ServerName findServerWithSameHostnamePortWithLock(ServerName serverName)
```
    Assumes onlineServers is locked.
    
    Returns:
    ServerName with matching hostname and port.
  - recordNewServerWithLock
```
void recordNewServerWithLock(ServerName serverName,
                           ServerLoad sl)
```
    Adds the onlineServers list. onlineServers should be locked.
    
    Parameters:
    serverName - The remote servers name.
    sl -
  - getLastFlushedSequenceId
```
public org.apache.hadoop.hbase.protobuf.generated.ClusterStatusProtos.RegionStoreSequenceIds getLastFlushedSequenceId(byte[] encodedRegionName)
```
  - getLoad
```
public ServerLoad getLoad(ServerName serverName)
```
    Parameters:
    serverName -
    
    Returns:
    ServerLoad if serverName is known else null
  - getAverageLoad
```
public double getAverageLoad()
```
    Compute the average load across all region servers. Currently, this uses a very naive computation - just uses the number of regions being served, ignoring stats about number of requests.
    
    Returns:
    the average load
  - countOfRegionServers
```
public int countOfRegionServers()
```
    Returns:
    the count of active regionservers
  - getOnlineServers
```
public Map<ServerName,ServerLoad> getOnlineServers()
```
    Returns:
    Read-only map of servers to serverinfo
  - getDeadServers
```
public DeadServer getDeadServers()
```
  - areDeadServersInProgress
```
public boolean areDeadServersInProgress()
```
    Checks if any dead servers are currently in progress.
    
    Returns:
    true if any RS are being processed as dead, false if not
  - letRegionServersShutdown
```
void letRegionServersShutdown()
```
  - expireServer
```
public void expireServer(ServerName serverName)
```
  - moveFromOnelineToDeadServers
```
public void moveFromOnelineToDeadServers(ServerName sn)
```
  - processDeadServer
```
public void processDeadServer(ServerName serverName,
                     boolean shouldSplitWal)
```
  - processQueuedDeadServers
```
void processQueuedDeadServers()
```
    Process the servers which died during master's initialization. It will be called after HMaster#assignMeta and AssignmentManager#joinCluster.
  - removeServerFromDrainList
```
public boolean removeServerFromDrainList(ServerName sn)
```
  - addServerToDrainList
```
public boolean addServerToDrainList(ServerName sn)
```
  - sendRegionOpen
```
public RegionOpeningState sendRegionOpen(ServerName server,
                                HRegionInfo region,
                                int versionOfOfflineNode,
                                List<ServerName> favoredNodes)
                                  throws IOException
```
    Sends an OPEN RPC to the specified server to open the specified region.
    Open should not fail but can if server just crashed.
    
    Parameters:
    server - server to open a region
    region - region to open
    versionOfOfflineNode - that needs to be present in the offline node when RS tries to change the state from OFFLINE to other states.
    favoredNodes -
    
    Throws:
    
    IOException
  - sendRegionOpen
```
public List<RegionOpeningState> sendRegionOpen(ServerName server,
                                      List<Triple<HRegionInfo,Integer,List<ServerName>>> regionOpenInfos)
                                        throws IOException
```
    Sends an OPEN RPC to the specified server to open the specified region.
    Open should not fail but can if server just crashed.
    
    Parameters:
    server - server to open a region
    regionOpenInfos - info of a list of regions to open
    
    Returns:
    a list of region opening states
    
    Throws:
    
    IOException
  - newRpcController
```
private PayloadCarryingRpcController newRpcController()
```
  - sendRegionClose
```
public boolean sendRegionClose(ServerName server,
                      HRegionInfo region,
                      int versionOfClosingNode,
                      ServerName dest,
                      boolean transitionInZK)
                        throws IOException
```
    Sends an CLOSE RPC to the specified server to close the specified region.
    A region server could reject the close request because it either does not have the specified region or the region is being split.
    
    Parameters:
    server - server to open a region
    region - region to open
    versionOfClosingNode - the version of znode to compare when RS transitions the znode from CLOSING state.
    dest - - if the region is moved to another server, the destination server. null otherwise.
    
    Returns:
    true if server acknowledged close, false if not
    
    Throws:
    
    IOException
  - sendRegionClose
```
public boolean sendRegionClose(ServerName server,
                      HRegionInfo region,
                      int versionOfClosingNode)
                        throws IOException
```
    Throws:
    
    IOException
  - sendRegionWarmup
```
public void sendRegionWarmup(ServerName server,
                    HRegionInfo region)
```
    Sends a WARMUP RPC to the specified server to warmup the specified region.
    A region server could reject the close request because it either does not have the specified region or the region is being split.
    
    Parameters:
    server - server to warmup a region
    region - region to warmup
  - closeRegionSilentlyAndWait
```
public static void closeRegionSilentlyAndWait(ClusterConnection connection,
                              ServerName server,
                              HRegionInfo region,
                              long timeout)
                                       throws IOException,
                                              InterruptedException
```
    Contacts a region server and waits up to timeout ms to close the region. This bypasses the active hmaster.
    
    Throws:
    
    IOException
    
    InterruptedException
  - sendRegionsMerge
```
public void sendRegionsMerge(ServerName server,
                    HRegionInfo region_a,
                    HRegionInfo region_b,
                    boolean forcible)
                      throws IOException
```
    Sends an MERGE REGIONS RPC to the specified server to merge the specified regions.
    A region server could reject the close request because it either does not have the specified region.
    
    Parameters:
    server - server to merge regions
    region_a - region to merge
    region_b - region to merge
    forcible - true if do a compulsory merge, otherwise we will only merge two adjacent regions
    
    Throws:
    
    IOException
  - isServerReachable
```
public boolean isServerReachable(ServerName server)
```
    Check if a region server is reachable and has the expected start code
  - getRsAdmin
```
private org.apache.hadoop.hbase.protobuf.generated.AdminProtos.AdminService.BlockingInterface getRsAdmin(ServerName sn)
                                                                                                  throws IOException
```
    Parameters:
    sn -
    
    Returns:
    Admin interface for the remote regionserver named sn
    
    Throws:
    
    IOException
    
    RetriesExhaustedException - wrapping a ConnectException if failed
  - waitForRegionServers
```
public void waitForRegionServers(MonitoredTask status)
                          throws InterruptedException
```
    Wait for the region servers to report in. We will wait until one of this condition is met: - the master is stopped - the 'hbase.master.wait.on.regionservers.maxtostart' number of region servers is reached - the 'hbase.master.wait.on.regionservers.mintostart' is reached AND there have been no new region server in for 'hbase.master.wait.on.regionservers.interval' time AND the 'hbase.master.wait.on.regionservers.timeout' is reached
    
    Throws:
    
    InterruptedException
  - getOnlineServersList
```
public List<ServerName> getOnlineServersList()
```
    Returns:
    A copy of the internal list of online servers.
  - getDrainingServersList
```
public List<ServerName> getDrainingServersList()
```
    Returns:
    A copy of the internal list of draining servers.
  - getDeadNotExpiredServers
```
Set<ServerName> getDeadNotExpiredServers()
```
    Returns:
    A copy of the internal set of deadNotExpired servers.
  - removeRequeuedDeadServers
```
void removeRequeuedDeadServers()
```
    During startup, if we figure it is not a failover, i.e. there is no more WAL files to split, we won't try to recover these dead servers. So we just remove them from the queue. Use caution in calling this.
  - getRequeuedDeadServers
```
Map<ServerName,Boolean> getRequeuedDeadServers()
```
    Returns:
    A copy of the internal map of requeuedDeadServers servers and their corresponding splitlog need flag.
  - isServerOnline
```
public boolean isServerOnline(ServerName serverName)
```
  - isServerWithSameHostnamePortOnline
```
public boolean isServerWithSameHostnamePortOnline(ServerName serverName)
```
    Check whether a server is online based on hostname and port
    
    Returns:
    true if finding a server with matching hostname and port.
  - isServerDead
```
public boolean isServerDead(ServerName serverName)
```
    Check if a server is known to be dead. A server can be online, or known to be dead, or unknown to this manager (i.e, not online, not known to be dead either. it is simply not tracked by the master any more, for example, a very old previous instance).
  - shutdownCluster
```
public void shutdownCluster()
```
  - isClusterShutdown
```
public boolean isClusterShutdown()
```
  - stop
```
public void stop()
```
    Stop the ServerManager. Currently closes the connection to the master.
  - createDestinationServersList
```
public List<ServerName> createDestinationServersList(ServerName serverToExclude)
```
    Creates a list of possible destinations for a region. It contains the online servers, but not the draining or dying servers.
    
    Parameters:
    serverToExclude - can be null if there is no server to exclude
  - createDestinationServersList
```
public List<ServerName> createDestinationServersList()
```
    Calls createDestinationServersList(org.apache.hadoop.hbase.ServerName) without server to exclude.
  - removeDeadNotExpiredServers
```
void removeDeadNotExpiredServers(List<ServerName> servers)
```
    Loop through the deadNotExpired server list and remove them from the servers. This function should be used carefully outside of this class. You should use a high level method such as createDestinationServersList() instead of managing you own list.
  - clearDeadServersWithSameHostNameAndPortOfOnlineServer
```
void clearDeadServersWithSameHostNameAndPortOfOnlineServer()
```
    To clear any dead server with same host name and port of any online server
  - removeRegion
```
public void removeRegion(HRegionInfo regionInfo)
```
    Called by delete table and similar to notify the ServerManager that a region was removed.
  - isRegionInServerManagerStates
```
public boolean isRegionInServerManagerStates(HRegionInfo hri)
```
  - removeRegions
```
public void removeRegions(List<HRegionInfo> regions)
```
    Called by delete table and similar to notify the ServerManager that a region was removed.

Class ServerManager

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

WAIT_ON_REGIONSERVERS_MAXTOSTART

WAIT_ON_REGIONSERVERS_MINTOSTART

WAIT_ON_REGIONSERVERS_TIMEOUT

WAIT_ON_REGIONSERVERS_INTERVAL

LOG

clusterShutdown

flushedSequenceIdByRegion

storeFlushedSequenceIdsByRegion

onlineServers

rsAdmins

drainingServers

master

services

connection

deadservers

maxSkew

warningSkew

pingRetryCounterFactory

rpcControllerFactory

queuedDeadServers

requeuedDeadServers

listeners

Constructor Detail

ServerManager

ServerManager

Method Detail

registerListener

unregisterListener

regionServerStartup

getOrCreateStoreFlushedSequenceId

updateLastFlushedSequenceIds

regionServerReport

checkAndRecordNewServer

checkClockSkew

checkIsDead

findServerWithSameHostnamePortWithLock

recordNewServerWithLock

getLastFlushedSequenceId

getLoad

getAverageLoad

countOfRegionServers

getOnlineServers

getDeadServers

areDeadServersInProgress

letRegionServersShutdown

expireServer

moveFromOnelineToDeadServers

processDeadServer

processQueuedDeadServers

removeServerFromDrainList

addServerToDrainList

sendRegionOpen

sendRegionOpen

newRpcController

sendRegionClose

sendRegionClose

sendRegionWarmup

closeRegionSilentlyAndWait

sendRegionsMerge

isServerReachable

getRsAdmin

waitForRegionServers

getOnlineServersList

getDrainingServersList

getDeadNotExpiredServers

removeRequeuedDeadServers

getRequeuedDeadServers

isServerOnline

isServerWithSameHostnamePortOnline

isServerDead

shutdownCluster

isClusterShutdown

stop

createDestinationServersList