Example #1
0
        private void OfflineAnnounceTest()
        {
            var udpTracker = (UdpTracker)TrackerFactory.Create(new Uri("udp://127.0.0.1:57532/announce"));

            udpTracker.RetryDelay = TimeSpan.FromMilliseconds(500);
            var id = new TrackerConnectionID(udpTracker, false, TorrentEvent.Started, new ManualResetEvent(false));

            AnnounceResponseEventArgs p = null;

            udpTracker.AnnounceComplete += delegate(object o, AnnounceResponseEventArgs e)
            {
                p = e;
                id.WaitHandle.Set();
            };
            var pars = new AnnounceParameters
            {
                InfoHash = new InfoHash(new byte[20]),
                PeerId   = ""
            };

            udpTracker.Announce(pars, id);
            Wait(id.WaitHandle);
            Assert.IsNotNull(p, "#1");
            Assert.IsFalse(p.Successful);
        }
Example #2
0
        public void ScrapeTest()
        {
            var t = TrackerFactory.Create(new Uri(Prefix.Substring(0, Prefix.Length - 1)));

            Assert.IsTrue(t.CanScrape, "#1");
            var id = new TrackerConnectionID(t, false, TorrentEvent.Started, new ManualResetEvent(false));

            AnnounceResponseEventArgs p = null;

            t.AnnounceComplete += delegate(object o, AnnounceResponseEventArgs e)
            {
                p = e;
                id.WaitHandle.Set();
            };
            var pars = new AnnounceParameters {
                PeerId = "id", InfoHash = new InfoHash(new byte[20])
            };

            t.Announce(pars, id);
            Wait(id.WaitHandle);
            Assert.IsNotNull(p, "#2");
            Assert.IsTrue(p.Successful, "#3");
            Assert.AreEqual(1, t.Complete, "#1");
            Assert.AreEqual(0, t.Incomplete, "#2");
            Assert.AreEqual(0, t.Downloaded, "#3");
        }
Example #3
0
 public override Task ScrapeAsync(ScrapeParameters parameters, TrackerConnectionID state)
 {
     RaiseBeforeScrape();
     ScrapedAt.Add(DateTime.Now);
     RaiseScrapeComplete(new ScrapeResponseEventArgs(this, state, !FailScrape));
     return(Task.CompletedTask);
 }
Example #4
0
        public void MultipleAnnounce()
        {
            var announceCount = 0;
            var random        = new Random();
            var handle        = new ManualResetEvent(false);

            for (var i = 0; i < 20; i++)
            {
                var infoHash = new InfoHash(new byte[20]);
                random.NextBytes(infoHash.Hash);
                var tier = new TrackerTier(new[] { _uri.ToString() });
                tier.Trackers[0].AnnounceComplete += (sender, args) =>
                {
                    if (++announceCount == 20)
                    {
                        handle.Set();
                    }
                };
                var id = new TrackerConnectionID(tier.Trackers[0], false, TorrentEvent.Started,
                                                 new ManualResetEvent(false));
                var parameters = new AnnounceParameters(0, 0, 0, TorrentEvent.Started,
                                                        infoHash, false, new string('1', 20),
                                                        string.Empty, 1411);
                tier.Trackers[0].Announce(parameters, id);
            }

            Assert.IsTrue(handle.WaitOne(5000, true), "Some of the responses weren't received");
        }
Example #5
0
        public void ScrapeTest()
        {
            var udpTracker = (UdpTracker)TrackerFactory.Create(new Uri(Prefix));

            Assert.IsTrue(udpTracker.CanScrape, "#1");

            var id = new TrackerConnectionID(udpTracker, false, TorrentEvent.Started, new ManualResetEvent(false));

            ScrapeResponseEventArgs p = null;

            udpTracker.ScrapeComplete += delegate(object o, ScrapeResponseEventArgs e)
            {
                p = e;
                id.WaitHandle.Set();
            };
            var pars = new ScrapeParameters(new InfoHash(new byte[20]));

            udpTracker.Scrape(pars, id);
            Wait(id.WaitHandle);
            Assert.IsNotNull(p, "#2");
            Assert.IsTrue(p.Successful, "#3");
            Assert.AreEqual(0, udpTracker.Complete, "#1");
            Assert.AreEqual(0, udpTracker.Incomplete, "#2");
            Assert.AreEqual(0, udpTracker.Downloaded, "#3");
        }
Example #6
0
        private void OfflineScrapeTest()
        {
            var udpTracker = (UdpTracker)TrackerFactory.Create(new Uri("udp://127.0.0.1:57532/announce"));

            udpTracker.RetryDelay = TimeSpan.FromMilliseconds(500);
            var id = new TrackerConnectionID(udpTracker, false, TorrentEvent.Started, new ManualResetEvent(false));

            ScrapeResponseEventArgs p = null;

            udpTracker.ScrapeComplete += (o, e) =>
            {
                if (e.Successful)
                {
                    Console.ReadLine();
                }
                p = e;
                id.WaitHandle.Set();
            };
            var pars = new ScrapeParameters(new InfoHash(new byte[20]));

            udpTracker.Scrape(pars, id);
            Wait(id.WaitHandle);
            Assert.IsNotNull(p, "#1");
            Assert.IsFalse(p.Successful);
        }
Example #7
0
        void OfflineScrapeTest()
        {
            UdpTracker t = (UdpTracker)TrackerFactory.Create(new Uri("udp://127.0.0.1:57532/announce"));

            t.RetryDelay = TimeSpan.FromMilliseconds(500);
            TrackerConnectionID id = new TrackerConnectionID(t, false, TorrentEvent.Started, new ManualResetEvent(false));

            ScrapeResponseEventArgs p = null;

            t.ScrapeComplete += delegate(object o, ScrapeResponseEventArgs e)
            {
                if (e.Successful)
                {
                    Console.ReadLine();
                }
                p = e;
                id.WaitHandle.Set();
            };
            System.Net.BitTorrent.Client.Tracker.ScrapeParameters pars = new ScrapeParameters(new InfoHash(new byte[20]));

            t.Scrape(pars, id);
            Wait(id.WaitHandle);
            Assert.IsNotNull(p, "#1");
            Assert.IsFalse(p.Successful);
        }
Example #8
0
        public void MultipleAnnounce()
        {
            int              announceCount = 0;
            Random           r             = new Random();
            ManualResetEvent handle        = new ManualResetEvent(false);

            for (int i = 0; i < 20; i++)
            {
                InfoHash infoHash = new InfoHash(new byte[20]);
                r.NextBytes(infoHash.Hash);
                TrackerTier tier = new TrackerTier(new string[] { uri.ToString() });
                tier.Trackers[0].AnnounceComplete += delegate {
                    if (++announceCount == 20)
                    {
                        handle.Set();
                    }
                };
                TrackerConnectionID id = new TrackerConnectionID(tier.Trackers[0], false, TorrentEvent.Started, new ManualResetEvent(false));
                System.Net.BitTorrent.Client.Tracker.AnnounceParameters parameters;
                parameters = new System.Net.BitTorrent.Client.Tracker.AnnounceParameters(0, 0, 0, TorrentEvent.Started,
                                                                                         infoHash, false, new string('1', 20), "", 1411);
                tier.Trackers[0].Announce(parameters, id);
            }

            Assert.IsTrue(handle.WaitOne(5000, true), "Some of the responses weren't received");
        }
Example #9
0
        public void MultipleAnnounce()
        {
            var announceCount = 0;
            var random = new Random();
            var handle = new ManualResetEvent(false);

            for (var i = 0; i < 20; i++)
            {
                var infoHash = new InfoHash(new byte[20]);
                random.NextBytes(infoHash.Hash);
                var tier = new TrackerTier(new[] {_uri.ToString()});
                tier.Trackers[0].AnnounceComplete += (sender, args) =>
                                                         {
                                                             if (++announceCount == 20)
                                                                 handle.Set();
                                                         };
                var id = new TrackerConnectionID(tier.Trackers[0], false, TorrentEvent.Started,
                                                 new ManualResetEvent(false));
                var parameters = new OctoTorrent.Client.Tracker.AnnounceParameters(0, 0, 0, TorrentEvent.Started,
                                                                                   infoHash, false, new string('1', 20),
                                                                                   string.Empty, 1411);
                tier.Trackers[0].Announce(parameters, id);
            }

            Assert.IsTrue(handle.WaitOne(5000, true), "Some of the responses weren't received");
        }
        public void ScrapeTest()
        {
            UdpTracker t = (UdpTracker)TrackerFactory.Create(new Uri(prefix));

            Assert.IsTrue(t.CanScrape, "#1");
            TrackerConnectionID id = new TrackerConnectionID(t, false, TorrentEvent.Started, new ManualResetEvent(false));

            ScrapeResponseEventArgs p = null;

            t.ScrapeComplete += delegate(object o, ScrapeResponseEventArgs e)
            {
                p = e;
                id.WaitHandle.Set();
            };
            MonoTorrent.Client.Tracker.ScrapeParameters pars = new ScrapeParameters(new InfoHash(new byte[20]));

            t.Scrape(pars, id);
            Wait(id.WaitHandle);
            Assert.IsNotNull(p, "#2");

            //TODO: search and fix SocketException
            //Assert.IsTrue(p.Successful, "#3");
            Assert.AreEqual(0, t.Complete, "#1");
            Assert.AreEqual(0, t.Incomplete, "#2");
            Assert.AreEqual(0, t.Downloaded, "#3");
        }
Example #11
0
 public override Task AnnounceAsync(AnnounceParameters parameters, TrackerConnectionID state)
 {
     RaiseBeforeAnnounce();
     AnnouncedAt.Add(DateTime.Now);
     RaiseAnnounceComplete(new AnnounceResponseEventArgs(this, state, !FailAnnounce));
     return(Task.CompletedTask);
 }
        public void AddFailedPeer(Peer p)
        {
            TrackerConnectionID       id = new TrackerConnectionID(this, true, TorrentEvent.None, null);
            AnnounceResponseEventArgs e  = new AnnounceResponseEventArgs(this, null, true);

            e.Peers.Add(p);
            e.Successful = false;
            RaiseAnnounceComplete(e);
        }
Example #13
0
        public void AddPeer(Peer p)
        {
            TrackerConnectionID       id = new TrackerConnectionID(this, false, TorrentEvent.None, new ManualResetEvent(false));
            AnnounceResponseEventArgs e  = new AnnounceResponseEventArgs(this, id, true);

            e.Peers.Add(p);
            RaiseAnnounceComplete(e);
            Assert.IsTrue(id.WaitHandle.WaitOne(1000, true), "#1 Tracker never raised the AnnounceComplete event");
        }
Example #14
0
        public void Setup()
        {
            keys.Clear();
            tracker            = (UdpTracker)TrackerFactory.Create(new Uri("udp://127.0.0.1:6767/announce/"));
            tracker.RetryDelay = TimeSpan.FromMilliseconds(50);
            id = new TrackerConnectionID(tracker, false, TorrentEvent.Started, new ManualResetEvent(false));

            listener.IgnoreAnnounces = false;
            listener.IgnoreConnects  = false;
            listener.IgnoreErrors    = false;
            listener.IgnoreScrapes   = false;
        }
Example #15
0
        public void AddFailedPeer(Peer p)
        {
            TrackerConnectionID       id = new TrackerConnectionID(this, true, TorrentEvent.None, new ManualResetEvent(false));
            AnnounceResponseEventArgs e  = new AnnounceResponseEventArgs(this, id, false);

            e.Peers.Add(p);
            RaiseAnnounceComplete(e);
#if NETSTANDARD1_5
            Assert.True(id.WaitHandle.WaitOne(1000), "#2 Tracker never raised the AnnounceComplete event");
#else
            Assert.True(id.WaitHandle.WaitOne(1000, true), "#2 Tracker never raised the AnnounceComplete event");
#endif
        }
Example #16
0
        public void KeyTest()
        {
            MonoTorrent.Client.Tracker.AnnounceParameters pars = new AnnounceParameters();
            pars.PeerId   = "id";
            pars.InfoHash = new InfoHash(new byte[20]);

            Tracker.Tracker     t  = TrackerFactory.Create(new Uri(prefix + "?key=value"));
            TrackerConnectionID id = new TrackerConnectionID(t, false, TorrentEvent.Started, new ManualResetEvent(false));

            t.AnnounceComplete += delegate { id.WaitHandle.Set(); };
            t.Announce(pars, id);
            Wait(id.WaitHandle);
            Assert.AreEqual("value", keys[0], "#1");
        }
Example #17
0
        private WaitHandle Announce(Tracker.Tracker tracker, TorrentEvent clientEvent, bool trySubsequent,
                                    ManualResetEvent waitHandle)
        {
            ClientEngine engine = _manager.Engine;

            // If the engine is null, we have been unregistered
            if (engine == null)
            {
                waitHandle.Set();
                return(waitHandle);
            }

            UpdateSucceeded = true;
            LastUpdated     = DateTime.Now;

            EncryptionTypes e = engine.Settings.AllowedEncryption;
            var             requireEncryption  = !Toolbox.HasEncryption(e, EncryptionTypes.PlainText);
            var             supportsEncryption = Toolbox.HasEncryption(e, EncryptionTypes.RC4Full) ||
                                                 Toolbox.HasEncryption(e, EncryptionTypes.RC4Header);

            requireEncryption  = requireEncryption && ClientEngine.SupportsEncryption;
            supportsEncryption = supportsEncryption && ClientEngine.SupportsEncryption;

            IPEndPoint reportedAddress = engine.Settings.ReportedAddress;
            var        ip   = reportedAddress?.Address.ToString();
            int        port = reportedAddress?.Port ?? engine.Listener.Endpoint.Port;

            // FIXME: In metadata mode we need to pretend we need to download data otherwise
            // tracker optimisations might result in no peers being sent back.
            long bytesLeft = 1000;

            if (_manager.HasMetadata)
            {
                bytesLeft = (long)((1 - _manager.Bitfield.PercentComplete / 100.0) * _manager.Torrent.Size);
            }
            var p = new AnnounceParameters(_manager.Monitor.DataBytesDownloaded,
                                           _manager.Monitor.DataBytesUploaded,
                                           bytesLeft,
                                           clientEvent, _infoHash, requireEncryption, _manager.Engine.PeerId,
                                           ip, port)
            {
                SupportsEncryption = supportsEncryption
            };
            var id = new TrackerConnectionID(tracker, trySubsequent, clientEvent, waitHandle);

            tracker.Announce(p, id);
            return(waitHandle);
        }
Example #18
0
        private WaitHandle Scrape(Tracker.Tracker tracker, bool trySubsequent)
        {
            if (tracker == null)
            {
                throw new ArgumentNullException(nameof(tracker));
            }

            if (!tracker.CanScrape)
            {
                throw new TorrentException("This tracker does not support scraping");
            }

            var id = new TrackerConnectionID(tracker, trySubsequent, TorrentEvent.None, new ManualResetEvent(false));

            tracker.Scrape(new ScrapeParameters(_infoHash), id);
            return(id.WaitHandle);
        }
Example #19
0
        public void AnnounceTest()
        {
            HTTPTracker         t  = (HTTPTracker)TrackerFactory.Create(new Uri(prefix));
            TrackerConnectionID id = new TrackerConnectionID(t, false, TorrentEvent.Started, new ManualResetEvent(false));

            AnnounceResponseEventArgs p = null;

            t.AnnounceComplete += delegate(object o, AnnounceResponseEventArgs e) {
                p = e;
                id.WaitHandle.Set();
            };
            MonoTorrent.Client.Tracker.AnnounceParameters pars = new AnnounceParameters();
            pars.PeerId   = "id";
            pars.InfoHash = new InfoHash(new byte[20]);

            t.Announce(pars, id);
            Wait(id.WaitHandle);
            Assert.IsNotNull(p, "#1");
            Assert.IsTrue(p.Successful);
            Assert.AreEqual(keys[0].ToLowerInvariant(), t.Key.ToLowerInvariant(), "#2");
        }
Example #20
0
        void OfflineAnnounceTest()
        {
            UdpTracker t = (UdpTracker)TrackerFactory.Create(new Uri("udp://127.0.0.1:57532/announce"));

            t.RetryDelay = TimeSpan.FromMilliseconds(500);
            TrackerConnectionID id = new TrackerConnectionID(t, false, TorrentEvent.Started, new ManualResetEvent(false));

            AnnounceResponseEventArgs p = null;

            t.AnnounceComplete += delegate(object o, AnnounceResponseEventArgs e) {
                p = e;
                id.WaitHandle.Set();
            };
            System.Net.BitTorrent.Client.Tracker.AnnounceParameters pars = new AnnounceParameters();
            pars.InfoHash = new InfoHash(new byte[20]);
            pars.PeerId   = "";

            t.Announce(pars, id);
            Wait(id.WaitHandle);
            Assert.NotNull(p);
            Assert.False(p.Successful);
        }
Example #21
0
        public void AnnounceTest()
        {
            UdpTracker          t  = (UdpTracker)TrackerFactory.Create(new Uri(prefix));
            TrackerConnectionID id = new TrackerConnectionID(t, false, TorrentEvent.Started, new ManualResetEvent(false));

            AnnounceResponseEventArgs p = null;

            t.AnnounceComplete += delegate(object o, AnnounceResponseEventArgs e)
            {
                p = e;
                id.WaitHandle.Set();
            };
            System.Net.BitTorrent.Client.Tracker.AnnounceParameters pars = new AnnounceParameters();
            pars.InfoHash = new InfoHash(new byte[20]);
            pars.PeerId   = "";

            t.Announce(pars, id);
            Wait(id.WaitHandle);
            Assert.NotNull(p);
            Assert.True(p.Successful);
            //Assert.Equal(keys[0], t.Key, "#2");
        }
Example #22
0
        public void AnnounceTest()
        {
            var t = (HTTPTracker) TrackerFactory.Create(new Uri(Prefix));
            var id = new TrackerConnectionID(t, false, TorrentEvent.Started, new ManualResetEvent(false));

            AnnounceResponseEventArgs p = null;
            t.AnnounceComplete += (o, e) =>
                                      {
                                          p = e;
                                          id.WaitHandle.Set();
                                      };
            var pars = new AnnounceParameters
                           {
                               PeerId = "id",
                               InfoHash = new InfoHash(new byte[20])
                           };

            t.Announce(pars, id);
            Wait(id.WaitHandle);
            Assert.IsNotNull(p, "#1");
            Assert.IsTrue(p.Successful);
            Assert.AreEqual(_keys[0], t.Key, "#2");
        }
        public void ScrapeTest()
        {
            Tracker.Tracker t = TrackerFactory.Create(new Uri(prefix.Substring(0, prefix.Length - 1)));
            Assert.True(t.CanScrape, "#1");
            TrackerConnectionID id = new TrackerConnectionID(t, false, TorrentEvent.Started, new ManualResetEvent(false));

            AnnounceResponseEventArgs p = null;

            t.AnnounceComplete += delegate(object o, AnnounceResponseEventArgs e) {
                p = e;
                id.WaitHandle.Set();
            };
            System.Net.BitTorrent.Client.Tracker.AnnounceParameters pars = new AnnounceParameters();
            pars.PeerId   = "id";
            pars.InfoHash = new InfoHash(new byte[20]);

            t.Announce(pars, id);
            Wait(id.WaitHandle);
            Assert.NotNull(p);
            Assert.True(p.Successful, "#3");
            Assert.Equal(1, t.Complete);
            Assert.Equal(0, t.Incomplete);
            Assert.Equal(0, t.Downloaded);
        }
Example #24
0
        public void AnnounceTest()
        {
            var udpTracker = (UdpTracker)TrackerFactory.Create(new Uri(Prefix));
            var id         = new TrackerConnectionID(udpTracker, false, TorrentEvent.Started, new ManualResetEvent(false));

            AnnounceResponseEventArgs p = null;

            udpTracker.AnnounceComplete += delegate(object o, AnnounceResponseEventArgs e)
            {
                p = e;
                id.WaitHandle.Set();
            };
            var pars = new AnnounceParameters
            {
                InfoHash = new InfoHash(new byte[20]),
                PeerId   = ""
            };

            udpTracker.Announce(pars, id);
            Wait(id.WaitHandle);
            Assert.IsNotNull(p, "#1");
            Assert.IsTrue(p.Successful);
            //Assert.AreEqual(keys[0], t.Key, "#2");
        }
Example #25
0
        public void AnnounceTest()
        {
            var t  = (HTTPTracker)TrackerFactory.Create(new Uri(Prefix));
            var id = new TrackerConnectionID(t, false, TorrentEvent.Started, new ManualResetEvent(false));

            AnnounceResponseEventArgs p = null;

            t.AnnounceComplete += (o, e) =>
            {
                p = e;
                id.WaitHandle.Set();
            };
            var pars = new AnnounceParameters
            {
                PeerId   = "id",
                InfoHash = new InfoHash(new byte[20])
            };

            t.Announce(pars, id);
            Wait(id.WaitHandle);
            Assert.IsNotNull(p, "#1");
            Assert.IsTrue(p.Successful);
            Assert.AreEqual(_keys[0], t.Key, "#2");
        }
Example #26
0
        public void KeyTest()
        {
            var pars = new AnnounceParameters
                           {
                               PeerId = "id",
                               InfoHash = new InfoHash(new byte[20])
                           };

            var t = TrackerFactory.Create(new Uri(Prefix + "?key=value"));
            var id = new TrackerConnectionID(t, false, TorrentEvent.Started, new ManualResetEvent(false));
            t.AnnounceComplete += delegate { id.WaitHandle.Set(); };
            t.Announce(pars, id);
            Wait(id.WaitHandle);
            Assert.AreEqual("value", _keys[0], "#1");
        }
 public override Task ScrapeAsync(ScrapeParameters parameters, TrackerConnectionID state)
 {
     RaiseScrapeComplete(new ScrapeResponseEventArgs(this, state, true));
     return(Task.CompletedTask);
 }
Example #28
0
        public void ScrapeTest()
        {
            var udpTracker = (UdpTracker) TrackerFactory.Create(new Uri(Prefix));
            Assert.IsTrue(udpTracker.CanScrape, "#1");

            var id = new TrackerConnectionID(udpTracker, false, TorrentEvent.Started, new ManualResetEvent(false));

            ScrapeResponseEventArgs p = null;
            udpTracker.ScrapeComplete += delegate(object o, ScrapeResponseEventArgs e)
                                             {
                                                 p = e;
                                                 id.WaitHandle.Set();
                                             };
            var pars = new ScrapeParameters(new InfoHash(new byte[20]));

            udpTracker.Scrape(pars, id);
            Wait(id.WaitHandle);
            Assert.IsNotNull(p, "#2");
            Assert.IsTrue(p.Successful, "#3");
            Assert.AreEqual(0, udpTracker.Complete, "#1");
            Assert.AreEqual(0, udpTracker.Incomplete, "#2");
            Assert.AreEqual(0, udpTracker.Downloaded, "#3");
        }
Example #29
0
        public void AnnounceTest()
        {
            var udpTracker = (UdpTracker) TrackerFactory.Create(new Uri(Prefix));
            var id = new TrackerConnectionID(udpTracker, false, TorrentEvent.Started, new ManualResetEvent(false));

            AnnounceResponseEventArgs p = null;
            udpTracker.AnnounceComplete += delegate(object o, AnnounceResponseEventArgs e)
                                               {
                                                   p = e;
                                                   id.WaitHandle.Set();
                                               };
            var pars = new AnnounceParameters
                           {
                               InfoHash = new InfoHash(new byte[20]),
                               PeerId = ""
                           };

            udpTracker.Announce(pars, id);
            Wait(id.WaitHandle);
            Assert.IsNotNull(p, "#1");
            Assert.IsTrue(p.Successful);
            //Assert.AreEqual(keys[0], t.Key, "#2");
        }
Example #30
0
        private void OfflineScrapeTest()
        {
            var udpTracker = (UdpTracker) TrackerFactory.Create(new Uri("udp://127.0.0.1:57532/announce"));
            udpTracker.RetryDelay = TimeSpan.FromMilliseconds(500);
            var id = new TrackerConnectionID(udpTracker, false, TorrentEvent.Started, new ManualResetEvent(false));

            ScrapeResponseEventArgs p = null;
            udpTracker.ScrapeComplete += (o, e) =>
                                             {
                                                 if (e.Successful)
                                                     Console.ReadLine();
                                                 p = e;
                                                 id.WaitHandle.Set();
                                             };
            var pars = new ScrapeParameters(new InfoHash(new byte[20]));

            udpTracker.Scrape(pars, id);
            Wait(id.WaitHandle);
            Assert.IsNotNull(p, "#1");
            Assert.IsFalse(p.Successful);
        }
Example #31
0
        private void OfflineAnnounceTest()
        {
            var udpTracker = (UdpTracker) TrackerFactory.Create(new Uri("udp://127.0.0.1:57532/announce"));
            udpTracker.RetryDelay = TimeSpan.FromMilliseconds(500);
            var id = new TrackerConnectionID(udpTracker, false, TorrentEvent.Started, new ManualResetEvent(false));

            AnnounceResponseEventArgs p = null;
            udpTracker.AnnounceComplete += delegate(object o, AnnounceResponseEventArgs e)
                                      {
                                          p = e;
                                          id.WaitHandle.Set();
                                      };
            var pars = new AnnounceParameters
                           {
                               InfoHash = new InfoHash(new byte[20]),
                               PeerId = ""
                           };

            udpTracker.Announce(pars, id);
            Wait(id.WaitHandle);
            Assert.IsNotNull(p, "#1");
            Assert.IsFalse(p.Successful);
        }
Example #32
0
        public void ScrapeTest()
        {
            var t = TrackerFactory.Create(new Uri(Prefix.Substring(0, Prefix.Length - 1)));
            Assert.IsTrue(t.CanScrape, "#1");
            var id = new TrackerConnectionID(t, false, TorrentEvent.Started, new ManualResetEvent(false));

            AnnounceResponseEventArgs p = null;
            t.AnnounceComplete += delegate(object o, AnnounceResponseEventArgs e)
                                      {
                                          p = e;
                                          id.WaitHandle.Set();
                                      };
            var pars = new AnnounceParameters {PeerId = "id", InfoHash = new InfoHash(new byte[20])};

            t.Announce(pars, id);
            Wait(id.WaitHandle);
            Assert.IsNotNull(p, "#2");
            Assert.IsTrue(p.Successful, "#3");
            Assert.AreEqual(1, t.Complete, "#1");
            Assert.AreEqual(0, t.Incomplete, "#2");
            Assert.AreEqual(0, t.Downloaded, "#3");
        }
 public void AddFailedPeer(Peer p)
 {
     var id = new TrackerConnectionID(this, true, TorrentEvent.None, null);
     var e = new AnnounceResponseEventArgs(this, null, true);
     e.Peers.Add(p);
     e.Successful = false;
     RaiseAnnounceComplete(e);
 }
 public override Task AnnounceAsync(AnnounceParameters parameters, TrackerConnectionID state)
 {
     return(Task.CompletedTask);
 }
 public override Task AnnounceAsync(AnnounceParameters parameters, TrackerConnectionID state)
 {
     RaiseAnnounceComplete(new AnnounceResponseEventArgs(this, state, true));
     return(Task.CompletedTask);
 }
 public override Task ScrapeAsync(ScrapeParameters parameters, TrackerConnectionID state)
 {
     return(Task.CompletedTask);
 }