- org.apache.spark.deploy.master.Master
- 我们先看Master的伴生对象，此处是Java进程的入口（被
start-master.sh启动）private[deploy] object Master extends Logging {
val SYSTEM_NAME = "sparkMaster"
val ENDPOINT_NAME = "Master"
def main(argStrings: Array[String]) {
Thread.setDefaultUncaughtExceptionHandler(new SparkUncaughtExceptionHandler(
exitOnUncaughtException = false))
Utils.initDaemon(log)
val conf = new SparkConf
// 此处会解析外部传入的参数argStrings，由其内部的parse方法解析
// 示例：--port 7077 --webui-port 8081
val args = new MasterArguments(argStrings, conf)
// 启动Master对应的RpcEndpoint、NettyRpcEnv
val (rpcEnv, _, _) = startRpcEnvAndEndpoint(args.host, args.port, args.webUiPort, conf)
// 此处调用的就是我们前面在NettyRpcEnv所讲的
// 'ctrl + alt + 鼠标左键' 点击'awaitTermination'，选择其实现类NettyRpcEnv，可以看到调用了dispatcher
// 再继续点击，可以看到实际是调用了threadpool.awaitTermination(...)，在此处进行了阻塞
// 而该threadpool正是运行了MessageLoop(用于处理Inbox消息)的线程池
rpcEnv.awaitTermination()
}
def startRpcEnvAndEndpoint(
host: String,
port: Int,
webUiPort: Int,
conf: SparkConf): (RpcEnv, Int, Option[Int]) = {
// 安全管理，例如ACL、Sasl
val securityMgr = new SecurityManager(conf)
// 创建NettyRpcEnv，由NettyRpcEnvFactory调用create(...)创建
val rpcEnv = RpcEnv.create(SYSTEM_NAME, host, port, conf, securityMgr)
// 创建Master这个RpcEndpoint，并将其注册到RpcEnv中
val masterEndpoint = rpcEnv.setupEndpoint(ENDPOINT_NAME,
new Master(rpcEnv, rpcEnv.address, webUiPort, securityMgr, conf))
// 向Master发送了一个BoundPortsRequest，并同步返回一个BoundPortsResponse（包含了Master的端口信息）
val portsResponse = masterEndpoint.askSync[BoundPortsResponse](BoundPortsRequest)
(rpcEnv, portsResponse.webUIPort, portsResponse.restPort)
}
}
- 此处代码，相对来说还是比较简单的。Shell调用
start-master.sh后，会启动一个Java进程。传入的参数则被MasterArguments进行了解析，最重要的参数是host、port、webUiPort。
- 接着，就会调用startRpcEnvAndEndpoint(…)，开始创建NettyRpcEnv与Master，并将Master注册进RpcEnv。
- 创建NettyRpcEnv是利用的NettyRpcEnvFactory调用create(…)
- Master则是直接被new实例化，此时该RpcEndpoint的构造器被调用
- 注册Master则是调用了setupEndpoint(…)，进而调用了dispatcher的registerRpcEndpoint(…)方法：
- 为Master创建了一个EndpointData，包含一个Inbox。Inbox实例化时顺带将OnStart消息放入了队列。
- 将EndpointData放入了receivers队列中，后续会被MessageLoop取出
- 因此，我们可以看到，Master被实例化时，先调用了其构造器。接着，将其注册入RpcEnv时，其Inbox中放入了第一条消息OnStart。然后，该消息OnStart将被MessageLoop取出并处理，调用了Master这个Endpoint的onStart方法。也就是说Master的生命周期前面部分是：constructor -> onStart -> …
- Worker在启动时，是需要注册到Master的，我们来详细看看此部分代码。
- Worker的onStart()中调用的registerWithMaster()方法如下
private def registerWithMaster() {
registrationRetryTimer match {
case None => // 第一次进来时，registrationRetryTimer为None
registered = false
// 此处，是向所有Master发起注册请求
// 因为高可用模式下会存在多个Master
registerMasterFutures = tryRegisterAllMasters()
connectionAttemptCount = 0
// 由于网络等问题，可能注册失败，因此需要一个能够重试的定时器，去注册
registrationRetryTimer = Some(forwordMessageScheduler.scheduleAtFixedRate(
new Runnable {
override def run(): Unit = Utils.tryLogNonFatalError {
Option(self).foreach(_.send(ReregisterWithMaster))
}
},
INITIAL_REGISTRATION_RETRY_INTERVAL_SECONDS,
INITIAL_REGISTRATION_RETRY_INTERVAL_SECONDS,
TimeUnit.SECONDS))
case Some(_) =>
// registrationRetryTimer已存在，不需要再创建了
logInfo("Not spawning another attempt to register with the master, since there is an" +
" attempt scheduled already.")
}
}
- 接着，再看tryRegisterAllMasters()的代码
private def tryRegisterAllMasters(): Array[JFuture[_]] = {
masterRpcAddresses.map { masterAddress =>
// 线程池提交，返回一个JFuture
registerMasterThreadPool.submit(new Runnable {
override def run(): Unit = {
try {
logInfo("Connecting to master " + masterAddress + "...")
// 获取到Master对应的RpcEndpointRef
val masterEndpoint = rpcEnv.setupEndpointRef(masterAddress, Master.ENDPOINT_NAME)
// 向Master发送注册消息
sendRegisterMessageToMaster(masterEndpoint)
} catch {
case ie: InterruptedException => // Cancelled
case NonFatal(e) => logWarning(s"Failed to connect to master $masterAddress", e)
}
}
})
}
}
- 再看sendRegisterMessageToMaster(…)方法
private def sendRegisterMessageToMaster(masterEndpoint: RpcEndpointRef): Unit = {
masterEndpoint.send(RegisterWorker(
workerId,
host,
port,
self,
cores,
memory,
workerWebUiUrl,
masterEndpoint.address))
}
- 此处，正式向Master发送了消息RegisterWorker，进行注册
- 快速查看技巧：利用’ctrl+鼠标左键’点击RegisterWorker，看到case class RegisterWorker。再次利用’ctrl+鼠标左键’点击RegisterWorker，IDEA会为我们展示出什么地方使用了它。可以看到IDEA展示的部分：
Worker.scala <- masterEndpoint.send(RegisterWorker(，此处是Worker发送该消息的代码处Master.scala <- case RegisterWorker(，此处既是Master接收到该消息的地方
- 利用上面的技巧，我们可以快速地在RpcEndpoint的代码之间跳转，方便了对其交互流程的查看。（消息通信的具体实现，请看RpcEndpoint、RpcEnv）
- 此时，我们来到了Master的receive方法，代码如下
override def receive: PartialFunction[Any, Unit] = {
// 省略部分代码
case RegisterWorker(
id, workerHost, workerPort, workerRef, cores, memory, workerWebUiUrl, masterAddress) =>
// Master收到了Worker发来的RegisterWorker消息，开始进行处理
logInfo("Registering worker %s:%d with %d cores, %s RAM".format(
workerHost, workerPort, cores, Utils.megabytesToString(memory)))
if (state == RecoveryState.STANDBY) {
// 高可用模式下，该Master可能是STANDBY的，因此回复一个MasterInStandby
workerRef.send(MasterInStandby)
} else if (idToWorker.contains(id)) {
// 如果该Worker已经注册了，回一个RegisterWorkerFailed
workerRef.send(RegisterWorkerFailed("Duplicate worker ID"))
} else {
// 开始注册Worker
val worker = new WorkerInfo(id, workerHost, workerPort, cores, memory,
workerRef, workerWebUiUrl)
// 调用registerWorker(...)，将worker添加到本节点
if (registerWorker(worker)) {
persistenceEngine.addWorker(worker)
// 如果过成功，那么就向Worker回复消息RegisteredWorker
workerRef.send(RegisteredWorker(self, masterWebUiUrl, masterAddress))
schedule()
} else {
// 注册失败，回复RegisterWorkerFailed
val workerAddress = worker.endpoint.address
logWarning("Worker registration failed. Attempted to re-register worker at same " +
"address: " + workerAddress)
workerRef.send(RegisterWorkerFailed("Attempted to re-register worker at same address: "
+ workerAddress))
}
}
// 省略部分代码
}
- Master收到消息后，需要检测本节点的状态是否是STANDBY、是否已经注册该Worker，如果没问题，那么调用registerWorker(…)，将worker添加到本节点，最后会回复Worker一个消息RegisteredWorker
- 跟随着RegisteredWorker消息，我们来到Worker接收消息处。Worker中先是receive被调用，再匹配到RegisterWorkerResponse，接着调用了handleRegisterResponse(…)方法，代码如下
private def handleRegisterResponse(msg: RegisterWorkerResponse): Unit = synchronized {
msg match {
case RegisteredWorker(masterRef, masterWebUiUrl, masterAddress) =>
// 如果在Master注册成功，则会收到RegisteredWorker
if (preferConfiguredMasterAddress) {
logInfo("Successfully registered with master " + masterAddress.toSparkURL)
} else {
logInfo("Successfully registered with master " + masterRef.address.toSparkURL)
}
registered = true
// 修改本Worker节点对应的Master
changeMaster(masterRef, masterWebUiUrl, masterAddress)
// 启用定时器，发送心跳
// 追踪SendHeartbeat可知，定时器先发送给自己，Worker在receive处收到后，再调用sendToMaster(...)发送给Master
forwordMessageScheduler.scheduleAtFixedRate(new Runnable {
override def run(): Unit = Utils.tryLogNonFatalError {
self.send(SendHeartbeat)
}
}, 0, HEARTBEAT_MILLIS, TimeUnit.MILLISECONDS)
// 是否删除之前应用的工作目录，默认false
if (CLEANUP_ENABLED) {
logInfo(
s"Worker cleanup enabled; old application directories will be deleted in: $workDir")
forwordMessageScheduler.scheduleAtFixedRate(new Runnable {
override def run(): Unit = Utils.tryLogNonFatalError {
self.send(WorkDirCleanup)
}
}, CLEANUP_INTERVAL_MILLIS, CLEANUP_INTERVAL_MILLIS, TimeUnit.MILLISECONDS)
}
// 准备本Worker的Executor信息，并将最新状态消息WorkerLatestState发送给Master
// 不过，显然第一次启动时，本节点是没有启动Excutor的
val execs = executors.values.map { e =>
new ExecutorDescription(e.appId, e.execId, e.cores, e.state)
}
masterRef.send(WorkerLatestState(workerId, execs.toList, drivers.keys.toSeq))
case RegisterWorkerFailed(message) =>
// 注册失败，回复此消息RegisterWorkerFailed
if (!registered) {
logError("Worker registration failed: " + message)
System.exit(1)
}
case MasterInStandby =>
// Ignore. Master not yet ready.
}
}
- 最后，Master将会收到WorkerLatestState消息，代码如下
override def receive: PartialFunction[Any, Unit] = {
// 省略部分代码
case WorkerLatestState(workerId, executors, driverIds) =>
idToWorker.get(workerId) match {
case Some(worker) =>
// 因为是第一次，因此该executors是空的，for中代码不执行
for (exec <- executors) {
val executorMatches = worker.executors.exists {
case (_, e) => e.application.id == exec.appId && e.id == exec.execId
}
if (!executorMatches) {
// master doesn't recognize this executor. So just tell worker to kill it.
worker.endpoint.send(KillExecutor(masterUrl, exec.appId, exec.execId))
}
}
// 因为是第一次，因此该driverIds是空的，for中代码不执行
for (driverId <- driverIds) {
val driverMatches = worker.drivers.exists { case (id, _) => id == driverId }
if (!driverMatches) {
// master doesn't recognize this driver. So just tell worker to kill it.
worker.endpoint.send(KillDriver(driverId))
}
}
case None =>
logWarning("Worker state from unknown worker: " + workerId)
}
// 省略部分代码
}
- 至此，Worker注册到Master通信流程，完全结束。^_^
- 后面整个集群会持续以下模式：由Worker定时向Master发送心跳包，而Master也会在本节点定时检测Worker的心跳，移除超时的Worker。
- Worker注册到Master的通信流程示意图如下
