org.apache.hadoop.hbase.coprocessor.BaseRegionObserver Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of hbase-server Show documentation
Main functionality for HBase
There is a newer version: 3.0.0-beta-1
/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

package org.apache.hadoop.hbase.coprocessor;

import java.io.IOException;
import java.util.List;
import java.util.NavigableSet;

import org.apache.hadoop.hbase.classification.InterfaceAudience;
import org.apache.hadoop.hbase.classification.InterfaceStability;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.CoprocessorEnvironment;
import org.apache.hadoop.hbase.HBaseInterfaceAudience;
import org.apache.hadoop.hbase.HRegionInfo;
import org.apache.hadoop.hbase.client.Append;
import org.apache.hadoop.hbase.client.Delete;
import org.apache.hadoop.hbase.client.Durability;
import org.apache.hadoop.hbase.client.Get;
import org.apache.hadoop.hbase.client.Increment;
import org.apache.hadoop.hbase.client.Mutation;
import org.apache.hadoop.hbase.client.Put;
import org.apache.hadoop.hbase.client.Result;
import org.apache.hadoop.hbase.client.Scan;
import org.apache.hadoop.hbase.filter.ByteArrayComparable;
import org.apache.hadoop.hbase.filter.CompareFilter.CompareOp;
import org.apache.hadoop.hbase.io.FSDataInputStreamWrapper;
import org.apache.hadoop.hbase.io.Reference;
import org.apache.hadoop.hbase.io.hfile.CacheConfig;
import org.apache.hadoop.hbase.regionserver.DeleteTracker;
import org.apache.hadoop.hbase.regionserver.InternalScanner;
import org.apache.hadoop.hbase.regionserver.KeyValueScanner;
import org.apache.hadoop.hbase.regionserver.MiniBatchOperationInProgress;
import org.apache.hadoop.hbase.regionserver.Region;
import org.apache.hadoop.hbase.regionserver.Region.Operation;
import org.apache.hadoop.hbase.regionserver.RegionScanner;
import org.apache.hadoop.hbase.regionserver.ScanType;
import org.apache.hadoop.hbase.regionserver.Store;
import org.apache.hadoop.hbase.regionserver.StoreFile;
import org.apache.hadoop.hbase.regionserver.StoreFile.Reader;
import org.apache.hadoop.hbase.regionserver.compactions.CompactionRequest;
import org.apache.hadoop.hbase.regionserver.wal.HLogKey;
import org.apache.hadoop.hbase.wal.WALKey;
import org.apache.hadoop.hbase.regionserver.wal.WALEdit;
import org.apache.hadoop.hbase.util.Pair;

import com.google.common.collect.ImmutableList;

/**
 * An abstract class that implements RegionObserver.
 * By extending it, you can create your own region observer without
 * overriding all abstract methods of RegionObserver.
 */
@InterfaceAudience.LimitedPrivate(HBaseInterfaceAudience.COPROC)
@InterfaceStability.Evolving
public abstract class BaseRegionObserver implements RegionObserver {
  @Override
  public void start(CoprocessorEnvironment e) throws IOException { }

  @Override
  public void stop(CoprocessorEnvironment e) throws IOException { }

  @Override
  public void preOpen(ObserverContext e) throws IOException { }

  @Override
  public void postOpen(ObserverContext e) { }

  @Override
  public void postLogReplay(ObserverContext e) { }

  @Override
  public void preClose(ObserverContext c, boolean abortRequested)
      throws IOException { }

  @Override
  public void postClose(ObserverContext e,
      boolean abortRequested) { }

  @Override
  public InternalScanner preFlushScannerOpen(final ObserverContext c,
      final Store store, final KeyValueScanner memstoreScanner, final InternalScanner s)
      throws IOException {
    return s;
  }

  @Override
  public void preFlush(ObserverContext e) throws IOException {
  }

  @Override
  public void postFlush(ObserverContext e) throws IOException {
  }

  @Override
  public InternalScanner preFlush(ObserverContext e, Store store,
      InternalScanner scanner) throws IOException {
    return scanner;
  }

  @Override
  public void postFlush(ObserverContext e, Store store,
      StoreFile resultFile) throws IOException {
  }

  @Override
  public void preSplit(ObserverContext e) throws IOException {
  }
  
  @Override
  public void preSplit(ObserverContext c,
      byte[] splitRow) throws IOException {
  }

  @Override
  public void preSplitBeforePONR(ObserverContext ctx,
      byte[] splitKey, List metaEntries) throws IOException {
  }
  
  @Override
  public void preSplitAfterPONR(
      ObserverContext ctx) throws IOException {
  }
  
  @Override
  public void preRollBackSplit(ObserverContext ctx)
      throws IOException {
  }
  
  @Override
  public void postRollBackSplit(
      ObserverContext ctx) throws IOException {
  }
  
  @Override
  public void postCompleteSplit(
      ObserverContext ctx) throws IOException {
  }

  @Override
  public void postSplit(ObserverContext e, Region l, Region r)
      throws IOException {
  }

  @Override
  public void preCompactSelection(final ObserverContext c,
      final Store store, final List candidates) throws IOException { }

  @Override
  public void preCompactSelection(final ObserverContext c,
      final Store store, final List candidates, final CompactionRequest request)
      throws IOException {
    preCompactSelection(c, store, candidates);
  }

  @Override
  public void postCompactSelection(final ObserverContext c,
      final Store store, final ImmutableList selected) { }

  @Override
  public void postCompactSelection(final ObserverContext c,
      final Store store, final ImmutableList selected, CompactionRequest request) {
    postCompactSelection(c, store, selected);
  }

  @Override
  public InternalScanner preCompact(ObserverContext e,
      final Store store, final InternalScanner scanner, final ScanType scanType)
      throws IOException {
    return scanner;
  }

  @Override
  public InternalScanner preCompact(ObserverContext e,
      final Store store, final InternalScanner scanner, final ScanType scanType,
      CompactionRequest request) throws IOException {
    return preCompact(e, store, scanner, scanType);
  }

  @Override
  public InternalScanner preCompactScannerOpen(
      final ObserverContext c, final Store store,
      List scanners, final ScanType scanType, final long earliestPutTs,
      final InternalScanner s) throws IOException {
    return s;
  }

  @Override
  public InternalScanner preCompactScannerOpen(
      final ObserverContext c, final Store store,
      List scanners, final ScanType scanType, final long earliestPutTs,
      final InternalScanner s, CompactionRequest request) throws IOException {
    return preCompactScannerOpen(c, store, scanners, scanType, earliestPutTs, s);
  }

  @Override
  public void postCompact(ObserverContext e, final Store store,
      final StoreFile resultFile) throws IOException {
  }

@Override
  public void postCompact(ObserverContext e, final Store store,
      final StoreFile resultFile, CompactionRequest request) throws IOException {
    postCompact(e, store, resultFile);
  }

  @Override
  public void preGetClosestRowBefore(final ObserverContext e,
      final byte [] row, final byte [] family, final Result result)
    throws IOException {
  }

  @Override
  public void postGetClosestRowBefore(final ObserverContext e,
      final byte [] row, final byte [] family, final Result result)
      throws IOException {
  }

  @Override
  public void preGetOp(final ObserverContext e,
      final Get get, final List results) throws IOException {
  }

  @Override
  public void postGetOp(final ObserverContext e,
      final Get get, final List results) throws IOException {
  }

  @Override
  public boolean preExists(final ObserverContext e,
      final Get get, final boolean exists) throws IOException {
    return exists;
  }

  @Override
  public boolean postExists(final ObserverContext e,
      final Get get, boolean exists) throws IOException {
    return exists;
  }

  @Override
  public void prePut(final ObserverContext e, 
      final Put put, final WALEdit edit, final Durability durability) throws IOException {
  }

  @Override
  public void postPut(final ObserverContext e, 
      final Put put, final WALEdit edit, final Durability durability) throws IOException {
  }

  @Override
  public void preDelete(final ObserverContext e, final Delete delete,
      final WALEdit edit, final Durability durability) throws IOException {
  }

  @Override
  public void prePrepareTimeStampForDeleteVersion(
      final ObserverContext e, final Mutation delete,
      final Cell cell, final byte[] byteNow, final Get get) throws IOException {
  }

  @Override
  public void postDelete(final ObserverContext e,
      final Delete delete, final WALEdit edit, final Durability durability)
      throws IOException {
  }
  
  @Override
  public void preBatchMutate(final ObserverContext c,
      final MiniBatchOperationInProgress miniBatchOp) throws IOException {
  }

  @Override
  public void postBatchMutate(final ObserverContext c,
      final MiniBatchOperationInProgress miniBatchOp) throws IOException {
  }

  @Override
  public void postBatchMutateIndispensably(final ObserverContext ctx,
      MiniBatchOperationInProgress miniBatchOp, final boolean success) throws IOException {
  }

  @Override
  public boolean preCheckAndPut(final ObserverContext e,
      final byte [] row, final byte [] family, final byte [] qualifier,
      final CompareOp compareOp, final ByteArrayComparable comparator,
      final Put put, final boolean result) throws IOException {
    return result;
  }

  @Override
  public boolean preCheckAndPutAfterRowLock(
      final ObserverContext e,
      final byte[] row, final byte[] family, final byte[] qualifier, final CompareOp compareOp,
      final ByteArrayComparable comparator, final Put put,
      final boolean result) throws IOException {
    return result;
  }

  @Override
  public boolean postCheckAndPut(final ObserverContext e,
      final byte [] row, final byte [] family, final byte [] qualifier,
      final CompareOp compareOp, final ByteArrayComparable comparator,
      final Put put, final boolean result) throws IOException {
    return result;
  }

  @Override
  public boolean preCheckAndDelete(final ObserverContext e,
      final byte [] row, final byte [] family, final byte [] qualifier,
      final CompareOp compareOp, final ByteArrayComparable comparator,
      final Delete delete, final boolean result) throws IOException {
    return result;
  }

  @Override
  public boolean preCheckAndDeleteAfterRowLock(
      final ObserverContext e,
      final byte[] row, final byte[] family, final byte[] qualifier, final CompareOp compareOp,
      final ByteArrayComparable comparator, final Delete delete,
      final boolean result) throws IOException {
    return result;
  }

  @Override
  public boolean postCheckAndDelete(final ObserverContext e,
      final byte [] row, final byte [] family, final byte [] qualifier,
      final CompareOp compareOp, final ByteArrayComparable comparator,
      final Delete delete, final boolean result) throws IOException {
    return result;
  }

  @Override
  public Result preAppend(final ObserverContext e,
      final Append append) throws IOException {
    return null;
  }

  @Override
  public Result preAppendAfterRowLock(final ObserverContext e,
      final Append append) throws IOException {
    return null;
  }

  @Override
  public Result postAppend(final ObserverContext e,
      final Append append, final Result result) throws IOException {
    return result;
  }

  @Override
  public long preIncrementColumnValue(final ObserverContext e,
      final byte [] row, final byte [] family, final byte [] qualifier,
      final long amount, final boolean writeToWAL) throws IOException {
    return amount;
  }

  @Override
  public long postIncrementColumnValue(final ObserverContext e,
      final byte [] row, final byte [] family, final byte [] qualifier,
      final long amount, final boolean writeToWAL, long result)
      throws IOException {
    return result;
  }

  @Override
  public Result preIncrement(final ObserverContext e,
      final Increment increment) throws IOException {
    return null;
  }

  @Override
  public Result preIncrementAfterRowLock(final ObserverContext e,
      final Increment increment) throws IOException {
    return null;
  }

  @Override
  public Result postIncrement(final ObserverContext e,
      final Increment increment, final Result result) throws IOException {
    return result;
  }

  @Override
  public RegionScanner preScannerOpen(final ObserverContext e,
      final Scan scan, final RegionScanner s) throws IOException {
    return s;
  }

  @Override
  public KeyValueScanner preStoreScannerOpen(final ObserverContext c,
      final Store store, final Scan scan, final NavigableSet targetCols,
      final KeyValueScanner s) throws IOException {
    return s;
  }

  @Override
  public RegionScanner postScannerOpen(final ObserverContext e,
      final Scan scan, final RegionScanner s) throws IOException {
    return s;
  }

  @Override
  public boolean preScannerNext(final ObserverContext e,
      final InternalScanner s, final List results,
      final int limit, final boolean hasMore) throws IOException {
    return hasMore;
  }

  @Override
  public boolean postScannerNext(final ObserverContext e,
      final InternalScanner s, final List results, final int limit,
      final boolean hasMore) throws IOException {
    return hasMore;
  }

  @Override
  public boolean postScannerFilterRow(final ObserverContext e,
      final InternalScanner s, final byte[] currentRow, final int offset, final short length,
      final boolean hasMore) throws IOException {
    return hasMore;
  }

  @Override
  public void preScannerClose(final ObserverContext e,
      final InternalScanner s) throws IOException {
  }

  @Override
  public void postScannerClose(final ObserverContext e,
      final InternalScanner s) throws IOException {
  }

  /**
   * Implementers should override this version of the method and leave the deprecated one as-is.
   */
  @Override
  public void preWALRestore(ObserverContext env,
      HRegionInfo info, WALKey logKey, WALEdit logEdit) throws IOException {
  }

  @Override
  public void preWALRestore(ObserverContext env, HRegionInfo info,
      HLogKey logKey, WALEdit logEdit) throws IOException {
    preWALRestore(env, info, (WALKey)logKey, logEdit);
  }

  /**
   * Implementers should override this version of the method and leave the deprecated one as-is.
   */
  @Override
  public void postWALRestore(ObserverContext env,
      HRegionInfo info, WALKey logKey, WALEdit logEdit) throws IOException {
  }

  @Override
  public void postWALRestore(ObserverContext env,
      HRegionInfo info, HLogKey logKey, WALEdit logEdit) throws IOException {
    postWALRestore(env, info, (WALKey)logKey, logEdit);
  }

  @Override
  public void preBulkLoadHFile(final ObserverContext ctx,
    List> familyPaths) throws IOException {
  }

  @Override
  public boolean postBulkLoadHFile(ObserverContext ctx,
    List> familyPaths, boolean hasLoaded) throws IOException {
    return hasLoaded;
  }

  @Override
  public Reader preStoreFileReaderOpen(ObserverContext ctx,
      FileSystem fs, Path p, FSDataInputStreamWrapper in, long size, CacheConfig cacheConf,
      Reference r, Reader reader) throws IOException {
    return reader;
  }

  @Override
  public Reader postStoreFileReaderOpen(ObserverContext ctx,
      FileSystem fs, Path p, FSDataInputStreamWrapper in, long size, CacheConfig cacheConf,
      Reference r, Reader reader) throws IOException {
    return reader;
  }

  @Override
  public Cell postMutationBeforeWAL(ObserverContext ctx,
      MutationType opType, Mutation mutation, Cell oldCell, Cell newCell) throws IOException {
    return newCell;
  }

  @Override
  public void postStartRegionOperation(final ObserverContext ctx,
      Operation op) throws IOException {
  }

  @Override
  public void postCloseRegionOperation(final ObserverContext ctx,
      Operation op) throws IOException {
  }

  @Override
  public DeleteTracker postInstantiateDeleteTracker(
      final ObserverContext ctx, DeleteTracker delTracker)
      throws IOException {
    return delTracker;
  }
}