DelayedFetch分析

DelayedFetch是FecthRequest对应的延迟操作，和DelayedProduce类似，他的流程是：来自消费者或者其他follower replica的请求到来，会交给KafkaApi的handleFetchRequest处理，然后他会调用Replica

Manager的fetchMessage方法对应Log中读取消息，并生成Delayed

Fetch添加到delayedFetchPurgatory中处理

我们先看一下ReplicaManager#fetchMessage的逻辑：

def fetchMessages(timeout: Long, replicaId: Int, fetchMinBytes: Int, fetchMaxBytes: Int, hardMaxBytesLimit: Boolean,
  fetchInfos: Seq[(TopicAndPartition, PartitionFetchInfo)], quota: ReplicaQuota = UnboundedQuota,
  responseCallback: Seq[(TopicAndPartition, FetchResponsePartitionData)] => Unit) {
  val isFromFollower = replicaId >= 0
  val fetchOnlyFromLeader: Boolean = replicaId != Request.DebuggingConsumerId
  val fetchOnlyCommitted: Boolean = ! Request.isValidBrokerId(replicaId)

  // 从本地日志读取文件
  val logReadResults = readFromLocalLog(
    replicaId = replicaId,
    fetchOnlyFromLeader= fetchOnlyFromLeader,
    readOnlyCommitted= fetchOnlyCommitted,
    fetchMaxBytes= fetchMaxBytes,
    hardMaxBytesLimit= hardMaxBytesLimit,
    readPartitionInfo= fetchInfos,
    quota = quota)

  // 如果fetch请求来自follower，则更新它的LOE
  if(Request.isValidBrokerId(replicaId))
    /*
     * 主要逻辑：
     * 1 在leader中维护了follower副本各个状态，这里会更新对应follower的状态比如LEO等
     * 2 检测是否需要对ISR进行扩张，如果ISR发生变化，则将ISR集合变化记录保存到zookeeper
     * 3 检测是否后移HighWatermark
     * 4 检测delayedProducePurgatory中相关key对应的DelayedProduce，如果满足则执行完成
     */
    updateFollowerLogReadResults(replicaId, logReadResults)

  // 获取从日志读取到的总字节数
  val logReadResultValues = logReadResults.map { case (_, v) => v }
  // 统计读取到的总字节数
  val bytesReadable = logReadResultValues.map(_.info.messageSet.sizeInBytes).sum
  // 检查读取结果是否有错误
  val errorReadingData = logReadResultValues.foldLeft(false) ((errorIncurred, readResult) =>
    errorIncurred|| (readResult.errorCode != Errors.NONE.code))

  /*
   * 判断是否能够立即返回FetchResponse
   * 1 不想等待，需要立即返回的
   * 2 FetchRequest没有指定要读取的分区
   * 3 数据已经够了
   * 4 读取数据时候发生了错误，即检查errorReadingData
   */
  if (timeout <= 0 || fetchInfos.isEmpty || bytesReadable >= fetchMinBytes || errorReadingData) {
    val fetchPartitionData = logReadResults.map { case (tp, result) =>
      tp -> FetchResponsePartitionData(result.errorCode, result.hw, result.info.messageSet)
    }
    // 直接调用回调函数
    responseCallback(fetchPartitionData)
  } else {
    // 封装返回结果
    val fetchPartitionStatus = logReadResults.map { case (topicAndPartition, result) =>
      val fetchInfo = fetchInfos.collectFirst {
        case (tp, v) if tp == topicAndPartition => v
      }.getOrElse(sys.error(s"Partition $topicAndPartition not found in fetchInfos"))
      (topicAndPartition, FetchPartitionStatus(result.info.fetchOffsetMetadata, fetchInfo))
    }
    // 构造FetchMetadata对象
    val fetchMetadata = FetchMetadata(fetchMinBytes, fetchMaxBytes, hardMaxBytesLimit, fetchOnlyFromLeader,
      fetchOnlyCommitted, isFromFollower, replicaId, fetchPartitionStatus)
    // 构造一个DelayedFetdch对象
    val delayedFetch = new DelayedFetch(timeout, fetchMetadata, this, quota, responseCallback)

    // 创建一个(topic, partition)键值对对形式的列表作为delayed fetch操作的key
    val delayedFetchKeys = fetchPartitionStatus.map { case (tp, _) => new TopicPartitionOperationKey(tp) }
    // 尝试立即完成当前的请求，否则放入purgatory
    delayedFetchPurgatory.tryCompleteElseWatch(delayedFetch, delayedFetchKeys)
  }
}

一 DelayedProduce 和 DelayedFetch之间的关系

在处理ProdcueRequest的过程中向Log添加数据，可能会后移leader的log end offset,follower副本就可以读取到足量的数据，所以会尝试DelayedFetch;

在处理来自follower或者消费者FetchRequest可能会后移HW,所以会尝试完成DelayedProduce

 

二 核心字段

delayMs: 延迟操作的时长

fetchMetadata: FetchMetadata 为FetchRequest中所有相关分区记录相关状态，主要用于判断DelayedProduce是否满足执行条件

responseCallback: 任务满足条件或到期执行在DelayedFetch#onCom

plete调用的回调函数，其主要功能是创建FetchResponse并添加到RequestChannel的responseQueue队列

 

三 重要方法

DelayedFetch的tryComplete方法主要负责检测DelayedFetch的执行条件，并在满足DelayedFetch的执行条件：

# 发生leader副本迁移，该节点不再是leader副本

# 当前节点找不到需要读取数据的分区

# 开始读取的offset不在新的activeSegment中，此时可能发生了log截断或者日志滚动产生了新的LogSegment

# 累计读取的字节数超过最小字节数

override def tryComplete() : Boolean = {
  var accumulatedSize = 0 // 累计的字节数
  var accumulatedThrottledSize = 0
  // 遍历FetchMetadata中所有的Partition状态
  fetchMetadata.fetchPartitionStatus.foreach {
    case (topicAndPartition, fetchStatus) =>
      // 获取之前读取log的结束位置
      val fetchOffset = fetchStatus.startOffsetMetadata
      try {
        if (fetchOffset != LogOffsetMetadata.UnknownOffsetMetadata) {
          // 查找partition的分区副本
          val replica = replicaManager.getLeaderReplicaIfLocal(topicAndPartition.topic, topicAndPartition.partition)
          // 根据FetchRequest的请求来源不同设置endOffset（读取日志结束位置）
          // 消费者对应endOffset是HW，而生产者对应的endOffset是LOE
          val endOffset =
            if (fetchMetadata.fetchOnlyCommitted)
              replica.highWatermark
            else
              replica.logEndOffset

          // 检查之前读取的endOffset是否发生变化，如果没变之前读不到足够数据现在还是读不到，任务条件依然不满足；如果变了则继续下面的检查看是否
          // 真正满足任务执行条件
          if (endOffset.messageOffset != fetchOffset.messageOffset) {
            if (endOffset.onOlderSegment(fetchOffset)) {
              // endOffset出现减小的情况，跑到了baseOffset较小的Segment上，可能是leader副本日志出现了截断
              debug("Satisfying fetch %s since it is fetching later segments of partition %s.".format(fetchMetadata, topicAndPartition))
              return forceComplete()
            } else if (fetchOffset.onOlderSegment(endOffset)) {
              // fetchOffset在新的endOffset之前，但是产生了新的activeSegment，fetchOffset在较旧的LogSegmnet,但是endOffset在新的LogSegment
              debug("Satisfying fetch %s immediately since it is fetching older segments.".format(fetchMetadata))
              // We will not force complete the fetch request if a replica should be throttled.
              if (!replicaManager.shouldLeaderThrottle(quota, topicAndPartition, fetchMetadata.replicaId))
                return forceComplete()
            } else if (fetchOffset.messageOffset < endOffset.messageOffset) {
              // endOffset和fetchOffset在同一个LogSegment且endOffset向后移动，那就尝试计算累计的字节数
              val bytesAvailable = math.min(endOffset.positionDiff(fetchOffset), fetchStatus.fetchInfo.fetchSize)
              if (quota.isThrottled(topicAndPartition))
                accumulatedThrottledSize += bytesAvailable
              else
                accumulatedSize += bytesAvailable // 累加字节数
            }
          }
        }
      } catch {
        case utpe: UnknownTopicOrPartitionException => // Case B
          debug("Broker no longer know of %s, satisfy %s immediately".format(topicAndPartition, fetchMetadata))
          return forceComplete()
        case nle: NotLeaderForPartitionException =>  // Case A
          debug("Broker is no longer the leader of %s, satisfy %s immediately".format(topicAndPartition, fetchMetadata))
          return forceComplete()
      }
  }

  // 累计的字节数足够，调用forceComplete方法
  if (accumulatedSize >= fetchMetadata.fetchMinBytes
    || ((accumulatedSize + accumulatedThrottledSize) >= fetchMetadata.fetchMinBytes && !quota.isQuotaExceeded()))
    forceComplete()
  else
    false
}