Java 类org.apache.hadoop.hbase.protobuf.generated.AdminProtos.FlushRegionResponse 实例源码

/**
 * Flush a region on the region server.
 *
 * @param controller the RPC controller
 * @param request the request
 * @throws ServiceException
 */
@Override
@QosPriority(priority=HConstants.HIGH_QOS)
public FlushRegionResponse flushRegion(final RpcController controller,
    final FlushRegionRequest request) throws ServiceException {
  try {
    checkOpen();
    requestCount.increment();
    HRegion region = getRegion(request.getRegion());
    LOG.info("Flushing " + region.getRegionNameAsString());
    boolean shouldFlush = true;
    if (request.hasIfOlderThanTs()) {
      shouldFlush = region.getLastFlushTime() < request.getIfOlderThanTs();
    }
    FlushRegionResponse.Builder builder = FlushRegionResponse.newBuilder();
    if (shouldFlush) {
      builder.setFlushed(region.flushcache());
    }
    builder.setLastFlushTime(region.getLastFlushTime());
    return builder.build();
  } catch (IOException ie) {
    throw new ServiceException(ie);
  }
}

private FlushRegionResponse flushRegion() throws IOException {
  // check whether we should still do the flush to this region. If the regions are changed due
  // to splits or merges, etc return success
  if (!Bytes.equals(location.getRegionInfo().getRegionName(), regionName)) {
    if (!reload) {
      throw new IOException("Cached location seems to be different than requested region.");
    }
    LOG.info("Skipping flush region, because the located region "
        + Bytes.toStringBinary(location.getRegionInfo().getRegionName()) + " is different than "
        + " requested region " + Bytes.toStringBinary(regionName));
    return FlushRegionResponse.newBuilder()
        .setLastFlushTime(EnvironmentEdgeManager.currentTime())
        .setFlushed(false)
        .setWroteFlushWalMarker(false)
        .build();
  }

  FlushRegionRequest request =
      RequestConverter.buildFlushRegionRequest(regionName, writeFlushWalMarker);

  try {
    PayloadCarryingRpcController controller = rpcControllerFactory.newController();
    controller.setPriority(tableName);
    return stub.flushRegion(controller, request);
  } catch (ServiceException se) {
    throw ProtobufUtil.getRemoteException(se);
  }
}

/**
 * Flush a region on the region server.
 *
 * @param controller the RPC controller
 * @param request the request
 * @throws ServiceException
 */
@Override
@QosPriority(priority=HConstants.HIGH_QOS)
public FlushRegionResponse flushRegion(final RpcController controller,
    final FlushRegionRequest request) throws ServiceException {
  try {
    checkOpen();
    requestCount.increment();
    HRegion region = getRegion(request.getRegion());
    LOG.info("Flushing " + region.getRegionNameAsString());
    boolean shouldFlush = true;
    if (request.hasIfOlderThanTs()) {
      shouldFlush = region.getLastFlushTime() < request.getIfOlderThanTs();
    }
    FlushRegionResponse.Builder builder = FlushRegionResponse.newBuilder();
    if (shouldFlush) {
      boolean result = region.flushcache().isCompactionNeeded();
      if (result) {
        this.compactSplitThread.requestSystemCompaction(region,
            "Compaction through user triggered flush");
      }
      builder.setFlushed(result);
    }
    builder.setLastFlushTime(region.getLastFlushTime());
    return builder.build();
  } catch (DroppedSnapshotException ex) {
    // Cache flush can fail in a few places. If it fails in a critical
    // section, we get a DroppedSnapshotException and a replay of hlog
    // is required. Currently the only way to do this is a restart of
    // the server.
    abort("Replay of HLog required. Forcing server shutdown", ex);
    throw new ServiceException(ex);
  } catch (IOException ie) {
    throw new ServiceException(ie);
  }
}

/**
 * Flush a region on the region server.
 *
 * @param controller the RPC controller
 * @param request the request
 * @throws ServiceException
 */
@Override
@QosPriority(priority=HConstants.HIGH_QOS)
public FlushRegionResponse flushRegion(final RpcController controller,
    final FlushRegionRequest request) throws ServiceException {
  try {
    checkOpen();
    requestCount.increment();
    HRegion region = getRegion(request.getRegion());
    LOG.info("Flushing " + region.getRegionNameAsString());
    boolean shouldFlush = true;
    if (request.hasIfOlderThanTs()) {
      shouldFlush = region.getLastFlushTime() < request.getIfOlderThanTs();
    }
    FlushRegionResponse.Builder builder = FlushRegionResponse.newBuilder();
    if (shouldFlush) {
      boolean result = region.flushcache().isCompactionNeeded();
      if (result) {
        regionServer.compactSplitThread.requestSystemCompaction(region,
          "Compaction through user triggered flush");
      }
      builder.setFlushed(result);
    }
    builder.setLastFlushTime(region.getLastFlushTime());
    return builder.build();
  } catch (DroppedSnapshotException ex) {
    // Cache flush can fail in a few places. If it fails in a critical
    // section, we get a DroppedSnapshotException and a replay of hlog
    // is required. Currently the only way to do this is a restart of
    // the server.
    regionServer.abort("Replay of HLog required. Forcing server shutdown", ex);
    throw new ServiceException(ex);
  } catch (IOException ie) {
    throw new ServiceException(ie);
  }
}

/**
 * Flush a region on the region server.
 *
 * @param controller the RPC controller
 * @param request the request
 * @throws ServiceException
 */
@Override
@QosPriority(priority=HConstants.HIGH_QOS)
public FlushRegionResponse flushRegion(final RpcController controller,
    final FlushRegionRequest request) throws ServiceException {
  try {
    checkOpen();
    requestCount.increment();
    HRegion region = getRegion(request.getRegion());
    LOG.info("Flushing " + region.getRegionNameAsString());
    boolean shouldFlush = true;
    if (request.hasIfOlderThanTs()) {
      shouldFlush = region.getLastFlushTime() < request.getIfOlderThanTs();
    }
    FlushRegionResponse.Builder builder = FlushRegionResponse.newBuilder();
    if (shouldFlush) {
      boolean result = region.flushcache();
      if (result) {
        this.compactSplitThread.requestSystemCompaction(region,
            "Compaction through user triggered flush");
      }
      builder.setFlushed(result);
    }
    builder.setLastFlushTime(region.getLastFlushTime());
    return builder.build();
  } catch (IOException ie) {
    throw new ServiceException(ie);
  }
}

void triggerFlushInPrimaryRegion(final HRegion region) throws IOException, RuntimeException {
  long pause = connection.getConfiguration().getLong(HConstants.HBASE_CLIENT_PAUSE,
    HConstants.DEFAULT_HBASE_CLIENT_PAUSE);

  int maxAttempts = getRetriesCount(connection.getConfiguration());
  RetryCounter counter = new RetryCounterFactory(maxAttempts, (int)pause).create();

  if (LOG.isDebugEnabled()) {
    LOG.debug("Attempting to do an RPC to the primary region replica " + ServerRegionReplicaUtil
      .getRegionInfoForDefaultReplica(region.getRegionInfo()).getEncodedName() + " of region "
     + region.getRegionInfo().getEncodedName() + " to trigger a flush");
  }
  while (!region.isClosing() && !region.isClosed()
      && !server.isAborted() && !server.isStopped()) {
    FlushRegionCallable flushCallable = new FlushRegionCallable(
      connection, rpcControllerFactory,
      RegionReplicaUtil.getRegionInfoForDefaultReplica(region.getRegionInfo()), true);

    // TODO: flushRegion() is a blocking call waiting for the flush to complete. Ideally we
    // do not have to wait for the whole flush here, just initiate it.
    FlushRegionResponse response = null;
    try {
       response = rpcRetryingCallerFactory.<FlushRegionResponse>newCaller()
        .callWithRetries(flushCallable, this.operationTimeout);
    } catch (IOException ex) {
      if (ex instanceof TableNotFoundException
          || connection.isTableDisabled(region.getRegionInfo().getTable())) {
        return;
      }
      throw ex;
    }

    if (response.getFlushed()) {
      // then we have to wait for seeing the flush entry. All reads will be rejected until we see
      // a complete flush cycle or replay a region open event
      if (LOG.isDebugEnabled()) {
        LOG.debug("Successfully triggered a flush of primary region replica "
            + ServerRegionReplicaUtil
              .getRegionInfoForDefaultReplica(region.getRegionInfo()).getEncodedName()
              + " of region " + region.getRegionInfo().getEncodedName()
              + " Now waiting and blocking reads until observing a full flush cycle");
      }
      break;
    } else {
      if (response.hasWroteFlushWalMarker()) {
        if(response.getWroteFlushWalMarker()) {
          if (LOG.isDebugEnabled()) {
            LOG.debug("Successfully triggered an empty flush marker(memstore empty) of primary "
                + "region replica " + ServerRegionReplicaUtil
                  .getRegionInfoForDefaultReplica(region.getRegionInfo()).getEncodedName()
                + " of region " + region.getRegionInfo().getEncodedName() + " Now waiting and "
                + "blocking reads until observing a flush marker");
          }
          break;
        } else {
          // somehow we were not able to get the primary to write the flush request. It may be
          // closing or already flushing. Retry flush again after some sleep.
          if (!counter.shouldRetry()) {
            throw new IOException("Cannot cause primary to flush or drop a wal marker after " +
                "retries. Failing opening of this region replica "
                + region.getRegionInfo().getEncodedName());
          }
        }
      } else {
        // nothing to do. Are we dealing with an old server?
        LOG.warn("Was not able to trigger a flush from primary region due to old server version? "
            + "Continuing to open the secondary region replica: "
            + region.getRegionInfo().getEncodedName());
        region.setReadsEnabled(true);
        break;
      }
    }
    try {
      counter.sleepUntilNextRetry();
    } catch (InterruptedException e) {
      throw new InterruptedIOException(e.getMessage());
    }
  }
}

/**
 * Flush a region on the region server.
 *
 * @param controller the RPC controller
 * @param request the request
 * @throws ServiceException
 */
@Override
@QosPriority(priority=HConstants.ADMIN_QOS)
public FlushRegionResponse flushRegion(final RpcController controller,
    final FlushRegionRequest request) throws ServiceException {
  try {
    checkOpen();
    requestCount.increment();
    Region region = getRegion(request.getRegion());
    LOG.info("Flushing " + region.getRegionInfo().getRegionNameAsString());
    boolean shouldFlush = true;
    if (request.hasIfOlderThanTs()) {
      shouldFlush = region.getEarliestFlushTimeForAllStores() < request.getIfOlderThanTs();
    }
    FlushRegionResponse.Builder builder = FlushRegionResponse.newBuilder();
    if (shouldFlush) {
      boolean writeFlushWalMarker =  request.hasWriteFlushWalMarker() ?
          request.getWriteFlushWalMarker() : false;
      long startTime = EnvironmentEdgeManager.currentTime();
      // Go behind the curtain so we can manage writing of the flush WAL marker
      HRegion.FlushResultImpl flushResult = (HRegion.FlushResultImpl)
          ((HRegion)region).flushcache(true, writeFlushWalMarker);
      if (flushResult.isFlushSucceeded()) {
        long endTime = EnvironmentEdgeManager.currentTime();
        regionServer.metricsRegionServer.updateFlushTime(endTime - startTime);
      }
      boolean compactionNeeded = flushResult.isCompactionNeeded();
      if (compactionNeeded) {
        regionServer.compactSplitThread.requestSystemCompaction(region,
          "Compaction through user triggered flush");
      }
      builder.setFlushed(flushResult.isFlushSucceeded());
      builder.setWroteFlushWalMarker(flushResult.wroteFlushWalMarker);
    }
    builder.setLastFlushTime(region.getEarliestFlushTimeForAllStores());
    return builder.build();
  } catch (DroppedSnapshotException ex) {
    // Cache flush can fail in a few places. If it fails in a critical
    // section, we get a DroppedSnapshotException and a replay of wal
    // is required. Currently the only way to do this is a restart of
    // the server.
    regionServer.abort("Replay of WAL required. Forcing server shutdown", ex);
    throw new ServiceException(ex);
  } catch (IOException ie) {
    throw new ServiceException(ie);
  }
}

@Override
public FlushRegionResponse flushRegion(RpcController controller,
    FlushRegionRequest request) throws ServiceException {
  // TODO Auto-generated method stub
  return null;
}

@Override
public FlushRegionResponse call(int callTimeout) throws Exception {
  return flushRegion();
}

/**
 * Flush a region on the region server.
 *
 * @param controller the RPC controller
 * @param request    the request
 * @throws ServiceException
 */
@Override
@QosPriority(priority = HConstants.ADMIN_QOS)
public FlushRegionResponse flushRegion(final RpcController controller,
                                       final FlushRegionRequest request) throws ServiceException {
    try {
        checkOpen();
        requestCount.increment();
        HRegion region = getRegion(request.getRegion());
        LOG.info("Flushing " + region.getRegionNameAsString());
        boolean shouldFlush = true;
        if (request.hasIfOlderThanTs()) {
            shouldFlush = region.getLastFlushTime() < request.getIfOlderThanTs();
        }
        FlushRegionResponse.Builder builder = FlushRegionResponse.newBuilder();
        if (shouldFlush) {
            long startTime = EnvironmentEdgeManager.currentTime();
            HRegion.FlushResult flushResult = region.flushcache();
            if (flushResult.isFlushSucceeded()) {
                long endTime = EnvironmentEdgeManager.currentTime();
                regionServer.metricsRegionServer.updateFlushTime(endTime - startTime);
            }
            boolean result = flushResult.isCompactionNeeded();
            if (result) {
                regionServer.compactSplitThread.requestSystemCompaction(region,
                        "Compaction through user triggered flush");
            }
            builder.setFlushed(result);
        }
        builder.setLastFlushTime(region.getLastFlushTime());
        return builder.build();
    } catch (DroppedSnapshotException ex) {
        // Cache flush can fail in a few places. If it fails in a critical
        // section, we get a DroppedSnapshotException and a replay of wal
        // is required. Currently the only way to do this is a restart of
        // the server.
        regionServer.abort("Replay of WAL required. Forcing server shutdown", ex);
        throw new ServiceException(ex);
    } catch (IOException ie) {
        throw new ServiceException(ie);
    }
}

@Override
public FlushRegionResponse flushRegion(RpcController controller,
    FlushRegionRequest request) throws ServiceException {
  // TODO Auto-generated method stub
  return null;
}

@Override
public FlushRegionResponse flushRegion(RpcController controller,
    FlushRegionRequest request) throws ServiceException {
  // TODO Auto-generated method stub
  return null;
}

@Override
public FlushRegionResponse flushRegion(RpcController controller,
    FlushRegionRequest request) throws ServiceException {
  // TODO Auto-generated method stub
  return null;
}

@Override
public FlushRegionResponse flushRegion(RpcController controller,
    FlushRegionRequest request) throws ServiceException {
  // TODO Auto-generated method stub
  return null;
}

@Override
public FlushRegionResponse flushRegion(RpcController controller,
    FlushRegionRequest request) throws ServiceException {
  // TODO Auto-generated method stub
  return null;
}