HMaster (Apache HBase 2.0.6 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, ConfigurationObserver, MasterServices, FavoredNodesForRegion, LastSequenceId, MutableOnlineRegions, OnlineRegions, RegionServerServices, Server, Stoppable

Direct Known Subclasses:

HMasterCommandLine.LocalHMaster
```
@InterfaceAudience.LimitedPrivate(value="Tools")
public class HMaster
extends HRegionServer
implements MasterServices
```
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.
`static class`	`HMaster.MasterStoppedException`
`static class`	`HMaster.RedirectServlet`
`protected static interface`	`HMaster.TableDescriptorGetter` Implement to return TableDescriptor after pre-checks

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 boolean`	`activeMaster`
`private ActiveMasterManager`	`activeMasterManager`
`private AssignmentManager`	`assignmentManager`
`private LoadBalancer`	`balancer`
`private BalancerChore`	`balancerChore`
`(package private) CatalogJanitor`	`catalogJanitorChore`
`private ClusterSchemaService`	`clusterSchemaService`
`private ClusterStatusChore`	`clusterStatusChore`
`private ClusterStatusPublisher`	`clusterStatusPublisherChore`
`(package private) Map<String,com.google.protobuf.Service>`	`coprocessorServiceHandlers`
`(package private) MasterCoprocessorHost`	`cpHost`
`static int`	`DEFAULT_HBASE_MASTER_WAIT_ON_SERVICE_IN_SECONDS`
`private DrainingServerTracker`	`drainingServerTracker`
`private ExpiredMobFileCleanerChore`	`expiredMobFileCleanerChore`
`private FavoredNodesManager`	`favoredNodesManager`
`private MasterFileSystem`	`fileSystemManager`
`static String`	`HBASE_MASTER_WAIT_ON_SERVICE_IN_SECONDS`
`private HbckChore`	`hbckChore`
`private HFileCleaner`	`hfileCleaner`
`private ProcedureEvent`	`initialized`
`(package private) LoadBalancerTracker`	`loadBalancerTracker`
`private LockManager`	`lockManager`
`private static org.slf4j.Logger`	`LOG`
`private LogCleaner`	`logCleaner`
`(package private) static String`	`MAINTENANCE_MODE`
`private boolean`	`maintenanceMode`
`static String`	`MASTER`
`private long`	`masterActiveTime`
`private boolean`	`masterCheckCompression`
`private boolean`	`masterCheckEncryption`
`private long`	`masterFinishedInitializationTime`
`private org.eclipse.jetty.server.Server`	`masterJettyServer` jetty server for master to redirect requests to regionserver infoServer
`private int`	`maxBlancingTime`
`private double`	`maxRitPercent`
`private long`	`mergePlanCount`
`(package private) MetricsMaster`	`metricsMaster`
`private MobCompactionChore`	`mobCompactChore`
`private IdLock`	`mobCompactionLock`
`private Map<TableName,AtomicInteger>`	`mobCompactionStates`
`private MasterMobCompactionThread`	`mobCompactThread`
`private MasterProcedureManagerHost`	`mpmHost`
`private RegionNormalizer`	`normalizer`
`private RegionNormalizerChore`	`normalizerChore`
`private boolean`	`preLoadTableDescriptors`
`private ProcedureExecutor<MasterProcedureEnv>`	`procedureExecutor`
`private WALProcedureStore`	`procedureStore`
`private MasterQuotaManager`	`quotaManager`
`private QuotaObserverChore`	`quotaObserverChore`
`private RegionNormalizerTracker`	`regionNormalizerTracker`
`private RegionServerTracker`	`regionServerTracker`
`private ReplicationManager`	`replicationManager`
`private ReplicationZKNodeCleanerChore`	`replicationZKNodeCleanerChore`
`(package private) MemoryBoundedLogMessageBuffer`	`rsFatals`
`private ServerManager`	`serverManager`
`(package private) boolean`	`serviceStarted`
`(package private) SnapshotManager`	`snapshotManager`
`private SnapshotQuotaObserverChore`	`snapshotQuotaChore`
`private SpaceQuotaSnapshotNotifier`	`spaceQuotaSnapshotNotifier`
`private SplitOrMergeTracker`	`splitOrMergeTracker`
`private long`	`splitPlanCount`
`private TableStateManager`	`tableStateManager`
`private MasterWalManager`	`walManager`

Fields inherited from class org.apache.hadoop.hbase.regionserver.HRegionServer
ABORT_TIMEOUT, ABORT_TIMEOUT_TASK, cacheConfig, cacheFlusher, clusterConnection, clusterId, clusterStatusTracker, compactSplitThread, conf, configurationManager, csm, executorService, fs, fsOk, fsUtilizationChore, hMemManager, infoServer, leases, lock, MASTER_HOSTNAME_KEY, metaTableLocator, movedRegions, msgInterval, numRegionsToReport, onlineRegions, regionFavoredNodesMap, REGIONSERVER, regionsInTransitionInRS, replicationSinkHandler, replicationSourceHandler, rpcServices, secureBulkLoadManager, serverName, sleeper, startcode, tableDescriptors, TEST_SKIP_REPORTING_TRANSITION, threadWakeFrequency, useThisHostnameInstead, walFactory, walFs, walRoller, zooKeeper

Constructor Summary

Constructors
Constructor and Description

HMaster(org.apache.hadoop.conf.Configuration conf)
Initializes the HMaster.

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

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`abort(String reason, Throwable cause)` Cause the server to exit without closing the regions it is serving, the log it is using and without notifying the master.
`boolean`	`abortProcedure(long procId, boolean mayInterruptIfRunning)` Abort a procedure.
`long`	`addColumn(TableName tableName, ColumnFamilyDescriptor column, long nonceGroup, long nonce)` Add a new column to an existing table
`void`	`addReplicationPeer(String peerId, ReplicationPeerConfig peerConfig, boolean enabled)` Add a new replication peer for replicating data to slave cluster
`boolean`	`balance()`
`boolean`	`balance(boolean force)`
`boolean`	`balanceSwitch(boolean b)`
`private void`	`balanceThrottling(long nextBalanceStartTime, int maxRegionsInTransition, long cutoffTime)` It first sleep to the next balance plan start time.
`protected boolean`	`canCreateBaseZNode()`
`protected boolean`	`canUpdateTableDescriptor()`
`private void`	`checkClassLoading(org.apache.hadoop.conf.Configuration conf, TableDescriptor htd)`
`private void`	`checkCompactionPolicy(org.apache.hadoop.conf.Configuration conf, TableDescriptor htd)`
`private void`	`checkCompression(ColumnFamilyDescriptor hcd)`
`private void`	`checkCompression(TableDescriptor htd)`
`private void`	`checkEncryption(org.apache.hadoop.conf.Configuration conf, ColumnFamilyDescriptor hcd)`
`private void`	`checkEncryption(org.apache.hadoop.conf.Configuration conf, TableDescriptor htd)`
`void`	`checkIfShouldMoveSystemRegionAsync()` Called when a new RegionServer is added to the cluster.
`(package private) void`	`checkInitialized()`
`private void`	`checkReplicationScope(ColumnFamilyDescriptor hcd)`
`(package private) void`	`checkServiceStarted()`
`private void`	`checkTableExists(TableName tableName)`
`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)` Utility for constructing an instance of the passed HMaster class.
`protected MasterMetaBootstrap`	`createMetaBootstrap()` Create a `MasterMetaBootstrap` instance.
`(package private) long`	`createNamespace(NamespaceDescriptor namespaceDescriptor, long nonceGroup, long nonce)` Create a new Namespace.
`private void`	`createProcedureExecutor()`
`private SpaceQuotaSnapshotNotifier`	`createQuotaSnapshotNotifier()`
`protected RSRpcServices`	`createRpcServices()`
`protected ServerManager`	`createServerManager(MasterServices master)` Create a `ServerManager` instance.
`long`	`createSystemTable(TableDescriptor tableDescriptor)` Create a system table using the given table definition.
`long`	`createTable(TableDescriptor tableDescriptor, byte[][] splitKeys, long nonceGroup, long nonce)` Create a table using the given table definition.
`void`	`decommissionRegionServers(List<ServerName> servers, boolean offload)` Mark region server(s) as decommissioned (previously called 'draining') to prevent additional regions from getting assigned to them.
`static void`	`decorateMasterConfiguration(org.apache.hadoop.conf.Configuration conf)` This method modifies the master's configuration in order to inject replication-related features
`long`	`deleteColumn(TableName tableName, byte[] columnName, long nonceGroup, long nonce)` Delete a column from an existing table
`(package private) long`	`deleteNamespace(String name, long nonceGroup, long nonce)` Delete an existing Namespace.
`long`	`deleteTable(TableName tableName, long nonceGroup, long nonce)` Delete a table
`void`	`disableReplicationPeer(String peerId)` Stop the replication stream to the specified peer
`long`	`disableTable(TableName tableName, long nonceGroup, long nonce)` Disable an existing table
`void`	`enableReplicationPeer(String peerId)` Restart the replication stream to the specified peer
`long`	`enableTable(TableName tableName, long nonceGroup, long nonce)` Enable an existing table
`private static void`	`filterTablesByRegex(Collection<TableDescriptor> 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 List<ServerName>`	`getBackupMasters()`
`CatalogJanitor`	`getCatalogJanitor()`
`String`	`getClientIdAuditPrefix()`
`ClusterMetrics`	`getClusterMetrics()`
`ClusterMetrics`	`getClusterMetrics(EnumSet<ClusterMetrics.Option> options)`
`ClusterMetrics`	`getClusterMetricsWithoutCoprocessor()`
`ClusterMetrics`	`getClusterMetricsWithoutCoprocessor(EnumSet<ClusterMetrics.Option> options)`
`ClusterSchema`	`getClusterSchema()`
`protected Class<? extends javax.servlet.http.HttpServlet>`	`getDumpServlet()`
`FavoredNodesManager`	`getFavoredNodesManager()`
`HbckChore`	`getHbckChore()`
`HFileCleaner`	`getHFileCleaner()`
`ProcedureEvent`	`getInitializedEvent()`
`long`	`getLastMajorCompactionTimestamp(TableName table)`
`long`	`getLastMajorCompactionTimestampForRegion(byte[] regionName)`
`LoadBalancer`	`getLoadBalancer()`
`String`	`getLoadBalancerClassName()` Fetch the configured `LoadBalancer` class name.
`static String`	`getLoadedCoprocessors()` The set of loaded coprocessors is stored in a static set.
`LockManager`	`getLockManager()`
`List<LockedResource>`	`getLocks()` Get locks
`LogCleaner`	`getLogCleaner()`
`long`	`getMasterActiveTime()`
`MasterCoprocessorHost`	`getMasterCoprocessorHost()`
`String[]`	`getMasterCoprocessors()`
`MasterFileSystem`	`getMasterFileSystem()`
`long`	`getMasterFinishedInitializationTime()`
`MetricsMaster`	`getMasterMetrics()`
`ProcedureExecutor<MasterProcedureEnv>`	`getMasterProcedureExecutor()`
`MasterProcedureManagerHost`	`getMasterProcedureManagerHost()`
`MasterQuotaManager`	`getMasterQuotaManager()`
`MasterRpcServices`	`getMasterRpcServices()`
`long`	`getMasterStartTime()`
`MasterWalManager`	`getMasterWalManager()`
`private int`	`getMaxBalancingTime()`
`private int`	`getMaxRegionsInTransition()`
`long`	`getMergePlanCount()`
`protected Function<TableDescriptorBuilder,TableDescriptorBuilder>`	`getMetaTableObserver()`
`org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.GetRegionInfoResponse.CompactionState`	`getMobCompactionState(TableName tableName)` Gets the mob file compaction state for a specific table.
`(package private) NamespaceDescriptor`	`getNamespace(String name)` Get a Namespace
`(package private) List<NamespaceDescriptor>`	`getNamespaces()` Get all Namespaces
`int`	`getNumWALFiles()`
`List<Procedure<?>>`	`getProcedures()` Get procedures
`protected String`	`getProcessName()`
`QuotaObserverChore`	`getQuotaObserverChore()`
`RegionNormalizer`	`getRegionNormalizer()`
`RegionNormalizerTracker`	`getRegionNormalizerTracker()`
`MemoryBoundedLogMessageBuffer`	`getRegionServerFatalLogBuffer()`
`int`	`getRegionServerInfoPort(ServerName sn)`
`String`	`getRegionServerVersion(ServerName sn)`
`(package private) InetAddress`	`getRemoteInetAddress(int port, long serverStartCode)`
`ReplicationPeerConfig`	`getReplicationPeerConfig(String peerId)` Returns the configured ReplicationPeerConfig for the specified peer
`ServerManager`	`getServerManager()`
`ServerName`	`getServerName()`
`SnapshotManager`	`getSnapshotManager()`
`SpaceQuotaSnapshotNotifier`	`getSpaceQuotaSnapshotNotifier()`
`SplitOrMergeTracker`	`getSplitOrMergeTracker()`
`long`	`getSplitPlanCount()`
`TableDescriptors`	`getTableDescriptors()`
`private List<TableDescriptor>`	`getTableDescriptors(List<TableDescriptor> htds, String namespace, String regex, List<TableName> tableNameList, boolean includeSysTables)`
`TableStateManager`	`getTableStateManager()`
`protected String`	`getUseThisHostnameInstead(org.apache.hadoop.conf.Configuration conf)`
`WALProcedureStore`	`getWalProcedureStore()`
`ZKWatcher`	`getZooKeeper()` Gets the ZooKeeper instance for this server.
`protected void`	`initClusterSchemaService()`
`protected void`	`initializeZKBasedSystemTrackers()` Initialize all ZK based system trackers.
`private void`	`initMobCleaner()`
`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)`
`(package private) boolean`	`isCleanerChoreEnabled()`
`boolean`	`isInitialized()` Report whether this master has completed with its initialization and is ready.
`boolean`	`isInMaintenanceMode()` Report whether this master is in maintenance mode.
`boolean`	`isNormalizerOn()` Queries the state of the `RegionNormalizerTracker`.
`private boolean`	`isRegionOnline(RegionInfo ri)`
`boolean`	`isSplitOrMergeEnabled(MasterSwitchType switchType)` Queries the state of the `SplitOrMergeTracker`.
`List<ServerName>`	`listDecommissionedRegionServers()` List region servers marked as decommissioned (previously called 'draining') to not get regions assigned to them.
`List<ReplicationPeerDescription>`	`listReplicationPeers(String regex)` Return a list of replication peers.
`List<TableDescriptor>`	`listTableDescriptors(String namespace, String regex, List<TableName> tableNameList, boolean includeSysTables)` Returns the list of table descriptors that match the specified request
`List<TableDescriptor>`	`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)`
`long`	`mergeRegions(RegionInfo[] regionsToMerge, boolean forcible, long ng, long nonce)` Merge regions in a table.
`long`	`modifyColumn(TableName tableName, ColumnFamilyDescriptor descriptor, long nonceGroup, long nonce)` Modify the column descriptor of an existing column in an existing table
`(package private) long`	`modifyNamespace(NamespaceDescriptor newNsDescriptor, long nonceGroup, long nonce)` Modify an existing Namespace.
`private long`	`modifyTable(TableName tableName, HMaster.TableDescriptorGetter newDescriptorGetter, long nonceGroup, long nonce)`
`long`	`modifyTable(TableName tableName, TableDescriptor newDescriptor, long nonceGroup, long nonce)` Modify the descriptor of an existing table
`void`	`move(byte[] encodedRegionName, byte[] destServerName)`
`boolean`	`normalizeRegions()` Perform normalization of cluster (invoked by `RegionNormalizerChore`).
`private int`	`putUpJettyServer()`
`void`	`recommissionRegionServer(ServerName server, List<byte[]> encodedRegionNames)` Remove decommission marker (previously called 'draining') from a region server to allow regions assignments.
`boolean`	`registerService(com.google.protobuf.Service instance)` Registers a new protocol buffer `Service` subclass as a coprocessor endpoint to be available for handling
`void`	`removeReplicationPeer(String peerId)` Removes a peer and stops the replication
`void`	`reportMobCompactionEnd(TableName tableName)`
`void`	`reportMobCompactionStart(TableName tableName)`
`void`	`requestMobCompaction(TableName tableName, List<ColumnFamilyDescriptor> columns, boolean allFiles)` Requests mob compaction.
`long`	`restoreSnapshot(org.apache.hadoop.hbase.shaded.protobuf.generated.SnapshotProtos.SnapshotDescription snapshotDesc, long nonceGroup, long nonce, boolean restoreAcl)`
`void`	`run()` The HRegionServer sticks in this loop until closed.
`private void`	`sanityCheckTableDescriptor(TableDescriptor htd)` Checks whether the table conforms to some sane limits, and configured values (compression, etc) work.
`void`	`setCatalogJanitorEnabled(boolean b)` Switch for the background CatalogJanitor thread.
`void`	`setInitialized(boolean isInitialized)`
`void`	`shutdown()` Shutdown the cluster.
`long`	`splitRegion(RegionInfo regionInfo, byte[] splitRow, long nonceGroup, long nonce)` Split a region.
`private void`	`startActiveMasterManager(int infoPort)`
`private void`	`startProcedureExecutor()`
`private void`	`startServiceThreads()`
`void`	`stop(String msg)` Stop this service.
`private void`	`stopChores()`
`void`	`stopMaster()`
`private void`	`stopProcedureExecutor()`
`protected void`	`stopServiceThreads()` Wait on all threads to finish.
`long`	`truncateTable(TableName tableName, boolean preserveSplits, long nonceGroup, long nonce)` Truncate a table
`void`	`updateConfigurationForQuotasObserver(org.apache.hadoop.conf.Configuration conf)` Adds the `MasterQuotasObserver` to the list of configured Master observers to automatically remove quotas for a table when that table is deleted.
`void`	`updateReplicationPeerConfig(String peerId, ReplicationPeerConfig peerConfig)` Update the peerConfig for the specified peer
`protected void`	`waitForMasterActive()` If configured to put regions on active master, wait till a backup master becomes active.
`private void`	`waitForRegionServers(MonitoredTask status)`
`boolean`	`waitUntilMetaOnline()` Check hbase:meta is up and ready for reading.
`boolean`	`waitUntilNamespaceOnline()` Check hbase:namespace table is assigned.
`private static void`	`warnOrThrowExceptionForFailure(boolean logWarn, String confKey, String message, Exception cause)`

Methods inherited from class org.apache.hadoop.hbase.regionserver.HRegionServer
abort, addRegion, addToMovedRegions, checkFileSystem, cleanMovedRegions, clearRegionBlockCache, closeAllRegions, closeAndOfflineRegionForSplitOrMerge, closeRegion, constructRegionServer, convertThrowableToIOE, createClusterConnection, createConnection, createRegionLoad, createRegionServerStatusStub, createRegionServerStatusStub, execRegionServerService, getCacheConfig, getChoreService, getClusterConnection, getClusterId, getCompactionPressure, getCompactionRequestor, getCompactSplitThread, getConfiguration, getConfigurationManager, getConnection, getCoordinatedStateManager, getEventLoopGroupConfig, getExecutorService, getFavoredNodesForRegion, getFileSystem, getFlushPressure, getFlushRequester, getFlushThroughputController, getFsTableDescriptors, getHeapMemoryManager, getInfoServer, getLastSequenceId, getLeases, getMasterAddressTracker, getMetaTableLocator, getMetrics, getMostLoadedRegions, getNonceManager, getNumberOfOnlineRegions, getOnlineRegion, getOnlineRegionsLocalContext, getOnlineTables, getRegion, getRegion, getRegionBlockLocations, getRegionByEncodedName, getRegionByEncodedName, getRegions, getRegions, getRegionServerAccounting, getRegionServerCoprocessorHost, getRegionServerCoprocessors, getRegionServerMetrics, getRegionServerRpcQuotaManager, getRegionServerSpaceQuotaManager, getRegionsInTransitionInRS, getReplicationSourceService, getRootDir, getRpcServer, getRSRpcServices, getSecureBulkLoadManager, getStartcode, getThreadWakeFrequency, getWAL, getWALFileSystem, getWalRoller, getWALRootDir, getWALs, handleReportForDutyResponse, initializeMemStoreChunkCreator, isAborted, isClusterUp, isOnline, isStopped, isStopping, kill, movedRegionCleanerPeriod, onConfigurationChange, postOpenDeployTasks, regionLock, removeRegion, reportRegionSizesForQuotas, reportRegionStateTransition, sendShutdownInterrupt, setupClusterConnection, stop, toString, tryRegionServerReport, unassign, 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, isClusterUp

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

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

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

- Field Detail
  - LOG
```
private static org.slf4j.Logger LOG
```
  - MASTER
```
public static final String MASTER
```
    See Also:
    
    Constant Field Values
  - activeMasterManager
```
private final ActiveMasterManager activeMasterManager
```
  - regionServerTracker
```
private RegionServerTracker regionServerTracker
```
  - drainingServerTracker
```
private DrainingServerTracker drainingServerTracker
```
  - loadBalancerTracker
```
LoadBalancerTracker loadBalancerTracker
```
  - splitOrMergeTracker
```
private SplitOrMergeTracker splitOrMergeTracker
```
  - regionNormalizerTracker
```
private RegionNormalizerTracker regionNormalizerTracker
```
  - clusterSchemaService
```
private ClusterSchemaService clusterSchemaService
```
  - HBASE_MASTER_WAIT_ON_SERVICE_IN_SECONDS
```
public static final String HBASE_MASTER_WAIT_ON_SERVICE_IN_SECONDS
```
    See Also:
    
    Constant Field Values
  - DEFAULT_HBASE_MASTER_WAIT_ON_SERVICE_IN_SECONDS
```
public static final int DEFAULT_HBASE_MASTER_WAIT_ON_SERVICE_IN_SECONDS
```
    See Also:
    
    Constant Field Values
  - metricsMaster
```
final MetricsMaster metricsMaster
```
  - fileSystemManager
```
private MasterFileSystem fileSystemManager
```
  - walManager
```
private MasterWalManager walManager
```
  - serverManager
```
private volatile ServerManager serverManager
```
  - assignmentManager
```
private AssignmentManager assignmentManager
```
  - replicationManager
```
private ReplicationManager replicationManager
```
  - rsFatals
```
MemoryBoundedLogMessageBuffer rsFatals
```
  - activeMaster
```
private volatile boolean activeMaster
```
  - initialized
```
private final ProcedureEvent initialized
```
  - serviceStarted
```
volatile boolean serviceStarted
```
  - maxBlancingTime
```
private final int maxBlancingTime
```
  - maxRitPercent
```
private final double maxRitPercent
```
  - lockManager
```
private final LockManager lockManager
```
  - balancer
```
private LoadBalancer balancer
```
  - normalizer
```
private RegionNormalizer normalizer
```
  - balancerChore
```
private BalancerChore balancerChore
```
  - normalizerChore
```
private RegionNormalizerChore normalizerChore
```
  - clusterStatusChore
```
private ClusterStatusChore clusterStatusChore
```
  - clusterStatusPublisherChore
```
private ClusterStatusPublisher clusterStatusPublisherChore
```
  - hbckChore
```
private HbckChore hbckChore
```
  - catalogJanitorChore
```
CatalogJanitor catalogJanitorChore
```
  - replicationZKNodeCleanerChore
```
private ReplicationZKNodeCleanerChore replicationZKNodeCleanerChore
```
  - logCleaner
```
private LogCleaner logCleaner
```
  - hfileCleaner
```
private HFileCleaner hfileCleaner
```
  - expiredMobFileCleanerChore
```
private ExpiredMobFileCleanerChore expiredMobFileCleanerChore
```
  - mobCompactChore
```
private MobCompactionChore mobCompactChore
```
  - mobCompactThread
```
private MasterMobCompactionThread mobCompactThread
```
  - mobCompactionLock
```
private final IdLock mobCompactionLock
```
  - mobCompactionStates
```
private Map<TableName,AtomicInteger> mobCompactionStates
```
  - cpHost
```
MasterCoprocessorHost cpHost
```
  - preLoadTableDescriptors
```
private final boolean preLoadTableDescriptors
```
  - masterActiveTime
```
private long masterActiveTime
```
  - masterFinishedInitializationTime
```
private long masterFinishedInitializationTime
```
  - masterCheckCompression
```
private final boolean masterCheckCompression
```
  - masterCheckEncryption
```
private final boolean masterCheckEncryption
```
  - coprocessorServiceHandlers
```
Map<String,com.google.protobuf.Service> coprocessorServiceHandlers
```
  - snapshotManager
```
SnapshotManager snapshotManager
```
  - mpmHost
```
private MasterProcedureManagerHost mpmHost
```
  - quotaManager
```
private volatile MasterQuotaManager quotaManager
```
  - spaceQuotaSnapshotNotifier
```
private SpaceQuotaSnapshotNotifier spaceQuotaSnapshotNotifier
```
  - quotaObserverChore
```
private QuotaObserverChore quotaObserverChore
```
  - snapshotQuotaChore
```
private SnapshotQuotaObserverChore snapshotQuotaChore
```
  - procedureExecutor
```
private ProcedureExecutor<MasterProcedureEnv> procedureExecutor
```
  - procedureStore
```
private WALProcedureStore procedureStore
```
  - tableStateManager
```
private TableStateManager tableStateManager
```
  - splitPlanCount
```
private long splitPlanCount
```
  - mergePlanCount
```
private long mergePlanCount
```
  - favoredNodesManager
```
private FavoredNodesManager favoredNodesManager
```
  - masterJettyServer
```
private org.eclipse.jetty.server.Server masterJettyServer
```
    jetty server for master to redirect requests to regionserver infoServer
  - maintenanceMode
```
private final boolean maintenanceMode
```
  - MAINTENANCE_MODE
```
static final String MAINTENANCE_MODE
```
    See Also:
    
    Constant Field Values
- Constructor Detail
  - HMaster
```
public HMaster(org.apache.hadoop.conf.Configuration conf)
        throws IOException,
               org.apache.zookeeper.KeeperException
```
    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:
    
    IOException
    
    org.apache.zookeeper.KeeperException
- Method Detail
  - getUseThisHostnameInstead
```
protected String getUseThisHostnameInstead(org.apache.hadoop.conf.Configuration conf)
```
    Overrides:
    
    getUseThisHostnameInstead in class HRegionServer
  - run
```
public void run()
```
    Description copied from class: HRegionServer
    
    The HRegionServer sticks in this loop until closed.
    
    Specified by:
    
    run in interface Runnable
    
    Overrides:
    
    run in class HRegionServer
  - putUpJettyServer
```
private int putUpJettyServer()
                      throws IOException
```
    Throws:
    
    IOException
  - getMetaTableObserver
```
protected Function<TableDescriptorBuilder,TableDescriptorBuilder> getMetaTableObserver()
```
    Overrides:
    
    getMetaTableObserver in class HRegionServer
  - 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
  - getMasterMetrics
```
public MetricsMaster getMasterMetrics()
```
    Specified by:
    
    getMasterMetrics in interface MasterServices
    
    Returns:
    
    Master's instance of MetricsMaster
  - initializeZKBasedSystemTrackers
```
protected void initializeZKBasedSystemTrackers()
                                        throws IOException,
                                               InterruptedException,
                                               org.apache.zookeeper.KeeperException
```
    Initialize all ZK based system trackers. But do not include RegionServerTracker, it should have already been initialized along with ServerManager. Will be overridden in tests.
    
    Throws:
    
    IOException
    
    InterruptedException
    
    org.apache.zookeeper.KeeperException
  - finishActiveMasterInitialization
```
private void finishActiveMasterInitialization(MonitoredTask status)
                                       throws IOException,
                                              InterruptedException,
                                              org.apache.zookeeper.KeeperException
```
    Finish initialization of HMaster after becoming the primary master. The startup order is a bit complicated but very important, do not change it unless you know what you are doing.
  - Initialize file system based components - file system manager, wal manager, table descriptors, etc
  - Publish cluster id
  - Here comes the most complicated part - initialize server manager, assignment manager and region server tracker
    1. Create server manager
    2. Create procedure executor, load the procedures, but do not start workers. We will start it later after we finish scheduling SCPs to avoid scheduling duplicated SCPs for the same server
    3. Create assignment manager and start it, load the meta region state, but do not load data from meta region
    4. Start region server tracker, construct the online servers set and find out dead servers and schedule SCP for them. The online servers will be constructed by scanning zk, and we will also scan the wal directory to find out possible live region servers, and the differences between these two sets are the dead servers
  - If this is a new deploy, schedule a InitMetaProcedure to initialize meta
  - Start necessary service threads - balancer, catalog janior, executor services, and also the procedure executor, etc. Notice that the balancer must be created first as assignment manager may use it when assigning regions.
  - Wait for meta to be initialized if necesssary, start table state manager.
  - Wait for enough region servers to check-in
  - Let assignment manager load data from meta and construct region states
  - Start all other things such as chore services, etc

Throws:: IOException; InterruptedException; org.apache.zookeeper.KeeperException

waitUntilMetaOnline
```
public boolean waitUntilMetaOnline()
                            throws InterruptedException
```
Check hbase:meta is up and ready for reading. For use during Master startup only.

Returns:

True if meta is UP and online and startup can progress. Otherwise, meta is not online and we will hold here until operator intervention.

Throws:

InterruptedException

isRegionOnline
```
private boolean isRegionOnline(RegionInfo ri)
                        throws InterruptedException
```
Returns:

True if region is online and scannable else false if an error or shutdown (Otherwise we just block in here holding up all forward-progess).

Throws:

InterruptedException

waitUntilNamespaceOnline
```
public boolean waitUntilNamespaceOnline()
                                 throws InterruptedException
```
Check hbase:namespace table is assigned. If not, startup will hang looking for the ns table (TODO: Fix this! NS should not hold-up startup).

Returns:

True if namespace table is up/online.

Throws:

InterruptedException

updateConfigurationForQuotasObserver
```
public void updateConfigurationForQuotasObserver(org.apache.hadoop.conf.Configuration conf)
```
Adds the MasterQuotasObserver to the list of configured Master observers to automatically remove quotas for a table when that table is deleted.

initMobCleaner
```
private void initMobCleaner()
```

createMetaBootstrap
```
protected MasterMetaBootstrap createMetaBootstrap()
```
Create a MasterMetaBootstrap instance.

Will be overridden in tests.

createServerManager

protected ServerManager createServerManager(MasterServices master)
                                     throws IOException

Create a ServerManager instance.

Will be overridden in tests.

Throws:: IOException

waitForRegionServers

private void waitForRegionServers(MonitoredTask status)
                           throws IOException,
                                  InterruptedException

Throws:: IOException; InterruptedException

initClusterSchemaService

protected void initClusterSchemaService()
                                 throws IOException,
                                        InterruptedException

Throws:: IOException; InterruptedException

initQuotaManager

private void initQuotaManager()
                       throws IOException

Throws:: IOException

createQuotaSnapshotNotifier

private SpaceQuotaSnapshotNotifier createQuotaSnapshotNotifier()

isCatalogJanitorEnabled
```
boolean isCatalogJanitorEnabled()
```

isCleanerChoreEnabled
```
boolean isCleanerChoreEnabled()
```

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.

getMasterWalManager
```
public MasterWalManager getMasterWalManager()
```
Specified by:

getMasterWalManager in interface MasterServices

Returns:

Master's WALs MasterWalManager utility class.

getTableStateManager
```
public TableStateManager getTableStateManager()
```
Specified by:

getTableStateManager in interface MasterServices

Returns:

Master's instance of TableStateManager

startServiceThreads

private void startServiceThreads()
                          throws IOException

Throws:: IOException

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

createProcedureExecutor

private void createProcedureExecutor()
                              throws IOException

Throws:: IOException

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

getMaxBalancingTime
```
private int getMaxBalancingTime()
```
Returns:

Maximum time we should run balancer for

getMaxRegionsInTransition
```
private int getMaxRegionsInTransition()
```
Returns:

Maximum number of regions in transition

balanceThrottling
```
private void balanceThrottling(long nextBalanceStartTime,
                               int maxRegionsInTransition,
                               long cutoffTime)
```
It first sleep to the next balance plan start time. Meanwhile, throttling by the max number regions in transition to protect availability.

Parameters:

nextBalanceStartTime - The next balance plan start time

maxRegionsInTransition - max number of regions in transition

cutoffTime - when to exit balancer

balance

public boolean balance()
                throws IOException

Throws:: IOException

balance

public boolean balance(boolean force)
                throws IOException

Throws:: IOException

getRegionNormalizer
```
public RegionNormalizer getRegionNormalizer()
```
Specified by:

getRegionNormalizer in interface MasterServices

Returns:

Master's instance of RegionNormalizer

normalizeRegions
```
public boolean normalizeRegions()
                         throws IOException
```
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

getClientIdAuditPrefix
```
public String getClientIdAuditPrefix()
```
Specified by:

getClientIdAuditPrefix in interface MasterServices

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.

mergeRegions
```
public long mergeRegions(RegionInfo[] regionsToMerge,
                         boolean forcible,
                         long ng,
                         long nonce)
                  throws IOException
```
Description copied from interface: MasterServices

Merge regions in a table.

Specified by:

mergeRegions in interface MasterServices

Parameters:

regionsToMerge - daughter regions to merge

forcible - whether to force to merge even two regions are not adjacent

ng - used to detect duplicate

nonce - used to detect duplicate

Returns:

procedure Id

Throws:

IOException

splitRegion
```
public long splitRegion(RegionInfo regionInfo,
                        byte[] splitRow,
                        long nonceGroup,
                        long nonce)
                 throws IOException
```
Description copied from interface: MasterServices

Split a region.

Specified by:

splitRegion in interface MasterServices

Parameters:

regionInfo - region to split

splitRow - split point

nonceGroup - used to detect duplicate

nonce - used to detect duplicate

Returns:

procedure Id

Throws:

IOException

move

public void move(byte[] encodedRegionName,
                 byte[] destServerName)
          throws HBaseIOException

Throws:: HBaseIOException

createTable
```
public long createTable(TableDescriptor tableDescriptor,
                        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:

tableDescriptor - The table definition

splitKeys - Starting row keys for the initial table regions. If null

nonce - a single region is created.

Throws:

IOException

createSystemTable
```
public long createSystemTable(TableDescriptor tableDescriptor)
                       throws IOException
```
Description copied from interface: MasterServices

Create a system table using the given table definition.

Specified by:

createSystemTable in interface MasterServices

Parameters:

tableDescriptor - The system table definition a single region is created.

Throws:

IOException

sanityCheckTableDescriptor
```
private void sanityCheckTableDescriptor(TableDescriptor 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

checkReplicationScope

private void checkReplicationScope(ColumnFamilyDescriptor hcd)
                            throws IOException

Throws:: IOException

checkCompactionPolicy

private void checkCompactionPolicy(org.apache.hadoop.conf.Configuration conf,
                                   TableDescriptor 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(TableDescriptor htd)
                       throws IOException

Throws:: IOException

checkCompression

private void checkCompression(ColumnFamilyDescriptor hcd)
                       throws IOException

Throws:: IOException

checkEncryption

private void checkEncryption(org.apache.hadoop.conf.Configuration conf,
                             TableDescriptor htd)
                      throws IOException

Throws:: IOException

checkEncryption

private void checkEncryption(org.apache.hadoop.conf.Configuration conf,
                             ColumnFamilyDescriptor hcd)
                      throws IOException

Throws:: IOException

checkClassLoading

private void checkClassLoading(org.apache.hadoop.conf.Configuration conf,
                               TableDescriptor 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 long 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 long addColumn(TableName tableName,
                      ColumnFamilyDescriptor column,
                      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; column - The column definition
Throws:: IOException

modifyColumn
```
public long modifyColumn(TableName tableName,
                         ColumnFamilyDescriptor 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 long 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

modifyTable

private long modifyTable(TableName tableName,
                         HMaster.TableDescriptorGetter newDescriptorGetter,
                         long nonceGroup,
                         long nonce)
                  throws IOException

Throws:: IOException

modifyTable

public long modifyTable(TableName tableName,
                        TableDescriptor newDescriptor,
                        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; newDescriptor - The updated table descriptor
Throws:: IOException

restoreSnapshot

public long restoreSnapshot(org.apache.hadoop.hbase.shaded.protobuf.generated.SnapshotProtos.SnapshotDescription snapshotDesc,
                            long nonceGroup,
                            long nonce,
                            boolean restoreAcl)
                     throws IOException

Throws:: IOException

checkTableExists

private void checkTableExists(TableName tableName)
                       throws IOException,
                              TableNotFoundException

Throws:: IOException; TableNotFoundException

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

getClusterMetricsWithoutCoprocessor

public ClusterMetrics getClusterMetricsWithoutCoprocessor()
                                                   throws InterruptedIOException

Throws:: InterruptedIOException

getClusterMetricsWithoutCoprocessor

public ClusterMetrics getClusterMetricsWithoutCoprocessor(EnumSet<ClusterMetrics.Option> options)
                                                   throws InterruptedIOException

Throws:: InterruptedIOException

getClusterMetrics

public ClusterMetrics getClusterMetrics()
                                 throws IOException

Returns:: cluster status
Throws:: IOException

getClusterMetrics

public ClusterMetrics getClusterMetrics(EnumSet<ClusterMetrics.Option> options)
                                 throws IOException

Throws:: IOException

getBackupMasters

private List<ServerName> getBackupMasters()
                                   throws InterruptedIOException

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.

getMasterFinishedInitializationTime
```
public long getMasterFinishedInitializationTime()
```
Returns:

timestamp in millis when HMaster finished becoming the active master

getNumWALFiles
```
public int getNumWALFiles()
```

getWalProcedureStore

public WALProcedureStore getWalProcedureStore()

getRegionServerInfoPort

public int getRegionServerInfoPort(ServerName sn)

getRegionServerVersion
```
public String getRegionServerVersion(ServerName sn)
```
Specified by:

getRegionServerVersion in interface MasterServices

checkIfShouldMoveSystemRegionAsync
```
public void checkIfShouldMoveSystemRegionAsync()
```
Description copied from interface: MasterServices

Called when a new RegionServer is added to the cluster. Checks if new server has a newer version than any existing server and will move system tables there if so.

Specified by:

checkIfShouldMoveSystemRegionAsync in interface MasterServices

getMasterCoprocessors
```
public String[] getMasterCoprocessors()
```
Returns:

array of coprocessor SimpleNames.

abort
```
public void abort(String reason,
                  Throwable cause)
```
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:

reason - the reason we are aborting

cause - the exception that caused the abort, or null

getZooKeeper
```
public ZKWatcher 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

getCatalogJanitor
```
public CatalogJanitor getCatalogJanitor()
```
Specified by:

getCatalogJanitor in interface MasterServices

Returns:

Master's instance of CatalogJanitor

getRegionServerFatalLogBuffer

public MemoryBoundedLogMessageBuffer getRegionServerFatalLogBuffer()

shutdown
```
public void shutdown()
              throws IOException
```
Shutdown the cluster. Master runs a coordinated stop of all RegionServers and then itself.

Throws:

IOException

stopMaster

public void stopMaster()
                throws IOException

Throws:: IOException

stop
```
public void stop(String msg)
```
Description copied from interface: Stoppable

Stop this service. Implementers should favor logging errors over throwing RuntimeExceptions.

Specified by:

stop in interface Stoppable

Overrides:

stop in class HRegionServer

Parameters:

msg - Why we're stopping.

checkServiceStarted

void checkServiceStarted()
                  throws ServerNotRunningYetException

Throws:: ServerNotRunningYetException

checkInitialized

void checkInitialized()
               throws PleaseHoldException,
                      ServerNotRunningYetException,
                      MasterNotRunningException,
                      HMaster.MasterStoppedException

Throws:: PleaseHoldException; ServerNotRunningYetException; MasterNotRunningException; HMaster.MasterStoppedException

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.

Specified by:

isActiveMaster in interface MasterServices

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.

isInMaintenanceMode
```
public boolean isInMaintenanceMode()
```
Report whether this master is in maintenance mode.

Specified by:

isInMaintenanceMode in interface MasterServices

Returns:

true if master is in maintenanceMode

setInitialized

public void setInitialized(boolean isInitialized)

getInitializedEvent
```
public ProcedureEvent getInitializedEvent()
```
Specified by:

getInitializedEvent in interface MasterServices

Returns:

Tripped when Master has finished initialization.

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

getSplitPlanCount
```
public long getSplitPlanCount()
```

getMergePlanCount
```
public long getMergePlanCount()
```

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)

Utility for constructing an instance of the passed HMaster class.

Parameters:: masterClass -
Returns:: HMaster instance.

main

public static void main(String[] args)

See Also:: HMasterCommandLine

getHFileCleaner
```
public HFileCleaner getHFileCleaner()
```

getLogCleaner
```
public LogCleaner getLogCleaner()
```

getSnapshotManager
```
public SnapshotManager getSnapshotManager()
```
Specified by:

getSnapshotManager in interface MasterServices

Returns:

the underlying snapshot manager

getMasterProcedureManagerHost
```
public MasterProcedureManagerHost getMasterProcedureManagerHost()
```
Specified by:

getMasterProcedureManagerHost in interface MasterServices

Returns:

the underlying MasterProcedureManagerHost

getClusterSchema
```
public ClusterSchema getClusterSchema()
```
Specified by:

getClusterSchema in interface MasterServices

Returns:

Master's instance of ClusterSchema

createNamespace
```
long createNamespace(NamespaceDescriptor namespaceDescriptor,
                     long nonceGroup,
                     long nonce)
              throws IOException
```
Create a new Namespace.

Parameters:

namespaceDescriptor - descriptor for new Namespace

nonceGroup - Identifier for the source of the request, a client or process.

nonce - A unique identifier for this operation from the client or process identified by nonceGroup (the source must ensure each operation gets a unique id).

Returns:

procedure id

Throws:

IOException

modifyNamespace
```
long modifyNamespace(NamespaceDescriptor newNsDescriptor,
                     long nonceGroup,
                     long nonce)
              throws IOException
```
Modify an existing Namespace.

Parameters:

nonceGroup - Identifier for the source of the request, a client or process.

nonce - A unique identifier for this operation from the client or process identified by nonceGroup (the source must ensure each operation gets a unique id).

Returns:

procedure id

Throws:

IOException

deleteNamespace
```
long deleteNamespace(String name,
                     long nonceGroup,
                     long nonce)
              throws IOException
```
Delete an existing Namespace. Only empty Namespaces (no tables) can be removed.

Parameters:

nonceGroup - Identifier for the source of the request, a client or process.

nonce - A unique identifier for this operation from the client or process identified by nonceGroup (the source must ensure each operation gets a unique id).

Returns:

procedure id

Throws:

IOException

getNamespace
```
NamespaceDescriptor getNamespace(String name)
                          throws IOException
```
Get a Namespace

Parameters:

name - Name of the Namespace

Returns:

Namespace descriptor for name

Throws:

IOException

getNamespaces

List<NamespaceDescriptor> getNamespaces()
                                 throws IOException

Get all Namespaces

Returns:: All Namespace 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

listTableDescriptorsByNamespace
```
public List<TableDescriptor> 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

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

getProcedures
```
public List<Procedure<?>> getProcedures()
                                 throws IOException
```
Description copied from interface: MasterServices

Get procedures

Specified by:

getProcedures in interface MasterServices

Returns:

procedure list

Throws:

IOException

getLocks
```
public List<LockedResource> getLocks()
                              throws IOException
```
Description copied from interface: MasterServices

Get locks

Specified by:

getLocks in interface MasterServices

Returns:

lock list

Throws:

IOException

listTableDescriptors

public List<TableDescriptor> 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

getTableDescriptors

private List<TableDescriptor> getTableDescriptors(List<TableDescriptor> htds,
                                                  String namespace,
                                                  String regex,
                                                  List<TableName> tableNameList,
                                                  boolean includeSysTables)
                                           throws IOException

Returns:: list of table table descriptors after filtering by regex and whether to include system tables, etc.
Throws:: IOException

filterTablesByRegex

private static void filterTablesByRegex(Collection<TableDescriptor> 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

Parameters:

table - the table for which last successful major compaction time is queried

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

getMobCompactionState
```
public org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.GetRegionInfoResponse.CompactionState getMobCompactionState(TableName tableName)
```
Gets the mob file compaction state for a specific table. Whether all the mob files are selected is known during the compaction execution, but the statistic is done just before compaction starts, it is hard to know the compaction type at that time, so the rough statistics are chosen for the mob file compaction. Only two compaction states are available, CompactionState.MAJOR_AND_MINOR and CompactionState.NONE.

Parameters:

tableName - The current table name.

Returns:

If a given table is in mob file compaction now.

reportMobCompactionStart

public void reportMobCompactionStart(TableName tableName)
                              throws IOException

Throws:: IOException

reportMobCompactionEnd

public void reportMobCompactionEnd(TableName tableName)
                            throws IOException

Throws:: IOException

requestMobCompaction

public void requestMobCompaction(TableName tableName,
                                 List<ColumnFamilyDescriptor> columns,
                                 boolean allFiles)
                          throws IOException

Requests mob compaction.

Parameters:: tableName - The table the compact.; columns - The compacted columns.; allFiles - Whether add all mob files into the compaction.
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.

isSplitOrMergeEnabled
```
public boolean isSplitOrMergeEnabled(MasterSwitchType switchType)
```
Queries the state of the SplitOrMergeTracker. If it is not initialized, false is returned. If switchType is illegal, false will return.

Specified by:

isSplitOrMergeEnabled in interface MasterServices

Parameters:

switchType - see MasterSwitchType

Returns:

The state of the switch

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

getSplitOrMergeTracker

public SplitOrMergeTracker getSplitOrMergeTracker()

getLoadBalancer
```
public LoadBalancer getLoadBalancer()
```
Specified by:

getLoadBalancer in interface MasterServices

Returns:

load balancer

getFavoredNodesManager
```
public FavoredNodesManager getFavoredNodesManager()
```
Specified by:

getFavoredNodesManager in interface MasterServices

Returns:

Favored Nodes Manager

addReplicationPeer
```
public void addReplicationPeer(String peerId,
                               ReplicationPeerConfig peerConfig,
                               boolean enabled)
                        throws ReplicationException,
                               IOException
```
Description copied from interface: MasterServices

Add a new replication peer for replicating data to slave cluster

Specified by:

addReplicationPeer in interface MasterServices

Parameters:

peerId - a short name that identifies the peer

peerConfig - configuration for the replication slave cluster

enabled - peer state, true if ENABLED and false if DISABLED

Throws:

ReplicationException

IOException

removeReplicationPeer
```
public void removeReplicationPeer(String peerId)
                           throws ReplicationException,
                                  IOException
```
Description copied from interface: MasterServices

Removes a peer and stops the replication

Specified by:

removeReplicationPeer in interface MasterServices

Parameters:

peerId - a short name that identifies the peer

Throws:

ReplicationException

IOException

enableReplicationPeer
```
public void enableReplicationPeer(String peerId)
                           throws ReplicationException,
                                  IOException
```
Description copied from interface: MasterServices

Restart the replication stream to the specified peer

Specified by:

enableReplicationPeer in interface MasterServices

Parameters:

peerId - a short name that identifies the peer

Throws:

ReplicationException

IOException

disableReplicationPeer
```
public void disableReplicationPeer(String peerId)
                            throws ReplicationException,
                                   IOException
```
Description copied from interface: MasterServices

Stop the replication stream to the specified peer

Specified by:

disableReplicationPeer in interface MasterServices

Parameters:

peerId - a short name that identifies the peer

Throws:

ReplicationException

IOException

getReplicationPeerConfig
```
public ReplicationPeerConfig getReplicationPeerConfig(String peerId)
                                               throws ReplicationException,
                                                      IOException
```
Description copied from interface: MasterServices

Returns the configured ReplicationPeerConfig for the specified peer

Specified by:

getReplicationPeerConfig in interface MasterServices

Parameters:

peerId - a short name that identifies the peer

Returns:

ReplicationPeerConfig for the peer

Throws:

ReplicationException

IOException

updateReplicationPeerConfig

public void updateReplicationPeerConfig(String peerId,
                                        ReplicationPeerConfig peerConfig)
                                 throws ReplicationException,
                                        IOException

Description copied from interface: MasterServices

Update the peerConfig for the specified peer

Specified by:: updateReplicationPeerConfig in interface MasterServices
Parameters:: peerId - a short name that identifies the peer; peerConfig - new config for the peer
Throws:: ReplicationException; IOException

listReplicationPeers
```
public List<ReplicationPeerDescription> listReplicationPeers(String regex)
                                                      throws ReplicationException,
                                                             IOException
```
Description copied from interface: MasterServices

Return a list of replication peers.

Specified by:

listReplicationPeers in interface MasterServices

Parameters:

regex - The regular expression to match peer id

Returns:

a list of replication peers description

Throws:

ReplicationException

IOException

decommissionRegionServers
```
public void decommissionRegionServers(List<ServerName> servers,
                                      boolean offload)
                               throws HBaseIOException
```
Mark region server(s) as decommissioned (previously called 'draining') to prevent additional regions from getting assigned to them. Also unload the regions on the servers asynchronously.0

Parameters:

servers - Region servers to decommission.

Throws:

HBaseIOException

listDecommissionedRegionServers
```
public List<ServerName> listDecommissionedRegionServers()
```
List region servers marked as decommissioned (previously called 'draining') to not get regions assigned to them.

Returns:

List of decommissioned servers.

recommissionRegionServer
```
public void recommissionRegionServer(ServerName server,
                                     List<byte[]> encodedRegionNames)
                              throws HBaseIOException
```
Remove decommission marker (previously called 'draining') from a region server to allow regions assignments. Load regions onto the server asynchronously if a list of regions is given

Parameters:

server - Region server to remove decommission marker from.

Throws:

HBaseIOException

getLockManager
```
public LockManager getLockManager()
```
Specified by:

getLockManager in interface MasterServices

Returns:

LockManager to lock namespaces/tables/regions.

getQuotaObserverChore

public QuotaObserverChore getQuotaObserverChore()

getSpaceQuotaSnapshotNotifier

public SpaceQuotaSnapshotNotifier getSpaceQuotaSnapshotNotifier()

decorateMasterConfiguration
```
public static void decorateMasterConfiguration(org.apache.hadoop.conf.Configuration conf)
```
This method modifies the master's configuration in order to inject replication-related features

getHbckChore
```
public HbckChore getHbckChore()
```

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

splitOrMergeTracker

regionNormalizerTracker

clusterSchemaService

HBASE_MASTER_WAIT_ON_SERVICE_IN_SECONDS

DEFAULT_HBASE_MASTER_WAIT_ON_SERVICE_IN_SECONDS

metricsMaster

fileSystemManager

walManager

serverManager

assignmentManager

replicationManager

rsFatals

activeMaster

initialized

serviceStarted

maxBlancingTime

maxRitPercent

lockManager

balancer

normalizer

balancerChore

normalizerChore

clusterStatusChore

clusterStatusPublisherChore

hbckChore

catalogJanitorChore

replicationZKNodeCleanerChore

logCleaner

hfileCleaner

expiredMobFileCleanerChore

mobCompactChore

mobCompactThread

mobCompactionLock

mobCompactionStates

cpHost

preLoadTableDescriptors

masterActiveTime

masterFinishedInitializationTime

masterCheckCompression

masterCheckEncryption

coprocessorServiceHandlers

snapshotManager

mpmHost

quotaManager

spaceQuotaSnapshotNotifier

quotaObserverChore

snapshotQuotaChore

procedureExecutor

procedureStore

tableStateManager

splitPlanCount

mergePlanCount

favoredNodesManager

masterJettyServer

maintenanceMode

MAINTENANCE_MODE

Constructor Detail

HMaster