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