import org.apache.hadoop.hbase.exceptions.FailedSanityCheckException; //导入依赖的package包/类
@Override public void checkTimestamps(final Map<byte[], List<Cell>> familyMap, long now)
    throws FailedSanityCheckException {
  if (timestampSlop == HConstants.LATEST_TIMESTAMP) {
    return;
  }
  long maxTs = now + timestampSlop;
  for (List<Cell> kvs : familyMap.values()) {
    assert kvs instanceof RandomAccess;
    int listSize = kvs.size();
    for (int i = 0; i < listSize; i++) {
      Cell cell = kvs.get(i);
      // see if the user-side TS is out of range. latest = server-side
      long ts = cell.getTimestamp();
      if (ts != HConstants.LATEST_TIMESTAMP && ts > maxTs) {
        throw new FailedSanityCheckException(
            "Timestamp for KV out of range " + cell + " (too.new=" + timestampSlop + ")");
      }
    }
  }
}
 

import org.apache.hadoop.hbase.exceptions.FailedSanityCheckException; //导入依赖的package包/类
void checkTimestamps(final Map<byte[], List<Cell>> familyMap,
                     long now) throws FailedSanityCheckException {
    if (timestampSlop == HConstants.LATEST_TIMESTAMP) {
        return;
    }
    long maxTs = now + timestampSlop;
    for (List<Cell> kvs : familyMap.values()) {
        assert kvs instanceof RandomAccess;
        int listSize = kvs.size();
        for (int i = 0; i < listSize; i++) {
            Cell cell = kvs.get(i);
            // see if the user-side TS is out of range. latest = server-side
            long ts = cell.getTimestamp();
            if (ts != HConstants.LATEST_TIMESTAMP && ts > maxTs) {
                throw new FailedSanityCheckException("Timestamp for KV out of range "
                        + cell + " (too.new=" + timestampSlop + ")");
            }
        }
    }
}
 

import org.apache.hadoop.hbase.exceptions.FailedSanityCheckException; //导入依赖的package包/类
void checkTimestamps(final Map<byte[], List<Cell>> familyMap,
    long now) throws FailedSanityCheckException {
  if (timestampSlop == HConstants.LATEST_TIMESTAMP) {
    return;
  }
  long maxTs = now + timestampSlop;
  for (List<Cell> kvs : familyMap.values()) {
    for (Cell cell : kvs) {
      // see if the user-side TS is out of range. latest = server-side
      KeyValue kv = KeyValueUtil.ensureKeyValue(cell);
      if (!kv.isLatestTimestamp() && kv.getTimestamp() > maxTs) {
        throw new FailedSanityCheckException("Timestamp for KV out of range "
            + cell + " (too.new=" + timestampSlop + ")");
      }
    }
  }
}
 

import org.apache.hadoop.hbase.exceptions.FailedSanityCheckException; //导入依赖的package包/类
/**
 * Check the collection of families for valid timestamps
 * @param familyMap
 * @param now current timestamp
 * @throws FailedSanityCheckException
 */
public void checkTimestamps(final Map<byte[], List<Cell>> familyMap, long now)
    throws FailedSanityCheckException {
  if (timestampSlop == HConstants.LATEST_TIMESTAMP) {
    return;
  }
  long maxTs = now + timestampSlop;
  for (List<Cell> kvs : familyMap.values()) {
    // Optimization: 'foreach' loop is not used. See:
    // HBASE-12023 HRegion.applyFamilyMapToMemstore creates too many iterator objects
    assert kvs instanceof RandomAccess;
    int listSize  = kvs.size();
    for (int i=0; i < listSize; i++) {
      Cell cell = kvs.get(i);
      // see if the user-side TS is out of range. latest = server-side
      long ts = cell.getTimestamp();
      if (ts != HConstants.LATEST_TIMESTAMP && ts > maxTs) {
        throw new FailedSanityCheckException("Timestamp for KV out of range "
            + cell + " (too.new=" + timestampSlop + ")");
      }
    }
  }
}
 

import org.apache.hadoop.hbase.exceptions.FailedSanityCheckException; //导入依赖的package包/类
@Override
public Result preAppend(ObserverContext<RegionCoprocessorEnvironment> e, Append append)
    throws IOException {
  // If authorization is not enabled, we don't care about reserved tags
  if (!authorizationEnabled) {
    return null;
  }
  for (CellScanner cellScanner = append.cellScanner(); cellScanner.advance();) {
    if (!checkForReservedVisibilityTagPresence(cellScanner.current())) {
      throw new FailedSanityCheckException("Append contains cell with reserved type tag");
    }
  }
  return null;
}
 

import org.apache.hadoop.hbase.exceptions.FailedSanityCheckException; //导入依赖的package包/类
@Override
public Result preIncrement(ObserverContext<RegionCoprocessorEnvironment> e, Increment increment)
    throws IOException {
  // If authorization is not enabled, we don't care about reserved tags
  if (!authorizationEnabled) {
    return null;
  }
  for (CellScanner cellScanner = increment.cellScanner(); cellScanner.advance();) {
    if (!checkForReservedVisibilityTagPresence(cellScanner.current())) {
      throw new FailedSanityCheckException("Increment contains cell with reserved type tag");
    }
  }
  return null;
}
 

import org.apache.hadoop.hbase.exceptions.FailedSanityCheckException; //导入依赖的package包/类
private void doBatchMutate(Mutation mutation) throws IOException {
  // Currently this is only called for puts and deletes, so no nonces.
  OperationStatus[] batchMutate = this.batchMutate(new Mutation[] { mutation });
  if (batchMutate[0].getOperationStatusCode().equals(OperationStatusCode.SANITY_CHECK_FAILURE)) {
    throw new FailedSanityCheckException(batchMutate[0].getExceptionMsg());
  } else if (batchMutate[0].getOperationStatusCode().equals(OperationStatusCode.BAD_FAMILY)) {
    throw new NoSuchColumnFamilyException(batchMutate[0].getExceptionMsg());
  }
}
 

import org.apache.hadoop.hbase.exceptions.FailedSanityCheckException; //导入依赖的package包/类
public void exception(Throwable throwable) {
  source.exception();

  /**
   * Keep some metrics for commonly seen exceptions
   *
   * Try and  put the most common types first.
   * Place child types before the parent type that they extend.
   *
   * If this gets much larger we might have to go to a hashmap
   */
  if (throwable != null) {
    if (throwable instanceof OutOfOrderScannerNextException) {
      source.outOfOrderException();
    } else if (throwable instanceof RegionTooBusyException) {
      source.tooBusyException();
    } else if (throwable instanceof UnknownScannerException) {
      source.unknownScannerException();
    } else if (throwable instanceof RegionMovedException) {
      source.movedRegionException();
    } else if (throwable instanceof NotServingRegionException) {
      source.notServingRegionException();
    } else if (throwable instanceof FailedSanityCheckException) {
      source.failedSanityException();
    } else if (throwable instanceof MultiActionResultTooLarge) {
      source.multiActionTooLargeException();
    }
  }
}
 

import org.apache.hadoop.hbase.exceptions.FailedSanityCheckException; //导入依赖的package包/类
/**
 * Tests that there is server-side filtering for invalid timestamp upper
 * bound. Note that the timestamp lower bound is automatically handled for us
 * by the TTL field.
 */
@Test
public void testPutWithTsSlop() throws IOException {
  byte[] fam = Bytes.toBytes("info");
  byte[][] families = { fam };
  String method = this.getName();

  // add data with a timestamp that is too recent for range. Ensure assert
  CONF.setInt("hbase.hregion.keyvalue.timestamp.slop.millisecs", 1000);
  this.region = initHRegion(tableName, method, CONF, families);
  boolean caughtExcep = false;
  try {
    try {
      // no TS specified == use latest. should not error
      region.put(new Put(row).add(fam, Bytes.toBytes("qual"), Bytes.toBytes("value")));
      // TS out of range. should error
      region.put(new Put(row).add(fam, Bytes.toBytes("qual"), System.currentTimeMillis() + 2000,
          Bytes.toBytes("value")));
      fail("Expected IOE for TS out of configured timerange");
    } catch (FailedSanityCheckException ioe) {
      LOG.debug("Received expected exception", ioe);
      caughtExcep = true;
    }
    assertTrue("Should catch FailedSanityCheckException", caughtExcep);
  } finally {
    HRegion.closeHRegion(this.region);
    this.region = null;
  }
}
 

import org.apache.hadoop.hbase.exceptions.FailedSanityCheckException; //导入依赖的package包/类
@Override
public Result preAppend(ObserverContext<RegionCoprocessorEnvironment> e, Append append)
    throws IOException {
  for (CellScanner cellScanner = append.cellScanner(); cellScanner.advance();) {
    if (!checkForReservedVisibilityTagPresence(cellScanner.current())) {
      throw new FailedSanityCheckException("Append contains cell with reserved type tag");
    }
  }
  return null;
}
 

import org.apache.hadoop.hbase.exceptions.FailedSanityCheckException; //导入依赖的package包/类
@Override
public Result preIncrement(ObserverContext<RegionCoprocessorEnvironment> e, Increment increment)
    throws IOException {
  for (CellScanner cellScanner = increment.cellScanner(); cellScanner.advance();) {
    if (!checkForReservedVisibilityTagPresence(cellScanner.current())) {
      throw new FailedSanityCheckException("Increment contains cell with reserved type tag");
    }
  }
  return null;
}
 

import org.apache.hadoop.hbase.exceptions.FailedSanityCheckException; //导入依赖的package包/类
private void doBatchMutate(Mutation mutation) throws IOException, DoNotRetryIOException {

        // Currently this is only called for puts and deletes, so no nonces.
        OperationStatus[] batchMutate = this.batchMutate(new Mutation[]{mutation},
                HConstants.NO_NONCE, HConstants.NO_NONCE);
        if (batchMutate[0].getOperationStatusCode().equals(OperationStatusCode.SANITY_CHECK_FAILURE)) {
            throw new FailedSanityCheckException(batchMutate[0].getExceptionMsg());
        } else if (batchMutate[0].getOperationStatusCode().equals(OperationStatusCode.BAD_FAMILY)) {
            throw new NoSuchColumnFamilyException(batchMutate[0].getExceptionMsg());
        }
    }
 

import org.apache.hadoop.hbase.exceptions.FailedSanityCheckException; //导入依赖的package包/类
private void doBatchMutate(Mutation mutation) throws IOException, DoNotRetryIOException {
  // Currently this is only called for puts and deletes, so no nonces.
  OperationStatus[] batchMutate = this.batchMutate(new Mutation[] { mutation },
      HConstants.NO_NONCE, HConstants.NO_NONCE);
  if (batchMutate[0].getOperationStatusCode().equals(OperationStatusCode.SANITY_CHECK_FAILURE)) {
    throw new FailedSanityCheckException(batchMutate[0].getExceptionMsg());
  } else if (batchMutate[0].getOperationStatusCode().equals(OperationStatusCode.BAD_FAMILY)) {
    throw new NoSuchColumnFamilyException(batchMutate[0].getExceptionMsg());
  }
}
 

import org.apache.hadoop.hbase.exceptions.FailedSanityCheckException; //导入依赖的package包/类
/**
 * Increment the count for a specific exception type.  This is called for each exception type
 * that is returned to the thrift handler.
 * @param rawThrowable type of exception
 */
public void exception(Throwable rawThrowable) {
  source.exception();

  Throwable throwable = unwrap(rawThrowable);
  /**
   * Keep some metrics for commonly seen exceptions
   *
   * Try and  put the most common types first.
   * Place child types before the parent type that they extend.
   *
   * If this gets much larger we might have to go to a hashmap
   */
  if (throwable != null) {
    if (throwable instanceof OutOfOrderScannerNextException) {
      source.outOfOrderException();
    } else if (throwable instanceof RegionTooBusyException) {
      source.tooBusyException();
    } else if (throwable instanceof UnknownScannerException) {
      source.unknownScannerException();
    } else if (throwable instanceof ScannerResetException) {
      source.scannerResetException();
    } else if (throwable instanceof RegionMovedException) {
      source.movedRegionException();
    } else if (throwable instanceof NotServingRegionException) {
      source.notServingRegionException();
    } else if (throwable instanceof FailedSanityCheckException) {
      source.failedSanityException();
    } else if (throwable instanceof MultiActionResultTooLarge) {
      source.multiActionTooLargeException();
    } else if (throwable instanceof CallQueueTooBigException) {
      source.callQueueTooBigException();
    }
  }
}
 

import org.apache.hadoop.hbase.exceptions.FailedSanityCheckException; //导入依赖的package包/类
@Override
public void preGetOp(ObserverContext<RegionCoprocessorEnvironment> e,
                     Get get, List<Cell> results) throws IOException {
  byte[] errorType = get.getAttribute(SHOULD_ERROR_ATTRIBUTE);
  if (errorType != null) {
    ErrorType type = ErrorType.valueOf(Bytes.toString(errorType));
    switch (type) {
      case CALL_QUEUE_TOO_BIG:
        throw new CallQueueTooBigException("Failing for test");
      case MULTI_ACTION_RESULT_TOO_LARGE:
        throw new MultiActionResultTooLarge("Failing for test");
      case FAILED_SANITY_CHECK:
        throw new FailedSanityCheckException("Failing for test");
      case NOT_SERVING_REGION:
        throw new NotServingRegionException("Failing for test");
      case REGION_MOVED:
        throw new RegionMovedException(e.getEnvironment().getServerName(), 1);
      case SCANNER_RESET:
        throw new ScannerResetException("Failing for test");
      case UNKNOWN_SCANNER:
        throw new UnknownScannerException("Failing for test");
      case REGION_TOO_BUSY:
        throw new RegionTooBusyException("Failing for test");
      case OUT_OF_ORDER_SCANNER_NEXT:
        throw new OutOfOrderScannerNextException("Failing for test");
      default:
        throw new DoNotRetryIOException("Failing for test");
    }
  }
}
 

import org.apache.hadoop.hbase.exceptions.FailedSanityCheckException; //导入依赖的package包/类
private void doBatchMutate(Mutation mutation) throws IOException {
  // Currently this is only called for puts and deletes, so no nonces.
  OperationStatus[] batchMutate = this.batchMutate(new Mutation[]{mutation});
  if (batchMutate[0].getOperationStatusCode().equals(OperationStatusCode.SANITY_CHECK_FAILURE)) {
    throw new FailedSanityCheckException(batchMutate[0].getExceptionMsg());
  } else if (batchMutate[0].getOperationStatusCode().equals(OperationStatusCode.BAD_FAMILY)) {
    throw new NoSuchColumnFamilyException(batchMutate[0].getExceptionMsg());
  }
}
 

import org.apache.hadoop.hbase.exceptions.FailedSanityCheckException; //导入依赖的package包/类
public void exception(Throwable throwable) {
  source.exception();

  /**
   * Keep some metrics for commonly seen exceptions
   *
   * Try and  put the most common types first.
   * Place child types before the parent type that they extend.
   *
   * If this gets much larger we might have to go to a hashmap
   */
  if (throwable != null) {
    if (throwable instanceof OutOfOrderScannerNextException) {
      source.outOfOrderException();
    } else if (throwable instanceof RegionTooBusyException) {
      source.tooBusyException();
    } else if (throwable instanceof UnknownScannerException) {
      source.unknownScannerException();
    } else if (throwable instanceof ScannerResetException) {
      source.scannerResetException();
    } else if (throwable instanceof RegionMovedException) {
      source.movedRegionException();
    } else if (throwable instanceof NotServingRegionException) {
      source.notServingRegionException();
    } else if (throwable instanceof FailedSanityCheckException) {
      source.failedSanityException();
    } else if (throwable instanceof MultiActionResultTooLarge) {
      source.multiActionTooLargeException();
    } else if (throwable instanceof CallQueueTooBigException) {
      source.callQueueTooBigException();
    }
  }
}
 

import org.apache.hadoop.hbase.exceptions.FailedSanityCheckException; //导入依赖的package包/类
/**
 * Tests that there is server-side filtering for invalid timestamp upper
 * bound. Note that the timestamp lower bound is automatically handled for us
 * by the TTL field.
 */
@Test
public void testPutWithTsSlop() throws IOException {
  byte[] fam = Bytes.toBytes("info");
  byte[][] families = { fam };

  // add data with a timestamp that is too recent for range. Ensure assert
  CONF.setInt("hbase.hregion.keyvalue.timestamp.slop.millisecs", 1000);
  this.region = initHRegion(tableName, method, CONF, families);
  boolean caughtExcep = false;
  try {
    try {
      // no TS specified == use latest. should not error
      region.put(new Put(row).addColumn(fam, Bytes.toBytes("qual"), Bytes.toBytes("value")));
      // TS out of range. should error
      region.put(new Put(row).addColumn(fam, Bytes.toBytes("qual"),
          System.currentTimeMillis() + 2000, Bytes.toBytes("value")));
      fail("Expected IOE for TS out of configured timerange");
    } catch (FailedSanityCheckException ioe) {
      LOG.debug("Received expected exception", ioe);
      caughtExcep = true;
    }
    assertTrue("Should catch FailedSanityCheckException", caughtExcep);
  } finally {
    HBaseTestingUtility.closeRegionAndWAL(this.region);
    this.region = null;
  }
}
 

import org.apache.hadoop.hbase.exceptions.FailedSanityCheckException; //导入依赖的package包/类
private void doBatchMutate(Mutation mutation) throws IOException,
    org.apache.hadoop.hbase.DoNotRetryIOException {
  OperationStatus[] batchMutate = this.batchMutate(new Mutation[] { mutation });
  if (batchMutate[0].getOperationStatusCode().equals(OperationStatusCode.SANITY_CHECK_FAILURE)) {
    throw new FailedSanityCheckException(batchMutate[0].getExceptionMsg());
  } else if (batchMutate[0].getOperationStatusCode().equals(OperationStatusCode.BAD_FAMILY)) {
    throw new NoSuchColumnFamilyException(batchMutate[0].getExceptionMsg());
  }
}
 

import org.apache.hadoop.hbase.exceptions.FailedSanityCheckException; //导入依赖的package包/类
/**
 * Tests that there is server-side filtering for invalid timestamp upper
 * bound. Note that the timestamp lower bound is automatically handled for us
 * by the TTL field.
 */
@Test
public void testPutWithTsSlop() throws IOException {
  byte[] fam = Bytes.toBytes("info");
  byte[][] families = { fam };
  String method = this.getName();

  // add data with a timestamp that is too recent for range. Ensure assert
  conf.setInt("hbase.hregion.keyvalue.timestamp.slop.millisecs", 1000);
  this.region = initHRegion(tableName, method, conf, families);
  boolean caughtExcep = false;
  try {
    try {
      // no TS specified == use latest. should not error
      region.put(new Put(row).add(fam, Bytes.toBytes("qual"), Bytes.toBytes("value")));
      // TS out of range. should error
      region.put(new Put(row).add(fam, Bytes.toBytes("qual"), System.currentTimeMillis() + 2000,
          Bytes.toBytes("value")));
      fail("Expected IOE for TS out of configured timerange");
    } catch (FailedSanityCheckException ioe) {
      LOG.debug("Received expected exception", ioe);
      caughtExcep = true;
    }
    assertTrue("Should catch FailedSanityCheckException", caughtExcep);
  } finally {
    HRegion.closeHRegion(this.region);
    this.region = null;
  }
}