public void Setup()
{
keys.Clear();
listener.IncompleteAnnounce = listener.IncompleteScrape = false;
server = new TrackerServer(trackerId)
{
AllowUnregisteredTorrents = true
};
server.RegisterListener(listener);
client = new HttpClient();
trackerConnection = new HttpTrackerConnection(AnnounceUrl, client);
tracker = new Tracker(trackerConnection);
var infoHashBytes = new[] { ' ', '%', '&', '?', '&', '&', '?', '5', '1', '=' }
.Select(t => (byte)t);
infoHash = new InfoHash(infoHashBytes.Concat(infoHashBytes).ToArray());
announceParams = new MonoTorrent.Trackers.AnnounceRequest(infoHash)
.WithPort(5555)
.WithPeerId(peerId.Span.ToArray());
scrapeParams = new MonoTorrent.Trackers.ScrapeRequest(infoHash);
}
public async ReusableTask <AnnounceResponse> AnnounceAsync(AnnounceRequest parameters, CancellationToken token)
{
try {
StatusOverride = TrackerState.Connecting;
var response = LastAnnounceResponse = await Connection.AnnounceAsync(parameters, token);
LastResponse = response;
return(response);
} finally {
StatusOverride = null;
LastAnnounced.Restart();
}
}
public async ReusableTask AnnounceAsync(ITracker tracker, CancellationToken token)
{
Check.Tracker(tracker);
// If the user initiates an Announce we need to go to the correct thread to process it.
await ClientEngine.MainLoop;
try {
var trackerTier = Tiers.First(t => t.Trackers.Contains(tracker));
AnnounceRequest args = RequestFactory.CreateAnnounce(TorrentEvent.None);
await AnnounceTrackerAsync(trackerTier, args, tracker, token);
} catch {
}
}
public async Task MultipleAnnounce()
{
Random r = new Random();
for (int i = 0; i < 20; i++)
{
var buffer = new byte[20];
r.NextBytes(buffer);
var infoHash = new InfoHash(buffer);
TrackerTier tier = new TrackerTier(Factories.Default, new[] { uri.ToString() });
var parameters = new MonoTorrent.Trackers.AnnounceRequest(0, 0, 0, TorrentEvent.Started,
infoHash, false, new BEncodedString(new string ('1', 20)).Span.ToArray(), "", 1411, false);
Assert.IsTrue(tier.ActiveTracker.CanScrape);
await tier.Trackers[0].AnnounceAsync(parameters, CancellationToken.None);
}
}
public async Task AnnounceTest()
{
announceparams = announceparams
.WithBytesDownloaded(123)
.WithBytesLeft(456)
.WithBytesUploaded(789);
var announceArgsTask = new TaskCompletionSource <AnnounceEventArgs> ();
server.PeerAnnounced += (o, e) => announceArgsTask.TrySetResult(e);
await tracker.AnnounceAsync(announceparams, CancellationToken.None);
await announceArgsTask.Task;
var args = announceArgsTask.Task.Result;
Assert.AreEqual((BEncodedString)PeerId, args.Peer.PeerId, "#1");
Assert.AreEqual(123, args.Peer.Downloaded);
Assert.AreEqual(456, args.Peer.Remaining);
Assert.AreEqual(789, args.Peer.Uploaded);
}
public void Setup()
{
keys = new List <BEncodedString> ();
server = new MonoTorrent.TrackerServer.TrackerServer();
server.AllowUnregisteredTorrents = true;
server.RegisterListener(listener);
peerEndpoints = new List <IPEndPoint> {
new IPEndPoint(IPAddress.Parse("123.123.123.123"), 12312),
new IPEndPoint(IPAddress.Parse("254.254.254.254"), 3522),
new IPEndPoint(IPAddress.Parse("1.1.1.1"), 123),
new IPEndPoint(IPAddress.Parse("1.2.3.4"), 65000),
};
trackerConnection = new UdpTrackerConnection(new Uri($"udp://127.0.0.1:{listener.LocalEndPoint.Port}/announce/"));
tracker = new Tracker(trackerConnection);
announceparams = announceparams.WithPort(listener.LocalEndPoint.Port);
listener.IgnoreAnnounces = false;
listener.IgnoreConnects = false;
listener.IgnoreErrors = false;
listener.IgnoreScrapes = false;
listener.IncompleteAnnounce = listener.IncompleteConnect = listener.IncompleteScrape = false;
}
async ReusableTask AnnounceTrackerAsync(TrackerTier tier, AnnounceRequest args, ITracker tracker, CancellationToken token)
{
using (await AnnounceLimiter.EnterAsync())
await tier.AnnounceAsync(args, tracker, token);
}
