org.apache.hadoop.hbase.regionserver

Class RegionCoprocessorHost

java.lang.Object

org.apache.hadoop.hbase.coprocessor.CoprocessorHost<org.apache.hadoop.hbase.regionserver.RegionCoprocessorHost.RegionEnvironment>

org.apache.hadoop.hbase.regionserver.RegionCoprocessorHost

@InterfaceAudience.LimitedPrivate(value="Coprocesssor")
 @InterfaceStability.Evolving
public class RegionCoprocessorHost
extends CoprocessorHost<org.apache.hadoop.hbase.regionserver.RegionCoprocessorHost.RegionEnvironment>

Implements the coprocessor environment and runtime support for coprocessors loaded within a Region.

Nested Class Summary

Nested classes/interfaces inherited from class org.apache.hadoop.hbase.coprocessor.CoprocessorHost

CoprocessorHost.Environment

Field Summary

Fields inherited from class org.apache.hadoop.hbase.coprocessor.CoprocessorHost

ABORT_ON_ERROR_KEY, abortable, conf, coprocessors, COPROCESSORS_ENABLED_CONF_KEY, DEFAULT_ABORT_ON_ERROR, DEFAULT_COPROCESSORS_ENABLED, DEFAULT_USER_COPROCESSORS_ENABLED, loadSequence, MASTER_COPROCESSOR_CONF_KEY, pathPrefix, REGION_COPROCESSOR_CONF_KEY, REGIONSERVER_COPROCESSOR_CONF_KEY, USER_COPROCESSORS_ENABLED_CONF_KEY, USER_REGION_COPROCESSOR_CONF_KEY, WAL_COPROCESSOR_CONF_KEY

Constructor Summary

Constructors

Constructor and Description
RegionCoprocessorHost(Region region, RegionServerServices rsServices, org.apache.hadoop.conf.Configuration conf) Constructor

Method Summary

Modifier and Type	Method and Description
org.apache.hadoop.hbase.regionserver.RegionCoprocessorHost.RegionEnvironment	createEnvironment(Class<?> implClass, Coprocessor instance, int priority, int seq, org.apache.hadoop.conf.Configuration conf) Called when a new Coprocessor class is loaded
Result	postAppend(Append append, Result result)
void	postBatchMutate(MiniBatchOperationInProgress<Mutation> miniBatchOp)
void	postBatchMutateIndispensably(MiniBatchOperationInProgress<Mutation> miniBatchOp, boolean success)
boolean	postBulkLoadHFile(List<Pair<byte[],String>> familyPaths, Map<byte[],List<org.apache.hadoop.fs.Path>> map, boolean hasLoaded)
boolean	postCheckAndDelete(byte[] row, byte[] family, byte[] qualifier, CompareOperator op, ByteArrayComparable comparator, Delete delete, boolean result)
boolean	postCheckAndPut(byte[] row, byte[] family, byte[] qualifier, CompareOperator op, ByteArrayComparable comparator, Put put, boolean result)
void	postClose(boolean abortRequested) Invoked after a region is closed
void	postCloseRegionOperation(Region.Operation op)
void	postCommitStoreFile(byte[] family, org.apache.hadoop.fs.Path srcPath, org.apache.hadoop.fs.Path dstPath)
void	postCompact(Store store, StoreFile resultFile, CompactionLifeCycleTracker tracker, User user) Called after the store compaction has completed.
void	postCompactSelection(Store store, org.apache.hadoop.hbase.shaded.com.google.common.collect.ImmutableList<StoreFile> selected, CompactionLifeCycleTracker tracker, User user) Called after the StoreFiles to be compacted have been selected from the available candidates.
void	postDelete(Delete delete, WALEdit edit, Durability durability)
void	postEndpointInvocation(com.google.protobuf.Service service, String methodName, com.google.protobuf.Message request, com.google.protobuf.Message.Builder responseBuilder)
boolean	postExists(Get get, boolean exists)
void	postFlush() Invoked after a memstore flush
void	postFlush(Store store, StoreFile storeFile) Invoked after a memstore flush
void	postGet(Get get, List<Cell> results)
Result	postIncrement(Increment increment, Result result)
DeleteTracker	postInstantiateDeleteTracker(DeleteTracker tracker)
void	postLogReplay() Invoked after log replay on region
Cell	postMutationBeforeWAL(RegionObserver.MutationType opType, Mutation mutation, Cell oldCell, Cell newCell)
void	postOpen() Invoked after a region open
void	postPut(Put put, WALEdit edit, Durability durability)
void	postReplayWALs(HRegionInfo info, org.apache.hadoop.fs.Path edits)
void	postScannerClose(InternalScanner s)
boolean	postScannerFilterRow(InternalScanner s, Cell curRowCell) This will be called by the scan flow when the current scanned row is being filtered out by the filter.
boolean	postScannerNext(InternalScanner s, List<Result> results, int limit, boolean hasMore)
RegionScanner	postScannerOpen(Scan scan, RegionScanner s)
void	postStartRegionOperation(Region.Operation op)
StoreFileReader	postStoreFileReaderOpen(org.apache.hadoop.fs.FileSystem fs, org.apache.hadoop.fs.Path p, FSDataInputStreamWrapper in, long size, CacheConfig cacheConf, Reference r, StoreFileReader reader)
void	postWALRestore(HRegionInfo info, WALKey logKey, WALEdit logEdit)
Result	preAppend(Append append)
Result	preAppendAfterRowLock(Append append)
boolean	preBatchMutate(MiniBatchOperationInProgress<Mutation> miniBatchOp)
boolean	preBulkLoadHFile(List<Pair<byte[],String>> familyPaths)
Boolean	preCheckAndDelete(byte[] row, byte[] family, byte[] qualifier, CompareOperator op, ByteArrayComparable comparator, Delete delete)
Boolean	preCheckAndDeleteAfterRowLock(byte[] row, byte[] family, byte[] qualifier, CompareOperator op, ByteArrayComparable comparator, Delete delete)
Boolean	preCheckAndPut(byte[] row, byte[] family, byte[] qualifier, CompareOperator op, ByteArrayComparable comparator, Put put)
Boolean	preCheckAndPutAfterRowLock(byte[] row, byte[] family, byte[] qualifier, CompareOperator op, ByteArrayComparable comparator, Put put)
void	preClose(boolean abortRequested) Invoked before a region is closed
boolean	preCommitStoreFile(byte[] family, List<Pair<org.apache.hadoop.fs.Path,org.apache.hadoop.fs.Path>> pairs)
InternalScanner	preCompact(Store store, InternalScanner scanner, ScanType scanType, CompactionLifeCycleTracker tracker, User user) Called prior to rewriting the store files selected for compaction
InternalScanner	preCompactScannerOpen(Store store, List<StoreFileScanner> scanners, ScanType scanType, long earliestPutTs, CompactionLifeCycleTracker tracker, User user, long readPoint) See RegionObserver.preCompactScannerOpen(ObserverContext, Store, List, ScanType, long, InternalScanner, CompactionLifeCycleTracker, long)
boolean	preCompactSelection(Store store, List<StoreFile> candidates, CompactionLifeCycleTracker tracker, User user) Called prior to selecting the StoreFiles for compaction from the list of currently available candidates.
boolean	preDelete(Delete delete, WALEdit edit, Durability durability)
com.google.protobuf.Message	preEndpointInvocation(com.google.protobuf.Service service, String methodName, com.google.protobuf.Message request)
Boolean	preExists(Get get)
void	preFlush() Invoked before a memstore flush
InternalScanner	preFlush(Store store, InternalScanner scanner) Invoked before a memstore flush
InternalScanner	preFlushScannerOpen(Store store, List<KeyValueScanner> scanners, long readPoint) See RegionObserver.preFlushScannerOpen(ObserverContext, Store, List, InternalScanner, long)
boolean	preGet(Get get, List<Cell> results)
Result	preIncrement(Increment increment)
Result	preIncrementAfterRowLock(Increment increment)
void	preOpen() Invoked before a region open.
boolean	prePrepareTimeStampForDeleteVersion(Mutation mutation, Cell kv, byte[] byteNow, Get get)
boolean	prePut(Put put, WALEdit edit, Durability durability)
void	preReplayWALs(HRegionInfo info, org.apache.hadoop.fs.Path edits)
boolean	preScannerClose(InternalScanner s)
Boolean	preScannerNext(InternalScanner s, List<Result> results, int limit)
RegionScanner	preScannerOpen(Scan scan)
StoreFileReader	preStoreFileReaderOpen(org.apache.hadoop.fs.FileSystem fs, org.apache.hadoop.fs.Path p, FSDataInputStreamWrapper in, long size, CacheConfig cacheConf, Reference r)
KeyValueScanner	preStoreScannerOpen(Store store, Scan scan, NavigableSet<byte[]> targetCols, long readPt) See RegionObserver.preStoreScannerOpen(ObserverContext, Store, Scan, NavigableSet, KeyValueScanner, long)
boolean	preWALRestore(HRegionInfo info, WALKey logKey, WALEdit logEdit)
static void	testTableCoprocessorAttrs(org.apache.hadoop.conf.Configuration conf, TableDescriptor htd) Sanity check the table coprocessor attributes of the supplied schema.

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

abortServer, abortServer, findCoprocessor, findCoprocessorEnvironment, findCoprocessorEnvironment, findCoprocessors, getCoprocessors, getLoadedCoprocessors, handleCoprocessorThrowable, legacyWarning, load, load, load, loadInstance, loadSystemCoprocessors, shutdown, useLegacyMethod

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

RegionCoprocessorHost

public RegionCoprocessorHost(Region region,
                             RegionServerServices rsServices,
                             org.apache.hadoop.conf.Configuration conf)

Constructor

Parameters:

region - the region

rsServices - interface to available region server functionality

conf - the configuration

Method Detail

testTableCoprocessorAttrs

public static void testTableCoprocessorAttrs(org.apache.hadoop.conf.Configuration conf,
                                             TableDescriptor htd)
                                      throws IOException

Sanity check the table coprocessor attributes of the supplied schema. Will throw an exception if there is a problem.

Parameters:

conf -

htd -

Throws:

IOException

createEnvironment

public org.apache.hadoop.hbase.regionserver.RegionCoprocessorHost.RegionEnvironment createEnvironment(Class<?> implClass,
                                                                                                      Coprocessor instance,
                                                                                                      int priority,
                                                                                                      int seq,
                                                                                                      org.apache.hadoop.conf.Configuration conf)

Description copied from class: CoprocessorHost

Called when a new Coprocessor class is loaded

Specified by:

createEnvironment in class CoprocessorHost<org.apache.hadoop.hbase.regionserver.RegionCoprocessorHost.RegionEnvironment>

preOpen

public void preOpen()
             throws IOException

Invoked before a region open.

Throws:

IOException - Signals that an I/O exception has occurred.

postOpen

public void postOpen()

Invoked after a region open

postLogReplay

public void postLogReplay()

Invoked after log replay on region

preClose

public void preClose(boolean abortRequested)
              throws IOException

Invoked before a region is closed

Parameters:

abortRequested - true if the server is aborting

Throws:

IOException

postClose

public void postClose(boolean abortRequested)

Invoked after a region is closed

Parameters:

abortRequested - true if the server is aborting

preCompactScannerOpen

public InternalScanner preCompactScannerOpen(Store store,
                                             List<StoreFileScanner> scanners,
                                             ScanType scanType,
                                             long earliestPutTs,
                                             CompactionLifeCycleTracker tracker,
                                             User user,
                                             long readPoint)
                                      throws IOException

See RegionObserver.preCompactScannerOpen(ObserverContext, Store, List, ScanType, long, InternalScanner, CompactionLifeCycleTracker, long)

Throws:

IOException

preCompactSelection

public boolean preCompactSelection(Store store,
                                   List<StoreFile> candidates,
                                   CompactionLifeCycleTracker tracker,
                                   User user)
                            throws IOException

Called prior to selecting the StoreFiles for compaction from the list of currently available candidates.

Parameters:

store - The store where compaction is being requested

candidates - The currently available store files

tracker - used to track the life cycle of a compaction

Returns:

If true, skip the normal selection process and use the current list

Throws:

IOException

postCompactSelection

public void postCompactSelection(Store store,
                                 org.apache.hadoop.hbase.shaded.com.google.common.collect.ImmutableList<StoreFile> selected,
                                 CompactionLifeCycleTracker tracker,
                                 User user)
                          throws IOException

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

Parameters:

store - The store where compaction is being requested

selected - The store files selected to compact

tracker - used to track the life cycle of a compaction

Throws:

IOException

preCompact

public InternalScanner preCompact(Store store,
                                  InternalScanner scanner,
                                  ScanType scanType,
                                  CompactionLifeCycleTracker tracker,
                                  User user)
                           throws IOException

Called prior to rewriting the store files selected for compaction

Parameters:

store - the store being compacted

scanner - the scanner used to read store data during compaction

scanType - type of Scan

tracker - used to track the life cycle of a compaction

Throws:

IOException

postCompact

public void postCompact(Store store,
                        StoreFile resultFile,
                        CompactionLifeCycleTracker tracker,
                        User user)
                 throws IOException

Called after the store compaction has completed.

Parameters:

store - the store being compacted

resultFile - the new store file written during compaction

tracker - used to track the life cycle of a compaction

Throws:

IOException

preFlush

public InternalScanner preFlush(Store store,
                                InternalScanner scanner)
                         throws IOException

Invoked before a memstore flush

Throws:

IOException

preFlush

public void preFlush()
              throws IOException

Invoked before a memstore flush

Throws:

IOException

preFlushScannerOpen

public InternalScanner preFlushScannerOpen(Store store,
                                           List<KeyValueScanner> scanners,
                                           long readPoint)
                                    throws IOException

See RegionObserver.preFlushScannerOpen(ObserverContext, Store, List, InternalScanner, long)

Throws:

IOException

postFlush

public void postFlush()
               throws IOException

Invoked after a memstore flush

Throws:

IOException

postFlush

public void postFlush(Store store,
                      StoreFile storeFile)
               throws IOException

Invoked after a memstore flush

Throws:

IOException

preGet

public boolean preGet(Get get,
                      List<Cell> results)
               throws IOException

Parameters:

get - the Get request

Returns:

true if default processing should be bypassed

Throws:

IOException - Exception

postGet

public void postGet(Get get,
                    List<Cell> results)
             throws IOException

Parameters:

get - the Get request

results - the result sett

Throws:

IOException - Exception

preExists

public Boolean preExists(Get get)
                  throws IOException

Parameters:

get - the Get request

Returns:

true or false to return to client if bypassing normal operation, or null otherwise

Throws:

IOException - Exception

postExists

public boolean postExists(Get get,
                          boolean exists)
                   throws IOException

Parameters:

get - the Get request

exists - the result returned by the region server

Returns:

the result to return to the client

Throws:

IOException - Exception

prePut

public boolean prePut(Put put,
                      WALEdit edit,
                      Durability durability)
               throws IOException

Parameters:

put - The Put object

edit - The WALEdit object.

durability - The durability used

Returns:

true if default processing should be bypassed

Throws:

IOException - Exception

prePrepareTimeStampForDeleteVersion

public boolean prePrepareTimeStampForDeleteVersion(Mutation mutation,
                                                   Cell kv,
                                                   byte[] byteNow,
                                                   Get get)
                                            throws IOException

Parameters:

mutation - - the current mutation

kv - - the current cell

byteNow - - current timestamp in bytes

get - - the get that could be used Note that the get only does not specify the family and qualifier that should be used

Returns:

true if default processing should be bypassed

Throws:

IOException - Exception

postPut

public void postPut(Put put,
                    WALEdit edit,
                    Durability durability)
             throws IOException

Parameters:

put - The Put object

edit - The WALEdit object.

durability - The durability used

Throws:

IOException - Exception

preDelete

public boolean preDelete(Delete delete,
                         WALEdit edit,
                         Durability durability)
                  throws IOException

Parameters:

delete - The Delete object

edit - The WALEdit object.

durability - The durability used

Returns:

true if default processing should be bypassed

Throws:

IOException - Exception

postDelete

public void postDelete(Delete delete,
                       WALEdit edit,
                       Durability durability)
                throws IOException

Parameters:

delete - The Delete object

edit - The WALEdit object.

durability - The durability used

Throws:

IOException - Exception

preBatchMutate

public boolean preBatchMutate(MiniBatchOperationInProgress<Mutation> miniBatchOp)
                       throws IOException

Parameters:

miniBatchOp -

Returns:

true if default processing should be bypassed

Throws:

IOException

postBatchMutate

public void postBatchMutate(MiniBatchOperationInProgress<Mutation> miniBatchOp)
                     throws IOException

Parameters:

miniBatchOp -

Throws:

IOException

postBatchMutateIndispensably

public void postBatchMutateIndispensably(MiniBatchOperationInProgress<Mutation> miniBatchOp,
                                         boolean success)
                                  throws IOException

Throws:

IOException

preCheckAndPut

public Boolean preCheckAndPut(byte[] row,
                              byte[] family,
                              byte[] qualifier,
                              CompareOperator op,
                              ByteArrayComparable comparator,
                              Put put)
                       throws IOException

Parameters:

row - row to check

family - column family

qualifier - column qualifier

op - the comparison operation

comparator - the comparator

put - data to put if check succeeds

Returns:

true or false to return to client if default processing should be bypassed, or null otherwise

Throws:

IOException - e

preCheckAndPutAfterRowLock

public Boolean preCheckAndPutAfterRowLock(byte[] row,
                                          byte[] family,
                                          byte[] qualifier,
                                          CompareOperator op,
                                          ByteArrayComparable comparator,
                                          Put put)
                                   throws IOException

Parameters:

row - row to check

family - column family

qualifier - column qualifier

op - the comparison operation

comparator - the comparator

put - data to put if check succeeds

Returns:

true or false to return to client if default processing should be bypassed, or null otherwise

Throws:

IOException - e

postCheckAndPut

public boolean postCheckAndPut(byte[] row,
                               byte[] family,
                               byte[] qualifier,
                               CompareOperator op,
                               ByteArrayComparable comparator,
                               Put put,
                               boolean result)
                        throws IOException

Parameters:

row - row to check

family - column family

qualifier - column qualifier

op - the comparison operation

comparator - the comparator

put - data to put if check succeeds

Throws:

IOException - e

preCheckAndDelete

public Boolean preCheckAndDelete(byte[] row,
                                 byte[] family,
                                 byte[] qualifier,
                                 CompareOperator op,
                                 ByteArrayComparable comparator,
                                 Delete delete)
                          throws IOException

Parameters:

row - row to check

family - column family

qualifier - column qualifier

op - the comparison operation

comparator - the comparator

delete - delete to commit if check succeeds

Returns:

true or false to return to client if default processing should be bypassed, or null otherwise

Throws:

IOException - e

preCheckAndDeleteAfterRowLock

public Boolean preCheckAndDeleteAfterRowLock(byte[] row,
                                             byte[] family,
                                             byte[] qualifier,
                                             CompareOperator op,
                                             ByteArrayComparable comparator,
                                             Delete delete)
                                      throws IOException

Parameters:

row - row to check

family - column family

qualifier - column qualifier

op - the comparison operation

comparator - the comparator

delete - delete to commit if check succeeds

Returns:

true or false to return to client if default processing should be bypassed, or null otherwise

Throws:

IOException - e

postCheckAndDelete

public boolean postCheckAndDelete(byte[] row,
                                  byte[] family,
                                  byte[] qualifier,
                                  CompareOperator op,
                                  ByteArrayComparable comparator,
                                  Delete delete,
                                  boolean result)
                           throws IOException

Parameters:

row - row to check

family - column family

qualifier - column qualifier

op - the comparison operation

comparator - the comparator

delete - delete to commit if check succeeds

Throws:

IOException - e

preAppend

public Result preAppend(Append append)
                 throws IOException

Parameters:

append - append object

Returns:

result to return to client if default operation should be bypassed, null otherwise

Throws:

IOException - if an error occurred on the coprocessor

preAppendAfterRowLock

public Result preAppendAfterRowLock(Append append)
                             throws IOException

Parameters:

append - append object

Returns:

result to return to client if default operation should be bypassed, null otherwise

Throws:

IOException - if an error occurred on the coprocessor

preIncrement

public Result preIncrement(Increment increment)
                    throws IOException

Parameters:

increment - increment object

Returns:

result to return to client if default operation should be bypassed, null otherwise

Throws:

IOException - if an error occurred on the coprocessor

preIncrementAfterRowLock

public Result preIncrementAfterRowLock(Increment increment)
                                throws IOException

Parameters:

increment - increment object

Returns:

result to return to client if default operation should be bypassed, null otherwise

Throws:

IOException - if an error occurred on the coprocessor

postAppend

public Result postAppend(Append append,
                         Result result)
                  throws IOException

Parameters:

append - Append object

result - the result returned by the append

Throws:

IOException - if an error occurred on the coprocessor

postIncrement

public Result postIncrement(Increment increment,
                            Result result)
                     throws IOException

Parameters:

increment - increment object

result - the result returned by postIncrement

Throws:

IOException - if an error occurred on the coprocessor

preScannerOpen

public RegionScanner preScannerOpen(Scan scan)
                             throws IOException

Parameters:

scan - the Scan specification

Returns:

scanner id to return to client if default operation should be bypassed, null otherwise

Throws:

IOException - Exception

preStoreScannerOpen

public KeyValueScanner preStoreScannerOpen(Store store,
                                           Scan scan,
                                           NavigableSet<byte[]> targetCols,
                                           long readPt)
                                    throws IOException

See RegionObserver.preStoreScannerOpen(ObserverContext, Store, Scan, NavigableSet, KeyValueScanner, long)

Throws:

IOException

postScannerOpen

public RegionScanner postScannerOpen(Scan scan,
                                     RegionScanner s)
                              throws IOException

Parameters:

scan - the Scan specification

s - the scanner

Returns:

the scanner instance to use

Throws:

IOException - Exception

preScannerNext

public Boolean preScannerNext(InternalScanner s,
                              List<Result> results,
                              int limit)
                       throws IOException

Parameters:

s - the scanner

results - the result set returned by the region server

limit - the maximum number of results to return

Returns:

'has next' indication to client if bypassing default behavior, or null otherwise

Throws:

IOException - Exception

postScannerNext

public boolean postScannerNext(InternalScanner s,
                               List<Result> results,
                               int limit,
                               boolean hasMore)
                        throws IOException

Parameters:

s - the scanner

results - the result set returned by the region server

limit - the maximum number of results to return

hasMore -

Returns:

'has more' indication to give to client

Throws:

IOException - Exception

postScannerFilterRow

public boolean postScannerFilterRow(InternalScanner s,
                                    Cell curRowCell)
                             throws IOException

This will be called by the scan flow when the current scanned row is being filtered out by the filter.

Parameters:

s - the scanner

curRowCell - The cell in the current row which got filtered out

Returns:

whether more rows are available for the scanner or not

Throws:

IOException

preScannerClose

public boolean preScannerClose(InternalScanner s)
                        throws IOException

Parameters:

s - the scanner

Returns:

true if default behavior should be bypassed, false otherwise

Throws:

IOException - Exception

postScannerClose

public void postScannerClose(InternalScanner s)
                      throws IOException

Throws:

IOException - Exception

preReplayWALs

public void preReplayWALs(HRegionInfo info,
                          org.apache.hadoop.fs.Path edits)
                   throws IOException

Parameters:

info - the RegionInfo for this region

edits - the file of recovered edits

Throws:

IOException - Exception

postReplayWALs

public void postReplayWALs(HRegionInfo info,
                           org.apache.hadoop.fs.Path edits)
                    throws IOException

Parameters:

info - the RegionInfo for this region

edits - the file of recovered edits

Throws:

IOException - Exception

preWALRestore

public boolean preWALRestore(HRegionInfo info,
                             WALKey logKey,
                             WALEdit logEdit)
                      throws IOException

Parameters:

info -

logKey -

logEdit -

Returns:

true if default behavior should be bypassed, false otherwise

Throws:

IOException

postWALRestore

public void postWALRestore(HRegionInfo info,
                           WALKey logKey,
                           WALEdit logEdit)
                    throws IOException

Parameters:

info -

logKey -

logEdit -

Throws:

IOException

preBulkLoadHFile

public boolean preBulkLoadHFile(List<Pair<byte[],String>> familyPaths)
                         throws IOException

Parameters:

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

Returns:

true if the default operation should be bypassed

Throws:

IOException

preCommitStoreFile

public boolean preCommitStoreFile(byte[] family,
                                  List<Pair<org.apache.hadoop.fs.Path,org.apache.hadoop.fs.Path>> pairs)
                           throws IOException

Throws:

IOException

postCommitStoreFile

public void postCommitStoreFile(byte[] family,
                                org.apache.hadoop.fs.Path srcPath,
                                org.apache.hadoop.fs.Path dstPath)
                         throws IOException

Throws:

IOException

postBulkLoadHFile

public boolean postBulkLoadHFile(List<Pair<byte[],String>> familyPaths,
                                 Map<byte[],List<org.apache.hadoop.fs.Path>> map,
                                 boolean hasLoaded)
                          throws IOException

Parameters:

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

map - Map of CF to List of file paths for the final loaded files

hasLoaded - whether load was successful or not

Returns:

the possibly modified value of hasLoaded

Throws:

IOException

postStartRegionOperation

public void postStartRegionOperation(Region.Operation op)
                              throws IOException

Throws:

IOException

postCloseRegionOperation

public void postCloseRegionOperation(Region.Operation op)
                              throws IOException

Throws:

IOException

preStoreFileReaderOpen

public StoreFileReader preStoreFileReaderOpen(org.apache.hadoop.fs.FileSystem fs,
                                              org.apache.hadoop.fs.Path p,
                                              FSDataInputStreamWrapper in,
                                              long size,
                                              CacheConfig cacheConf,
                                              Reference r)
                                       throws IOException

Parameters:

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.

Returns:

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

Throws:

IOException

postStoreFileReaderOpen

public StoreFileReader postStoreFileReaderOpen(org.apache.hadoop.fs.FileSystem fs,
                                               org.apache.hadoop.fs.Path p,
                                               FSDataInputStreamWrapper in,
                                               long size,
                                               CacheConfig cacheConf,
                                               Reference r,
                                               StoreFileReader reader)
                                        throws IOException

Parameters:

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

public Cell postMutationBeforeWAL(RegionObserver.MutationType opType,
                                  Mutation mutation,
                                  Cell oldCell,
                                  Cell newCell)
                           throws IOException

Throws:

IOException

preEndpointInvocation

public com.google.protobuf.Message preEndpointInvocation(com.google.protobuf.Service service,
                                                         String methodName,
                                                         com.google.protobuf.Message request)
                                                  throws IOException

Throws:

IOException

postEndpointInvocation

public void postEndpointInvocation(com.google.protobuf.Service service,
                                   String methodName,
                                   com.google.protobuf.Message request,
                                   com.google.protobuf.Message.Builder responseBuilder)
                            throws IOException

Throws:

IOException

postInstantiateDeleteTracker

public DeleteTracker postInstantiateDeleteTracker(DeleteTracker tracker)
                                           throws IOException

Throws:

IOException