Java HConstants.NO_SEQNUM屬性代碼示例

/**
 * Iterates over the given Map and compares sequence ids with corresponding
 * entries in {@link #oldestUnflushedRegionSequenceIds}. If a region in
 * {@link #oldestUnflushedRegionSequenceIds} has a sequence id less than that passed
 * in <code>sequenceids</code> then return it.
 * @param sequenceids Sequenceids keyed by encoded region name.
 * @return regions found in this instance with sequence ids less than those passed in.
 */
byte[][] findLower(Map<byte[], Long> sequenceids) {
  List<byte[]> toFlush = null;
  // Keeping the old behavior of iterating unflushedSeqNums under oldestSeqNumsLock.
  synchronized (tieLock) {
    for (Map.Entry<byte[], Long> e: sequenceids.entrySet()) {
      Map<byte[], Long> m = this.lowestUnflushedSequenceIds.get(e.getKey());
      if (m == null) continue;
      // The lowest sequence id outstanding for this region.
      long lowest = getLowestSequenceId(m);
      if (lowest != HConstants.NO_SEQNUM && lowest <= e.getValue()) {
        if (toFlush == null) toFlush = new ArrayList<byte[]>();
        toFlush.add(e.getKey());
      }
    }
  }
  return toFlush == null? null: toFlush.toArray(new byte[][] { HConstants.EMPTY_BYTE_ARRAY });
}
 

RegionLoad.Builder setCompleteSequenceId(RegionLoad.Builder regionLoadBldr) {
  long lastFlushOpSeqIdLocal = this.lastFlushOpSeqId;
  byte[] encodedRegionName = this.getRegionInfo().getEncodedNameAsBytes();
  regionLoadBldr.clearStoreCompleteSequenceId();
  for (byte[] familyName : this.stores.keySet()) {
    long earliest = this.wal.getEarliestMemstoreSeqNum(encodedRegionName, familyName);
    // Subtract - 1 to go earlier than the current oldest, unflushed edit in
    // memstore; this will
    // give us a sequence id that is for sure flushed. We want edit replay to
    // start after this
    // sequence id in this region. If NO_SEQNUM, use the regions maximum flush
    // id.
    long csid = (earliest == HConstants.NO_SEQNUM) ? lastFlushOpSeqIdLocal : earliest - 1;
    regionLoadBldr.addStoreCompleteSequenceId(
        StoreSequenceId.newBuilder().setFamilyName(ByteString.copyFrom(familyName))
            .setSequenceId(csid).build());
  }
  return regionLoadBldr.setCompleteSequenceId(getMaxFlushedSeqId());
}
 

/**
 * Updates last flushed sequence Ids for the regions on server sn
 * @param sn
 * @param hsl
 */
private void updateLastFlushedSequenceIds(ServerName sn, ServerLoad hsl) {
  Map<byte[], RegionLoad> regionsLoad = hsl.getRegionsLoad();
  for (Entry<byte[], RegionLoad> entry : regionsLoad.entrySet()) {
    byte[] encodedRegionName = Bytes.toBytes(HRegionInfo.encodeRegionName(entry.getKey()));
    Long existingValue = flushedSequenceIdByRegion.get(encodedRegionName);
    long l = entry.getValue().getCompleteSequenceId();
    // Don't let smaller sequence ids override greater sequence ids.
    if (LOG.isTraceEnabled()) {
      LOG.trace(Bytes.toString(encodedRegionName) + ", existingValue=" + existingValue +
        ", completeSequenceId=" + l);
    }
    if (existingValue == null || (l != HConstants.NO_SEQNUM && l > existingValue)) {
      flushedSequenceIdByRegion.put(encodedRegionName, l);
    } else if (l != HConstants.NO_SEQNUM && l < existingValue) {
      LOG.warn("RegionServer " + sn + " indicates a last flushed sequence id ("
          + l + ") that is less than the previous last flushed sequence id ("
          + existingValue + ") for region " + Bytes.toString(entry.getKey()) + " Ignoring.");
    }
    ConcurrentNavigableMap<byte[], Long> storeFlushedSequenceId =
        getOrCreateStoreFlushedSequenceId(encodedRegionName);
    for (StoreSequenceId storeSeqId : entry.getValue().getStoreCompleteSequenceId()) {
      byte[] family = storeSeqId.getFamilyName().toByteArray();
      existingValue = storeFlushedSequenceId.get(family);
      l = storeSeqId.getSequenceId();
      if (LOG.isTraceEnabled()) {
        LOG.trace(Bytes.toString(encodedRegionName) + ", family=" + Bytes.toString(family) +
          ", existingValue=" + existingValue + ", completeSequenceId=" + l);
      }
      // Don't let smaller sequence ids override greater sequence ids.
      if (existingValue == null || (l != HConstants.NO_SEQNUM && l > existingValue.longValue())) {
        storeFlushedSequenceId.put(family, l);
      }
    }
  }
}
 

@Override public boolean removeFromOnlineRegions(final Region r, ServerName destination) {
  Region toReturn = this.onlineRegions.remove(r.getRegionInfo().getEncodedName());
  if (destination != null) {
    long closeSeqNum = r.getMaxFlushedSeqId();
    if (closeSeqNum == HConstants.NO_SEQNUM) {
      // No edits in WAL for this region; get the sequence number when the region was opened.
      closeSeqNum = r.getOpenSeqNum();
      if (closeSeqNum == HConstants.NO_SEQNUM) closeSeqNum = 0;
    }
    addToMovedRegions(r.getRegionInfo().getEncodedName(), destination, closeSeqNum);
  }
  this.regionFavoredNodesMap.remove(r.getRegionInfo().getEncodedName());
  return toReturn != null;
}
 

/**
 * Returns the lowest unflushed sequence id for the region.
 * @param encodedRegionName
 * @return Lowest outstanding unflushed sequenceid for <code>encodedRegionName</code>. Will
 * return {@link HConstants#NO_SEQNUM} when none.
 */
long getLowestSequenceId(final byte [] encodedRegionName) {
  synchronized (this.tieLock)  {
    Map<byte[], Long> m = this.flushingSequenceIds.get(encodedRegionName);
    long flushingLowest = m != null? getLowestSequenceId(m): Long.MAX_VALUE;
    m = this.lowestUnflushedSequenceIds.get(encodedRegionName);
    long unflushedLowest = m != null? getLowestSequenceId(m): HConstants.NO_SEQNUM;
    return Math.min(flushingLowest, unflushedLowest);
  }
}
 

/**
 * @param src
 * @return New Map that has same keys as <code>src</code> but instead of a Map for a value, it
 * instead has found the smallest sequence id and it returns that as the value instead.
 */
private <T extends Map<byte[], Long>> Map<byte[], Long> flattenToLowestSequenceId(
    Map<byte[], T> src) {
  if (src == null || src.isEmpty()) return null;
  Map<byte[], Long> tgt = Maps.newHashMap();
  for (Map.Entry<byte[], T> entry: src.entrySet()) {
    long lowestSeqId = getLowestSequenceId(entry.getValue());
    if (lowestSeqId != HConstants.NO_SEQNUM) {
      tgt.put(entry.getKey(), lowestSeqId);
    }
  }
  return tgt;
}
 

/**
 * For hadoop.ipc internal call. Do NOT use.
 * We have to parse the hostname to recreate the exception.
 * The input is the one generated by {@link #getMessage()}
 */
public RegionMovedException(String s) {
  int posHostname = s.indexOf(HOST_FIELD) + HOST_FIELD.length();
  int posPort = s.indexOf(PORT_FIELD) + PORT_FIELD.length();
  int posStartCode = s.indexOf(STARTCODE_FIELD) + STARTCODE_FIELD.length();
  int posSeqNum = s.indexOf(LOCATIONSEQNUM_FIELD) + LOCATIONSEQNUM_FIELD.length();

  String tmpHostname = null;
  int tmpPort = -1;
  long tmpStartCode = -1;
  long tmpSeqNum = HConstants.NO_SEQNUM;
  try {
    // TODO: this whole thing is extremely brittle.
    tmpHostname = s.substring(posHostname, s.indexOf(' ', posHostname));
    tmpPort = Integer.parseInt(s.substring(posPort, s.indexOf(' ', posPort)));
    tmpStartCode =  Long.parseLong(s.substring(posStartCode, s.indexOf('.', posStartCode)));
    tmpSeqNum = Long.parseLong(s.substring(posSeqNum, s.indexOf('.', posSeqNum)));
  } catch (Exception ignored) {
    LOG.warn("Can't parse the hostname, port and startCode from this string: " +
        s + ", continuing");
  }

  hostname = tmpHostname;
  port = tmpPort;
  startCode = tmpStartCode;
  locationSeqNum = tmpSeqNum;
}
 

@Override
public Long startCacheFlush(final byte[] encodedRegionName, Set<byte[]> flushedFamilyNames) {
  if (closed.get()) return null;
  return HConstants.NO_SEQNUM;
}
 

@Override
public long getEarliestMemstoreSeqNum(byte[] encodedRegionName) {
  return HConstants.NO_SEQNUM;
}
 

@Override public void postOpenDeployTasks(final PostOpenDeployContext context)
    throws KeeperException, IOException {
  Region r = context.getRegion();
  long masterSystemTime = context.getMasterSystemTime();
  Preconditions.checkArgument(r instanceof HRegion, "r must be an HRegion");
  rpcServices.checkOpen();
  LOG.info("Post open deploy tasks for " + r.getRegionInfo().getRegionNameAsString());
  // Do checks to see if we need to compact (references or too many files)
  for (Store s : r.getStores()) {
    if (s.hasReferences() || s.needsCompaction()) {
      this.compactSplitThread.requestSystemCompaction(r, s, "Opening Region");
    }
  }
  long openSeqNum = r.getOpenSeqNum();
  if (openSeqNum == HConstants.NO_SEQNUM) {
    // If we opened a region, we should have read some sequence number from it.
    LOG.error(
        "No sequence number found when opening " + r.getRegionInfo().getRegionNameAsString());
    openSeqNum = 0;
  }

  // Update flushed sequence id of a recovering region in ZK
  updateRecoveringRegionLastFlushedSequenceId(r);

  // Update ZK, or META
  if (r.getRegionInfo().isMetaRegion()) {
    MetaTableLocator.setMetaLocation(getZooKeeper(), serverName, r.getRegionInfo().getReplicaId(),
        State.OPEN);
  } else if (useZKForAssignment) {
    MetaTableAccessor
        .updateRegionLocation(getConnection(), r.getRegionInfo(), this.serverName, openSeqNum,
            masterSystemTime);
  }
  if (!useZKForAssignment && !reportRegionStateTransition(
      new RegionStateTransitionContext(TransitionCode.OPENED, openSeqNum, masterSystemTime,
          r.getRegionInfo()))) {
    throw new IOException(
        "Failed to report opened region to master: " + r.getRegionInfo().getRegionNameAsString());
  }

  triggerFlushInPrimaryRegion((HRegion) r);

  LOG.debug("Finished post open deploy task for " + r.getRegionInfo().getRegionNameAsString());
}
 

/**
 * @param encodedRegionName Region to flush.
 * @param families Families to flush. May be a subset of all families in the region.
 * @return Returns {@link HConstants#NO_SEQNUM} if we are flushing the whole region OR if
 * we are flushing a subset of all families but there are no edits in those families not
 * being flushed; in other words, this is effectively same as a flush of all of the region
 * though we were passed a subset of regions. Otherwise, it returns the sequence id of the
 * oldest/lowest outstanding edit.
 */
Long startCacheFlush(final byte[] encodedRegionName, final Set<byte[]> families) {
  Map<byte[], Long> oldSequenceIds = null;
  Long lowestUnflushedInRegion = HConstants.NO_SEQNUM;
  synchronized (tieLock) {
    Map<byte[], Long> m = this.lowestUnflushedSequenceIds.get(encodedRegionName);
    if (m != null) {
      // NOTE: Removal from this.lowestUnflushedSequenceIds must be done in controlled
      // circumstance because another concurrent thread now may add sequenceids for this family
      // (see above in getOrCreateLowestSequenceId). Make sure you are ok with this. Usually it
      // is fine because updates are blocked when this method is called. Make sure!!!
      for (byte[] familyName: families) {
        Long seqId = m.remove(familyName);
        if (seqId != null) {
          if (oldSequenceIds == null) oldSequenceIds = Maps.newTreeMap(Bytes.BYTES_COMPARATOR);
          oldSequenceIds.put(familyName, seqId);
        }
      }
      if (oldSequenceIds != null && !oldSequenceIds.isEmpty()) {
        if (this.flushingSequenceIds.put(encodedRegionName, oldSequenceIds) != null) {
          LOG.warn("Flushing Map not cleaned up for " + Bytes.toString(encodedRegionName) +
            ", sequenceid=" + oldSequenceIds);
        }
      }
      if (m.isEmpty()) {
        // Remove it otherwise it will be in oldestUnflushedStoreSequenceIds for ever
        // even if the region is already moved to other server.
        // Do not worry about data racing, we held write lock of region when calling
        // startCacheFlush, so no one can add value to the map we removed.
        this.lowestUnflushedSequenceIds.remove(encodedRegionName);
      } else {
        // Flushing a subset of the region families. Return the sequence id of the oldest entry.
        lowestUnflushedInRegion = Collections.min(m.values());
      }
    }
  }
  // Do this check outside lock.
  if (oldSequenceIds != null && oldSequenceIds.isEmpty()) {
    // TODO: if we have no oldStoreSeqNum, and WAL is not disabled, presumably either
    // the region is already flushing (which would make this call invalid), or there
    // were no appends after last flush, so why are we starting flush? Maybe we should
    // assert not empty. Less rigorous, but safer, alternative is telling the caller to stop.
    // For now preserve old logic.
    LOG.warn("Couldn't find oldest sequenceid for " + Bytes.toString(encodedRegionName));
  }
  return lowestUnflushedInRegion;
}