public virtual void HandleMessage(Packet message)
{
ZeroPacket zeroPacket = new ZeroPacket(message);
HandleMessage(zeroPacket);
zeroPacket.Release();
}
public override void HandleMessage(ZeroPacket message)
{
base.HandleMessage(message);
switch (message.PacketType)
{
case Eth65MessageCode.PooledTransactions:
PooledTransactionsMessage pooledTxMsg
= Deserialize <PooledTransactionsMessage>(message.Content);
Metrics.Eth65PooledTransactionsReceived++;
ReportIn(pooledTxMsg);
Handle(pooledTxMsg);
break;
case Eth65MessageCode.GetPooledTransactions:
GetPooledTransactionsMessage getPooledTxMsg
= Deserialize <GetPooledTransactionsMessage>(message.Content);
ReportIn(getPooledTxMsg);
Handle(getPooledTxMsg);
break;
case Eth65MessageCode.NewPooledTransactionHashes:
NewPooledTransactionHashesMessage newPooledTxMsg =
Deserialize <NewPooledTransactionHashesMessage>(message.Content);
ReportIn(newPooledTxMsg);
Handle(newPooledTxMsg);
break;
}
}
public override void HandleMessage(Packet message)
{
ZeroPacket zeroPacket = new ZeroPacket(message);
HandleMessage(zeroPacket);
zeroPacket.Release();
}
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:
GetReceiptsMessage getReceiptsMessage = Deserialize <GetReceiptsMessage>(message.Content);
ReportIn(getReceiptsMessage);
Handle(getReceiptsMessage);
break;
case Eth63MessageCode.Receipts:
ReceiptsMessage receiptsMessage = Deserialize <ReceiptsMessage>(message.Content);
ReportIn(receiptsMessage);
Handle(receiptsMessage, size);
break;
case Eth63MessageCode.GetNodeData:
GetNodeDataMessage getNodeDataMessage = Deserialize <GetNodeDataMessage>(message.Content);
ReportIn(getNodeDataMessage);
Handle(getNodeDataMessage);
break;
case Eth63MessageCode.NodeData:
NodeDataMessage nodeDataMessage = Deserialize <NodeDataMessage>(message.Content);
ReportIn(nodeDataMessage);
Handle(nodeDataMessage, size);
break;
}
}
public void SerializeAndCreatePacket()
{
IByteBuffer buf = _ser.ZeroSerialize(_txMsg);
_zeroPacket = new ZeroPacket(buf);
_zeroPacket.PacketType = buf.ReadByte();
_zeroPacket.PacketType = Eth62MessageCode.Transactions;
}
public void Current()
{
IByteBuffer buf = _ser.ZeroSerialize(_txMsg);
_zeroPacket = new ZeroPacket(buf);
_zeroPacket.PacketType = buf.ReadByte();
_zeroPacket.PacketType = Eth62MessageCode.Transactions;
_handler.HandleMessage(_zeroPacket);
}
public override void HandleMessage(ZeroPacket message)
{
int size = message.Content.ReadableBytes;
switch (message.PacketType)
{
case SnapMessageCode.GetAccountRange:
GetAccountRangeMessage getAccountRangeMessage = Deserialize <GetAccountRangeMessage>(message.Content);
ReportIn(getAccountRangeMessage);
Handle(getAccountRangeMessage);
break;
case SnapMessageCode.AccountRange:
AccountRangeMessage accountRangeMessage = Deserialize <AccountRangeMessage>(message.Content);
ReportIn(accountRangeMessage);
Handle(accountRangeMessage, size);
break;
case SnapMessageCode.GetStorageRanges:
GetStorageRangeMessage getStorageRangesMessage = Deserialize <GetStorageRangeMessage>(message.Content);
ReportIn(getStorageRangesMessage);
Handle(getStorageRangesMessage);
break;
case SnapMessageCode.StorageRanges:
StorageRangeMessage storageRangesMessage = Deserialize <StorageRangeMessage>(message.Content);
ReportIn(storageRangesMessage);
Handle(storageRangesMessage, size);
break;
case SnapMessageCode.GetByteCodes:
GetByteCodesMessage getByteCodesMessage = Deserialize <GetByteCodesMessage>(message.Content);
ReportIn(getByteCodesMessage);
Handle(getByteCodesMessage);
break;
case SnapMessageCode.ByteCodes:
ByteCodesMessage byteCodesMessage = Deserialize <ByteCodesMessage>(message.Content);
ReportIn(byteCodesMessage);
Handle(byteCodesMessage, size);
break;
case SnapMessageCode.GetTrieNodes:
GetTrieNodesMessage getTrieNodesMessage = Deserialize <GetTrieNodesMessage>(message.Content);
ReportIn(getTrieNodesMessage);
Handle(getTrieNodesMessage);
break;
case SnapMessageCode.TrieNodes:
TrieNodesMessage trieNodesMessage = Deserialize <TrieNodesMessage>(message.Content);
ReportIn(trieNodesMessage);
Handle(trieNodesMessage, size);
break;
}
}
public void HandleMessage(ZeroPacket message)
{
switch (message.PacketType)
{
case AaMessageCode.UserOperations:
Metrics.UserOperationsMessagesReceived++;
UserOperationsMessage uopMsg = Deserialize <UserOperationsMessage>(message.Content);
ReportIn(uopMsg);
Handle(uopMsg);
break;
}
}
public void SetUp()
{
Console.WriteLine("AAA");
Session session = new Session(8545, Substitute.For <IChannel>(), Substitute.For <IDisconnectsAnalyzer>(), LimboLogs.Instance);
session.RemoteNodeId = TestItem.PublicKeyA;
session.RemoteHost = "127.0.0.1";
session.RemotePort = 30303;
_ser = new MessageSerializationService();
_ser.Register(new TransactionsMessageSerializer());
_ser.Register(new StatusMessageSerializer());
NodeStatsManager stats = new NodeStatsManager(TimerFactory.Default, LimboLogs.Instance);
var ecdsa = new EthereumEcdsa(ChainId.Mainnet, LimboLogs.Instance);
var tree = Build.A.BlockTree().TestObject;
var stateProvider = new StateProvider(new TrieStore(new MemDb(), LimboLogs.Instance), new MemDb(), LimboLogs.Instance);
var specProvider = MainnetSpecProvider.Instance;
TxPool.TxPool txPool = new TxPool.TxPool(
ecdsa,
new ChainHeadInfoProvider(new FixedBlockChainHeadSpecProvider(MainnetSpecProvider.Instance), tree, stateProvider),
new TxPoolConfig(),
new TxValidator(ChainId.Mainnet),
LimboLogs.Instance,
new TransactionComparerProvider(specProvider, tree).GetDefaultComparer());
ISyncServer syncSrv = Substitute.For <ISyncServer>();
BlockHeader head = Build.A.BlockHeader.WithNumber(1).TestObject;
syncSrv.Head.Returns(head);
_handler = new Eth62ProtocolHandler(session, _ser, stats, syncSrv, txPool, ShouldGossip.Instance, LimboLogs.Instance);
_handler.DisableTxFiltering();
StatusMessage statusMessage = new StatusMessage();
statusMessage.ProtocolVersion = 63;
statusMessage.BestHash = Keccak.Compute("1");
statusMessage.GenesisHash = Keccak.Compute("0");
statusMessage.TotalDifficulty = 131200;
statusMessage.ChainId = 1;
IByteBuffer bufStatus = _ser.ZeroSerialize(statusMessage);
_zeroPacket = new ZeroPacket(bufStatus);
_zeroPacket.PacketType = bufStatus.ReadByte();
_handler.HandleMessage(_zeroPacket);
Transaction tx = Build.A.Transaction.SignedAndResolved(ecdsa, TestItem.PrivateKeyA).TestObject;
_txMsg = new TransactionsMessage(new[] { tx });
}
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:
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:
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:
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:
Interlocked.Increment(ref Counter);
if (Logger.IsTrace)
{
Logger.Trace($"{Counter:D5} NodeData from {Node:c}");
}
Metrics.Eth63NodeDataReceived++;
Handle(Deserialize <NodeDataMessage>(message.Content), size);
break;
}
}
private Packet Run(Packet packet, StackType inbound, StackType outbound, bool framingEnabled)
{
EmbeddedChannel embeddedChannel = null;
try
{
embeddedChannel = BuildEmbeddedChannel(inbound, outbound, framingEnabled);
if (outbound == StackType.Zero)
{
IByteBuffer packetBuffer = embeddedChannel.Allocator.Buffer(1 + packet.Data.Length);
packetBuffer.WriteByte(packet.PacketType);
packetBuffer.WriteBytes(packet.Data);
embeddedChannel.WriteOutbound(packetBuffer);
}
else // allocating
{
embeddedChannel.WriteOutbound(packet);
}
while (embeddedChannel.OutboundMessages.Any())
{
IByteBuffer encodedPacket = embeddedChannel.ReadOutbound <IByteBuffer>();
embeddedChannel.WriteInbound(encodedPacket);
}
if (inbound == StackType.Zero)
{
ZeroPacket decodedPacket = embeddedChannel.ReadInbound <ZeroPacket>();
Assert.AreEqual(packet.Data.ToHexString(), decodedPacket.Content.ReadAllHex());
Assert.AreEqual(packet.PacketType, decodedPacket.PacketType);
decodedPacket.Release();
}
else // allocating
{
Packet decodedPacket = embeddedChannel.ReadInbound <Packet>();
Assert.AreEqual(packet.Data.ToHexString(), decodedPacket.Data.ToHexString());
Assert.AreEqual(packet.PacketType, decodedPacket.PacketType);
}
}
finally
{
embeddedChannel?.Finish();
}
return(packet);
}
public override void HandleMessage(ZeroPacket message)
{
base.HandleMessage(message);
switch (message.PacketType)
{
case Eth65MessageCode.PooledTransactions:
Handle(Deserialize <PooledTransactionsMessage>(message.Content));
break;
case Eth65MessageCode.GetPooledTransactions:
Handle(Deserialize <GetPooledTransactionsMessage>(message.Content));
break;
case Eth65MessageCode.NewPooledTransactionHashes:
Metrics.Eth65NewPooledTransactionHashesReceived++;
break;
}
}
public void HandleMessage(ZeroPacket message)
{
int size = message.Content.ReadableBytes;
int packetType = message.PacketType;
switch (packetType)
{
case WitMessageCode.GetBlockWitnessHashes:
GetBlockWitnessHashesMessage requestMsg = Deserialize <GetBlockWitnessHashesMessage>(message.Content);
ReportIn(requestMsg);
Handle(requestMsg);
break;
case WitMessageCode.BlockWitnessHashes:
BlockWitnessHashesMessage responseMsg = Deserialize <BlockWitnessHashesMessage>(message.Content);
ReportIn(responseMsg);
Handle(responseMsg, size);
break;
}
}
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 HandleMessage(ZeroPacket message)
{
int packetType = message.PacketType;
if (!_statusReceived && packetType != Eth62MessageCode.Status)
{
throw new SubprotocolException(
$"No {nameof(StatusMessage)} received prior to communication with {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 statusMsg = Deserialize <StatusMessage>(message.Content);
ReportIn(statusMsg);
Handle(statusMsg);
break;
case Eth62MessageCode.NewBlockHashes:
NewBlockHashesMessage newBlockHashesMessage = Deserialize <NewBlockHashesMessage>(message.Content);
ReportIn(newBlockHashesMessage);
Handle(newBlockHashesMessage);
break;
case Eth62MessageCode.Transactions:
Metrics.Eth62TransactionsReceived++;
if (_floodController.IsAllowed())
{
TransactionsMessage txMsg = Deserialize <TransactionsMessage>(message.Content);
ReportIn(txMsg);
Handle(txMsg);
}
break;
case Eth62MessageCode.GetBlockHeaders:
GetBlockHeadersMessage getBlockHeadersMessage
= Deserialize <GetBlockHeadersMessage>(message.Content);
ReportIn(getBlockHeadersMessage);
Handle(getBlockHeadersMessage);
break;
case Eth62MessageCode.BlockHeaders:
BlockHeadersMessage headersMsg = Deserialize <BlockHeadersMessage>(message.Content);
ReportIn(headersMsg);
Handle(headersMsg, size);
break;
case Eth62MessageCode.GetBlockBodies:
GetBlockBodiesMessage getBodiesMsg = Deserialize <GetBlockBodiesMessage>(message.Content);
ReportIn(getBodiesMsg);
Handle(getBodiesMsg);
break;
case Eth62MessageCode.BlockBodies:
HandleBodies(message.Content, size);
break;
case Eth62MessageCode.NewBlock:
NewBlockMessage newBlockMsg = Deserialize <NewBlockMessage>(message.Content);
ReportIn(newBlockMsg);
Handle(newBlockMsg);
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;
}
}
public override void HandleMessage(ZeroPacket message)
{
int size = message.Content.ReadableBytes;
switch (message.PacketType)
{
case Eth66MessageCode.GetBlockHeaders:
GetBlockHeadersMessage getBlockHeadersMessage
= Deserialize <GetBlockHeadersMessage>(message.Content);
Metrics.Eth66GetBlockHeadersReceived++;
ReportIn(getBlockHeadersMessage);
Handle(getBlockHeadersMessage);
break;
case Eth66MessageCode.BlockHeaders:
BlockHeadersMessage headersMsg = Deserialize <BlockHeadersMessage>(message.Content);
Metrics.Eth66BlockHeadersReceived++;
ReportIn(headersMsg);
Handle(headersMsg.EthMessage, size);
break;
case Eth66MessageCode.GetBlockBodies:
GetBlockBodiesMessage getBodiesMsg = Deserialize <GetBlockBodiesMessage>(message.Content);
Metrics.Eth66GetBlockBodiesReceived++;
ReportIn(getBodiesMsg);
Handle(getBodiesMsg);
break;
case Eth66MessageCode.BlockBodies:
BlockBodiesMessage bodiesMsg = Deserialize <BlockBodiesMessage>(message.Content);
Metrics.Eth66BlockBodiesReceived++;
ReportIn(bodiesMsg);
HandleBodies(bodiesMsg.EthMessage, size);
break;
case Eth66MessageCode.GetPooledTransactions:
GetPooledTransactionsMessage getPooledTxMsg
= Deserialize <GetPooledTransactionsMessage>(message.Content);
Metrics.Eth66GetPooledTransactionsReceived++;
ReportIn(getPooledTxMsg);
Handle(getPooledTxMsg);
break;
case Eth66MessageCode.PooledTransactions:
PooledTransactionsMessage pooledTxMsg
= Deserialize <PooledTransactionsMessage>(message.Content);
Metrics.Eth66PooledTransactionsReceived++;
ReportIn(pooledTxMsg);
Handle(pooledTxMsg.EthMessage);
break;
case Eth66MessageCode.GetReceipts:
GetReceiptsMessage getReceiptsMessage = Deserialize <GetReceiptsMessage>(message.Content);
Metrics.Eth66GetReceiptsReceived++;
ReportIn(getReceiptsMessage);
Handle(getReceiptsMessage);
break;
case Eth66MessageCode.Receipts:
ReceiptsMessage receiptsMessage = Deserialize <ReceiptsMessage>(message.Content);
Metrics.Eth66ReceiptsReceived++;
ReportIn(receiptsMessage);
Handle(receiptsMessage.EthMessage, size);
break;
case Eth66MessageCode.GetNodeData:
GetNodeDataMessage getNodeDataMessage = Deserialize <GetNodeDataMessage>(message.Content);
Metrics.Eth66GetNodeDataReceived++;
ReportIn(getNodeDataMessage);
Handle(getNodeDataMessage);
break;
case Eth66MessageCode.NodeData:
NodeDataMessage nodeDataMessage = Deserialize <NodeDataMessage>(message.Content);
Metrics.Eth66NodeDataReceived++;
ReportIn(nodeDataMessage);
Handle(nodeDataMessage.EthMessage, size);
break;
default:
base.HandleMessage(message);
break;
}
}
public abstract void HandleMessage(ZeroPacket message);
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;
switch (message.PacketType)
{
case Eth62MessageCode.Status:
StatusMessage statusMessage = Deserialize <StatusMessage>(message.Content);
Handle(statusMessage);
break;
case Eth62MessageCode.NewBlockHashes:
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++;
if (!_isDowngradedDueToTxFlooding || 10 > _random.Next(0, 99)) // TODO: disable that when IsMining is set to true
{
Handle(Deserialize <TransactionsMessage>(message.Content));
}
break;
case Eth62MessageCode.GetBlockHeaders:
Interlocked.Increment(ref Counter);
if (Logger.IsTrace)
{
Logger.Trace($"{Counter:D5} GetBlockHeaders from {Node:c}");
}
Metrics.Eth62GetBlockHeadersReceived++;
Handle(Deserialize <GetBlockHeadersMessage>(message.Content));
break;
case Eth62MessageCode.BlockHeaders:
Interlocked.Increment(ref Counter);
if (Logger.IsTrace)
{
Logger.Trace($"{Counter:D5} BlockHeaders from {Node:c}");
}
Metrics.Eth62BlockHeadersReceived++;
Handle(Deserialize <BlockHeadersMessage>(message.Content), size);
break;
case Eth62MessageCode.GetBlockBodies:
Interlocked.Increment(ref Counter);
if (Logger.IsTrace)
{
Logger.Trace($"{Counter:D5} GetBlockBodies from {Node:c}");
}
Metrics.Eth62GetBlockBodiesReceived++;
Handle(Deserialize <GetBlockBodiesMessage>(message.Content));
break;
case Eth62MessageCode.BlockBodies:
Interlocked.Increment(ref Counter);
if (Logger.IsTrace)
{
Logger.Trace($"{Counter:D5} BlockBodies from {Node:c}");
}
Metrics.Eth62BlockBodiesReceived++;
Handle(Deserialize <BlockBodiesMessage>(message.Content), size);
break;
case Eth62MessageCode.NewBlock:
Interlocked.Increment(ref Counter);
if (Logger.IsTrace)
{
Logger.Trace($"{Counter:D5} NewBlock from {Node:c}");
}
Metrics.Eth62NewBlockReceived++;
Handle(Deserialize <NewBlockMessage>(message.Content));
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));
}
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;
}
}
