/// <summary>
/// Emit a ping and wait the pong.
/// </summary>
/// <param name="cancellation"></param>
/// <param name="peer"></param>
/// <returns>Latency.</returns>
public async Task <TimeSpan> PingPongAsync(INetworkPeer peer, CancellationToken cancellation = default(CancellationToken))
{
using (var listener = new NetworkPeerListener(peer))
{
var ping = new PingPayload()
{
Nonce = RandomUtils.GetUInt64()
};
DateTimeOffset before = DateTimeOffset.UtcNow;
await peer.SendMessageAsync(ping, cancellation);
while ((await listener.ReceivePayloadAsync <PongPayload>(cancellation).ConfigureAwait(false)).Nonce != ping.Nonce)
{
}
DateTimeOffset after = DateTimeOffset.UtcNow;
return(after - before);
}
}
/// <summary>
/// Emit a ping and wait the pong.
/// </summary>
/// <param name="cancellation"></param>
/// <param name="peer"></param>
/// <returns>Latency.</returns>
public TimeSpan PingPong(NetworkPeer peer, CancellationToken cancellation = default(CancellationToken))
{
using (NetworkPeerListener listener = peer.CreateListener().OfType <PongPayload>())
{
var ping = new PingPayload()
{
Nonce = RandomUtils.GetUInt64()
};
DateTimeOffset before = DateTimeOffset.UtcNow;
peer.SendMessageVoidAsync(ping);
while (listener.ReceivePayload <PongPayload>(cancellation).Nonce != ping.Nonce)
{
}
DateTimeOffset after = DateTimeOffset.UtcNow;
return(after - before);
}
}
public IEnumerable <ChainedHeader> GetHeadersFromFork(INetworkPeer peer, ChainedHeader currentTip, uint256 hashStop = null, CancellationToken cancellationToken = default(CancellationToken))
{
this.AssertStateAsync(peer, NetworkPeerState.HandShaked, cancellationToken).GetAwaiter().GetResult();
using (var listener = new NetworkPeerListener(peer))
{
int acceptMaxReorgDepth = 0;
while (true)
{
// Get before last so, at the end, we should only receive 1 header equals to this one (so we will not have race problems with concurrent GetChains).
BlockLocator awaited = currentTip.Previous == null?currentTip.GetLocator() : currentTip.Previous.GetLocator();
peer.SendMessageAsync(new GetHeadersPayload()
{
BlockLocator = awaited,
HashStop = hashStop
}, cancellationToken).GetAwaiter().GetResult();
while (true)
{
bool isOurs = false;
HeadersPayload headers = null;
using (CancellationTokenSource headersCancel = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken))
{
headersCancel.CancelAfter(TimeSpan.FromMinutes(1.0));
try
{
headers = listener.ReceivePayloadAsync <HeadersPayload>(headersCancel.Token).GetAwaiter().GetResult();
}
catch (OperationCanceledException)
{
acceptMaxReorgDepth += 6;
if (cancellationToken.IsCancellationRequested)
{
throw;
}
// Send a new GetHeaders.
break;
}
}
// In the special case where the remote node is at height 0 as well as us, then the headers count will be 0.
if ((headers.Headers.Count == 0) && (peer.PeerVersion.StartHeight == 0) && (currentTip.HashBlock == peer.Network.GenesisHash))
{
yield break;
}
if ((headers.Headers.Count == 1) && (headers.Headers[0].GetHash() == currentTip.HashBlock))
{
yield break;
}
foreach (BlockHeader header in headers.Headers)
{
uint256 hash = header.GetHash();
if (hash == currentTip.HashBlock)
{
continue;
}
// The previous headers request timeout, this can arrive in case of big reorg.
if (header.HashPrevBlock != currentTip.HashBlock)
{
int reorgDepth = 0;
ChainedHeader tempCurrentTip = currentTip;
while (reorgDepth != acceptMaxReorgDepth && tempCurrentTip != null && header.HashPrevBlock != tempCurrentTip.HashBlock)
{
reorgDepth++;
tempCurrentTip = tempCurrentTip.Previous;
}
if (reorgDepth != acceptMaxReorgDepth && tempCurrentTip != null)
{
currentTip = tempCurrentTip;
}
}
if (header.HashPrevBlock == currentTip.HashBlock)
{
isOurs = true;
currentTip = new ChainedHeader(header, hash, currentTip);
yield return(currentTip);
if (currentTip.HashBlock == hashStop)
{
yield break;
}
}
else
{
break; // Not our headers, continue receive.
}
}
if (isOurs)
{
break; //Go ask for next header.
}
}
}
}
}
