Transport模块分析

1. 网络模块初始化

public interface NetworkPlugin
1.构建Netty4Transport作为Transport
public final class NetworkModule
Map<String, Supplier> httpTransportFactory = plugin.getTransports(settings, threadPool, bigArrays,
circuitBreakerService, namedWriteableRegistry, networkService);
2.构建Netty4HttpServerTransport MF h HttpServerTransport
public final class NetworkModule
Map<String, Supplier> httpTransportFactory = plugin.getHttpTransports(settings, threadPool, bigArrays,
circuitBreakerService, namedWriteableRegistry, xContentRegistry, networkService, dispatcher);

public class Node implements Closeable
1.已注册好的REST请求处理器
final RestController restController = actionModule.getRestController();
2. 初始化Networ kModule
final NetworkModule networkModule = new NetworkModule(settings, false, pluginsService.filterPlugins(NetworkPlugin.class),
threadPool, bigArrays, circuitBreakerService, namedWriteableRegistry, xContentRegistry, networkService, restController);

public class NioTransport extends TcpTransport
NioTransport #doStart
1.初始化Client
client = createClient();
2. 初始化Serve
for (ProfileSettings profileSettings : profileSettings) {
profileToChannelFactory.putIfAbsent(profileSettings.profileName, new ChannelFactory(profileSettings, tcpReadHandler));
// 初始化Serve
bindServer(profileSettings);
}

public abstract class TransportClient extends AbstractClient
TransportClient #buildTemplate -> ClientTemplate
1.通过网络模块获取已初始化的Transport
final Transport transport = networkModule.getTransportSupplier().get();

2.基于网络模块的Transport构建TransportService
final TransportService transportService = new TransportService(settings, transport, threadPool,
networkModule.getTransportInterceptor()

public class TransportService extends AbstractLifecycleComponent
1.连接node
TransportService #connectToNode(final DiscoveryNode node, ConnectionProfile connectionProfile)

public abstract class TcpTransport extends AbstractLifecycleComponent implements Transport
TcpTransport#buildDefaultConnectionProfile(Settings settings) -> ConnectionProfile
ConnectionProfile统一管理连接
static ConnectionProfile buildDefaultConnectionProfile(Settings settings) {
int connectionsPerNodeRecovery = CONNECTIONS_PER_NODE_RECOVERY.get(settings);
int connectionsPerNodeBulk = CONNECTIONS_PER_NODE_BULK.get(settings);
int connectionsPerNodeReg = CONNECTIONS_PER_NODE_REG.get(settings);
int connectionsPerNodeState = CONNECTIONS_PER_NODE_STATE.get(settings);
int connectionsPerNodePing = CONNECTIONS_PER_NODE_PING.get(settings);
ConnectionProfile.Builder builder = new ConnectionProfile.Builder();
builder.setConnectTimeout(TCP_CONNECT_TIMEOUT.get(settings));
builder.setHandshakeTimeout(TCP_CONNECT_TIMEOUT.get(settings));
builder.addConnections(connectionsPerNodeBulk, TransportRequestOptions.Type.BULK);
builder.addConnections(connectionsPerNodePing, TransportRequestOptions.Type.PING);
// if we are not master eligible we don’t need a dedicated channel to publish the state
builder.addConnections(DiscoveryNode.isMasterNode(settings) ? connectionsPerNodeState : 0, TransportRequestOptions.Type.STATE);
// if we are not a data-node we don’t need any dedicated channels for recovery
builder.addConnections(DiscoveryNode.isDataNode(settings) ? connectionsPerNodeRecovery : 0, TransportRequestOptions.Type.RECOVERY);
builder.addConnections(connectionsPerNodeReg, TransportRequestOptions.Type.REG);
return builder.build();
}

1.NodeChannels类,保存了这些连接，当发送数据时,根据请求类型找到对应的连接来发送数据。
public final class NodeChannels implements Connection
// 保存每个请求对应的连接
private final Map<TransportRequestOptions.Type, ConnectionProfile.ConnectionTypeHandle> typeMapping;
// 保存已建立的TCP连接
private final Channel[] channels;
// 目的节点是哪个
private final DiscoveryNode node;

public abstract class TcpTransport extends AbstractLifecycleComponent implements Transport
TcpTransport#connectToNode(DiscoveryNode node, ConnectionProfile connectionProfile,
CheckedBiConsumer<Connection, ConnectionProfile, IOException> connectionValidator)
如果13个连接中有一个连接失败，则整体认为失败，关闭已建立的连接
// 建立一个连接
nodeChannels = openConnection(node, connectionProfile);
connectionValidator.accept(nodeChannels, connectionProfile);
// we acquire a connection lock, so no way there is an existing connection
connectedNodes.put(node, nodeChannels);

2.发送请求

内部的RPC请求通过TransportService#sendRequest发送
sendRequest会检查目的节点是否是本节点，如果是本节点，
则在sendLocalRequest方法中直接通过action 获取对应的Handler,调用对应的处理函数
public class TransportService extends AbstractLifecycleComponent
TransportService#sendRequest
Transport.Connection localNodeConnection = new Transport.Connection()
sendLocalRequest(requestId, action, request, options);

public abstract class TcpTransport extends AbstractLifecycleComponent implements Transport
TcpTransport#sendRequest
@Override
public void sendRequest(long requestId, String action, TransportRequest request, TransportRequestOptions options)
throws IOException, TransportException {
if (closed.get()) {
throw new NodeNotConnectedException(node, “connection already closed”);
}
// 通过请求类型获取13个连接中的相应连接
Channel channel = channel(options.type());
// 发送请求
sendRequestToChannel(this.node, channel, requestId, action, request, options, getVersion(), (byte) 0);
}

3. 定义对Response的处理

public class SyncedFlushService extends AbstractComponent implements IndexEventListener

SyncedFlushService #getInflightOpsCount(final ShardId shardId, ClusterState state, IndexShardRoutingTable shardRoutingTable, final ActionListener listener)
// TransportResponseHandler类主要定义了对远程节点执行RPC请求后返回成功还是失败处理
transportService.sendRequest(primaryNode, IN_FLIGHT_OPS_ACTION_NAME, new InFlightOpsRequest(shardId),
new TransportResponseHandler() {
// 返回一个新的response
@Override
public InFlightOpsResponse newInstance() {
return new InFlightOpsResponse();
}
// 对远程节点执行成功的处理
@Override
public void handleResponse(InFlightOpsResponse response) {
listener.onResponse(response);
}
// 对远程节点执行失败的处理
@Override
public void handleException(TransportException exp) {
logger.debug(“{} unexpected error while retrieving in flight op count”, shardId);
listener.onFailure(exp);
}
// 返回线程池名称
@Override
public String executor() {
return ThreadPool.Names.SAME;
}
});