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; } }