TestMasterObserver.CPMasterObserver (Apache HBase 2.1.0-cdh6.x-SNAPSHOT Test API)

java.lang.Object
- org.apache.hadoop.hbase.coprocessor.TestMasterObserver.CPMasterObserver

All Implemented Interfaces:: Coprocessor, MasterCoprocessor, MasterObserver

Enclosing class:: TestMasterObserver

public static class TestMasterObserver.CPMasterObserver
extends Object
implements MasterCoprocessor, MasterObserver

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

Constructor Summary

Constructors
Constructor and Description

CPMasterObserver()

Constructors
Constructor and Description
`CPMasterObserver()`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Optional<MasterObserver>`	`getMasterObserver()`
`void`	`postAbortProcedure(ObserverContext<MasterCoprocessorEnvironment> ctx)`
`void`	`postAddRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx, String name)`
`void`	`postAssign(ObserverContext<MasterCoprocessorEnvironment> env, RegionInfo regionInfo)`
`void`	`postBalance(ObserverContext<MasterCoprocessorEnvironment> env, List<RegionPlan> plans)`
`void`	`postBalanceRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx, String groupName, boolean balancerRan)`
`void`	`postBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> env, boolean oldValue, boolean newValue)`
`void`	`postCloneSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, SnapshotDescription snapshot, TableDescriptor hTableDescriptor)`
`void`	`postCompletedCreateTableAction(ObserverContext<MasterCoprocessorEnvironment> ctx, TableDescriptor desc, RegionInfo[] regions)`
`void`	`postCompletedDeleteTableAction(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)`
`void`	`postCompletedDisableTableAction(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)`
`void`	`postCompletedEnableTableAction(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)`
`void`	`postCompletedMergeRegionsAction(ObserverContext<MasterCoprocessorEnvironment> c, RegionInfo[] regionsToMerge, RegionInfo mergedRegion)`
`void`	`postCompletedModifyTableAction(ObserverContext<MasterCoprocessorEnvironment> env, TableName tableName, TableDescriptor htd)`
`void`	`postCompletedSplitRegionAction(ObserverContext<MasterCoprocessorEnvironment> c, RegionInfo regionInfoA, RegionInfo regionInfoB)`
`void`	`postCompletedTruncateTableAction(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)`
`void`	`postCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> env, NamespaceDescriptor ns)`
`void`	`postCreateTable(ObserverContext<MasterCoprocessorEnvironment> env, TableDescriptor desc, RegionInfo[] regions)`
`void`	`postDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> env, String name)`
`void`	`postDeleteSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, SnapshotDescription snapshot)`
`void`	`postDeleteTable(ObserverContext<MasterCoprocessorEnvironment> env, TableName tableName)`
`void`	`postDisableTable(ObserverContext<MasterCoprocessorEnvironment> env, TableName tableName)`
`void`	`postEnableTable(ObserverContext<MasterCoprocessorEnvironment> env, TableName tableName)`
`void`	`postGetLocks(ObserverContext<MasterCoprocessorEnvironment> ctx)`
`void`	`postGetNamespaceDescriptor(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns)`
`void`	`postGetProcedures(ObserverContext<MasterCoprocessorEnvironment> ctx)`
`void`	`postGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx, List<TableName> tableNamesList, List<TableDescriptor> descriptors, String regex)`
`void`	`postGetTableNames(ObserverContext<MasterCoprocessorEnvironment> ctx, List<TableDescriptor> descriptors, String regex)`
`void`	`postListNamespaceDescriptors(ObserverContext<MasterCoprocessorEnvironment> env, List<NamespaceDescriptor> descriptors)`
`void`	`postListSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, SnapshotDescription snapshot)`
`void`	`postLockHeartbeat(ObserverContext<MasterCoprocessorEnvironment> ctx)`
`void`	`postMergeRegions(ObserverContext<MasterCoprocessorEnvironment> ctx, RegionInfo[] regionsToMerge)`
`void`	`postMergeRegionsCommitAction(ObserverContext<MasterCoprocessorEnvironment> ctx, RegionInfo[] regionsToMerge, RegionInfo mergedRegion)`
`void`	`postModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> env, NamespaceDescriptor ns)`
`void`	`postModifyTable(ObserverContext<MasterCoprocessorEnvironment> env, TableName tableName, TableDescriptor htd)`
`void`	`postMove(ObserverContext<MasterCoprocessorEnvironment> env, RegionInfo region, ServerName srcServer, ServerName destServer)`
`void`	`postMoveServers(ObserverContext<MasterCoprocessorEnvironment> ctx, Set<Address> servers, String targetGroup)`
`void`	`postMoveServersAndTables(ObserverContext<MasterCoprocessorEnvironment> ctx, Set<Address> servers, Set<TableName> tables, String targetGroup)`
`void`	`postMoveTables(ObserverContext<MasterCoprocessorEnvironment> ctx, Set<TableName> tables, String targetGroup)`
`void`	`postRegionOffline(ObserverContext<MasterCoprocessorEnvironment> env, RegionInfo regionInfo)`
`void`	`postRemoveRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx, String name)`
`void`	`postRequestLock(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace, TableName tableName, RegionInfo[] regionInfos, String description)`
`void`	`postRestoreSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, SnapshotDescription snapshot, TableDescriptor hTableDescriptor)`
`void`	`postRollBackMergeRegionsAction(ObserverContext<MasterCoprocessorEnvironment> ctx, RegionInfo[] regionsToMerge)`
`void`	`postRollBackSplitRegionAction(ObserverContext<MasterCoprocessorEnvironment> ctx)`
`void`	`postSetNamespaceQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace, GlobalQuotaSettings quotas)`
`void`	`postSetSplitOrMergeEnabled(ObserverContext<MasterCoprocessorEnvironment> ctx, boolean newValue, MasterSwitchType switchType)`
`void`	`postSetTableQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, GlobalQuotaSettings quotas)`
`void`	`postSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, String userName, GlobalQuotaSettings quotas)`
`void`	`postSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, String userName, String namespace, GlobalQuotaSettings quotas)`
`void`	`postSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, String userName, TableName tableName, GlobalQuotaSettings quotas)`
`void`	`postSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, SnapshotDescription snapshot, TableDescriptor hTableDescriptor)`
`void`	`postStartMaster(ObserverContext<MasterCoprocessorEnvironment> ctx)`
`void`	`postTableFlush(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)`
`void`	`postTruncateTable(ObserverContext<MasterCoprocessorEnvironment> env, TableName tableName)`
`void`	`postUnassign(ObserverContext<MasterCoprocessorEnvironment> env, RegionInfo regionInfo, boolean force)`
`void`	`preAbortProcedure(ObserverContext<MasterCoprocessorEnvironment> ctx, long procId)`
`void`	`preAddRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx, String name)`
`boolean`	`preAndPostForQueueLockAndHeartbeatLockCalled()`
`void`	`preAssign(ObserverContext<MasterCoprocessorEnvironment> env, RegionInfo regionInfo)`
`boolean`	`preAssignCalledOnly()`
`void`	`preBalance(ObserverContext<MasterCoprocessorEnvironment> env)`
`boolean`	`preBalanceCalledOnly()`
`void`	`preBalanceRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx, String groupName)`
`void`	`preBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> env, boolean b)`
`boolean`	`preBalanceSwitchCalledOnly()`
`void`	`preCloneSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, SnapshotDescription snapshot, TableDescriptor hTableDescriptor)`
`void`	`preCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> env, NamespaceDescriptor ns)`
`boolean`	`preCreateNamespaceCalledOnly()`
`void`	`preCreateTable(ObserverContext<MasterCoprocessorEnvironment> env, TableDescriptor desc, RegionInfo[] regions)`
`void`	`preCreateTableAction(ObserverContext<MasterCoprocessorEnvironment> env, TableDescriptor desc, RegionInfo[] regions)`
`boolean`	`preCreateTableCalledOnly()`
`void`	`preDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> env, String name)`
`boolean`	`preDeleteNamespaceCalledOnly()`
`void`	`preDeleteSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, SnapshotDescription snapshot)`
`void`	`preDeleteTable(ObserverContext<MasterCoprocessorEnvironment> env, TableName tableName)`
`void`	`preDeleteTableAction(ObserverContext<MasterCoprocessorEnvironment> env, TableName tableName)`
`boolean`	`preDeleteTableCalledOnly()`
`void`	`preDisableTable(ObserverContext<MasterCoprocessorEnvironment> env, TableName tableName)`
`void`	`preDisableTableAction(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)`
`boolean`	`preDisableTableActionCalledOnly()`
`boolean`	`preDisableTableCalledOnly()`
`void`	`preEnableTable(ObserverContext<MasterCoprocessorEnvironment> env, TableName tableName)`
`void`	`preEnableTableAction(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)`
`boolean`	`preEnableTableActionCalledOnly()`
`boolean`	`preEnableTableCalledOnly()`
`void`	`preGetLocks(ObserverContext<MasterCoprocessorEnvironment> ctx)`
`void`	`preGetNamespaceDescriptor(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace)`
`void`	`preGetProcedures(ObserverContext<MasterCoprocessorEnvironment> ctx)`
`void`	`preGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx, List<TableName> tableNamesList, List<TableDescriptor> descriptors, String regex)`
`void`	`preGetTableNames(ObserverContext<MasterCoprocessorEnvironment> ctx, List<TableDescriptor> descriptors, String regex)`
`void`	`preListNamespaceDescriptors(ObserverContext<MasterCoprocessorEnvironment> env, List<NamespaceDescriptor> descriptors)`
`boolean`	`preListNamespaceDescriptorsCalledOnly()`
`void`	`preListSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, SnapshotDescription snapshot)`
`void`	`preLockHeartbeat(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tn, String description)`
`void`	`preMasterInitialization(ObserverContext<MasterCoprocessorEnvironment> ctx)`
`void`	`preMergeRegions(ObserverContext<MasterCoprocessorEnvironment> ctx, RegionInfo[] regionsToMerge)`
`void`	`preMergeRegionsAction(ObserverContext<MasterCoprocessorEnvironment> ctx, RegionInfo[] regionsToMerge)`
`void`	`preMergeRegionsCommitAction(ObserverContext<MasterCoprocessorEnvironment> ctx, RegionInfo[] regionsToMerge, List<Mutation> metaEntries)`
`void`	`preModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> env, NamespaceDescriptor ns)`
`boolean`	`preModifyNamespaceCalledOnly()`
`void`	`preModifyTable(ObserverContext<MasterCoprocessorEnvironment> env, TableName tableName, TableDescriptor htd)`
`void`	`preModifyTableAction(ObserverContext<MasterCoprocessorEnvironment> env, TableName tableName, TableDescriptor htd)`
`boolean`	`preModifyTableCalledOnly()`
`void`	`preMove(ObserverContext<MasterCoprocessorEnvironment> env, RegionInfo region, ServerName srcServer, ServerName destServer)`
`boolean`	`preMoveCalledOnly()`
`void`	`preMoveServers(ObserverContext<MasterCoprocessorEnvironment> ctx, Set<Address> servers, String targetGroup)`
`void`	`preMoveServersAndTables(ObserverContext<MasterCoprocessorEnvironment> ctx, Set<Address> servers, Set<TableName> tables, String targetGroup)`
`void`	`preMoveTables(ObserverContext<MasterCoprocessorEnvironment> ctx, Set<TableName> tables, String targetGroupGroup)`
`void`	`preRegionOffline(ObserverContext<MasterCoprocessorEnvironment> env, RegionInfo regionInfo)`
`boolean`	`preRegionOfflineCalledOnly()`
`void`	`preRemoveRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx, String name)`
`void`	`preRequestLock(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace, TableName tableName, RegionInfo[] regionInfos, String description)`
`void`	`preRestoreSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, SnapshotDescription snapshot, TableDescriptor hTableDescriptor)`
`void`	`preSetNamespaceQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace, GlobalQuotaSettings quotas)`
`void`	`preSetTableQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, GlobalQuotaSettings quotas)`
`void`	`preSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, String userName, GlobalQuotaSettings quotas)`
`void`	`preSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, String userName, String namespace, GlobalQuotaSettings quotas)`
`void`	`preSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, String userName, TableName tableName, GlobalQuotaSettings quotas)`
`void`	`preShutdown(ObserverContext<MasterCoprocessorEnvironment> env)`
`void`	`preSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, SnapshotDescription snapshot, TableDescriptor hTableDescriptor)`
`void`	`preSplitRegion(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, byte[] splitRow)`
`void`	`preSplitRegionAction(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, byte[] splitRow)`
`void`	`preSplitRegionAfterMETAAction(ObserverContext<MasterCoprocessorEnvironment> ctx)`
`void`	`preSplitRegionBeforeMETAAction(ObserverContext<MasterCoprocessorEnvironment> ctx, byte[] splitKey, List<Mutation> metaEntries)`
`void`	`preStopMaster(ObserverContext<MasterCoprocessorEnvironment> env)`
`void`	`preTableFlush(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)`
`void`	`preTruncateTable(ObserverContext<MasterCoprocessorEnvironment> env, TableName tableName)`
`void`	`preTruncateTableAction(ObserverContext<MasterCoprocessorEnvironment> env, TableName tableName)`
`boolean`	`preTruncateTableCalledOnly()`
`void`	`preUnassign(ObserverContext<MasterCoprocessorEnvironment> env, RegionInfo regionInfo, boolean force)`
`boolean`	`preUnassignCalledOnly()`
`void`	`resetStates()`
`void`	`start(CoprocessorEnvironment env)`
`void`	`stop(CoprocessorEnvironment env)`
`boolean`	`wasAbortProcedureCalled()`
`boolean`	`wasAssignCalled()`
`boolean`	`wasBalanceCalled()`
`boolean`	`wasBalanceSwitchCalled()`
`boolean`	`wasCloneSnapshotCalled()`
`boolean`	`wasCreateNamespaceCalled()`
`boolean`	`wasCreateTableActionCalled()`
`boolean`	`wasCreateTableActionCalledOnly()`
`boolean`	`wasCreateTableCalled()`
`boolean`	`wasDeleteNamespaceCalled()`
`boolean`	`wasDeleteSnapshotCalled()`
`boolean`	`wasDeleteTableActionCalled()`
`boolean`	`wasDeleteTableActionCalledOnly()`
`boolean`	`wasDeleteTableCalled()`
`boolean`	`wasDisableTableActionCalled()`
`boolean`	`wasDisableTableCalled()`
`boolean`	`wasEnableTableActionCalled()`
`boolean`	`wasEnableTableCalled()`
`boolean`	`wasGetLocksCalled()`
`boolean`	`wasGetNamespaceDescriptorCalled()`
`boolean`	`wasGetProceduresCalled()`
`boolean`	`wasGetTableDescriptorsCalled()`
`boolean`	`wasGetTableNamesCalled()`
`boolean`	`wasListNamespaceDescriptorsCalled()`
`boolean`	`wasListSnapshotCalled()`
`boolean`	`wasMasterInitializationCalled()`
`boolean`	`wasMergeRegionsCalled()`
`boolean`	`wasModifyNamespaceCalled()`
`boolean`	`wasModifyTableActionCalled()`
`boolean`	`wasModifyTableActionCalledOnly()`
`boolean`	`wasModifyTableCalled()`
`boolean`	`wasMoveCalled()`
`boolean`	`wasPreAbortProcedureCalledOnly()`
`boolean`	`wasPreCreateTableActionCalled()`
`boolean`	`wasPreGetLocksCalledOnly()`
`boolean`	`wasPreGetProceduresCalledOnly()`
`boolean`	`wasRegionOfflineCalled()`
`boolean`	`wasRestoreSnapshotCalled()`
`boolean`	`wasShutdownCalled()`
`boolean`	`wasSnapshotCalled()`
`boolean`	`wasStarted()`
`boolean`	`wasStartMasterCalled()`
`boolean`	`wasStopMasterCalled()`
`boolean`	`wasStopped()`
`boolean`	`wasTruncateTableActionCalled()`
`boolean`	`wasTruncateTableActionCalledOnly()`
`boolean`	`wasTruncateTableCalled()`
`boolean`	`wasUnassignCalled()`

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

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

Methods inherited from interface org.apache.hadoop.hbase.coprocessor.MasterObserver
postAddReplicationPeer, postClearDeadServers, postCompletedModifyTableAction, postDecommissionRegionServers, postDisableReplicationPeer, postEnableReplicationPeer, postGetClusterMetrics, postGetReplicationPeerConfig, postListDecommissionedRegionServers, postListReplicationPeers, postModifyNamespace, postModifyTable, postRecommissionRegionServer, postRemoveReplicationPeer, postRemoveServers, postUpdateReplicationPeerConfig, preAddReplicationPeer, preClearDeadServers, preDecommissionRegionServers, preDisableReplicationPeer, preEnableReplicationPeer, preGetClusterMetrics, preGetReplicationPeerConfig, preListDecommissionedRegionServers, preListReplicationPeers, preModifyNamespace, preModifyTable, preModifyTableAction, preRecommissionRegionServer, preRemoveReplicationPeer, preRemoveServers, preSetSplitOrMergeEnabled, preUpdateReplicationPeerConfig

Constructor Detail
- CPMasterObserver
```
public CPMasterObserver()
```

Method Detail

resetStates
```
public void resetStates()
```

getMasterObserver
```
public Optional<MasterObserver> getMasterObserver()
```
Specified by:

getMasterObserver in interface MasterCoprocessor

preMergeRegions

public void preMergeRegions(ObserverContext<MasterCoprocessorEnvironment> ctx,
                            RegionInfo[] regionsToMerge)
                     throws IOException

Specified by:: preMergeRegions in interface MasterObserver
Throws:: IOException

postMergeRegions

public void postMergeRegions(ObserverContext<MasterCoprocessorEnvironment> ctx,
                             RegionInfo[] regionsToMerge)
                      throws IOException

Specified by:: postMergeRegions in interface MasterObserver
Throws:: IOException

wasMergeRegionsCalled

public boolean wasMergeRegionsCalled()

preCreateTable

public void preCreateTable(ObserverContext<MasterCoprocessorEnvironment> env,
                           TableDescriptor desc,
                           RegionInfo[] regions)
                    throws IOException

Specified by:: preCreateTable in interface MasterObserver
Throws:: IOException

postCreateTable

public void postCreateTable(ObserverContext<MasterCoprocessorEnvironment> env,
                            TableDescriptor desc,
                            RegionInfo[] regions)
                     throws IOException

Specified by:: postCreateTable in interface MasterObserver
Throws:: IOException

wasCreateTableCalled
```
public boolean wasCreateTableCalled()
```

preCreateTableCalledOnly

public boolean preCreateTableCalledOnly()

preDeleteTable

public void preDeleteTable(ObserverContext<MasterCoprocessorEnvironment> env,
                           TableName tableName)
                    throws IOException

Specified by:: preDeleteTable in interface MasterObserver
Throws:: IOException

postDeleteTable

public void postDeleteTable(ObserverContext<MasterCoprocessorEnvironment> env,
                            TableName tableName)
                     throws IOException

Specified by:: postDeleteTable in interface MasterObserver
Throws:: IOException

wasDeleteTableCalled
```
public boolean wasDeleteTableCalled()
```

preDeleteTableCalledOnly

public boolean preDeleteTableCalledOnly()

preTruncateTable

public void preTruncateTable(ObserverContext<MasterCoprocessorEnvironment> env,
                             TableName tableName)
                      throws IOException

Specified by:: preTruncateTable in interface MasterObserver
Throws:: IOException

postTruncateTable

public void postTruncateTable(ObserverContext<MasterCoprocessorEnvironment> env,
                              TableName tableName)
                       throws IOException

Specified by:: postTruncateTable in interface MasterObserver
Throws:: IOException

wasTruncateTableCalled

public boolean wasTruncateTableCalled()

preTruncateTableCalledOnly

public boolean preTruncateTableCalledOnly()

postSetSplitOrMergeEnabled

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

Specified by:: postSetSplitOrMergeEnabled in interface MasterObserver
Throws:: IOException

preModifyTable

public void preModifyTable(ObserverContext<MasterCoprocessorEnvironment> env,
                           TableName tableName,
                           TableDescriptor htd)
                    throws IOException

Specified by:: preModifyTable in interface MasterObserver
Throws:: IOException

postModifyTable

public void postModifyTable(ObserverContext<MasterCoprocessorEnvironment> env,
                            TableName tableName,
                            TableDescriptor htd)
                     throws IOException

Specified by:: postModifyTable in interface MasterObserver
Throws:: IOException

wasModifyTableCalled
```
public boolean wasModifyTableCalled()
```

preModifyTableCalledOnly

public boolean preModifyTableCalledOnly()

preCreateNamespace

public void preCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> env,
                               NamespaceDescriptor ns)
                        throws IOException

Specified by:: preCreateNamespace in interface MasterObserver
Throws:: IOException

postCreateNamespace

public void postCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> env,
                                NamespaceDescriptor ns)
                         throws IOException

Specified by:: postCreateNamespace in interface MasterObserver
Throws:: IOException

wasCreateNamespaceCalled

public boolean wasCreateNamespaceCalled()

preCreateNamespaceCalledOnly

public boolean preCreateNamespaceCalledOnly()

preDeleteNamespace

public void preDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> env,
                               String name)
                        throws IOException

Specified by:: preDeleteNamespace in interface MasterObserver
Throws:: IOException

postDeleteNamespace

public void postDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> env,
                                String name)
                         throws IOException

Specified by:: postDeleteNamespace in interface MasterObserver
Throws:: IOException

wasDeleteNamespaceCalled

public boolean wasDeleteNamespaceCalled()

preDeleteNamespaceCalledOnly

public boolean preDeleteNamespaceCalledOnly()

preModifyNamespace

public void preModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> env,
                               NamespaceDescriptor ns)
                        throws IOException

Specified by:: preModifyNamespace in interface MasterObserver
Throws:: IOException

postModifyNamespace

public void postModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> env,
                                NamespaceDescriptor ns)
                         throws IOException

Specified by:: postModifyNamespace in interface MasterObserver
Throws:: IOException

wasModifyNamespaceCalled

public boolean wasModifyNamespaceCalled()

preModifyNamespaceCalledOnly

public boolean preModifyNamespaceCalledOnly()

preGetNamespaceDescriptor

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

Specified by:: preGetNamespaceDescriptor in interface MasterObserver
Throws:: IOException

postGetNamespaceDescriptor

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

Specified by:: postGetNamespaceDescriptor in interface MasterObserver
Throws:: IOException

wasGetNamespaceDescriptorCalled

public boolean wasGetNamespaceDescriptorCalled()

preListNamespaceDescriptors

public void preListNamespaceDescriptors(ObserverContext<MasterCoprocessorEnvironment> env,
                                        List<NamespaceDescriptor> descriptors)
                                 throws IOException

Specified by:: preListNamespaceDescriptors in interface MasterObserver
Throws:: IOException

postListNamespaceDescriptors

public void postListNamespaceDescriptors(ObserverContext<MasterCoprocessorEnvironment> env,
                                         List<NamespaceDescriptor> descriptors)
                                  throws IOException

Specified by:: postListNamespaceDescriptors in interface MasterObserver
Throws:: IOException

wasListNamespaceDescriptorsCalled

public boolean wasListNamespaceDescriptorsCalled()

preListNamespaceDescriptorsCalledOnly

public boolean preListNamespaceDescriptorsCalledOnly()

preEnableTable

public void preEnableTable(ObserverContext<MasterCoprocessorEnvironment> env,
                           TableName tableName)
                    throws IOException

Specified by:: preEnableTable in interface MasterObserver
Throws:: IOException

postEnableTable

public void postEnableTable(ObserverContext<MasterCoprocessorEnvironment> env,
                            TableName tableName)
                     throws IOException

Specified by:: postEnableTable in interface MasterObserver
Throws:: IOException

wasEnableTableCalled
```
public boolean wasEnableTableCalled()
```

preEnableTableCalledOnly

public boolean preEnableTableCalledOnly()

preDisableTable

public void preDisableTable(ObserverContext<MasterCoprocessorEnvironment> env,
                            TableName tableName)
                     throws IOException

Specified by:: preDisableTable in interface MasterObserver
Throws:: IOException

postDisableTable

public void postDisableTable(ObserverContext<MasterCoprocessorEnvironment> env,
                             TableName tableName)
                      throws IOException

Specified by:: postDisableTable in interface MasterObserver
Throws:: IOException

wasDisableTableCalled

public boolean wasDisableTableCalled()

preDisableTableCalledOnly

public boolean preDisableTableCalledOnly()

preAbortProcedure

public void preAbortProcedure(ObserverContext<MasterCoprocessorEnvironment> ctx,
                              long procId)
                       throws IOException

Specified by:: preAbortProcedure in interface MasterObserver
Throws:: IOException

postAbortProcedure

public void postAbortProcedure(ObserverContext<MasterCoprocessorEnvironment> ctx)
                        throws IOException

Specified by:: postAbortProcedure in interface MasterObserver
Throws:: IOException

wasAbortProcedureCalled

public boolean wasAbortProcedureCalled()

wasPreAbortProcedureCalledOnly

public boolean wasPreAbortProcedureCalledOnly()

preGetProcedures

public void preGetProcedures(ObserverContext<MasterCoprocessorEnvironment> ctx)
                      throws IOException

Specified by:: preGetProcedures in interface MasterObserver
Throws:: IOException

postGetProcedures

public void postGetProcedures(ObserverContext<MasterCoprocessorEnvironment> ctx)
                       throws IOException

Specified by:: postGetProcedures in interface MasterObserver
Throws:: IOException

wasGetProceduresCalled

public boolean wasGetProceduresCalled()

wasPreGetProceduresCalledOnly

public boolean wasPreGetProceduresCalledOnly()

preGetLocks

public void preGetLocks(ObserverContext<MasterCoprocessorEnvironment> ctx)
                 throws IOException

Specified by:: preGetLocks in interface MasterObserver
Throws:: IOException

postGetLocks

public void postGetLocks(ObserverContext<MasterCoprocessorEnvironment> ctx)
                  throws IOException

Specified by:: postGetLocks in interface MasterObserver
Throws:: IOException

wasGetLocksCalled
```
public boolean wasGetLocksCalled()
```

wasPreGetLocksCalledOnly

public boolean wasPreGetLocksCalledOnly()

preMove

public void preMove(ObserverContext<MasterCoprocessorEnvironment> env,
                    RegionInfo region,
                    ServerName srcServer,
                    ServerName destServer)
             throws IOException

Specified by:: preMove in interface MasterObserver
Throws:: IOException

postMove

public void postMove(ObserverContext<MasterCoprocessorEnvironment> env,
                     RegionInfo region,
                     ServerName srcServer,
                     ServerName destServer)
              throws IOException

Specified by:: postMove in interface MasterObserver
Throws:: IOException

wasMoveCalled
```
public boolean wasMoveCalled()
```

preMoveCalledOnly
```
public boolean preMoveCalledOnly()
```

preAssign

public void preAssign(ObserverContext<MasterCoprocessorEnvironment> env,
                      RegionInfo regionInfo)
               throws IOException

Specified by:: preAssign in interface MasterObserver
Throws:: IOException

postAssign

public void postAssign(ObserverContext<MasterCoprocessorEnvironment> env,
                       RegionInfo regionInfo)
                throws IOException

Specified by:: postAssign in interface MasterObserver
Throws:: IOException

wasAssignCalled
```
public boolean wasAssignCalled()
```

preAssignCalledOnly
```
public boolean preAssignCalledOnly()
```

preUnassign

public void preUnassign(ObserverContext<MasterCoprocessorEnvironment> env,
                        RegionInfo regionInfo,
                        boolean force)
                 throws IOException

Specified by:: preUnassign in interface MasterObserver
Throws:: IOException

postUnassign

public void postUnassign(ObserverContext<MasterCoprocessorEnvironment> env,
                         RegionInfo regionInfo,
                         boolean force)
                  throws IOException

Specified by:: postUnassign in interface MasterObserver
Throws:: IOException

wasUnassignCalled
```
public boolean wasUnassignCalled()
```

preUnassignCalledOnly

public boolean preUnassignCalledOnly()

preRegionOffline

public void preRegionOffline(ObserverContext<MasterCoprocessorEnvironment> env,
                             RegionInfo regionInfo)
                      throws IOException

Specified by:: preRegionOffline in interface MasterObserver
Throws:: IOException

postRegionOffline

public void postRegionOffline(ObserverContext<MasterCoprocessorEnvironment> env,
                              RegionInfo regionInfo)
                       throws IOException

Specified by:: postRegionOffline in interface MasterObserver
Throws:: IOException

wasRegionOfflineCalled

public boolean wasRegionOfflineCalled()

preRegionOfflineCalledOnly

public boolean preRegionOfflineCalledOnly()

preBalance

public void preBalance(ObserverContext<MasterCoprocessorEnvironment> env)
                throws IOException

Specified by:: preBalance in interface MasterObserver
Throws:: IOException

postBalance

public void postBalance(ObserverContext<MasterCoprocessorEnvironment> env,
                        List<RegionPlan> plans)
                 throws IOException

Specified by:: postBalance in interface MasterObserver
Throws:: IOException

wasBalanceCalled
```
public boolean wasBalanceCalled()
```

preBalanceCalledOnly
```
public boolean preBalanceCalledOnly()
```

preBalanceSwitch

public void preBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> env,
                             boolean b)
                      throws IOException

Specified by:: preBalanceSwitch in interface MasterObserver
Throws:: IOException

postBalanceSwitch

public void postBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> env,
                              boolean oldValue,
                              boolean newValue)
                       throws IOException

Specified by:: postBalanceSwitch in interface MasterObserver
Throws:: IOException

wasBalanceSwitchCalled

public boolean wasBalanceSwitchCalled()

preBalanceSwitchCalledOnly

public boolean preBalanceSwitchCalledOnly()

preShutdown

public void preShutdown(ObserverContext<MasterCoprocessorEnvironment> env)
                 throws IOException

Specified by:: preShutdown in interface MasterObserver
Throws:: IOException

wasShutdownCalled
```
public boolean wasShutdownCalled()
```

preStopMaster

public void preStopMaster(ObserverContext<MasterCoprocessorEnvironment> env)
                   throws IOException

Specified by:: preStopMaster in interface MasterObserver
Throws:: IOException

wasStopMasterCalled
```
public boolean wasStopMasterCalled()
```

preMasterInitialization

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

Specified by:: preMasterInitialization in interface MasterObserver
Throws:: IOException

wasMasterInitializationCalled

public boolean wasMasterInitializationCalled()

postStartMaster

public void postStartMaster(ObserverContext<MasterCoprocessorEnvironment> ctx)
                     throws IOException

Specified by:: postStartMaster in interface MasterObserver
Throws:: IOException

wasStartMasterCalled
```
public boolean wasStartMasterCalled()
```

start

public void start(CoprocessorEnvironment env)
           throws IOException

Specified by:: start in interface Coprocessor
Throws:: IOException

stop

public void stop(CoprocessorEnvironment env)
          throws IOException

Specified by:: stop in interface Coprocessor
Throws:: IOException

wasStarted
```
public boolean wasStarted()
```

wasStopped
```
public boolean wasStopped()
```

preSnapshot

public void preSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
                        SnapshotDescription snapshot,
                        TableDescriptor hTableDescriptor)
                 throws IOException

Specified by:: preSnapshot in interface MasterObserver
Throws:: IOException

postSnapshot

public void postSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
                         SnapshotDescription snapshot,
                         TableDescriptor hTableDescriptor)
                  throws IOException

Specified by:: postSnapshot in interface MasterObserver
Throws:: IOException

wasSnapshotCalled
```
public boolean wasSnapshotCalled()
```

preListSnapshot

public void preListSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
                            SnapshotDescription snapshot)
                     throws IOException

Specified by:: preListSnapshot in interface MasterObserver
Throws:: IOException

postListSnapshot

public void postListSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
                             SnapshotDescription snapshot)
                      throws IOException

Specified by:: postListSnapshot in interface MasterObserver
Throws:: IOException

wasListSnapshotCalled

public boolean wasListSnapshotCalled()

preCloneSnapshot

public void preCloneSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
                             SnapshotDescription snapshot,
                             TableDescriptor hTableDescriptor)
                      throws IOException

Specified by:: preCloneSnapshot in interface MasterObserver
Throws:: IOException

postCloneSnapshot

public void postCloneSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
                              SnapshotDescription snapshot,
                              TableDescriptor hTableDescriptor)
                       throws IOException

Specified by:: postCloneSnapshot in interface MasterObserver
Throws:: IOException

wasCloneSnapshotCalled

public boolean wasCloneSnapshotCalled()

preRestoreSnapshot

public void preRestoreSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
                               SnapshotDescription snapshot,
                               TableDescriptor hTableDescriptor)
                        throws IOException

Specified by:: preRestoreSnapshot in interface MasterObserver
Throws:: IOException

postRestoreSnapshot

public void postRestoreSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                SnapshotDescription snapshot,
                                TableDescriptor hTableDescriptor)
                         throws IOException

Specified by:: postRestoreSnapshot in interface MasterObserver
Throws:: IOException

wasRestoreSnapshotCalled

public boolean wasRestoreSnapshotCalled()

preDeleteSnapshot

public void preDeleteSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
                              SnapshotDescription snapshot)
                       throws IOException

Specified by:: preDeleteSnapshot in interface MasterObserver
Throws:: IOException

postDeleteSnapshot

public void postDeleteSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
                               SnapshotDescription snapshot)
                        throws IOException

Specified by:: postDeleteSnapshot in interface MasterObserver
Throws:: IOException

wasDeleteSnapshotCalled

public boolean wasDeleteSnapshotCalled()

preCreateTableAction

public void preCreateTableAction(ObserverContext<MasterCoprocessorEnvironment> env,
                                 TableDescriptor desc,
                                 RegionInfo[] regions)
                          throws IOException

Specified by:: preCreateTableAction in interface MasterObserver
Throws:: IOException

postCompletedCreateTableAction

public void postCompletedCreateTableAction(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                           TableDescriptor desc,
                                           RegionInfo[] regions)
                                    throws IOException

Specified by:: postCompletedCreateTableAction in interface MasterObserver
Throws:: IOException

wasPreCreateTableActionCalled

public boolean wasPreCreateTableActionCalled()

wasCreateTableActionCalled

public boolean wasCreateTableActionCalled()

wasCreateTableActionCalledOnly

public boolean wasCreateTableActionCalledOnly()

preDeleteTableAction

public void preDeleteTableAction(ObserverContext<MasterCoprocessorEnvironment> env,
                                 TableName tableName)
                          throws IOException

Specified by:: preDeleteTableAction in interface MasterObserver
Throws:: IOException

postCompletedDeleteTableAction

public void postCompletedDeleteTableAction(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                           TableName tableName)
                                    throws IOException

Specified by:: postCompletedDeleteTableAction in interface MasterObserver
Throws:: IOException

wasDeleteTableActionCalled

public boolean wasDeleteTableActionCalled()

wasDeleteTableActionCalledOnly

public boolean wasDeleteTableActionCalledOnly()

preTruncateTableAction

public void preTruncateTableAction(ObserverContext<MasterCoprocessorEnvironment> env,
                                   TableName tableName)
                            throws IOException

Specified by:: preTruncateTableAction in interface MasterObserver
Throws:: IOException

postCompletedTruncateTableAction

public void postCompletedTruncateTableAction(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                             TableName tableName)
                                      throws IOException

Specified by:: postCompletedTruncateTableAction in interface MasterObserver
Throws:: IOException

wasTruncateTableActionCalled

public boolean wasTruncateTableActionCalled()

wasTruncateTableActionCalledOnly

public boolean wasTruncateTableActionCalledOnly()

preModifyTableAction

public void preModifyTableAction(ObserverContext<MasterCoprocessorEnvironment> env,
                                 TableName tableName,
                                 TableDescriptor htd)
                          throws IOException

Specified by:: preModifyTableAction in interface MasterObserver
Throws:: IOException

postCompletedModifyTableAction

public void postCompletedModifyTableAction(ObserverContext<MasterCoprocessorEnvironment> env,
                                           TableName tableName,
                                           TableDescriptor htd)
                                    throws IOException

Specified by:: postCompletedModifyTableAction in interface MasterObserver
Throws:: IOException

wasModifyTableActionCalled

public boolean wasModifyTableActionCalled()

wasModifyTableActionCalledOnly

public boolean wasModifyTableActionCalledOnly()

preEnableTableAction

public void preEnableTableAction(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                 TableName tableName)
                          throws IOException

Specified by:: preEnableTableAction in interface MasterObserver
Throws:: IOException

postCompletedEnableTableAction

public void postCompletedEnableTableAction(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                           TableName tableName)
                                    throws IOException

Specified by:: postCompletedEnableTableAction in interface MasterObserver
Throws:: IOException

wasEnableTableActionCalled

public boolean wasEnableTableActionCalled()

preEnableTableActionCalledOnly

public boolean preEnableTableActionCalledOnly()

preDisableTableAction

public void preDisableTableAction(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                  TableName tableName)
                           throws IOException

Specified by:: preDisableTableAction in interface MasterObserver
Throws:: IOException

postCompletedDisableTableAction

public void postCompletedDisableTableAction(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                            TableName tableName)
                                     throws IOException

Specified by:: postCompletedDisableTableAction in interface MasterObserver
Throws:: IOException

wasDisableTableActionCalled

public boolean wasDisableTableActionCalled()

preDisableTableActionCalledOnly

public boolean preDisableTableActionCalledOnly()

preGetTableDescriptors

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

Specified by:: preGetTableDescriptors in interface MasterObserver
Throws:: IOException

postGetTableDescriptors

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

Specified by:: postGetTableDescriptors in interface MasterObserver
Throws:: IOException

wasGetTableDescriptorsCalled

public boolean wasGetTableDescriptorsCalled()

preGetTableNames

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

Specified by:: preGetTableNames in interface MasterObserver
Throws:: IOException

postGetTableNames

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

Specified by:: postGetTableNames in interface MasterObserver
Throws:: IOException

wasGetTableNamesCalled

public boolean wasGetTableNamesCalled()

preTableFlush

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

Specified by:: preTableFlush in interface MasterObserver
Throws:: IOException

postTableFlush

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

Specified by:: postTableFlush in interface MasterObserver
Throws:: IOException

preSetUserQuota

public void preSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx,
                            String userName,
                            GlobalQuotaSettings quotas)
                     throws IOException

Specified by:: preSetUserQuota in interface MasterObserver
Throws:: IOException

postSetUserQuota

public void postSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx,
                             String userName,
                             GlobalQuotaSettings quotas)
                      throws IOException

Specified by:: postSetUserQuota in interface MasterObserver
Throws:: IOException

preSetUserQuota

public void preSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx,
                            String userName,
                            TableName tableName,
                            GlobalQuotaSettings quotas)
                     throws IOException

Specified by:: preSetUserQuota in interface MasterObserver
Throws:: IOException

postSetUserQuota

public void postSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx,
                             String userName,
                             TableName tableName,
                             GlobalQuotaSettings quotas)
                      throws IOException

Specified by:: postSetUserQuota in interface MasterObserver
Throws:: IOException

preSetUserQuota

public void preSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx,
                            String userName,
                            String namespace,
                            GlobalQuotaSettings quotas)
                     throws IOException

Specified by:: preSetUserQuota in interface MasterObserver
Throws:: IOException

postSetUserQuota

public void postSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx,
                             String userName,
                             String namespace,
                             GlobalQuotaSettings quotas)
                      throws IOException

Specified by:: postSetUserQuota in interface MasterObserver
Throws:: IOException

preSetTableQuota

public void preSetTableQuota(ObserverContext<MasterCoprocessorEnvironment> ctx,
                             TableName tableName,
                             GlobalQuotaSettings quotas)
                      throws IOException

Specified by:: preSetTableQuota in interface MasterObserver
Throws:: IOException

postSetTableQuota

public void postSetTableQuota(ObserverContext<MasterCoprocessorEnvironment> ctx,
                              TableName tableName,
                              GlobalQuotaSettings quotas)
                       throws IOException

Specified by:: postSetTableQuota in interface MasterObserver
Throws:: IOException

preSetNamespaceQuota

public void preSetNamespaceQuota(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                 String namespace,
                                 GlobalQuotaSettings quotas)
                          throws IOException

Specified by:: preSetNamespaceQuota in interface MasterObserver
Throws:: IOException

postSetNamespaceQuota

public void postSetNamespaceQuota(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                  String namespace,
                                  GlobalQuotaSettings quotas)
                           throws IOException

Specified by:: postSetNamespaceQuota in interface MasterObserver
Throws:: IOException

preMoveServersAndTables

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

Specified by:: preMoveServersAndTables in interface MasterObserver
Throws:: IOException

postMoveServersAndTables

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

Specified by:: postMoveServersAndTables in interface MasterObserver
Throws:: IOException

preMoveServers

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

Specified by:: preMoveServers in interface MasterObserver
Throws:: IOException

postMoveServers

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

Specified by:: postMoveServers in interface MasterObserver
Throws:: IOException

preMoveTables

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

Specified by:: preMoveTables in interface MasterObserver
Throws:: IOException

postMoveTables

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

Specified by:: postMoveTables in interface MasterObserver
Throws:: IOException

preAddRSGroup

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

Specified by:: preAddRSGroup in interface MasterObserver
Throws:: IOException

postAddRSGroup

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

Specified by:: postAddRSGroup in interface MasterObserver
Throws:: IOException

preRemoveRSGroup

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

Specified by:: preRemoveRSGroup in interface MasterObserver
Throws:: IOException

postRemoveRSGroup

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

Specified by:: postRemoveRSGroup in interface MasterObserver
Throws:: IOException

preBalanceRSGroup

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

Specified by:: preBalanceRSGroup in interface MasterObserver
Throws:: IOException

postBalanceRSGroup

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

Specified by:: postBalanceRSGroup in interface MasterObserver
Throws:: IOException

preRequestLock

public void preRequestLock(ObserverContext<MasterCoprocessorEnvironment> ctx,
                           String namespace,
                           TableName tableName,
                           RegionInfo[] regionInfos,
                           String description)
                    throws IOException

Specified by:: preRequestLock in interface MasterObserver
Throws:: IOException

postRequestLock

public void postRequestLock(ObserverContext<MasterCoprocessorEnvironment> ctx,
                            String namespace,
                            TableName tableName,
                            RegionInfo[] regionInfos,
                            String description)
                     throws IOException

Specified by:: postRequestLock in interface MasterObserver
Throws:: IOException

preLockHeartbeat

public void preLockHeartbeat(ObserverContext<MasterCoprocessorEnvironment> ctx,
                             TableName tn,
                             String description)
                      throws IOException

Specified by:: preLockHeartbeat in interface MasterObserver
Throws:: IOException

postLockHeartbeat

public void postLockHeartbeat(ObserverContext<MasterCoprocessorEnvironment> ctx)
                       throws IOException

Specified by:: postLockHeartbeat in interface MasterObserver
Throws:: IOException

preAndPostForQueueLockAndHeartbeatLockCalled

public boolean preAndPostForQueueLockAndHeartbeatLockCalled()

preSplitRegion

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

Specified by:: preSplitRegion in interface MasterObserver
Throws:: IOException

preSplitRegionAction

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

Specified by:: preSplitRegionAction in interface MasterObserver
Throws:: IOException

postCompletedSplitRegionAction

public void postCompletedSplitRegionAction(ObserverContext<MasterCoprocessorEnvironment> c,
                                           RegionInfo regionInfoA,
                                           RegionInfo regionInfoB)
                                    throws IOException

Specified by:: postCompletedSplitRegionAction in interface MasterObserver
Throws:: IOException

preSplitRegionBeforeMETAAction

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

Specified by:: preSplitRegionBeforeMETAAction in interface MasterObserver
Throws:: IOException

preSplitRegionAfterMETAAction

public void preSplitRegionAfterMETAAction(ObserverContext<MasterCoprocessorEnvironment> ctx)
                                   throws IOException

Specified by:: preSplitRegionAfterMETAAction in interface MasterObserver
Throws:: IOException

postRollBackSplitRegionAction

public void postRollBackSplitRegionAction(ObserverContext<MasterCoprocessorEnvironment> ctx)
                                   throws IOException

Specified by:: postRollBackSplitRegionAction in interface MasterObserver
Throws:: IOException

preMergeRegionsAction

public void preMergeRegionsAction(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                  RegionInfo[] regionsToMerge)
                           throws IOException

Specified by:: preMergeRegionsAction in interface MasterObserver
Throws:: IOException

postCompletedMergeRegionsAction

public void postCompletedMergeRegionsAction(ObserverContext<MasterCoprocessorEnvironment> c,
                                            RegionInfo[] regionsToMerge,
                                            RegionInfo mergedRegion)
                                     throws IOException

Specified by:: postCompletedMergeRegionsAction in interface MasterObserver
Throws:: IOException

preMergeRegionsCommitAction

public void preMergeRegionsCommitAction(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                        RegionInfo[] regionsToMerge,
                                        List<Mutation> metaEntries)
                                 throws IOException

Specified by:: preMergeRegionsCommitAction in interface MasterObserver
Throws:: IOException

postMergeRegionsCommitAction

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

Specified by:: postMergeRegionsCommitAction in interface MasterObserver
Throws:: IOException

postRollBackMergeRegionsAction

public void postRollBackMergeRegionsAction(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                           RegionInfo[] regionsToMerge)
                                    throws IOException

Specified by:: postRollBackMergeRegionsAction in interface MasterObserver
Throws:: IOException

Class TestMasterObserver.CPMasterObserver

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

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

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

Methods inherited from interface org.apache.hadoop.hbase.coprocessor.MasterObserver

Constructor Detail

CPMasterObserver

Method Detail

resetStates

getMasterObserver

preMergeRegions

postMergeRegions

wasMergeRegionsCalled

preCreateTable

postCreateTable

wasCreateTableCalled

preCreateTableCalledOnly

preDeleteTable

postDeleteTable

wasDeleteTableCalled

preDeleteTableCalledOnly

preTruncateTable

postTruncateTable

wasTruncateTableCalled

preTruncateTableCalledOnly

postSetSplitOrMergeEnabled

preModifyTable

postModifyTable

wasModifyTableCalled

preModifyTableCalledOnly

preCreateNamespace

postCreateNamespace

wasCreateNamespaceCalled

preCreateNamespaceCalledOnly

preDeleteNamespace

postDeleteNamespace

wasDeleteNamespaceCalled

preDeleteNamespaceCalledOnly

preModifyNamespace

postModifyNamespace

wasModifyNamespaceCalled

preModifyNamespaceCalledOnly

preGetNamespaceDescriptor

postGetNamespaceDescriptor

wasGetNamespaceDescriptorCalled

preListNamespaceDescriptors

postListNamespaceDescriptors

wasListNamespaceDescriptorsCalled

preListNamespaceDescriptorsCalledOnly

preEnableTable

postEnableTable

wasEnableTableCalled

preEnableTableCalledOnly

preDisableTable

postDisableTable

wasDisableTableCalled

preDisableTableCalledOnly

preAbortProcedure

postAbortProcedure

wasAbortProcedureCalled

wasPreAbortProcedureCalledOnly

preGetProcedures

postGetProcedures

wasGetProceduresCalled

wasPreGetProceduresCalledOnly

preGetLocks

postGetLocks

wasGetLocksCalled

wasPreGetLocksCalledOnly

preMove

postMove

wasMoveCalled

preMoveCalledOnly

preAssign

postAssign