Uses of Class
org.apache.hadoop.hbase.coprocessor.ObserverContext

Packages that use ObserverContext
org.apache.hadoop.hbase.constraint Restrict the domain of a data attribute, often times to fulfill business rules/requirements. 
org.apache.hadoop.hbase.coprocessor Table of Contents 
org.apache.hadoop.hbase.coprocessor.example   
org.apache.hadoop.hbase.security.access   
org.apache.hadoop.hbase.security.visibility   
org.apache.hadoop.hbase.tool   
 

Uses of ObserverContext in org.apache.hadoop.hbase.constraint
 

Methods in org.apache.hadoop.hbase.constraint with parameters of type ObserverContext
 void ConstraintProcessor.prePut(ObserverContext<RegionCoprocessorEnvironment> e, Put put, WALEdit edit, Durability durability)
           
 

Uses of ObserverContext in org.apache.hadoop.hbase.coprocessor
 

Methods in org.apache.hadoop.hbase.coprocessor that return ObserverContext
static
<T extends CoprocessorEnvironment>
ObserverContext<T>
ObserverContext.createAndPrepare(T env, ObserverContext<T> context)
          Instantiates a new ObserverContext instance if the passed reference is null and sets the environment in the new or existing instance.
 

Methods in org.apache.hadoop.hbase.coprocessor with parameters of type ObserverContext
static
<T extends CoprocessorEnvironment>
ObserverContext<T>
ObserverContext.createAndPrepare(T env, ObserverContext<T> context)
          Instantiates a new ObserverContext instance if the passed reference is null and sets the environment in the new or existing instance.
 void BaseMasterAndRegionObserver.postAddColumn(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, HColumnDescriptor column)
           
 void MasterObserver.postAddColumn(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, HColumnDescriptor column)
          Called after the new column family has been created.
 void BaseMasterObserver.postAddColumn(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, HColumnDescriptor column)
           
 void BaseMasterAndRegionObserver.postAddColumnHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, HColumnDescriptor column)
           
 void MasterObserver.postAddColumnHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, HColumnDescriptor column)
          Called after the new column family has been created.
 void BaseMasterObserver.postAddColumnHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, HColumnDescriptor column)
           
 Result RegionObserver.postAppend(ObserverContext<RegionCoprocessorEnvironment> c, Append append, Result result)
          Called after Append
 Result BaseRegionObserver.postAppend(ObserverContext<RegionCoprocessorEnvironment> e, Append append, Result result)
           
 void BaseMasterAndRegionObserver.postAssign(ObserverContext<MasterCoprocessorEnvironment> ctx, HRegionInfo regionInfo)
           
 void MasterObserver.postAssign(ObserverContext<MasterCoprocessorEnvironment> ctx, HRegionInfo regionInfo)
          Called after the region assignment has been requested.
 void BaseMasterObserver.postAssign(ObserverContext<MasterCoprocessorEnvironment> ctx, HRegionInfo regionInfo)
           
 void BaseMasterAndRegionObserver.postBalance(ObserverContext<MasterCoprocessorEnvironment> ctx, List<RegionPlan> plans)
           
 void MasterObserver.postBalance(ObserverContext<MasterCoprocessorEnvironment> ctx, List<RegionPlan> plans)
          Called after the balancing plan has been submitted.
 void BaseMasterObserver.postBalance(ObserverContext<MasterCoprocessorEnvironment> ctx, List<RegionPlan> plans)
           
 void BaseMasterAndRegionObserver.postBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> ctx, boolean oldValue, boolean newValue)
           
 void MasterObserver.postBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> ctx, boolean oldValue, boolean newValue)
          Called after the flag to enable/disable balancing has changed.
 void BaseMasterObserver.postBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> ctx, boolean oldValue, boolean newValue)
           
 void RegionObserver.postBatchMutate(ObserverContext<RegionCoprocessorEnvironment> c, MiniBatchOperationInProgress<Mutation> miniBatchOp)
          This will be called after applying a batch of Mutations on a region.
 void BaseRegionObserver.postBatchMutate(ObserverContext<RegionCoprocessorEnvironment> c, MiniBatchOperationInProgress<Mutation> miniBatchOp)
           
 void RegionObserver.postBatchMutateIndispensably(ObserverContext<RegionCoprocessorEnvironment> ctx, MiniBatchOperationInProgress<Mutation> miniBatchOp, boolean success)
          Called after the completion of batch put/delete and will be called even if the batch operation fails
 void BaseRegionObserver.postBatchMutateIndispensably(ObserverContext<RegionCoprocessorEnvironment> ctx, MiniBatchOperationInProgress<Mutation> miniBatchOp, boolean success)
           
 boolean RegionObserver.postBulkLoadHFile(ObserverContext<RegionCoprocessorEnvironment> ctx, List<Pair<byte[],String>> familyPaths, boolean hasLoaded)
          Called after bulkLoadHFile.
 boolean BaseRegionObserver.postBulkLoadHFile(ObserverContext<RegionCoprocessorEnvironment> ctx, List<Pair<byte[],String>> familyPaths, boolean hasLoaded)
           
 boolean RegionObserver.postCheckAndDelete(ObserverContext<RegionCoprocessorEnvironment> c, byte[] row, byte[] family, byte[] qualifier, CompareFilter.CompareOp compareOp, ByteArrayComparable comparator, Delete delete, boolean result)
          Called after checkAndDelete
 boolean BaseRegionObserver.postCheckAndDelete(ObserverContext<RegionCoprocessorEnvironment> e, byte[] row, byte[] family, byte[] qualifier, CompareFilter.CompareOp compareOp, ByteArrayComparable comparator, Delete delete, boolean result)
           
 boolean RegionObserver.postCheckAndPut(ObserverContext<RegionCoprocessorEnvironment> c, byte[] row, byte[] family, byte[] qualifier, CompareFilter.CompareOp compareOp, ByteArrayComparable comparator, Put put, boolean result)
          Called after checkAndPut
 boolean BaseRegionObserver.postCheckAndPut(ObserverContext<RegionCoprocessorEnvironment> e, byte[] row, byte[] family, byte[] qualifier, CompareFilter.CompareOp compareOp, ByteArrayComparable comparator, Put put, boolean result)
           
 void BaseMasterAndRegionObserver.postCloneSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, HBaseProtos.SnapshotDescription snapshot, HTableDescriptor hTableDescriptor)
           
 void MasterObserver.postCloneSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, HBaseProtos.SnapshotDescription snapshot, HTableDescriptor hTableDescriptor)
          Called after a snapshot clone operation has been requested.
 void BaseMasterObserver.postCloneSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, HBaseProtos.SnapshotDescription snapshot, HTableDescriptor hTableDescriptor)
           
 void RegionObserver.postClose(ObserverContext<RegionCoprocessorEnvironment> c, boolean abortRequested)
          Called after the region is reported as closed to the master.
 void BaseRegionObserver.postClose(ObserverContext<RegionCoprocessorEnvironment> e, boolean abortRequested)
           
 void RegionObserver.postCloseRegionOperation(ObserverContext<RegionCoprocessorEnvironment> ctx, HRegion.Operation operation)
          Called after releasing read lock in HRegion.closeRegionOperation(Operation).
 void BaseRegionObserver.postCloseRegionOperation(ObserverContext<RegionCoprocessorEnvironment> ctx, HRegion.Operation op)
           
 void RegionObserver.postCompact(ObserverContext<RegionCoprocessorEnvironment> c, Store store, StoreFile resultFile)
          Deprecated. Use RegionObserver.postCompact(ObserverContext, Store, StoreFile, CompactionRequest) instead
 void BaseRegionObserver.postCompact(ObserverContext<RegionCoprocessorEnvironment> e, Store store, StoreFile resultFile)
           
 void RegionObserver.postCompact(ObserverContext<RegionCoprocessorEnvironment> c, Store store, StoreFile resultFile, CompactionRequest request)
          Called after compaction has completed and the new store file has been moved in to place.
 void BaseRegionObserver.postCompact(ObserverContext<RegionCoprocessorEnvironment> e, Store store, StoreFile resultFile, CompactionRequest request)
           
 void RegionObserver.postCompactSelection(ObserverContext<RegionCoprocessorEnvironment> c, Store store, com.google.common.collect.ImmutableList<StoreFile> selected)
          Deprecated. use RegionObserver.postCompactSelection(ObserverContext, Store, ImmutableList, CompactionRequest) instead.
 void BaseRegionObserver.postCompactSelection(ObserverContext<RegionCoprocessorEnvironment> c, Store store, com.google.common.collect.ImmutableList<StoreFile> selected)
           
 void RegionObserver.postCompactSelection(ObserverContext<RegionCoprocessorEnvironment> c, Store store, com.google.common.collect.ImmutableList<StoreFile> selected, CompactionRequest request)
          Called after the StoreFiles to compact have been selected from the available candidates.
 void BaseRegionObserver.postCompactSelection(ObserverContext<RegionCoprocessorEnvironment> c, Store store, com.google.common.collect.ImmutableList<StoreFile> selected, CompactionRequest request)
           
 void RegionObserver.postCompleteSplit(ObserverContext<RegionCoprocessorEnvironment> ctx)
          Called after any split request is processed.
 void BaseRegionObserver.postCompleteSplit(ObserverContext<RegionCoprocessorEnvironment> ctx)
           
 void BaseMasterAndRegionObserver.postCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns)
           
 void MasterObserver.postCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns)
          Called after the createNamespace operation has been requested.
 void BaseMasterObserver.postCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns)
           
 ReplicationEndpoint BaseRegionServerObserver.postCreateReplicationEndPoint(ObserverContext<RegionServerCoprocessorEnvironment> ctx, ReplicationEndpoint endpoint)
           
 ReplicationEndpoint RegionServerObserver.postCreateReplicationEndPoint(ObserverContext<RegionServerCoprocessorEnvironment> ctx, ReplicationEndpoint endpoint)
          This will be called after the replication endpoint is instantiated.
 void BaseMasterAndRegionObserver.postCreateTable(ObserverContext<MasterCoprocessorEnvironment> ctx, HTableDescriptor desc, HRegionInfo[] regions)
           
 void MasterObserver.postCreateTable(ObserverContext<MasterCoprocessorEnvironment> ctx, HTableDescriptor desc, HRegionInfo[] regions)
          Called after the createTable operation has been requested.
 void BaseMasterObserver.postCreateTable(ObserverContext<MasterCoprocessorEnvironment> ctx, HTableDescriptor desc, HRegionInfo[] regions)
           
 void BaseMasterAndRegionObserver.postCreateTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, HTableDescriptor desc, HRegionInfo[] regions)
           
 void MasterObserver.postCreateTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, HTableDescriptor desc, HRegionInfo[] regions)
          Called after the createTable operation has been requested.
 void BaseMasterObserver.postCreateTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, HTableDescriptor desc, HRegionInfo[] regions)
           
 void RegionObserver.postDelete(ObserverContext<RegionCoprocessorEnvironment> c, Delete delete, WALEdit edit, Durability durability)
          Called after the client deletes a value.
 void BaseRegionObserver.postDelete(ObserverContext<RegionCoprocessorEnvironment> e, Delete delete, WALEdit edit, Durability durability)
           
 void BaseMasterAndRegionObserver.postDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, byte[] c)
           
 void MasterObserver.postDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, byte[] c)
          Called after the column family has been deleted.
 void BaseMasterObserver.postDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, byte[] c)
           
 void BaseMasterAndRegionObserver.postDeleteColumnHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, byte[] c)
           
 void MasterObserver.postDeleteColumnHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, byte[] c)
          Called after the column family has been deleted.
 void BaseMasterObserver.postDeleteColumnHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, byte[] c)
           
 void BaseMasterAndRegionObserver.postDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace)
           
 void MasterObserver.postDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace)
          Called after the deleteNamespace operation has been requested.
 void BaseMasterObserver.postDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace)
           
 void BaseMasterAndRegionObserver.postDeleteSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, HBaseProtos.SnapshotDescription snapshot)
           
 void MasterObserver.postDeleteSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, HBaseProtos.SnapshotDescription snapshot)
          Called after the delete snapshot operation has been requested.
 void BaseMasterObserver.postDeleteSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, HBaseProtos.SnapshotDescription snapshot)
           
 void BaseMasterAndRegionObserver.postDeleteTable(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)
           
 void MasterObserver.postDeleteTable(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)
          Called after the deleteTable operation has been requested.
 void BaseMasterObserver.postDeleteTable(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)
           
 void BaseMasterAndRegionObserver.postDeleteTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)
           
 void MasterObserver.postDeleteTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)
          Called after HMaster deletes a table.
 void BaseMasterObserver.postDeleteTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)
           
 void BaseMasterAndRegionObserver.postDisableTable(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)
           
 void MasterObserver.postDisableTable(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)
          Called after the disableTable operation has been requested.
 void BaseMasterObserver.postDisableTable(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)
           
 void BaseMasterAndRegionObserver.postDisableTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)
           
 void MasterObserver.postDisableTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)
          Called after the disableTable operation has been requested.
 void BaseMasterObserver.postDisableTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)
           
 void BaseMasterAndRegionObserver.postEnableTable(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)
           
 void MasterObserver.postEnableTable(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)
          Called after the enableTable operation has been requested.
 void BaseMasterObserver.postEnableTable(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)
           
 void BaseMasterAndRegionObserver.postEnableTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)
           
 void MasterObserver.postEnableTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)
          Called after the enableTable operation has been requested.
 void BaseMasterObserver.postEnableTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)
           
 void EndpointObserver.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.
 boolean RegionObserver.postExists(ObserverContext<RegionCoprocessorEnvironment> c, Get get, boolean exists)
          Called after the client tests for existence using a Get.
 boolean BaseRegionObserver.postExists(ObserverContext<RegionCoprocessorEnvironment> e, Get get, boolean exists)
           
 void RegionObserver.postFlush(ObserverContext<RegionCoprocessorEnvironment> c)
          Deprecated. use RegionObserver.preFlush(ObserverContext, Store, InternalScanner) instead.
 void BaseRegionObserver.postFlush(ObserverContext<RegionCoprocessorEnvironment> e)
           
 void RegionObserver.postFlush(ObserverContext<RegionCoprocessorEnvironment> c, Store store, StoreFile resultFile)
          Called after a Store's memstore is flushed to disk.
 void BaseRegionObserver.postFlush(ObserverContext<RegionCoprocessorEnvironment> e, Store store, StoreFile resultFile)
           
 void RegionObserver.postGet(ObserverContext<RegionCoprocessorEnvironment> c, Get get, List<KeyValue> result)
          Deprecated. 
 void BaseRegionObserver.postGet(ObserverContext<RegionCoprocessorEnvironment> c, Get get, List<KeyValue> result)
          Deprecated. 
 void RegionObserver.postGetClosestRowBefore(ObserverContext<RegionCoprocessorEnvironment> c, byte[] row, byte[] family, Result result)
          Called after a client makes a GetClosestRowBefore request.
 void BaseRegionObserver.postGetClosestRowBefore(ObserverContext<RegionCoprocessorEnvironment> e, byte[] row, byte[] family, Result result)
           
 void RegionObserver.postGetOp(ObserverContext<RegionCoprocessorEnvironment> c, Get get, List<Cell> result)
          Called after the client performs a Get
 void BaseRegionObserver.postGetOp(ObserverContext<RegionCoprocessorEnvironment> e, Get get, List<Cell> results)
           
 void BaseMasterAndRegionObserver.postGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx, List<HTableDescriptor> descriptors)
           
 void MasterObserver.postGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx, List<HTableDescriptor> descriptors)
          Called after a getTableDescriptors request has been processed.
 void BaseMasterObserver.postGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx, List<HTableDescriptor> descriptors)
           
 Result RegionObserver.postIncrement(ObserverContext<RegionCoprocessorEnvironment> c, Increment increment, Result result)
          Called after increment
 Result BaseRegionObserver.postIncrement(ObserverContext<RegionCoprocessorEnvironment> e, Increment increment, Result result)
           
 long RegionObserver.postIncrementColumnValue(ObserverContext<RegionCoprocessorEnvironment> c, byte[] row, byte[] family, byte[] qualifier, long amount, boolean writeToWAL, long result)
          Deprecated. This hook is no longer called by the RegionServer
 long BaseRegionObserver.postIncrementColumnValue(ObserverContext<RegionCoprocessorEnvironment> e, byte[] row, byte[] family, byte[] qualifier, long amount, boolean writeToWAL, long result)
           
 DeleteTracker RegionObserver.postInstantiateDeleteTracker(ObserverContext<RegionCoprocessorEnvironment> ctx, DeleteTracker delTracker)
          Called after the ScanQueryMatcher creates ScanDeleteTracker.
 DeleteTracker BaseRegionObserver.postInstantiateDeleteTracker(ObserverContext<RegionCoprocessorEnvironment> ctx, DeleteTracker delTracker)
           
 void RegionObserver.postLogReplay(ObserverContext<RegionCoprocessorEnvironment> c)
          Called after the log replay on the region is over.
 void BaseRegionObserver.postLogReplay(ObserverContext<RegionCoprocessorEnvironment> e)
           
 void BaseRegionServerObserver.postMerge(ObserverContext<RegionServerCoprocessorEnvironment> c, HRegion regionA, HRegion regionB, HRegion mergedRegion)
           
 void RegionServerObserver.postMerge(ObserverContext<RegionServerCoprocessorEnvironment> c, HRegion regionA, HRegion regionB, HRegion mergedRegion)
          called after the regions merge.
 void BaseRegionServerObserver.postMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB, HRegion mergedRegion)
           
 void RegionServerObserver.postMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB, HRegion mergedRegion)
          This will be called after PONR step as part of regions merge transaction.
 void BaseMasterAndRegionObserver.postModifyColumn(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, HColumnDescriptor descriptor)
           
 void MasterObserver.postModifyColumn(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, HColumnDescriptor descriptor)
          Called after the column family has been updated.
 void BaseMasterObserver.postModifyColumn(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, HColumnDescriptor descriptor)
           
 void BaseMasterAndRegionObserver.postModifyColumnHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, HColumnDescriptor descriptor)
           
 void MasterObserver.postModifyColumnHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, HColumnDescriptor descriptor)
          Called after the column family has been updated.
 void BaseMasterObserver.postModifyColumnHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, HColumnDescriptor descriptor)
           
 void BaseMasterAndRegionObserver.postModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns)
           
 void MasterObserver.postModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns)
          Called after the modifyNamespace operation has been requested.
 void BaseMasterObserver.postModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns)
           
 void BaseMasterAndRegionObserver.postModifyTable(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, HTableDescriptor htd)
           
 void MasterObserver.postModifyTable(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, HTableDescriptor htd)
          Called after the modifyTable operation has been requested.
 void BaseMasterObserver.postModifyTable(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, HTableDescriptor htd)
           
 void BaseMasterAndRegionObserver.postModifyTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, HTableDescriptor htd)
           
 void MasterObserver.postModifyTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, HTableDescriptor htd)
          Called after to modifying a table's properties.
 void BaseMasterObserver.postModifyTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, HTableDescriptor htd)
           
 void BaseMasterAndRegionObserver.postMove(ObserverContext<MasterCoprocessorEnvironment> ctx, HRegionInfo region, ServerName srcServer, ServerName destServer)
           
 void MasterObserver.postMove(ObserverContext<MasterCoprocessorEnvironment> ctx, HRegionInfo region, ServerName srcServer, ServerName destServer)
          Called after the region move has been requested.
 void BaseMasterObserver.postMove(ObserverContext<MasterCoprocessorEnvironment> ctx, HRegionInfo region, ServerName srcServer, ServerName destServer)
           
 Cell RegionObserver.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.
 Cell BaseRegionObserver.postMutationBeforeWAL(ObserverContext<RegionCoprocessorEnvironment> ctx, RegionObserver.MutationType opType, Mutation mutation, Cell oldCell, Cell newCell)
           
 void RegionObserver.postOpen(ObserverContext<RegionCoprocessorEnvironment> c)
          Called after the region is reported as open to the master.
 void BaseRegionObserver.postOpen(ObserverContext<RegionCoprocessorEnvironment> e)
           
 void RegionObserver.postPut(ObserverContext<RegionCoprocessorEnvironment> c, Put put, WALEdit edit, Durability durability)
          Called after the client stores a value.
 void BaseRegionObserver.postPut(ObserverContext<RegionCoprocessorEnvironment> e, Put put, WALEdit edit, Durability durability)
           
 void BaseMasterAndRegionObserver.postRegionOffline(ObserverContext<MasterCoprocessorEnvironment> ctx, HRegionInfo regionInfo)
           
 void MasterObserver.postRegionOffline(ObserverContext<MasterCoprocessorEnvironment> ctx, HRegionInfo regionInfo)
          Called after the region has been marked offline.
 void BaseMasterObserver.postRegionOffline(ObserverContext<MasterCoprocessorEnvironment> ctx, HRegionInfo regionInfo)
           
 void BaseRegionServerObserver.postReplicateLogEntries(ObserverContext<RegionServerCoprocessorEnvironment> ctx, List<AdminProtos.WALEntry> entries, CellScanner cells)
           
 void RegionServerObserver.postReplicateLogEntries(ObserverContext<RegionServerCoprocessorEnvironment> ctx, List<AdminProtos.WALEntry> entries, CellScanner cells)
          This will be called after executing replication request to shipping log entries.
 void BaseMasterAndRegionObserver.postRestoreSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, HBaseProtos.SnapshotDescription snapshot, HTableDescriptor hTableDescriptor)
           
 void MasterObserver.postRestoreSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, HBaseProtos.SnapshotDescription snapshot, HTableDescriptor hTableDescriptor)
          Called after a snapshot restore operation has been requested.
 void BaseMasterObserver.postRestoreSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, HBaseProtos.SnapshotDescription snapshot, HTableDescriptor hTableDescriptor)
           
 void BaseRegionServerObserver.postRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB)
           
 void RegionServerObserver.postRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB)
          This will be called after the roll back of the regions merge.
 void RegionObserver.postRollBackSplit(ObserverContext<RegionCoprocessorEnvironment> ctx)
          This will be called after the roll back of the split region is completed
 void BaseRegionObserver.postRollBackSplit(ObserverContext<RegionCoprocessorEnvironment> ctx)
           
 void BaseRegionServerObserver.postRollWALWriterRequest(ObserverContext<RegionServerCoprocessorEnvironment> ctx)
           
 void RegionServerObserver.postRollWALWriterRequest(ObserverContext<RegionServerCoprocessorEnvironment> ctx)
          This will be called after executing user request to roll a region server WAL.
 void RegionObserver.postScannerClose(ObserverContext<RegionCoprocessorEnvironment> c, InternalScanner s)
          Called after the client closes a scanner.
 void BaseRegionObserver.postScannerClose(ObserverContext<RegionCoprocessorEnvironment> e, InternalScanner s)
           
 boolean RegionObserver.postScannerFilterRow(ObserverContext<RegionCoprocessorEnvironment> c, InternalScanner s, byte[] currentRow, int offset, short length, boolean hasMore)
          This will be called by the scan flow when the current scanned row is being filtered out by the filter.
 boolean BaseRegionObserver.postScannerFilterRow(ObserverContext<RegionCoprocessorEnvironment> e, InternalScanner s, byte[] currentRow, int offset, short length, boolean hasMore)
           
 boolean RegionObserver.postScannerNext(ObserverContext<RegionCoprocessorEnvironment> c, InternalScanner s, List<Result> result, int limit, boolean hasNext)
          Called after the client asks for the next row on a scanner.
 boolean BaseRegionObserver.postScannerNext(ObserverContext<RegionCoprocessorEnvironment> e, InternalScanner s, List<Result> results, int limit, boolean hasMore)
           
 RegionScanner RegionObserver.postScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c, Scan scan, RegionScanner s)
          Called after the client opens a new scanner.
 RegionScanner BaseRegionObserver.postScannerOpen(ObserverContext<RegionCoprocessorEnvironment> e, Scan scan, RegionScanner s)
           
 void BaseMasterAndRegionObserver.postSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, HBaseProtos.SnapshotDescription snapshot, HTableDescriptor hTableDescriptor)
           
 void MasterObserver.postSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, HBaseProtos.SnapshotDescription snapshot, HTableDescriptor hTableDescriptor)
          Called after the snapshot operation has been requested.
 void BaseMasterObserver.postSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, HBaseProtos.SnapshotDescription snapshot, HTableDescriptor hTableDescriptor)
           
 void RegionObserver.postSplit(ObserverContext<RegionCoprocessorEnvironment> c, HRegion l, HRegion r)
          Deprecated. Use postCompleteSplit() instead
 void BaseRegionObserver.postSplit(ObserverContext<RegionCoprocessorEnvironment> e, HRegion l, HRegion r)
           
 void BaseMasterAndRegionObserver.postStartMaster(ObserverContext<MasterCoprocessorEnvironment> ctx)
           
 void MasterObserver.postStartMaster(ObserverContext<MasterCoprocessorEnvironment> ctx)
          Called immediately after an active master instance has completed initialization.
 void BaseMasterObserver.postStartMaster(ObserverContext<MasterCoprocessorEnvironment> ctx)
           
 void RegionObserver.postStartRegionOperation(ObserverContext<RegionCoprocessorEnvironment> ctx, HRegion.Operation operation)
          This will be called for region operations where read lock is acquired in HRegion.startRegionOperation().
 void BaseRegionObserver.postStartRegionOperation(ObserverContext<RegionCoprocessorEnvironment> ctx, HRegion.Operation op)
           
 StoreFile.Reader RegionObserver.postStoreFileReaderOpen(ObserverContext<RegionCoprocessorEnvironment> ctx, org.apache.hadoop.fs.FileSystem fs, org.apache.hadoop.fs.Path p, FSDataInputStreamWrapper in, long size, CacheConfig cacheConf, Reference r, StoreFile.Reader reader)
          Called after the creation of Reader for a store file.
 StoreFile.Reader BaseRegionObserver.postStoreFileReaderOpen(ObserverContext<RegionCoprocessorEnvironment> ctx, org.apache.hadoop.fs.FileSystem fs, org.apache.hadoop.fs.Path p, FSDataInputStreamWrapper in, long size, CacheConfig cacheConf, Reference r, StoreFile.Reader reader)
           
 void MasterObserver.postTruncateTable(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)
          Called after the truncateTable operation has been requested.
 void BaseMasterObserver.postTruncateTable(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)
           
 void MasterObserver.postTruncateTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)
          Called after HMaster truncates a table.
 void BaseMasterObserver.postTruncateTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)
           
 void BaseMasterAndRegionObserver.postUnassign(ObserverContext<MasterCoprocessorEnvironment> ctx, HRegionInfo regionInfo, boolean force)
           
 void MasterObserver.postUnassign(ObserverContext<MasterCoprocessorEnvironment> ctx, HRegionInfo regionInfo, boolean force)
          Called after the region unassignment has been requested.
 void BaseMasterObserver.postUnassign(ObserverContext<MasterCoprocessorEnvironment> ctx, HRegionInfo regionInfo, boolean force)
           
 void RegionObserver.postWALRestore(ObserverContext<RegionCoprocessorEnvironment> ctx, HRegionInfo info, HLogKey logKey, WALEdit logEdit)
          Called after a WALEdit replayed for this region.
 void BaseRegionObserver.postWALRestore(ObserverContext<RegionCoprocessorEnvironment> env, HRegionInfo info, HLogKey logKey, WALEdit logEdit)
           
 void BaseWALObserver.postWALWrite(ObserverContext<WALCoprocessorEnvironment> ctx, HRegionInfo info, HLogKey logKey, WALEdit logEdit)
           
 void WALObserver.postWALWrite(ObserverContext<WALCoprocessorEnvironment> ctx, HRegionInfo info, HLogKey logKey, WALEdit logEdit)
          Called after a WALEdit is writen to WAL.
 void BaseMasterAndRegionObserver.preAddColumn(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, HColumnDescriptor column)
           
 void MasterObserver.preAddColumn(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, HColumnDescriptor column)
          Called prior to adding a new column family to the table.
 void BaseMasterObserver.preAddColumn(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, HColumnDescriptor column)
           
 void BaseMasterAndRegionObserver.preAddColumnHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, HColumnDescriptor column)
           
 void MasterObserver.preAddColumnHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, HColumnDescriptor column)
          Called prior to adding a new column family to the table.
 void BaseMasterObserver.preAddColumnHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, HColumnDescriptor column)
           
 Result RegionObserver.preAppend(ObserverContext<RegionCoprocessorEnvironment> c, Append append)
          Called before Append.
 Result BaseRegionObserver.preAppend(ObserverContext<RegionCoprocessorEnvironment> e, Append append)
           
 Result RegionObserver.preAppendAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> c, Append append)
          Called before Append but after acquiring rowlock.
 Result BaseRegionObserver.preAppendAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> e, Append append)
           
 void BaseMasterAndRegionObserver.preAssign(ObserverContext<MasterCoprocessorEnvironment> ctx, HRegionInfo regionInfo)
           
 void MasterObserver.preAssign(ObserverContext<MasterCoprocessorEnvironment> ctx, HRegionInfo regionInfo)
          Called prior to assigning a specific region.
 void BaseMasterObserver.preAssign(ObserverContext<MasterCoprocessorEnvironment> ctx, HRegionInfo regionInfo)
           
 void BaseMasterAndRegionObserver.preBalance(ObserverContext<MasterCoprocessorEnvironment> ctx)
           
 void MasterObserver.preBalance(ObserverContext<MasterCoprocessorEnvironment> ctx)
          Called prior to requesting rebalancing of the cluster regions, though after the initial checks for regions in transition and the balance switch flag.
 void BaseMasterObserver.preBalance(ObserverContext<MasterCoprocessorEnvironment> ctx)
           
 boolean BaseMasterAndRegionObserver.preBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> ctx, boolean b)
           
 boolean MasterObserver.preBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> ctx, boolean newValue)
          Called prior to modifying the flag used to enable/disable region balancing.
 boolean BaseMasterObserver.preBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> ctx, boolean b)
           
 void RegionObserver.preBatchMutate(ObserverContext<RegionCoprocessorEnvironment> c, MiniBatchOperationInProgress<Mutation> miniBatchOp)
          This will be called for every batch mutation operation happening at the server.
 void BaseRegionObserver.preBatchMutate(ObserverContext<RegionCoprocessorEnvironment> c, MiniBatchOperationInProgress<Mutation> miniBatchOp)
           
 void RegionObserver.preBulkLoadHFile(ObserverContext<RegionCoprocessorEnvironment> ctx, List<Pair<byte[],String>> familyPaths)
          Called before bulkLoadHFile.
 void BaseRegionObserver.preBulkLoadHFile(ObserverContext<RegionCoprocessorEnvironment> ctx, List<Pair<byte[],String>> familyPaths)
           
 boolean RegionObserver.preCheckAndDelete(ObserverContext<RegionCoprocessorEnvironment> c, byte[] row, byte[] family, byte[] qualifier, CompareFilter.CompareOp compareOp, ByteArrayComparable comparator, Delete delete, boolean result)
          Called before checkAndDelete.
 boolean BaseRegionObserver.preCheckAndDelete(ObserverContext<RegionCoprocessorEnvironment> e, byte[] row, byte[] family, byte[] qualifier, CompareFilter.CompareOp compareOp, ByteArrayComparable comparator, Delete delete, boolean result)
           
 boolean RegionObserver.preCheckAndDeleteAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> c, byte[] row, byte[] family, byte[] qualifier, CompareFilter.CompareOp compareOp, ByteArrayComparable comparator, Delete delete, boolean result)
          Called before checkAndDelete but after acquiring rowock.
 boolean BaseRegionObserver.preCheckAndDeleteAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> e, byte[] row, byte[] family, byte[] qualifier, CompareFilter.CompareOp compareOp, ByteArrayComparable comparator, Delete delete, boolean result)
           
 boolean RegionObserver.preCheckAndPut(ObserverContext<RegionCoprocessorEnvironment> c, byte[] row, byte[] family, byte[] qualifier, CompareFilter.CompareOp compareOp, ByteArrayComparable comparator, Put put, boolean result)
          Called before checkAndPut.
 boolean BaseRegionObserver.preCheckAndPut(ObserverContext<RegionCoprocessorEnvironment> e, byte[] row, byte[] family, byte[] qualifier, CompareFilter.CompareOp compareOp, ByteArrayComparable comparator, Put put, boolean result)
           
 boolean RegionObserver.preCheckAndPutAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> c, byte[] row, byte[] family, byte[] qualifier, CompareFilter.CompareOp compareOp, ByteArrayComparable comparator, Put put, boolean result)
          Called before checkAndPut but after acquiring rowlock.
 boolean BaseRegionObserver.preCheckAndPutAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> e, byte[] row, byte[] family, byte[] qualifier, CompareFilter.CompareOp compareOp, ByteArrayComparable comparator, Put put, boolean result)
           
 void BulkLoadObserver.preCleanupBulkLoad(ObserverContext<RegionCoprocessorEnvironment> ctx, SecureBulkLoadProtos.CleanupBulkLoadRequest request)
          Called as part of SecureBulkLoadEndpoint.cleanupBulkLoad() RPC call.
 void BaseMasterAndRegionObserver.preCloneSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, HBaseProtos.SnapshotDescription snapshot, HTableDescriptor hTableDescriptor)
           
 void MasterObserver.preCloneSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, HBaseProtos.SnapshotDescription snapshot, HTableDescriptor hTableDescriptor)
          Called before a snapshot is cloned.
 void BaseMasterObserver.preCloneSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, HBaseProtos.SnapshotDescription snapshot, HTableDescriptor hTableDescriptor)
           
 void RegionObserver.preClose(ObserverContext<RegionCoprocessorEnvironment> c, boolean abortRequested)
          Called before the region is reported as closed to the master.
 void BaseRegionObserver.preClose(ObserverContext<RegionCoprocessorEnvironment> c, boolean abortRequested)
           
 InternalScanner RegionObserver.preCompact(ObserverContext<RegionCoprocessorEnvironment> c, Store store, InternalScanner scanner, ScanType scanType)
          Deprecated. use RegionObserver.preCompact(ObserverContext, Store, InternalScanner, ScanType, CompactionRequest) instead
 InternalScanner BaseRegionObserver.preCompact(ObserverContext<RegionCoprocessorEnvironment> e, Store store, InternalScanner scanner, ScanType scanType)
           
 InternalScanner RegionObserver.preCompact(ObserverContext<RegionCoprocessorEnvironment> c, Store store, InternalScanner scanner, ScanType scanType, CompactionRequest request)
          Called prior to writing the StoreFiles selected for compaction into a new StoreFile.
 InternalScanner BaseRegionObserver.preCompact(ObserverContext<RegionCoprocessorEnvironment> e, Store store, InternalScanner scanner, ScanType scanType, CompactionRequest request)
           
 InternalScanner RegionObserver.preCompactScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c, Store store, List<? extends KeyValueScanner> scanners, ScanType scanType, long earliestPutTs, InternalScanner s)
          Deprecated. Use RegionObserver.preCompactScannerOpen(ObserverContext, Store, List, ScanType, long, InternalScanner, CompactionRequest) instead.
 InternalScanner BaseRegionObserver.preCompactScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c, Store store, List<? extends KeyValueScanner> scanners, ScanType scanType, long earliestPutTs, InternalScanner s)
           
 InternalScanner RegionObserver.preCompactScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c, Store store, List<? extends KeyValueScanner> scanners, ScanType scanType, long earliestPutTs, InternalScanner s, CompactionRequest request)
          Called prior to writing the StoreFiles selected for compaction into a new StoreFile and prior to creating the scanner used to read the input files.
 InternalScanner BaseRegionObserver.preCompactScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c, Store store, List<? extends KeyValueScanner> scanners, ScanType scanType, long earliestPutTs, InternalScanner s, CompactionRequest request)
           
 void RegionObserver.preCompactSelection(ObserverContext<RegionCoprocessorEnvironment> c, Store store, List<StoreFile> candidates)
          Deprecated. Use RegionObserver.preCompactSelection(ObserverContext, Store, List, CompactionRequest) instead
 void BaseRegionObserver.preCompactSelection(ObserverContext<RegionCoprocessorEnvironment> c, Store store, List<StoreFile> candidates)
           
 void RegionObserver.preCompactSelection(ObserverContext<RegionCoprocessorEnvironment> c, Store store, List<StoreFile> candidates, CompactionRequest request)
          Called prior to selecting the StoreFiles to compact from the list of available candidates.
 void BaseRegionObserver.preCompactSelection(ObserverContext<RegionCoprocessorEnvironment> c, Store store, List<StoreFile> candidates, CompactionRequest request)
           
 void BaseMasterAndRegionObserver.preCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns)
           
 void MasterObserver.preCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns)
          Called before a new namespace is created by HMaster.
 void BaseMasterObserver.preCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns)
           
 void BaseMasterAndRegionObserver.preCreateTable(ObserverContext<MasterCoprocessorEnvironment> ctx, HTableDescriptor desc, HRegionInfo[] regions)
           
 void MasterObserver.preCreateTable(ObserverContext<MasterCoprocessorEnvironment> ctx, HTableDescriptor desc, HRegionInfo[] regions)
          Called before a new table is created by HMaster.
 void BaseMasterObserver.preCreateTable(ObserverContext<MasterCoprocessorEnvironment> ctx, HTableDescriptor desc, HRegionInfo[] regions)
           
 void BaseMasterAndRegionObserver.preCreateTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, HTableDescriptor desc, HRegionInfo[] regions)
           
 void MasterObserver.preCreateTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, HTableDescriptor desc, HRegionInfo[] regions)
          Called before a new table is created by HMaster.
 void BaseMasterObserver.preCreateTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, HTableDescriptor desc, HRegionInfo[] regions)
           
 void RegionObserver.preDelete(ObserverContext<RegionCoprocessorEnvironment> c, Delete delete, WALEdit edit, Durability durability)
          Called before the client deletes a value.
 void BaseRegionObserver.preDelete(ObserverContext<RegionCoprocessorEnvironment> e, Delete delete, WALEdit edit, Durability durability)
           
 void BaseMasterAndRegionObserver.preDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, byte[] c)
           
 void MasterObserver.preDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, byte[] c)
          Called prior to deleting the entire column family.
 void BaseMasterObserver.preDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, byte[] c)
           
 void BaseMasterAndRegionObserver.preDeleteColumnHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, byte[] c)
           
 void MasterObserver.preDeleteColumnHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, byte[] c)
          Called prior to deleting the entire column family.
 void BaseMasterObserver.preDeleteColumnHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, byte[] c)
           
 void BaseMasterAndRegionObserver.preDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace)
           
 void MasterObserver.preDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace)
          Called before HMaster deletes a namespace It can't bypass the default action, e.g., ctx.bypass() won't have effect.
 void BaseMasterObserver.preDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace)
           
 void BaseMasterAndRegionObserver.preDeleteSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, HBaseProtos.SnapshotDescription snapshot)
           
 void MasterObserver.preDeleteSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, HBaseProtos.SnapshotDescription snapshot)
          Called before a snapshot is deleted.
 void BaseMasterObserver.preDeleteSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, HBaseProtos.SnapshotDescription snapshot)
           
 void BaseMasterAndRegionObserver.preDeleteTable(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)
           
 void MasterObserver.preDeleteTable(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)
          Called before HMaster deletes a table.
 void BaseMasterObserver.preDeleteTable(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)
           
 void BaseMasterAndRegionObserver.preDeleteTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)
           
 void MasterObserver.preDeleteTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)
          Called before HMaster deletes a table.
 void BaseMasterObserver.preDeleteTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)
           
 void BaseMasterAndRegionObserver.preDisableTable(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)
           
 void MasterObserver.preDisableTable(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)
          Called prior to disabling a table.
 void BaseMasterObserver.preDisableTable(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)
           
 void BaseMasterAndRegionObserver.preDisableTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)
           
 void MasterObserver.preDisableTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)
          Called prior to disabling a table.
 void BaseMasterObserver.preDisableTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)
           
 void BaseMasterAndRegionObserver.preEnableTable(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)
           
 void MasterObserver.preEnableTable(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)
          Called prior to enabling a table.
 void BaseMasterObserver.preEnableTable(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)
           
 void BaseMasterAndRegionObserver.preEnableTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)
           
 void MasterObserver.preEnableTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)
          Called prior to enabling a table.
 void BaseMasterObserver.preEnableTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)
           
 com.google.protobuf.Message EndpointObserver.preEndpointInvocation(ObserverContext<RegionCoprocessorEnvironment> ctx, com.google.protobuf.Service service, String methodName, com.google.protobuf.Message request)
          Called before an Endpoint service method is invoked.
 boolean RegionObserver.preExists(ObserverContext<RegionCoprocessorEnvironment> c, Get get, boolean exists)
          Called before the client tests for existence using a Get.
 boolean BaseRegionObserver.preExists(ObserverContext<RegionCoprocessorEnvironment> e, Get get, boolean exists)
           
 void RegionObserver.preFlush(ObserverContext<RegionCoprocessorEnvironment> c)
          Deprecated. use RegionObserver.preFlush(ObserverContext, Store, InternalScanner) instead
 void BaseRegionObserver.preFlush(ObserverContext<RegionCoprocessorEnvironment> e)
           
 InternalScanner RegionObserver.preFlush(ObserverContext<RegionCoprocessorEnvironment> c, Store store, InternalScanner scanner)
          Called before a Store's memstore is flushed to disk.
 InternalScanner BaseRegionObserver.preFlush(ObserverContext<RegionCoprocessorEnvironment> e, Store store, InternalScanner scanner)
           
 InternalScanner RegionObserver.preFlushScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c, Store store, KeyValueScanner memstoreScanner, InternalScanner s)
          Called before a memstore is flushed to disk and prior to creating the scanner to read from the memstore.
 InternalScanner BaseRegionObserver.preFlushScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c, Store store, KeyValueScanner memstoreScanner, InternalScanner s)
           
 void RegionObserver.preGet(ObserverContext<RegionCoprocessorEnvironment> c, Get get, List<KeyValue> result)
          Deprecated. 
 void BaseRegionObserver.preGet(ObserverContext<RegionCoprocessorEnvironment> c, Get get, List<KeyValue> result)
          Deprecated. 
 void RegionObserver.preGetClosestRowBefore(ObserverContext<RegionCoprocessorEnvironment> c, byte[] row, byte[] family, Result result)
          Called before a client makes a GetClosestRowBefore request.
 void BaseRegionObserver.preGetClosestRowBefore(ObserverContext<RegionCoprocessorEnvironment> e, byte[] row, byte[] family, Result result)
           
 void RegionObserver.preGetOp(ObserverContext<RegionCoprocessorEnvironment> c, Get get, List<Cell> result)
          Called before the client performs a Get
 void BaseRegionObserver.preGetOp(ObserverContext<RegionCoprocessorEnvironment> e, Get get, List<Cell> results)
           
 void BaseMasterAndRegionObserver.preGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx, List<TableName> tableNamesList, List<HTableDescriptor> descriptors)
           
 void MasterObserver.preGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx, List<TableName> tableNamesList, List<HTableDescriptor> descriptors)
          Called before a getTableDescriptors request has been processed.
 void BaseMasterObserver.preGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx, List<TableName> tableNamesList, List<HTableDescriptor> descriptors)
           
 Result RegionObserver.preIncrement(ObserverContext<RegionCoprocessorEnvironment> c, Increment increment)
          Called before Increment.
 Result BaseRegionObserver.preIncrement(ObserverContext<RegionCoprocessorEnvironment> e, Increment increment)
           
 Result RegionObserver.preIncrementAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> c, Increment increment)
          Called before Increment but after acquiring rowlock.
 Result BaseRegionObserver.preIncrementAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> e, Increment increment)
           
 long RegionObserver.preIncrementColumnValue(ObserverContext<RegionCoprocessorEnvironment> c, byte[] row, byte[] family, byte[] qualifier, long amount, boolean writeToWAL)
          Deprecated. This hook is no longer called by the RegionServer
 long BaseRegionObserver.preIncrementColumnValue(ObserverContext<RegionCoprocessorEnvironment> e, byte[] row, byte[] family, byte[] qualifier, long amount, boolean writeToWAL)
           
 void BaseMasterAndRegionObserver.preMasterInitialization(ObserverContext<MasterCoprocessorEnvironment> ctx)
           
 void MasterObserver.preMasterInitialization(ObserverContext<MasterCoprocessorEnvironment> ctx)
          Call before the master initialization is set to true.
 void BaseMasterObserver.preMasterInitialization(ObserverContext<MasterCoprocessorEnvironment> ctx)
           
 void BaseRegionServerObserver.preMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB)
           
 void RegionServerObserver.preMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB)
          Called before the regions merge.
 void BaseRegionServerObserver.preMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB, List<Mutation> metaEntries)
           
 void RegionServerObserver.preMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB, List<Mutation> metaEntries)
          This will be called before PONR step as part of regions merge transaction.
 void BaseMasterAndRegionObserver.preModifyColumn(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, HColumnDescriptor descriptor)
           
 void MasterObserver.preModifyColumn(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, HColumnDescriptor descriptor)
          Called prior to modifying a column family's attributes.
 void BaseMasterObserver.preModifyColumn(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, HColumnDescriptor descriptor)
           
 void BaseMasterAndRegionObserver.preModifyColumnHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, HColumnDescriptor descriptor)
           
 void MasterObserver.preModifyColumnHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, HColumnDescriptor descriptor)
          Called prior to modifying a column family's attributes.
 void BaseMasterObserver.preModifyColumnHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, HColumnDescriptor descriptor)
           
 void BaseMasterAndRegionObserver.preModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns)
           
 void MasterObserver.preModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns)
          Called prior to modifying a namespace's properties.
 void BaseMasterObserver.preModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns)
           
 void BaseMasterAndRegionObserver.preModifyTable(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, HTableDescriptor htd)
           
 void MasterObserver.preModifyTable(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, HTableDescriptor htd)
          Called prior to modifying a table's properties.
 void BaseMasterObserver.preModifyTable(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, HTableDescriptor htd)
           
 void BaseMasterAndRegionObserver.preModifyTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, HTableDescriptor htd)
           
 void MasterObserver.preModifyTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, HTableDescriptor htd)
          Called prior to modifying a table's properties.
 void BaseMasterObserver.preModifyTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, HTableDescriptor htd)
           
 void BaseMasterAndRegionObserver.preMove(ObserverContext<MasterCoprocessorEnvironment> ctx, HRegionInfo region, ServerName srcServer, ServerName destServer)
           
 void MasterObserver.preMove(ObserverContext<MasterCoprocessorEnvironment> ctx, HRegionInfo region, ServerName srcServer, ServerName destServer)
          Called prior to moving a given region from one region server to another.
 void BaseMasterObserver.preMove(ObserverContext<MasterCoprocessorEnvironment> ctx, HRegionInfo region, ServerName srcServer, ServerName destServer)
           
 void RegionObserver.preOpen(ObserverContext<RegionCoprocessorEnvironment> c)
          Called before the region is reported as open to the master.
 void BaseRegionObserver.preOpen(ObserverContext<RegionCoprocessorEnvironment> e)
           
 void BulkLoadObserver.prePrepareBulkLoad(ObserverContext<RegionCoprocessorEnvironment> ctx, SecureBulkLoadProtos.PrepareBulkLoadRequest request)
          Called as part of SecureBulkLoadEndpoint.prepareBulkLoad() RPC call.
 void RegionObserver.prePrepareTimeStampForDeleteVersion(ObserverContext<RegionCoprocessorEnvironment> c, Mutation mutation, Cell cell, byte[] byteNow, Get get)
          Called before the server updates the timestamp for version delete with latest timestamp.
 void BaseRegionObserver.prePrepareTimeStampForDeleteVersion(ObserverContext<RegionCoprocessorEnvironment> e, Mutation delete, Cell cell, byte[] byteNow, Get get)
           
 void RegionObserver.prePut(ObserverContext<RegionCoprocessorEnvironment> c, Put put, WALEdit edit, Durability durability)
          Called before the client stores a value.
 void BaseRegionObserver.prePut(ObserverContext<RegionCoprocessorEnvironment> e, Put put, WALEdit edit, Durability durability)
           
 void BaseMasterAndRegionObserver.preRegionOffline(ObserverContext<MasterCoprocessorEnvironment> ctx, HRegionInfo regionInfo)
           
 void MasterObserver.preRegionOffline(ObserverContext<MasterCoprocessorEnvironment> ctx, HRegionInfo regionInfo)
          Called prior to marking a given region as offline.
 void BaseMasterObserver.preRegionOffline(ObserverContext<MasterCoprocessorEnvironment> ctx, HRegionInfo regionInfo)
           
 void BaseRegionServerObserver.preReplicateLogEntries(ObserverContext<RegionServerCoprocessorEnvironment> ctx, List<AdminProtos.WALEntry> entries, CellScanner cells)
           
 void RegionServerObserver.preReplicateLogEntries(ObserverContext<RegionServerCoprocessorEnvironment> ctx, List<AdminProtos.WALEntry> entries, CellScanner cells)
          This will be called before executing replication request to shipping log entries.
 void BaseMasterAndRegionObserver.preRestoreSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, HBaseProtos.SnapshotDescription snapshot, HTableDescriptor hTableDescriptor)
           
 void MasterObserver.preRestoreSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, HBaseProtos.SnapshotDescription snapshot, HTableDescriptor hTableDescriptor)
          Called before a snapshot is restored.
 void BaseMasterObserver.preRestoreSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, HBaseProtos.SnapshotDescription snapshot, HTableDescriptor hTableDescriptor)
           
 void BaseRegionServerObserver.preRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB)
           
 void RegionServerObserver.preRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB)
          This will be called before the roll back of the regions merge.
 void RegionObserver.preRollBackSplit(ObserverContext<RegionCoprocessorEnvironment> ctx)
          This will be called before the roll back of the split region is completed
 void BaseRegionObserver.preRollBackSplit(ObserverContext<RegionCoprocessorEnvironment> ctx)
           
 void BaseRegionServerObserver.preRollWALWriterRequest(ObserverContext<RegionServerCoprocessorEnvironment> ctx)
           
 void RegionServerObserver.preRollWALWriterRequest(ObserverContext<RegionServerCoprocessorEnvironment> ctx)
          This will be called before executing user request to roll a region server WAL.
 void RegionObserver.preScannerClose(ObserverContext<RegionCoprocessorEnvironment> c, InternalScanner s)
          Called before the client closes a scanner.
 void BaseRegionObserver.preScannerClose(ObserverContext<RegionCoprocessorEnvironment> e, InternalScanner s)
           
 boolean RegionObserver.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.
 boolean BaseRegionObserver.preScannerNext(ObserverContext<RegionCoprocessorEnvironment> e, InternalScanner s, List<Result> results, int limit, boolean hasMore)
           
 RegionScanner RegionObserver.preScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c, Scan scan, RegionScanner s)
          Called before the client opens a new scanner.
 RegionScanner BaseRegionObserver.preScannerOpen(ObserverContext<RegionCoprocessorEnvironment> e, Scan scan, RegionScanner s)
           
 void BaseMasterAndRegionObserver.preShutdown(ObserverContext<MasterCoprocessorEnvironment> ctx)
           
 void MasterObserver.preShutdown(ObserverContext<MasterCoprocessorEnvironment> ctx)
          Called prior to shutting down the full HBase cluster, including this HMaster process.
 void BaseMasterObserver.preShutdown(ObserverContext<MasterCoprocessorEnvironment> ctx)
           
 void BaseMasterAndRegionObserver.preSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, HBaseProtos.SnapshotDescription snapshot, HTableDescriptor hTableDescriptor)
           
 void MasterObserver.preSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, HBaseProtos.SnapshotDescription snapshot, HTableDescriptor hTableDescriptor)
          Called before a new snapshot is taken.
 void BaseMasterObserver.preSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, HBaseProtos.SnapshotDescription snapshot, HTableDescriptor hTableDescriptor)
           
 void RegionObserver.preSplit(ObserverContext<RegionCoprocessorEnvironment> c)
          Deprecated. Use preSplit( final ObserverContext c, byte[] splitRow)
 void BaseRegionObserver.preSplit(ObserverContext<RegionCoprocessorEnvironment> e)
           
 void RegionObserver.preSplit(ObserverContext<RegionCoprocessorEnvironment> c, byte[] splitRow)
          Called before the region is split.
 void BaseRegionObserver.preSplit(ObserverContext<RegionCoprocessorEnvironment> c, byte[] splitRow)
           
 void RegionObserver.preSplitAfterPONR(ObserverContext<RegionCoprocessorEnvironment> ctx)
          This will be called after PONR step as part of split transaction Calling bypass() has no effect in this hook.
 void BaseRegionObserver.preSplitAfterPONR(ObserverContext<RegionCoprocessorEnvironment> ctx)
           
 void RegionObserver.preSplitBeforePONR(ObserverContext<RegionCoprocessorEnvironment> ctx, byte[] splitKey, List<Mutation> metaEntries)
          This will be called before PONR step as part of split transaction.
 void BaseRegionObserver.preSplitBeforePONR(ObserverContext<RegionCoprocessorEnvironment> ctx, byte[] splitKey, List<Mutation> metaEntries)
           
 void BaseMasterAndRegionObserver.preStopMaster(ObserverContext<MasterCoprocessorEnvironment> ctx)
           
 void MasterObserver.preStopMaster(ObserverContext<MasterCoprocessorEnvironment> ctx)
          Called immediately prior to stopping this HMaster process.
 void BaseMasterObserver.preStopMaster(ObserverContext<MasterCoprocessorEnvironment> ctx)
           
 void BaseRegionServerObserver.preStopRegionServer(ObserverContext<RegionServerCoprocessorEnvironment> env)
           
 void RegionServerObserver.preStopRegionServer(ObserverContext<RegionServerCoprocessorEnvironment> env)
          Called before stopping region server.
 StoreFile.Reader RegionObserver.preStoreFileReaderOpen(ObserverContext<RegionCoprocessorEnvironment> ctx, org.apache.hadoop.fs.FileSystem fs, org.apache.hadoop.fs.Path p, FSDataInputStreamWrapper in, long size, CacheConfig cacheConf, Reference r, StoreFile.Reader reader)
          Called before creation of Reader for a store file.
 StoreFile.Reader BaseRegionObserver.preStoreFileReaderOpen(ObserverContext<RegionCoprocessorEnvironment> ctx, org.apache.hadoop.fs.FileSystem fs, org.apache.hadoop.fs.Path p, FSDataInputStreamWrapper in, long size, CacheConfig cacheConf, Reference r, StoreFile.Reader reader)
           
 KeyValueScanner RegionObserver.preStoreScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c, Store store, Scan scan, NavigableSet<byte[]> targetCols, KeyValueScanner s)
          Called before a store opens a new scanner.
 KeyValueScanner BaseRegionObserver.preStoreScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c, Store store, Scan scan, NavigableSet<byte[]> targetCols, KeyValueScanner s)
           
 void MasterObserver.preTruncateTable(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)
          Called before HMaster truncates a table.
 void BaseMasterObserver.preTruncateTable(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)
           
 void MasterObserver.preTruncateTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)
          Called before HMaster truncates a table.
 void BaseMasterObserver.preTruncateTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)
           
 void BaseMasterAndRegionObserver.preUnassign(ObserverContext<MasterCoprocessorEnvironment> ctx, HRegionInfo regionInfo, boolean force)
           
 void MasterObserver.preUnassign(ObserverContext<MasterCoprocessorEnvironment> ctx, HRegionInfo regionInfo, boolean force)
          Called prior to unassigning a given region.
 void BaseMasterObserver.preUnassign(ObserverContext<MasterCoprocessorEnvironment> ctx, HRegionInfo regionInfo, boolean force)
           
 void RegionObserver.preWALRestore(ObserverContext<RegionCoprocessorEnvironment> ctx, HRegionInfo info, HLogKey logKey, WALEdit logEdit)
          Called before a WALEdit replayed for this region.
 void BaseRegionObserver.preWALRestore(ObserverContext<RegionCoprocessorEnvironment> env, HRegionInfo info, HLogKey logKey, WALEdit logEdit)
           
 boolean BaseWALObserver.preWALWrite(ObserverContext<WALCoprocessorEnvironment> ctx, HRegionInfo info, HLogKey logKey, WALEdit logEdit)
           
 boolean WALObserver.preWALWrite(ObserverContext<WALCoprocessorEnvironment> ctx, HRegionInfo info, HLogKey logKey, WALEdit logEdit)
          Called before a WALEdit is writen to WAL.
 

Uses of ObserverContext in org.apache.hadoop.hbase.coprocessor.example
 

Methods in org.apache.hadoop.hbase.coprocessor.example with parameters of type ObserverContext
 InternalScanner ZooKeeperScanPolicyObserver.preCompactScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c, Store store, List<? extends KeyValueScanner> scanners, ScanType scanType, long earliestPutTs, InternalScanner s)
           
 InternalScanner ZooKeeperScanPolicyObserver.preFlushScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c, Store store, KeyValueScanner memstoreScanner, InternalScanner s)
           
 KeyValueScanner ZooKeeperScanPolicyObserver.preStoreScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c, Store store, Scan scan, NavigableSet<byte[]> targetCols, KeyValueScanner s)
           
 

Uses of ObserverContext in org.apache.hadoop.hbase.security.access
 

Methods in org.apache.hadoop.hbase.security.access with parameters of type ObserverContext
 ReplicationEndpoint AccessController.postCreateReplicationEndPoint(ObserverContext<RegionServerCoprocessorEnvironment> ctx, ReplicationEndpoint endpoint)
           
 void AccessController.postCreateTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, HTableDescriptor desc, HRegionInfo[] regions)
           
 void AccessController.postDelete(ObserverContext<RegionCoprocessorEnvironment> c, Delete delete, WALEdit edit, Durability durability)
           
 void AccessController.postDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, byte[] col)
           
 void AccessController.postDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace)
           
 void AccessController.postDeleteTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName)
           
 void AccessController.postEndpointInvocation(ObserverContext<RegionCoprocessorEnvironment> ctx, com.google.protobuf.Service service, String methodName, com.google.protobuf.Message request, com.google.protobuf.Message.Builder responseBuilder)
           
 void AccessController.postLogReplay(ObserverContext<RegionCoprocessorEnvironment> c)
           
 void AccessController.postMerge(ObserverContext<RegionServerCoprocessorEnvironment> c, HRegion regionA, HRegion regionB, HRegion mergedRegion)
           
 void AccessController.postMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB, HRegion mergedRegion)
           
 void AccessController.postModifyTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HTableDescriptor htd)
           
 Cell AccessController.postMutationBeforeWAL(ObserverContext<RegionCoprocessorEnvironment> ctx, RegionObserver.MutationType opType, Mutation mutation, Cell oldCell, Cell newCell)
           
 void AccessController.postOpen(ObserverContext<RegionCoprocessorEnvironment> c)
           
 void AccessController.postPut(ObserverContext<RegionCoprocessorEnvironment> c, Put put, WALEdit edit, Durability durability)
           
 void AccessController.postReplicateLogEntries(ObserverContext<RegionServerCoprocessorEnvironment> ctx, List<AdminProtos.WALEntry> entries, CellScanner cells)
           
 void AccessController.postRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB)
           
 void AccessController.postRollWALWriterRequest(ObserverContext<RegionServerCoprocessorEnvironment> ctx)
           
 void AccessController.postScannerClose(ObserverContext<RegionCoprocessorEnvironment> c, InternalScanner s)
           
 RegionScanner AccessController.postScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c, Scan scan, RegionScanner s)
           
 void AccessController.postStartMaster(ObserverContext<MasterCoprocessorEnvironment> ctx)
           
 void AccessController.postTruncateTable(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)
           
 void AccessController.postTruncateTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName)
           
 void AccessController.preAddColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor column)
           
 Result AccessController.preAppend(ObserverContext<RegionCoprocessorEnvironment> c, Append append)
           
 Result AccessController.preAppendAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> c, Append append)
           
 void AccessController.preAssign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo)
           
 void AccessController.preBalance(ObserverContext<MasterCoprocessorEnvironment> c)
           
 boolean AccessController.preBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> c, boolean newValue)
           
 void AccessController.preBatchMutate(ObserverContext<RegionCoprocessorEnvironment> c, MiniBatchOperationInProgress<Mutation> miniBatchOp)
           
 void AccessController.preBulkLoadHFile(ObserverContext<RegionCoprocessorEnvironment> ctx, List<Pair<byte[],String>> familyPaths)
          Verifies user has CREATE privileges on the Column Families involved in the bulkLoadHFile request.
 boolean AccessController.preCheckAndDelete(ObserverContext<RegionCoprocessorEnvironment> c, byte[] row, byte[] family, byte[] qualifier, CompareFilter.CompareOp compareOp, ByteArrayComparable comparator, Delete delete, boolean result)
           
 boolean AccessController.preCheckAndDeleteAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> c, byte[] row, byte[] family, byte[] qualifier, CompareFilter.CompareOp compareOp, ByteArrayComparable comparator, Delete delete, boolean result)
           
 boolean AccessController.preCheckAndPut(ObserverContext<RegionCoprocessorEnvironment> c, byte[] row, byte[] family, byte[] qualifier, CompareFilter.CompareOp compareOp, ByteArrayComparable comparator, Put put, boolean result)
           
 boolean AccessController.preCheckAndPutAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> c, byte[] row, byte[] family, byte[] qualifier, CompareFilter.CompareOp compareOp, ByteArrayComparable comparator, Put put, boolean result)
           
 void AccessController.preCleanupBulkLoad(ObserverContext<RegionCoprocessorEnvironment> ctx, SecureBulkLoadProtos.CleanupBulkLoadRequest request)
          Authorization security check for SecureBulkLoadProtocol.cleanupBulkLoad()
 void AccessController.preCloneSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, HBaseProtos.SnapshotDescription snapshot, HTableDescriptor hTableDescriptor)
           
 void AccessController.preClose(ObserverContext<RegionCoprocessorEnvironment> e, boolean abortRequested)
           
 InternalScanner AccessController.preCompact(ObserverContext<RegionCoprocessorEnvironment> e, Store store, InternalScanner scanner, ScanType scanType)
           
 void AccessController.preCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns)
           
 void AccessController.preCreateTable(ObserverContext<MasterCoprocessorEnvironment> c, HTableDescriptor desc, HRegionInfo[] regions)
           
 void AccessController.preDelete(ObserverContext<RegionCoprocessorEnvironment> c, Delete delete, WALEdit edit, Durability durability)
           
 void AccessController.preDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, byte[] col)
           
 void AccessController.preDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, String namespace)
           
 void AccessController.preDeleteSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, HBaseProtos.SnapshotDescription snapshot)
           
 void AccessController.preDeleteTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName)
           
 void AccessController.preDisableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName)
           
 void AccessController.preEnableTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName)
           
 com.google.protobuf.Message AccessController.preEndpointInvocation(ObserverContext<RegionCoprocessorEnvironment> ctx, com.google.protobuf.Service service, String methodName, com.google.protobuf.Message request)
           
 boolean AccessController.preExists(ObserverContext<RegionCoprocessorEnvironment> c, Get get, boolean exists)
           
 void AccessController.preFlush(ObserverContext<RegionCoprocessorEnvironment> e)
           
 void AccessController.preGetClosestRowBefore(ObserverContext<RegionCoprocessorEnvironment> c, byte[] row, byte[] family, Result result)
           
 void AccessController.preGetOp(ObserverContext<RegionCoprocessorEnvironment> c, Get get, List<Cell> result)
           
 void AccessController.preGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx, List<TableName> tableNamesList, List<HTableDescriptor> descriptors)
           
 Result AccessController.preIncrement(ObserverContext<RegionCoprocessorEnvironment> c, Increment increment)
           
 Result AccessController.preIncrementAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> c, Increment increment)
           
 long AccessController.preIncrementColumnValue(ObserverContext<RegionCoprocessorEnvironment> c, byte[] row, byte[] family, byte[] qualifier, long amount, boolean writeToWAL)
           
 void AccessController.preMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB)
           
 void AccessController.preMergeCommit(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB, List<Mutation> metaEntries)
           
 void AccessController.preModifyColumn(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HColumnDescriptor descriptor)
           
 void AccessController.preModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, NamespaceDescriptor ns)
           
 void AccessController.preModifyTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName, HTableDescriptor htd)
           
 void AccessController.preMove(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo region, ServerName srcServer, ServerName destServer)
           
 void AccessController.preOpen(ObserverContext<RegionCoprocessorEnvironment> e)
           
 void AccessController.prePrepareBulkLoad(ObserverContext<RegionCoprocessorEnvironment> ctx, SecureBulkLoadProtos.PrepareBulkLoadRequest request)
          Authorization check for SecureBulkLoadProtocol.prepareBulkLoad()
 void AccessController.prePut(ObserverContext<RegionCoprocessorEnvironment> c, Put put, WALEdit edit, Durability durability)
           
 void AccessController.preRegionOffline(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo)
           
 void AccessController.preReplicateLogEntries(ObserverContext<RegionServerCoprocessorEnvironment> ctx, List<AdminProtos.WALEntry> entries, CellScanner cells)
           
 void AccessController.preRestoreSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, HBaseProtos.SnapshotDescription snapshot, HTableDescriptor hTableDescriptor)
           
 void AccessController.preRollBackMerge(ObserverContext<RegionServerCoprocessorEnvironment> ctx, HRegion regionA, HRegion regionB)
           
 void AccessController.preRollWALWriterRequest(ObserverContext<RegionServerCoprocessorEnvironment> ctx)
           
 void AccessController.preScannerClose(ObserverContext<RegionCoprocessorEnvironment> c, InternalScanner s)
           
 boolean AccessController.preScannerNext(ObserverContext<RegionCoprocessorEnvironment> c, InternalScanner s, List<Result> result, int limit, boolean hasNext)
           
 RegionScanner AccessController.preScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c, Scan scan, RegionScanner s)
           
 void AccessController.preShutdown(ObserverContext<MasterCoprocessorEnvironment> c)
           
 void AccessController.preSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, HBaseProtos.SnapshotDescription snapshot, HTableDescriptor hTableDescriptor)
           
 void AccessController.preSplit(ObserverContext<RegionCoprocessorEnvironment> e)
           
 void AccessController.preSplit(ObserverContext<RegionCoprocessorEnvironment> e, byte[] splitRow)
           
 void AccessController.preStopMaster(ObserverContext<MasterCoprocessorEnvironment> c)
           
 void AccessController.preStopRegionServer(ObserverContext<RegionServerCoprocessorEnvironment> env)
           
 void AccessController.preTruncateTable(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName)
           
 void AccessController.preTruncateTableHandler(ObserverContext<MasterCoprocessorEnvironment> c, TableName tableName)
           
 void AccessController.preUnassign(ObserverContext<MasterCoprocessorEnvironment> c, HRegionInfo regionInfo, boolean force)
           
 

Uses of ObserverContext in org.apache.hadoop.hbase.security.visibility
 

Methods in org.apache.hadoop.hbase.security.visibility with parameters of type ObserverContext
 ReplicationEndpoint VisibilityController.VisibilityReplication.postCreateReplicationEndPoint(ObserverContext<RegionServerCoprocessorEnvironment> ctx, ReplicationEndpoint endpoint)
           
 DeleteTracker VisibilityController.postInstantiateDeleteTracker(ObserverContext<RegionCoprocessorEnvironment> ctx, DeleteTracker delTracker)
           
 void VisibilityController.postLogReplay(ObserverContext<RegionCoprocessorEnvironment> e)
           
 Cell VisibilityController.postMutationBeforeWAL(ObserverContext<RegionCoprocessorEnvironment> ctx, RegionObserver.MutationType opType, Mutation mutation, Cell oldCell, Cell newCell)
           
 void VisibilityController.postOpen(ObserverContext<RegionCoprocessorEnvironment> e)
          Region related hooks
 void VisibilityController.postScannerClose(ObserverContext<RegionCoprocessorEnvironment> c, InternalScanner s)
           
 RegionScanner VisibilityController.postScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c, Scan scan, RegionScanner s)
           
 void VisibilityController.postStartMaster(ObserverContext<MasterCoprocessorEnvironment> ctx)
          Master related hooks
 void VisibilityController.postTruncateTable(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)
           
 void VisibilityController.postTruncateTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)
           
 void VisibilityController.preAddColumn(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, HColumnDescriptor column)
           
 Result VisibilityController.preAppend(ObserverContext<RegionCoprocessorEnvironment> e, Append append)
           
 void VisibilityController.preBatchMutate(ObserverContext<RegionCoprocessorEnvironment> c, MiniBatchOperationInProgress<Mutation> miniBatchOp)
           
 void VisibilityController.preDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, byte[] c)
           
 void VisibilityController.preDisableTable(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)
           
 void VisibilityController.preGetOp(ObserverContext<RegionCoprocessorEnvironment> e, Get get, List<Cell> results)
           
 Result VisibilityController.preIncrement(ObserverContext<RegionCoprocessorEnvironment> e, Increment increment)
           
 void VisibilityController.preModifyColumn(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, HColumnDescriptor descriptor)
           
 void VisibilityController.preModifyTable(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName, HTableDescriptor htd)
           
 void VisibilityController.prePrepareTimeStampForDeleteVersion(ObserverContext<RegionCoprocessorEnvironment> ctx, Mutation delete, Cell cell, byte[] byteNow, Get get)
           
 void VisibilityController.preScannerClose(ObserverContext<RegionCoprocessorEnvironment> c, InternalScanner s)
           
 boolean VisibilityController.preScannerNext(ObserverContext<RegionCoprocessorEnvironment> c, InternalScanner s, List<Result> result, int limit, boolean hasNext)
           
 RegionScanner VisibilityController.preScannerOpen(ObserverContext<RegionCoprocessorEnvironment> e, Scan scan, RegionScanner s)
           
 void VisibilityController.preTruncateTable(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)
           
 void VisibilityController.preTruncateTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName)
           
 

Uses of ObserverContext in org.apache.hadoop.hbase.tool
 

Methods in org.apache.hadoop.hbase.tool with parameters of type ObserverContext
 void WriteSinkCoprocessor.preBatchMutate(ObserverContext<RegionCoprocessorEnvironment> c, MiniBatchOperationInProgress<Mutation> miniBatchOp)
           
 void WriteSinkCoprocessor.preOpen(ObserverContext<RegionCoprocessorEnvironment> e)
           
 



Copyright © 2007–2015 The Apache Software Foundation. All rights reserved.