private void InitializeChannel(IChannel channel, EncryptionHandshakeRole role, NodeId remoteId = null, string remoteHost = null, int?remotePort = null)
{
var connectionType = remoteId == null ? ClientConnectionType.In : ClientConnectionType.Out;
P2PSession p2PSession = new P2PSession(
LocalNodeId,
_localPort,
_serializationService,
_synchronizationManager,
_logManager)
{
ClientConnectionType = connectionType
};
//This is the first moment we get confirmed publicKey of remote node in case of outgoing connections
if (connectionType == ClientConnectionType.Out)
{
if (_logger.IsInfoEnabled)
{
_logger.Info($"Initializing {connectionType.ToString().ToUpper()} channel{(connectionType == ClientConnectionType.Out ? $": {remoteId}@{remoteHost}:{remoteId}" : string.Empty)}");
}
p2PSession.RemoteNodeId = remoteId;
p2PSession.RemoteHost = remoteHost;
p2PSession.RemotePort = remotePort;
ConnectionInitialized?.Invoke(this, new ConnectionInitializedEventArgs(p2PSession, connectionType));
}
var handshakeHandler = new NettyHandshakeHandler(_encryptionHandshakeService, p2PSession, role, remoteId, _logger);
handshakeHandler.HandshakeInitialized += (s, e) =>
{
//This is the first moment we get confirmed publicKey of remote node in case of incoming connections
if (connectionType == ClientConnectionType.In)
{
if (_logger.IsInfoEnabled)
{
_logger.Info($"Initializing {connectionType.ToString().ToUpper()} channel {p2PSession.RemoteNodeId}@{p2PSession.RemoteHost}:{p2PSession.RemotePort}");
}
ConnectionInitialized?.Invoke(this, new ConnectionInitializedEventArgs(p2PSession, connectionType));
}
};
IChannelPipeline pipeline = channel.Pipeline;
pipeline.AddLast(new LoggingHandler(connectionType.ToString().ToUpper(), DotNetty.Handlers.Logging.LogLevel.TRACE));
pipeline.AddLast("enc-handshake-dec", new LengthFieldBasedFrameDecoder(ByteOrder.BigEndian, ushort.MaxValue, 0, 2, 0, 0, true));
pipeline.AddLast("enc-handshake-handler", handshakeHandler);
channel.CloseCompletion.ContinueWith(async x =>
{
if (_logger.IsInfoEnabled)
{
_logger.Info($"Channel disconnection: {p2PSession.RemoteNodeId}");
}
await p2PSession.DisconnectAsync(DisconnectReason.ClientQuitting, DisconnectType.Remote);
});
}
private void InitializeChannel(IChannel channel, ConnectionDirection connectionDirection, NodeId remoteId = null, string remoteHost = null, int?remotePort = null, INodeStats nodeStats = null)
{
if (connectionDirection == ConnectionDirection.In)
{
Metrics.IncomingConnections++;
}
else
{
Metrics.OutgoingConnections++;
}
P2PSession session = new P2PSession(
LocalNodeId,
remoteId,
_localPort,
connectionDirection,
_serializationService,
_synchronizationManager,
_nodeStatsProvider,
nodeStats,
_logManager, channel, _perfService, _blockTree, _transactionPool, _timestamp);
if (connectionDirection == ConnectionDirection.Out)
{
if (_logger.IsTrace)
{
_logger.Trace($"Initializing {connectionDirection.ToString().ToUpper()} channel{(connectionDirection == ConnectionDirection.Out ? $": {remoteId}@{remoteHost}:{remotePort}" : string.Empty)}");
}
// this is the first moment we get confirmed publicKey of remote node in case of outgoing connections
session.RemoteNodeId = remoteId;
session.RemoteHost = remoteHost;
session.RemotePort = remotePort;
}
SessionCreated?.Invoke(this, new SessionEventArgs(session));
HandshakeRole role = connectionDirection == ConnectionDirection.In ? HandshakeRole.Recipient : HandshakeRole.Initiator;
var handshakeHandler = new NettyHandshakeHandler(_encryptionHandshakeService, session, role, remoteId, _logManager);
IChannelPipeline pipeline = channel.Pipeline;
pipeline.AddLast(new LoggingHandler(connectionDirection.ToString().ToUpper(), DotNetty.Handlers.Logging.LogLevel.TRACE));
pipeline.AddLast("enc-handshake-dec", new LengthFieldBasedFrameDecoder(ByteOrder.BigEndian, ushort.MaxValue, 0, 2, 0, 0, true));
pipeline.AddLast("enc-handshake-handler", handshakeHandler);
channel.CloseCompletion.ContinueWith(async x =>
{
if (_logger.IsTrace)
{
_logger.Trace($"Channel disconnected: {session.RemoteNodeId}");
}
await session.DisconnectAsync(DisconnectReason.ClientQuitting, DisconnectType.Remote);
SessionClosing?.Invoke(this, new SessionEventArgs(session));
});
}
private void InitializeChannel(IChannel channel, ISession session)
{
if (session.Direction == ConnectionDirection.In)
{
Metrics.IncomingConnections++;
}
else
{
Metrics.OutgoingConnections++;
}
if (_logger.IsTrace)
{
_logger.Trace($"Initializing {session.Direction.ToString().ToUpper()} channel{(session.Direction == ConnectionDirection.Out ? $": {session.RemoteNodeId}@{session.RemoteHost}:{session.RemotePort}" : string.Empty)}");
}
_sessionMonitor.AddSession(session);
session.Disconnected += SessionOnPeerDisconnected;
SessionCreated?.Invoke(this, new SessionEventArgs(session));
HandshakeRole role = session.Direction == ConnectionDirection.In ? HandshakeRole.Recipient : HandshakeRole.Initiator;
var handshakeHandler = new NettyHandshakeHandler(_encryptionHandshakeService, session, role, session.RemoteNodeId, _logManager);
IChannelPipeline pipeline = channel.Pipeline;
// pipeline.AddLast(new LoggingHandler(session.Direction.ToString().ToUpper(), DotNetty.Handlers.Logging.LogLevel.TRACE));
pipeline.AddLast("enc-handshake-dec", new LengthFieldBasedFrameDecoder(ByteOrder.BigEndian, ushort.MaxValue, 0, 2, 0, 0, true));
pipeline.AddLast("enc-handshake-handler", handshakeHandler);
channel.CloseCompletion.ContinueWith(x =>
{
if (_logger.IsTrace)
{
_logger.Trace($"Channel disconnected: {session.RemoteNodeId}");
}
session.Disconnect(DisconnectReason.ClientQuitting, DisconnectType.Remote);
});
}