Java HConstants.ADMIN_QOS屬性代碼示例

/**
 * Returns a 'priority' based on the request type.
 *
 * Currently the returned priority is used for queue selection.
 * See the SimpleRpcScheduler as example. It maintains a queue per 'priory type'
 * HIGH_QOS (meta requests), REPLICATION_QOS (replication requests),
 * NORMAL_QOS (user requests).
 */
@Override
public int getPriority(RequestHeader header, Message param, User user) {
  int priorityByAnnotation = getAnnotatedPriority(header);

  if (priorityByAnnotation >= 0) {
    return priorityByAnnotation;
  }

  // all requests executed by super users have high QoS
  try {
    if (Superusers.isSuperUser(user)) {
      return HConstants.ADMIN_QOS;
    }
  } catch (IllegalStateException ex) {
    // Not good throwing an exception out of here, a runtime anyways.  Let the query go into the
    // server and have it throw the exception if still an issue.  Just mark it normal priority.
    if (LOG.isTraceEnabled()) LOG.trace("Marking normal priority after getting exception=" + ex);
    return HConstants.NORMAL_QOS;
  }

  return getBasePriority(header, param);
}
 

@Override
@QosPriority(priority=HConstants.ADMIN_QOS)
public GetOnlineRegionResponse getOnlineRegion(final RpcController controller,
    final GetOnlineRegionRequest request) throws ServiceException {
  try {
    checkOpen();
    requestCount.increment();
    Map<String, Region> onlineRegions = regionServer.onlineRegions;
    List<HRegionInfo> list = new ArrayList<HRegionInfo>(onlineRegions.size());
    for (Region region: onlineRegions.values()) {
      list.add(region.getRegionInfo());
    }
    Collections.sort(list);
    return ResponseConverter.buildGetOnlineRegionResponse(list);
  } catch (IOException ie) {
    throw new ServiceException(ie);
  }
}
 

@Override
@QosPriority(priority=HConstants.ADMIN_QOS)
public GetRegionInfoResponse getRegionInfo(final RpcController controller,
    final GetRegionInfoRequest request) throws ServiceException {
  try {
    checkOpen();
    requestCount.increment();
    Region region = getRegion(request.getRegion());
    HRegionInfo info = region.getRegionInfo();
    GetRegionInfoResponse.Builder builder = GetRegionInfoResponse.newBuilder();
    builder.setRegionInfo(HRegionInfo.convert(info));
    if (request.hasCompactionState() && request.getCompactionState()) {
      builder.setCompactionState(region.getCompactionState());
    }
    builder.setIsRecovering(region.isRecovering());
    return builder.build();
  } catch (IOException ie) {
    throw new ServiceException(ie);
  }
}
 

@Override
@QosPriority(priority=HConstants.ADMIN_QOS)
public GetStoreFileResponse getStoreFile(final RpcController controller,
    final GetStoreFileRequest request) throws ServiceException {
  try {
    checkOpen();
    Region region = getRegion(request.getRegion());
    requestCount.increment();
    Set<byte[]> columnFamilies;
    if (request.getFamilyCount() == 0) {
      columnFamilies = region.getTableDesc().getFamiliesKeys();
    } else {
      columnFamilies = new TreeSet<byte[]>(Bytes.BYTES_RAWCOMPARATOR);
      for (ByteString cf: request.getFamilyList()) {
        columnFamilies.add(cf.toByteArray());
      }
    }
    int nCF = columnFamilies.size();
    List<String>  fileList = region.getStoreFileList(
      columnFamilies.toArray(new byte[nCF][]));
    GetStoreFileResponse.Builder builder = GetStoreFileResponse.newBuilder();
    builder.addAllStoreFile(fileList);
    return builder.build();
  } catch (IOException ie) {
    throw new ServiceException(ie);
  }
}
 

@Override
@QosPriority(priority = HConstants.ADMIN_QOS)
public GetLastFlushedSequenceIdResponse getLastFlushedSequenceId(RpcController controller,
    GetLastFlushedSequenceIdRequest request) throws ServiceException {
  try {
    master.checkServiceStarted();
  } catch (IOException ioe) {
    throw new ServiceException(ioe);
  }
  byte[] encodedRegionName = request.getRegionName().toByteArray();
  RegionStoreSequenceIds ids = master.serverManager.getLastFlushedSequenceId(encodedRegionName);
  return ResponseConverter.buildGetLastFlushedSequenceIdResponse(ids);
}
 

/**
 * Close a region on the region server.
 *
 * @param controller the RPC controller
 * @param request the request
 * @throws ServiceException
 */
@Override
@QosPriority(priority=HConstants.ADMIN_QOS)
public CloseRegionResponse closeRegion(final RpcController controller,
    final CloseRegionRequest request) throws ServiceException {
  final ServerName sn = (request.hasDestinationServer() ?
    ProtobufUtil.toServerName(request.getDestinationServer()) : null);

  try {
    checkOpen();
    if (request.hasServerStartCode()) {
      // check that we are the same server that this RPC is intended for.
      long serverStartCode = request.getServerStartCode();
      if (regionServer.serverName.getStartcode() !=  serverStartCode) {
        throw new ServiceException(new DoNotRetryIOException("This RPC was intended for a " +
            "different server with startCode: " + serverStartCode + ", this server is: "
            + regionServer.serverName));
      }
    }
    final String encodedRegionName = ProtobufUtil.getRegionEncodedName(request.getRegion());

    // Can be null if we're calling close on a region that's not online
    final Region region = regionServer.getFromOnlineRegions(encodedRegionName);
    if ((region  != null) && (region .getCoprocessorHost() != null)) {
      region.getCoprocessorHost().preClose(false);
    }

    requestCount.increment();
    LOG.info("Close " + encodedRegionName + ", moving to " + sn);
    CloseRegionCoordination.CloseRegionDetails crd = regionServer.getCoordinatedStateManager()
      .getCloseRegionCoordination().parseFromProtoRequest(request);

    boolean closed = regionServer.closeRegion(encodedRegionName, false, crd, sn);
    CloseRegionResponse.Builder builder = CloseRegionResponse.newBuilder().setClosed(closed);
    return builder.build();
  } catch (IOException ie) {
    throw new ServiceException(ie);
  }
}
 

/**
 * Get some information of the region server.
 *
 * @param controller the RPC controller
 * @param request the request
 * @throws ServiceException
 */
@Override
@QosPriority(priority=HConstants.ADMIN_QOS)
public GetServerInfoResponse getServerInfo(final RpcController controller,
    final GetServerInfoRequest request) throws ServiceException {
  try {
    checkOpen();
  } catch (IOException ie) {
    throw new ServiceException(ie);
  }
  requestCount.increment();
  int infoPort = regionServer.infoServer != null ? regionServer.infoServer.getPort() : -1;
  return ResponseConverter.buildGetServerInfoResponse(regionServer.serverName, infoPort);
}
 

/**
 * Split a region on the region server.
 *
 * @param controller the RPC controller
 * @param request the request
 * @throws ServiceException
 */
@Override
@QosPriority(priority=HConstants.ADMIN_QOS)
public SplitRegionResponse splitRegion(final RpcController controller,
    final SplitRegionRequest request) throws ServiceException {
  try {
    checkOpen();
    requestCount.increment();
    Region region = getRegion(request.getRegion());
    region.startRegionOperation(Operation.SPLIT_REGION);
    if (region.getRegionInfo().getReplicaId() != HRegionInfo.DEFAULT_REPLICA_ID) {
      throw new IOException("Can't split replicas directly. "
          + "Replicas are auto-split when their primary is split.");
    }
    LOG.info("Splitting " + region.getRegionInfo().getRegionNameAsString());
    long startTime = EnvironmentEdgeManager.currentTime();
    FlushResult flushResult = region.flush(true);
    if (flushResult.isFlushSucceeded()) {
      long endTime = EnvironmentEdgeManager.currentTime();
      regionServer.metricsRegionServer.updateFlushTime(endTime - startTime);
    }
    byte[] splitPoint = null;
    if (request.hasSplitPoint()) {
      splitPoint = request.getSplitPoint().toByteArray();
    }
    ((HRegion)region).forceSplit(splitPoint);
    regionServer.compactSplitThread.requestSplit(region, ((HRegion)region).checkSplit(),
      RpcServer.getRequestUser());
    return SplitRegionResponse.newBuilder().build();
  } catch (DroppedSnapshotException ex) {
    regionServer.abort("Replay of WAL required. Forcing server shutdown", ex);
    throw new ServiceException(ex);
  } catch (IOException ie) {
    throw new ServiceException(ie);
  }
}
 

/**
 * Stop the region server.
 *
 * @param controller the RPC controller
 * @param request the request
 * @throws ServiceException
 */
@Override
@QosPriority(priority=HConstants.ADMIN_QOS)
public StopServerResponse stopServer(final RpcController controller,
    final StopServerRequest request) throws ServiceException {
  requestCount.increment();
  String reason = request.getReason();
  regionServer.stop(reason);
  return StopServerResponse.newBuilder().build();
}
 

/**
 * Compact a region on the region server.
 *
 * @param controller the RPC controller
 * @param request the request
 * @throws ServiceException
 */
@Override
@QosPriority(priority=HConstants.ADMIN_QOS)
public CompactRegionResponse compactRegion(final RpcController controller,
    final CompactRegionRequest request) throws ServiceException {
  try {
    checkOpen();
    requestCount.increment();
    Region region = getRegion(request.getRegion());
    region.startRegionOperation(Operation.COMPACT_REGION);
    LOG.info("Compacting " + region.getRegionInfo().getRegionNameAsString());
    boolean major = false;
    byte [] family = null;
    Store store = null;
    if (request.hasFamily()) {
      family = request.getFamily().toByteArray();
      store = region.getStore(family);
      if (store == null) {
        throw new ServiceException(new IOException("column family " + Bytes.toString(family)
          + " does not exist in region " + region.getRegionInfo().getRegionNameAsString()));
      }
    }
    if (request.hasMajor()) {
      major = request.getMajor();
    }
    if (major) {
      if (family != null) {
        store.triggerMajorCompaction();
      } else {
        region.triggerMajorCompaction();
      }
    }

    String familyLogMsg = (family != null)?" for column family: " + Bytes.toString(family):"";
    if (LOG.isTraceEnabled()) {
      LOG.trace("User-triggered compaction requested for region "
        + region.getRegionInfo().getRegionNameAsString() + familyLogMsg);
    }
    String log = "User-triggered " + (major ? "major " : "") + "compaction" + familyLogMsg;
    if(family != null) {
      regionServer.compactSplitThread.requestCompaction(region, store, log,
        Store.PRIORITY_USER, null, RpcServer.getRequestUser());
    } else {
      regionServer.compactSplitThread.requestCompaction(region, log,
        Store.PRIORITY_USER, null, RpcServer.getRequestUser());
    }
    return CompactRegionResponse.newBuilder().build();
  } 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.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);
  }
}