TestMasterObserver.CPMasterObserver (Hortonworks Data Platform Apache HBase Java API Reference)

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

All Implemented Interfaces:: Coprocessor, MasterObserver

Enclosing class:: TestMasterObserver

public static class TestMasterObserver.CPMasterObserver
extends java.lang.Object
implements 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
`void`	`enableBypass(boolean bypass)`
`void`	`postAbortProcedure(ObserverContext<MasterCoprocessorEnvironment> ctx)` Called after a abortProcedure request has been processed.
`void`	`postAddColumn(ObserverContext<MasterCoprocessorEnvironment> env, TableName tableName, HColumnDescriptor column)` Called after the new column family has been created.
`void`	`postAddColumnHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, HColumnDescriptor column)` Called after the new column family has been created.
`void`	`postAddRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx, java.lang.String name)` Called after a new region server group is added
`void`	`postAssign(ObserverContext<MasterCoprocessorEnvironment> env, HRegionInfo regionInfo)` Called after the region assignment has been requested.
`void`	`postBalance(ObserverContext<MasterCoprocessorEnvironment> env, java.util.List<RegionPlan> plans)` Called after the balancing plan has been submitted.
`void`	`postBalanceRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx, java.lang.String groupName, boolean balancerRan)` Called after a region server group is removed
`void`	`postBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> env, boolean oldValue, boolean newValue)` Called after the flag to enable/disable balancing has changed.
`void`	`postCloneSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, HBaseProtos.SnapshotDescription snapshot, HTableDescriptor hTableDescriptor)` Called after a snapshot clone operation has been requested.
`void`	`postCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> env, NamespaceDescriptor ns)` Called after the createNamespace operation has been requested.
`void`	`postCreateTable(ObserverContext<MasterCoprocessorEnvironment> env, HTableDescriptor desc, HRegionInfo[] regions)` Called after the createTable operation has been requested.
`void`	`postCreateTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, HTableDescriptor desc, HRegionInfo[] regions)` Called after the createTable operation has been requested.
`void`	`postDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> env, TableName tableName, byte[] c)` Called after the column family has been deleted.
`void`	`postDeleteColumnHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, byte[] c)` Called after the column family has been deleted.
`void`	`postDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> env, java.lang.String name)` Called after the deleteNamespace operation has been requested.
`void`	`postDeleteSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, HBaseProtos.SnapshotDescription snapshot)` Called after the delete snapshot operation has been requested.
`void`	`postDeleteTable(ObserverContext<MasterCoprocessorEnvironment> env, TableName tableName)` Called after the deleteTable operation has been requested.
`void`	`postDeleteTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)` Called after `HMaster` deletes a table.
`void`	`postDisableTable(ObserverContext<MasterCoprocessorEnvironment> env, TableName tableName)` Called after the disableTable operation has been requested.
`void`	`postDisableTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)` Called after the disableTable operation has been requested.
`void`	`postEnableTable(ObserverContext<MasterCoprocessorEnvironment> env, TableName tableName)` Called after the enableTable operation has been requested.
`void`	`postEnableTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)` Called after the enableTable operation has been requested.
`void`	`postGetNamespaceDescriptor(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns)` Called after a getNamespaceDescriptor request has been processed.
`void`	`postGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx, java.util.List<HTableDescriptor> descriptors)` Called after a getTableDescriptors request has been processed.
`void`	`postGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx, java.util.List<TableName> tableNamesList, java.util.List<HTableDescriptor> descriptors, java.lang.String regex)` Called after a getTableDescriptors request has been processed.
`void`	`postGetTableNames(ObserverContext<MasterCoprocessorEnvironment> ctx, java.util.List<HTableDescriptor> descriptors, java.lang.String regex)` Called after a getTableNames request has been processed.
`void`	`postListNamespaceDescriptors(ObserverContext<MasterCoprocessorEnvironment> env, java.util.List<NamespaceDescriptor> descriptors)` Called after a listNamespaceDescriptors request has been processed.
`void`	`postListProcedures(ObserverContext<MasterCoprocessorEnvironment> ctx, java.util.List<ProcedureInfo> procInfoList)` Called after a listProcedures request has been processed.
`void`	`postListSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, HBaseProtos.SnapshotDescription snapshot)` Called after listSnapshots request has been processed.
`void`	`postModifyColumn(ObserverContext<MasterCoprocessorEnvironment> env, TableName tableName, HColumnDescriptor descriptor)` Called after the column family has been updated.
`void`	`postModifyColumnHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, HColumnDescriptor descriptor)` Called after the column family has been updated.
`void`	`postModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> env, NamespaceDescriptor ns)` Called after the modifyNamespace operation has been requested.
`void`	`postModifyTable(ObserverContext<MasterCoprocessorEnvironment> env, TableName tableName, HTableDescriptor htd)` Called after the modifyTable operation has been requested.
`void`	`postModifyTableHandler(ObserverContext<MasterCoprocessorEnvironment> env, TableName tableName, HTableDescriptor htd)` Called after to modifying a table's properties.
`void`	`postMove(ObserverContext<MasterCoprocessorEnvironment> env, HRegionInfo region, ServerName srcServer, ServerName destServer)` Called after the region move has been requested.
`void`	`postMoveServers(ObserverContext<MasterCoprocessorEnvironment> ctx, java.util.Set<HostAndPort> servers, java.lang.String targetGroup)` Called after servers are moved to target region server group
`void`	`postMoveTables(ObserverContext<MasterCoprocessorEnvironment> ctx, java.util.Set<TableName> tables, java.lang.String targetGroup)` Called after servers are moved to target region server group
`void`	`postRegionOffline(ObserverContext<MasterCoprocessorEnvironment> env, HRegionInfo regionInfo)` Called after the region has been marked offline.
`void`	`postRemoveRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx, java.lang.String name)` Called after a region server group is removed
`void`	`postRestoreSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, HBaseProtos.SnapshotDescription snapshot, HTableDescriptor hTableDescriptor)` Called after a snapshot restore operation has been requested.
`void`	`postSetNamespaceQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, java.lang.String namespace, QuotaProtos.Quotas quotas)` Called after the quota for the namespace is stored.
`void`	`postSetTableQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, QuotaProtos.Quotas quotas)` Called after the quota for the table is stored.
`void`	`postSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, java.lang.String userName, QuotaProtos.Quotas quotas)` Called after the quota for the user is stored.
`void`	`postSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, java.lang.String userName, java.lang.String namespace, QuotaProtos.Quotas quotas)` Called after the quota for the user on the specified namespace is stored.
`void`	`postSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, java.lang.String userName, TableName tableName, QuotaProtos.Quotas quotas)` Called after the quota for the user on the specified table is stored.
`void`	`postSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, HBaseProtos.SnapshotDescription snapshot, HTableDescriptor hTableDescriptor)` Called after the snapshot operation has been requested.
`void`	`postStartMaster(ObserverContext<MasterCoprocessorEnvironment> ctx)` Called immediately after an active master instance has completed initialization.
`void`	`postTableFlush(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)` Called after the table memstore is flushed to disk.
`void`	`postTruncateTable(ObserverContext<MasterCoprocessorEnvironment> env, TableName tableName)` Called after the truncateTable operation has been requested.
`void`	`postTruncateTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)` Called after `HMaster` truncates a table.
`void`	`postUnassign(ObserverContext<MasterCoprocessorEnvironment> env, HRegionInfo regionInfo, boolean force)` Called after the region unassignment has been requested.
`void`	`preAbortProcedure(ObserverContext<MasterCoprocessorEnvironment> ctx, ProcedureExecutor<MasterProcedureEnv> procEnv, long procId)` Called before a abortProcedure request has been processed.
`void`	`preAddColumn(ObserverContext<MasterCoprocessorEnvironment> env, TableName tableName, HColumnDescriptor column)` Called prior to adding a new column family to the table.
`boolean`	`preAddColumnCalledOnly()`
`void`	`preAddColumnHandler(ObserverContext<MasterCoprocessorEnvironment> env, TableName tableName, HColumnDescriptor column)` Called prior to adding a new column family to the table.
`boolean`	`preAddColumnHandlerCalledOnly()`
`void`	`preAddRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx, java.lang.String name)` Called before a new region server group is added
`void`	`preAssign(ObserverContext<MasterCoprocessorEnvironment> env, HRegionInfo regionInfo)` Called prior to assigning a specific region.
`boolean`	`preAssignCalledOnly()`
`void`	`preBalance(ObserverContext<MasterCoprocessorEnvironment> env)` Called prior to requesting rebalancing of the cluster regions, though after the initial checks for regions in transition and the balance switch flag.
`boolean`	`preBalanceCalledOnly()`
`void`	`preBalanceRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx, java.lang.String groupName)` Called before a region server group is removed
`boolean`	`preBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> env, boolean b)` Called prior to modifying the flag used to enable/disable region balancing.
`boolean`	`preBalanceSwitchCalledOnly()`
`void`	`preCloneSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, HBaseProtos.SnapshotDescription snapshot, HTableDescriptor hTableDescriptor)` Called before a snapshot is cloned.
`void`	`preCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> env, NamespaceDescriptor ns)` Called before a new namespace is created by `HMaster`.
`boolean`	`preCreateNamespaceCalledOnly()`
`void`	`preCreateTable(ObserverContext<MasterCoprocessorEnvironment> env, HTableDescriptor desc, HRegionInfo[] regions)` Called before a new table is created by `HMaster`.
`boolean`	`preCreateTableCalledOnly()`
`void`	`preCreateTableHandler(ObserverContext<MasterCoprocessorEnvironment> env, HTableDescriptor desc, HRegionInfo[] regions)` Called before a new table is created by `HMaster`.
`void`	`preDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> env, TableName tableName, byte[] c)` Called prior to deleting the entire column family.
`boolean`	`preDeleteColumnCalledOnly()`
`void`	`preDeleteColumnHandler(ObserverContext<MasterCoprocessorEnvironment> env, TableName tableName, byte[] c)` Called prior to deleting the entire column family.
`boolean`	`preDeleteColumnHandlerCalledOnly()`
`void`	`preDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> env, java.lang.String name)` Called before `HMaster` deletes a namespace It can't bypass the default action, e.g., ctx.bypass() won't have effect.
`boolean`	`preDeleteNamespaceCalledOnly()`
`void`	`preDeleteSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, HBaseProtos.SnapshotDescription snapshot)` Called before a snapshot is deleted.
`void`	`preDeleteTable(ObserverContext<MasterCoprocessorEnvironment> env, TableName tableName)` Called before `HMaster` deletes a table.
`boolean`	`preDeleteTableCalledOnly()`
`void`	`preDeleteTableHandler(ObserverContext<MasterCoprocessorEnvironment> env, TableName tableName)` Called before `HMaster` deletes a table.
`void`	`preDisableTable(ObserverContext<MasterCoprocessorEnvironment> env, TableName tableName)` Called prior to disabling a table.
`boolean`	`preDisableTableCalledOnly()`
`void`	`preDisableTableHandler(ObserverContext<MasterCoprocessorEnvironment> env, TableName tableName)` Called prior to disabling a table.
`boolean`	`preDisableTableHandlerCalledOnly()`
`void`	`preEnableTable(ObserverContext<MasterCoprocessorEnvironment> env, TableName tableName)` Called prior to enabling a table.
`boolean`	`preEnableTableCalledOnly()`
`void`	`preEnableTableHandler(ObserverContext<MasterCoprocessorEnvironment> env, TableName tableName)` Called prior to enabling a table.
`boolean`	`preEnableTableHandlerCalledOnly()`
`void`	`preGetNamespaceDescriptor(ObserverContext<MasterCoprocessorEnvironment> ctx, java.lang.String namespace)` Called before a getNamespaceDescriptor request has been processed.
`void`	`preGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx, java.util.List<TableName> tableNamesList, java.util.List<HTableDescriptor> descriptors)` Called before a getTableDescriptors request has been processed.
`void`	`preGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx, java.util.List<TableName> tableNamesList, java.util.List<HTableDescriptor> descriptors, java.lang.String regex)` Called before a getTableDescriptors request has been processed.
`void`	`preGetTableNames(ObserverContext<MasterCoprocessorEnvironment> ctx, java.util.List<HTableDescriptor> descriptors, java.lang.String regex)` Called before a getTableNames request has been processed.
`void`	`preListNamespaceDescriptors(ObserverContext<MasterCoprocessorEnvironment> env, java.util.List<NamespaceDescriptor> descriptors)` Called before a listNamespaceDescriptors request has been processed.
`boolean`	`preListNamespaceDescriptorsCalledOnly()`
`void`	`preListProcedures(ObserverContext<MasterCoprocessorEnvironment> ctx)` Called before a listProcedures request has been processed.
`void`	`preListSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, HBaseProtos.SnapshotDescription snapshot)` Called before listSnapshots request has been processed.
`void`	`preMasterInitialization(ObserverContext<MasterCoprocessorEnvironment> ctx)` Call before the master initialization is set to true.
`void`	`preModifyColumn(ObserverContext<MasterCoprocessorEnvironment> env, TableName tableName, HColumnDescriptor descriptor)` Called prior to modifying a column family's attributes.
`boolean`	`preModifyColumnCalledOnly()`
`void`	`preModifyColumnHandler(ObserverContext<MasterCoprocessorEnvironment> env, TableName tableName, HColumnDescriptor descriptor)` Called prior to modifying a column family's attributes.
`boolean`	`preModifyColumnHandlerCalledOnly()`
`void`	`preModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> env, NamespaceDescriptor ns)` Called prior to modifying a namespace's properties.
`boolean`	`preModifyNamespaceCalledOnly()`
`void`	`preModifyTable(ObserverContext<MasterCoprocessorEnvironment> env, TableName tableName, HTableDescriptor htd)` Called prior to modifying a table's properties.
`boolean`	`preModifyTableCalledOnly()`
`void`	`preModifyTableHandler(ObserverContext<MasterCoprocessorEnvironment> env, TableName tableName, HTableDescriptor htd)` Called prior to modifying a table's properties.
`void`	`preMove(ObserverContext<MasterCoprocessorEnvironment> env, HRegionInfo region, ServerName srcServer, ServerName destServer)` Called prior to moving a given region from one region server to another.
`boolean`	`preMoveCalledOnly()`
`void`	`preMoveServers(ObserverContext<MasterCoprocessorEnvironment> ctx, java.util.Set<HostAndPort> servers, java.lang.String targetGroup)` Called before servers are moved to target region server group
`void`	`preMoveTables(ObserverContext<MasterCoprocessorEnvironment> ctx, java.util.Set<TableName> tables, java.lang.String targetGroupGroup)` Called before tables are moved to target region server group
`void`	`preRegionOffline(ObserverContext<MasterCoprocessorEnvironment> env, HRegionInfo regionInfo)` Called prior to marking a given region as offline.
`boolean`	`preRegionOfflineCalledOnly()`
`void`	`preRemoveRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx, java.lang.String name)` Called before a region server group is removed
`void`	`preRestoreSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, HBaseProtos.SnapshotDescription snapshot, HTableDescriptor hTableDescriptor)` Called before a snapshot is restored.
`void`	`preSetNamespaceQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, java.lang.String namespace, QuotaProtos.Quotas quotas)` Called before the quota for the namespace is stored.
`void`	`preSetTableQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, QuotaProtos.Quotas quotas)` Called before the quota for the table is stored.
`void`	`preSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, java.lang.String userName, QuotaProtos.Quotas quotas)` Called before the quota for the user is stored.
`void`	`preSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, java.lang.String userName, java.lang.String namespace, QuotaProtos.Quotas quotas)` Called before the quota for the user on the specified namespace is stored.
`void`	`preSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, java.lang.String userName, TableName tableName, QuotaProtos.Quotas quotas)` Called before the quota for the user on the specified table is stored.
`void`	`preShutdown(ObserverContext<MasterCoprocessorEnvironment> env)` Called prior to shutting down the full HBase cluster, including this `HMaster` process.
`void`	`preSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, HBaseProtos.SnapshotDescription snapshot, HTableDescriptor hTableDescriptor)` Called before a new snapshot is taken.
`void`	`preStopMaster(ObserverContext<MasterCoprocessorEnvironment> env)` Called immediately prior to stopping this `HMaster` process.
`void`	`preTableFlush(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)` Called before the table memstore is flushed to disk.
`void`	`preTruncateTable(ObserverContext<MasterCoprocessorEnvironment> env, TableName tableName)` Called before `HMaster` truncates a table.
`boolean`	`preTruncateTableCalledOnly()`
`void`	`preTruncateTableHandler(ObserverContext<MasterCoprocessorEnvironment> env, TableName tableName)` Called before `HMaster` truncates a table.
`void`	`preUnassign(ObserverContext<MasterCoprocessorEnvironment> env, HRegionInfo regionInfo, boolean force)` Called prior to unassigning a given region.
`boolean`	`preUnassignCalledOnly()`
`void`	`resetStates()`
`void`	`start(CoprocessorEnvironment env)`
`void`	`stop(CoprocessorEnvironment env)`
`boolean`	`wasAbortProcedureCalled()`
`boolean`	`wasAddColumnCalled()`
`boolean`	`wasAddColumnHandlerCalled()`
`boolean`	`wasAssignCalled()`
`boolean`	`wasBalanceCalled()`
`boolean`	`wasBalanceSwitchCalled()`
`boolean`	`wasCloneSnapshotCalled()`
`boolean`	`wasCreateNamespaceCalled()`
`boolean`	`wasCreateTableCalled()`
`boolean`	`wasCreateTableHandlerCalled()`
`boolean`	`wasCreateTableHandlerCalledOnly()`
`boolean`	`wasDeleteColumnCalled()`
`boolean`	`wasDeleteColumnHandlerCalled()`
`boolean`	`wasDeleteNamespaceCalled()`
`boolean`	`wasDeleteSnapshotCalled()`
`boolean`	`wasDeleteTableCalled()`
`boolean`	`wasDeleteTableHandlerCalled()`
`boolean`	`wasDeleteTableHandlerCalledOnly()`
`boolean`	`wasDisableTableCalled()`
`boolean`	`wasDisableTableHandlerCalled()`
`boolean`	`wasEnableTableCalled()`
`boolean`	`wasEnableTableHandlerCalled()`
`boolean`	`wasGetNamespaceDescriptorCalled()`
`boolean`	`wasGetTableDescriptorsCalled()`
`boolean`	`wasGetTableNamesCalled()`
`boolean`	`wasListNamespaceDescriptorsCalled()`
`boolean`	`wasListProceduresCalled()`
`boolean`	`wasListSnapshotCalled()`
`boolean`	`wasMasterInitializationCalled()`
`boolean`	`wasModifyColumnCalled()`
`boolean`	`wasModifyColumnHandlerCalled()`
`boolean`	`wasModifyNamespaceCalled()`
`boolean`	`wasModifyTableCalled()`
`boolean`	`wasModifyTableHandlerCalled()`
`boolean`	`wasModifyTableHandlerCalledOnly()`
`boolean`	`wasMoveCalled()`
`boolean`	`wasPreAbortProcedureCalledOnly()`
`boolean`	`wasPreCreateTableHandlerCalled()`
`boolean`	`wasPreListProceduresCalledOnly()`
`boolean`	`wasRegionOfflineCalled()`
`boolean`	`wasRestoreSnapshotCalled()`
`boolean`	`wasSnapshotCalled()`
`boolean`	`wasStarted()`
`boolean`	`wasStartMasterCalled()`
`boolean`	`wasStopped()`
`boolean`	`wasTruncateTableCalled()`
`boolean`	`wasTruncateTableHandlerCalled()`
`boolean`	`wasTruncateTableHandlerCalledOnly()`
`boolean`	`wasUnassignCalled()`

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

- Constructor Detail
  - CPMasterObserver
```
public CPMasterObserver()
```
- Method Detail
  - enableBypass
```
public void enableBypass(boolean bypass)
```
  - resetStates
```
public void resetStates()
```
  - preCreateTable
```
public void preCreateTable(ObserverContext<MasterCoprocessorEnvironment> env,
                           HTableDescriptor desc,
                           HRegionInfo[] regions)
                    throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    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.
    
    Specified by:
    
    preCreateTable in interface MasterObserver
    
    Parameters:
    
    env - the environment to interact with the framework and master
    
    desc - the HTableDescriptor for the table
    
    regions - the initial regions created for the table
    
    Throws:
    
    java.io.IOException
  - postCreateTable
```
public void postCreateTable(ObserverContext<MasterCoprocessorEnvironment> env,
                            HTableDescriptor desc,
                            HRegionInfo[] regions)
                     throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called after the createTable operation has been requested. Called as part of create table RPC call.
    
    Specified by:
    
    postCreateTable in interface MasterObserver
    
    Parameters:
    
    env - the environment to interact with the framework and master
    
    desc - the HTableDescriptor for the table
    
    regions - the initial regions created for the table
    
    Throws:
    
    java.io.IOException
  - wasCreateTableCalled
```
public boolean wasCreateTableCalled()
```
  - preCreateTableCalledOnly
```
public boolean preCreateTableCalledOnly()
```
  - preDeleteTable
```
public void preDeleteTable(ObserverContext<MasterCoprocessorEnvironment> env,
                           TableName tableName)
                    throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    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.
    
    Specified by:
    
    preDeleteTable in interface MasterObserver
    
    Parameters:
    
    env - the environment to interact with the framework and master
    
    tableName - the name of the table
    
    Throws:
    
    java.io.IOException
  - postDeleteTable
```
public void postDeleteTable(ObserverContext<MasterCoprocessorEnvironment> env,
                            TableName tableName)
                     throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called after the deleteTable operation has been requested. Called as part of delete table RPC call.
    
    Specified by:
    
    postDeleteTable in interface MasterObserver
    
    Parameters:
    
    env - the environment to interact with the framework and master
    
    tableName - the name of the table
    
    Throws:
    
    java.io.IOException
  - wasDeleteTableCalled
```
public boolean wasDeleteTableCalled()
```
  - preDeleteTableCalledOnly
```
public boolean preDeleteTableCalledOnly()
```
  - preTruncateTable
```
public void preTruncateTable(ObserverContext<MasterCoprocessorEnvironment> env,
                             TableName tableName)
                      throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    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.
    
    Specified by:
    
    preTruncateTable in interface MasterObserver
    
    Parameters:
    
    env - the environment to interact with the framework and master
    
    tableName - the name of the table
    
    Throws:
    
    java.io.IOException
  - postTruncateTable
```
public void postTruncateTable(ObserverContext<MasterCoprocessorEnvironment> env,
                              TableName tableName)
                       throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    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.
    
    Specified by:
    
    postTruncateTable in interface MasterObserver
    
    Parameters:
    
    env - the environment to interact with the framework and master
    
    tableName - the name of the table
    
    Throws:
    
    java.io.IOException
  - wasTruncateTableCalled
```
public boolean wasTruncateTableCalled()
```
  - preTruncateTableCalledOnly
```
public boolean preTruncateTableCalledOnly()
```
  - preModifyTable
```
public void preModifyTable(ObserverContext<MasterCoprocessorEnvironment> env,
                           TableName tableName,
                           HTableDescriptor htd)
                    throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    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.
    
    Specified by:
    
    preModifyTable in interface MasterObserver
    
    Parameters:
    
    env - the environment to interact with the framework and master
    
    tableName - the name of the table
    
    htd - the HTableDescriptor
    
    Throws:
    
    java.io.IOException
  - postModifyTable
```
public void postModifyTable(ObserverContext<MasterCoprocessorEnvironment> env,
                            TableName tableName,
                            HTableDescriptor htd)
                     throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called after the modifyTable operation has been requested. Called as part of modify table RPC call.
    
    Specified by:
    
    postModifyTable in interface MasterObserver
    
    Parameters:
    
    env - the environment to interact with the framework and master
    
    tableName - the name of the table
    
    htd - the HTableDescriptor
    
    Throws:
    
    java.io.IOException
  - wasModifyTableCalled
```
public boolean wasModifyTableCalled()
```
  - preModifyTableCalledOnly
```
public boolean preModifyTableCalledOnly()
```
  - preCreateNamespace
```
public void preCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> env,
                               NamespaceDescriptor ns)
                        throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called before a new namespace is created by HMaster. It can't bypass the default action, e.g., ctx.bypass() won't have effect.
    
    Specified by:
    
    preCreateNamespace in interface MasterObserver
    
    Parameters:
    
    env - the environment to interact with the framework and master
    
    ns - the NamespaceDescriptor for the table
    
    Throws:
    
    java.io.IOException
  - postCreateNamespace
```
public void postCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> env,
                                NamespaceDescriptor ns)
                         throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called after the createNamespace operation has been requested.
    
    Specified by:
    
    postCreateNamespace in interface MasterObserver
    
    Parameters:
    
    env - the environment to interact with the framework and master
    
    ns - the NamespaceDescriptor for the table
    
    Throws:
    
    java.io.IOException
  - wasCreateNamespaceCalled
```
public boolean wasCreateNamespaceCalled()
```
  - preCreateNamespaceCalledOnly
```
public boolean preCreateNamespaceCalledOnly()
```
  - preDeleteNamespace
```
public void preDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> env,
                               java.lang.String name)
                        throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called before HMaster deletes a namespace It can't bypass the default action, e.g., ctx.bypass() won't have effect.
    
    Specified by:
    
    preDeleteNamespace in interface MasterObserver
    
    Parameters:
    
    env - the environment to interact with the framework and master
    
    name - the name of the namespace
    
    Throws:
    
    java.io.IOException
  - postDeleteNamespace
```
public void postDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> env,
                                java.lang.String name)
                         throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called after the deleteNamespace operation has been requested.
    
    Specified by:
    
    postDeleteNamespace in interface MasterObserver
    
    Parameters:
    
    env - the environment to interact with the framework and master
    
    name - the name of the namespace
    
    Throws:
    
    java.io.IOException
  - wasDeleteNamespaceCalled
```
public boolean wasDeleteNamespaceCalled()
```
  - preDeleteNamespaceCalledOnly
```
public boolean preDeleteNamespaceCalledOnly()
```
  - preModifyNamespace
```
public void preModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> env,
                               NamespaceDescriptor ns)
                        throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called prior to modifying a namespace's properties. It can't bypass the default action, e.g., ctx.bypass() won't have effect.
    
    Specified by:
    
    preModifyNamespace in interface MasterObserver
    
    Parameters:
    
    env - the environment to interact with the framework and master
    
    ns - the NamespaceDescriptor
    
    Throws:
    
    java.io.IOException
  - postModifyNamespace
```
public void postModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> env,
                                NamespaceDescriptor ns)
                         throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called after the modifyNamespace operation has been requested.
    
    Specified by:
    
    postModifyNamespace in interface MasterObserver
    
    Parameters:
    
    env - the environment to interact with the framework and master
    
    ns - the NamespaceDescriptor
    
    Throws:
    
    java.io.IOException
  - wasModifyNamespaceCalled
```
public boolean wasModifyNamespaceCalled()
```
  - preModifyNamespaceCalledOnly
```
public boolean preModifyNamespaceCalledOnly()
```
  - preGetNamespaceDescriptor
```
public void preGetNamespaceDescriptor(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                      java.lang.String namespace)
                               throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called before a getNamespaceDescriptor request has been processed.
    
    Specified by:
    
    preGetNamespaceDescriptor in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    namespace - the name of the namespace
    
    Throws:
    
    java.io.IOException
  - postGetNamespaceDescriptor
```
public void postGetNamespaceDescriptor(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                       NamespaceDescriptor ns)
                                throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called after a getNamespaceDescriptor request has been processed.
    
    Specified by:
    
    postGetNamespaceDescriptor in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    ns - the NamespaceDescriptor
    
    Throws:
    
    java.io.IOException
  - wasGetNamespaceDescriptorCalled
```
public boolean wasGetNamespaceDescriptorCalled()
```
  - preListNamespaceDescriptors
```
public void preListNamespaceDescriptors(ObserverContext<MasterCoprocessorEnvironment> env,
                                        java.util.List<NamespaceDescriptor> descriptors)
                                 throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called before a listNamespaceDescriptors request has been processed.
    
    Specified by:
    
    preListNamespaceDescriptors in interface MasterObserver
    
    Parameters:
    
    env - the environment to interact with the framework and master
    
    descriptors - an empty list, can be filled with what to return if bypassing
    
    Throws:
    
    java.io.IOException
  - postListNamespaceDescriptors
```
public void postListNamespaceDescriptors(ObserverContext<MasterCoprocessorEnvironment> env,
                                         java.util.List<NamespaceDescriptor> descriptors)
                                  throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called after a listNamespaceDescriptors request has been processed.
    
    Specified by:
    
    postListNamespaceDescriptors in interface MasterObserver
    
    Parameters:
    
    env - the environment to interact with the framework and master
    
    descriptors - the list of descriptors about to be returned
    
    Throws:
    
    java.io.IOException
  - wasListNamespaceDescriptorsCalled
```
public boolean wasListNamespaceDescriptorsCalled()
```
  - preListNamespaceDescriptorsCalledOnly
```
public boolean preListNamespaceDescriptorsCalledOnly()
```
  - preAddColumn
```
public void preAddColumn(ObserverContext<MasterCoprocessorEnvironment> env,
                         TableName tableName,
                         HColumnDescriptor column)
                  throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called prior to adding a new column family to the table. Called as part of add column RPC call.
    
    Specified by:
    
    preAddColumn in interface MasterObserver
    
    Parameters:
    
    env - the environment to interact with the framework and master
    
    tableName - the name of the table
    
    column - the HColumnDescriptor
    
    Throws:
    
    java.io.IOException
  - postAddColumn
```
public void postAddColumn(ObserverContext<MasterCoprocessorEnvironment> env,
                          TableName tableName,
                          HColumnDescriptor column)
                   throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called after the new column family has been created. Called as part of add column RPC call.
    
    Specified by:
    
    postAddColumn in interface MasterObserver
    
    Parameters:
    
    env - the environment to interact with the framework and master
    
    tableName - the name of the table
    
    column - the HColumnDescriptor
    
    Throws:
    
    java.io.IOException
  - wasAddColumnCalled
```
public boolean wasAddColumnCalled()
```
  - preAddColumnCalledOnly
```
public boolean preAddColumnCalledOnly()
```
  - preModifyColumn
```
public void preModifyColumn(ObserverContext<MasterCoprocessorEnvironment> env,
                            TableName tableName,
                            HColumnDescriptor descriptor)
                     throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called prior to modifying a column family's attributes. Called as part of modify column RPC call.
    
    Specified by:
    
    preModifyColumn in interface MasterObserver
    
    Parameters:
    
    env - the environment to interact with the framework and master
    
    tableName - the name of the table
    
    descriptor - the HColumnDescriptor
    
    Throws:
    
    java.io.IOException
  - postModifyColumn
```
public void postModifyColumn(ObserverContext<MasterCoprocessorEnvironment> env,
                             TableName tableName,
                             HColumnDescriptor descriptor)
                      throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called after the column family has been updated. Called as part of modify column RPC call.
    
    Specified by:
    
    postModifyColumn in interface MasterObserver
    
    Parameters:
    
    env - the environment to interact with the framework and master
    
    tableName - the name of the table
    
    descriptor - the HColumnDescriptor
    
    Throws:
    
    java.io.IOException
  - wasModifyColumnCalled
```
public boolean wasModifyColumnCalled()
```
  - preModifyColumnCalledOnly
```
public boolean preModifyColumnCalledOnly()
```
  - preDeleteColumn
```
public void preDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> env,
                            TableName tableName,
                            byte[] c)
                     throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called prior to deleting the entire column family. Called as part of delete column RPC call.
    
    Specified by:
    
    preDeleteColumn in interface MasterObserver
    
    Parameters:
    
    env - the environment to interact with the framework and master
    
    tableName - the name of the table
    
    c - the column
    
    Throws:
    
    java.io.IOException
  - postDeleteColumn
```
public void postDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> env,
                             TableName tableName,
                             byte[] c)
                      throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called after the column family has been deleted. Called as part of delete column RPC call.
    
    Specified by:
    
    postDeleteColumn in interface MasterObserver
    
    Parameters:
    
    env - the environment to interact with the framework and master
    
    tableName - the name of the table
    
    c - the column
    
    Throws:
    
    java.io.IOException
  - wasDeleteColumnCalled
```
public boolean wasDeleteColumnCalled()
```
  - preDeleteColumnCalledOnly
```
public boolean preDeleteColumnCalledOnly()
```
  - preEnableTable
```
public void preEnableTable(ObserverContext<MasterCoprocessorEnvironment> env,
                           TableName tableName)
                    throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    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.
    
    Specified by:
    
    preEnableTable in interface MasterObserver
    
    Parameters:
    
    env - the environment to interact with the framework and master
    
    tableName - the name of the table
    
    Throws:
    
    java.io.IOException
  - postEnableTable
```
public void postEnableTable(ObserverContext<MasterCoprocessorEnvironment> env,
                            TableName tableName)
                     throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called after the enableTable operation has been requested. Called as part of enable table RPC call.
    
    Specified by:
    
    postEnableTable in interface MasterObserver
    
    Parameters:
    
    env - the environment to interact with the framework and master
    
    tableName - the name of the table
    
    Throws:
    
    java.io.IOException
  - wasEnableTableCalled
```
public boolean wasEnableTableCalled()
```
  - preEnableTableCalledOnly
```
public boolean preEnableTableCalledOnly()
```
  - preDisableTable
```
public void preDisableTable(ObserverContext<MasterCoprocessorEnvironment> env,
                            TableName tableName)
                     throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    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.
    
    Specified by:
    
    preDisableTable in interface MasterObserver
    
    Parameters:
    
    env - the environment to interact with the framework and master
    
    tableName - the name of the table
    
    Throws:
    
    java.io.IOException
  - postDisableTable
```
public void postDisableTable(ObserverContext<MasterCoprocessorEnvironment> env,
                             TableName tableName)
                      throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called after the disableTable operation has been requested. Called as part of disable table RPC call.
    
    Specified by:
    
    postDisableTable in interface MasterObserver
    
    Parameters:
    
    env - the environment to interact with the framework and master
    
    tableName - the name of the table
    
    Throws:
    
    java.io.IOException
  - wasDisableTableCalled
```
public boolean wasDisableTableCalled()
```
  - preDisableTableCalledOnly
```
public boolean preDisableTableCalledOnly()
```
  - preAbortProcedure
```
public void preAbortProcedure(ObserverContext<MasterCoprocessorEnvironment> ctx,
                              ProcedureExecutor<MasterProcedureEnv> procEnv,
                              long procId)
                       throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called before a abortProcedure request has been processed.
    
    Specified by:
    
    preAbortProcedure in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    Throws:
    
    java.io.IOException
  - postAbortProcedure
```
public void postAbortProcedure(ObserverContext<MasterCoprocessorEnvironment> ctx)
                        throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called after a abortProcedure request has been processed.
    
    Specified by:
    
    postAbortProcedure in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    Throws:
    
    java.io.IOException
  - wasAbortProcedureCalled
```
public boolean wasAbortProcedureCalled()
```
  - wasPreAbortProcedureCalledOnly
```
public boolean wasPreAbortProcedureCalledOnly()
```
  - preListProcedures
```
public void preListProcedures(ObserverContext<MasterCoprocessorEnvironment> ctx)
                       throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called before a listProcedures request has been processed.
    
    Specified by:
    
    preListProcedures in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    Throws:
    
    java.io.IOException
  - postListProcedures
```
public void postListProcedures(ObserverContext<MasterCoprocessorEnvironment> ctx,
                               java.util.List<ProcedureInfo> procInfoList)
                        throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called after a listProcedures request has been processed.
    
    Specified by:
    
    postListProcedures in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    procInfoList - the list of procedures about to be returned
    
    Throws:
    
    java.io.IOException
  - wasListProceduresCalled
```
public boolean wasListProceduresCalled()
```
  - wasPreListProceduresCalledOnly
```
public boolean wasPreListProceduresCalledOnly()
```
  - preMove
```
public void preMove(ObserverContext<MasterCoprocessorEnvironment> env,
                    HRegionInfo region,
                    ServerName srcServer,
                    ServerName destServer)
             throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called prior to moving a given region from one region server to another.
    
    Specified by:
    
    preMove in interface MasterObserver
    
    Parameters:
    
    env - the environment to interact with the framework and master
    
    region - the HRegionInfo
    
    srcServer - the source ServerName
    
    destServer - the destination ServerName
    
    Throws:
    
    java.io.IOException
  - postMove
```
public void postMove(ObserverContext<MasterCoprocessorEnvironment> env,
                     HRegionInfo region,
                     ServerName srcServer,
                     ServerName destServer)
              throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called after the region move has been requested.
    
    Specified by:
    
    postMove in interface MasterObserver
    
    Parameters:
    
    env - the environment to interact with the framework and master
    
    region - the HRegionInfo
    
    srcServer - the source ServerName
    
    destServer - the destination ServerName
    
    Throws:
    
    java.io.IOException
  - wasMoveCalled
```
public boolean wasMoveCalled()
```
  - preMoveCalledOnly
```
public boolean preMoveCalledOnly()
```
  - preAssign
```
public void preAssign(ObserverContext<MasterCoprocessorEnvironment> env,
                      HRegionInfo regionInfo)
               throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called prior to assigning a specific region.
    
    Specified by:
    
    preAssign in interface MasterObserver
    
    Parameters:
    
    env - the environment to interact with the framework and master
    
    regionInfo - the regionInfo of the region
    
    Throws:
    
    java.io.IOException
  - postAssign
```
public void postAssign(ObserverContext<MasterCoprocessorEnvironment> env,
                       HRegionInfo regionInfo)
                throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called after the region assignment has been requested.
    
    Specified by:
    
    postAssign in interface MasterObserver
    
    Parameters:
    
    env - the environment to interact with the framework and master
    
    regionInfo - the regionInfo of the region
    
    Throws:
    
    java.io.IOException
  - wasAssignCalled
```
public boolean wasAssignCalled()
```
  - preAssignCalledOnly
```
public boolean preAssignCalledOnly()
```
  - preUnassign
```
public void preUnassign(ObserverContext<MasterCoprocessorEnvironment> env,
                        HRegionInfo regionInfo,
                        boolean force)
                 throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called prior to unassigning a given region.
    
    Specified by:
    
    preUnassign in interface MasterObserver
    
    Parameters:
    
    env - the environment to interact with the framework and master
    
    force - whether to force unassignment or not
    
    Throws:
    
    java.io.IOException
  - postUnassign
```
public void postUnassign(ObserverContext<MasterCoprocessorEnvironment> env,
                         HRegionInfo regionInfo,
                         boolean force)
                  throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called after the region unassignment has been requested.
    
    Specified by:
    
    postUnassign in interface MasterObserver
    
    Parameters:
    
    env - the environment to interact with the framework and master
    
    force - whether to force unassignment or not
    
    Throws:
    
    java.io.IOException
  - wasUnassignCalled
```
public boolean wasUnassignCalled()
```
  - preUnassignCalledOnly
```
public boolean preUnassignCalledOnly()
```
  - preRegionOffline
```
public void preRegionOffline(ObserverContext<MasterCoprocessorEnvironment> env,
                             HRegionInfo regionInfo)
                      throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called prior to marking a given region as offline. ctx.bypass() will not have any impact on this hook.
    
    Specified by:
    
    preRegionOffline in interface MasterObserver
    
    Parameters:
    
    env - the environment to interact with the framework and master
    
    Throws:
    
    java.io.IOException
  - postRegionOffline
```
public void postRegionOffline(ObserverContext<MasterCoprocessorEnvironment> env,
                              HRegionInfo regionInfo)
                       throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called after the region has been marked offline.
    
    Specified by:
    
    postRegionOffline in interface MasterObserver
    
    Parameters:
    
    env - the environment to interact with the framework and master
    
    Throws:
    
    java.io.IOException
  - wasRegionOfflineCalled
```
public boolean wasRegionOfflineCalled()
```
  - preRegionOfflineCalledOnly
```
public boolean preRegionOfflineCalledOnly()
```
  - preBalance
```
public void preBalance(ObserverContext<MasterCoprocessorEnvironment> env)
                throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called prior to requesting rebalancing of the cluster regions, though after the initial checks for regions in transition and the balance switch flag.
    
    Specified by:
    
    preBalance in interface MasterObserver
    
    Parameters:
    
    env - the environment to interact with the framework and master
    
    Throws:
    
    java.io.IOException
  - postBalance
```
public void postBalance(ObserverContext<MasterCoprocessorEnvironment> env,
                        java.util.List<RegionPlan> plans)
                 throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called after the balancing plan has been submitted.
    
    Specified by:
    
    postBalance in interface MasterObserver
    
    Parameters:
    
    env - 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:
    
    java.io.IOException
  - wasBalanceCalled
```
public boolean wasBalanceCalled()
```
  - preBalanceCalledOnly
```
public boolean preBalanceCalledOnly()
```
  - preBalanceSwitch
```
public boolean preBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> env,
                                boolean b)
                         throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called prior to modifying the flag used to enable/disable region balancing.
    
    Specified by:
    
    preBalanceSwitch in interface MasterObserver
    
    Parameters:
    
    env - the coprocessor instance's environment
    
    b - the new flag value submitted in the call
    
    Throws:
    
    java.io.IOException
  - postBalanceSwitch
```
public void postBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> env,
                              boolean oldValue,
                              boolean newValue)
                       throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called after the flag to enable/disable balancing has changed.
    
    Specified by:
    
    postBalanceSwitch in interface MasterObserver
    
    Parameters:
    
    env - the coprocessor instance's environment
    
    oldValue - the previously set balanceSwitch value
    
    newValue - the newly set balanceSwitch value
    
    Throws:
    
    java.io.IOException
  - wasBalanceSwitchCalled
```
public boolean wasBalanceSwitchCalled()
```
  - preBalanceSwitchCalledOnly
```
public boolean preBalanceSwitchCalledOnly()
```
  - preShutdown
```
public void preShutdown(ObserverContext<MasterCoprocessorEnvironment> env)
                 throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called prior to shutting down the full HBase cluster, including this HMaster process.
    
    Specified by:
    
    preShutdown in interface MasterObserver
    
    Throws:
    
    java.io.IOException
  - preStopMaster
```
public void preStopMaster(ObserverContext<MasterCoprocessorEnvironment> env)
                   throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called immediately prior to stopping this HMaster process.
    
    Specified by:
    
    preStopMaster in interface MasterObserver
    
    Throws:
    
    java.io.IOException
  - preMasterInitialization
```
public void preMasterInitialization(ObserverContext<MasterCoprocessorEnvironment> ctx)
                             throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Call before the master initialization is set to true. HMaster process.
    
    Specified by:
    
    preMasterInitialization in interface MasterObserver
    
    Throws:
    
    java.io.IOException
  - wasMasterInitializationCalled
```
public boolean wasMasterInitializationCalled()
```
  - postStartMaster
```
public void postStartMaster(ObserverContext<MasterCoprocessorEnvironment> ctx)
                     throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    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.
    
    Specified by:
    
    postStartMaster in interface MasterObserver
    
    Throws:
    
    java.io.IOException
  - wasStartMasterCalled
```
public boolean wasStartMasterCalled()
```
  - start
```
public void start(CoprocessorEnvironment env)
           throws java.io.IOException
```
    Specified by:
    
    start in interface Coprocessor
    
    Throws:
    
    java.io.IOException
  - stop
```
public void stop(CoprocessorEnvironment env)
          throws java.io.IOException
```
    Specified by:
    
    stop in interface Coprocessor
    
    Throws:
    
    java.io.IOException
  - wasStarted
```
public boolean wasStarted()
```
  - wasStopped
```
public boolean wasStopped()
```
  - preSnapshot
```
public void preSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
                        HBaseProtos.SnapshotDescription snapshot,
                        HTableDescriptor hTableDescriptor)
                 throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    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.
    
    Specified by:
    
    preSnapshot in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    snapshot - the SnapshotDescriptor for the snapshot
    
    hTableDescriptor - the hTableDescriptor of the table to snapshot
    
    Throws:
    
    java.io.IOException
  - postSnapshot
```
public void postSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
                         HBaseProtos.SnapshotDescription snapshot,
                         HTableDescriptor hTableDescriptor)
                  throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called after the snapshot operation has been requested. Called as part of snapshot RPC call.
    
    Specified by:
    
    postSnapshot in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    snapshot - the SnapshotDescriptor for the snapshot
    
    hTableDescriptor - the hTableDescriptor of the table to snapshot
    
    Throws:
    
    java.io.IOException
  - wasSnapshotCalled
```
public boolean wasSnapshotCalled()
```
  - preListSnapshot
```
public void preListSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
                            HBaseProtos.SnapshotDescription snapshot)
                     throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called before listSnapshots request has been processed. It can't bypass the default action, e.g., ctx.bypass() won't have effect.
    
    Specified by:
    
    preListSnapshot in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    snapshot - the SnapshotDescriptor of the snapshot to list
    
    Throws:
    
    java.io.IOException
  - postListSnapshot
```
public void postListSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
                             HBaseProtos.SnapshotDescription snapshot)
                      throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called after listSnapshots request has been processed. It can't bypass the default action, e.g., ctx.bypass() won't have effect.
    
    Specified by:
    
    postListSnapshot in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    snapshot - the SnapshotDescriptor of the snapshot to list
    
    Throws:
    
    java.io.IOException
  - wasListSnapshotCalled
```
public boolean wasListSnapshotCalled()
```
  - preCloneSnapshot
```
public void preCloneSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
                             HBaseProtos.SnapshotDescription snapshot,
                             HTableDescriptor hTableDescriptor)
                      throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    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.
    
    Specified by:
    
    preCloneSnapshot in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    snapshot - the SnapshotDescriptor for the snapshot
    
    hTableDescriptor - the hTableDescriptor of the table to create
    
    Throws:
    
    java.io.IOException
  - postCloneSnapshot
```
public void postCloneSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
                              HBaseProtos.SnapshotDescription snapshot,
                              HTableDescriptor hTableDescriptor)
                       throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called after a snapshot clone operation has been requested. Called as part of restoreSnapshot RPC call.
    
    Specified by:
    
    postCloneSnapshot in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    snapshot - the SnapshotDescriptor for the snapshot
    
    hTableDescriptor - the hTableDescriptor of the table to create
    
    Throws:
    
    java.io.IOException
  - wasCloneSnapshotCalled
```
public boolean wasCloneSnapshotCalled()
```
  - preRestoreSnapshot
```
public void preRestoreSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
                               HBaseProtos.SnapshotDescription snapshot,
                               HTableDescriptor hTableDescriptor)
                        throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    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.
    
    Specified by:
    
    preRestoreSnapshot in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    snapshot - the SnapshotDescriptor for the snapshot
    
    hTableDescriptor - the hTableDescriptor of the table to restore
    
    Throws:
    
    java.io.IOException
  - postRestoreSnapshot
```
public void postRestoreSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                HBaseProtos.SnapshotDescription snapshot,
                                HTableDescriptor hTableDescriptor)
                         throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called after a snapshot restore operation has been requested. Called as part of restoreSnapshot RPC call.
    
    Specified by:
    
    postRestoreSnapshot in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    snapshot - the SnapshotDescriptor for the snapshot
    
    hTableDescriptor - the hTableDescriptor of the table to restore
    
    Throws:
    
    java.io.IOException
  - wasRestoreSnapshotCalled
```
public boolean wasRestoreSnapshotCalled()
```
  - preDeleteSnapshot
```
public void preDeleteSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
                              HBaseProtos.SnapshotDescription snapshot)
                       throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    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.
    
    Specified by:
    
    preDeleteSnapshot in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    snapshot - the SnapshotDescriptor of the snapshot to delete
    
    Throws:
    
    java.io.IOException
  - postDeleteSnapshot
```
public void postDeleteSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
                               HBaseProtos.SnapshotDescription snapshot)
                        throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called after the delete snapshot operation has been requested. Called as part of deleteSnapshot RPC call.
    
    Specified by:
    
    postDeleteSnapshot in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    snapshot - the SnapshotDescriptor of the snapshot to delete
    
    Throws:
    
    java.io.IOException
  - wasDeleteSnapshotCalled
```
public boolean wasDeleteSnapshotCalled()
```
  - preCreateTableHandler
```
public void preCreateTableHandler(ObserverContext<MasterCoprocessorEnvironment> env,
                                  HTableDescriptor desc,
                                  HRegionInfo[] regions)
                           throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called before a new table is created by HMaster. Called as part of create table handler and it is async to the create RPC call. It can't bypass the default action, e.g., ctx.bypass() won't have effect.
    
    Specified by:
    
    preCreateTableHandler in interface MasterObserver
    
    Parameters:
    
    env - the environment to interact with the framework and master
    
    desc - the HTableDescriptor for the table
    
    regions - the initial regions created for the table
    
    Throws:
    
    java.io.IOException
  - postCreateTableHandler
```
public void postCreateTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                   HTableDescriptor desc,
                                   HRegionInfo[] regions)
                            throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called after the createTable operation has been requested. Called as part of create table RPC call. Called as part of create table handler and it is async to the create RPC call.
    
    Specified by:
    
    postCreateTableHandler in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    desc - the HTableDescriptor for the table
    
    regions - the initial regions created for the table
    
    Throws:
    
    java.io.IOException
  - wasPreCreateTableHandlerCalled
```
public boolean wasPreCreateTableHandlerCalled()
```
  - wasCreateTableHandlerCalled
```
public boolean wasCreateTableHandlerCalled()
```
  - wasCreateTableHandlerCalledOnly
```
public boolean wasCreateTableHandlerCalledOnly()
```
  - preDeleteTableHandler
```
public void preDeleteTableHandler(ObserverContext<MasterCoprocessorEnvironment> env,
                                  TableName tableName)
                           throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called before HMaster deletes a table. Called as part of delete table handler and it is async to the delete RPC call. It can't bypass the default action, e.g., ctx.bypass() won't have effect.
    
    Specified by:
    
    preDeleteTableHandler in interface MasterObserver
    
    Parameters:
    
    env - the environment to interact with the framework and master
    
    tableName - the name of the table
    
    Throws:
    
    java.io.IOException
  - postDeleteTableHandler
```
public void postDeleteTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                   TableName tableName)
                            throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called after HMaster deletes a table. Called as part of delete table handler and it is async to the delete RPC call. It can't bypass the default action, e.g., ctx.bypass() won't have effect.
    
    Specified by:
    
    postDeleteTableHandler in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    tableName - the name of the table
    
    Throws:
    
    java.io.IOException
  - wasDeleteTableHandlerCalled
```
public boolean wasDeleteTableHandlerCalled()
```
  - wasDeleteTableHandlerCalledOnly
```
public boolean wasDeleteTableHandlerCalledOnly()
```
  - preTruncateTableHandler
```
public void preTruncateTableHandler(ObserverContext<MasterCoprocessorEnvironment> env,
                                    TableName tableName)
                             throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called before HMaster truncates a table. Called as part of truncate table handler and it is sync to the truncate RPC call. It can't bypass the default action, e.g., ctx.bypass() won't have effect.
    
    Specified by:
    
    preTruncateTableHandler in interface MasterObserver
    
    Parameters:
    
    env - the environment to interact with the framework and master
    
    tableName - the name of the table
    
    Throws:
    
    java.io.IOException
  - postTruncateTableHandler
```
public void postTruncateTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                     TableName tableName)
                              throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called after HMaster truncates a table. Called as part of truncate table handler and it is sync to the truncate RPC call. It can't bypass the default action, e.g., ctx.bypass() won't have effect.
    
    Specified by:
    
    postTruncateTableHandler in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    tableName - the name of the table
    
    Throws:
    
    java.io.IOException
  - wasTruncateTableHandlerCalled
```
public boolean wasTruncateTableHandlerCalled()
```
  - wasTruncateTableHandlerCalledOnly
```
public boolean wasTruncateTableHandlerCalledOnly()
```
  - preModifyTableHandler
```
public void preModifyTableHandler(ObserverContext<MasterCoprocessorEnvironment> env,
                                  TableName tableName,
                                  HTableDescriptor htd)
                           throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called prior to modifying a table's properties. Called as part of modify table handler 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.
    
    Specified by:
    
    preModifyTableHandler in interface MasterObserver
    
    Parameters:
    
    env - the environment to interact with the framework and master
    
    tableName - the name of the table
    
    htd - the HTableDescriptor
    
    Throws:
    
    java.io.IOException
  - postModifyTableHandler
```
public void postModifyTableHandler(ObserverContext<MasterCoprocessorEnvironment> env,
                                   TableName tableName,
                                   HTableDescriptor htd)
                            throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called after to modifying a table's properties. Called as part of modify table handler 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.
    
    Specified by:
    
    postModifyTableHandler in interface MasterObserver
    
    Parameters:
    
    env - the environment to interact with the framework and master
    
    tableName - the name of the table
    
    htd - the HTableDescriptor
    
    Throws:
    
    java.io.IOException
  - wasModifyTableHandlerCalled
```
public boolean wasModifyTableHandlerCalled()
```
  - wasModifyTableHandlerCalledOnly
```
public boolean wasModifyTableHandlerCalledOnly()
```
  - preAddColumnHandler
```
public void preAddColumnHandler(ObserverContext<MasterCoprocessorEnvironment> env,
                                TableName tableName,
                                HColumnDescriptor column)
                         throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called prior to adding a new column family to the table. Called as part of add column handler.
    
    Specified by:
    
    preAddColumnHandler in interface MasterObserver
    
    Parameters:
    
    env - the environment to interact with the framework and master
    
    tableName - the name of the table
    
    column - the HColumnDescriptor
    
    Throws:
    
    java.io.IOException
  - postAddColumnHandler
```
public void postAddColumnHandler(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                 TableName tableName,
                                 HColumnDescriptor column)
                          throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called after the new column family has been created. Called as part of add column handler.
    
    Specified by:
    
    postAddColumnHandler in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    tableName - the name of the table
    
    column - the HColumnDescriptor
    
    Throws:
    
    java.io.IOException
  - wasAddColumnHandlerCalled
```
public boolean wasAddColumnHandlerCalled()
```
  - preAddColumnHandlerCalledOnly
```
public boolean preAddColumnHandlerCalledOnly()
```
  - preModifyColumnHandler
```
public void preModifyColumnHandler(ObserverContext<MasterCoprocessorEnvironment> env,
                                   TableName tableName,
                                   HColumnDescriptor descriptor)
                            throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called prior to modifying a column family's attributes. Called as part of modify column handler.
    
    Specified by:
    
    preModifyColumnHandler in interface MasterObserver
    
    Parameters:
    
    env - the environment to interact with the framework and master
    
    tableName - the name of the table
    
    descriptor - the HColumnDescriptor
    
    Throws:
    
    java.io.IOException
  - postModifyColumnHandler
```
public void postModifyColumnHandler(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                    TableName tableName,
                                    HColumnDescriptor descriptor)
                             throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called after the column family has been updated. Called as part of modify column handler.
    
    Specified by:
    
    postModifyColumnHandler in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    tableName - the name of the table
    
    descriptor - the HColumnDescriptor
    
    Throws:
    
    java.io.IOException
  - wasModifyColumnHandlerCalled
```
public boolean wasModifyColumnHandlerCalled()
```
  - preModifyColumnHandlerCalledOnly
```
public boolean preModifyColumnHandlerCalledOnly()
```
  - preDeleteColumnHandler
```
public void preDeleteColumnHandler(ObserverContext<MasterCoprocessorEnvironment> env,
                                   TableName tableName,
                                   byte[] c)
                            throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called prior to deleting the entire column family. Called as part of delete column handler.
    
    Specified by:
    
    preDeleteColumnHandler in interface MasterObserver
    
    Parameters:
    
    env - the environment to interact with the framework and master
    
    tableName - the name of the table
    
    c - the column
    
    Throws:
    
    java.io.IOException
  - postDeleteColumnHandler
```
public void postDeleteColumnHandler(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                    TableName tableName,
                                    byte[] c)
                             throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called after the column family has been deleted. Called as part of delete column handler.
    
    Specified by:
    
    postDeleteColumnHandler in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    tableName - the name of the table
    
    c - the column
    
    Throws:
    
    java.io.IOException
  - wasDeleteColumnHandlerCalled
```
public boolean wasDeleteColumnHandlerCalled()
```
  - preDeleteColumnHandlerCalledOnly
```
public boolean preDeleteColumnHandlerCalledOnly()
```
  - preEnableTableHandler
```
public void preEnableTableHandler(ObserverContext<MasterCoprocessorEnvironment> env,
                                  TableName tableName)
                           throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called prior to enabling a table. Called as part of enable table handler 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.
    
    Specified by:
    
    preEnableTableHandler in interface MasterObserver
    
    Parameters:
    
    env - the environment to interact with the framework and master
    
    tableName - the name of the table
    
    Throws:
    
    java.io.IOException
  - postEnableTableHandler
```
public void postEnableTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                   TableName tableName)
                            throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called after the enableTable operation has been requested. Called as part of enable table handler and it is async to the enable table RPC call.
    
    Specified by:
    
    postEnableTableHandler in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    tableName - the name of the table
    
    Throws:
    
    java.io.IOException
  - wasEnableTableHandlerCalled
```
public boolean wasEnableTableHandlerCalled()
```
  - preEnableTableHandlerCalledOnly
```
public boolean preEnableTableHandlerCalledOnly()
```
  - preDisableTableHandler
```
public void preDisableTableHandler(ObserverContext<MasterCoprocessorEnvironment> env,
                                   TableName tableName)
                            throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called prior to disabling a table. Called as part of disable table handler 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.
    
    Specified by:
    
    preDisableTableHandler in interface MasterObserver
    
    Parameters:
    
    env - the environment to interact with the framework and master
    
    tableName - the name of the table
    
    Throws:
    
    java.io.IOException
  - postDisableTableHandler
```
public void postDisableTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                    TableName tableName)
                             throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called after the disableTable operation has been requested. Called as part of disable table handler and it is asyn to the disable table RPC call.
    
    Specified by:
    
    postDisableTableHandler in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    tableName - the name of the table
    
    Throws:
    
    java.io.IOException
  - wasDisableTableHandlerCalled
```
public boolean wasDisableTableHandlerCalled()
```
  - preDisableTableHandlerCalledOnly
```
public boolean preDisableTableHandlerCalledOnly()
```
  - preGetTableDescriptors
```
public void preGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                   java.util.List<TableName> tableNamesList,
                                   java.util.List<HTableDescriptor> descriptors)
                            throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called before a getTableDescriptors request has been processed.
    
    Specified by:
    
    preGetTableDescriptors in interface MasterObserver
    
    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
    
    Throws:
    
    java.io.IOException
  - postGetTableDescriptors
```
public void postGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                    java.util.List<HTableDescriptor> descriptors)
                             throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called after a getTableDescriptors request has been processed.
    
    Specified by:
    
    postGetTableDescriptors in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    descriptors - the list of descriptors about to be returned
    
    Throws:
    
    java.io.IOException
  - preGetTableDescriptors
```
public void preGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                   java.util.List<TableName> tableNamesList,
                                   java.util.List<HTableDescriptor> descriptors,
                                   java.lang.String regex)
                            throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called before a getTableDescriptors request has been processed.
    
    Specified by:
    
    preGetTableDescriptors in interface MasterObserver
    
    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:
    
    java.io.IOException
  - postGetTableDescriptors
```
public void postGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                    java.util.List<TableName> tableNamesList,
                                    java.util.List<HTableDescriptor> descriptors,
                                    java.lang.String regex)
                             throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called after a getTableDescriptors request has been processed.
    
    Specified by:
    
    postGetTableDescriptors in interface MasterObserver
    
    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:
    
    java.io.IOException
  - wasGetTableDescriptorsCalled
```
public boolean wasGetTableDescriptorsCalled()
```
  - preGetTableNames
```
public void preGetTableNames(ObserverContext<MasterCoprocessorEnvironment> ctx,
                             java.util.List<HTableDescriptor> descriptors,
                             java.lang.String regex)
                      throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called before a getTableNames request has been processed.
    
    Specified by:
    
    preGetTableNames in interface MasterObserver
    
    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:
    
    java.io.IOException
  - postGetTableNames
```
public void postGetTableNames(ObserverContext<MasterCoprocessorEnvironment> ctx,
                              java.util.List<HTableDescriptor> descriptors,
                              java.lang.String regex)
                       throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called after a getTableNames request has been processed.
    
    Specified by:
    
    postGetTableNames in interface MasterObserver
    
    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:
    
    java.io.IOException
  - wasGetTableNamesCalled
```
public boolean wasGetTableNamesCalled()
```
  - preTableFlush
```
public void preTableFlush(ObserverContext<MasterCoprocessorEnvironment> ctx,
                          TableName tableName)
                   throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called before the table memstore is flushed to disk.
    
    Specified by:
    
    preTableFlush in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    tableName - the name of the table
    
    Throws:
    
    java.io.IOException
  - postTableFlush
```
public void postTableFlush(ObserverContext<MasterCoprocessorEnvironment> ctx,
                           TableName tableName)
                    throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called after the table memstore is flushed to disk.
    
    Specified by:
    
    postTableFlush in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    tableName - the name of the table
    
    Throws:
    
    java.io.IOException
  - preSetUserQuota
```
public void preSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx,
                            java.lang.String userName,
                            QuotaProtos.Quotas quotas)
                     throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called before the quota for the user is stored.
    
    Specified by:
    
    preSetUserQuota in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    userName - the name of user
    
    quotas - the quota settings
    
    Throws:
    
    java.io.IOException
  - postSetUserQuota
```
public void postSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx,
                             java.lang.String userName,
                             QuotaProtos.Quotas quotas)
                      throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called after the quota for the user is stored.
    
    Specified by:
    
    postSetUserQuota in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    userName - the name of user
    
    quotas - the quota settings
    
    Throws:
    
    java.io.IOException
  - preSetUserQuota
```
public void preSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx,
                            java.lang.String userName,
                            TableName tableName,
                            QuotaProtos.Quotas quotas)
                     throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called before the quota for the user on the specified table is stored.
    
    Specified by:
    
    preSetUserQuota in interface MasterObserver
    
    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:
    
    java.io.IOException
  - postSetUserQuota
```
public void postSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx,
                             java.lang.String userName,
                             TableName tableName,
                             QuotaProtos.Quotas quotas)
                      throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called after the quota for the user on the specified table is stored.
    
    Specified by:
    
    postSetUserQuota in interface MasterObserver
    
    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:
    
    java.io.IOException
  - preSetUserQuota
```
public void preSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx,
                            java.lang.String userName,
                            java.lang.String namespace,
                            QuotaProtos.Quotas quotas)
                     throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called before the quota for the user on the specified namespace is stored.
    
    Specified by:
    
    preSetUserQuota in interface MasterObserver
    
    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:
    
    java.io.IOException
  - postSetUserQuota
```
public void postSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx,
                             java.lang.String userName,
                             java.lang.String namespace,
                             QuotaProtos.Quotas quotas)
                      throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called after the quota for the user on the specified namespace is stored.
    
    Specified by:
    
    postSetUserQuota in interface MasterObserver
    
    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:
    
    java.io.IOException
  - preSetTableQuota
```
public void preSetTableQuota(ObserverContext<MasterCoprocessorEnvironment> ctx,
                             TableName tableName,
                             QuotaProtos.Quotas quotas)
                      throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called before the quota for the table is stored.
    
    Specified by:
    
    preSetTableQuota in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    tableName - the name of the table
    
    quotas - the quota settings
    
    Throws:
    
    java.io.IOException
  - postSetTableQuota
```
public void postSetTableQuota(ObserverContext<MasterCoprocessorEnvironment> ctx,
                              TableName tableName,
                              QuotaProtos.Quotas quotas)
                       throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called after the quota for the table is stored.
    
    Specified by:
    
    postSetTableQuota in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    tableName - the name of the table
    
    quotas - the quota settings
    
    Throws:
    
    java.io.IOException
  - preSetNamespaceQuota
```
public void preSetNamespaceQuota(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                 java.lang.String namespace,
                                 QuotaProtos.Quotas quotas)
                          throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called before the quota for the namespace is stored.
    
    Specified by:
    
    preSetNamespaceQuota in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    namespace - the name of the namespace
    
    quotas - the quota settings
    
    Throws:
    
    java.io.IOException
  - postSetNamespaceQuota
```
public void postSetNamespaceQuota(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                  java.lang.String namespace,
                                  QuotaProtos.Quotas quotas)
                           throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called after the quota for the namespace is stored.
    
    Specified by:
    
    postSetNamespaceQuota in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    namespace - the name of the namespace
    
    quotas - the quota settings
    
    Throws:
    
    java.io.IOException
  - preMoveServers
```
public void preMoveServers(ObserverContext<MasterCoprocessorEnvironment> ctx,
                           java.util.Set<HostAndPort> servers,
                           java.lang.String targetGroup)
                    throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called before servers are moved to target region server group
    
    Specified by:
    
    preMoveServers in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    servers - set of servers to move
    
    targetGroup - destination group
    
    Throws:
    
    java.io.IOException - on failure
  - postMoveServers
```
public void postMoveServers(ObserverContext<MasterCoprocessorEnvironment> ctx,
                            java.util.Set<HostAndPort> servers,
                            java.lang.String targetGroup)
                     throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called after servers are moved to target region server group
    
    Specified by:
    
    postMoveServers in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    servers - set of servers to move
    
    targetGroup - name of group
    
    Throws:
    
    java.io.IOException - on failure
  - preMoveTables
```
public void preMoveTables(ObserverContext<MasterCoprocessorEnvironment> ctx,
                          java.util.Set<TableName> tables,
                          java.lang.String targetGroupGroup)
                   throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called before tables are moved to target region server group
    
    Specified by:
    
    preMoveTables in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    tables - set of tables to move
    
    targetGroupGroup - name of group
    
    Throws:
    
    java.io.IOException - on failure
  - postMoveTables
```
public void postMoveTables(ObserverContext<MasterCoprocessorEnvironment> ctx,
                           java.util.Set<TableName> tables,
                           java.lang.String targetGroup)
                    throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called after servers are moved to target region server group
    
    Specified by:
    
    postMoveTables in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    tables - set of tables to move
    
    targetGroup - name of group
    
    Throws:
    
    java.io.IOException - on failure
  - preAddRSGroup
```
public void preAddRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx,
                          java.lang.String name)
                   throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called before a new region server group is added
    
    Specified by:
    
    preAddRSGroup in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    name - group name
    
    Throws:
    
    java.io.IOException - on failure
  - postAddRSGroup
```
public void postAddRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx,
                           java.lang.String name)
                    throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called after a new region server group is added
    
    Specified by:
    
    postAddRSGroup in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    name - group name
    
    Throws:
    
    java.io.IOException - on failure
  - preRemoveRSGroup
```
public void preRemoveRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx,
                             java.lang.String name)
                      throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called before a region server group is removed
    
    Specified by:
    
    preRemoveRSGroup in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    name - group name
    
    Throws:
    
    java.io.IOException - on failure
  - postRemoveRSGroup
```
public void postRemoveRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx,
                              java.lang.String name)
                       throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called after a region server group is removed
    
    Specified by:
    
    postRemoveRSGroup in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    name - group name
    
    Throws:
    
    java.io.IOException - on failure
  - preBalanceRSGroup
```
public void preBalanceRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx,
                              java.lang.String groupName)
                       throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called before a region server group is removed
    
    Specified by:
    
    preBalanceRSGroup in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    groupName - group name
    
    Throws:
    
    java.io.IOException - on failure
  - postBalanceRSGroup
```
public void postBalanceRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx,
                               java.lang.String groupName,
                               boolean balancerRan)
                        throws java.io.IOException
```
    Description copied from interface: MasterObserver
    
    Called after a region server group is removed
    
    Specified by:
    
    postBalanceRSGroup in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    groupName - group name
    
    Throws:
    
    java.io.IOException - on failure

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

Constructor Detail

CPMasterObserver

Method Detail

enableBypass

resetStates

preCreateTable

postCreateTable

wasCreateTableCalled

preCreateTableCalledOnly

preDeleteTable

postDeleteTable

wasDeleteTableCalled

preDeleteTableCalledOnly

preTruncateTable

postTruncateTable

wasTruncateTableCalled

preTruncateTableCalledOnly

preModifyTable

postModifyTable

wasModifyTableCalled

preModifyTableCalledOnly

preCreateNamespace

postCreateNamespace

wasCreateNamespaceCalled

preCreateNamespaceCalledOnly

preDeleteNamespace

postDeleteNamespace

wasDeleteNamespaceCalled

preDeleteNamespaceCalledOnly

preModifyNamespace

postModifyNamespace

wasModifyNamespaceCalled

preModifyNamespaceCalledOnly

preGetNamespaceDescriptor

postGetNamespaceDescriptor

wasGetNamespaceDescriptorCalled

preListNamespaceDescriptors

postListNamespaceDescriptors

wasListNamespaceDescriptorsCalled

preListNamespaceDescriptorsCalledOnly

preAddColumn

postAddColumn

wasAddColumnCalled

preAddColumnCalledOnly

preModifyColumn

postModifyColumn

wasModifyColumnCalled

preModifyColumnCalledOnly

preDeleteColumn

postDeleteColumn

wasDeleteColumnCalled

preDeleteColumnCalledOnly

preEnableTable

postEnableTable

wasEnableTableCalled

preEnableTableCalledOnly

preDisableTable

postDisableTable

wasDisableTableCalled

preDisableTableCalledOnly

preAbortProcedure

postAbortProcedure

wasAbortProcedureCalled

wasPreAbortProcedureCalledOnly

preListProcedures

postListProcedures

wasListProceduresCalled

wasPreListProceduresCalledOnly

preMove

postMove

wasMoveCalled

preMoveCalledOnly