HDFS源码分析EditLog之读取操作符

 在《HDFS源码分析EditLog之获取编辑日志输入流》一文中，我们详细了解了如何获取编辑日志输入流EditLogInputStream。在我们得到编辑日志输入流后，是不是就该从输入流中获取数据来处理呢？答案是显而易见的！在《HDFS源码分析之EditLogTailer》一文中，我们在讲编辑日志追踪同步时，也讲到了如下两个连续的处理流程：

        4、从编辑日志editLog中获取编辑日志输入流集合streams，获取的输入流为最新事务ID加1之后的数据
        5、调用文件系统镜像FSImage实例image的loadEdits()，利用编辑日志输入流集合streams，加载编辑日志至目标namesystem中的文件系统镜像FSImage，并获得编辑日志加载的大小editsLoaded；

        可见，我们在获得编辑日志输入流EditLogInputStream的集合streams后，就需要调用FSImage的loadEdits()方法，利用编辑日志输入流集合streams，加载编辑日志至目标namesystem中的文件系统镜像FSImage。而HDFS是如何从编辑日志输入流中读取数据的呢？本文，我们将进行详细的探究！

        首先，在加载编辑日志的主要类FSEditLogLoader中，其核心方法loadEditRecords()中有如下一段代码：

 

while (true) {
  try {
    FSEditLogOp op;
    try {

    // 从编辑日志输入流in中读取操作符op
      op = in.readOp();

      // 如果操作符op为空，直接跳出循环，并返回
      if (op == null) {
        break;
      }
    } catch (Throwable e) {
      // ...省略部分代码
    }

    // ...省略部分代码

    try {
      // ...省略部分代码
      long inodeId = applyEditLogOp(op, fsDir, startOpt,
          in.getVersion(true), lastInodeId);
      if (lastInodeId < inodeId) {
        lastInodeId = inodeId;
      }
    } catch (RollingUpgradeOp.RollbackException e) {
      // ...省略部分代码
    } catch (Throwable e) {
      // ...省略部分代码
    }
    // ...省略部分代码
  } catch (RollingUpgradeOp.RollbackException e) {
    // ...省略部分代码
  } catch (MetaRecoveryContext.RequestStopException e) {
    // ...省略部分代码
  }
}

        它会从编辑日志输入流in中读取一个操作符op，然后调用applyEditLogOp()方法，将操作符作用于内存元数据FSNamesystem。那么问题来了，这个操作符如何从数据流中被读取并解析的呢？

        接下来，我们就看下如何从编辑日志输出流EditLogInputStream中读取一个操作符，我们先看其readOp()方法，代码如下：

 

/**
 * Read an operation from the stream
 * @return an operation from the stream or null if at end of stream
 * @throws IOException if there is an error reading from the stream
 */
public FSEditLogOp readOp() throws IOException {
  FSEditLogOp ret;

  // 如果缓存的cachedOp不为null，返回缓存的cachedOp，并将其清空
  if (cachedOp != null) {
    ret = cachedOp;
    cachedOp = null;
    return ret;
  }

  // 如果缓存的cachedOp为null，调用nextOp()进行处理
  return nextOp();
}

        很简单，如果缓存的cachedOp不为null，返回缓存的cachedOp，并将其清空，如果缓存的cachedOp为null，则调用nextOp()进行处理。而EditLogInputStream中nextOp()是一个抽象方法，我们需要看其子类的实现方法，下面就以EditLogFileInputStream为例，看下其nextOp()方法：

 

 

@Override
protected FSEditLogOp nextOp() throws IOException {
  return nextOpImpl(false);
}

        继续追踪nextOpImpl()方法，代码如下：

 

 

private FSEditLogOp nextOpImpl(boolean skipBrokenEdits) throws IOException {
  FSEditLogOp op = null;

  // 根据编辑日志文件输入流的状态判断：
  switch (state) {
  case UNINIT:// 如果为未初始化状态UNINIT
    try {
    // 调用init()方法进行初始化
      init(true);
    } catch (Throwable e) {
      LOG.error("caught exception initializing " + this, e);
      if (skipBrokenEdits) {
        return null;
      }
      Throwables.propagateIfPossible(e, IOException.class);
    }

    // 检测编辑日志文件输入流状态，此时不应为UNINIT
    Preconditions.checkState(state != State.UNINIT);

    // 再次调用nextOpImpl()方法
    return nextOpImpl(skipBrokenEdits);
  case OPEN:// 如果为打开OPEN状态

    // 调用FSEditLogOp.Reader的readOp()方法，读取操作符
    op = reader.readOp(skipBrokenEdits);
    if ((op != null) && (op.hasTransactionId())) {
      long txId = op.getTransactionId();
      if ((txId >= lastTxId) &&
          (lastTxId != HdfsConstants.INVALID_TXID)) {
        //
        // Sometimes, the NameNode crashes while it's writing to the
        // edit log.  In that case, you can end up with an unfinalized edit log
        // which has some garbage at the end.
        // JournalManager#recoverUnfinalizedSegments will finalize these
        // unfinished edit logs, giving them a defined final transaction
        // ID.  Then they will be renamed, so that any subsequent
        // readers will have this information.
        //
        // Since there may be garbage at the end of these "cleaned up"
        // logs, we want to be sure to skip it here if we've read everything
        // we were supposed to read out of the stream.
        // So we force an EOF on all subsequent reads.
        //
        long skipAmt = log.length() - tracker.getPos();
        if (skipAmt > 0) {
          if (LOG.isDebugEnabled()) {
              LOG.debug("skipping " + skipAmt + " bytes at the end " +
                "of edit log  '" + getName() + "': reached txid " + txId +
                " out of " + lastTxId);
          }
          tracker.clearLimit();
          IOUtils.skipFully(tracker, skipAmt);
        }
      }
    }
    break;
    case CLOSED: // 如果为关闭CLOSED状态，直接返回null
      break; // return null
  }
  return op;
}

        nextOpImpl()方法的大体处理逻辑如下：

 

        根据编辑日志文件输入流的状态判断：

        1、如果为未初始化状态UNINIT，调用init()方法进行初始化，然后检测编辑日志文件输入流状态，此时不应为UNINIT，最后再次调用nextOpImpl()方法；

        2、如果为打开OPEN状态，调用FSEditLogOp.Reader的readOp()方法，读取操作符op；

        3、如果为关闭CLOSED状态，直接返回null。

        我们重点关注下FSEditLogOp.Reader的readOp()方法，代码如下：

 

/**
 * Read an operation from the input stream.
 *
 * Note that the objects returned from this method may be re-used by future
 * calls to the same method.
 *
 * @param skipBrokenEdits    If true, attempt to skip over damaged parts of
 * the input stream, rather than throwing an IOException
 * @return the operation read from the stream, or null at the end of the
 *         file
 * @throws IOException on error.  This function should only throw an
 *         exception when skipBrokenEdits is false.
 */
public FSEditLogOp readOp(boolean skipBrokenEdits) throws IOException {
  while (true) {
    try {

      // 调用decodeOp()方法
      return decodeOp();
    } catch (IOException e) {
      in.reset();
      if (!skipBrokenEdits) {
        throw e;
      }
    } catch (RuntimeException e) {
      // FSEditLogOp#decodeOp is not supposed to throw RuntimeException.
      // However, we handle it here for recovery mode, just to be more
      // robust.
      in.reset();
      if (!skipBrokenEdits) {
        throw e;
      }
    } catch (Throwable e) {
      in.reset();
      if (!skipBrokenEdits) {
        throw new IOException("got unexpected exception " +
            e.getMessage(), e);
      }
    }
    // Move ahead one byte and re-try the decode process.
    if (in.skip(1) < 1) {
      return null;
    }
  }
}

        继续追踪decodeOp()方法，代码如下：

 

 

/**
 * Read an opcode from the input stream.
 * 从输入流中读取一个操作符code
 *
 * @return   the opcode, or null on EOF.
 *
 * If an exception is thrown, the stream's mark will be set to the first
 * problematic byte.  This usually means the beginning of the opcode.
 */
private FSEditLogOp decodeOp() throws IOException {
  limiter.setLimit(maxOpSize);
  in.mark(maxOpSize);

  if (checksum != null) {
    checksum.reset();
  }

  byte opCodeByte;
  try {

    // 从输入流in中读取一个byte，即opCodeByte
    opCodeByte = in.readByte();
  } catch (EOFException eof) {
    // EOF at an opcode boundary is expected.
    return null;
  }

  // 将byte类型的opCodeByte转换成FSEditLogOpCodes对象opCode
  FSEditLogOpCodes opCode = FSEditLogOpCodes.fromByte(opCodeByte);
  if (opCode == OP_INVALID) {
    verifyTerminator();
    return null;
  }

  // 根据FSEditLogOpCodes对象opCode从cache中获取FSEditLogOp对象op
  FSEditLogOp op = cache.get(opCode);
  if (op == null) {
    throw new IOException("Read invalid opcode " + opCode);
  }

  // 如果支持编辑日志长度，从输入流读入一个int，
  if (supportEditLogLength) {
    in.readInt();
  }

  if (NameNodeLayoutVersion.supports(
      LayoutVersion.Feature.STORED_TXIDS, logVersion)) {
    // Read the txid
    // 如果支持事务ID，读入一个long，作为事务ID，并在FSEditLogOp实例op中设置事务ID
    op.setTransactionId(in.readLong());
  } else {
    // 如果不支持事务ID，在FSEditLogOp实例op中设置事务ID为-12345
    op.setTransactionId(HdfsConstants.INVALID_TXID);
  }

  // 从输入流in中读入其他域，并设置入FSEditLogOp实例op
  op.readFields(in, logVersion);

  validateChecksum(in, checksum, op.txid);
  return op;
}

        decodeOp()方法的逻辑很简单：

 

        1、从输入流in中读取一个byte，即opCodeByte，确定操作类型；

        2、将byte类型的opCodeByte转换成FSEditLogOpCodes对象opCode；

        3、根据FSEditLogOpCodes对象opCode从cache中获取FSEditLogOp对象op，这样我们就得到了操作符对象；

        4、如果支持编辑日志长度，从输入流读入一个int；

        5、如果支持事务ID，读入一个long，作为事务ID，并在FSEditLogOp实例op中设置事务ID，否则在FSEditLogOp实例op中设置事务ID为-12345；

        6、调用操作符对象op的readFields()方法，从输入流in中读入其他域，并设置入FSEditLogOp实例op。

        接下来，我们再看下操作符对象的readFields()方法，因为不同种类的操作符肯定包含不同的属性，所以它们的readFields()方法肯定也各不相同。下面，我们就以操作符AddCloseOp为例来分析，其readFields()方法如下：

 

@Override
void readFields(DataInputStream in, int logVersion)
    throws IOException {

  // 读取长度：如果支持读入长度，从输入流in读取一个int，赋值给length
  if (!NameNodeLayoutVersion.supports(
      LayoutVersion.Feature.EDITLOG_OP_OPTIMIZATION, logVersion)) {
    this.length = in.readInt();
  }

  // 读取节点ID：如果支持读入节点ID，从输入流in读取一个long，赋值给inodeId，否则inodeId默认为0
  if (NameNodeLayoutVersion.supports(
      LayoutVersion.Feature.ADD_INODE_ID, logVersion)) {
    this.inodeId = in.readLong();
  } else {
    // The inodeId should be updated when this editLogOp is applied
    this.inodeId = INodeId.GRANDFATHER_INODE_ID;
  }

  // 版本兼容性校验
  if ((-17 < logVersion && length != 4) ||
      (logVersion <= -17 && length != 5 && !NameNodeLayoutVersion.supports(
          LayoutVersion.Feature.EDITLOG_OP_OPTIMIZATION, logVersion))) {
    throw new IOException("Incorrect data format."  +
                          " logVersion is " + logVersion +
                          " but writables.length is " +
                          length + ". ");
  }

  // 读取路径：从输入流in读取一个String，赋值给path
  this.path = FSImageSerialization.readString(in);

  // 读取副本数、修改时间：如果支持读取副本数、修改时间，分别从输入流读取一个short、long，
  // 赋值给replication、mtime
  if (NameNodeLayoutVersion.supports(
      LayoutVersion.Feature.EDITLOG_OP_OPTIMIZATION, logVersion)) {
    this.replication = FSImageSerialization.readShort(in);
    this.mtime = FSImageSerialization.readLong(in);
  } else {
    this.replication = readShort(in);
    this.mtime = readLong(in);
  }

  // 读取访问时间：如果支持读取访问时间，从输入流读取一个long，赋值给atime，否则atime默认为0
  if (NameNodeLayoutVersion.supports(
      LayoutVersion.Feature.FILE_ACCESS_TIME, logVersion)) {
    if (NameNodeLayoutVersion.supports(
        LayoutVersion.Feature.EDITLOG_OP_OPTIMIZATION, logVersion)) {
      this.atime = FSImageSerialization.readLong(in);
    } else {
      this.atime = readLong(in);
    }
  } else {
    this.atime = 0;
  }

  // 读取数据块大小：如果支持读取数据块大小，从输入流读取一个long，赋值给blockSize
  if (NameNodeLayoutVersion.supports(
      LayoutVersion.Feature.EDITLOG_OP_OPTIMIZATION, logVersion)) {
    this.blockSize = FSImageSerialization.readLong(in);
  } else {
    this.blockSize = readLong(in);
  }

  // 调用readBlocks()方法读取数据块，赋值给数据块数组blocks
  this.blocks = readBlocks(in, logVersion);

  // 从输入流读入权限，赋值给permissions
  this.permissions = PermissionStatus.read(in);

  // 如果是ADD操作，需要额外处理客户端名称clientName、客户端机器clientMachine、覆盖写标志overwrite等属性
  if (this.opCode == OP_ADD) {
    aclEntries = AclEditLogUtil.read(in, logVersion);
    this.xAttrs = readXAttrsFromEditLog(in, logVersion);
    this.clientName = FSImageSerialization.readString(in);
    this.clientMachine = FSImageSerialization.readString(in);
    if (NameNodeLayoutVersion.supports(
        NameNodeLayoutVersion.Feature.CREATE_OVERWRITE, logVersion)) {
      this.overwrite = FSImageSerialization.readBoolean(in);
    } else {
      this.overwrite = false;
    }
    if (NameNodeLayoutVersion.supports(
        NameNodeLayoutVersion.Feature.BLOCK_STORAGE_POLICY, logVersion)) {
      this.storagePolicyId = FSImageSerialization.readByte(in);
    } else {
      this.storagePolicyId = BlockStoragePolicySuite.ID_UNSPECIFIED;
    }
    // read clientId and callId
    readRpcIds(in, logVersion);
  } else {
    this.clientName = "";
    this.clientMachine = "";
  }
}

        这个没有什么特别好讲的，依次读入操作符需要的，在输入流中依次存在的属性即可。
        不过，我们仍然需要重点讲解下读入数据块的readBlocks()方法，代码如下：

 

 

private static Block[] readBlocks(
    DataInputStream in,
    int logVersion) throws IOException {

  // 读取block数目numBlocks，占一个int
  int numBlocks = in.readInt();

  // 校验block数目numBlocks，应大于等于0，小于等于1024 * 1024 * 64
  if (numBlocks < 0) {
    throw new IOException("invalid negative number of blocks");
  } else if (numBlocks > MAX_BLOCKS) {
    throw new IOException("invalid number of blocks: " + numBlocks +
        ".  The maximum number of blocks per file is " + MAX_BLOCKS);
  }

  // 构造block数组blocks，大小即为numBlocks
  Block[] blocks = new Block[numBlocks];

  // 从输入流中读取numBlocks个数据块
  for (int i = 0; i < numBlocks; i++) {

    // 构造数据块Block实例blk
    Block blk = new Block();

    // 调用Block的readFields()方法，从输入流读入数据块
    blk.readFields(in);

    // 将数据块blk放入数据块数组blocks
    blocks[i] = blk;
  }

  // 返回数据块数组blocks
  return blocks;
}

        很简单，先从输入流读取block数目numBlocks，确定一共需要读取多少个数据块，然后构造block数组blocks，大小即为numBlocks，最后从输入流中读取numBlocks个数据块，每次都是先构造数据块Block实例blk，调用Block的readFields()方法，从输入流读入数据块，然后将数据块blk放入数据块数组blocks。全部数据块读取完毕后，返回数据块数组blocks。

        我们再看下数据块Block的readFields()方法，如下：

 

@Override // Writable
public void readFields(DataInput in) throws IOException {
  readHelper(in);
}

        继续看readHelper()方法，如下：

 

 

 final void readHelper(DataInput in) throws IOException {
   // 从输入流读取一个long，作为数据块艾迪blockId
this.blockId = in.readLong();
// 从输入流读取一个long，作为数据块大小numBytes
   this.numBytes = in.readLong();
   // 从输入流读取一个long，作为数据块产生的时间戳generationStamp
   this.generationStamp = in.readLong();

   // 校验：数据块大小numBytes应大于等于0
   if (numBytes < 0) {
     throw new IOException("Unexpected block size: " + numBytes);
   }
 }

        从输入流依次读入数据块艾迪blockId、数据块大小numBytes、数据块产生的时间戳generationStamp即可，三者均为long类型。