private async Task <TransactionReceipt[][]> SendRequest(GetReceiptsMessage message, CancellationToken token)
{
if (Logger.IsTrace)
{
Logger.Trace("Sending node fata request:");
Logger.Trace($"Hashes count: {message.BlockHashes.Length}");
}
var request = new Request <GetReceiptsMessage, TransactionReceipt[][]>(message);
_receiptsRequests.Add(request, token);
Send(request.Message);
Task <TransactionReceipt[][]> task = request.CompletionSource.Task;
var firstTask = await Task.WhenAny(task, Task.Delay(Timeouts.Eth, token));
if (firstTask.IsCanceled)
{
token.ThrowIfCancellationRequested();
}
if (firstTask == task)
{
return(task.Result);
}
throw new TimeoutException($"{Session} Request timeout in {nameof(GetReceiptsMessage)}");
}
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 override async Task <TransactionReceipt[][]> GetReceipts(Keccak[] blockHashes, CancellationToken token)
{
var msg = new GetReceiptsMessage(blockHashes);
TransactionReceipt[][] transactionReceipts = await SendRequest(msg, token);
return(transactionReceipts);
}
private void Handle(GetReceiptsMessage msg)
{
TransactionReceipt[][] transactionReceipts = SyncServer.GetReceipts(msg.BlockHashes);
Interlocked.Increment(ref _counter);
if (Logger.IsTrace)
{
Logger.Trace($"OUT {_counter:D5} Receipts to {Node:s}");
}
Send(new ReceiptsMessage(transactionReceipts));
}
private void Handle(GetReceiptsMessage msg)
{
Stopwatch stopwatch = Stopwatch.StartNew();
TxReceipt[][] txReceipts = SyncServer.GetReceipts(msg.BlockHashes);
Interlocked.Increment(ref Counter);
Send(new ReceiptsMessage(txReceipts));
stopwatch.Stop();
if (Logger.IsTrace)
{
Logger.Trace($"OUT {Counter:D5} Receipts to {Node:c} in {stopwatch.Elapsed.TotalMilliseconds}ms");
}
}
public override async Task <TxReceipt[][]> GetReceipts(IList <Keccak> blockHashes, CancellationToken token)
{
if (blockHashes.Count == 0)
{
return(Array.Empty <TxReceipt[]>());
}
GetReceiptsMessage msg = new GetReceiptsMessage(blockHashes);
TxReceipt[][] txReceipts = await SendRequest(msg, token);
return(txReceipts);
}
public override async Task <TxReceipt[][]> GetReceipts(Keccak[] blockHashes, CancellationToken token)
{
if (blockHashes.Length == 0)
{
return(new TxReceipt[0][]);
}
var msg = new GetReceiptsMessage(blockHashes);
TxReceipt[][] txReceipts = await SendRequest(msg, token);
return(txReceipts);
}
public override async Task <TxReceipt[][]> GetReceipts(IList <Keccak> blockHashes, CancellationToken token)
{
if (blockHashes.Count == 0)
{
return(Array.Empty <TxReceipt[]>());
}
// Logger.Info($"Sending receipts request ({blockHashes.Count}) to {this}");
var msg = new GetReceiptsMessage(blockHashes);
TxReceipt[][] txReceipts = await SendRequest(msg, token);
// Logger.Info($"Sent receipts request ({blockHashes.Count}) to {this} - received {txReceipts.Length}");
return(txReceipts);
}
private async Task <TxReceipt[][]> SendRequest(GetReceiptsMessage message, CancellationToken token)
{
if (Logger.IsTrace)
{
Logger.Trace("Sending node fata request:");
Logger.Trace($"Hashes count: {message.Hashes.Count}");
}
Request <GetReceiptsMessage, TxReceipt[][]> request
= new Request <GetReceiptsMessage, TxReceipt[][]>(message);
request.StartMeasuringTime();
_receiptsRequests.Add(request, token);
Send(request.Message);
Task <TxReceipt[][]> task = request.CompletionSource.Task;
using CancellationTokenSource delayCancellation = new CancellationTokenSource();
using CancellationTokenSource compositeCancellation
= CancellationTokenSource.CreateLinkedTokenSource(token, delayCancellation.Token);
Task firstTask = await Task.WhenAny(task, Task.Delay(Timeouts.Eth, compositeCancellation.Token));
if (firstTask.IsCanceled)
{
token.ThrowIfCancellationRequested();
}
if (firstTask == task)
{
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.Receipts, bytesPerMillisecond);
return(task.Result);
}
StatsManager.ReportTransferSpeedEvent(Session.Node, TransferSpeedType.Receipts, 0L);
throw new TimeoutException($"{Session} Request timeout in {nameof(GetReceiptsMessage)}");
}
private void Handle(GetReceiptsMessage msg)
{
Metrics.Eth63GetReceiptsReceived++;
if (msg.Hashes.Count > 512)
{
throw new EthSyncException("Incoming receipts request for more than 512 blocks");
}
Stopwatch stopwatch = Stopwatch.StartNew();
TxReceipt[][] txReceipts = SyncServer.GetReceipts(msg.Hashes);
Send(new ReceiptsMessage(txReceipts));
stopwatch.Stop();
if (Logger.IsTrace)
{
Logger.Trace($"OUT {Counter:D5} Receipts to {Node:c} in {stopwatch.Elapsed.TotalMilliseconds}ms");
}
}
private void Handle(GetReceiptsMessage msg)
{
TransactionReceipt[][] transactionReceipts = SyncServer.GetReceipts(msg.BlockHashes);
Send(new ReceiptsMessage(transactionReceipts));
}
