AccessController (Apache HBase - Server 1.4.14 API)

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

所有已实现的接口:

Coprocessor, BulkLoadObserver, CoprocessorService, EndpointObserver, MasterObserver, RegionObserver, RegionServerObserver, org.apache.hadoop.hbase.protobuf.generated.AccessControlProtos.AccessControlService.Interface
```
@InterfaceAudience.LimitedPrivate(value="Configuration")
public class AccessController
extends BaseMasterAndRegionObserver
implements 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.

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

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

构造器概要

构造器
构造器和说明

AccessController()

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

方法概要

方法
限定符和类型	方法和说明
`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`	`postClearDeadServers(ObserverContext<MasterCoprocessorEnvironment> ctx, List<ServerName> servers, List<ServerName> notClearedServers)` Called after clear dead region servers.
`ReplicationEndpoint`	`postCreateReplicationEndPoint(ObserverContext<RegionServerCoprocessorEnvironment> ctx, ReplicationEndpoint endpoint)` This will be called after the replication endpoint is instantiated.
`void`	`postCreateTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, HTableDescriptor desc, HRegionInfo[] regions)` Called after the createTable operation has been requested.
`void`	`postDelete(ObserverContext<RegionCoprocessorEnvironment> c, Delete delete, WALEdit edit, Durability durability)` Called after the client deletes a value.
`void`	`postDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, byte[] col)` 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`	`postGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx, List<TableName> tableNamesList, List<HTableDescriptor> descriptors, String regex)` Called after a getTableDescriptors request has been processed.
`void`	`postGetTableNames(ObserverContext<MasterCoprocessorEnvironment> ctx, List<HTableDescriptor> descriptors, String regex)` Called after a getTableNames request has been processed.
`void`	`postListNamespaceDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx, List<NamespaceDescriptor> descriptors)` Called after a listNamespaceDescriptors request has been processed.
`void`	`postListProcedures(ObserverContext<MasterCoprocessorEnvironment> ctx, List<ProcedureInfo> procInfoList)` Called after a listProcedures request has been processed.
`void`	`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, HTableDescriptor 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.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.
`RegionScanner`	`postScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c, Scan scan, RegionScanner s)` Called after the client opens a new scanner.
`void`	`postSetSplitOrMergeEnabled(ObserverContext<MasterCoprocessorEnvironment> ctx, boolean newValue, Admin.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`	`preAddColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor column)` Called prior to adding a new column family to the table.
`void`	`preAddRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx, String name)` Called before a new region server group is added
`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, CompareFilter.CompareOp compareOp, ByteArrayComparable comparator, Delete delete, boolean result)` Called before checkAndDelete.
`boolean`	`preCheckAndDeleteAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> c, byte[] row, byte[] family, byte[] qualifier, CompareFilter.CompareOp compareOp, ByteArrayComparable comparator, Delete delete, boolean result)` Called before checkAndDelete but after acquiring rowock.
`boolean`	`preCheckAndPut(ObserverContext<RegionCoprocessorEnvironment> c, byte[] row, byte[] family, byte[] qualifier, CompareFilter.CompareOp compareOp, ByteArrayComparable comparator, Put put, boolean result)` Called before checkAndPut.
`boolean`	`preCheckAndPutAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> c, byte[] row, byte[] family, byte[] qualifier, CompareFilter.CompareOp compareOp, ByteArrayComparable comparator, Put put, boolean result)` Called before checkAndPut but after acquiring rowlock.
`void`	`preCleanupBulkLoad(ObserverContext<RegionCoprocessorEnvironment> ctx, org.apache.hadoop.hbase.protobuf.generated.SecureBulkLoadProtos.CleanupBulkLoadRequest request)` Authorization security check for SecureBulkLoadProtocol.cleanupBulkLoad()
`void`	`preClearDeadServers(ObserverContext<MasterCoprocessorEnvironment> ctx)` Called before clear dead region servers.
`void`	`preCloneSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.SnapshotDescription snapshot, HTableDescriptor hTableDescriptor)` Called before a snapshot is cloned.
`void`	`preClose(ObserverContext<RegionCoprocessorEnvironment> e, boolean abortRequested)` Called before the region is reported as closed to the master.
`InternalScanner`	`preCompact(ObserverContext<RegionCoprocessorEnvironment> e, Store store, InternalScanner scanner, ScanType scanType)` 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, HTableDescriptor 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`	`preDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, byte[] col)` Called prior to deleting the entire column family.
`void`	`preDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace)` Called before `HMaster` deletes a namespace It can't bypass the default action, e.g., ctx.bypass() won't have effect.
`void`	`preDeleteSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.SnapshotDescription snapshot)` Called before a snapshot is deleted.
`void`	`preDeleteTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName)` Called before `HMaster` deletes a table.
`void`	`preDisableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName)` Called prior to disabling a table.
`void`	`preDispatchMerge(ObserverContext<MasterCoprocessorEnvironment> ctx, HRegionInfo regionA, HRegionInfo regionB)` Called before dispatching region merge request.
`void`	`preEnableTable(ObserverContext<MasterCoprocessorEnvironment> 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> e)` Called before the memstore is flushed to disk.
`void`	`preGetClosestRowBefore(ObserverContext<RegionCoprocessorEnvironment> c, byte[] row, byte[] family, Result result)` Called before a client makes a GetClosestRowBefore request.
`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 Call CoprocessorEnvironment#bypass to skip default actions Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
`void`	`preGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx, List<TableName> tableNamesList, List<HTableDescriptor> 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.
`long`	`preIncrementColumnValue(ObserverContext<RegionCoprocessorEnvironment> c, byte[] row, byte[] family, byte[] qualifier, long amount, boolean writeToWAL)` Called before incrementColumnValue Call CoprocessorEnvironment#bypass to skip default actions Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
`void`	`preListProcedures(ObserverContext<MasterCoprocessorEnvironment> ctx)` Called before a listProcedures request has been processed.
`void`	`preListSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.SnapshotDescription snapshot)` Called before listSnapshots request has been processed.
`void`	`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`	`preModifyColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor descriptor)` Called prior to modifying a column family's attributes.
`void`	`preModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns)` Called prior to modifying a namespace's properties.
`void`	`preModifyTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HTableDescriptor 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> e)` Called before the region is reported as open to the master.
`void`	`prePrepareBulkLoad(ObserverContext<RegionCoprocessorEnvironment> ctx, org.apache.hadoop.hbase.protobuf.generated.SecureBulkLoadProtos.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`	`preRemoveRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx, String name)` Called before a region server group is removed
`void`	`preRemoveServers(ObserverContext<MasterCoprocessorEnvironment> ctx, Set<Address> servers)` Called before servers are removed from rsgroup
`void`	`preReplicateLogEntries(ObserverContext<RegionServerCoprocessorEnvironment> ctx, List<org.apache.hadoop.hbase.protobuf.generated.AdminProtos.WALEntry> entries, CellScanner cells)` This will be called before executing replication request to shipping log entries.
`void`	`preRestoreSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.SnapshotDescription snapshot, HTableDescriptor 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.protobuf.generated.QuotaProtos.Quotas quotas)` Called before the quota for the namespace is stored.
`boolean`	`preSetSplitOrMergeEnabled(ObserverContext<MasterCoprocessorEnvironment> ctx, boolean newValue, Admin.MasterSwitchType switchType)` Called prior to setting split / merge switch
`void`	`preSetTableQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, org.apache.hadoop.hbase.protobuf.generated.QuotaProtos.Quotas quotas)` Called before the quota for the table is stored.
`void`	`preSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, String userName, org.apache.hadoop.hbase.protobuf.generated.QuotaProtos.Quotas quotas)` Called before the quota for the user is stored.
`void`	`preSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, String userName, String namespace, org.apache.hadoop.hbase.protobuf.generated.QuotaProtos.Quotas quotas)` Called before the quota for the user on the specified namespace is stored.
`void`	`preSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, String userName, TableName tableName, org.apache.hadoop.hbase.protobuf.generated.QuotaProtos.Quotas quotas)` Called before the quota for the user on the specified table is stored.
`void`	`preShutdown(ObserverContext<MasterCoprocessorEnvironment> c)` Called prior to shutting down the full HBase cluster, including this `HMaster` process.
`void`	`preSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.SnapshotDescription snapshot, HTableDescriptor hTableDescriptor)` Called before a new snapshot is taken.
`void`	`preSplit(ObserverContext<RegionCoprocessorEnvironment> e)` Called before the region is split.
`void`	`preSplit(ObserverContext<RegionCoprocessorEnvironment> e, byte[] splitRow)` Called before the region is split.
`void`	`preStopMaster(ObserverContext<MasterCoprocessorEnvironment> c)` Called immediately prior to stopping this `HMaster` process.
`void`	`preStopRegionServer(ObserverContext<RegionServerCoprocessorEnvironment> env)` 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`	`requireAccess(String request, TableName tableName, Permission.Action... permissions)` Authorizes that the current user has any of the given permissions to access the table.
`void`	`requireGlobalPermission(String request, Permission.Action perm, String namespace)` Checks that the user has the given global permission.
`void`	`requireGlobalPermission(String request, Permission.Action perm, TableName tableName, Map<byte[],? extends Collection<byte[]>> familyMap)` Checks that the user has the given global permission.
`void`	`requireNamespacePermission(String request, String namespace, Permission.Action... permissions)` Checks that the user has the given global or namespace permission.
`void`	`requireNamespacePermission(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`	`requirePermission(String request, Permission.Action perm)` Authorizes that the current user has global privileges for the given action.
`void`	`requirePermission(String request, TableName tableName, byte[] family, byte[] qualifier, Permission.Action... permissions)` Authorizes that the current user has any of the given permissions for the given table, column family and column qualifier.
`void`	`requireTablePermission(String request, TableName tableName, byte[] family, byte[] qualifier, Permission.Action... permissions)` Authorizes that the current user has any of the given permissions for the given table, column family and column qualifier.
`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)`

从类继承的方法 org.apache.hadoop.hbase.coprocessor.BaseMasterAndRegionObserver
postAddColumn, postAddColumnHandler, postAddRSGroup, postAssign, postBalance, postBalanceRSGroup, postBalanceSwitch, postCloneSnapshot, postCreateNamespace, postCreateTable, postDeleteColumnHandler, postDeleteSnapshot, postDeleteTableHandler, postDisableTable, postDisableTableHandler, postDispatchMerge, postEnableTable, postEnableTableHandler, postGetClusterStatus, postGetNamespaceDescriptor, postGetTableDescriptors, postListSnapshot, postModifyColumn, postModifyColumnHandler, postModifyNamespace, postModifyTableHandler, postMove, postMoveServers, postMoveServersAndTables, postMoveTables, postRegionOffline, postRemoveRSGroup, postRemoveServers, postRestoreSnapshot, postSetNamespaceQuota, postSetTableQuota, postSetUserQuota, postSetUserQuota, postSetUserQuota, postSnapshot, postTableFlush, postTruncateTableHandler, postUnassign, preAddColumnHandler, preCreateTableHandler, preDeleteColumnHandler, preDeleteTableHandler, preDisableTableHandler, preEnableTableHandler, preGetClusterStatus, preGetTableDescriptors, preGetTableNames, preListNamespaceDescriptors, preMasterInitialization, preModifyColumnHandler, preModifyTableHandler, preTruncateTableHandler

从类继承的方法 org.apache.hadoop.hbase.coprocessor.BaseRegionObserver
postAppend, postBatchMutate, postBatchMutateIndispensably, postBulkLoadHFile, postCheckAndDelete, postCheckAndPut, postClose, postCloseRegionOperation, postCommitStoreFile, postCompact, postCompact, postCompactSelection, postCompactSelection, postCompleteSplit, postExists, postFlush, postFlush, postGetClosestRowBefore, postGetOp, postIncrement, postIncrementColumnValue, postInstantiateDeleteTracker, postRollBackSplit, postScannerFilterRow, postScannerNext, postSplit, postStartRegionOperation, postStoreFileReaderOpen, postWALRestore, postWALRestore, preCommitStoreFile, preCompact, preCompactScannerOpen, preCompactScannerOpen, preCompactScannerOpen, preCompactSelection, preCompactSelection, preFlush, preFlushScannerOpen, preFlushScannerOpen, prePrepareTimeStampForDeleteVersion, preRollBackSplit, preSplitAfterPONR, preSplitBeforePONR, preStoreFileReaderOpen, preStoreScannerOpen, preWALRestore, preWALRestore

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

- 构造器详细资料
  - AccessController
```
public AccessController()
```
- 方法详细资料
  - 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()
```
  - requirePermission
```
public void requirePermission(String request,
                     TableName tableName,
                     byte[] family,
                     byte[] qualifier,
                     Permission.Action... permissions)
                       throws IOException
```
    Authorizes that the current user has any of the given permissions for the given table, column family and column qualifier.
    
    参数:
    tableName - Table requested
    family - Column family requested
    qualifier - Column qualifier requested
    
    抛出:
    
    IOException - if obtaining the current user fails
    
    AccessDeniedException - if user has no authorization
  - requireTablePermission
```
public void requireTablePermission(String request,
                          TableName tableName,
                          byte[] family,
                          byte[] qualifier,
                          Permission.Action... permissions)
                            throws IOException
```
    Authorizes that the current user has any of the given permissions for the given table, column family and column qualifier.
    
    参数:
    tableName - Table requested
    family - Column family param
    qualifier - Column qualifier param
    
    抛出:
    
    IOException - if obtaining the current user fails
    
    AccessDeniedException - if user has no authorization
  - requireAccess
```
public void requireAccess(String request,
                 TableName tableName,
                 Permission.Action... permissions)
                   throws IOException
```
    Authorizes that the current user has any of the given permissions to access the table.
    
    参数:
    tableName - Table requested
    permissions - Actions being requested
    
    抛出:
    
    IOException - if obtaining the current user fails
    
    AccessDeniedException - if user has no authorization
  - requirePermission
```
public void requirePermission(String request,
                     Permission.Action perm)
                       throws IOException
```
    Authorizes that the current user has global privileges for the given action.
    
    参数:
    perm - The action being requested
    
    抛出:
    
    IOException - if obtaining the current user fails
    
    AccessDeniedException - if authorization is denied
  - requireGlobalPermission
```
public void requireGlobalPermission(String request,
                           Permission.Action perm,
                           TableName tableName,
                           Map<byte[],? extends Collection<byte[]>> familyMap)
                             throws IOException
```
    Checks that the user has the given global permission. The generated audit log message will contain context information for the operation being authorized, based on the given parameters.
    
    参数:
    perm - Action being requested
    tableName - Affected table name.
    familyMap - Affected column families.
    
    抛出:
    
    IOException
  - requireGlobalPermission
```
public void requireGlobalPermission(String request,
                           Permission.Action perm,
                           String namespace)
                             throws IOException
```
    Checks that the user has the given global permission. The generated audit log message will contain context information for the operation being authorized, based on the given parameters.
    
    参数:
    perm - Action being requested
    namespace - The given namespace
    
    抛出:
    
    IOException
  - requireNamespacePermission
```
public void requireNamespacePermission(String request,
                              String namespace,
                              Permission.Action... permissions)
                                throws IOException
```
    Checks that the user has the given global or namespace permission.
    
    参数:
    namespace - The given namespace
    permissions - Actions being requested
    
    抛出:
    
    IOException
  - requireNamespacePermission
```
public void requireNamespacePermission(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.
    
    参数:
    namespace - The given namespace
    permissions - Actions being requested
    
    抛出:
    
    IOException
  - start
```
public void start(CoprocessorEnvironment env)
           throws IOException
```
    指定者:
    
    start 在接口中 Coprocessor
    
    覆盖:
    
    start 在类中 BaseMasterAndRegionObserver
    
    抛出:
    
    IOException
  - stop
```
public void stop(CoprocessorEnvironment env)
```
    指定者:
    
    stop 在接口中 Coprocessor
    
    覆盖:
    
    stop 在类中 BaseMasterAndRegionObserver
  - preCreateTable
```
public void preCreateTable(ObserverContext<MasterCoprocessorEnvironment> c,
                  HTableDescriptor desc,
                  HRegionInfo[] regions)
                    throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before a new table is created by HMaster. Called as part of create table RPC call. It can't bypass the default action, e.g., ctx.bypass() won't have effect.
    
    指定者:
    
    preCreateTable 在接口中 MasterObserver
    
    覆盖:
    
    preCreateTable 在类中 BaseMasterAndRegionObserver
    
    参数:
    c - the environment to interact with the framework and master
    desc - the HTableDescriptor for the table
    regions - the initial regions created for the table
    
    抛出:
    
    IOException
  - postCreateTableHandler
```
public void postCreateTableHandler(ObserverContext<MasterCoprocessorEnvironment> c,
                          HTableDescriptor desc,
                          HRegionInfo[] regions)
                            throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called after the createTable operation has been requested. Called as part of create table RPC call. Called as part of create table handler and it is async to the create RPC call.
    
    指定者:
    
    postCreateTableHandler 在接口中 MasterObserver
    
    覆盖:
    
    postCreateTableHandler 在类中 BaseMasterAndRegionObserver
    
    参数:
    c - the environment to interact with the framework and master
    desc - the HTableDescriptor for the table
    regions - the initial regions created for the table
    
    抛出:
    
    IOException
  - preDeleteTable
```
public void preDeleteTable(ObserverContext<MasterCoprocessorEnvironment> c,
                  TableName tableName)
                    throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before HMaster deletes a table. Called as part of delete table RPC call. It can't bypass the default action, e.g., ctx.bypass() won't have effect.
    
    指定者:
    
    preDeleteTable 在接口中 MasterObserver
    
    覆盖:
    
    preDeleteTable 在类中 BaseMasterAndRegionObserver
    
    参数:
    c - the environment to interact with the framework and master
    tableName - the name of the table
    
    抛出:
    
    IOException
  - postDeleteTable
```
public void postDeleteTable(ObserverContext<MasterCoprocessorEnvironment> c,
                   TableName tableName)
                     throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called after the deleteTable operation has been requested. Called as part of delete table RPC call.
    
    指定者:
    
    postDeleteTable 在接口中 MasterObserver
    
    覆盖:
    
    postDeleteTable 在类中 BaseMasterAndRegionObserver
    
    参数:
    c - the environment to interact with the framework and master
    tableName - the name of the table
    
    抛出:
    
    IOException
  - preTruncateTable
```
public void preTruncateTable(ObserverContext<MasterCoprocessorEnvironment> c,
                    TableName tableName)
                      throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before HMaster truncates a table. Called as part of truncate table RPC call. It can't bypass the default action, e.g., ctx.bypass() won't have effect.
    
    指定者:
    
    preTruncateTable 在接口中 MasterObserver
    
    覆盖:
    
    preTruncateTable 在类中 BaseMasterAndRegionObserver
    
    参数:
    c - the environment to interact with the framework and master
    tableName - the name of the table
    
    抛出:
    
    IOException
  - postTruncateTable
```
public void postTruncateTable(ObserverContext<MasterCoprocessorEnvironment> ctx,
                     TableName tableName)
                       throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called after the truncateTable operation has been requested. Called as part of truncate table RPC call. The truncate is synchronous, so this method will be called when the truncate operation is terminated.
    
    指定者:
    
    postTruncateTable 在接口中 MasterObserver
    
    覆盖:
    
    postTruncateTable 在类中 BaseMasterAndRegionObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    tableName - the name of the table
    
    抛出:
    
    IOException
  - preModifyTable
```
public void preModifyTable(ObserverContext<MasterCoprocessorEnvironment> c,
                  TableName tableName,
                  HTableDescriptor htd)
                    throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called prior to modifying a table's properties. Called as part of modify table RPC call. It can't bypass the default action, e.g., ctx.bypass() won't have effect.
    
    指定者:
    
    preModifyTable 在接口中 MasterObserver
    
    覆盖:
    
    preModifyTable 在类中 BaseMasterAndRegionObserver
    
    参数:
    c - the environment to interact with the framework and master
    tableName - the name of the table
    htd - the HTableDescriptor
    
    抛出:
    
    IOException
  - postModifyTable
```
public void postModifyTable(ObserverContext<MasterCoprocessorEnvironment> c,
                   TableName tableName,
                   HTableDescriptor htd)
                     throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called after the modifyTable operation has been requested. Called as part of modify table RPC call.
    
    指定者:
    
    postModifyTable 在接口中 MasterObserver
    
    覆盖:
    
    postModifyTable 在类中 BaseMasterAndRegionObserver
    
    参数:
    c - the environment to interact with the framework and master
    tableName - the name of the table
    htd - the HTableDescriptor
    
    抛出:
    
    IOException
  - preAddColumn
```
public void preAddColumn(ObserverContext<MasterCoprocessorEnvironment> c,
                TableName tableName,
                HColumnDescriptor column)
                  throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called prior to adding a new column family to the table. Called as part of add column RPC call.
    
    指定者:
    
    preAddColumn 在接口中 MasterObserver
    
    覆盖:
    
    preAddColumn 在类中 BaseMasterAndRegionObserver
    
    参数:
    c - the environment to interact with the framework and master
    tableName - the name of the table
    column - the HColumnDescriptor
    
    抛出:
    
    IOException
  - preModifyColumn
```
public void preModifyColumn(ObserverContext<MasterCoprocessorEnvironment> c,
                   TableName tableName,
                   HColumnDescriptor descriptor)
                     throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called prior to modifying a column family's attributes. Called as part of modify column RPC call.
    
    指定者:
    
    preModifyColumn 在接口中 MasterObserver
    
    覆盖:
    
    preModifyColumn 在类中 BaseMasterAndRegionObserver
    
    参数:
    c - the environment to interact with the framework and master
    tableName - the name of the table
    descriptor - the HColumnDescriptor
    
    抛出:
    
    IOException
  - preDeleteColumn
```
public void preDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> c,
                   TableName tableName,
                   byte[] col)
                     throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called prior to deleting the entire column family. Called as part of delete column RPC call.
    
    指定者:
    
    preDeleteColumn 在接口中 MasterObserver
    
    覆盖:
    
    preDeleteColumn 在类中 BaseMasterAndRegionObserver
    
    参数:
    c - the environment to interact with the framework and master
    tableName - the name of the table
    col - the column
    
    抛出:
    
    IOException
  - postDeleteColumn
```
public void postDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> c,
                    TableName tableName,
                    byte[] col)
                      throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called after the column family has been deleted. Called as part of delete column RPC call.
    
    指定者:
    
    postDeleteColumn 在接口中 MasterObserver
    
    覆盖:
    
    postDeleteColumn 在类中 BaseMasterAndRegionObserver
    
    参数:
    c - the environment to interact with the framework and master
    tableName - the name of the table
    col - the column
    
    抛出:
    
    IOException
  - preEnableTable
```
public void preEnableTable(ObserverContext<MasterCoprocessorEnvironment> c,
                  TableName tableName)
                    throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called prior to enabling a table. Called as part of enable table RPC call. It can't bypass the default action, e.g., ctx.bypass() won't have effect.
    
    指定者:
    
    preEnableTable 在接口中 MasterObserver
    
    覆盖:
    
    preEnableTable 在类中 BaseMasterAndRegionObserver
    
    参数:
    c - the environment to interact with the framework and master
    tableName - the name of the table
    
    抛出:
    
    IOException
  - preDisableTable
```
public void preDisableTable(ObserverContext<MasterCoprocessorEnvironment> c,
                   TableName tableName)
                     throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called prior to disabling a table. Called as part of disable table RPC call. It can't bypass the default action, e.g., ctx.bypass() won't have effect.
    
    指定者:
    
    preDisableTable 在接口中 MasterObserver
    
    覆盖:
    
    preDisableTable 在类中 BaseMasterAndRegionObserver
    
    参数:
    c - the environment to interact with the framework and master
    tableName - the name of the table
    
    抛出:
    
    IOException
  - preAbortProcedure
```
public void preAbortProcedure(ObserverContext<MasterCoprocessorEnvironment> ctx,
                     ProcedureExecutor<MasterProcedureEnv> procEnv,
                     long procId)
                       throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before a abortProcedure request has been processed.
    
    指定者:
    
    preAbortProcedure 在接口中 MasterObserver
    
    覆盖:
    
    preAbortProcedure 在类中 BaseMasterAndRegionObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    
    抛出:
    
    IOException
  - postAbortProcedure
```
public void postAbortProcedure(ObserverContext<MasterCoprocessorEnvironment> ctx)
                        throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called after a abortProcedure request has been processed.
    
    指定者:
    
    postAbortProcedure 在接口中 MasterObserver
    
    覆盖:
    
    postAbortProcedure 在类中 BaseMasterAndRegionObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    
    抛出:
    
    IOException
  - preListProcedures
```
public void preListProcedures(ObserverContext<MasterCoprocessorEnvironment> ctx)
                       throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before a listProcedures request has been processed.
    
    指定者:
    
    preListProcedures 在接口中 MasterObserver
    
    覆盖:
    
    preListProcedures 在类中 BaseMasterAndRegionObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    
    抛出:
    
    IOException
  - postListProcedures
```
public void postListProcedures(ObserverContext<MasterCoprocessorEnvironment> ctx,
                      List<ProcedureInfo> procInfoList)
                        throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called after a listProcedures request has been processed.
    
    指定者:
    
    postListProcedures 在接口中 MasterObserver
    
    覆盖:
    
    postListProcedures 在类中 BaseMasterAndRegionObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    procInfoList - the list of procedures about to be returned
    
    抛出:
    
    IOException
  - preMove
```
public void preMove(ObserverContext<MasterCoprocessorEnvironment> c,
           HRegionInfo region,
           ServerName srcServer,
           ServerName destServer)
             throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called prior to moving a given region from one region server to another.
    
    指定者:
    
    preMove 在接口中 MasterObserver
    
    覆盖:
    
    preMove 在类中 BaseMasterAndRegionObserver
    
    参数:
    c - the environment to interact with the framework and master
    region - the HRegionInfo
    srcServer - the source ServerName
    destServer - the destination ServerName
    
    抛出:
    
    IOException
  - preAssign
```
public void preAssign(ObserverContext<MasterCoprocessorEnvironment> c,
             HRegionInfo regionInfo)
               throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called prior to assigning a specific region.
    
    指定者:
    
    preAssign 在接口中 MasterObserver
    
    覆盖:
    
    preAssign 在类中 BaseMasterAndRegionObserver
    
    参数:
    c - the environment to interact with the framework and master
    regionInfo - the regionInfo of the region
    
    抛出:
    
    IOException
  - preUnassign
```
public void preUnassign(ObserverContext<MasterCoprocessorEnvironment> c,
               HRegionInfo regionInfo,
               boolean force)
                 throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called prior to unassigning a given region.
    
    指定者:
    
    preUnassign 在接口中 MasterObserver
    
    覆盖:
    
    preUnassign 在类中 BaseMasterAndRegionObserver
    
    参数:
    c - the environment to interact with the framework and master
    force - whether to force unassignment or not
    
    抛出:
    
    IOException
  - preRegionOffline
```
public void preRegionOffline(ObserverContext<MasterCoprocessorEnvironment> c,
                    HRegionInfo regionInfo)
                      throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called prior to marking a given region as offline. ctx.bypass() will not have any impact on this hook.
    
    指定者:
    
    preRegionOffline 在接口中 MasterObserver
    
    覆盖:
    
    preRegionOffline 在类中 BaseMasterAndRegionObserver
    
    参数:
    c - the environment to interact with the framework and master
    
    抛出:
    
    IOException
  - preSetSplitOrMergeEnabled
```
public boolean preSetSplitOrMergeEnabled(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                boolean newValue,
                                Admin.MasterSwitchType switchType)
                                  throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called prior to setting split / merge switch
    
    指定者:
    
    preSetSplitOrMergeEnabled 在接口中 MasterObserver
    
    覆盖:
    
    preSetSplitOrMergeEnabled 在类中 BaseMasterAndRegionObserver
    
    参数:
    ctx - the coprocessor instance's environment
    newValue - the new value submitted in the call
    switchType - type of switch
    
    抛出:
    
    IOException
  - postSetSplitOrMergeEnabled
```
public void postSetSplitOrMergeEnabled(ObserverContext<MasterCoprocessorEnvironment> ctx,
                              boolean newValue,
                              Admin.MasterSwitchType switchType)
                                throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called after setting split / merge switch
    
    指定者:
    
    postSetSplitOrMergeEnabled 在接口中 MasterObserver
    
    覆盖:
    
    postSetSplitOrMergeEnabled 在类中 BaseMasterAndRegionObserver
    
    参数:
    ctx - the coprocessor instance's environment
    newValue - the new value submitted in the call
    switchType - type of switch
    
    抛出:
    
    IOException
  - preBalance
```
public void preBalance(ObserverContext<MasterCoprocessorEnvironment> c)
                throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called prior to requesting rebalancing of the cluster regions, though after the initial checks for regions in transition and the balance switch flag.
    
    指定者:
    
    preBalance 在接口中 MasterObserver
    
    覆盖:
    
    preBalance 在类中 BaseMasterAndRegionObserver
    
    参数:
    c - the environment to interact with the framework and master
    
    抛出:
    
    IOException
  - preBalanceSwitch
```
public boolean preBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> c,
                       boolean newValue)
                         throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called prior to modifying the flag used to enable/disable region balancing.
    
    指定者:
    
    preBalanceSwitch 在接口中 MasterObserver
    
    覆盖:
    
    preBalanceSwitch 在类中 BaseMasterAndRegionObserver
    
    参数:
    c - the coprocessor instance's environment
    newValue - the new flag value submitted in the call
    
    抛出:
    
    IOException
  - preShutdown
```
public void preShutdown(ObserverContext<MasterCoprocessorEnvironment> c)
                 throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called prior to shutting down the full HBase cluster, including this HMaster process.
    
    指定者:
    
    preShutdown 在接口中 MasterObserver
    
    覆盖:
    
    preShutdown 在类中 BaseMasterAndRegionObserver
    
    抛出:
    
    IOException
  - preStopMaster
```
public void preStopMaster(ObserverContext<MasterCoprocessorEnvironment> c)
                   throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called immediately prior to stopping this HMaster process.
    
    指定者:
    
    preStopMaster 在接口中 MasterObserver
    
    覆盖:
    
    preStopMaster 在类中 BaseMasterAndRegionObserver
    
    抛出:
    
    IOException
  - postStartMaster
```
public void postStartMaster(ObserverContext<MasterCoprocessorEnvironment> ctx)
                     throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called immediately after an active master instance has completed initialization. Will not be called on standby master instances unless they take over the active role.
    
    指定者:
    
    postStartMaster 在接口中 MasterObserver
    
    覆盖:
    
    postStartMaster 在类中 BaseMasterAndRegionObserver
    
    抛出:
    
    IOException
  - preSnapshot
```
public void preSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
               org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.SnapshotDescription snapshot,
               HTableDescriptor hTableDescriptor)
                 throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before a new snapshot is taken. Called as part of snapshot RPC call. It can't bypass the default action, e.g., ctx.bypass() won't have effect.
    
    指定者:
    
    preSnapshot 在接口中 MasterObserver
    
    覆盖:
    
    preSnapshot 在类中 BaseMasterAndRegionObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    snapshot - the SnapshotDescriptor for the snapshot
    hTableDescriptor - the hTableDescriptor of the table to snapshot
    
    抛出:
    
    IOException
  - preListSnapshot
```
public void preListSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
                   org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.SnapshotDescription snapshot)
                     throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before listSnapshots request has been processed. It can't bypass the default action, e.g., ctx.bypass() won't have effect.
    
    指定者:
    
    preListSnapshot 在接口中 MasterObserver
    
    覆盖:
    
    preListSnapshot 在类中 BaseMasterAndRegionObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    snapshot - the SnapshotDescriptor of the snapshot to list
    
    抛出:
    
    IOException
  - preCloneSnapshot
```
public void preCloneSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
                    org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.SnapshotDescription snapshot,
                    HTableDescriptor hTableDescriptor)
                      throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before a snapshot is cloned. Called as part of restoreSnapshot RPC call. It can't bypass the default action, e.g., ctx.bypass() won't have effect.
    
    指定者:
    
    preCloneSnapshot 在接口中 MasterObserver
    
    覆盖:
    
    preCloneSnapshot 在类中 BaseMasterAndRegionObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    snapshot - the SnapshotDescriptor for the snapshot
    hTableDescriptor - the hTableDescriptor of the table to create
    
    抛出:
    
    IOException
  - preRestoreSnapshot
```
public void preRestoreSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
                      org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.SnapshotDescription snapshot,
                      HTableDescriptor hTableDescriptor)
                        throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before a snapshot is restored. Called as part of restoreSnapshot RPC call. It can't bypass the default action, e.g., ctx.bypass() won't have effect.
    
    指定者:
    
    preRestoreSnapshot 在接口中 MasterObserver
    
    覆盖:
    
    preRestoreSnapshot 在类中 BaseMasterAndRegionObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    snapshot - the SnapshotDescriptor for the snapshot
    hTableDescriptor - the hTableDescriptor of the table to restore
    
    抛出:
    
    IOException
  - preDeleteSnapshot
```
public void preDeleteSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
                     org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.SnapshotDescription snapshot)
                       throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before a snapshot is deleted. Called as part of deleteSnapshot RPC call. It can't bypass the default action, e.g., ctx.bypass() won't have effect.
    
    指定者:
    
    preDeleteSnapshot 在接口中 MasterObserver
    
    覆盖:
    
    preDeleteSnapshot 在类中 BaseMasterAndRegionObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    snapshot - the SnapshotDescriptor of the snapshot to delete
    
    抛出:
    
    IOException
  - preCreateNamespace
```
public void preCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
                      NamespaceDescriptor ns)
                        throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before a new namespace is created by HMaster. It can't bypass the default action, e.g., ctx.bypass() won't have effect.
    
    指定者:
    
    preCreateNamespace 在接口中 MasterObserver
    
    覆盖:
    
    preCreateNamespace 在类中 BaseMasterAndRegionObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    ns - the NamespaceDescriptor for the table
    
    抛出:
    
    IOException
  - preDeleteNamespace
```
public void preDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
                      String namespace)
                        throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before HMaster deletes a namespace It can't bypass the default action, e.g., ctx.bypass() won't have effect.
    
    指定者:
    
    preDeleteNamespace 在接口中 MasterObserver
    
    覆盖:
    
    preDeleteNamespace 在类中 BaseMasterAndRegionObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    namespace - the name of the namespace
    
    抛出:
    
    IOException
  - postDeleteNamespace
```
public void postDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
                       String namespace)
                         throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called after the deleteNamespace operation has been requested.
    
    指定者:
    
    postDeleteNamespace 在接口中 MasterObserver
    
    覆盖:
    
    postDeleteNamespace 在类中 BaseMasterAndRegionObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    namespace - the name of the namespace
    
    抛出:
    
    IOException
  - preModifyNamespace
```
public void preModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
                      NamespaceDescriptor ns)
                        throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called prior to modifying a namespace's properties. It can't bypass the default action, e.g., ctx.bypass() won't have effect.
    
    指定者:
    
    preModifyNamespace 在接口中 MasterObserver
    
    覆盖:
    
    preModifyNamespace 在类中 BaseMasterAndRegionObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    ns - the NamespaceDescriptor
    
    抛出:
    
    IOException
  - preGetNamespaceDescriptor
```
public void preGetNamespaceDescriptor(ObserverContext<MasterCoprocessorEnvironment> ctx,
                             String namespace)
                               throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before a getNamespaceDescriptor request has been processed.
    
    指定者:
    
    preGetNamespaceDescriptor 在接口中 MasterObserver
    
    覆盖:
    
    preGetNamespaceDescriptor 在类中 BaseMasterAndRegionObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    namespace - the name of the namespace
    
    抛出:
    
    IOException
  - postListNamespaceDescriptors
```
public void postListNamespaceDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                List<NamespaceDescriptor> descriptors)
                                  throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called after a listNamespaceDescriptors request has been processed.
    
    指定者:
    
    postListNamespaceDescriptors 在接口中 MasterObserver
    
    覆盖:
    
    postListNamespaceDescriptors 在类中 BaseMasterAndRegionObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    descriptors - the list of descriptors about to be returned
    
    抛出:
    
    IOException
  - preTableFlush
```
public void preTableFlush(ObserverContext<MasterCoprocessorEnvironment> ctx,
                 TableName tableName)
                   throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before the table memstore is flushed to disk.
    
    指定者:
    
    preTableFlush 在接口中 MasterObserver
    
    覆盖:
    
    preTableFlush 在类中 BaseMasterAndRegionObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    tableName - the name of the table
    
    抛出:
    
    IOException
  - preOpen
```
public void preOpen(ObserverContext<RegionCoprocessorEnvironment> e)
             throws IOException
```
    从接口复制的说明: RegionObserver
    
    Called before the region is reported as open to the master.
    
    指定者:
    
    preOpen 在接口中 RegionObserver
    
    覆盖:
    
    preOpen 在类中 BaseRegionObserver
    
    参数:
    e - the environment provided by the region server
    
    抛出:
    
    IOException - if an error occurred on the coprocessor
  - postOpen
```
public void postOpen(ObserverContext<RegionCoprocessorEnvironment> c)
```
    从接口复制的说明: RegionObserver
    
    Called after the region is reported as open to the master.
    
    指定者:
    
    postOpen 在接口中 RegionObserver
    
    覆盖:
    
    postOpen 在类中 BaseRegionObserver
    
    参数:
    c - the environment provided by the region server
  - postLogReplay
```
public void postLogReplay(ObserverContext<RegionCoprocessorEnvironment> c)
```
    从接口复制的说明: RegionObserver
    
    Called after the log replay on the region is over.
    
    指定者:
    
    postLogReplay 在接口中 RegionObserver
    
    覆盖:
    
    postLogReplay 在类中 BaseRegionObserver
    
    参数:
    c - the environment provided by the region server
  - preFlush
```
public void preFlush(ObserverContext<RegionCoprocessorEnvironment> e)
              throws IOException
```
    从接口复制的说明: RegionObserver
    
    Called before the memstore is flushed to disk.
    
    指定者:
    
    preFlush 在接口中 RegionObserver
    
    覆盖:
    
    preFlush 在类中 BaseRegionObserver
    
    参数:
    e - the environment provided by the region server
    
    抛出:
    
    IOException - if an error occurred on the coprocessor
  - preSplit
```
public void preSplit(ObserverContext<RegionCoprocessorEnvironment> e)
              throws IOException
```
    从接口复制的说明: RegionObserver
    
    Called before the region is split.
    
    指定者:
    
    preSplit 在接口中 RegionObserver
    
    覆盖:
    
    preSplit 在类中 BaseRegionObserver
    
    参数:
    e - the environment provided by the region server (e.getRegion() returns the parent region)
    
    抛出:
    
    IOException - if an error occurred on the coprocessor
  - preSplit
```
public void preSplit(ObserverContext<RegionCoprocessorEnvironment> e,
            byte[] splitRow)
              throws IOException
```
    从接口复制的说明: RegionObserver
    
    Called before the region is split.
    
    指定者:
    
    preSplit 在接口中 RegionObserver
    
    覆盖:
    
    preSplit 在类中 BaseRegionObserver
    
    参数:
    e - the environment provided by the region server (e.getRegion() returns the parent region)
    
    抛出:
    
    IOException - if an error occurred on the coprocessor
  - preCompact
```
public InternalScanner preCompact(ObserverContext<RegionCoprocessorEnvironment> e,
                         Store store,
                         InternalScanner scanner,
                         ScanType scanType)
                           throws IOException
```
    从接口复制的说明: 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.
    指定者:
    
    preCompact 在接口中 RegionObserver
    
    覆盖:
    
    preCompact 在类中 BaseRegionObserver
    
    参数:
    e - 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
    
    返回:
    the scanner to use during compaction. Should not be null unless the implementation is writing new store files on its own.
    
    抛出:
    
    IOException - if an error occurred on the coprocessor
  - preGetClosestRowBefore
```
public void preGetClosestRowBefore(ObserverContext<RegionCoprocessorEnvironment> c,
                          byte[] row,
                          byte[] family,
                          Result result)
                            throws IOException
```
    从接口复制的说明: RegionObserver
    
    Called before a client makes a GetClosestRowBefore request.
    Call CoprocessorEnvironment#bypass to skip default actions
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    
    指定者:
    
    preGetClosestRowBefore 在接口中 RegionObserver
    
    覆盖:
    
    preGetClosestRowBefore 在类中 BaseRegionObserver
    
    参数:
    c - the environment provided by the region server
    row - the row
    family - the family
    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.
    
    抛出:
    
    IOException - if an error occurred on the coprocessor
  - preGetOp
```
public void preGetOp(ObserverContext<RegionCoprocessorEnvironment> c,
            Get get,
            List<Cell> result)
              throws IOException
```
    从接口复制的说明: RegionObserver
    
    Called before the client performs a Get
    Call CoprocessorEnvironment#bypass to skip default actions
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    
    指定者:
    
    preGetOp 在接口中 RegionObserver
    
    覆盖:
    
    preGetOp 在类中 BaseRegionObserver
    
    参数:
    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.
    
    抛出:
    
    IOException - if an error occurred on the coprocessor
  - preExists
```
public boolean preExists(ObserverContext<RegionCoprocessorEnvironment> c,
                Get get,
                boolean exists)
                  throws IOException
```
    从接口复制的说明: 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
    
    指定者:
    
    preExists 在接口中 RegionObserver
    
    覆盖:
    
    preExists 在类中 BaseRegionObserver
    
    参数:
    c - the environment provided by the region server
    get - the Get request
    
    返回:
    the value to return to the client if bypassing default processing
    
    抛出:
    
    IOException - if an error occurred on the coprocessor
  - prePut
```
public void prePut(ObserverContext<RegionCoprocessorEnvironment> c,
          Put put,
          WALEdit edit,
          Durability durability)
            throws IOException
```
    从接口复制的说明: RegionObserver
    
    Called before the client stores a value.
    Call CoprocessorEnvironment#bypass to skip default actions
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    
    指定者:
    
    prePut 在接口中 RegionObserver
    
    覆盖:
    
    prePut 在类中 BaseRegionObserver
    
    参数:
    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
    
    抛出:
    
    IOException - if an error occurred on the coprocessor
  - postPut
```
public void postPut(ObserverContext<RegionCoprocessorEnvironment> c,
           Put put,
           WALEdit edit,
           Durability durability)
```
    从接口复制的说明: RegionObserver
    
    Called after the client stores a value.
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    
    指定者:
    
    postPut 在接口中 RegionObserver
    
    覆盖:
    
    postPut 在类中 BaseRegionObserver
    
    参数:
    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
```
    从接口复制的说明: RegionObserver
    
    Called before the client deletes a value.
    Call CoprocessorEnvironment#bypass to skip default actions
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    
    指定者:
    
    preDelete 在接口中 RegionObserver
    
    覆盖:
    
    preDelete 在类中 BaseRegionObserver
    
    参数:
    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
    
    抛出:
    
    IOException - if an error occurred on the coprocessor
  - preBatchMutate
```
public void preBatchMutate(ObserverContext<RegionCoprocessorEnvironment> c,
                  MiniBatchOperationInProgress<Mutation> miniBatchOp)
                    throws IOException
```
    从接口复制的说明: 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.
    
    指定者:
    
    preBatchMutate 在接口中 RegionObserver
    
    覆盖:
    
    preBatchMutate 在类中 BaseRegionObserver
    
    参数:
    c - the environment provided by the region server
    miniBatchOp - batch of Mutations getting applied to region.
    
    抛出:
    
    IOException - if an error occurred on the coprocessor
  - postDelete
```
public void postDelete(ObserverContext<RegionCoprocessorEnvironment> c,
              Delete delete,
              WALEdit edit,
              Durability durability)
                throws IOException
```
    从接口复制的说明: RegionObserver
    
    Called after the client deletes a value.
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    
    指定者:
    
    postDelete 在接口中 RegionObserver
    
    覆盖:
    
    postDelete 在类中 BaseRegionObserver
    
    参数:
    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
    
    抛出:
    
    IOException - if an error occurred on the coprocessor
  - preCheckAndPut
```
public boolean preCheckAndPut(ObserverContext<RegionCoprocessorEnvironment> c,
                     byte[] row,
                     byte[] family,
                     byte[] qualifier,
                     CompareFilter.CompareOp compareOp,
                     ByteArrayComparable comparator,
                     Put put,
                     boolean result)
                       throws IOException
```
    从接口复制的说明: RegionObserver
    
    Called before checkAndPut.
    Call CoprocessorEnvironment#bypass to skip default actions
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    
    指定者:
    
    preCheckAndPut 在接口中 RegionObserver
    
    覆盖:
    
    preCheckAndPut 在类中 BaseRegionObserver
    
    参数:
    c - the environment provided by the region server
    row - row to check
    family - column family
    qualifier - column qualifier
    compareOp - the comparison operation
    comparator - the comparator
    put - data to put if check succeeds
    
    返回:
    the return value to return to client if bypassing default processing
    
    抛出:
    
    IOException - if an error occurred on the coprocessor
  - preCheckAndPutAfterRowLock
```
public boolean preCheckAndPutAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> c,
                                 byte[] row,
                                 byte[] family,
                                 byte[] qualifier,
                                 CompareFilter.CompareOp compareOp,
                                 ByteArrayComparable comparator,
                                 Put put,
                                 boolean result)
                                   throws IOException
```
    从接口复制的说明: 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
    
    指定者:
    
    preCheckAndPutAfterRowLock 在接口中 RegionObserver
    
    覆盖:
    
    preCheckAndPutAfterRowLock 在类中 BaseRegionObserver
    
    参数:
    c - the environment provided by the region server
    row - row to check
    family - column family
    qualifier - column qualifier
    compareOp - the comparison operation
    comparator - the comparator
    put - data to put if check succeeds
    
    返回:
    the return value to return to client if bypassing default processing
    
    抛出:
    
    IOException - if an error occurred on the coprocessor
  - preCheckAndDelete
```
public boolean preCheckAndDelete(ObserverContext<RegionCoprocessorEnvironment> c,
                        byte[] row,
                        byte[] family,
                        byte[] qualifier,
                        CompareFilter.CompareOp compareOp,
                        ByteArrayComparable comparator,
                        Delete delete,
                        boolean result)
                          throws IOException
```
    从接口复制的说明: RegionObserver
    
    Called before checkAndDelete.
    Call CoprocessorEnvironment#bypass to skip default actions
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    
    指定者:
    
    preCheckAndDelete 在接口中 RegionObserver
    
    覆盖:
    
    preCheckAndDelete 在类中 BaseRegionObserver
    
    参数:
    c - the environment provided by the region server
    row - row to check
    family - column family
    qualifier - column qualifier
    compareOp - the comparison operation
    comparator - the comparator
    delete - delete to commit if check succeeds
    
    返回:
    the value to return to client if bypassing default processing
    
    抛出:
    
    IOException - if an error occurred on the coprocessor
  - preCheckAndDeleteAfterRowLock
```
public boolean preCheckAndDeleteAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> c,
                                    byte[] row,
                                    byte[] family,
                                    byte[] qualifier,
                                    CompareFilter.CompareOp compareOp,
                                    ByteArrayComparable comparator,
                                    Delete delete,
                                    boolean result)
                                      throws IOException
```
    从接口复制的说明: 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
    
    指定者:
    
    preCheckAndDeleteAfterRowLock 在接口中 RegionObserver
    
    覆盖:
    
    preCheckAndDeleteAfterRowLock 在类中 BaseRegionObserver
    
    参数:
    c - the environment provided by the region server
    row - row to check
    family - column family
    qualifier - column qualifier
    compareOp - the comparison operation
    comparator - the comparator
    delete - delete to commit if check succeeds
    
    返回:
    the value to return to client if bypassing default processing
    
    抛出:
    
    IOException - if an error occurred on the coprocessor
  - preIncrementColumnValue
```
public long preIncrementColumnValue(ObserverContext<RegionCoprocessorEnvironment> c,
                           byte[] row,
                           byte[] family,
                           byte[] qualifier,
                           long amount,
                           boolean writeToWAL)
                             throws IOException
```
    从接口复制的说明: RegionObserver
    
    Called before incrementColumnValue
    Call CoprocessorEnvironment#bypass to skip default actions
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    
    指定者:
    
    preIncrementColumnValue 在接口中 RegionObserver
    
    覆盖:
    
    preIncrementColumnValue 在类中 BaseRegionObserver
    
    参数:
    c - the environment provided by the region server
    row - row to check
    family - column family
    qualifier - column qualifier
    amount - long amount to increment
    writeToWAL - true if the change should be written to the WAL
    
    返回:
    value to return to the client if bypassing default processing
    
    抛出:
    
    IOException - if an error occurred on the coprocessor
  - preAppend
```
public Result preAppend(ObserverContext<RegionCoprocessorEnvironment> c,
               Append append)
                 throws IOException
```
    从接口复制的说明: RegionObserver
    
    Called before Append.
    Call CoprocessorEnvironment#bypass to skip default actions
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    
    指定者:
    
    preAppend 在接口中 RegionObserver
    
    覆盖:
    
    preAppend 在类中 BaseRegionObserver
    
    参数:
    c - the environment provided by the region server
    append - Append object
    
    返回:
    result to return to the client if bypassing default processing
    
    抛出:
    
    IOException - if an error occurred on the coprocessor
  - preAppendAfterRowLock
```
public Result preAppendAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> c,
                           Append append)
                             throws IOException
```
    从接口复制的说明: 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
    
    指定者:
    
    preAppendAfterRowLock 在接口中 RegionObserver
    
    覆盖:
    
    preAppendAfterRowLock 在类中 BaseRegionObserver
    
    参数:
    c - the environment provided by the region server
    append - Append object
    
    返回:
    result to return to the client if bypassing default processing
    
    抛出:
    
    IOException - if an error occurred on the coprocessor
  - preIncrement
```
public Result preIncrement(ObserverContext<RegionCoprocessorEnvironment> c,
                  Increment increment)
                    throws IOException
```
    从接口复制的说明: RegionObserver
    
    Called before Increment.
    Call CoprocessorEnvironment#bypass to skip default actions
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    
    指定者:
    
    preIncrement 在接口中 RegionObserver
    
    覆盖:
    
    preIncrement 在类中 BaseRegionObserver
    
    参数:
    c - the environment provided by the region server
    increment - increment object
    
    返回:
    result to return to the client if bypassing default processing
    
    抛出:
    
    IOException - if an error occurred on the coprocessor
  - preIncrementAfterRowLock
```
public Result preIncrementAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> c,
                              Increment increment)
                                throws IOException
```
    从接口复制的说明: 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
    
    指定者:
    
    preIncrementAfterRowLock 在接口中 RegionObserver
    
    覆盖:
    
    preIncrementAfterRowLock 在类中 BaseRegionObserver
    
    参数:
    c - the environment provided by the region server
    increment - increment object
    
    返回:
    result to return to the client if bypassing default processing
    
    抛出:
    
    IOException - if an error occurred on the coprocessor
  - postMutationBeforeWAL
```
public Cell postMutationBeforeWAL(ObserverContext<RegionCoprocessorEnvironment> ctx,
                         RegionObserver.MutationType opType,
                         Mutation mutation,
                         Cell oldCell,
                         Cell newCell)
                           throws IOException
```
    从接口复制的说明: 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.
    
    指定者:
    
    postMutationBeforeWAL 在接口中 RegionObserver
    
    覆盖:
    
    postMutationBeforeWAL 在类中 BaseRegionObserver
    
    参数:
    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
    
    返回:
    the new cell, possibly changed
    
    抛出:
    
    IOException
  - preScannerOpen
```
public RegionScanner preScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c,
                           Scan scan,
                           RegionScanner s)
                             throws IOException
```
    从接口复制的说明: 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
    
    指定者:
    
    preScannerOpen 在接口中 RegionObserver
    
    覆盖:
    
    preScannerOpen 在类中 BaseRegionObserver
    
    参数:
    c - the environment provided by the region server
    scan - the Scan specification
    s - if not null, the base scanner
    
    返回:
    an RegionScanner instance to use instead of the base scanner if overriding default behavior, null otherwise
    
    抛出:
    
    IOException - if an error occurred on the coprocessor
  - postScannerOpen
```
public RegionScanner postScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c,
                            Scan scan,
                            RegionScanner s)
                              throws IOException
```
    从接口复制的说明: RegionObserver
    
    Called after the client opens a new scanner.
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    
    指定者:
    
    postScannerOpen 在接口中 RegionObserver
    
    覆盖:
    
    postScannerOpen 在类中 BaseRegionObserver
    
    参数:
    c - the environment provided by the region server
    scan - the Scan specification
    s - if not null, the base scanner
    
    返回:
    the scanner instance to use
    
    抛出:
    
    IOException - if an error occurred on the coprocessor
  - preScannerNext
```
public boolean preScannerNext(ObserverContext<RegionCoprocessorEnvironment> c,
                     InternalScanner s,
                     List<Result> result,
                     int limit,
                     boolean hasNext)
                       throws IOException
```
    从接口复制的说明: 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
    
    指定者:
    
    preScannerNext 在接口中 RegionObserver
    
    覆盖:
    
    preScannerNext 在类中 BaseRegionObserver
    
    参数:
    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
    
    返回:
    'has more' indication that should be sent to client
    
    抛出:
    
    IOException - if an error occurred on the coprocessor
  - preScannerClose
```
public void preScannerClose(ObserverContext<RegionCoprocessorEnvironment> c,
                   InternalScanner s)
                     throws IOException
```
    从接口复制的说明: RegionObserver
    
    Called before the client closes a scanner.
    Call CoprocessorEnvironment#bypass to skip default actions
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    
    指定者:
    
    preScannerClose 在接口中 RegionObserver
    
    覆盖:
    
    preScannerClose 在类中 BaseRegionObserver
    
    参数:
    c - the environment provided by the region server
    s - the scanner
    
    抛出:
    
    IOException - if an error occurred on the coprocessor
  - postScannerClose
```
public void postScannerClose(ObserverContext<RegionCoprocessorEnvironment> c,
                    InternalScanner s)
                      throws IOException
```
    从接口复制的说明: RegionObserver
    
    Called after the client closes a scanner.
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    
    指定者:
    
    postScannerClose 在接口中 RegionObserver
    
    覆盖:
    
    postScannerClose 在类中 BaseRegionObserver
    
    参数:
    c - the environment provided by the region server
    s - the scanner
    
    抛出:
    
    IOException - if an error occurred on the coprocessor
  - 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.
    
    指定者:
    
    preBulkLoadHFile 在接口中 RegionObserver
    
    覆盖:
    
    preBulkLoadHFile 在类中 BaseRegionObserver
    
    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.
    
    抛出:
    
    IOException
  - prePrepareBulkLoad
```
public void prePrepareBulkLoad(ObserverContext<RegionCoprocessorEnvironment> ctx,
                      org.apache.hadoop.hbase.protobuf.generated.SecureBulkLoadProtos.PrepareBulkLoadRequest request)
                        throws IOException
```
    Authorization check for SecureBulkLoadProtocol.prepareBulkLoad()
    
    指定者:
    
    prePrepareBulkLoad 在接口中 BulkLoadObserver
    
    参数:
    ctx - the context
    request - the request
    
    抛出:
    
    IOException
  - preCleanupBulkLoad
```
public void preCleanupBulkLoad(ObserverContext<RegionCoprocessorEnvironment> ctx,
                      org.apache.hadoop.hbase.protobuf.generated.SecureBulkLoadProtos.CleanupBulkLoadRequest request)
                        throws IOException
```
    Authorization security check for SecureBulkLoadProtocol.cleanupBulkLoad()
    
    指定者:
    
    preCleanupBulkLoad 在接口中 BulkLoadObserver
    
    参数:
    ctx - the context
    request - the request
    
    抛出:
    
    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
```
    从接口复制的说明: 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.
    
    指定者:
    
    preEndpointInvocation 在接口中 EndpointObserver
    
    参数:
    ctx - the environment provided by the region server
    service - the endpoint service
    methodName - the invoked service method
    request - the request message
    
    返回:
    the possibly modified message
    
    抛出:
    
    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
```
    从接口复制的说明: EndpointObserver
    
    Called after an Endpoint service method is invoked. The response message can be altered using the builder.
    
    指定者:
    
    postEndpointInvocation 在接口中 EndpointObserver
    
    参数:
    ctx - the environment provided by the region server
    service - the endpoint service
    methodName - the invoked service method
    request - the request message
    responseBuilder - the response message builder
    
    抛出:
    
    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)
```
    指定者:
    
    grant 在接口中 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)
```
    指定者:
    
    revoke 在接口中 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)
```
    指定者:
    
    getUserPermissions 在接口中 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)
```
    指定者:
    
    checkPermissions 在接口中 org.apache.hadoop.hbase.protobuf.generated.AccessControlProtos.AccessControlService.Interface
  - getService
```
public com.google.protobuf.Service getService()
```
    指定者:
    
    getService 在接口中 CoprocessorService
  - preClose
```
public void preClose(ObserverContext<RegionCoprocessorEnvironment> e,
            boolean abortRequested)
              throws IOException
```
    从接口复制的说明: RegionObserver
    
    Called before the region is reported as closed to the master.
    
    指定者:
    
    preClose 在接口中 RegionObserver
    
    覆盖:
    
    preClose 在类中 BaseRegionObserver
    
    参数:
    e - the environment provided by the region server
    abortRequested - true if the region server is aborting
    
    抛出:
    
    IOException
  - preStopRegionServer
```
public void preStopRegionServer(ObserverContext<RegionServerCoprocessorEnvironment> env)
                         throws IOException
```
    从接口复制的说明: RegionServerObserver
    
    Called before stopping region server.
    
    指定者:
    
    preStopRegionServer 在接口中 RegionServerObserver
    
    参数:
    env - An instance of RegionServerCoprocessorEnvironment
    
    抛出:
    
    IOException - Signals that an I/O exception has occurred.
  - preGetTableDescriptors
```
public void preGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
                          List<TableName> tableNamesList,
                          List<HTableDescriptor> descriptors,
                          String regex)
                            throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before a getTableDescriptors request has been processed.
    
    指定者:
    
    preGetTableDescriptors 在接口中 MasterObserver
    
    覆盖:
    
    preGetTableDescriptors 在类中 BaseMasterAndRegionObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    tableNamesList - the list of table names, or null if querying for all
    descriptors - an empty list, can be filled with what to return if bypassing
    regex - regular expression used for filtering the table names
    
    抛出:
    
    IOException
  - postGetTableDescriptors
```
public void postGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
                           List<TableName> tableNamesList,
                           List<HTableDescriptor> descriptors,
                           String regex)
                             throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called after a getTableDescriptors request has been processed.
    
    指定者:
    
    postGetTableDescriptors 在接口中 MasterObserver
    
    覆盖:
    
    postGetTableDescriptors 在类中 BaseMasterAndRegionObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    tableNamesList - the list of table names, or null if querying for all
    descriptors - the list of descriptors about to be returned
    regex - regular expression used for filtering the table names
    
    抛出:
    
    IOException
  - postGetTableNames
```
public void postGetTableNames(ObserverContext<MasterCoprocessorEnvironment> ctx,
                     List<HTableDescriptor> descriptors,
                     String regex)
                       throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called after a getTableNames request has been processed.
    
    指定者:
    
    postGetTableNames 在接口中 MasterObserver
    
    覆盖:
    
    postGetTableNames 在类中 BaseMasterAndRegionObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    descriptors - the list of descriptors about to be returned
    regex - regular expression used for filtering the table names
    
    抛出:
    
    IOException
  - preDispatchMerge
```
public void preDispatchMerge(ObserverContext<MasterCoprocessorEnvironment> ctx,
                    HRegionInfo regionA,
                    HRegionInfo regionB)
                      throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before dispatching region merge request. It can't bypass the default action, e.g., ctx.bypass() won't have effect.
    
    指定者:
    
    preDispatchMerge 在接口中 MasterObserver
    
    覆盖:
    
    preDispatchMerge 在类中 BaseMasterAndRegionObserver
    
    参数:
    ctx - coprocessor environment
    regionA - first region to be merged
    regionB - second region to be merged
    
    抛出:
    
    IOException - if an error occurred on the coprocessor
  - preClearDeadServers
```
public void preClearDeadServers(ObserverContext<MasterCoprocessorEnvironment> ctx)
                         throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before clear dead region servers.
    
    指定者:
    
    preClearDeadServers 在接口中 MasterObserver
    
    覆盖:
    
    preClearDeadServers 在类中 BaseMasterAndRegionObserver
    
    抛出:
    
    IOException
  - postClearDeadServers
```
public void postClearDeadServers(ObserverContext<MasterCoprocessorEnvironment> ctx,
                        List<ServerName> servers,
                        List<ServerName> notClearedServers)
                          throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called after clear dead region servers.
    
    指定者:
    
    postClearDeadServers 在接口中 MasterObserver
    
    覆盖:
    
    postClearDeadServers 在类中 BaseMasterAndRegionObserver
    
    抛出:
    
    IOException
  - preMerge
```
public void preMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
            Region regionA,
            Region regionB)
              throws IOException
```
    从接口复制的说明: RegionServerObserver
    
    Called before the regions merge. Call ObserverContext.bypass() to skip the merge.
    
    指定者:
    
    preMerge 在接口中 RegionServerObserver
    
    抛出:
    
    IOException - if an error occurred on the coprocessor
  - postMerge
```
public void postMerge(ObserverContext<RegionServerCoprocessorEnvironment> c,
             Region regionA,
             Region regionB,
             Region mergedRegion)
               throws IOException
```
    从接口复制的说明: RegionServerObserver
    
    called after the regions merge.
    
    指定者:
    
    postMerge 在接口中 RegionServerObserver
    
    抛出:
    
    IOException
  - preMergeCommit
```
public void preMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
                  Region regionA,
                  Region regionB,
                  List<Mutation> metaEntries)
                    throws IOException
```
    从接口复制的说明: RegionServerObserver
    
    This will be called before PONR step as part of regions merge transaction. Calling ObserverContext.bypass() rollback the merge
    
    指定者:
    
    preMergeCommit 在接口中 RegionServerObserver
    
    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.
    
    抛出:
    
    IOException
  - postMergeCommit
```
public void postMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
                   Region regionA,
                   Region regionB,
                   Region mergedRegion)
                     throws IOException
```
    从接口复制的说明: RegionServerObserver
    
    This will be called after PONR step as part of regions merge transaction.
    
    指定者:
    
    postMergeCommit 在接口中 RegionServerObserver
    
    抛出:
    
    IOException
  - preRollBackMerge
```
public void preRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
                    Region regionA,
                    Region regionB)
                      throws IOException
```
    从接口复制的说明: RegionServerObserver
    
    This will be called before the roll back of the regions merge.
    
    指定者:
    
    preRollBackMerge 在接口中 RegionServerObserver
    
    抛出:
    
    IOException
  - postRollBackMerge
```
public void postRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
                     Region regionA,
                     Region regionB)
                       throws IOException
```
    从接口复制的说明: RegionServerObserver
    
    This will be called after the roll back of the regions merge.
    
    指定者:
    
    postRollBackMerge 在接口中 RegionServerObserver
    
    抛出:
    
    IOException
  - preRollWALWriterRequest
```
public void preRollWALWriterRequest(ObserverContext<RegionServerCoprocessorEnvironment> ctx)
                             throws IOException
```
    从接口复制的说明: RegionServerObserver
    
    This will be called before executing user request to roll a region server WAL.
    
    指定者:
    
    preRollWALWriterRequest 在接口中 RegionServerObserver
    
    参数:
    ctx - An instance of ObserverContext
    
    抛出:
    
    IOException - Signals that an I/O exception has occurred.
  - postRollWALWriterRequest
```
public void postRollWALWriterRequest(ObserverContext<RegionServerCoprocessorEnvironment> ctx)
                              throws IOException
```
    从接口复制的说明: RegionServerObserver
    
    This will be called after executing user request to roll a region server WAL.
    
    指定者:
    
    postRollWALWriterRequest 在接口中 RegionServerObserver
    
    参数:
    ctx - An instance of ObserverContext
    
    抛出:
    
    IOException - Signals that an I/O exception has occurred.
  - postCreateReplicationEndPoint
```
public ReplicationEndpoint postCreateReplicationEndPoint(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
                                                ReplicationEndpoint endpoint)
```
    从接口复制的说明: RegionServerObserver
    
    This will be called after the replication endpoint is instantiated.
    
    指定者:
    
    postCreateReplicationEndPoint 在接口中 RegionServerObserver
    
    endpoint - - the base endpoint for replication
    
    返回:
    the endpoint to use during replication.
  - preReplicateLogEntries
```
public void preReplicateLogEntries(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
                          List<org.apache.hadoop.hbase.protobuf.generated.AdminProtos.WALEntry> entries,
                          CellScanner cells)
                            throws IOException
```
    从接口复制的说明: RegionServerObserver
    
    This will be called before executing replication request to shipping log entries.
    
    指定者:
    
    preReplicateLogEntries 在接口中 RegionServerObserver
    
    参数:
    ctx - An instance of ObserverContext
    entries - list of WALEntries to replicate
    cells - Cells that the WALEntries refer to (if cells is non-null)
    
    抛出:
    
    IOException - Signals that an I/O exception has occurred.
  - postReplicateLogEntries
```
public void postReplicateLogEntries(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
                           List<org.apache.hadoop.hbase.protobuf.generated.AdminProtos.WALEntry> entries,
                           CellScanner cells)
                             throws IOException
```
    从接口复制的说明: RegionServerObserver
    
    This will be called after executing replication request to shipping log entries.
    
    指定者:
    
    postReplicateLogEntries 在接口中 RegionServerObserver
    
    参数:
    ctx - An instance of ObserverContext
    entries - list of WALEntries to replicate
    cells - Cells that the WALEntries refer to (if cells is non-null)
    
    抛出:
    
    IOException - Signals that an I/O exception has occurred.
  - preSetUserQuota
```
public void preSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx,
                   String userName,
                   org.apache.hadoop.hbase.protobuf.generated.QuotaProtos.Quotas quotas)
                     throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before the quota for the user is stored.
    
    指定者:
    
    preSetUserQuota 在接口中 MasterObserver
    
    覆盖:
    
    preSetUserQuota 在类中 BaseMasterAndRegionObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    userName - the name of user
    quotas - the quota settings
    
    抛出:
    
    IOException
  - preSetUserQuota
```
public void preSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx,
                   String userName,
                   TableName tableName,
                   org.apache.hadoop.hbase.protobuf.generated.QuotaProtos.Quotas quotas)
                     throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before the quota for the user on the specified table is stored.
    
    指定者:
    
    preSetUserQuota 在接口中 MasterObserver
    
    覆盖:
    
    preSetUserQuota 在类中 BaseMasterAndRegionObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    userName - the name of user
    tableName - the name of the table
    quotas - the quota settings
    
    抛出:
    
    IOException
  - preSetUserQuota
```
public void preSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx,
                   String userName,
                   String namespace,
                   org.apache.hadoop.hbase.protobuf.generated.QuotaProtos.Quotas quotas)
                     throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before the quota for the user on the specified namespace is stored.
    
    指定者:
    
    preSetUserQuota 在接口中 MasterObserver
    
    覆盖:
    
    preSetUserQuota 在类中 BaseMasterAndRegionObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    userName - the name of user
    namespace - the name of the namespace
    quotas - the quota settings
    
    抛出:
    
    IOException
  - preSetTableQuota
```
public void preSetTableQuota(ObserverContext<MasterCoprocessorEnvironment> ctx,
                    TableName tableName,
                    org.apache.hadoop.hbase.protobuf.generated.QuotaProtos.Quotas quotas)
                      throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before the quota for the table is stored.
    
    指定者:
    
    preSetTableQuota 在接口中 MasterObserver
    
    覆盖:
    
    preSetTableQuota 在类中 BaseMasterAndRegionObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    tableName - the name of the table
    quotas - the quota settings
    
    抛出:
    
    IOException
  - preSetNamespaceQuota
```
public void preSetNamespaceQuota(ObserverContext<MasterCoprocessorEnvironment> ctx,
                        String namespace,
                        org.apache.hadoop.hbase.protobuf.generated.QuotaProtos.Quotas quotas)
                          throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before the quota for the namespace is stored.
    
    指定者:
    
    preSetNamespaceQuota 在接口中 MasterObserver
    
    覆盖:
    
    preSetNamespaceQuota 在类中 BaseMasterAndRegionObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    namespace - the name of the namespace
    quotas - the quota settings
    
    抛出:
    
    IOException
  - preMoveServersAndTables
```
public void preMoveServersAndTables(ObserverContext<MasterCoprocessorEnvironment> ctx,
                           Set<Address> servers,
                           Set<TableName> tables,
                           String targetGroup)
                             throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before servers are moved to target region server group
    
    指定者:
    
    preMoveServersAndTables 在接口中 MasterObserver
    
    覆盖:
    
    preMoveServersAndTables 在类中 BaseMasterAndRegionObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    servers - set of servers to move
    targetGroup - destination group
    
    抛出:
    
    IOException - on failure
  - preMoveServers
```
public void preMoveServers(ObserverContext<MasterCoprocessorEnvironment> ctx,
                  Set<Address> servers,
                  String targetGroup)
                    throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before servers are moved to target region server group
    
    指定者:
    
    preMoveServers 在接口中 MasterObserver
    
    覆盖:
    
    preMoveServers 在类中 BaseMasterAndRegionObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    servers - set of servers to move
    targetGroup - destination group
    
    抛出:
    
    IOException
  - preMoveTables
```
public void preMoveTables(ObserverContext<MasterCoprocessorEnvironment> ctx,
                 Set<TableName> tables,
                 String targetGroup)
                   throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before tables are moved to target region server group
    
    指定者:
    
    preMoveTables 在接口中 MasterObserver
    
    覆盖:
    
    preMoveTables 在类中 BaseMasterAndRegionObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    tables - set of tables to move
    targetGroup - name of group
    
    抛出:
    
    IOException - on failure
  - preRemoveServers
```
public void preRemoveServers(ObserverContext<MasterCoprocessorEnvironment> ctx,
                    Set<Address> servers)
                      throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before servers are removed from rsgroup
    
    指定者:
    
    preRemoveServers 在接口中 MasterObserver
    
    覆盖:
    
    preRemoveServers 在类中 BaseMasterAndRegionObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    servers - set of decommissioned servers to remove
    
    抛出:
    
    IOException
  - preAddRSGroup
```
public void preAddRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx,
                 String name)
                   throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before a new region server group is added
    
    指定者:
    
    preAddRSGroup 在接口中 MasterObserver
    
    覆盖:
    
    preAddRSGroup 在类中 BaseMasterAndRegionObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    name - group name
    
    抛出:
    
    IOException - on failure
  - preRemoveRSGroup
```
public void preRemoveRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx,
                    String name)
                      throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before a region server group is removed
    
    指定者:
    
    preRemoveRSGroup 在接口中 MasterObserver
    
    覆盖:
    
    preRemoveRSGroup 在类中 BaseMasterAndRegionObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    name - group name
    
    抛出:
    
    IOException - on failure
  - preBalanceRSGroup
```
public void preBalanceRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx,
                     String groupName)
                       throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before a region server group is removed
    
    指定者:
    
    preBalanceRSGroup 在接口中 MasterObserver
    
    覆盖:
    
    preBalanceRSGroup 在类中 BaseMasterAndRegionObserver
    
    参数:
    ctx - the environment to interact with the framework and master
    groupName - group name
    
    抛出:
    
    IOException - on failure

类 AccessController

嵌套类概要

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

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

字段概要

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

构造器概要

方法概要

从类继承的方法 org.apache.hadoop.hbase.coprocessor.BaseMasterAndRegionObserver

从类继承的方法 org.apache.hadoop.hbase.coprocessor.BaseRegionObserver

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

构造器详细资料

AccessController

方法详细资料

isAuthorizationSupported

isCellAuthorizationSupported

getRegion

getAuthManager

requirePermission

requireTablePermission

requireAccess

requirePermission

requireGlobalPermission

requireGlobalPermission

requireNamespacePermission

requireNamespacePermission

start

stop

preCreateTable

postCreateTableHandler

preDeleteTable

postDeleteTable

preTruncateTable

postTruncateTable

preModifyTable

postModifyTable

preAddColumn

preModifyColumn

preDeleteColumn

postDeleteColumn

preEnableTable

preDisableTable

preAbortProcedure

postAbortProcedure

preListProcedures

postListProcedures

preMove

preAssign

preUnassign

preRegionOffline

preSetSplitOrMergeEnabled

postSetSplitOrMergeEnabled

preBalance

preBalanceSwitch

preShutdown

preStopMaster

postStartMaster

preSnapshot

preListSnapshot

preCloneSnapshot

preRestoreSnapshot

preDeleteSnapshot

preCreateNamespace

preDeleteNamespace

postDeleteNamespace

preModifyNamespace

preGetNamespaceDescriptor

postListNamespaceDescriptors

preTableFlush

preOpen

postOpen

postLogReplay

preFlush

preSplit

preSplit

preCompact

preGetClosestRowBefore

preGetOp

preExists

prePut