HRegionServer (Apache HBase 2.0.6 API)

java.lang.Object
- org.apache.hadoop.hbase.util.HasThread
- - org.apache.hadoop.hbase.regionserver.HRegionServer

All Implemented Interfaces:

Runnable, Abortable, ConfigurationObserver, FavoredNodesForRegion, LastSequenceId, MutableOnlineRegions, OnlineRegions, RegionServerServices, Server, Stoppable

Direct Known Subclasses:

HMaster
```
@InterfaceAudience.LimitedPrivate(value="Tools")
public class HRegionServer
extends HasThread
implements RegionServerServices, LastSequenceId, ConfigurationObserver
```
HRegionServer makes a set of HRegions available to clients. It checks in with the HMaster. There are many HRegionServers in a single HBase deployment.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`private static class`	`HRegionServer.CompactionChecker`
`private static class`	`HRegionServer.MovedRegionInfo`
`protected static class`	`HRegionServer.MovedRegionsCleaner` Creates a Chore thread to clean the moved region cache.
`(package private) static class`	`HRegionServer.PeriodicMemStoreFlusher`
`private static class`	`HRegionServer.SystemExitWhenAbortTimeout` Force to terminate region server when abort timeout.

Nested classes/interfaces inherited from interface org.apache.hadoop.hbase.regionserver.RegionServerServices
RegionServerServices.PostOpenDeployContext, RegionServerServices.RegionStateTransitionContext

Field Summary

Fields
Modifier and Type	Field and Description
`static String`	`ABORT_TIMEOUT`
`static String`	`ABORT_TIMEOUT_TASK`
`private boolean`	`abortRequested`
`protected CacheConfig`	`cacheConfig`
`protected MemStoreFlusher`	`cacheFlusher`
`private ChoreService`	`choreService` ChoreService used to schedule tasks that we want to run periodically
`protected ClusterConnection`	`clusterConnection` Cluster connection to be shared by services.
`protected String`	`clusterId` Unique identifier for the cluster we are a part of.
`protected ClusterStatusTracker`	`clusterStatusTracker`
`(package private) CompactedHFilesDischarger`	`compactedFileDischarger`
`(package private) ScheduledChore`	`compactionChecker`
`CompactSplit`	`compactSplitThread`
`protected org.apache.hadoop.conf.Configuration`	`conf`
`protected ConfigurationManager`	`configurationManager` Configuration manager is used to register/deregister and notify the configuration observers when the regionserver is notified that there was a change in the on disk configs.
`private Map<String,com.google.protobuf.Service>`	`coprocessorServiceHandlers`
`protected CoordinatedStateManager`	`csm`
`private static long`	`DEFAULT_ABORT_TIMEOUT`
`private NettyEventLoopGroupConfig`	`eventLoopGroupConfig`
`protected ExecutorService`	`executorService`
`private ThroughputController`	`flushThroughputController`
`protected HFileSystem`	`fs`
`protected boolean`	`fsOk`
`protected FileSystemUtilizationChore`	`fsUtilizationChore`
`private HealthCheckChore`	`healthCheckChore` The health check chore.
`protected HeapMemoryManager`	`hMemManager`
`protected InfoServer`	`infoServer`
`private static int`	`INIT_PAUSE_TIME_MS`
`(package private) boolean`	`killed`
`protected Leases`	`leases`
`protected ReentrantReadWriteLock`	`lock`
`private org.apache.hadoop.hbase.shaded.protobuf.generated.LockServiceProtos.LockService.BlockingInterface`	`lockStub`
`private static org.slf4j.Logger`	`LOG`
`protected static String`	`MASTER_HOSTNAME_KEY`
`private MasterAddressTracker`	`masterAddressTracker`
`private boolean`	`masterless` True if this RegionServer is coming up in a cluster where there is no Master; means it needs to just come up and make do without a Master to talk to: e.g.
`(package private) static String`	`MASTERLESS_CONFIG_NAME`
`protected MetaTableLocator`	`metaTableLocator`
`(package private) MetricsRegionServer`	`metricsRegionServer`
`(package private) MetricsTable`	`metricsTable`
`(package private) MobCacheConfig`	`mobCacheConfig`
`protected Map<String,HRegionServer.MovedRegionInfo>`	`movedRegions`
`private HRegionServer.MovedRegionsCleaner`	`movedRegionsCleaner` Chore to clean periodically the moved region list
`protected int`	`msgInterval`
`(package private) ServerNonceManager`	`nonceManager` Nonce manager.
`private ScheduledChore`	`nonceManagerChore` The nonce manager chore.
`protected int`	`numRegionsToReport`
`(package private) int`	`numRetries`
`(package private) AtomicBoolean`	`online`
`protected Map<String,HRegion>`	`onlineRegions` Map of regions currently being served by this region server.
`private int`	`operationTimeout`
`private JvmPauseMonitor`	`pauseMonitor`
`(package private) ScheduledChore`	`periodicFlusher`
`protected Map<String,InetSocketAddress[]>`	`regionFavoredNodesMap` Map of encoded region names to the DataNode locations they should be hosted on We store the value as InetSocketAddress since this is used only in HDFS API (create() that takes favored nodes as hints for placing file blocks).
`static String`	`REGIONSERVER` region server process name
`private RegionServerAccounting`	`regionServerAccounting`
`protected ConcurrentMap<byte[],Boolean>`	`regionsInTransitionInRS`
`protected ReplicationSinkService`	`replicationSinkHandler`
`protected ReplicationSourceService`	`replicationSourceHandler`
`private org.apache.hadoop.fs.Path`	`rootDir`
`(package private) ConcurrentMap<String,Integer>`	`rowlocks`
`(package private) RpcClient`	`rpcClient`
`private RpcControllerFactory`	`rpcControllerFactory`
`private RpcRetryingCallerFactory`	`rpcRetryingCallerFactory`
`protected RSRpcServices`	`rpcServices`
`(package private) static String`	`RS_HOSTNAME_DISABLE_MASTER_REVERSEDNS_KEY`
`(package private) static String`	`RS_HOSTNAME_KEY`
`private RegionServerCoprocessorHost`	`rsHost`
`private RegionServerProcedureManagerHost`	`rspmHost`
`private RegionServerRpcQuotaManager`	`rsQuotaManager`
`private RegionServerSpaceQuotaManager`	`rsSpaceQuotaManager`
`private org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.RegionServerStatusService.BlockingInterface`	`rssStub`
`protected SecureBulkLoadManager`	`secureBulkLoadManager`
`protected ServerName`	`serverName` The server name the Master sees us as.
`private int`	`shortOperationTimeout`
`protected Sleeper`	`sleeper`
`private SpanReceiverHost`	`spanReceiverHost`
`private SplitLogWorker`	`splitLogWorker`
`protected long`	`startcode` This servers startcode.
`private boolean`	`stopped`
`private boolean`	`stopping`
`private StorefileRefresherChore`	`storefileRefresher`
`protected TableDescriptors`	`tableDescriptors` Go here to get table descriptors.
`static boolean`	`TEST_SKIP_REPORTING_TRANSITION` For testing only! Set to true to skip notifying region assignment to master .
`protected int`	`threadWakeFrequency`
`private static int`	`TIMEOUT_REGION_MOVED`
`private Thread.UncaughtExceptionHandler`	`uncaughtExceptionHandler`
`private UserProvider`	`userProvider`
`protected String`	`useThisHostnameInstead`
`protected WALFactory`	`walFactory`
`protected HFileSystem`	`walFs`
`protected LogRoller`	`walRoller`
`private org.apache.hadoop.fs.Path`	`walRootDir`
`protected ZKWatcher`	`zooKeeper`

Constructor Summary

Constructors
Constructor and Description

HRegionServer(org.apache.hadoop.conf.Configuration conf)
Starts a HRegionServer at the default location

Constructors
Constructor and Description
`HRegionServer(org.apache.hadoop.conf.Configuration conf)` Starts a HRegionServer at the default location

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`abort(String reason)`
`void`	`abort(String reason, Throwable cause)` Cause the server to exit without closing the regions it is serving, the log it is using and without notifying the master.
`void`	`addRegion(HRegion region)` Add to online regions.
`protected void`	`addToMovedRegions(String encodedName, ServerName destination, long closeSeqNum)`
`private boolean`	`areAllUserRegionsOffline()`
`private void`	`blockAndCheckIfStopped(ZKNodeTracker tracker)` Utilty method to wait indefinitely on a znode availability while checking if the region server is shut down
`(package private) org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.RegionSpaceUseReportRequest`	`buildRegionSpaceUseReportRequest(Map<RegionInfo,Long> regionSizes)` Builds a `RegionServerStatusProtos.RegionSpaceUseReportRequest` protobuf message from the region size map.
`(package private) org.apache.hadoop.hbase.shaded.protobuf.generated.ClusterStatusProtos.ServerLoad`	`buildServerLoad(long reportStartTime, long reportEndTime)`
`protected boolean`	`canCreateBaseZNode()`
`protected boolean`	`canUpdateTableDescriptor()`
`private static void`	`checkCodecs(org.apache.hadoop.conf.Configuration c)` Run test on configured codecs to make sure supporting libs are in place.
`boolean`	`checkFileSystem()` Checks to see if the file system is still accessible.
`protected void`	`cleanMovedRegions()` Remove the expired entries from the moved regions list.
`private Throwable`	`cleanup(Throwable t, String msg)`
`CacheEvictionStats`	`clearRegionBlockCache(Region region)`
`protected void`	`closeAllRegions(boolean abort)` Closes all regions.
`protected boolean`	`closeAndOfflineRegionForSplitOrMerge(List<String> regionEncodedName)` Close and offline the region for split or merge
`(package private) void`	`closeMetaTableRegions(boolean abort)` Close meta region if we carry it
`protected boolean`	`closeRegion(String encodedName, boolean abort, ServerName sn)` Close asynchronously a region, can be called from the master or internally by the regionserver when stopping.
`private void`	`closeRegionIgnoreErrors(RegionInfo region, boolean abort)` Try to close the region, logs a warning on failure but continues.
`(package private) void`	`closeUserRegions(boolean abort)` Schedule closes on all user regions.
`protected void`	`configureInfoServer()`
`static HRegionServer`	`constructRegionServer(Class<? extends HRegionServer> regionServerClass, org.apache.hadoop.conf.Configuration conf2)` Utility for constructing an instance of the passed HRegionServer class.
`private boolean`	`containsMetaTableRegions()`
`(package private) org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.RegionSpaceUse`	`convertRegionSize(RegionInfo regionInfo, Long sizeInBytes)` Converts a pair of `RegionInfo` and `long` into a `RegionServerStatusProtos.RegionSpaceUse` protobuf message.
`protected IOException`	`convertThrowableToIOE(Throwable t, String msg)`
`protected ClusterConnection`	`createClusterConnection()` Create a 'smarter' Connection, one that is capable of by-passing RPC if the request is to the local server; i.e.
`Connection`	`createConnection(org.apache.hadoop.conf.Configuration conf)`
`private void`	`createMyEphemeralNode()`
`private static void`	`createNewReplicationInstance(org.apache.hadoop.conf.Configuration conf, HRegionServer server, org.apache.hadoop.fs.FileSystem walFs, org.apache.hadoop.fs.Path walDir, org.apache.hadoop.fs.Path oldWALDir, WALProvider walProvider)` Load the replication executorService objects, if any
`(package private) org.apache.hadoop.hbase.shaded.protobuf.generated.ClusterStatusProtos.RegionLoad`	`createRegionLoad(HRegion r, org.apache.hadoop.hbase.shaded.protobuf.generated.ClusterStatusProtos.RegionLoad.Builder regionLoadBldr, org.apache.hadoop.hbase.shaded.protobuf.generated.HBaseProtos.RegionSpecifier.Builder regionSpecifier)`
`org.apache.hadoop.hbase.shaded.protobuf.generated.ClusterStatusProtos.RegionLoad`	`createRegionLoad(String encodedRegionName)`
`protected ServerName`	`createRegionServerStatusStub()` Get the current master from ZooKeeper and open the RPC connection to it.
`protected ServerName`	`createRegionServerStatusStub(boolean refresh)` Get the current master from ZooKeeper and open the RPC connection to it.
`protected RSRpcServices`	`createRpcServices()`
`private void`	`deleteMyEphemeralNode()`
`org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.CoprocessorServiceResponse`	`execRegionServerService(org.apache.hbase.thirdparty.com.google.protobuf.RpcController controller, org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.CoprocessorServiceRequest serviceRequest)`
`CacheConfig`	`getCacheConfig()`
`ChoreService`	`getChoreService()`
`ClusterConnection`	`getClusterConnection()` Returns a reference to the servers' cluster connection.
`String`	`getClusterId()`
`double`	`getCompactionPressure()`
`CompactionRequester`	`getCompactionRequestor()`
`CompactSplit`	`getCompactSplitThread()`
`org.apache.hadoop.conf.Configuration`	`getConfiguration()` Gets the configuration object for this server.
`protected ConfigurationManager`	`getConfigurationManager()`
`Connection`	`getConnection()` Returns a reference to the servers' connection.
`CoordinatedStateManager`	`getCoordinatedStateManager()` Get CoordinatedStateManager instance for this server.
`(package private) SortedMap<Long,HRegion>`	`getCopyOfOnlineRegionsSortedByOffHeapSize()`
`(package private) SortedMap<Long,HRegion>`	`getCopyOfOnlineRegionsSortedByOnHeapSize()`
`protected Class<? extends javax.servlet.http.HttpServlet>`	`getDumpServlet()`
`NettyEventLoopGroupConfig`	`getEventLoopGroupConfig()`
`ExecutorService`	`getExecutorService()`
`InetSocketAddress[]`	`getFavoredNodesForRegion(String encodedRegionName)` Return the favored nodes for a region given its encoded name.
`org.apache.hadoop.fs.FileSystem`	`getFileSystem()`
`double`	`getFlushPressure()`
`FlushRequester`	`getFlushRequester()`
`ThroughputController`	`getFlushThroughputController()`
`protected TableDescriptors`	`getFsTableDescriptors()`
`HeapMemoryManager`	`getHeapMemoryManager()`
`InfoServer`	`getInfoServer()`
`org.apache.hadoop.hbase.shaded.protobuf.generated.ClusterStatusProtos.RegionStoreSequenceIds`	`getLastSequenceId(byte[] encodedRegionName)`
`Leases`	`getLeases()`
`MasterAddressTracker`	`getMasterAddressTracker()`
`MetaTableLocator`	`getMetaTableLocator()` Returns instance of `MetaTableLocator` running inside this server.
`protected Function<TableDescriptorBuilder,TableDescriptorBuilder>`	`getMetaTableObserver()`
`MetricsRegionServer`	`getMetrics()`
`protected RegionInfo[]`	`getMostLoadedRegions()` Get the top N most loaded regions this server is serving so we can tell the master which regions it can reallocate if we're overloaded.
`private HRegionServer.MovedRegionInfo`	`getMovedRegion(String encodedRegionName)`
`private String`	`getMyEphemeralNodePath()`
`ServerNonceManager`	`getNonceManager()` Only required for "old" log replay; if it's removed, remove this.
`int`	`getNumberOfOnlineRegions()`
`HRegion`	`getOnlineRegion(byte[] regionName)`
`(package private) String`	`getOnlineRegionsAsPrintableString()`
`Collection<HRegion>`	`getOnlineRegionsLocalContext()` For tests, web ui and metrics.
`Set<TableName>`	`getOnlineTables()` Gets the online tables in this RS.
`protected String`	`getProcessName()`
`protected HRegion`	`getRegion(byte[] regionName)` Protected Utility method for safely obtaining an HRegion handle.
`HRegion`	`getRegion(String encodedRegionName)` Return `Region` instance.
`InetSocketAddress[]`	`getRegionBlockLocations(String encodedRegionName)`
`protected HRegion`	`getRegionByEncodedName(byte[] regionName, String encodedRegionName)`
`HRegion`	`getRegionByEncodedName(String encodedRegionName)`
`List<HRegion>`	`getRegions()` Get all online regions in this RS.
`List<HRegion>`	`getRegions(TableName tableName)` Gets the online regions of the specified table.
`RegionServerAccounting`	`getRegionServerAccounting()`
`RegionServerCoprocessorHost`	`getRegionServerCoprocessorHost()`
`String[]`	`getRegionServerCoprocessors()`
`MetricsRegionServer`	`getRegionServerMetrics()`
`RegionServerRpcQuotaManager`	`getRegionServerRpcQuotaManager()`
`RegionServerSpaceQuotaManager`	`getRegionServerSpaceQuotaManager()`
`ConcurrentMap<byte[],Boolean>`	`getRegionsInTransitionInRS()` Get the regions that are currently being opened or closed in the RS
`(package private) ReplicationSinkService`	`getReplicationSinkService()`
`ReplicationSourceService`	`getReplicationSourceService()`
`protected org.apache.hadoop.fs.Path`	`getRootDir()`
`RpcServerInterface`	`getRpcServer()` Returns a reference to the region server's RPC server
`RSRpcServices`	`getRSRpcServices()`
`SecureBulkLoadManager`	`getSecureBulkLoadManager()`
`ServerName`	`getServerName()`
`long`	`getStartcode()`
`TableDescriptors`	`getTableDescriptors()`
`int`	`getThreadWakeFrequency()` Interval at which threads should run
`protected String`	`getUseThisHostnameInstead(org.apache.hadoop.conf.Configuration conf)`
`WAL`	`getWAL(RegionInfo regionInfo)`
`org.apache.hadoop.fs.FileSystem`	`getWALFileSystem()`
`LogRoller`	`getWalRoller()`
`org.apache.hadoop.fs.Path`	`getWALRootDir()`
`List<WAL>`	`getWALs()`
`(package private) ReentrantReadWriteLock.WriteLock`	`getWriteLock()`
`private long`	`getWriteRequestCount()`
`ZKWatcher`	`getZooKeeper()` Gets the ZooKeeper instance for this server.
`protected void`	`handleReportForDutyResponse(org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.RegionServerStartupResponse c)`
`private void`	`initializeFileSystem()`
`protected void`	`initializeMemStoreChunkCreator()`
`private void`	`initializeThreads()`
`private void`	`initializeZooKeeper()` Bring up connection to zk ensemble and then wait until a master for this cluster and then after that, wait until cluster 'up' flag has been set.
`boolean`	`isAborted()` Check if the server or client was aborted.
`boolean`	`isClusterUp()`
`private boolean`	`isHealthCheckerConfigured()`
`private boolean`	`isHealthy()`
`boolean`	`isOnline()` Report the status of the server.
`(package private) boolean`	`isOnlineRegionsEmpty()`
`boolean`	`isStopped()`
`boolean`	`isStopping()`
`private boolean`	`keepLooping()`
`protected void`	`kill()`
`protected void`	`login(UserProvider user, String host)`
`static void`	`main(String[] args)`
`protected int`	`movedRegionCleanerPeriod()`
`private static <T extends ReplicationService> T`	`newReplicationInstance(String classname, Class<T> xface, org.apache.hadoop.conf.Configuration conf, HRegionServer server, org.apache.hadoop.fs.FileSystem walFs, org.apache.hadoop.fs.Path logDir, org.apache.hadoop.fs.Path oldLogDir, WALProvider walProvider)`
`void`	`onConfigurationChange(org.apache.hadoop.conf.Configuration newConf)` This method would be called by the `ConfigurationManager` object when the `Configuration` object is reloaded from disk.
`void`	`postOpenDeployTasks(RegionServerServices.PostOpenDeployContext context)` Tasks to perform after region open to complete deploy of region on regionserver
`private void`	`preRegistrationInitialization()` All initialization needed before we go register with Master. Do bare minimum.
`private int`	`putUpWebUI()` Puts up the webui.
`EntityLock`	`regionLock(List<RegionInfo> regionInfos, String description, Abortable abort)` Master based locks on namespaces/tables/regions.
`private void`	`registerConfigurationObservers()`
`boolean`	`registerService(com.google.protobuf.Service instance)` Registers a new protocol buffer `Service` subclass as a coprocessor endpoint to be available for handling
`(package private) void`	`removeFromMovedRegions(String encodedName)`
`boolean`	`removeRegion(HRegion r, ServerName destination)` Removes the given Region from the list of onlineRegions.
`private org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.RegionServerStartupResponse`	`reportForDuty()`
`boolean`	`reportRegionSizesForQuotas(Map<RegionInfo,Long> onlineRegionSizes)` Reports the given map of Regions and their size on the filesystem to the active Master.
`boolean`	`reportRegionStateTransition(RegionServerServices.RegionStateTransitionContext context)` Notify master that a handler requests to change a region state
`void`	`run()` The HRegionServer sticks in this loop until closed.
`protected void`	`sendShutdownInterrupt()` Called on stop/abort before closing the cluster connection and meta locator.
`protected void`	`setupClusterConnection()` Setup our cluster connection if not already initialized.
`private static NettyEventLoopGroupConfig`	`setupNetty(org.apache.hadoop.conf.Configuration conf)`
`private void`	`setupWALAndReplication()` Setup WAL log and replication if enabled.
`private static void`	`setupWindows(org.apache.hadoop.conf.Configuration conf, ConfigurationManager cm)` If running on Windows, do windows-specific setup.
`private void`	`shutdownWAL(boolean close)`
`private boolean`	`sleep(long millis)`
`private void`	`startHeapMemoryManager()`
`private void`	`startReplicationService()` Start up replication source and sink handlers.
`private void`	`startServices()`
`void`	`stop(String msg)` Stop this service.
`void`	`stop(String msg, boolean force, User user)` Stops the regionserver.
`protected void`	`stopServiceThreads()` Wait on all threads to finish.
`String`	`toString()`
`(package private) void`	`triggerFlushInPrimaryRegion(HRegion region)` Trigger a flush in the primary region replica if this region is a secondary replica.
`protected void`	`tryRegionServerReport(long reportStartTime, long reportEndTime)`
`void`	`unassign(byte[] regionName)` Unassign the given region from the current regionserver and assign it randomly.
`void`	`updateConfiguration()` Reload the configuration from disk.
`void`	`updateRegionFavoredNodesMapping(String encodedRegionName, List<org.apache.hadoop.hbase.shaded.protobuf.generated.HBaseProtos.ServerName> favoredNodes)` Used to update the favored nodes mapping when required.
`protected void`	`waitForMasterActive()` Wait for an active Master.
`void`	`waitForServerOnline()`
`private void`	`waitOnAllRegionsToClose(boolean abort)` Wait on regions close.
`boolean`	`walRollRequestFinished()` For testing

Methods inherited from class org.apache.hadoop.hbase.util.HasThread
getName, getThread, interrupt, isAlive, isInterrupted, join, join, join, setDaemon, setName, setPriority, setUncaughtExceptionHandler, start

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

- Field Detail
  - INIT_PAUSE_TIME_MS
```
private static final int INIT_PAUSE_TIME_MS
```
    See Also:
    
    Constant Field Values
  - LOG
```
private static final org.slf4j.Logger LOG
```
  - TEST_SKIP_REPORTING_TRANSITION
```
public static boolean TEST_SKIP_REPORTING_TRANSITION
```
    For testing only! Set to true to skip notifying region assignment to master .
  - regionsInTransitionInRS
```
protected final ConcurrentMap<byte[],Boolean> regionsInTransitionInRS
```
  - cacheFlusher
```
protected MemStoreFlusher cacheFlusher
```
  - hMemManager
```
protected HeapMemoryManager hMemManager
```
  - clusterConnection
```
protected ClusterConnection clusterConnection
```
    Cluster connection to be shared by services. Initialized at server startup and closed when server shuts down. Clients must never close it explicitly. Clients hosted by this Server should make use of this clusterConnection rather than create their own; if they create their own, there is no way for the hosting server to shutdown ongoing client RPCs.
  - metaTableLocator
```
protected MetaTableLocator metaTableLocator
```
  - tableDescriptors
```
protected TableDescriptors tableDescriptors
```
    Go here to get table descriptors.
  - replicationSourceHandler
```
protected ReplicationSourceService replicationSourceHandler
```
  - replicationSinkHandler
```
protected ReplicationSinkService replicationSinkHandler
```
  - compactSplitThread
```
public CompactSplit compactSplitThread
```
  - onlineRegions
```
protected final Map<String,HRegion> onlineRegions
```
    Map of regions currently being served by this region server. Key is the encoded region name. All access should be synchronized.
  - regionFavoredNodesMap
```
protected final Map<String,InetSocketAddress[]> regionFavoredNodesMap
```
    Map of encoded region names to the DataNode locations they should be hosted on We store the value as InetSocketAddress since this is used only in HDFS API (create() that takes favored nodes as hints for placing file blocks). We could have used ServerName here as the value class, but we'd need to convert it to InetSocketAddress at some point before the HDFS API call, and it seems a bit weird to store ServerName since ServerName refers to RegionServers and here we really mean DataNode locations.
  - leases
```
protected Leases leases
```
  - executorService
```
protected ExecutorService executorService
```
  - fsOk
```
protected volatile boolean fsOk
```
  - fs
```
protected HFileSystem fs
```
  - walFs
```
protected HFileSystem walFs
```
  - stopped
```
private volatile boolean stopped
```
  - abortRequested
```
private volatile boolean abortRequested
```
  - ABORT_TIMEOUT
```
public static final String ABORT_TIMEOUT
```
    See Also:
    
    Constant Field Values
  - DEFAULT_ABORT_TIMEOUT
```
private static final long DEFAULT_ABORT_TIMEOUT
```
    See Also:
    
    Constant Field Values
  - ABORT_TIMEOUT_TASK
```
public static final String ABORT_TIMEOUT_TASK
```
    See Also:
    
    Constant Field Values
  - rowlocks
```
ConcurrentMap<String,Integer> rowlocks
```
  - stopping
```
private boolean stopping
```
  - killed
```
volatile boolean killed
```
  - conf
```
protected final org.apache.hadoop.conf.Configuration conf
```
  - rootDir
```
private org.apache.hadoop.fs.Path rootDir
```
  - walRootDir
```
private org.apache.hadoop.fs.Path walRootDir
```
  - lock
```
protected final ReentrantReadWriteLock lock
```
  - numRetries
```
final int numRetries
```
  - threadWakeFrequency
```
protected final int threadWakeFrequency
```
  - msgInterval
```
protected final int msgInterval
```
  - numRegionsToReport
```
protected final int numRegionsToReport
```
  - rssStub
```
private volatile org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.RegionServerStatusService.BlockingInterface rssStub
```
  - lockStub
```
private volatile org.apache.hadoop.hbase.shaded.protobuf.generated.LockServiceProtos.LockService.BlockingInterface lockStub
```
  - rpcClient
```
RpcClient rpcClient
```
  - rpcRetryingCallerFactory
```
private RpcRetryingCallerFactory rpcRetryingCallerFactory
```
  - rpcControllerFactory
```
private RpcControllerFactory rpcControllerFactory
```
  - uncaughtExceptionHandler
```
private Thread.UncaughtExceptionHandler uncaughtExceptionHandler
```
  - infoServer
```
protected InfoServer infoServer
```
  - pauseMonitor
```
private JvmPauseMonitor pauseMonitor
```
  - REGIONSERVER
```
public static final String REGIONSERVER
```
    region server process name
    
    See Also:
    
    Constant Field Values
  - metricsRegionServer
```
MetricsRegionServer metricsRegionServer
```
  - metricsTable
```
MetricsTable metricsTable
```
  - spanReceiverHost
```
private SpanReceiverHost spanReceiverHost
```
  - choreService
```
private ChoreService choreService
```
    ChoreService used to schedule tasks that we want to run periodically
  - compactionChecker
```
ScheduledChore compactionChecker
```
  - periodicFlusher
```
ScheduledChore periodicFlusher
```
  - walFactory
```
protected volatile WALFactory walFactory
```
  - walRoller
```
protected LogRoller walRoller
```
  - online
```
final AtomicBoolean online
```
  - zooKeeper
```
protected final ZKWatcher zooKeeper
```
  - masterAddressTracker
```
private final MasterAddressTracker masterAddressTracker
```
  - clusterStatusTracker
```
protected final ClusterStatusTracker clusterStatusTracker
```
  - splitLogWorker
```
private SplitLogWorker splitLogWorker
```
  - sleeper
```
protected final Sleeper sleeper
```
  - operationTimeout
```
private final int operationTimeout
```
  - shortOperationTimeout
```
private final int shortOperationTimeout
```
  - regionServerAccounting
```
private final RegionServerAccounting regionServerAccounting
```
  - cacheConfig
```
protected CacheConfig cacheConfig
```
  - mobCacheConfig
```
final MobCacheConfig mobCacheConfig
```
  - healthCheckChore
```
private HealthCheckChore healthCheckChore
```
    The health check chore.
  - nonceManagerChore
```
private ScheduledChore nonceManagerChore
```
    The nonce manager chore.
  - coprocessorServiceHandlers
```
private Map<String,com.google.protobuf.Service> coprocessorServiceHandlers
```
  - serverName
```
protected ServerName serverName
```
    The server name the Master sees us as. Its made from the hostname the master passes us, port, and server startcode. Gets set after registration against Master.
  - useThisHostnameInstead
```
protected String useThisHostnameInstead
```
  - RS_HOSTNAME_KEY
```
@InterfaceAudience.LimitedPrivate(value="Configuration")
static final String RS_HOSTNAME_KEY
```
    See Also:
    
    Constant Field Values
  - MASTER_HOSTNAME_KEY
```
@InterfaceAudience.LimitedPrivate(value="Configuration")
protected static final String MASTER_HOSTNAME_KEY
```
    See Also:
    
    Constant Field Values
  - RS_HOSTNAME_DISABLE_MASTER_REVERSEDNS_KEY
```
static final String RS_HOSTNAME_DISABLE_MASTER_REVERSEDNS_KEY
```
    See Also:
    
    Constant Field Values
  - startcode
```
protected final long startcode
```
    This servers startcode.
  - clusterId
```
protected String clusterId
```
    Unique identifier for the cluster we are a part of.
  - movedRegionsCleaner
```
private HRegionServer.MovedRegionsCleaner movedRegionsCleaner
```
    Chore to clean periodically the moved region list
  - storefileRefresher
```
private StorefileRefresherChore storefileRefresher
```
  - rsHost
```
private RegionServerCoprocessorHost rsHost
```
  - rspmHost
```
private RegionServerProcedureManagerHost rspmHost
```
  - rsQuotaManager
```
private RegionServerRpcQuotaManager rsQuotaManager
```
  - rsSpaceQuotaManager
```
private RegionServerSpaceQuotaManager rsSpaceQuotaManager
```
  - nonceManager
```
final ServerNonceManager nonceManager
```
    Nonce manager. Nonces are used to make operations like increment and append idempotent in the case where client doesn't receive the response from a successful operation and retries. We track the successful ops for some time via a nonce sent by client and handle duplicate operations (currently, by failing them; in future we might use MVCC to return result). Nonces are also recovered from WAL during, recovery; however, the caveats (from HBASE-3787) are: - WAL recovery is optimized, and under high load we won't read nearly nonce-timeout worth of past records. If we don't read the records, we don't read and recover the nonces. Some WALs within nonce-timeout at recovery may not even be present due to rolling/cleanup. - There's no WAL recovery during normal region move, so nonces will not be transfered. We can have separate additional "Nonce WAL". It will just contain bunch of numbers and won't be flushed on main path - because WAL itself also contains nonces, if we only flush it before memstore flush, for a given nonce we will either see it in the WAL (if it was never flushed to disk, it will be part of recovery), or we'll see it as part of the nonce log (or both occasionally, which doesn't matter). Nonce log file can be deleted after the latest nonce in it expired. It can also be recovered during move.
  - userProvider
```
private UserProvider userProvider
```
  - rpcServices
```
protected final RSRpcServices rpcServices
```
  - csm
```
protected CoordinatedStateManager csm
```
  - configurationManager
```
protected final ConfigurationManager configurationManager
```
    Configuration manager is used to register/deregister and notify the configuration observers when the regionserver is notified that there was a change in the on disk configs.
  - compactedFileDischarger
```
CompactedHFilesDischarger compactedFileDischarger
```
  - flushThroughputController
```
private volatile ThroughputController flushThroughputController
```
  - secureBulkLoadManager
```
protected SecureBulkLoadManager secureBulkLoadManager
```
  - fsUtilizationChore
```
protected FileSystemUtilizationChore fsUtilizationChore
```
  - eventLoopGroupConfig
```
private final NettyEventLoopGroupConfig eventLoopGroupConfig
```
  - masterless
```
private final boolean masterless
```
    True if this RegionServer is coming up in a cluster where there is no Master; means it needs to just come up and make do without a Master to talk to: e.g. in test or HRegionServer is doing other than its usual duties: e.g. as an hollowed-out host whose only purpose is as a Replication-stream sink; see HBASE-18846 for more.
  - MASTERLESS_CONFIG_NAME
```
static final String MASTERLESS_CONFIG_NAME
```
    See Also:
    
    Constant Field Values
  - movedRegions
```
protected Map<String,HRegionServer.MovedRegionInfo> movedRegions
```
  - TIMEOUT_REGION_MOVED
```
private static final int TIMEOUT_REGION_MOVED
```
    See Also:
    
    Constant Field Values
- Constructor Detail
  - HRegionServer
```
public HRegionServer(org.apache.hadoop.conf.Configuration conf)
              throws IOException
```
    Starts a HRegionServer at the default location
    
    Throws:
    
    IOException
- Method Detail
  - getUseThisHostnameInstead
```
protected String getUseThisHostnameInstead(org.apache.hadoop.conf.Configuration conf)
                                    throws IOException
```
    Throws:
    
    IOException
  - setupWindows
```
private static void setupWindows(org.apache.hadoop.conf.Configuration conf,
                                 ConfigurationManager cm)
```
    If running on Windows, do windows-specific setup.
  - setupNetty
```
private static NettyEventLoopGroupConfig setupNetty(org.apache.hadoop.conf.Configuration conf)
```
  - initializeFileSystem
```
private void initializeFileSystem()
                           throws IOException
```
    Throws:
    
    IOException
  - getFsTableDescriptors
```
protected TableDescriptors getFsTableDescriptors()
                                          throws IOException
```
    Throws:
    
    IOException
  - getMetaTableObserver
```
protected Function<TableDescriptorBuilder,TableDescriptorBuilder> getMetaTableObserver()
```
  - login
```
protected void login(UserProvider user,
                     String host)
              throws IOException
```
    Throws:
    
    IOException
  - waitForMasterActive
```
protected void waitForMasterActive()
```
    Wait for an active Master. See override in Master superclass for how it is used.
  - getProcessName
```
protected String getProcessName()
```
  - canCreateBaseZNode
```
protected boolean canCreateBaseZNode()
```
  - canUpdateTableDescriptor
```
protected boolean canUpdateTableDescriptor()
```
  - createRpcServices
```
protected RSRpcServices createRpcServices()
                                   throws IOException
```
    Throws:
    
    IOException
  - configureInfoServer
```
protected void configureInfoServer()
```
  - getDumpServlet
```
protected Class<? extends javax.servlet.http.HttpServlet> getDumpServlet()
```
  - registerService
```
public boolean registerService(com.google.protobuf.Service instance)
```
    Description copied from interface: RegionServerServices
    
    Registers a new protocol buffer Service subclass as a coprocessor endpoint to be available for handling
    
    Specified by:
    
    registerService in interface RegionServerServices
    
    Parameters:
    
    instance - the Service subclass instance to expose as a coprocessor endpoint
    
    Returns:
    
    true if the registration was successful, false
  - createClusterConnection
```
protected ClusterConnection createClusterConnection()
                                             throws IOException
```
    Create a 'smarter' Connection, one that is capable of by-passing RPC if the request is to the local server; i.e. a short-circuit Connection. Safe to use going to local or remote server. Create this instance in a method can be intercepted and mocked in tests.
    
    Throws:
    
    IOException
  - checkCodecs
```
private static void checkCodecs(org.apache.hadoop.conf.Configuration c)
                         throws IOException
```
    Run test on configured codecs to make sure supporting libs are in place.
    
    Parameters:
    
    c -
    
    Throws:
    
    IOException
  - getClusterId
```
public String getClusterId()
```
  - setupClusterConnection
```
protected void setupClusterConnection()
                               throws IOException
```
    Setup our cluster connection if not already initialized.
    
    Throws:
    
    IOException
  - preRegistrationInitialization
```
private void preRegistrationInitialization()
```
    All initialization needed before we go register with Master.
    Do bare minimum. Do bulk of initializations AFTER we've connected to the Master.
    In here we just put up the RpcServer, setup Connection, and ZooKeeper.
  - initializeZooKeeper
```
private void initializeZooKeeper()
                          throws IOException,
                                 InterruptedException
```
    Bring up connection to zk ensemble and then wait until a master for this cluster and then after that, wait until cluster 'up' flag has been set. This is the order in which master does things.
    Finally open long-living server short-circuit connection.
    
    Throws:
    
    IOException
    
    InterruptedException
  - blockAndCheckIfStopped
```
private void blockAndCheckIfStopped(ZKNodeTracker tracker)
                             throws IOException,
                                    InterruptedException
```
    Utilty method to wait indefinitely on a znode availability while checking if the region server is shut down
    
    Parameters:
    
    tracker - znode tracker to use
    
    Throws:
    
    IOException - any IO exception, plus if the RS is stopped
    
    InterruptedException
  - isClusterUp
```
public boolean isClusterUp()
```
    Specified by:
    
    isClusterUp in interface RegionServerServices
    
    Returns:
    
    True if the cluster is up.
  - run
```
public void run()
```
    The HRegionServer sticks in this loop until closed.
    
    Specified by:
    
    run in interface Runnable
    
    Specified by:
    
    run in class HasThread
  - containsMetaTableRegions
```
private boolean containsMetaTableRegions()
```
  - areAllUserRegionsOffline
```
private boolean areAllUserRegionsOffline()
```
  - getWriteRequestCount
```
private long getWriteRequestCount()
```
    Returns:
    
    Current write count for all online regions.
  - tryRegionServerReport
```
protected void tryRegionServerReport(long reportStartTime,
                                     long reportEndTime)
                              throws IOException
```
    Throws:
    
    IOException
  - reportRegionSizesForQuotas
```
public boolean reportRegionSizesForQuotas(Map<RegionInfo,Long> onlineRegionSizes)
```
    Reports the given map of Regions and their size on the filesystem to the active Master.
    
    Parameters:
    
    onlineRegionSizes - A map of region info to size in bytes
    
    Returns:
    
    false if FileSystemUtilizationChore should pause reporting to master. true otherwise
  - buildRegionSpaceUseReportRequest
```
org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.RegionSpaceUseReportRequest buildRegionSpaceUseReportRequest(Map<RegionInfo,Long> regionSizes)
```
    Builds a RegionServerStatusProtos.RegionSpaceUseReportRequest protobuf message from the region size map.
    
    Parameters:
    
    regionSizes - Map of region info to size in bytes.
    
    Returns:
    
    The corresponding protocol buffer message.
  - convertRegionSize
```
org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.RegionSpaceUse convertRegionSize(RegionInfo regionInfo,
                                                                                                            Long sizeInBytes)
```
    Converts a pair of RegionInfo and long into a RegionServerStatusProtos.RegionSpaceUse protobuf message.
    
    Parameters:
    
    regionInfo - The RegionInfo
    
    sizeInBytes - The size in bytes of the Region
    
    Returns:
    
    The protocol buffer
  - buildServerLoad
```
org.apache.hadoop.hbase.shaded.protobuf.generated.ClusterStatusProtos.ServerLoad buildServerLoad(long reportStartTime,
                                                                                                 long reportEndTime)
                                                                                          throws IOException
```
    Throws:
    
    IOException
  - getOnlineRegionsAsPrintableString
```
String getOnlineRegionsAsPrintableString()
```
  - waitOnAllRegionsToClose
```
private void waitOnAllRegionsToClose(boolean abort)
```
    Wait on regions close.
  - sleep
```
private boolean sleep(long millis)
```
  - shutdownWAL
```
private void shutdownWAL(boolean close)
```
  - handleReportForDutyResponse
```
protected void handleReportForDutyResponse(org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.RegionServerStartupResponse c)
                                    throws IOException
```
    Throws:
    
    IOException
  - initializeMemStoreChunkCreator
```
protected void initializeMemStoreChunkCreator()
```
  - startHeapMemoryManager
```
private void startHeapMemoryManager()
```
  - createMyEphemeralNode
```
private void createMyEphemeralNode()
                            throws org.apache.zookeeper.KeeperException,
                                   IOException
```
    Throws:
    
    org.apache.zookeeper.KeeperException
    
    IOException
  - deleteMyEphemeralNode
```
private void deleteMyEphemeralNode()
                            throws org.apache.zookeeper.KeeperException
```
    Throws:
    
    org.apache.zookeeper.KeeperException
  - getRegionServerAccounting
```
public RegionServerAccounting getRegionServerAccounting()
```
    Specified by:
    
    getRegionServerAccounting in interface RegionServerServices
    
    Returns:
    
    the RegionServerAccounting for this Region Server
  - createRegionLoad
```
org.apache.hadoop.hbase.shaded.protobuf.generated.ClusterStatusProtos.RegionLoad createRegionLoad(HRegion r,
                                                                                                  org.apache.hadoop.hbase.shaded.protobuf.generated.ClusterStatusProtos.RegionLoad.Builder regionLoadBldr,
                                                                                                  org.apache.hadoop.hbase.shaded.protobuf.generated.HBaseProtos.RegionSpecifier.Builder regionSpecifier)
                                                                                           throws IOException
```
    Throws:
    
    IOException
  - createRegionLoad
```
public org.apache.hadoop.hbase.shaded.protobuf.generated.ClusterStatusProtos.RegionLoad createRegionLoad(String encodedRegionName)
                                                                                                  throws IOException
```
    Parameters:
    
    encodedRegionName -
    
    Returns:
    
    An instance of RegionLoad.
    
    Throws:
    
    IOException
  - isOnline
```
public boolean isOnline()
```
    Report the status of the server. A server is online once all the startup is completed (setting up filesystem, starting executorService threads, etc.). This method is designed mostly to be useful in tests.
    
    Returns:
    
    true if online, false if not.
  - setupWALAndReplication
```
private void setupWALAndReplication()
                             throws IOException
```
    Setup WAL log and replication if enabled. Replication setup is done in here because it wants to be hooked up to WAL.
    
    Throws:
    
    IOException
  - startReplicationService
```
private void startReplicationService()
                              throws IOException
```
    Start up replication source and sink handlers.
    
    Throws:
    
    IOException
  - getRegionServerMetrics
```
public MetricsRegionServer getRegionServerMetrics()
```
  - getMasterAddressTracker
```
public MasterAddressTracker getMasterAddressTracker()
```
    Returns:
    
    Master address tracker instance.
  - startServices
```
private void startServices()
                    throws IOException
```
    Throws:
    
    IOException
  - initializeThreads
```
private void initializeThreads()
                        throws IOException
```
    Throws:
    
    IOException
  - registerConfigurationObservers
```
private void registerConfigurationObservers()
```
  - putUpWebUI
```
private int putUpWebUI()
                throws IOException
```
    Puts up the webui.
    
    Returns:
    
    Returns final port -- maybe different from what we started with.
    
    Throws:
    
    IOException
  - isHealthy
```
private boolean isHealthy()
```
  - getWALs
```
public List<WAL> getWALs()
                  throws IOException
```
    Specified by:
    
    getWALs in interface RegionServerServices
    
    Returns:
    
    the List of WALs that are used by this server Doesn't include the meta WAL
    
    Throws:
    
    IOException
  - getWAL
```
public WAL getWAL(RegionInfo regionInfo)
           throws IOException
```
    Specified by:
    
    getWAL in interface RegionServerServices
    
    Returns:
    
    the WAL for a particular region. Pass null for getting the default (common) WAL
    
    Throws:
    
    IOException
  - getWalRoller
```
public LogRoller getWalRoller()
```
  - getConnection
```
public Connection getConnection()
```
    Description copied from interface: Server
    
    Returns a reference to the servers' connection. Important note: this method returns a reference to Connection which is managed by Server itself, so callers must NOT attempt to close connection obtained.
    
    Specified by:
    
    getConnection in interface Server
  - getClusterConnection
```
public ClusterConnection getClusterConnection()
```
    Description copied from interface: Server
    
    Returns a reference to the servers' cluster connection. Prefer Server.getConnection(). Important note: this method returns a reference to Connection which is managed by Server itself, so callers must NOT attempt to close connection obtained.
    
    Specified by:
    
    getClusterConnection in interface Server
  - getMetaTableLocator
```
public MetaTableLocator getMetaTableLocator()
```
    Description copied from interface: Server
    
    Returns instance of MetaTableLocator running inside this server. This MetaServerLocator is started and stopped by server, clients shouldn't manage it's lifecycle.
    
    Specified by:
    
    getMetaTableLocator in interface Server
    
    Returns:
    
    instance of MetaTableLocator associated with this server.
  - stop
```
public void stop(String msg)
```
    Description copied from interface: Stoppable
    
    Stop this service. Implementers should favor logging errors over throwing RuntimeExceptions.
    
    Specified by:
    
    stop in interface Stoppable
    
    Parameters:
    
    msg - Why we're stopping.
  - stop
```
public void stop(String msg,
                 boolean force,
                 User user)
```
    Stops the regionserver.
    
    Parameters:
    
    msg - Status message
    
    force - True if this is a regionserver abort
    
    user - The user executing the stop request, or null if no user is associated
  - waitForServerOnline
```
public void waitForServerOnline()
```
  - postOpenDeployTasks
```
public void postOpenDeployTasks(RegionServerServices.PostOpenDeployContext context)
                         throws org.apache.zookeeper.KeeperException,
                                IOException
```
    Description copied from interface: RegionServerServices
    
    Tasks to perform after region open to complete deploy of region on regionserver
    
    Specified by:
    
    postOpenDeployTasks in interface RegionServerServices
    
    Parameters:
    
    context - the context
    
    Throws:
    
    org.apache.zookeeper.KeeperException
    
    IOException
  - reportRegionStateTransition
```
public boolean reportRegionStateTransition(RegionServerServices.RegionStateTransitionContext context)
```
    Description copied from interface: RegionServerServices
    
    Notify master that a handler requests to change a region state
    
    Specified by:
    
    reportRegionStateTransition in interface RegionServerServices
  - triggerFlushInPrimaryRegion
```
void triggerFlushInPrimaryRegion(HRegion region)
```
    Trigger a flush in the primary region replica if this region is a secondary replica. Does not block this thread. See RegionReplicaFlushHandler for details.
  - getRpcServer
```
public RpcServerInterface getRpcServer()
```
    Description copied from interface: RegionServerServices
    
    Returns a reference to the region server's RPC server
    
    Specified by:
    
    getRpcServer in interface RegionServerServices
  - getRSRpcServices
```
public RSRpcServices getRSRpcServices()
```
  - abort
```
public void abort(String reason,
                  Throwable cause)
```
    Cause the server to exit without closing the regions it is serving, the log it is using and without notifying the master. Used unit testing and on catastrophic events such as HDFS is yanked out from under hbase or we OOME.
    
    Specified by:
    
    abort in interface Abortable
    
    Parameters:
    
    reason - the reason we are aborting
    
    cause - the exception that caused the abort, or null
  - abort
```
public void abort(String reason)
```
    See Also:
    
    abort(String, Throwable)
  - isAborted
```
public boolean isAborted()
```
    Description copied from interface: Abortable
    
    Check if the server or client was aborted.
    
    Specified by:
    
    isAborted in interface Abortable
    
    Returns:
    
    true if the server or client was aborted, false otherwise
  - kill
```
protected void kill()
```
  - sendShutdownInterrupt
```
protected void sendShutdownInterrupt()
```
    Called on stop/abort before closing the cluster connection and meta locator.
  - stopServiceThreads
```
protected void stopServiceThreads()
```
    Wait on all threads to finish. Presumption is that all closes and stops have already been called.
  - getReplicationSourceService
```
public ReplicationSourceService getReplicationSourceService()
```
    Returns:
    
    Return the object that implements the replication source executorService.
  - getReplicationSinkService
```
ReplicationSinkService getReplicationSinkService()
```
    Returns:
    
    Return the object that implements the replication sink executorService.
  - createRegionServerStatusStub
```
protected ServerName createRegionServerStatusStub()
```
    Get the current master from ZooKeeper and open the RPC connection to it. To get a fresh connection, the current rssStub must be null. Method will block until a master is available. You can break from this block by requesting the server stop.
    
    Returns:
    
    master + port, or null if server has been stopped
  - createRegionServerStatusStub
```
protected ServerName createRegionServerStatusStub(boolean refresh)
```
    Get the current master from ZooKeeper and open the RPC connection to it. To get a fresh connection, the current rssStub must be null. Method will block until a master is available. You can break from this block by requesting the server stop.
    
    Parameters:
    
    refresh - If true then master address will be read from ZK, otherwise use cached data
    
    Returns:
    
    master + port, or null if server has been stopped
  - keepLooping
```
private boolean keepLooping()
```
    Returns:
    
    True if we should break loop because cluster is going down or this server has been stopped or hdfs has gone bad.
  - reportForDuty
```
private org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.RegionServerStartupResponse reportForDuty()
                                                                                                                      throws IOException
```
    Throws:
    
    IOException
  - getLastSequenceId
```
public org.apache.hadoop.hbase.shaded.protobuf.generated.ClusterStatusProtos.RegionStoreSequenceIds getLastSequenceId(byte[] encodedRegionName)
```
    Specified by:
    
    getLastSequenceId in interface LastSequenceId
    
    Parameters:
    
    encodedRegionName - Encoded region name
    
    Returns:
    
    Last flushed sequence Id for region and its stores. Id will be -1 if it can't be determined
  - closeAllRegions
```
protected void closeAllRegions(boolean abort)
```
    Closes all regions. Called on our way out. Assumes that its not possible for new regions to be added to onlineRegions while this method runs.
  - closeMetaTableRegions
```
void closeMetaTableRegions(boolean abort)
```
    Close meta region if we carry it
    
    Parameters:
    
    abort - Whether we're running an abort.
  - closeUserRegions
```
void closeUserRegions(boolean abort)
```
    Schedule closes on all user regions. Should be safe calling multiple times because it wont' close regions that are already closed or that are closing.
    
    Parameters:
    
    abort - Whether we're running an abort.
  - getInfoServer
```
public InfoServer getInfoServer()
```
    Returns:
    
    the info server
  - isStopped
```
public boolean isStopped()
```
    Specified by:
    
    isStopped in interface Stoppable
    
    Returns:
    
    true if a stop has been requested.
  - isStopping
```
public boolean isStopping()
```
    Specified by:
    
    isStopping in interface Server
    
    Returns:
    
    True is the server is Stopping
  - getConfiguration
```
public org.apache.hadoop.conf.Configuration getConfiguration()
```
    Description copied from interface: Server
    
    Gets the configuration object for this server.
    
    Specified by:
    
    getConfiguration in interface Server
    
    Returns:
    
    the configuration
  - getWriteLock
```
ReentrantReadWriteLock.WriteLock getWriteLock()
```
    Returns:
    
    the write lock for the server
  - getNumberOfOnlineRegions
```
public int getNumberOfOnlineRegions()
```
  - isOnlineRegionsEmpty
```
boolean isOnlineRegionsEmpty()
```
  - getOnlineRegionsLocalContext
```
public Collection<HRegion> getOnlineRegionsLocalContext()
```
    For tests, web ui and metrics. This method will only work if HRegionServer is in the same JVM as client; HRegion cannot be serialized to cross an rpc.
  - addRegion
```
public void addRegion(HRegion region)
```
    Description copied from interface: MutableOnlineRegions
    
    Add to online regions.
    
    Specified by:
    
    addRegion in interface MutableOnlineRegions
  - getCopyOfOnlineRegionsSortedByOffHeapSize
```
SortedMap<Long,HRegion> getCopyOfOnlineRegionsSortedByOffHeapSize()
```
    Returns:
    
    A new Map of online regions sorted by region off-heap size with the first entry being the biggest. If two regions are the same size, then the last one found wins; i.e. this method may NOT return all regions.
  - getCopyOfOnlineRegionsSortedByOnHeapSize
```
SortedMap<Long,HRegion> getCopyOfOnlineRegionsSortedByOnHeapSize()
```
    Returns:
    
    A new Map of online regions sorted by region heap size with the first entry being the biggest. If two regions are the same size, then the last one found wins; i.e. this method may NOT return all regions.
  - getStartcode
```
public long getStartcode()
```
    Returns:
    
    time stamp in millis of when this region server was started
  - getFlushRequester
```
public FlushRequester getFlushRequester()
```
    Specified by:
    
    getFlushRequester in interface RegionServerServices
    
    Returns:
    
    reference to FlushRequester
  - getCompactionRequestor
```
public CompactionRequester getCompactionRequestor()
```
    Specified by:
    
    getCompactionRequestor in interface RegionServerServices
    
    Returns:
    
    Implementation of CompactionRequester or null. Usually it will not be null unless during intialization.
  - getMostLoadedRegions
```
protected RegionInfo[] getMostLoadedRegions()
```
    Get the top N most loaded regions this server is serving so we can tell the master which regions it can reallocate if we're overloaded. TODO: actually calculate which regions are most loaded. (Right now, we're just grabbing the first N regions being served regardless of load.)
  - getLeases
```
public Leases getLeases()
```
    Specified by:
    
    getLeases in interface RegionServerServices
    
    Returns:
    
    The RegionServer's "Leases" service
  - getRootDir
```
protected org.apache.hadoop.fs.Path getRootDir()
```
    Returns:
    
    Return the rootDir.
  - getFileSystem
```
public org.apache.hadoop.fs.FileSystem getFileSystem()
```
    Specified by:
    
    getFileSystem in interface Server
    
    Returns:
    
    Return the fs.
  - getWALRootDir
```
public org.apache.hadoop.fs.Path getWALRootDir()
```
    Returns:
    
    Return the walRootDir.
  - getWALFileSystem
```
public org.apache.hadoop.fs.FileSystem getWALFileSystem()
```
    Returns:
    
    Return the walFs.
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - getThreadWakeFrequency
```
public int getThreadWakeFrequency()
```
    Interval at which threads should run
    
    Returns:
    
    the interval
  - getZooKeeper
```
public ZKWatcher getZooKeeper()
```
    Description copied from interface: Server
    
    Gets the ZooKeeper instance for this server.
    
    Specified by:
    
    getZooKeeper in interface Server
  - getCoordinatedStateManager
```
public CoordinatedStateManager getCoordinatedStateManager()
```
    Description copied from interface: Server
    
    Get CoordinatedStateManager instance for this server.
    
    Specified by:
    
    getCoordinatedStateManager in interface Server
  - getServerName
```
public ServerName getServerName()
```
    Specified by:
    
    getServerName in interface Server
    
    Returns:
    
    The unique server name for this server.
  - getRegionServerCoprocessorHost
```
public RegionServerCoprocessorHost getRegionServerCoprocessorHost()
```
  - getRegionsInTransitionInRS
```
public ConcurrentMap<byte[],Boolean> getRegionsInTransitionInRS()
```
    Description copied from interface: RegionServerServices
    
    Get the regions that are currently being opened or closed in the RS
    
    Specified by:
    
    getRegionsInTransitionInRS in interface RegionServerServices
    
    Returns:
    
    map of regions in transition in this RS
  - getExecutorService
```
public ExecutorService getExecutorService()
```
    Specified by:
    
    getExecutorService in interface RegionServerServices
    
    Returns:
    
    hbase executor service
  - getChoreService
```
public ChoreService getChoreService()
```
    Specified by:
    
    getChoreService in interface Server
    
    Returns:
    
    The ChoreService instance for this server
  - getRegionServerRpcQuotaManager
```
public RegionServerRpcQuotaManager getRegionServerRpcQuotaManager()
```
    Specified by:
    
    getRegionServerRpcQuotaManager in interface RegionServerServices
    
    Returns:
    
    RegionServer's instance of RegionServerRpcQuotaManager
  - createNewReplicationInstance
```
private static void createNewReplicationInstance(org.apache.hadoop.conf.Configuration conf,
                                                 HRegionServer server,
                                                 org.apache.hadoop.fs.FileSystem walFs,
                                                 org.apache.hadoop.fs.Path walDir,
                                                 org.apache.hadoop.fs.Path oldWALDir,
                                                 WALProvider walProvider)
                                          throws IOException
```
    Load the replication executorService objects, if any
    
    Throws:
    
    IOException
  - newReplicationInstance
```
private static <T extends ReplicationService> T newReplicationInstance(String classname,
                                                                       Class<T> xface,
                                                                       org.apache.hadoop.conf.Configuration conf,
                                                                       HRegionServer server,
                                                                       org.apache.hadoop.fs.FileSystem walFs,
                                                                       org.apache.hadoop.fs.Path logDir,
                                                                       org.apache.hadoop.fs.Path oldLogDir,
                                                                       WALProvider walProvider)
                                                                throws IOException
```
    Throws:
    
    IOException
  - constructRegionServer
```
public static HRegionServer constructRegionServer(Class<? extends HRegionServer> regionServerClass,
                                                  org.apache.hadoop.conf.Configuration conf2)
```
    Utility for constructing an instance of the passed HRegionServer class.
    
    Parameters:
    
    regionServerClass -
    
    conf2 -
    
    Returns:
    
    HRegionServer instance.
  - main
```
public static void main(String[] args)
                 throws Exception
```
    Throws:
    
    Exception
    
    See Also:
    
    HRegionServerCommandLine
  - getRegions
```
public List<HRegion> getRegions(TableName tableName)
```
    Gets the online regions of the specified table. This method looks at the in-memory onlineRegions. It does not go to hbase:meta. Only returns online regions. If a region on this table has been closed during a disable, etc., it will not be included in the returned list. So, the returned list may not necessarily be ALL regions in this table, its all the ONLINE regions in the table.
    
    Specified by:
    
    getRegions in interface OnlineRegions
    
    Parameters:
    
    tableName -
    
    Returns:
    
    Online regions from tableName
  - getRegions
```
public List<HRegion> getRegions()
```
    Description copied from interface: OnlineRegions
    
    Get all online regions in this RS.
    
    Specified by:
    
    getRegions in interface OnlineRegions
    
    Returns:
    
    List of online Region
  - getOnlineTables
```
public Set<TableName> getOnlineTables()
```
    Gets the online tables in this RS. This method looks at the in-memory onlineRegions.
    
    Returns:
    
    all the online tables in this RS
  - getRegionServerCoprocessors
```
public String[] getRegionServerCoprocessors()
```
  - closeRegionIgnoreErrors
```
private void closeRegionIgnoreErrors(RegionInfo region,
                                     boolean abort)
```
    Try to close the region, logs a warning on failure but continues.
    
    Parameters:
    
    region - Region to close
  - closeRegion
```
protected boolean closeRegion(String encodedName,
                              boolean abort,
                              ServerName sn)
                       throws NotServingRegionException
```
    Close asynchronously a region, can be called from the master or internally by the regionserver when stopping. If called from the master, the region will update the znode status.
    If an opening was in progress, this method will cancel it, but will not start a new close. The coprocessors are not called in this case. A NotServingRegionException exception is thrown.
    
    If a close was in progress, this new request will be ignored, and an exception thrown.
    
    Parameters:
    
    encodedName - Region to close
    
    abort - True if we are aborting
    
    Returns:
    
    True if closed a region.
    
    Throws:
    
    NotServingRegionException - if the region is not online
  - closeAndOfflineRegionForSplitOrMerge
```
protected boolean closeAndOfflineRegionForSplitOrMerge(List<String> regionEncodedName)
                                                throws IOException
```
    Close and offline the region for split or merge
    
    Parameters:
    
    regionEncodedName - the name of the region(s) to close
    
    Returns:
    
    true if closed the region successfully.
    
    Throws:
    
    IOException
  - getOnlineRegion
```
public HRegion getOnlineRegion(byte[] regionName)
```
    Returns:
    
    HRegion for the passed binary regionName or null if named region is not member of the online regions.
  - getRegionBlockLocations
```
public InetSocketAddress[] getRegionBlockLocations(String encodedRegionName)
```
  - getRegion
```
public HRegion getRegion(String encodedRegionName)
```
    Description copied from interface: OnlineRegions
    
    Return Region instance. Only works if caller is in same context, in same JVM. Region is not serializable.
    
    Specified by:
    
    getRegion in interface OnlineRegions
    
    Returns:
    
    Region for the passed encoded encodedRegionName or null if named region is not member of the online regions.
  - removeRegion
```
public boolean removeRegion(HRegion r,
                            ServerName destination)
```
    Description copied from interface: MutableOnlineRegions
    
    Removes the given Region from the list of onlineRegions.
    
    Specified by:
    
    removeRegion in interface MutableOnlineRegions
    
    Parameters:
    
    r - Region to remove.
    
    destination - Destination, if any, null otherwise.
    
    Returns:
    
    True if we removed a region from online list.
  - getRegion
```
protected HRegion getRegion(byte[] regionName)
                     throws NotServingRegionException
```
    Protected Utility method for safely obtaining an HRegion handle.
    
    Parameters:
    
    regionName - Name of online HRegion to return
    
    Returns:
    
    HRegion for regionName
    
    Throws:
    
    NotServingRegionException
  - getRegionByEncodedName
```
public HRegion getRegionByEncodedName(String encodedRegionName)
                               throws NotServingRegionException
```
    Throws:
    
    NotServingRegionException
  - getRegionByEncodedName
```
protected HRegion getRegionByEncodedName(byte[] regionName,
                                         String encodedRegionName)
                                  throws NotServingRegionException
```
    Throws:
    
    NotServingRegionException
  - cleanup
```
private Throwable cleanup(Throwable t,
                          String msg)
```
  - convertThrowableToIOE
```
protected IOException convertThrowableToIOE(Throwable t,
                                            String msg)
```
  - checkFileSystem
```
public boolean checkFileSystem()
```
    Checks to see if the file system is still accessible. If not, sets abortRequested and stopRequested
    
    Returns:
    
    false if file system is not available
  - updateRegionFavoredNodesMapping
```
public void updateRegionFavoredNodesMapping(String encodedRegionName,
                                            List<org.apache.hadoop.hbase.shaded.protobuf.generated.HBaseProtos.ServerName> favoredNodes)
```
    Description copied from interface: FavoredNodesForRegion
    
    Used to update the favored nodes mapping when required.
    
    Specified by:
    
    updateRegionFavoredNodesMapping in interface FavoredNodesForRegion
  - getFavoredNodesForRegion
```
public InetSocketAddress[] getFavoredNodesForRegion(String encodedRegionName)
```
    Return the favored nodes for a region given its encoded name. Look at the comment around regionFavoredNodesMap on why it is InetSocketAddress[]
    
    Specified by:
    
    getFavoredNodesForRegion in interface FavoredNodesForRegion
    
    Parameters:
    
    encodedRegionName -
    
    Returns:
    
    array of favored locations
  - getNonceManager
```
public ServerNonceManager getNonceManager()
```
    Description copied from interface: RegionServerServices
    
    Only required for "old" log replay; if it's removed, remove this.
    
    Specified by:
    
    getNonceManager in interface RegionServerServices
    
    Returns:
    
    The RegionServer's NonceManager
  - addToMovedRegions
```
protected void addToMovedRegions(String encodedName,
                                 ServerName destination,
                                 long closeSeqNum)
```
  - removeFromMovedRegions
```
void removeFromMovedRegions(String encodedName)
```
  - getMovedRegion
```
private HRegionServer.MovedRegionInfo getMovedRegion(String encodedRegionName)
```
  - cleanMovedRegions
```
protected void cleanMovedRegions()
```
    Remove the expired entries from the moved regions list.
  - movedRegionCleanerPeriod
```
protected int movedRegionCleanerPeriod()
```
  - getMyEphemeralNodePath
```
private String getMyEphemeralNodePath()
```
  - isHealthCheckerConfigured
```
private boolean isHealthCheckerConfigured()
```
  - getCompactSplitThread
```
public CompactSplit getCompactSplitThread()
```
    Returns:
    
    the underlying CompactSplit for the servers
  - execRegionServerService
```
public org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.CoprocessorServiceResponse execRegionServerService(org.apache.hbase.thirdparty.com.google.protobuf.RpcController controller,
                                                                                                                         org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.CoprocessorServiceRequest serviceRequest)
                                                                                                                  throws org.apache.hbase.thirdparty.com.google.protobuf.ServiceException
```
    Throws:
    
    org.apache.hbase.thirdparty.com.google.protobuf.ServiceException
  - getCacheConfig
```
public CacheConfig getCacheConfig()
```
    Returns:
    
    The cache config instance used by the regionserver.
  - getConfigurationManager
```
protected ConfigurationManager getConfigurationManager()
```
    Returns:
    
    : Returns the ConfigurationManager object for testing purposes.
  - getTableDescriptors
```
public TableDescriptors getTableDescriptors()
```
    Returns:
    
    Return table descriptors implementation.
  - updateConfiguration
```
public void updateConfiguration()
```
    Reload the configuration from disk.
  - clearRegionBlockCache
```
public CacheEvictionStats clearRegionBlockCache(Region region)
```
  - getCompactionPressure
```
public double getCompactionPressure()
```
    Specified by:
    
    getCompactionPressure in interface RegionServerServices
    
    Returns:
    
    the max compaction pressure of all stores on this regionserver. The value should be greater than or equal to 0.0, and any value greater than 1.0 means we enter the emergency state that some stores have too many store files.
    
    See Also:
    
    Store.getCompactionPressure()
  - getHeapMemoryManager
```
public HeapMemoryManager getHeapMemoryManager()
```
    Specified by:
    
    getHeapMemoryManager in interface RegionServerServices
    
    Returns:
    
    heap memory manager instance
  - walRollRequestFinished
```
public boolean walRollRequestFinished()
```
    For testing
    
    Returns:
    
    whether all wal roll request finished for this regionserver
  - getFlushThroughputController
```
public ThroughputController getFlushThroughputController()
```
    Specified by:
    
    getFlushThroughputController in interface RegionServerServices
    
    Returns:
    
    the controller to avoid flush too fast
  - getFlushPressure
```
public double getFlushPressure()
```
    Specified by:
    
    getFlushPressure in interface RegionServerServices
    
    Returns:
    
    the flush pressure of all stores on this regionserver. The value should be greater than or equal to 0.0, and any value greater than 1.0 means we enter the emergency state that global memstore size already exceeds lower limit.
  - onConfigurationChange
```
public void onConfigurationChange(org.apache.hadoop.conf.Configuration newConf)
```
    Description copied from interface: ConfigurationObserver
    
    This method would be called by the ConfigurationManager object when the Configuration object is reloaded from disk.
    
    Specified by:
    
    onConfigurationChange in interface ConfigurationObserver
  - getMetrics
```
public MetricsRegionServer getMetrics()
```
    Specified by:
    
    getMetrics in interface RegionServerServices
    
    Returns:
    
    the metrics tracker for the region server
  - getSecureBulkLoadManager
```
public SecureBulkLoadManager getSecureBulkLoadManager()
```
    Specified by:
    
    getSecureBulkLoadManager in interface RegionServerServices
    
    Returns:
    
    RegionServer's instance of SecureBulkLoadManager
  - regionLock
```
public EntityLock regionLock(List<RegionInfo> regionInfos,
                             String description,
                             Abortable abort)
                      throws IOException
```
    Description copied from interface: RegionServerServices
    
    Master based locks on namespaces/tables/regions.
    
    Specified by:
    
    regionLock in interface RegionServerServices
    
    Throws:
    
    IOException
  - unassign
```
public void unassign(byte[] regionName)
              throws IOException
```
    Description copied from interface: RegionServerServices
    
    Unassign the given region from the current regionserver and assign it randomly. Could still be assigned to us. This is used to solve some tough problems for which you need to reset the state of a region. For example, if you hit FileNotFound exception and want to refresh the store file list.
    See HBASE-17712 for more details.
    
    Specified by:
    
    unassign in interface RegionServerServices
    
    Throws:
    
    IOException
  - getRegionServerSpaceQuotaManager
```
public RegionServerSpaceQuotaManager getRegionServerSpaceQuotaManager()
```
    Specified by:
    
    getRegionServerSpaceQuotaManager in interface RegionServerServices
    
    Returns:
    
    RegionServer's instance of RegionServerSpaceQuotaManager
  - getEventLoopGroupConfig
```
public NettyEventLoopGroupConfig getEventLoopGroupConfig()
```
  - createConnection
```
public Connection createConnection(org.apache.hadoop.conf.Configuration conf)
                            throws IOException
```
    Specified by:
    
    createConnection in interface Server
    
    Throws:
    
    IOException

Class HRegionServer

Nested Class Summary

Nested classes/interfaces inherited from interface org.apache.hadoop.hbase.regionserver.RegionServerServices

Field Summary

Constructor Summary

Method Summary

Methods inherited from class org.apache.hadoop.hbase.util.HasThread

Methods inherited from class java.lang.Object

Field Detail

INIT_PAUSE_TIME_MS

LOG

TEST_SKIP_REPORTING_TRANSITION

regionsInTransitionInRS

cacheFlusher

hMemManager

clusterConnection

metaTableLocator

tableDescriptors

replicationSourceHandler

replicationSinkHandler

compactSplitThread

onlineRegions

regionFavoredNodesMap

leases

executorService

fsOk

fs

walFs

stopped

abortRequested

ABORT_TIMEOUT

DEFAULT_ABORT_TIMEOUT

ABORT_TIMEOUT_TASK

rowlocks

stopping

killed

conf

rootDir

walRootDir

lock

numRetries

threadWakeFrequency

msgInterval

numRegionsToReport

rssStub

lockStub

rpcClient

rpcRetryingCallerFactory

rpcControllerFactory

uncaughtExceptionHandler

infoServer

pauseMonitor

REGIONSERVER

metricsRegionServer

metricsTable

spanReceiverHost

choreService

compactionChecker

periodicFlusher

walFactory

walRoller

online

zooKeeper

masterAddressTracker

clusterStatusTracker

splitLogWorker

sleeper

operationTimeout

shortOperationTimeout

regionServerAccounting

cacheConfig

mobCacheConfig

healthCheckChore

nonceManagerChore

coprocessorServiceHandlers

serverName

useThisHostnameInstead

RS_HOSTNAME_KEY

MASTER_HOSTNAME_KEY

RS_HOSTNAME_DISABLE_MASTER_REVERSEDNS_KEY