ServerManager (Apache HBase - Server 3.0.0-alpha-3 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.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class ServerManager.ServerLiveState

Nested Classes
Modifier and Type	Class and Description
`static class`	`ServerManager.ServerLiveState`

Field Summary

Fields
Modifier and Type	Field and Description
`static String`	`FLUSHEDSEQUENCEID_FLUSHER_INTERVAL`
`static int`	`FLUSHEDSEQUENCEID_FLUSHER_INTERVAL_DEFAULT`
`static String`	`MAX_CLOCK_SKEW_MS`
`static String`	`PERSIST_FLUSHEDSEQUENCEID` see HBASE-20727 if set to true, flushedSequenceIdByRegion and storeFlushedSequenceIdsByRegion will be persisted to HDFS and loaded when master restart to speed up log split
`static boolean`	`PERSIST_FLUSHEDSEQUENCEID_DEFAULT`
`static String`	`WAIT_ON_REGIONSERVERS_INTERVAL`
`static String`	`WAIT_ON_REGIONSERVERS_MAXTOSTART`
`static String`	`WAIT_ON_REGIONSERVERS_MINTOSTART`
`static String`	`WAIT_ON_REGIONSERVERS_TIMEOUT`

Constructor Summary

Constructors
Constructor and Description

ServerManager(MasterServices master, RegionServerList storage)
Constructor.

Constructors
Constructor and Description
`ServerManager(MasterServices master, RegionServerList storage)` Constructor.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`addServerToDrainList(ServerName sn)` Add the server to the drain list.
`boolean`	`areDeadServersInProgress()` Checks if any dead servers are currently in progress.
`static void`	`closeRegionSilentlyAndWait(AsyncClusterConnection connection, ServerName server, RegionInfo region, long timeout)` Contacts a region server and waits up to timeout ms to close the region.
`int`	`countOfRegionServers()`
`List<ServerName>`	`createDestinationServersList()` Calls `createDestinationServersList(java.util.List<org.apache.hadoop.hbase.ServerName>)` without server to exclude.
`List<ServerName>`	`createDestinationServersList(List<ServerName> serversToExclude)` Creates a list of possible destinations for a region.
`long`	`expireServer(ServerName serverName)` Expire the passed server.
`double`	`getAverageLoad()` Compute the average load across all region servers.
`DeadServer`	`getDeadServers()`
`List<ServerName>`	`getDrainingServersList()`
`ConcurrentNavigableMap<byte[],Long>`	`getFlushedSequenceIdByRegion()`
`int`	`getInfoPort(ServerName serverName)`
`org.apache.hadoop.hbase.shaded.protobuf.generated.ClusterStatusProtos.RegionStoreSequenceIds`	`getLastFlushedSequenceId(byte[] encodedRegionName)`
`ServerMetrics`	`getLoad(ServerName serverName)` n * @return ServerMetrics if serverName is known else null
`Map<ServerName,ServerMetrics>`	`getOnlineServers()`
`List<ServerName>`	`getOnlineServersList()`
`List<ServerName>`	`getOnlineServersListWithPredicator(List<ServerName> keys, Predicate<ServerMetrics> idleServerPredicator)`
`String`	`getVersion(ServerName serverName)` May return "0.0.0" when server is not online
`int`	`getVersionNumber(ServerName serverName)` May return 0 when server is not online.
`boolean`	`isClusterShutdown()`
`boolean`	`isRegionInServerManagerStates(RegionInfo hri)`
`boolean`	`isServerDead(ServerName serverName)` Check if a server is known to be dead.
`ServerManager.ServerLiveState`	`isServerKnownAndOnline(ServerName serverName)`
`boolean`	`isServerOnline(ServerName serverName)`
`boolean`	`isServerUnknown(ServerName serverName)` Check if a server is unknown.
`void`	`loadLastFlushedSequenceIds()` Load last flushed sequence id of each region from HDFS, if persisted
`void`	`moveFromOnlineToDeadServers(ServerName sn)` Called when server has expired.
`void`	`regionServerReport(ServerName sn, ServerMetrics sl)`
`void`	`registerListener(ServerListener listener)` Add the listener to the notification list.
`void`	`removeDeletedRegionFromLoadedFlushedSequenceIds()` Regions may have been removed between latest persist of FlushedSequenceIds and master abort.
`void`	`removeRegion(RegionInfo regionInfo)` Called by delete table and similar to notify the ServerManager that a region was removed.
`void`	`removeRegions(List<RegionInfo> regions)` Called by delete table and similar to notify the ServerManager that a region was removed.
`boolean`	`removeServerFromDrainList(ServerName sn)`
`void`	`shutdownCluster()`
`void`	`startChore()` start chore in ServerManager
`void`	`stop()` Stop the ServerManager.
`boolean`	`unregisterListener(ServerListener listener)` Remove the listener from the notification list.
`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
  - PERSIST_FLUSHEDSEQUENCEID
```
public static final String PERSIST_FLUSHEDSEQUENCEID
```
    see HBASE-20727 if set to true, flushedSequenceIdByRegion and storeFlushedSequenceIdsByRegion will be persisted to HDFS and loaded when master restart to speed up log split
    
    See Also:
    
    Constant Field Values
  - PERSIST_FLUSHEDSEQUENCEID_DEFAULT
```
public static final boolean PERSIST_FLUSHEDSEQUENCEID_DEFAULT
```
    See Also:
    
    Constant Field Values
  - FLUSHEDSEQUENCEID_FLUSHER_INTERVAL
```
public static final String FLUSHEDSEQUENCEID_FLUSHER_INTERVAL
```
    See Also:
    
    Constant Field Values
  - FLUSHEDSEQUENCEID_FLUSHER_INTERVAL_DEFAULT
```
public static final int FLUSHEDSEQUENCEID_FLUSHER_INTERVAL_DEFAULT
```
    See Also:
    
    Constant Field Values
  - MAX_CLOCK_SKEW_MS
```
public static final String MAX_CLOCK_SKEW_MS
```
    See Also:
    
    Constant Field Values
- Constructor Detail
  - ServerManager
```
public ServerManager(MasterServices master,
                     RegionServerList storage)
```
    Constructor.
- 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
  - regionServerReport
```
public void regionServerReport(ServerName sn,
                               ServerMetrics sl)
                        throws YouAreDeadException
```
    Throws:
    
    YouAreDeadException
  - getFlushedSequenceIdByRegion
```
public ConcurrentNavigableMap<byte[],Long> getFlushedSequenceIdByRegion()
```
  - getLastFlushedSequenceId
```
public org.apache.hadoop.hbase.shaded.protobuf.generated.ClusterStatusProtos.RegionStoreSequenceIds getLastFlushedSequenceId(byte[] encodedRegionName)
```
  - getLoad
```
public ServerMetrics getLoad(ServerName serverName)
```
    n * @return ServerMetrics 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,ServerMetrics> getOnlineServers()
```
    Returns:
    
    Read-only map of servers to serverinfo
  - getDeadServers
```
public DeadServer getDeadServers()
```
  - areDeadServersInProgress
```
public boolean areDeadServersInProgress()
                                 throws IOException
```
    Checks if any dead servers are currently in progress.
    
    Returns:
    
    true if any RS are being processed as dead, false if not
    
    Throws:
    
    IOException
  - expireServer
```
public long expireServer(ServerName serverName)
```
    Expire the passed server. Add it to list of dead servers and queue a shutdown processing.
    
    Returns:
    
    pid if we queued a ServerCrashProcedure else Procedure.NO_PROC_ID if we did not (could happen for many reasons including the fact that its this server that is going down or we already have queued an SCP for this server or SCP processing is currently disabled because we are in startup phase).
  - moveFromOnlineToDeadServers
```
public void moveFromOnlineToDeadServers(ServerName sn)
```
    Called when server has expired.
  - removeServerFromDrainList
```
public boolean removeServerFromDrainList(ServerName sn)
```
  - addServerToDrainList
```
public boolean addServerToDrainList(ServerName sn)
```
    Add the server to the drain list. n * @return True if the server is added or the server is already on the drain list.
  - closeRegionSilentlyAndWait
```
public static void closeRegionSilentlyAndWait(AsyncClusterConnection connection,
                                              ServerName server,
                                              RegionInfo 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. Pass -1 as timeout if you do not want to wait on result.
    
    Throws:
    
    IOException
    
    InterruptedException
  - 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 n
    
    Throws:
    
    InterruptedException
  - getOnlineServersList
```
public List<ServerName> getOnlineServersList()
```
    Returns:
    
    A copy of the internal list of online servers.
  - getOnlineServersListWithPredicator
```
public List<ServerName> getOnlineServersListWithPredicator(List<ServerName> keys,
                                                           Predicate<ServerMetrics> idleServerPredicator)
```
    Parameters:
    
    keys - The target server name
    
    idleServerPredicator - Evaluates the server on the given load
    
    Returns:
    
    A copy of the internal list of online servers matched by the predicator
  - getDrainingServersList
```
public List<ServerName> getDrainingServersList()
```
    Returns:
    
    A copy of the internal list of draining servers.
  - isServerOnline
```
public boolean isServerOnline(ServerName serverName)
```
  - isServerKnownAndOnline
```
public ServerManager.ServerLiveState isServerKnownAndOnline(ServerName serverName)
```
    Returns:
    
    whether the server is online, dead, or unknown.
  - 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).
  - isServerUnknown
```
public boolean isServerUnknown(ServerName serverName)
```
    Check if a server is unknown. 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()
```
  - startChore
```
public void startChore()
```
    start chore in ServerManager
  - stop
```
public void stop()
```
    Stop the ServerManager.
  - createDestinationServersList
```
public List<ServerName> createDestinationServersList(List<ServerName> serversToExclude)
```
    Creates a list of possible destinations for a region. It contains the online servers, but not the draining or dying servers.
    
    Parameters:
    
    serversToExclude - can be null if there is no server to exclude
  - createDestinationServersList
```
public List<ServerName> createDestinationServersList()
```
    Calls createDestinationServersList(java.util.List<org.apache.hadoop.hbase.ServerName>) without server to exclude.
  - removeRegion
```
public void removeRegion(RegionInfo regionInfo)
```
    Called by delete table and similar to notify the ServerManager that a region was removed.
  - isRegionInServerManagerStates
```
public boolean isRegionInServerManagerStates(RegionInfo hri)
```
  - removeRegions
```
public void removeRegions(List<RegionInfo> regions)
```
    Called by delete table and similar to notify the ServerManager that a region was removed.
  - getVersionNumber
```
public int getVersionNumber(ServerName serverName)
```
    May return 0 when server is not online.
  - getVersion
```
public String getVersion(ServerName serverName)
```
    May return "0.0.0" when server is not online
  - getInfoPort
```
public int getInfoPort(ServerName serverName)
```
  - loadLastFlushedSequenceIds
```
public void loadLastFlushedSequenceIds()
                                throws IOException
```
    Load last flushed sequence id of each region from HDFS, if persisted
    
    Throws:
    
    IOException
  - removeDeletedRegionFromLoadedFlushedSequenceIds
```
public void removeDeletedRegionFromLoadedFlushedSequenceIds()
```
    Regions may have been removed between latest persist of FlushedSequenceIds and master abort. So after loading FlushedSequenceIds from file, and after meta loaded, we need to remove the deleted region according to RegionStates.

Class ServerManager

Nested Class Summary

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

PERSIST_FLUSHEDSEQUENCEID

PERSIST_FLUSHEDSEQUENCEID_DEFAULT

FLUSHEDSEQUENCEID_FLUSHER_INTERVAL

FLUSHEDSEQUENCEID_FLUSHER_INTERVAL_DEFAULT

MAX_CLOCK_SKEW_MS

Constructor Detail

ServerManager

Method Detail

registerListener

unregisterListener

regionServerReport

getFlushedSequenceIdByRegion

getLastFlushedSequenceId

getLoad

getAverageLoad

countOfRegionServers

getOnlineServers

getDeadServers

areDeadServersInProgress

expireServer

moveFromOnlineToDeadServers

removeServerFromDrainList

addServerToDrainList

closeRegionSilentlyAndWait

waitForRegionServers

getOnlineServersList

getOnlineServersListWithPredicator

getDrainingServersList

isServerOnline

isServerKnownAndOnline

isServerDead

isServerUnknown

shutdownCluster

isClusterShutdown

startChore

stop

createDestinationServersList

createDestinationServersList

removeRegion

isRegionInServerManagerStates

removeRegions

getVersionNumber

getVersion

getInfoPort

loadLastFlushedSequenceIds

removeDeletedRegionFromLoadedFlushedSequenceIds