org.apache.hadoop.hbase.coprocessor
Interface RegionObserver

All Superinterfaces:

Coprocessor

All Known Implementing Classes:

AccessController, BaseMasterAndRegionObserver, BaseRegionObserver, ConstraintProcessor, VisibilityController, WriteSinkCoprocessor

@InterfaceAudience.LimitedPrivate(value="Coprocesssor")
@InterfaceStability.Evolving
public interface RegionObserver
extends Coprocessor

Coprocessors implement this interface to observe and mediate client actions on the region.

Nested Class Summary

static class

RegionObserver.MutationType Mutation type for postMutationBeforeWAL hook

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

Coprocessor.State

Field Summary

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

PRIORITY_HIGHEST, PRIORITY_LOWEST, PRIORITY_SYSTEM, PRIORITY_USER, VERSION

Method Summary

Result	postAppend(ObserverContext<RegionCoprocessorEnvironment> c, Append append, Result result) Called after Append
void	postBatchMutate(ObserverContext<RegionCoprocessorEnvironment> c, MiniBatchOperationInProgress<Mutation> miniBatchOp) This will be called after applying a batch of Mutations on a region.
void	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
boolean	postBulkLoadHFile(ObserverContext<RegionCoprocessorEnvironment> ctx, List<Pair<byte[],String>> familyPaths, boolean hasLoaded) Called after bulkLoadHFile.
boolean	postCheckAndDelete(ObserverContext<RegionCoprocessorEnvironment> c, byte[] row, byte[] family, byte[] qualifier, CompareFilter.CompareOp compareOp, ByteArrayComparable comparator, Delete delete, boolean result) Called after checkAndDelete
boolean	postCheckAndPut(ObserverContext<RegionCoprocessorEnvironment> c, byte[] row, byte[] family, byte[] qualifier, CompareFilter.CompareOp compareOp, ByteArrayComparable comparator, Put put, boolean result) Called after checkAndPut
void	postClose(ObserverContext<RegionCoprocessorEnvironment> c, boolean abortRequested) Called after the region is reported as closed to the master.
void	postCloseRegionOperation(ObserverContext<RegionCoprocessorEnvironment> ctx, HRegion.Operation operation) Called after releasing read lock in HRegion.closeRegionOperation(Operation).
void	postCompact(ObserverContext<RegionCoprocessorEnvironment> c, Store store, StoreFile resultFile) Deprecated. Use postCompact(ObserverContext, Store, StoreFile, CompactionRequest) instead
void	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	postCompactSelection(ObserverContext<RegionCoprocessorEnvironment> c, Store store, com.google.common.collect.ImmutableList<StoreFile> selected) Deprecated. use postCompactSelection(ObserverContext, Store, ImmutableList, CompactionRequest) instead.
void	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	postCompleteSplit(ObserverContext<RegionCoprocessorEnvironment> ctx) Called after any split request is processed.
void	postDelete(ObserverContext<RegionCoprocessorEnvironment> c, Delete delete, WALEdit edit, Durability durability) Called after the client deletes a value.
boolean	postExists(ObserverContext<RegionCoprocessorEnvironment> c, Get get, boolean exists) Called after the client tests for existence using a Get.
void	postFlush(ObserverContext<RegionCoprocessorEnvironment> c) Deprecated. use preFlush(ObserverContext, Store, InternalScanner) instead.
void	postFlush(ObserverContext<RegionCoprocessorEnvironment> c, Store store, StoreFile resultFile) Called after a Store's memstore is flushed to disk.
void	postGet(ObserverContext<RegionCoprocessorEnvironment> c, Get get, List<KeyValue> result) Deprecated.
void	postGetClosestRowBefore(ObserverContext<RegionCoprocessorEnvironment> c, byte[] row, byte[] family, Result result) Called after a client makes a GetClosestRowBefore request.
void	postGetOp(ObserverContext<RegionCoprocessorEnvironment> c, Get get, List<Cell> result) Called after the client performs a Get
Result	postIncrement(ObserverContext<RegionCoprocessorEnvironment> c, Increment increment, Result result) Called after increment
long	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
DeleteTracker	postInstantiateDeleteTracker(ObserverContext<RegionCoprocessorEnvironment> ctx, DeleteTracker delTracker) Called after the ScanQueryMatcher creates ScanDeleteTracker.
void	postLogReplay(ObserverContext<RegionCoprocessorEnvironment> c) Called after the log replay on the region is over.
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	postRollBackSplit(ObserverContext<RegionCoprocessorEnvironment> ctx) This will be called after the roll back of the split region is completed
void	postScannerClose(ObserverContext<RegionCoprocessorEnvironment> c, InternalScanner s) Called after the client closes a scanner.
boolean	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	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.
RegionScanner	postScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c, Scan scan, RegionScanner s) Called after the client opens a new scanner.
void	postSplit(ObserverContext<RegionCoprocessorEnvironment> c, HRegion l, HRegion r) Deprecated. Use postCompleteSplit() instead
void	postStartRegionOperation(ObserverContext<RegionCoprocessorEnvironment> ctx, HRegion.Operation operation) This will be called for region operations where read lock is acquired in HRegion.startRegionOperation().
StoreFile.Reader	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.
void	postWALRestore(ObserverContext<RegionCoprocessorEnvironment> ctx, HRegionInfo info, HLogKey logKey, WALEdit logEdit) Called after a WALEdit replayed for this region.
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	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) Called before bulkLoadHFile.
boolean	preCheckAndDelete(ObserverContext<RegionCoprocessorEnvironment> c, byte[] row, byte[] family, byte[] qualifier, CompareFilter.CompareOp compareOp, ByteArrayComparable comparator, Delete delete, boolean result) Called before checkAndDelete.
boolean	preCheckAndDeleteAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> c, byte[] row, byte[] family, byte[] qualifier, CompareFilter.CompareOp compareOp, ByteArrayComparable comparator, Delete delete, boolean result) Called before checkAndDelete but after acquiring rowock.
boolean	preCheckAndPut(ObserverContext<RegionCoprocessorEnvironment> c, byte[] row, byte[] family, byte[] qualifier, CompareFilter.CompareOp compareOp, ByteArrayComparable comparator, Put put, boolean result) Called before checkAndPut.
boolean	preCheckAndPutAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> c, byte[] row, byte[] family, byte[] qualifier, CompareFilter.CompareOp compareOp, ByteArrayComparable comparator, Put put, boolean result) Called before checkAndPut but after acquiring rowlock.
void	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) Deprecated. use preCompact(ObserverContext, Store, InternalScanner, ScanType, CompactionRequest) instead
InternalScanner	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	preCompactScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c, Store store, List<? extends KeyValueScanner> scanners, ScanType scanType, long earliestPutTs, InternalScanner s) Deprecated. Use preCompactScannerOpen(ObserverContext, Store, List, ScanType, long, InternalScanner, CompactionRequest) instead.
InternalScanner	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.
void	preCompactSelection(ObserverContext<RegionCoprocessorEnvironment> c, Store store, List<StoreFile> candidates) Deprecated. Use preCompactSelection(ObserverContext, Store, List, CompactionRequest) instead
void	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	preDelete(ObserverContext<RegionCoprocessorEnvironment> c, Delete delete, WALEdit edit, Durability durability) Called before the client deletes a value.
boolean	preExists(ObserverContext<RegionCoprocessorEnvironment> c, Get get, boolean exists) Called before the client tests for existence using a Get.
void	preFlush(ObserverContext<RegionCoprocessorEnvironment> c) Deprecated. use preFlush(ObserverContext, Store, InternalScanner) instead
InternalScanner	preFlush(ObserverContext<RegionCoprocessorEnvironment> c, Store store, InternalScanner scanner) Called before a Store's memstore is flushed to disk.
InternalScanner	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.
void	preGet(ObserverContext<RegionCoprocessorEnvironment> c, Get get, List<KeyValue> result) Deprecated.
void	preGetClosestRowBefore(ObserverContext<RegionCoprocessorEnvironment> c, byte[] row, byte[] family, Result result) Called before a client makes a GetClosestRowBefore request.
void	preGetOp(ObserverContext<RegionCoprocessorEnvironment> c, Get get, List<Cell> result) Called before the client performs a Get
Result	preIncrement(ObserverContext<RegionCoprocessorEnvironment> c, Increment increment) Called before Increment.
Result	preIncrementAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> c, Increment increment) Called before Increment but after acquiring rowlock.
long	preIncrementColumnValue(ObserverContext<RegionCoprocessorEnvironment> c, byte[] row, byte[] family, byte[] qualifier, long amount, boolean writeToWAL) Deprecated. This hook is no longer called by the RegionServer
void	preOpen(ObserverContext<RegionCoprocessorEnvironment> c) Called before the region is reported as open to the master.
void	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	prePut(ObserverContext<RegionCoprocessorEnvironment> c, Put put, WALEdit edit, Durability durability) Called before the client stores a value.
void	preRollBackSplit(ObserverContext<RegionCoprocessorEnvironment> ctx) This will be called before the roll back of the split region is completed
void	preScannerClose(ObserverContext<RegionCoprocessorEnvironment> c, InternalScanner s) Called before the client closes a scanner.
boolean	preScannerNext(ObserverContext<RegionCoprocessorEnvironment> c, InternalScanner s, List<Result> result, int limit, boolean hasNext) Called before the client asks for the next row on a scanner.
RegionScanner	preScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c, Scan scan, RegionScanner s) Called before the client opens a new scanner.
void	preSplit(ObserverContext<RegionCoprocessorEnvironment> c) Deprecated. Use preSplit( final ObserverContext c, byte[] splitRow)
void	preSplit(ObserverContext<RegionCoprocessorEnvironment> c, byte[] splitRow) Called before the region is split.
void	preSplitAfterPONR(ObserverContext<RegionCoprocessorEnvironment> ctx) This will be called after PONR step as part of split transaction Calling ObserverContext.bypass() has no effect in this hook.
void	preSplitBeforePONR(ObserverContext<RegionCoprocessorEnvironment> ctx, byte[] splitKey, List<Mutation> metaEntries) This will be called before PONR step as part of split transaction.
StoreFile.Reader	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.
KeyValueScanner	preStoreScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c, Store store, Scan scan, NavigableSet<byte[]> targetCols, KeyValueScanner s) Called before a store opens a new scanner.
void	preWALRestore(ObserverContext<RegionCoprocessorEnvironment> ctx, HRegionInfo info, HLogKey logKey, WALEdit logEdit) Called before a WALEdit replayed for this region.

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

start, stop

Method Detail

preOpen

void preOpen(ObserverContext<RegionCoprocessorEnvironment> c)
             throws IOException

Called before the region is reported as open to the master.

Parameters:

c - the environment provided by the region server

Throws:

IOException - if an error occurred on the coprocessor

postOpen

void postOpen(ObserverContext<RegionCoprocessorEnvironment> c)

Called after the region is reported as open to the master.

Parameters:

c - the environment provided by the region server

postLogReplay

void postLogReplay(ObserverContext<RegionCoprocessorEnvironment> c)

Called after the log replay on the region is over.

Parameters:

c - the environment provided by the region server

preFlushScannerOpen

InternalScanner preFlushScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c,
                                    Store store,
                                    KeyValueScanner memstoreScanner,
                                    InternalScanner s)
                                    throws IOException

Called before a memstore is flushed to disk and prior to creating the scanner to read from the memstore. To override or modify how a memstore is flushed, implementing classes can return a new scanner to provide the KeyValues to be stored into the new StoreFile or null to perform the default processing. Calling ObserverContext.bypass() has no effect in this hook.

Parameters:

c - the environment provided by the region server

store - the store being flushed

memstoreScanner - the scanner for the memstore that is flushed

s - the base scanner, if not null, from previous RegionObserver in the chain

Returns:

the scanner to use during the flush. null if the default implementation is to be used.

Throws:

IOException - if an error occurred on the coprocessor

preFlush

void preFlush(ObserverContext<RegionCoprocessorEnvironment> c)
              throws IOException

Deprecated. use preFlush(ObserverContext, Store, InternalScanner) instead

Called before the memstore is flushed to disk.

Parameters:

c - the environment provided by the region server

Throws:

IOException - if an error occurred on the coprocessor

preFlush

InternalScanner preFlush(ObserverContext<RegionCoprocessorEnvironment> c,
                         Store store,
                         InternalScanner scanner)
                         throws IOException

Called before a Store's memstore is flushed to disk.

Parameters:

c - the environment provided by the region server

store - the store where compaction is being requested

scanner - the scanner over existing data used in the store file

Returns:

the scanner to use during compaction. Should not be null unless the implementation is writing new store files on its own.

Throws:

IOException - if an error occurred on the coprocessor

postFlush

void postFlush(ObserverContext<RegionCoprocessorEnvironment> c)
               throws IOException

Deprecated. use preFlush(ObserverContext, Store, InternalScanner) instead.

Called after the memstore is flushed to disk.

Parameters:

c - the environment provided by the region server

Throws:

IOException - if an error occurred on the coprocessor

postFlush

void postFlush(ObserverContext<RegionCoprocessorEnvironment> c,
               Store store,
               StoreFile resultFile)
               throws IOException

Called after a Store's memstore is flushed to disk.

Parameters:

c - the environment provided by the region server

store - the store being flushed

resultFile - the new store file written out during compaction

Throws:

IOException - if an error occurred on the coprocessor

preCompactSelection

void preCompactSelection(ObserverContext<RegionCoprocessorEnvironment> c,
                         Store store,
                         List<StoreFile> candidates,
                         CompactionRequest request)
                         throws IOException

Called prior to selecting the StoreFiles to compact from the list of available candidates. To alter the files used for compaction, you may mutate the passed in list of candidates.

Parameters:

c - the environment provided by the region server

store - the store where compaction is being requested

candidates - the store files currently available for compaction

request - custom compaction request

Throws:

IOException - if an error occurred on the coprocessor

preCompactSelection

@Deprecated
void preCompactSelection(ObserverContext<RegionCoprocessorEnvironment> c,
                                    Store store,
                                    List<StoreFile> candidates)
                         throws IOException

Deprecated. Use preCompactSelection(ObserverContext, Store, List, CompactionRequest) instead

Called prior to selecting the StoreFiles to compact from the list of available candidates. To alter the files used for compaction, you may mutate the passed in list of candidates.

Parameters:

c - the environment provided by the region server

store - the store where compaction is being requested

candidates - the store files currently available for compaction

Throws:

IOException - if an error occurred on the coprocessor

postCompactSelection

void 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.

Parameters:

c - the environment provided by the region server

store - the store being compacted

selected - the store files selected to compact

request - custom compaction request

postCompactSelection

@Deprecated
void postCompactSelection(ObserverContext<RegionCoprocessorEnvironment> c,
                                     Store store,
                                     com.google.common.collect.ImmutableList<StoreFile> selected)

Deprecated. use postCompactSelection(ObserverContext, Store, ImmutableList, CompactionRequest) instead.

Called after the StoreFiles to compact have been selected from the available candidates.

Parameters:

c - the environment provided by the region server

store - the store being compacted

selected - the store files selected to compact

preCompact

InternalScanner preCompact(ObserverContext<RegionCoprocessorEnvironment> c,
                           Store store,
                           InternalScanner scanner,
                           ScanType scanType,
                           CompactionRequest request)
                           throws IOException

Called prior to writing the StoreFiles selected for compaction into a new StoreFile. To override or modify the compaction process, implementing classes have two options:

• Wrap the provided InternalScanner with a custom implementation that is returned from this method. The custom scanner can then inspect KeyValues from the wrapped scanner, applying its own policy to what gets written.
• Call ObserverContext.bypass() and provide a custom implementation for writing of new StoreFiles. Note: any implementations bypassing core compaction using this approach must write out new store files themselves or the existing data will no longer be available after compaction.

Parameters:

c - the environment provided by the region server

store - the store being compacted

scanner - the scanner over existing data used in the store file rewriting

scanType - type of Scan

request - the requested compaction

Returns:

the scanner to use during compaction. Should not be null unless the implementation is writing new store files on its own.

Throws:

IOException - if an error occurred on the coprocessor

preCompact

@Deprecated
InternalScanner preCompact(ObserverContext<RegionCoprocessorEnvironment> c,
                                      Store store,
                                      InternalScanner scanner,
                                      ScanType scanType)
                           throws IOException

Deprecated. use preCompact(ObserverContext, Store, InternalScanner, ScanType, CompactionRequest) instead

Called prior to writing the StoreFiles selected for compaction into a new StoreFile. To override or modify the compaction process, implementing classes have two options:

• Wrap the provided InternalScanner with a custom implementation that is returned from this method. The custom scanner can then inspect KeyValues from the wrapped scanner, applying its own policy to what gets written.
• Call ObserverContext.bypass() and provide a custom implementation for writing of new StoreFiles. Note: any implementations bypassing core compaction using this approach must write out new store files themselves or the existing data will no longer be available after compaction.

Parameters:

c - the environment provided by the region server

store - the store being compacted

scanner - the scanner over existing data used in the store file rewriting

scanType - type of Scan

Returns:

the scanner to use during compaction. Should not be null unless the implementation is writing new store files on its own.

Throws:

IOException - if an error occurred on the coprocessor

preCompactScannerOpen

InternalScanner preCompactScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c,
                                      Store store,
                                      List<? extends KeyValueScanner> scanners,
                                      ScanType scanType,
                                      long earliestPutTs,
                                      InternalScanner s,
                                      CompactionRequest request)
                                      throws IOException

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. To override or modify the compaction process, implementing classes can return a new scanner to provide the KeyValues to be stored into the new StoreFile or null to perform the default processing. Calling ObserverContext.bypass() has no effect in this hook.

Parameters:

c - the environment provided by the region server

store - the store being compacted

scanners - the list StoreFileScanners to be read from

scanType - the ScanType indicating whether this is a major or minor compaction

earliestPutTs - timestamp of the earliest put that was found in any of the involved store files

s - the base scanner, if not null, from previous RegionObserver in the chain

request - the requested compaction

Returns:

the scanner to use during compaction. null if the default implementation is to be used.

Throws:

IOException - if an error occurred on the coprocessor

preCompactScannerOpen

@Deprecated
InternalScanner preCompactScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c,
                                                 Store store,
                                                 List<? extends KeyValueScanner> scanners,
                                                 ScanType scanType,
                                                 long earliestPutTs,
                                                 InternalScanner s)
                                      throws IOException

Deprecated. Use preCompactScannerOpen(ObserverContext, Store, List, ScanType, long, InternalScanner, CompactionRequest) instead.

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. To override or modify the compaction process, implementing classes can return a new scanner to provide the KeyValues to be stored into the new StoreFile or null to perform the default processing. Calling ObserverContext.bypass() has no effect in this hook.

Parameters:

c - the environment provided by the region server

store - the store being compacted

scanners - the list StoreFileScanners to be read from

scanType - the ScanType indicating whether this is a major or minor compaction

earliestPutTs - timestamp of the earliest put that was found in any of the involved store files

s - the base scanner, if not null, from previous RegionObserver in the chain

Returns:

the scanner to use during compaction. null if the default implementation is to be used.

Throws:

IOException - if an error occurred on the coprocessor

postCompact

void postCompact(ObserverContext<RegionCoprocessorEnvironment> c,
                 Store store,
                 StoreFile resultFile,
                 CompactionRequest request)
                 throws IOException

Called after compaction has completed and the new store file has been moved in to place.

Parameters:

c - the environment provided by the region server

store - the store being compacted

resultFile - the new store file written out during compaction

request - the requested compaction

Throws:

IOException - if an error occurred on the coprocessor

postCompact

@Deprecated
void postCompact(ObserverContext<RegionCoprocessorEnvironment> c,
                            Store store,
                            StoreFile resultFile)
                 throws IOException

Deprecated. Use postCompact(ObserverContext, Store, StoreFile, CompactionRequest) instead

Called after compaction has completed and the new store file has been moved in to place.

Parameters:

c - the environment provided by the region server

store - the store being compacted

resultFile - the new store file written out during compaction

Throws:

IOException - if an error occurred on the coprocessor

preSplit

void preSplit(ObserverContext<RegionCoprocessorEnvironment> c)
              throws IOException

Deprecated. Use preSplit( final ObserverContext c, byte[] splitRow)

Called before the region is split.

Parameters:

c - the environment provided by the region server (e.getRegion() returns the parent region)

Throws:

IOException - if an error occurred on the coprocessor

preSplit

void preSplit(ObserverContext<RegionCoprocessorEnvironment> c,
              byte[] splitRow)
              throws IOException

Called before the region is split.

Parameters:

c - the environment provided by the region server (e.getRegion() returns the parent region)

Throws:

IOException - if an error occurred on the coprocessor

postSplit

void postSplit(ObserverContext<RegionCoprocessorEnvironment> c,
               HRegion l,
               HRegion r)
               throws IOException

Deprecated. Use postCompleteSplit() instead

Called after the region is split.

Parameters:

c - the environment provided by the region server (e.getRegion() returns the parent region)

l - the left daughter region

r - the right daughter region

Throws:

IOException - if an error occurred on the coprocessor

preSplitBeforePONR

void preSplitBeforePONR(ObserverContext<RegionCoprocessorEnvironment> ctx,
                        byte[] splitKey,
                        List<Mutation> metaEntries)
                        throws IOException

This will be called before PONR step as part of split transaction. Calling ObserverContext.bypass() rollback the split

Parameters:

ctx -

splitKey -

metaEntries -

Throws:

IOException

preSplitAfterPONR

void preSplitAfterPONR(ObserverContext<RegionCoprocessorEnvironment> ctx)
                       throws IOException

This will be called after PONR step as part of split transaction Calling ObserverContext.bypass() has no effect in this hook.

Parameters:

ctx -

Throws:

IOException

preRollBackSplit

void preRollBackSplit(ObserverContext<RegionCoprocessorEnvironment> ctx)
                      throws IOException

This will be called before the roll back of the split region is completed

Parameters:

ctx -

Throws:

IOException

postRollBackSplit

void postRollBackSplit(ObserverContext<RegionCoprocessorEnvironment> ctx)
                       throws IOException

This will be called after the roll back of the split region is completed

Parameters:

ctx -

Throws:

IOException

postCompleteSplit

void postCompleteSplit(ObserverContext<RegionCoprocessorEnvironment> ctx)
                       throws IOException

Called after any split request is processed. This will be called irrespective of success or failure of the split.

Parameters:

ctx -

Throws:

IOException

preClose

void preClose(ObserverContext<RegionCoprocessorEnvironment> c,
              boolean abortRequested)
              throws IOException

Called before the region is reported as closed to the master.

Parameters:

c - the environment provided by the region server

abortRequested - true if the region server is aborting

Throws:

IOException

postClose

void postClose(ObserverContext<RegionCoprocessorEnvironment> c,
               boolean abortRequested)

Called after the region is reported as closed to the master.

Parameters:

c - the environment provided by the region server

abortRequested - true if the region server is aborting

preGetClosestRowBefore

void preGetClosestRowBefore(ObserverContext<RegionCoprocessorEnvironment> c,
                            byte[] row,
                            byte[] family,
                            Result result)
                            throws IOException

Called before a client makes a GetClosestRowBefore request.

Call CoprocessorEnvironment#bypass to skip default actions

Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors

Parameters:

c - the environment provided by the region server

row - the row

family - the family

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

Throws:

IOException - if an error occurred on the coprocessor

postGetClosestRowBefore

void postGetClosestRowBefore(ObserverContext<RegionCoprocessorEnvironment> c,
                             byte[] row,
                             byte[] family,
                             Result result)
                             throws IOException

Called after a client makes a GetClosestRowBefore request.

Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors

Parameters:

c - the environment provided by the region server

row - the row

family - the desired family

result - the result to return to the client, modify as necessary

Throws:

IOException - if an error occurred on the coprocessor

preGetOp

void preGetOp(ObserverContext<RegionCoprocessorEnvironment> c,
              Get get,
              List<Cell> result)
              throws IOException

Called before the client performs a Get

Call CoprocessorEnvironment#bypass to skip default actions

Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors

Parameters:

c - the environment provided by the region server

get - the Get request

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

Throws:

IOException - if an error occurred on the coprocessor

preGet

@Deprecated
void preGet(ObserverContext<RegionCoprocessorEnvironment> c,
                       Get get,
                       List<KeyValue> result)
            throws IOException

Deprecated.

WARNING: please override preGetOp instead of this method. This is to maintain some compatibility and to ease the transition from 0.94 -> 0.96.

Throws:

IOException

postGetOp

void postGetOp(ObserverContext<RegionCoprocessorEnvironment> c,
               Get get,
               List<Cell> result)
               throws IOException

Called after the client performs a Get

Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors

Parameters:

c - the environment provided by the region server

get - the Get request

result - the result to return to the client, modify as necessary

Throws:

IOException - if an error occurred on the coprocessor

postGet

@Deprecated
void postGet(ObserverContext<RegionCoprocessorEnvironment> c,
                        Get get,
                        List<KeyValue> result)
             throws IOException

Deprecated.

WARNING: please override postGetOp instead of this method. This is to maintain some compatibility and to ease the transition from 0.94 -> 0.96.

Throws:

IOException

preExists

boolean preExists(ObserverContext<RegionCoprocessorEnvironment> c,
                  Get get,
                  boolean exists)
                  throws IOException

Called before the client tests for existence using a Get.

Call CoprocessorEnvironment#bypass to skip default actions

Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors

Parameters:

c - the environment provided by the region server

get - the Get request

exists -

Returns:

the value to return to the client if bypassing default processing

Throws:

IOException - if an error occurred on the coprocessor

postExists

boolean postExists(ObserverContext<RegionCoprocessorEnvironment> c,
                   Get get,
                   boolean exists)
                   throws IOException

Called after the client tests for existence using a Get.

Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors

Parameters:

c - the environment provided by the region server

get - the Get request

exists - the result returned by the region server

Returns:

the result to return to the client

Throws:

IOException - if an error occurred on the coprocessor

prePut

void prePut(ObserverContext<RegionCoprocessorEnvironment> c,
            Put put,
            WALEdit edit,
            Durability durability)
            throws IOException

Called before the client stores a value.

Call CoprocessorEnvironment#bypass to skip default actions

Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors

Parameters:

c - the environment provided by the region server

put - The Put object

edit - The WALEdit object that will be written to the wal

durability - Persistence guarantee for this Put

Throws:

IOException - if an error occurred on the coprocessor

postPut

void postPut(ObserverContext<RegionCoprocessorEnvironment> c,
             Put put,
             WALEdit edit,
             Durability durability)
             throws IOException

Called after the client stores a value.

Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors

Parameters:

c - the environment provided by the region server

put - The Put object

edit - The WALEdit object for the wal

durability - Persistence guarantee for this Put

Throws:

IOException - if an error occurred on the coprocessor

preDelete

void preDelete(ObserverContext<RegionCoprocessorEnvironment> c,
               Delete delete,
               WALEdit edit,
               Durability durability)
               throws IOException

Called before the client deletes a value.

Call CoprocessorEnvironment#bypass to skip default actions

Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors

Parameters:

c - the environment provided by the region server

delete - The Delete object

edit - The WALEdit object for the wal

durability - Persistence guarantee for this Delete

Throws:

IOException - if an error occurred on the coprocessor

prePrepareTimeStampForDeleteVersion

void prePrepareTimeStampForDeleteVersion(ObserverContext<RegionCoprocessorEnvironment> c,
                                         Mutation mutation,
                                         Cell cell,
                                         byte[] byteNow,
                                         Get get)
                                         throws IOException

Called before the server updates the timestamp for version delete with latest timestamp.

Call CoprocessorEnvironment#bypass to skip default actions

Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors

Parameters:

c - the environment provided by the region server

mutation - - the parent mutation associated with this delete cell

cell - - The deleteColumn with latest version cell

byteNow - - timestamp bytes

get - - the get formed using the current cell's row. Note that the get does not specify the family and qualifier

Throws:

IOException

postDelete

void postDelete(ObserverContext<RegionCoprocessorEnvironment> c,
                Delete delete,
                WALEdit edit,
                Durability durability)
                throws IOException

Called after the client deletes a value.

Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors

Parameters:

c - the environment provided by the region server

delete - The Delete object

edit - The WALEdit object for the wal

durability - Persistence guarantee for this Delete

Throws:

IOException - if an error occurred on the coprocessor

preBatchMutate

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

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

Parameters:

c - the environment provided by the region server

miniBatchOp - batch of Mutations getting applied to region.

Throws:

IOException - if an error occurred on the coprocessor

postBatchMutate

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

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

Parameters:

c - the environment provided by the region server

miniBatchOp - batch of Mutations applied to region.

Throws:

IOException - if an error occurred on the coprocessor

postStartRegionOperation

void postStartRegionOperation(ObserverContext<RegionCoprocessorEnvironment> ctx,
                              HRegion.Operation operation)
                              throws IOException

This will be called for region operations where read lock is acquired in HRegion.startRegionOperation().

Parameters:

ctx -

operation - The operation is about to be taken on the region

Throws:

IOException

postCloseRegionOperation

void postCloseRegionOperation(ObserverContext<RegionCoprocessorEnvironment> ctx,
                              HRegion.Operation operation)
                              throws IOException

Called after releasing read lock in HRegion.closeRegionOperation(Operation).

Parameters:

ctx -

operation -

Throws:

IOException

postBatchMutateIndispensably

void postBatchMutateIndispensably(ObserverContext<RegionCoprocessorEnvironment> ctx,
                                  MiniBatchOperationInProgress<Mutation> miniBatchOp,
                                  boolean success)
                                  throws IOException

Called after the completion of batch put/delete and will be called even if the batch operation fails

Parameters:

ctx -

miniBatchOp -

success - true if batch operation is successful otherwise false.

Throws:

IOException

preCheckAndPut

boolean preCheckAndPut(ObserverContext<RegionCoprocessorEnvironment> c,
                       byte[] row,
                       byte[] family,
                       byte[] qualifier,
                       CompareFilter.CompareOp compareOp,
                       ByteArrayComparable comparator,
                       Put put,
                       boolean result)
                       throws IOException

Called before checkAndPut.

Call CoprocessorEnvironment#bypass to skip default actions

Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors

Parameters:

c - the environment provided by the region server

row - row to check

family - column family

qualifier - column qualifier

compareOp - the comparison operation

comparator - the comparator

put - data to put if check succeeds

result -

Returns:

the return value to return to client if bypassing default processing

Throws:

IOException - if an error occurred on the coprocessor

preCheckAndPutAfterRowLock

boolean preCheckAndPutAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> c,
                                   byte[] row,
                                   byte[] family,
                                   byte[] qualifier,
                                   CompareFilter.CompareOp compareOp,
                                   ByteArrayComparable comparator,
                                   Put put,
                                   boolean result)
                                   throws IOException

Called before checkAndPut but after acquiring rowlock.

Note: Caution to be taken for not doing any long time operation in this hook. Row will be locked for longer time. Trying to acquire lock on another row, within this, can lead to potential deadlock.

Call CoprocessorEnvironment#bypass to skip default actions

Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors

Parameters:

c - the environment provided by the region server

row - row to check

family - column family

qualifier - column qualifier

compareOp - the comparison operation

comparator - the comparator

put - data to put if check succeeds

result -

Returns:

the return value to return to client if bypassing default processing

Throws:

IOException - if an error occurred on the coprocessor

postCheckAndPut

boolean postCheckAndPut(ObserverContext<RegionCoprocessorEnvironment> c,
                        byte[] row,
                        byte[] family,
                        byte[] qualifier,
                        CompareFilter.CompareOp compareOp,
                        ByteArrayComparable comparator,
                        Put put,
                        boolean result)
                        throws IOException

Called after checkAndPut

Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors

Parameters:

c - the environment provided by the region server

row - row to check

family - column family

qualifier - column qualifier

compareOp - the comparison operation

comparator - the comparator

put - data to put if check succeeds

result - from the checkAndPut

Returns:

the possibly transformed return value to return to client

Throws:

IOException - if an error occurred on the coprocessor

preCheckAndDelete

boolean preCheckAndDelete(ObserverContext<RegionCoprocessorEnvironment> c,
                          byte[] row,
                          byte[] family,
                          byte[] qualifier,
                          CompareFilter.CompareOp compareOp,
                          ByteArrayComparable comparator,
                          Delete delete,
                          boolean result)
                          throws IOException

Called before checkAndDelete.

Call CoprocessorEnvironment#bypass to skip default actions

Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors

Parameters:

c - the environment provided by the region server

row - row to check

family - column family

qualifier - column qualifier

compareOp - the comparison operation

comparator - the comparator

delete - delete to commit if check succeeds

result -

Returns:

the value to return to client if bypassing default processing

Throws:

IOException - if an error occurred on the coprocessor

preCheckAndDeleteAfterRowLock

boolean preCheckAndDeleteAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> c,
                                      byte[] row,
                                      byte[] family,
                                      byte[] qualifier,
                                      CompareFilter.CompareOp compareOp,
                                      ByteArrayComparable comparator,
                                      Delete delete,
                                      boolean result)
                                      throws IOException

Called before checkAndDelete but after acquiring rowock.

Note: Caution to be taken for not doing any long time operation in this hook. Row will be locked for longer time. Trying to acquire lock on another row, within this, can lead to potential deadlock.

Call CoprocessorEnvironment#bypass to skip default actions

Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors

Parameters:

c - the environment provided by the region server

row - row to check

family - column family

qualifier - column qualifier

compareOp - the comparison operation

comparator - the comparator

delete - delete to commit if check succeeds

result -

Returns:

the value to return to client if bypassing default processing

Throws:

IOException - if an error occurred on the coprocessor

postCheckAndDelete

boolean postCheckAndDelete(ObserverContext<RegionCoprocessorEnvironment> c,
                           byte[] row,
                           byte[] family,
                           byte[] qualifier,
                           CompareFilter.CompareOp compareOp,
                           ByteArrayComparable comparator,
                           Delete delete,
                           boolean result)
                           throws IOException

Called after checkAndDelete

Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors

Parameters:

c - the environment provided by the region server

row - row to check

family - column family

qualifier - column qualifier

compareOp - the comparison operation

comparator - the comparator

delete - delete to commit if check succeeds

result - from the CheckAndDelete

Returns:

the possibly transformed returned value to return to client

Throws:

IOException - if an error occurred on the coprocessor

preIncrementColumnValue

@Deprecated
long preIncrementColumnValue(ObserverContext<RegionCoprocessorEnvironment> c,
                                        byte[] row,
                                        byte[] family,
                                        byte[] qualifier,
                                        long amount,
                                        boolean writeToWAL)
                             throws IOException

Deprecated. This hook is no longer called by the RegionServer

Called before incrementColumnValue

Call CoprocessorEnvironment#bypass to skip default actions

Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors

Parameters:

c - the environment provided by the region server

row - row to check

family - column family

qualifier - column qualifier

amount - long amount to increment

writeToWAL - true if the change should be written to the WAL

Returns:

value to return to the client if bypassing default processing

Throws:

IOException - if an error occurred on the coprocessor

postIncrementColumnValue

@Deprecated
long postIncrementColumnValue(ObserverContext<RegionCoprocessorEnvironment> c,
                                         byte[] row,
                                         byte[] family,
                                         byte[] qualifier,
                                         long amount,
                                         boolean writeToWAL,
                                         long result)
                              throws IOException

Deprecated. This hook is no longer called by the RegionServer

Called after incrementColumnValue

Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors

Parameters:

c - the environment provided by the region server

row - row to check

family - column family

qualifier - column qualifier

amount - long amount to increment

writeToWAL - true if the change should be written to the WAL

result - the result returned by incrementColumnValue

Returns:

the result to return to the client

Throws:

IOException - if an error occurred on the coprocessor

preAppend

Result preAppend(ObserverContext<RegionCoprocessorEnvironment> c,
                 Append append)
                 throws IOException

Called before Append.

Call CoprocessorEnvironment#bypass to skip default actions

Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors

Parameters:

c - the environment provided by the region server

append - Append object

Returns:

result to return to the client if bypassing default processing

Throws:

IOException - if an error occurred on the coprocessor

preAppendAfterRowLock

Result preAppendAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> c,
                             Append append)
                             throws IOException

Called before Append but after acquiring rowlock.

Note: Caution to be taken for not doing any long time operation in this hook. Row will be locked for longer time. Trying to acquire lock on another row, within this, can lead to potential deadlock.

Call CoprocessorEnvironment#bypass to skip default actions

Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors

Parameters:

c - the environment provided by the region server

append - Append object

Returns:

result to return to the client if bypassing default processing

Throws:

IOException - if an error occurred on the coprocessor

postAppend

Result postAppend(ObserverContext<RegionCoprocessorEnvironment> c,
                  Append append,
                  Result result)
                  throws IOException

Called after Append

Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors

Parameters:

c - the environment provided by the region server

append - Append object

result - the result returned by increment

Returns:

the result to return to the client

Throws:

IOException - if an error occurred on the coprocessor

preIncrement

Result preIncrement(ObserverContext<RegionCoprocessorEnvironment> c,
                    Increment increment)
                    throws IOException

Called before Increment.

Call CoprocessorEnvironment#bypass to skip default actions

Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors

Parameters:

c - the environment provided by the region server

increment - increment object

Returns:

result to return to the client if bypassing default processing

Throws:

IOException - if an error occurred on the coprocessor

preIncrementAfterRowLock

Result preIncrementAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> c,
                                Increment increment)
                                throws IOException

Called before Increment but after acquiring rowlock.

Note: Caution to be taken for not doing any long time operation in this hook. Row will be locked for longer time. Trying to acquire lock on another row, within this, can lead to potential deadlock.

Call CoprocessorEnvironment#bypass to skip default actions

Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors

Parameters:

c - the environment provided by the region server

increment - increment object

Returns:

result to return to the client if bypassing default processing

Throws:

IOException - if an error occurred on the coprocessor

postIncrement

Result postIncrement(ObserverContext<RegionCoprocessorEnvironment> c,
                     Increment increment,
                     Result result)
                     throws IOException

Called after increment

Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors

Parameters:

c - the environment provided by the region server

increment - increment object

result - the result returned by increment

Returns:

the result to return to the client

Throws:

IOException - if an error occurred on the coprocessor

preScannerOpen

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

Called before the client opens a new scanner.

Call CoprocessorEnvironment#bypass to skip default actions

Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors

Parameters:

c - the environment provided by the region server

scan - the Scan specification

s - if not null, the base scanner

Returns:

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

Throws:

IOException - if an error occurred on the coprocessor

preStoreScannerOpen

KeyValueScanner preStoreScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c,
                                    Store store,
                                    Scan scan,
                                    NavigableSet<byte[]> targetCols,
                                    KeyValueScanner s)
                                    throws IOException

Called before a store opens a new scanner. This hook is called when a "user" scanner is opened.

See preFlushScannerOpen(ObserverContext, Store, KeyValueScanner, InternalScanner) and preCompactScannerOpen(ObserverContext, Store, List, ScanType, long, InternalScanner) to override scanners created for flushes or compactions, resp.

Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors. Calling ObserverContext.bypass() has no effect in this hook.

Parameters:

c - the environment provided by the region server

store - the store being scanned

scan - the Scan specification

targetCols - columns to be used in the scanner

s - the base scanner, if not null, from previous RegionObserver in the chain

Returns:

a KeyValueScanner instance to use or null to use the default implementation

Throws:

IOException - if an error occurred on the coprocessor

postScannerOpen

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

Called after the client opens a new scanner.

Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors

Parameters:

c - the environment provided by the region server

scan - the Scan specification

s - if not null, the base scanner

Returns:

the scanner instance to use

Throws:

IOException - if an error occurred on the coprocessor

preScannerNext

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

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

Call CoprocessorEnvironment#bypass to skip default actions

Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors

Parameters:

c - the environment provided by the region server

s - the scanner

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

limit - the maximum number of results to return

hasNext - the 'has more' indication

Returns:

'has more' indication that should be sent to client

Throws:

IOException - if an error occurred on the coprocessor

postScannerNext

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

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

Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors

Parameters:

c - the environment provided by the region server

s - the scanner

result - the result to return to the client, can be modified

limit - the maximum number of results to return

hasNext - the 'has more' indication

Returns:

'has more' indication that should be sent to client

Throws:

IOException - if an error occurred on the coprocessor

postScannerFilterRow

boolean postScannerFilterRow(ObserverContext<RegionCoprocessorEnvironment> c,
                             InternalScanner s,
                             byte[] currentRow,
                             int offset,
                             short length,
                             boolean hasMore)
                             throws IOException

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. void filterRow(List kvs) removing all the kvs from the passed List

Parameters:

c - the environment provided by the region server

s - the scanner

currentRow - The current rowkey which got filtered out

offset - offset to rowkey

length - length of rowkey

hasMore - the 'has more' indication

Returns:

whether more rows are available for the scanner or not

Throws:

IOException

preScannerClose

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

Called before the client closes a scanner.

Call CoprocessorEnvironment#bypass to skip default actions

Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors

Parameters:

c - the environment provided by the region server

s - the scanner

Throws:

IOException - if an error occurred on the coprocessor

postScannerClose

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

Called after the client closes a scanner.

Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors

Parameters:

c - the environment provided by the region server

s - the scanner

Throws:

IOException - if an error occurred on the coprocessor

preWALRestore

void preWALRestore(ObserverContext<RegionCoprocessorEnvironment> ctx,
                   HRegionInfo info,
                   HLogKey logKey,
                   WALEdit logEdit)
                   throws IOException

Called before a WALEdit replayed for this region.

Parameters:

ctx -

info -

logKey -

logEdit -

Throws:

IOException

postWALRestore

void postWALRestore(ObserverContext<RegionCoprocessorEnvironment> ctx,
                    HRegionInfo info,
                    HLogKey logKey,
                    WALEdit logEdit)
                    throws IOException

Called after a WALEdit replayed for this region.

Parameters:

ctx -

info -

logKey -

logEdit -

Throws:

IOException

preBulkLoadHFile

void preBulkLoadHFile(ObserverContext<RegionCoprocessorEnvironment> ctx,
                      List<Pair<byte[],String>> familyPaths)
                      throws IOException

Called before bulkLoadHFile. Users can create a StoreFile instance to access the contents of a HFile.

Parameters:

ctx -

familyPaths - pairs of { CF, HFile path } submitted for bulk load. Adding or removing from this list will add or remove HFiles to be bulk loaded.

Throws:

IOException

postBulkLoadHFile

boolean postBulkLoadHFile(ObserverContext<RegionCoprocessorEnvironment> ctx,
                          List<Pair<byte[],String>> familyPaths,
                          boolean hasLoaded)
                          throws IOException

Called after bulkLoadHFile.

Parameters:

ctx -

familyPaths - pairs of { CF, HFile path } submitted for bulk load

hasLoaded - whether the bulkLoad was successful

Returns:

the new value of hasLoaded

Throws:

IOException

preStoreFileReaderOpen

StoreFile.Reader 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)
                                        throws IOException

Called before creation of Reader for a store file. Calling ObserverContext.bypass() has no effect in this hook.

Parameters:

ctx - the environment provided by the region server

fs - fileystem to read from

p - path to the file

in - FSDataInputStreamWrapper

size - Full size of the file

cacheConf -

r - original reference file. This will be not null only when reading a split file.

reader - the base reader, if not null, from previous RegionObserver in the chain

Returns:

a Reader instance to use instead of the base reader if overriding default behavior, null otherwise

Throws:

IOException

postStoreFileReaderOpen

StoreFile.Reader 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)
                                         throws IOException

Called after the creation of Reader for a store file.

Parameters:

ctx - the environment provided by the region server

fs - fileystem to read from

p - path to the file

in - FSDataInputStreamWrapper

size - Full size of the file

cacheConf -

r - original reference file. This will be not null only when reading a split file.

reader - the base reader instance

Returns:

The reader to use

Throws:

IOException

postMutationBeforeWAL

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

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.

Parameters:

ctx - the environment provided by the region server

opType - the operation type

mutation - the current mutation

oldCell - old cell containing previous value

newCell - the new cell containing the computed value

Returns:

the new cell, possibly changed

Throws:

IOException

postInstantiateDeleteTracker

DeleteTracker postInstantiateDeleteTracker(ObserverContext<RegionCoprocessorEnvironment> ctx,
                                           DeleteTracker delTracker)
                                           throws IOException

Called after the ScanQueryMatcher creates ScanDeleteTracker. Implementing this hook would help in creating customised DeleteTracker and returning the newly created DeleteTracker

Parameters:

ctx - the environment provided by the region server

delTracker - the deleteTracker that is created by the QueryMatcher

Returns:

the Delete Tracker

Throws:

IOException