HDFS源码分析数据块之CorruptReplicasMap

CorruptReplicasMap用于存储文件系统中所有损坏数据块的信息。仅当它的所有副本损坏时一个数据块才被认定为损坏。当汇报数据块的副本时，我们隐藏所有损坏副本。一旦一个数据块被发现完好副本达到预期，它将从CorruptReplicasMap中被移除。

        我们先看下CorruptReplicasMap都有哪些成员变量，如下所示：

 

// 存储损坏数据块Block与它对应每个数据节点与损坏原因集合映射关系的集合
private final SortedMap<Block, Map<DatanodeDescriptor, Reason>> corruptReplicasMap =
  new TreeMap<Block, Map<DatanodeDescriptor, Reason>>();

        是的，你没看错，就这一个corruptReplicasMap集合，它是一个用来存储损坏数据块Block实例与它对应每个数据节点和损坏原因集合的映射关系的集合。

 

        我们看下CorruptReplicasMap都提供了哪些有用的方法。

        一、addToCorruptReplicasMap()

        标记属于指定数据节点的数据块为损坏

/**
 * Mark the block belonging to datanode as corrupt.
 * 标记属于指定数据节点的数据块为损坏
 *
 * @param blk Block to be added to CorruptReplicasMap
 * @param dn DatanodeDescriptor which holds the corrupt replica
 * @param reason a textual reason (for logging purposes)
 * @param reasonCode the enum representation of the reason
 */
void addToCorruptReplicasMap(Block blk, DatanodeDescriptor dn,
    String reason, Reason reasonCode) {

/ 先从corruptReplicasMap集合中查找是否存在对应数据块blk
  Map <DatanodeDescriptor, Reason> nodes = corruptReplicasMap.get(blk);

  // 如果不存在，构造一个HashMap<DatanodeDescriptor, Reason>集合nodes，将blk与nodes存入corruptReplicasMap
  if (nodes == null) {
    nodes = new HashMap<DatanodeDescriptor, Reason>();
    corruptReplicasMap.put(blk, nodes);
  }

  String reasonText;
  if (reason != null) {
    reasonText = " because " + reason;
  } else {
    reasonText = "";
  }

  // 判断nodes中是否存在对应数据节点dn，分别记录日志信息
  if (!nodes.keySet().contains(dn)) {
    NameNode.blockStateChangeLog.info("BLOCK NameSystem.addToCorruptReplicasMap: "+
                                 blk.getBlockName() +
                                 " added as corrupt on " + dn +
                                 " by " + Server.getRemoteIp() +
                                 reasonText);
  } else {

    NameNode.blockStateChangeLog.info("BLOCK NameSystem.addToCorruptReplicasMap: "+
                                 "duplicate requested for " +
                                 blk.getBlockName() + " to add as corrupt " +
                                 "on " + dn +
                                 " by " + Server.getRemoteIp() +
                                 reasonText);
  }

  // Add the node or update the reason.
  // 将数据节点dn、损坏原因编码reasonCode加入或更新入nodes
  nodes.put(dn, reasonCode);
}

        处理逻辑很简单，大体如下：

 

        1、先从corruptReplicasMap集合中查找是否存在对应数据块blk；

        2、如果不存在，构造一个HashMap<DatanodeDescriptor, Reason>集合nodes，将blk与nodes存入corruptReplicasMap；

        3、判断nodes中是否存在对应数据节点dn，分别记录日志信息；

        4、将数据节点dn、损坏原因编码reasonCode加入或更新入nodes。

        二、removeFromCorruptReplicasMap()

        将指定数据块、数据节点，根据指定原因从集合corruptReplicasMap移除

// 将指定数据块、数据节点，根据指定原因从集合corruptReplicasMap移除
boolean removeFromCorruptReplicasMap(Block blk, DatanodeDescriptor datanode,
    Reason reason) {

/ 先从corruptReplicasMap集合中查找是否存在对应数据块blk，获得datanodes
  Map <DatanodeDescriptor, Reason> datanodes = corruptReplicasMap.get(blk);

  // 如果不存在，直接返回false，表明移除失败
  if (datanodes==null)
    return false;

  // if reasons can be compared but don't match, return false.

  // 取出数据节点datanode对应的存储损坏原因storedReason
  Reason storedReason = datanodes.get(datanode);

  // 判断存储损坏原因storedReason与参数损坏原因reason是否一致，不一致直接返回false，表明移除失败，
  // 判断的依据为参数损坏原因reason不是ANY且存储损坏原因storedReason不为空的情况下，两者不一致
  if (reason != Reason.ANY && storedReason != null &&
      reason != storedReason) {
    return false;
  }

  // 将datanode对应数据从datanodes中移除
  if (datanodes.remove(datanode) != null) { // remove the replicas

    // 移除datanode后，如果datanodes为空
    if (datanodes.isEmpty()) {
      // remove the block if there is no more corrupted replicas
    // 将数据块blk从集合corruptReplicasMap中移除
      corruptReplicasMap.remove(blk);
    }

    // 返回true，表明移除成功
    return true;
  }

  // 其他情况下直接返回false，表明移除失败
  return false;
}

        三、getCorruptReplicaBlockIds()

 

        获取指定大小和起始数据块ID的损坏数据块ID数组

 

/**
 * Return a range of corrupt replica block ids. Up to numExpectedBlocks
 * blocks starting at the next block after startingBlockId are returned
 * (fewer if numExpectedBlocks blocks are unavailable). If startingBlockId
 * is null, up to numExpectedBlocks blocks are returned from the beginning.
 * If startingBlockId cannot be found, null is returned.
 * 获取指定大小和起始数据块ID的损坏数据块ID数组
 *
 * @param numExpectedBlocks Number of block ids to return.
 *  0 <= numExpectedBlocks <= 100
 * @param startingBlockId Block id from which to start. If null, start at
 *  beginning.
 * @return Up to numExpectedBlocks blocks from startingBlockId if it exists
 *
 */
long[] getCorruptReplicaBlockIds(int numExpectedBlocks,
                                 Long startingBlockId) {

/ 校验numExpectedBlocks，需要获取的数据块ID数组最多有100个元素
  if (numExpectedBlocks < 0 || numExpectedBlocks > 100) {
    return null;
  }

  // 获得corruptReplicasMap集合的数据块迭代器blockIt
  Iterator<Block> blockIt = corruptReplicasMap.keySet().iterator();

  // if the starting block id was specified, iterate over keys until
  // we find the matching block. If we find a matching block, break
  // to leave the iterator on the next block after the specified block.

  // 如果设定了起始数据块艾迪startingBlockId
  if (startingBlockId != null) {
    boolean isBlockFound = false;

    // 遍历corruptReplicasMap，查看是否存在startingBlockId，如果存在，跳出循环，此时已记录住迭代器的位置了
    while (blockIt.hasNext()) {
      Block b = blockIt.next();
      if (b.getBlockId() == startingBlockId) {
        isBlockFound = true;
        break;
      }
    }

    // 如果不存在，直接返回null
    if (!isBlockFound) {
      return null;
    }
  }

  // 构造一个存储数据块ID的列表corruptReplicaBlockIds
  ArrayList<Long> corruptReplicaBlockIds = new ArrayList<Long>();

  // append up to numExpectedBlocks blockIds to our list

  // 遍历corruptReplicasMap，将最多numExpectedBlocks个数据块ID添加到列表corruptReplicaBlockIds，
  // 此时的迭代器可能不是从头开始取数据的，在startingBlockId需要并存在的情况下，它是从下一个元素开始获取的
  for(int i=0; i<numExpectedBlocks && blockIt.hasNext(); i++) {
    corruptReplicaBlockIds.add(blockIt.next().getBlockId());
  }

  // 将数据块ID列表corruptReplicaBlockIds转换成数组ret
  long[] ret = new long[corruptReplicaBlockIds.size()];
  for(int i=0; i<ret.length; i++) {
    ret[i] = corruptReplicaBlockIds.get(i);
  }

  // 返回数据块ID数组ret
  return ret;
}

        四、getNodes()

 

        根据损坏数据块获取对应数据节点集合

/**
 * Get Nodes which have corrupt replicas of Block
 * 根据损坏数据块获取对应数据节点集合
 *
 * @param blk Block for which nodes are requested
 * @return collection of nodes. Null if does not exists
 */
Collection<DatanodeDescriptor> getNodes(Block blk) {
  Map <DatanodeDescriptor, Reason> nodes = corruptReplicasMap.get(blk);
  if (nodes == null)
    return null;
  return nodes.keySet();
}

        五、isReplicaCorrupt()

 

        检测指定数据块和数据节点是否为损坏的

 

/**
 * Check if replica belonging to Datanode is corrupt
 * 检测指定数据块和数据节点是否为损坏的
 *
 * @param blk Block to check
 * @param node DatanodeDescriptor which holds the replica
 * @return true if replica is corrupt, false if does not exists in this map
 */
boolean isReplicaCorrupt(Block blk, DatanodeDescriptor node) {
  Collection<DatanodeDescriptor> nodes = getNodes(blk);
  return ((nodes != null) && (nodes.contains(node)));
}

        六、numCorruptReplicas()

 

        获取给定数据块对应数据节点数量

 

// 获取给定数据块对应数据节点数量
int numCorruptReplicas(Block blk) {
  Collection<DatanodeDescriptor> nodes = getNodes(blk);
  return (nodes == null) ? 0 : nodes.size();
}

        七、size()

 

        获取损坏数据块数量

// 获取损坏数据块数量
int size() {
  return corruptReplicasMap.size();
}