AccessController (Apache HBase

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

所有已实现的接口:

Coprocessor, BulkLoadObserver, EndpointObserver, MasterCoprocessor, MasterObserver, RegionCoprocessor, RegionObserver, RegionServerCoprocessor, RegionServerObserver, org.apache.hadoop.hbase.protobuf.generated.AccessControlProtos.AccessControlService.Interface
```
@InterfaceAudience.LimitedPrivate(value="Configuration")
public class AccessController
extends Object
implements MasterCoprocessor, RegionCoprocessor, RegionServerCoprocessor, org.apache.hadoop.hbase.protobuf.generated.AccessControlProtos.AccessControlService.Interface, MasterObserver, RegionObserver, RegionServerObserver, 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`	`checkLockPermissions(ObserverContext<?> ctx, String namespace, TableName tableName, RegionInfo[] regionInfos, String reason)`
`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()`
`Optional<BulkLoadObserver>`	`getBulkLoadObserver()`
`Optional<EndpointObserver>`	`getEndpointObserver()`
`Optional<MasterObserver>`	`getMasterObserver()`
`Region`	`getRegion()`
`Optional<RegionObserver>`	`getRegionObserver()` Observer/Service Getters
`Optional<RegionServerObserver>`	`getRegionServerObserver()`
`Iterable<com.google.protobuf.Service>`	`getServices()`
`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`	`isCellAuthorizationSupported(org.apache.hadoop.conf.Configuration conf)`
`void`	`postAbortProcedure(ObserverContext<MasterCoprocessorEnvironment> ctx)` Called after a abortProcedure request has been processed.
`void`	`postCompletedCreateTableAction(ObserverContext<MasterCoprocessorEnvironment> c, TableDescriptor desc, RegionInfo[] regions)` Called after the createTable operation has been requested.
`ReplicationEndpoint`	`postCreateReplicationEndPoint(ObserverContext<RegionServerCoprocessorEnvironment> ctx, ReplicationEndpoint endpoint)` This will be called after the replication endpoint is instantiated.
`void`	`postDelete(ObserverContext<RegionCoprocessorEnvironment> c, Delete delete, WALEdit edit, Durability durability)` Called after the client deletes a value.
`void`	`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<TableDescriptor> descriptors, String regex)` Called after a getTableDescriptors request has been processed.
`void`	`postGetTableNames(ObserverContext<MasterCoprocessorEnvironment> ctx, List<TableDescriptor> descriptors, String regex)` Called after a getTableNames request has been processed.
`void`	`postListNamespaceDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx, List<NamespaceDescriptor> descriptors)` Called after a listNamespaceDescriptors request has been processed.
`void`	`postModifyTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, TableDescriptor htd)` Called after the modifyTable operation has been requested.
`Cell`	`postMutationBeforeWAL(ObserverContext<RegionCoprocessorEnvironment> ctx, RegionObserver.MutationType opType, Mutation mutation, Cell oldCell, Cell newCell)` Called after a new cell has been created during an increment operation, but before it is committed to the WAL or memstore.
`void`	`postOpen(ObserverContext<RegionCoprocessorEnvironment> c)` Called after the region is reported as open to the master.
`void`	`postPut(ObserverContext<RegionCoprocessorEnvironment> c, Put put, WALEdit edit, Durability durability)` Called after the client stores a value.
`void`	`postRollWALWriterRequest(ObserverContext<RegionServerCoprocessorEnvironment> ctx)` This will be called after executing user request to roll a region server WAL.
`void`	`postScannerClose(ObserverContext<RegionCoprocessorEnvironment> c, InternalScanner s)` Called after the client closes a scanner.
`boolean`	`postScannerFilterRow(ObserverContext<RegionCoprocessorEnvironment> e, InternalScanner s, Cell curRowCell, boolean hasMore)` This will be called by the scan flow when the current scanned row is being filtered out by the filter.
`RegionScanner`	`postScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c, Scan scan, RegionScanner s)` Called after the client opens a new scanner.
`void`	`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, long procId)` Called before a abortProcedure request has been processed.
`void`	`preAddReplicationPeer(ObserverContext<MasterCoprocessorEnvironment> ctx, String peerId, ReplicationPeerConfig peerConfig)` Called before add a replication peer
`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, RegionInfo 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`	`preBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> c, boolean newValue)` Called prior to modifying the flag used to enable/disable region balancing.
`void`	`preBatchMutate(ObserverContext<RegionCoprocessorEnvironment> c, MiniBatchOperationInProgress<Mutation> miniBatchOp)` This will be called for every batch mutation operation happening at the server.
`void`	`preBulkLoadHFile(ObserverContext<RegionCoprocessorEnvironment> ctx, List<Pair<byte[],String>> familyPaths)` Verifies user has CREATE privileges on the Column Families involved in the bulkLoadHFile request.
`boolean`	`preCheckAndDelete(ObserverContext<RegionCoprocessorEnvironment> c, byte[] row, byte[] family, byte[] qualifier, CompareOperator op, ByteArrayComparable comparator, Delete delete, boolean result)` Called before checkAndDelete.
`boolean`	`preCheckAndDeleteAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> c, byte[] row, byte[] family, byte[] qualifier, CompareOperator op, ByteArrayComparable comparator, Delete delete, boolean result)` Called before checkAndDelete but after acquiring rowock.
`boolean`	`preCheckAndPut(ObserverContext<RegionCoprocessorEnvironment> c, byte[] row, byte[] family, byte[] qualifier, CompareOperator op, ByteArrayComparable comparator, Put put, boolean result)` Called before checkAndPut.
`boolean`	`preCheckAndPutAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> c, byte[] row, byte[] family, byte[] qualifier, CompareOperator opp, ByteArrayComparable comparator, Put put, boolean result)` Called before checkAndPut but after acquiring rowlock.
`void`	`preCleanupBulkLoad(ObserverContext<RegionCoprocessorEnvironment> ctx)` Authorization security check for SecureBulkLoadProtocol.cleanupBulkLoad()
`void`	`preClearCompactionQueues(ObserverContext<RegionServerCoprocessorEnvironment> ctx)` This will be called before clearing compaction queues
`void`	`preClearDeadServers(ObserverContext<MasterCoprocessorEnvironment> ctx)` Called before clear dead region servers.
`void`	`preCloneSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, SnapshotDescription snapshot, TableDescriptor hTableDescriptor)` Called before a snapshot is cloned.
`void`	`preClose(ObserverContext<RegionCoprocessorEnvironment> c, boolean abortRequested)` Called before the region is reported as closed to the master.
`InternalScanner`	`preCompact(ObserverContext<RegionCoprocessorEnvironment> c, Store store, InternalScanner scanner, ScanType scanType, CompactionLifeCycleTracker tracker, CompactionRequest request)` Called prior to writing the `StoreFile`s selected for compaction into a new `StoreFile`.
`void`	`preCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns)` Called before a new namespace is created by `HMaster`.
`void`	`preCreateTable(ObserverContext<MasterCoprocessorEnvironment> c, TableDescriptor desc, RegionInfo[] regions)` Observer implementations
`void`	`preDecommissionRegionServers(ObserverContext<MasterCoprocessorEnvironment> ctx, List<ServerName> servers, boolean offload)` Called before decommission region servers.
`void`	`preDelete(ObserverContext<RegionCoprocessorEnvironment> c, Delete delete, WALEdit edit, Durability durability)` Called before the client deletes a value.
`void`	`preDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace)` Called before `HMaster` deletes a namespace
`void`	`preDeleteSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, SnapshotDescription snapshot)` Called before a snapshot is deleted.
`void`	`preDeleteTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName)` Called before `HMaster` deletes a table.
`void`	`preDisableReplicationPeer(ObserverContext<MasterCoprocessorEnvironment> ctx, String peerId)` Called before disable a replication peer
`void`	`preDisableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName)` Called prior to disabling a table.
`void`	`preEnableReplicationPeer(ObserverContext<MasterCoprocessorEnvironment> ctx, String peerId)` Called before enable a replication peer
`void`	`preEnableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName)` Called prior to enabling a table.
`com.google.protobuf.Message`	`preEndpointInvocation(ObserverContext<RegionCoprocessorEnvironment> ctx, com.google.protobuf.Service service, String methodName, com.google.protobuf.Message request)` Called before an Endpoint service method is invoked.
`void`	`preExecuteProcedures(ObserverContext<RegionServerCoprocessorEnvironment> ctx)` This will be called before executing procedures
`boolean`	`preExists(ObserverContext<RegionCoprocessorEnvironment> c, Get get, boolean exists)` Called before the client tests for existence using a Get.
`void`	`preFlush(ObserverContext<RegionCoprocessorEnvironment> c, FlushLifeCycleTracker tracker)` Called before the memstore is flushed to disk.
`void`	`preGetLocks(ObserverContext<MasterCoprocessorEnvironment> ctx)` Called before a getLocks request has been processed.
`void`	`preGetNamespaceDescriptor(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace)` Called before a getNamespaceDescriptor request has been processed.
`void`	`preGetOp(ObserverContext<RegionCoprocessorEnvironment> c, Get get, List<Cell> result)` Called before the client performs a Get Call CoprocessorEnvironment#bypass to skip default actions.
`void`	`preGetProcedures(ObserverContext<MasterCoprocessorEnvironment> ctx)` Called before a getProcedures request has been processed.
`void`	`preGetReplicationPeerConfig(ObserverContext<MasterCoprocessorEnvironment> ctx, String peerId)` Called before get the configured ReplicationPeerConfig for the specified peer
`void`	`preGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx, List<TableName> tableNamesList, List<TableDescriptor> descriptors, String regex)` Called before a getTableDescriptors request has been processed.
`Result`	`preIncrement(ObserverContext<RegionCoprocessorEnvironment> c, Increment increment)` Called before Increment.
`Result`	`preIncrementAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> c, Increment increment)` Called before Increment but after acquiring rowlock.
`void`	`preListDecommissionedRegionServers(ObserverContext<MasterCoprocessorEnvironment> ctx)` Called before list decommissioned region servers.
`void`	`preListReplicationPeers(ObserverContext<MasterCoprocessorEnvironment> ctx, String regex)` Called before list replication peers.
`void`	`preListSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, SnapshotDescription snapshot)` Called before listSnapshots request has been processed.
`void`	`preLockHeartbeat(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, String description)` Called before heartbeat to a lock.
`void`	`preMergeRegions(ObserverContext<MasterCoprocessorEnvironment> ctx, RegionInfo[] regionsToMerge)` Called before merge regions request.
`void`	`preModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns)` Called prior to modifying a namespace's properties.
`void`	`preModifyTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, TableDescriptor htd)` Called prior to modifying a table's properties.
`void`	`preMove(ObserverContext<MasterCoprocessorEnvironment> c, RegionInfo region, ServerName srcServer, ServerName destServer)` Called prior to moving a given region from one region server to another.
`void`	`preOpen(ObserverContext<RegionCoprocessorEnvironment> c)` Called before the region is reported as open to the master.
`void`	`prePrepareBulkLoad(ObserverContext<RegionCoprocessorEnvironment> ctx)` Authorization check for SecureBulkLoadProtocol.prepareBulkLoad()
`void`	`prePut(ObserverContext<RegionCoprocessorEnvironment> c, Put put, WALEdit edit, Durability durability)` Called before the client stores a value.
`void`	`preRecommissionRegionServer(ObserverContext<MasterCoprocessorEnvironment> ctx, ServerName server, List<byte[]> encodedRegionNames)` Called before recommission region server.
`void`	`preRegionOffline(ObserverContext<MasterCoprocessorEnvironment> c, RegionInfo regionInfo)` Called prior to marking a given region as offline.
`void`	`preRemoveReplicationPeer(ObserverContext<MasterCoprocessorEnvironment> ctx, String peerId)` Called before remove a replication peer
`void`	`preReplicateLogEntries(ObserverContext<RegionServerCoprocessorEnvironment> ctx)` This will be called before executing replication request to shipping log entries.
`void`	`preRequestLock(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace, TableName tableName, RegionInfo[] regionInfos, String description)` Called before new LockProcedure is queued.
`void`	`preRestoreSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, SnapshotDescription snapshot, TableDescriptor hTableDescriptor)` Called before a snapshot is restored.
`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.
`void`	`preScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c, Scan scan)` Called before the client opens a new scanner.
`void`	`preSetNamespaceQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace, GlobalQuotaSettings quotas)` Called before the quota for the namespace is stored.
`void`	`preSetSplitOrMergeEnabled(ObserverContext<MasterCoprocessorEnvironment> ctx, boolean newValue, MasterSwitchType switchType)` Called prior to setting split / merge switch Supports Coprocessor 'bypass'.
`void`	`preSetTableQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, GlobalQuotaSettings quotas)` Called before the quota for the table is stored.
`void`	`preSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, String userName, GlobalQuotaSettings quotas)` Called before the quota for the user is stored.
`void`	`preSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, String userName, String namespace, GlobalQuotaSettings quotas)` Called before the quota for the user on the specified namespace is stored.
`void`	`preSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, String userName, TableName tableName, GlobalQuotaSettings 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, SnapshotDescription snapshot, TableDescriptor hTableDescriptor)` Called before a new snapshot is taken.
`void`	`preSplitRegion(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, byte[] splitRow)` Called before the split region procedure is called.
`void`	`preStopMaster(ObserverContext<MasterCoprocessorEnvironment> c)` Called immediately prior to stopping this `HMaster` process.
`void`	`preStopRegionServer(ObserverContext<RegionServerCoprocessorEnvironment> ctx)` Called before stopping region server.
`void`	`preTableFlush(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)` Called before the table memstore is flushed to disk.
`void`	`preTruncateTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName)` Called before `HMaster` truncates a table.
`void`	`preUnassign(ObserverContext<MasterCoprocessorEnvironment> c, RegionInfo regionInfo, boolean force)` Called prior to unassigning a given region.
`void`	`preUpdateReplicationPeerConfig(ObserverContext<MasterCoprocessorEnvironment> ctx, String peerId, ReplicationPeerConfig peerConfig)` Called before update peerConfig for the specified peer
`void`	`requireAccess(ObserverContext<?> ctx, String request, TableName tableName, Permission.Action... permissions)`
`void`	`requireGlobalPermission(ObserverContext<?> ctx, String request, Permission.Action perm, String namespace)`
`void`	`requireGlobalPermission(ObserverContext<?> ctx, String request, Permission.Action perm, TableName tableName, Map<byte[],? extends Collection<byte[]>> familyMap)`
`void`	`requireNamespacePermission(ObserverContext<?> ctx, String request, String namespace, Permission.Action... permissions)`
`void`	`requireNamespacePermission(ObserverContext<?> ctx, String request, String namespace, TableName tableName, Map<byte[],? extends Collection<byte[]>> familyMap, Permission.Action... permissions)`
`void`	`requirePermission(ObserverContext<?> ctx, String request, Permission.Action perm)`
`void`	`requirePermission(ObserverContext<?> ctx, String request, TableName tableName, byte[] family, byte[] qualifier, Permission.Action... permissions)`
`void`	`requireTablePermission(ObserverContext<?> ctx, String request, TableName tableName, byte[] family, byte[] qualifier, Permission.Action... permissions)`
`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)`

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

从接口继承的方法 org.apache.hadoop.hbase.coprocessor.MasterObserver
postAddReplicationPeer, postAddRSGroup, postAssign, postBalance, postBalanceRSGroup, postBalanceSwitch, postClearDeadServers, postCloneSnapshot, postCompletedDeleteTableAction, postCompletedDisableTableAction, postCompletedEnableTableAction, postCompletedMergeRegionsAction, postCompletedModifyTableAction, postCompletedModifyTableAction, postCompletedSplitRegionAction, postCompletedTruncateTableAction, postCreateNamespace, postCreateTable, postDecommissionRegionServers, postDeleteSnapshot, postDisableReplicationPeer, postDisableTable, postEnableReplicationPeer, postEnableTable, postGetClusterMetrics, postGetLocks, postGetNamespaceDescriptor, postGetProcedures, postGetReplicationPeerConfig, postListDecommissionedRegionServers, postListReplicationPeers, postListSnapshot, postLockHeartbeat, postMergeRegions, postMergeRegionsCommitAction, postModifyNamespace, postModifyNamespace, postModifyTable, postMove, postMoveServers, postMoveServersAndTables, postMoveTables, postRecommissionRegionServer, postRegionOffline, postRemoveReplicationPeer, postRemoveRSGroup, postRemoveServers, postRequestLock, postRestoreSnapshot, postRollBackMergeRegionsAction, postRollBackSplitRegionAction, postSetNamespaceQuota, postSetSplitOrMergeEnabled, postSetTableQuota, postSetUserQuota, postSetUserQuota, postSetUserQuota, postSnapshot, postTableFlush, postUnassign, postUpdateReplicationPeerConfig, preAddRSGroup, preBalanceRSGroup, preCreateTableAction, preDeleteTableAction, preDisableTableAction, preEnableTableAction, preGetClusterMetrics, preGetTableNames, preListNamespaceDescriptors, preMasterInitialization, preMergeRegionsAction, preMergeRegionsCommitAction, preModifyNamespace, preModifyTable, preModifyTableAction, preModifyTableAction, preMoveServers, preMoveServersAndTables, preMoveTables, preRemoveRSGroup, preRemoveServers, preSplitRegionAction, preSplitRegionAfterMETAAction, preSplitRegionBeforeMETAAction, preTruncateTableAction

从接口继承的方法 org.apache.hadoop.hbase.coprocessor.RegionServerObserver
postClearCompactionQueues, postExecuteProcedures, postReplicateLogEntries

- 构造器详细资料
  - AccessController
```
public AccessController()
```
- 方法详细资料
  - isCellAuthorizationSupported
```
public static boolean isCellAuthorizationSupported(org.apache.hadoop.conf.Configuration conf)
```
  - getRegion
```
public Region getRegion()
```
  - getAuthManager
```
public TableAuthManager getAuthManager()
```
  - requireAccess
```
public void requireAccess(ObserverContext<?> ctx,
                          String request,
                          TableName tableName,
                          Permission.Action... permissions)
                   throws IOException
```
    抛出:
    
    IOException
  - requirePermission
```
public void requirePermission(ObserverContext<?> ctx,
                              String request,
                              Permission.Action perm)
                       throws IOException
```
    抛出:
    
    IOException
  - requireGlobalPermission
```
public void requireGlobalPermission(ObserverContext<?> ctx,
                                    String request,
                                    Permission.Action perm,
                                    TableName tableName,
                                    Map<byte[],? extends Collection<byte[]>> familyMap)
                             throws IOException
```
    抛出:
    
    IOException
  - requireGlobalPermission
```
public void requireGlobalPermission(ObserverContext<?> ctx,
                                    String request,
                                    Permission.Action perm,
                                    String namespace)
                             throws IOException
```
    抛出:
    
    IOException
  - requireNamespacePermission
```
public void requireNamespacePermission(ObserverContext<?> ctx,
                                       String request,
                                       String namespace,
                                       Permission.Action... permissions)
                                throws IOException
```
    抛出:
    
    IOException
  - requireNamespacePermission
```
public void requireNamespacePermission(ObserverContext<?> ctx,
                                       String request,
                                       String namespace,
                                       TableName tableName,
                                       Map<byte[],? extends Collection<byte[]>> familyMap,
                                       Permission.Action... permissions)
                                throws IOException
```
    抛出:
    
    IOException
  - requirePermission
```
public void requirePermission(ObserverContext<?> ctx,
                              String request,
                              TableName tableName,
                              byte[] family,
                              byte[] qualifier,
                              Permission.Action... permissions)
                       throws IOException
```
    抛出:
    
    IOException
  - requireTablePermission
```
public void requireTablePermission(ObserverContext<?> ctx,
                                   String request,
                                   TableName tableName,
                                   byte[] family,
                                   byte[] qualifier,
                                   Permission.Action... permissions)
                            throws IOException
```
    抛出:
    
    IOException
  - checkLockPermissions
```
public void checkLockPermissions(ObserverContext<?> ctx,
                                 String namespace,
                                 TableName tableName,
                                 RegionInfo[] regionInfos,
                                 String reason)
                          throws IOException
```
    抛出:
    
    IOException
  - start
```
public void start(CoprocessorEnvironment env)
           throws IOException
```
    指定者:
    
    start 在接口中 Coprocessor
    
    抛出:
    
    IOException
  - stop
```
public void stop(CoprocessorEnvironment env)
```
    指定者:
    
    stop 在接口中 Coprocessor
  - getRegionObserver
```
public Optional<RegionObserver> getRegionObserver()
```
    Observer/Service Getters
    
    指定者:
    
    getRegionObserver 在接口中 RegionCoprocessor
  - getMasterObserver
```
public Optional<MasterObserver> getMasterObserver()
```
    指定者:
    
    getMasterObserver 在接口中 MasterCoprocessor
  - getEndpointObserver
```
public Optional<EndpointObserver> getEndpointObserver()
```
    指定者:
    
    getEndpointObserver 在接口中 RegionCoprocessor
  - getBulkLoadObserver
```
public Optional<BulkLoadObserver> getBulkLoadObserver()
```
    指定者:
    
    getBulkLoadObserver 在接口中 RegionCoprocessor
  - getRegionServerObserver
```
public Optional<RegionServerObserver> getRegionServerObserver()
```
    指定者:
    
    getRegionServerObserver 在接口中 RegionServerCoprocessor
  - getServices
```
public Iterable<com.google.protobuf.Service> getServices()
```
    指定者:
    
    getServices 在接口中 Coprocessor
  - preCreateTable
```
public void preCreateTable(ObserverContext<MasterCoprocessorEnvironment> c,
                           TableDescriptor desc,
                           RegionInfo[] regions)
                    throws IOException
```
    Observer implementations
    
    指定者:
    
    preCreateTable 在接口中 MasterObserver
    
    参数:
    
    c - the environment to interact with the framework and master
    
    desc - the TableDescriptor for the table
    
    regions - the initial regions created for the table
    
    抛出:
    
    IOException
  - postCompletedCreateTableAction
```
public void postCompletedCreateTableAction(ObserverContext<MasterCoprocessorEnvironment> c,
                                           TableDescriptor desc,
                                           RegionInfo[] 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 procedure and it is async to the create RPC call.
    
    指定者:
    
    postCompletedCreateTableAction 在接口中 MasterObserver
    
    参数:
    
    c - the environment to interact with the framework and master
    
    desc - the TableDescriptor 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.
    
    指定者:
    
    preDeleteTable 在接口中 MasterObserver
    
    参数:
    
    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
    
    参数:
    
    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.
    
    指定者:
    
    preTruncateTable 在接口中 MasterObserver
    
    参数:
    
    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
    
    参数:
    
    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,
                           TableDescriptor htd)
                    throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called prior to modifying a table's properties. Called as part of modify table RPC call.
    
    指定者:
    
    preModifyTable 在接口中 MasterObserver
    
    参数:
    
    c - the environment to interact with the framework and master
    
    tableName - the name of the table
    
    htd - after modify operation, table will have this descriptor
    
    抛出:
    
    IOException
  - postModifyTable
```
public void postModifyTable(ObserverContext<MasterCoprocessorEnvironment> c,
                            TableName tableName,
                            TableDescriptor htd)
                     throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called after the modifyTable operation has been requested. Called as part of modify table RPC call.
    
    指定者:
    
    postModifyTable 在接口中 MasterObserver
    
    参数:
    
    c - the environment to interact with the framework and master
    
    tableName - the name of the table
    
    htd - current TableDescriptor of the table
    
    抛出:
    
    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.
    
    指定者:
    
    preEnableTable 在接口中 MasterObserver
    
    参数:
    
    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.
    
    指定者:
    
    preDisableTable 在接口中 MasterObserver
    
    参数:
    
    c - the environment to interact with the framework and master
    
    tableName - the name of the table
    
    抛出:
    
    IOException
  - preAbortProcedure
```
public void preAbortProcedure(ObserverContext<MasterCoprocessorEnvironment> ctx,
                              long procId)
                       throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before a abortProcedure request has been processed.
    
    指定者:
    
    preAbortProcedure 在接口中 MasterObserver
    
    参数:
    
    ctx - the environment to interact with the framework and master
    
    procId - the Id of the procedure
    
    抛出:
    
    IOException
  - postAbortProcedure
```
public void postAbortProcedure(ObserverContext<MasterCoprocessorEnvironment> ctx)
                        throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called after a abortProcedure request has been processed.
    
    指定者:
    
    postAbortProcedure 在接口中 MasterObserver
    
    参数:
    
    ctx - the environment to interact with the framework and master
    
    抛出:
    
    IOException
  - preGetProcedures
```
public void preGetProcedures(ObserverContext<MasterCoprocessorEnvironment> ctx)
                      throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before a getProcedures request has been processed.
    
    指定者:
    
    preGetProcedures 在接口中 MasterObserver
    
    参数:
    
    ctx - the environment to interact with the framework and master
    
    抛出:
    
    IOException
  - preGetLocks
```
public void preGetLocks(ObserverContext<MasterCoprocessorEnvironment> ctx)
                 throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before a getLocks request has been processed.
    
    指定者:
    
    preGetLocks 在接口中 MasterObserver
    
    参数:
    
    ctx - the environment to interact with the framework and master
    
    抛出:
    
    IOException - if something went wrong
  - preMove
```
public void preMove(ObserverContext<MasterCoprocessorEnvironment> c,
                    RegionInfo region,
                    ServerName srcServer,
                    ServerName destServer)
             throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called prior to moving a given region from one region server to another.
    
    指定者:
    
    preMove 在接口中 MasterObserver
    
    参数:
    
    c - the environment to interact with the framework and master
    
    region - the RegionInfo
    
    srcServer - the source ServerName
    
    destServer - the destination ServerName
    
    抛出:
    
    IOException
  - preAssign
```
public void preAssign(ObserverContext<MasterCoprocessorEnvironment> c,
                      RegionInfo regionInfo)
               throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called prior to assigning a specific region.
    
    指定者:
    
    preAssign 在接口中 MasterObserver
    
    参数:
    
    c - the environment to interact with the framework and master
    
    regionInfo - the regionInfo of the region
    
    抛出:
    
    IOException
  - preUnassign
```
public void preUnassign(ObserverContext<MasterCoprocessorEnvironment> c,
                        RegionInfo regionInfo,
                        boolean force)
                 throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called prior to unassigning a given region.
    
    指定者:
    
    preUnassign 在接口中 MasterObserver
    
    参数:
    
    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,
                             RegionInfo regionInfo)
                      throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called prior to marking a given region as offline.
    
    指定者:
    
    preRegionOffline 在接口中 MasterObserver
    
    参数:
    
    c - the environment to interact with the framework and master
    
    抛出:
    
    IOException
  - preSetSplitOrMergeEnabled
```
public void preSetSplitOrMergeEnabled(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                      boolean newValue,
                                      MasterSwitchType switchType)
                               throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called prior to setting split / merge switch Supports Coprocessor 'bypass'.
    
    指定者:
    
    preSetSplitOrMergeEnabled 在接口中 MasterObserver
    
    参数:
    
    ctx - the coprocessor instance's environment
    
    newValue - the new value submitted in the call
    
    switchType - type of switch
    
    抛出:
    
    IOException
  - preBalance
```
public void preBalance(ObserverContext<MasterCoprocessorEnvironment> 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
    
    参数:
    
    c - the environment to interact with the framework and master
    
    抛出:
    
    IOException
  - preBalanceSwitch
```
public void preBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> c,
                             boolean newValue)
                      throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called prior to modifying the flag used to enable/disable region balancing.
    
    指定者:
    
    preBalanceSwitch 在接口中 MasterObserver
    
    参数:
    
    c - the coprocessor instance's environment
    
    抛出:
    
    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
    
    抛出:
    
    IOException
  - preStopMaster
```
public void preStopMaster(ObserverContext<MasterCoprocessorEnvironment> c)
                   throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called immediately prior to stopping this HMaster process.
    
    指定者:
    
    preStopMaster 在接口中 MasterObserver
    
    抛出:
    
    IOException
  - postStartMaster
```
public void postStartMaster(ObserverContext<MasterCoprocessorEnvironment> ctx)
                     throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called immediately after an active master instance has completed initialization. Will not be called on standby master instances unless they take over the active role.
    
    指定者:
    
    postStartMaster 在接口中 MasterObserver
    
    抛出:
    
    IOException
  - preSnapshot
```
public void preSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
                        SnapshotDescription snapshot,
                        TableDescriptor hTableDescriptor)
                 throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before a new snapshot is taken. Called as part of snapshot RPC call.
    
    指定者:
    
    preSnapshot 在接口中 MasterObserver
    
    参数:
    
    ctx - the environment to interact with the framework and master
    
    snapshot - the SnapshotDescriptor for the snapshot
    
    hTableDescriptor - the TableDescriptor of the table to snapshot
    
    抛出:
    
    IOException
  - preListSnapshot
```
public void preListSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
                            SnapshotDescription snapshot)
                     throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before listSnapshots request has been processed.
    
    指定者:
    
    preListSnapshot 在接口中 MasterObserver
    
    参数:
    
    ctx - the environment to interact with the framework and master
    
    snapshot - the SnapshotDescriptor of the snapshot to list
    
    抛出:
    
    IOException
  - preCloneSnapshot
```
public void preCloneSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
                             SnapshotDescription snapshot,
                             TableDescriptor hTableDescriptor)
                      throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before a snapshot is cloned. Called as part of restoreSnapshot RPC call.
    
    指定者:
    
    preCloneSnapshot 在接口中 MasterObserver
    
    参数:
    
    ctx - the environment to interact with the framework and master
    
    snapshot - the SnapshotDescriptor for the snapshot
    
    hTableDescriptor - the TableDescriptor of the table to create
    
    抛出:
    
    IOException
  - preRestoreSnapshot
```
public void preRestoreSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
                               SnapshotDescription snapshot,
                               TableDescriptor hTableDescriptor)
                        throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before a snapshot is restored. Called as part of restoreSnapshot RPC call.
    
    指定者:
    
    preRestoreSnapshot 在接口中 MasterObserver
    
    参数:
    
    ctx - the environment to interact with the framework and master
    
    snapshot - the SnapshotDescriptor for the snapshot
    
    hTableDescriptor - the TableDescriptor of the table to restore
    
    抛出:
    
    IOException
  - preDeleteSnapshot
```
public void preDeleteSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
                              SnapshotDescription snapshot)
                       throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before a snapshot is deleted. Called as part of deleteSnapshot RPC call.
    
    指定者:
    
    preDeleteSnapshot 在接口中 MasterObserver
    
    参数:
    
    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.
    
    指定者:
    
    preCreateNamespace 在接口中 MasterObserver
    
    参数:
    
    ctx - the environment to interact with the framework and master
    
    ns - the NamespaceDescriptor for the table
    
    抛出:
    
    IOException
  - preDeleteNamespace
```
public void preDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
                               String namespace)
                        throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before HMaster deletes a namespace
    
    指定者:
    
    preDeleteNamespace 在接口中 MasterObserver
    
    参数:
    
    ctx - the environment to interact with the framework and master
    
    namespace - the name of the namespace
    
    抛出:
    
    IOException
  - postDeleteNamespace
```
public void postDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                String namespace)
                         throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called after the deleteNamespace operation has been requested.
    
    指定者:
    
    postDeleteNamespace 在接口中 MasterObserver
    
    参数:
    
    ctx - the environment to interact with the framework and master
    
    namespace - the name of the namespace
    
    抛出:
    
    IOException
  - preModifyNamespace
```
public void preModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
                               NamespaceDescriptor ns)
                        throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called prior to modifying a namespace's properties.
    
    指定者:
    
    preModifyNamespace 在接口中 MasterObserver
    
    参数:
    
    ctx - the environment to interact with the framework and master
    
    ns - after modify operation, namespace will have this descriptor
    
    抛出:
    
    IOException
  - preGetNamespaceDescriptor
```
public void preGetNamespaceDescriptor(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                      String namespace)
                               throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before a getNamespaceDescriptor request has been processed.
    
    指定者:
    
    preGetNamespaceDescriptor 在接口中 MasterObserver
    
    参数:
    
    ctx - the environment to interact with the framework and master
    
    namespace - the name of the namespace
    
    抛出:
    
    IOException
  - postListNamespaceDescriptors
```
public void postListNamespaceDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                         List<NamespaceDescriptor> descriptors)
                                  throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called after a listNamespaceDescriptors request has been processed.
    
    指定者:
    
    postListNamespaceDescriptors 在接口中 MasterObserver
    
    参数:
    
    ctx - the environment to interact with the framework and master
    
    descriptors - the list of descriptors about to be returned
    
    抛出:
    
    IOException
  - preTableFlush
```
public void preTableFlush(ObserverContext<MasterCoprocessorEnvironment> ctx,
                          TableName tableName)
                   throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before the table memstore is flushed to disk.
    
    指定者:
    
    preTableFlush 在接口中 MasterObserver
    
    参数:
    
    ctx - the environment to interact with the framework and master
    
    tableName - the name of the table
    
    抛出:
    
    IOException
  - preSplitRegion
```
public void preSplitRegion(ObserverContext<MasterCoprocessorEnvironment> ctx,
                           TableName tableName,
                           byte[] splitRow)
                    throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before the split region procedure is called.
    
    指定者:
    
    preSplitRegion 在接口中 MasterObserver
    
    参数:
    
    ctx - the environment to interact with the framework and master
    
    tableName - the table where the region belongs to
    
    splitRow - split point
    
    抛出:
    
    IOException
  - preClearDeadServers
```
public void preClearDeadServers(ObserverContext<MasterCoprocessorEnvironment> ctx)
                         throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before clear dead region servers.
    
    指定者:
    
    preClearDeadServers 在接口中 MasterObserver
    
    抛出:
    
    IOException
  - preDecommissionRegionServers
```
public void preDecommissionRegionServers(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                         List<ServerName> servers,
                                         boolean offload)
                                  throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before decommission region servers.
    
    指定者:
    
    preDecommissionRegionServers 在接口中 MasterObserver
    
    抛出:
    
    IOException
  - preListDecommissionedRegionServers
```
public void preListDecommissionedRegionServers(ObserverContext<MasterCoprocessorEnvironment> ctx)
                                        throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before list decommissioned region servers.
    
    指定者:
    
    preListDecommissionedRegionServers 在接口中 MasterObserver
    
    抛出:
    
    IOException
  - preRecommissionRegionServer
```
public void preRecommissionRegionServer(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                        ServerName server,
                                        List<byte[]> encodedRegionNames)
                                 throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before recommission region server.
    
    指定者:
    
    preRecommissionRegionServer 在接口中 MasterObserver
    
    抛出:
    
    IOException
  - preOpen
```
public void preOpen(ObserverContext<RegionCoprocessorEnvironment> c)
             throws IOException
```
    从接口复制的说明: RegionObserver
    
    Called before the region is reported as open to the master.
    
    指定者:
    
    preOpen 在接口中 RegionObserver
    
    参数:
    
    c - the environment provided by the region server
    
    抛出:
    
    IOException
  - postOpen
```
public void postOpen(ObserverContext<RegionCoprocessorEnvironment> c)
```
    从接口复制的说明: RegionObserver
    
    Called after the region is reported as open to the master.
    
    指定者:
    
    postOpen 在接口中 RegionObserver
    
    参数:
    
    c - the environment provided by the region server
  - preFlush
```
public void preFlush(ObserverContext<RegionCoprocessorEnvironment> c,
                     FlushLifeCycleTracker tracker)
              throws IOException
```
    从接口复制的说明: RegionObserver
    
    Called before the memstore is flushed to disk.
    
    指定者:
    
    preFlush 在接口中 RegionObserver
    
    参数:
    
    c - the environment provided by the region server
    
    tracker - tracker used to track the life cycle of a flush
    
    抛出:
    
    IOException
  - preCompact
```
public InternalScanner preCompact(ObserverContext<RegionCoprocessorEnvironment> c,
                                  Store store,
                                  InternalScanner scanner,
                                  ScanType scanType,
                                  CompactionLifeCycleTracker tracker,
                                  CompactionRequest request)
                           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 can wrap the provided InternalScanner with a custom implementation that is returned from this method. The custom scanner can then inspect Cells from the wrapped scanner, applying its own policy to what gets written.
    
    指定者:
    
    preCompact 在接口中 RegionObserver
    
    参数:
    
    c - the environment provided by the region server
    
    store - the store being compacted
    
    scanner - the scanner over existing data used in the store file rewriting
    
    scanType - type of Scan
    
    tracker - tracker used to track the life cycle of a compaction
    
    request - the requested compaction
    
    返回:
    
    the scanner to use during compaction. Should not be null unless the implementation is writing new store files on its own.
    
    抛出:
    
    IOException
  - 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. If 'bypass' is set, we skip out on calling any subsequent chained coprocessors.
    
    指定者:
    
    preGetOp 在接口中 RegionObserver
    
    参数:
    
    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
  - 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. If 'bypass' is set, we skip out on calling any subsequent chained coprocessors.
    
    指定者:
    
    preExists 在接口中 RegionObserver
    
    参数:
    
    c - the environment provided by the region server
    
    get - the Get request
    
    exists - the result returned by the region server
    
    返回:
    
    the value to return to the client if bypassing default processing
    
    抛出:
    
    IOException
  - 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. If 'bypass' is set, we skip out on calling any subsequent chained coprocessors.
    Note: Do not retain references to any Cells in 'put' beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.
    
    指定者:
    
    prePut 在接口中 RegionObserver
    
    参数:
    
    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
  - postPut
```
public void postPut(ObserverContext<RegionCoprocessorEnvironment> c,
                    Put put,
                    WALEdit edit,
                    Durability durability)
```
    从接口复制的说明: RegionObserver
    
    Called after the client stores a value.
    Note: Do not retain references to any Cells in 'put' beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.
    
    指定者:
    
    postPut 在接口中 RegionObserver
    
    参数:
    
    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. If 'bypass' is set, we skip out on calling any subsequent chained coprocessors.
    Note: Do not retain references to any Cells in 'delete' beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.
    
    指定者:
    
    preDelete 在接口中 RegionObserver
    
    参数:
    
    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
  - 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.
    Note: Do not retain references to any Cells in Mutations beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.
    
    指定者:
    
    preBatchMutate 在接口中 RegionObserver
    
    参数:
    
    c - the environment provided by the region server
    
    miniBatchOp - batch of Mutations getting applied to region.
    
    抛出:
    
    IOException
  - postDelete
```
public void postDelete(ObserverContext<RegionCoprocessorEnvironment> c,
                       Delete delete,
                       WALEdit edit,
                       Durability durability)
                throws IOException
```
    从接口复制的说明: RegionObserver
    
    Called after the client deletes a value.
    Note: Do not retain references to any Cells in 'delete' beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.
    
    指定者:
    
    postDelete 在接口中 RegionObserver
    
    参数:
    
    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
  - preCheckAndPut
```
public boolean preCheckAndPut(ObserverContext<RegionCoprocessorEnvironment> c,
                              byte[] row,
                              byte[] family,
                              byte[] qualifier,
                              CompareOperator op,
                              ByteArrayComparable comparator,
                              Put put,
                              boolean result)
                       throws IOException
```
    从接口复制的说明: RegionObserver
    
    Called before checkAndPut.
    Call CoprocessorEnvironment#bypass to skip default actions. If 'bypass' is set, we skip out on calling any subsequent chained coprocessors.
    Note: Do not retain references to any Cells in 'put' beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.
    
    指定者:
    
    preCheckAndPut 在接口中 RegionObserver
    
    参数:
    
    c - the environment provided by the region server
    
    row - row to check
    
    family - column family
    
    qualifier - column qualifier
    
    op - the comparison operation
    
    comparator - the comparator
    
    put - data to put if check succeeds
    
    返回:
    
    the return value to return to client if bypassing default processing
    
    抛出:
    
    IOException
  - preCheckAndPutAfterRowLock
```
public boolean preCheckAndPutAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> c,
                                          byte[] row,
                                          byte[] family,
                                          byte[] qualifier,
                                          CompareOperator opp,
                                          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. If 'bypass' is set, we skip out on calling any subsequent chained coprocessors.
    Note: Do not retain references to any Cells in 'put' beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.
    
    指定者:
    
    preCheckAndPutAfterRowLock 在接口中 RegionObserver
    
    参数:
    
    c - the environment provided by the region server
    
    row - row to check
    
    family - column family
    
    qualifier - column qualifier
    
    opp - the comparison operation
    
    comparator - the comparator
    
    put - data to put if check succeeds
    
    返回:
    
    the return value to return to client if bypassing default processing
    
    抛出:
    
    IOException
  - preCheckAndDelete
```
public boolean preCheckAndDelete(ObserverContext<RegionCoprocessorEnvironment> c,
                                 byte[] row,
                                 byte[] family,
                                 byte[] qualifier,
                                 CompareOperator op,
                                 ByteArrayComparable comparator,
                                 Delete delete,
                                 boolean result)
                          throws IOException
```
    从接口复制的说明: RegionObserver
    
    Called before checkAndDelete.
    Call CoprocessorEnvironment#bypass to skip default actions. If 'bypass' is set, we skip out on calling any subsequent chained coprocessors.
    Note: Do not retain references to any Cells in 'delete' beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.
    
    指定者:
    
    preCheckAndDelete 在接口中 RegionObserver
    
    参数:
    
    c - the environment provided by the region server
    
    row - row to check
    
    family - column family
    
    qualifier - column qualifier
    
    op - the comparison operation
    
    comparator - the comparator
    
    delete - delete to commit if check succeeds
    
    返回:
    
    the value to return to client if bypassing default processing
    
    抛出:
    
    IOException
  - preCheckAndDeleteAfterRowLock
```
public boolean preCheckAndDeleteAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> c,
                                             byte[] row,
                                             byte[] family,
                                             byte[] qualifier,
                                             CompareOperator op,
                                             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. If 'bypass' is set, we skip out on calling any subsequent chained coprocessors.
    Note: Do not retain references to any Cells in 'delete' beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.
    
    指定者:
    
    preCheckAndDeleteAfterRowLock 在接口中 RegionObserver
    
    参数:
    
    c - the environment provided by the region server
    
    row - row to check
    
    family - column family
    
    qualifier - column qualifier
    
    op - the comparison operation
    
    comparator - the comparator
    
    delete - delete to commit if check succeeds
    
    返回:
    
    the value to return to client if bypassing default processing
    
    抛出:
    
    IOException
  - preAppend
```
public Result preAppend(ObserverContext<RegionCoprocessorEnvironment> c,
                        Append append)
                 throws IOException
```
    从接口复制的说明: RegionObserver
    
    Called before Append.
    Call CoprocessorEnvironment#bypass to skip default actions. If 'bypass' is set, we skip out on calling any subsequent chained coprocessors.
    Note: Do not retain references to any Cells in 'append' beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.
    
    指定者:
    
    preAppend 在接口中 RegionObserver
    
    参数:
    
    c - the environment provided by the region server
    
    append - Append object
    
    返回:
    
    result to return to the client if bypassing default processing
    
    抛出:
    
    IOException
  - 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. If 'bypass' is set, we skip out on calling any subsequent chained coprocessors.
    Note: Do not retain references to any Cells in 'append' beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.
    
    指定者:
    
    preAppendAfterRowLock 在接口中 RegionObserver
    
    参数:
    
    c - the environment provided by the region server
    
    append - Append object
    
    返回:
    
    result to return to the client if bypassing default processing
    
    抛出:
    
    IOException
  - preIncrement
```
public Result preIncrement(ObserverContext<RegionCoprocessorEnvironment> c,
                           Increment increment)
                    throws IOException
```
    从接口复制的说明: RegionObserver
    
    Called before Increment.
    Call CoprocessorEnvironment#bypass to skip default actions. If 'bypass' is set, we skip out on calling any subsequent chained coprocessors.
    Note: Do not retain references to any Cells in 'increment' beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.
    
    指定者:
    
    preIncrement 在接口中 RegionObserver
    
    参数:
    
    c - the environment provided by the region server
    
    increment - increment object
    
    返回:
    
    result to return to the client if bypassing default processing
    
    抛出:
    
    IOException
  - 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. If 'bypass' is set, we skip out on calling any subsequent chained coprocessors.
    Note: Do not retain references to any Cells in 'increment' beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.
    
    指定者:
    
    preIncrementAfterRowLock 在接口中 RegionObserver
    
    参数:
    
    c - the environment provided by the region server
    
    increment - increment object
    
    返回:
    
    result to return to the client if bypassing default processing if an error occurred on the coprocessor
    
    抛出:
    
    IOException
  - 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
    
    参数:
    
    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 void preScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c,
                           Scan scan)
                    throws IOException
```
    从接口复制的说明: RegionObserver
    
    Called before the client opens a new scanner.
    Note: Do not retain references to any Cells returned by scanner, beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.
    
    指定者:
    
    preScannerOpen 在接口中 RegionObserver
    
    参数:
    
    c - the environment provided by the region server
    
    scan - the Scan specification
    
    抛出:
    
    IOException
  - postScannerOpen
```
public RegionScanner postScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c,
                                     Scan scan,
                                     RegionScanner s)
                              throws IOException
```
    从接口复制的说明: RegionObserver
    
    Called after the client opens a new scanner.
    Note: Do not retain references to any Cells returned by scanner, beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.
    
    指定者:
    
    postScannerOpen 在接口中 RegionObserver
    
    参数:
    
    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
  - 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. If 'bypass' is set, we skip out on calling any subsequent chained coprocessors.
    Note: Do not retain references to any Cells returned by scanner, beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.
    
    指定者:
    
    preScannerNext 在接口中 RegionObserver
    
    参数:
    
    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
  - 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. If 'bypass' is set, we skip out on calling any subsequent chained coprocessors.
    
    指定者:
    
    preScannerClose 在接口中 RegionObserver
    
    参数:
    
    c - the environment provided by the region server
    
    s - the scanner
    
    抛出:
    
    IOException
  - postScannerClose
```
public void postScannerClose(ObserverContext<RegionCoprocessorEnvironment> c,
                             InternalScanner s)
                      throws IOException
```
    从接口复制的说明: RegionObserver
    
    Called after the client closes a scanner.
    
    指定者:
    
    postScannerClose 在接口中 RegionObserver
    
    参数:
    
    c - the environment provided by the region server
    
    s - the scanner
    
    抛出:
    
    IOException
  - postScannerFilterRow
```
public boolean postScannerFilterRow(ObserverContext<RegionCoprocessorEnvironment> e,
                                    InternalScanner s,
                                    Cell curRowCell,
                                    boolean hasMore)
                             throws IOException
```
    从接口复制的说明: RegionObserver
    This will be called by the scan flow when the current scanned row is being filtered out by the filter. The filter may be filtering out the row via any of the below scenarios
    1. boolean filterRowKey(byte [] buffer, int offset, int length) returning true
    2. boolean filterRow() returning true
    3. default void filterRow(List<KeyValue> kvs) removing all the kvs from the passed List
    Note: Do not retain references to any Cells returned by scanner, beyond the life of this invocation. If need a Cell reference for later use, copy the cell and use that.
    指定者:
    
    postScannerFilterRow 在接口中 RegionObserver
    
    参数:
    
    e - the environment provided by the region server
    
    s - the scanner
    
    curRowCell - The cell in the current row which got filtered out
    
    hasMore - the 'has more' indication
    
    返回:
    
    whether more rows are available for the scanner or not
    
    抛出:
    
    IOException
  - preBulkLoadHFile
```
public void preBulkLoadHFile(ObserverContext<RegionCoprocessorEnvironment> ctx,
                             List<Pair<byte[],String>> familyPaths)
                      throws IOException
```
    Verifies user has CREATE privileges on the Column Families involved in the bulkLoadHFile request. Specific Column Write privileges are presently ignored.
    
    指定者:
    
    preBulkLoadHFile 在接口中 RegionObserver
    
    参数:
    
    ctx - the environment provided by the region server
    
    familyPaths - pairs of { CF, HFile path } submitted for bulk load. Adding or removing from this list will add or remove HFiles to be bulk loaded.
    
    抛出:
    
    IOException
  - prePrepareBulkLoad
```
public void prePrepareBulkLoad(ObserverContext<RegionCoprocessorEnvironment> ctx)
                        throws IOException
```
    Authorization check for SecureBulkLoadProtocol.prepareBulkLoad()
    
    指定者:
    
    prePrepareBulkLoad 在接口中 BulkLoadObserver
    
    参数:
    
    ctx - the context
    
    抛出:
    
    IOException
  - preCleanupBulkLoad
```
public void preCleanupBulkLoad(ObserverContext<RegionCoprocessorEnvironment> ctx)
                        throws IOException
```
    Authorization security check for SecureBulkLoadProtocol.cleanupBulkLoad()
    
    指定者:
    
    preCleanupBulkLoad 在接口中 BulkLoadObserver
    
    参数:
    
    ctx - the context
    
    抛出:
    
    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 - Request message expected by given Service's method (by the name methodName).
    
    返回:
    
    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 - Request message expected by given Service's method (by the name methodName).
    
    responseBuilder - Builder for final response to the client, with original response from Service's method merged into it.
    
    抛出:
    
    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
  - preClose
```
public void preClose(ObserverContext<RegionCoprocessorEnvironment> c,
                     boolean abortRequested)
              throws IOException
```
    从接口复制的说明: RegionObserver
    
    Called before the region is reported as closed to the master.
    
    指定者:
    
    preClose 在接口中 RegionObserver
    
    参数:
    
    c - the environment provided by the region server
    
    abortRequested - true if the region server is aborting
    
    抛出:
    
    IOException
  - preStopRegionServer
```
public void preStopRegionServer(ObserverContext<RegionServerCoprocessorEnvironment> ctx)
                         throws IOException
```
    从接口复制的说明: RegionServerObserver
    
    Called before stopping region server.
    
    指定者:
    
    preStopRegionServer 在接口中 RegionServerObserver
    
    参数:
    
    ctx - the environment to interact with the framework and region server.
    
    抛出:
    
    IOException
  - preGetTableDescriptors
```
public void preGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                   List<TableName> tableNamesList,
                                   List<TableDescriptor> descriptors,
                                   String regex)
                            throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before a getTableDescriptors request has been processed.
    
    指定者:
    
    preGetTableDescriptors 在接口中 MasterObserver
    
    参数:
    
    ctx - the environment to interact with the framework and master
    
    tableNamesList - the list of table names, or null if querying for all
    
    descriptors - an empty list, can be filled with what to return in coprocessor
    
    regex - regular expression used for filtering the table names
    
    抛出:
    
    IOException
  - postGetTableDescriptors
```
public void postGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                    List<TableName> tableNamesList,
                                    List<TableDescriptor> descriptors,
                                    String regex)
                             throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called after a getTableDescriptors request has been processed.
    
    指定者:
    
    postGetTableDescriptors 在接口中 MasterObserver
    
    参数:
    
    ctx - the environment to interact with the framework and master
    
    tableNamesList - the list of table names, or null if querying for all
    
    descriptors - the list of descriptors about to be returned
    
    regex - regular expression used for filtering the table names
    
    抛出:
    
    IOException
  - postGetTableNames
```
public void postGetTableNames(ObserverContext<MasterCoprocessorEnvironment> ctx,
                              List<TableDescriptor> descriptors,
                              String regex)
                       throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called after a getTableNames request has been processed.
    
    指定者:
    
    postGetTableNames 在接口中 MasterObserver
    
    参数:
    
    ctx - the environment to interact with the framework and master
    
    descriptors - the list of descriptors about to be returned
    
    regex - regular expression used for filtering the table names
    
    抛出:
    
    IOException
  - preMergeRegions
```
public void preMergeRegions(ObserverContext<MasterCoprocessorEnvironment> ctx,
                            RegionInfo[] regionsToMerge)
                     throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before merge regions request.
    
    指定者:
    
    preMergeRegions 在接口中 MasterObserver
    
    参数:
    
    ctx - coprocessor environment
    
    regionsToMerge - regions to be merged
    
    抛出:
    
    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 - the environment to interact with the framework and region server.
    
    抛出:
    
    IOException
  - 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 - the environment to interact with the framework and region server.
    
    抛出:
    
    IOException
  - preSetUserQuota
```
public void preSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx,
                            String userName,
                            GlobalQuotaSettings quotas)
                     throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before the quota for the user is stored.
    
    指定者:
    
    preSetUserQuota 在接口中 MasterObserver
    
    参数:
    
    ctx - the environment to interact with the framework and master
    
    userName - the name of user
    
    quotas - the current quota for the user
    
    抛出:
    
    IOException
  - preSetUserQuota
```
public void preSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx,
                            String userName,
                            TableName tableName,
                            GlobalQuotaSettings quotas)
                     throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before the quota for the user on the specified table is stored.
    
    指定者:
    
    preSetUserQuota 在接口中 MasterObserver
    
    参数:
    
    ctx - the environment to interact with the framework and master
    
    userName - the name of user
    
    tableName - the name of the table
    
    quotas - the current quota for the user on the table
    
    抛出:
    
    IOException
  - preSetUserQuota
```
public void preSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx,
                            String userName,
                            String namespace,
                            GlobalQuotaSettings quotas)
                     throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before the quota for the user on the specified namespace is stored.
    
    指定者:
    
    preSetUserQuota 在接口中 MasterObserver
    
    参数:
    
    ctx - the environment to interact with the framework and master
    
    userName - the name of user
    
    namespace - the name of the namespace
    
    quotas - the current quota for the user on the namespace
    
    抛出:
    
    IOException
  - preSetTableQuota
```
public void preSetTableQuota(ObserverContext<MasterCoprocessorEnvironment> ctx,
                             TableName tableName,
                             GlobalQuotaSettings quotas)
                      throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before the quota for the table is stored.
    
    指定者:
    
    preSetTableQuota 在接口中 MasterObserver
    
    参数:
    
    ctx - the environment to interact with the framework and master
    
    tableName - the name of the table
    
    quotas - the current quota for the table
    
    抛出:
    
    IOException
  - preSetNamespaceQuota
```
public void preSetNamespaceQuota(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                 String namespace,
                                 GlobalQuotaSettings quotas)
                          throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before the quota for the namespace is stored.
    
    指定者:
    
    preSetNamespaceQuota 在接口中 MasterObserver
    
    参数:
    
    ctx - the environment to interact with the framework and master
    
    namespace - the name of the namespace
    
    quotas - the current quota for the namespace
    
    抛出:
    
    IOException
  - postCreateReplicationEndPoint
```
public ReplicationEndpoint postCreateReplicationEndPoint(ObserverContext<RegionServerCoprocessorEnvironment> ctx,
                                                         ReplicationEndpoint endpoint)
```
    从接口复制的说明: RegionServerObserver
    
    This will be called after the replication endpoint is instantiated.
    
    指定者:
    
    postCreateReplicationEndPoint 在接口中 RegionServerObserver
    
    参数:
    
    ctx - the environment to interact with the framework and region server.
    
    endpoint - - the base endpoint for replication
    
    返回:
    
    the endpoint to use during replication.
  - preReplicateLogEntries
```
public void preReplicateLogEntries(ObserverContext<RegionServerCoprocessorEnvironment> ctx)
                            throws IOException
```
    从接口复制的说明: RegionServerObserver
    
    This will be called before executing replication request to shipping log entries.
    
    指定者:
    
    preReplicateLogEntries 在接口中 RegionServerObserver
    
    参数:
    
    ctx - the environment to interact with the framework and region server.
    
    抛出:
    
    IOException
  - preClearCompactionQueues
```
public void preClearCompactionQueues(ObserverContext<RegionServerCoprocessorEnvironment> ctx)
                              throws IOException
```
    从接口复制的说明: RegionServerObserver
    
    This will be called before clearing compaction queues
    
    指定者:
    
    preClearCompactionQueues 在接口中 RegionServerObserver
    
    参数:
    
    ctx - the environment to interact with the framework and region server.
    
    抛出:
    
    IOException
  - preAddReplicationPeer
```
public void preAddReplicationPeer(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                  String peerId,
                                  ReplicationPeerConfig peerConfig)
                           throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before add a replication peer
    
    指定者:
    
    preAddReplicationPeer 在接口中 MasterObserver
    
    参数:
    
    ctx - the environment to interact with the framework and master
    
    peerId - a short name that identifies the peer
    
    peerConfig - configuration for the replication peer
    
    抛出:
    
    IOException
  - preRemoveReplicationPeer
```
public void preRemoveReplicationPeer(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                     String peerId)
                              throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before remove a replication peer
    
    指定者:
    
    preRemoveReplicationPeer 在接口中 MasterObserver
    
    peerId - a short name that identifies the peer
    
    抛出:
    
    IOException
  - preEnableReplicationPeer
```
public void preEnableReplicationPeer(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                     String peerId)
                              throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before enable a replication peer
    
    指定者:
    
    preEnableReplicationPeer 在接口中 MasterObserver
    
    peerId - a short name that identifies the peer
    
    抛出:
    
    IOException
  - preDisableReplicationPeer
```
public void preDisableReplicationPeer(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                      String peerId)
                               throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before disable a replication peer
    
    指定者:
    
    preDisableReplicationPeer 在接口中 MasterObserver
    
    peerId - a short name that identifies the peer
    
    抛出:
    
    IOException
  - preGetReplicationPeerConfig
```
public void preGetReplicationPeerConfig(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                        String peerId)
                                 throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before get the configured ReplicationPeerConfig for the specified peer
    
    指定者:
    
    preGetReplicationPeerConfig 在接口中 MasterObserver
    
    peerId - a short name that identifies the peer
    
    抛出:
    
    IOException
  - preUpdateReplicationPeerConfig
```
public void preUpdateReplicationPeerConfig(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                           String peerId,
                                           ReplicationPeerConfig peerConfig)
                                    throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before update peerConfig for the specified peer
    
    指定者:
    
    preUpdateReplicationPeerConfig 在接口中 MasterObserver
    
    peerId - a short name that identifies the peer
    
    抛出:
    
    IOException
  - preListReplicationPeers
```
public void preListReplicationPeers(ObserverContext<MasterCoprocessorEnvironment> ctx,
                                    String regex)
                             throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before list replication peers.
    
    指定者:
    
    preListReplicationPeers 在接口中 MasterObserver
    
    参数:
    
    ctx - the environment to interact with the framework and master
    
    regex - The regular expression to match peer id
    
    抛出:
    
    IOException
  - preRequestLock
```
public void preRequestLock(ObserverContext<MasterCoprocessorEnvironment> ctx,
                           String namespace,
                           TableName tableName,
                           RegionInfo[] regionInfos,
                           String description)
                    throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before new LockProcedure is queued.
    
    指定者:
    
    preRequestLock 在接口中 MasterObserver
    
    参数:
    
    ctx - the environment to interact with the framework and master
    
    抛出:
    
    IOException
  - preLockHeartbeat
```
public void preLockHeartbeat(ObserverContext<MasterCoprocessorEnvironment> ctx,
                             TableName tableName,
                             String description)
                      throws IOException
```
    从接口复制的说明: MasterObserver
    
    Called before heartbeat to a lock.
    
    指定者:
    
    preLockHeartbeat 在接口中 MasterObserver
    
    参数:
    
    ctx - the environment to interact with the framework and master
    
    抛出:
    
    IOException
  - preExecuteProcedures
```
public void preExecuteProcedures(ObserverContext<RegionServerCoprocessorEnvironment> ctx)
                          throws IOException
```
    从接口复制的说明: RegionServerObserver
    
    This will be called before executing procedures
    
    指定者:
    
    preExecuteProcedures 在接口中 RegionServerObserver
    
    参数:
    
    ctx - the environment to interact with the framework and region server.
    
    抛出:
    
    IOException

类 AccessController

嵌套类概要

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

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

字段概要

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

构造器概要

方法概要

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

从接口继承的方法 org.apache.hadoop.hbase.coprocessor.MasterObserver

从接口继承的方法 org.apache.hadoop.hbase.coprocessor.RegionObserver

从接口继承的方法 org.apache.hadoop.hbase.coprocessor.RegionServerObserver

构造器详细资料

AccessController

方法详细资料

isCellAuthorizationSupported

getRegion

getAuthManager

requireAccess

requirePermission

requireGlobalPermission

requireGlobalPermission

requireNamespacePermission

requireNamespacePermission

requirePermission

requireTablePermission

checkLockPermissions

start

stop

getRegionObserver

getMasterObserver

getEndpointObserver

getBulkLoadObserver

getRegionServerObserver

getServices

preCreateTable

postCompletedCreateTableAction

preDeleteTable

postDeleteTable

preTruncateTable

postTruncateTable

preModifyTable

postModifyTable

preEnableTable

preDisableTable

preAbortProcedure

postAbortProcedure

preGetProcedures

preGetLocks

preMove

preAssign

preUnassign

preRegionOffline

preSetSplitOrMergeEnabled

preBalance

preBalanceSwitch

preShutdown

preStopMaster

postStartMaster

preSnapshot

preListSnapshot

preCloneSnapshot

preRestoreSnapshot

preDeleteSnapshot

preCreateNamespace

preDeleteNamespace

postDeleteNamespace

preModifyNamespace

preGetNamespaceDescriptor

postListNamespaceDescriptors

preTableFlush

preSplitRegion

preClearDeadServers

preDecommissionRegionServers

preListDecommissionedRegionServers

preRecommissionRegionServer

preOpen

postOpen

preFlush

preCompact