AccessController (Apache HBase - Server 2.0.0-alpha3 API)

java.lang.Object
- org.apache.hadoop.hbase.security.access.AccessController

All Implemented Interfaces:

Coprocessor, BulkLoadObserver, CoprocessorService, EndpointObserver, MasterObserver, RegionObserver, RegionServerObserver, org.apache.hadoop.hbase.protobuf.generated.AccessControlProtos.AccessControlService.Interface
```
@InterfaceAudience.LimitedPrivate(value="Configuration")
public class AccessController
extends Object
implements MasterObserver, RegionObserver, RegionServerObserver, org.apache.hadoop.hbase.protobuf.generated.AccessControlProtos.AccessControlService.Interface, CoprocessorService, EndpointObserver, BulkLoadObserver
```
Provides basic authorization checks for data access and administrative operations.
AccessController performs authorization checks for HBase operations based on:
- the identity of the user performing the operation
- the scope over which the operation is performed, in increasing specificity: global, table, column family, or qualifier
- the type of action being performed (as mapped to Permission.Action values)
If the authorization check fails, an AccessDeniedException will be thrown for the operation.

To perform authorization checks, AccessController relies on the RpcServerEngine being loaded to provide the user identities for remote requests.

The access control lists used for authorization can be manipulated via the exposed AccessControlProtos.AccessControlService Interface implementation, and the associated grant, revoke, and user_permission HBase shell commands.

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

AccessController()

Constructors
Constructor and Description
`AccessController()`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`checkPermissions(com.google.protobuf.RpcController controller, org.apache.hadoop.hbase.protobuf.generated.AccessControlProtos.CheckPermissionsRequest request, com.google.protobuf.RpcCallback<org.apache.hadoop.hbase.protobuf.generated.AccessControlProtos.CheckPermissionsResponse> done)`
`TableAuthManager`	`getAuthManager()`
`Region`	`getRegion()`
`com.google.protobuf.Service`	`getService()`
`void`	`getUserPermissions(com.google.protobuf.RpcController controller, org.apache.hadoop.hbase.protobuf.generated.AccessControlProtos.GetUserPermissionsRequest request, com.google.protobuf.RpcCallback<org.apache.hadoop.hbase.protobuf.generated.AccessControlProtos.GetUserPermissionsResponse> done)`
`void`	`grant(com.google.protobuf.RpcController controller, org.apache.hadoop.hbase.protobuf.generated.AccessControlProtos.GrantRequest request, com.google.protobuf.RpcCallback<org.apache.hadoop.hbase.protobuf.generated.AccessControlProtos.GrantResponse> done)`
`static boolean`	`isAuthorizationSupported(org.apache.hadoop.conf.Configuration conf)`
`static boolean`	`isCellAuthorizationSupported(org.apache.hadoop.conf.Configuration conf)`
`void`	`postAbortProcedure(ObserverContext<MasterCoprocessorEnvironment> ctx)` Called after a abortProcedure request has been processed.
`void`	`postCompletedCreateTableAction(ObserverContext<MasterCoprocessorEnvironment> c, TableDescriptor desc, HRegionInfo[] regions)` Called after the createTable operation has been requested.
`ReplicationEndpoint`	`postCreateReplicationEndPoint(ObserverContext<RegionServerCoprocessorEnvironment> ctx, ReplicationEndpoint endpoint)` This will be called after the replication endpoint is instantiated.
`void`	`postDelete(ObserverContext<RegionCoprocessorEnvironment> c, Delete delete, WALEdit edit, Durability durability)` Called after the client deletes a value.
`void`	`postDeleteColumnFamily(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, byte[] columnFamily)` Called after the column family has been deleted.
`void`	`postDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace)` Called after the deleteNamespace operation has been requested.
`void`	`postDeleteTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName)` Called after the deleteTable operation has been requested.
`void`	`postEndpointInvocation(ObserverContext<RegionCoprocessorEnvironment> ctx, com.google.protobuf.Service service, String methodName, com.google.protobuf.Message request, com.google.protobuf.Message.Builder responseBuilder)` Called after an Endpoint service method is invoked.
`void`	`postGetProcedures(ObserverContext<MasterCoprocessorEnvironment> ctx, List<Procedure<?>> procList)` Called after a getProcedures request has been processed.
`void`	`postGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx, List<TableName> tableNamesList, List<TableDescriptor> descriptors, String regex)` Called after a getTableDescriptors request has been processed.
`void`	`postGetTableNames(ObserverContext<MasterCoprocessorEnvironment> ctx, List<TableDescriptor> descriptors, String regex)` Called after a getTableNames request has been processed.
`void`	`postListNamespaceDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx, List<NamespaceDescriptor> descriptors)` Called after a listNamespaceDescriptors request has been processed.
`void`	`postLogReplay(ObserverContext<RegionCoprocessorEnvironment> c)` Called after the log replay on the region is over.
`void`	`postMerge(ObserverContext<RegionServerCoprocessorEnvironment> c, Region regionA, Region regionB, Region mergedRegion)` called after the regions merge.
`void`	`postMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx, Region regionA, Region regionB, Region mergedRegion)` This will be called after PONR step as part of regions merge transaction.
`void`	`postModifyTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, TableDescriptor htd)` Called after the modifyTable operation 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> c)` Called after the region is reported as open to the master.
`void`	`postPut(ObserverContext<RegionCoprocessorEnvironment> c, Put put, WALEdit edit, Durability durability)` Called after the client stores a value.
`void`	`postReplicateLogEntries(ObserverContext<RegionServerCoprocessorEnvironment> ctx, List<org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.WALEntry> entries, CellScanner cells)` This will be called after executing replication request to shipping log entries.
`void`	`postRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx, Region regionA, Region regionB)` This will be called after the roll back of the regions merge.
`void`	`postRollWALWriterRequest(ObserverContext<RegionServerCoprocessorEnvironment> ctx)` This will be called after executing user request to roll a region server WAL.
`void`	`postScannerClose(ObserverContext<RegionCoprocessorEnvironment> c, InternalScanner s)` Called after the client closes a scanner.
`boolean`	`postScannerFilterRow(ObserverContext<RegionCoprocessorEnvironment> e, InternalScanner s, Cell curRowCell, boolean hasMore)` This will be called by the scan flow when the current scanned row is being filtered out by the filter.
`RegionScanner`	`postScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c, Scan scan, RegionScanner s)` Called after the client opens a new scanner.
`void`	`postSetSplitOrMergeEnabled(ObserverContext<MasterCoprocessorEnvironment> ctx, boolean newValue, MasterSwitchType switchType)` Called after setting split / merge switch
`void`	`postStartMaster(ObserverContext<MasterCoprocessorEnvironment> ctx)` Called immediately after an active master instance has completed initialization.
`void`	`postTruncateTable(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)` Called after the truncateTable operation has been requested.
`void`	`preAbortProcedure(ObserverContext<MasterCoprocessorEnvironment> ctx, ProcedureExecutor<MasterProcedureEnv> procEnv, long procId)` Called before a abortProcedure request has been processed.
`void`	`preAddColumnFamily(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, ColumnFamilyDescriptor columnFamily)` Called prior to adding a new column family to the table.
`void`	`preAddReplicationPeer(ObserverContext<MasterCoprocessorEnvironment> ctx, String peerId, ReplicationPeerConfig peerConfig)` Called before add a replication peer
`void`	`preAddRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx, String name)` Called before a new region server group is added
`Result`	`preAppend(ObserverContext<RegionCoprocessorEnvironment> c, Append append)` Called before Append.
`Result`	`preAppendAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> c, Append append)` Called before Append but after acquiring rowlock.
`void`	`preAssign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo)` Called prior to assigning a specific region.
`void`	`preBalance(ObserverContext<MasterCoprocessorEnvironment> c)` Called prior to requesting rebalancing of the cluster regions, though after the initial checks for regions in transition and the balance switch flag.
`void`	`preBalanceRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx, String groupName)` Called before a region server group is removed
`boolean`	`preBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> c, 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`	`preBulkLoadHFile(ObserverContext<RegionCoprocessorEnvironment> ctx, List<Pair<byte[],String>> familyPaths)` Verifies user has CREATE privileges on the Column Families involved in the bulkLoadHFile request.
`boolean`	`preCheckAndDelete(ObserverContext<RegionCoprocessorEnvironment> c, byte[] row, byte[] family, byte[] qualifier, CompareOperator op, ByteArrayComparable comparator, Delete delete, boolean result)` Called before checkAndDelete.
`boolean`	`preCheckAndDeleteAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> c, byte[] row, byte[] family, byte[] qualifier, CompareOperator op, ByteArrayComparable comparator, Delete delete, boolean result)` Called before checkAndDelete but after acquiring rowock.
`boolean`	`preCheckAndPut(ObserverContext<RegionCoprocessorEnvironment> c, byte[] row, byte[] family, byte[] qualifier, CompareOperator op, ByteArrayComparable comparator, Put put, boolean result)` Called before checkAndPut.
`boolean`	`preCheckAndPutAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> c, byte[] row, byte[] family, byte[] qualifier, CompareOperator opp, ByteArrayComparable comparator, Put put, boolean result)` Called before checkAndPut but after acquiring rowlock.
`void`	`preCleanupBulkLoad(ObserverContext<RegionCoprocessorEnvironment> ctx, org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.CleanupBulkLoadRequest request)` Authorization security check for SecureBulkLoadProtocol.cleanupBulkLoad()
`void`	`preClearCompactionQueues(ObserverContext<RegionServerCoprocessorEnvironment> ctx)` This will be called before clearing compaction queues
`void`	`preClearDeadServers(ObserverContext<MasterCoprocessorEnvironment> ctx)` Called before clear dead region servers.
`void`	`preCloneSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, org.apache.hadoop.hbase.shaded.protobuf.generated.SnapshotProtos.SnapshotDescription snapshot, TableDescriptor hTableDescriptor)` Called before a snapshot is cloned.
`void`	`preClose(ObserverContext<RegionCoprocessorEnvironment> c, boolean abortRequested)` Called before the region is reported as closed to the master.
`InternalScanner`	`preCompact(ObserverContext<RegionCoprocessorEnvironment> c, Store store, InternalScanner scanner, ScanType scanType, CompactionLifeCycleTracker tracker)` Called prior to writing the `StoreFile`s selected for compaction into a new `StoreFile`.
`void`	`preCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns)` Called before a new namespace is created by `HMaster`.
`void`	`preCreateTable(ObserverContext<MasterCoprocessorEnvironment> c, TableDescriptor desc, HRegionInfo[] regions)` Called before a new table is created by `HMaster`.
`void`	`preDelete(ObserverContext<RegionCoprocessorEnvironment> c, Delete delete, WALEdit edit, Durability durability)` Called before the client deletes a value.
`void`	`preDeleteColumnFamily(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, byte[] columnFamily)` Called prior to deleting the entire column family.
`void`	`preDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace)` Called before `HMaster` deletes a namespace It can't bypass the default action, e.g., ctx.bypass() won't have effect.
`void`	`preDeleteSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, org.apache.hadoop.hbase.shaded.protobuf.generated.SnapshotProtos.SnapshotDescription snapshot)` Called before a snapshot is deleted.
`void`	`preDeleteTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName)` Called before `HMaster` deletes a table.
`void`	`preDisableReplicationPeer(ObserverContext<MasterCoprocessorEnvironment> ctx, String peerId)` Called before disable a replication peer
`void`	`preDisableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName)` Called prior to disabling a table.
`void`	`preEnableReplicationPeer(ObserverContext<MasterCoprocessorEnvironment> ctx, String peerId)` Called before enable a replication peer
`void`	`preEnableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName)` Called prior to enabling a table.
`com.google.protobuf.Message`	`preEndpointInvocation(ObserverContext<RegionCoprocessorEnvironment> ctx, com.google.protobuf.Service service, String methodName, com.google.protobuf.Message request)` Called before an Endpoint service method is invoked.
`boolean`	`preExists(ObserverContext<RegionCoprocessorEnvironment> c, Get get, boolean exists)` Called before the client tests for existence using a Get.
`void`	`preFlush(ObserverContext<RegionCoprocessorEnvironment> c)` Called before the memstore is flushed to disk.
`void`	`preGetLocks(ObserverContext<MasterCoprocessorEnvironment> ctx)` Called before a getLocks request has been processed.
`void`	`preGetNamespaceDescriptor(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace)` Called before a getNamespaceDescriptor request has been processed.
`void`	`preGetOp(ObserverContext<RegionCoprocessorEnvironment> c, Get get, List<Cell> result)` Called before the client performs a Get
`void`	`preGetProcedures(ObserverContext<MasterCoprocessorEnvironment> ctx)` Called before a getProcedures request has been processed.
`void`	`preGetReplicationPeerConfig(ObserverContext<MasterCoprocessorEnvironment> ctx, String peerId)` Called before get the configured ReplicationPeerConfig for the specified peer
`void`	`preGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx, List<TableName> tableNamesList, List<TableDescriptor> descriptors, String regex)` Called before a getTableDescriptors request has been processed.
`Result`	`preIncrement(ObserverContext<RegionCoprocessorEnvironment> c, Increment increment)` Called before Increment.
`Result`	`preIncrementAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> c, Increment increment)` Called before Increment but after acquiring rowlock.
`void`	`preListReplicationPeers(ObserverContext<MasterCoprocessorEnvironment> ctx, String regex)` Called before list replication peers.
`void`	`preListSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, org.apache.hadoop.hbase.shaded.protobuf.generated.SnapshotProtos.SnapshotDescription snapshot)` Called before listSnapshots request has been processed.
`void`	`preLockHeartbeat(ObserverContext<MasterCoprocessorEnvironment> ctx, LockProcedure proc, boolean keepAlive)` Called before heartbeat to a lock.
`void`	`preMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx, Region regionA, Region regionB)` Called before the regions merge.
`void`	`preMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx, Region regionA, Region regionB, List<Mutation> metaEntries)` This will be called before PONR step as part of regions merge transaction.
`void`	`preMergeRegions(ObserverContext<MasterCoprocessorEnvironment> ctx, HRegionInfo[] regionsToMerge)` Called before merge regions request.
`void`	`preModifyColumnFamily(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, ColumnFamilyDescriptor columnFamily)` 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> c, TableName tableName, TableDescriptor htd)` Called prior to modifying a table's properties.
`void`	`preMove(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo region, ServerName srcServer, ServerName destServer)` Called prior to moving a given region from one region server to another.
`void`	`preMoveServers(ObserverContext<MasterCoprocessorEnvironment> ctx, Set<Address> servers, String targetGroup)` Called before servers are moved to target region server group
`void`	`preMoveServersAndTables(ObserverContext<MasterCoprocessorEnvironment> ctx, Set<Address> servers, Set<TableName> tables, String targetGroup)` Called before servers are moved to target region server group
`void`	`preMoveTables(ObserverContext<MasterCoprocessorEnvironment> ctx, Set<TableName> tables, String targetGroup)` Called before tables are moved to target region server group
`void`	`preOpen(ObserverContext<RegionCoprocessorEnvironment> c)` Called before the region is reported as open to the master.
`void`	`prePrepareBulkLoad(ObserverContext<RegionCoprocessorEnvironment> ctx, org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.PrepareBulkLoadRequest request)` Authorization check for SecureBulkLoadProtocol.prepareBulkLoad()
`void`	`prePut(ObserverContext<RegionCoprocessorEnvironment> c, Put put, WALEdit edit, Durability durability)` Called before the client stores a value.
`void`	`preRegionOffline(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo)` Called prior to marking a given region as offline.
`void`	`preRemoveReplicationPeer(ObserverContext<MasterCoprocessorEnvironment> ctx, String peerId)` Called before remove a replication peer
`void`	`preRemoveRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx, String name)` Called before a region server group is removed
`void`	`preReplicateLogEntries(ObserverContext<RegionServerCoprocessorEnvironment> ctx, List<org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.WALEntry> entries, CellScanner cells)` This will be called before executing replication request to shipping log entries.
`void`	`preRequestLock(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace, TableName tableName, HRegionInfo[] regionInfos, LockType type, String description)` Called before new LockProcedure is queued.
`void`	`preRestoreSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, org.apache.hadoop.hbase.shaded.protobuf.generated.SnapshotProtos.SnapshotDescription snapshot, TableDescriptor hTableDescriptor)` Called before a snapshot is restored.
`void`	`preRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx, Region regionA, Region regionB)` This will be called before the roll back of the regions merge.
`void`	`preRollWALWriterRequest(ObserverContext<RegionServerCoprocessorEnvironment> ctx)` This will be called before executing user request to roll a region server WAL.
`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> c, Scan scan, RegionScanner s)` Called before the client opens a new scanner.
`void`	`preSetNamespaceQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace, org.apache.hadoop.hbase.shaded.protobuf.generated.QuotaProtos.Quotas quotas)` Called before the quota for the namespace is stored.
`boolean`	`preSetSplitOrMergeEnabled(ObserverContext<MasterCoprocessorEnvironment> ctx, boolean newValue, MasterSwitchType switchType)` Called prior to setting split / merge switch
`void`	`preSetTableQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, org.apache.hadoop.hbase.shaded.protobuf.generated.QuotaProtos.Quotas quotas)` Called before the quota for the table is stored.
`void`	`preSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, String userName, org.apache.hadoop.hbase.shaded.protobuf.generated.QuotaProtos.Quotas quotas)` Called before the quota for the user is stored.
`void`	`preSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, String userName, String namespace, org.apache.hadoop.hbase.shaded.protobuf.generated.QuotaProtos.Quotas quotas)` Called before the quota for the user on the specified namespace is stored.
`void`	`preSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, String userName, TableName tableName, org.apache.hadoop.hbase.shaded.protobuf.generated.QuotaProtos.Quotas quotas)` Called before the quota for the user on the specified table is stored.
`void`	`preShutdown(ObserverContext<MasterCoprocessorEnvironment> c)` Called prior to shutting down the full HBase cluster, including this `HMaster` process.
`void`	`preSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, org.apache.hadoop.hbase.shaded.protobuf.generated.SnapshotProtos.SnapshotDescription snapshot, TableDescriptor hTableDescriptor)` Called before a new snapshot is taken.
`void`	`preSplitRegion(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, byte[] splitRow)` Called before the split region procedure is called.
`void`	`preStopMaster(ObserverContext<MasterCoprocessorEnvironment> c)` Called immediately prior to stopping this `HMaster` process.
`void`	`preStopRegionServer(ObserverContext<RegionServerCoprocessorEnvironment> ctx)` Called before stopping region server.
`void`	`preTableFlush(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)` Called before the table memstore is flushed to disk.
`void`	`preTruncateTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName)` Called before `HMaster` truncates a table.
`void`	`preUnassign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo, boolean force)` Called prior to unassigning a given region.
`void`	`preUpdateReplicationPeerConfig(ObserverContext<MasterCoprocessorEnvironment> ctx, String peerId, ReplicationPeerConfig peerConfig)` Called before update peerConfig for the specified peer
`void`	`requireNamespacePermission(User user, String request, String namespace, Permission.Action... permissions)` Checks that the user has the given global or namespace permission.
`void`	`requireNamespacePermission(User user, String request, String namespace, TableName tableName, Map<byte[],? extends Collection<byte[]>> familyMap, Permission.Action... permissions)` Checks that the user has the given global or namespace permission.
`void`	`revoke(com.google.protobuf.RpcController controller, org.apache.hadoop.hbase.protobuf.generated.AccessControlProtos.RevokeRequest request, com.google.protobuf.RpcCallback<org.apache.hadoop.hbase.protobuf.generated.AccessControlProtos.RevokeResponse> done)`
`void`	`start(CoprocessorEnvironment env)`
`void`	`stop(CoprocessorEnvironment env)`

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.MasterObserver
postAddColumnFamily, postAddReplicationPeer, postAddRSGroup, postAssign, postBalance, postBalanceRSGroup, postBalanceSwitch, postClearDeadServers, postCloneSnapshot, postCompletedAddColumnFamilyAction, postCompletedDeleteColumnFamilyAction, postCompletedDeleteTableAction, postCompletedDisableTableAction, postCompletedEnableTableAction, postCompletedMergeRegionsAction, postCompletedModifyColumnFamilyAction, postCompletedModifyTableAction, postCompletedSplitRegionAction, postCompletedTruncateTableAction, postCreateNamespace, postCreateTable, postDeleteSnapshot, postDisableReplicationPeer, postDisableTable, postEnableReplicationPeer, postEnableTable, postGetLocks, postGetNamespaceDescriptor, postGetReplicationPeerConfig, postListDeadServers, postListReplicationPeers, postListSnapshot, postLockHeartbeat, postMergeRegions, postMergeRegionsCommitAction, postModifyColumnFamily, postModifyNamespace, postMove, postMoveServers, postMoveServersAndTables, postMoveTables, postRegionOffline, postRemoveReplicationPeer, postRemoveRSGroup, postRequestLock, postRestoreSnapshot, postRollBackMergeRegionsAction, postRollBackSplitRegionAction, postSetNamespaceQuota, postSetTableQuota, postSetUserQuota, postSetUserQuota, postSetUserQuota, postSnapshot, postTableFlush, postUnassign, postUpdateReplicationPeerConfig, preAddColumnFamilyAction, preCreateTableAction, preDeleteColumnFamilyAction, preDeleteTableAction, preDisableTableAction, preEnableTableAction, preGetTableNames, preListDeadServers, preListNamespaceDescriptors, preMasterInitialization, preMergeRegionsAction, preMergeRegionsCommitAction, preModifyColumnFamilyAction, preModifyTableAction, preSplitRegionAction, preSplitRegionAfterPONRAction, preSplitRegionBeforePONRAction, preTruncateTableAction

Methods inherited from interface org.apache.hadoop.hbase.coprocessor.RegionServerObserver
postClearCompactionQueues

- Constructor Detail
  - AccessController
```
public AccessController()
```
- Method Detail
  - isAuthorizationSupported
```
public static boolean isAuthorizationSupported(org.apache.hadoop.conf.Configuration conf)
```
  - isCellAuthorizationSupported
```
public static boolean isCellAuthorizationSupported(org.apache.hadoop.conf.Configuration conf)
```
  - getRegion
```
public Region getRegion()
```
  - getAuthManager
```
public TableAuthManager getAuthManager()
```
  - requireNamespacePermission
```
public void requireNamespacePermission(User user,
                                       String request,
                                       String namespace,
                                       Permission.Action... permissions)
                                throws IOException
```
    Checks that the user has the given global or namespace permission.
    
    Parameters:
    
    namespace -
    
    permissions - Actions being requested
    
    Throws:
    
    IOException
  - requireNamespacePermission
```
public void requireNamespacePermission(User user,
                                       String request,
                                       String namespace,
                                       TableName tableName,
                                       Map<byte[],? extends Collection<byte[]>> familyMap,
                                       Permission.Action... permissions)
                                throws IOException
```
    Checks that the user has the given global or namespace permission.
    
    Parameters:
    
    namespace -
    
    permissions - Actions being requested
    
    Throws:
    
    IOException
  - start
```
public void start(CoprocessorEnvironment env)
           throws IOException
```
    Specified by:
    
    start in interface Coprocessor
    
    Throws:
    
    IOException
  - stop
```
public void stop(CoprocessorEnvironment env)
```
    Specified by:
    
    stop in interface Coprocessor
  - preCreateTable
```
public void preCreateTable(ObserverContext<MasterCoprocessorEnvironment> c,
                           TableDescriptor 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:
    
    c - the environment to interact with the framework and master
    
    desc - the TableDescriptor for the table
    
    regions - the initial regions created for the table
    
    Throws:
    
    IOException
  - postCompletedCreateTableAction
```
public void postCompletedCreateTableAction(ObserverContext<MasterCoprocessorEnvironment> c,
                                           TableDescriptor 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 procedure and it is async to the create RPC call.
    
    Specified by:
    
    postCompletedCreateTableAction in interface MasterObserver
    
    Parameters:
    
    c - the environment to interact with the framework and master
    
    desc - the TableDescriptor for the table
    
    regions - the initial regions created for the table
    
    Throws:
    
    IOException
  - preDeleteTable
```
public void preDeleteTable(ObserverContext<MasterCoprocessorEnvironment> c,
                           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:
    
    c - the environment to interact with the framework and master
    
    tableName - the name of the table
    
    Throws:
    
    IOException
  - postDeleteTable
```
public void postDeleteTable(ObserverContext<MasterCoprocessorEnvironment> c,
                            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:
    
    c - the environment to interact with the framework and master
    
    tableName - the name of the table
    
    Throws:
    
    IOException
  - preTruncateTable
```
public void preTruncateTable(ObserverContext<MasterCoprocessorEnvironment> c,
                             TableName tableName)
                      throws IOException
```
    Description copied from interface: MasterObserver
    
    Called before HMaster truncates a table. Called as part of truncate table RPC call. It can't bypass the default action, e.g., ctx.bypass() won't have effect.
    
    Specified by:
    
    preTruncateTable in interface MasterObserver
    
    Parameters:
    
    c - the environment to interact with the framework and master
    
    tableName - the name of the table
    
    Throws:
    
    IOException
  - postTruncateTable
```
public void postTruncateTable(ObserverContext<MasterCoprocessorEnvironment> ctx,
                              TableName tableName)
                       throws IOException
```
    Description copied from interface: MasterObserver
    
    Called after the truncateTable operation has been requested. Called as part of truncate table RPC call. The truncate is synchronous, so this method will be called when the truncate operation is terminated.
    
    Specified by:
    
    postTruncateTable in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    tableName - the name of the table
    
    Throws:
    
    IOException
  - preModifyTable
```
public void preModifyTable(ObserverContext<MasterCoprocessorEnvironment> c,
                           TableName tableName,
                           TableDescriptor 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:
    
    c - the environment to interact with the framework and master
    
    tableName - the name of the table
    
    htd - the TableDescriptor
    
    Throws:
    
    IOException
  - postModifyTable
```
public void postModifyTable(ObserverContext<MasterCoprocessorEnvironment> c,
                            TableName tableName,
                            TableDescriptor 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:
    
    c - the environment to interact with the framework and master
    
    tableName - the name of the table
    
    htd - the TableDescriptor
    
    Throws:
    
    IOException
  - preAddColumnFamily
```
public void preAddColumnFamily(ObserverContext<MasterCoprocessorEnvironment> ctx,
                               TableName tableName,
                               ColumnFamilyDescriptor columnFamily)
                        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:
    
    preAddColumnFamily in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    tableName - the name of the table
    
    columnFamily - the ColumnFamilyDescriptor
    
    Throws:
    
    IOException
  - preModifyColumnFamily
```
public void preModifyColumnFamily(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                  TableName tableName,
                                  ColumnFamilyDescriptor columnFamily)
                           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:
    
    preModifyColumnFamily in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    tableName - the name of the table
    
    columnFamily - the ColumnFamilyDescriptor
    
    Throws:
    
    IOException
  - preDeleteColumnFamily
```
public void preDeleteColumnFamily(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                  TableName tableName,
                                  byte[] columnFamily)
                           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:
    
    preDeleteColumnFamily in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    tableName - the name of the table
    
    columnFamily - the column
    
    Throws:
    
    IOException
  - postDeleteColumnFamily
```
public void postDeleteColumnFamily(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                   TableName tableName,
                                   byte[] columnFamily)
                            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:
    
    postDeleteColumnFamily in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    tableName - the name of the table
    
    columnFamily - the column family
    
    Throws:
    
    IOException
  - preEnableTable
```
public void preEnableTable(ObserverContext<MasterCoprocessorEnvironment> c,
                           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:
    
    c - the environment to interact with the framework and master
    
    tableName - the name of the table
    
    Throws:
    
    IOException
  - preDisableTable
```
public void preDisableTable(ObserverContext<MasterCoprocessorEnvironment> c,
                            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:
    
    c - the environment to interact with the framework and master
    
    tableName - the name of the table
    
    Throws:
    
    IOException
  - preAbortProcedure
```
public void preAbortProcedure(ObserverContext<MasterCoprocessorEnvironment> ctx,
                              ProcedureExecutor<MasterProcedureEnv> procEnv,
                              long procId)
                       throws IOException
```
    Description copied from interface: MasterObserver
    
    Called before a abortProcedure request has been processed.
    
    Specified by:
    
    preAbortProcedure in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    procEnv - procedure executor
    
    procId - the Id of the procedure
    
    Throws:
    
    IOException
  - postAbortProcedure
```
public void postAbortProcedure(ObserverContext<MasterCoprocessorEnvironment> ctx)
                        throws IOException
```
    Description copied from interface: MasterObserver
    
    Called after a abortProcedure request has been processed.
    
    Specified by:
    
    postAbortProcedure in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    Throws:
    
    IOException
  - preGetProcedures
```
public void preGetProcedures(ObserverContext<MasterCoprocessorEnvironment> ctx)
                      throws IOException
```
    Description copied from interface: MasterObserver
    
    Called before a getProcedures request has been processed.
    
    Specified by:
    
    preGetProcedures in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    Throws:
    
    IOException
  - postGetProcedures
```
public void postGetProcedures(ObserverContext<MasterCoprocessorEnvironment> ctx,
                              List<Procedure<?>> procList)
                       throws IOException
```
    Description copied from interface: MasterObserver
    
    Called after a getProcedures request has been processed.
    
    Specified by:
    
    postGetProcedures in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    procList - the list of procedures about to be returned
    
    Throws:
    
    IOException
  - preGetLocks
```
public void preGetLocks(ObserverContext<MasterCoprocessorEnvironment> ctx)
                 throws IOException
```
    Description copied from interface: MasterObserver
    
    Called before a getLocks request has been processed.
    
    Specified by:
    
    preGetLocks in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    Throws:
    
    IOException - if something went wrong
  - preMove
```
public void preMove(ObserverContext<MasterCoprocessorEnvironment> c,
                    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:
    
    c - 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> c,
                      HRegionInfo regionInfo)
               throws IOException
```
    Description copied from interface: MasterObserver
    
    Called prior to assigning a specific region.
    
    Specified by:
    
    preAssign in interface MasterObserver
    
    Parameters:
    
    c - the environment to interact with the framework and master
    
    regionInfo - the regionInfo of the region
    
    Throws:
    
    IOException
  - preUnassign
```
public void preUnassign(ObserverContext<MasterCoprocessorEnvironment> c,
                        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:
    
    c - the environment to interact with the framework and master
    
    force - whether to force unassignment or not
    
    Throws:
    
    IOException
  - preRegionOffline
```
public void preRegionOffline(ObserverContext<MasterCoprocessorEnvironment> c,
                             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:
    
    c - the environment to interact with the framework and master
    
    Throws:
    
    IOException
  - preSetSplitOrMergeEnabled
```
public boolean preSetSplitOrMergeEnabled(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                         boolean newValue,
                                         MasterSwitchType switchType)
                                  throws IOException
```
    Description copied from interface: MasterObserver
    
    Called prior to setting split / merge switch
    
    Specified by:
    
    preSetSplitOrMergeEnabled in interface MasterObserver
    
    Parameters:
    
    ctx - the coprocessor instance's environment
    
    newValue - the new value submitted in the call
    
    switchType - type of switch
    
    Throws:
    
    IOException
  - postSetSplitOrMergeEnabled
```
public void postSetSplitOrMergeEnabled(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                       boolean newValue,
                                       MasterSwitchType switchType)
                                throws IOException
```
    Description copied from interface: MasterObserver
    
    Called after setting split / merge switch
    
    Specified by:
    
    postSetSplitOrMergeEnabled in interface MasterObserver
    
    Parameters:
    
    ctx - the coprocessor instance's environment
    
    newValue - the new value submitted in the call
    
    switchType - type of switch
    
    Throws:
    
    IOException
  - preBalance
```
public void preBalance(ObserverContext<MasterCoprocessorEnvironment> c)
                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:
    
    c - the environment to interact with the framework and master
    
    Throws:
    
    IOException
  - preBalanceSwitch
```
public boolean preBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> c,
                                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:
    
    c - the coprocessor instance's environment
    
    newValue - the new flag value submitted in the call
    
    Throws:
    
    IOException
  - preShutdown
```
public void preShutdown(ObserverContext<MasterCoprocessorEnvironment> c)
                 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> c)
                   throws IOException
```
    Description copied from interface: MasterObserver
    
    Called immediately prior to stopping this HMaster process.
    
    Specified by:
    
    preStopMaster in interface MasterObserver
    
    Throws:
    
    IOException
  - postStartMaster
```
public void postStartMaster(ObserverContext<MasterCoprocessorEnvironment> ctx)
                     throws IOException
```
    Description copied from interface: MasterObserver
    
    Called immediately after an active master instance has completed initialization. Will not be called on standby master instances unless they take over the active role.
    
    Specified by:
    
    postStartMaster in interface MasterObserver
    
    Throws:
    
    IOException
  - preSnapshot
```
public void preSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
                        org.apache.hadoop.hbase.shaded.protobuf.generated.SnapshotProtos.SnapshotDescription snapshot,
                        TableDescriptor 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 TableDescriptor of the table to snapshot
    
    Throws:
    
    IOException
  - preListSnapshot
```
public void preListSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
                            org.apache.hadoop.hbase.shaded.protobuf.generated.SnapshotProtos.SnapshotDescription snapshot)
                     throws IOException
```
    Description copied from interface: MasterObserver
    
    Called before listSnapshots request has been processed. It can't bypass the default action, e.g., ctx.bypass() won't have effect.
    
    Specified by:
    
    preListSnapshot in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    snapshot - the SnapshotDescriptor of the snapshot to list
    
    Throws:
    
    IOException
  - preCloneSnapshot
```
public void preCloneSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
                             org.apache.hadoop.hbase.shaded.protobuf.generated.SnapshotProtos.SnapshotDescription snapshot,
                             TableDescriptor 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 TableDescriptor of the table to create
    
    Throws:
    
    IOException
  - preRestoreSnapshot
```
public void preRestoreSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
                               org.apache.hadoop.hbase.shaded.protobuf.generated.SnapshotProtos.SnapshotDescription snapshot,
                               TableDescriptor 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 TableDescriptor of the table to restore
    
    Throws:
    
    IOException
  - preDeleteSnapshot
```
public void preDeleteSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
                              org.apache.hadoop.hbase.shaded.protobuf.generated.SnapshotProtos.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
  - 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
  - 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
  - preGetNamespaceDescriptor
```
public void preGetNamespaceDescriptor(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                      String namespace)
                               throws IOException
```
    Description copied from interface: MasterObserver
    
    Called before a getNamespaceDescriptor request has been processed.
    
    Specified by:
    
    preGetNamespaceDescriptor in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    namespace - the name of the namespace
    
    Throws:
    
    IOException
  - postListNamespaceDescriptors
```
public void postListNamespaceDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                         List<NamespaceDescriptor> descriptors)
                                  throws IOException
```
    Description copied from interface: MasterObserver
    
    Called after a listNamespaceDescriptors request has been processed.
    
    Specified by:
    
    postListNamespaceDescriptors 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
  - preTableFlush
```
public void preTableFlush(ObserverContext<MasterCoprocessorEnvironment> ctx,
                          TableName tableName)
                   throws IOException
```
    Description copied from interface: MasterObserver
    
    Called before the table memstore is flushed to disk.
    
    Specified by:
    
    preTableFlush in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    tableName - the name of the table
    
    Throws:
    
    IOException
  - preSplitRegion
```
public void preSplitRegion(ObserverContext<MasterCoprocessorEnvironment> ctx,
                           TableName tableName,
                           byte[] splitRow)
                    throws IOException
```
    Description copied from interface: MasterObserver
    
    Called before the split region procedure is called.
    
    Specified by:
    
    preSplitRegion in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    tableName - the table where the region belongs to
    
    splitRow - split point
    
    Throws:
    
    IOException
  - preClearDeadServers
```
public void preClearDeadServers(ObserverContext<MasterCoprocessorEnvironment> ctx)
                         throws IOException
```
    Description copied from interface: MasterObserver
    
    Called before clear dead region servers.
    
    Specified by:
    
    preClearDeadServers in interface MasterObserver
    
    Throws:
    
    IOException
  - preOpen
```
public void preOpen(ObserverContext<RegionCoprocessorEnvironment> c)
             throws IOException
```
    Description copied from interface: RegionObserver
    
    Called before the region is reported as open to the master.
    
    Specified by:
    
    preOpen in interface RegionObserver
    
    Parameters:
    
    c - the environment provided by the region server
    
    Throws:
    
    IOException
  - postOpen
```
public void postOpen(ObserverContext<RegionCoprocessorEnvironment> c)
```
    Description copied from interface: RegionObserver
    
    Called after the region is reported as open to the master.
    
    Specified by:
    
    postOpen in interface RegionObserver
    
    Parameters:
    
    c - the environment provided by the region server
  - postLogReplay
```
public void postLogReplay(ObserverContext<RegionCoprocessorEnvironment> c)
```
    Description copied from interface: RegionObserver
    
    Called after the log replay on the region is over.
    
    Specified by:
    
    postLogReplay in interface RegionObserver
    
    Parameters:
    
    c - the environment provided by the region server
  - preFlush
```
public void preFlush(ObserverContext<RegionCoprocessorEnvironment> c)
              throws IOException
```
    Description copied from interface: RegionObserver
    
    Called before the memstore is flushed to disk.
    
    Specified by:
    
    preFlush in interface RegionObserver
    
    Parameters:
    
    c - the environment provided by the region server
    
    Throws:
    
    IOException
  - preCompact
```
public InternalScanner preCompact(ObserverContext<RegionCoprocessorEnvironment> c,
                                  Store store,
                                  InternalScanner scanner,
                                  ScanType scanType,
                                  CompactionLifeCycleTracker tracker)
                           throws IOException
```
    Description copied from interface: RegionObserver
    Called prior to writing the StoreFiles selected for compaction into a new StoreFile. To override or modify the compaction process, implementing classes have two options:
    - Wrap the provided InternalScanner with a custom implementation that is returned from this method. The custom scanner can then inspect KeyValues from the wrapped scanner, applying its own policy to what gets written.
    - Call ObserverContext.bypass() and provide a custom implementation for writing of new StoreFiles. Note: any implementations bypassing core compaction using this approach must write out new store files themselves or the existing data will no longer be available after compaction.
    Specified by:
    
    preCompact in interface RegionObserver
    
    Parameters:
    
    c - the environment provided by the region server
    
    store - the store being compacted
    
    scanner - the scanner over existing data used in the store file rewriting
    
    scanType - type of Scan
    
    tracker - tracker used to track the life cycle of a compaction
    
    Returns:
    
    the scanner to use during compaction. Should not be null unless the implementation is writing new store files on its own.
    
    Throws:
    
    IOException
  - preGetOp
```
public void preGetOp(ObserverContext<RegionCoprocessorEnvironment> c,
                     Get get,
                     List<Cell> result)
              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
    
    Parameters:
    
    c - the environment provided by the region server
    
    get - the Get request
    
    result - 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
  - preExists
```
public boolean preExists(ObserverContext<RegionCoprocessorEnvironment> c,
                         Get get,
                         boolean exists)
                  throws IOException
```
    Description copied from interface: RegionObserver
    
    Called before the client tests for existence using a Get.
    Call CoprocessorEnvironment#bypass to skip default actions
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    
    Specified by:
    
    preExists in interface RegionObserver
    
    Parameters:
    
    c - the environment provided by the region server
    
    get - the Get request
    
    Returns:
    
    the value to return to the client if bypassing default processing
    
    Throws:
    
    IOException
  - prePut
```
public void prePut(ObserverContext<RegionCoprocessorEnvironment> c,
                   Put put,
                   WALEdit edit,
                   Durability durability)
            throws IOException
```
    Description copied from interface: RegionObserver
    
    Called before the client stores a value.
    Call CoprocessorEnvironment#bypass to skip default actions
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    Note: Do not retain references to any Cells in 'put' beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.
    
    Specified by:
    
    prePut in interface RegionObserver
    
    Parameters:
    
    c - the environment provided by the region server
    
    put - The Put object
    
    edit - The WALEdit object that will be written to the wal
    
    durability - Persistence guarantee for this Put
    
    Throws:
    
    IOException
  - postPut
```
public void postPut(ObserverContext<RegionCoprocessorEnvironment> c,
                    Put put,
                    WALEdit edit,
                    Durability durability)
```
    Description copied from interface: RegionObserver
    
    Called after the client stores a value.
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    Note: Do not retain references to any Cells in 'put' beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.
    
    Specified by:
    
    postPut in interface RegionObserver
    
    Parameters:
    
    c - the environment provided by the region server
    
    put - The Put object
    
    edit - The WALEdit object for the wal
    
    durability - Persistence guarantee for this Put
  - preDelete
```
public void preDelete(ObserverContext<RegionCoprocessorEnvironment> c,
                      Delete delete,
                      WALEdit edit,
                      Durability durability)
               throws IOException
```
    Description copied from interface: RegionObserver
    
    Called before the client deletes a value.
    Call CoprocessorEnvironment#bypass to skip default actions
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    Note: Do not retain references to any Cells in 'delete' beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.
    
    Specified by:
    
    preDelete in interface RegionObserver
    
    Parameters:
    
    c - the environment provided by the region server
    
    delete - The Delete object
    
    edit - The WALEdit object for the wal
    
    durability - Persistence guarantee for this Delete
    
    Throws:
    
    IOException
  - 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 Region to skip these Mutations.
    Note: Do not retain references to any Cells in Mutations beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.
    
    Specified by:
    
    preBatchMutate in interface RegionObserver
    
    Parameters:
    
    c - the environment provided by the region server
    
    miniBatchOp - batch of Mutations getting applied to region.
    
    Throws:
    
    IOException
  - postDelete
```
public void postDelete(ObserverContext<RegionCoprocessorEnvironment> c,
                       Delete delete,
                       WALEdit edit,
                       Durability durability)
                throws IOException
```
    Description copied from interface: RegionObserver
    
    Called after the client deletes a value.
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    Note: Do not retain references to any Cells in 'delete' beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.
    
    Specified by:
    
    postDelete in interface RegionObserver
    
    Parameters:
    
    c - the environment provided by the region server
    
    delete - The Delete object
    
    edit - The WALEdit object for the wal
    
    durability - Persistence guarantee for this Delete
    
    Throws:
    
    IOException
  - preCheckAndPut
```
public boolean preCheckAndPut(ObserverContext<RegionCoprocessorEnvironment> c,
                              byte[] row,
                              byte[] family,
                              byte[] qualifier,
                              CompareOperator op,
                              ByteArrayComparable comparator,
                              Put put,
                              boolean result)
                       throws IOException
```
    Description copied from interface: RegionObserver
    
    Called before checkAndPut.
    Call CoprocessorEnvironment#bypass to skip default actions
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    Note: Do not retain references to any Cells in 'put' beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.
    
    Specified by:
    
    preCheckAndPut in interface RegionObserver
    
    Parameters:
    
    c - the environment provided by the region server
    
    row - row to check
    
    family - column family
    
    qualifier - column qualifier
    
    op - the comparison operation
    
    comparator - the comparator
    
    put - data to put if check succeeds
    
    Returns:
    
    the return value to return to client if bypassing default processing
    
    Throws:
    
    IOException
  - preCheckAndPutAfterRowLock
```
public boolean preCheckAndPutAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> c,
                                          byte[] row,
                                          byte[] family,
                                          byte[] qualifier,
                                          CompareOperator opp,
                                          ByteArrayComparable comparator,
                                          Put put,
                                          boolean result)
                                   throws IOException
```
    Description copied from interface: RegionObserver
    
    Called before checkAndPut but after acquiring rowlock.
    Note: Caution to be taken for not doing any long time operation in this hook. Row will be locked for longer time. Trying to acquire lock on another row, within this, can lead to potential deadlock.
    Call CoprocessorEnvironment#bypass to skip default actions
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    Note: Do not retain references to any Cells in 'put' beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.
    
    Specified by:
    
    preCheckAndPutAfterRowLock in interface RegionObserver
    
    Parameters:
    
    c - the environment provided by the region server
    
    row - row to check
    
    family - column family
    
    qualifier - column qualifier
    
    opp - the comparison operation
    
    comparator - the comparator
    
    put - data to put if check succeeds
    
    Returns:
    
    the return value to return to client if bypassing default processing
    
    Throws:
    
    IOException
  - preCheckAndDelete
```
public boolean preCheckAndDelete(ObserverContext<RegionCoprocessorEnvironment> c,
                                 byte[] row,
                                 byte[] family,
                                 byte[] qualifier,
                                 CompareOperator op,
                                 ByteArrayComparable comparator,
                                 Delete delete,
                                 boolean result)
                          throws IOException
```
    Description copied from interface: RegionObserver
    
    Called before checkAndDelete.
    Call CoprocessorEnvironment#bypass to skip default actions
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    Note: Do not retain references to any Cells in 'delete' beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.
    
    Specified by:
    
    preCheckAndDelete in interface RegionObserver
    
    Parameters:
    
    c - the environment provided by the region server
    
    row - row to check
    
    family - column family
    
    qualifier - column qualifier
    
    op - the comparison operation
    
    comparator - the comparator
    
    delete - delete to commit if check succeeds
    
    Returns:
    
    the value to return to client if bypassing default processing
    
    Throws:
    
    IOException
  - preCheckAndDeleteAfterRowLock
```
public boolean preCheckAndDeleteAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> c,
                                             byte[] row,
                                             byte[] family,
                                             byte[] qualifier,
                                             CompareOperator op,
                                             ByteArrayComparable comparator,
                                             Delete delete,
                                             boolean result)
                                      throws IOException
```
    Description copied from interface: RegionObserver
    
    Called before checkAndDelete but after acquiring rowock.
    Note: Caution to be taken for not doing any long time operation in this hook. Row will be locked for longer time. Trying to acquire lock on another row, within this, can lead to potential deadlock.
    Call CoprocessorEnvironment#bypass to skip default actions
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    Note: Do not retain references to any Cells in 'delete' beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.
    
    Specified by:
    
    preCheckAndDeleteAfterRowLock in interface RegionObserver
    
    Parameters:
    
    c - the environment provided by the region server
    
    row - row to check
    
    family - column family
    
    qualifier - column qualifier
    
    op - the comparison operation
    
    comparator - the comparator
    
    delete - delete to commit if check succeeds
    
    Returns:
    
    the value to return to client if bypassing default processing
    
    Throws:
    
    IOException
  - preAppend
```
public Result preAppend(ObserverContext<RegionCoprocessorEnvironment> c,
                        Append append)
                 throws IOException
```
    Description copied from interface: RegionObserver
    
    Called before Append.
    Call CoprocessorEnvironment#bypass to skip default actions
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    Note: Do not retain references to any Cells in 'append' beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.
    
    Specified by:
    
    preAppend in interface RegionObserver
    
    Parameters:
    
    c - the environment provided by the region server
    
    append - Append object
    
    Returns:
    
    result to return to the client if bypassing default processing
    
    Throws:
    
    IOException
  - preAppendAfterRowLock
```
public Result preAppendAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> c,
                                    Append append)
                             throws IOException
```
    Description copied from interface: RegionObserver
    
    Called before Append but after acquiring rowlock.
    Note: Caution to be taken for not doing any long time operation in this hook. Row will be locked for longer time. Trying to acquire lock on another row, within this, can lead to potential deadlock.
    Call CoprocessorEnvironment#bypass to skip default actions
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    Note: Do not retain references to any Cells in 'append' beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.
    
    Specified by:
    
    preAppendAfterRowLock in interface RegionObserver
    
    Parameters:
    
    c - the environment provided by the region server
    
    append - Append object
    
    Returns:
    
    result to return to the client if bypassing default processing
    
    Throws:
    
    IOException
  - preIncrement
```
public Result preIncrement(ObserverContext<RegionCoprocessorEnvironment> c,
                           Increment increment)
                    throws IOException
```
    Description copied from interface: RegionObserver
    
    Called before Increment.
    Call CoprocessorEnvironment#bypass to skip default actions
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    Note: Do not retain references to any Cells in 'increment' beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.
    
    Specified by:
    
    preIncrement in interface RegionObserver
    
    Parameters:
    
    c - the environment provided by the region server
    
    increment - increment object
    
    Returns:
    
    result to return to the client if bypassing default processing
    
    Throws:
    
    IOException
  - preIncrementAfterRowLock
```
public Result preIncrementAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> c,
                                       Increment increment)
                                throws IOException
```
    Description copied from interface: RegionObserver
    
    Called before Increment but after acquiring rowlock.
    Note: Caution to be taken for not doing any long time operation in this hook. Row will be locked for longer time. Trying to acquire lock on another row, within this, can lead to potential deadlock.
    Call CoprocessorEnvironment#bypass to skip default actions
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    Note: Do not retain references to any Cells in 'increment' beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.
    
    Specified by:
    
    preIncrementAfterRowLock in interface RegionObserver
    
    Parameters:
    
    c - the environment provided by the region server
    
    increment - increment object
    
    Returns:
    
    result to return to the client if bypassing default processing if an error occurred on the coprocessor
    
    Throws:
    
    IOException
  - 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
    
    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
  - preScannerOpen
```
public RegionScanner preScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c,
                                    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
    Note: Do not retain references to any Cells returned by scanner, beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.
    
    Specified by:
    
    preScannerOpen in interface RegionObserver
    
    Parameters:
    
    c - 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
  - 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
    Note: Do not retain references to any Cells returned by scanner, beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.
    
    Specified by:
    
    postScannerOpen in interface RegionObserver
    
    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
  - 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
    Note: Do not retain references to any Cells returned by scanner, beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.
    
    Specified by:
    
    preScannerNext in interface RegionObserver
    
    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
  - 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
    
    Parameters:
    
    c - the environment provided by the region server
    
    s - the scanner
    
    Throws:
    
    IOException
  - 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
    
    Parameters:
    
    c - the environment provided by the region server
    
    s - the scanner
    
    Throws:
    
    IOException
  - postScannerFilterRow
```
public boolean postScannerFilterRow(ObserverContext<RegionCoprocessorEnvironment> e,
                                    InternalScanner s,
                                    Cell curRowCell,
                                    boolean hasMore)
                             throws IOException
```
    Description copied from interface: RegionObserver
    This will be called by the scan flow when the current scanned row is being filtered out by the filter. The filter may be filtering out the row via any of the below scenarios
    1. boolean filterRowKey(byte [] buffer, int offset, int length) returning true
    2. boolean filterRow() returning true
    3. default void filterRow(List<KeyValue> kvs) removing all the kvs from the passed List
    Note: Do not retain references to any Cells returned by scanner, beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.
    Specified by:
    
    postScannerFilterRow in interface RegionObserver
    
    Parameters:
    
    e - the environment provided by the region server
    
    s - the scanner
    
    curRowCell - The cell in the current row which got filtered out
    
    hasMore - the 'has more' indication
    
    Returns:
    
    whether more rows are available for the scanner or not
    
    Throws:
    
    IOException
  - preBulkLoadHFile
```
public void preBulkLoadHFile(ObserverContext<RegionCoprocessorEnvironment> ctx,
                             List<Pair<byte[],String>> familyPaths)
                      throws IOException
```
    Verifies user has CREATE privileges on the Column Families involved in the bulkLoadHFile request. Specific Column Write privileges are presently ignored.
    
    Specified by:
    
    preBulkLoadHFile in interface RegionObserver
    
    Parameters:
    
    ctx - the environment provided by the region server
    
    familyPaths - pairs of { CF, HFile path } submitted for bulk load. Adding or removing from this list will add or remove HFiles to be bulk loaded.
    
    Throws:
    
    IOException
  - prePrepareBulkLoad
```
public void prePrepareBulkLoad(ObserverContext<RegionCoprocessorEnvironment> ctx,
                               org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.PrepareBulkLoadRequest request)
                        throws IOException
```
    Authorization check for SecureBulkLoadProtocol.prepareBulkLoad()
    
    Specified by:
    
    prePrepareBulkLoad in interface BulkLoadObserver
    
    Parameters:
    
    ctx - the context
    
    request - the request
    
    Throws:
    
    IOException
  - preCleanupBulkLoad
```
public void preCleanupBulkLoad(ObserverContext<RegionCoprocessorEnvironment> ctx,
                               org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.CleanupBulkLoadRequest request)
                        throws IOException
```
    Authorization security check for SecureBulkLoadProtocol.cleanupBulkLoad()
    
    Specified by:
    
    preCleanupBulkLoad in interface BulkLoadObserver
    
    Parameters:
    
    ctx - the context
    
    request - the request
    
    Throws:
    
    IOException
  - preEndpointInvocation
```
public com.google.protobuf.Message preEndpointInvocation(ObserverContext<RegionCoprocessorEnvironment> ctx,
                                                         com.google.protobuf.Service service,
                                                         String methodName,
                                                         com.google.protobuf.Message request)
                                                  throws IOException
```
    Description copied from interface: EndpointObserver
    
    Called before an Endpoint service method is invoked. The request message can be altered by returning a new instance. Throwing an exception will abort the invocation. Calling ObserverContext.bypass() has no effect in this hook.
    
    Specified by:
    
    preEndpointInvocation in interface EndpointObserver
    
    Parameters:
    
    ctx - the environment provided by the region server
    
    service - the endpoint service
    
    methodName - the invoked service method
    
    request - Request message expected by given Service's method (by the name methodName).
    
    Returns:
    
    the possibly modified message
    
    Throws:
    
    IOException
  - postEndpointInvocation
```
public void postEndpointInvocation(ObserverContext<RegionCoprocessorEnvironment> ctx,
                                   com.google.protobuf.Service service,
                                   String methodName,
                                   com.google.protobuf.Message request,
                                   com.google.protobuf.Message.Builder responseBuilder)
                            throws IOException
```
    Description copied from interface: EndpointObserver
    
    Called after an Endpoint service method is invoked. The response message can be altered using the builder.
    
    Specified by:
    
    postEndpointInvocation in interface EndpointObserver
    
    Parameters:
    
    ctx - the environment provided by the region server
    
    service - the endpoint service
    
    methodName - the invoked service method
    
    request - Request message expected by given Service's method (by the name methodName).
    
    responseBuilder - Builder for final response to the client, with original response from Service's method merged into it.
    
    Throws:
    
    IOException
  - grant
```
public void grant(com.google.protobuf.RpcController controller,
                  org.apache.hadoop.hbase.protobuf.generated.AccessControlProtos.GrantRequest request,
                  com.google.protobuf.RpcCallback<org.apache.hadoop.hbase.protobuf.generated.AccessControlProtos.GrantResponse> done)
```
    Specified by:
    
    grant in interface org.apache.hadoop.hbase.protobuf.generated.AccessControlProtos.AccessControlService.Interface
  - revoke
```
public void revoke(com.google.protobuf.RpcController controller,
                   org.apache.hadoop.hbase.protobuf.generated.AccessControlProtos.RevokeRequest request,
                   com.google.protobuf.RpcCallback<org.apache.hadoop.hbase.protobuf.generated.AccessControlProtos.RevokeResponse> done)
```
    Specified by:
    
    revoke in interface org.apache.hadoop.hbase.protobuf.generated.AccessControlProtos.AccessControlService.Interface
  - getUserPermissions
```
public void getUserPermissions(com.google.protobuf.RpcController controller,
                               org.apache.hadoop.hbase.protobuf.generated.AccessControlProtos.GetUserPermissionsRequest request,
                               com.google.protobuf.RpcCallback<org.apache.hadoop.hbase.protobuf.generated.AccessControlProtos.GetUserPermissionsResponse> done)
```
    Specified by:
    
    getUserPermissions in interface org.apache.hadoop.hbase.protobuf.generated.AccessControlProtos.AccessControlService.Interface
  - checkPermissions
```
public void checkPermissions(com.google.protobuf.RpcController controller,
                             org.apache.hadoop.hbase.protobuf.generated.AccessControlProtos.CheckPermissionsRequest request,
                             com.google.protobuf.RpcCallback<org.apache.hadoop.hbase.protobuf.generated.AccessControlProtos.CheckPermissionsResponse> done)
```
    Specified by:
    
    checkPermissions in interface org.apache.hadoop.hbase.protobuf.generated.AccessControlProtos.AccessControlService.Interface
  - getService
```
public com.google.protobuf.Service getService()
```
    Specified by:
    
    getService in interface CoprocessorService
  - preClose
```
public void preClose(ObserverContext<RegionCoprocessorEnvironment> c,
                     boolean abortRequested)
              throws IOException
```
    Description copied from interface: RegionObserver
    
    Called before the region is reported as closed to the master.
    
    Specified by:
    
    preClose in interface RegionObserver
    
    Parameters:
    
    c - the environment provided by the region server
    
    abortRequested - true if the region server is aborting
    
    Throws:
    
    IOException
  - preStopRegionServer
```
public void preStopRegionServer(ObserverContext<RegionServerCoprocessorEnvironment> ctx)
                         throws IOException
```
    Description copied from interface: RegionServerObserver
    
    Called before stopping region server.
    
    Specified by:
    
    preStopRegionServer in interface RegionServerObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and region server.
    
    Throws:
    
    IOException
  - preGetTableDescriptors
```
public void preGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                   List<TableName> tableNamesList,
                                   List<TableDescriptor> descriptors,
                                   String regex)
                            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
    
    regex - regular expression used for filtering the table names
    
    Throws:
    
    IOException
  - postGetTableDescriptors
```
public void postGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                    List<TableName> tableNamesList,
                                    List<TableDescriptor> descriptors,
                                    String regex)
                             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
    
    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
  - postGetTableNames
```
public void postGetTableNames(ObserverContext<MasterCoprocessorEnvironment> ctx,
                              List<TableDescriptor> descriptors,
                              String regex)
                       throws IOException
```
    Description copied from interface: MasterObserver
    
    Called after a getTableNames request has been processed.
    
    Specified by:
    
    postGetTableNames in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    descriptors - the list of descriptors about to be returned
    
    regex - regular expression used for filtering the table names
    
    Throws:
    
    IOException
  - preMergeRegions
```
public void preMergeRegions(ObserverContext<MasterCoprocessorEnvironment> ctx,
                            HRegionInfo[] regionsToMerge)
                     throws IOException
```
    Description copied from interface: MasterObserver
    
    Called before merge regions request. It can't bypass the default action, e.g., ctx.bypass() won't have effect.
    
    Specified by:
    
    preMergeRegions in interface MasterObserver
    
    Parameters:
    
    ctx - coprocessor environment
    
    regionsToMerge - regions to be merged
    
    Throws:
    
    IOException
  - preMerge
```
public void preMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
                     Region regionA,
                     Region regionB)
              throws IOException
```
    Description copied from interface: RegionServerObserver
    
    Called before the regions merge. Call ObserverContext.bypass() to skip the merge.
    
    Specified by:
    
    preMerge in interface RegionServerObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and region server.
    
    regionA - region being merged.
    
    regionB - region being merged.
    
    Throws:
    
    IOException
  - postMerge
```
public void postMerge(ObserverContext<RegionServerCoprocessorEnvironment> c,
                      Region regionA,
                      Region regionB,
                      Region mergedRegion)
               throws IOException
```
    Description copied from interface: RegionServerObserver
    
    called after the regions merge.
    
    Specified by:
    
    postMerge in interface RegionServerObserver
    
    Parameters:
    
    c - the environment to interact with the framework and region server.
    
    regionA - region being merged.
    
    regionB - region being merged.
    
    Throws:
    
    IOException
  - preMergeCommit
```
public void preMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
                           Region regionA,
                           Region regionB,
                           List<Mutation> metaEntries)
                    throws IOException
```
    Description copied from interface: RegionServerObserver
    
    This will be called before PONR step as part of regions merge transaction. Calling ObserverContext.bypass() rollback the merge
    
    Specified by:
    
    preMergeCommit in interface RegionServerObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and region server.
    
    regionA - region being merged.
    
    regionB - region being merged.
    
    metaEntries - mutations to execute on hbase:meta atomically with regions merge updates. Any puts or deletes to execute on hbase:meta can be added to the mutations.
    
    Throws:
    
    IOException
  - postMergeCommit
```
public void postMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
                            Region regionA,
                            Region regionB,
                            Region mergedRegion)
                     throws IOException
```
    Description copied from interface: RegionServerObserver
    
    This will be called after PONR step as part of regions merge transaction.
    
    Specified by:
    
    postMergeCommit in interface RegionServerObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and region server.
    
    regionA - region being merged.
    
    regionB - region being merged.
    
    Throws:
    
    IOException
  - preRollBackMerge
```
public void preRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
                             Region regionA,
                             Region regionB)
                      throws IOException
```
    Description copied from interface: RegionServerObserver
    
    This will be called before the roll back of the regions merge.
    
    Specified by:
    
    preRollBackMerge in interface RegionServerObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and region server.
    
    regionA - region being merged.
    
    regionB - region being merged.
    
    Throws:
    
    IOException
  - postRollBackMerge
```
public void postRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
                              Region regionA,
                              Region regionB)
                       throws IOException
```
    Description copied from interface: RegionServerObserver
    
    This will be called after the roll back of the regions merge.
    
    Specified by:
    
    postRollBackMerge in interface RegionServerObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and region server.
    
    regionA - region being merged.
    
    regionB - region being merged.
    
    Throws:
    
    IOException
  - preRollWALWriterRequest
```
public void preRollWALWriterRequest(ObserverContext<RegionServerCoprocessorEnvironment> ctx)
                             throws IOException
```
    Description copied from interface: RegionServerObserver
    
    This will be called before executing user request to roll a region server WAL.
    
    Specified by:
    
    preRollWALWriterRequest in interface RegionServerObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and region server.
    
    Throws:
    
    IOException
  - postRollWALWriterRequest
```
public void postRollWALWriterRequest(ObserverContext<RegionServerCoprocessorEnvironment> ctx)
                              throws IOException
```
    Description copied from interface: RegionServerObserver
    
    This will be called after executing user request to roll a region server WAL.
    
    Specified by:
    
    postRollWALWriterRequest in interface RegionServerObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and region server.
    
    Throws:
    
    IOException
  - preSetUserQuota
```
public void preSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx,
                            String userName,
                            org.apache.hadoop.hbase.shaded.protobuf.generated.QuotaProtos.Quotas quotas)
                     throws IOException
```
    Description copied from interface: MasterObserver
    
    Called before the quota for the user is stored.
    
    Specified by:
    
    preSetUserQuota in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    userName - the name of user
    
    quotas - the quota settings
    
    Throws:
    
    IOException
  - preSetUserQuota
```
public void preSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx,
                            String userName,
                            TableName tableName,
                            org.apache.hadoop.hbase.shaded.protobuf.generated.QuotaProtos.Quotas quotas)
                     throws IOException
```
    Description copied from interface: MasterObserver
    
    Called before the quota for the user on the specified table is stored.
    
    Specified by:
    
    preSetUserQuota in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    userName - the name of user
    
    tableName - the name of the table
    
    quotas - the quota settings
    
    Throws:
    
    IOException
  - preSetUserQuota
```
public void preSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx,
                            String userName,
                            String namespace,
                            org.apache.hadoop.hbase.shaded.protobuf.generated.QuotaProtos.Quotas quotas)
                     throws IOException
```
    Description copied from interface: MasterObserver
    
    Called before the quota for the user on the specified namespace is stored.
    
    Specified by:
    
    preSetUserQuota in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    userName - the name of user
    
    namespace - the name of the namespace
    
    quotas - the quota settings
    
    Throws:
    
    IOException
  - preSetTableQuota
```
public void preSetTableQuota(ObserverContext<MasterCoprocessorEnvironment> ctx,
                             TableName tableName,
                             org.apache.hadoop.hbase.shaded.protobuf.generated.QuotaProtos.Quotas quotas)
                      throws IOException
```
    Description copied from interface: MasterObserver
    
    Called before the quota for the table is stored.
    
    Specified by:
    
    preSetTableQuota in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    tableName - the name of the table
    
    quotas - the quota settings
    
    Throws:
    
    IOException
  - preSetNamespaceQuota
```
public void preSetNamespaceQuota(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                 String namespace,
                                 org.apache.hadoop.hbase.shaded.protobuf.generated.QuotaProtos.Quotas quotas)
                          throws IOException
```
    Description copied from interface: MasterObserver
    
    Called before the quota for the namespace is stored.
    
    Specified by:
    
    preSetNamespaceQuota in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    namespace - the name of the namespace
    
    quotas - the quota settings
    
    Throws:
    
    IOException
  - postCreateReplicationEndPoint
```
public ReplicationEndpoint postCreateReplicationEndPoint(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
                                                         ReplicationEndpoint endpoint)
```
    Description copied from interface: RegionServerObserver
    
    This will be called after the replication endpoint is instantiated.
    
    Specified by:
    
    postCreateReplicationEndPoint in interface RegionServerObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and region server.
    
    endpoint - - the base endpoint for replication
    
    Returns:
    
    the endpoint to use during replication.
  - preReplicateLogEntries
```
public void preReplicateLogEntries(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
                                   List<org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.WALEntry> entries,
                                   CellScanner cells)
                            throws IOException
```
    Description copied from interface: RegionServerObserver
    
    This will be called before executing replication request to shipping log entries.
    
    Specified by:
    
    preReplicateLogEntries in interface RegionServerObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and region server.
    
    entries - list of WALEntries to replicate
    
    cells - Cells that the WALEntries refer to (if cells is non-null)
    
    Throws:
    
    IOException
  - postReplicateLogEntries
```
public void postReplicateLogEntries(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
                                    List<org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.WALEntry> entries,
                                    CellScanner cells)
                             throws IOException
```
    Description copied from interface: RegionServerObserver
    
    This will be called after executing replication request to shipping log entries.
    
    Specified by:
    
    postReplicateLogEntries in interface RegionServerObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and region server.
    
    entries - list of WALEntries to replicate
    
    cells - Cells that the WALEntries refer to (if cells is non-null)
    
    Throws:
    
    IOException
  - preClearCompactionQueues
```
public void preClearCompactionQueues(ObserverContext<RegionServerCoprocessorEnvironment> ctx)
                              throws IOException
```
    Description copied from interface: RegionServerObserver
    
    This will be called before clearing compaction queues
    
    Specified by:
    
    preClearCompactionQueues in interface RegionServerObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and region server.
    
    Throws:
    
    IOException
  - preMoveServersAndTables
```
public void preMoveServersAndTables(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                    Set<Address> servers,
                                    Set<TableName> tables,
                                    String targetGroup)
                             throws IOException
```
    Description copied from interface: MasterObserver
    
    Called before servers are moved to target region server group
    
    Specified by:
    
    preMoveServersAndTables in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    servers - set of servers to move
    
    targetGroup - destination group
    
    Throws:
    
    IOException
  - preMoveServers
```
public void preMoveServers(ObserverContext<MasterCoprocessorEnvironment> ctx,
                           Set<Address> servers,
                           String targetGroup)
                    throws IOException
```
    Description copied from interface: MasterObserver
    
    Called before servers are moved to target region server group
    
    Specified by:
    
    preMoveServers in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    servers - set of servers to move
    
    targetGroup - destination group
    
    Throws:
    
    IOException
  - preMoveTables
```
public void preMoveTables(ObserverContext<MasterCoprocessorEnvironment> ctx,
                          Set<TableName> tables,
                          String targetGroup)
                   throws IOException
```
    Description copied from interface: MasterObserver
    
    Called before tables are moved to target region server group
    
    Specified by:
    
    preMoveTables in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    tables - set of tables to move
    
    targetGroup - name of group
    
    Throws:
    
    IOException
  - preAddRSGroup
```
public void preAddRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx,
                          String name)
                   throws IOException
```
    Description copied from interface: MasterObserver
    
    Called before a new region server group is added
    
    Specified by:
    
    preAddRSGroup in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    name - group name
    
    Throws:
    
    IOException
  - preRemoveRSGroup
```
public void preRemoveRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx,
                             String name)
                      throws IOException
```
    Description copied from interface: MasterObserver
    
    Called before a region server group is removed
    
    Specified by:
    
    preRemoveRSGroup in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    name - group name
    
    Throws:
    
    IOException
  - preBalanceRSGroup
```
public void preBalanceRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx,
                              String groupName)
                       throws IOException
```
    Description copied from interface: MasterObserver
    
    Called before a region server group is removed
    
    Specified by:
    
    preBalanceRSGroup in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    groupName - group name
    
    Throws:
    
    IOException
  - preAddReplicationPeer
```
public void preAddReplicationPeer(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                  String peerId,
                                  ReplicationPeerConfig peerConfig)
                           throws IOException
```
    Description copied from interface: MasterObserver
    
    Called before add a replication peer
    
    Specified by:
    
    preAddReplicationPeer in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    peerId - a short name that identifies the peer
    
    peerConfig - configuration for the replication peer
    
    Throws:
    
    IOException
  - preRemoveReplicationPeer
```
public void preRemoveReplicationPeer(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                     String peerId)
                              throws IOException
```
    Description copied from interface: MasterObserver
    
    Called before remove a replication peer
    
    Specified by:
    
    preRemoveReplicationPeer in interface MasterObserver
    
    peerId - a short name that identifies the peer
    
    Throws:
    
    IOException
  - preEnableReplicationPeer
```
public void preEnableReplicationPeer(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                     String peerId)
                              throws IOException
```
    Description copied from interface: MasterObserver
    
    Called before enable a replication peer
    
    Specified by:
    
    preEnableReplicationPeer in interface MasterObserver
    
    peerId - a short name that identifies the peer
    
    Throws:
    
    IOException
  - preDisableReplicationPeer
```
public void preDisableReplicationPeer(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                      String peerId)
                               throws IOException
```
    Description copied from interface: MasterObserver
    
    Called before disable a replication peer
    
    Specified by:
    
    preDisableReplicationPeer in interface MasterObserver
    
    peerId - a short name that identifies the peer
    
    Throws:
    
    IOException
  - preGetReplicationPeerConfig
```
public void preGetReplicationPeerConfig(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                        String peerId)
                                 throws IOException
```
    Description copied from interface: MasterObserver
    
    Called before get the configured ReplicationPeerConfig for the specified peer
    
    Specified by:
    
    preGetReplicationPeerConfig in interface MasterObserver
    
    peerId - a short name that identifies the peer
    
    Throws:
    
    IOException
  - preUpdateReplicationPeerConfig
```
public void preUpdateReplicationPeerConfig(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                           String peerId,
                                           ReplicationPeerConfig peerConfig)
                                    throws IOException
```
    Description copied from interface: MasterObserver
    
    Called before update peerConfig for the specified peer
    
    Specified by:
    
    preUpdateReplicationPeerConfig in interface MasterObserver
    
    peerId - a short name that identifies the peer
    
    Throws:
    
    IOException
  - preListReplicationPeers
```
public void preListReplicationPeers(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                    String regex)
                             throws IOException
```
    Description copied from interface: MasterObserver
    
    Called before list replication peers.
    
    Specified by:
    
    preListReplicationPeers in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    regex - The regular expression to match peer id
    
    Throws:
    
    IOException
  - preRequestLock
```
public void preRequestLock(ObserverContext<MasterCoprocessorEnvironment> ctx,
                           String namespace,
                           TableName tableName,
                           HRegionInfo[] regionInfos,
                           LockType type,
                           String description)
                    throws IOException
```
    Description copied from interface: MasterObserver
    
    Called before new LockProcedure is queued.
    
    Specified by:
    
    preRequestLock in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    Throws:
    
    IOException
  - preLockHeartbeat
```
public void preLockHeartbeat(ObserverContext<MasterCoprocessorEnvironment> ctx,
                             LockProcedure proc,
                             boolean keepAlive)
                      throws IOException
```
    Description copied from interface: MasterObserver
    
    Called before heartbeat to a lock.
    
    Specified by:
    
    preLockHeartbeat in interface MasterObserver
    
    Parameters:
    
    ctx - the environment to interact with the framework and master
    
    keepAlive - if lock should be kept alive; lock will be released if set to false.
    
    Throws:
    
    IOException

Class AccessController

Nested Class Summary

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

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

Field Summary

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

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

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

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

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

Constructor Detail

AccessController

Method Detail

isAuthorizationSupported

isCellAuthorizationSupported

getRegion

getAuthManager

requireNamespacePermission

requireNamespacePermission

start

stop

preCreateTable

postCompletedCreateTableAction

preDeleteTable

postDeleteTable

preTruncateTable

postTruncateTable

preModifyTable

postModifyTable

preAddColumnFamily

preModifyColumnFamily

preDeleteColumnFamily

postDeleteColumnFamily

preEnableTable

preDisableTable

preAbortProcedure

postAbortProcedure

preGetProcedures

postGetProcedures

preGetLocks

preMove

preAssign

preUnassign

preRegionOffline

preSetSplitOrMergeEnabled

postSetSplitOrMergeEnabled

preBalance

preBalanceSwitch

preShutdown

preStopMaster

postStartMaster

preSnapshot

preListSnapshot

preCloneSnapshot

preRestoreSnapshot

preDeleteSnapshot

preCreateNamespace

preDeleteNamespace

postDeleteNamespace

preModifyNamespace

preGetNamespaceDescriptor

postListNamespaceDescriptors

preTableFlush

preSplitRegion

preClearDeadServers

preOpen

postOpen

postLogReplay

preFlush

preCompact

preGetOp

preExists

prePut

postPut

preDelete

preBatchMutate

postDelete

preCheckAndPut