org.apache.hadoop.hbase.security.visibility

Class VisibilityController

java.lang.Object

org.apache.hadoop.hbase.coprocessor.BaseRegionObserver

org.apache.hadoop.hbase.security.visibility.VisibilityController

All Implemented Interfaces:

Coprocessor, CoprocessorService, MasterObserver, RegionObserver, VisibilityLabelsProtos.VisibilityLabelsService.Interface

@InterfaceAudience.Private
public class VisibilityController
extends BaseRegionObserver
implements MasterObserver, RegionObserver, VisibilityLabelsProtos.VisibilityLabelsService.Interface, CoprocessorService

Coprocessor that has both the MasterObserver and RegionObserver implemented that supports in visibility labels

Nested Class Summary

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

RegionObserver.MutationType

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

Coprocessor.State

Field Summary

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

PRIORITY_HIGHEST, PRIORITY_LOWEST, PRIORITY_SYSTEM, PRIORITY_USER, VERSION

Constructor Summary

Constructors

Constructor and Description
VisibilityController()

Method Summary

Methods

Modifier and Type	Method and Description
void	addLabels(RpcController controller, VisibilityLabelsProtos.VisibilityLabelsRequest request, RpcCallback<VisibilityLabelsProtos.VisibilityLabelsResponse> done) VisibilityEndpoint service related methods
void	clearAuths(RpcController controller, VisibilityLabelsProtos.SetAuthsRequest request, RpcCallback<VisibilityLabelsProtos.VisibilityLabelsResponse> done)
void	getAuths(RpcController controller, VisibilityLabelsProtos.GetAuthsRequest request, RpcCallback<VisibilityLabelsProtos.GetAuthsResponse> done)
Service	getService()
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	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	postBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> ctx, boolean oldValue, boolean newValue) Called after the flag to enable/disable balancing has changed.
void	postBatchMutate(ObserverContext<RegionCoprocessorEnvironment> c, MiniBatchOperationInProgress<Mutation> miniBatchOp) This will be called after applying a batch of Mutations on a region.
void	postCloneSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, 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, 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	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	postGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx, List<HTableDescriptor> descriptors) Called after a getTableDescriptors request has been processed.
void	postLogReplay(ObserverContext<RegionCoprocessorEnvironment> e) Called after the log replay on the region is over.
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.
Cell	postMutationBeforeWAL(ObserverContext<RegionCoprocessorEnvironment> ctx, RegionObserver.MutationType opType, Mutation mutation, Cell oldCell, Cell newCell) Called after a new cell has been created during an increment operation, but before it is committed to the WAL or memstore.
void	postOpen(ObserverContext<RegionCoprocessorEnvironment> e) Region related hooks
void	postRegionOffline(ObserverContext<MasterCoprocessorEnvironment> ctx, HRegionInfo regionInfo) Called after the region has been marked offline.
void	postRestoreSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, HBaseProtos.SnapshotDescription snapshot, HTableDescriptor hTableDescriptor) Called after a snapshot restore operation has been requested.
void	postScannerClose(ObserverContext<RegionCoprocessorEnvironment> c, InternalScanner s) Called after the client closes a scanner.
RegionScanner	postScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c, Scan scan, RegionScanner s) Called after the client opens a new scanner.
void	postSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, HBaseProtos.SnapshotDescription snapshot, HTableDescriptor hTableDescriptor) Called after the snapshot operation has been requested.
void	postStartMaster(ObserverContext<MasterCoprocessorEnvironment> ctx) Master related hooks
void	postUnassign(ObserverContext<MasterCoprocessorEnvironment> ctx, HRegionInfo regionInfo, boolean force) Called after the region unassignment has been requested.
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	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.
boolean	preBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> ctx, boolean newValue) Called prior to modifying the flag used to enable/disable region balancing.
void	preBatchMutate(ObserverContext<RegionCoprocessorEnvironment> c, MiniBatchOperationInProgress<Mutation> miniBatchOp) This will be called for every batch mutation operation happening at the server.
void	preCloneSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, 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, 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	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	preGetOp(ObserverContext<RegionCoprocessorEnvironment> e, Get get, List<Cell> results) Called before the client performs a Get
void	preGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx, List<TableName> tableNamesList, List<HTableDescriptor> descriptors) Called before a getTableDescriptors 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	preRegionOffline(ObserverContext<MasterCoprocessorEnvironment> ctx, HRegionInfo regionInfo) Called prior to marking a given region as offline.
void	preRestoreSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, HBaseProtos.SnapshotDescription snapshot, HTableDescriptor hTableDescriptor) Called before a snapshot is restored.
void	preScannerClose(ObserverContext<RegionCoprocessorEnvironment> c, InternalScanner s) Called before the client closes a scanner.
boolean	preScannerNext(ObserverContext<RegionCoprocessorEnvironment> c, InternalScanner s, List<Result> result, int limit, boolean hasNext) Called before the client asks for the next row on a scanner.
RegionScanner	preScannerOpen(ObserverContext<RegionCoprocessorEnvironment> e, Scan scan, RegionScanner s) Called before the client opens a new scanner.
void	preShutdown(ObserverContext<MasterCoprocessorEnvironment> ctx) Called prior to shutting down the full HBase cluster, including this HMaster process.
void	preSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, HBaseProtos.SnapshotDescription snapshot, HTableDescriptor hTableDescriptor) Called before a new snapshot is taken.
void	preStopMaster(ObserverContext<MasterCoprocessorEnvironment> ctx) Called immediately prior to stopping this HMaster process.
void	preUnassign(ObserverContext<MasterCoprocessorEnvironment> ctx, HRegionInfo regionInfo, boolean force) Called prior to unassigning a given region.
void	setAuths(RpcController controller, VisibilityLabelsProtos.SetAuthsRequest request, RpcCallback<VisibilityLabelsProtos.VisibilityLabelsResponse> done)
void	start(CoprocessorEnvironment env)
void	stop(CoprocessorEnvironment env)

Methods inherited from class org.apache.hadoop.hbase.coprocessor.BaseRegionObserver

postAppend, postBatchMutateIndispensably, postBulkLoadHFile, postCheckAndDelete, postCheckAndPut, postClose, postCloseRegionOperation, postCompact, postCompact, postCompactSelection, postCompactSelection, postCompleteSplit, postDelete, postExists, postFlush, postFlush, postGet, postGetClosestRowBefore, postGetOp, postIncrement, postIncrementColumnValue, postInstantiateDeleteTracker, postPut, postRollBackSplit, postScannerFilterRow, postScannerNext, postSplit, postStartRegionOperation, postStoreFileReaderOpen, postWALRestore, preAppend, preBulkLoadHFile, preCheckAndDelete, preCheckAndPut, preClose, preCompact, preCompact, preCompactScannerOpen, preCompactScannerOpen, preCompactSelection, preCompactSelection, preDelete, preExists, preFlush, preFlush, preFlushScannerOpen, preGet, preGetClosestRowBefore, preIncrement, preIncrementColumnValue, preOpen, prePut, preRollBackSplit, preSplit, preSplit, preSplitAfterPONR, preSplitBeforePONR, preStoreFileReaderOpen, preStoreScannerOpen, preWALRestore

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

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

postAppend, postBatchMutateIndispensably, postBulkLoadHFile, postCheckAndDelete, postCheckAndPut, postClose, postCloseRegionOperation, postCompact, postCompact, postCompactSelection, postCompactSelection, postCompleteSplit, postDelete, postExists, postFlush, postFlush, postGet, postGetClosestRowBefore, postGetOp, postIncrement, postIncrementColumnValue, postInstantiateDeleteTracker, postPut, postRollBackSplit, postScannerFilterRow, postScannerNext, postSplit, postStartRegionOperation, postStoreFileReaderOpen, postWALRestore, preAppend, preBulkLoadHFile, preCheckAndDelete, preCheckAndPut, preClose, preCompact, preCompact, preCompactScannerOpen, preCompactScannerOpen, preCompactSelection, preCompactSelection, preDelete, preExists, preFlush, preFlush, preFlushScannerOpen, preGet, preGetClosestRowBefore, preIncrement, preIncrementColumnValue, preOpen, prePut, preRollBackSplit, preSplit, preSplit, preSplitAfterPONR, preSplitBeforePONR, preStoreFileReaderOpen, preStoreScannerOpen, preWALRestore

Constructor Detail

VisibilityController

public VisibilityController()

Method Detail

start

public void start(CoprocessorEnvironment env)
           throws IOException

Specified by:

start in interface Coprocessor

Overrides:

start in class BaseRegionObserver

Throws:

IOException

stop

public void stop(CoprocessorEnvironment env)
          throws IOException

Specified by:

stop in interface Coprocessor

Overrides:

stop in class BaseRegionObserver

Throws:

IOException

postStartMaster

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

Master related hooks

Specified by:

postStartMaster in interface MasterObserver

Throws:

IOException

preCreateTable

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

Description copied from interface: MasterObserver

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

Specified by:

preCreateTable in interface MasterObserver

Parameters:

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

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

Description copied from interface: MasterObserver

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

Specified by:

postCreateTable in interface MasterObserver

Parameters:

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

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

Description copied from interface: MasterObserver

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

Specified by:

preCreateTableHandler in interface MasterObserver

Parameters:

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

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

Description copied from interface: MasterObserver

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

Specified by:

postCreateTableHandler in interface MasterObserver

Parameters:

ctx - the environment to interact with the framework and master

desc - the HTableDescriptor for the table

regions - the initial regions created for the table

Throws:

IOException

preDeleteTable

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

Description copied from interface: MasterObserver

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

Specified by:

preDeleteTable in interface MasterObserver

Parameters:

ctx - the environment to interact with the framework and master

tableName - the name of the table

Throws:

IOException

postDeleteTable

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

Description copied from interface: MasterObserver

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

Specified by:

postDeleteTable in interface MasterObserver

Parameters:

ctx - the environment to interact with the framework and master

tableName - the name of the table

Throws:

IOException

preDeleteTableHandler

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

Description copied from interface: MasterObserver

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

Specified by:

preDeleteTableHandler in interface MasterObserver

Parameters:

ctx - the environment to interact with the framework and master

tableName - the name of the table

Throws:

IOException

postDeleteTableHandler

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

Description copied from interface: MasterObserver

Called after HMaster deletes a table. Called as part of delete table handler and it is async to the delete RPC call. It can't bypass the default action, e.g., ctx.bypass() won't have effect.

Specified by:

postDeleteTableHandler in interface MasterObserver

Parameters:

ctx - the environment to interact with the framework and master

tableName - the name of the table

Throws:

IOException

preModifyTable

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

Description copied from interface: MasterObserver

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

Specified by:

preModifyTable in interface MasterObserver

Parameters:

ctx - the environment to interact with the framework and master

tableName - the name of the table

htd - the HTableDescriptor

Throws:

IOException

postModifyTable

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

Description copied from interface: MasterObserver

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

Specified by:

postModifyTable in interface MasterObserver

Parameters:

ctx - the environment to interact with the framework and master

tableName - the name of the table

htd - the HTableDescriptor

Throws:

IOException

preModifyTableHandler

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

Description copied from interface: MasterObserver

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

Specified by:

preModifyTableHandler in interface MasterObserver

Parameters:

ctx - the environment to interact with the framework and master

tableName - the name of the table

htd - the HTableDescriptor

Throws:

IOException

postModifyTableHandler

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

Description copied from interface: MasterObserver

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

Specified by:

postModifyTableHandler in interface MasterObserver

Parameters:

ctx - the environment to interact with the framework and master

tableName - the name of the table

htd - the HTableDescriptor

Throws:

IOException

preAddColumn

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

Description copied from interface: MasterObserver

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

Specified by:

preAddColumn in interface MasterObserver

Parameters:

ctx - the environment to interact with the framework and master

tableName - the name of the table

column - the HColumnDescriptor

Throws:

IOException

postAddColumn

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

Description copied from interface: MasterObserver

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

Specified by:

postAddColumn in interface MasterObserver

Parameters:

ctx - the environment to interact with the framework and master

tableName - the name of the table

column - the HColumnDescriptor

Throws:

IOException

preAddColumnHandler

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

Description copied from interface: MasterObserver

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

Specified by:

preAddColumnHandler in interface MasterObserver

Parameters:

ctx - the environment to interact with the framework and master

tableName - the name of the table

column - the HColumnDescriptor

Throws:

IOException

postAddColumnHandler

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

Description copied from interface: MasterObserver

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

Specified by:

postAddColumnHandler in interface MasterObserver

Parameters:

ctx - the environment to interact with the framework and master

tableName - the name of the table

column - the HColumnDescriptor

Throws:

IOException

preModifyColumn

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

Description copied from interface: MasterObserver

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

Specified by:

preModifyColumn in interface MasterObserver

Parameters:

ctx - the environment to interact with the framework and master

tableName - the name of the table

descriptor - the HColumnDescriptor

Throws:

IOException

postModifyColumn

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

Description copied from interface: MasterObserver

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

Specified by:

postModifyColumn in interface MasterObserver

Parameters:

ctx - the environment to interact with the framework and master

tableName - the name of the table

descriptor - the HColumnDescriptor

Throws:

IOException

preModifyColumnHandler

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

Description copied from interface: MasterObserver

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

Specified by:

preModifyColumnHandler in interface MasterObserver

Parameters:

ctx - the environment to interact with the framework and master

tableName - the name of the table

descriptor - the HColumnDescriptor

Throws:

IOException

postModifyColumnHandler

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

Description copied from interface: MasterObserver

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

Specified by:

postModifyColumnHandler in interface MasterObserver

Parameters:

ctx - the environment to interact with the framework and master

tableName - the name of the table

descriptor - the HColumnDescriptor

Throws:

IOException

preDeleteColumn

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

Description copied from interface: MasterObserver

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

Specified by:

preDeleteColumn in interface MasterObserver

Parameters:

ctx - the environment to interact with the framework and master

tableName - the name of the table

c - the column

Throws:

IOException

postDeleteColumn

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

Description copied from interface: MasterObserver

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

Specified by:

postDeleteColumn in interface MasterObserver

Parameters:

ctx - the environment to interact with the framework and master

tableName - the name of the table

c - the column

Throws:

IOException

preDeleteColumnHandler

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

Description copied from interface: MasterObserver

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

Specified by:

preDeleteColumnHandler in interface MasterObserver

Parameters:

ctx - the environment to interact with the framework and master

tableName - the name of the table

c - the column

Throws:

IOException

postDeleteColumnHandler

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

Description copied from interface: MasterObserver

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

Specified by:

postDeleteColumnHandler in interface MasterObserver

Parameters:

ctx - the environment to interact with the framework and master

tableName - the name of the table

c - the column

Throws:

IOException

preEnableTable

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

Description copied from interface: MasterObserver

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

Specified by:

preEnableTable in interface MasterObserver

Parameters:

ctx - the environment to interact with the framework and master

tableName - the name of the table

Throws:

IOException

postEnableTable

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

Description copied from interface: MasterObserver

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

Specified by:

postEnableTable in interface MasterObserver

Parameters:

ctx - the environment to interact with the framework and master

tableName - the name of the table

Throws:

IOException

preEnableTableHandler

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

Description copied from interface: MasterObserver

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

Specified by:

preEnableTableHandler in interface MasterObserver

Parameters:

ctx - the environment to interact with the framework and master

tableName - the name of the table

Throws:

IOException

postEnableTableHandler

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

Description copied from interface: MasterObserver

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

Specified by:

postEnableTableHandler in interface MasterObserver

Parameters:

ctx - the environment to interact with the framework and master

tableName - the name of the table

Throws:

IOException

preDisableTable

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

Description copied from interface: MasterObserver

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

Specified by:

preDisableTable in interface MasterObserver

Parameters:

ctx - the environment to interact with the framework and master

tableName - the name of the table

Throws:

IOException

postDisableTable

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

Description copied from interface: MasterObserver

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

Specified by:

postDisableTable in interface MasterObserver

Parameters:

ctx - the environment to interact with the framework and master

tableName - the name of the table

Throws:

IOException

preDisableTableHandler

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

Description copied from interface: MasterObserver

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

Specified by:

preDisableTableHandler in interface MasterObserver

Parameters:

ctx - the environment to interact with the framework and master

tableName - the name of the table

Throws:

IOException

postDisableTableHandler

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

Description copied from interface: MasterObserver

Called after the disableTable operation has been requested. Called as part of disable table handler and it is asyn to the disable table RPC call.

Specified by:

postDisableTableHandler in interface MasterObserver

Parameters:

ctx - the environment to interact with the framework and master

tableName - the name of the table

Throws:

IOException

preMove

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

Description copied from interface: MasterObserver

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

Specified by:

preMove in interface MasterObserver

Parameters:

ctx - the environment to interact with the framework and master

region - the HRegionInfo

srcServer - the source ServerName

destServer - the destination ServerName

Throws:

IOException

postMove

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

Description copied from interface: MasterObserver

Called after the region move has been requested.

Specified by:

postMove in interface MasterObserver

Parameters:

ctx - the environment to interact with the framework and master

region - the HRegionInfo

srcServer - the source ServerName

destServer - the destination ServerName

Throws:

IOException

preAssign

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

Description copied from interface: MasterObserver

Called prior to assigning a specific region.

Specified by:

preAssign in interface MasterObserver

Parameters:

ctx - the environment to interact with the framework and master

regionInfo - the regionInfo of the region

Throws:

IOException

postAssign

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

Description copied from interface: MasterObserver

Called after the region assignment has been requested.

Specified by:

postAssign in interface MasterObserver

Parameters:

ctx - the environment to interact with the framework and master

regionInfo - the regionInfo of the region

Throws:

IOException

preUnassign

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

Description copied from interface: MasterObserver

Called prior to unassigning a given region.

Specified by:

preUnassign in interface MasterObserver

Parameters:

ctx - the environment to interact with the framework and master

force - whether to force unassignment or not

Throws:

IOException

postUnassign

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

Description copied from interface: MasterObserver

Called after the region unassignment has been requested.

Specified by:

postUnassign in interface MasterObserver

Parameters:

ctx - the environment to interact with the framework and master

force - whether to force unassignment or not

Throws:

IOException

preRegionOffline

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

Description copied from interface: MasterObserver

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

Specified by:

preRegionOffline in interface MasterObserver

Parameters:

ctx - the environment to interact with the framework and master

Throws:

IOException

postRegionOffline

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

Description copied from interface: MasterObserver

Called after the region has been marked offline.

Specified by:

postRegionOffline in interface MasterObserver

Parameters:

ctx - the environment to interact with the framework and master

Throws:

IOException

preBalance

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

Description copied from interface: MasterObserver

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

Specified by:

preBalance in interface MasterObserver

Parameters:

ctx - the environment to interact with the framework and master

Throws:

IOException

postBalance

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

Description copied from interface: MasterObserver

Called after the balancing plan has been submitted.

Specified by:

postBalance in interface MasterObserver

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

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

Description copied from interface: MasterObserver

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

Specified by:

preBalanceSwitch in interface MasterObserver

Parameters:

ctx - the coprocessor instance's environment

newValue - the new flag value submitted in the call

Throws:

IOException

postBalanceSwitch

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

Description copied from interface: MasterObserver

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

Specified by:

postBalanceSwitch in interface MasterObserver

Parameters:

ctx - the coprocessor instance's environment

oldValue - the previously set balanceSwitch value

newValue - the newly set balanceSwitch value

Throws:

IOException

preShutdown

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

Description copied from interface: MasterObserver

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

Specified by:

preShutdown in interface MasterObserver

Throws:

IOException

preStopMaster

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

Description copied from interface: MasterObserver

Called immediately prior to stopping this HMaster process.

Specified by:

preStopMaster in interface MasterObserver

Throws:

IOException

preSnapshot

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

Description copied from interface: MasterObserver

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

Specified by:

preSnapshot in interface MasterObserver

Parameters:

ctx - the environment to interact with the framework and master

snapshot - the SnapshotDescriptor for the snapshot

hTableDescriptor - the hTableDescriptor of the table to snapshot

Throws:

IOException

postSnapshot

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

Description copied from interface: MasterObserver

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

Specified by:

postSnapshot in interface MasterObserver

Parameters:

ctx - the environment to interact with the framework and master

snapshot - the SnapshotDescriptor for the snapshot

hTableDescriptor - the hTableDescriptor of the table to snapshot

Throws:

IOException

preCloneSnapshot

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

Description copied from interface: MasterObserver

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

Specified by:

preCloneSnapshot in interface MasterObserver

Parameters:

ctx - the environment to interact with the framework and master

snapshot - the SnapshotDescriptor for the snapshot

hTableDescriptor - the hTableDescriptor of the table to create

Throws:

IOException

postCloneSnapshot

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

Description copied from interface: MasterObserver

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

Specified by:

postCloneSnapshot in interface MasterObserver

Parameters:

ctx - the environment to interact with the framework and master

snapshot - the SnapshotDescriptor for the snapshot

hTableDescriptor - the hTableDescriptor of the table to create

Throws:

IOException

preRestoreSnapshot

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

Description copied from interface: MasterObserver

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

Specified by:

preRestoreSnapshot in interface MasterObserver

Parameters:

ctx - the environment to interact with the framework and master

snapshot - the SnapshotDescriptor for the snapshot

hTableDescriptor - the hTableDescriptor of the table to restore

Throws:

IOException

postRestoreSnapshot

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

Description copied from interface: MasterObserver

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

Specified by:

postRestoreSnapshot in interface MasterObserver

Parameters:

ctx - the environment to interact with the framework and master

snapshot - the SnapshotDescriptor for the snapshot

hTableDescriptor - the hTableDescriptor of the table to restore

Throws:

IOException

preDeleteSnapshot

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

Description copied from interface: MasterObserver

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

Specified by:

preDeleteSnapshot in interface MasterObserver

Parameters:

ctx - the environment to interact with the framework and master

snapshot - the SnapshotDescriptor of the snapshot to delete

Throws:

IOException

postDeleteSnapshot

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

Description copied from interface: MasterObserver

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

Specified by:

postDeleteSnapshot in interface MasterObserver

Parameters:

ctx - the environment to interact with the framework and master

snapshot - the SnapshotDescriptor of the snapshot to delete

Throws:

IOException

preGetTableDescriptors

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

Description copied from interface: MasterObserver

Called before a getTableDescriptors request has been processed.

Specified by:

preGetTableDescriptors in interface MasterObserver

Parameters:

ctx - the environment to interact with the framework and master

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

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

Throws:

IOException

postGetTableDescriptors

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

Description copied from interface: MasterObserver

Called after a getTableDescriptors request has been processed.

Specified by:

postGetTableDescriptors in interface MasterObserver

Parameters:

ctx - the environment to interact with the framework and master

descriptors - the list of descriptors about to be returned

Throws:

IOException

preCreateNamespace

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

Description copied from interface: MasterObserver

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

Specified by:

preCreateNamespace in interface MasterObserver

Parameters:

ctx - the environment to interact with the framework and master

ns - the NamespaceDescriptor for the table

Throws:

IOException

postCreateNamespace

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

Description copied from interface: MasterObserver

Called after the createNamespace operation has been requested.

Specified by:

postCreateNamespace in interface MasterObserver

Parameters:

ctx - the environment to interact with the framework and master

ns - the NamespaceDescriptor for the table

Throws:

IOException

preDeleteNamespace

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

Description copied from interface: MasterObserver

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

Specified by:

preDeleteNamespace in interface MasterObserver

Parameters:

ctx - the environment to interact with the framework and master

namespace - the name of the namespace

Throws:

IOException

postDeleteNamespace

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

Description copied from interface: MasterObserver

Called after the deleteNamespace operation has been requested.

Specified by:

postDeleteNamespace in interface MasterObserver

Parameters:

ctx - the environment to interact with the framework and master

namespace - the name of the namespace

Throws:

IOException

preModifyNamespace

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

Description copied from interface: MasterObserver

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

Specified by:

preModifyNamespace in interface MasterObserver

Parameters:

ctx - the environment to interact with the framework and master

ns - the NamespaceDescriptor

Throws:

IOException

postModifyNamespace

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

Description copied from interface: MasterObserver

Called after the modifyNamespace operation has been requested.

Specified by:

postModifyNamespace in interface MasterObserver

Parameters:

ctx - the environment to interact with the framework and master

ns - the NamespaceDescriptor

Throws:

IOException

preMasterInitialization

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

Description copied from interface: MasterObserver

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

Specified by:

preMasterInitialization in interface MasterObserver

Throws:

IOException

postOpen

public void postOpen(ObserverContext<RegionCoprocessorEnvironment> e)

Region related hooks

Specified by:

postOpen in interface RegionObserver

Overrides:

postOpen in class BaseRegionObserver

Parameters:

e - the environment provided by the region server

postLogReplay

public void postLogReplay(ObserverContext<RegionCoprocessorEnvironment> e)

Description copied from interface: RegionObserver

Called after the log replay on the region is over.

Specified by:

postLogReplay in interface RegionObserver

Overrides:

postLogReplay in class BaseRegionObserver

Parameters:

e - the environment provided by the region server

preBatchMutate

public void preBatchMutate(ObserverContext<RegionCoprocessorEnvironment> c,
                  MiniBatchOperationInProgress<Mutation> miniBatchOp)
                    throws IOException

Description copied from interface: RegionObserver

This will be called for every batch mutation operation happening at the server. This will be called after acquiring the locks on the mutating rows and after applying the proper timestamp for each Mutation at the server. The batch may contain Put/Delete. By setting OperationStatus of Mutations (MiniBatchOperationInProgress.setOperationStatus(int, OperationStatus)), RegionObserver can make HRegion to skip these Mutations.

Specified by:

preBatchMutate in interface RegionObserver

Overrides:

preBatchMutate in class BaseRegionObserver

Parameters:

c - the environment provided by the region server

miniBatchOp - batch of Mutations getting applied to region.

Throws:

IOException - if an error occurred on the coprocessor

postBatchMutate

public void postBatchMutate(ObserverContext<RegionCoprocessorEnvironment> c,
                   MiniBatchOperationInProgress<Mutation> miniBatchOp)
                     throws IOException

Description copied from interface: RegionObserver

This will be called after applying a batch of Mutations on a region. The Mutations are added to memstore and WAL.

Specified by:

postBatchMutate in interface RegionObserver

Overrides:

postBatchMutate in class BaseRegionObserver

Parameters:

c - the environment provided by the region server

miniBatchOp - batch of Mutations applied to region.

Throws:

IOException - if an error occurred on the coprocessor

preScannerOpen

public RegionScanner preScannerOpen(ObserverContext<RegionCoprocessorEnvironment> e,
                           Scan scan,
                           RegionScanner s)
                             throws IOException

Description copied from interface: RegionObserver

Called before the client opens a new scanner.

Call CoprocessorEnvironment#bypass to skip default actions

Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors

Specified by:

preScannerOpen in interface RegionObserver

Overrides:

preScannerOpen in class BaseRegionObserver

Parameters:

e - the environment provided by the region server

scan - the Scan specification

s - if not null, the base scanner

Returns:

an RegionScanner instance to use instead of the base scanner if overriding default behavior, null otherwise

Throws:

IOException - if an error occurred on the coprocessor

postScannerOpen

public RegionScanner postScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c,
                            Scan scan,
                            RegionScanner s)
                              throws IOException

Description copied from interface: RegionObserver

Called after the client opens a new scanner.

Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors

Specified by:

postScannerOpen in interface RegionObserver

Overrides:

postScannerOpen in class BaseRegionObserver

Parameters:

c - the environment provided by the region server

scan - the Scan specification

s - if not null, the base scanner

Returns:

the scanner instance to use

Throws:

IOException - if an error occurred on the coprocessor

preScannerNext

public boolean preScannerNext(ObserverContext<RegionCoprocessorEnvironment> c,
                     InternalScanner s,
                     List<Result> result,
                     int limit,
                     boolean hasNext)
                       throws IOException

Description copied from interface: RegionObserver

Called before the client asks for the next row on a scanner.

Call CoprocessorEnvironment#bypass to skip default actions

Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors

Specified by:

preScannerNext in interface RegionObserver

Overrides:

preScannerNext in class BaseRegionObserver

Parameters:

c - the environment provided by the region server

s - the scanner

result - The result to return to the client if default processing is bypassed. Can be modified. Will not be returned if default processing is not bypassed.

limit - the maximum number of results to return

hasNext - the 'has more' indication

Returns:

'has more' indication that should be sent to client

Throws:

IOException - if an error occurred on the coprocessor

preScannerClose

public void preScannerClose(ObserverContext<RegionCoprocessorEnvironment> c,
                   InternalScanner s)
                     throws IOException

Description copied from interface: RegionObserver

Called before the client closes a scanner.

Call CoprocessorEnvironment#bypass to skip default actions

Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors

Specified by:

preScannerClose in interface RegionObserver

Overrides:

preScannerClose in class BaseRegionObserver

Parameters:

c - the environment provided by the region server

s - the scanner

Throws:

IOException - if an error occurred on the coprocessor

postScannerClose

public void postScannerClose(ObserverContext<RegionCoprocessorEnvironment> c,
                    InternalScanner s)
                      throws IOException

Description copied from interface: RegionObserver

Called after the client closes a scanner.

Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors

Specified by:

postScannerClose in interface RegionObserver

Overrides:

postScannerClose in class BaseRegionObserver

Parameters:

c - the environment provided by the region server

s - the scanner

Throws:

IOException - if an error occurred on the coprocessor

preGetOp

public void preGetOp(ObserverContext<RegionCoprocessorEnvironment> e,
            Get get,
            List<Cell> results)
              throws IOException

Description copied from interface: RegionObserver

Called before the client performs a Get

Call CoprocessorEnvironment#bypass to skip default actions

Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors

Specified by:

preGetOp in interface RegionObserver

Overrides:

preGetOp in class BaseRegionObserver

Parameters:

e - the environment provided by the region server

get - the Get request

results - The result to return to the client if default processing is bypassed. Can be modified. Will not be used if default processing is not bypassed.

Throws:

IOException - if an error occurred on the coprocessor

postMutationBeforeWAL

public Cell postMutationBeforeWAL(ObserverContext<RegionCoprocessorEnvironment> ctx,
                         RegionObserver.MutationType opType,
                         Mutation mutation,
                         Cell oldCell,
                         Cell newCell)
                           throws IOException

Description copied from interface: RegionObserver

Called after a new cell has been created during an increment operation, but before it is committed to the WAL or memstore. Calling ObserverContext.bypass() has no effect in this hook.

Specified by:

postMutationBeforeWAL in interface RegionObserver

Overrides:

postMutationBeforeWAL in class BaseRegionObserver

Parameters:

ctx - the environment provided by the region server

opType - the operation type

mutation - the current mutation

oldCell - old cell containing previous value

newCell - the new cell containing the computed value

Returns:

the new cell, possibly changed

Throws:

IOException

getService

public Service getService()

Specified by:

getService in interface CoprocessorService

addLabels

public void addLabels(RpcController controller,
             VisibilityLabelsProtos.VisibilityLabelsRequest request,
             RpcCallback<VisibilityLabelsProtos.VisibilityLabelsResponse> done)

VisibilityEndpoint service related methods

Specified by:

addLabels in interface VisibilityLabelsProtos.VisibilityLabelsService.Interface

setAuths

public void setAuths(RpcController controller,
            VisibilityLabelsProtos.SetAuthsRequest request,
            RpcCallback<VisibilityLabelsProtos.VisibilityLabelsResponse> done)

Specified by:

setAuths in interface VisibilityLabelsProtos.VisibilityLabelsService.Interface

getAuths

public void getAuths(RpcController controller,
            VisibilityLabelsProtos.GetAuthsRequest request,
            RpcCallback<VisibilityLabelsProtos.GetAuthsResponse> done)

Specified by:

getAuths in interface VisibilityLabelsProtos.VisibilityLabelsService.Interface

clearAuths

public void clearAuths(RpcController controller,
              VisibilityLabelsProtos.SetAuthsRequest request,
              RpcCallback<VisibilityLabelsProtos.VisibilityLabelsResponse> done)

Specified by:

clearAuths in interface VisibilityLabelsProtos.VisibilityLabelsService.Interface