TopicDeletionManager分析

TopicDeletionManager主要用于管理删除topic的状态机。

一 核心字段

controllerContext: ControllerContext 用于维护KafkaController中上下文信息

partitionStateMachine: PartitionStateMachinepartition状态机

replicaStateMachine： ReplicaStateMahcine replica 状态机

topicsToBeDeleted：Set[String] 记录将要被删除topic集合

partitionsToBeDeleted:Set[TopicAndPartition] 记录将要被删除partition集合

topicsIneligibleForDeletion:Set[String] 用于记录不可删除的集合

deleteTopicStateChanged：AtomicBoolean 用于标记topic删除操作是否开始

deleteTopicsThread：DeleteTopicsThread 用于删除topic的后台线程

isDeleteTopicEnabled：Boolean  是否允许删除topic

 

二 重要方法

2.1 start方法

defstart() {
  // 判断是否支持删除topic
  if (isDeleteTopicEnabled) {
    // 创建DeleteTopicsThread线程对象
    deleteTopicsThread= new DeleteTopicsThread()
    // 如果已经存在将要被删除的topic
    if (topicsToBeDeleted.nonEmpty)
      // 标记删除操作开始
      deleteTopicStateChanged.set(true)
    // 启动线程
    deleteTopicsThread.start()
  }
}

 

2.2 DeleteTopicsThread的doWork方法使我们进行删除操作的入口方法

 

第一：获取待删除的topic的分区集合，发送UpdateMetadataCache

Request发送给所有的broker

private def onTopicDeletion(topics: Set[String]) {
  info("Topic deletion callback for %s".format(topics.mkString(",")))
  // 获取topic分区
  val partitions = topics.flatMap(controllerContext.partitionsForTopic)
  // 发送UpdateMetadataRequest请求
  controller.sendUpdateMetadataRequest(controllerContext.liveOrShuttingDownBrokerIds.toSeq, partitions)
  // 获取所有AR并且按照topic分区
  val partitionReplicaAssignmentByTopic = controllerContext.partitionReplicaAssignment.groupBy(p => p._1.topic)
  topics.foreach { topic =>
      // 传入指定topic的AR副本集，开始分区的删除操作
    onPartitionDeletion(partitionReplicaAssignmentByTopic(topic).keySet)
  }
}

 

第二：调用onPartitionDeletion方法开始对指定分区进行删除

将不可用副本转化为ReplicaDeletionIneligible状态；

将可用副本转化为OfflineReplica状态，而且还会发送StopReplica

Request请求到带删除的副本，同时还会向broker发送跟新元数据的请求，将副本从ISR列表移除；

将可用副本由OfflineReplica转化为ReplicationDeletionStarted。

 

private def onPartitionDeletion(partitionsToBeDeleted: Set[TopicAndPartition]) {
  info("Partition deletion callback for %s".format(partitionsToBeDeleted.mkString(",")))
  // 获取每一个分区的副本
  val replicasPerPartition = controllerContext.replicasForPartition(partitionsToBeDeleted)
  // 开始删除
  startReplicaDeletion(replicasPerPartition)
}

 

 

private def startReplicaDeletion(replicasForTopicsToBeDeleted: Set[PartitionAndReplica]) {
  // 将要被删除的topic对应的分区副本按照topic分组
  replicasForTopicsToBeDeleted.groupBy(_.topic).foreach { case(topic, replicas) =>
    // 获取topic中所有可用的副本
    var aliveReplicasForTopic = controllerContext.allLiveReplicas().filter(p => p.topic.equals(topic))
    // 获取不可用的副本
    val deadReplicasForTopic = replicasForTopicsToBeDeleted -- aliveReplicasForTopic
    val successfullyDeletedReplicas = controller.replicaStateMachine.replicasInState(topic, ReplicaDeletionSuccessful)
    // 第一次删除的副本集合
    val replicasForDeletionRetry = aliveReplicasForTopic -- successfullyDeletedReplicas
    // 将不可用副本转换为ReplicaDeletionIneligible状态
    replicaStateMachine.handleStateChanges(deadReplicasForTopic, ReplicaDeletionIneligible)
    // 将待删除副本转化为OfflineReplica
    replicaStateMachine.handleStateChanges(replicasForDeletionRetry, OfflineReplica)
    debug("Deletion started for replicas %s".format(replicasForDeletionRetry.mkString(",")))
    // 将待删除副本转化为ReplicaDeletionStarted
    controller.replicaStateMachine.handleStateChanges(replicasForDeletionRetry, ReplicaDeletionStarted,
      new Callbacks.CallbackBuilder().stopReplicaCallback(deleteTopicStopReplicaCallback).build)
    if(deadReplicasForTopic.nonEmpty) {
      debug("Dead Replicas (%s) found for topic %s".format(deadReplicasForTopic.mkString(","), topic))
      // 如果有副本挂掉，标记不能删除
      markTopicIneligibleForDeletion(Set(topic))
    }
  }
}

 

第三 ： 调用StopReplicaResponse错误吗正常，则将副本转化为ReplicaDeletionSuccessful状态，否则转化为ReplicaDeletionIneligible状态，并标记该副本所在topic不能被删除，将该topic添加到topics

IneligibleForDeletion队列，最后唤醒DeleteTopicsThread

private def deleteTopicStopReplicaCallback(stopReplicaResponseObj: AbstractRequestResponse, replicaId: Int) {
  // 获取StopReplicaResponse响应
  val stopReplicaResponse = stopReplicaResponseObj.asInstanceOf[StopReplicaResponse]
  debug("Delete topic callback invoked for %s".format(stopReplicaResponse))
  val responseMap = stopReplicaResponse.responses.asScala
  val partitionsInError =
    if (stopReplicaResponse.errorCode != Errors.NONE.code) responseMap.keySet
    else responseMap.filter { case (_, error) => error != Errors.NONE.code }.keySet
  val replicasInError = partitionsInError.map(p => PartitionAndReplica(p.topic, p.partition, replicaId))
  inLock(controllerContext.controllerLock) {
    // move all the failed replicas to ReplicaDeletionIneligible
    failReplicaDeletion(replicasInError)
    // 如果响应没有异常
    if (replicasInError.size != responseMap.size) {
      val deletedReplicas = responseMap.keySet -- partitionsInError
      completeReplicaDeletion(deletedReplicas.map(p => PartitionAndReplica(p.topic, p.partition, replicaId)))
    }
  }
}

 

def failReplicaDeletion(replicas: Set[PartitionAndReplica]) {
  if(isDeleteTopicEnabled) {
    val replicasThatFailedToDelete = replicas.filter(r => isTopicQueuedUpForDeletion(r.topic))
    if(replicasThatFailedToDelete.nonEmpty) {
      val topics = replicasThatFailedToDelete.map(_.topic)
      debug("Deletion failed for replicas %s. Halting deletion for topics %s"
        .format(replicasThatFailedToDelete.mkString(","), topics))
      controller.replicaStateMachine.handleStateChanges(replicasThatFailedToDelete, ReplicaDeletionIneligible)
      // 将当前线程标记为不可用
      markTopicIneligibleForDeletion(topics)
      // 唤醒DeleteTopicsThread
      resumeTopicDeletionThread()
    }
  }
}

private def completeReplicaDeletion(replicas: Set[PartitionAndReplica]) {
  val successfullyDeletedReplicas = replicas.filter(r => isTopicQueuedUpForDeletion(r.topic))
  debug("Deletion successfully completed for replicas %s".format(successfullyDeletedReplicas.mkString(",")))
  // 成功的将删除的副本转化为ReplicaDeletionSuccessful状态
  controller.replicaStateMachine.handleStateChanges(successfullyDeletedReplicas, ReplicaDeletionSuccessful)
  resumeTopicDeletionThread() // 唤醒DeleteTopicThread
}

第四：开始第二次调用doWork方法，如果副本已经处于Replica

DeletionSuccessful状态，调用completeDeleteTopic方法完成topic删除

private def completeDeleteTopic(topic: String) {
  // 取消partitionModificationListener的监听
  partitionStateMachine.deregisterPartitionChangeListener(topic)
  // 获取已经删除topic的副本
  val replicasForDeletedTopic = controller.replicaStateMachine.replicasInState(topic, ReplicaDeletionSuccessful)
  // 将状态转化为NonExistentReplica对象
  replicaStateMachine.handleStateChanges(replicasForDeletedTopic, NonExistentReplica)
  val partitionsForDeletedTopic = controllerContext.partitionsForTopic(topic)
  // 将topic对应的parition 转化为offlinePartition
  partitionStateMachine.handleStateChanges(partitionsForDeletedTopic, OfflinePartition)
  // 紧接着转化为NonExistentPartition
  partitionStateMachine.handleStateChanges(partitionsForDeletedTopic, NonExistentPartition)
  // 将该topic从待删除队里移除
  topicsToBeDeleted -= topic
  partitionsToBeDeleted.retain(_.topic != topic)
  val zkUtils = controllerContext.zkUtils
  zkUtils.zkClient.deleteRecursive(getTopicPath(topic))
  zkUtils.zkClient.deleteRecursive(getEntityConfigPath(ConfigType.Topic, topic))
  zkUtils.zkClient.delete(getDeleteTopicPath(topic))
  // 从ControllerContext中移除该topic
  controllerContext.removeTopic(topic)
}