public void EnqueueMessage()
{
var priorityQueue = new PriorityQueue <int, PeerMessageReceivedArgs>(2);
var incomingJobs = new BlockingCollection <KeyValuePair <int, PeerMessageReceivedArgs> >(priorityQueue);
PeerMessageReceivedArgs higherPriorityMsg = new PeerMessageReceivedArgs();
PeerMessageReceivedArgs msg = new PeerMessageReceivedArgs();
var kvp_p_1 = new KeyValuePair <int, PeerMessageReceivedArgs>(0, higherPriorityMsg);
var kvp_p_2 = new KeyValuePair <int, PeerMessageReceivedArgs>(1, msg);
// Event though we add kvp_p_2 first, kvp_p_1 should be the first to be dequeued.
incomingJobs.Add(kvp_p_2);
incomingJobs.Add(kvp_p_1);
incomingJobs.TryTake(out var out01);
Assert.NotNull(out01);
Assert.Equal(out01.Value, kvp_p_1.Value);
incomingJobs.TryTake(out var out02);
Assert.NotNull(out02);
Assert.Equal(out02.Value, kvp_p_2.Value);
}
private async Task HandleHeaderRequest(PeerMessageReceivedArgs args)
{
try
{
var hashReq = BlockHeaderRequest.Parser.ParseFrom(args.Message.Payload);
var blockHeaderList = await _nodeService.GetBlockHeaderList((ulong)hashReq.Height, hashReq.Count);
var req = NetRequestFactory.CreateMessage(AElfProtocolMsgType.Headers, blockHeaderList.ToByteArray());
if (args.Message.HasId)
{
req.Id = args.Message.Id;
}
args.Peer.EnqueueOutgoing(req);
_logger?.Debug($"Send {blockHeaderList.Headers.Count} block headers start " +
$"from {blockHeaderList.Headers.FirstOrDefault()?.GetHash().DumpHex()}, to node {args.Peer}.");
}
catch (Exception e)
{
_logger?.Error(e, "Error while during HandleBlockRequest.");
}
}
public async void New_AfterConnecting_FiresMessageReceivedWhenDataAvailable()
{
var versionMessage = new MsgVersion()
{
ProtocolVersion = 1
};
var versionMessageHeader = new MessageHeader(_currencyNet, MsgCommand.Version, versionMessage.Encode());
// Write the header + message to the READ stream, then reset the stream position.
var writer = new BinaryWriter(_readStream);
versionMessageHeader.Encode(writer);
versionMessage.Encode(writer);
_readStream.Position = 0;
var subject = new Peer(_networkClientMock.Object, _currencyNet);
await subject.ConnectAsync();
// Closure to capture the data passed to the raised event
PeerMessageReceivedArgs eventArgs = null;
var resetEvent = new ManualResetEvent(false);
subject.MessageReceived += (sender, e) =>
{
eventArgs = e;
resetEvent.Set();
};
resetEvent.WaitOne(TimeSpan.FromSeconds(1));
Assert.True(eventArgs != null);
Assert.Equal(versionMessageHeader.Checksum, (IEnumerable <byte>)eventArgs.Header.Checksum);
}
private async Task StartProcessingIncoming()
{
while (true)
{
try
{
PeerMessageReceivedArgs msg = _incomingJobs.Take();
await ProcessPeerMessage(msg);
}
catch (Exception e)
{
_logger?.Error(e, "Error while processing incoming messages");
}
}
}
private async Task ProcessPeerMessage(PeerMessageReceivedArgs args)
{
if (args?.Peer == null)
{
_logger.Warn("Peer is invalid.");
return;
}
if (args.Message?.Payload == null)
{
_logger?.Warn($"Message from {args.Peer}, message/payload is null.");
return;
}
AElfProtocolMsgType msgType = (AElfProtocolMsgType)args.Message.Type;
switch (msgType)
{
case AElfProtocolMsgType.Announcement:
HandleAnnouncement(args.Message, args.Peer);
break;
case AElfProtocolMsgType.Block:
MessageHub.Instance.Publish(new BlockReceived(args.Block));
break;
case AElfProtocolMsgType.NewTransaction:
HandleNewTransaction(args.Message);
break;
case AElfProtocolMsgType.Headers:
HandleHeaders(args.Message);
break;
case AElfProtocolMsgType.RequestBlock:
await HandleBlockRequestJob(args);
break;
case AElfProtocolMsgType.HeaderRequest:
await HandleHeaderRequest(args);
break;
}
}
public void TakeTest_EnqueueMessage()
{
BlockingPriorityQueue <PeerMessageReceivedArgs> prioQ = new BlockingPriorityQueue <PeerMessageReceivedArgs>();
PeerMessageReceivedArgs higherPriorityMsg = new PeerMessageReceivedArgs();
PeerMessageReceivedArgs msg = new PeerMessageReceivedArgs();
prioQ.Enqueue(msg, 1);
prioQ.Enqueue(higherPriorityMsg, 0);
var out01 = prioQ.Take();
Assert.NotNull(out01);
Assert.Equal(out01, higherPriorityMsg);
var out02 = prioQ.Take();
Assert.NotNull(out02);
Assert.Equal(out02, msg);
}
private async Task HandleBlockRequestJob(PeerMessageReceivedArgs args)
{
try
{
var breq = BlockRequest.Parser.ParseFrom(args.Message.Payload);
Block b;
if (breq.Id != null && breq.Id.Length > 0)
{
b = await _nodeService.GetBlockFromHash(breq.Id.ToByteArray());
}
else
{
b = await _nodeService.GetBlockAtHeight(breq.Height);
}
if (b == null)
{
_logger?.Warn($"Block not found {breq.Id?.ToByteArray().ToHex()}");
return;
}
Message req = NetRequestFactory.CreateMessage(AElfProtocolMsgType.Block, b.ToByteArray());
if (args.Message.HasId)
{
req.Id = args.Message.Id;
}
// Send response
args.Peer.EnqueueOutgoing(req, (_) =>
{
_logger?.Debug($"Block sent {{ hash: {b.BlockHashToHex}, to: {args.Peer} }}");
});
}
catch (Exception e)
{
_logger?.Error(e, "Error while during HandleBlockRequest.");
}
}
public NetMessageReceivedEventArgs(Message message, PeerMessageReceivedArgs peerMessage)
{
Message = message;
PeerMessage = peerMessage;
}
