private async Task <BlockBody[]> SendRequest(GetBlockBodiesMessage message, CancellationToken token) { if (Logger.IsTrace) { Logger.Trace("Sending bodies request:"); Logger.Trace($"Blockhashes count: {message.BlockHashes.Count}"); } Request <GetBlockBodiesMessage, BlockBody[]> request = new(message); _bodiesRequests.Send(request); // Logger.Warn($"Sending bodies request of length {request.Message.BlockHashes.Count} to {this}"); Task <BlockBody[]> task = request.CompletionSource.Task; using CancellationTokenSource delayCancellation = new(); using CancellationTokenSource compositeCancellation = CancellationTokenSource.CreateLinkedTokenSource(token, delayCancellation.Token); Task firstTask = await Task.WhenAny(task, Task.Delay(Timeouts.Eth, compositeCancellation.Token)); if (firstTask.IsCanceled) { // Logger.Warn($"Bodies request of length {request.Message.BlockHashes.Count} expired with {this}"); token.ThrowIfCancellationRequested(); } if (firstTask == task) { // Logger.Warn($"Bodies request of length {request.Message.BlockHashes.Count} received with size {request.ResponseSize} from {this}"); delayCancellation.Cancel(); long elapsed = request.FinishMeasuringTime(); long bytesPerMillisecond = (long)((decimal)request.ResponseSize / Math.Max(1, elapsed)); if (Logger.IsTrace) { Logger.Trace($"{this} speed is {request.ResponseSize}/{elapsed} = {bytesPerMillisecond}"); } StatsManager.ReportTransferSpeedEvent(Session.Node, TransferSpeedType.Bodies, bytesPerMillisecond); return(task.Result); } StatsManager.ReportTransferSpeedEvent(Session.Node, TransferSpeedType.Bodies, 0L); throw new TimeoutException($"{Session} Request timeout in {nameof(GetBlockBodiesMessage)} with {message.BlockHashes.Count} block hashes"); }
public void Roundtrip() { GetBlockBodiesMessageSerializer serializer = new GetBlockBodiesMessageSerializer(); GetBlockBodiesMessage message = new GetBlockBodiesMessage(Keccak.OfAnEmptySequenceRlp, Keccak.Zero, Keccak.EmptyTreeHash); byte[] bytes = serializer.Serialize(message); byte[] expectedBytes = Bytes.FromHexString("f863a01dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347a00000000000000000000000000000000000000000000000000000000000000000a056e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421"); Assert.True(Bytes.AreEqual(bytes, expectedBytes), "bytes"); GetBlockBodiesMessage deserialized = serializer.Deserialize(bytes); Assert.AreEqual(message.BlockHashes.Count, deserialized.BlockHashes.Count, $"count"); for (int i = 0; i < message.BlockHashes.Count; i++) { Assert.AreEqual(message.BlockHashes[i], deserialized.BlockHashes[i], $"hash {i}"); } SerializerTester.TestZero(serializer, message); }
protected BlockBodiesMessage FulfillBlockBodiesRequest(GetBlockBodiesMessage getBlockBodiesMessage) { IReadOnlyList <Keccak> hashes = getBlockBodiesMessage.BlockHashes; Block[] blocks = new Block[hashes.Count]; ulong sizeEstimate = 0; for (int i = 0; i < hashes.Count; i++) { blocks[i] = SyncServer.Find(hashes[i]); sizeEstimate += MessageSizeEstimator.EstimateSize(blocks[i]); if (sizeEstimate > SoftOutgoingMessageSizeLimit) { break; } } return(new BlockBodiesMessage(blocks)); }
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; } }
private void Handle(GetBlockBodiesMessage getBlockBodies) { V62.Messages.BlockBodiesMessage ethBlockBodiesMessage = FulfillBlockBodiesRequest(getBlockBodies.EthMessage); Send(new BlockBodiesMessage(getBlockBodies.RequestId, ethBlockBodiesMessage)); }
public void To_string() { GetBlockBodiesMessage newBlockMessage = new GetBlockBodiesMessage(); _ = newBlockMessage.ToString(); }