HRegionServer (Apache HBase 2.5.0 API)

java.lang.Object
- java.lang.Thread
- - 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 Thread
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` Inner class that runs on a long period checking if regions need compaction.
`private static class`	`HRegionServer.MovedRegionInfo`
`private static class`	`HRegionServer.PeriodicMemStoreFlusher`
`private static class`	`HRegionServer.SystemExitWhenAbortTimeout` Force to terminate region server when abort timeout.

Nested classes/interfaces inherited from class java.lang.Thread
Thread.State, Thread.UncaughtExceptionHandler

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
`(package private) static String`	`ABORT_TIMEOUT`
`(package private) static String`	`ABORT_TIMEOUT_TASK`
`private Timer`	`abortMonitor`
`private AtomicBoolean`	`abortRequested`
`private BlockCache`	`blockCache`
`private BrokenStoreFileCleaner`	`brokenStoreFileCleaner`
`private 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`
`private ScheduledChore`	`compactionChecker` Check for compactions requests.
`private int`	`compactionCheckFrequency`
`private 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`
`private CoordinatedStateManager`	`csm`
`private HFileSystem`	`dataFs`
`private boolean`	`dataFsOk`
`private org.apache.hadoop.fs.Path`	`dataRootDir`
`private static long`	`DEFAULT_ABORT_TIMEOUT`
`private NettyEventLoopGroupConfig`	`eventLoopGroupConfig`
`private org.apache.hbase.thirdparty.com.google.common.cache.Cache<Long,Long>`	`executedRegionProcedures` Used to cache the open/close region procedures which already executed.
`protected ExecutorService`	`executorService`
`private int`	`flushCheckFrequency`
`private ThroughputController`	`flushThroughputController`
`private FileSystemUtilizationChore`	`fsUtilizationChore`
`private HealthCheckChore`	`healthCheckChore` The health check chore.
`private HeapMemoryManager`	`hMemManager`
`protected InfoServer`	`infoServer`
`private boolean`	`killed`
`private LeaseManager`	`leaseManager`
`private org.apache.hadoop.hbase.shaded.protobuf.generated.LockServiceProtos.LockService.BlockingInterface`	`lockStub`
`private static org.slf4j.Logger`	`LOG`
`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.
`private static String`	`MASTERLESS_CONFIG_NAME`
`private MetaRegionLocationCache`	`metaRegionLocationCache` Cache for the meta region replica's locations.
`private MetricsRegionServer`	`metricsRegionServer`
`(package private) MetricsRegionServerWrapperImpl`	`metricsRegionServerImpl`
`private MobFileCache`	`mobFileCache`
`private org.apache.hbase.thirdparty.com.google.common.cache.Cache<String,HRegionServer.MovedRegionInfo>`	`movedRegionInfoCache` Used to cache the moved-out regions
`(package private) int`	`msgInterval`
`private NamedQueueRecorder`	`namedQueueRecorder` Provide online slow log responses from ringbuffer
`(package private) ServerNonceManager`	`nonceManager` Nonce manager.
`private ScheduledChore`	`nonceManagerChore` The nonce manager chore.
`(package private) AtomicBoolean`	`online`
`private Map<String,HRegion>`	`onlineRegions` Map of regions currently being served by this region server.
`private ReentrantReadWriteLock`	`onlineRegionsLock` Lock for gating access to `onlineRegions`.
`private int`	`operationTimeout`
`private JvmPauseMonitor`	`pauseMonitor`
`private static String`	`PERIOD_COMPACTION`
`private static String`	`PERIOD_FLUSH`
`private ScheduledChore`	`periodicFlusher` Check for flushes
`private RemoteProcedureResultReporter`	`procedureResultReporter`
`private Map<String,Address[]>`	`regionFavoredNodesMap` Map of encoded region names to the DataNode locations they should be hosted on We store the value as Address since InetSocketAddress is required by the HDFS API (create() that takes favored nodes as hints for placing file blocks).
`static String`	`REGIONSERVER` region server process name
`private static String`	`REGIONSERVER_CODEC` regionserver codec list
`private RegionServerAccounting`	`regionServerAccounting`
`private RegionServerAddressTracker`	`regionServerAddressTracker` Cache for all the region servers in the cluster.
`private ConcurrentMap<byte[],Boolean>`	`regionsInTransitionInRS` A map from RegionName to current action in progress.
`private ReplicationSinkService`	`replicationSinkHandler`
`private ReplicationSourceService`	`replicationSourceHandler`
`private long`	`retryPauseTime`
`private RpcClient`	`rpcClient`
`private RpcControllerFactory`	`rpcControllerFactory`
`private RpcRetryingCallerFactory`	`rpcRetryingCallerFactory`
`protected RSRpcServices`	`rpcServices`
`(package private) static String`	`RS_HOSTNAME_DISABLE_MASTER_REVERSEDNS_KEY` Deprecated. since 2.4.0 and will be removed in 4.0.0. Use `UNSAFE_RS_HOSTNAME_DISABLE_MASTER_REVERSEDNS_KEY` instead.
`private RegionServerCoprocessorHost`	`rsHost`
`private RSMobFileCleanerChore`	`rsMobFileCleanerChore`
`private RegionServerProcedureManagerHost`	`rspmHost`
`private RegionServerRpcQuotaManager`	`rsQuotaManager`
`private RegionServerSpaceQuotaManager`	`rsSpaceQuotaManager`
`private org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.RegionServerStatusService.BlockingInterface`	`rssStub`
`private SecureBulkLoadManager`	`secureBulkLoadManager`
`protected ServerName`	`serverName` The server name the Master sees us as.
`private int`	`shortOperationTimeout`
`private boolean`	`shutDown`
`protected Sleeper`	`sleeper`
`private SlowLogTableOpsChore`	`slowLogTableOpsChore`
`private SplitLogWorker`	`splitLogWorker`
`protected long`	`startcode` This servers startcode.
`private boolean`	`stopped`
`private boolean`	`stopping`
`private StorefileRefresherChore`	`storefileRefresher`
`private ConcurrentMap<Long,Long>`	`submittedRegionProcedures` Used to cache the open/close region procedures which already submitted.
`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 .
`private int`	`threadWakeFrequency`
`private static int`	`TIMEOUT_REGION_MOVED` We need a timeout.
`private Thread.UncaughtExceptionHandler`	`uncaughtExceptionHandler`
`(package private) static String`	`UNSAFE_RS_HOSTNAME_DISABLE_MASTER_REVERSEDNS_KEY` HBASE-18226: This config and hbase.unsafe.regionserver.hostname are mutually exclusive.
`private UserProvider`	`userProvider`
`protected String`	`useThisHostnameInstead` hostname specified by hostname config
`private WALFactory`	`walFactory`
`private HFileSystem`	`walFs`
`private LogRoller`	`walRoller`
`private org.apache.hadoop.fs.Path`	`walRootDir`
`protected ZKWatcher`	`zooKeeper`

Fields inherited from class java.lang.Thread
MAX_PRIORITY, MIN_PRIORITY, NORM_PRIORITY

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, 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.
`private void`	`addToMovedRegions(String encodedName, ServerName destination, long closeSeqNum, boolean selfMove)`
`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(RegionSizeStore regionSizes)` Builds a `RegionServerStatusProtos.RegionSpaceUseReportRequest` protobuf message from the region size map.
`private void`	`buildReportAndSend(org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.RegionServerStatusService.BlockingInterface rss, RegionSizeStore regionSizeStore)` Builds the region size report and sends it to the master.
`private org.apache.hadoop.hbase.shaded.protobuf.generated.ClusterStatusProtos.ServerLoad`	`buildServerLoad(long reportStartTime, long reportEndTime)`
`protected boolean`	`cacheTableDescriptor()`
`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.
`(package private) boolean`	`checkFileSystem()` Checks to see if the file system is still accessible.
`private Throwable`	`cleanup(Throwable t, String msg)` Cleanup after Throwable caught invoking method.
`(package private) CacheEvictionStats`	`clearRegionBlockCache(Region region)`
`private void`	`closeMetaTableRegions(boolean abort)` Close meta region if we carry it
`protected boolean`	`closeRegion(String encodedName, boolean abort, ServerName destination)` 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.
`private void`	`closeUserRegions(boolean abort)` Schedule closes on all user regions.
`protected void`	`configureInfoServer()`
`(package private) static HRegionServer`	`constructRegionServer(Class<? extends HRegionServer> regionServerClass, org.apache.hadoop.conf.Configuration conf)` 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.
`private IOException`	`convertThrowableToIOE(Throwable t, String msg)`
`protected ClusterConnection`	`createClusterConnection()`
`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, WALFactory walFactory)` 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)`
`private 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.
`private org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.ReportRegionStateTransitionRequest`	`createReportRegionStateTransitionRequest(RegionServerServices.RegionStateTransitionContext context)`
`protected RSRpcServices`	`createRpcServices()`
`private org.apache.hadoop.hbase.shaded.protobuf.generated.ClusterStatusProtos.UserLoad`	`createUserLoad(String user, MetricsUserSource userSource)`
`private void`	`deleteMyEphemeralNode()`
`void`	`dumpRowLocks(PrintWriter out)` Used by `RSDumpServlet` to generate debugging information.
`(package private) 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)`
`(package private) void`	`executeProcedure(long procId, RSProcedureCallable callable)`
`void`	`finishRegionProcedure(long procId)` See `submitRegionProcedure(long)`.
`AccessChecker`	`getAccessChecker()` Returns the `AccessChecker`
`Optional<ServerName>`	`getActiveMaster()`
`List<ServerName>`	`getBackupMasters()`
`Optional<BlockCache>`	`getBlockCache()` May be null if this is a master which not carry table.
`BrokenStoreFileCleaner`	`getBrokenStoreFileCleaner()`
`ChoreService`	`getChoreService()` Returns The `ChoreService` instance for this server
`ClusterConnection`	`getClusterConnection()` Returns a reference to the servers' cluster connection.
`String`	`getClusterId()`
`CompactedHFilesDischarger`	`getCompactedHFilesDischarger()`
`double`	`getCompactionPressure()`
`CompactionRequester`	`getCompactionRequestor()`
`CompactSplit`	`getCompactSplitThread()` Returns the underlying `CompactSplit` for the servers
`org.apache.hadoop.conf.Configuration`	`getConfiguration()` Gets the configuration object for this server.
`(package private) ConfigurationManager`	`getConfigurationManager()` Returns : Returns the ConfigurationManager object for testing purposes.
`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 org.apache.hadoop.fs.Path`	`getDataRootDir()` Returns Return the rootDir.
`protected Class<? extends javax.servlet.http.HttpServlet>`	`getDumpServlet()`
`NettyEventLoopGroupConfig`	`getEventLoopGroupConfig()`
`ExecutorService`	`getExecutorService()` Returns hbase executor service
`InetSocketAddress[]`	`getFavoredNodesForRegion(String encodedRegionName)` Return the favored nodes for a region given its encoded name.
`org.apache.hadoop.fs.FileSystem`	`getFileSystem()` Returns Return the FileSystem object used (can return null!).
`double`	`getFlushPressure()`
`FlushRequester`	`getFlushRequester()` Returns reference to FlushRequester
`ThroughputController`	`getFlushThroughputController()` Returns the controller to avoid flush too fast
`HeapMemoryManager`	`getHeapMemoryManager()` Returns heap memory manager instance
`InfoServer`	`getInfoServer()` Returns the info server
`org.apache.hadoop.hbase.shaded.protobuf.generated.ClusterStatusProtos.RegionStoreSequenceIds`	`getLastSequenceId(byte[] encodedRegionName)`
`LeaseManager`	`getLeaseManager()` Returns The RegionServer's "Leases" service
`MasterAddressTracker`	`getMasterAddressTracker()` Returns Master address tracker instance.
`MemStoreFlusher`	`getMemStoreFlusher()`
`MetaRegionLocationCache`	`getMetaRegionLocationCache()`
`MetricsRegionServer`	`getMetrics()` Returns the metrics tracker for the region server
`Optional<MobFileCache>`	`getMobFileCache()` May be null if this is a master which not carry table.
`HRegionServer.MovedRegionInfo`	`getMovedRegion(String encodedRegionName)`
`private String`	`getMyEphemeralNodePath()`
`NamedQueueRecorder`	`getNamedQueueRecorder()` get NamedQueue Provider to add different logs to ringbuffer n
`ServerNonceManager`	`getNonceManager()` Only required for "old" log replay; if it's removed, remove this.
`int`	`getNumberOfOnlineRegions()`
`HRegion`	`getOnlineRegion(byte[] regionName)`
`protected Map<String,HRegion>`	`getOnlineRegions()`
`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.
`private 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()` Returns the RegionServerAccounting for this Region Server
`RegionServerCoprocessorHost`	`getRegionServerCoprocessorHost()`
`String[]`	`getRegionServerCoprocessors()`
`RegionServerRpcQuotaManager`	`getRegionServerRpcQuotaManager()` Returns RegionServer's instance of `RegionServerRpcQuotaManager`
`Iterator<ServerName>`	`getRegionServers()`
`RegionServerSpaceQuotaManager`	`getRegionServerSpaceQuotaManager()` Returns RegionServer's instance of `RegionServerSpaceQuotaManager`
`ConcurrentMap<byte[],Boolean>`	`getRegionsInTransitionInRS()` Get the regions that are currently being opened or closed in the RS
`(package private) ReplicationSinkService`	`getReplicationSinkService()` Returns Return the object that implements the replication sink executorService.
`ReplicationSourceService`	`getReplicationSourceService()` Returns Return the object that implements the replication source executorService.
`long`	`getRetryPauseTime()` Return pause time configured in `HConstants.HBASE_RPC_SHORTOPERATION_RETRY_PAUSE_TIME`}
`RpcServerInterface`	`getRpcServer()` Returns a reference to the region server's RPC server
`RSMobFileCleanerChore`	`getRSMobFileCleanerChore()`
`RSRpcServices`	`getRSRpcServices()`
`SecureBulkLoadManager`	`getSecureBulkLoadManager()` Returns RegionServer's instance of `SecureBulkLoadManager`
`ServerName`	`getServerName()` Returns The unique server name for this server.
`long`	`getStartcode()` Returns time stamp in millis of when this region server was started
`TableDescriptors`	`getTableDescriptors()` Returns Return table descriptors implementation.
`protected String`	`getUseThisHostnameInstead(org.apache.hadoop.conf.Configuration conf)`
`WAL`	`getWAL(RegionInfo regionInfo)` Returns the WAL for a particular region.
`(package private) WALFactory`	`getWalFactory()`
`org.apache.hadoop.fs.FileSystem`	`getWALFileSystem()` Returns Return the walFs.
`Map<String,ReplicationStatus>`	`getWalGroupsReplicationStatus()`
`LogRoller`	`getWalRoller()`
`org.apache.hadoop.fs.Path`	`getWALRootDir()` Returns Return the walRootDir.
`List<WAL>`	`getWALs()` Returns the List of WALs that are used by this server Doesn't include the meta WAL
`private long`	`getWriteRequestCount()` Returns Current write count for all online regions.
`ZKPermissionWatcher`	`getZKPermissionWatcher()` Returns `ZKPermissionWatcher`
`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.
`private void`	`initNamedQueueRecorder(org.apache.hadoop.conf.Configuration conf)`
`boolean`	`isAborted()` Check if the server or client was aborted.
`boolean`	`isClusterUp()` Returns True if the cluster is up.
`(package private) boolean`	`isDataFileSystemOk()` Returns `true` when the data file system is available, `false` otherwise.
`private boolean`	`isHealthCheckerConfigured()`
`private boolean`	`isHealthy()`
`boolean`	`isOnline()` Report the status of the server.
`boolean`	`isShutDown()`
`boolean`	`isStopped()` Returns true if a stop has been requested.
`boolean`	`isStopping()` Returns True is the server is Stopping
`private boolean`	`keepLooping()`
`protected void`	`kill()`
`protected void`	`login(UserProvider user, String host)`
`static void`	`main(String[] args)`
`int`	`movedRegionCacheExpiredTime()`
`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, WALFactory walFactory)`
`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 void`	`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
`void`	`remoteProcedureComplete(long procId, Throwable error)`
`(package private) void`	`removeFromMovedRegions(String encodedName)`
`boolean`	`removeRegion(HRegion r, ServerName destination)` Removes the given Region from the list of onlineRegions.
`boolean`	`reportFileArchivalForQuotas(TableName tableName, Collection<Map.Entry<String,Long>> archivedFiles)` Reports a collection of files, and their sizes, that belonged to the given `table` were just moved to the archive directory.
`private org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.RegionServerStartupResponse`	`reportForDuty()`
`(package private) void`	`reportProcedureDone(org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.ReportProcedureDoneRequest request)`
`boolean`	`reportRegionSizesForQuotas(RegionSizeStore regionSizeStore)` 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
`private static int`	`roundSize(long sizeInByte, int sizeUnit)`
`void`	`run()` The HRegionServer sticks in this loop until closed.
`private void`	`scheduleAbortTimer()`
`protected boolean`	`setAbortRequested()` Sets the abort state if not already set.
`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.
`protected void`	`shutdownChore(ScheduledChore chore)`
`private void`	`shutdownWAL(boolean close)`
`private boolean`	`skipReportingTransition(RegionServerServices.RegionStateTransitionContext context)` Helper method for use in tests.
`private static boolean`	`sleepInterrupted(long millis)`
`private void`	`startHeapMemoryManager()`
`private void`	`startReplicationService()` Start up replication source and sink handlers.
`private void`	`startServices()` Start maintenance Threads, Server, Worker and lease checker threads.
`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.
`(package private) boolean`	`submitRegionProcedure(long procId)` Will ignore the open/close region procedures which already submitted or executed.
`String`	`toString()`
`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.
`(package private) 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 java.lang.Thread
activeCount, checkAccess, clone, countStackFrames, currentThread, destroy, dumpStack, enumerate, getAllStackTraces, getContextClassLoader, getDefaultUncaughtExceptionHandler, getId, getName, getPriority, getStackTrace, getState, getThreadGroup, getUncaughtExceptionHandler, holdsLock, interrupt, interrupted, isAlive, isDaemon, isInterrupted, join, join, join, resume, setContextClassLoader, setDaemon, setDefaultUncaughtExceptionHandler, setName, setPriority, setUncaughtExceptionHandler, sleep, sleep, start, stop, stop, suspend, yield

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

Methods inherited from interface org.apache.hadoop.hbase.Abortable
abort

- Field Detail
  - LOG
```
private static final org.slf4j.Logger LOG
```
  - TEST_SKIP_REPORTING_TRANSITION
```
@InterfaceAudience.Private
public static boolean TEST_SKIP_REPORTING_TRANSITION
```
    For testing only! Set to true to skip notifying region assignment to master .
  - regionsInTransitionInRS
```
private final ConcurrentMap<byte[],Boolean> regionsInTransitionInRS
```
    A map from RegionName to current action in progress. Boolean value indicates: true - if open region action in progress false - if close region action in progress
  - submittedRegionProcedures
```
private final ConcurrentMap<Long,Long> submittedRegionProcedures
```
    Used to cache the open/close region procedures which already submitted. See submitRegionProcedure(long).
  - executedRegionProcedures
```
private final org.apache.hbase.thirdparty.com.google.common.cache.Cache<Long,Long> executedRegionProcedures
```
    Used to cache the open/close region procedures which already executed. See submitRegionProcedure(long).
  - movedRegionInfoCache
```
private final org.apache.hbase.thirdparty.com.google.common.cache.Cache<String,HRegionServer.MovedRegionInfo> movedRegionInfoCache
```
    Used to cache the moved-out regions
  - cacheFlusher
```
private MemStoreFlusher cacheFlusher
```
  - hMemManager
```
private 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.
  - tableDescriptors
```
protected TableDescriptors tableDescriptors
```
    Go here to get table descriptors.
  - replicationSourceHandler
```
private ReplicationSourceService replicationSourceHandler
```
  - replicationSinkHandler
```
private ReplicationSinkService replicationSinkHandler
```
  - compactSplitThread
```
private CompactSplit compactSplitThread
```
  - onlineRegions
```
private 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.
  - onlineRegionsLock
```
private final ReentrantReadWriteLock onlineRegionsLock
```
    Lock for gating access to onlineRegions. TODO: If this map is gated by a lock, does it need to be a ConcurrentHashMap?
  - regionFavoredNodesMap
```
private final Map<String,Address[]> regionFavoredNodesMap
```
    Map of encoded region names to the DataNode locations they should be hosted on We store the value as Address since InetSocketAddress is required by the 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. We don't store it as InetSocketAddress here because the conversion on demand from Address to InetSocketAddress will guarantee the resolution results will be fresh when we need it.
  - leaseManager
```
private LeaseManager leaseManager
```
  - executorService
```
protected ExecutorService executorService
```
  - dataFsOk
```
private volatile boolean dataFsOk
```
  - dataFs
```
private HFileSystem dataFs
```
  - walFs
```
private HFileSystem walFs
```
  - stopped
```
private volatile boolean stopped
```
  - abortRequested
```
private AtomicBoolean abortRequested
```
  - ABORT_TIMEOUT
```
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
```
static final String ABORT_TIMEOUT_TASK
```
    See Also:
    
    Constant Field Values
  - stopping
```
private boolean stopping
```
  - killed
```
private volatile boolean killed
```
  - shutDown
```
private volatile boolean shutDown
```
  - conf
```
protected final org.apache.hadoop.conf.Configuration conf
```
  - dataRootDir
```
private org.apache.hadoop.fs.Path dataRootDir
```
  - walRootDir
```
private org.apache.hadoop.fs.Path walRootDir
```
  - threadWakeFrequency
```
private final int threadWakeFrequency
```
  - msgInterval
```
final int msgInterval
```
  - PERIOD_COMPACTION
```
private static final String PERIOD_COMPACTION
```
    See Also:
    
    Constant Field Values
  - compactionCheckFrequency
```
private final int compactionCheckFrequency
```
  - PERIOD_FLUSH
```
private static final String PERIOD_FLUSH
```
    See Also:
    
    Constant Field Values
  - flushCheckFrequency
```
private final int flushCheckFrequency
```
  - 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
```
private 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
```
private MetricsRegionServer metricsRegionServer
```
  - metricsRegionServerImpl
```
MetricsRegionServerWrapperImpl metricsRegionServerImpl
```
  - choreService
```
private ChoreService choreService
```
    ChoreService used to schedule tasks that we want to run periodically
  - compactionChecker
```
private ScheduledChore compactionChecker
```
    Check for compactions requests.
  - periodicFlusher
```
private ScheduledChore periodicFlusher
```
    Check for flushes
  - walFactory
```
private volatile WALFactory walFactory
```
  - walRoller
```
private LogRoller walRoller
```
  - procedureResultReporter
```
private RemoteProcedureResultReporter procedureResultReporter
```
  - online
```
final AtomicBoolean online
```
  - zooKeeper
```
protected final ZKWatcher zooKeeper
```
  - masterAddressTracker
```
private final MasterAddressTracker masterAddressTracker
```
  - metaRegionLocationCache
```
private final MetaRegionLocationCache metaRegionLocationCache
```
    Cache for the meta region replica's locations. Also tracks their changes to avoid stale cache entries. Used for serving ClientMetaService.
  - regionServerAddressTracker
```
private final RegionServerAddressTracker regionServerAddressTracker
```
    Cache for all the region servers in the cluster. Used for serving ClientMetaService.
  - clusterStatusTracker
```
protected final ClusterStatusTracker clusterStatusTracker
```
  - splitLogWorker
```
private SplitLogWorker splitLogWorker
```
  - sleeper
```
protected final Sleeper sleeper
```
  - operationTimeout
```
private final int operationTimeout
```
  - shortOperationTimeout
```
private final int shortOperationTimeout
```
  - retryPauseTime
```
private final long retryPauseTime
```
  - regionServerAccounting
```
private final RegionServerAccounting regionServerAccounting
```
  - slowLogTableOpsChore
```
private SlowLogTableOpsChore slowLogTableOpsChore
```
  - blockCache
```
private BlockCache blockCache
```
  - mobFileCache
```
private MobFileCache mobFileCache
```
  - 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
```
    hostname specified by hostname config
  - RS_HOSTNAME_DISABLE_MASTER_REVERSEDNS_KEY
```
@Deprecated
 @InterfaceAudience.LimitedPrivate(value="Configuration")
static final String RS_HOSTNAME_DISABLE_MASTER_REVERSEDNS_KEY
```
    Deprecated. since 2.4.0 and will be removed in 4.0.0. Use UNSAFE_RS_HOSTNAME_DISABLE_MASTER_REVERSEDNS_KEY instead.
    
    See Also:
    
    HBASE-24667, Constant Field Values
  - UNSAFE_RS_HOSTNAME_DISABLE_MASTER_REVERSEDNS_KEY
```
@InterfaceAudience.LimitedPrivate(value="Configuration")
static final String UNSAFE_RS_HOSTNAME_DISABLE_MASTER_REVERSEDNS_KEY
```
    HBASE-18226: This config and hbase.unsafe.regionserver.hostname are mutually exclusive. Exception will be thrown if both are used.
    
    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.
  - storefileRefresher
```
private StorefileRefresherChore storefileRefresher
```
  - rsHost
```
private volatile 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
```
private 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.
  - brokenStoreFileCleaner
```
private BrokenStoreFileCleaner brokenStoreFileCleaner
```
  - rsMobFileCleanerChore
```
private RSMobFileCleanerChore rsMobFileCleanerChore
```
  - compactedFileDischarger
```
@InterfaceAudience.Private
CompactedHFilesDischarger compactedFileDischarger
```
  - flushThroughputController
```
private volatile ThroughputController flushThroughputController
```
  - secureBulkLoadManager
```
private SecureBulkLoadManager secureBulkLoadManager
```
  - fsUtilizationChore
```
private FileSystemUtilizationChore fsUtilizationChore
```
  - eventLoopGroupConfig
```
private final NettyEventLoopGroupConfig eventLoopGroupConfig
```
  - namedQueueRecorder
```
private NamedQueueRecorder namedQueueRecorder
```
    Provide online slow log responses from ringbuffer
  - 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. TODO: can this replace TEST_SKIP_REPORTING_TRANSITION ?
  - MASTERLESS_CONFIG_NAME
```
private static final String MASTERLESS_CONFIG_NAME
```
    See Also:
    
    Constant Field Values
  - REGIONSERVER_CODEC
```
private static final String REGIONSERVER_CODEC
```
    regionserver codec list
    
    See Also:
    
    Constant Field Values
  - abortMonitor
```
private Timer abortMonitor
```
  - TIMEOUT_REGION_MOVED
```
private static final int TIMEOUT_REGION_MOVED
```
    We need a timeout. If not there is a risk of giving a wrong information: this would double the number of network calls instead of reducing them.
    
    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.
    Don't start any services or managers in here in the Constructor. Defer till after we register with the Master as much as possible. See startServices().
    
    Throws:
    
    IOException
- Method Detail
  - initNamedQueueRecorder
```
private void initNamedQueueRecorder(org.apache.hadoop.conf.Configuration conf)
```
  - 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
  - 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()
```
  - cacheTableDescriptor
```
protected boolean cacheTableDescriptor()
```
  - createRpcServices
```
protected RSRpcServices createRpcServices()
                                   throws IOException
```
    Throws:
    
    IOException
  - configureInfoServer
```
protected void configureInfoServer()
```
  - getDumpServlet
```
protected Class<? extends javax.servlet.http.HttpServlet> getDumpServlet()
```
  - dumpRowLocks
```
public void dumpRowLocks(PrintWriter out)
```
    Used by RSDumpServlet to generate debugging information.
  - 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
```
    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 - configuration object
    
    Throws:
    
    IOException - if compression test fails for any regionserver codec
  - 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 - if the waiting thread is interrupted
  - isClusterUp
```
public boolean isClusterUp()
```
    Returns True if the cluster is up.
    
    Specified by:
    
    isClusterUp in interface RegionServerServices
  - run
```
public void run()
```
    The HRegionServer sticks in this loop until closed.
    
    Specified by:
    
    run in interface Runnable
    
    Overrides:
    
    run in class Thread
  - containsMetaTableRegions
```
private boolean containsMetaTableRegions()
```
  - areAllUserRegionsOffline
```
private boolean areAllUserRegionsOffline()
```
  - getWriteRequestCount
```
private long getWriteRequestCount()
```
    Returns Current write count for all online regions.
  - tryRegionServerReport
```
@InterfaceAudience.Private
protected void tryRegionServerReport(long reportStartTime,
                                                                long reportEndTime)
                                                         throws IOException
```
    Throws:
    
    IOException
  - reportRegionSizesForQuotas
```
public boolean reportRegionSizesForQuotas(RegionSizeStore regionSizeStore)
```
    Reports the given map of Regions and their size on the filesystem to the active Master.
    
    Specified by:
    
    reportRegionSizesForQuotas in interface RegionServerServices
    
    Parameters:
    
    regionSizeStore - The store containing region sizes
    
    Returns:
    
    false if FileSystemUtilizationChore should pause reporting to master. true otherwise
  - buildReportAndSend
```
private void buildReportAndSend(org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.RegionServerStatusService.BlockingInterface rss,
                                RegionSizeStore regionSizeStore)
                         throws org.apache.hbase.thirdparty.com.google.protobuf.ServiceException
```
    Builds the region size report and sends it to the master. Upon successful sending of the report, the region sizes that were sent are marked as sent.
    
    Parameters:
    
    rss - The stub to send to the Master
    
    regionSizeStore - The store containing region sizes
    
    Throws:
    
    org.apache.hbase.thirdparty.com.google.protobuf.ServiceException
  - buildRegionSpaceUseReportRequest
```
org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.RegionSpaceUseReportRequest buildRegionSpaceUseReportRequest(RegionSizeStore regionSizes)
```
    Builds a RegionServerStatusProtos.RegionSpaceUseReportRequest protobuf message from the region size map.
    
    Parameters:
    
    regionSizes - The size in bytes of regions
    
    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
```
private org.apache.hadoop.hbase.shaded.protobuf.generated.ClusterStatusProtos.ServerLoad buildServerLoad(long reportStartTime,
                                                                                                         long reportEndTime)
                                                                                                  throws IOException
```
    Throws:
    
    IOException
  - getOnlineRegionsAsPrintableString
```
private String getOnlineRegionsAsPrintableString()
```
  - waitOnAllRegionsToClose
```
private void waitOnAllRegionsToClose(boolean abort)
```
    Wait on regions close.
  - sleepInterrupted
```
private static boolean sleepInterrupted(long millis)
```
  - shutdownWAL
```
private void shutdownWAL(boolean close)
```
  - getNamedQueueRecorder
```
public NamedQueueRecorder getNamedQueueRecorder()
```
    get NamedQueue Provider to add different logs to ringbuffer n
  - 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
```
    Throws:
    
    org.apache.zookeeper.KeeperException
  - deleteMyEphemeralNode
```
private void deleteMyEphemeralNode()
                            throws org.apache.zookeeper.KeeperException
```
    Throws:
    
    org.apache.zookeeper.KeeperException
  - getRegionServerAccounting
```
public RegionServerAccounting getRegionServerAccounting()
```
    Description copied from interface: RegionServerServices
    
    Returns the RegionServerAccounting for this Region Server
    
    Specified by:
    
    getRegionServerAccounting in interface RegionServerServices
  - roundSize
```
private static int roundSize(long sizeInByte,
                             int sizeUnit)
```
  - 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
```
    Parameters:
    
    r - Region to get RegionLoad for.
    
    regionLoadBldr - the RegionLoad.Builder, can be null
    
    regionSpecifier - the RegionSpecifier.Builder, can be null
    
    Returns:
    
    RegionLoad instance.
    
    Throws:
    
    IOException
  - createUserLoad
```
private org.apache.hadoop.hbase.shaded.protobuf.generated.ClusterStatusProtos.UserLoad createUserLoad(String user,
                                                                                                      MetricsUserSource userSource)
```
  - createRegionLoad
```
public org.apache.hadoop.hbase.shaded.protobuf.generated.ClusterStatusProtos.RegionLoad createRegionLoad(String encodedRegionName)
                                                                                                  throws IOException
```
    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
  - getMasterAddressTracker
```
public MasterAddressTracker getMasterAddressTracker()
```
    Returns Master address tracker instance.
  - startServices
```
private void startServices()
                    throws IOException
```
    Start maintenance Threads, Server, Worker and lease checker threads. Start all threads we need to run. This is called after we've successfully registered with the Master. Install an UncaughtExceptionHandler that calls abort of RegionServer if we get an unhandled exception. We cannot set the handler on all threads. Server's internal Listener thread is off limits. For Server, if an OOME, it waits a while then retries. Meantime, a flush or a compaction that tries to run should trigger same critical condition and the shutdown will run. On its way out, this server will shut down Server. Leases are sort of inbetween. It has an internal thread that while it inherits from Chore, it keeps its own internal stop mechanism so needs to be stopped by this hosting server. Worker logs the exception and exits.
    
    Throws:
    
    IOException
  - initializeThreads
```
private void initializeThreads()
```
  - registerConfigurationObservers
```
private void registerConfigurationObservers()
```
  - putUpWebUI
```
private void putUpWebUI()
                 throws IOException
```
    Puts up the webui.
    
    Throws:
    
    IOException
  - isHealthy
```
private boolean isHealthy()
```
  - getWALs
```
public List<WAL> getWALs()
```
    Description copied from interface: RegionServerServices
    
    Returns the List of WALs that are used by this server Doesn't include the meta WAL
    
    Specified by:
    
    getWALs in interface RegionServerServices
  - getWAL
```
public WAL getWAL(RegionInfo regionInfo)
           throws IOException
```
    Description copied from interface: RegionServerServices
    
    Returns the WAL for a particular region. Pass null for getting the default (common) WAL
    
    Specified by:
    
    getWAL in interface RegionServerServices
    
    Throws:
    
    IOException
  - getWalRoller
```
public LogRoller getWalRoller()
```
  - getWalFactory
```
WALFactory getWalFactory()
```
  - 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
  - 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 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:
    
    IOException
  - skipReportingTransition
```
private boolean skipReportingTransition(RegionServerServices.RegionStateTransitionContext context)
```
    Helper method for use in tests. Skip the region transition report when there's no master around to receive it.
  - createReportRegionStateTransitionRequest
```
private org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.ReportRegionStateTransitionRequest createReportRegionStateTransitionRequest(RegionServerServices.RegionStateTransitionContext context)
```
  - 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
```
private 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
```
@InterfaceAudience.Private
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. n * the reason we are aborting n * the exception that caused the abort, or null
    
    Specified by:
    
    abort in interface Abortable
    
    Parameters:
    
    reason - Why we're aborting.
    
    cause - Throwable that caused abort. Can be null.
  - setAbortRequested
```
protected boolean setAbortRequested()
```
    Sets the abort state if not already set.
    
    Returns:
    
    True if abortRequested set to True successfully, false if an abort is already in progress.
  - 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
```
@InterfaceAudience.Private
protected void kill()
```
  - scheduleAbortTimer
```
private void scheduleAbortTimer()
```
  - shutdownChore
```
protected final void shutdownChore(ScheduledChore chore)
```
  - stopServiceThreads
```
protected void stopServiceThreads()
```
    Wait on all threads to finish. Presumption is that all closes and stops have already been called.
  - getReplicationSourceService
```
@InterfaceAudience.Private
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
```
private 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
```
@InterfaceAudience.Private
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
  - closeMetaTableRegions
```
private void closeMetaTableRegions(boolean abort)
```
    Close meta region if we carry it
    
    Parameters:
    
    abort - Whether we're running an abort.
  - closeUserRegions
```
private 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()
```
    Returns true if a stop has been requested.
    
    Specified by:
    
    isStopped in interface Stoppable
  - isStopping
```
public boolean isStopping()
```
    Description copied from interface: Server
    
    Returns True is the server is Stopping
    
    Specified by:
    
    isStopping in interface 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
  - getOnlineRegions
```
protected Map<String,HRegion> getOnlineRegions()
```
  - getNumberOfOnlineRegions
```
public int getNumberOfOnlineRegions()
```
  - 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. n
    
    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()
```
    Returns reference to FlushRequester
    
    Specified by:
    
    getFlushRequester in interface RegionServerServices
    
    Returns:
    
    Implementation of FlushRequester or null. Usually it will not be null unless during intialization.
  - 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.
  - getLeaseManager
```
public LeaseManager getLeaseManager()
```
    Description copied from interface: RegionServerServices
    
    Returns The RegionServer's "Leases" service
    
    Specified by:
    
    getLeaseManager in interface RegionServerServices
  - getDataRootDir
```
protected org.apache.hadoop.fs.Path getDataRootDir()
```
    Returns Return the rootDir.
  - getFileSystem
```
public org.apache.hadoop.fs.FileSystem getFileSystem()
```
    Description copied from interface: Server
    
    Returns Return the FileSystem object used (can return null!).
    
    Specified by:
    
    getFileSystem in interface Server
  - isDataFileSystemOk
```
boolean isDataFileSystemOk()
```
    Returns true when the data file system is available, false otherwise.
  - 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 Thread
  - 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()
```
    Description copied from interface: Server
    
    Returns The unique server name for this server.
    
    Specified by:
    
    getServerName in interface 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()
```
    Description copied from interface: RegionServerServices
    
    Returns hbase executor service
    
    Specified by:
    
    getExecutorService in interface RegionServerServices
  - getChoreService
```
public ChoreService getChoreService()
```
    Description copied from interface: Server
    
    Returns The ChoreService instance for this server
    
    Specified by:
    
    getChoreService in interface Server
  - getRegionServerRpcQuotaManager
```
public RegionServerRpcQuotaManager getRegionServerRpcQuotaManager()
```
    Description copied from interface: RegionServerServices
    
    Returns RegionServer's instance of RegionServerRpcQuotaManager
    
    Specified by:
    
    getRegionServerRpcQuotaManager in interface RegionServerServices
  - 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,
                                                 WALFactory walFactory)
                                          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,
                                                                       WALFactory walFactory)
                                                                throws IOException
```
    Throws:
    
    IOException
  - getWalGroupsReplicationStatus
```
public Map<String,ReplicationStatus> getWalGroupsReplicationStatus()
```
  - constructRegionServer
```
static HRegionServer constructRegionServer(Class<? extends HRegionServer> regionServerClass,
                                           org.apache.hadoop.conf.Configuration conf)
```
    Utility for constructing an instance of the passed HRegionServer class.
  - main
```
public static void main(String[] args)
```
    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 - table to limit the scope of the query
    
    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 destination)
                       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 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
    
    destination - Where the Region is being moved too... maybe null if unknown.
    
    Returns:
    
    True if closed a region.
    
    Throws:
    
    NotServingRegionException - if the region is not online
  - 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.
  - 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. n * @return Region for the passed encoded encodedRegionName or null if named region is not member of the online regions.
    
    Specified by:
    
    getRegion in interface OnlineRegions
  - 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
```
private HRegion getRegionByEncodedName(byte[] regionName,
                                       String encodedRegionName)
                                throws NotServingRegionException
```
    Throws:
    
    NotServingRegionException
  - cleanup
```
private Throwable cleanup(Throwable t,
                          String msg)
```
    Cleanup after Throwable caught invoking method. Converts t to IOE if it isn't already.
    
    Parameters:
    
    t - Throwable
    
    msg - Message to log in error. Can be null.
    
    Returns:
    
    Throwable converted to an IOE; methods can only let out IOEs.
  - convertThrowableToIOE
```
private IOException convertThrowableToIOE(Throwable t,
                                          String msg)
```
    Parameters:
    
    msg - Message to put in new IOE if passed t is not an IOE
    
    Returns:
    
    Make t an IOE if it isn't already.
  - checkFileSystem
```
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. nn
    
    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 we convert to InetSocketAddress[] here.
    
    Specified by:
    
    getFavoredNodesForRegion in interface FavoredNodesForRegion
    
    Parameters:
    
    encodedRegionName - the encoded region name.
    
    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
```
private void addToMovedRegions(String encodedName,
                               ServerName destination,
                               long closeSeqNum,
                               boolean selfMove)
```
  - removeFromMovedRegions
```
void removeFromMovedRegions(String encodedName)
```
  - getMovedRegion
```
@InterfaceAudience.Private
public HRegionServer.MovedRegionInfo getMovedRegion(String encodedRegionName)
```
  - movedRegionCacheExpiredTime
```
@InterfaceAudience.Private
public int movedRegionCacheExpiredTime()
```
  - getMyEphemeralNodePath
```
private String getMyEphemeralNodePath()
```
  - isHealthCheckerConfigured
```
private boolean isHealthCheckerConfigured()
```
  - getCompactSplitThread
```
public CompactSplit getCompactSplitThread()
```
    Returns the underlying CompactSplit for the servers
  - execRegionServerService
```
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
  - getBlockCache
```
public Optional<BlockCache> getBlockCache()
```
    May be null if this is a master which not carry table.
    
    Specified by:
    
    getBlockCache in interface RegionServerServices
    
    Returns:
    
    The block cache instance used by the regionserver.
  - getMobFileCache
```
public Optional<MobFileCache> getMobFileCache()
```
    May be null if this is a master which not carry table.
    
    Specified by:
    
    getMobFileCache in interface RegionServerServices
    
    Returns:
    
    The cache for mob files used by the regionserver.
  - getAccessChecker
```
public AccessChecker getAccessChecker()
```
    Description copied from interface: RegionServerServices
    
    Returns the AccessChecker
    
    Specified by:
    
    getAccessChecker in interface RegionServerServices
  - getZKPermissionWatcher
```
public ZKPermissionWatcher getZKPermissionWatcher()
```
    Description copied from interface: RegionServerServices
    
    Returns ZKPermissionWatcher
    
    Specified by:
    
    getZKPermissionWatcher in interface RegionServerServices
  - getConfigurationManager
```
@InterfaceAudience.Private
ConfigurationManager getConfigurationManager()
```
    Returns : Returns the ConfigurationManager object for testing purposes.
  - getTableDescriptors
```
public TableDescriptors getTableDescriptors()
```
    Returns Return table descriptors implementation.
    
    Specified by:
    
    getTableDescriptors in interface RegionServerServices
  - updateConfiguration
```
void updateConfiguration()
```
    Reload the configuration from disk.
  - clearRegionBlockCache
```
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()
```
    Description copied from interface: RegionServerServices
    
    Returns heap memory manager instance
    
    Specified by:
    
    getHeapMemoryManager in interface RegionServerServices
  - getMemStoreFlusher
```
public MemStoreFlusher getMemStoreFlusher()
```
  - walRollRequestFinished
```
@InterfaceAudience.Private
public boolean walRollRequestFinished()
```
    For testing
    
    Returns:
    
    whether all wal roll request finished for this regionserver
  - getFlushThroughputController
```
public ThroughputController getFlushThroughputController()
```
    Description copied from interface: RegionServerServices
    
    Returns the controller to avoid flush too fast
    
    Specified by:
    
    getFlushThroughputController in interface RegionServerServices
  - 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()
```
    Description copied from interface: RegionServerServices
    
    Returns the metrics tracker for the region server
    
    Specified by:
    
    getMetrics in interface RegionServerServices
  - getSecureBulkLoadManager
```
public SecureBulkLoadManager getSecureBulkLoadManager()
```
    Description copied from interface: RegionServerServices
    
    Returns RegionServer's instance of SecureBulkLoadManager
    
    Specified by:
    
    getSecureBulkLoadManager in interface RegionServerServices
  - regionLock
```
public EntityLock regionLock(List<RegionInfo> regionInfos,
                             String description,
                             Abortable abort)
```
    Description copied from interface: RegionServerServices
    
    Master based locks on namespaces/tables/regions.
    
    Specified by:
    
    regionLock in interface RegionServerServices
  - 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()
```
    Description copied from interface: RegionServerServices
    
    Returns RegionServer's instance of RegionServerSpaceQuotaManager
    
    Specified by:
    
    getRegionServerSpaceQuotaManager in interface RegionServerServices
  - reportFileArchivalForQuotas
```
public boolean reportFileArchivalForQuotas(TableName tableName,
                                           Collection<Map.Entry<String,Long>> archivedFiles)
```
    Description copied from interface: RegionServerServices
    
    Reports a collection of files, and their sizes, that belonged to the given table were just moved to the archive directory.
    
    Specified by:
    
    reportFileArchivalForQuotas in interface RegionServerServices
    
    Parameters:
    
    tableName - The name of the table that files previously belonged to
    
    archivedFiles - Files and their sizes that were moved to archive
    
    Returns:
    
    true if the files were successfully reported, false otherwise.
  - getEventLoopGroupConfig
```
public NettyEventLoopGroupConfig getEventLoopGroupConfig()
```
  - createConnection
```
public Connection createConnection(org.apache.hadoop.conf.Configuration conf)
                            throws IOException
```
    Specified by:
    
    createConnection in interface Server
    
    Throws:
    
    IOException
  - executeProcedure
```
void executeProcedure(long procId,
                      RSProcedureCallable callable)
```
  - remoteProcedureComplete
```
public void remoteProcedureComplete(long procId,
                                    Throwable error)
```
  - reportProcedureDone
```
void reportProcedureDone(org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.ReportProcedureDoneRequest request)
                  throws IOException
```
    Throws:
    
    IOException
  - submitRegionProcedure
```
boolean submitRegionProcedure(long procId)
```
    Will ignore the open/close region procedures which already submitted or executed. When master had unfinished open/close region procedure and restarted, new active master may send duplicate open/close region request to regionserver. The open/close request is submitted to a thread pool and execute. So first need a cache for submitted open/close region procedures. After the open/close region request executed and report region transition succeed, cache it in executed region procedures cache. See finishRegionProcedure(long). After report region transition succeed, master will not send the open/close region request to regionserver again. And we thought that the ongoing duplicate open/close region request should not be delayed more than 600 seconds. So the executed region procedures cache will expire after 600 seconds. See HBASE-22404 for more details.
    
    Parameters:
    
    procId - the id of the open/close region procedure
    
    Returns:
    
    true if the procedure can be submitted.
  - finishRegionProcedure
```
public void finishRegionProcedure(long procId)
```
    See submitRegionProcedure(long).
    
    Parameters:
    
    procId - the id of the open/close region procedure
  - isShutDown
```
public boolean isShutDown()
```
  - getCompactedHFilesDischarger
```
@InterfaceAudience.Private
public CompactedHFilesDischarger getCompactedHFilesDischarger()
```
  - getRetryPauseTime
```
@InterfaceAudience.Private
public long getRetryPauseTime()
```
    Return pause time configured in HConstants.HBASE_RPC_SHORTOPERATION_RETRY_PAUSE_TIME}
    
    Returns:
    
    pause time
  - getActiveMaster
```
public Optional<ServerName> getActiveMaster()
```
  - getBackupMasters
```
public List<ServerName> getBackupMasters()
```
  - getRegionServers
```
public Iterator<ServerName> getRegionServers()
```
  - getMetaRegionLocationCache
```
public MetaRegionLocationCache getMetaRegionLocationCache()
```
  - getBrokenStoreFileCleaner
```
@InterfaceAudience.Private
public BrokenStoreFileCleaner getBrokenStoreFileCleaner()
```
  - getRSMobFileCleanerChore
```
@InterfaceAudience.Private
public RSMobFileCleanerChore getRSMobFileCleanerChore()
```

Class HRegionServer

Nested Class Summary

Nested classes/interfaces inherited from class java.lang.Thread

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

Field Summary

Fields inherited from class java.lang.Thread

Constructor Summary

Method Summary

Methods inherited from class java.lang.Thread

Methods inherited from class java.lang.Object

Methods inherited from interface org.apache.hadoop.hbase.Abortable

Field Detail

LOG

TEST_SKIP_REPORTING_TRANSITION

regionsInTransitionInRS

submittedRegionProcedures

executedRegionProcedures

movedRegionInfoCache

cacheFlusher

hMemManager

clusterConnection

tableDescriptors

replicationSourceHandler

replicationSinkHandler

compactSplitThread

onlineRegions

onlineRegionsLock

regionFavoredNodesMap

leaseManager

executorService

dataFsOk

dataFs

walFs

stopped

abortRequested

ABORT_TIMEOUT

DEFAULT_ABORT_TIMEOUT

ABORT_TIMEOUT_TASK

stopping

killed

shutDown

conf

dataRootDir

walRootDir

threadWakeFrequency

msgInterval

PERIOD_COMPACTION

compactionCheckFrequency

PERIOD_FLUSH

flushCheckFrequency

rssStub

lockStub

rpcClient

rpcRetryingCallerFactory

rpcControllerFactory

uncaughtExceptionHandler

infoServer

pauseMonitor

REGIONSERVER

metricsRegionServer

metricsRegionServerImpl

choreService

compactionChecker

periodicFlusher

walFactory

walRoller

procedureResultReporter

online

zooKeeper

masterAddressTracker

metaRegionLocationCache

regionServerAddressTracker

clusterStatusTracker

splitLogWorker

sleeper

operationTimeout

shortOperationTimeout

retryPauseTime

regionServerAccounting

slowLogTableOpsChore