hadoop rpc

来源：互联网发布：雕刻软件type3 编辑：程序博客网时间：2024/05/22 18:40

RPC 是一种通过网络从远程计算机上请求服务，但不需要了解底层网络技术的协议。RPC 协议假定某些传输协议（如 TCP 或 UDP 等）已经存在，并通过这些传输协议为通信程序之间传递访问请求或者应答信息。在 OSI 网络通信模型中，RPC 跨越了传输层和应用层。RPC 使得开发分布式应用程序更加容易。

一 RPC 总体架构

二使用方法

Hadoop RPC 对外主要提供了两种接口（见类org.apache.hadoop.ipc.RPC），分别是：
1. public static <T> ProtocolProxy <T> getProxy/waitForProxy(…) ：构造一个客户端代理对象（该对象实现了某个协议），用于向服务器发送RPC 请求。

2.public static Server RPC.Builder (Configuration).build() ❑ ：为某个协议（实际上是 Java接口）实例构造一个服务器对象，用于处理客户端发送的请求。

示例如下

定义rpc 协议代码

public interface TestProtocol extends VersionedProtocol {
long versionID = 1L;
String echo(String msg);
}

实现rpc 协议代码

public class TestProtocolImpl implements TestProtocol {
@Override
public long getProtocolVersion(String protocol, long clientVersion) throws IOException {
return TestProtocol.versionID;
}
@Override
public ProtocolSignature getProtocolSignature(String protocol, long clientVersion, int clientMethodsHash)
throws IOException {
return new ProtocolSignature(TestProtocol.versionID, null);
}
@Override
public String echo(String msg) {
return msg;
}
}

Java代码

public class RPCTest {
public static void main(String[] args) {
Configuration conf = new Configuration();
Server server = startServer(conf);
echo(conf, server);
}
//构造RPC Client 并发送RPC 请求
private static void echo(Configuration conf, Server server) {
try {
TestProtocol proxy = (TestProtocol) RPC.getProxy(TestProtocol.class, TestProtocol.versionID,
server.getListenerAddress(), conf);
System.err.println(proxy.echo("hello world!!!"));
server.stop();
} catch (Exception e) {
throw new Error(e);
}
}
//构造并启动RPC Server
private static Server startServer(Configuration conf) {
try {
Server server = new RPC.Builder(conf).setProtocol(TestProtocol.class).setInstance(new TestProtocolImpl())
.setBindAddress("127.0.0.1").setPort(0).setNumHandlers(5).build();
server.start();
return server;
} catch (Exception e) {
throw new Error(e);
}
}
}

三.RPC类详解

Hadoop RPC 内部实现位于源代码目录中hadoop-common-project/hadoop-common/src/main/java 下的org.apache.hadoop.ipc 包中，而YARN 对RPC 的Protocol Buffers 封装则位于hadoop-yarn-project/hadoop-yarn/hadoop-yarn-common/src/main/java 目录下的org.apache.hadoop.yarn.ipc 包中。

3.1 rpc

hadoop的rpc序列化有protocol buffers和自带的writable，默认为writable实现。rpc采用java动态代理完成对远程方法的调用，即客户端在RpcInvocationHandler的invoke中将函数的调用信息（函数名，函数参数等）打包成Invocation发送到服务端，服务端收到调用信息后解析函数调用信息，通过反射完成函数的调用后返回给客户端。

3.2 client

client包含Call和Connection两个大类。当动态代理调用client的call方式时，创建Call，创建Connection，将Call放入Connection的hash表calls中，调用sendRpcRequest方法发送调用信息，并异步通过receiveRpcResponse接收消息将对于Call的状态改为done并将其移除calls。client检查Call的状态，当Call的状态为done时返回消息。

3.3server

listener的selector对象注册SelectionKey.OP_ACCEPT事件，接收到请求后轮询选择reader,reader的readSelector监听SelectionKey.OP_READ事件，将接收到的请求转成call放入server的callQueue中。server的handlers数据循环从callQueue取出call执行函数调用,调用完后将将结果返回给客户端，当数据不能一次返回时使用responder线程异步发送未完成的结果。

一个Server只有一个listener和responder，reader的数量由ipc.server.read.threadpool.size配置，默认1个。

四.yarn rpc

yarn rpc是基于hadoop rpc且采用protocol buffers序列化框架的通信协议。

应用实例以ResourceTracker的为例：

协议接口代码

package org.apache.hadoop.yarn.server.api;
public interface ResourceTracker {
@Idempotent
public RegisterNodeManagerResponse registerNodeManager(
RegisterNodeManagerRequest request) throws YarnException,
IOException;
@AtMostOnce
public NodeHeartbeatResponse nodeHeartbeat(NodeHeartbeatRequest request)
throws YarnException, IOException;
}

Rpcserverfactorypbimpl代码

//RpcServerFactoryPBImpl的包名为协议接口的包名加.impl.pb.service
package org.apache.hadoop.yarn.server.api.impl.pb.service;
//RpcServerFactoryPBImpl的类名为协议接口名加PBServiceImpl
public class ResourceTrackerPBServiceImpl implements ResourceTrackerPB {
private ResourceTracker real;
public ResourceTrackerPBServiceImpl(ResourceTracker impl) {
this.real = impl;
}
....
}

Rpcclientfactorypbimp❑代码

//RpcClientFactoryPBImp的包名为协议接口的包名加.impl.pb.client
package org.apache.hadoop.yarn.server.api.impl.pb.client;
//RpcClientFactoryPBImp的类名为协议接口名加PBClientImpl
public class ResourceTrackerPBClientImpl implements ResourceTracker, Closeable {
private ResourceTrackerPB proxy;
public ResourceTrackerPBClientImpl(long clientVersion, InetSocketAddress addr, Configuration conf) throws IOException {
RPC.setProtocolEngine(conf, ResourceTrackerPB.class, ProtobufRpcEngine.class);
proxy = (ResourceTrackerPB)RPC.getProxy(
ResourceTrackerPB.class, clientVersion, addr, conf);
}
```
}

Java代码

package org.apache.hadoop.yarn.server.resourcemanager;
public class ResourceTrackerService extends AbstractService implements
ResourceTracker {
protected void serviceStart() throws Exception {
super.serviceStart();
Configuration conf = getConfig();
YarnRPC rpc = YarnRPC.create(conf);
this.server =
rpc.getServer(ResourceTracker.class, this, resourceTrackerAddress,
conf, null,
conf.getInt(YarnConfiguration.RM_RESOURCE_TRACKER_CLIENT_THREAD_COUNT,
YarnConfiguration.DEFAULT_RM_RESOURCE_TRACKER_CLIENT_THREAD_COUNT));
````
}
public RegisterNodeManagerResponse registerNodeManager(
RegisterNodeManagerRequest request) throws YarnException,
IOException{
````
}
public NodeHeartbeatResponse nodeHeartbeat(NodeHeartbeatRequest request)
throws YarnException, IOException{
````
}
}

Java代码

package org.apache.hadoop.yarn.server.nodemanager;
public class NodeStatusUpdaterImpl extends AbstractService implements
NodeStatusUpdater {
private ResourceTracker resourceTracker;
@Override
protected void serviceStart() throws Exception {
// NodeManager is the last service to start, so NodeId is available.
this.nodeId = this.context.getNodeId();
this.httpPort = this.context.getHttpPort();
this.nodeManagerVersionId = YarnVersionInfo.getVersion();
try {
// Registration has to be in start so that ContainerManager can get the
// perNM tokens needed to authenticate ContainerTokens.
this.resourceTracker = getRMClient();
registerWithRM();
super.serviceStart();
startStatusUpdater();
} catch (Exception e) {
String errorMessage = "Unexpected error starting NodeStatusUpdater";
LOG.error(errorMessage, e);
throw new YarnRuntimeException(e);
}}
protected ResourceTracker getRMClient() throws IOException {
Configuration conf = getConfig();
return ServerRMProxy.createRMProxy(conf, ResourceTracker.class);
}
}

Java代码

public class RMProxy<T> {
@Private
static <T> T getProxy(final Configuration conf,
final Class<T> protocol, final InetSocketAddress rmAddress)
throws IOException {
return UserGroupInformation.getCurrentUser().doAs(
new PrivilegedAction<T>() {
@Override
public T run() {
return (T) YarnRPC.create(conf).getProxy(protocol, rmAddress, conf);
}
});
}
```
}

0 0