protected void ReportIn(string messageInfo)
{
if (NetworkDiagTracer.IsEnabled)
{
NetworkDiagTracer.ReportIncomingMessage(Session.Node.Address, Name, messageInfo);
}
}
private void HandlePing()
{
if (NetworkDiagTracer.IsEnabled)
{
NetworkDiagTracer.ReportIncomingMessage(Session.Node.Host, "p2p", "Ping");
}
if (Logger.IsTrace)
{
Logger.Trace($"{Session} P2P responding to ping");
}
Send(PongMessage.Instance);
}
protected void ReportIn(string messageInfo)
{
if (Logger.IsTrace)
{
Logger.Trace($"OUT {Counter:D5} {messageInfo}");
}
if (NetworkDiagTracer.IsEnabled)
{
NetworkDiagTracer.ReportIncomingMessage(Session?.Node?.Address, Name, messageInfo);
}
}
protected void Send <T>(T message) where T : P2PMessage
{
if (Logger.IsTrace)
{
Logger.Trace($"Sending {typeof(T).Name}");
}
if (NetworkDiagTracer.IsEnabled)
{
NetworkDiagTracer.ReportOutgoingMessage(Session.Node.Host, Name, typeof(T).Name);
}
Session.DeliverMessage(message);
}
protected void Send <T>(T message) where T : P2PMessage
{
Interlocked.Increment(ref Counter);
if (Logger.IsTrace)
{
Logger.Trace($"{Counter} Sending {typeof(T).Name}");
}
if (NetworkDiagTracer.IsEnabled)
{
NetworkDiagTracer.ReportOutgoingMessage(Session.Node?.Address, Name, message.ToString());
}
Session.DeliverMessage(message);
}
private void HandlePong(Packet msg)
{
if (NetworkDiagTracer.IsEnabled)
{
NetworkDiagTracer.ReportIncomingMessage(Session.Node.Host, "p2p", "Pong");
}
if (Logger.IsTrace)
{
Logger.Trace($"{Session} sending P2P pong");
}
_nodeStatsManager.ReportEvent(Session.Node, NodeStatsEventType.P2PPingIn);
_pongCompletionSource?.TrySetResult(msg);
}
public override void Init()
{
if (Logger.IsTrace)
{
Logger.Trace($"{ProtocolCode} v{ProtocolVersion} subprotocol initializing with {Session.Node:c}");
}
if (SyncServer.Head == null)
{
throw new InvalidOperationException($"Cannot initialize {ProtocolCode} v{ProtocolVersion} protocol without the head block set");
}
BlockHeader head = SyncServer.Head;
StatusMessage statusMessage = new StatusMessage
{
ProtocolVersion = ProtocolVersion,
ChainId = (UInt256)SyncServer.ChainId,
TotalDifficulty = head.TotalDifficulty ?? head.Difficulty,
BestHash = head.Hash,
HeadBlockNo = head.Number,
GenesisHash = SyncServer.Genesis.Hash,
// TODO - implement config option for these
ServeHeaders = true,
ServeChainSince = 0x00,
//if (config.recentchain != null)
// ServeRecentChain = Config.recentchain
ServeStateSince = 0x00,
//if (Config.serverecentstate != null)
// ServeRecentState = Config.RecentState
TxRelay = true,
// TODO - should allow setting to infinite
BufferLimit = int.MaxValue,
MaximumRechargeRate = int.MaxValue
};
Send(statusMessage);
if (NetworkDiagTracer.IsEnabled)
{
NetworkDiagTracer.ReportOutgoingMessage(Session.Node.Address, Name, statusMessage.ToString());
}
Metrics.LesStatusesSent++;
CheckProtocolInitTimeout().ContinueWith(x =>
{
if (x.IsFaulted && Logger.IsError)
{
Logger.Error("Error during lesProtocol handler timeout logic", x.Exception);
}
});
}
public override void DisconnectProtocol(DisconnectReason disconnectReason, string details)
{
if (Logger.IsTrace)
{
Logger.Trace($"Sending disconnect {disconnectReason} ({details}) to {Session.Node:s}");
}
DisconnectMessage message = new DisconnectMessage(disconnectReason);
Send(message);
if (NetworkDiagTracer.IsEnabled)
{
NetworkDiagTracer.ReportDisconnect(Session.Node.Address, $"Local {disconnectReason} {details}");
}
}
private void Handle(NewBlockMessage newBlockMessage)
{
Metrics.Eth62NewBlockReceived++;
if (NetworkDiagTracer.IsEnabled)
{
NetworkDiagTracer.ReportIncomingMessage(Session.Node.Host, Name, $"{nameof(NewBlockMessage)}({newBlockMessage.Block.Number})");
}
newBlockMessage.Block.Header.TotalDifficulty = newBlockMessage.TotalDifficulty;
try
{
SyncServer.AddNewBlock(newBlockMessage.Block, this);
}
catch (Exception e)
{
Logger.Debug($"Adding new block {newBlockMessage.Block?.ToString(Block.Format.Short)} from {Node:c} failed: " + e.Message);
throw;
}
}
public void AddPeer(ISyncPeer syncPeer)
{
if (_logger.IsDebug)
{
_logger.Debug($"Adding sync peer {syncPeer.Node:c}");
}
if (!_isStarted)
{
if (_logger.IsDebug)
{
_logger.Debug($"Sync peer pool not started yet - adding peer is blocked: {syncPeer.Node:s}");
}
return;
}
if (_peers.ContainsKey(syncPeer.Node.Id))
{
if (_logger.IsDebug)
{
_logger.Debug($"Sync peer {syncPeer.Node:c} already in peers collection.");
}
return;
}
PeerInfo peerInfo = new PeerInfo(syncPeer);
_peers.TryAdd(syncPeer.Node.Id, peerInfo);
Metrics.SyncPeers = _peers.Count;
if (_logger.IsDebug)
{
_logger.Debug($"Adding {syncPeer.Node:c} to refresh queue");
}
if (NetworkDiagTracer.IsEnabled)
{
NetworkDiagTracer.ReportInterestingEvent(syncPeer.Node.Host, "adding node to refresh queue");
}
_peerRefreshQueue.Add(new RefreshTotalDiffTask {
SyncPeer = syncPeer
});
}
public override void HandleMessage(ZeroPacket message)
{
if (message.PacketType != LesMessageCode.Status && !_statusReceived)
{
throw new SubprotocolException($"No {nameof(StatusMessage)} received prior to communication with {Session.Node:c}.");
}
int size = message.Content.ReadableBytes;
switch (message.PacketType)
{
case LesMessageCode.Status:
StatusMessage statusMessage = Deserialize <StatusMessage>(message.Content);
if (NetworkDiagTracer.IsEnabled)
{
NetworkDiagTracer.ReportIncomingMessage(Session.Node.Host, Name, statusMessage.ToString());
}
Handle(statusMessage);
break;
}
}
public override int MessageIdSpaceSize => 17; // magic number here following Go
public override void HandleMessage(ZeroPacket message)
{
base.HandleMessage(message);
int size = message.Content.ReadableBytes;
switch (message.PacketType)
{
case Eth63MessageCode.GetReceipts:
if (NetworkDiagTracer.IsEnabled)
{
NetworkDiagTracer.ReportIncomingMessage(Session.Node.Host, Name, nameof(GetReceiptsMessage));
}
Handle(Deserialize <GetReceiptsMessage>(message.Content));
break;
case Eth63MessageCode.Receipts:
if (NetworkDiagTracer.IsEnabled)
{
NetworkDiagTracer.ReportIncomingMessage(Session.Node.Host, Name, nameof(ReceiptsMessage));
}
Handle(Deserialize <ReceiptsMessage>(message.Content), size);
break;
case Eth63MessageCode.GetNodeData:
if (NetworkDiagTracer.IsEnabled)
{
NetworkDiagTracer.ReportIncomingMessage(Session.Node.Host, Name, nameof(GetNodeDataMessage));
}
Handle(Deserialize <GetNodeDataMessage>(message.Content));
break;
case Eth63MessageCode.NodeData:
if (NetworkDiagTracer.IsEnabled)
{
NetworkDiagTracer.ReportIncomingMessage(Session.Node.Host, Name, nameof(NodeDataMessage));
}
Handle(Deserialize <NodeDataMessage>(message.Content), size);
break;
}
}
public override void Init()
{
if (Logger.IsTrace)
{
Logger.Trace($"{ProtocolCode} v{ProtocolVersion} subprotocol initializing with {Session.Node:c}");
}
if (SyncServer.Head == null)
{
throw new InvalidOperationException($"Cannot initialize {ProtocolCode} v{ProtocolVersion} protocol without the head block set");
}
BlockHeader head = SyncServer.Head;
StatusMessage statusMessage = new StatusMessage();
statusMessage.ChainId = (UInt256)SyncServer.ChainId;
statusMessage.ProtocolVersion = ProtocolVersion;
statusMessage.TotalDifficulty = head.TotalDifficulty ?? head.Difficulty;
statusMessage.BestHash = head.Hash;
statusMessage.GenesisHash = SyncServer.Genesis.Hash;
Send(statusMessage);
if (NetworkDiagTracer.IsEnabled)
{
NetworkDiagTracer.ReportOutgoingMessage(Session.Node.Host, Name, statusMessage.ToString());
}
Metrics.StatusesSent++;
//We are expecting receiving Status message anytime from the p2p completion, irrespective of sending Status from our side
CheckProtocolInitTimeout().ContinueWith(x =>
{
if (x.IsFaulted && Logger.IsError)
{
Logger.Error("Error during eth62Protocol handler timeout logic", x.Exception);
}
});
}
private async Task Initialize()
{
if (_context.DbProvider == null)
{
throw new StepDependencyException(nameof(_context.DbProvider));
}
if (_context.BlockTree == null)
{
throw new StepDependencyException(nameof(_context.BlockTree));
}
if (_context.ReceiptStorage == null)
{
throw new StepDependencyException(nameof(_context.ReceiptStorage));
}
if (_context.BlockValidator == null)
{
throw new StepDependencyException(nameof(_context.BlockValidator));
}
if (_context.SealValidator == null)
{
throw new StepDependencyException(nameof(_context.SealValidator));
}
if (_context.Enode == null)
{
throw new StepDependencyException(nameof(_context.Enode));
}
if (_networkConfig.DiagTracerEnabled)
{
NetworkDiagTracer.IsEnabled = true;
NetworkDiagTracer.Start();
}
// Environment.SetEnvironmentVariable("io.netty.allocator.pageSize", "8192");
Environment.SetEnvironmentVariable("io.netty.allocator.maxOrder", _networkConfig.NettyArenaOrder.ToString());
int maxPeersCount = _networkConfig.ActivePeersMaxCount;
_context.SyncPeerPool = new EthSyncPeerPool(_context.BlockTree, _context.NodeStatsManager, maxPeersCount, _context.LogManager);
_context.DisposeStack.Push(_context.SyncPeerPool);
NodeDataFeed feed = new NodeDataFeed(_context.DbProvider.CodeDb, _context.DbProvider.StateDb, _context.LogManager);
NodeDataDownloader nodeDataDownloader = new NodeDataDownloader(_context.SyncPeerPool, feed, _context.NodeDataConsumer, _context.LogManager);
_context.Synchronizer = new Synchronizer(_context.SpecProvider, _context.BlockTree, _context.ReceiptStorage, _context.BlockValidator, _context.SealValidator, _context.SyncPeerPool, _context.Config <ISyncConfig>(), nodeDataDownloader, _context.NodeStatsManager, _context.LogManager);
_context.DisposeStack.Push(_context.Synchronizer);
_context.SyncServer = new SyncServer(
_context.DbProvider.StateDb,
_context.DbProvider.CodeDb,
_context.BlockTree,
_context.ReceiptStorage,
_context.BlockValidator,
_context.SealValidator,
_context.SyncPeerPool,
_context.Synchronizer,
_context.Config <ISyncConfig>(),
_context.LogManager);
InitDiscovery();
await InitPeer().ContinueWith(initPeerTask =>
{
if (initPeerTask.IsFaulted)
{
_logger.Error("Unable to init the peer manager.", initPeerTask.Exception);
}
});
await StartSync().ContinueWith(initNetTask =>
{
if (initNetTask.IsFaulted)
{
_logger.Error("Unable to start the synchronizer.", initNetTask.Exception);
}
});
await StartDiscovery().ContinueWith(initDiscoveryTask =>
{
if (initDiscoveryTask.IsFaulted)
{
_logger.Error("Unable to start the discovery protocol.", initDiscoveryTask.Exception);
}
});
try
{
StartPeer();
}
catch (Exception e)
{
_logger.Error("Unable to start the peer manager.", e);
}
ThisNodeInfo.AddInfo("Ethereum :", $"tcp://{_context.Enode.HostIp}:{_context.Enode.Port}");
ThisNodeInfo.AddInfo("Version :", $"{ClientVersion.Description.Replace("Nethermind/v", string.Empty)}");
ThisNodeInfo.AddInfo("This node :", $"{_context.Enode.Info}");
ThisNodeInfo.AddInfo("Node address :", $"{_context.Enode.Address} (do not use as an account)");
}
private async Task Initialize(CancellationToken cancellationToken)
{
if (_networkConfig.DiagTracerEnabled)
{
NetworkDiagTracer.IsEnabled = true;
NetworkDiagTracer.Start();
}
Environment.SetEnvironmentVariable("io.netty.allocator.maxOrder", _networkConfig.NettyArenaOrder.ToString());
var cht = new CanonicalHashTrie(_api.DbProvider !.ChtDb);
int maxPeersCount = _networkConfig.ActivePeersMaxCount;
_api.SyncPeerPool = new SyncPeerPool(_api.BlockTree !, _api.NodeStatsManager !, maxPeersCount, _api.LogManager);
_api.DisposeStack.Push(_api.SyncPeerPool);
SyncProgressResolver syncProgressResolver = new SyncProgressResolver(_api.BlockTree !, _api.ReceiptStorage !, _api.DbProvider.StateDb, _api.DbProvider.BeamStateDb, _syncConfig, _api.LogManager);
MultiSyncModeSelector syncModeSelector = CreateMultiSyncModeSelector(syncProgressResolver);
if (_api.SyncModeSelector != null)
{
// this is really bad and is a result of lack of proper dependency management
PendingSyncModeSelector pendingOne = (PendingSyncModeSelector)_api.SyncModeSelector;
pendingOne.SetActual(syncModeSelector);
}
_api.SyncModeSelector = syncModeSelector;
_api.DisposeStack.Push(syncModeSelector);
_api.Synchronizer = new Synchronizer(
_api.DbProvider,
_api.SpecProvider !,
_api.BlockTree !,
_api.ReceiptStorage !,
_api.BlockValidator !,
_api.SealValidator !,
_api.SyncPeerPool,
_api.NodeStatsManager !,
_api.SyncModeSelector,
_syncConfig,
_api.LogManager);
_api.DisposeStack.Push(_api.Synchronizer);
_api.SyncServer = new SyncServer(
_api.DbProvider.StateDb,
_api.DbProvider.CodeDb,
_api.BlockTree !,
_api.ReceiptStorage !,
_api.BlockValidator !,
_api.SealValidator !,
_api.SyncPeerPool,
_api.SyncModeSelector,
_api.Config <ISyncConfig>(),
_api.LogManager,
cht);
_ = _api.SyncServer.BuildCHT();
_api.DisposeStack.Push(_api.SyncServer);
InitDiscovery();
if (cancellationToken.IsCancellationRequested)
{
return;
}
await InitPeer().ContinueWith(initPeerTask =>
{
if (initPeerTask.IsFaulted)
{
_logger.Error("Unable to init the peer manager.", initPeerTask.Exception);
}
});
if (cancellationToken.IsCancellationRequested)
{
return;
}
await StartSync().ContinueWith(initNetTask =>
{
if (initNetTask.IsFaulted)
{
_logger.Error("Unable to start the synchronizer.", initNetTask.Exception);
}
});
if (cancellationToken.IsCancellationRequested)
{
return;
}
await StartDiscovery().ContinueWith(initDiscoveryTask =>
{
if (initDiscoveryTask.IsFaulted)
{
_logger.Error("Unable to start the discovery protocol.", initDiscoveryTask.Exception);
}
});
try
{
if (cancellationToken.IsCancellationRequested)
{
return;
}
StartPeer();
}
catch (Exception e)
{
_logger.Error("Unable to start the peer manager.", e);
}
if (_api.Enode == null)
{
throw new InvalidOperationException("Cannot initialize network without knowing own enode");
}
ThisNodeInfo.AddInfo("Ethereum :", $"tcp://{_api.Enode.HostIp}:{_api.Enode.Port}");
ThisNodeInfo.AddInfo("Version :", $"{ClientVersion.Description.Replace("Nethermind/v", string.Empty)}");
ThisNodeInfo.AddInfo("This node :", $"{_api.Enode.Info}");
ThisNodeInfo.AddInfo("Node address :", $"{_api.Enode.Address} (do not use as an account)");
}
public override void HandleMessage(ZeroPacket message)
{
if (message.PacketType != LesMessageCode.Status && !_statusReceived)
{
throw new SubprotocolException($"No {nameof(StatusMessage)} received prior to communication with {Session.Node:c}.");
}
int size = message.Content.ReadableBytes;
switch (message.PacketType)
{
case LesMessageCode.Status:
StatusMessage statusMessage = Deserialize <StatusMessage>(message.Content);
if (NetworkDiagTracer.IsEnabled)
{
NetworkDiagTracer.ReportIncomingMessage(Session.Node.Address, Name, statusMessage.ToString());
}
Handle(statusMessage);
break;
case LesMessageCode.GetBlockHeaders:
GetBlockHeadersMessage getBlockHeadersMessage = Deserialize <GetBlockHeadersMessage>(message.Content);
if (NetworkDiagTracer.IsEnabled)
{
NetworkDiagTracer.ReportIncomingMessage(Session.Node.Address, Name, getBlockHeadersMessage.ToString());
}
Handle(getBlockHeadersMessage);
break;
case LesMessageCode.GetBlockBodies:
GetBlockBodiesMessage getBlockBodiesMessage = Deserialize <GetBlockBodiesMessage>(message.Content);
if (NetworkDiagTracer.IsEnabled)
{
NetworkDiagTracer.ReportIncomingMessage(Session.Node.Address, Name, getBlockBodiesMessage.ToString());
}
Handle(getBlockBodiesMessage);
break;
case LesMessageCode.GetReceipts:
GetReceiptsMessage getReceiptsMessage = Deserialize <GetReceiptsMessage>(message.Content);
if (NetworkDiagTracer.IsEnabled)
{
NetworkDiagTracer.ReportIncomingMessage(Session.Node.Address, Name, getReceiptsMessage.ToString());
}
Handle(getReceiptsMessage);
break;
case LesMessageCode.GetContractCodes:
GetContractCodesMessage getContractCodesMessage = Deserialize <GetContractCodesMessage>(message.Content);
if (NetworkDiagTracer.IsEnabled)
{
NetworkDiagTracer.ReportIncomingMessage(Session.Node.Address, Name, getContractCodesMessage.ToString());
}
Handle(getContractCodesMessage);
break;
case LesMessageCode.GetHelperTrieProofs:
GetHelperTrieProofsMessage getHelperTrieProofsMessage = Deserialize <GetHelperTrieProofsMessage>(message.Content);
if (NetworkDiagTracer.IsEnabled)
{
NetworkDiagTracer.ReportIncomingMessage(Session.Node.Address, Name, getHelperTrieProofsMessage.ToString());
}
Handle(getHelperTrieProofsMessage);
break;
}
}
public virtual void HandleMessage(ZeroPacket message)
{
if (Logger.IsTrace)
{
Logger.Trace($"Handling {message} message from {Session.Node:c}.");
}
if (message.PacketType != Eth62MessageCode.Status && !_statusReceived)
{
throw new SubprotocolException($"No {nameof(StatusMessage)} received prior to communication with {Session.Node:c}.");
}
int size = message.Content.ReadableBytes;
// Logger.Warn($"Received a message {message.Protocol}.{Enum.GetName(typeof(Eth62MessageCode), message.PacketType)} of size {size/1024}kb");
switch (message.PacketType)
{
case Eth62MessageCode.Status:
StatusMessage statusMessage = Deserialize <StatusMessage>(message.Content);
if (NetworkDiagTracer.IsEnabled)
{
NetworkDiagTracer.ReportIncomingMessage(Session.Node.Host, Name, statusMessage.ToString());
}
Handle(statusMessage);
break;
case Eth62MessageCode.NewBlockHashes:
if (NetworkDiagTracer.IsEnabled)
{
NetworkDiagTracer.ReportIncomingMessage(Session.Node.Host, Name, nameof(NewBlockHashesMessage));
}
Interlocked.Increment(ref Counter);
if (Logger.IsTrace)
{
Logger.Trace($"{Counter:D5} NewBlockHashes from {Node:c}");
}
Metrics.Eth62NewBlockHashesReceived++;
Handle(Deserialize <NewBlockHashesMessage>(message.Content));
break;
case Eth62MessageCode.Transactions:
Interlocked.Increment(ref Counter);
Metrics.Eth62TransactionsReceived++;
TransactionsMessage transactionsMessage = Deserialize <TransactionsMessage>(message.Content);
if (NetworkDiagTracer.IsEnabled)
{
NetworkDiagTracer.ReportIncomingMessage(Session.Node.Host, Name, $"{nameof(TransactionsMessage)}({transactionsMessage.Transactions.Length})");
}
if (!_isDowngradedDueToTxFlooding || 10 > _random.Next(0, 99)) // TODO: disable that when IsMining is set to true
{
Handle(transactionsMessage);
}
break;
case Eth62MessageCode.GetBlockHeaders:
Interlocked.Increment(ref Counter);
if (Logger.IsTrace)
{
Logger.Trace($"{Counter:D5} GetBlockHeaders from {Node:c}");
}
Metrics.Eth62GetBlockHeadersReceived++;
GetBlockHeadersMessage getBlockHeadersMessage = Deserialize <GetBlockHeadersMessage>(message.Content);
if (NetworkDiagTracer.IsEnabled)
{
NetworkDiagTracer.ReportIncomingMessage(Session.Node.Host, Name, $"{nameof(GetBlockHeadersMessage)}({getBlockHeadersMessage.StartingBlockNumber}|{getBlockHeadersMessage.StartingBlockHash}, {getBlockHeadersMessage.MaxHeaders})");
}
Handle(getBlockHeadersMessage);
break;
case Eth62MessageCode.BlockHeaders:
Interlocked.Increment(ref Counter);
if (Logger.IsTrace)
{
Logger.Trace($"{Counter:D5} BlockHeaders from {Node:c}");
}
Metrics.Eth62BlockHeadersReceived++;
BlockHeadersMessage blockHeadersMessage = Deserialize <BlockHeadersMessage>(message.Content);
if (NetworkDiagTracer.IsEnabled)
{
NetworkDiagTracer.ReportIncomingMessage(Session.Node.Host, Name, $"{nameof(BlockHeadersMessage)}({blockHeadersMessage.BlockHeaders.Length})");
}
Handle(blockHeadersMessage, size);
break;
case Eth62MessageCode.GetBlockBodies:
Interlocked.Increment(ref Counter);
if (Logger.IsTrace)
{
Logger.Trace($"{Counter:D5} GetBlockBodies from {Node:c}");
}
Metrics.Eth62GetBlockBodiesReceived++;
GetBlockBodiesMessage getBlockBodiesMessage = Deserialize <GetBlockBodiesMessage>(message.Content);
if (NetworkDiagTracer.IsEnabled)
{
NetworkDiagTracer.ReportIncomingMessage(Session.Node.Host, Name, $"{nameof(GetBlockBodiesMessage)}({getBlockBodiesMessage.BlockHashes.Count})");
}
Handle(getBlockBodiesMessage);
break;
case Eth62MessageCode.BlockBodies:
Interlocked.Increment(ref Counter);
if (Logger.IsTrace)
{
Logger.Trace($"{Counter:D5} BlockBodies from {Node:c}");
}
Metrics.Eth62BlockBodiesReceived++;
BlockBodiesMessage blockBodiesMessage = Deserialize <BlockBodiesMessage>(message.Content);
if (NetworkDiagTracer.IsEnabled)
{
NetworkDiagTracer.ReportIncomingMessage(Session.Node.Host, Name, $"{nameof(BlockBodiesMessage)}({blockBodiesMessage.Bodies.Length})");
}
Handle(blockBodiesMessage, size);
break;
case Eth62MessageCode.NewBlock:
Interlocked.Increment(ref Counter);
if (Logger.IsTrace)
{
Logger.Trace($"{Counter:D5} NewBlock from {Node:c}");
}
Metrics.Eth62NewBlockReceived++;
NewBlockMessage newBlockMessage = Deserialize <NewBlockMessage>(message.Content);
if (NetworkDiagTracer.IsEnabled)
{
NetworkDiagTracer.ReportIncomingMessage(Session.Node.Host, Name, $"{nameof(NewBlockMessage)}({newBlockMessage.Block.Number})");
}
Handle(newBlockMessage);
break;
}
}
public override void HandleMessage(ZeroPacket message)
{
int packetType = message.PacketType;
if (packetType != Eth62MessageCode.Status && !_statusReceived)
{
throw new SubprotocolException($"No {nameof(StatusMessage)} received prior to communication with {Session.Node:c}.");
}
int size = message.Content.ReadableBytes;
if (Logger.IsTrace)
{
Logger.Trace($"{Counter:D5} {Eth62MessageCode.GetDescription(packetType)} from {Node:c}");
}
switch (packetType)
{
case Eth62MessageCode.Status:
StatusMessage statusMessage = Deserialize <StatusMessage>(message.Content);
if (NetworkDiagTracer.IsEnabled)
{
NetworkDiagTracer.ReportIncomingMessage(Session.Node.Host, Name, statusMessage.ToString());
}
Handle(statusMessage);
break;
case Eth62MessageCode.NewBlockHashes:
if (NetworkDiagTracer.IsEnabled)
{
NetworkDiagTracer.ReportIncomingMessage(Session.Node.Host, Name, nameof(NewBlockHashesMessage));
}
Handle(Deserialize <NewBlockHashesMessage>(message.Content));
break;
case Eth62MessageCode.Transactions:
TransactionsMessage transactionsMessage = Deserialize <TransactionsMessage>(message.Content);
if (NetworkDiagTracer.IsEnabled)
{
NetworkDiagTracer.ReportIncomingMessage(Session.Node.Host, Name, $"{nameof(TransactionsMessage)}({transactionsMessage.Transactions.Count})");
}
Handle(transactionsMessage);
break;
case Eth62MessageCode.GetBlockHeaders:
GetBlockHeadersMessage getBlockHeadersMessage = Deserialize <GetBlockHeadersMessage>(message.Content);
if (NetworkDiagTracer.IsEnabled)
{
NetworkDiagTracer.ReportIncomingMessage(Session.Node.Host, Name, $"{nameof(GetBlockHeadersMessage)}({getBlockHeadersMessage.StartingBlockNumber}|{getBlockHeadersMessage.StartingBlockHash}, {getBlockHeadersMessage.MaxHeaders})");
}
Handle(getBlockHeadersMessage);
break;
case Eth62MessageCode.BlockHeaders:
BlockHeadersMessage blockHeadersMessage = Deserialize <BlockHeadersMessage>(message.Content);
if (NetworkDiagTracer.IsEnabled)
{
NetworkDiagTracer.ReportIncomingMessage(Session.Node.Host, Name, $"{nameof(BlockHeadersMessage)}({blockHeadersMessage.BlockHeaders.Length})");
}
Handle(blockHeadersMessage, size);
break;
case Eth62MessageCode.GetBlockBodies:
GetBlockBodiesMessage getBlockBodiesMessage = Deserialize <GetBlockBodiesMessage>(message.Content);
if (NetworkDiagTracer.IsEnabled)
{
NetworkDiagTracer.ReportIncomingMessage(Session.Node.Host, Name, $"{nameof(GetBlockBodiesMessage)}({getBlockBodiesMessage.BlockHashes.Count})");
}
Handle(getBlockBodiesMessage);
break;
case Eth62MessageCode.BlockBodies:
BlockBodiesMessage blockBodiesMessage = Deserialize <BlockBodiesMessage>(message.Content);
if (NetworkDiagTracer.IsEnabled)
{
NetworkDiagTracer.ReportIncomingMessage(Session.Node.Host, Name, $"{nameof(BlockBodiesMessage)}({blockBodiesMessage.Bodies.Length})");
}
Handle(blockBodiesMessage, size);
break;
case Eth62MessageCode.NewBlock:
NewBlockMessage newBlockMessage = Deserialize <NewBlockMessage>(message.Content);
if (NetworkDiagTracer.IsEnabled)
{
NetworkDiagTracer.ReportIncomingMessage(Session.Node.Host, Name, $"{nameof(NewBlockMessage)}({newBlockMessage.Block.Number})");
}
Handle(newBlockMessage);
break;
}
}
private async Task Initialize(CancellationToken cancellationToken)
{
if (_ctx.DbProvider == null)
{
throw new StepDependencyException(nameof(_ctx.DbProvider));
}
if (_ctx.BlockTree == null)
{
throw new StepDependencyException(nameof(_ctx.BlockTree));
}
if (_ctx.ReceiptStorage == null)
{
throw new StepDependencyException(nameof(_ctx.ReceiptStorage));
}
if (_ctx.BlockValidator == null)
{
throw new StepDependencyException(nameof(_ctx.BlockValidator));
}
if (_ctx.SealValidator == null)
{
throw new StepDependencyException(nameof(_ctx.SealValidator));
}
if (_ctx.Enode == null)
{
throw new StepDependencyException(nameof(_ctx.Enode));
}
if (_networkConfig.DiagTracerEnabled)
{
NetworkDiagTracer.IsEnabled = true;
NetworkDiagTracer.Start();
}
ThisNodeInfo.AddInfo("Mem est netty:", $"{NettyMemoryEstimator.Estimate((uint)Environment.ProcessorCount, _networkConfig.NettyArenaOrder) / 1000 / 1000}MB".PadLeft(8));
ThisNodeInfo.AddInfo("Mem est peers:", $"{_networkConfig.ActivePeersMaxCount}MB".PadLeft(8));
Environment.SetEnvironmentVariable("io.netty.allocator.maxOrder", _networkConfig.NettyArenaOrder.ToString());
int maxPeersCount = _networkConfig.ActivePeersMaxCount;
_ctx.SyncPeerPool = new SyncPeerPool(_ctx.BlockTree, _ctx.NodeStatsManager, maxPeersCount, _ctx.LogManager);
_ctx.DisposeStack.Push(_ctx.SyncPeerPool);
SyncProgressResolver syncProgressResolver = new SyncProgressResolver(_ctx.BlockTree, _ctx.ReceiptStorage, _ctx.DbProvider.StateDb, _ctx.DbProvider.BeamStateDb, _syncConfig, _ctx.LogManager);
MultiSyncModeSelector syncModeSelector = new MultiSyncModeSelector(syncProgressResolver, _ctx.SyncPeerPool, _syncConfig, _ctx.LogManager);
if (_ctx.SyncModeSelector != null)
{
// this is really bad and is a result of lack of proper dependency management
PendingSyncModeSelector pendingOne = (PendingSyncModeSelector)_ctx.SyncModeSelector;
pendingOne.SetActual(syncModeSelector);
}
_ctx.SyncModeSelector = syncModeSelector;
_ctx.DisposeStack.Push(syncModeSelector);
_ctx.Synchronizer = new Synchronizer(
_ctx.DbProvider,
_ctx.SpecProvider,
_ctx.BlockTree,
_ctx.ReceiptStorage,
_ctx.BlockValidator,
_ctx.SealValidator,
_ctx.SyncPeerPool,
_ctx.NodeStatsManager,
_ctx.SyncModeSelector,
_syncConfig,
_ctx.LogManager);
_ctx.DisposeStack.Push(_ctx.Synchronizer);
_ctx.SyncServer = new SyncServer(
_ctx.DbProvider.StateDb,
_ctx.DbProvider.CodeDb,
_ctx.BlockTree,
_ctx.ReceiptStorage,
_ctx.BlockValidator,
_ctx.SealValidator,
_ctx.SyncPeerPool,
_ctx.SyncModeSelector,
_ctx.Config <ISyncConfig>(),
_ctx.LogManager);
_ctx.DisposeStack.Push(_ctx.SyncServer);
InitDiscovery();
if (cancellationToken.IsCancellationRequested)
{
return;
}
await InitPeer().ContinueWith(initPeerTask =>
{
if (initPeerTask.IsFaulted)
{
_logger.Error("Unable to init the peer manager.", initPeerTask.Exception);
}
});
if (cancellationToken.IsCancellationRequested)
{
return;
}
await StartSync().ContinueWith(initNetTask =>
{
if (initNetTask.IsFaulted)
{
_logger.Error("Unable to start the synchronizer.", initNetTask.Exception);
}
});
if (cancellationToken.IsCancellationRequested)
{
return;
}
await StartDiscovery().ContinueWith(initDiscoveryTask =>
{
if (initDiscoveryTask.IsFaulted)
{
_logger.Error("Unable to start the discovery protocol.", initDiscoveryTask.Exception);
}
});
try
{
if (cancellationToken.IsCancellationRequested)
{
return;
}
StartPeer();
}
catch (Exception e)
{
_logger.Error("Unable to start the peer manager.", e);
}
ThisNodeInfo.AddInfo("Ethereum :", $"tcp://{_ctx.Enode.HostIp}:{_ctx.Enode.Port}");
ThisNodeInfo.AddInfo("Version :", $"{ClientVersion.Description.Replace("Nethermind/v", string.Empty)}");
ThisNodeInfo.AddInfo("This node :", $"{_ctx.Enode.Info}");
ThisNodeInfo.AddInfo("Node address :", $"{_ctx.Enode.Address} (do not use as an account)");
}
private async Task Initialize(CancellationToken cancellationToken)
{
if (_api.DbProvider == null)
{
throw new StepDependencyException(nameof(_api.DbProvider));
}
if (_networkConfig.DiagTracerEnabled)
{
NetworkDiagTracer.IsEnabled = true;
}
if (NetworkDiagTracer.IsEnabled)
{
NetworkDiagTracer.Start(_api.LogManager);
}
Environment.SetEnvironmentVariable("io.netty.allocator.maxOrder", _networkConfig.NettyArenaOrder.ToString());
CanonicalHashTrie cht = new CanonicalHashTrie(_api.DbProvider !.ChtDb);
ProgressTracker progressTracker = new(_api.BlockTree !, _api.DbProvider.StateDb, _api.LogManager);
_api.SnapProvider = new SnapProvider(progressTracker, _api.DbProvider, _api.LogManager);
SyncProgressResolver syncProgressResolver = new(
_api.BlockTree !,
_api.ReceiptStorage !,
_api.DbProvider.StateDb,
_api.ReadOnlyTrieStore !,
progressTracker,
_syncConfig,
_api.LogManager);
_api.SyncProgressResolver = syncProgressResolver;
_api.BetterPeerStrategy = new TotalDifficultyBetterPeerStrategy(_api.LogManager);
int maxPeersCount = _networkConfig.ActivePeersMaxCount;
int maxPriorityPeersCount = _networkConfig.PriorityPeersMaxCount;
SyncPeerPool apiSyncPeerPool = new(_api.BlockTree !, _api.NodeStatsManager !, _api.BetterPeerStrategy, maxPeersCount, maxPriorityPeersCount, SyncPeerPool.DefaultUpgradeIntervalInMs, _api.LogManager);
_api.SyncPeerPool = apiSyncPeerPool;
_api.PeerDifficultyRefreshPool = apiSyncPeerPool;
_api.DisposeStack.Push(_api.SyncPeerPool);
IEnumerable <ISynchronizationPlugin> synchronizationPlugins = _api.GetSynchronizationPlugins();
foreach (ISynchronizationPlugin plugin in synchronizationPlugins)
{
await plugin.InitSynchronization();
}
_api.SyncModeSelector ??= CreateMultiSyncModeSelector(syncProgressResolver);
_api.DisposeStack.Push(_api.SyncModeSelector);
_api.Pivot ??= new Pivot(_syncConfig);
if (_api.BlockDownloaderFactory is null || _api.Synchronizer is null)
{
SyncReport syncReport = new(_api.SyncPeerPool !, _api.NodeStatsManager !, _api.SyncModeSelector, _syncConfig, _api.Pivot, _api.LogManager);
_api.BlockDownloaderFactory ??= new BlockDownloaderFactory(_api.SpecProvider !,
_api.BlockTree !,
_api.ReceiptStorage !,
_api.BlockValidator !,
_api.SealValidator !,
_api.SyncPeerPool !,
_api.BetterPeerStrategy !,
syncReport,
_api.LogManager);
_api.Synchronizer ??= new Synchronizer(
_api.DbProvider,
_api.SpecProvider !,
_api.BlockTree !,
_api.ReceiptStorage !,
_api.SyncPeerPool,
_api.NodeStatsManager !,
_api.SyncModeSelector,
_syncConfig,
_api.SnapProvider,
_api.BlockDownloaderFactory,
_api.Pivot,
syncReport,
_api.LogManager);
}
_api.DisposeStack.Push(_api.Synchronizer);
_api.SyncServer = new SyncServer(
_api.TrieStore !,
_api.DbProvider.CodeDb,
_api.BlockTree !,
_api.ReceiptStorage !,
_api.BlockValidator !,
_api.SealValidator !,
_api.SyncPeerPool,
_api.SyncModeSelector,
_api.Config <ISyncConfig>(),
_api.WitnessRepository,
_api.GossipPolicy,
_api.SpecProvider !,
_api.LogManager,
cht);
_ = _api.SyncServer.BuildCHT();
_api.DisposeStack.Push(_api.SyncServer);
InitDiscovery();
if (cancellationToken.IsCancellationRequested)
{
return;
}
await InitPeer().ContinueWith(initPeerTask =>
{
if (initPeerTask.IsFaulted)
{
_logger.Error("Unable to init the peer manager.", initPeerTask.Exception);
}
});
if (_syncConfig.SnapSync)
{
SnapCapabilitySwitcher snapCapabilitySwitcher = new(_api.ProtocolsManager, progressTracker);
snapCapabilitySwitcher.EnableSnapCapabilityUntilSynced();
}
if (cancellationToken.IsCancellationRequested)
{
return;
}
await StartSync().ContinueWith(initNetTask =>
{
if (initNetTask.IsFaulted)
{
_logger.Error("Unable to start the synchronizer.", initNetTask.Exception);
}
});
if (cancellationToken.IsCancellationRequested)
{
return;
}
await StartDiscovery().ContinueWith(initDiscoveryTask =>
{
if (initDiscoveryTask.IsFaulted)
{
_logger.Error("Unable to start the discovery protocol.", initDiscoveryTask.Exception);
}
});
try
{
if (cancellationToken.IsCancellationRequested)
{
return;
}
StartPeer();
}
catch (Exception e)
{
_logger.Error("Unable to start the peer manager.", e);
}
if (_api.Enode == null)
{
throw new InvalidOperationException("Cannot initialize network without knowing own enode");
}
ThisNodeInfo.AddInfo("Ethereum :", $"tcp://{_api.Enode.HostIp}:{_api.Enode.Port}");
ThisNodeInfo.AddInfo("Version :", $"{ClientVersion.Description.Replace("Nethermind/v", string.Empty)}");
ThisNodeInfo.AddInfo("This node :", $"{_api.Enode.Info}");
ThisNodeInfo.AddInfo("Node address :", $"{_api.Enode.Address} (do not use as an account)");
}
public override void HandleMessage(Packet msg)
{
if (msg.PacketType == P2PMessageCode.Hello)
{
HandleHello(Deserialize <HelloMessage>(msg.Data));
Metrics.HellosReceived++;
foreach (Capability capability in AgreedCapabilities.GroupBy(c => c.ProtocolCode).Select(c => c.OrderBy(v => v.Version).Last()))
{
if (Logger.IsTrace)
{
Logger.Trace($"{Session.RemoteNodeId} Starting protocolHandler for {capability.ProtocolCode} v{capability.Version} on {Session.RemotePort}");
}
SubprotocolRequested?.Invoke(this, new ProtocolEventArgs(capability.ProtocolCode, capability.Version));
}
}
else if (msg.PacketType == P2PMessageCode.Disconnect)
{
DisconnectMessage disconnectMessage = Deserialize <DisconnectMessage>(msg.Data);
if (NetworkDiagTracer.IsEnabled)
{
NetworkDiagTracer.ReportIncomingMessage(Session.Node.Host, "p2p", $"Disconnect({disconnectMessage.Reason})");
}
if (Logger.IsTrace)
{
Logger.Trace($"|NetworkTrace| {Session.RemoteNodeId} Received disconnect ({(Enum.IsDefined(typeof(DisconnectReason), (byte) disconnectMessage.Reason) ? ((DisconnectReason) disconnectMessage.Reason).ToString() : disconnectMessage.Reason.ToString())}) on {Session.RemotePort}");
}
Close(disconnectMessage.Reason);
}
else if (msg.PacketType == P2PMessageCode.Ping)
{
if (Logger.IsTrace)
{
Logger.Trace($"{Session.RemoteNodeId} Received PING on {Session.RemotePort}");
}
HandlePing();
}
else if (msg.PacketType == P2PMessageCode.Pong)
{
if (Logger.IsTrace)
{
Logger.Trace($"{Session.RemoteNodeId} Received PONG on {Session.RemotePort}");
}
HandlePong(msg);
}
else if (msg.PacketType == P2PMessageCode.AddCapability)
{
AddCapabilityMessage message = Deserialize <AddCapabilityMessage>(msg.Data);
Capability capability = message.Capability;
AgreedCapabilities.Add(message.Capability);
SupportedCapabilities.Add(message.Capability);
if (Logger.IsTrace)
{
Logger.Trace($"{Session.RemoteNodeId} Starting protocolHandler for {capability.ProtocolCode} v{capability.Version} on {Session.RemotePort}");
}
SubprotocolRequested?.Invoke(this, new ProtocolEventArgs(capability.ProtocolCode, capability.Version));
}
else
{
Logger.Error($"{Session.RemoteNodeId} Unhandled packet type: {msg.PacketType}");
}
}
private void HandleHello(HelloMessage hello)
{
if (NetworkDiagTracer.IsEnabled)
{
NetworkDiagTracer.ReportIncomingMessage(Session.Node.Host, "p2p", $"Hello({hello.ClientId}, {string.Join(", ", hello.Capabilities)})");
}
bool isInbound = !_sentHello;
if (Logger.IsTrace)
{
Logger.Trace($"{Session} P2P received hello.");
}
if (!hello.NodeId.Equals(Session.RemoteNodeId))
{
if (Logger.IsDebug)
{
Logger.Debug($"Inconsistent Node ID details - expected {Session.RemoteNodeId}, received hello with {hello.NodeId} on " + (isInbound ? "IN connection" : "OUT connection"));
}
// it does not really matter if there is mismatch - we do not use it anywhere
// throw new NodeDetailsMismatchException();
}
RemoteClientId = hello.ClientId;
Session.Node.ClientId = hello.ClientId;
if (Logger.IsTrace)
{
Logger.Trace(!_sentHello
? $"{Session.RemoteNodeId} P2P initiating inbound {hello.Protocol}.{hello.P2PVersion} on {hello.ListenPort} ({hello.ClientId})"
: $"{Session.RemoteNodeId} P2P initiating outbound {hello.Protocol}.{hello.P2PVersion} on {hello.ListenPort} ({hello.ClientId})");
}
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-8.md
// Clients implementing a newer version simply send a packet with higher version and possibly additional list elements.
// * If such a packet is received by a node with lower version, it will blindly assume that the remote end is backwards-compatible and respond with the old handshake.
// * If the packet is received by a node with equal version, new features of the protocol can be used.
// * If the packet is received by a node with higher version, it can enable backwards-compatibility logic or drop the connection.
ProtocolVersion = hello.P2PVersion;
List <Capability> capabilities = hello.Capabilities;
AvailableCapabilities = new List <Capability>(capabilities);
foreach (Capability remotePeerCapability in capabilities)
{
if (SupportedCapabilities.Contains(remotePeerCapability))
{
if (Logger.IsTrace)
{
Logger.Trace($"{Session.RemoteNodeId} Agreed on {remotePeerCapability.ProtocolCode} v{remotePeerCapability.Version}");
}
AgreedCapabilities.Add(remotePeerCapability);
}
else
{
if (Logger.IsTrace)
{
Logger.Trace($"{Session.RemoteNodeId} Capability not supported {remotePeerCapability.ProtocolCode} v{remotePeerCapability.Version}");
}
}
}
if (!capabilities.Any(c => SupportedCapabilities.Contains(c)))
{
InitiateDisconnect(DisconnectReason.UselessPeer, $"capabilities: {string.Join(", ", capabilities.Select(c => string.Concat(c.ProtocolCode, c.Version)))}");
}
ReceivedProtocolInitMsg(hello);
P2PProtocolInitializedEventArgs eventArgs = new P2PProtocolInitializedEventArgs(this)
{
P2PVersion = ProtocolVersion,
ClientId = RemoteClientId,
Capabilities = capabilities,
ListenPort = hello.ListenPort
};
ProtocolInitialized?.Invoke(this, eventArgs);
}
protected override void ChannelRead0(IChannelHandlerContext ctx, DatagramPacket packet)
{
IByteBuffer content = packet.Content;
EndPoint address = packet.Sender;
byte[] msg = new byte[content.ReadableBytes];
content.ReadBytes(msg);
if (msg.Length < 98)
{
if (_logger.IsDebug)
{
_logger.Debug($"Incorrect discovery message, length: {msg.Length}, sender: {address}");
}
return;
}
byte typeRaw = msg[97];
if (!Enum.IsDefined(typeof(MessageType), (int)typeRaw))
{
if (_logger.IsDebug)
{
_logger.Debug($"Unsupported message type: {typeRaw}, sender: {address}, message {msg.ToHexString()}");
}
return;
}
MessageType type = (MessageType)typeRaw;
if (_logger.IsTrace)
{
_logger.Trace($"Received message: {type}");
}
DiscoveryMessage message;
try
{
message = Deserialize(type, msg);
message.FarAddress = (IPEndPoint)address;
}
catch (Exception e)
{
if (_logger.IsDebug)
{
_logger.Debug($"Error during deserialization of the message, type: {type}, sender: {address}, msg: {msg.ToHexString()}, {e.Message}");
}
return;
}
try
{
if ((ulong)message.ExpirationTime < _timestamper.EpochSeconds)
{
if (_logger.IsDebug)
{
_logger.Debug($"Received a discovery message that has expired, type: {type}, sender: {address}, message: {message}");
}
return;
}
if (!message.FarAddress.Equals((IPEndPoint)packet.Sender))
{
if (_logger.IsDebug)
{
_logger.Debug($"Discovery fake IP detected - pretended {message.FarAddress} but was {ctx.Channel.RemoteAddress}, type: {type}, sender: {address}, message: {message}");
}
return;
}
if (message.FarPublicKey == null)
{
if (_logger.IsDebug)
{
_logger.Debug($"Discovery message without a valid signature {message.FarAddress} but was {ctx.Channel.RemoteAddress}, type: {type}, sender: {address}, message: {message}");
}
return;
}
if (message is PingMessage pingMessage)
{
if (NetworkDiagTracer.IsEnabled)
{
NetworkDiagTracer.ReportIncomingMessage(pingMessage.FarAddress.Address.ToString(), "HANDLER disc v4", $"PING {pingMessage.SourceAddress.Address} -> {pingMessage.DestinationAddress.Address}");
}
}
else
{
if (NetworkDiagTracer.IsEnabled)
{
NetworkDiagTracer.ReportIncomingMessage(message.FarAddress.Address.ToString(), "HANDLER disc v4", message.MessageType.ToString());
}
}
_discoveryManager.OnIncomingMessage(message);
}
catch (Exception e)
{
if (_logger.IsDebug)
{
_logger.Error($"DEBUG/ERROR Error while processing message, type: {type}, sender: {address}, message: {message}", e);
}
}
}
public override int MessageIdSpaceSize => 17; // magic number here following Go
public override void HandleMessage(ZeroPacket message)
{
base.HandleMessage(message);
int size = message.Content.ReadableBytes;
switch (message.PacketType)
{
case Eth63MessageCode.GetReceipts:
if (NetworkDiagTracer.IsEnabled)
{
NetworkDiagTracer.ReportIncomingMessage(Session.Node.Host, Name, nameof(GetReceiptsMessage));
}
Interlocked.Increment(ref Counter);
if (Logger.IsTrace)
{
Logger.Trace($"{Counter:D5} GetReceipts from {Node:c}");
}
Metrics.Eth63GetReceiptsReceived++;
Handle(Deserialize <GetReceiptsMessage>(message.Content));
break;
case Eth63MessageCode.Receipts:
if (NetworkDiagTracer.IsEnabled)
{
NetworkDiagTracer.ReportIncomingMessage(Session.Node.Host, Name, nameof(ReceiptsMessage));
}
Interlocked.Increment(ref Counter);
if (Logger.IsTrace)
{
Logger.Trace($"{Counter:D5} Receipts from {Node:c}");
}
Metrics.Eth63ReceiptsReceived++;
Handle(Deserialize <ReceiptsMessage>(message.Content), size);
break;
case Eth63MessageCode.GetNodeData:
if (NetworkDiagTracer.IsEnabled)
{
NetworkDiagTracer.ReportIncomingMessage(Session.Node.Host, Name, nameof(GetNodeDataMessage));
}
Interlocked.Increment(ref Counter);
if (Logger.IsTrace)
{
Logger.Trace($"{Counter:D5} GetNodeData from {Node:c}");
}
Metrics.Eth63GetNodeDataReceived++;
Handle(Deserialize <GetNodeDataMessage>(message.Content));
break;
case Eth63MessageCode.NodeData:
if (NetworkDiagTracer.IsEnabled)
{
NetworkDiagTracer.ReportIncomingMessage(Session.Node.Host, Name, nameof(NodeDataMessage));
}
Interlocked.Increment(ref Counter);
if (Logger.IsTrace)
{
Logger.Trace($"{Counter:D5} NodeData from {Node:c}");
}
Metrics.Eth63NodeDataReceived++;
Handle(Deserialize <NodeDataMessage>(message.Content), size);
break;
}
}
