SimpleRegionObserver (Hortonworks Data Platform Apache HBase Java API Reference)

java.lang.Object
- org.apache.hadoop.hbase.coprocessor.BaseRegionObserver
- - org.apache.hadoop.hbase.coprocessor.SimpleRegionObserver

All Implemented Interfaces:

Coprocessor, RegionObserver

Direct Known Subclasses:

SimpleRegionObserver.Legacy, TestNegativeMemstoreSizeWithSlowCoprocessor.FlushingRegionObserver, TestRegionServerCoprocessorExceptionWithAbort.BuggyRegionObserver, TestRegionServerCoprocessorExceptionWithAbort.FailedInitializationObserver, TestRegionServerCoprocessorExceptionWithRemove.BuggyRegionObserver
```
public class SimpleRegionObserver
extends BaseRegionObserver
```
A sample region observer that tests the RegionObserver interface. It works with TestRegionObserverInterface to provide the test case.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`SimpleRegionObserver.Legacy` This implementation should trigger our legacy support because it does not directly implement the newer API calls.

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

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

Field Summary
- Fields inherited from interface org.apache.hadoop.hbase.Coprocessor
  PRIORITY_HIGHEST, PRIORITY_LOWEST, PRIORITY_SYSTEM, PRIORITY_USER, VERSION

Constructor Summary

Constructors
Constructor and Description

SimpleRegionObserver()

Constructors
Constructor and Description
`SimpleRegionObserver()`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`int`	`getCtBeforeDelete()`
`int`	`getCtPostClose()`
`int`	`getCtPostCloseRegionOperation()`
`int`	`getCtPostCompact()`
`int`	`getCtPostCompactSelect()`
`int`	`getCtPostDeleted()`
`int`	`getCtPostFlush()`
`int`	`getCtPostGet()`
`int`	`getCtPostGetClosestRowBefore()`
`int`	`getCtPostIncrement()`
`int`	`getCtPostOpen()`
`int`	`getCtPostPut()`
`int`	`getCtPostSplit()`
`int`	`getCtPostStartRegionOperation()`
`int`	`getCtPostWALRestore()`
`int`	`getCtPostWALRestoreDeprecated()`
`int`	`getCtPreClose()`
`int`	`getCtPreCompact()`
`int`	`getCtPreCompactScanner()`
`int`	`getCtPreCompactSelect()`
`int`	`getCtPreDeleted()`
`int`	`getCtPreFlush()`
`int`	`getCtPreFlushScannerOpen()`
`int`	`getCtPreGet()`
`int`	`getCtPreGetClosestRowBefore()`
`int`	`getCtPreIncrement()`
`int`	`getCtPreOpen()`
`int`	`getCtPrePut()`
`int`	`getCtPreSplit()`
`int`	`getCtPreSplitAfterPONR()`
`int`	`getCtPreSplitBeforePONR()`
`int`	`getCtPreWALRestore()`
`int`	`getCtPreWALRestoreDeprecated()`
`boolean`	`hadDelete()`
`boolean`	`hadDeleted()`
`boolean`	`hadPostAppend()`
`boolean`	`hadPostBatchMutate()`
`boolean`	`hadPostBatchMutateIndispensably()`
`boolean`	`hadPostBulkLoadHFile()`
`boolean`	`hadPostCheckAndDelete()`
`boolean`	`hadPostCheckAndPut()`
`boolean`	`hadPostCloseRegionOperation()`
`boolean`	`hadPostGet()`
`boolean`	`hadPostIncrement()`
`boolean`	`hadPostPut()`
`boolean`	`hadPostStartRegionOperation()`
`boolean`	`hadPostWALRestore()`
`boolean`	`hadPreAppend()`
`boolean`	`hadPreAppendAfterRowLock()`
`boolean`	`hadPreBatchMutate()`
`boolean`	`hadPreBulkLoadHFile()`
`boolean`	`hadPreCheckAndDelete()`
`boolean`	`hadPreCheckAndDeleteAfterRowLock()`
`boolean`	`hadPreCheckAndPut()`
`boolean`	`hadPreCheckAndPutAfterRowLock()`
`boolean`	`hadPreGet()`
`boolean`	`hadPreIncrement()`
`boolean`	`hadPreIncrementAfterRowLock()`
`boolean`	`hadPrePreparedDeleteTS()`
`boolean`	`hadPrePut()`
`boolean`	`hadPreWALRestore()`
`Result`	`postAppend(ObserverContext<RegionCoprocessorEnvironment> e, 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, Map<byte[],List<Path>> map, boolean hasLoaded)` Called after bulkLoadHFile.
`boolean`	`postCheckAndDelete(ObserverContext<RegionCoprocessorEnvironment> e, byte[] row, byte[] family, byte[] qualifier, CompareFilter.CompareOp compareOp, ByteArrayComparable comparator, Delete delete, boolean result)` Called after checkAndDelete
`boolean`	`postCheckAndPut(ObserverContext<RegionCoprocessorEnvironment> e, 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, Region.Operation op)` Called after releasing read lock in `Region.closeRegionOperation()`.
`void`	`postCompact(ObserverContext<RegionCoprocessorEnvironment> e, Store store, StoreFile resultFile)` Called after compaction has completed and the new store file has been moved in to place.
`void`	`postCompactSelection(ObserverContext<RegionCoprocessorEnvironment> c, Store store, <any> selected)` Called after the `StoreFile`s to compact have been selected from the available candidates.
`void`	`postDelete(ObserverContext<RegionCoprocessorEnvironment> c, Delete delete, WALEdit edit, Durability durability)` Called after the client deletes a value.
`void`	`postFlush(ObserverContext<RegionCoprocessorEnvironment> c, Store store, StoreFile resultFile)` Called after a Store's memstore is flushed to disk.
`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> results)` Called after the client performs a Get
`Result`	`postIncrement(ObserverContext<RegionCoprocessorEnvironment> c, Increment increment, Result result)` Called after increment
`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`	`postScannerClose(ObserverContext<RegionCoprocessorEnvironment> c, InternalScanner s)` Called after the client closes a scanner.
`boolean`	`postScannerNext(ObserverContext<RegionCoprocessorEnvironment> c, InternalScanner s, List<Result> results, int limit, boolean hasMore)` 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, Region l, Region r)` Called after the region is split.
`void`	`postStartRegionOperation(ObserverContext<RegionCoprocessorEnvironment> ctx, Region.Operation op)` This will be called for region operations where read lock is acquired in `Region.startRegionOperation()`.
`StoreFile.Reader`	`postStoreFileReaderOpen(ObserverContext<RegionCoprocessorEnvironment> ctx, FileSystem 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<? extends RegionCoprocessorEnvironment> env, HRegionInfo info, WALKey logKey, WALEdit logEdit)` Implementers should override this version of the method and leave the deprecated one as-is.
`void`	`postWALRestore(ObserverContext<RegionCoprocessorEnvironment> env, HRegionInfo info, HLogKey logKey, WALEdit logEdit)` Called after a `WALEdit` replayed for this region.
`Result`	`preAppend(ObserverContext<RegionCoprocessorEnvironment> e, Append append)` Called before Append.
`Result`	`preAppendAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> e, 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> e, byte[] row, byte[] family, byte[] qualifier, CompareFilter.CompareOp compareOp, ByteArrayComparable comparator, Delete delete, boolean result)` Called before checkAndDelete.
`boolean`	`preCheckAndDeleteAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> e, 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> e, byte[] row, byte[] family, byte[] qualifier, CompareFilter.CompareOp compareOp, ByteArrayComparable comparator, Put put, boolean result)` Called before checkAndPut.
`boolean`	`preCheckAndPutAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> e, 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> e, Store store, InternalScanner scanner, ScanType scanType)` Called prior to writing the `StoreFile`s selected for compaction into a new `StoreFile`.
`InternalScanner`	`preCompactScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c, Store store, List<? extends KeyValueScanner> scanners, ScanType scanType, long earliestPutTs, InternalScanner s)` Called prior to writing the `StoreFile`s 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)` Called prior to selecting the `StoreFile`s 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.
`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`	`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> results)` Called before the client performs a Get
`Result`	`preIncrement(ObserverContext<RegionCoprocessorEnvironment> c, Increment increment)` Called before Increment.
`Result`	`preIncrementAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> e, Increment increment)` Called before Increment but after acquiring rowlock.
`void`	`preOpen(ObserverContext<RegionCoprocessorEnvironment> c)` Called before the region is reported as open to the master.
`void`	`prePrepareTimeStampForDeleteVersion(ObserverContext<RegionCoprocessorEnvironment> e, Mutation delete, 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`	`preScannerClose(ObserverContext<RegionCoprocessorEnvironment> c, InternalScanner s)` Called before the client closes a scanner.
`boolean`	`preScannerNext(ObserverContext<RegionCoprocessorEnvironment> c, InternalScanner s, List<Result> results, int limit, boolean hasMore)` 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)` 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, FileSystem 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<? extends RegionCoprocessorEnvironment> env, HRegionInfo info, WALKey logKey, WALEdit logEdit)` Implementers should override this version of the method and leave the deprecated one as-is.
`void`	`preWALRestore(ObserverContext<RegionCoprocessorEnvironment> env, HRegionInfo info, HLogKey logKey, WALEdit logEdit)` Called before a `WALEdit` replayed for this region.
`void`	`setThrowOnPostFlush(Boolean val)`
`void`	`start(CoprocessorEnvironment e)`
`boolean`	`wasClosed()`
`boolean`	`wasCompacted()`
`boolean`	`wasFlushed()`
`boolean`	`wasOpened()`
`boolean`	`wasScannerCloseCalled()`
`boolean`	`wasScannerNextCalled()`
`boolean`	`wasScannerOpenCalled()`
`boolean`	`wasSplit()`
`boolean`	`wasStoreFileReaderOpenCalled()`

Methods inherited from class org.apache.hadoop.hbase.coprocessor.BaseRegionObserver
postBulkLoadHFile, postCommitStoreFile, postCompact, postCompactSelection, postCompleteSplit, postExists, postFlush, postIncrementColumnValue, postInstantiateDeleteTracker, postLogReplay, postMutationBeforeWAL, postRollBackSplit, postScannerFilterRow, preCommitStoreFile, preCompact, preCompactScannerOpen, preCompactSelection, preExists, preFlush, preIncrementColumnValue, preRollBackSplit, preSplit, stop

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - SimpleRegionObserver
```
public SimpleRegionObserver()
```
- Method Detail
  - setThrowOnPostFlush
```
public void setThrowOnPostFlush(Boolean val)
```
  - start
```
public void start(CoprocessorEnvironment e)
           throws IOException
```
    Specified by:
    
    start in interface Coprocessor
    
    Overrides:
    
    start in class BaseRegionObserver
    
    Throws:
    
    IOException
  - preOpen
```
public void preOpen(ObserverContext<RegionCoprocessorEnvironment> c)
```
    Description copied from interface: RegionObserver
    
    Called before the region is reported as open to the master.
    
    Specified by:
    
    preOpen in interface RegionObserver
    
    Overrides:
    
    preOpen in class BaseRegionObserver
    
    Parameters:
    
    c - the environment provided by the region server
  - postOpen
```
public void postOpen(ObserverContext<RegionCoprocessorEnvironment> c)
```
    Description copied from interface: RegionObserver
    
    Called after the region is reported as open to the master.
    
    Specified by:
    
    postOpen in interface RegionObserver
    
    Overrides:
    
    postOpen in class BaseRegionObserver
    
    Parameters:
    
    c - the environment provided by the region server
  - wasOpened
```
public boolean wasOpened()
```
  - preClose
```
public void preClose(ObserverContext<RegionCoprocessorEnvironment> c,
                     boolean abortRequested)
```
    Description copied from interface: RegionObserver
    
    Called before the region is reported as closed to the master.
    
    Specified by:
    
    preClose in interface RegionObserver
    
    Overrides:
    
    preClose in class BaseRegionObserver
    
    Parameters:
    
    c - the environment provided by the region server
    
    abortRequested - true if the region server is aborting
  - postClose
```
public void postClose(ObserverContext<RegionCoprocessorEnvironment> c,
                      boolean abortRequested)
```
    Description copied from interface: RegionObserver
    
    Called after the region is reported as closed to the master.
    
    Specified by:
    
    postClose in interface RegionObserver
    
    Overrides:
    
    postClose in class BaseRegionObserver
    
    Parameters:
    
    c - the environment provided by the region server
    
    abortRequested - true if the region server is aborting
  - wasClosed
```
public boolean wasClosed()
```
  - preFlush
```
public InternalScanner preFlush(ObserverContext<RegionCoprocessorEnvironment> c,
                                Store store,
                                InternalScanner scanner)
                         throws IOException
```
    Description copied from interface: RegionObserver
    
    Called before a Store's memstore is flushed to disk.
    
    Specified by:
    
    preFlush in interface RegionObserver
    
    Overrides:
    
    preFlush in class BaseRegionObserver
    
    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
  - preFlushScannerOpen
```
public InternalScanner preFlushScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c,
                                           Store store,
                                           KeyValueScanner memstoreScanner,
                                           InternalScanner s)
                                    throws IOException
```
    Description copied from interface: RegionObserver
    
    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.
    
    Specified by:
    
    preFlushScannerOpen in interface RegionObserver
    
    Overrides:
    
    preFlushScannerOpen in class BaseRegionObserver
    
    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
  - postFlush
```
public void postFlush(ObserverContext<RegionCoprocessorEnvironment> c,
                      Store store,
                      StoreFile resultFile)
               throws IOException
```
    Description copied from interface: RegionObserver
    
    Called after a Store's memstore is flushed to disk.
    
    Specified by:
    
    postFlush in interface RegionObserver
    
    Overrides:
    
    postFlush in class BaseRegionObserver
    
    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
  - wasFlushed
```
public boolean wasFlushed()
```
  - preSplit
```
public void preSplit(ObserverContext<RegionCoprocessorEnvironment> c)
```
    Description copied from interface: RegionObserver
    
    Called before the region is split.
    
    Specified by:
    
    preSplit in interface RegionObserver
    
    Overrides:
    
    preSplit in class BaseRegionObserver
    
    Parameters:
    
    c - the environment provided by the region server (e.getRegion() returns the parent region)
  - preSplitBeforePONR
```
public void preSplitBeforePONR(ObserverContext<RegionCoprocessorEnvironment> ctx,
                               byte[] splitKey,
                               List<Mutation> metaEntries)
                        throws IOException
```
    Description copied from interface: RegionObserver
    
    This will be called before PONR step as part of split transaction. Calling ObserverContext.bypass() rollback the split
    
    Specified by:
    
    preSplitBeforePONR in interface RegionObserver
    
    Overrides:
    
    preSplitBeforePONR in class BaseRegionObserver
    
    Throws:
    
    IOException
  - preSplitAfterPONR
```
public void preSplitAfterPONR(ObserverContext<RegionCoprocessorEnvironment> ctx)
                       throws IOException
```
    Description copied from interface: RegionObserver
    
    This will be called after PONR step as part of split transaction Calling ObserverContext.bypass() has no effect in this hook.
    
    Specified by:
    
    preSplitAfterPONR in interface RegionObserver
    
    Overrides:
    
    preSplitAfterPONR in class BaseRegionObserver
    
    Throws:
    
    IOException
  - postSplit
```
public void postSplit(ObserverContext<RegionCoprocessorEnvironment> c,
                      Region l,
                      Region r)
```
    Description copied from interface: RegionObserver
    
    Called after the region is split.
    
    Specified by:
    
    postSplit in interface RegionObserver
    
    Overrides:
    
    postSplit in class BaseRegionObserver
    
    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
  - wasSplit
```
public boolean wasSplit()
```
  - preCompactSelection
```
public void preCompactSelection(ObserverContext<RegionCoprocessorEnvironment> c,
                                Store store,
                                List<StoreFile> candidates)
```
    Description copied from interface: RegionObserver
    
    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.
    
    Specified by:
    
    preCompactSelection in interface RegionObserver
    
    Overrides:
    
    preCompactSelection in class BaseRegionObserver
    
    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
  - postCompactSelection
```
public void postCompactSelection(ObserverContext<RegionCoprocessorEnvironment> c,
                                 Store store,
                                 <any> selected)
```
    Description copied from interface: RegionObserver
    
    Called after the StoreFiles to compact have been selected from the available candidates.
    
    Specified by:
    
    postCompactSelection in interface RegionObserver
    
    Overrides:
    
    postCompactSelection in class BaseRegionObserver
    
    Parameters:
    
    c - the environment provided by the region server
    
    store - the store being compacted
    
    selected - the store files selected to compact
  - preCompact
```
public InternalScanner preCompact(ObserverContext<RegionCoprocessorEnvironment> e,
                                  Store store,
                                  InternalScanner scanner,
                                  ScanType scanType)
```
    Description copied from interface: RegionObserver
    Called prior to writing the StoreFiles selected for compaction into a new StoreFile. To override or modify the compaction process, implementing classes have two options:
    - Wrap the provided InternalScanner with a custom implementation that is returned from this method. The custom scanner can then inspect KeyValues from the wrapped scanner, applying its own policy to what gets written.
    - Call ObserverContext.bypass() and provide a custom implementation for writing of new StoreFiles. Note: any implementations bypassing core compaction using this approach must write out new store files themselves or the existing data will no longer be available after compaction.
    Specified by:
    
    preCompact in interface RegionObserver
    
    Overrides:
    
    preCompact in class BaseRegionObserver
    
    Parameters:
    
    e - the environment provided by the region server
    
    store - the store being compacted
    
    scanner - the scanner over existing data used in the store file rewriting
    
    scanType - type of Scan
    
    Returns:
    
    the scanner to use during compaction. Should not be null unless the implementation is writing new store files on its own.
  - preCompactScannerOpen
```
public InternalScanner preCompactScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c,
                                             Store store,
                                             List<? extends KeyValueScanner> scanners,
                                             ScanType scanType,
                                             long earliestPutTs,
                                             InternalScanner s)
                                      throws IOException
```
    Description copied from interface: RegionObserver
    
    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.
    
    Specified by:
    
    preCompactScannerOpen in interface RegionObserver
    
    Overrides:
    
    preCompactScannerOpen in class BaseRegionObserver
    
    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
```
public void postCompact(ObserverContext<RegionCoprocessorEnvironment> e,
                        Store store,
                        StoreFile resultFile)
```
    Description copied from interface: RegionObserver
    
    Called after compaction has completed and the new store file has been moved in to place.
    
    Specified by:
    
    postCompact in interface RegionObserver
    
    Overrides:
    
    postCompact in class BaseRegionObserver
    
    Parameters:
    
    e - the environment provided by the region server
    
    store - the store being compacted
    
    resultFile - the new store file written out during compaction
  - wasCompacted
```
public boolean wasCompacted()
```
  - preScannerOpen
```
public RegionScanner preScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c,
                                    Scan scan,
                                    RegionScanner s)
                             throws IOException
```
    Description copied from interface: RegionObserver
    
    Called before the client opens a new scanner.
    Call CoprocessorEnvironment#bypass to skip default actions
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    
    Specified by:
    
    preScannerOpen in interface RegionObserver
    
    Overrides:
    
    preScannerOpen in class BaseRegionObserver
    
    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
```
public KeyValueScanner preStoreScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c,
                                           Store store,
                                           Scan scan,
                                           NavigableSet<byte[]> targetCols,
                                           KeyValueScanner s)
                                    throws IOException
```
    Description copied from interface: RegionObserver
    
    Called before a store opens a new scanner. This hook is called when a "user" scanner is opened.
    See RegionObserver.preFlushScannerOpen(ObserverContext, Store, KeyValueScanner, InternalScanner) and RegionObserver.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.
    
    Specified by:
    
    preStoreScannerOpen in interface RegionObserver
    
    Overrides:
    
    preStoreScannerOpen in class BaseRegionObserver
    
    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
```
public RegionScanner postScannerOpen(ObserverContext<RegionCoprocessorEnvironment> c,
                                     Scan scan,
                                     RegionScanner s)
                              throws IOException
```
    Description copied from interface: RegionObserver
    
    Called after the client opens a new scanner.
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    
    Specified by:
    
    postScannerOpen in interface RegionObserver
    
    Overrides:
    
    postScannerOpen in class BaseRegionObserver
    
    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
```
public boolean preScannerNext(ObserverContext<RegionCoprocessorEnvironment> c,
                              InternalScanner s,
                              List<Result> results,
                              int limit,
                              boolean hasMore)
                       throws IOException
```
    Description copied from interface: RegionObserver
    
    Called before the client asks for the next row on a scanner.
    Call CoprocessorEnvironment#bypass to skip default actions
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    
    Specified by:
    
    preScannerNext in interface RegionObserver
    
    Overrides:
    
    preScannerNext in class BaseRegionObserver
    
    Parameters:
    
    c - the environment provided by the region server
    
    s - the scanner
    
    results - 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
    
    hasMore - the 'has more' indication
    
    Returns:
    
    'has more' indication that should be sent to client
    
    Throws:
    
    IOException - if an error occurred on the coprocessor
  - postScannerNext
```
public boolean postScannerNext(ObserverContext<RegionCoprocessorEnvironment> c,
                               InternalScanner s,
                               List<Result> results,
                               int limit,
                               boolean hasMore)
                        throws IOException
```
    Description copied from interface: RegionObserver
    
    Called after the client asks for the next row on a scanner.
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    
    Specified by:
    
    postScannerNext in interface RegionObserver
    
    Overrides:
    
    postScannerNext in class BaseRegionObserver
    
    Parameters:
    
    c - the environment provided by the region server
    
    s - the scanner
    
    results - the result to return to the client, can be modified
    
    limit - the maximum number of results to return
    
    hasMore - the 'has more' indication
    
    Returns:
    
    'has more' indication that should be sent to client
    
    Throws:
    
    IOException - if an error occurred on the coprocessor
  - preScannerClose
```
public void preScannerClose(ObserverContext<RegionCoprocessorEnvironment> c,
                            InternalScanner s)
                     throws IOException
```
    Description copied from interface: RegionObserver
    
    Called before the client closes a scanner.
    Call CoprocessorEnvironment#bypass to skip default actions
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    
    Specified by:
    
    preScannerClose in interface RegionObserver
    
    Overrides:
    
    preScannerClose in class BaseRegionObserver
    
    Parameters:
    
    c - the environment provided by the region server
    
    s - the scanner
    
    Throws:
    
    IOException - if an error occurred on the coprocessor
  - postScannerClose
```
public void postScannerClose(ObserverContext<RegionCoprocessorEnvironment> c,
                             InternalScanner s)
                      throws IOException
```
    Description copied from interface: RegionObserver
    
    Called after the client closes a scanner.
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    
    Specified by:
    
    postScannerClose in interface RegionObserver
    
    Overrides:
    
    postScannerClose in class BaseRegionObserver
    
    Parameters:
    
    c - the environment provided by the region server
    
    s - the scanner
    
    Throws:
    
    IOException - if an error occurred on the coprocessor
  - preGetOp
```
public void preGetOp(ObserverContext<RegionCoprocessorEnvironment> c,
                     Get get,
                     List<Cell> results)
              throws IOException
```
    Description copied from interface: RegionObserver
    
    Called before the client performs a Get
    Call CoprocessorEnvironment#bypass to skip default actions
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    
    Specified by:
    
    preGetOp in interface RegionObserver
    
    Overrides:
    
    preGetOp in class BaseRegionObserver
    
    Parameters:
    
    c - the environment provided by the region server
    
    get - the Get request
    
    results - 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
  - postGetOp
```
public void postGetOp(ObserverContext<RegionCoprocessorEnvironment> c,
                      Get get,
                      List<Cell> results)
```
    Description copied from interface: RegionObserver
    
    Called after the client performs a Get
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    
    Specified by:
    
    postGetOp in interface RegionObserver
    
    Overrides:
    
    postGetOp in class BaseRegionObserver
    
    Parameters:
    
    c - the environment provided by the region server
    
    get - the Get request
    
    results - the result to return to the client, modify as necessary
  - prePut
```
public void prePut(ObserverContext<RegionCoprocessorEnvironment> c,
                   Put put,
                   WALEdit edit,
                   Durability durability)
            throws IOException
```
    Description copied from interface: RegionObserver
    
    Called before the client stores a value.
    Call CoprocessorEnvironment#bypass to skip default actions
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    
    Specified by:
    
    prePut in interface RegionObserver
    
    Overrides:
    
    prePut in class BaseRegionObserver
    
    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
```
public void postPut(ObserverContext<RegionCoprocessorEnvironment> c,
                    Put put,
                    WALEdit edit,
                    Durability durability)
             throws IOException
```
    Description copied from interface: RegionObserver
    
    Called after the client stores a value.
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    
    Specified by:
    
    postPut in interface RegionObserver
    
    Overrides:
    
    postPut in class BaseRegionObserver
    
    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
```
public void preDelete(ObserverContext<RegionCoprocessorEnvironment> c,
                      Delete delete,
                      WALEdit edit,
                      Durability durability)
               throws IOException
```
    Description copied from interface: RegionObserver
    
    Called before the client deletes a value.
    Call CoprocessorEnvironment#bypass to skip default actions
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    
    Specified by:
    
    preDelete in interface RegionObserver
    
    Overrides:
    
    preDelete in class BaseRegionObserver
    
    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
```
public void prePrepareTimeStampForDeleteVersion(ObserverContext<RegionCoprocessorEnvironment> e,
                                                Mutation delete,
                                                Cell cell,
                                                byte[] byteNow,
                                                Get get)
                                         throws IOException
```
    Description copied from interface: RegionObserver
    
    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
    
    Specified by:
    
    prePrepareTimeStampForDeleteVersion in interface RegionObserver
    
    Overrides:
    
    prePrepareTimeStampForDeleteVersion in class BaseRegionObserver
    
    Parameters:
    
    e - the environment provided by the region server
    
    delete - - 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
```
public void postDelete(ObserverContext<RegionCoprocessorEnvironment> c,
                       Delete delete,
                       WALEdit edit,
                       Durability durability)
                throws IOException
```
    Description copied from interface: RegionObserver
    
    Called after the client deletes a value.
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    
    Specified by:
    
    postDelete in interface RegionObserver
    
    Overrides:
    
    postDelete in class BaseRegionObserver
    
    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
```
public void preBatchMutate(ObserverContext<RegionCoprocessorEnvironment> c,
                           MiniBatchOperationInProgress<Mutation> miniBatchOp)
                    throws IOException
```
    Description copied from interface: RegionObserver
    
    This will be called for every batch mutation operation happening at the server. This will be called after acquiring the locks on the mutating rows and after applying the proper timestamp for each Mutation at the server. The batch may contain Put/Delete. By setting OperationStatus of Mutations (MiniBatchOperationInProgress.setOperationStatus(int, OperationStatus)), RegionObserver can make Region to skip these Mutations.
    
    Specified by:
    
    preBatchMutate in interface RegionObserver
    
    Overrides:
    
    preBatchMutate in class BaseRegionObserver
    
    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
```
public void postBatchMutate(ObserverContext<RegionCoprocessorEnvironment> c,
                            MiniBatchOperationInProgress<Mutation> miniBatchOp)
                     throws IOException
```
    Description copied from interface: RegionObserver
    
    This will be called after applying a batch of Mutations on a region. The Mutations are added to memstore and WAL.
    
    Specified by:
    
    postBatchMutate in interface RegionObserver
    
    Overrides:
    
    postBatchMutate in class BaseRegionObserver
    
    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
```
public void postStartRegionOperation(ObserverContext<RegionCoprocessorEnvironment> ctx,
                                     Region.Operation op)
                              throws IOException
```
    Description copied from interface: RegionObserver
    
    This will be called for region operations where read lock is acquired in Region.startRegionOperation().
    
    Specified by:
    
    postStartRegionOperation in interface RegionObserver
    
    Overrides:
    
    postStartRegionOperation in class BaseRegionObserver
    
    op - The operation is about to be taken on the region
    
    Throws:
    
    IOException
  - postCloseRegionOperation
```
public void postCloseRegionOperation(ObserverContext<RegionCoprocessorEnvironment> ctx,
                                     Region.Operation op)
                              throws IOException
```
    Description copied from interface: RegionObserver
    
    Called after releasing read lock in Region.closeRegionOperation().
    
    Specified by:
    
    postCloseRegionOperation in interface RegionObserver
    
    Overrides:
    
    postCloseRegionOperation in class BaseRegionObserver
    
    Throws:
    
    IOException
  - postBatchMutateIndispensably
```
public void postBatchMutateIndispensably(ObserverContext<RegionCoprocessorEnvironment> ctx,
                                         MiniBatchOperationInProgress<Mutation> miniBatchOp,
                                         boolean success)
                                  throws IOException
```
    Description copied from interface: RegionObserver
    
    Called after the completion of batch put/delete and will be called even if the batch operation fails
    
    Specified by:
    
    postBatchMutateIndispensably in interface RegionObserver
    
    Overrides:
    
    postBatchMutateIndispensably in class BaseRegionObserver
    
    success - true if batch operation is successful otherwise false.
    
    Throws:
    
    IOException
  - preGetClosestRowBefore
```
public void preGetClosestRowBefore(ObserverContext<RegionCoprocessorEnvironment> c,
                                   byte[] row,
                                   byte[] family,
                                   Result result)
                            throws IOException
```
    Description copied from interface: RegionObserver
    
    Called before a client makes a GetClosestRowBefore request.
    Call CoprocessorEnvironment#bypass to skip default actions
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    
    Specified by:
    
    preGetClosestRowBefore in interface RegionObserver
    
    Overrides:
    
    preGetClosestRowBefore in class BaseRegionObserver
    
    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
```
public void postGetClosestRowBefore(ObserverContext<RegionCoprocessorEnvironment> c,
                                    byte[] row,
                                    byte[] family,
                                    Result result)
                             throws IOException
```
    Description copied from interface: RegionObserver
    
    Called after a client makes a GetClosestRowBefore request.
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    
    Specified by:
    
    postGetClosestRowBefore in interface RegionObserver
    
    Overrides:
    
    postGetClosestRowBefore in class BaseRegionObserver
    
    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
  - preIncrement
```
public Result preIncrement(ObserverContext<RegionCoprocessorEnvironment> c,
                           Increment increment)
                    throws IOException
```
    Description copied from interface: RegionObserver
    
    Called before Increment.
    Call CoprocessorEnvironment#bypass to skip default actions
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    
    Specified by:
    
    preIncrement in interface RegionObserver
    
    Overrides:
    
    preIncrement in class BaseRegionObserver
    
    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
```
public Result preIncrementAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> e,
                                       Increment increment)
                                throws IOException
```
    Description copied from interface: RegionObserver
    
    Called before Increment but after acquiring rowlock.
    Note: Caution to be taken for not doing any long time operation in this hook. Row will be locked for longer time. Trying to acquire lock on another row, within this, can lead to potential deadlock.
    Call CoprocessorEnvironment#bypass to skip default actions
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    
    Specified by:
    
    preIncrementAfterRowLock in interface RegionObserver
    
    Overrides:
    
    preIncrementAfterRowLock in class BaseRegionObserver
    
    Parameters:
    
    e - 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
```
public Result postIncrement(ObserverContext<RegionCoprocessorEnvironment> c,
                            Increment increment,
                            Result result)
                     throws IOException
```
    Description copied from interface: RegionObserver
    
    Called after increment
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    
    Specified by:
    
    postIncrement in interface RegionObserver
    
    Overrides:
    
    postIncrement in class BaseRegionObserver
    
    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
  - preCheckAndPut
```
public boolean preCheckAndPut(ObserverContext<RegionCoprocessorEnvironment> e,
                              byte[] row,
                              byte[] family,
                              byte[] qualifier,
                              CompareFilter.CompareOp compareOp,
                              ByteArrayComparable comparator,
                              Put put,
                              boolean result)
                       throws IOException
```
    Description copied from interface: RegionObserver
    
    Called before checkAndPut.
    Call CoprocessorEnvironment#bypass to skip default actions
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    
    Specified by:
    
    preCheckAndPut in interface RegionObserver
    
    Overrides:
    
    preCheckAndPut in class BaseRegionObserver
    
    Parameters:
    
    e - 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
    
    Returns:
    
    the return value to return to client if bypassing default processing
    
    Throws:
    
    IOException - if an error occurred on the coprocessor
  - preCheckAndPutAfterRowLock
```
public boolean preCheckAndPutAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> e,
                                          byte[] row,
                                          byte[] family,
                                          byte[] qualifier,
                                          CompareFilter.CompareOp compareOp,
                                          ByteArrayComparable comparator,
                                          Put put,
                                          boolean result)
                                   throws IOException
```
    Description copied from interface: RegionObserver
    
    Called before checkAndPut but after acquiring rowlock.
    Note: Caution to be taken for not doing any long time operation in this hook. Row will be locked for longer time. Trying to acquire lock on another row, within this, can lead to potential deadlock.
    Call CoprocessorEnvironment#bypass to skip default actions
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    
    Specified by:
    
    preCheckAndPutAfterRowLock in interface RegionObserver
    
    Overrides:
    
    preCheckAndPutAfterRowLock in class BaseRegionObserver
    
    Parameters:
    
    e - 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
    
    Returns:
    
    the return value to return to client if bypassing default processing
    
    Throws:
    
    IOException - if an error occurred on the coprocessor
  - postCheckAndPut
```
public boolean postCheckAndPut(ObserverContext<RegionCoprocessorEnvironment> e,
                               byte[] row,
                               byte[] family,
                               byte[] qualifier,
                               CompareFilter.CompareOp compareOp,
                               ByteArrayComparable comparator,
                               Put put,
                               boolean result)
                        throws IOException
```
    Description copied from interface: RegionObserver
    
    Called after checkAndPut
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    
    Specified by:
    
    postCheckAndPut in interface RegionObserver
    
    Overrides:
    
    postCheckAndPut in class BaseRegionObserver
    
    Parameters:
    
    e - 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
```
public boolean preCheckAndDelete(ObserverContext<RegionCoprocessorEnvironment> e,
                                 byte[] row,
                                 byte[] family,
                                 byte[] qualifier,
                                 CompareFilter.CompareOp compareOp,
                                 ByteArrayComparable comparator,
                                 Delete delete,
                                 boolean result)
                          throws IOException
```
    Description copied from interface: RegionObserver
    
    Called before checkAndDelete.
    Call CoprocessorEnvironment#bypass to skip default actions
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    
    Specified by:
    
    preCheckAndDelete in interface RegionObserver
    
    Overrides:
    
    preCheckAndDelete in class BaseRegionObserver
    
    Parameters:
    
    e - 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
    
    Returns:
    
    the value to return to client if bypassing default processing
    
    Throws:
    
    IOException - if an error occurred on the coprocessor
  - preCheckAndDeleteAfterRowLock
```
public boolean preCheckAndDeleteAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> e,
                                             byte[] row,
                                             byte[] family,
                                             byte[] qualifier,
                                             CompareFilter.CompareOp compareOp,
                                             ByteArrayComparable comparator,
                                             Delete delete,
                                             boolean result)
                                      throws IOException
```
    Description copied from interface: RegionObserver
    
    Called before checkAndDelete but after acquiring rowock.
    Note: Caution to be taken for not doing any long time operation in this hook. Row will be locked for longer time. Trying to acquire lock on another row, within this, can lead to potential deadlock.
    Call CoprocessorEnvironment#bypass to skip default actions
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    
    Specified by:
    
    preCheckAndDeleteAfterRowLock in interface RegionObserver
    
    Overrides:
    
    preCheckAndDeleteAfterRowLock in class BaseRegionObserver
    
    Parameters:
    
    e - 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
    
    Returns:
    
    the value to return to client if bypassing default processing
    
    Throws:
    
    IOException - if an error occurred on the coprocessor
  - postCheckAndDelete
```
public boolean postCheckAndDelete(ObserverContext<RegionCoprocessorEnvironment> e,
                                  byte[] row,
                                  byte[] family,
                                  byte[] qualifier,
                                  CompareFilter.CompareOp compareOp,
                                  ByteArrayComparable comparator,
                                  Delete delete,
                                  boolean result)
                           throws IOException
```
    Description copied from interface: RegionObserver
    
    Called after checkAndDelete
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    
    Specified by:
    
    postCheckAndDelete in interface RegionObserver
    
    Overrides:
    
    postCheckAndDelete in class BaseRegionObserver
    
    Parameters:
    
    e - 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
  - preAppendAfterRowLock
```
public Result preAppendAfterRowLock(ObserverContext<RegionCoprocessorEnvironment> e,
                                    Append append)
                             throws IOException
```
    Description copied from interface: RegionObserver
    
    Called before Append but after acquiring rowlock.
    Note: Caution to be taken for not doing any long time operation in this hook. Row will be locked for longer time. Trying to acquire lock on another row, within this, can lead to potential deadlock.
    Call CoprocessorEnvironment#bypass to skip default actions
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    
    Specified by:
    
    preAppendAfterRowLock in interface RegionObserver
    
    Overrides:
    
    preAppendAfterRowLock in class BaseRegionObserver
    
    Parameters:
    
    e - 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
  - preAppend
```
public Result preAppend(ObserverContext<RegionCoprocessorEnvironment> e,
                        Append append)
                 throws IOException
```
    Description copied from interface: RegionObserver
    
    Called before Append.
    Call CoprocessorEnvironment#bypass to skip default actions
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    
    Specified by:
    
    preAppend in interface RegionObserver
    
    Overrides:
    
    preAppend in class BaseRegionObserver
    
    Parameters:
    
    e - 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
```
public Result postAppend(ObserverContext<RegionCoprocessorEnvironment> e,
                         Append append,
                         Result result)
                  throws IOException
```
    Description copied from interface: RegionObserver
    
    Called after Append
    Call CoprocessorEnvironment#complete to skip any subsequent chained coprocessors
    
    Specified by:
    
    postAppend in interface RegionObserver
    
    Overrides:
    
    postAppend in class BaseRegionObserver
    
    Parameters:
    
    e - 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
  - preBulkLoadHFile
```
public void preBulkLoadHFile(ObserverContext<RegionCoprocessorEnvironment> ctx,
                             List<Pair<byte[],String>> familyPaths)
                      throws IOException
```
    Description copied from interface: RegionObserver
    
    Called before bulkLoadHFile. Users can create a StoreFile instance to access the contents of a HFile.
    
    Specified by:
    
    preBulkLoadHFile in interface RegionObserver
    
    Overrides:
    
    preBulkLoadHFile in class BaseRegionObserver
    
    familyPaths - pairs of { CF, HFile path } submitted for bulk load. Adding or removing from this list will add or remove HFiles to be bulk loaded.
    
    Throws:
    
    IOException
  - postBulkLoadHFile
```
public boolean postBulkLoadHFile(ObserverContext<RegionCoprocessorEnvironment> ctx,
                                 List<Pair<byte[],String>> familyPaths,
                                 Map<byte[],List<Path>> map,
                                 boolean hasLoaded)
                          throws IOException
```
    Description copied from interface: RegionObserver
    
    Called after bulkLoadHFile.
    
    Specified by:
    
    postBulkLoadHFile in interface RegionObserver
    
    Overrides:
    
    postBulkLoadHFile in class BaseRegionObserver
    
    familyPaths - pairs of { CF, HFile path } submitted for bulk load
    
    map - Map of CF to List of file paths for the final loaded files
    
    hasLoaded - whether the bulkLoad was successful
    
    Returns:
    
    the new value of hasLoaded
    
    Throws:
    
    IOException
  - preWALRestore
```
public void preWALRestore(ObserverContext<? extends RegionCoprocessorEnvironment> env,
                          HRegionInfo info,
                          WALKey logKey,
                          WALEdit logEdit)
                   throws IOException
```
    Description copied from class: BaseRegionObserver
    
    Implementers should override this version of the method and leave the deprecated one as-is.
    
    Specified by:
    
    preWALRestore in interface RegionObserver
    
    Overrides:
    
    preWALRestore in class BaseRegionObserver
    
    Throws:
    
    IOException
  - preWALRestore
```
public void preWALRestore(ObserverContext<RegionCoprocessorEnvironment> env,
                          HRegionInfo info,
                          HLogKey logKey,
                          WALEdit logEdit)
                   throws IOException
```
    Description copied from interface: RegionObserver
    
    Called before a WALEdit replayed for this region. This method is left in place to maintain binary compatibility with older RegionObservers. If an implementation directly overrides RegionObserver.preWALRestore(ObserverContext, HRegionInfo, WALKey, WALEdit) then this version won't be called at all, barring problems with the Security Manager. To work correctly in the presence of a strict Security Manager, or in the case of an implementation that relies on a parent class to implement preWALRestore, you should implement this method as a call to the non-deprecated version. Users of this method will see all edits that can be treated as HLogKey. If there are edits that can't be treated as HLogKey they won't be offered to coprocessors that rely on this method. If a coprocessor gets skipped because of this mechanism, a log message at ERROR will be generated per coprocessor on the logger for CoprocessorHost once per classloader.
    
    Specified by:
    
    preWALRestore in interface RegionObserver
    
    Overrides:
    
    preWALRestore in class BaseRegionObserver
    
    Throws:
    
    IOException
  - postWALRestore
```
public void postWALRestore(ObserverContext<? extends RegionCoprocessorEnvironment> env,
                           HRegionInfo info,
                           WALKey logKey,
                           WALEdit logEdit)
                    throws IOException
```
    Description copied from class: BaseRegionObserver
    
    Implementers should override this version of the method and leave the deprecated one as-is.
    
    Specified by:
    
    postWALRestore in interface RegionObserver
    
    Overrides:
    
    postWALRestore in class BaseRegionObserver
    
    Throws:
    
    IOException
  - postWALRestore
```
public void postWALRestore(ObserverContext<RegionCoprocessorEnvironment> env,
                           HRegionInfo info,
                           HLogKey logKey,
                           WALEdit logEdit)
                    throws IOException
```
    Description copied from interface: RegionObserver
    
    Called after a WALEdit replayed for this region. This method is left in place to maintain binary compatibility with older RegionObservers. If an implementation directly overrides RegionObserver.postWALRestore(ObserverContext, HRegionInfo, WALKey, WALEdit) then this version won't be called at all, barring problems with the Security Manager. To work correctly in the presence of a strict Security Manager, or in the case of an implementation that relies on a parent class to implement preWALRestore, you should implement this method as a call to the non-deprecated version. Users of this method will see all edits that can be treated as HLogKey. If there are edits that can't be treated as HLogKey they won't be offered to coprocessors that rely on this method. If a coprocessor gets skipped because of this mechanism, a log message at ERROR will be generated per coprocessor on the logger for CoprocessorHost once per classloader.
    
    Specified by:
    
    postWALRestore in interface RegionObserver
    
    Overrides:
    
    postWALRestore in class BaseRegionObserver
    
    Throws:
    
    IOException
  - preStoreFileReaderOpen
```
public StoreFile.Reader preStoreFileReaderOpen(ObserverContext<RegionCoprocessorEnvironment> ctx,
                                               FileSystem fs,
                                               Path p,
                                               FSDataInputStreamWrapper in,
                                               long size,
                                               CacheConfig cacheConf,
                                               Reference r,
                                               StoreFile.Reader reader)
                                        throws IOException
```
    Description copied from interface: RegionObserver
    
    Called before creation of Reader for a store file. Calling ObserverContext.bypass() has no effect in this hook.
    
    Specified by:
    
    preStoreFileReaderOpen in interface RegionObserver
    
    Overrides:
    
    preStoreFileReaderOpen in class BaseRegionObserver
    
    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
    
    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
```
public StoreFile.Reader postStoreFileReaderOpen(ObserverContext<RegionCoprocessorEnvironment> ctx,
                                                FileSystem fs,
                                                Path p,
                                                FSDataInputStreamWrapper in,
                                                long size,
                                                CacheConfig cacheConf,
                                                Reference r,
                                                StoreFile.Reader reader)
                                         throws IOException
```
    Description copied from interface: RegionObserver
    
    Called after the creation of Reader for a store file.
    
    Specified by:
    
    postStoreFileReaderOpen in interface RegionObserver
    
    Overrides:
    
    postStoreFileReaderOpen in class BaseRegionObserver
    
    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
    
    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
  - hadPreGet
```
public boolean hadPreGet()
```
  - hadPostGet
```
public boolean hadPostGet()
```
  - hadPrePut
```
public boolean hadPrePut()
```
  - hadPostPut
```
public boolean hadPostPut()
```
  - hadPreBatchMutate
```
public boolean hadPreBatchMutate()
```
  - hadPostBatchMutate
```
public boolean hadPostBatchMutate()
```
  - hadPostBatchMutateIndispensably
```
public boolean hadPostBatchMutateIndispensably()
```
  - hadPostStartRegionOperation
```
public boolean hadPostStartRegionOperation()
```
  - hadPostCloseRegionOperation
```
public boolean hadPostCloseRegionOperation()
```
  - hadDelete
```
public boolean hadDelete()
```
  - getCtPostStartRegionOperation
```
public int getCtPostStartRegionOperation()
```
  - getCtPostCloseRegionOperation
```
public int getCtPostCloseRegionOperation()
```
  - hadPreCheckAndPut
```
public boolean hadPreCheckAndPut()
```
  - hadPreCheckAndPutAfterRowLock
```
public boolean hadPreCheckAndPutAfterRowLock()
```
  - hadPostCheckAndPut
```
public boolean hadPostCheckAndPut()
```
  - hadPreCheckAndDelete
```
public boolean hadPreCheckAndDelete()
```
  - hadPreCheckAndDeleteAfterRowLock
```
public boolean hadPreCheckAndDeleteAfterRowLock()
```
  - hadPostCheckAndDelete
```
public boolean hadPostCheckAndDelete()
```
  - hadPreIncrement
```
public boolean hadPreIncrement()
```
  - hadPreIncrementAfterRowLock
```
public boolean hadPreIncrementAfterRowLock()
```
  - hadPostIncrement
```
public boolean hadPostIncrement()
```
  - hadPreAppend
```
public boolean hadPreAppend()
```
  - hadPreAppendAfterRowLock
```
public boolean hadPreAppendAfterRowLock()
```
  - hadPostAppend
```
public boolean hadPostAppend()
```
  - hadPrePreparedDeleteTS
```
public boolean hadPrePreparedDeleteTS()
```
  - hadPreWALRestore
```
public boolean hadPreWALRestore()
```
  - hadPostWALRestore
```
public boolean hadPostWALRestore()
```
  - wasScannerNextCalled
```
public boolean wasScannerNextCalled()
```
  - wasScannerCloseCalled
```
public boolean wasScannerCloseCalled()
```
  - wasScannerOpenCalled
```
public boolean wasScannerOpenCalled()
```
  - hadDeleted
```
public boolean hadDeleted()
```
  - hadPostBulkLoadHFile
```
public boolean hadPostBulkLoadHFile()
```
  - hadPreBulkLoadHFile
```
public boolean hadPreBulkLoadHFile()
```
  - getCtBeforeDelete
```
public int getCtBeforeDelete()
```
  - getCtPreOpen
```
public int getCtPreOpen()
```
  - getCtPostOpen
```
public int getCtPostOpen()
```
  - getCtPreClose
```
public int getCtPreClose()
```
  - getCtPostClose
```
public int getCtPostClose()
```
  - getCtPreFlush
```
public int getCtPreFlush()
```
  - getCtPreFlushScannerOpen
```
public int getCtPreFlushScannerOpen()
```
  - getCtPostFlush
```
public int getCtPostFlush()
```
  - getCtPreSplit
```
public int getCtPreSplit()
```
  - getCtPreSplitBeforePONR
```
public int getCtPreSplitBeforePONR()
```
  - getCtPreSplitAfterPONR
```
public int getCtPreSplitAfterPONR()
```
  - getCtPostSplit
```
public int getCtPostSplit()
```
  - getCtPreCompactSelect
```
public int getCtPreCompactSelect()
```
  - getCtPostCompactSelect
```
public int getCtPostCompactSelect()
```
  - getCtPreCompactScanner
```
public int getCtPreCompactScanner()
```
  - getCtPreCompact
```
public int getCtPreCompact()
```
  - getCtPostCompact
```
public int getCtPostCompact()
```
  - getCtPreGet
```
public int getCtPreGet()
```
  - getCtPostGet
```
public int getCtPostGet()
```
  - getCtPrePut
```
public int getCtPrePut()
```
  - getCtPostPut
```
public int getCtPostPut()
```
  - getCtPreDeleted
```
public int getCtPreDeleted()
```
  - getCtPostDeleted
```
public int getCtPostDeleted()
```
  - getCtPreGetClosestRowBefore
```
public int getCtPreGetClosestRowBefore()
```
  - getCtPostGetClosestRowBefore
```
public int getCtPostGetClosestRowBefore()
```
  - getCtPreIncrement
```
public int getCtPreIncrement()
```
  - getCtPostIncrement
```
public int getCtPostIncrement()
```
  - getCtPreWALRestore
```
public int getCtPreWALRestore()
```
  - getCtPostWALRestore
```
public int getCtPostWALRestore()
```
  - getCtPreWALRestoreDeprecated
```
public int getCtPreWALRestoreDeprecated()
```
  - getCtPostWALRestoreDeprecated
```
public int getCtPostWALRestoreDeprecated()
```
  - wasStoreFileReaderOpenCalled
```
public boolean wasStoreFileReaderOpenCalled()
```

Class SimpleRegionObserver

Nested Class Summary

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

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

Field Summary

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

Constructor Summary

Method Summary

Methods inherited from class org.apache.hadoop.hbase.coprocessor.BaseRegionObserver

Methods inherited from class java.lang.Object

Constructor Detail

SimpleRegionObserver

Method Detail

setThrowOnPostFlush

start

preOpen

postOpen

wasOpened

preClose

postClose

wasClosed

preFlush

preFlushScannerOpen

postFlush

wasFlushed

preSplit

preSplitBeforePONR

preSplitAfterPONR

postSplit

wasSplit

preCompactSelection

postCompactSelection

preCompact

preCompactScannerOpen

postCompact

wasCompacted

preScannerOpen

preStoreScannerOpen

postScannerOpen

preScannerNext

postScannerNext

preScannerClose

postScannerClose

preGetOp

postGetOp

prePut

postPut

preDelete

prePrepareTimeStampForDeleteVersion

postDelete

preBatchMutate

postBatchMutate

postStartRegionOperation

postCloseRegionOperation

postBatchMutateIndispensably

preGetClosestRowBefore

postGetClosestRowBefore

preIncrement

preIncrementAfterRowLock

postIncrement

preCheckAndPut

preCheckAndPutAfterRowLock

postCheckAndPut

preCheckAndDelete

preCheckAndDeleteAfterRowLock

postCheckAndDelete

preAppendAfterRowLock

preAppend

postAppend

preBulkLoadHFile

postBulkLoadHFile

preWALRestore

preWALRestore

postWALRestore

postWALRestore

preStoreFileReaderOpen

postStoreFileReaderOpen

hadPreGet

hadPostGet

hadPrePut