spark core原始碼分析3 Master HA

這一節講解master 選舉以及之後的處理流程

上一節說到在Master啟動過程中，首先呼叫了 Akka actor的preStart方法。

上面的persistenceEngine_封裝了在zk中讀寫後設資料資訊，以及序列化反序列化的介面

leaderElectionAgent_封裝了master的選舉過程，見下面程式碼註釋中的解釋

[java] view plain copy
 
private[master] class ZooKeeperLeaderElectionAgent(val masterActor: LeaderElectable,  
    conf: SparkConf) extends LeaderLatchListener with LeaderElectionAgent with Logging  {  
  
  //依賴zk中的一個節點來判斷選主  
  val WORKING_DIR = conf.get("spark.deploy.zookeeper.dir", "/spark") + "/leader_election"  
  
  private var zk: CuratorFramework = _  
  private var leaderLatch: LeaderLatch = _  
  private var status = LeadershipStatus.NOT_LEADER  
  
  //構造這個物件之後就呼叫了start方法  
  start()  
  //leaderLatch.start()一旦呼叫，LeaderLatch會和其它使用相同latch path的其它LeaderLatch交涉，然後隨機的選擇其中一個作為leader  
  private def start() {  
    logInfo("Starting ZooKeeper LeaderElection agent")  
    zk = SparkCuratorUtil.newClient(conf)  
    leaderLatch = new LeaderLatch(zk, WORKING_DIR)  
    leaderLatch.addListener(this)  
    leaderLatch.start()  
  }  
  
  override def stop() {  
    leaderLatch.close()  
    zk.close()  
  }  
  
  //當一個master被選為主時，isLeader方法被回撥，說明在這一輪選舉中勝出  
  override def isLeader() {  
    synchronized {  
      // could have lost leadership by now.  
      if (!leaderLatch.hasLeadership) {  
        return  
      }  
  
      logInfo("We have gained leadership")  
      updateLeadershipStatus(true)  
    }  
  }  
  
  //當一個master被選為備時，notLeader方法被回撥，說明在這一輪選舉中落敗  
  override def notLeader() {  
    synchronized {  
      // could have gained leadership by now.  
      if (leaderLatch.hasLeadership) {  
        return  
      }  
  
      logInfo("We have lost leadership")  
      updateLeadershipStatus(false)  
    }  
  }  
  private def updateLeadershipStatus(isLeader: Boolean) {  
    //當一個master之前狀態為備，目前被選為主  
    if (isLeader && status == LeadershipStatus.NOT_LEADER) {  
      status = LeadershipStatus.LEADER  
      masterActor.electedLeader()//呼叫master類的electedLeader方法      
      //當一個master之前狀態為主，目前被選為備  
    } else if (!isLeader && status == LeadershipStatus.LEADER) {  
      status = LeadershipStatus.NOT_LEADER  
      masterActor.revokedLeadership()//呼叫master類的revokedLeadership方法      
    }  
  }  
  
  private object LeadershipStatus extends Enumeration {  
    type LeadershipStatus = Value  
    val LEADER, NOT_LEADER = Value  
  }  
}  
繼續檢視master中的邏輯

[java] view plain copy
 
override def receiveWithLogging: PartialFunction[Any, Unit] = {  
  case ElectedLeader => {  
    //既然之前是備，現在想變成主，就需要讀取zk中的必要的資訊來構造後設資料  
    val (storedApps, storedDrivers, storedWorkers) = persistenceEngine.readPersistedData()  
    state = if (storedApps.isEmpty && storedDrivers.isEmpty && storedWorkers.isEmpty) {  
      RecoveryState.ALIVE//如果沒有任何後設資料需要構造，則直接置為alive狀態  
    } else {  
      RecoveryState.RECOVERING//不然需要置為恢復中  
    }  
    logInfo("I have been elected leader! New state: " + state)  
    if (state == RecoveryState.RECOVERING) {  
      beginRecovery(storedApps, storedDrivers, storedWorkers)//見下面介紹  
      recoveryCompletionTask = context.system.scheduler.scheduleOnce(WORKER_TIMEOUT millis, self,  
        CompleteRecovery)  
    }  
  }  
  
  case CompleteRecovery => completeRecovery()  
  
  //之前是主，現在被置為備了，不需要額外操作，退出即可  
  case RevokedLeadership => {  
    logError("Leadership has been revoked -- master shutting down.")  
    System.exit(0)  
  }  
開始恢復
[java] view plain copy
 
private def beginRecovery(storedApps: Seq[ApplicationInfo], storedDrivers: Seq[DriverInfo],  
    storedWorkers: Seq[WorkerInfo]) {  
  for (app <- storedApps) {  
    logInfo("Trying to recover app: " + app.id)  
    try {  
      registerApplication(app)//將讀到的app載入到記憶體  
      app.state = ApplicationState.UNKNOWN//狀態置為unknown  
      app.driver ! MasterChanged(masterUrl, masterWebUiUrl)//向driver傳送MasterChanged訊息  
    } catch {  
      case e: Exception => logInfo("App " + app.id + " had exception on reconnect")  
    }  
  }  
  
  for (driver <- storedDrivers) {  
    // Here we just read in the list of drivers. Any drivers associated with now-lost workers  
    // will be re-launched when we detect that the worker is missing.  
    drivers += driver//將讀到的driver載入到記憶體  
  }  
  
  for (worker <- storedWorkers) {  
    logInfo("Trying to recover worker: " + worker.id)  
    try {  
      registerWorker(worker)//將讀到的worker資訊載入到記憶體  
      worker.state = WorkerState.UNKNOWN//同樣狀態需要置為unknown，需要等到worker傳送訊息過來之後才能認為該worker是可用的  
      worker.actor ! MasterChanged(masterUrl, masterWebUiUrl)//向worker傳送MasterChanged訊息  
    } catch {  
      case e: Exception => logInfo("Worker " + worker.id + " had exception on reconnect")  
    }  
  }  
}  
看driver端收到MasterChanged訊息會發生什麼？在AppClient.scala中
只有主master會傳送MasterChanged訊息，所以這裡的masterUrl肯定是新的主master的
[java] view plain copy
 
case MasterChanged(masterUrl, masterWebUiUrl) =>  
  logInfo("Master has changed, new master is at " + masterUrl)  
  //收到這個訊息之後，driver需要修改之前儲存的master資訊，用於之後向新的master通訊  
  changeMaster(masterUrl)  
  alreadyDisconnected = false  
  sender ! MasterChangeAcknowledged(appId)//向master反饋MasterChangeAcknowledged訊息  
master這時會收到所有app中driver發來的訊息，我們看master收到MasterChangeAcknowledged訊息的處理方式，引數為appId
[java] view plain copy
 
case MasterChangeAcknowledged(appId) => {  
  idToApp.get(appId) match {  
    case Some(app) =>  
      logInfo("Application has been re-registered: " + appId)  
      app.state = ApplicationState.WAITING  //收到訊息後將app狀態置為WAITING  
    case None =>  
      logWarning("Master change ack from unknown app: " + appId)  
  }  
  
  if (canCompleteRecovery) { completeRecovery() }  //這個只是優先判斷訊息處理是否都結束了，這樣就不用等待worker_timeout的時間間隔再呼叫completeRecovery了  
}  
看worker端收到MasterChanged訊息會發生什麼？在Worker.scala中
[java] view plain copy
 
case MasterChanged(masterUrl, masterWebUiUrl) =>  
  logInfo("Master has changed, new master is at " + masterUrl)  
  changeMaster(masterUrl, masterWebUiUrl)//同上  
  
//master不與Executor互動，所以需要worker來告訴master關於Executor的資訊  
val execs = executors.values.  
    map(e => new ExecutorDescription(e.appId, e.execId, e.cores, e.state))  
  sender ! WorkerSchedulerStateResponse(workerId, execs.toList, drivers.keys.toSeq)  
繼續看master中的處理邏輯
[java] view plain copy
 
case WorkerSchedulerStateResponse(workerId, executors, driverIds) => {  
  idToWorker.get(workerId) match {  
    case Some(worker) =>  
      logInfo("Worker has been re-registered: " + workerId)  
      worker.state = WorkerState.ALIVE //這時可以將之前worker狀態unknown修改為ALIVE，代表該worker可用  
  
      //將接受到的Executor資訊更新到相關的app，worker中  
      val validExecutors = executors.filter(exec => idToApp.get(exec.appId).isDefined)  
      for (exec <- validExecutors) {  
        val app = idToApp.get(exec.appId).get  
        val execInfo = app.addExecutor(worker, exec.cores, Some(exec.execId))  
        worker.addExecutor(execInfo)  
        execInfo.copyState(exec)  
      }  
  
      //將master中driver資訊更新，狀態置為RUNNING  
      for (driverId <- driverIds) {  
        drivers.find(_.id == driverId).foreach { driver =>  
          driver.worker = Some(worker)  
          driver.state = DriverState.RUNNING  
          worker.drivers(driverId) = driver  
        }  
      }  
    case None =>  
      logWarning("Scheduler state from unknown worker: " + workerId)  
  }  
  
  if (canCompleteRecovery) { completeRecovery() }  //同上  
}  
這一切都處理完畢之後，看master的completeRecovery，這個是在beginRecovery呼叫之後，在延遲worker_timeout時間之後呼叫，一般情況下，上面的訊息來回傳送處理應該都已經結束了
[java] view plain copy
 
private def completeRecovery() {  
  // Ensure "only-once" recovery semantics using a short synchronization period.  
  synchronized {  
    if (state != RecoveryState.RECOVERING) { return }  
    state = RecoveryState.COMPLETING_RECOVERY//狀態置為恢復完成  
  }  
  
  // Kill off any workers and apps that didn't respond to us.  
  //清理在這個worker_timeout間隔過後還未處理成功的worker和app  
  workers.filter(_.state == WorkerState.UNKNOWN).foreach(removeWorker)  
  apps.filter(_.state == ApplicationState.UNKNOWN).foreach(finishApplication)  
  
  // Reschedule drivers which were not claimed by any workers  
  //在一番訊息通訊之後，本應該在driver中更新的worker資訊不見了，則重啟driver或者刪除  
  drivers.filter(_.worker.isEmpty).foreach { d =>  
    logWarning(s"Driver ${d.id} was not found after master recovery")  
    if (d.desc.supervise) {  
      logWarning(s"Re-launching ${d.id}")  
      relaunchDriver(d)  
    } else {  
      removeDriver(d.id, DriverState.ERROR, None)  
      logWarning(s"Did not re-launch ${d.id} because it was not supervised")  
    }  
  }  
  
  state = RecoveryState.ALIVE  //這時恢復狀態真正結束了  
  schedule() //整個選主流程結束時候，重新排程一次  
  logInfo("Recovery complete - resuming operations!")  
}  

轉載：http://blog.csdn.net/yueqian_zhu/article/details/47954705