HRegionServer (Hortonworks Data Platform Apache HBase Java API Reference)

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

All Implemented Interfaces:

ConfigurationObserver, FavoredNodesForRegion, LastSequenceId, MutableOnlineRegions, OnlineRegions, RegionServerServices, Server

Direct Known Subclasses:

HMaster
```
public class HRegionServer
extends HasThread
implements RegionServerServices, LastSequenceId, ConfigurationObserver
```
HRegionServer makes a set of HRegions available to clients. It checks in with the HMaster. There are many HRegionServers in a single HBase deployment.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

protected static class HRegionServer.MovedRegionsCleaner
Creates a Chore thread to clean the moved region cache.
- Nested classes/interfaces inherited from interface org.apache.hadoop.hbase.regionserver.RegionServerServices
  RegionServerServices.PostOpenDeployContext, RegionServerServices.RegionStateTransitionContext

Nested Classes
Modifier and Type	Class and Description
`protected static class`	`HRegionServer.MovedRegionsCleaner` Creates a Chore thread to clean the moved region cache.

Field Summary

Fields
Modifier and Type	Field and Description
`protected CacheConfig`	`cacheConfig`
`protected org.apache.hadoop.hbase.regionserver.MemStoreFlusher`	`cacheFlusher`
`protected ClusterConnection`	`clusterConnection` Cluster connection to be shared by services.
`protected java.lang.String`	`clusterId` Unique identifier for the cluster we are a part of.
`protected ClusterStatusTracker`	`clusterStatusTracker`
`CompactSplit`	`compactSplitThread`
`protected 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.
`protected CoordinatedStateManager`	`csm`
`protected ExecutorService`	`executorService`
`protected HFileSystem`	`fs`
`protected boolean`	`fsOk`
`protected FileSystemUtilizationChore`	`fsUtilizationChore`
`protected HeapMemoryManager`	`hMemManager`
`protected InfoServer`	`infoServer`
`protected Leases`	`leases`
`protected java.util.concurrent.locks.ReentrantReadWriteLock`	`lock`
`protected static java.lang.String`	`MASTER_HOSTNAME_KEY`
`protected MetaTableLocator`	`metaTableLocator`
`protected java.util.Map<java.lang.String,org.apache.hadoop.hbase.regionserver.HRegionServer.MovedRegionInfo>`	`movedRegions`
`protected int`	`msgInterval`
`protected int`	`numRegionsToReport`
`protected java.util.Map<java.lang.String,HRegion>`	`onlineRegions` Map of regions currently being served by this region server.
`protected java.util.Map<java.lang.String,java.net.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 java.lang.String`	`REGIONSERVER` region server process name
`protected java.util.concurrent.ConcurrentMap<byte[],java.lang.Boolean>`	`regionsInTransitionInRS`
`protected ReplicationSinkService`	`replicationSinkHandler`
`protected ReplicationSourceService`	`replicationSourceHandler`
`protected RSRpcServices`	`rpcServices`
`protected SecureBulkLoadManager`	`secureBulkLoadManager`
`protected ServerName`	`serverName` The server name the Master sees us as.
`protected Sleeper`	`sleeper`
`protected long`	`startcode` This servers startcode.
`protected TableDescriptors`	`tableDescriptors` Go here to get table descriptors.
`static boolean`	`TEST_SKIP_REPORTING_TRANSITION` For testing only! Set to true to skip notifying region assignment to master .
`protected int`	`threadWakeFrequency`
`protected java.lang.String`	`useThisHostnameInstead`
`protected WALFactory`	`walFactory`
`protected HFileSystem`	`walFs`
`protected LogRoller`	`walRoller`
`protected ZKWatcher`	`zooKeeper`

Constructor Summary

Constructors
Constructor and Description

HRegionServer(Configuration conf)
Starts a HRegionServer at the default location

Constructors
Constructor and Description
`HRegionServer(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(java.lang.String reason)`
`void`	`abort(java.lang.String reason, java.lang.Throwable cause)` Cause the server to exit without closing the regions it is serving, the log it is using and without notifying the master.
`void`	`addRegion(HRegion region)` Add to online regions.
`protected void`	`addToMovedRegions(java.lang.String encodedName, ServerName destination, long closeSeqNum)`
`protected boolean`	`canCreateBaseZNode()`
`protected boolean`	`canUpdateTableDescriptor()`
`boolean`	`checkFileSystem()` Checks to see if the file system is still accessible.
`protected void`	`cleanMovedRegions()` Remove the expired entries from the moved regions list.
`CacheEvictionStats`	`clearRegionBlockCache(Region region)`
`protected void`	`closeAllRegions(boolean abort)` Closes all regions.
`protected boolean`	`closeAndOfflineRegionForSplitOrMerge(java.util.List<java.lang.String> regionEncodedName)` Close and offline the region for split or merge
`protected boolean`	`closeRegion(java.lang.String encodedName, boolean abort, ServerName sn)` Close asynchronously a region, can be called from the master or internally by the regionserver when stopping.
`protected void`	`configureInfoServer()`
`static HRegionServer`	`constructRegionServer(java.lang.Class<? extends HRegionServer> regionServerClass, Configuration conf2)` Utility for constructing an instance of the passed HRegionServer class.
`protected java.io.IOException`	`convertThrowableToIOE(java.lang.Throwable t, java.lang.String msg)`
`protected ClusterConnection`	`createClusterConnection()` Create a 'smarter' Connection, one that is capable of by-passing RPC if the request is to the local server; i.e.
`Connection`	`createConnection(Configuration conf)`
`RegionLoad`	`createRegionLoad(java.lang.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()`
`CoprocessorServiceResponse`	`execRegionServerService(RpcController controller, CoprocessorServiceRequest serviceRequest)`
`CacheConfig`	`getCacheConfig()`
`ChoreService`	`getChoreService()`
`ClusterConnection`	`getClusterConnection()` Returns a reference to the servers' cluster connection.
`java.lang.String`	`getClusterId()`
`double`	`getCompactionPressure()`
`CompactionRequester`	`getCompactionRequestor()`
`CompactSplit`	`getCompactSplitThread()`
`Configuration`	`getConfiguration()` Gets the configuration object for this server.
`protected ConfigurationManager`	`getConfigurationManager()`
`Connection`	`getConnection()` Returns a reference to the servers' connection.
`CoordinatedStateManager`	`getCoordinatedStateManager()` Get CoordinatedStateManager instance for this server.
`protected java.lang.Class<? extends HttpServlet>`	`getDumpServlet()`
`NettyEventLoopGroupConfig`	`getEventLoopGroupConfig()`
`ExecutorService`	`getExecutorService()`
`java.net.InetSocketAddress[]`	`getFavoredNodesForRegion(java.lang.String encodedRegionName)` Return the favored nodes for a region given its encoded name.
`FileSystem`	`getFileSystem()`
`double`	`getFlushPressure()`
`FlushRequester`	`getFlushRequester()`
`ThroughputController`	`getFlushThroughputController()`
`protected TableDescriptors`	`getFsTableDescriptors()`
`HeapMemoryManager`	`getHeapMemoryManager()`
`InfoServer`	`getInfoServer()`
`RegionStoreSequenceIds`	`getLastSequenceId(byte[] encodedRegionName)`
`Leases`	`getLeases()`
`MasterAddressTracker`	`getMasterAddressTracker()`
`MetaTableLocator`	`getMetaTableLocator()` Returns instance of `org.apache.hadoop.hbase.zookeeper.MetaTableLocator` running inside this server.
`protected java.util.function.Function<TableDescriptorBuilder,TableDescriptorBuilder>`	`getMetaTableObserver()`
`MetricsRegionServer`	`getMetrics()`
`protected RegionInfo[]`	`getMostLoadedRegions()` Get the top N most loaded regions this server is serving so we can tell the master which regions it can reallocate if we're overloaded.
`ServerNonceManager`	`getNonceManager()` Only required for "old" log replay; if it's removed, remove this.
`int`	`getNumberOfOnlineRegions()`
`HRegion`	`getOnlineRegion(byte[] regionName)`
`java.util.Collection<HRegion>`	`getOnlineRegionsLocalContext()` For tests, web ui and metrics.
`java.util.Set<TableName>`	`getOnlineTables()` Gets the online tables in this RS.
`protected java.lang.String`	`getProcessName()`
`protected HRegion`	`getRegion(byte[] regionName)` Protected Utility method for safely obtaining an HRegion handle.
`HRegion`	`getRegion(java.lang.String encodedRegionName)` Return `Region` instance.
`java.net.InetSocketAddress[]`	`getRegionBlockLocations(java.lang.String encodedRegionName)`
`protected HRegion`	`getRegionByEncodedName(byte[] regionName, java.lang.String encodedRegionName)`
`HRegion`	`getRegionByEncodedName(java.lang.String encodedRegionName)`
`java.util.List<HRegion>`	`getRegions()` Get all online regions in this RS.
`java.util.List<HRegion>`	`getRegions(TableName tableName)` Gets the online regions of the specified table.
`RegionServerAccounting`	`getRegionServerAccounting()`
`RegionServerCoprocessorHost`	`getRegionServerCoprocessorHost()`
`java.lang.String[]`	`getRegionServerCoprocessors()`
`MetricsRegionServer`	`getRegionServerMetrics()`
`RegionServerRpcQuotaManager`	`getRegionServerRpcQuotaManager()`
`RegionServerSpaceQuotaManager`	`getRegionServerSpaceQuotaManager()`
`java.util.concurrent.ConcurrentMap<byte[],java.lang.Boolean>`	`getRegionsInTransitionInRS()` Get the regions that are currently being opened or closed in the RS
`ReplicationSourceService`	`getReplicationSourceService()`
`protected Path`	`getRootDir()`
`RpcServerInterface`	`getRpcServer()` Returns a reference to the region server's RPC server
`RSRpcServices`	`getRSRpcServices()`
`SecureBulkLoadManager`	`getSecureBulkLoadManager()`
`ServerName`	`getServerName()`
`long`	`getStartcode()`
`TableDescriptors`	`getTableDescriptors()`
`int`	`getThreadWakeFrequency()` Interval at which threads should run
`protected java.lang.String`	`getUseThisHostnameInstead(Configuration conf)`
`WAL`	`getWAL(RegionInfo regionInfo)`
`protected FileSystem`	`getWALFileSystem()`
`LogRoller`	`getWalRoller()`
`protected Path`	`getWALRootDir()`
`java.util.List<WAL>`	`getWALs()`
`ZKWatcher`	`getZooKeeper()` Gets the ZooKeeper instance for this server.
`protected void`	`handleReportForDutyResponse(RegionServerStartupResponse c)`
`protected void`	`initializeMemStoreChunkCreator()`
`boolean`	`isAborted()`
`boolean`	`isClusterUp()`
`boolean`	`isOnline()` Report the status of the server.
`boolean`	`isStopped()`
`boolean`	`isStopping()`
`protected void`	`kill()`
`protected void`	`login(UserProvider user, java.lang.String host)`
`static void`	`main(java.lang.String[] args)`
`protected int`	`movedRegionCleanerPeriod()`
`void`	`onConfigurationChange(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
`EntityLock`	`regionLock(java.util.List<RegionInfo> regionInfos, java.lang.String description, Abortable abort)` Master based locks on namespaces/tables/regions.
`boolean`	`registerService(com.google.protobuf.Service instance)` Registers a new protocol buffer `Service` subclass as a coprocessor endpoint to be available for handling
`boolean`	`removeRegion(HRegion r, ServerName destination)` Removes the given Region from the list of onlineRegions.
`boolean`	`reportFileArchivalForQuotas(TableName tableName, java.util.Collection<java.util.Map.Entry<java.lang.String,java.lang.Long>> archivedFiles)` Reports a collection of files, and their sizes, that belonged to the given `table` were just moved to the archive directory.
`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
`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.
`void`	`stop(java.lang.String msg)`
`void`	`stop(java.lang.String msg, boolean force, User user)` Stops the regionserver.
`protected void`	`stopServiceThreads()` Wait on all threads to finish.
`java.lang.String`	`toString()`
`protected void`	`tryRegionServerReport(long reportStartTime, long reportEndTime)`
`void`	`unassign(byte[] regionName)` Unassign the given region from the current regionserver and assign it randomly.
`void`	`updateConfiguration()` Reload the configuration from disk.
`void`	`updateRegionFavoredNodesMapping(java.lang.String encodedRegionName, java.util.List<org.apache.hadoop.hbase.shaded.protobuf.generated.HBaseProtos.ServerName> favoredNodes)` Used to update the favored nodes mapping when required.
`protected void`	`waitForMasterActive()`
`void`	`waitForServerOnline()`
`boolean`	`walRollRequestFinished()` For testing

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

- Field Detail
  - TEST_SKIP_REPORTING_TRANSITION
```
public static boolean TEST_SKIP_REPORTING_TRANSITION
```
    For testing only! Set to true to skip notifying region assignment to master .
  - regionsInTransitionInRS
```
protected final java.util.concurrent.ConcurrentMap<byte[],java.lang.Boolean> regionsInTransitionInRS
```
  - cacheFlusher
```
protected org.apache.hadoop.hbase.regionserver.MemStoreFlusher cacheFlusher
```
  - hMemManager
```
protected HeapMemoryManager hMemManager
```
  - clusterConnection
```
protected ClusterConnection clusterConnection
```
    Cluster connection to be shared by services. Initialized at server startup and closed when server shuts down. Clients must never close it explicitly. Clients hosted by this Server should make use of this clusterConnection rather than create their own; if they create their own, there is no way for the hosting server to shutdown ongoing client RPCs.
  - metaTableLocator
```
protected MetaTableLocator metaTableLocator
```
  - tableDescriptors
```
protected TableDescriptors tableDescriptors
```
    Go here to get table descriptors.
  - replicationSourceHandler
```
protected ReplicationSourceService replicationSourceHandler
```
  - replicationSinkHandler
```
protected ReplicationSinkService replicationSinkHandler
```
  - compactSplitThread
```
public CompactSplit compactSplitThread
```
  - onlineRegions
```
protected final java.util.Map<java.lang.String,HRegion> onlineRegions
```
    Map of regions currently being served by this region server. Key is the encoded region name. All access should be synchronized.
  - regionFavoredNodesMap
```
protected final java.util.Map<java.lang.String,java.net.InetSocketAddress[]> regionFavoredNodesMap
```
    Map of encoded region names to the DataNode locations they should be hosted on We store the value as InetSocketAddress since this is used only in HDFS API (create() that takes favored nodes as hints for placing file blocks). We could have used ServerName here as the value class, but we'd need to convert it to InetSocketAddress at some point before the HDFS API call, and it seems a bit weird to store ServerName since ServerName refers to RegionServers and here we really mean DataNode locations.
  - leases
```
protected Leases leases
```
  - executorService
```
protected ExecutorService executorService
```
  - fsOk
```
protected volatile boolean fsOk
```
  - fs
```
protected HFileSystem fs
```
  - walFs
```
protected HFileSystem walFs
```
  - conf
```
protected final Configuration conf
```
  - lock
```
protected final java.util.concurrent.locks.ReentrantReadWriteLock lock
```
  - threadWakeFrequency
```
protected final int threadWakeFrequency
```
  - msgInterval
```
protected final int msgInterval
```
  - numRegionsToReport
```
protected final int numRegionsToReport
```
  - infoServer
```
protected InfoServer infoServer
```
  - REGIONSERVER
```
public static final java.lang.String REGIONSERVER
```
    region server process name
    
    See Also:
    
    Constant Field Values
  - walFactory
```
protected volatile WALFactory walFactory
```
  - walRoller
```
protected LogRoller walRoller
```
  - zooKeeper
```
protected final ZKWatcher zooKeeper
```
  - clusterStatusTracker
```
protected final ClusterStatusTracker clusterStatusTracker
```
  - sleeper
```
protected final Sleeper sleeper
```
  - cacheConfig
```
protected CacheConfig cacheConfig
```
  - 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 java.lang.String useThisHostnameInstead
```
  - MASTER_HOSTNAME_KEY
```
protected static final java.lang.String MASTER_HOSTNAME_KEY
```
    See Also:
    
    Constant Field Values
  - startcode
```
protected final long startcode
```
    This servers startcode.
  - clusterId
```
protected java.lang.String clusterId
```
    Unique identifier for the cluster we are a part of.
  - rpcServices
```
protected final RSRpcServices rpcServices
```
  - csm
```
protected CoordinatedStateManager csm
```
  - configurationManager
```
protected final ConfigurationManager configurationManager
```
    Configuration manager is used to register/deregister and notify the configuration observers when the regionserver is notified that there was a change in the on disk configs.
  - secureBulkLoadManager
```
protected SecureBulkLoadManager secureBulkLoadManager
```
  - fsUtilizationChore
```
protected FileSystemUtilizationChore fsUtilizationChore
```
  - movedRegions
```
protected java.util.Map<java.lang.String,org.apache.hadoop.hbase.regionserver.HRegionServer.MovedRegionInfo> movedRegions
```
- Constructor Detail
  - HRegionServer
```
public HRegionServer(Configuration conf)
              throws java.io.IOException
```
    Starts a HRegionServer at the default location
    
    Throws:
    
    java.io.IOException
- Method Detail
  - getUseThisHostnameInstead
```
protected java.lang.String getUseThisHostnameInstead(Configuration conf)
                                              throws java.io.IOException
```
    Throws:
    
    java.io.IOException
  - getFsTableDescriptors
```
protected TableDescriptors getFsTableDescriptors()
                                          throws java.io.IOException
```
    Throws:
    
    java.io.IOException
  - getMetaTableObserver
```
protected java.util.function.Function<TableDescriptorBuilder,TableDescriptorBuilder> getMetaTableObserver()
```
  - login
```
protected void login(UserProvider user,
                     java.lang.String host)
              throws java.io.IOException
```
    Throws:
    
    java.io.IOException
  - waitForMasterActive
```
protected void waitForMasterActive()
```
  - getProcessName
```
protected java.lang.String getProcessName()
```
  - canCreateBaseZNode
```
protected boolean canCreateBaseZNode()
```
  - canUpdateTableDescriptor
```
protected boolean canUpdateTableDescriptor()
```
  - createRpcServices
```
protected RSRpcServices createRpcServices()
                                   throws java.io.IOException
```
    Throws:
    
    java.io.IOException
  - configureInfoServer
```
protected void configureInfoServer()
```
  - getDumpServlet
```
protected java.lang.Class<? extends 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 java.io.IOException
```
    Create a 'smarter' Connection, one that is capable of by-passing RPC if the request is to the local server; i.e. a short-circuit Connection. Safe to use going to local or remote server. Create this instance in a method can be intercepted and mocked in tests.
    
    Throws:
    
    java.io.IOException
  - getClusterId
```
public java.lang.String getClusterId()
```
  - setupClusterConnection
```
protected void setupClusterConnection()
                               throws java.io.IOException
```
    Setup our cluster connection if not already initialized.
    
    Throws:
    
    java.io.IOException
  - isClusterUp
```
public boolean isClusterUp()
```
    Specified by:
    
    isClusterUp in interface RegionServerServices
    
    Returns:
    
    True if the cluster is up.
  - run
```
public void run()
```
    The HRegionServer sticks in this loop until closed.
  - tryRegionServerReport
```
protected void tryRegionServerReport(long reportStartTime,
                                     long reportEndTime)
                              throws java.io.IOException
```
    Throws:
    
    java.io.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
  - handleReportForDutyResponse
```
protected void handleReportForDutyResponse(RegionServerStartupResponse c)
                                    throws java.io.IOException
```
    Throws:
    
    java.io.IOException
  - initializeMemStoreChunkCreator
```
protected void initializeMemStoreChunkCreator()
```
  - getRegionServerAccounting
```
public RegionServerAccounting getRegionServerAccounting()
```
    Specified by:
    
    getRegionServerAccounting in interface RegionServerServices
    
    Returns:
    
    the RegionServerAccounting for this Region Server
  - createRegionLoad
```
public RegionLoad createRegionLoad(java.lang.String encodedRegionName)
                            throws java.io.IOException
```
    Parameters:
    
    encodedRegionName -
    
    Returns:
    
    An instance of RegionLoad.
    
    Throws:
    
    java.io.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.
  - getRegionServerMetrics
```
public MetricsRegionServer getRegionServerMetrics()
```
  - getMasterAddressTracker
```
public MasterAddressTracker getMasterAddressTracker()
```
    Returns:
    
    Master address tracker instance.
  - getWALs
```
public java.util.List<WAL> getWALs()
                            throws java.io.IOException
```
    Specified by:
    
    getWALs in interface RegionServerServices
    
    Returns:
    
    the List of WALs that are used by this server Doesn't include the meta WAL
    
    Throws:
    
    java.io.IOException
  - getWAL
```
public WAL getWAL(RegionInfo regionInfo)
           throws java.io.IOException
```
    Specified by:
    
    getWAL in interface RegionServerServices
    
    Returns:
    
    the WAL for a particular region. Pass null for getting the default (common) WAL
    
    Throws:
    
    java.io.IOException
  - getWalRoller
```
public LogRoller getWalRoller()
```
  - getConnection
```
public Connection getConnection()
```
    Description copied from interface: Server
    
    Returns a reference to the servers' connection. Important note: this method returns a reference to Connection which is managed by Server itself, so callers must NOT attempt to close connection obtained.
    
    Specified by:
    
    getConnection in interface Server
  - getClusterConnection
```
public ClusterConnection getClusterConnection()
```
    Description copied from interface: Server
    
    Returns a reference to the servers' cluster connection. Prefer Server.getConnection(). Important note: this method returns a reference to Connection which is managed by Server itself, so callers must NOT attempt to close connection obtained.
    
    Specified by:
    
    getClusterConnection in interface Server
  - getMetaTableLocator
```
public MetaTableLocator getMetaTableLocator()
```
    Description copied from interface: Server
    
    Returns instance of org.apache.hadoop.hbase.zookeeper.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(java.lang.String msg)
```
  - stop
```
public void stop(java.lang.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 KeeperException,
                                java.io.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:
    
    KeeperException
    
    java.io.IOException
  - reportRegionStateTransition
```
public boolean reportRegionStateTransition(RegionServerServices.RegionStateTransitionContext context)
```
    Description copied from interface: RegionServerServices
    
    Notify master that a handler requests to change a region state
    
    Specified by:
    
    reportRegionStateTransition in interface RegionServerServices
  - 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(java.lang.String reason,
                  java.lang.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.
    
    Parameters:
    
    reason - the reason we are aborting
    
    cause - the exception that caused the abort, or null
  - abort
```
public void abort(java.lang.String reason)
```
    See Also:
    
    abort(String, Throwable)
  - isAborted
```
public boolean isAborted()
```
  - kill
```
protected void kill()
```
  - sendShutdownInterrupt
```
protected void sendShutdownInterrupt()
```
    Called on stop/abort before closing the cluster connection and meta locator.
  - stopServiceThreads
```
protected void stopServiceThreads()
```
    Wait on all threads to finish. Presumption is that all closes and stops have already been called.
  - getReplicationSourceService
```
public ReplicationSourceService getReplicationSourceService()
```
    Returns:
    
    Return the object that implements the replication source executorService.
  - 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
  - getLastSequenceId
```
public 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.
  - getInfoServer
```
public InfoServer getInfoServer()
```
    Returns:
    
    the info server
  - isStopped
```
public boolean isStopped()
```
    Returns:
    
    true if a stop has been requested.
  - isStopping
```
public boolean isStopping()
```
    Specified by:
    
    isStopping in interface Server
    
    Returns:
    
    True is the server is Stopping
  - getConfiguration
```
public Configuration getConfiguration()
```
    Description copied from interface: Server
    
    Gets the configuration object for this server.
    
    Specified by:
    
    getConfiguration in interface Server
    
    Returns:
    
    the configuration
  - getNumberOfOnlineRegions
```
public int getNumberOfOnlineRegions()
```
  - getOnlineRegionsLocalContext
```
public java.util.Collection<HRegion> getOnlineRegionsLocalContext()
```
    For tests, web ui and metrics. This method will only work if HRegionServer is in the same JVM as client; HRegion cannot be serialized to cross an rpc.
  - addRegion
```
public void addRegion(HRegion region)
```
    Description copied from interface: MutableOnlineRegions
    
    Add to online regions.
    
    Specified by:
    
    addRegion in interface MutableOnlineRegions
  - getStartcode
```
public long getStartcode()
```
    Returns:
    
    time stamp in millis of when this region server was started
  - getFlushRequester
```
public FlushRequester getFlushRequester()
```
    Specified by:
    
    getFlushRequester in interface RegionServerServices
    
    Returns:
    
    reference to FlushRequester
  - getCompactionRequestor
```
public CompactionRequester getCompactionRequestor()
```
    Specified by:
    
    getCompactionRequestor in interface RegionServerServices
    
    Returns:
    
    Implementation of CompactionRequester or null. Usually it will not be null unless during intialization.
  - getMostLoadedRegions
```
protected RegionInfo[] getMostLoadedRegions()
```
    Get the top N most loaded regions this server is serving so we can tell the master which regions it can reallocate if we're overloaded. TODO: actually calculate which regions are most loaded. (Right now, we're just grabbing the first N regions being served regardless of load.)
  - getLeases
```
public Leases getLeases()
```
    Specified by:
    
    getLeases in interface RegionServerServices
    
    Returns:
    
    The RegionServer's "Leases" service
  - getRootDir
```
protected Path getRootDir()
```
    Returns:
    
    Return the rootDir.
  - getFileSystem
```
public FileSystem getFileSystem()
```
    Specified by:
    
    getFileSystem in interface Server
    
    Returns:
    
    Return the fs.
  - getWALRootDir
```
protected Path getWALRootDir()
```
    Returns:
    
    Return the walRootDir.
  - getWALFileSystem
```
protected FileSystem getWALFileSystem()
```
    Returns:
    
    Return the walFs.
  - toString
```
public java.lang.String toString()
```
  - getThreadWakeFrequency
```
public int getThreadWakeFrequency()
```
    Interval at which threads should run
    
    Returns:
    
    the interval
  - getZooKeeper
```
public ZKWatcher getZooKeeper()
```
    Description copied from interface: Server
    
    Gets the ZooKeeper instance for this server.
    
    Specified by:
    
    getZooKeeper in interface Server
  - getCoordinatedStateManager
```
public CoordinatedStateManager getCoordinatedStateManager()
```
    Description copied from interface: Server
    
    Get CoordinatedStateManager instance for this server.
    
    Specified by:
    
    getCoordinatedStateManager in interface Server
  - getServerName
```
public ServerName getServerName()
```
    Specified by:
    
    getServerName in interface Server
    
    Returns:
    
    The unique server name for this server.
  - getRegionServerCoprocessorHost
```
public RegionServerCoprocessorHost getRegionServerCoprocessorHost()
```
  - getRegionsInTransitionInRS
```
public java.util.concurrent.ConcurrentMap<byte[],java.lang.Boolean> getRegionsInTransitionInRS()
```
    Description copied from interface: RegionServerServices
    
    Get the regions that are currently being opened or closed in the RS
    
    Specified by:
    
    getRegionsInTransitionInRS in interface RegionServerServices
    
    Returns:
    
    map of regions in transition in this RS
  - getExecutorService
```
public ExecutorService getExecutorService()
```
    Specified by:
    
    getExecutorService in interface RegionServerServices
    
    Returns:
    
    hbase executor service
  - getChoreService
```
public ChoreService getChoreService()
```
    Specified by:
    
    getChoreService in interface Server
    
    Returns:
    
    The ChoreService instance for this server
  - getRegionServerRpcQuotaManager
```
public RegionServerRpcQuotaManager getRegionServerRpcQuotaManager()
```
    Specified by:
    
    getRegionServerRpcQuotaManager in interface RegionServerServices
    
    Returns:
    
    RegionServer's instance of RegionServerRpcQuotaManager
  - constructRegionServer
```
public static HRegionServer constructRegionServer(java.lang.Class<? extends HRegionServer> regionServerClass,
                                                  Configuration conf2)
```
    Utility for constructing an instance of the passed HRegionServer class.
    
    Parameters:
    
    regionServerClass -
    
    conf2 -
    
    Returns:
    
    HRegionServer instance.
  - main
```
public static void main(java.lang.String[] args)
                 throws java.lang.Exception
```
    Throws:
    
    java.lang.Exception
    
    See Also:
    
    HRegionServerCommandLine
  - getRegions
```
public java.util.List<HRegion> getRegions(TableName tableName)
```
    Gets the online regions of the specified table. This method looks at the in-memory onlineRegions. It does not go to hbase:meta. Only returns online regions. If a region on this table has been closed during a disable, etc., it will not be included in the returned list. So, the returned list may not necessarily be ALL regions in this table, its all the ONLINE regions in the table.
    
    Specified by:
    
    getRegions in interface OnlineRegions
    
    Parameters:
    
    tableName -
    
    Returns:
    
    Online regions from tableName
  - getRegions
```
public java.util.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 java.util.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 java.lang.String[] getRegionServerCoprocessors()
```
  - closeRegion
```
protected boolean closeRegion(java.lang.String encodedName,
                              boolean abort,
                              ServerName sn)
                       throws NotServingRegionException
```
    Close asynchronously a region, can be called from the master or internally by the regionserver when stopping. If called from the master, the region will update the znode status.
    If an opening was in progress, this method will cancel it, but will not start a new close. The coprocessors are not called in this case. A NotServingRegionException exception is thrown.
    
    If a close was in progress, this new request will be ignored, and an exception thrown.
    
    Parameters:
    
    encodedName - Region to close
    
    abort - True if we are aborting
    
    Returns:
    
    True if closed a region.
    
    Throws:
    
    NotServingRegionException - if the region is not online
  - closeAndOfflineRegionForSplitOrMerge
```
protected boolean closeAndOfflineRegionForSplitOrMerge(java.util.List<java.lang.String> regionEncodedName)
                                                throws java.io.IOException
```
    Close and offline the region for split or merge
    
    Parameters:
    
    regionEncodedName - the name of the region(s) to close
    
    Returns:
    
    true if closed the region successfully.
    
    Throws:
    
    java.io.IOException
  - getOnlineRegion
```
public HRegion 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 java.net.InetSocketAddress[] getRegionBlockLocations(java.lang.String encodedRegionName)
```
  - getRegion
```
public HRegion getRegion(java.lang.String encodedRegionName)
```
    Description copied from interface: OnlineRegions
    
    Return Region instance. Only works if caller is in same context, in same JVM. Region is not serializable.
    
    Specified by:
    
    getRegion in interface OnlineRegions
    
    Returns:
    
    Region for the passed encoded encodedRegionName or null if named region is not member of the online regions.
  - removeRegion
```
public boolean removeRegion(HRegion r,
                            ServerName destination)
```
    Description copied from interface: MutableOnlineRegions
    
    Removes the given Region from the list of onlineRegions.
    
    Specified by:
    
    removeRegion in interface MutableOnlineRegions
    
    Parameters:
    
    r - Region to remove.
    
    destination - Destination, if any, null otherwise.
    
    Returns:
    
    True if we removed a region from online list.
  - getRegion
```
protected HRegion getRegion(byte[] regionName)
                     throws NotServingRegionException
```
    Protected Utility method for safely obtaining an HRegion handle.
    
    Parameters:
    
    regionName - Name of online HRegion to return
    
    Returns:
    
    HRegion for regionName
    
    Throws:
    
    NotServingRegionException
  - getRegionByEncodedName
```
public HRegion getRegionByEncodedName(java.lang.String encodedRegionName)
                               throws NotServingRegionException
```
    Throws:
    
    NotServingRegionException
  - getRegionByEncodedName
```
protected HRegion getRegionByEncodedName(byte[] regionName,
                                         java.lang.String encodedRegionName)
                                  throws NotServingRegionException
```
    Throws:
    
    NotServingRegionException
  - convertThrowableToIOE
```
protected java.io.IOException convertThrowableToIOE(java.lang.Throwable t,
                                                    java.lang.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(java.lang.String encodedRegionName,
                                            java.util.List<org.apache.hadoop.hbase.shaded.protobuf.generated.HBaseProtos.ServerName> favoredNodes)
```
    Description copied from interface: FavoredNodesForRegion
    
    Used to update the favored nodes mapping when required.
    
    Specified by:
    
    updateRegionFavoredNodesMapping in interface FavoredNodesForRegion
  - getFavoredNodesForRegion
```
public java.net.InetSocketAddress[] getFavoredNodesForRegion(java.lang.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(java.lang.String encodedName,
                                 ServerName destination,
                                 long closeSeqNum)
```
  - cleanMovedRegions
```
protected void cleanMovedRegions()
```
    Remove the expired entries from the moved regions list.
  - movedRegionCleanerPeriod
```
protected int movedRegionCleanerPeriod()
```
  - getCompactSplitThread
```
public CompactSplit getCompactSplitThread()
```
    Returns:
    
    the underlying CompactSplit for the servers
  - execRegionServerService
```
public CoprocessorServiceResponse execRegionServerService(RpcController controller,
                                                          CoprocessorServiceRequest serviceRequest)
                                                   throws ServiceException
```
    Throws:
    
    ServiceException
  - getCacheConfig
```
public CacheConfig getCacheConfig()
```
    Returns:
    
    The cache config instance used by the regionserver.
  - getConfigurationManager
```
protected ConfigurationManager getConfigurationManager()
```
    Returns:
    
    : Returns the ConfigurationManager object for testing purposes.
  - getTableDescriptors
```
public TableDescriptors getTableDescriptors()
```
    Returns:
    
    Return table descriptors implementation.
  - updateConfiguration
```
public void updateConfiguration()
```
    Reload the configuration from disk.
  - clearRegionBlockCache
```
public CacheEvictionStats clearRegionBlockCache(Region region)
```
  - getCompactionPressure
```
public double getCompactionPressure()
```
    Specified by:
    
    getCompactionPressure in interface RegionServerServices
    
    Returns:
    
    the max compaction pressure of all stores on this regionserver. The value should be greater than or equal to 0.0, and any value greater than 1.0 means we enter the emergency state that some stores have too many store files.
    
    See Also:
    
    Store.getCompactionPressure()
  - getHeapMemoryManager
```
public HeapMemoryManager getHeapMemoryManager()
```
    Specified by:
    
    getHeapMemoryManager in interface RegionServerServices
    
    Returns:
    
    heap memory manager instance
  - walRollRequestFinished
```
public boolean walRollRequestFinished()
```
    For testing
    
    Returns:
    
    whether all wal roll request finished for this regionserver
  - getFlushThroughputController
```
public ThroughputController getFlushThroughputController()
```
    Specified by:
    
    getFlushThroughputController in interface RegionServerServices
    
    Returns:
    
    the controller to avoid flush too fast
  - getFlushPressure
```
public double getFlushPressure()
```
    Specified by:
    
    getFlushPressure in interface RegionServerServices
    
    Returns:
    
    the flush pressure of all stores on this regionserver. The value should be greater than or equal to 0.0, and any value greater than 1.0 means we enter the emergency state that global memstore size already exceeds lower limit.
  - onConfigurationChange
```
public void onConfigurationChange(Configuration newConf)
```
    Description copied from interface: ConfigurationObserver
    
    This method would be called by the ConfigurationManager object when the Configuration object is reloaded from disk.
    
    Specified by:
    
    onConfigurationChange in interface ConfigurationObserver
  - getMetrics
```
public MetricsRegionServer getMetrics()
```
    Specified by:
    
    getMetrics in interface RegionServerServices
    
    Returns:
    
    the metrics tracker for the region server
  - getSecureBulkLoadManager
```
public SecureBulkLoadManager getSecureBulkLoadManager()
```
    Specified by:
    
    getSecureBulkLoadManager in interface RegionServerServices
    
    Returns:
    
    RegionServer's instance of SecureBulkLoadManager
  - regionLock
```
public EntityLock regionLock(java.util.List<RegionInfo> regionInfos,
                             java.lang.String description,
                             Abortable abort)
                      throws java.io.IOException
```
    Description copied from interface: RegionServerServices
    
    Master based locks on namespaces/tables/regions.
    
    Specified by:
    
    regionLock in interface RegionServerServices
    
    Throws:
    
    java.io.IOException
  - unassign
```
public void unassign(byte[] regionName)
              throws java.io.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:
    
    java.io.IOException
  - getRegionServerSpaceQuotaManager
```
public RegionServerSpaceQuotaManager getRegionServerSpaceQuotaManager()
```
    Specified by:
    
    getRegionServerSpaceQuotaManager in interface RegionServerServices
    
    Returns:
    
    RegionServer's instance of RegionServerSpaceQuotaManager
  - reportFileArchivalForQuotas
```
public boolean reportFileArchivalForQuotas(TableName tableName,
                                           java.util.Collection<java.util.Map.Entry<java.lang.String,java.lang.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(Configuration conf)
                            throws java.io.IOException
```
    Specified by:
    
    createConnection in interface Server
    
    Throws:
    
    java.io.IOException

Class HRegionServer

Nested Class Summary

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

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

TEST_SKIP_REPORTING_TRANSITION

regionsInTransitionInRS

cacheFlusher

hMemManager

clusterConnection

metaTableLocator

tableDescriptors

replicationSourceHandler

replicationSinkHandler

compactSplitThread

onlineRegions

regionFavoredNodesMap

leases

executorService

fsOk

fs

walFs

conf

lock

threadWakeFrequency

msgInterval

numRegionsToReport

infoServer

REGIONSERVER

walFactory

walRoller

zooKeeper

clusterStatusTracker

sleeper

cacheConfig

serverName

useThisHostnameInstead

MASTER_HOSTNAME_KEY

startcode

clusterId

rpcServices

csm

configurationManager

secureBulkLoadManager

fsUtilizationChore

movedRegions

Constructor Detail

HRegionServer

Method Detail

getUseThisHostnameInstead

getFsTableDescriptors

getMetaTableObserver

login

waitForMasterActive

getProcessName

canCreateBaseZNode

canUpdateTableDescriptor

createRpcServices

configureInfoServer

getDumpServlet

registerService

createClusterConnection

getClusterId

setupClusterConnection

isClusterUp

run

tryRegionServerReport

reportRegionSizesForQuotas

handleReportForDutyResponse

initializeMemStoreChunkCreator

getRegionServerAccounting

createRegionLoad

isOnline

getRegionServerMetrics

getMasterAddressTracker

getWALs

getWAL