Method Detail

• preCreateTable

  void preCreateTable(ObserverContext<MasterCoprocessorEnvironment> ctx,
                    HTableDescriptor desc,
                    HRegionInfo[] regions)
                      throws IOException

  Called before a new table is created by HMaster. Called as part of create table RPC call. It can't bypass the default action, e.g., ctx.bypass() won't have effect.

  Parameters:

  ctx - the environment to interact with the framework and master

  desc - the HTableDescriptor for the table

  regions - the initial regions created for the table

  Throws:

  IOException

• postCreateTable

  void postCreateTable(ObserverContext<MasterCoprocessorEnvironment> ctx,
                     HTableDescriptor desc,
                     HRegionInfo[] regions)
                       throws IOException

  Called after the createTable operation has been requested. Called as part of create table RPC call.

  Parameters:

  ctx - the environment to interact with the framework and master

  desc - the HTableDescriptor for the table

  regions - the initial regions created for the table

  Throws:

  IOException

• preCreateTableHandler

  void preCreateTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx,
                           HTableDescriptor desc,
                           HRegionInfo[] regions)
                             throws IOException

  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.

  Parameters:

  ctx - the environment to interact with the framework and master

  desc - the HTableDescriptor for the table

  regions - the initial regions created for the table

  Throws:

  IOException

• postCreateTableHandler

  void postCreateTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx,
                            HTableDescriptor desc,
                            HRegionInfo[] regions)
                              throws IOException

  Called after the createTable operation has been requested. Called as part of create table RPC call. Called as part of create table handler and it is async to the create RPC call.

  Parameters:

  ctx - the environment to interact with the framework and master

  desc - the HTableDescriptor for the table

  regions - the initial regions created for the table

  Throws:

  IOException

• preDeleteTable

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

  Called before HMaster deletes a table. Called as part of delete table RPC call. It can't bypass the default action, e.g., ctx.bypass() won't have effect.

  Parameters:

  ctx - the environment to interact with the framework and master

  tableName - the name of the table

  Throws:

  IOException

• postDeleteTable

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

  Called after the deleteTable operation has been requested. Called as part of delete table RPC call.

  Parameters:

  ctx - the environment to interact with the framework and master

  tableName - the name of the table

  Throws:

  IOException

• preDeleteTableHandler

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

  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.

  Parameters:

  ctx - the environment to interact with the framework and master

  tableName - the name of the table

  Throws:

  IOException

• postDeleteTableHandler

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

  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.

  Parameters:

  ctx - the environment to interact with the framework and master

  tableName - the name of the table

  Throws:

  IOException

• preTruncateTable

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

  Called before HMaster truncates a table. Called as part of truncate table RPC call. It can't bypass the default action, e.g., ctx.bypass() won't have effect.

  Parameters:

  ctx - the environment to interact with the framework and master

  tableName - the name of the table

  Throws:

  IOException

• postTruncateTable

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

  Called after the truncateTable operation has been requested. Called as part of truncate table RPC call. The truncate is synchronous, so this method will be called when the truncate operation is terminated.

  Parameters:

  ctx - the environment to interact with the framework and master

  tableName - the name of the table

  Throws:

  IOException

• preTruncateTableHandler

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

  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.

  Parameters:

  ctx - the environment to interact with the framework and master

  tableName - the name of the table

  Throws:

  IOException

• postTruncateTableHandler

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

  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.

  Parameters:

  ctx - the environment to interact with the framework and master

  tableName - the name of the table

  Throws:

  IOException

• preModifyTable

  void preModifyTable(ObserverContext<MasterCoprocessorEnvironment> ctx,
                    TableName tableName,
                    HTableDescriptor htd)
                      throws IOException

  Called prior to modifying a table's properties. Called as part of modify table RPC call. It can't bypass the default action, e.g., ctx.bypass() won't have effect.

  Parameters:

  ctx - the environment to interact with the framework and master

  tableName - the name of the table

  htd - the HTableDescriptor

  Throws:

  IOException

• postModifyTable

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

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

  Parameters:

  ctx - the environment to interact with the framework and master

  tableName - the name of the table

  htd - the HTableDescriptor

  Throws:

  IOException

• preModifyTableHandler

  void preModifyTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx,
                           TableName tableName,
                           HTableDescriptor htd)
                             throws IOException

  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.

  Parameters:

  ctx - the environment to interact with the framework and master

  tableName - the name of the table

  htd - the HTableDescriptor

  Throws:

  IOException

• postModifyTableHandler

  void postModifyTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx,
                            TableName tableName,
                            HTableDescriptor htd)
                              throws IOException

  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.

  Parameters:

  ctx - the environment to interact with the framework and master

  tableName - the name of the table

  htd - the HTableDescriptor

  Throws:

  IOException

• preAddColumn

  void preAddColumn(ObserverContext<MasterCoprocessorEnvironment> ctx,
                  TableName tableName,
                  HColumnDescriptor column)
                    throws IOException

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

  Parameters:

  ctx - the environment to interact with the framework and master

  tableName - the name of the table

  column - the HColumnDescriptor

  Throws:

  IOException

• postAddColumn

  void postAddColumn(ObserverContext<MasterCoprocessorEnvironment> ctx,
                   TableName tableName,
                   HColumnDescriptor column)
                     throws IOException

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

  Parameters:

  ctx - the environment to interact with the framework and master

  tableName - the name of the table

  column - the HColumnDescriptor

  Throws:

  IOException

• preAddColumnHandler

  void preAddColumnHandler(ObserverContext<MasterCoprocessorEnvironment> ctx,
                         TableName tableName,
                         HColumnDescriptor column)
                           throws IOException

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

  Parameters:

  ctx - the environment to interact with the framework and master

  tableName - the name of the table

  column - the HColumnDescriptor

  Throws:

  IOException

• postAddColumnHandler

  void postAddColumnHandler(ObserverContext<MasterCoprocessorEnvironment> ctx,
                          TableName tableName,
                          HColumnDescriptor column)
                            throws IOException

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

  Parameters:

  ctx - the environment to interact with the framework and master

  tableName - the name of the table

  column - the HColumnDescriptor

  Throws:

  IOException

• preModifyColumn

  void preModifyColumn(ObserverContext<MasterCoprocessorEnvironment> ctx,
                     TableName tableName,
                     HColumnDescriptor descriptor)
                       throws IOException

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

  Parameters:

  ctx - the environment to interact with the framework and master

  tableName - the name of the table

  descriptor - the HColumnDescriptor

  Throws:

  IOException

• postModifyColumn

  void postModifyColumn(ObserverContext<MasterCoprocessorEnvironment> ctx,
                      TableName tableName,
                      HColumnDescriptor descriptor)
                        throws IOException

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

  Parameters:

  ctx - the environment to interact with the framework and master

  tableName - the name of the table

  descriptor - the HColumnDescriptor

  Throws:

  IOException

• preModifyColumnHandler

  void preModifyColumnHandler(ObserverContext<MasterCoprocessorEnvironment> ctx,
                            TableName tableName,
                            HColumnDescriptor descriptor)
                              throws IOException

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

  Parameters:

  ctx - the environment to interact with the framework and master

  tableName - the name of the table

  descriptor - the HColumnDescriptor

  Throws:

  IOException

• postModifyColumnHandler

  void postModifyColumnHandler(ObserverContext<MasterCoprocessorEnvironment> ctx,
                             TableName tableName,
                             HColumnDescriptor descriptor)
                               throws IOException

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

  Parameters:

  ctx - the environment to interact with the framework and master

  tableName - the name of the table

  descriptor - the HColumnDescriptor

  Throws:

  IOException

• preDeleteColumn

  void preDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> ctx,
                     TableName tableName,
                     byte[] c)
                       throws IOException

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

  Parameters:

  ctx - the environment to interact with the framework and master

  tableName - the name of the table

  c - the column

  Throws:

  IOException

• postDeleteColumn

  void postDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> ctx,
                      TableName tableName,
                      byte[] c)
                        throws IOException

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

  Parameters:

  ctx - the environment to interact with the framework and master

  tableName - the name of the table

  c - the column

  Throws:

  IOException

• preDeleteColumnHandler

  void preDeleteColumnHandler(ObserverContext<MasterCoprocessorEnvironment> ctx,
                            TableName tableName,
                            byte[] c)
                              throws IOException

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

  Parameters:

  ctx - the environment to interact with the framework and master

  tableName - the name of the table

  c - the column

  Throws:

  IOException

• postDeleteColumnHandler

  void postDeleteColumnHandler(ObserverContext<MasterCoprocessorEnvironment> ctx,
                             TableName tableName,
                             byte[] c)
                               throws IOException

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

  Parameters:

  ctx - the environment to interact with the framework and master

  tableName - the name of the table

  c - the column

  Throws:

  IOException

• preEnableTable

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

  Called prior to enabling a table. Called as part of enable table RPC call. It can't bypass the default action, e.g., ctx.bypass() won't have effect.

  Parameters:

  ctx - the environment to interact with the framework and master

  tableName - the name of the table

  Throws:

  IOException

• postEnableTable

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

  Called after the enableTable operation has been requested. Called as part of enable table RPC call.

  Parameters:

  ctx - the environment to interact with the framework and master

  tableName - the name of the table

  Throws:

  IOException

• preEnableTableHandler

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

  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.

  Parameters:

  ctx - the environment to interact with the framework and master

  tableName - the name of the table

  Throws:

  IOException

• postEnableTableHandler

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

  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.

  Parameters:

  ctx - the environment to interact with the framework and master

  tableName - the name of the table

  Throws:

  IOException

• preDisableTable

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

  Called prior to disabling a table. Called as part of disable table RPC call. It can't bypass the default action, e.g., ctx.bypass() won't have effect.

  Parameters:

  ctx - the environment to interact with the framework and master

  tableName - the name of the table

  Throws:

  IOException

• postDisableTable

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

  Called after the disableTable operation has been requested. Called as part of disable table RPC call.

  Parameters:

  ctx - the environment to interact with the framework and master

  tableName - the name of the table

  Throws:

  IOException

• preDisableTableHandler

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

  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.

  Parameters:

  ctx - the environment to interact with the framework and master

  tableName - the name of the table

  Throws:

  IOException

• postDisableTableHandler

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

  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.

  Parameters:

  ctx - the environment to interact with the framework and master

  tableName - the name of the table

  Throws:

  IOException

• preMove

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

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

  Parameters:

  ctx - the environment to interact with the framework and master

  region - the HRegionInfo

  srcServer - the source ServerName

  destServer - the destination ServerName

  Throws:

  IOException

• postMove

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

  Called after the region move has been requested.

  Parameters:

  ctx - the environment to interact with the framework and master

  region - the HRegionInfo

  srcServer - the source ServerName

  destServer - the destination ServerName

  Throws:

  IOException

• preAbortProcedure

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

  Called before a abortProcedure request has been processed.

  Parameters:

  ctx - the environment to interact with the framework and master

  Throws:

  IOException

• postAbortProcedure

  void postAbortProcedure(ObserverContext<MasterCoprocessorEnvironment> ctx)
                          throws IOException

  Called after a abortProcedure request has been processed.

  Parameters:

  ctx - the environment to interact with the framework and master

  Throws:

  IOException

• preListProcedures

  void preListProcedures(ObserverContext<MasterCoprocessorEnvironment> ctx)
                         throws IOException

  Called before a listProcedures request has been processed.

  Parameters:

  ctx - the environment to interact with the framework and master

  Throws:

  IOException

• postListProcedures

  void postListProcedures(ObserverContext<MasterCoprocessorEnvironment> ctx,
                        List<ProcedureInfo> procInfoList)
                          throws IOException

  Called after a listProcedures request has been processed.

  Parameters:

  ctx - the environment to interact with the framework and master

  procInfoList - the list of procedures about to be returned

  Throws:

  IOException

• preAssign

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

  Called prior to assigning a specific region.

  Parameters:

  ctx - the environment to interact with the framework and master

  regionInfo - the regionInfo of the region

  Throws:

  IOException

• postAssign

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

  Called after the region assignment has been requested.

  Parameters:

  ctx - the environment to interact with the framework and master

  regionInfo - the regionInfo of the region

  Throws:

  IOException

• preUnassign

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

  Called prior to unassigning a given region.

  Parameters:

  ctx - the environment to interact with the framework and master

  regionInfo -

  force - whether to force unassignment or not

  Throws:

  IOException

• postUnassign

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

  Called after the region unassignment has been requested.

  Parameters:

  ctx - the environment to interact with the framework and master

  regionInfo -

  force - whether to force unassignment or not

  Throws:

  IOException

• preRegionOffline

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

  Called prior to marking a given region as offline. ctx.bypass() will not have any impact on this hook.

  Parameters:

  ctx - the environment to interact with the framework and master

  regionInfo -

  Throws:

  IOException

• postRegionOffline

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

  Called after the region has been marked offline.

  Parameters:

  ctx - the environment to interact with the framework and master

  regionInfo -

  Throws:

  IOException

• preBalance

  void preBalance(ObserverContext<MasterCoprocessorEnvironment> ctx)
                  throws IOException

  Called prior to requesting rebalancing of the cluster regions, though after the initial checks for regions in transition and the balance switch flag.

  Parameters:

  ctx - the environment to interact with the framework and master

  Throws:

  IOException

• postBalance

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

  Called after the balancing plan has been submitted.

  Parameters:

  ctx - the environment to interact with the framework and master

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

  Throws:

  IOException

• preBalanceSwitch

  boolean preBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> ctx,
                         boolean newValue)
                           throws IOException

  Called prior to modifying the flag used to enable/disable region balancing.

  Parameters:

  ctx - the coprocessor instance's environment

  newValue - the new flag value submitted in the call

  Throws:

  IOException

• postBalanceSwitch

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

  Called after the flag to enable/disable balancing has changed.

  Parameters:

  ctx - the coprocessor instance's environment

  oldValue - the previously set balanceSwitch value

  newValue - the newly set balanceSwitch value

  Throws:

  IOException

• preShutdown

  void preShutdown(ObserverContext<MasterCoprocessorEnvironment> ctx)
                   throws IOException

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

  Throws:

  IOException

• preStopMaster

  void preStopMaster(ObserverContext<MasterCoprocessorEnvironment> ctx)
                     throws IOException

  Called immediately prior to stopping this HMaster process.

  Throws:

  IOException

• postStartMaster

  void postStartMaster(ObserverContext<MasterCoprocessorEnvironment> ctx)
                       throws IOException

  Called immediately after an active master instance has completed initialization. Will not be called on standby master instances unless they take over the active role.

  Throws:

  IOException

• preMasterInitialization

  void preMasterInitialization(ObserverContext<MasterCoprocessorEnvironment> ctx)
                               throws IOException

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

  Throws:

  IOException

• preSnapshot

  void preSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
                 org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.SnapshotDescription snapshot,
                 HTableDescriptor hTableDescriptor)
                   throws IOException

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

  Parameters:

  ctx - the environment to interact with the framework and master

  snapshot - the SnapshotDescriptor for the snapshot

  hTableDescriptor - the hTableDescriptor of the table to snapshot

  Throws:

  IOException

• postSnapshot

  void postSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
                  org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.SnapshotDescription snapshot,
                  HTableDescriptor hTableDescriptor)
                    throws IOException

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

  Parameters:

  ctx - the environment to interact with the framework and master

  snapshot - the SnapshotDescriptor for the snapshot

  hTableDescriptor - the hTableDescriptor of the table to snapshot

  Throws:

  IOException

• preListSnapshot

  void preListSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
                     org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.SnapshotDescription snapshot)
                       throws IOException

  Called before listSnapshots request has been processed. It can't bypass the default action, e.g., ctx.bypass() won't have effect.

  Parameters:

  ctx - the environment to interact with the framework and master

  snapshot - the SnapshotDescriptor of the snapshot to list

  Throws:

  IOException

• postListSnapshot

  void postListSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
                      org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.SnapshotDescription snapshot)
                        throws IOException

  Called after listSnapshots request has been processed. It can't bypass the default action, e.g., ctx.bypass() won't have effect.

  Parameters:

  ctx - the environment to interact with the framework and master

  snapshot - the SnapshotDescriptor of the snapshot to list

  Throws:

  IOException

• preCloneSnapshot

  void preCloneSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
                      org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.SnapshotDescription snapshot,
                      HTableDescriptor hTableDescriptor)
                        throws IOException

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

  Parameters:

  ctx - the environment to interact with the framework and master

  snapshot - the SnapshotDescriptor for the snapshot

  hTableDescriptor - the hTableDescriptor of the table to create

  Throws:

  IOException

• postCloneSnapshot

  void postCloneSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
                       org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.SnapshotDescription snapshot,
                       HTableDescriptor hTableDescriptor)
                         throws IOException

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

  Parameters:

  ctx - the environment to interact with the framework and master

  snapshot - the SnapshotDescriptor for the snapshot

  hTableDescriptor - the hTableDescriptor of the table to create

  Throws:

  IOException

• preRestoreSnapshot

  void preRestoreSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
                        org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.SnapshotDescription snapshot,
                        HTableDescriptor hTableDescriptor)
                          throws IOException

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

  Parameters:

  ctx - the environment to interact with the framework and master

  snapshot - the SnapshotDescriptor for the snapshot

  hTableDescriptor - the hTableDescriptor of the table to restore

  Throws:

  IOException

• postRestoreSnapshot

  void postRestoreSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
                         org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.SnapshotDescription snapshot,
                         HTableDescriptor hTableDescriptor)
                           throws IOException

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

  Parameters:

  ctx - the environment to interact with the framework and master

  snapshot - the SnapshotDescriptor for the snapshot

  hTableDescriptor - the hTableDescriptor of the table to restore

  Throws:

  IOException

• preDeleteSnapshot

  void preDeleteSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
                       org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.SnapshotDescription snapshot)
                         throws IOException

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

  Parameters:

  ctx - the environment to interact with the framework and master

  snapshot - the SnapshotDescriptor of the snapshot to delete

  Throws:

  IOException

• postDeleteSnapshot

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

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

  Parameters:

  ctx - the environment to interact with the framework and master

  snapshot - the SnapshotDescriptor of the snapshot to delete

  Throws:

  IOException

• preGetTableDescriptors

  @Deprecated
  void preGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                       List<TableName> tableNamesList,
                                       List<HTableDescriptor> descriptors)
                              throws IOException

  Deprecated. Use preGetTableDescriptors with regex instead.
  Called before a getTableDescriptors request has been processed.

  Parameters:

  ctx - the environment to interact with the framework and master

  tableNamesList - the list of table names, or null if querying for all

  descriptors - an empty list, can be filled with what to return if bypassing

  Throws:

  IOException

• postGetTableDescriptors

  @Deprecated
  void postGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                        List<HTableDescriptor> descriptors)
                               throws IOException

  Deprecated. Use postGetTableDescriptors with regex instead.
  Called after a getTableDescriptors request has been processed.

  Parameters:

  ctx - the environment to interact with the framework and master

  descriptors - the list of descriptors about to be returned

  Throws:

  IOException

• preGetTableDescriptors

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

  Called before a getTableDescriptors request has been processed.

  Parameters:

  ctx - the environment to interact with the framework and master

  tableNamesList - the list of table names, or null if querying for all

  descriptors - an empty list, can be filled with what to return if bypassing

  regex - regular expression used for filtering the table names

  Throws:

  IOException

• postGetTableDescriptors

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

  Called after a getTableDescriptors request has been processed.

  Parameters:

  ctx - the environment to interact with the framework and master

  tableNamesList - the list of table names, or null if querying for all

  descriptors - the list of descriptors about to be returned

  regex - regular expression used for filtering the table names

  Throws:

  IOException

• preGetTableNames

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

  Called before a getTableNames request has been processed.

  Parameters:

  ctx - the environment to interact with the framework and master

  descriptors - an empty list, can be filled with what to return if bypassing

  regex - regular expression used for filtering the table names

  Throws:

  IOException

• postGetTableNames

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

  Called after a getTableNames request has been processed.

  Parameters:

  ctx - the environment to interact with the framework and master

  descriptors - the list of descriptors about to be returned

  regex - regular expression used for filtering the table names

  Throws:

  IOException

• preCreateNamespace

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

  Called before a new namespace is created by HMaster. It can't bypass the default action, e.g., ctx.bypass() won't have effect.

  Parameters:

  ctx - the environment to interact with the framework and master

  ns - the NamespaceDescriptor for the table

  Throws:

  IOException

• postCreateNamespace

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

  Called after the createNamespace operation has been requested.

  Parameters:

  ctx - the environment to interact with the framework and master

  ns - the NamespaceDescriptor for the table

  Throws:

  IOException

• preDeleteNamespace

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

  Called before HMaster deletes a namespace It can't bypass the default action, e.g., ctx.bypass() won't have effect.

  Parameters:

  ctx - the environment to interact with the framework and master

  namespace - the name of the namespace

  Throws:

  IOException

• postDeleteNamespace

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

  Called after the deleteNamespace operation has been requested.

  Parameters:

  ctx - the environment to interact with the framework and master

  namespace - the name of the namespace

  Throws:

  IOException

• preModifyNamespace

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

  Called prior to modifying a namespace's properties. It can't bypass the default action, e.g., ctx.bypass() won't have effect.

  Parameters:

  ctx - the environment to interact with the framework and master

  ns - the NamespaceDescriptor

  Throws:

  IOException

• postModifyNamespace

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

  Called after the modifyNamespace operation has been requested.

  Parameters:

  ctx - the environment to interact with the framework and master

  ns - the NamespaceDescriptor

  Throws:

  IOException

• preGetNamespaceDescriptor

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

  Called before a getNamespaceDescriptor request has been processed.

  Parameters:

  ctx - the environment to interact with the framework and master

  namespace - the name of the namespace

  Throws:

  IOException

• postGetNamespaceDescriptor

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

  Called after a getNamespaceDescriptor request has been processed.

  Parameters:

  ctx - the environment to interact with the framework and master

  ns - the NamespaceDescriptor

  Throws:

  IOException

• preListNamespaceDescriptors

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

  Called before a listNamespaceDescriptors request has been processed.

  Parameters:

  ctx - the environment to interact with the framework and master

  descriptors - an empty list, can be filled with what to return if bypassing

  Throws:

  IOException

• postListNamespaceDescriptors

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

  Called after a listNamespaceDescriptors request has been processed.

  Parameters:

  ctx - the environment to interact with the framework and master

  descriptors - the list of descriptors about to be returned

  Throws:

  IOException

• preTableFlush

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

  Called before the table memstore is flushed to disk.

  Parameters:

  ctx - the environment to interact with the framework and master

  tableName - the name of the table

  Throws:

  IOException

• postTableFlush

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

  Called after the table memstore is flushed to disk.

  Parameters:

  ctx - the environment to interact with the framework and master

  tableName - the name of the table

  Throws:

  IOException

• preSetUserQuota

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

  Called before the quota for the user is stored.

  Parameters:

  ctx - the environment to interact with the framework and master

  userName - the name of user

  quotas - the quota settings

  Throws:

  IOException

• postSetUserQuota

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

  Called after the quota for the user is stored.

  Parameters:

  ctx - the environment to interact with the framework and master

  userName - the name of user

  quotas - the quota settings

  Throws:

  IOException

• preSetUserQuota

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

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

  Parameters:

  ctx - the environment to interact with the framework and master

  userName - the name of user

  tableName - the name of the table

  quotas - the quota settings

  Throws:

  IOException

• postSetUserQuota

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

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

  Parameters:

  ctx - the environment to interact with the framework and master

  userName - the name of user

  tableName - the name of the table

  quotas - the quota settings

  Throws:

  IOException

• preSetUserQuota

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

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

  Parameters:

  ctx - the environment to interact with the framework and master

  userName - the name of user

  namespace - the name of the namespace

  quotas - the quota settings

  Throws:

  IOException

• postSetUserQuota

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

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

  Parameters:

  ctx - the environment to interact with the framework and master

  userName - the name of user

  namespace - the name of the namespace

  quotas - the quota settings

  Throws:

  IOException

• preSetTableQuota

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

  Called before the quota for the table is stored.

  Parameters:

  ctx - the environment to interact with the framework and master

  tableName - the name of the table

  quotas - the quota settings

  Throws:

  IOException

• postSetTableQuota

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

  Called after the quota for the table is stored.

  Parameters:

  ctx - the environment to interact with the framework and master

  tableName - the name of the table

  quotas - the quota settings

  Throws:

  IOException

• preSetNamespaceQuota

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

  Called before the quota for the namespace is stored.

  Parameters:

  ctx - the environment to interact with the framework and master

  namespace - the name of the namespace

  quotas - the quota settings

  Throws:

  IOException

• postSetNamespaceQuota

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

  Called after the quota for the namespace is stored.

  Parameters:

  ctx - the environment to interact with the framework and master

  namespace - the name of the namespace

  quotas - the quota settings

  Throws:

  IOException