HRegionServer (Hortonworks Data Platform Apache HBase Java API Reference)

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

All Implemented Interfaces:

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

Direct Known Subclasses:

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

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

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 static String`	`CLOSE`
`protected ClusterConnection`	`clusterConnection` Cluster connection to be shared by services.
`protected ClusterStatusTracker`	`clusterStatusTracker`
`CompactSplitThread`	`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 BaseCoordinatedStateManager`	`csm`
`protected HFileSystem`	`fs`
`protected boolean`	`fsOk`
`protected HeapMemoryManager`	`hMemManager`
`protected InfoServer`	`infoServer`
`protected Leases`	`leases`
`protected ReentrantReadWriteLock`	`lock`
`static Log`	`LOG`
`protected MetaTableLocator`	`metaTableLocator`
`protected Map<String,org.apache.hadoop.hbase.regionserver.HRegionServer.MovedRegionInfo>`	`movedRegions`
`protected int`	`msgInterval`
`protected int`	`numRegionsToReport`
`protected Map<String,Region>`	`onlineRegions` Map of regions currently being served by this region server.
`protected static String`	`OPEN`
`protected Map<String,Region>`	`recoveringRegions` Set of regions currently being in recovering state which means it can accept writes(edits from previous failed region server) but not reads.
`protected Map<String,InetSocketAddress[]>`	`regionFavoredNodesMap` Map of encoded region names to the DataNode locations they should be hosted on We store the value as InetSocketAddress since this is used only in HDFS API (create() that takes favored nodes as hints for placing file blocks).
`static String`	`REGIONSERVER` region server process name
`protected ConcurrentMap<byte[],Boolean>`	`regionsInTransitionInRS`
`protected ReplicationSinkService`	`replicationSinkHandler`
`protected ReplicationSourceService`	`replicationSourceHandler`
`protected RSRpcServices`	`rpcServices`
`protected ServerName`	`serverName` The server name the Master sees us as.
`protected ExecutorService`	`service`
`protected Sleeper`	`sleeper`
`protected long`	`startcode` This servers startcode.
`protected TableDescriptors`	`tableDescriptors` Go here to get table descriptors.
`protected TableLockManager`	`tableLockManager`
`protected int`	`threadWakeFrequency`
`protected WALFactory`	`walFactory`
`protected ZooKeeperWatcher`	`zooKeeper`

Constructor Summary

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

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`abort(String reason)`
`void`	`abort(String reason, Throwable cause)` Cause the server to exit without closing the regions it is serving, the log it is using and without notifying the master.
`protected void`	`addToMovedRegions(String encodedName, ServerName destination, long closeSeqNum)`
`void`	`addToOnlineRegions(Region region)` Add to online regions.
`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.
`protected void`	`closeAllRegions(boolean abort)` Closes all regions.
`protected boolean`	`closeRegion(String encodedName, boolean abort, CloseRegionCoordination.CloseRegionDetails crd, ServerName sn)` Close asynchronously a region, can be called from the master or internally by the regionserver when stopping.
`protected void`	`configureInfoServer()`
`static HRegionServer`	`constructRegionServer(Class<? extends HRegionServer> regionServerClass, Configuration conf2, CoordinatedStateManager cp)` Utility for constructing an instance of the passed HRegionServer class.
`protected IOException`	`convertThrowableToIOE(Throwable t, String msg)`
`protected ClusterConnection`	`createClusterConnection()` Create a 'smarter' HConnection, one that is capable of by-passing RPC if the request is to the local server.
`ClusterStatusProtos.RegionLoad`	`createRegionLoad(String encodedRegionName)`
`protected ServerName`	`createRegionServerStatusStub()` Get the current master from ZooKeeper and open the RPC connection to it.
`protected RSRpcServices`	`createRpcServices()`
`protected void`	`doMetrics()`
`protected LogRoller`	`ensureMetaWALRoller()` We initialize the roller for the wal that handles meta lazily since we don't know if this regionserver will handle it.
`ClientProtos.CoprocessorServiceResponse`	`execRegionServerService(RpcController controller, ClientProtos.CoprocessorServiceRequest serviceRequest)`
`CacheConfig`	`getCacheConfig()`
`ChoreService`	`getChoreService()`
`String`	`getClusterId()`
`double`	`getCompactionPressure()`
`CompactionRequestor`	`getCompactionRequester()`
`CompactSplitThread`	`getCompactSplitThread()`
`Configuration`	`getConfiguration()` Gets the configuration object for this server.
`protected ConfigurationManager`	`getConfigurationManager()`
`ClusterConnection`	`getConnection()` Returns a reference to the servers' cluster connection.
`BaseCoordinatedStateManager`	`getCoordinatedStateManager()` Get CoordinatedStateManager instance for this server.
`protected Class<? extends HttpServlet>`	`getDumpServlet()`
`ExecutorService`	`getExecutorService()`
`InetSocketAddress[]`	`getFavoredNodesForRegion(String encodedRegionName)` Return the favored nodes for a region given its encoded name.
`FileSystem`	`getFileSystem()`
`FlushRequester`	`getFlushRequester()`
`Region`	`getFromOnlineRegions(String encodedRegionName)` Return `Region` instance.
`HeapMemoryManager`	`getHeapMemoryManager()`
`InfoServer`	`getInfoServer()`
`ClusterStatusProtos.RegionStoreSequenceIds`	`getLastSequenceId(byte[] encodedRegionName)`
`Leases`	`getLeases()`
`MasterAddressTracker`	`getMasterAddressTracker()`
`MetaTableLocator`	`getMetaTableLocator()` Returns instance of `MetaTableLocator` running inside this server.
`protected HRegionInfo[]`	`getMostLoadedRegions()` Get the top N most loaded regions this server is serving so we can tell the master which regions it can reallocate if we're overloaded.
`ServerNonceManager`	`getNonceManager()` Only required for "old" log replay; if it's removed, remove this.
`int`	`getNumberOfOnlineRegions()`
`Region`	`getOnlineRegion(byte[] regionName)`
`List<Region>`	`getOnlineRegions(TableName tableName)` Gets the online regions of the specified table.
`Collection<Region>`	`getOnlineRegionsLocalContext()` For tests, web ui and metrics.
`Set<TableName>`	`getOnlineTables()` Gets the online tables in this RS.
`protected String`	`getProcessName()`
`Map<String,Region>`	`getRecoveringRegions()`
`protected Region`	`getRegion(byte[] regionName)` Protected utility method for safely obtaining an HRegion handle.
`InetSocketAddress[]`	`getRegionBlockLocations(String encodedRegionName)`
`protected Region`	`getRegionByEncodedName(byte[] regionName, String encodedRegionName)`
`Region`	`getRegionByEncodedName(String encodedRegionName)`
`RegionServerAccounting`	`getRegionServerAccounting()`
`RegionServerCoprocessorHost`	`getRegionServerCoprocessorHost()`
`String[]`	`getRegionServerCoprocessors()`
`MetricsRegionServer`	`getRegionServerMetrics()`
`RegionServerQuotaManager`	`getRegionServerQuotaManager()`
`ConcurrentMap<byte[],Boolean>`	`getRegionsInTransitionInRS()` Get the regions that are currently being opened or closed in the RS
`protected Path`	`getRootDir()`
`RpcServerInterface`	`getRpcServer()` Returns a reference to the region server's RPC server
`RSRpcServices`	`getRSRpcServices()`
`ServerName`	`getServerName()`
`long`	`getStartcode()`
`TableDescriptors`	`getTableDescriptors()`
`TableLockManager`	`getTableLockManager()`
`int`	`getThreadWakeFrequency()` Interval at which threads should run
`WAL`	`getWAL(HRegionInfo regionInfo)`
`ZooKeeperWatcher`	`getZooKeeper()` Gets the ZooKeeper instance for this server.
`protected void`	`handleReportForDutyResponse(RegionServerStatusProtos.RegionServerStartupResponse c)`
`boolean`	`isAborted()` Check if the server or client was aborted.
`boolean`	`isOnline()` Report the status of the server.
`boolean`	`isStopped()`
`boolean`	`isStopping()`
`protected void`	`kill()`
`protected void`	`login(UserProvider user, String host)`
`static void`	`main(String[] args)`
`protected int`	`movedRegionCleanerPeriod()`
`void`	`postOpenDeployTasks(Region r)` Tasks to perform after region open to complete deploy of region on regionserver
`void`	`postOpenDeployTasks(RegionServerServices.PostOpenDeployContext context)` Tasks to perform after region open to complete deploy of region on regionserver
`boolean`	`registerService(Service instance)` Registers a new protocol buffer `Service` subclass as a coprocessor endpoint to be available for handling
`boolean`	`removeFromOnlineRegions(Region r, ServerName destination)` This method removes Region corresponding to hri from the Map of onlineRegions.
`boolean`	`reportRegionStateTransition(RegionServerServices.RegionStateTransitionContext context)` Notify master that a handler requests to change a region state
`boolean`	`reportRegionStateTransition(RegionServerStatusProtos.RegionStateTransition.TransitionCode code, HRegionInfo... hris)` Notify master that a handler requests to change a region state
`boolean`	`reportRegionStateTransition(RegionServerStatusProtos.RegionStateTransition.TransitionCode code, long openSeqNum, HRegionInfo... hris)` Notify master that a handler requests to change a region state
`void`	`run()` The HRegionServer sticks in this loop until closed.
`protected void`	`sendShutdownInterrupt()` Called on stop/abort before closing the cluster connection and meta locator.
`protected void`	`setupClusterConnection()` Setup our cluster connection if not already initialized.
`protected boolean`	`shouldUseThisHostnameInstead()`
`void`	`stop(String msg)` Stop this service.
`protected void`	`stopServiceThreads()` Wait on all threads to finish.
`String`	`toString()`
`protected void`	`tryRegionServerReport(long reportStartTime, long reportEndTime)`
`void`	`updateConfiguration()` Reload the configuration from disk.
`void`	`updateRegionFavoredNodesMapping(String encodedRegionName, List<HBaseProtos.ServerName> favoredNodes)` Used to update the favored nodes mapping when required.
`protected void`	`waitForMasterActive()`
`void`	`waitForServerOnline()`

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

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

- Field Detail
  - LOG
```
public static final Log LOG
```
  - OPEN
```
protected static final String OPEN
```
    See Also:
    
    Constant Field Values
  - CLOSE
```
protected static final String CLOSE
```
    See Also:
    
    Constant Field Values
  - regionsInTransitionInRS
```
protected final ConcurrentMap<byte[],Boolean> regionsInTransitionInRS
```
  - cacheFlusher
```
protected 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.
  - metaTableLocator
```
protected MetaTableLocator metaTableLocator
```
  - tableDescriptors
```
protected TableDescriptors tableDescriptors
```
    Go here to get table descriptors.
  - replicationSourceHandler
```
protected ReplicationSourceService replicationSourceHandler
```
  - replicationSinkHandler
```
protected ReplicationSinkService replicationSinkHandler
```
  - compactSplitThread
```
public CompactSplitThread compactSplitThread
```
  - onlineRegions
```
protected final Map<String,Region> onlineRegions
```
    Map of regions currently being served by this region server. Key is the encoded region name. All access should be synchronized.
  - regionFavoredNodesMap
```
protected final Map<String,InetSocketAddress[]> regionFavoredNodesMap
```
    Map of encoded region names to the DataNode locations they should be hosted on We store the value as InetSocketAddress since this is used only in HDFS API (create() that takes favored nodes as hints for placing file blocks). We could have used ServerName here as the value class, but we'd need to convert it to InetSocketAddress at some point before the HDFS API call, and it seems a bit weird to store ServerName since ServerName refers to RegionServers and here we really mean DataNode locations.
  - recoveringRegions
```
protected final Map<String,Region> recoveringRegions
```
    Set of regions currently being in recovering state which means it can accept writes(edits from previous failed region server) but not reads. A recovering region is also an online region.
  - leases
```
protected Leases leases
```
  - service
```
protected ExecutorService service
```
  - fsOk
```
protected volatile boolean fsOk
```
  - fs
```
protected HFileSystem fs
```
  - conf
```
protected final Configuration conf
```
  - lock
```
protected final 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 String REGIONSERVER
```
    region server process name
    
    See Also:
    
    Constant Field Values
  - walFactory
```
protected volatile WALFactory walFactory
```
  - zooKeeper
```
protected ZooKeeperWatcher zooKeeper
```
  - clusterStatusTracker
```
protected 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.
  - startcode
```
protected final long startcode
```
    This servers startcode.
  - tableLockManager
```
protected TableLockManager tableLockManager
```
  - rpcServices
```
protected final RSRpcServices rpcServices
```
  - csm
```
protected BaseCoordinatedStateManager 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.
  - movedRegions
```
protected Map<String,org.apache.hadoop.hbase.regionserver.HRegionServer.MovedRegionInfo> movedRegions
```
- Constructor Detail
  - HRegionServer
```
public HRegionServer(Configuration conf)
              throws IOException,
                     InterruptedException
```
    Starts a HRegionServer at the default location.
    
    Parameters:
    
    conf -
    
    Throws:
    
    IOException
    
    InterruptedException
  - HRegionServer
```
public HRegionServer(Configuration conf,
                     CoordinatedStateManager csm)
              throws IOException,
                     InterruptedException
```
    Starts a HRegionServer at the default location
    
    Parameters:
    
    conf -
    
    csm - implementation of CoordinatedStateManager to be used
    
    Throws:
    
    IOException
    
    InterruptedException
- Method Detail
  - shouldUseThisHostnameInstead
```
protected boolean shouldUseThisHostnameInstead()
```
  - login
```
protected void login(UserProvider user,
                     String host)
              throws IOException
```
    Throws:
    
    IOException
  - waitForMasterActive
```
protected void waitForMasterActive()
```
  - getProcessName
```
protected String getProcessName()
```
  - canCreateBaseZNode
```
protected boolean canCreateBaseZNode()
```
  - canUpdateTableDescriptor
```
protected boolean canUpdateTableDescriptor()
```
  - createRpcServices
```
protected RSRpcServices createRpcServices()
                                   throws IOException
```
    Throws:
    
    IOException
  - configureInfoServer
```
protected void configureInfoServer()
```
  - getDumpServlet
```
protected Class<? extends HttpServlet> getDumpServlet()
```
  - doMetrics
```
protected void doMetrics()
```
  - registerService
```
public boolean registerService(Service instance)
```
    Description copied from interface: RegionServerServices
    
    Registers a new protocol buffer Service subclass as a coprocessor endpoint to be available for handling
    
    Specified by:
    
    registerService in interface RegionServerServices
    
    Parameters:
    
    instance - the Service subclass instance to expose as a coprocessor endpoint
    
    Returns:
    
    true if the registration was successful, false
  - createClusterConnection
```
protected ClusterConnection createClusterConnection()
                                             throws IOException
```
    Create a 'smarter' HConnection, one that is capable of by-passing RPC if the request is to the local server. Safe to use going to local or remote server. Create this instance in a method can be intercepted and mocked in tests.
    
    Throws:
    
    IOException
  - getClusterId
```
public String getClusterId()
```
  - setupClusterConnection
```
protected void setupClusterConnection()
                               throws IOException
```
    Setup our cluster connection if not already initialized.
    
    Throws:
    
    IOException
  - run
```
public void run()
```
    The HRegionServer sticks in this loop until closed.
    
    Specified by:
    
    run in interface Runnable
    
    Specified by:
    
    run in class HasThread
  - tryRegionServerReport
```
protected void tryRegionServerReport(long reportStartTime,
                                     long reportEndTime)
                              throws IOException
```
    Throws:
    
    IOException
  - handleReportForDutyResponse
```
protected void handleReportForDutyResponse(RegionServerStatusProtos.RegionServerStartupResponse c)
                                    throws IOException
```
    Throws:
    
    IOException
  - getRegionServerAccounting
```
public RegionServerAccounting getRegionServerAccounting()
```
    Specified by:
    
    getRegionServerAccounting in interface RegionServerServices
    
    Returns:
    
    the RegionServerAccounting for this Region Server
  - getTableLockManager
```
public TableLockManager getTableLockManager()
```
    Specified by:
    
    getTableLockManager in interface RegionServerServices
    
    Returns:
    
    RegionServer's instance of TableLockManager
  - createRegionLoad
```
public ClusterStatusProtos.RegionLoad createRegionLoad(String encodedRegionName)
                                                throws IOException
```
    Parameters:
    
    encodedRegionName -
    
    Returns:
    
    An instance of RegionLoad.
    
    Throws:
    
    IOException
  - isOnline
```
public boolean isOnline()
```
    Report the status of the server. A server is online once all the startup is completed (setting up filesystem, starting service threads, etc.). This method is designed mostly to be useful in tests.
    
    Returns:
    
    true if online, false if not.
  - ensureMetaWALRoller
```
protected LogRoller ensureMetaWALRoller()
```
    We initialize the roller for the wal that handles meta lazily since we don't know if this regionserver will handle it. All calls to this method return a reference to the that same roller. As newly referenced meta regions are brought online, they will be offered to the roller for maintenance. As a part of that registration process, the roller will add itself as a listener on the wal.
  - getRegionServerMetrics
```
public MetricsRegionServer getRegionServerMetrics()
```
  - getMasterAddressTracker
```
public MasterAddressTracker getMasterAddressTracker()
```
    Returns:
    
    Master address tracker instance.
  - getWAL
```
public WAL getWAL(HRegionInfo regionInfo)
           throws IOException
```
    Specified by:
    
    getWAL in interface RegionServerServices
    
    Returns:
    
    the WAL for a particular region. Pass null for getting the default (common) WAL
    
    Throws:
    
    IOException
  - getConnection
```
public ClusterConnection getConnection()
```
    Description copied from interface: Server
    
    Returns a reference to the servers' cluster connection. Important note: this method returns a reference to Connection which is managed by Server itself, so callers must NOT attempt to close connection obtained.
    
    Specified by:
    
    getConnection in interface Server
  - getMetaTableLocator
```
public MetaTableLocator getMetaTableLocator()
```
    Description copied from interface: Server
    
    Returns instance of MetaTableLocator running inside this server. This MetaServerLocator is started and stopped by server, clients shouldn't manage it's lifecycle.
    
    Specified by:
    
    getMetaTableLocator in interface Server
    
    Returns:
    
    instance of MetaTableLocator associated with this server.
  - stop
```
public void stop(String msg)
```
    Description copied from interface: Stoppable
    
    Stop this service.
    
    Specified by:
    
    stop in interface Stoppable
    
    Parameters:
    
    msg - Why we're stopping.
  - waitForServerOnline
```
public void waitForServerOnline()
```
  - postOpenDeployTasks
```
public void postOpenDeployTasks(Region r)
                         throws KeeperException,
                                IOException
```
    Description copied from interface: RegionServerServices
    
    Tasks to perform after region open to complete deploy of region on regionserver
    
    Specified by:
    
    postOpenDeployTasks in interface RegionServerServices
    
    Parameters:
    
    r - Region to open.
    
    Throws:
    
    KeeperException
    
    IOException
  - postOpenDeployTasks
```
public void postOpenDeployTasks(RegionServerServices.PostOpenDeployContext context)
                         throws KeeperException,
                                IOException
```
    Description copied from interface: RegionServerServices
    
    Tasks to perform after region open to complete deploy of region on regionserver
    
    Specified by:
    
    postOpenDeployTasks in interface RegionServerServices
    
    Parameters:
    
    context - the context
    
    Throws:
    
    KeeperException
    
    IOException
  - reportRegionStateTransition
```
public boolean reportRegionStateTransition(RegionServerStatusProtos.RegionStateTransition.TransitionCode code,
                                           HRegionInfo... hris)
```
    Description copied from interface: RegionServerServices
    
    Notify master that a handler requests to change a region state
    
    Specified by:
    
    reportRegionStateTransition in interface RegionServerServices
  - reportRegionStateTransition
```
public boolean reportRegionStateTransition(RegionServerStatusProtos.RegionStateTransition.TransitionCode code,
                                           long openSeqNum,
                                           HRegionInfo... hris)
```
    Description copied from interface: RegionServerServices
    
    Notify master that a handler requests to change a region state
    
    Specified by:
    
    reportRegionStateTransition in interface RegionServerServices
  - reportRegionStateTransition
```
public boolean reportRegionStateTransition(RegionServerServices.RegionStateTransitionContext context)
```
    Description copied from interface: RegionServerServices
    
    Notify master that a handler requests to change a region state
    
    Specified by:
    
    reportRegionStateTransition in interface RegionServerServices
  - getRpcServer
```
public RpcServerInterface getRpcServer()
```
    Description copied from interface: RegionServerServices
    
    Returns a reference to the region server's RPC server
    
    Specified by:
    
    getRpcServer in interface RegionServerServices
  - getRSRpcServices
```
public RSRpcServices getRSRpcServices()
```
  - abort
```
public void abort(String reason,
                  Throwable cause)
```
    Cause the server to exit without closing the regions it is serving, the log it is using and without notifying the master. Used unit testing and on catastrophic events such as HDFS is yanked out from under hbase or we OOME.
    
    Specified by:
    
    abort in interface Abortable
    
    Parameters:
    
    reason - the reason we are aborting
    
    cause - the exception that caused the abort, or null
  - abort
```
public void abort(String reason)
```
    See Also:
    
    abort(String, Throwable)
  - isAborted
```
public boolean isAborted()
```
    Description copied from interface: Abortable
    
    Check if the server or client was aborted.
    
    Specified by:
    
    isAborted in interface Abortable
    
    Returns:
    
    true if the server or client was aborted, false otherwise
  - kill
```
protected void kill()
```
  - sendShutdownInterrupt
```
protected void sendShutdownInterrupt()
```
    Called on stop/abort before closing the cluster connection and meta locator.
  - stopServiceThreads
```
protected void stopServiceThreads()
```
    Wait on all threads to finish. Presumption is that all closes and stops have already been called.
  - 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
  - getLastSequenceId
```
public ClusterStatusProtos.RegionStoreSequenceIds getLastSequenceId(byte[] encodedRegionName)
```
    Specified by:
    
    getLastSequenceId in interface LastSequenceId
    
    Parameters:
    
    encodedRegionName - Encoded region name
    
    Returns:
    
    Last flushed sequence Id for region and its stores. Id will be -1 if it can't be determined
  - closeAllRegions
```
protected void closeAllRegions(boolean abort)
```
    Closes all regions. Called on our way out. Assumes that its not possible for new regions to be added to onlineRegions while this method runs.
  - getInfoServer
```
public InfoServer getInfoServer()
```
    Returns:
    
    the info server
  - isStopped
```
public boolean isStopped()
```
    Specified by:
    
    isStopped in interface Stoppable
    
    Returns:
    
    true if a stop has been requested.
  - isStopping
```
public boolean isStopping()
```
    Specified by:
    
    isStopping in interface RegionServerServices
    
    Returns:
    
    True if this regionserver is stopping.
  - getRecoveringRegions
```
public Map<String,Region> getRecoveringRegions()
```
    Specified by:
    
    getRecoveringRegions in interface RegionServerServices
    
    Returns:
    
    set of recovering regions on the hosting region server
  - getConfiguration
```
public 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 Collection<Region> getOnlineRegionsLocalContext()
```
    For tests, web ui and metrics. This method will only work if HRegionServer is in the same JVM as client; HRegion cannot be serialized to cross an rpc.
  - addToOnlineRegions
```
public void addToOnlineRegions(Region region)
```
    Description copied from interface: OnlineRegions
    
    Add to online regions.
    
    Specified by:
    
    addToOnlineRegions in interface OnlineRegions
  - getStartcode
```
public long getStartcode()
```
    Returns:
    
    time stamp in millis of when this region server was started
  - getFlushRequester
```
public FlushRequester getFlushRequester()
```
    Specified by:
    
    getFlushRequester in interface RegionServerServices
    
    Returns:
    
    reference to FlushRequester
  - getMostLoadedRegions
```
protected HRegionInfo[] getMostLoadedRegions()
```
    Get the top N most loaded regions this server is serving so we can tell the master which regions it can reallocate if we're overloaded. TODO: actually calculate which regions are most loaded. (Right now, we're just grabbing the first N regions being served regardless of load.)
  - getLeases
```
public Leases getLeases()
```
    Specified by:
    
    getLeases in interface RegionServerServices
    
    Returns:
    
    The RegionServer's "Leases" service
  - getRootDir
```
protected Path getRootDir()
```
    Returns:
    
    Return the rootDir.
  - getFileSystem
```
public FileSystem getFileSystem()
```
    Specified by:
    
    getFileSystem in interface RegionServerServices
    
    Returns:
    
    Return the fs.
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - getThreadWakeFrequency
```
public int getThreadWakeFrequency()
```
    Interval at which threads should run
    
    Returns:
    
    the interval
  - getZooKeeper
```
public ZooKeeperWatcher getZooKeeper()
```
    Description copied from interface: Server
    
    Gets the ZooKeeper instance for this server.
    
    Specified by:
    
    getZooKeeper in interface Server
  - getCoordinatedStateManager
```
public BaseCoordinatedStateManager getCoordinatedStateManager()
```
    Description copied from interface: Server
    
    Get CoordinatedStateManager instance for this server.
    
    Specified by:
    
    getCoordinatedStateManager in interface Server
  - getServerName
```
public ServerName getServerName()
```
    Specified by:
    
    getServerName in interface Server
    
    Returns:
    
    The unique server name for this server.
  - getCompactionRequester
```
public CompactionRequestor getCompactionRequester()
```
    Specified by:
    
    getCompactionRequester in interface RegionServerServices
    
    Returns:
    
    Implementation of CompactionRequestor or null.
  - getRegionServerCoprocessorHost
```
public RegionServerCoprocessorHost getRegionServerCoprocessorHost()
```
  - getRegionsInTransitionInRS
```
public ConcurrentMap<byte[],Boolean> getRegionsInTransitionInRS()
```
    Description copied from interface: RegionServerServices
    
    Get the regions that are currently being opened or closed in the RS
    
    Specified by:
    
    getRegionsInTransitionInRS in interface RegionServerServices
    
    Returns:
    
    map of regions in transition in this RS
  - getExecutorService
```
public ExecutorService getExecutorService()
```
    Specified by:
    
    getExecutorService in interface RegionServerServices
    
    Returns:
    
    hbase executor service
  - getChoreService
```
public ChoreService getChoreService()
```
    Specified by:
    
    getChoreService in interface Server
    
    Returns:
    
    The ChoreService instance for this server
  - getRegionServerQuotaManager
```
public RegionServerQuotaManager getRegionServerQuotaManager()
```
    Specified by:
    
    getRegionServerQuotaManager in interface RegionServerServices
    
    Returns:
    
    RegionServer's instance of RegionServerQuotaManager
  - constructRegionServer
```
public static HRegionServer constructRegionServer(Class<? extends HRegionServer> regionServerClass,
                                                  Configuration conf2,
                                                  CoordinatedStateManager cp)
```
    Utility for constructing an instance of the passed HRegionServer class.
    
    Parameters:
    
    regionServerClass -
    
    conf2 -
    
    Returns:
    
    HRegionServer instance.
  - main
```
public static void main(String[] args)
                 throws Exception
```
    Throws:
    
    Exception
    
    See Also:
    
    HRegionServerCommandLine
  - getOnlineRegions
```
public List<Region> getOnlineRegions(TableName tableName)
```
    Gets the online regions of the specified table. This method looks at the in-memory onlineRegions. It does not go to hbase:meta. Only returns online regions. If a region on this table has been closed during a disable, etc., it will not be included in the returned list. So, the returned list may not necessarily be ALL regions in this table, its all the ONLINE regions in the table.
    
    Specified by:
    
    getOnlineRegions in interface OnlineRegions
    
    Parameters:
    
    tableName -
    
    Returns:
    
    Online regions from tableName
  - getOnlineTables
```
public Set<TableName> getOnlineTables()
```
    Gets the online tables in this RS. This method looks at the in-memory onlineRegions.
    
    Specified by:
    
    getOnlineTables in interface RegionServerServices
    
    Returns:
    
    all the online tables in this RS
  - getRegionServerCoprocessors
```
public String[] getRegionServerCoprocessors()
```
  - closeRegion
```
protected boolean closeRegion(String encodedName,
                              boolean abort,
                              CloseRegionCoordination.CloseRegionDetails crd,
                              ServerName sn)
                       throws NotServingRegionException,
                              RegionAlreadyInTransitionException
```
    Close asynchronously a region, can be called from the master or internally by the regionserver when stopping. If called from the master, the region will update the znode status.
    If an opening was in progress, this method will cancel it, but will not start a new close. The coprocessors are not called in this case. A NotServingRegionException exception is thrown.
    
    If a close was in progress, this new request will be ignored, and an exception thrown.
    
    Parameters:
    
    encodedName - Region to close
    
    abort - True if we are aborting
    
    crd - details about closing region coordination-coordinated task
    
    Returns:
    
    True if closed a region.
    
    Throws:
    
    NotServingRegionException - if the region is not online
    
    RegionAlreadyInTransitionException - if the region is already closing
  - getOnlineRegion
```
public Region getOnlineRegion(byte[] regionName)
```
    Parameters:
    
    regionName -
    
    Returns:
    
    HRegion for the passed binary regionName or null if named region is not member of the online regions.
  - getRegionBlockLocations
```
public InetSocketAddress[] getRegionBlockLocations(String encodedRegionName)
```
  - getFromOnlineRegions
```
public Region getFromOnlineRegions(String encodedRegionName)
```
    Description copied from interface: OnlineRegions
    
    Return Region instance. Only works if caller is in same context, in same JVM. Region is not serializable.
    
    Specified by:
    
    getFromOnlineRegions in interface OnlineRegions
    
    Returns:
    
    Region for the passed encoded encodedRegionName or null if named region is not member of the online regions.
  - removeFromOnlineRegions
```
public boolean removeFromOnlineRegions(Region r,
                                       ServerName destination)
```
    Description copied from interface: OnlineRegions
    
    This method removes Region corresponding to hri from the Map of onlineRegions.
    
    Specified by:
    
    removeFromOnlineRegions in interface OnlineRegions
    
    Parameters:
    
    r - Region to remove.
    
    destination - Destination, if any, null otherwise.
    
    Returns:
    
    True if we removed a region from online list.
  - getRegion
```
protected Region getRegion(byte[] regionName)
                    throws NotServingRegionException
```
    Protected utility method for safely obtaining an HRegion handle.
    
    Parameters:
    
    regionName - Name of online Region to return
    
    Returns:
    
    Region for regionName
    
    Throws:
    
    NotServingRegionException
  - getRegionByEncodedName
```
public Region getRegionByEncodedName(String encodedRegionName)
                              throws NotServingRegionException
```
    Throws:
    
    NotServingRegionException
  - getRegionByEncodedName
```
protected Region getRegionByEncodedName(byte[] regionName,
                                        String encodedRegionName)
                                 throws NotServingRegionException
```
    Throws:
    
    NotServingRegionException
  - convertThrowableToIOE
```
protected IOException convertThrowableToIOE(Throwable t,
                                            String msg)
```
  - checkFileSystem
```
public boolean checkFileSystem()
```
    Checks to see if the file system is still accessible. If not, sets abortRequested and stopRequested
    
    Returns:
    
    false if file system is not available
  - updateRegionFavoredNodesMapping
```
public void updateRegionFavoredNodesMapping(String encodedRegionName,
                                            List<HBaseProtos.ServerName> favoredNodes)
```
    Description copied from interface: FavoredNodesForRegion
    
    Used to update the favored nodes mapping when required.
    
    Specified by:
    
    updateRegionFavoredNodesMapping in interface FavoredNodesForRegion
  - getFavoredNodesForRegion
```
public InetSocketAddress[] getFavoredNodesForRegion(String encodedRegionName)
```
    Return the favored nodes for a region given its encoded name. Look at the comment around regionFavoredNodesMap on why it is InetSocketAddress[]
    
    Specified by:
    
    getFavoredNodesForRegion in interface FavoredNodesForRegion
    
    Parameters:
    
    encodedRegionName -
    
    Returns:
    
    array of favored locations
  - getNonceManager
```
public ServerNonceManager getNonceManager()
```
    Description copied from interface: RegionServerServices
    
    Only required for "old" log replay; if it's removed, remove this.
    
    Specified by:
    
    getNonceManager in interface RegionServerServices
    
    Returns:
    
    The RegionServer's NonceManager
  - addToMovedRegions
```
protected void addToMovedRegions(String encodedName,
                                 ServerName destination,
                                 long closeSeqNum)
```
  - cleanMovedRegions
```
protected void cleanMovedRegions()
```
    Remove the expired entries from the moved regions list.
  - movedRegionCleanerPeriod
```
protected int movedRegionCleanerPeriod()
```
  - getCompactSplitThread
```
public CompactSplitThread getCompactSplitThread()
```
    Returns:
    
    the underlying CompactSplitThread for the servers
  - execRegionServerService
```
public ClientProtos.CoprocessorServiceResponse execRegionServerService(RpcController controller,
                                                                       ClientProtos.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.
  - getHeapMemoryManager
```
public HeapMemoryManager getHeapMemoryManager()
```
    Specified by:
    
    getHeapMemoryManager in interface RegionServerServices
    
    Returns:
    
    heap memory manager instance
  - getCompactionPressure
```
public double getCompactionPressure()
```
    Specified by:
    
    getCompactionPressure in interface RegionServerServices
    
    Returns:
    
    the max compaction pressure of all stores on this regionserver. The value should be greater than or equal to 0.0, and any value greater than 1.0 means we enter the emergency state that some stores have too many store files.
    
    See Also:
    
    Store.getCompactionPressure()

Class HRegionServer

Nested Class Summary

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

Field Summary

Constructor Summary

Method Summary

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

Methods inherited from class java.lang.Object

Field Detail

LOG

OPEN

CLOSE

regionsInTransitionInRS

cacheFlusher

hMemManager

clusterConnection

metaTableLocator

tableDescriptors

replicationSourceHandler

replicationSinkHandler

compactSplitThread

onlineRegions

regionFavoredNodesMap

recoveringRegions

leases

service

fsOk

fs

conf

lock

threadWakeFrequency

msgInterval

numRegionsToReport

infoServer

REGIONSERVER

walFactory

zooKeeper

clusterStatusTracker

sleeper

cacheConfig

serverName

startcode

tableLockManager

rpcServices

csm

configurationManager

movedRegions

Constructor Detail

HRegionServer

HRegionServer

Method Detail

shouldUseThisHostnameInstead

login

waitForMasterActive

getProcessName

canCreateBaseZNode

canUpdateTableDescriptor

createRpcServices

configureInfoServer

getDumpServlet

doMetrics

registerService

createClusterConnection

getClusterId

setupClusterConnection

run

tryRegionServerReport

handleReportForDutyResponse

getRegionServerAccounting

getTableLockManager

createRegionLoad

isOnline

ensureMetaWALRoller

getRegionServerMetrics

getMasterAddressTracker

getWAL

getConnection

getMetaTableLocator

stop

waitForServerOnline