spark 源码分析之五 -- Spark内置RPC机制剖析之一创建NettyRpcEnv

在前面源码剖析介绍中，spark 源码分析之二 -- SparkContext 的初始化过程 中的SparkEnv和 spark 源码分析之四 -- TaskScheduler的创建和启动过程 中的ClientApp启动过程中，都涉及到了Spark的内置RPC的知识。本篇专门把RPC 拿出来剖析一下。

因为RPC 在 Spark 中内容虽然不多，但理清楚还是花费很多精力的，计划每天只剖析一小部分，等剖析完毕，会专门有一篇总结性的文章出来。

本篇作为RPC分析开篇，主要剖析了NettyRpcEnv创建的过程。

Spark Rpc使用示例

我们以 org.apache.spark.deploy.ClientApp#start 方法中的调用API创建 RPC 的过程入口。

// 1. 创建 RPC Environment
val rpcEnv = RpcEnv.create("driverClient", Utils.localHostName(), 0, conf, new SecurityManager(conf))

创建NettyRpcEnv

如下是创建NettyRpcEnv的时序图（画的不好看，见谅）：

RpcEnv是scala 的object伴生对象（本质上是一个java 单例对象），去调用NettyRpcEnvFactory去创建 NettyRpcEnv 对象，序列化使用的是java序列化内建的方式，然后调用Utils 类重试启动Server。启动成功后返回给用户。

org.apache.spark.rpc.netty.NettyRpcEnv#startServer 代码如下：

 def startServer(bindAddress: String, port: Int): Unit = {
     val bootstraps: java.util.List[TransportServerBootstrap] =
       if (securityManager.isAuthenticationEnabled()) {
         java.util.Arrays.asList(new AuthServerBootstrap(transportConf, securityManager))
       } else {
         java.util.Collections.emptyList()
       }
     server = transportContext.createServer(bindAddress, port, bootstraps)
     dispatcher.registerRpcEndpoint(
       RpcEndpointVerifier.NAME, new RpcEndpointVerifier(this, dispatcher))
   }

在TransportServer构造过程中调用了init方法。org.apache.spark.network.server.TransportServer#init 源码如下：

 private void init(String hostToBind, int portToBind) {

   IOMode ioMode = IOMode.valueOf(conf.ioMode());
   EventLoopGroup bossGroup =
     NettyUtils.createEventLoop(ioMode, conf.serverThreads(), conf.getModuleName() + "-server");
   EventLoopGroup workerGroup = bossGroup;

   PooledByteBufAllocator allocator = NettyUtils.createPooledByteBufAllocator(
     conf.preferDirectBufs(), true /* allowCache */, conf.serverThreads());

   bootstrap = new ServerBootstrap()
     .group(bossGroup, workerGroup)
     .channel(NettyUtils.getServerChannelClass(ioMode))
     .option(ChannelOption.ALLOCATOR, allocator)
     .option(ChannelOption.SO_REUSEADDR, !SystemUtils.IS_OS_WINDOWS)
     .childOption(ChannelOption.ALLOCATOR, allocator);

   this.metrics = new NettyMemoryMetrics(
     allocator, conf.getModuleName() + "-server", conf);

   if (conf.backLog() > 0) {
     bootstrap.option(ChannelOption.SO_BACKLOG, conf.backLog());
   }

   if (conf.receiveBuf() > 0) {
     bootstrap.childOption(ChannelOption.SO_RCVBUF, conf.receiveBuf());
   }

   if (conf.sendBuf() > 0) {
     bootstrap.childOption(ChannelOption.SO_SNDBUF, conf.sendBuf());
   }

   bootstrap.childHandler(new ChannelInitializer<SocketChannel>() {
     @Override
     protected void initChannel(SocketChannel ch) {
       RpcHandler rpcHandler = appRpcHandler;
       for (TransportServerBootstrap bootstrap : bootstraps) {
         rpcHandler = bootstrap.doBootstrap(ch, rpcHandler);
       }
       context.initializePipeline(ch, rpcHandler);
     }
   });

   InetSocketAddress address = hostToBind == null ?
       new InetSocketAddress(portToBind): new InetSocketAddress(hostToBind, portToBind);
   channelFuture = bootstrap.bind(address);
   channelFuture.syncUninterruptibly();

   port = ((InetSocketAddress) channelFuture.channel().localAddress()).getPort();
   logger.debug("Shuffle server started on port: {}", port);
 }

主要功能是：调用netty API 初始化 nettyServer。

org.apache.spark.rpc.netty.Dispatcher#registerRpcEndpoint的源码如下：

 def registerRpcEndpoint(name: String, endpoint: RpcEndpoint): NettyRpcEndpointRef = {
   val addr = RpcEndpointAddress(nettyEnv.address, name)
   val endpointRef = new NettyRpcEndpointRef(nettyEnv.conf, addr, nettyEnv)
   synchronized {
     if (stopped) {
       throw new IllegalStateException("RpcEnv has been stopped")
     }
     if (endpoints.putIfAbsent(name, new EndpointData(name, endpoint, endpointRef)) != null) {
       throw new IllegalArgumentException(s"There is already an RpcEndpoint called $name")
     }
     val data = endpoints.get(name)
     endpointRefs.put(data.endpoint, data.ref)
     receivers.offer(data)  // for the OnStart message
   }
   endpointRef
 }

EndpointData 在初始化过程中会放入 OnStart 消息。
在 Inbox 的 process 中，有如下代码：

 case OnStart =>
   endpoint.onStart()
   if (!endpoint.isInstanceOf[ThreadSafeRpcEndpoint]) {
     inbox.synchronized {
       if (!stopped) {
         enableConcurrent = true
       }
     }
   }

调用 endpoint 的 onStart 方法和 初始化 是否支持并发处理模式。endpoint 指的是 RpcEndpointVerifier， 其 onStart 方法如下：

 /**
    * Invoked before [[RpcEndpoint]] starts to handle any message.
    */
   def onStart(): Unit = {
     // By default, do nothing.
   }

即不做任何事情，直接返回，至此初始化NettyRPCEnv 流程就剖析完。伴生对象RpcEnv调用netty rpc 工厂创建NettyRpcEnv 对象，然后使用重试机制启动TransportServer，然后NettyRpcEnv注册RpcEndpointVerifier

到Dispatcher。最终返回 NettyRpcEnv 给API调用端，NettyRpcEnv 创建成功。在这里，Dispatcher 和 TransportServer 等组件暂不做深入了解，后续会一一剖析。