MasterObserver (Apache HBase - Server 2.0.0-alpha3 API)

All Superinterfaces:

Coprocessor

All Known Implementing Classes:

AccessController, CoprocessorWhitelistMasterObserver, MasterSpaceQuotaObserver, VisibilityController
```
@InterfaceAudience.LimitedPrivate(value="Coprocesssor")
 @InterfaceStability.Evolving
public interface MasterObserver
extends Coprocessor
```
Defines coprocessor hooks for interacting with operations on the HMaster process.

Since most implementations will be interested in only a subset of hooks, this class uses 'default' functions to avoid having to add unnecessary overrides. When the functions are non-empty, it's simply to satisfy the compiler by returning value of expected (non-void) type. It is done in a way that these default definitions act as no-op. So our suggestion to implementation would be to not call these 'default' methods from overrides.

Exception Handling
For all functions, exception handling is done as follows:
- Exceptions of type IOException are reported back to client.
- For any other kind of exception:
  - If the configuration CoprocessorHost.ABORT_ON_ERROR_KEY is set to true, then the server aborts.
  - Otherwise, coprocessor is removed from the server and DoNotRetryIOException is returned to the client.

Nested Class Summary
- Nested classes/interfaces inherited from interface org.apache.hadoop.hbase.Coprocessor
  Coprocessor.State

Field Summary
- Fields inherited from interface org.apache.hadoop.hbase.Coprocessor
  PRIORITY_HIGHEST, PRIORITY_LOWEST, PRIORITY_SYSTEM, PRIORITY_USER, VERSION

Method Summary

All Methods Instance Methods Default Methods
Modifier and Type	Method and Description
`default void`	`postAbortProcedure(ObserverContext<MasterCoprocessorEnvironment> ctx)` Called after a abortProcedure request has been processed.
`default void`	`postAddColumnFamily(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, ColumnFamilyDescriptor columnFamily)` Called after the new column family has been created.
`default void`	`postAddReplicationPeer(ObserverContext<MasterCoprocessorEnvironment> ctx, String peerId, ReplicationPeerConfig peerConfig)` Called after add a replication peer
`default void`	`postAddRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx, String name)` Called after a new region server group is added
`default void`	`postAssign(ObserverContext<MasterCoprocessorEnvironment> ctx, HRegionInfo regionInfo)` Called after the region assignment has been requested.
`default void`	`postBalance(ObserverContext<MasterCoprocessorEnvironment> ctx, List<RegionPlan> plans)` Called after the balancing plan has been submitted.
`default void`	`postBalanceRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx, String groupName, boolean balancerRan)` Called after a region server group is removed
`default void`	`postBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> ctx, boolean oldValue, boolean newValue)` Called after the flag to enable/disable balancing has changed.
`default void`	`postClearDeadServers(ObserverContext<MasterCoprocessorEnvironment> ctx)` Called after clear dead region servers.
`default void`	`postCloneSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, org.apache.hadoop.hbase.shaded.protobuf.generated.SnapshotProtos.SnapshotDescription snapshot, TableDescriptor tableDescriptor)` Called after a snapshot clone operation has been requested.
`default void`	`postCompletedAddColumnFamilyAction(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, ColumnFamilyDescriptor columnFamily)` Called after the new column family has been created.
`default void`	`postCompletedCreateTableAction(ObserverContext<MasterCoprocessorEnvironment> ctx, TableDescriptor desc, HRegionInfo[] regions)` Called after the createTable operation has been requested.
`default void`	`postCompletedDeleteColumnFamilyAction(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, byte[] columnFamily)` Called after the column family has been deleted.
`default void`	`postCompletedDeleteTableAction(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)` Called after `HMaster` deletes a table.
`default void`	`postCompletedDisableTableAction(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)` Called after the disableTable operation has been requested.
`default void`	`postCompletedEnableTableAction(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)` Called after the enableTable operation has been requested.
`default void`	`postCompletedMergeRegionsAction(ObserverContext<MasterCoprocessorEnvironment> ctx, HRegionInfo[] regionsToMerge, HRegionInfo mergedRegion)` called after the regions merge.
`default void`	`postCompletedModifyColumnFamilyAction(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, ColumnFamilyDescriptor columnFamily)` Called after the column family has been updated.
`default void`	`postCompletedModifyTableAction(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, TableDescriptor htd)` Called after to modifying a table's properties.
`default void`	`postCompletedSplitRegionAction(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfoA, HRegionInfo regionInfoB)` Called after the region is split.
`default void`	`postCompletedTruncateTableAction(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)` Called after `HMaster` truncates a table.
`default void`	`postCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns)` Called after the createNamespace operation has been requested.
`default void`	`postCreateTable(ObserverContext<MasterCoprocessorEnvironment> ctx, TableDescriptor desc, HRegionInfo[] regions)` Called after the createTable operation has been requested.
`default void`	`postDeleteColumnFamily(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, byte[] columnFamily)` Called after the column family has been deleted.
`default void`	`postDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace)` Called after the deleteNamespace operation has been requested.
`default void`	`postDeleteSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, org.apache.hadoop.hbase.shaded.protobuf.generated.SnapshotProtos.SnapshotDescription snapshot)` Called after the delete snapshot operation has been requested.
`default void`	`postDeleteTable(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)` Called after the deleteTable operation has been requested.
`default void`	`postDisableReplicationPeer(ObserverContext<MasterCoprocessorEnvironment> ctx, String peerId)` Called after disable a replication peer
`default void`	`postDisableTable(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)` Called after the disableTable operation has been requested.
`default void`	`postEnableReplicationPeer(ObserverContext<MasterCoprocessorEnvironment> ctx, String peerId)` Called after enable a replication peer
`default void`	`postEnableTable(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)` Called after the enableTable operation has been requested.
`default void`	`postGetLocks(ObserverContext<MasterCoprocessorEnvironment> ctx, List<LockedResource> lockedResources)` Called after a getLocks request has been processed.
`default void`	`postGetNamespaceDescriptor(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns)` Called after a getNamespaceDescriptor request has been processed.
`default void`	`postGetProcedures(ObserverContext<MasterCoprocessorEnvironment> ctx, List<Procedure<?>> procList)` Called after a getProcedures request has been processed.
`default void`	`postGetReplicationPeerConfig(ObserverContext<MasterCoprocessorEnvironment> ctx, String peerId)` Called after get the configured ReplicationPeerConfig for the specified peer
`default void`	`postGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx, List<TableName> tableNamesList, List<TableDescriptor> descriptors, String regex)` Called after a getTableDescriptors request has been processed.
`default void`	`postGetTableNames(ObserverContext<MasterCoprocessorEnvironment> ctx, List<TableDescriptor> descriptors, String regex)` Called after a getTableNames request has been processed.
`default void`	`postListDeadServers(ObserverContext<MasterCoprocessorEnvironment> ctx)` Called after list dead region servers.
`default void`	`postListNamespaceDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx, List<NamespaceDescriptor> descriptors)` Called after a listNamespaceDescriptors request has been processed.
`default void`	`postListReplicationPeers(ObserverContext<MasterCoprocessorEnvironment> ctx, String regex)` Called after list replication peers.
`default void`	`postListSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, org.apache.hadoop.hbase.shaded.protobuf.generated.SnapshotProtos.SnapshotDescription snapshot)` Called after listSnapshots request has been processed.
`default void`	`postLockHeartbeat(ObserverContext<MasterCoprocessorEnvironment> ctx, LockProcedure proc, boolean keepAlive)` Called after heartbeat to a lock.
`default void`	`postMergeRegions(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo[] regionsToMerge)` called after merge regions request.
`default void`	`postMergeRegionsCommitAction(ObserverContext<MasterCoprocessorEnvironment> ctx, HRegionInfo[] regionsToMerge, HRegionInfo mergedRegion)` This will be called after PONR step as part of regions merge transaction.
`default void`	`postModifyColumnFamily(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, ColumnFamilyDescriptor columnFamily)` Called after the column family has been updated.
`default void`	`postModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns)` Called after the modifyNamespace operation has been requested.
`default void`	`postModifyTable(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, TableDescriptor htd)` Called after the modifyTable operation has been requested.
`default void`	`postMove(ObserverContext<MasterCoprocessorEnvironment> ctx, HRegionInfo region, ServerName srcServer, ServerName destServer)` Called after the region move has been requested.
`default void`	`postMoveServers(ObserverContext<MasterCoprocessorEnvironment> ctx, Set<Address> servers, String targetGroup)` Called after servers are moved to target region server group
`default void`	`postMoveServersAndTables(ObserverContext<MasterCoprocessorEnvironment> ctx, Set<Address> servers, Set<TableName> tables, String targetGroup)` Called after servers are moved to target region server group
`default void`	`postMoveTables(ObserverContext<MasterCoprocessorEnvironment> ctx, Set<TableName> tables, String targetGroup)` Called after servers are moved to target region server group
`default void`	`postRegionOffline(ObserverContext<MasterCoprocessorEnvironment> ctx, HRegionInfo regionInfo)` Called after the region has been marked offline.
`default void`	`postRemoveReplicationPeer(ObserverContext<MasterCoprocessorEnvironment> ctx, String peerId)` Called after remove a replication peer
`default void`	`postRemoveRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx, String name)` Called after a region server group is removed
`default void`	`postRequestLock(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace, TableName tableName, HRegionInfo[] regionInfos, LockType type, String description)` Called after new LockProcedure is queued.
`default void`	`postRestoreSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, org.apache.hadoop.hbase.shaded.protobuf.generated.SnapshotProtos.SnapshotDescription snapshot, TableDescriptor tableDescriptor)` Called after a snapshot restore operation has been requested.
`default void`	`postRollBackMergeRegionsAction(ObserverContext<MasterCoprocessorEnvironment> ctx, HRegionInfo[] regionsToMerge)` This will be called after the roll back of the regions merge.
`default void`	`postRollBackSplitRegionAction(ObserverContext<MasterCoprocessorEnvironment> ctx)` This will be called after the roll back of the split region is completed
`default void`	`postSetNamespaceQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace, org.apache.hadoop.hbase.shaded.protobuf.generated.QuotaProtos.Quotas quotas)` Called after the quota for the namespace is stored.
`default void`	`postSetSplitOrMergeEnabled(ObserverContext<MasterCoprocessorEnvironment> ctx, boolean newValue, MasterSwitchType switchType)` Called after setting split / merge switch
`default void`	`postSetTableQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, org.apache.hadoop.hbase.shaded.protobuf.generated.QuotaProtos.Quotas quotas)` Called after the quota for the table is stored.
`default void`	`postSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, String userName, org.apache.hadoop.hbase.shaded.protobuf.generated.QuotaProtos.Quotas quotas)` Called after the quota for the user is stored.
`default void`	`postSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, String userName, String namespace, org.apache.hadoop.hbase.shaded.protobuf.generated.QuotaProtos.Quotas quotas)` Called after the quota for the user on the specified namespace is stored.
`default void`	`postSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, String userName, TableName tableName, org.apache.hadoop.hbase.shaded.protobuf.generated.QuotaProtos.Quotas quotas)` Called after the quota for the user on the specified table is stored.
`default void`	`postSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, org.apache.hadoop.hbase.shaded.protobuf.generated.SnapshotProtos.SnapshotDescription snapshot, TableDescriptor tableDescriptor)` Called after the snapshot operation has been requested.
`default void`	`postStartMaster(ObserverContext<MasterCoprocessorEnvironment> ctx)` Called immediately after an active master instance has completed initialization.
`default void`	`postTableFlush(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)` Called after the table memstore is flushed to disk.
`default void`	`postTruncateTable(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)` Called after the truncateTable operation has been requested.
`default void`	`postUnassign(ObserverContext<MasterCoprocessorEnvironment> ctx, HRegionInfo regionInfo, boolean force)` Called after the region unassignment has been requested.
`default void`	`postUpdateReplicationPeerConfig(ObserverContext<MasterCoprocessorEnvironment> ctx, String peerId, ReplicationPeerConfig peerConfig)` Called after update peerConfig for the specified peer
`default void`	`preAbortProcedure(ObserverContext<MasterCoprocessorEnvironment> ctx, ProcedureExecutor<MasterProcedureEnv> procEnv, long procId)` Called before a abortProcedure request has been processed.
`default void`	`preAddColumnFamily(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, ColumnFamilyDescriptor columnFamily)` Called prior to adding a new column family to the table.
`default void`	`preAddColumnFamilyAction(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, ColumnFamilyDescriptor columnFamily)` Called prior to adding a new column family to the table.
`default void`	`preAddReplicationPeer(ObserverContext<MasterCoprocessorEnvironment> ctx, String peerId, ReplicationPeerConfig peerConfig)` Called before add a replication peer
`default void`	`preAddRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx, String name)` Called before a new region server group is added
`default void`	`preAssign(ObserverContext<MasterCoprocessorEnvironment> ctx, HRegionInfo regionInfo)` Called prior to assigning a specific region.
`default void`	`preBalance(ObserverContext<MasterCoprocessorEnvironment> ctx)` Called prior to requesting rebalancing of the cluster regions, though after the initial checks for regions in transition and the balance switch flag.
`default void`	`preBalanceRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx, String groupName)` Called before a region server group is removed
`default boolean`	`preBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> ctx, boolean newValue)` Called prior to modifying the flag used to enable/disable region balancing.
`default void`	`preClearDeadServers(ObserverContext<MasterCoprocessorEnvironment> ctx)` Called before clear dead region servers.
`default void`	`preCloneSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, org.apache.hadoop.hbase.shaded.protobuf.generated.SnapshotProtos.SnapshotDescription snapshot, TableDescriptor tableDescriptor)` Called before a snapshot is cloned.
`default void`	`preCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns)` Called before a new namespace is created by `HMaster`.
`default void`	`preCreateTable(ObserverContext<MasterCoprocessorEnvironment> ctx, TableDescriptor desc, HRegionInfo[] regions)` Called before a new table is created by `HMaster`.
`default void`	`preCreateTableAction(ObserverContext<MasterCoprocessorEnvironment> ctx, TableDescriptor desc, HRegionInfo[] regions)` Called before a new table is created by `HMaster`.
`default void`	`preDeleteColumnFamily(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, byte[] columnFamily)` Called prior to deleting the entire column family.
`default void`	`preDeleteColumnFamilyAction(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, byte[] columnFamily)` Called prior to deleting the entire column family.
`default void`	`preDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace)` Called before `HMaster` deletes a namespace It can't bypass the default action, e.g., ctx.bypass() won't have effect.
`default void`	`preDeleteSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, org.apache.hadoop.hbase.shaded.protobuf.generated.SnapshotProtos.SnapshotDescription snapshot)` Called before a snapshot is deleted.
`default void`	`preDeleteTable(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)` Called before `HMaster` deletes a table.
`default void`	`preDeleteTableAction(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)` Called before `HMaster` deletes a table.
`default void`	`preDisableReplicationPeer(ObserverContext<MasterCoprocessorEnvironment> ctx, String peerId)` Called before disable a replication peer
`default void`	`preDisableTable(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)` Called prior to disabling a table.
`default void`	`preDisableTableAction(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)` Called prior to disabling a table.
`default void`	`preEnableReplicationPeer(ObserverContext<MasterCoprocessorEnvironment> ctx, String peerId)` Called before enable a replication peer
`default void`	`preEnableTable(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)` Called prior to enabling a table.
`default void`	`preEnableTableAction(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)` Called prior to enabling a table.
`default void`	`preGetLocks(ObserverContext<MasterCoprocessorEnvironment> ctx)` Called before a getLocks request has been processed.
`default void`	`preGetNamespaceDescriptor(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace)` Called before a getNamespaceDescriptor request has been processed.
`default void`	`preGetProcedures(ObserverContext<MasterCoprocessorEnvironment> ctx)` Called before a getProcedures request has been processed.
`default void`	`preGetReplicationPeerConfig(ObserverContext<MasterCoprocessorEnvironment> ctx, String peerId)` Called before get the configured ReplicationPeerConfig for the specified peer
`default void`	`preGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx, List<TableName> tableNamesList, List<TableDescriptor> descriptors, String regex)` Called before a getTableDescriptors request has been processed.
`default void`	`preGetTableNames(ObserverContext<MasterCoprocessorEnvironment> ctx, List<TableDescriptor> descriptors, String regex)` Called before a getTableNames request has been processed.
`default void`	`preListDeadServers(ObserverContext<MasterCoprocessorEnvironment> ctx)` Called before list dead region servers.
`default void`	`preListNamespaceDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx, List<NamespaceDescriptor> descriptors)` Called before a listNamespaceDescriptors request has been processed.
`default void`	`preListReplicationPeers(ObserverContext<MasterCoprocessorEnvironment> ctx, String regex)` Called before list replication peers.
`default void`	`preListSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, org.apache.hadoop.hbase.shaded.protobuf.generated.SnapshotProtos.SnapshotDescription snapshot)` Called before listSnapshots request has been processed.
`default void`	`preLockHeartbeat(ObserverContext<MasterCoprocessorEnvironment> ctx, LockProcedure proc, boolean keepAlive)` Called before heartbeat to a lock.
`default void`	`preMasterInitialization(ObserverContext<MasterCoprocessorEnvironment> ctx)` Call before the master initialization is set to true.
`default void`	`preMergeRegions(ObserverContext<MasterCoprocessorEnvironment> ctx, HRegionInfo[] regionsToMerge)` Called before merge regions request.
`default void`	`preMergeRegionsAction(ObserverContext<MasterCoprocessorEnvironment> ctx, HRegionInfo[] regionsToMerge)` Called before the regions merge.
`default void`	`preMergeRegionsCommitAction(ObserverContext<MasterCoprocessorEnvironment> ctx, HRegionInfo[] regionsToMerge, List<Mutation> metaEntries)` This will be called before PONR step as part of regions merge transaction.
`default void`	`preModifyColumnFamily(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, ColumnFamilyDescriptor columnFamily)` Called prior to modifying a column family's attributes.
`default void`	`preModifyColumnFamilyAction(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, ColumnFamilyDescriptor columnFamily)` Called prior to modifying a column family's attributes.
`default void`	`preModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns)` Called prior to modifying a namespace's properties.
`default void`	`preModifyTable(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, TableDescriptor htd)` Called prior to modifying a table's properties.
`default void`	`preModifyTableAction(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, TableDescriptor htd)` Called prior to modifying a table's properties.
`default void`	`preMove(ObserverContext<MasterCoprocessorEnvironment> ctx, HRegionInfo region, ServerName srcServer, ServerName destServer)` Called prior to moving a given region from one region server to another.
`default void`	`preMoveServers(ObserverContext<MasterCoprocessorEnvironment> ctx, Set<Address> servers, String targetGroup)` Called before servers are moved to target region server group
`default void`	`preMoveServersAndTables(ObserverContext<MasterCoprocessorEnvironment> ctx, Set<Address> servers, Set<TableName> tables, String targetGroup)` Called before servers are moved to target region server group
`default void`	`preMoveTables(ObserverContext<MasterCoprocessorEnvironment> ctx, Set<TableName> tables, String targetGroup)` Called before tables are moved to target region server group
`default void`	`preRegionOffline(ObserverContext<MasterCoprocessorEnvironment> ctx, HRegionInfo regionInfo)` Called prior to marking a given region as offline.
`default void`	`preRemoveReplicationPeer(ObserverContext<MasterCoprocessorEnvironment> ctx, String peerId)` Called before remove a replication peer
`default void`	`preRemoveRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx, String name)` Called before a region server group is removed
`default void`	`preRequestLock(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace, TableName tableName, HRegionInfo[] regionInfos, LockType type, String description)` Called before new LockProcedure is queued.
`default void`	`preRestoreSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, org.apache.hadoop.hbase.shaded.protobuf.generated.SnapshotProtos.SnapshotDescription snapshot, TableDescriptor tableDescriptor)` Called before a snapshot is restored.
`default void`	`preSetNamespaceQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace, org.apache.hadoop.hbase.shaded.protobuf.generated.QuotaProtos.Quotas quotas)` Called before the quota for the namespace is stored.
`default boolean`	`preSetSplitOrMergeEnabled(ObserverContext<MasterCoprocessorEnvironment> ctx, boolean newValue, MasterSwitchType switchType)` Called prior to setting split / merge switch
`default void`	`preSetTableQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, org.apache.hadoop.hbase.shaded.protobuf.generated.QuotaProtos.Quotas quotas)` Called before the quota for the table is stored.
`default void`	`preSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, String userName, org.apache.hadoop.hbase.shaded.protobuf.generated.QuotaProtos.Quotas quotas)` Called before the quota for the user is stored.
`default void`	`preSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, String userName, String namespace, org.apache.hadoop.hbase.shaded.protobuf.generated.QuotaProtos.Quotas quotas)` Called before the quota for the user on the specified namespace is stored.
`default void`	`preSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, String userName, TableName tableName, org.apache.hadoop.hbase.shaded.protobuf.generated.QuotaProtos.Quotas quotas)` Called before the quota for the user on the specified table is stored.
`default void`	`preShutdown(ObserverContext<MasterCoprocessorEnvironment> ctx)` Called prior to shutting down the full HBase cluster, including this `HMaster` process.
`default void`	`preSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, org.apache.hadoop.hbase.shaded.protobuf.generated.SnapshotProtos.SnapshotDescription snapshot, TableDescriptor tableDescriptor)` Called before a new snapshot is taken.
`default void`	`preSplitRegion(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, byte[] splitRow)` Called before the split region procedure is called.
`default void`	`preSplitRegionAction(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, byte[] splitRow)` Called before the region is split.
`default void`	`preSplitRegionAfterPONRAction(ObserverContext<MasterCoprocessorEnvironment> ctx)` This will be called after PONR step as part of split transaction Calling `ObserverContext.bypass()` has no effect in this hook.
`default void`	`preSplitRegionBeforePONRAction(ObserverContext<MasterCoprocessorEnvironment> ctx, byte[] splitKey, List<Mutation> metaEntries)` This will be called before PONR step as part of split transaction.
`default void`	`preStopMaster(ObserverContext<MasterCoprocessorEnvironment> ctx)` Called immediately prior to stopping this `HMaster` process.
`default void`	`preTableFlush(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)` Called before the table memstore is flushed to disk.
`default void`	`preTruncateTable(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)` Called before `HMaster` truncates a table.
`default void`	`preTruncateTableAction(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)` Called before `HMaster` truncates a table.
`default void`	`preUnassign(ObserverContext<MasterCoprocessorEnvironment> ctx, HRegionInfo regionInfo, boolean force)` Called prior to unassigning a given region.
`default void`	`preUpdateReplicationPeerConfig(ObserverContext<MasterCoprocessorEnvironment> ctx, String peerId, ReplicationPeerConfig peerConfig)` Called before update peerConfig for the specified peer

Methods inherited from interface org.apache.hadoop.hbase.Coprocessor
start, stop

Method Detail

preCreateTable
```
default void preCreateTable(ObserverContext<MasterCoprocessorEnvironment> ctx,
                            TableDescriptor desc,
                            HRegionInfo[] regions)
                     throws IOException
```
Called before a new table is created by HMaster. Called as part of create table RPC call. It can't bypass the default action, e.g., ctx.bypass() won't have effect.

Parameters:

ctx - the environment to interact with the framework and master

desc - the TableDescriptor for the table

regions - the initial regions created for the table

Throws:

IOException

postCreateTable
```
default void postCreateTable(ObserverContext<MasterCoprocessorEnvironment> ctx,
                             TableDescriptor desc,
                             HRegionInfo[] regions)
                      throws IOException
```
Called after the createTable operation has been requested. Called as part of create table RPC call.

Parameters:

ctx - the environment to interact with the framework and master

desc - the TableDescriptor for the table

regions - the initial regions created for the table

Throws:

IOException

preCreateTableAction
```
default void preCreateTableAction(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                  TableDescriptor desc,
                                  HRegionInfo[] regions)
                           throws IOException
```
Called before a new table is created by HMaster. Called as part of create table procedure and it is async to the create RPC call. It can't bypass the default action, e.g., ctx.bypass() won't have effect.

Parameters:

ctx - the environment to interact with the framework and master

desc - the TableDescriptor for the table

regions - the initial regions created for the table

Throws:

IOException

postCompletedCreateTableAction
```
default void postCompletedCreateTableAction(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                            TableDescriptor desc,
                                            HRegionInfo[] regions)
                                     throws IOException
```
Called after the createTable operation has been requested. Called as part of create table RPC call. Called as part of create table procedure and it is async to the create RPC call.

Parameters:

ctx - the environment to interact with the framework and master

desc - the TableDescriptor for the table

regions - the initial regions created for the table

Throws:

IOException

preDeleteTable
```
default void preDeleteTable(ObserverContext<MasterCoprocessorEnvironment> ctx,
                            TableName tableName)
                     throws IOException
```
Called before HMaster deletes a table. Called as part of delete table RPC call. It can't bypass the default action, e.g., ctx.bypass() won't have effect.

Parameters:

ctx - the environment to interact with the framework and master

tableName - the name of the table

Throws:

IOException

postDeleteTable
```
default void postDeleteTable(ObserverContext<MasterCoprocessorEnvironment> ctx,
                             TableName tableName)
                      throws IOException
```
Called after the deleteTable operation has been requested. Called as part of delete table RPC call.

Parameters:

ctx - the environment to interact with the framework and master

tableName - the name of the table

Throws:

IOException

preDeleteTableAction
```
default void preDeleteTableAction(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                  TableName tableName)
                           throws IOException
```
Called before HMaster deletes a table. Called as part of delete table procedure and it is async to the delete RPC call. It can't bypass the default action, e.g., ctx.bypass() won't have effect.

Parameters:

ctx - the environment to interact with the framework and master

tableName - the name of the table

Throws:

IOException

postCompletedDeleteTableAction
```
default void postCompletedDeleteTableAction(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                            TableName tableName)
                                     throws IOException
```
Called after HMaster deletes a table. Called as part of delete table procedure and it is async to the delete RPC call. It can't bypass the default action, e.g., ctx.bypass() won't have effect.

Parameters:

ctx - the environment to interact with the framework and master

tableName - the name of the table

Throws:

IOException

preTruncateTable
```
default void preTruncateTable(ObserverContext<MasterCoprocessorEnvironment> ctx,
                              TableName tableName)
                       throws IOException
```
Called before HMaster truncates a table. Called as part of truncate table RPC call. It can't bypass the default action, e.g., ctx.bypass() won't have effect.

Parameters:

ctx - the environment to interact with the framework and master

tableName - the name of the table

Throws:

IOException

postTruncateTable
```
default void postTruncateTable(ObserverContext<MasterCoprocessorEnvironment> ctx,
                               TableName tableName)
                        throws IOException
```
Called after the truncateTable operation has been requested. Called as part of truncate table RPC call. The truncate is synchronous, so this method will be called when the truncate operation is terminated.

Parameters:

ctx - the environment to interact with the framework and master

tableName - the name of the table

Throws:

IOException

preTruncateTableAction
```
default void preTruncateTableAction(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                    TableName tableName)
                             throws IOException
```
Called before HMaster truncates a table. Called as part of truncate table procedure and it is async to the truncate RPC call. It can't bypass the default action, e.g., ctx.bypass() won't have effect.

Parameters:

ctx - the environment to interact with the framework and master

tableName - the name of the table

Throws:

IOException

postCompletedTruncateTableAction
```
default void postCompletedTruncateTableAction(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                              TableName tableName)
                                       throws IOException
```
Called after HMaster truncates a table. Called as part of truncate table procedure and it is async to the truncate RPC call. It can't bypass the default action, e.g., ctx.bypass() won't have effect.

Parameters:

ctx - the environment to interact with the framework and master

tableName - the name of the table

Throws:

IOException

preModifyTable
```
default void preModifyTable(ObserverContext<MasterCoprocessorEnvironment> ctx,
                            TableName tableName,
                            TableDescriptor htd)
                     throws IOException
```
Called prior to modifying a table's properties. Called as part of modify table RPC call. It can't bypass the default action, e.g., ctx.bypass() won't have effect.

Parameters:

ctx - the environment to interact with the framework and master

tableName - the name of the table

htd - the TableDescriptor

Throws:

IOException

postModifyTable

default void postModifyTable(ObserverContext<MasterCoprocessorEnvironment> ctx,
                             TableName tableName,
                             TableDescriptor htd)
                      throws IOException

Called after the modifyTable operation has been requested. Called as part of modify table RPC call.

Parameters:: ctx - the environment to interact with the framework and master; tableName - the name of the table; htd - the TableDescriptor
Throws:: IOException

preModifyTableAction
```
default void preModifyTableAction(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                  TableName tableName,
                                  TableDescriptor htd)
                           throws IOException
```
Called prior to modifying a table's properties. Called as part of modify table procedure and it is async to the modify table RPC call. It can't bypass the default action, e.g., ctx.bypass() won't have effect.

Parameters:

ctx - the environment to interact with the framework and master

tableName - the name of the table

htd - the TableDescriptor

Throws:

IOException

postCompletedModifyTableAction
```
default void postCompletedModifyTableAction(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                            TableName tableName,
                                            TableDescriptor htd)
                                     throws IOException
```
Called after to modifying a table's properties. Called as part of modify table procedure and it is async to the modify table RPC call. It can't bypass the default action, e.g., ctx.bypass() won't have effect.

Parameters:

ctx - the environment to interact with the framework and master

tableName - the name of the table

htd - the TableDescriptor

Throws:

IOException

preAddColumnFamily

default void preAddColumnFamily(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                TableName tableName,
                                ColumnFamilyDescriptor columnFamily)
                         throws IOException

Called prior to adding a new column family to the table. Called as part of add column RPC call.

Parameters:: ctx - the environment to interact with the framework and master; tableName - the name of the table; columnFamily - the ColumnFamilyDescriptor
Throws:: IOException

postAddColumnFamily

default void postAddColumnFamily(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                 TableName tableName,
                                 ColumnFamilyDescriptor columnFamily)
                          throws IOException

Called after the new column family has been created. Called as part of add column RPC call.

Parameters:: ctx - the environment to interact with the framework and master; tableName - the name of the table; columnFamily - the ColumnFamilyDescriptor
Throws:: IOException

preAddColumnFamilyAction

default void preAddColumnFamilyAction(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                      TableName tableName,
                                      ColumnFamilyDescriptor columnFamily)
                               throws IOException

Called prior to adding a new column family to the table. Called as part of add column procedure.

Parameters:: ctx - the environment to interact with the framework and master; tableName - the name of the table; columnFamily - the ColumnFamilyDescriptor
Throws:: IOException

postCompletedAddColumnFamilyAction

default void postCompletedAddColumnFamilyAction(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                                TableName tableName,
                                                ColumnFamilyDescriptor columnFamily)
                                         throws IOException

Called after the new column family has been created. Called as part of add column procedure.

Parameters:: ctx - the environment to interact with the framework and master; tableName - the name of the table; columnFamily - the ColumnFamilyDescriptor
Throws:: IOException

preModifyColumnFamily

default void preModifyColumnFamily(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                   TableName tableName,
                                   ColumnFamilyDescriptor columnFamily)
                            throws IOException

Called prior to modifying a column family's attributes. Called as part of modify column RPC call.

Parameters:: ctx - the environment to interact with the framework and master; tableName - the name of the table; columnFamily - the ColumnFamilyDescriptor
Throws:: IOException

postModifyColumnFamily

default void postModifyColumnFamily(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                    TableName tableName,
                                    ColumnFamilyDescriptor columnFamily)
                             throws IOException

Called after the column family has been updated. Called as part of modify column RPC call.

Parameters:: ctx - the environment to interact with the framework and master; tableName - the name of the table; columnFamily - the ColumnFamilyDescriptor
Throws:: IOException

preModifyColumnFamilyAction

default void preModifyColumnFamilyAction(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                         TableName tableName,
                                         ColumnFamilyDescriptor columnFamily)
                                  throws IOException

Called prior to modifying a column family's attributes. Called as part of modify column procedure.

Parameters:: ctx - the environment to interact with the framework and master; tableName - the name of the table; columnFamily - the ColumnFamilyDescriptor
Throws:: IOException

postCompletedModifyColumnFamilyAction

default void postCompletedModifyColumnFamilyAction(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                                   TableName tableName,
                                                   ColumnFamilyDescriptor columnFamily)
                                            throws IOException

Called after the column family has been updated. Called as part of modify column procedure.

Parameters:: ctx - the environment to interact with the framework and master; tableName - the name of the table; columnFamily - the ColumnFamilyDescriptor
Throws:: IOException

preDeleteColumnFamily

default void preDeleteColumnFamily(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                   TableName tableName,
                                   byte[] columnFamily)
                            throws IOException

Called prior to deleting the entire column family. Called as part of delete column RPC call.

Parameters:: ctx - the environment to interact with the framework and master; tableName - the name of the table; columnFamily - the column
Throws:: IOException

postDeleteColumnFamily

default void postDeleteColumnFamily(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                    TableName tableName,
                                    byte[] columnFamily)
                             throws IOException

Called after the column family has been deleted. Called as part of delete column RPC call.

Parameters:: ctx - the environment to interact with the framework and master; tableName - the name of the table; columnFamily - the column family
Throws:: IOException

preDeleteColumnFamilyAction

default void preDeleteColumnFamilyAction(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                         TableName tableName,
                                         byte[] columnFamily)
                                  throws IOException

Called prior to deleting the entire column family. Called as part of delete column procedure.

Parameters:: ctx - the environment to interact with the framework and master; tableName - the name of the table; columnFamily - the column family
Throws:: IOException

postCompletedDeleteColumnFamilyAction

default void postCompletedDeleteColumnFamilyAction(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                                   TableName tableName,
                                                   byte[] columnFamily)
                                            throws IOException

Called after the column family has been deleted. Called as part of delete column procedure.

Parameters:: ctx - the environment to interact with the framework and master; tableName - the name of the table; columnFamily - the column family
Throws:: IOException

preEnableTable
```
default void preEnableTable(ObserverContext<MasterCoprocessorEnvironment> ctx,
                            TableName tableName)
                     throws IOException
```
Called prior to enabling a table. Called as part of enable table RPC call. It can't bypass the default action, e.g., ctx.bypass() won't have effect.

Parameters:

ctx - the environment to interact with the framework and master

tableName - the name of the table

Throws:

IOException

postEnableTable
```
default void postEnableTable(ObserverContext<MasterCoprocessorEnvironment> ctx,
                             TableName tableName)
                      throws IOException
```
Called after the enableTable operation has been requested. Called as part of enable table RPC call.

Parameters:

ctx - the environment to interact with the framework and master

tableName - the name of the table

Throws:

IOException

preEnableTableAction
```
default void preEnableTableAction(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                  TableName tableName)
                           throws IOException
```
Called prior to enabling a table. Called as part of enable table procedure and it is async to the enable table RPC call. It can't bypass the default action, e.g., ctx.bypass() won't have effect.

Parameters:

ctx - the environment to interact with the framework and master

tableName - the name of the table

Throws:

IOException

postCompletedEnableTableAction
```
default void postCompletedEnableTableAction(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                            TableName tableName)
                                     throws IOException
```
Called after the enableTable operation has been requested. Called as part of enable table procedure and it is async to the enable table RPC call.

Parameters:

ctx - the environment to interact with the framework and master

tableName - the name of the table

Throws:

IOException

preDisableTable
```
default void preDisableTable(ObserverContext<MasterCoprocessorEnvironment> ctx,
                             TableName tableName)
                      throws IOException
```
Called prior to disabling a table. Called as part of disable table RPC call. It can't bypass the default action, e.g., ctx.bypass() won't have effect.

Parameters:

ctx - the environment to interact with the framework and master

tableName - the name of the table

Throws:

IOException

postDisableTable
```
default void postDisableTable(ObserverContext<MasterCoprocessorEnvironment> ctx,
                              TableName tableName)
                       throws IOException
```
Called after the disableTable operation has been requested. Called as part of disable table RPC call.

Parameters:

ctx - the environment to interact with the framework and master

tableName - the name of the table

Throws:

IOException

preDisableTableAction
```
default void preDisableTableAction(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                   TableName tableName)
                            throws IOException
```
Called prior to disabling a table. Called as part of disable table procedure and it is asyn to the disable table RPC call. It can't bypass the default action, e.g., ctx.bypass() won't have effect.

Parameters:

ctx - the environment to interact with the framework and master

tableName - the name of the table

Throws:

IOException

postCompletedDisableTableAction
```
default void postCompletedDisableTableAction(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                             TableName tableName)
                                      throws IOException
```
Called after the disableTable operation has been requested. Called as part of disable table procedure and it is asyn to the disable table RPC call.

Parameters:

ctx - the environment to interact with the framework and master

tableName - the name of the table

Throws:

IOException

preAbortProcedure

default void preAbortProcedure(ObserverContext<MasterCoprocessorEnvironment> ctx,
                               ProcedureExecutor<MasterProcedureEnv> procEnv,
                               long procId)
                        throws IOException

Called before a abortProcedure request has been processed.

Parameters:: ctx - the environment to interact with the framework and master; procEnv - procedure executor; procId - the Id of the procedure
Throws:: IOException

postAbortProcedure
```
default void postAbortProcedure(ObserverContext<MasterCoprocessorEnvironment> ctx)
                         throws IOException
```
Called after a abortProcedure request has been processed.

Parameters:

ctx - the environment to interact with the framework and master

Throws:

IOException

preGetProcedures
```
default void preGetProcedures(ObserverContext<MasterCoprocessorEnvironment> ctx)
                       throws IOException
```
Called before a getProcedures request has been processed.

Parameters:

ctx - the environment to interact with the framework and master

Throws:

IOException

postGetProcedures

default void postGetProcedures(ObserverContext<MasterCoprocessorEnvironment> ctx,
                               List<Procedure<?>> procList)
                        throws IOException

Called after a getProcedures request has been processed.

Parameters:: ctx - the environment to interact with the framework and master; procList - the list of procedures about to be returned
Throws:: IOException

preGetLocks
```
default void preGetLocks(ObserverContext<MasterCoprocessorEnvironment> ctx)
                  throws IOException
```
Called before a getLocks request has been processed.

Parameters:

ctx - the environment to interact with the framework and master

Throws:

IOException - if something went wrong

postGetLocks
```
default void postGetLocks(ObserverContext<MasterCoprocessorEnvironment> ctx,
                          List<LockedResource> lockedResources)
                   throws IOException
```
Called after a getLocks request has been processed.

Parameters:

ctx - the environment to interact with the framework and master

lockedResources - the list of locks about to be returned

Throws:

IOException - if something went wrong

preMove

default void preMove(ObserverContext<MasterCoprocessorEnvironment> ctx,
                     HRegionInfo region,
                     ServerName srcServer,
                     ServerName destServer)
              throws IOException

Called prior to moving a given region from one region server to another.

Parameters:: ctx - the environment to interact with the framework and master; region - the HRegionInfo; srcServer - the source ServerName; destServer - the destination ServerName
Throws:: IOException

postMove

default void postMove(ObserverContext<MasterCoprocessorEnvironment> ctx,
                      HRegionInfo region,
                      ServerName srcServer,
                      ServerName destServer)
               throws IOException

Called after the region move has been requested.

Parameters:: ctx - the environment to interact with the framework and master; region - the HRegionInfo; srcServer - the source ServerName; destServer - the destination ServerName
Throws:: IOException

preAssign

default void preAssign(ObserverContext<MasterCoprocessorEnvironment> ctx,
                       HRegionInfo regionInfo)
                throws IOException

Called prior to assigning a specific region.

Parameters:: ctx - the environment to interact with the framework and master; regionInfo - the regionInfo of the region
Throws:: IOException

postAssign
```
default void postAssign(ObserverContext<MasterCoprocessorEnvironment> ctx,
                        HRegionInfo regionInfo)
                 throws IOException
```
Called after the region assignment has been requested.

Parameters:

ctx - the environment to interact with the framework and master

regionInfo - the regionInfo of the region

Throws:

IOException

preUnassign

default void preUnassign(ObserverContext<MasterCoprocessorEnvironment> ctx,
                         HRegionInfo regionInfo,
                         boolean force)
                  throws IOException

Called prior to unassigning a given region.

Parameters:: ctx - the environment to interact with the framework and master; regionInfo -; force - whether to force unassignment or not
Throws:: IOException

postUnassign

default void postUnassign(ObserverContext<MasterCoprocessorEnvironment> ctx,
                          HRegionInfo regionInfo,
                          boolean force)
                   throws IOException

Called after the region unassignment has been requested.

Parameters:: ctx - the environment to interact with the framework and master; regionInfo -; force - whether to force unassignment or not
Throws:: IOException

preRegionOffline
```
default void preRegionOffline(ObserverContext<MasterCoprocessorEnvironment> ctx,
                              HRegionInfo regionInfo)
                       throws IOException
```
Called prior to marking a given region as offline. ctx.bypass() will not have any impact on this hook.

Parameters:

ctx - the environment to interact with the framework and master

regionInfo -

Throws:

IOException

postRegionOffline

default void postRegionOffline(ObserverContext<MasterCoprocessorEnvironment> ctx,
                               HRegionInfo regionInfo)
                        throws IOException

Called after the region has been marked offline.

Parameters:: ctx - the environment to interact with the framework and master; regionInfo -
Throws:: IOException

preBalance
```
default void preBalance(ObserverContext<MasterCoprocessorEnvironment> ctx)
                 throws IOException
```
Called prior to requesting rebalancing of the cluster regions, though after the initial checks for regions in transition and the balance switch flag.

Parameters:

ctx - the environment to interact with the framework and master

Throws:

IOException

postBalance
```
default void postBalance(ObserverContext<MasterCoprocessorEnvironment> ctx,
                         List<RegionPlan> plans)
                  throws IOException
```
Called after the balancing plan has been submitted.

Parameters:

ctx - the environment to interact with the framework and master

plans - the RegionPlans which master has executed. RegionPlan serves as hint as for the final destination for the underlying region but may not represent the final state of assignment

Throws:

IOException

preSetSplitOrMergeEnabled

default boolean preSetSplitOrMergeEnabled(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                          boolean newValue,
                                          MasterSwitchType switchType)
                                   throws IOException

Called prior to setting split / merge switch

Parameters:: ctx - the coprocessor instance's environment; newValue - the new value submitted in the call; switchType - type of switch
Throws:: IOException

postSetSplitOrMergeEnabled

default void postSetSplitOrMergeEnabled(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                        boolean newValue,
                                        MasterSwitchType switchType)
                                 throws IOException

Called after setting split / merge switch

Parameters:: ctx - the coprocessor instance's environment; newValue - the new value submitted in the call; switchType - type of switch
Throws:: IOException

preSplitRegion

default void preSplitRegion(ObserverContext<MasterCoprocessorEnvironment> c,
                            TableName tableName,
                            byte[] splitRow)
                     throws IOException

Called before the split region procedure is called.

Parameters:: c - the environment to interact with the framework and master; tableName - the table where the region belongs to; splitRow - split point
Throws:: IOException

preSplitRegionAction

default void preSplitRegionAction(ObserverContext<MasterCoprocessorEnvironment> c,
                                  TableName tableName,
                                  byte[] splitRow)
                           throws IOException

Called before the region is split.

Parameters:: c - the environment to interact with the framework and master; tableName - the table where the region belongs to; splitRow - split point
Throws:: IOException

postCompletedSplitRegionAction

default void postCompletedSplitRegionAction(ObserverContext<MasterCoprocessorEnvironment> c,
                                            HRegionInfo regionInfoA,
                                            HRegionInfo regionInfoB)
                                     throws IOException

Called after the region is split.

Parameters:: c - the environment to interact with the framework and master; regionInfoA - the left daughter region; regionInfoB - the right daughter region
Throws:: IOException

preSplitRegionBeforePONRAction

default void preSplitRegionBeforePONRAction(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                            byte[] splitKey,
                                            List<Mutation> metaEntries)
                                     throws IOException

This will be called before PONR step as part of split transaction. Calling ObserverContext.bypass() rollback the split

Parameters:: ctx - the environment to interact with the framework and master; splitKey -; metaEntries -
Throws:: IOException

preSplitRegionAfterPONRAction
```
default void preSplitRegionAfterPONRAction(ObserverContext<MasterCoprocessorEnvironment> ctx)
                                    throws IOException
```
This will be called after PONR step as part of split transaction Calling ObserverContext.bypass() has no effect in this hook.

Parameters:

ctx - the environment to interact with the framework and master

Throws:

IOException

postRollBackSplitRegionAction
```
default void postRollBackSplitRegionAction(ObserverContext<MasterCoprocessorEnvironment> ctx)
                                    throws IOException
```
This will be called after the roll back of the split region is completed

Parameters:

ctx - the environment to interact with the framework and master

Throws:

IOException

preMergeRegionsAction

default void preMergeRegionsAction(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                   HRegionInfo[] regionsToMerge)
                            throws IOException

Called before the regions merge. Call ObserverContext.bypass() to skip the merge.

Parameters:: ctx - the environment to interact with the framework and master
Throws:: IOException

postCompletedMergeRegionsAction

default void postCompletedMergeRegionsAction(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                             HRegionInfo[] regionsToMerge,
                                             HRegionInfo mergedRegion)
                                      throws IOException

called after the regions merge.

Parameters:: ctx - the environment to interact with the framework and master
Throws:: IOException

preMergeRegionsCommitAction

default void preMergeRegionsCommitAction(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                         HRegionInfo[] regionsToMerge,
                                         @MetaMutationAnnotation
                                         List<Mutation> metaEntries)
                                  throws IOException

This will be called before PONR step as part of regions merge transaction. Calling ObserverContext.bypass() rollback the merge

Parameters:: ctx - the environment to interact with the framework and master; metaEntries - mutations to execute on hbase:meta atomically with regions merge updates. Any puts or deletes to execute on hbase:meta can be added to the mutations.
Throws:: IOException

postMergeRegionsCommitAction

default void postMergeRegionsCommitAction(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                          HRegionInfo[] regionsToMerge,
                                          HRegionInfo mergedRegion)
                                   throws IOException

This will be called after PONR step as part of regions merge transaction.

Parameters:: ctx - the environment to interact with the framework and master
Throws:: IOException

postRollBackMergeRegionsAction

default void postRollBackMergeRegionsAction(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                            HRegionInfo[] regionsToMerge)
                                     throws IOException

This will be called after the roll back of the regions merge.

Parameters:: ctx - the environment to interact with the framework and master
Throws:: IOException

preBalanceSwitch
```
default boolean preBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                 boolean newValue)
                          throws IOException
```
Called prior to modifying the flag used to enable/disable region balancing.

Parameters:

ctx - the coprocessor instance's environment

newValue - the new flag value submitted in the call

Throws:

IOException

postBalanceSwitch
```
default void postBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> ctx,
                               boolean oldValue,
                               boolean newValue)
                        throws IOException
```
Called after the flag to enable/disable balancing has changed.

Parameters:

ctx - the coprocessor instance's environment

oldValue - the previously set balanceSwitch value

newValue - the newly set balanceSwitch value

Throws:

IOException

preShutdown

default void preShutdown(ObserverContext<MasterCoprocessorEnvironment> ctx)
                  throws IOException

Called prior to shutting down the full HBase cluster, including this HMaster process.

Throws:: IOException

preStopMaster

default void preStopMaster(ObserverContext<MasterCoprocessorEnvironment> ctx)
                    throws IOException

Called immediately prior to stopping this HMaster process.

Throws:: IOException

postStartMaster
```
default void postStartMaster(ObserverContext<MasterCoprocessorEnvironment> ctx)
                      throws IOException
```
Called immediately after an active master instance has completed initialization. Will not be called on standby master instances unless they take over the active role.

Throws:

IOException

preMasterInitialization

default void preMasterInitialization(ObserverContext<MasterCoprocessorEnvironment> ctx)
                              throws IOException

Call before the master initialization is set to true. HMaster process.

Throws:: IOException

preSnapshot
```
default void preSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
                         org.apache.hadoop.hbase.shaded.protobuf.generated.SnapshotProtos.SnapshotDescription snapshot,
                         TableDescriptor tableDescriptor)
                  throws IOException
```
Called before a new snapshot is taken. Called as part of snapshot RPC call. It can't bypass the default action, e.g., ctx.bypass() won't have effect.

Parameters:

ctx - the environment to interact with the framework and master

snapshot - the SnapshotDescriptor for the snapshot

tableDescriptor - the TableDescriptor of the table to snapshot

Throws:

IOException

postSnapshot

default void postSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
                          org.apache.hadoop.hbase.shaded.protobuf.generated.SnapshotProtos.SnapshotDescription snapshot,
                          TableDescriptor tableDescriptor)
                   throws IOException

Called after the snapshot operation has been requested. Called as part of snapshot RPC call.

Parameters:: ctx - the environment to interact with the framework and master; snapshot - the SnapshotDescriptor for the snapshot; tableDescriptor - the TableDescriptor of the table to snapshot
Throws:: IOException

preListSnapshot
```
default void preListSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
                             org.apache.hadoop.hbase.shaded.protobuf.generated.SnapshotProtos.SnapshotDescription snapshot)
                      throws IOException
```
Called before listSnapshots request has been processed. It can't bypass the default action, e.g., ctx.bypass() won't have effect.

Parameters:

ctx - the environment to interact with the framework and master

snapshot - the SnapshotDescriptor of the snapshot to list

Throws:

IOException

postListSnapshot
```
default void postListSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
                              org.apache.hadoop.hbase.shaded.protobuf.generated.SnapshotProtos.SnapshotDescription snapshot)
                       throws IOException
```
Called after listSnapshots request has been processed. It can't bypass the default action, e.g., ctx.bypass() won't have effect.

Parameters:

ctx - the environment to interact with the framework and master

snapshot - the SnapshotDescriptor of the snapshot to list

Throws:

IOException

preCloneSnapshot

default void preCloneSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
                              org.apache.hadoop.hbase.shaded.protobuf.generated.SnapshotProtos.SnapshotDescription snapshot,
                              TableDescriptor tableDescriptor)
                       throws IOException

Called before a snapshot is cloned. Called as part of restoreSnapshot RPC call. It can't bypass the default action, e.g., ctx.bypass() won't have effect.

Parameters:: ctx - the environment to interact with the framework and master; snapshot - the SnapshotDescriptor for the snapshot; tableDescriptor - the TableDescriptor of the table to create
Throws:: IOException

postCloneSnapshot

default void postCloneSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
                               org.apache.hadoop.hbase.shaded.protobuf.generated.SnapshotProtos.SnapshotDescription snapshot,
                               TableDescriptor tableDescriptor)
                        throws IOException

Called after a snapshot clone operation has been requested. Called as part of restoreSnapshot RPC call.

Parameters:: ctx - the environment to interact with the framework and master; snapshot - the SnapshotDescriptor for the snapshot; tableDescriptor - the v of the table to create
Throws:: IOException

preRestoreSnapshot

default void preRestoreSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                org.apache.hadoop.hbase.shaded.protobuf.generated.SnapshotProtos.SnapshotDescription snapshot,
                                TableDescriptor tableDescriptor)
                         throws IOException

Called before a snapshot is restored. Called as part of restoreSnapshot RPC call. It can't bypass the default action, e.g., ctx.bypass() won't have effect.

Parameters:: ctx - the environment to interact with the framework and master; snapshot - the SnapshotDescriptor for the snapshot; tableDescriptor - the TableDescriptor of the table to restore
Throws:: IOException

postRestoreSnapshot

default void postRestoreSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                 org.apache.hadoop.hbase.shaded.protobuf.generated.SnapshotProtos.SnapshotDescription snapshot,
                                 TableDescriptor tableDescriptor)
                          throws IOException

Called after a snapshot restore operation has been requested. Called as part of restoreSnapshot RPC call.

Parameters:: ctx - the environment to interact with the framework and master; snapshot - the SnapshotDescriptor for the snapshot; tableDescriptor - the TableDescriptor of the table to restore
Throws:: IOException

preDeleteSnapshot
```
default void preDeleteSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
                               org.apache.hadoop.hbase.shaded.protobuf.generated.SnapshotProtos.SnapshotDescription snapshot)
                        throws IOException
```
Called before a snapshot is deleted. Called as part of deleteSnapshot RPC call. It can't bypass the default action, e.g., ctx.bypass() won't have effect.

Parameters:

ctx - the environment to interact with the framework and master

snapshot - the SnapshotDescriptor of the snapshot to delete

Throws:

IOException

postDeleteSnapshot

default void postDeleteSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                org.apache.hadoop.hbase.shaded.protobuf.generated.SnapshotProtos.SnapshotDescription snapshot)
                         throws IOException

Called after the delete snapshot operation has been requested. Called as part of deleteSnapshot RPC call.

Parameters:: ctx - the environment to interact with the framework and master; snapshot - the SnapshotDescriptor of the snapshot to delete
Throws:: IOException

preGetTableDescriptors

default void preGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                    List<TableName> tableNamesList,
                                    List<TableDescriptor> descriptors,
                                    String regex)
                             throws IOException

Called before a getTableDescriptors request has been processed.

Parameters:: ctx - the environment to interact with the framework and master; tableNamesList - the list of table names, or null if querying for all; descriptors - an empty list, can be filled with what to return if bypassing; regex - regular expression used for filtering the table names
Throws:: IOException

postGetTableDescriptors

default void postGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                     List<TableName> tableNamesList,
                                     List<TableDescriptor> descriptors,
                                     String regex)
                              throws IOException

Called after a getTableDescriptors request has been processed.

Parameters:: ctx - the environment to interact with the framework and master; tableNamesList - the list of table names, or null if querying for all; descriptors - the list of descriptors about to be returned; regex - regular expression used for filtering the table names
Throws:: IOException

preGetTableNames

default void preGetTableNames(ObserverContext<MasterCoprocessorEnvironment> ctx,
                              List<TableDescriptor> descriptors,
                              String regex)
                       throws IOException

Called before a getTableNames request has been processed.

Parameters:: ctx - the environment to interact with the framework and master; descriptors - an empty list, can be filled with what to return if bypassing; regex - regular expression used for filtering the table names
Throws:: IOException

postGetTableNames

default void postGetTableNames(ObserverContext<MasterCoprocessorEnvironment> ctx,
                               List<TableDescriptor> descriptors,
                               String regex)
                        throws IOException

Called after a getTableNames request has been processed.

Parameters:: ctx - the environment to interact with the framework and master; descriptors - the list of descriptors about to be returned; regex - regular expression used for filtering the table names
Throws:: IOException

preCreateNamespace
```
default void preCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                NamespaceDescriptor ns)
                         throws IOException
```
Called before a new namespace is created by HMaster. It can't bypass the default action, e.g., ctx.bypass() won't have effect.

Parameters:

ctx - the environment to interact with the framework and master

ns - the NamespaceDescriptor for the table

Throws:

IOException

postCreateNamespace

default void postCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                 NamespaceDescriptor ns)
                          throws IOException

Called after the createNamespace operation has been requested.

Parameters:: ctx - the environment to interact with the framework and master; ns - the NamespaceDescriptor for the table
Throws:: IOException

preDeleteNamespace
```
default void preDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                String namespace)
                         throws IOException
```
Called before HMaster deletes a namespace It can't bypass the default action, e.g., ctx.bypass() won't have effect.

Parameters:

ctx - the environment to interact with the framework and master

namespace - the name of the namespace

Throws:

IOException

postDeleteNamespace

default void postDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                 String namespace)
                          throws IOException

Called after the deleteNamespace operation has been requested.

Parameters:: ctx - the environment to interact with the framework and master; namespace - the name of the namespace
Throws:: IOException

preModifyNamespace
```
default void preModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                NamespaceDescriptor ns)
                         throws IOException
```
Called prior to modifying a namespace's properties. It can't bypass the default action, e.g., ctx.bypass() won't have effect.

Parameters:

ctx - the environment to interact with the framework and master

ns - the NamespaceDescriptor

Throws:

IOException

postModifyNamespace

default void postModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                 NamespaceDescriptor ns)
                          throws IOException

Called after the modifyNamespace operation has been requested.

Parameters:: ctx - the environment to interact with the framework and master; ns - the NamespaceDescriptor
Throws:: IOException

preGetNamespaceDescriptor

default void preGetNamespaceDescriptor(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                       String namespace)
                                throws IOException

Called before a getNamespaceDescriptor request has been processed.

Parameters:: ctx - the environment to interact with the framework and master; namespace - the name of the namespace
Throws:: IOException

postGetNamespaceDescriptor

default void postGetNamespaceDescriptor(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                        NamespaceDescriptor ns)
                                 throws IOException

Called after a getNamespaceDescriptor request has been processed.

Parameters:: ctx - the environment to interact with the framework and master; ns - the NamespaceDescriptor
Throws:: IOException

preListNamespaceDescriptors

default void preListNamespaceDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                         List<NamespaceDescriptor> descriptors)
                                  throws IOException

Called before a listNamespaceDescriptors request has been processed.

Parameters:: ctx - the environment to interact with the framework and master; descriptors - an empty list, can be filled with what to return if bypassing
Throws:: IOException

postListNamespaceDescriptors

default void postListNamespaceDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                          List<NamespaceDescriptor> descriptors)
                                   throws IOException

Called after a listNamespaceDescriptors request has been processed.

Parameters:: ctx - the environment to interact with the framework and master; descriptors - the list of descriptors about to be returned
Throws:: IOException

preTableFlush

default void preTableFlush(ObserverContext<MasterCoprocessorEnvironment> ctx,
                           TableName tableName)
                    throws IOException

Called before the table memstore is flushed to disk.

Parameters:: ctx - the environment to interact with the framework and master; tableName - the name of the table
Throws:: IOException

postTableFlush

default void postTableFlush(ObserverContext<MasterCoprocessorEnvironment> ctx,
                            TableName tableName)
                     throws IOException

Called after the table memstore is flushed to disk.

Parameters:: ctx - the environment to interact with the framework and master; tableName - the name of the table
Throws:: IOException

preSetUserQuota

default void preSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx,
                             String userName,
                             org.apache.hadoop.hbase.shaded.protobuf.generated.QuotaProtos.Quotas quotas)
                      throws IOException

Called before the quota for the user is stored.

Parameters:: ctx - the environment to interact with the framework and master; userName - the name of user; quotas - the quota settings
Throws:: IOException

postSetUserQuota

default void postSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx,
                              String userName,
                              org.apache.hadoop.hbase.shaded.protobuf.generated.QuotaProtos.Quotas quotas)
                       throws IOException

Called after the quota for the user is stored.

Parameters:: ctx - the environment to interact with the framework and master; userName - the name of user; quotas - the quota settings
Throws:: IOException

preSetUserQuota

default void preSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx,
                             String userName,
                             TableName tableName,
                             org.apache.hadoop.hbase.shaded.protobuf.generated.QuotaProtos.Quotas quotas)
                      throws IOException

Called before the quota for the user on the specified table is stored.

Parameters:: ctx - the environment to interact with the framework and master; userName - the name of user; tableName - the name of the table; quotas - the quota settings
Throws:: IOException

postSetUserQuota

default void postSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx,
                              String userName,
                              TableName tableName,
                              org.apache.hadoop.hbase.shaded.protobuf.generated.QuotaProtos.Quotas quotas)
                       throws IOException

Called after the quota for the user on the specified table is stored.

Parameters:: ctx - the environment to interact with the framework and master; userName - the name of user; tableName - the name of the table; quotas - the quota settings
Throws:: IOException

preSetUserQuota

default void preSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx,
                             String userName,
                             String namespace,
                             org.apache.hadoop.hbase.shaded.protobuf.generated.QuotaProtos.Quotas quotas)
                      throws IOException

Called before the quota for the user on the specified namespace is stored.

Parameters:: ctx - the environment to interact with the framework and master; userName - the name of user; namespace - the name of the namespace; quotas - the quota settings
Throws:: IOException

postSetUserQuota

default void postSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx,
                              String userName,
                              String namespace,
                              org.apache.hadoop.hbase.shaded.protobuf.generated.QuotaProtos.Quotas quotas)
                       throws IOException

Called after the quota for the user on the specified namespace is stored.

Parameters:: ctx - the environment to interact with the framework and master; userName - the name of user; namespace - the name of the namespace; quotas - the quota settings
Throws:: IOException

preSetTableQuota

default void preSetTableQuota(ObserverContext<MasterCoprocessorEnvironment> ctx,
                              TableName tableName,
                              org.apache.hadoop.hbase.shaded.protobuf.generated.QuotaProtos.Quotas quotas)
                       throws IOException

Called before the quota for the table is stored.

Parameters:: ctx - the environment to interact with the framework and master; tableName - the name of the table; quotas - the quota settings
Throws:: IOException

postSetTableQuota

default void postSetTableQuota(ObserverContext<MasterCoprocessorEnvironment> ctx,
                               TableName tableName,
                               org.apache.hadoop.hbase.shaded.protobuf.generated.QuotaProtos.Quotas quotas)
                        throws IOException

Called after the quota for the table is stored.

Parameters:: ctx - the environment to interact with the framework and master; tableName - the name of the table; quotas - the quota settings
Throws:: IOException

preSetNamespaceQuota

default void preSetNamespaceQuota(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                  String namespace,
                                  org.apache.hadoop.hbase.shaded.protobuf.generated.QuotaProtos.Quotas quotas)
                           throws IOException

Called before the quota for the namespace is stored.

Parameters:: ctx - the environment to interact with the framework and master; namespace - the name of the namespace; quotas - the quota settings
Throws:: IOException

postSetNamespaceQuota

default void postSetNamespaceQuota(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                   String namespace,
                                   org.apache.hadoop.hbase.shaded.protobuf.generated.QuotaProtos.Quotas quotas)
                            throws IOException

Called after the quota for the namespace is stored.

Parameters:: ctx - the environment to interact with the framework and master; namespace - the name of the namespace; quotas - the quota settings
Throws:: IOException

preMergeRegions
```
default void preMergeRegions(ObserverContext<MasterCoprocessorEnvironment> ctx,
                             HRegionInfo[] regionsToMerge)
                      throws IOException
```
Called before merge regions request. It can't bypass the default action, e.g., ctx.bypass() won't have effect.

Parameters:

ctx - coprocessor environment

regionsToMerge - regions to be merged

Throws:

IOException

postMergeRegions

default void postMergeRegions(ObserverContext<MasterCoprocessorEnvironment> c,
                              HRegionInfo[] regionsToMerge)
                       throws IOException

called after merge regions request.

Parameters:: c - coprocessor environment; regionsToMerge - regions to be merged
Throws:: IOException

preMoveServersAndTables

default void preMoveServersAndTables(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                     Set<Address> servers,
                                     Set<TableName> tables,
                                     String targetGroup)
                              throws IOException

Called before servers are moved to target region server group

Parameters:: ctx - the environment to interact with the framework and master; servers - set of servers to move; targetGroup - destination group
Throws:: IOException

postMoveServersAndTables

default void postMoveServersAndTables(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                      Set<Address> servers,
                                      Set<TableName> tables,
                                      String targetGroup)
                               throws IOException

Called after servers are moved to target region server group

Parameters:: ctx - the environment to interact with the framework and master; servers - set of servers to move; targetGroup - name of group
Throws:: IOException

preMoveServers

default void preMoveServers(ObserverContext<MasterCoprocessorEnvironment> ctx,
                            Set<Address> servers,
                            String targetGroup)
                     throws IOException

Called before servers are moved to target region server group

Parameters:: ctx - the environment to interact with the framework and master; servers - set of servers to move; targetGroup - destination group
Throws:: IOException

postMoveServers

default void postMoveServers(ObserverContext<MasterCoprocessorEnvironment> ctx,
                             Set<Address> servers,
                             String targetGroup)
                      throws IOException

Called after servers are moved to target region server group

Parameters:: ctx - the environment to interact with the framework and master; servers - set of servers to move; targetGroup - name of group
Throws:: IOException

preMoveTables

default void preMoveTables(ObserverContext<MasterCoprocessorEnvironment> ctx,
                           Set<TableName> tables,
                           String targetGroup)
                    throws IOException

Called before tables are moved to target region server group

Parameters:: ctx - the environment to interact with the framework and master; tables - set of tables to move; targetGroup - name of group
Throws:: IOException

postMoveTables

default void postMoveTables(ObserverContext<MasterCoprocessorEnvironment> ctx,
                            Set<TableName> tables,
                            String targetGroup)
                     throws IOException

Called after servers are moved to target region server group

Parameters:: ctx - the environment to interact with the framework and master; tables - set of tables to move; targetGroup - name of group
Throws:: IOException

preAddRSGroup

default void preAddRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx,
                           String name)
                    throws IOException

Called before a new region server group is added

Parameters:: ctx - the environment to interact with the framework and master; name - group name
Throws:: IOException

postAddRSGroup

default void postAddRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx,
                            String name)
                     throws IOException

Called after a new region server group is added

Parameters:: ctx - the environment to interact with the framework and master; name - group name
Throws:: IOException

preRemoveRSGroup

default void preRemoveRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx,
                              String name)
                       throws IOException

Called before a region server group is removed

Parameters:: ctx - the environment to interact with the framework and master; name - group name
Throws:: IOException

postRemoveRSGroup

default void postRemoveRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx,
                               String name)
                        throws IOException

Called after a region server group is removed

Parameters:: ctx - the environment to interact with the framework and master; name - group name
Throws:: IOException

preBalanceRSGroup

default void preBalanceRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx,
                               String groupName)
                        throws IOException

Called before a region server group is removed

Parameters:: ctx - the environment to interact with the framework and master; groupName - group name
Throws:: IOException

postBalanceRSGroup

default void postBalanceRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                String groupName,
                                boolean balancerRan)
                         throws IOException

Called after a region server group is removed

Parameters:: ctx - the environment to interact with the framework and master; groupName - group name
Throws:: IOException

preAddReplicationPeer

default void preAddReplicationPeer(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                   String peerId,
                                   ReplicationPeerConfig peerConfig)
                            throws IOException

Called before add a replication peer

Parameters:: ctx - the environment to interact with the framework and master; peerId - a short name that identifies the peer; peerConfig - configuration for the replication peer
Throws:: IOException

postAddReplicationPeer

default void postAddReplicationPeer(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                    String peerId,
                                    ReplicationPeerConfig peerConfig)
                             throws IOException

Called after add a replication peer

Parameters:: ctx - the environment to interact with the framework and master; peerId - a short name that identifies the peer; peerConfig - configuration for the replication peer
Throws:: IOException

preRemoveReplicationPeer

default void preRemoveReplicationPeer(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                      String peerId)
                               throws IOException

Called before remove a replication peer

Parameters:: ctx -; peerId - a short name that identifies the peer
Throws:: IOException

postRemoveReplicationPeer

default void postRemoveReplicationPeer(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                       String peerId)
                                throws IOException

Called after remove a replication peer

Parameters:: ctx -; peerId - a short name that identifies the peer
Throws:: IOException

preEnableReplicationPeer

default void preEnableReplicationPeer(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                      String peerId)
                               throws IOException

Called before enable a replication peer

Parameters:: ctx -; peerId - a short name that identifies the peer
Throws:: IOException

postEnableReplicationPeer

default void postEnableReplicationPeer(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                       String peerId)
                                throws IOException

Called after enable a replication peer

Parameters:: ctx -; peerId - a short name that identifies the peer
Throws:: IOException

preDisableReplicationPeer

default void preDisableReplicationPeer(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                       String peerId)
                                throws IOException

Called before disable a replication peer

Parameters:: ctx -; peerId - a short name that identifies the peer
Throws:: IOException

postDisableReplicationPeer

default void postDisableReplicationPeer(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                        String peerId)
                                 throws IOException

Called after disable a replication peer

Parameters:: ctx -; peerId - a short name that identifies the peer
Throws:: IOException

preGetReplicationPeerConfig

default void preGetReplicationPeerConfig(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                         String peerId)
                                  throws IOException

Called before get the configured ReplicationPeerConfig for the specified peer

Parameters:: ctx -; peerId - a short name that identifies the peer
Throws:: IOException

postGetReplicationPeerConfig

default void postGetReplicationPeerConfig(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                          String peerId)
                                   throws IOException

Called after get the configured ReplicationPeerConfig for the specified peer

Parameters:: ctx -; peerId - a short name that identifies the peer
Throws:: IOException

preUpdateReplicationPeerConfig

default void preUpdateReplicationPeerConfig(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                            String peerId,
                                            ReplicationPeerConfig peerConfig)
                                     throws IOException

Called before update peerConfig for the specified peer

Parameters:: ctx -; peerId - a short name that identifies the peer
Throws:: IOException

postUpdateReplicationPeerConfig

default void postUpdateReplicationPeerConfig(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                             String peerId,
                                             ReplicationPeerConfig peerConfig)
                                      throws IOException

Called after update peerConfig for the specified peer

Parameters:: ctx - the environment to interact with the framework and master; peerId - a short name that identifies the peer
Throws:: IOException

preListReplicationPeers

default void preListReplicationPeers(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                     String regex)
                              throws IOException

Called before list replication peers.

Parameters:: ctx - the environment to interact with the framework and master; regex - The regular expression to match peer id
Throws:: IOException

postListReplicationPeers

default void postListReplicationPeers(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                      String regex)
                               throws IOException

Called after list replication peers.

Parameters:: ctx - the environment to interact with the framework and master; regex - The regular expression to match peer id
Throws:: IOException

preRequestLock

default void preRequestLock(ObserverContext<MasterCoprocessorEnvironment> ctx,
                            String namespace,
                            TableName tableName,
                            HRegionInfo[] regionInfos,
                            LockType type,
                            String description)
                     throws IOException

Called before new LockProcedure is queued.

Parameters:: ctx - the environment to interact with the framework and master
Throws:: IOException

postRequestLock

default void postRequestLock(ObserverContext<MasterCoprocessorEnvironment> ctx,
                             String namespace,
                             TableName tableName,
                             HRegionInfo[] regionInfos,
                             LockType type,
                             String description)
                      throws IOException

Called after new LockProcedure is queued.

Parameters:: ctx - the environment to interact with the framework and master
Throws:: IOException

preLockHeartbeat

default void preLockHeartbeat(ObserverContext<MasterCoprocessorEnvironment> ctx,
                              LockProcedure proc,
                              boolean keepAlive)
                       throws IOException

Called before heartbeat to a lock.

Parameters:: ctx - the environment to interact with the framework and master; keepAlive - if lock should be kept alive; lock will be released if set to false.
Throws:: IOException

postLockHeartbeat

default void postLockHeartbeat(ObserverContext<MasterCoprocessorEnvironment> ctx,
                               LockProcedure proc,
                               boolean keepAlive)
                        throws IOException

Called after heartbeat to a lock.

Parameters:: ctx - the environment to interact with the framework and master; keepAlive - if lock was kept alive; lock was released if set to false.
Throws:: IOException

preListDeadServers

default void preListDeadServers(ObserverContext<MasterCoprocessorEnvironment> ctx)
                         throws IOException

Called before list dead region servers.

Throws:: IOException

postListDeadServers

default void postListDeadServers(ObserverContext<MasterCoprocessorEnvironment> ctx)
                          throws IOException

Called after list dead region servers.

Throws:: IOException

preClearDeadServers

default void preClearDeadServers(ObserverContext<MasterCoprocessorEnvironment> ctx)
                          throws IOException

Called before clear dead region servers.

Throws:: IOException

postClearDeadServers

default void postClearDeadServers(ObserverContext<MasterCoprocessorEnvironment> ctx)
                           throws IOException

Called after clear dead region servers.

Throws:: IOException

Interface MasterObserver

Exception Handling

Nested Class Summary

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

Field Summary

Fields inherited from interface org.apache.hadoop.hbase.Coprocessor

Method Summary

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

Method Detail

preCreateTable

postCreateTable

preCreateTableAction

postCompletedCreateTableAction

preDeleteTable

postDeleteTable

preDeleteTableAction

postCompletedDeleteTableAction

preTruncateTable

postTruncateTable

preTruncateTableAction

postCompletedTruncateTableAction

preModifyTable

postModifyTable

preModifyTableAction

postCompletedModifyTableAction

preAddColumnFamily

postAddColumnFamily

preAddColumnFamilyAction

postCompletedAddColumnFamilyAction

preModifyColumnFamily

postModifyColumnFamily

preModifyColumnFamilyAction

postCompletedModifyColumnFamilyAction

preDeleteColumnFamily

postDeleteColumnFamily

preDeleteColumnFamilyAction

postCompletedDeleteColumnFamilyAction

preEnableTable

postEnableTable

preEnableTableAction

postCompletedEnableTableAction

preDisableTable

postDisableTable

preDisableTableAction

postCompletedDisableTableAction

preAbortProcedure

postAbortProcedure

preGetProcedures

postGetProcedures

preGetLocks

postGetLocks

preMove

postMove

preAssign

postAssign

preUnassign

postUnassign

preRegionOffline

postRegionOffline

preBalance

postBalance

preSetSplitOrMergeEnabled

postSetSplitOrMergeEnabled

preSplitRegion

preSplitRegionAction

postCompletedSplitRegionAction

preSplitRegionBeforePONRAction

preSplitRegionAfterPONRAction

postRollBackSplitRegionAction

preMergeRegionsAction

postCompletedMergeRegionsAction

preMergeRegionsCommitAction

postMergeRegionsCommitAction

postRollBackMergeRegionsAction

preBalanceSwitch

postBalanceSwitch

preShutdown

preStopMaster

postStartMaster

preMasterInitialization