BaseMasterObserver (Apache HBase

java.lang.Object
- org.apache.hadoop.hbase.coprocessor.BaseMasterObserver

所有已实现的接口:: Coprocessor, MasterObserver

@InterfaceAudience.LimitedPrivate(value={"Coprocesssor","Configuration"})
@InterfaceStability.Evolving
public class BaseMasterObserver
extends Object
implements MasterObserver

嵌套类概要
- 从接口继承的嵌套类/接口 org.apache.hadoop.hbase.Coprocessor
  Coprocessor.State

字段概要
- 从接口继承的字段 org.apache.hadoop.hbase.Coprocessor
  PRIORITY_HIGHEST, PRIORITY_LOWEST, PRIORITY_SYSTEM, PRIORITY_USER, VERSION

构造器概要

构造器
构造器和说明

BaseMasterObserver()

构造器
构造器和说明
`BaseMasterObserver()`

方法概要

方法
限定符和类型	方法和说明
`void`	`postAbortProcedure(ObserverContext<MasterCoprocessorEnvironment> ctx)` Called after a abortProcedure request has been processed.
`void`	`postAddColumn(ObserverContext<MasterCoprocessorEnvironment> ctx, 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, String name)` Called after a new region server group is added
`void`	`postAssign(ObserverContext<MasterCoprocessorEnvironment> ctx, HRegionInfo regionInfo)` Called after the region assignment has been requested.
`void`	`postBalance(ObserverContext<MasterCoprocessorEnvironment> ctx, List<RegionPlan> plans)` Called after the balancing plan has been submitted.
`void`	`postBalanceRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx, String groupName, boolean balancerRan)` Called after a region server group is removed
`void`	`postBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> ctx, boolean oldValue, boolean newValue)` Called after the flag to enable/disable balancing has changed.
`void`	`postClearDeadServers(ObserverContext<MasterCoprocessorEnvironment> ctx, List<ServerName> servers, List<ServerName> notClearedServers)` Called after clear dead region servers.
`void`	`postCloneSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.SnapshotDescription snapshot, HTableDescriptor hTableDescriptor)` Called after a snapshot clone operation has been requested.
`void`	`postCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns)` Called after the createNamespace operation has been requested.
`void`	`postCreateTable(ObserverContext<MasterCoprocessorEnvironment> ctx, 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> ctx, 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> ctx, String namespace)` Called after the deleteNamespace operation has been requested.
`void`	`postDeleteSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.SnapshotDescription snapshot)` Called after the delete snapshot operation has been requested.
`void`	`postDeleteTable(ObserverContext<MasterCoprocessorEnvironment> ctx, 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> ctx, 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`	`postDispatchMerge(ObserverContext<MasterCoprocessorEnvironment> ctx, HRegionInfo regionA, HRegionInfo regionB)` called after dispatching the region merge request.
`void`	`postEnableTable(ObserverContext<MasterCoprocessorEnvironment> ctx, 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`	`postGetClusterStatus(ObserverContext<MasterCoprocessorEnvironment> ctx, ClusterStatus status)` Called after get cluster status.
`void`	`postGetNamespaceDescriptor(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns)` Called after a getNamespaceDescriptor request has been processed.
`void`	`postGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx, List<HTableDescriptor> descriptors)` Called after a getTableDescriptors request has been processed.
`void`	`postGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx, List<TableName> tableNamesList, List<HTableDescriptor> descriptors, String regex)` Called after a getTableDescriptors request has been processed.
`void`	`postGetTableNames(ObserverContext<MasterCoprocessorEnvironment> ctx, List<HTableDescriptor> descriptors, String regex)` Called after a getTableNames request has been processed.
`void`	`postListNamespaceDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx, List<NamespaceDescriptor> descriptors)` Called after a listNamespaceDescriptors request has been processed.
`void`	`postListProcedures(ObserverContext<MasterCoprocessorEnvironment> ctx, List<ProcedureInfo> procInfoList)` Called after a listProcedures request has been processed.
`void`	`postListSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.SnapshotDescription snapshot)` Called after listSnapshots request has been processed.
`void`	`postModifyColumn(ObserverContext<MasterCoprocessorEnvironment> ctx, 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> ctx, NamespaceDescriptor ns)` Called after the modifyNamespace operation has been requested.
`void`	`postModifyTable(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, HTableDescriptor htd)` Called after the modifyTable operation has been requested.
`void`	`postModifyTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, HTableDescriptor htd)` Called after to modifying a table's properties.
`void`	`postMove(ObserverContext<MasterCoprocessorEnvironment> ctx, HRegionInfo region, ServerName srcServer, ServerName destServer)` Called after the region move has been requested.
`void`	`postMoveServers(ObserverContext<MasterCoprocessorEnvironment> ctx, Set<Address> servers, String targetGroup)` Called after servers are moved to target region server group
`void`	`postMoveServersAndTables(ObserverContext<MasterCoprocessorEnvironment> ctx, Set<Address> servers, Set<TableName> tables, String targetGroup)` Called after servers are moved to target region server group
`void`	`postMoveTables(ObserverContext<MasterCoprocessorEnvironment> ctx, Set<TableName> tables, String targetGroup)` Called after servers are moved to target region server group
`void`	`postRegionOffline(ObserverContext<MasterCoprocessorEnvironment> ctx, HRegionInfo regionInfo)` Called after the region has been marked offline.
`void`	`postRemoveRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx, String name)` Called after a region server group is removed
`void`	`postRemoveServers(ObserverContext<MasterCoprocessorEnvironment> ctx, Set<Address> servers)` Called after servers are removed from rsgroup
`void`	`postRestoreSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.SnapshotDescription snapshot, HTableDescriptor hTableDescriptor)` Called after a snapshot restore operation has been requested.
`void`	`postSetNamespaceQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace, org.apache.hadoop.hbase.protobuf.generated.QuotaProtos.Quotas quotas)` Called after the quota for the namespace is stored.
`void`	`postSetSplitOrMergeEnabled(ObserverContext<MasterCoprocessorEnvironment> ctx, boolean newValue, Admin.MasterSwitchType switchType)` Called after setting split / merge switch
`void`	`postSetTableQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, org.apache.hadoop.hbase.protobuf.generated.QuotaProtos.Quotas quotas)` Called after the quota for the table is stored.
`void`	`postSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, String userName, org.apache.hadoop.hbase.protobuf.generated.QuotaProtos.Quotas quotas)` Called after the quota for the user is stored.
`void`	`postSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, String userName, String namespace, org.apache.hadoop.hbase.protobuf.generated.QuotaProtos.Quotas quotas)` Called after the quota for the user on the specified namespace is stored.
`void`	`postSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, String userName, TableName tableName, org.apache.hadoop.hbase.protobuf.generated.QuotaProtos.Quotas quotas)` Called after the quota for the user on the specified table is stored.
`void`	`postSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, org.apache.hadoop.hbase.protobuf.generated.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> ctx, 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> ctx, 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> ctx, TableName tableName, HColumnDescriptor column)` Called prior to adding a new column family to the table.
`void`	`preAddColumnHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, HColumnDescriptor column)` Called prior to adding a new column family to the table.
`void`	`preAddRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx, String name)` Called before a new region server group is added
`void`	`preAssign(ObserverContext<MasterCoprocessorEnvironment> ctx, HRegionInfo regionInfo)` Called prior to assigning a specific region.
`void`	`preBalance(ObserverContext<MasterCoprocessorEnvironment> ctx)` Called prior to requesting rebalancing of the cluster regions, though after the initial checks for regions in transition and the balance switch flag.
`void`	`preBalanceRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx, String groupName)` Called before a region server group is removed
`boolean`	`preBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> ctx, boolean b)` Called prior to modifying the flag used to enable/disable region balancing.
`void`	`preClearDeadServers(ObserverContext<MasterCoprocessorEnvironment> ctx)` Called before clear dead region servers.
`void`	`preCloneSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.SnapshotDescription snapshot, HTableDescriptor hTableDescriptor)` Called before a snapshot is cloned.
`void`	`preCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns)` Called before a new namespace is created by `HMaster`.
`void`	`preCreateTable(ObserverContext<MasterCoprocessorEnvironment> ctx, HTableDescriptor desc, HRegionInfo[] regions)` Called before a new table is created by `HMaster`.
`void`	`preCreateTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, HTableDescriptor desc, HRegionInfo[] regions)` Called before a new table is created by `HMaster`.
`void`	`preDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, byte[] c)` Called prior to deleting the entire column family.
`void`	`preDeleteColumnHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, byte[] c)` Called prior to deleting the entire column family.
`void`	`preDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace)` Called before `HMaster` deletes a namespace It can't bypass the default action, e.g., ctx.bypass() won't have effect.
`void`	`preDeleteSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.SnapshotDescription snapshot)` Called before a snapshot is deleted.
`void`	`preDeleteTable(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)` Called before `HMaster` deletes a table.
`void`	`preDeleteTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)` Called before `HMaster` deletes a table.
`void`	`preDisableTable(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)` Called prior to disabling a table.
`void`	`preDisableTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)` Called prior to disabling a table.
`void`	`preDispatchMerge(ObserverContext<MasterCoprocessorEnvironment> ctx, HRegionInfo regionA, HRegionInfo regionB)` Called before dispatching region merge request.
`void`	`preEnableTable(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)` Called prior to enabling a table.
`void`	`preEnableTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)` Called prior to enabling a table.
`void`	`preGetClusterStatus(ObserverContext<MasterCoprocessorEnvironment> ctx)` Called before get cluster status.
`void`	`preGetNamespaceDescriptor(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace)` Called before a getNamespaceDescriptor request has been processed.
`void`	`preGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx, List<TableName> tableNamesList, List<HTableDescriptor> descriptors)` Called before a getTableDescriptors request has been processed.
`void`	`preGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx, List<TableName> tableNamesList, List<HTableDescriptor> descriptors, String regex)` Called before a getTableDescriptors request has been processed.
`void`	`preGetTableNames(ObserverContext<MasterCoprocessorEnvironment> ctx, List<HTableDescriptor> descriptors, String regex)` Called before a getTableNames request has been processed.
`void`	`preListNamespaceDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx, List<NamespaceDescriptor> descriptors)` Called before a listNamespaceDescriptors request has been processed.
`void`	`preListProcedures(ObserverContext<MasterCoprocessorEnvironment> ctx)` Called before a listProcedures request has been processed.
`void`	`preListSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, org.apache.hadoop.hbase.protobuf.generated.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> ctx, TableName tableName, HColumnDescriptor descriptor)` Called prior to modifying a column family's attributes.
`void`	`preModifyColumnHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, HColumnDescriptor descriptor)` Called prior to modifying a column family's attributes.
`void`	`preModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns)` Called prior to modifying a namespace's properties.
`void`	`preModifyTable(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, HTableDescriptor htd)` Called prior to modifying a table's properties.
`void`	`preModifyTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, HTableDescriptor htd)` Called prior to modifying a table's properties.
`void`	`preMove(ObserverContext<MasterCoprocessorEnvironment> ctx, HRegionInfo region, ServerName srcServer, ServerName destServer)` Called prior to moving a given region from one region server to another.
`void`	`preMoveServers(ObserverContext<MasterCoprocessorEnvironment> ctx, Set<Address> servers, String targetGroup)` Called before servers are moved to target region server group
`void`	`preMoveServersAndTables(ObserverContext<MasterCoprocessorEnvironment> ctx, Set<Address> servers, Set<TableName> tables, String targetGroup)` Called before servers are moved to target region server group
`void`	`preMoveTables(ObserverContext<MasterCoprocessorEnvironment> ctx, Set<TableName> tables, String targetGroup)` Called before tables are moved to target region server group
`void`	`preRegionOffline(ObserverContext<MasterCoprocessorEnvironment> ctx, HRegionInfo regionInfo)` Called prior to marking a given region as offline.
`void`	`preRemoveRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx, String name)` Called before a region server group is removed
`void`	`preRemoveServers(ObserverContext<MasterCoprocessorEnvironment> ctx, Set<Address> servers)` Called before servers are removed from rsgroup
`void`	`preRestoreSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.SnapshotDescription snapshot, HTableDescriptor hTableDescriptor)` Called before a snapshot is restored.
`void`	`preSetNamespaceQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace, org.apache.hadoop.hbase.protobuf.generated.QuotaProtos.Quotas quotas)` Called before the quota for the namespace is stored.
`boolean`	`preSetSplitOrMergeEnabled(ObserverContext<MasterCoprocessorEnvironment> ctx, boolean newValue, Admin.MasterSwitchType switchType)` Called prior to setting split / merge switch
`void`	`preSetTableQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, org.apache.hadoop.hbase.protobuf.generated.QuotaProtos.Quotas quotas)` Called before the quota for the table is stored.
`void`	`preSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, String userName, org.apache.hadoop.hbase.protobuf.generated.QuotaProtos.Quotas quotas)` Called before the quota for the user is stored.
`void`	`preSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, String userName, String namespace, org.apache.hadoop.hbase.protobuf.generated.QuotaProtos.Quotas quotas)` Called before the quota for the user on the specified namespace is stored.
`void`	`preSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, String userName, TableName tableName, org.apache.hadoop.hbase.protobuf.generated.QuotaProtos.Quotas quotas)` Called before the quota for the user on the specified table is stored.
`void`	`preShutdown(ObserverContext<MasterCoprocessorEnvironment> ctx)` Called prior to shutting down the full HBase cluster, including this `HMaster` process.
`void`	`preSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.SnapshotDescription snapshot, HTableDescriptor hTableDescriptor)` Called before a new snapshot is taken.
`void`	`preStopMaster(ObserverContext<MasterCoprocessorEnvironment> ctx)` 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> ctx, TableName tableName)` Called before `HMaster` truncates a table.
`void`	`preTruncateTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)` Called before `HMaster` truncates a table.
`void`	`preUnassign(ObserverContext<MasterCoprocessorEnvironment> ctx, HRegionInfo regionInfo, boolean force)` Called prior to unassigning a given region.
`void`	`start(CoprocessorEnvironment ctx)`
`void`	`stop(CoprocessorEnvironment ctx)`

从类继承的方法 java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- 构造器详细资料
  - BaseMasterObserver
```
public BaseMasterObserver()
```
- 方法详细资料
  - preCreateTable
```
public void preCreateTable(ObserverContext<MasterCoprocessorEnvironment> ctx,
                  HTableDescriptor desc,
                  HRegionInfo[] regions)
                    throws IOException
```
    从接口复制的说明: 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.
    
    指定者:
    
    preCreateTable 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    desc - the HTableDescriptor for the table
    regions - the initial regions created for the table
    
    抛出:
    
    IOException
  - postCreateTable
```
public void postCreateTable(ObserverContext<MasterCoprocessorEnvironment> ctx,
                   HTableDescriptor desc,
                   HRegionInfo[] regions)
                     throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called after the createTable operation has been requested. Called as part of create table RPC call.
    
    指定者:
    
    postCreateTable 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    desc - the HTableDescriptor for the table
    regions - the initial regions created for the table
    
    抛出:
    
    IOException
  - preCreateTableHandler
```
public void preCreateTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx,
                         HTableDescriptor desc,
                         HRegionInfo[] regions)
                           throws IOException
```
    从接口复制的说明: 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.
    
    指定者:
    
    preCreateTableHandler 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    desc - the HTableDescriptor for the table
    regions - the initial regions created for the table
    
    抛出:
    
    IOException
  - postCreateTableHandler
```
public void postCreateTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx,
                          HTableDescriptor desc,
                          HRegionInfo[] regions)
                            throws IOException
```
    从接口复制的说明: 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.
    
    指定者:
    
    postCreateTableHandler 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    desc - the HTableDescriptor for the table
    regions - the initial regions created for the table
    
    抛出:
    
    IOException
  - preDispatchMerge
```
public void preDispatchMerge(ObserverContext<MasterCoprocessorEnvironment> ctx,
                    HRegionInfo regionA,
                    HRegionInfo regionB)
                      throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before dispatching region merge request. It can't bypass the default action, e.g., ctx.bypass() won't have effect.
    
    指定者:
    
    preDispatchMerge 在接口中 MasterObserver
    
    参数:
    ctx - coprocessor environment
    regionA - first region to be merged
    regionB - second region to be merged
    
    抛出:
    
    IOException - if an error occurred on the coprocessor
  - postDispatchMerge
```
public void postDispatchMerge(ObserverContext<MasterCoprocessorEnvironment> ctx,
                     HRegionInfo regionA,
                     HRegionInfo regionB)
                       throws IOException
```
    从接口复制的说明: MasterObserver
    
    called after dispatching the region merge request.
    
    指定者:
    
    postDispatchMerge 在接口中 MasterObserver
    
    参数:
    ctx - coprocessor environment
    regionA - first region to be merged
    regionB - second region to be merged
    
    抛出:
    
    IOException - if an error occurred on the coprocessor
  - preGetClusterStatus
```
public void preGetClusterStatus(ObserverContext<MasterCoprocessorEnvironment> ctx)
                         throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before get cluster status.
    
    指定者:
    
    preGetClusterStatus 在接口中 MasterObserver
    
    抛出:
    
    IOException
  - postGetClusterStatus
```
public void postGetClusterStatus(ObserverContext<MasterCoprocessorEnvironment> ctx,
                        ClusterStatus status)
                          throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called after get cluster status.
    
    指定者:
    
    postGetClusterStatus 在接口中 MasterObserver
    
    抛出:
    
    IOException
  - preClearDeadServers
```
public void preClearDeadServers(ObserverContext<MasterCoprocessorEnvironment> ctx)
                         throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before clear dead region servers.
    
    指定者:
    
    preClearDeadServers 在接口中 MasterObserver
    
    抛出:
    
    IOException
  - postClearDeadServers
```
public void postClearDeadServers(ObserverContext<MasterCoprocessorEnvironment> ctx,
                        List<ServerName> servers,
                        List<ServerName> notClearedServers)
                          throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called after clear dead region servers.
    
    指定者:
    
    postClearDeadServers 在接口中 MasterObserver
    
    抛出:
    
    IOException
  - preDeleteTable
```
public void preDeleteTable(ObserverContext<MasterCoprocessorEnvironment> ctx,
                  TableName tableName)
                    throws IOException
```
    从接口复制的说明: 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.
    
    指定者:
    
    preDeleteTable 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    tableName - the name of the table
    
    抛出:
    
    IOException
  - postDeleteTable
```
public void postDeleteTable(ObserverContext<MasterCoprocessorEnvironment> ctx,
                   TableName tableName)
                     throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called after the deleteTable operation has been requested. Called as part of delete table RPC call.
    
    指定者:
    
    postDeleteTable 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    tableName - the name of the table
    
    抛出:
    
    IOException
  - preDeleteTableHandler
```
public void preDeleteTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx,
                         TableName tableName)
                           throws IOException
```
    从接口复制的说明: 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.
    
    指定者:
    
    preDeleteTableHandler 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    tableName - the name of the table
    
    抛出:
    
    IOException
  - postDeleteTableHandler
```
public void postDeleteTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx,
                          TableName tableName)
                            throws IOException
```
    从接口复制的说明: 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.
    
    指定者:
    
    postDeleteTableHandler 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    tableName - the name of the table
    
    抛出:
    
    IOException
  - preTruncateTable
```
public void preTruncateTable(ObserverContext<MasterCoprocessorEnvironment> ctx,
                    TableName tableName)
                      throws IOException
```
    从接口复制的说明: 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.
    
    指定者:
    
    preTruncateTable 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    tableName - the name of the table
    
    抛出:
    
    IOException
  - postTruncateTable
```
public void postTruncateTable(ObserverContext<MasterCoprocessorEnvironment> ctx,
                     TableName tableName)
                       throws IOException
```
    从接口复制的说明: 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.
    
    指定者:
    
    postTruncateTable 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    tableName - the name of the table
    
    抛出:
    
    IOException
  - preTruncateTableHandler
```
public void preTruncateTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx,
                           TableName tableName)
                             throws IOException
```
    从接口复制的说明: 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.
    
    指定者:
    
    preTruncateTableHandler 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    tableName - the name of the table
    
    抛出:
    
    IOException
  - postTruncateTableHandler
```
public void postTruncateTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx,
                            TableName tableName)
                              throws IOException
```
    从接口复制的说明: 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.
    
    指定者:
    
    postTruncateTableHandler 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    tableName - the name of the table
    
    抛出:
    
    IOException
  - preModifyTable
```
public void preModifyTable(ObserverContext<MasterCoprocessorEnvironment> ctx,
                  TableName tableName,
                  HTableDescriptor htd)
                    throws IOException
```
    从接口复制的说明: 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.
    
    指定者:
    
    preModifyTable 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    tableName - the name of the table
    htd - the HTableDescriptor
    
    抛出:
    
    IOException
  - postModifyTableHandler
```
public void postModifyTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx,
                          TableName tableName,
                          HTableDescriptor htd)
                            throws IOException
```
    从接口复制的说明: 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.
    
    指定者:
    
    postModifyTableHandler 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    tableName - the name of the table
    htd - the HTableDescriptor
    
    抛出:
    
    IOException
  - preModifyTableHandler
```
public void preModifyTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx,
                         TableName tableName,
                         HTableDescriptor htd)
                           throws IOException
```
    从接口复制的说明: 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.
    
    指定者:
    
    preModifyTableHandler 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    tableName - the name of the table
    htd - the HTableDescriptor
    
    抛出:
    
    IOException
  - postModifyTable
```
public void postModifyTable(ObserverContext<MasterCoprocessorEnvironment> ctx,
                   TableName tableName,
                   HTableDescriptor htd)
                     throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called after the modifyTable operation has been requested. Called as part of modify table RPC call.
    
    指定者:
    
    postModifyTable 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    tableName - the name of the table
    htd - the HTableDescriptor
    
    抛出:
    
    IOException
  - preCreateNamespace
```
public void preCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
                      NamespaceDescriptor ns)
                        throws IOException
```
    从接口复制的说明: 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.
    
    指定者:
    
    preCreateNamespace 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    ns - the NamespaceDescriptor for the table
    
    抛出:
    
    IOException
  - postCreateNamespace
```
public void postCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
                       NamespaceDescriptor ns)
                         throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called after the createNamespace operation has been requested.
    
    指定者:
    
    postCreateNamespace 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    ns - the NamespaceDescriptor for the table
    
    抛出:
    
    IOException
  - preDeleteNamespace
```
public void preDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
                      String namespace)
                        throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before HMaster deletes a namespace It can't bypass the default action, e.g., ctx.bypass() won't have effect.
    
    指定者:
    
    preDeleteNamespace 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    namespace - the name of the namespace
    
    抛出:
    
    IOException
  - postDeleteNamespace
```
public void postDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
                       String namespace)
                         throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called after the deleteNamespace operation has been requested.
    
    指定者:
    
    postDeleteNamespace 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    namespace - the name of the namespace
    
    抛出:
    
    IOException
  - preModifyNamespace
```
public void preModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
                      NamespaceDescriptor ns)
                        throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called prior to modifying a namespace's properties. It can't bypass the default action, e.g., ctx.bypass() won't have effect.
    
    指定者:
    
    preModifyNamespace 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    ns - the NamespaceDescriptor
    
    抛出:
    
    IOException
  - postModifyNamespace
```
public void postModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
                       NamespaceDescriptor ns)
                         throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called after the modifyNamespace operation has been requested.
    
    指定者:
    
    postModifyNamespace 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    ns - the NamespaceDescriptor
    
    抛出:
    
    IOException
  - preGetNamespaceDescriptor
```
public void preGetNamespaceDescriptor(ObserverContext<MasterCoprocessorEnvironment> ctx,
                             String namespace)
                               throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before a getNamespaceDescriptor request has been processed.
    
    指定者:
    
    preGetNamespaceDescriptor 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    namespace - the name of the namespace
    
    抛出:
    
    IOException
  - postGetNamespaceDescriptor
```
public void postGetNamespaceDescriptor(ObserverContext<MasterCoprocessorEnvironment> ctx,
                              NamespaceDescriptor ns)
                                throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called after a getNamespaceDescriptor request has been processed.
    
    指定者:
    
    postGetNamespaceDescriptor 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    ns - the NamespaceDescriptor
    
    抛出:
    
    IOException
  - preListNamespaceDescriptors
```
public void preListNamespaceDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
                               List<NamespaceDescriptor> descriptors)
                                 throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before a listNamespaceDescriptors request has been processed.
    
    指定者:
    
    preListNamespaceDescriptors 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    descriptors - an empty list, can be filled with what to return if bypassing
    
    抛出:
    
    IOException
  - postListNamespaceDescriptors
```
public void postListNamespaceDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                List<NamespaceDescriptor> descriptors)
                                  throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called after a listNamespaceDescriptors request has been processed.
    
    指定者:
    
    postListNamespaceDescriptors 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    descriptors - the list of descriptors about to be returned
    
    抛出:
    
    IOException
  - preAddColumn
```
public void preAddColumn(ObserverContext<MasterCoprocessorEnvironment> ctx,
                TableName tableName,
                HColumnDescriptor column)
                  throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called prior to adding a new column family to the table. Called as part of add column RPC call.
    
    指定者:
    
    preAddColumn 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    tableName - the name of the table
    column - the HColumnDescriptor
    
    抛出:
    
    IOException
  - postAddColumn
```
public void postAddColumn(ObserverContext<MasterCoprocessorEnvironment> ctx,
                 TableName tableName,
                 HColumnDescriptor column)
                   throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called after the new column family has been created. Called as part of add column RPC call.
    
    指定者:
    
    postAddColumn 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    tableName - the name of the table
    column - the HColumnDescriptor
    
    抛出:
    
    IOException
  - preAddColumnHandler
```
public void preAddColumnHandler(ObserverContext<MasterCoprocessorEnvironment> ctx,
                       TableName tableName,
                       HColumnDescriptor column)
                         throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called prior to adding a new column family to the table. Called as part of add column handler.
    
    指定者:
    
    preAddColumnHandler 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    tableName - the name of the table
    column - the HColumnDescriptor
    
    抛出:
    
    IOException
  - postAddColumnHandler
```
public void postAddColumnHandler(ObserverContext<MasterCoprocessorEnvironment> ctx,
                        TableName tableName,
                        HColumnDescriptor column)
                          throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called after the new column family has been created. Called as part of add column handler.
    
    指定者:
    
    postAddColumnHandler 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    tableName - the name of the table
    column - the HColumnDescriptor
    
    抛出:
    
    IOException
  - preModifyColumn
```
public void preModifyColumn(ObserverContext<MasterCoprocessorEnvironment> ctx,
                   TableName tableName,
                   HColumnDescriptor descriptor)
                     throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called prior to modifying a column family's attributes. Called as part of modify column RPC call.
    
    指定者:
    
    preModifyColumn 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    tableName - the name of the table
    descriptor - the HColumnDescriptor
    
    抛出:
    
    IOException
  - postModifyColumn
```
public void postModifyColumn(ObserverContext<MasterCoprocessorEnvironment> ctx,
                    TableName tableName,
                    HColumnDescriptor descriptor)
                      throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called after the column family has been updated. Called as part of modify column RPC call.
    
    指定者:
    
    postModifyColumn 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    tableName - the name of the table
    descriptor - the HColumnDescriptor
    
    抛出:
    
    IOException
  - preModifyColumnHandler
```
public void preModifyColumnHandler(ObserverContext<MasterCoprocessorEnvironment> ctx,
                          TableName tableName,
                          HColumnDescriptor descriptor)
                            throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called prior to modifying a column family's attributes. Called as part of modify column handler.
    
    指定者:
    
    preModifyColumnHandler 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    tableName - the name of the table
    descriptor - the HColumnDescriptor
    
    抛出:
    
    IOException
  - postModifyColumnHandler
```
public void postModifyColumnHandler(ObserverContext<MasterCoprocessorEnvironment> ctx,
                           TableName tableName,
                           HColumnDescriptor descriptor)
                             throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called after the column family has been updated. Called as part of modify column handler.
    
    指定者:
    
    postModifyColumnHandler 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    tableName - the name of the table
    descriptor - the HColumnDescriptor
    
    抛出:
    
    IOException
  - preDeleteColumn
```
public void preDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> ctx,
                   TableName tableName,
                   byte[] c)
                     throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called prior to deleting the entire column family. Called as part of delete column RPC call.
    
    指定者:
    
    preDeleteColumn 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    tableName - the name of the table
    c - the column
    
    抛出:
    
    IOException
  - postDeleteColumn
```
public void postDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> ctx,
                    TableName tableName,
                    byte[] c)
                      throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called after the column family has been deleted. Called as part of delete column RPC call.
    
    指定者:
    
    postDeleteColumn 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    tableName - the name of the table
    c - the column
    
    抛出:
    
    IOException
  - preDeleteColumnHandler
```
public void preDeleteColumnHandler(ObserverContext<MasterCoprocessorEnvironment> ctx,
                          TableName tableName,
                          byte[] c)
                            throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called prior to deleting the entire column family. Called as part of delete column handler.
    
    指定者:
    
    preDeleteColumnHandler 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    tableName - the name of the table
    c - the column
    
    抛出:
    
    IOException
  - postDeleteColumnHandler
```
public void postDeleteColumnHandler(ObserverContext<MasterCoprocessorEnvironment> ctx,
                           TableName tableName,
                           byte[] c)
                             throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called after the column family has been deleted. Called as part of delete column handler.
    
    指定者:
    
    postDeleteColumnHandler 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    tableName - the name of the table
    c - the column
    
    抛出:
    
    IOException
  - preEnableTable
```
public void preEnableTable(ObserverContext<MasterCoprocessorEnvironment> ctx,
                  TableName tableName)
                    throws IOException
```
    从接口复制的说明: 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.
    
    指定者:
    
    preEnableTable 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    tableName - the name of the table
    
    抛出:
    
    IOException
  - postEnableTable
```
public void postEnableTable(ObserverContext<MasterCoprocessorEnvironment> ctx,
                   TableName tableName)
                     throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called after the enableTable operation has been requested. Called as part of enable table RPC call.
    
    指定者:
    
    postEnableTable 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    tableName - the name of the table
    
    抛出:
    
    IOException
  - preEnableTableHandler
```
public void preEnableTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx,
                         TableName tableName)
                           throws IOException
```
    从接口复制的说明: 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.
    
    指定者:
    
    preEnableTableHandler 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    tableName - the name of the table
    
    抛出:
    
    IOException
  - postEnableTableHandler
```
public void postEnableTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx,
                          TableName tableName)
                            throws IOException
```
    从接口复制的说明: 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.
    
    指定者:
    
    postEnableTableHandler 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    tableName - the name of the table
    
    抛出:
    
    IOException
  - preDisableTable
```
public void preDisableTable(ObserverContext<MasterCoprocessorEnvironment> ctx,
                   TableName tableName)
                     throws IOException
```
    从接口复制的说明: 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.
    
    指定者:
    
    preDisableTable 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    tableName - the name of the table
    
    抛出:
    
    IOException
  - postDisableTable
```
public void postDisableTable(ObserverContext<MasterCoprocessorEnvironment> ctx,
                    TableName tableName)
                      throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called after the disableTable operation has been requested. Called as part of disable table RPC call.
    
    指定者:
    
    postDisableTable 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    tableName - the name of the table
    
    抛出:
    
    IOException
  - preDisableTableHandler
```
public void preDisableTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx,
                          TableName tableName)
                            throws IOException
```
    从接口复制的说明: 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.
    
    指定者:
    
    preDisableTableHandler 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    tableName - the name of the table
    
    抛出:
    
    IOException
  - postDisableTableHandler
```
public void postDisableTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx,
                           TableName tableName)
                             throws IOException
```
    从接口复制的说明: 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.
    
    指定者:
    
    postDisableTableHandler 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    tableName - the name of the table
    
    抛出:
    
    IOException
  - preAbortProcedure
```
public void preAbortProcedure(ObserverContext<MasterCoprocessorEnvironment> ctx,
                     ProcedureExecutor<MasterProcedureEnv> procEnv,
                     long procId)
                       throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before a abortProcedure request has been processed.
    
    指定者:
    
    preAbortProcedure 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    
    抛出:
    
    IOException
  - postAbortProcedure
```
public void postAbortProcedure(ObserverContext<MasterCoprocessorEnvironment> ctx)
                        throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called after a abortProcedure request has been processed.
    
    指定者:
    
    postAbortProcedure 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    
    抛出:
    
    IOException
  - preListProcedures
```
public void preListProcedures(ObserverContext<MasterCoprocessorEnvironment> ctx)
                       throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before a listProcedures request has been processed.
    
    指定者:
    
    preListProcedures 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    
    抛出:
    
    IOException
  - postListProcedures
```
public void postListProcedures(ObserverContext<MasterCoprocessorEnvironment> ctx,
                      List<ProcedureInfo> procInfoList)
                        throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called after a listProcedures request has been processed.
    
    指定者:
    
    postListProcedures 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    procInfoList - the list of procedures about to be returned
    
    抛出:
    
    IOException
  - preAssign
```
public void preAssign(ObserverContext<MasterCoprocessorEnvironment> ctx,
             HRegionInfo regionInfo)
               throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called prior to assigning a specific region.
    
    指定者:
    
    preAssign 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    regionInfo - the regionInfo of the region
    
    抛出:
    
    IOException
  - postAssign
```
public void postAssign(ObserverContext<MasterCoprocessorEnvironment> ctx,
              HRegionInfo regionInfo)
                throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called after the region assignment has been requested.
    
    指定者:
    
    postAssign 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    regionInfo - the regionInfo of the region
    
    抛出:
    
    IOException
  - preUnassign
```
public void preUnassign(ObserverContext<MasterCoprocessorEnvironment> ctx,
               HRegionInfo regionInfo,
               boolean force)
                 throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called prior to unassigning a given region.
    
    指定者:
    
    preUnassign 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    force - whether to force unassignment or not
    
    抛出:
    
    IOException
  - postUnassign
```
public void postUnassign(ObserverContext<MasterCoprocessorEnvironment> ctx,
                HRegionInfo regionInfo,
                boolean force)
                  throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called after the region unassignment has been requested.
    
    指定者:
    
    postUnassign 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    force - whether to force unassignment or not
    
    抛出:
    
    IOException
  - preRegionOffline
```
public void preRegionOffline(ObserverContext<MasterCoprocessorEnvironment> ctx,
                    HRegionInfo regionInfo)
                      throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called prior to marking a given region as offline. ctx.bypass() will not have any impact on this hook.
    
    指定者:
    
    preRegionOffline 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    
    抛出:
    
    IOException
  - postRegionOffline
```
public void postRegionOffline(ObserverContext<MasterCoprocessorEnvironment> ctx,
                     HRegionInfo regionInfo)
                       throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called after the region has been marked offline.
    
    指定者:
    
    postRegionOffline 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    
    抛出:
    
    IOException
  - preSetSplitOrMergeEnabled
```
public boolean preSetSplitOrMergeEnabled(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                boolean newValue,
                                Admin.MasterSwitchType switchType)
                                  throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called prior to setting split / merge switch
    
    指定者:
    
    preSetSplitOrMergeEnabled 在接口中 MasterObserver
    
    参数:
    ctx - the coprocessor instance's environment
    newValue - the new value submitted in the call
    switchType - type of switch
    
    抛出:
    
    IOException
  - postSetSplitOrMergeEnabled
```
public void postSetSplitOrMergeEnabled(ObserverContext<MasterCoprocessorEnvironment> ctx,
                              boolean newValue,
                              Admin.MasterSwitchType switchType)
                                throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called after setting split / merge switch
    
    指定者:
    
    postSetSplitOrMergeEnabled 在接口中 MasterObserver
    
    参数:
    ctx - the coprocessor instance's environment
    newValue - the new value submitted in the call
    switchType - type of switch
    
    抛出:
    
    IOException
  - preBalance
```
public void preBalance(ObserverContext<MasterCoprocessorEnvironment> ctx)
                throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called prior to requesting rebalancing of the cluster regions, though after the initial checks for regions in transition and the balance switch flag.
    
    指定者:
    
    preBalance 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    
    抛出:
    
    IOException
  - postBalance
```
public void postBalance(ObserverContext<MasterCoprocessorEnvironment> ctx,
               List<RegionPlan> plans)
                 throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called after the balancing plan has been submitted.
    
    指定者:
    
    postBalance 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    plans - the RegionPlans which master has executed. RegionPlan serves as hint as for the final destination for the underlying region but may not represent the final state of assignment
    
    抛出:
    
    IOException
  - preBalanceSwitch
```
public boolean preBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> ctx,
                       boolean b)
                         throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called prior to modifying the flag used to enable/disable region balancing.
    
    指定者:
    
    preBalanceSwitch 在接口中 MasterObserver
    
    参数:
    ctx - the coprocessor instance's environment
    b - the new flag value submitted in the call
    
    抛出:
    
    IOException
  - postBalanceSwitch
```
public void postBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> ctx,
                     boolean oldValue,
                     boolean newValue)
                       throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called after the flag to enable/disable balancing has changed.
    
    指定者:
    
    postBalanceSwitch 在接口中 MasterObserver
    
    参数:
    ctx - the coprocessor instance's environment
    oldValue - the previously set balanceSwitch value
    newValue - the newly set balanceSwitch value
    
    抛出:
    
    IOException
  - preShutdown
```
public void preShutdown(ObserverContext<MasterCoprocessorEnvironment> ctx)
                 throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called prior to shutting down the full HBase cluster, including this HMaster process.
    
    指定者:
    
    preShutdown 在接口中 MasterObserver
    
    抛出:
    
    IOException
  - preStopMaster
```
public void preStopMaster(ObserverContext<MasterCoprocessorEnvironment> ctx)
                   throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called immediately prior to stopping this HMaster process.
    
    指定者:
    
    preStopMaster 在接口中 MasterObserver
    
    抛出:
    
    IOException
  - postStartMaster
```
public void postStartMaster(ObserverContext<MasterCoprocessorEnvironment> ctx)
                     throws IOException
```
    从接口复制的说明: 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.
    
    指定者:
    
    postStartMaster 在接口中 MasterObserver
    
    抛出:
    
    IOException
  - preMasterInitialization
```
public void preMasterInitialization(ObserverContext<MasterCoprocessorEnvironment> ctx)
                             throws IOException
```
    从接口复制的说明: MasterObserver
    
    Call before the master initialization is set to true. HMaster process.
    
    指定者:
    
    preMasterInitialization 在接口中 MasterObserver
    
    抛出:
    
    IOException
  - start
```
public void start(CoprocessorEnvironment ctx)
           throws IOException
```
    指定者:
    
    start 在接口中 Coprocessor
    
    抛出:
    
    IOException
  - stop
```
public void stop(CoprocessorEnvironment ctx)
          throws IOException
```
    指定者:
    
    stop 在接口中 Coprocessor
    
    抛出:
    
    IOException
  - preMove
```
public void preMove(ObserverContext<MasterCoprocessorEnvironment> ctx,
           HRegionInfo region,
           ServerName srcServer,
           ServerName destServer)
             throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called prior to moving a given region from one region server to another.
    
    指定者:
    
    preMove 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    region - the HRegionInfo
    srcServer - the source ServerName
    destServer - the destination ServerName
    
    抛出:
    
    IOException
  - postMove
```
public void postMove(ObserverContext<MasterCoprocessorEnvironment> ctx,
            HRegionInfo region,
            ServerName srcServer,
            ServerName destServer)
              throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called after the region move has been requested.
    
    指定者:
    
    postMove 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    region - the HRegionInfo
    srcServer - the source ServerName
    destServer - the destination ServerName
    
    抛出:
    
    IOException
  - preSnapshot
```
public void preSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
               org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.SnapshotDescription snapshot,
               HTableDescriptor hTableDescriptor)
                 throws IOException
```
    从接口复制的说明: 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.
    
    指定者:
    
    preSnapshot 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    snapshot - the SnapshotDescriptor for the snapshot
    hTableDescriptor - the hTableDescriptor of the table to snapshot
    
    抛出:
    
    IOException
  - postSnapshot
```
public void postSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
                org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.SnapshotDescription snapshot,
                HTableDescriptor hTableDescriptor)
                  throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called after the snapshot operation has been requested. Called as part of snapshot RPC call.
    
    指定者:
    
    postSnapshot 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    snapshot - the SnapshotDescriptor for the snapshot
    hTableDescriptor - the hTableDescriptor of the table to snapshot
    
    抛出:
    
    IOException
  - preListSnapshot
```
public void preListSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
                   org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.SnapshotDescription snapshot)
                     throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before listSnapshots request has been processed. It can't bypass the default action, e.g., ctx.bypass() won't have effect.
    
    指定者:
    
    preListSnapshot 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    snapshot - the SnapshotDescriptor of the snapshot to list
    
    抛出:
    
    IOException
  - postListSnapshot
```
public void postListSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
                    org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.SnapshotDescription snapshot)
                      throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called after listSnapshots request has been processed. It can't bypass the default action, e.g., ctx.bypass() won't have effect.
    
    指定者:
    
    postListSnapshot 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    snapshot - the SnapshotDescriptor of the snapshot to list
    
    抛出:
    
    IOException
  - preCloneSnapshot
```
public void preCloneSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
                    org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.SnapshotDescription snapshot,
                    HTableDescriptor hTableDescriptor)
                      throws IOException
```
    从接口复制的说明: 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.
    
    指定者:
    
    preCloneSnapshot 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    snapshot - the SnapshotDescriptor for the snapshot
    hTableDescriptor - the hTableDescriptor of the table to create
    
    抛出:
    
    IOException
  - postCloneSnapshot
```
public void postCloneSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
                     org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.SnapshotDescription snapshot,
                     HTableDescriptor hTableDescriptor)
                       throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called after a snapshot clone operation has been requested. Called as part of restoreSnapshot RPC call.
    
    指定者:
    
    postCloneSnapshot 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    snapshot - the SnapshotDescriptor for the snapshot
    hTableDescriptor - the hTableDescriptor of the table to create
    
    抛出:
    
    IOException
  - preRestoreSnapshot
```
public void preRestoreSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
                      org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.SnapshotDescription snapshot,
                      HTableDescriptor hTableDescriptor)
                        throws IOException
```
    从接口复制的说明: 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.
    
    指定者:
    
    preRestoreSnapshot 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    snapshot - the SnapshotDescriptor for the snapshot
    hTableDescriptor - the hTableDescriptor of the table to restore
    
    抛出:
    
    IOException
  - postRestoreSnapshot
```
public void postRestoreSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
                       org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.SnapshotDescription snapshot,
                       HTableDescriptor hTableDescriptor)
                         throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called after a snapshot restore operation has been requested. Called as part of restoreSnapshot RPC call.
    
    指定者:
    
    postRestoreSnapshot 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    snapshot - the SnapshotDescriptor for the snapshot
    hTableDescriptor - the hTableDescriptor of the table to restore
    
    抛出:
    
    IOException
  - preDeleteSnapshot
```
public void preDeleteSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
                     org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.SnapshotDescription snapshot)
                       throws IOException
```
    从接口复制的说明: 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.
    
    指定者:
    
    preDeleteSnapshot 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    snapshot - the SnapshotDescriptor of the snapshot to delete
    
    抛出:
    
    IOException
  - postDeleteSnapshot
```
public void postDeleteSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
                      org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.SnapshotDescription snapshot)
                        throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called after the delete snapshot operation has been requested. Called as part of deleteSnapshot RPC call.
    
    指定者:
    
    postDeleteSnapshot 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    snapshot - the SnapshotDescriptor of the snapshot to delete
    
    抛出:
    
    IOException
  - preGetTableDescriptors
```
public void preGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
                          List<TableName> tableNamesList,
                          List<HTableDescriptor> descriptors)
                            throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before a getTableDescriptors request has been processed.
    
    指定者:
    
    preGetTableDescriptors 在接口中 MasterObserver
    
    参数:
    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
    
    抛出:
    
    IOException
  - postGetTableDescriptors
```
public void postGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
                           List<HTableDescriptor> descriptors)
                             throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called after a getTableDescriptors request has been processed.
    
    指定者:
    
    postGetTableDescriptors 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    descriptors - the list of descriptors about to be returned
    
    抛出:
    
    IOException
  - preGetTableDescriptors
```
public void preGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
                          List<TableName> tableNamesList,
                          List<HTableDescriptor> descriptors,
                          String regex)
                            throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before a getTableDescriptors request has been processed.
    
    指定者:
    
    preGetTableDescriptors 在接口中 MasterObserver
    
    参数:
    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
    
    抛出:
    
    IOException
  - postGetTableDescriptors
```
public void postGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
                           List<TableName> tableNamesList,
                           List<HTableDescriptor> descriptors,
                           String regex)
                             throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called after a getTableDescriptors request has been processed.
    
    指定者:
    
    postGetTableDescriptors 在接口中 MasterObserver
    
    参数:
    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
    
    抛出:
    
    IOException
  - preGetTableNames
```
public void preGetTableNames(ObserverContext<MasterCoprocessorEnvironment> ctx,
                    List<HTableDescriptor> descriptors,
                    String regex)
                      throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before a getTableNames request has been processed.
    
    指定者:
    
    preGetTableNames 在接口中 MasterObserver
    
    参数:
    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
    
    抛出:
    
    IOException
  - postGetTableNames
```
public void postGetTableNames(ObserverContext<MasterCoprocessorEnvironment> ctx,
                     List<HTableDescriptor> descriptors,
                     String regex)
                       throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called after a getTableNames request has been processed.
    
    指定者:
    
    postGetTableNames 在接口中 MasterObserver
    
    参数:
    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
    
    抛出:
    
    IOException
  - preTableFlush
```
public void preTableFlush(ObserverContext<MasterCoprocessorEnvironment> ctx,
                 TableName tableName)
                   throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before the table memstore is flushed to disk.
    
    指定者:
    
    preTableFlush 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    tableName - the name of the table
    
    抛出:
    
    IOException
  - postTableFlush
```
public void postTableFlush(ObserverContext<MasterCoprocessorEnvironment> ctx,
                  TableName tableName)
                    throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called after the table memstore is flushed to disk.
    
    指定者:
    
    postTableFlush 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    tableName - the name of the table
    
    抛出:
    
    IOException
  - preSetUserQuota
```
public void preSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx,
                   String userName,
                   org.apache.hadoop.hbase.protobuf.generated.QuotaProtos.Quotas quotas)
                     throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before the quota for the user is stored.
    
    指定者:
    
    preSetUserQuota 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    userName - the name of user
    quotas - the quota settings
    
    抛出:
    
    IOException
  - postSetUserQuota
```
public void postSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx,
                    String userName,
                    org.apache.hadoop.hbase.protobuf.generated.QuotaProtos.Quotas quotas)
                      throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called after the quota for the user is stored.
    
    指定者:
    
    postSetUserQuota 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    userName - the name of user
    quotas - the quota settings
    
    抛出:
    
    IOException
  - preSetUserQuota
```
public void preSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx,
                   String userName,
                   TableName tableName,
                   org.apache.hadoop.hbase.protobuf.generated.QuotaProtos.Quotas quotas)
                     throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before the quota for the user on the specified table is stored.
    
    指定者:
    
    preSetUserQuota 在接口中 MasterObserver
    
    参数:
    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
    
    抛出:
    
    IOException
  - postSetUserQuota
```
public void postSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx,
                    String userName,
                    TableName tableName,
                    org.apache.hadoop.hbase.protobuf.generated.QuotaProtos.Quotas quotas)
                      throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called after the quota for the user on the specified table is stored.
    
    指定者:
    
    postSetUserQuota 在接口中 MasterObserver
    
    参数:
    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
    
    抛出:
    
    IOException
  - preSetUserQuota
```
public void preSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx,
                   String userName,
                   String namespace,
                   org.apache.hadoop.hbase.protobuf.generated.QuotaProtos.Quotas quotas)
                     throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before the quota for the user on the specified namespace is stored.
    
    指定者:
    
    preSetUserQuota 在接口中 MasterObserver
    
    参数:
    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
    
    抛出:
    
    IOException
  - postSetUserQuota
```
public void postSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx,
                    String userName,
                    String namespace,
                    org.apache.hadoop.hbase.protobuf.generated.QuotaProtos.Quotas quotas)
                      throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called after the quota for the user on the specified namespace is stored.
    
    指定者:
    
    postSetUserQuota 在接口中 MasterObserver
    
    参数:
    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
    
    抛出:
    
    IOException
  - preSetTableQuota
```
public void preSetTableQuota(ObserverContext<MasterCoprocessorEnvironment> ctx,
                    TableName tableName,
                    org.apache.hadoop.hbase.protobuf.generated.QuotaProtos.Quotas quotas)
                      throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before the quota for the table is stored.
    
    指定者:
    
    preSetTableQuota 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    tableName - the name of the table
    quotas - the quota settings
    
    抛出:
    
    IOException
  - postSetTableQuota
```
public void postSetTableQuota(ObserverContext<MasterCoprocessorEnvironment> ctx,
                     TableName tableName,
                     org.apache.hadoop.hbase.protobuf.generated.QuotaProtos.Quotas quotas)
                       throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called after the quota for the table is stored.
    
    指定者:
    
    postSetTableQuota 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    tableName - the name of the table
    quotas - the quota settings
    
    抛出:
    
    IOException
  - preSetNamespaceQuota
```
public void preSetNamespaceQuota(ObserverContext<MasterCoprocessorEnvironment> ctx,
                        String namespace,
                        org.apache.hadoop.hbase.protobuf.generated.QuotaProtos.Quotas quotas)
                          throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before the quota for the namespace is stored.
    
    指定者:
    
    preSetNamespaceQuota 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    namespace - the name of the namespace
    quotas - the quota settings
    
    抛出:
    
    IOException
  - postSetNamespaceQuota
```
public void postSetNamespaceQuota(ObserverContext<MasterCoprocessorEnvironment> ctx,
                         String namespace,
                         org.apache.hadoop.hbase.protobuf.generated.QuotaProtos.Quotas quotas)
                           throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called after the quota for the namespace is stored.
    
    指定者:
    
    postSetNamespaceQuota 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    namespace - the name of the namespace
    quotas - the quota settings
    
    抛出:
    
    IOException
  - preMoveServers
```
public void preMoveServers(ObserverContext<MasterCoprocessorEnvironment> ctx,
                  Set<Address> servers,
                  String targetGroup)
                    throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before servers are moved to target region server group
    
    指定者:
    
    preMoveServers 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    servers - set of servers to move
    targetGroup - destination group
    
    抛出:
    
    IOException
  - postMoveServers
```
public void postMoveServers(ObserverContext<MasterCoprocessorEnvironment> ctx,
                   Set<Address> servers,
                   String targetGroup)
                     throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called after servers are moved to target region server group
    
    指定者:
    
    postMoveServers 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    servers - set of servers to move
    targetGroup - name of group
    
    抛出:
    
    IOException - on failure
  - preMoveTables
```
public void preMoveTables(ObserverContext<MasterCoprocessorEnvironment> ctx,
                 Set<TableName> tables,
                 String targetGroup)
                   throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before tables are moved to target region server group
    
    指定者:
    
    preMoveTables 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    tables - set of tables to move
    targetGroup - name of group
    
    抛出:
    
    IOException - on failure
  - postMoveTables
```
public void postMoveTables(ObserverContext<MasterCoprocessorEnvironment> ctx,
                  Set<TableName> tables,
                  String targetGroup)
                    throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called after servers are moved to target region server group
    
    指定者:
    
    postMoveTables 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    tables - set of tables to move
    targetGroup - name of group
    
    抛出:
    
    IOException - on failure
  - preMoveServersAndTables
```
public void preMoveServersAndTables(ObserverContext<MasterCoprocessorEnvironment> ctx,
                           Set<Address> servers,
                           Set<TableName> tables,
                           String targetGroup)
                             throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before servers are moved to target region server group
    
    指定者:
    
    preMoveServersAndTables 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    servers - set of servers to move
    targetGroup - destination group
    
    抛出:
    
    IOException - on failure
  - postMoveServersAndTables
```
public void postMoveServersAndTables(ObserverContext<MasterCoprocessorEnvironment> ctx,
                            Set<Address> servers,
                            Set<TableName> tables,
                            String targetGroup)
                              throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called after servers are moved to target region server group
    
    指定者:
    
    postMoveServersAndTables 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    servers - set of servers to move
    targetGroup - name of group
    
    抛出:
    
    IOException
  - preAddRSGroup
```
public void preAddRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx,
                 String name)
                   throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before a new region server group is added
    
    指定者:
    
    preAddRSGroup 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    name - group name
    
    抛出:
    
    IOException - on failure
  - postAddRSGroup
```
public void postAddRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx,
                  String name)
                    throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called after a new region server group is added
    
    指定者:
    
    postAddRSGroup 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    name - group name
    
    抛出:
    
    IOException - on failure
  - preRemoveRSGroup
```
public void preRemoveRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx,
                    String name)
                      throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before a region server group is removed
    
    指定者:
    
    preRemoveRSGroup 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    name - group name
    
    抛出:
    
    IOException - on failure
  - postRemoveRSGroup
```
public void postRemoveRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx,
                     String name)
                       throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called after a region server group is removed
    
    指定者:
    
    postRemoveRSGroup 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    name - group name
    
    抛出:
    
    IOException - on failure
  - preRemoveServers
```
public void preRemoveServers(ObserverContext<MasterCoprocessorEnvironment> ctx,
                    Set<Address> servers)
                      throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before servers are removed from rsgroup
    
    指定者:
    
    preRemoveServers 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    servers - set of decommissioned servers to remove
    
    抛出:
    
    IOException
  - postRemoveServers
```
public void postRemoveServers(ObserverContext<MasterCoprocessorEnvironment> ctx,
                     Set<Address> servers)
                       throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called after servers are removed from rsgroup
    
    指定者:
    
    postRemoveServers 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    servers - set of servers to remove
    
    抛出:
    
    IOException
  - preBalanceRSGroup
```
public void preBalanceRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx,
                     String groupName)
                       throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before a region server group is removed
    
    指定者:
    
    preBalanceRSGroup 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    groupName - group name
    
    抛出:
    
    IOException - on failure
  - postBalanceRSGroup
```
public void postBalanceRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx,
                      String groupName,
                      boolean balancerRan)
                        throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called after a region server group is removed
    
    指定者:
    
    postBalanceRSGroup 在接口中 MasterObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    groupName - group name
    
    抛出:
    
    IOException - on failure

类 BaseMasterObserver

嵌套类概要

从接口继承的嵌套类/接口 org.apache.hadoop.hbase.Coprocessor

字段概要

从接口继承的字段 org.apache.hadoop.hbase.Coprocessor

构造器概要

方法概要

从类继承的方法 java.lang.Object

构造器详细资料

BaseMasterObserver

方法详细资料

preCreateTable

postCreateTable

preCreateTableHandler

postCreateTableHandler

preDispatchMerge

postDispatchMerge

preGetClusterStatus

postGetClusterStatus

preClearDeadServers

postClearDeadServers

preDeleteTable

postDeleteTable

preDeleteTableHandler

postDeleteTableHandler

preTruncateTable

postTruncateTable

preTruncateTableHandler

postTruncateTableHandler

preModifyTable

postModifyTableHandler

preModifyTableHandler

postModifyTable

preCreateNamespace

postCreateNamespace

preDeleteNamespace

postDeleteNamespace

preModifyNamespace

postModifyNamespace

preGetNamespaceDescriptor

postGetNamespaceDescriptor

preListNamespaceDescriptors

postListNamespaceDescriptors

preAddColumn

postAddColumn

preAddColumnHandler

postAddColumnHandler

preModifyColumn

postModifyColumn

preModifyColumnHandler

postModifyColumnHandler

preDeleteColumn

postDeleteColumn

preDeleteColumnHandler

postDeleteColumnHandler

preEnableTable

postEnableTable

preEnableTableHandler

postEnableTableHandler

preDisableTable

postDisableTable

preDisableTableHandler

postDisableTableHandler

preAbortProcedure

postAbortProcedure

preListProcedures

postListProcedures

preAssign

postAssign

preUnassign

postUnassign

preRegionOffline

postRegionOffline

preSetSplitOrMergeEnabled

postSetSplitOrMergeEnabled

preBalance

postBalance

preBalanceSwitch

postBalanceSwitch

preShutdown