Esempio n. 1
0
 public void Handle(BitfieldChanged data)
 {
     context.Queue.Add(() =>
     {
         context.Bitfields.Handle(data);
     });
 }
Esempio n. 2
0
        public void ShouldTriggerBlockReserved()
        {
            BitfieldChanged bitfieldChanged = new BitfieldChanged
            {
                Peer     = PeerHash.Random(),
                Bitfield = Bitfield.Sequence(false, true)
            };

            using (OmnibusFixture fixture = new OmnibusFixture())
                using (OmnibusSession session = fixture.Start())
                {
                    Trigger trigger = Trigger.Bind(ref session.Hooks.OnBlockReserved, data =>
                    {
                        data.Hash.Should().Be(session.Hash);
                        data.Peer.Should().Be(bitfieldChanged.Peer);
                        data.Block.Should().NotBeNull();
                        data.Block.Piece.Index.Should().Be(1);
                        data.Block.Offset.Should().Be(0);
                        data.Block.Size.Should().Be(3616);
                    });

                    session.Service.Start();
                    session.Service.HandleMetafileVerified(session.Metainfo);
                    session.Service.HandleDataVerified(session.Metainfo.Pieces.Length);

                    session.Service.Handle(bitfieldChanged);

                    session.Service.Schedule(OmnibusStrategy.RarestFirst, bitfieldChanged.Peer, 1);
                    session.Pipeline.Process();

                    trigger.Wait().Should().BeTrue();
                }
        }
        public void Handle(BitfieldChanged data)
        {
            if (data.Bitfield != null)
            {
                byPeer[data.Peer] = data.Bitfield;
                ranking.Add(data.Bitfield);
            }

            if (data.Affected != null)
            {
                ranking.Add(data.Affected);
            }
        }
Esempio n. 4
0
        public void ShouldTriggerBlockReservedSequentialForNotCompletedPieces()
        {
            BitfieldChanged bitfieldChangedA = new BitfieldChanged
            {
                Peer     = PeerHash.Random(),
                Bitfield = Bitfield.Sequence(true, true)
            };

            BitfieldChanged bitfieldChangedB = new BitfieldChanged
            {
                Peer     = PeerHash.Random(),
                Bitfield = Bitfield.Sequence(true, false)
            };

            using (OmnibusFixture fixture = new OmnibusFixture())
                using (OmnibusSession session = fixture.Start())
                {
                    DataVerified verified = new DataVerified
                    {
                        Hash     = session.Hash,
                        Bitfield = Bitfield.Sequence(true, false)
                    };

                    Trigger trigger = Trigger.Bind(ref session.Hooks.OnBlockReserved, data =>
                    {
                        data.Block.Should().NotBeNull();
                        data.Block.Piece.Index.Should().Be(1);
                    });

                    session.Service.Start();
                    session.Service.HandleMetafileVerified(session.Metainfo);
                    session.Service.Handle(verified);

                    session.Service.Handle(bitfieldChangedA);
                    session.Service.Handle(bitfieldChangedB);
                    session.Pipeline.Process();

                    session.Service.Schedule(OmnibusStrategy.Sequential, bitfieldChangedA.Peer, 1);
                    session.Pipeline.Process();

                    trigger.Wait().Should().BeTrue();
                }
        }
Esempio n. 5
0
 private void OnPeerBitfieldChanged(BitfieldChanged data)
 {
     Notifications.Enqueue(new BitfieldChangedNotification(data.Peer, data.Bitfield));
     DataMap?.Handle(data);
 }