HMaster (Apache HBase 1.2.12 API)

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

All Implemented Interfaces:

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

Direct Known Subclasses:

HMasterCommandLine.LocalHMaster
```
@InterfaceAudience.LimitedPrivate(value="Tools")
public class HMaster
extends HRegionServer
implements MasterServices, Server
```
HMaster is the "master server" for HBase. An HBase cluster has one active master. If many masters are started, all compete. Whichever wins goes on to run the cluster. All others park themselves in their constructor until master or cluster shutdown or until the active master loses its lease in zookeeper. Thereafter, all running master jostle to take over master role.
The Master can be asked shutdown the cluster. See shutdown(). In this case it will tell all regionservers to go down and then wait on them all reporting in that they are down. This master will then shut itself down.
You can also shutdown just this master. Call stopMaster().

See Also:
Watcher

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`private static class`	`HMaster.InitializationMonitor` Protection against zombie master.
`private static class`	`HMaster.PeriodicDoMetrics`
`static class`	`HMaster.RedirectServlet`

Nested classes/interfaces inherited from class org.apache.hadoop.hbase.regionserver.HRegionServer
HRegionServer.MovedRegionsCleaner

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

Field Summary

Fields
Modifier and Type	Field and Description
`private ActiveMasterManager`	`activeMasterManager`
`(package private) AssignmentManager`	`assignmentManager`
`(package private) LoadBalancer`	`balancer`
`private BalancerChore`	`balancerChore`
`(package private) CatalogJanitor`	`catalogJanitorChore`
`private ClusterStatusChore`	`clusterStatusChore`
`private ClusterStatusPublisher`	`clusterStatusPublisherChore`
`(package private) Map<String,com.google.protobuf.Service>`	`coprocessorServiceHandlers`
`(package private) MasterCoprocessorHost`	`cpHost`
`private DrainingServerTracker`	`drainingServerTracker`
`private MasterFileSystem`	`fileSystemManager`
`private HFileCleaner`	`hfileCleaner`
`private boolean`	`initializationBeforeMetaAssignment` flag used in test cases in order to simulate RS failures during master initialization
`private MasterProcedureScheduler.ProcedureEvent`	`initialized`
`private boolean`	`isActiveMaster`
`(package private) LoadBalancerTracker`	`loadBalancerTracker`
`private static org.apache.commons.logging.Log`	`LOG`
`private LogCleaner`	`logCleaner`
`static String`	`MASTER`
`private long`	`masterActiveTime`
`private boolean`	`masterCheckCompression`
`private boolean`	`masterCheckEncryption`
`private org.mortbay.jetty.Server`	`masterJettyServer` jetty server for master to redirect requests to regionserver infoServer
`(package private) MetricsMaster`	`metricsMaster`
`(package private) MasterProcedureManagerHost`	`mpmHost`
`private RegionNormalizer`	`normalizer`
`private RegionNormalizerChore`	`normalizerChore`
`private HMaster.PeriodicDoMetrics`	`periodicDoMetricsChore`
`private boolean`	`preLoadTableDescriptors`
`private ProcedureExecutor<MasterProcedureEnv>`	`procedureExecutor`
`private WALProcedureStore`	`procedureStore`
`private MasterQuotaManager`	`quotaManager`
`private RegionNormalizerTracker`	`regionNormalizerTracker`
`(package private) RegionServerTracker`	`regionServerTracker`
`private ReplicationZKLockCleanerChore`	`replicationZKLockCleanerChore`
`(package private) MemoryBoundedLogMessageBuffer`	`rsFatals`
`private MasterProcedureScheduler.ProcedureEvent`	`serverCrashProcessingEnabled`
`(package private) ServerManager`	`serverManager`
`(package private) boolean`	`serviceStarted`
`(package private) SnapshotManager`	`snapshotManager`
`private TableNamespaceManager`	`tableNamespaceManager` Namespace stuff

Fields inherited from class org.apache.hadoop.hbase.regionserver.HRegionServer
cacheConfig, cacheFlusher, CLOSE, clusterConnection, clusterStatusTracker, compactSplitThread, conf, configurationManager, csm, fs, fsOk, hMemManager, infoServer, leases, lock, MASTER_HOSTNAME_KEY, metaTableLocator, movedRegions, msgInterval, numRegionsToReport, onlineRegions, OPEN, recoveringRegions, regionFavoredNodesMap, REGIONSERVER, regionsInTransitionInRS, replicationSinkHandler, replicationSourceHandler, rpcServices, serverName, service, sleeper, startcode, tableDescriptors, tableLockManager, threadWakeFrequency, useThisHostnameInstead, walFactory, zooKeeper

Constructor Summary

Constructors
Constructor and Description

HMaster(org.apache.hadoop.conf.Configuration conf, CoordinatedStateManager csm)
Initializes the HMaster.

Constructors
Constructor and Description
`HMaster(org.apache.hadoop.conf.Configuration conf, CoordinatedStateManager csm)` Initializes the HMaster.

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`abort(String msg, Throwable t)` Cause the server to exit without closing the regions it is serving, the log it is using and without notifying the master.
`boolean`	`abortProcedure(long procId, boolean mayInterruptIfRunning)` Abort a procedure.
`void`	`addColumn(TableName tableName, HColumnDescriptor columnDescriptor, long nonceGroup, long nonce)` Add a new column to an existing table
`(package private) void`	`assignMeta(MonitoredTask status, Set<ServerName> previouslyFailedMetaRSs, int replicaId)` Check `hbase:meta` is assigned.
`private void`	`assignMetaZkLess(RegionStates regionStates, RegionState regionState, long timeout, Set<ServerName> previouslyFailedRs)`
`void`	`assignRegion(HRegionInfo hri)`
`boolean`	`balance()`
`boolean`	`balanceSwitch(boolean b)`
`protected boolean`	`canCreateBaseZNode()`
`protected boolean`	`canUpdateTableDescriptor()`
`private void`	`checkClassLoading(org.apache.hadoop.conf.Configuration conf, HTableDescriptor htd)`
`private void`	`checkCompactionPolicy(org.apache.hadoop.conf.Configuration conf, HTableDescriptor htd)`
`private void`	`checkCompression(HColumnDescriptor hcd)`
`private void`	`checkCompression(HTableDescriptor htd)`
`private void`	`checkEncryption(org.apache.hadoop.conf.Configuration conf, HColumnDescriptor hcd)`
`private void`	`checkEncryption(org.apache.hadoop.conf.Configuration conf, HTableDescriptor htd)`
`(package private) void`	`checkInitialized()`
`(package private) void`	`checkNamespaceManagerReady()`
`(package private) void`	`checkServiceStarted()`
`void`	`checkTableModifiable(TableName tableName)` Check table is modifiable; i.e.
`protected void`	`configureInfoServer()`
`static HMaster`	`constructMaster(Class<? extends HMaster> masterClass, org.apache.hadoop.conf.Configuration conf, CoordinatedStateManager cp)` Utility for constructing an instance of the passed HMaster class.
`protected CatalogJanitor`	`createCatalogJanitor()`
`void`	`createNamespace(NamespaceDescriptor descriptor)` Create a new namespace
`protected RSRpcServices`	`createRpcServices()`
`(package private) ServerManager`	`createServerManager(Server master, MasterServices services)` Create a `ServerManager` instance.
`long`	`createTable(HTableDescriptor hTableDescriptor, byte[][] splitKeys, long nonceGroup, long nonce)` Create a table using the given table definition.
`void`	`deleteColumn(TableName tableName, byte[] columnName, long nonceGroup, long nonce)` Delete a column from an existing table
`void`	`deleteNamespace(String name)` Delete an existing namespace.
`long`	`deleteTable(TableName tableName, long nonceGroup, long nonce)` Delete a table
`long`	`disableTable(TableName tableName, long nonceGroup, long nonce)` Disable an existing table
`void`	`dispatchMergingRegions(HRegionInfo region_a, HRegionInfo region_b, boolean forcible)` Merge two regions.
`private void`	`doMetrics()` Emit the HMaster metrics, such as region in transition metrics.
`private void`	`enableCrashedServerProcessing(boolean waitForMeta)`
`private void`	`enableMeta(TableName metaTableName)`
`long`	`enableTable(TableName tableName, long nonceGroup, long nonce)` Enable an existing table
`protected void`	`ensureNamespaceExists(String name)` Ensure that the specified namespace exists, otherwise throws a NamespaceNotFoundException
`private static void`	`filterTablesByRegex(Collection<HTableDescriptor> descriptors, Pattern pattern)` Removes the table descriptors that don't match the pattern.
`private void`	`finishActiveMasterInitialization(MonitoredTask status)` Finish initialization of HMaster after becoming the primary master.
`AssignmentManager`	`getAssignmentManager()`
`double`	`getAverageLoad()` Compute the average load across all region servers.
`private int`	`getBalancerCutoffTime()`
`(package private) String`	`getClientIdAuditPrefix()`
`ClusterStatus`	`getClusterStatus()`
`protected Class<? extends javax.servlet.http.HttpServlet>`	`getDumpServlet()`
`HFileCleaner`	`getHFileCleaner()`
`MasterProcedureScheduler.ProcedureEvent`	`getInitializedEvent()`
`long`	`getLastMajorCompactionTimestamp(TableName table)`
`long`	`getLastMajorCompactionTimestampForRegion(byte[] regionName)`
`String`	`getLoadBalancerClassName()` Fetch the configured `LoadBalancer` class name.
`static String`	`getLoadedCoprocessors()` The set of loaded coprocessors is stored in a static set.
`long`	`getMasterActiveTime()`
`MasterCoprocessorHost`	`getMasterCoprocessorHost()`
`String[]`	`getMasterCoprocessors()`
`MasterFileSystem`	`getMasterFileSystem()`
`(package private) MetricsMaster`	`getMasterMetrics()`
`ProcedureExecutor<MasterProcedureEnv>`	`getMasterProcedureExecutor()`
`MasterQuotaManager`	`getMasterQuotaManager()`
`MasterRpcServices`	`getMasterRpcServices()`
`long`	`getMasterStartTime()`
`NamespaceDescriptor`	`getNamespaceDescriptor(String name)` Get a namespace descriptor by name
`private Set<ServerName>`	`getPreviouselyFailedMetaServersFromZK()` This function returns a set of region server names under hbase:meta recovering region ZK node
`protected String`	`getProcessName()`
`RegionNormalizerTracker`	`getRegionNormalizerTracker()`
`MemoryBoundedLogMessageBuffer`	`getRegionServerFatalLogBuffer()`
`int`	`getRegionServerInfoPort(ServerName sn)`
`String`	`getRegionServerVersion(ServerName sn)`
`(package private) InetAddress`	`getRemoteInetAddress(int port, long serverStartCode)`
`MasterProcedureScheduler.ProcedureEvent`	`getServerCrashProcessingEnabledEvent()`
`ServerManager`	`getServerManager()`
`ServerName`	`getServerName()`
`SnapshotManager`	`getSnapshotManager()` Exposed for TESTING!
`TableDescriptors`	`getTableDescriptors()`
`(package private) Pair<HRegionInfo,ServerName>`	`getTableRegionForRow(TableName tableName, byte[] rowKey)` Return the region and current deployment for the region containing the given row.
`ZooKeeperWatcher`	`getZooKeeper()` Gets the ZooKeeper instance for this server.
`(package private) void`	`initializeZKBasedSystemTrackers()` Initialize all ZK based system trackers.
`(package private) void`	`initNamespace()`
`private void`	`initQuotaManager()`
`boolean`	`isActiveMaster()` Report whether this master is currently the active master or not.
`boolean`	`isBalancerOn()` Queries the state of the `LoadBalancerTracker`.
`(package private) boolean`	`isCatalogJanitorEnabled()`
`private static boolean`	`isCatalogTable(TableName tableName)`
`boolean`	`isInitializationStartsMetaRegionAssignment()` Report whether this master has started initialization and is about to do meta region assignment
`boolean`	`isInitialized()` Report whether this master has completed with its initialization and is ready.
`boolean`	`isNormalizerOn()` Queries the state of the `RegionNormalizerTracker`.
`boolean`	`isServerCrashProcessingEnabled()` ServerCrashProcessingEnabled is set false before completing assignMeta to prevent processing of crashed servers.
`List<NamespaceDescriptor>`	`listNamespaceDescriptors()` List available namespace descriptors
`List<ProcedureInfo>`	`listProcedures()` List procedures
`List<HTableDescriptor>`	`listTableDescriptors(String namespace, String regex, List<TableName> tableNameList, boolean includeSysTables)` Returns the list of table descriptors that match the specified request
`List<HTableDescriptor>`	`listTableDescriptorsByNamespace(String name)` Get list of table descriptors by namespace
`List<TableName>`	`listTableNames(String namespace, String regex, boolean includeSysTables)` Returns the list of table names that match the specified request
`List<TableName>`	`listTableNamesByNamespace(String name)` Get list of table names by namespace
`protected void`	`login(UserProvider user, String host)` For compatibility, if failed with regionserver credentials, try the master one
`static void`	`main(String[] args)`
`void`	`modifyColumn(TableName tableName, HColumnDescriptor descriptor, long nonceGroup, long nonce)` Modify the column descriptor of an existing column in an existing table
`void`	`modifyNamespace(NamespaceDescriptor descriptor)` Modify an existing namespace
`void`	`modifyTable(TableName tableName, HTableDescriptor descriptor, long nonceGroup, long nonce)` Modify the descriptor of an existing table
`(package private) void`	`move(byte[] encodedRegionName, byte[] destServerName)`
`boolean`	`normalizeRegions()` Perform normalization of cluster (invoked by `RegionNormalizerChore`).
`private int`	`putUpJettyServer()`
`boolean`	`registerService(com.google.protobuf.Service instance)` Registers a new protocol buffer `Service` subclass as a coprocessor endpoint to be available for handling
`private void`	`sanityCheckTableDescriptor(HTableDescriptor htd)` Checks whether the table conforms to some sane limits, and configured values (compression, etc) work.
`protected void`	`sendShutdownInterrupt()` Called on stop/abort before closing the cluster connection and meta locator.
`void`	`setCatalogJanitorEnabled(boolean b)` Switch for the background CatalogJanitor thread.
`void`	`setInitialized(boolean isInitialized)`
`void`	`setServerCrashProcessingEnabled(boolean b)`
`void`	`shutdown()`
`private void`	`splitMetaLogBeforeAssignment(ServerName currentMetaServer)`
`private void`	`startActiveMasterManager(int infoPort)`
`private void`	`startProcedureExecutor()`
`private void`	`startServiceThreads()`
`private void`	`stopChores()`
`void`	`stopMaster()`
`private void`	`stopProcedureExecutor()`
`protected void`	`stopServiceThreads()` Wait on all threads to finish.
`void`	`truncateTable(TableName tableName, boolean preserveSplits, long nonceGroup, long nonce)` Truncate a table
`private void`	`unassignExcessMetaReplica(ZooKeeperWatcher zkw, int numMetaReplicasConfigured)`
`protected void`	`waitForMasterActive()` If configured to put regions on active master, wait till a backup master becomes active.
`private static void`	`warnOrThrowExceptionForFailure(boolean logWarn, String confKey, String message, Exception cause)`

Methods inherited from class org.apache.hadoop.hbase.regionserver.HRegionServer
abort, addToMovedRegions, addToOnlineRegions, checkFileSystem, cleanMovedRegions, closeAllRegions, closeRegion, constructRegionServer, convertThrowableToIOE, createClusterConnection, createRegionLoad, createRegionServerStatusStub, createRegionServerStatusStub, ensureMetaWALRoller, execRegionServerService, getCacheConfig, getChoreService, getClusterId, getCompactionPressure, getCompactionRequester, getCompactSplitThread, getConfiguration, getConfigurationManager, getConnection, getCoordinatedStateManager, getExecutorService, getFavoredNodesForRegion, getFileSystem, getFlushRequester, getFromOnlineRegions, getHeapMemoryManager, getInfoServer, getLastSequenceId, getLeases, getMasterAddressTracker, getMetaTableLocator, getMostLoadedRegions, getNonceManager, getNumberOfOnlineRegions, getOnlineRegion, getOnlineRegions, getOnlineRegionsLocalContext, getOnlineTables, getRecoveringRegions, getRegion, getRegionBlockLocations, getRegionByEncodedName, getRegionByEncodedName, getRegionServerAccounting, getRegionServerCoprocessorHost, getRegionServerCoprocessors, getRegionServerMetrics, getRegionServerQuotaManager, getRegionsInTransitionInRS, getReplicationSourceService, getRootDir, getRpcServer, getRSRpcServices, getStartcode, getTableLockManager, getThreadWakeFrequency, getWAL, handleReportForDutyResponse, isAborted, isOnline, isStopped, isStopping, kill, movedRegionCleanerPeriod, postOpenDeployTasks, postOpenDeployTasks, removeFromOnlineRegions, reportRegionStateTransition, reportRegionStateTransition, reportRegionStateTransition, run, setupClusterConnection, shouldUseThisHostnameInstead, stop, stop, toString, tryRegionServerReport, updateConfiguration, updateRegionFavoredNodesMapping, waitForServerOnline, walRollRequestFinished

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

Methods inherited from interface org.apache.hadoop.hbase.master.MasterServices
getExecutorService, getTableLockManager

Methods inherited from interface org.apache.hadoop.hbase.Server
getChoreService, getConfiguration, getConnection, getCoordinatedStateManager, getMetaTableLocator

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

Methods inherited from interface org.apache.hadoop.hbase.Stoppable
isStopped, stop

- Field Detail
  - LOG
```
private static final org.apache.commons.logging.Log LOG
```
  - MASTER
```
public static final String MASTER
```
    See Also:
    Constant Field Values
  - activeMasterManager
```
private final ActiveMasterManager activeMasterManager
```
  - regionServerTracker
```
RegionServerTracker regionServerTracker
```
  - drainingServerTracker
```
private DrainingServerTracker drainingServerTracker
```
  - loadBalancerTracker
```
LoadBalancerTracker loadBalancerTracker
```
  - regionNormalizerTracker
```
private RegionNormalizerTracker regionNormalizerTracker
```
  - tableNamespaceManager
```
private TableNamespaceManager tableNamespaceManager
```
    Namespace stuff
  - metricsMaster
```
final MetricsMaster metricsMaster
```
  - fileSystemManager
```
private MasterFileSystem fileSystemManager
```
  - serverManager
```
volatile ServerManager serverManager
```
  - assignmentManager
```
AssignmentManager assignmentManager
```
  - rsFatals
```
MemoryBoundedLogMessageBuffer rsFatals
```
  - isActiveMaster
```
private volatile boolean isActiveMaster
```
  - initialized
```
private final MasterProcedureScheduler.ProcedureEvent initialized
```
  - serviceStarted
```
volatile boolean serviceStarted
```
  - serverCrashProcessingEnabled
```
private final MasterProcedureScheduler.ProcedureEvent serverCrashProcessingEnabled
```
  - balancer
```
LoadBalancer balancer
```
  - normalizer
```
private RegionNormalizer normalizer
```
  - balancerChore
```
private BalancerChore balancerChore
```
  - normalizerChore
```
private RegionNormalizerChore normalizerChore
```
  - clusterStatusChore
```
private ClusterStatusChore clusterStatusChore
```
  - clusterStatusPublisherChore
```
private ClusterStatusPublisher clusterStatusPublisherChore
```
  - periodicDoMetricsChore
```
private HMaster.PeriodicDoMetrics periodicDoMetricsChore
```
  - catalogJanitorChore
```
CatalogJanitor catalogJanitorChore
```
  - replicationZKLockCleanerChore
```
private ReplicationZKLockCleanerChore replicationZKLockCleanerChore
```
  - logCleaner
```
private LogCleaner logCleaner
```
  - hfileCleaner
```
private HFileCleaner hfileCleaner
```
  - cpHost
```
MasterCoprocessorHost cpHost
```
  - preLoadTableDescriptors
```
private final boolean preLoadTableDescriptors
```
  - masterActiveTime
```
private long masterActiveTime
```
  - masterCheckCompression
```
private final boolean masterCheckCompression
```
  - masterCheckEncryption
```
private final boolean masterCheckEncryption
```
  - coprocessorServiceHandlers
```
Map<String,com.google.protobuf.Service> coprocessorServiceHandlers
```
  - snapshotManager
```
SnapshotManager snapshotManager
```
  - mpmHost
```
MasterProcedureManagerHost mpmHost
```
  - quotaManager
```
private volatile MasterQuotaManager quotaManager
```
  - procedureExecutor
```
private ProcedureExecutor<MasterProcedureEnv> procedureExecutor
```
  - procedureStore
```
private WALProcedureStore procedureStore
```
  - initializationBeforeMetaAssignment
```
private volatile boolean initializationBeforeMetaAssignment
```
    flag used in test cases in order to simulate RS failures during master initialization
  - masterJettyServer
```
private org.mortbay.jetty.Server masterJettyServer
```
    jetty server for master to redirect requests to regionserver infoServer
- Constructor Detail
  - HMaster
```
public HMaster(org.apache.hadoop.conf.Configuration conf,
       CoordinatedStateManager csm)
        throws IOException,
               org.apache.zookeeper.KeeperException,
               InterruptedException
```
    Initializes the HMaster. The steps are as follows:
    1. Initialize the local HRegionServer
    2. Start the ActiveMasterManager.
    Remaining steps of initialization occur in #finishActiveMasterInitialization(MonitoredTask) after the master becomes the active one.
    Throws:
    
    InterruptedException
    
    org.apache.zookeeper.KeeperException
    
    IOException
- Method Detail
  - putUpJettyServer
```
private int putUpJettyServer()
                      throws IOException
```
    Throws:
    
    IOException
  - login
```
protected void login(UserProvider user,
         String host)
              throws IOException
```
    For compatibility, if failed with regionserver credentials, try the master one
    
    Overrides:
    
    login in class HRegionServer
    
    Throws:
    
    IOException
  - waitForMasterActive
```
protected void waitForMasterActive()
```
    If configured to put regions on active master, wait till a backup master becomes active. Otherwise, loop till the server is stopped or aborted.
    
    Overrides:
    
    waitForMasterActive in class HRegionServer
  - getMasterRpcServices
```
public MasterRpcServices getMasterRpcServices()
```
  - balanceSwitch
```
public boolean balanceSwitch(boolean b)
                      throws IOException
```
    Throws:
    
    IOException
  - getProcessName
```
protected String getProcessName()
```
    Overrides:
    
    getProcessName in class HRegionServer
  - canCreateBaseZNode
```
protected boolean canCreateBaseZNode()
```
    Overrides:
    
    canCreateBaseZNode in class HRegionServer
  - canUpdateTableDescriptor
```
protected boolean canUpdateTableDescriptor()
```
    Overrides:
    
    canUpdateTableDescriptor in class HRegionServer
  - createRpcServices
```
protected RSRpcServices createRpcServices()
                                   throws IOException
```
    Overrides:
    
    createRpcServices in class HRegionServer
    
    Throws:
    
    IOException
  - configureInfoServer
```
protected void configureInfoServer()
```
    Overrides:
    
    configureInfoServer in class HRegionServer
  - getDumpServlet
```
protected Class<? extends javax.servlet.http.HttpServlet> getDumpServlet()
```
    Overrides:
    
    getDumpServlet in class HRegionServer
  - doMetrics
```
private void doMetrics()
```
    Emit the HMaster metrics, such as region in transition metrics. Surrounding in a try block just to be sure metrics doesn't abort HMaster.
  - getMasterMetrics
```
MetricsMaster getMasterMetrics()
```
  - initializeZKBasedSystemTrackers
```
void initializeZKBasedSystemTrackers()
                               throws IOException,
                                      InterruptedException,
                                      org.apache.zookeeper.KeeperException,
                                      CoordinatedStateException
```
    Initialize all ZK based system trackers.
    
    Throws:
    
    IOException
    
    InterruptedException
    
    org.apache.zookeeper.KeeperException
    
    CoordinatedStateException
  - finishActiveMasterInitialization
```
private void finishActiveMasterInitialization(MonitoredTask status)
                                       throws IOException,
                                              InterruptedException,
                                              org.apache.zookeeper.KeeperException,
                                              CoordinatedStateException
```
    Finish initialization of HMaster after becoming the primary master.
    1. Initialize master components - file system manager, server manager, assignment manager, region server tracker, etc
    2. Start necessary service threads - balancer, catalog janior, executor services, etc
    3. Set cluster as UP in ZooKeeper
    4. Wait for RegionServers to check-in
    5. Split logs and perform data recovery, if necessary
    6. Ensure assignment of meta/namespace regions
    8. Handle either fresh cluster start or master failover
    Throws:
    
    IOException
    
    InterruptedException
    
    org.apache.zookeeper.KeeperException
    
    CoordinatedStateException
  - createCatalogJanitor
```
protected CatalogJanitor createCatalogJanitor()
```
  - initQuotaManager
```
private void initQuotaManager()
                       throws IOException
```
    Throws:
    
    IOException
  - createServerManager
```
ServerManager createServerManager(Server master,
                                MasterServices services)
                            throws IOException
```
    Create a ServerManager instance.
    
    Parameters:
    master -
    services -
    
    Returns:
    An instance of ServerManager
    
    Throws:
    
    ZooKeeperConnectionException
    
    IOException
  - unassignExcessMetaReplica
```
private void unassignExcessMetaReplica(ZooKeeperWatcher zkw,
                             int numMetaReplicasConfigured)
```
  - assignMeta
```
void assignMeta(MonitoredTask status,
              Set<ServerName> previouslyFailedMetaRSs,
              int replicaId)
          throws InterruptedException,
                 IOException,
                 org.apache.zookeeper.KeeperException
```
    Check hbase:meta is assigned. If not, assign it.
    
    Parameters:
    status - MonitoredTask
    previouslyFailedMetaRSs -
    replicaId -
    
    Throws:
    
    InterruptedException
    
    IOException
    
    org.apache.zookeeper.KeeperException
  - assignMetaZkLess
```
private void assignMetaZkLess(RegionStates regionStates,
                    RegionState regionState,
                    long timeout,
                    Set<ServerName> previouslyFailedRs)
                       throws IOException,
                              org.apache.zookeeper.KeeperException
```
    Throws:
    
    IOException
    
    org.apache.zookeeper.KeeperException
  - initNamespace
```
void initNamespace()
             throws IOException
```
    Throws:
    
    IOException
  - isCatalogJanitorEnabled
```
boolean isCatalogJanitorEnabled()
```
  - splitMetaLogBeforeAssignment
```
private void splitMetaLogBeforeAssignment(ServerName currentMetaServer)
                                   throws IOException
```
    Throws:
    
    IOException
  - enableCrashedServerProcessing
```
private void enableCrashedServerProcessing(boolean waitForMeta)
                                    throws IOException,
                                           InterruptedException
```
    Throws:
    
    IOException
    
    InterruptedException
  - enableMeta
```
private void enableMeta(TableName metaTableName)
```
  - getPreviouselyFailedMetaServersFromZK
```
private Set<ServerName> getPreviouselyFailedMetaServersFromZK()
                                                       throws org.apache.zookeeper.KeeperException
```
    This function returns a set of region server names under hbase:meta recovering region ZK node
    
    Returns:
    Set of meta server names which were recorded in ZK
    
    Throws:
    
    org.apache.zookeeper.KeeperException
  - getTableDescriptors
```
public TableDescriptors getTableDescriptors()
```
    Specified by:
    
    getTableDescriptors in interface MasterServices
    
    Overrides:
    
    getTableDescriptors in class HRegionServer
    
    Returns:
    Return table descriptors implementation.
  - getServerManager
```
public ServerManager getServerManager()
```
    Specified by:
    
    getServerManager in interface MasterServices
    
    Returns:
    Master's ServerManager instance.
  - getMasterFileSystem
```
public MasterFileSystem getMasterFileSystem()
```
    Specified by:
    
    getMasterFileSystem in interface MasterServices
    
    Returns:
    Master's filesystem MasterFileSystem utility class.
  - startServiceThreads
```
private void startServiceThreads()
                          throws IOException
```
    Throws:
    
    IOException
  - sendShutdownInterrupt
```
protected void sendShutdownInterrupt()
```
    Description copied from class: HRegionServer
    
    Called on stop/abort before closing the cluster connection and meta locator.
    
    Overrides:
    
    sendShutdownInterrupt in class HRegionServer
  - stopServiceThreads
```
protected void stopServiceThreads()
```
    Description copied from class: HRegionServer
    
    Wait on all threads to finish. Presumption is that all closes and stops have already been called.
    
    Overrides:
    
    stopServiceThreads in class HRegionServer
  - startProcedureExecutor
```
private void startProcedureExecutor()
                             throws IOException
```
    Throws:
    
    IOException
  - stopProcedureExecutor
```
private void stopProcedureExecutor()
```
  - stopChores
```
private void stopChores()
```
  - getRemoteInetAddress
```
InetAddress getRemoteInetAddress(int port,
                               long serverStartCode)
                           throws UnknownHostException
```
    Returns:
    Get remote side's InetAddress
    
    Throws:
    
    UnknownHostException
  - getBalancerCutoffTime
```
private int getBalancerCutoffTime()
```
    Returns:
    Maximum time we should run balancer for
  - balance
```
public boolean balance()
                throws IOException
```
    Throws:
    
    IOException
  - normalizeRegions
```
public boolean normalizeRegions()
                         throws IOException,
                                CoordinatedStateException
```
    Perform normalization of cluster (invoked by RegionNormalizerChore).
    
    Returns:
    true if normalization step was performed successfully, false otherwise (specifically, if HMaster hasn't been initialized properly or normalization is globally disabled)
    
    Throws:
    
    IOException
    
    CoordinatedStateException
  - getClientIdAuditPrefix
```
String getClientIdAuditPrefix()
```
    Returns:
    Client info for use as prefix on an audit log string; who did an action
  - setCatalogJanitorEnabled
```
public void setCatalogJanitorEnabled(boolean b)
```
    Switch for the background CatalogJanitor thread. Used for testing. The thread will continue to run. It will just be a noop if disabled.
    
    Parameters:
    b - If false, the catalog janitor won't do anything.
  - dispatchMergingRegions
```
public void dispatchMergingRegions(HRegionInfo region_a,
                          HRegionInfo region_b,
                          boolean forcible)
                            throws IOException
```
    Description copied from interface: MasterServices
    
    Merge two regions. The real implementation is on the regionserver, master just move the regions together and send MERGE RPC to regionserver
    
    Specified by:
    
    dispatchMergingRegions in interface MasterServices
    
    Parameters:
    region_a - region to merge
    region_b - region to merge
    forcible - true if do a compulsory merge, otherwise we will only merge two adjacent regions
    
    Throws:
    
    IOException
  - move
```
void move(byte[] encodedRegionName,
        byte[] destServerName)
    throws HBaseIOException
```
    Throws:
    
    HBaseIOException
  - createTable
```
public long createTable(HTableDescriptor hTableDescriptor,
               byte[][] splitKeys,
               long nonceGroup,
               long nonce)
                 throws IOException
```
    Description copied from interface: MasterServices
    
    Create a table using the given table definition.
    
    Specified by:
    
    createTable in interface MasterServices
    
    Parameters:
    hTableDescriptor - The table definition
    splitKeys - Starting row keys for the initial table regions. If null
    nonce - a single region is created.
    
    Throws:
    
    IOException
  - sanityCheckTableDescriptor
```
private void sanityCheckTableDescriptor(HTableDescriptor htd)
                                 throws IOException
```
    Checks whether the table conforms to some sane limits, and configured values (compression, etc) work. Throws an exception if something is wrong.
    
    Throws:
    
    IOException
  - checkCompactionPolicy
```
private void checkCompactionPolicy(org.apache.hadoop.conf.Configuration conf,
                         HTableDescriptor htd)
                            throws IOException
```
    Throws:
    
    IOException
  - warnOrThrowExceptionForFailure
```
private static void warnOrThrowExceptionForFailure(boolean logWarn,
                                  String confKey,
                                  String message,
                                  Exception cause)
                                            throws IOException
```
    Throws:
    
    IOException
  - startActiveMasterManager
```
private void startActiveMasterManager(int infoPort)
                               throws org.apache.zookeeper.KeeperException
```
    Throws:
    
    org.apache.zookeeper.KeeperException
  - checkCompression
```
private void checkCompression(HTableDescriptor htd)
                       throws IOException
```
    Throws:
    
    IOException
  - checkCompression
```
private void checkCompression(HColumnDescriptor hcd)
                       throws IOException
```
    Throws:
    
    IOException
  - checkEncryption
```
private void checkEncryption(org.apache.hadoop.conf.Configuration conf,
                   HTableDescriptor htd)
                      throws IOException
```
    Throws:
    
    IOException
  - checkEncryption
```
private void checkEncryption(org.apache.hadoop.conf.Configuration conf,
                   HColumnDescriptor hcd)
                      throws IOException
```
    Throws:
    
    IOException
  - checkClassLoading
```
private void checkClassLoading(org.apache.hadoop.conf.Configuration conf,
                     HTableDescriptor htd)
                        throws IOException
```
    Throws:
    
    IOException
  - isCatalogTable
```
private static boolean isCatalogTable(TableName tableName)
```
  - deleteTable
```
public long deleteTable(TableName tableName,
               long nonceGroup,
               long nonce)
                 throws IOException
```
    Description copied from interface: MasterServices
    
    Delete a table
    
    Specified by:
    
    deleteTable in interface MasterServices
    
    Parameters:
    tableName - The table name
    
    Throws:
    
    IOException
  - truncateTable
```
public void truncateTable(TableName tableName,
                 boolean preserveSplits,
                 long nonceGroup,
                 long nonce)
                   throws IOException
```
    Description copied from interface: MasterServices
    
    Truncate a table
    
    Specified by:
    
    truncateTable in interface MasterServices
    
    Parameters:
    tableName - The table name
    preserveSplits - True if the splits should be preserved
    
    Throws:
    
    IOException
  - addColumn
```
public void addColumn(TableName tableName,
             HColumnDescriptor columnDescriptor,
             long nonceGroup,
             long nonce)
               throws IOException
```
    Description copied from interface: MasterServices
    
    Add a new column to an existing table
    
    Specified by:
    
    addColumn in interface MasterServices
    
    Parameters:
    tableName - The table name
    columnDescriptor - The column definition
    
    Throws:
    
    IOException
  - modifyColumn
```
public void modifyColumn(TableName tableName,
                HColumnDescriptor descriptor,
                long nonceGroup,
                long nonce)
                  throws IOException
```
    Description copied from interface: MasterServices
    
    Modify the column descriptor of an existing column in an existing table
    
    Specified by:
    
    modifyColumn in interface MasterServices
    
    Parameters:
    tableName - The table name
    descriptor - The updated column definition
    
    Throws:
    
    IOException
  - deleteColumn
```
public void deleteColumn(TableName tableName,
                byte[] columnName,
                long nonceGroup,
                long nonce)
                  throws IOException
```
    Description copied from interface: MasterServices
    
    Delete a column from an existing table
    
    Specified by:
    
    deleteColumn in interface MasterServices
    
    Parameters:
    tableName - The table name
    columnName - The column name
    
    Throws:
    
    IOException
  - enableTable
```
public long enableTable(TableName tableName,
               long nonceGroup,
               long nonce)
                 throws IOException
```
    Description copied from interface: MasterServices
    
    Enable an existing table
    
    Specified by:
    
    enableTable in interface MasterServices
    
    Parameters:
    tableName - The table name
    
    Throws:
    
    IOException
  - disableTable
```
public long disableTable(TableName tableName,
                long nonceGroup,
                long nonce)
                  throws IOException
```
    Description copied from interface: MasterServices
    
    Disable an existing table
    
    Specified by:
    
    disableTable in interface MasterServices
    
    Parameters:
    tableName - The table name
    
    Throws:
    
    IOException
  - getTableRegionForRow
```
Pair<HRegionInfo,ServerName> getTableRegionForRow(TableName tableName,
                                                byte[] rowKey)
                                            throws IOException
```
    Return the region and current deployment for the region containing the given row. If the region cannot be found, returns null. If it is found, but not currently deployed, the second element of the pair may be null.
    
    Throws:
    
    IOException
  - modifyTable
```
public void modifyTable(TableName tableName,
               HTableDescriptor descriptor,
               long nonceGroup,
               long nonce)
                 throws IOException
```
    Description copied from interface: MasterServices
    
    Modify the descriptor of an existing table
    
    Specified by:
    
    modifyTable in interface MasterServices
    
    Parameters:
    tableName - The table name
    descriptor - The updated table descriptor
    
    Throws:
    
    IOException
  - checkTableModifiable
```
public void checkTableModifiable(TableName tableName)
                          throws IOException,
                                 TableNotFoundException,
                                 TableNotDisabledException
```
    Description copied from interface: MasterServices
    
    Check table is modifiable; i.e. exists and is offline.
    
    Specified by:
    
    checkTableModifiable in interface MasterServices
    
    Parameters:
    tableName - Name of table to check.
    
    Throws:
    
    TableNotDisabledException
    
    TableNotFoundException
    
    IOException
  - getClusterStatus
```
public ClusterStatus getClusterStatus()
                               throws InterruptedIOException
```
    Returns:
    cluster status
    
    Throws:
    
    InterruptedIOException
  - getLoadedCoprocessors
```
public static String getLoadedCoprocessors()
```
    The set of loaded coprocessors is stored in a static set. Since it's statically allocated, it does not require that HMaster's cpHost be initialized prior to accessing it.
    
    Returns:
    a String representation of the set of names of the loaded coprocessors.
  - getMasterStartTime
```
public long getMasterStartTime()
```
    Returns:
    timestamp in millis when HMaster was started.
  - getMasterActiveTime
```
public long getMasterActiveTime()
```
    Returns:
    timestamp in millis when HMaster became the active master.
  - getRegionServerInfoPort
```
public int getRegionServerInfoPort(ServerName sn)
```
  - getRegionServerVersion
```
public String getRegionServerVersion(ServerName sn)
```
  - getMasterCoprocessors
```
public String[] getMasterCoprocessors()
```
    Returns:
    array of coprocessor SimpleNames.
  - abort
```
public void abort(String msg,
         Throwable t)
```
    Description copied from class: HRegionServer
    
    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
    
    Overrides:
    
    abort in class HRegionServer
    
    Parameters:
    msg - the reason we are aborting
    t - the exception that caused the abort, or null
  - getZooKeeper
```
public ZooKeeperWatcher getZooKeeper()
```
    Description copied from interface: Server
    
    Gets the ZooKeeper instance for this server.
    
    Specified by:
    
    getZooKeeper in interface Server
    
    Overrides:
    
    getZooKeeper in class HRegionServer
  - getMasterCoprocessorHost
```
public MasterCoprocessorHost getMasterCoprocessorHost()
```
    Specified by:
    
    getMasterCoprocessorHost in interface MasterServices
    
    Returns:
    Master's instance of MasterCoprocessorHost
  - getMasterQuotaManager
```
public MasterQuotaManager getMasterQuotaManager()
```
    Specified by:
    
    getMasterQuotaManager in interface MasterServices
    
    Returns:
    Master's instance of MasterQuotaManager
  - getMasterProcedureExecutor
```
public ProcedureExecutor<MasterProcedureEnv> getMasterProcedureExecutor()
```
    Specified by:
    
    getMasterProcedureExecutor in interface MasterServices
    
    Returns:
    Master's instance of ProcedureExecutor
  - getServerName
```
public ServerName getServerName()
```
    Specified by:
    
    getServerName in interface Server
    
    Overrides:
    
    getServerName in class HRegionServer
    
    Returns:
    The unique server name for this server.
  - getAssignmentManager
```
public AssignmentManager getAssignmentManager()
```
    Specified by:
    
    getAssignmentManager in interface MasterServices
    
    Returns:
    Master's instance of the AssignmentManager
  - getRegionServerFatalLogBuffer
```
public MemoryBoundedLogMessageBuffer getRegionServerFatalLogBuffer()
```
  - shutdown
```
public void shutdown()
              throws IOException
```
    Throws:
    
    IOException
  - stopMaster
```
public void stopMaster()
                throws IOException
```
    Throws:
    
    IOException
  - checkServiceStarted
```
void checkServiceStarted()
                   throws ServerNotRunningYetException
```
    Throws:
    
    ServerNotRunningYetException
  - checkInitialized
```
void checkInitialized()
                throws PleaseHoldException,
                       ServerNotRunningYetException
```
    Throws:
    
    PleaseHoldException
    
    ServerNotRunningYetException
  - checkNamespaceManagerReady
```
void checkNamespaceManagerReady()
                          throws IOException
```
    Throws:
    
    IOException
  - isActiveMaster
```
public boolean isActiveMaster()
```
    Report whether this master is currently the active master or not. If not active master, we are parked on ZK waiting to become active. This method is used for testing.
    
    Returns:
    true if active master, false if not.
  - isInitialized
```
public boolean isInitialized()
```
    Report whether this master has completed with its initialization and is ready. If ready, the master is also the active master. A standby master is never ready. This method is used for testing.
    
    Specified by:
    
    isInitialized in interface MasterServices
    
    Returns:
    true if master is ready to go, false if not.
  - setInitialized
```
public void setInitialized(boolean isInitialized)
```
  - getInitializedEvent
```
public MasterProcedureScheduler.ProcedureEvent getInitializedEvent()
```
  - isServerCrashProcessingEnabled
```
public boolean isServerCrashProcessingEnabled()
```
    ServerCrashProcessingEnabled is set false before completing assignMeta to prevent processing of crashed servers.
    
    Specified by:
    
    isServerCrashProcessingEnabled in interface MasterServices
    
    Returns:
    true if assignMeta has completed;
  - setServerCrashProcessingEnabled
```
public void setServerCrashProcessingEnabled(boolean b)
```
  - getServerCrashProcessingEnabledEvent
```
public MasterProcedureScheduler.ProcedureEvent getServerCrashProcessingEnabledEvent()
```
  - isInitializationStartsMetaRegionAssignment
```
public boolean isInitializationStartsMetaRegionAssignment()
```
    Report whether this master has started initialization and is about to do meta region assignment
    
    Returns:
    true if master is in initialization & about to assign hbase:meta regions
  - assignRegion
```
public void assignRegion(HRegionInfo hri)
```
  - getAverageLoad
```
public double getAverageLoad()
```
    Compute the average load across all region servers. Currently, this uses a very naive computation - just uses the number of regions being served, ignoring stats about number of requests.
    
    Returns:
    the average load
  - 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 MasterServices
    
    Specified by:
    
    registerService in interface RegionServerServices
    
    Overrides:
    
    registerService in class HRegionServer
    
    Parameters:
    instance - the Service subclass instance to expose as a coprocessor endpoint
    
    Returns:
    true if the registration was successful, false
  - constructMaster
```
public static HMaster constructMaster(Class<? extends HMaster> masterClass,
                      org.apache.hadoop.conf.Configuration conf,
                      CoordinatedStateManager cp)
```
    Utility for constructing an instance of the passed HMaster class.
    
    Parameters:
    masterClass -
    conf -
    
    Returns:
    HMaster instance.
  - main
```
public static void main(String[] args)
```
    See Also:
    HMasterCommandLine
  - getHFileCleaner
```
public HFileCleaner getHFileCleaner()
```
  - getSnapshotManager
```
public SnapshotManager getSnapshotManager()
```
    Exposed for TESTING!
    
    Returns:
    the underlying snapshot manager
  - createNamespace
```
public void createNamespace(NamespaceDescriptor descriptor)
                     throws IOException
```
    Description copied from interface: MasterServices
    
    Create a new namespace
    
    Specified by:
    
    createNamespace in interface MasterServices
    
    Parameters:
    descriptor - descriptor which describes the new namespace
    
    Throws:
    
    IOException
  - modifyNamespace
```
public void modifyNamespace(NamespaceDescriptor descriptor)
                     throws IOException
```
    Description copied from interface: MasterServices
    
    Modify an existing namespace
    
    Specified by:
    
    modifyNamespace in interface MasterServices
    
    Parameters:
    descriptor - descriptor which updates the existing namespace
    
    Throws:
    
    IOException
  - deleteNamespace
```
public void deleteNamespace(String name)
                     throws IOException
```
    Description copied from interface: MasterServices
    
    Delete an existing namespace. Only empty namespaces (no tables) can be removed.
    
    Specified by:
    
    deleteNamespace in interface MasterServices
    
    Parameters:
    name - namespace name
    
    Throws:
    
    IOException
  - ensureNamespaceExists
```
protected void ensureNamespaceExists(String name)
                              throws IOException,
                                     NamespaceNotFoundException
```
    Ensure that the specified namespace exists, otherwise throws a NamespaceNotFoundException
    
    Parameters:
    name - the namespace to check
    
    Throws:
    
    IOException - if the namespace manager is not ready yet.
    
    NamespaceNotFoundException - if the namespace does not exists
  - getNamespaceDescriptor
```
public NamespaceDescriptor getNamespaceDescriptor(String name)
                                           throws IOException
```
    Description copied from interface: MasterServices
    
    Get a namespace descriptor by name
    
    Specified by:
    
    getNamespaceDescriptor in interface MasterServices
    
    Parameters:
    name - name of namespace descriptor
    
    Returns:
    A descriptor
    
    Throws:
    
    IOException
  - listNamespaceDescriptors
```
public List<NamespaceDescriptor> listNamespaceDescriptors()
                                                   throws IOException
```
    Description copied from interface: MasterServices
    
    List available namespace descriptors
    
    Specified by:
    
    listNamespaceDescriptors in interface MasterServices
    
    Returns:
    A descriptor
    
    Throws:
    
    IOException
  - abortProcedure
```
public boolean abortProcedure(long procId,
                     boolean mayInterruptIfRunning)
                       throws IOException
```
    Description copied from interface: MasterServices
    
    Abort a procedure.
    
    Specified by:
    
    abortProcedure in interface MasterServices
    
    Parameters:
    procId - ID of the procedure
    mayInterruptIfRunning - if the proc completed at least one step, should it be aborted?
    
    Returns:
    true if aborted, false if procedure already completed or does not exist
    
    Throws:
    
    IOException
  - listProcedures
```
public List<ProcedureInfo> listProcedures()
                                   throws IOException
```
    Description copied from interface: MasterServices
    
    List procedures
    
    Specified by:
    
    listProcedures in interface MasterServices
    
    Returns:
    procedure list
    
    Throws:
    
    IOException
  - listTableDescriptorsByNamespace
```
public List<HTableDescriptor> listTableDescriptorsByNamespace(String name)
                                                       throws IOException
```
    Description copied from interface: MasterServices
    
    Get list of table descriptors by namespace
    
    Specified by:
    
    listTableDescriptorsByNamespace in interface MasterServices
    
    Parameters:
    name - namespace name
    
    Returns:
    descriptors
    
    Throws:
    
    IOException
  - listTableNamesByNamespace
```
public List<TableName> listTableNamesByNamespace(String name)
                                          throws IOException
```
    Description copied from interface: MasterServices
    
    Get list of table names by namespace
    
    Specified by:
    
    listTableNamesByNamespace in interface MasterServices
    
    Parameters:
    name - namespace name
    
    Returns:
    table names
    
    Throws:
    
    IOException
  - listTableDescriptors
```
public List<HTableDescriptor> listTableDescriptors(String namespace,
                                          String regex,
                                          List<TableName> tableNameList,
                                          boolean includeSysTables)
                                            throws IOException
```
    Returns the list of table descriptors that match the specified request
    
    Parameters:
    namespace - the namespace to query, or null if querying for all
    regex - The regular expression to match against, or null if querying for all
    tableNameList - the list of table names, or null if querying for all
    includeSysTables - False to match only against userspace tables
    
    Returns:
    the list of table descriptors
    
    Throws:
    
    IOException
  - listTableNames
```
public List<TableName> listTableNames(String namespace,
                             String regex,
                             boolean includeSysTables)
                               throws IOException
```
    Returns the list of table names that match the specified request
    
    Parameters:
    regex - The regular expression to match against, or null if querying for all
    namespace - the namespace to query, or null if querying for all
    includeSysTables - False to match only against userspace tables
    
    Returns:
    the list of table names
    
    Throws:
    
    IOException
  - filterTablesByRegex
```
private static void filterTablesByRegex(Collection<HTableDescriptor> descriptors,
                       Pattern pattern)
```
    Removes the table descriptors that don't match the pattern.
    
    Parameters:
    descriptors - list of table descriptors to filter
    pattern - the regex to use
  - getLastMajorCompactionTimestamp
```
public long getLastMajorCompactionTimestamp(TableName table)
                                     throws IOException
```
    Specified by:
    
    getLastMajorCompactionTimestamp in interface MasterServices
    
    Returns:
    the timestamp of the last successful major compaction for the passed table, or 0 if no HFile resulting from a major compaction exists
    
    Throws:
    
    IOException
  - getLastMajorCompactionTimestampForRegion
```
public long getLastMajorCompactionTimestampForRegion(byte[] regionName)
                                              throws IOException
```
    Specified by:
    
    getLastMajorCompactionTimestampForRegion in interface MasterServices
    
    Returns:
    the timestamp of the last successful major compaction for the passed region or 0 if no HFile resulting from a major compaction exists
    
    Throws:
    
    IOException
  - isBalancerOn
```
public boolean isBalancerOn()
```
    Queries the state of the LoadBalancerTracker. If the balancer is not initialized, false is returned.
    
    Returns:
    The state of the load balancer, or false if the load balancer isn't defined.
  - isNormalizerOn
```
public boolean isNormalizerOn()
```
    Queries the state of the RegionNormalizerTracker. If it's not initialized, false is returned.
  - getLoadBalancerClassName
```
public String getLoadBalancerClassName()
```
    Fetch the configured LoadBalancer class name. If none is set, a default is returned.
    
    Returns:
    The name of the LoadBalancer in use.
  - getRegionNormalizerTracker
```
public RegionNormalizerTracker getRegionNormalizerTracker()
```
    Returns:
    RegionNormalizerTracker instance

Class HMaster

Nested Class Summary

Nested classes/interfaces inherited from class org.apache.hadoop.hbase.regionserver.HRegionServer

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

Field Summary

Fields inherited from class org.apache.hadoop.hbase.regionserver.HRegionServer

Constructor Summary

Method Summary

Methods inherited from class org.apache.hadoop.hbase.regionserver.HRegionServer

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

Methods inherited from class java.lang.Object

Methods inherited from interface org.apache.hadoop.hbase.master.MasterServices

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

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

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

Field Detail

LOG

MASTER

activeMasterManager

regionServerTracker

drainingServerTracker

loadBalancerTracker

regionNormalizerTracker

tableNamespaceManager

metricsMaster

fileSystemManager

serverManager

assignmentManager

rsFatals

isActiveMaster

initialized

serviceStarted

serverCrashProcessingEnabled

balancer

normalizer

balancerChore

normalizerChore

clusterStatusChore

clusterStatusPublisherChore

periodicDoMetricsChore

catalogJanitorChore

replicationZKLockCleanerChore

logCleaner

hfileCleaner

cpHost

preLoadTableDescriptors

masterActiveTime

masterCheckCompression

masterCheckEncryption

coprocessorServiceHandlers

snapshotManager

mpmHost

quotaManager

procedureExecutor

procedureStore

initializationBeforeMetaAssignment

masterJettyServer

Constructor Detail

HMaster

Method Detail

putUpJettyServer

login

waitForMasterActive

getMasterRpcServices

balanceSwitch

getProcessName

canCreateBaseZNode

canUpdateTableDescriptor

createRpcServices

configureInfoServer

getDumpServlet

doMetrics

getMasterMetrics

initializeZKBasedSystemTrackers

finishActiveMasterInitialization

createCatalogJanitor

initQuotaManager

createServerManager

unassignExcessMetaReplica

assignMeta