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