HRegionServer (Apache HBase 1.2.12 API)

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

All Implemented Interfaces:

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

Direct Known Subclasses:

HMaster
```
@InterfaceAudience.LimitedPrivate(value="Tools")
public class HRegionServer
extends HasThread
implements RegionServerServices, LastSequenceId
```
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`

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
`private boolean`	`abortRequested`
`protected CacheConfig`	`cacheConfig`
`protected MemStoreFlusher`	`cacheFlusher`
`private ChoreService`	`choreService` ChoreService used to schedule tasks that we want to run periodically
`protected static String`	`CLOSE`
`protected ClusterConnection`	`clusterConnection` Cluster connection to be shared by services.
`private String`	`clusterId` Unique identifier for the cluster we are a part of.
`protected ClusterStatusTracker`	`clusterStatusTracker`
`(package private) ScheduledChore`	`compactionChecker`
`CompactSplitThread`	`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 BaseCoordinatedStateManager`	`csm`
`protected HFileSystem`	`fs`
`protected boolean`	`fsOk`
`private HealthCheckChore`	`healthCheckChore` The health check chore.
`protected HeapMemoryManager`	`hMemManager`
`protected InfoServer`	`infoServer`
`private boolean`	`killed`
`protected Leases`	`leases`
`protected ReentrantReadWriteLock`	`lock`
`private static org.apache.commons.logging.Log`	`LOG`
`protected static String`	`MASTER_HOSTNAME_KEY`
`private MasterAddressTracker`	`masterAddressTracker`
`protected MetaTableLocator`	`metaTableLocator`
`(package private) AtomicReference<LogRoller>`	`metawalRoller`
`(package private) MetricsRegionServer`	`metricsRegionServer`
`protected Map<String,HRegionServer.MovedRegionInfo>`	`movedRegions`
`private HRegionServer.MovedRegionsCleaner`	`movedRegionsCleaner` Chore to clean periodically the moved region list
`protected int`	`msgInterval`
`private ObjectName`	`mxBean` MX Bean for RegionServerInfo
`(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,Region>`	`onlineRegions` Map of regions currently being served by this region server.
`protected static String`	`OPEN`
`private int`	`operationTimeout`
`private JvmPauseMonitor`	`pauseMonitor`
`(package private) ScheduledChore`	`periodicFlusher`
`protected Map<String,Region>`	`recoveringRegions` Set of regions currently being in recovering state which means it can accept writes(edits from previous failed region server) but not reads.
`private RecoveringRegionWatcher`	`recoveringRegionWatcher`
`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_KEY`
`private RegionServerCoprocessorHost`	`rsHost`
`private RegionServerProcedureManagerHost`	`rspmHost`
`private RegionServerQuotaManager`	`rsQuotaManager`
`private org.apache.hadoop.hbase.protobuf.generated.RegionServerStatusProtos.RegionServerStatusService.BlockingInterface`	`rssStub`
`protected ServerName`	`serverName` The server name the Master sees us as.
`protected ExecutorService`	`service`
`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.
`protected TableLockManager`	`tableLockManager`
`protected int`	`threadWakeFrequency`
`private static int`	`TIMEOUT_REGION_MOVED`
`private Thread.UncaughtExceptionHandler`	`uncaughtExceptionHandler`
`private static byte[]`	`UNSPECIFIED_REGION`
`private UserProvider`	`userProvider`
`protected String`	`useThisHostnameInstead`
`private boolean`	`useZKForAssignment`
`protected WALFactory`	`walFactory`
`(package private) LogRoller`	`walRoller`
`protected ZooKeeperWatcher`	`zooKeeper`

Constructor Summary

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

Method Summary

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.
`protected void`	`addToMovedRegions(String encodedName, ServerName destination, long closeSeqNum)`
`void`	`addToOnlineRegions(Region region)` Add to online regions.
`private boolean`	`areAllUserRegionsOffline()`
`private void`	`blockAndCheckIfStopped(ZooKeeperNodeTracker 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.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)`
`protected void`	`closeAllRegions(boolean abort)` Closes all regions.
`(package private) void`	`closeMetaTableRegions(boolean abort)` Close meta region if we carry it
`protected boolean`	`closeRegion(String encodedName, boolean abort, CloseRegionCoordination.CloseRegionDetails crd, ServerName sn)` Close asynchronously a region, can be called from the master or internally by the regionserver when stopping.
`private void`	`closeRegionIgnoreErrors(HRegionInfo 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, CoordinatedStateManager cp)` Utility for constructing an instance of the passed HRegionServer class.
`private boolean`	`containsMetaTableRegions()`
`protected IOException`	`convertThrowableToIOE(Throwable t, String msg)`
`protected ClusterConnection`	`createClusterConnection()` Create a 'smarter' HConnection, one that is capable of by-passing RPC if the request is to the local server.
`private void`	`createMyEphemeralNode()`
`private static void`	`createNewReplicationInstance(org.apache.hadoop.conf.Configuration conf, HRegionServer server, org.apache.hadoop.fs.FileSystem fs, org.apache.hadoop.fs.Path logDir, org.apache.hadoop.fs.Path oldLogDir)` Load the replication service objects, if any
`private org.apache.hadoop.hbase.protobuf.generated.ClusterStatusProtos.RegionLoad`	`createRegionLoad(Region r, org.apache.hadoop.hbase.protobuf.generated.ClusterStatusProtos.RegionLoad.Builder regionLoadBldr, org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.RegionSpecifier.Builder regionSpecifier)`
`org.apache.hadoop.hbase.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()`
`protected LogRoller`	`ensureMetaWALRoller()` We initialize the roller for the wal that handles meta lazily since we don't know if this regionserver will handle it.
`org.apache.hadoop.hbase.protobuf.generated.ClientProtos.CoprocessorServiceResponse`	`execRegionServerService(com.google.protobuf.RpcController controller, org.apache.hadoop.hbase.protobuf.generated.ClientProtos.CoprocessorServiceRequest serviceRequest)`
`CacheConfig`	`getCacheConfig()`
`ChoreService`	`getChoreService()`
`String`	`getClusterId()`
`double`	`getCompactionPressure()`
`CompactionRequestor`	`getCompactionRequester()`
`CompactSplitThread`	`getCompactSplitThread()`
`org.apache.hadoop.conf.Configuration`	`getConfiguration()` Gets the configuration object for this server.
`protected ConfigurationManager`	`getConfigurationManager()`
`ClusterConnection`	`getConnection()` Returns a reference to the servers' cluster connection.
`BaseCoordinatedStateManager`	`getCoordinatedStateManager()` Get CoordinatedStateManager instance for this server.
`(package private) SortedMap<Long,Region>`	`getCopyOfOnlineRegionsSortedBySize()`
`protected Class<? extends javax.servlet.http.HttpServlet>`	`getDumpServlet()`
`ExecutorService`	`getExecutorService()`
`InetSocketAddress[]`	`getFavoredNodesForRegion(String encodedRegionName)` Return the favored nodes for a region given its encoded name.
`org.apache.hadoop.fs.FileSystem`	`getFileSystem()`
`FlushRequester`	`getFlushRequester()`
`Region`	`getFromOnlineRegions(String encodedRegionName)` Return `Region` instance.
`HeapMemoryManager`	`getHeapMemoryManager()`
`InfoServer`	`getInfoServer()`
`private String`	`getLastFailedRSFromZK(String encodedRegionName)` Return the last failed RS name under /hbase/recovering-regions/encodedRegionName
`org.apache.hadoop.hbase.protobuf.generated.ClusterStatusProtos.RegionStoreSequenceIds`	`getLastSequenceId(byte[] encodedRegionName)`
`Leases`	`getLeases()`
`MasterAddressTracker`	`getMasterAddressTracker()`
`MetaTableLocator`	`getMetaTableLocator()` Returns instance of `MetaTableLocator` running inside this server.
`protected HRegionInfo[]`	`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()`
`Region`	`getOnlineRegion(byte[] regionName)`
`List<Region>`	`getOnlineRegions(TableName tableName)` Gets the online regions of the specified table.
`(package private) String`	`getOnlineRegionsAsPrintableString()`
`Collection<Region>`	`getOnlineRegionsLocalContext()` For tests, web ui and metrics.
`Set<TableName>`	`getOnlineTables()` Gets the online tables in this RS.
`protected String`	`getProcessName()`
`Map<String,Region>`	`getRecoveringRegions()`
`protected Region`	`getRegion(byte[] regionName)` Protected utility method for safely obtaining an HRegion handle.
`InetSocketAddress[]`	`getRegionBlockLocations(String encodedRegionName)`
`protected Region`	`getRegionByEncodedName(byte[] regionName, String encodedRegionName)`
`Region`	`getRegionByEncodedName(String encodedRegionName)`
`RegionServerAccounting`	`getRegionServerAccounting()`
`RegionServerCoprocessorHost`	`getRegionServerCoprocessorHost()`
`String[]`	`getRegionServerCoprocessors()`
`MetricsRegionServer`	`getRegionServerMetrics()`
`RegionServerQuotaManager`	`getRegionServerQuotaManager()`
`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()`
`ServerName`	`getServerName()`
`long`	`getStartcode()`
`TableDescriptors`	`getTableDescriptors()`
`TableLockManager`	`getTableLockManager()`
`int`	`getThreadWakeFrequency()` Interval at which threads should run
`WAL`	`getWAL(HRegionInfo regionInfo)`
`(package private) ReentrantReadWriteLock.WriteLock`	`getWriteLock()`
`private long`	`getWriteRequestCount()`
`ZooKeeperWatcher`	`getZooKeeper()` Gets the ZooKeeper instance for this server.
`protected void`	`handleReportForDutyResponse(org.apache.hadoop.hbase.protobuf.generated.RegionServerStatusProtos.RegionServerStartupResponse c)`
`private void`	`initializeFileSystem()`
`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.
`private 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 ReplicationService`	`newReplicationInstance(String classname, org.apache.hadoop.conf.Configuration conf, HRegionServer server, org.apache.hadoop.fs.FileSystem fs, org.apache.hadoop.fs.Path logDir, org.apache.hadoop.fs.Path oldLogDir)`
`void`	`postOpenDeployTasks(Region r)` Tasks to perform after region open to complete deploy of region on regionserver
`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.
`private int`	`putUpWebUI()` Puts up the webui.
`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`	`removeFromOnlineRegions(Region r, ServerName destination)` This method removes Region corresponding to hri from the Map of onlineRegions.
`private org.apache.hadoop.hbase.protobuf.generated.RegionServerStatusProtos.RegionServerStartupResponse`	`reportForDuty()`
`boolean`	`reportRegionStateTransition(RegionServerServices.RegionStateTransitionContext context)` Notify master that a handler requests to change a region state
`boolean`	`reportRegionStateTransition(org.apache.hadoop.hbase.protobuf.generated.RegionServerStatusProtos.RegionStateTransition.TransitionCode code, HRegionInfo... hris)` Notify master that a handler requests to change a region state
`boolean`	`reportRegionStateTransition(org.apache.hadoop.hbase.protobuf.generated.RegionServerStatusProtos.RegionStateTransition.TransitionCode code, long openSeqNum, HRegionInfo... hris)` 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 WALFactory`	`setupWALAndReplication()` Setup WAL log and replication if enabled.
`protected boolean`	`shouldUseThisHostnameInstead()`
`private void`	`shutdownWAL(boolean close)`
`private boolean`	`sleep(long millis)`
`private void`	`startHeapMemoryManager()`
`private void`	`startServiceThreads()`
`void`	`stop(String msg)` Stop this service.
`void`	`stop(String msg, boolean force)` 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`	`updateConfiguration()` Reload the configuration from disk.
`private void`	`updateRecoveringRegionLastFlushedSequenceId(Region r)` A helper function to store the last flushed sequence Id with the previous failed RS for a recovering region.
`void`	`updateRegionFavoredNodesMapping(String encodedRegionName, List<org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.ServerName> favoredNodes)` Used to update the favored nodes mapping when required.
`protected void`	`waitForMasterActive()`
`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
  - LOG
```
private static final org.apache.commons.logging.Log LOG
```
  - OPEN
```
protected static final String OPEN
```
    See Also:
    Constant Field Values
  - CLOSE
```
protected static final String CLOSE
```
    See Also:
    Constant Field Values
  - 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.
  - metaTableLocator
```
protected MetaTableLocator metaTableLocator
```
  - recoveringRegionWatcher
```
private RecoveringRegionWatcher recoveringRegionWatcher
```
  - tableDescriptors
```
protected TableDescriptors tableDescriptors
```
    Go here to get table descriptors.
  - replicationSourceHandler
```
protected ReplicationSourceService replicationSourceHandler
```
  - replicationSinkHandler
```
protected ReplicationSinkService replicationSinkHandler
```
  - compactSplitThread
```
public CompactSplitThread compactSplitThread
```
  - onlineRegions
```
protected final Map<String,Region> 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.
  - recoveringRegions
```
protected final Map<String,Region> recoveringRegions
```
    Set of regions currently being in recovering state which means it can accept writes(edits from previous failed region server) but not reads. A recovering region is also an online region.
  - leases
```
protected Leases leases
```
  - service
```
protected ExecutorService service
```
  - fsOk
```
protected volatile boolean fsOk
```
  - fs
```
protected HFileSystem fs
```
  - stopped
```
private volatile boolean stopped
```
  - abortRequested
```
private volatile boolean abortRequested
```
  - rowlocks
```
ConcurrentMap<String,Integer> rowlocks
```
  - stopping
```
private boolean stopping
```
  - killed
```
private volatile boolean killed
```
  - conf
```
protected final org.apache.hadoop.conf.Configuration conf
```
  - rootDir
```
private org.apache.hadoop.fs.Path rootDir
```
  - 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.protobuf.generated.RegionServerStatusProtos.RegionServerStatusService.BlockingInterface rssStub
```
  - 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
```
  - spanReceiverHost
```
private SpanReceiverHost spanReceiverHost
```
  - choreService
```
private final 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
```
final LogRoller walRoller
```
  - metawalRoller
```
final AtomicReference<LogRoller> metawalRoller
```
  - online
```
final AtomicBoolean online
```
  - zooKeeper
```
protected ZooKeeperWatcher zooKeeper
```
  - masterAddressTracker
```
private MasterAddressTracker masterAddressTracker
```
  - clusterStatusTracker
```
protected 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
```
  - 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
  - startcode
```
protected final long startcode
```
    This servers startcode.
  - clusterId
```
private String clusterId
```
    Unique identifier for the cluster we are a part of.
  - mxBean
```
private ObjectName mxBean
```
    MX Bean for RegionServerInfo
  - 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 RegionServerQuotaManager rsQuotaManager
```
  - tableLockManager
```
protected TableLockManager tableLockManager
```
  - 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 BaseCoordinatedStateManager csm
```
  - useZKForAssignment
```
private final boolean useZKForAssignment
```
  - 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.
  - UNSPECIFIED_REGION
```
private static final byte[] UNSPECIFIED_REGION
```
  - 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,
                     InterruptedException
```
    Starts a HRegionServer at the default location.
    
    Throws:
    
    IOException
    
    InterruptedException
  - HRegionServer
```
public HRegionServer(org.apache.hadoop.conf.Configuration conf,
             CoordinatedStateManager csm)
              throws IOException,
                     InterruptedException
```
    Starts a HRegionServer at the default location
    
    Parameters:
    csm - implementation of CoordinatedStateManager to be used
    
    Throws:
    
    IOException
    
    InterruptedException
- Method Detail
  - initializeFileSystem
```
private void initializeFileSystem()
                           throws IOException
```
    Throws:
    
    IOException
  - shouldUseThisHostnameInstead
```
protected boolean shouldUseThisHostnameInstead()
```
  - login
```
protected void login(UserProvider user,
         String host)
              throws IOException
```
    Throws:
    
    IOException
  - waitForMasterActive
```
protected void waitForMasterActive()
```
  - 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' HConnection, one that is capable of by-passing RPC if the request is to the local server. 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.
    
    Throws:
    
    IOException
    
    InterruptedException
  - 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(ZooKeeperNodeTracker 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
```
private boolean isClusterUp()
```
    Returns:
    False if cluster shutdown in progress
  - initializeThreads
```
private void initializeThreads()
                        throws IOException
```
    Throws:
    
    IOException
  - registerConfigurationObservers
```
private void registerConfigurationObservers()
```
  - 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
  - buildServerLoad
```
org.apache.hadoop.hbase.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.protobuf.generated.RegionServerStatusProtos.RegionServerStartupResponse c)
                                    throws IOException
```
    Throws:
    
    IOException
  - 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
  - getTableLockManager
```
public TableLockManager getTableLockManager()
```
    Specified by:
    
    getTableLockManager in interface RegionServerServices
    
    Returns:
    RegionServer's instance of TableLockManager
  - createRegionLoad
```
private org.apache.hadoop.hbase.protobuf.generated.ClusterStatusProtos.RegionLoad createRegionLoad(Region r,
                                                                                         org.apache.hadoop.hbase.protobuf.generated.ClusterStatusProtos.RegionLoad.Builder regionLoadBldr,
                                                                                         org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.RegionSpecifier.Builder regionSpecifier)
                                                                                            throws IOException
```
    Throws:
    
    IOException
  - createRegionLoad
```
public org.apache.hadoop.hbase.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 service threads, etc.). This method is designed mostly to be useful in tests.
    
    Returns:
    true if online, false if not.
  - setupWALAndReplication
```
private WALFactory 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.
    
    Returns:
    A WAL instance.
    
    Throws:
    
    IOException
  - ensureMetaWALRoller
```
protected LogRoller ensureMetaWALRoller()
```
    We initialize the roller for the wal that handles meta lazily since we don't know if this regionserver will handle it. All calls to this method return a reference to the that same roller. As newly referenced meta regions are brought online, they will be offered to the roller for maintenance. As a part of that registration process, the roller will add itself as a listener on the wal.
  - getRegionServerMetrics
```
public MetricsRegionServer getRegionServerMetrics()
```
  - getMasterAddressTracker
```
public MasterAddressTracker getMasterAddressTracker()
```
    Returns:
    Master address tracker instance.
  - startServiceThreads
```
private void startServiceThreads()
                          throws IOException
```
    Throws:
    
    IOException
  - 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()
```
  - getWAL
```
public WAL getWAL(HRegionInfo 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
  - getConnection
```
public ClusterConnection getConnection()
```
    Description copied from interface: Server
    
    Returns a reference to the servers' cluster 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
  - 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.
    
    Specified by:
    
    stop in interface Stoppable
    
    Parameters:
    msg - Why we're stopping.
  - stop
```
public void stop(String msg,
        boolean force)
```
    Stops the regionserver.
    
    Parameters:
    msg - Status message
    force - True if this is a regionserver abort
  - waitForServerOnline
```
public void waitForServerOnline()
```
  - postOpenDeployTasks
```
public void postOpenDeployTasks(Region r)
                         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:
    r - Region to open.
    
    Throws:
    
    org.apache.zookeeper.KeeperException
    
    IOException
  - 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(org.apache.hadoop.hbase.protobuf.generated.RegionServerStatusProtos.RegionStateTransition.TransitionCode code,
                                  HRegionInfo... hris)
```
    Description copied from interface: RegionServerServices
    
    Notify master that a handler requests to change a region state
    
    Specified by:
    
    reportRegionStateTransition in interface RegionServerServices
  - reportRegionStateTransition
```
public boolean reportRegionStateTransition(org.apache.hadoop.hbase.protobuf.generated.RegionServerStatusProtos.RegionStateTransition.TransitionCode code,
                                  long openSeqNum,
                                  HRegionInfo... hris)
```
    Description copied from interface: RegionServerServices
    
    Notify master that a handler requests to change a region state
    
    Specified by:
    
    reportRegionStateTransition in interface RegionServerServices
  - 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 service.
  - getReplicationSinkService
```
ReplicationSinkService getReplicationSinkService()
```
    Returns:
    Return the object that implements the replication sink service.
  - 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.protobuf.generated.RegionServerStatusProtos.RegionServerStartupResponse reportForDuty()
                                                                                                               throws IOException
```
    Throws:
    
    IOException
  - getLastSequenceId
```
public org.apache.hadoop.hbase.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 RegionServerServices
    
    Returns:
    True if this regionserver is stopping.
  - getRecoveringRegions
```
public Map<String,Region> getRecoveringRegions()
```
    Specified by:
    
    getRecoveringRegions in interface RegionServerServices
    
    Returns:
    set of recovering regions on the hosting region server
  - 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<Region> 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.
  - addToOnlineRegions
```
public void addToOnlineRegions(Region region)
```
    Description copied from interface: OnlineRegions
    
    Add to online regions.
    
    Specified by:
    
    addToOnlineRegions in interface OnlineRegions
  - getCopyOfOnlineRegionsSortedBySize
```
SortedMap<Long,Region> getCopyOfOnlineRegionsSortedBySize()
```
    Returns:
    A new Map of online regions sorted by region 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
  - getMostLoadedRegions
```
protected HRegionInfo[] 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 RegionServerServices
    
    Returns:
    Return the fs.
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - getThreadWakeFrequency
```
public int getThreadWakeFrequency()
```
    Interval at which threads should run
    
    Returns:
    the interval
  - getZooKeeper
```
public ZooKeeperWatcher getZooKeeper()
```
    Description copied from interface: Server
    
    Gets the ZooKeeper instance for this server.
    
    Specified by:
    
    getZooKeeper in interface Server
  - getCoordinatedStateManager
```
public BaseCoordinatedStateManager 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.
  - getCompactionRequester
```
public CompactionRequestor getCompactionRequester()
```
    Specified by:
    
    getCompactionRequester in interface RegionServerServices
    
    Returns:
    Implementation of CompactionRequestor or null.
  - 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
  - getRegionServerQuotaManager
```
public RegionServerQuotaManager getRegionServerQuotaManager()
```
    Specified by:
    
    getRegionServerQuotaManager in interface RegionServerServices
    
    Returns:
    RegionServer's instance of RegionServerQuotaManager
  - createNewReplicationInstance
```
private static void createNewReplicationInstance(org.apache.hadoop.conf.Configuration conf,
                                HRegionServer server,
                                org.apache.hadoop.fs.FileSystem fs,
                                org.apache.hadoop.fs.Path logDir,
                                org.apache.hadoop.fs.Path oldLogDir)
                                          throws IOException
```
    Load the replication service objects, if any
    
    Throws:
    
    IOException
  - newReplicationInstance
```
private static ReplicationService newReplicationInstance(String classname,
                                        org.apache.hadoop.conf.Configuration conf,
                                        HRegionServer server,
                                        org.apache.hadoop.fs.FileSystem fs,
                                        org.apache.hadoop.fs.Path logDir,
                                        org.apache.hadoop.fs.Path oldLogDir)
                                                  throws IOException
```
    Throws:
    
    IOException
  - constructRegionServer
```
public static HRegionServer constructRegionServer(Class<? extends HRegionServer> regionServerClass,
                                  org.apache.hadoop.conf.Configuration conf2,
                                  CoordinatedStateManager cp)
```
    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
  - getOnlineRegions
```
public List<Region> getOnlineRegions(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:
    
    getOnlineRegions in interface OnlineRegions
    
    Parameters:
    tableName -
    
    Returns:
    Online regions from tableName
  - getOnlineTables
```
public Set<TableName> getOnlineTables()
```
    Gets the online tables in this RS. This method looks at the in-memory onlineRegions.
    
    Specified by:
    
    getOnlineTables in interface RegionServerServices
    
    Returns:
    all the online tables in this RS
  - getRegionServerCoprocessors
```
public String[] getRegionServerCoprocessors()
```
  - closeRegionIgnoreErrors
```
private void closeRegionIgnoreErrors(HRegionInfo 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,
                  CloseRegionCoordination.CloseRegionDetails crd,
                  ServerName sn)
                       throws NotServingRegionException,
                              RegionAlreadyInTransitionException
```
    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
    crd - details about closing region coordination-coordinated task
    
    Returns:
    True if closed a region.
    
    Throws:
    
    NotServingRegionException - if the region is not online
    
    RegionAlreadyInTransitionException - if the region is already closing
  - getOnlineRegion
```
public Region getOnlineRegion(byte[] regionName)
```
    Parameters:
    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)
```
  - getFromOnlineRegions
```
public Region getFromOnlineRegions(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:
    
    getFromOnlineRegions in interface OnlineRegions
    
    Returns:
    Region for the passed encoded encodedRegionName or null if named region is not member of the online regions.
  - removeFromOnlineRegions
```
public boolean removeFromOnlineRegions(Region r,
                              ServerName destination)
```
    Description copied from interface: OnlineRegions
    
    This method removes Region corresponding to hri from the Map of onlineRegions.
    
    Specified by:
    
    removeFromOnlineRegions in interface OnlineRegions
    
    Parameters:
    r - Region to remove.
    destination - Destination, if any, null otherwise.
    
    Returns:
    True if we removed a region from online list.
  - getRegion
```
protected Region getRegion(byte[] regionName)
                    throws NotServingRegionException
```
    Protected utility method for safely obtaining an HRegion handle.
    
    Parameters:
    regionName - Name of online Region to return
    
    Returns:
    Region for regionName
    
    Throws:
    
    NotServingRegionException
  - getRegionByEncodedName
```
public Region getRegionByEncodedName(String encodedRegionName)
                              throws NotServingRegionException
```
    Throws:
    
    NotServingRegionException
  - getRegionByEncodedName
```
protected Region 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.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 CompactSplitThread getCompactSplitThread()
```
    Returns:
    the underlying CompactSplitThread for the servers
  - updateRecoveringRegionLastFlushedSequenceId
```
private void updateRecoveringRegionLastFlushedSequenceId(Region r)
                                                  throws org.apache.zookeeper.KeeperException,
                                                         IOException
```
    A helper function to store the last flushed sequence Id with the previous failed RS for a recovering region. The Id is used to skip wal edits which are flushed. Since the flushed sequence id is only valid for each RS, we associate the Id with corresponding failed RS.
    
    Throws:
    
    org.apache.zookeeper.KeeperException
    
    IOException
  - getLastFailedRSFromZK
```
private String getLastFailedRSFromZK(String encodedRegionName)
                              throws org.apache.zookeeper.KeeperException
```
    Return the last failed RS name under /hbase/recovering-regions/encodedRegionName
    
    Parameters:
    encodedRegionName -
    
    Throws:
    
    org.apache.zookeeper.KeeperException
  - execRegionServerService
```
public org.apache.hadoop.hbase.protobuf.generated.ClientProtos.CoprocessorServiceResponse execRegionServerService(com.google.protobuf.RpcController controller,
                                                                                                         org.apache.hadoop.hbase.protobuf.generated.ClientProtos.CoprocessorServiceRequest serviceRequest)
                                                                                                           throws com.google.protobuf.ServiceException
```
    Throws:
    
    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.
  - getHeapMemoryManager
```
public HeapMemoryManager getHeapMemoryManager()
```
    Specified by:
    
    getHeapMemoryManager in interface RegionServerServices
    
    Returns:
    heap memory manager instance
  - 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()
  - walRollRequestFinished
```
public boolean walRollRequestFinished()
```
    For testing
    
    Returns:
    whether all wal roll request finished for this regionserver

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

LOG

OPEN

CLOSE

regionsInTransitionInRS

cacheFlusher

hMemManager

clusterConnection

metaTableLocator

recoveringRegionWatcher

tableDescriptors

replicationSourceHandler

replicationSinkHandler

compactSplitThread

onlineRegions

regionFavoredNodesMap

recoveringRegions

leases

service

fsOk

fs

stopped

abortRequested

rowlocks

stopping

killed

conf

rootDir

lock

numRetries

threadWakeFrequency

msgInterval

numRegionsToReport

rssStub

rpcClient

rpcRetryingCallerFactory

rpcControllerFactory

uncaughtExceptionHandler

infoServer

pauseMonitor

REGIONSERVER

metricsRegionServer

spanReceiverHost

choreService

compactionChecker

periodicFlusher

walFactory

walRoller

metawalRoller

online

zooKeeper

masterAddressTracker

clusterStatusTracker

splitLogWorker

sleeper

operationTimeout

shortOperationTimeout

regionServerAccounting

cacheConfig

healthCheckChore

nonceManagerChore

coprocessorServiceHandlers

serverName

useThisHostnameInstead

RS_HOSTNAME_KEY

MASTER_HOSTNAME_KEY

startcode

clusterId

mxBean

movedRegionsCleaner

storefileRefresher

rsHost