Java HRegionInfo.DEFAULT_REPLICA_ID屬性代碼示例

private void assignMetaZkLess(RegionStates regionStates, RegionState regionState, long timeout,
    Set<ServerName> previouslyFailedRs) throws IOException, KeeperException {
  ServerName currentServer = regionState.getServerName();
  if (serverManager.isServerOnline(currentServer)) {
    LOG.info("Meta was in transition on " + currentServer);
    assignmentManager.processRegionInTransitionZkLess();
  } else {
    if (currentServer != null) {
      if (regionState.getRegion().getReplicaId() == HRegionInfo.DEFAULT_REPLICA_ID) {
        splitMetaLogBeforeAssignment(currentServer);
        regionStates.logSplit(HRegionInfo.FIRST_META_REGIONINFO);
        previouslyFailedRs.add(currentServer);
      }
    }
    LOG.info("Re-assigning hbase:meta, it was on " + currentServer);
    regionStates.updateRegionState(regionState.getRegion(), State.OFFLINE);
    assignmentManager.assignMeta(regionState.getRegion());
  }
}
 

private void undeployRegions(HbckInfo hi) throws IOException, InterruptedException {
  undeployRegionsForHbi(hi);
  // undeploy replicas of the region (but only if the method is invoked for the primary)
  if (hi.getReplicaId() != HRegionInfo.DEFAULT_REPLICA_ID) {
    return;
  }
  int numReplicas = admin.getTableDescriptor(hi.getTableName()).getRegionReplication();
  for (int i = 1; i < numReplicas; i++) {
    if (hi.getPrimaryHRIForDeployedReplica() == null) continue;
    HRegionInfo hri = RegionReplicaUtil.getRegionInfoForReplica(
        hi.getPrimaryHRIForDeployedReplica(), i);
    HbckInfo h = regionInfoMap.get(hri.getEncodedName());
    if (h != null) {
      undeployRegionsForHbi(h);
      //set skip checks; we undeployed it, and we don't want to evaluate this anymore
      //in consistency checks
      h.setSkipChecks(true);
    }
  }
}
 

public void addRegionInfo(HbckInfo hir) {
  if (Bytes.equals(hir.getEndKey(), HConstants.EMPTY_END_ROW)) {
    // end key is absolute end key, just add it.
    // ignore replicas other than primary for these checks
    if (hir.getReplicaId() == HRegionInfo.DEFAULT_REPLICA_ID) sc.add(hir);
    return;
  }

  // if not the absolute end key, check for cycle
  if (Bytes.compareTo(hir.getStartKey(), hir.getEndKey()) > 0) {
    errors.reportError(
        ERROR_CODE.REGION_CYCLE,
        String.format("The endkey for this region comes before the "
            + "startkey, startkey=%s, endkey=%s",
            Bytes.toStringBinary(hir.getStartKey()),
            Bytes.toStringBinary(hir.getEndKey())), this, hir);
    backwards.add(hir);
    return;
  }

  // main case, add to split calculator
  // ignore replicas other than primary for these checks
  if (hir.getReplicaId() == HRegionInfo.DEFAULT_REPLICA_ID) sc.add(hir);
}
 

@Override public WAL getWAL(HRegionInfo regionInfo) throws IOException {
  WAL wal;
  LogRoller roller = walRoller;
  //_ROOT_ and hbase:meta regions have separate WAL.
  if (regionInfo != null && regionInfo.isMetaTable()
      && regionInfo.getReplicaId() == HRegionInfo.DEFAULT_REPLICA_ID) {
    roller = ensureMetaWALRoller();
    wal = walFactory.getMetaWAL(regionInfo.getEncodedNameAsBytes());
  } else if (regionInfo == null) {
    wal = walFactory.getWAL(UNSPECIFIED_REGION);
  } else {
    wal = walFactory.getWAL(regionInfo.getEncodedNameAsBytes());
  }
  roller.addWAL(wal);
  return wal;
}
 

/**
 * {@inheritDoc}
 */
@Override
public void splitRegion(final byte[] regionName, final byte [] splitPoint)
throws IOException {
  Pair<HRegionInfo, ServerName> regionServerPair = getRegion(regionName);
  if (regionServerPair == null) {
    throw new IllegalArgumentException("Invalid region: " + Bytes.toStringBinary(regionName));
  }
  if (regionServerPair.getFirst() != null &&
      regionServerPair.getFirst().getReplicaId() != HRegionInfo.DEFAULT_REPLICA_ID) {
    throw new IllegalArgumentException("Can't split replicas directly. "
        + "Replicas are auto-split when their primary is split.");
  }
  if (regionServerPair.getSecond() == null) {
    throw new NoServerForRegionException(Bytes.toStringBinary(regionName));
  }
  split(regionServerPair.getSecond(), regionServerPair.getFirst(), splitPoint);
}
 

/**
 * Sets the location of <code>hbase:meta</code> in ZooKeeper to the
 * specified server address.
 * @param zookeeper
 * @param serverName
 * @param replicaId
 * @param state
 * @throws KeeperException
 */
public static void setMetaLocation(ZooKeeperWatcher zookeeper,
    ServerName serverName, int replicaId, RegionState.State state) throws KeeperException {
  LOG.info("Setting hbase:meta region location in ZooKeeper as " + serverName);
  // Make the MetaRegionServer pb and then get its bytes and save this as
  // the znode content.
  MetaRegionServer pbrsr = MetaRegionServer.newBuilder()
    .setServer(ProtobufUtil.toServerName(serverName))
    .setRpcVersion(HConstants.RPC_CURRENT_VERSION)
    .setState(state.convert()).build();
  byte[] data = ProtobufUtil.prependPBMagic(pbrsr.toByteArray());
  try {
    ZKUtil.setData(zookeeper, zookeeper.getZNodeForReplica(replicaId), data);
  } catch(KeeperException.NoNodeException nne) {
    if (replicaId == HRegionInfo.DEFAULT_REPLICA_ID) {
      LOG.debug("META region location doesn't exist, create it");
    } else {
      LOG.debug("META region location doesn't exist for replicaId " + replicaId +
          ", create it");
    }
    ZKUtil.createAndWatch(zookeeper, zookeeper.getZNodeForReplica(replicaId), data);
  }
}
 

private void tryAssignmentRepair(HbckInfo hbi, String msg) throws IOException,
  KeeperException, InterruptedException {
  // If we are trying to fix the errors
  if (shouldFixAssignments()) {
    errors.print(msg);
    undeployRegions(hbi);
    setShouldRerun();
    HRegionInfo hri = hbi.getHdfsHRI();
    if (hri == null) {
      hri = hbi.metaEntry;
    }
    HBaseFsckRepair.fixUnassigned(admin, hri);
    HBaseFsckRepair.waitUntilAssigned(admin, hri);

    // also assign replicas if needed (do it only when this call operates on a primary replica)
    if (hbi.getReplicaId() != HRegionInfo.DEFAULT_REPLICA_ID) return;
    int replicationCount = admin.getTableDescriptor(hri.getTable()).getRegionReplication();
    for (int i = 1; i < replicationCount; i++) {
      hri = RegionReplicaUtil.getRegionInfoForReplica(hri, i);
      HbckInfo h = regionInfoMap.get(hri.getEncodedName());
      if (h != null) {
        undeployRegions(h);
        //set skip checks; we undeploy & deploy it; we don't want to evaluate this hbi anymore
        //in consistency checks
        h.setSkipChecks(true);
      }
      HBaseFsckRepair.fixUnassigned(admin, hri);
      HBaseFsckRepair.waitUntilAssigned(admin, hri);
    }

  }
}
 

/**
 * Should the memstore be flushed now
 */
boolean shouldFlush(final StringBuffer whyFlush) {
  whyFlush.setLength(0);
  // This is a rough measure.
  if (this.maxFlushedSeqId > 0 && (this.maxFlushedSeqId + this.flushPerChanges < this.mvcc
      .getReadPoint())) {
    whyFlush.append("more than max edits, " + this.flushPerChanges + ", since last flush");
    return true;
  }
  long modifiedFlushCheckInterval = flushCheckInterval;
  if (getRegionInfo().isSystemTable()
      && getRegionInfo().getReplicaId() == HRegionInfo.DEFAULT_REPLICA_ID) {
    modifiedFlushCheckInterval = SYSTEM_CACHE_FLUSH_INTERVAL;
  }
  if (modifiedFlushCheckInterval <= 0) { // disabled
    return false;
  }
  long now = EnvironmentEdgeManager.currentTime();
  // if we flushed in the recent past, we don't need to do again now
  if ((now - getEarliestFlushTimeForAllStores() < modifiedFlushCheckInterval)) {
    return false;
  }
  // since we didn't flush in the recent past, flush now if certain conditions
  // are met. Return true on first such memstore hit.
  for (Store s : getStores()) {
    if (s.timeOfOldestEdit() < now - modifiedFlushCheckInterval) {
      // we have an old enough edit in the memstore, flush
      whyFlush.append(s.toString() + " has an old edit so flush to free WALs");
      return true;
    }
  }
  return false;
}
 

/**
 * 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);
  }
}
 

/**
 * Merge two regions. Asynchronous operation.
 * @param nameOfRegionA encoded or full name of region a
 * @param nameOfRegionB encoded or full name of region b
 * @param forcible true if do a compulsory merge, otherwise we will only merge
 *          two adjacent regions
 * @throws IOException
 */
@Override
public void mergeRegions(final byte[] nameOfRegionA,
    final byte[] nameOfRegionB, final boolean forcible)
    throws IOException {
  final byte[] encodedNameOfRegionA = isEncodedRegionName(nameOfRegionA) ?
    nameOfRegionA : HRegionInfo.encodeRegionName(nameOfRegionA).getBytes();
  final byte[] encodedNameOfRegionB = isEncodedRegionName(nameOfRegionB) ?
    nameOfRegionB : HRegionInfo.encodeRegionName(nameOfRegionB).getBytes();

  Pair<HRegionInfo, ServerName> pair = getRegion(nameOfRegionA);
  if (pair != null && pair.getFirst().getReplicaId() != HRegionInfo.DEFAULT_REPLICA_ID)
    throw new IllegalArgumentException("Can't invoke merge on non-default regions directly");
  pair = getRegion(nameOfRegionB);
  if (pair != null && pair.getFirst().getReplicaId() != HRegionInfo.DEFAULT_REPLICA_ID)
    throw new IllegalArgumentException("Can't invoke merge on non-default regions directly");
  executeCallable(new MasterCallable<Void>(getConnection()) {
    @Override
    public Void call(int callTimeout) throws ServiceException {
      PayloadCarryingRpcController controller = rpcControllerFactory.newController();
      controller.setCallTimeout(callTimeout);

      try {
        DispatchMergingRegionsRequest request = RequestConverter
            .buildDispatchMergingRegionsRequest(encodedNameOfRegionA,
              encodedNameOfRegionB, forcible);
        master.dispatchMergingRegions(controller, request);
      } catch (DeserializationException de) {
        LOG.error("Could not parse destination server name: " + de);
      }
      return null;
    }
  });
}
 

public void deleteMetaLocation(ZooKeeperWatcher zookeeper, int replicaId)
throws KeeperException {
  if (replicaId == HRegionInfo.DEFAULT_REPLICA_ID) {
    LOG.info("Deleting hbase:meta region location in ZooKeeper");
  } else {
    LOG.info("Deleting hbase:meta for " + replicaId + " region location in ZooKeeper");
  }
  try {
    // Just delete the node.  Don't need any watches.
    ZKUtil.deleteNode(zookeeper, zookeeper.getZNodeForReplica(replicaId));
  } catch(KeeperException.NoNodeException nne) {
    // Has already been deleted
  }
}
 

/**
 * Parse the meta replicaId from the passed znode
 * @param znode
 * @return replicaId
 */
public int getMetaReplicaIdFromZnode(String znode) {
  String pattern = conf.get("zookeeper.znode.metaserver","meta-region-server");
  if (znode.equals(pattern)) return HRegionInfo.DEFAULT_REPLICA_ID;
  // the non-default replicas are of the pattern meta-region-server-<replicaId>
  String nonDefaultPattern = pattern + "-";
  return Integer.parseInt(znode.substring(nonDefaultPattern.length()));
}
 

/**
 * Check if a region belongs to some small system table.
 * If so, the primary replica may be expected to be put on the master regionserver.
 */
public boolean shouldBeOnMaster(HRegionInfo region) {
  return tablesOnMaster.contains(region.getTable().getNameAsString())
      && region.getReplicaId() == HRegionInfo.DEFAULT_REPLICA_ID;
}
 

/**
 * Attempts to undeploy a region from a region server based in information in
 * META.  Any operations that modify the file system should make sure that
 * its corresponding region is not deployed to prevent data races.
 *
 * A separate call is required to update the master in-memory region state
 * kept in the AssignementManager.  Because disable uses this state instead of
 * that found in META, we can't seem to cleanly disable/delete tables that
 * have been hbck fixed.  When used on a version of HBase that does not have
 * the offline ipc call exposed on the master (<0.90.5, <0.92.0) a master
 * restart or failover may be required.
 */
private void closeRegion(HbckInfo hi) throws IOException, InterruptedException {
  if (hi.metaEntry == null && hi.hdfsEntry == null) {
    undeployRegions(hi);
    return;
  }

  // get assignment info and hregioninfo from meta.
  Get get = new Get(hi.getRegionName());
  get.addColumn(HConstants.CATALOG_FAMILY, HConstants.REGIONINFO_QUALIFIER);
  get.addColumn(HConstants.CATALOG_FAMILY, HConstants.SERVER_QUALIFIER);
  get.addColumn(HConstants.CATALOG_FAMILY, HConstants.STARTCODE_QUALIFIER);
  // also get the locations of the replicas to close if the primary region is being closed
  if (hi.getReplicaId() == HRegionInfo.DEFAULT_REPLICA_ID) {
    int numReplicas = admin.getTableDescriptor(hi.getTableName()).getRegionReplication();
    for (int i = 0; i < numReplicas; i++) {
      get.addColumn(HConstants.CATALOG_FAMILY, MetaTableAccessor.getServerColumn(i));
      get.addColumn(HConstants.CATALOG_FAMILY, MetaTableAccessor.getStartCodeColumn(i));
    }
  }
  Result r = meta.get(get);
  RegionLocations rl = MetaTableAccessor.getRegionLocations(r);
  if (rl == null) {
    LOG.warn("Unable to close region " + hi.getRegionNameAsString() +
        " since meta does not have handle to reach it");
    return;
  }
  for (HRegionLocation h : rl.getRegionLocations()) {
    ServerName serverName = h.getServerName();
    if (serverName == null) {
      errors.reportError("Unable to close region "
          + hi.getRegionNameAsString() +  " because meta does not "
          + "have handle to reach it.");
      continue;
    }
    HRegionInfo hri = h.getRegionInfo();
    if (hri == null) {
      LOG.warn("Unable to close region " + hi.getRegionNameAsString()
          + " because hbase:meta had invalid or missing "
          + HConstants.CATALOG_FAMILY_STR + ":"
          + Bytes.toString(HConstants.REGIONINFO_QUALIFIER)
          + " qualifier value.");
      continue;
    }
    // close the region -- close files and remove assignment
    HBaseFsckRepair.closeRegionSilentlyAndWait(connection, serverName, hri);
  }
}
 

@Override public boolean isPrimaryReplicaStore() {
  return getRegionInfo().getReplicaId() == HRegionInfo.DEFAULT_REPLICA_ID;
}