public async Task Scrape ()
{
// make sure it's a unique infohash as the listener isn't re-created for every test.
infoHash = new InfoHash (Enumerable.Repeat ((byte) 1, 20).ToArray ());
var trackable = new InfoHashTrackable ("Test", infoHash);
server.Add (trackable);
scrapeParams = new ScrapeParameters (infoHash);
await tracker.ScrapeAsync (scrapeParams);
Assert.AreEqual (0, tracker.Complete, "#1");
Assert.AreEqual (0, tracker.Incomplete, "#2");
Assert.AreEqual (0, tracker.Downloaded, "#3");
await tracker.AnnounceAsync (new AnnounceParameters (0, 0, 100, TorrentEvent.Started, infoHash, false, "peer1", null, 1, false));
await tracker.ScrapeAsync (scrapeParams);
Assert.AreEqual (0, tracker.Complete, "#4");
Assert.AreEqual (1, tracker.Incomplete, "#5");
Assert.AreEqual (0, tracker.Downloaded, "#6");
await tracker.AnnounceAsync (new AnnounceParameters (0, 0, 0, TorrentEvent.Started, infoHash, false, "peer2", null, 2, false));
await tracker.ScrapeAsync (scrapeParams);
Assert.AreEqual (1, tracker.Complete, "#7");
Assert.AreEqual (1, tracker.Incomplete, "#8");
Assert.AreEqual (0, tracker.Downloaded, "#9");
await tracker.AnnounceAsync (new AnnounceParameters (0, 0, 0, TorrentEvent.Completed, infoHash, false, "peer3", null, 3, false));
await tracker.ScrapeAsync (scrapeParams);
Assert.AreEqual (2, tracker.Complete, "#10");
Assert.AreEqual (1, tracker.Incomplete, "#11");
Assert.AreEqual (1, tracker.Downloaded, "#12");
}
/// <summary>
/// Adds torrent to tracker thread-safely
/// </summary>
public void AddTorrentToTracker(Torrent torrent)
{
ITrackable trackable = new InfoHashTrackable(torrent);
lock (_dictTracker.Tracker) {
_dictTracker.Tracker.Add(trackable);
}
}
public async Task AnnounceTest_GetPeers()
{
var trackable = new InfoHashTrackable("Test", InfoHash);
server.Add(trackable);
var manager = (SimpleTorrentManager)server.GetTrackerItem(trackable);
foreach (var p in peerEndpoints)
{
manager.Add(new Peer(p, p));
}
var response = await tracker.AnnounceAsync(announceparams, CancellationToken.None);
var endpoints = response.Peers.Select(t => new IPEndPoint(IPAddress.Parse(t.Uri.Host), t.Uri.Port)).ToArray();
foreach (var p in peerEndpoints)
{
Assert.IsTrue(endpoints.Contains(p), "#1." + p);
}
}
//-------------------------------------------------------------
public void StartTracker(byte[] torrentData)
//-------------------------------------------------------------
{
Log.Get().Write("Starting torrent tracker server, http on port: " + TRACKERHTTP_PORT + " udp on port: " + TRACKERUDP_PORT);
if (!Helper.IsPortAvailable(TRACKERHTTP_PORT))
{
Log.Get().Write("Failed starting torrent tracker server on http port: " + TRACKERHTTP_PORT + " Port in use", Log.LogType.Error);
}
if (!Helper.IsPortAvailable(TRACKERUDP_PORT))
{
Log.Get().Write("Failed starting torrent tracker server on UDP port: " + TRACKERUDP_PORT + " Port in use", Log.LogType.Error);
}
//-------------------------------------------------------------
//Create tracker server
//-------------------------------------------------------------
if (trackerServer == null)
{
trackerServer = new TrackerServer();
listenerHttp = TrackerListenerFactory.CreateHttp(IPAddress.Any, TRACKERHTTP_PORT); // http://localhost:{TRACKER_PORT}/announce
listenerUdp = TrackerListenerFactory.CreateUdp(IPAddress.Any, TRACKERUDP_PORT); // http://localhost:{TRACKER_PORT}/announce
//Add logning
trackerServer.PeerAnnounced += delegate(object o, AnnounceEventArgs e) { Log.Get().Write("TrackerServer PeerAnnounced"); };
trackerServer.PeerScraped += delegate(object o, ScrapeEventArgs e) { Log.Get().Write("TrackerServer PeerScrape"); };
trackerServer.PeerTimedOut += delegate(object o, TimedOutEventArgs e) { Log.Get().Write("TrackerServer Peer timeout"); };
listenerHttp.AnnounceReceived += delegate(object o, AnnounceRequest e) { Log.Get().Write("TrackerListenerHTTP Announce received"); };
listenerHttp.ScrapeReceived += delegate(object o, TrackerScrapeRequest e) { Log.Get().Write("TrackerListenerHTTP Scrape received"); };
listenerHttp.StatusChanged += delegate(object o, EventArgs e)
{
Log.Get().Write("TrackerListenerHttp Status changed: " + listenerHttp.Status); //Typecast not working here, protectionlevel error. :( /*((MonoTorrent.Tracker.Listeners.HttpTrackerListener)o)*/
};
listenerUdp.AnnounceReceived += delegate(object o, AnnounceRequest e) { Log.Get().Write("TrackerListenerUDP Announce received"); };
listenerUdp.ScrapeReceived += delegate(object o, TrackerScrapeRequest e) { Log.Get().Write("TrackerListenerUDP Scrape received"); };
listenerUdp.StatusChanged += delegate(object o, EventArgs e)
{
Log.Get().Write("TrackerListenerUdp Status changed: " + listenerUdp.Status);
};
//Start tracking server
trackerServer.RegisterListener(listenerHttp);
trackerServer.RegisterListener(listenerUdp);
listenerUdp.Start();
listenerHttp.Start();
trackerServer.AllowUnregisteredTorrents = false; // If an announce request is received for a torrent which is not registered with the tracker an error will be returned.
Log.Get().Write("TrackerListener listener status http:" + listenerHttp.Status + " udp status: " + listenerUdp.Status);
}
//-------------------------------------------------------------
//Add new torrent to tracker
//-------------------------------------------------------------
MonoTorrent.Torrent torrent = MonoTorrent.Torrent.Load(torrentData);
InfoHashTrackable trackable = new InfoHashTrackable(torrent);
trackerServer.Add(trackable);
Log.Get().Write("Adding torrent to tracker server, torrent size: " + torrentData.Length);
//-------------------------------------------------------------
//Seed file
//-------------------------------------------------------------
Log.Get().Write("Prepare to seed file");
DownloadTorrent(torrent);
}
public SimpleTracker(string announcementEndpoint, string torrentsDirectoryPath)
{
// Make the listner.
var listener = new HttpListener(announcementEndpoint);
// Make the tracker.
Tracker = new Tracker();
Tracker.AnnounceInterval = new TimeSpan(0, 1, 0);
Tracker.AllowUnregisteredTorrents = true;
Tracker.RegisterListener(listener);
// Make mappings.
Mappings = new ConcurrentDictionary <string, InfoHashTrackable> ();
// Make watcher.
Watcher = new TorrentFolderWatcher(torrentsDirectoryPath, "*.torrent");
Watcher.TorrentFound += (sender, e) =>
{
try
{
// Wait for file to finish copying.
System.Threading.Thread.Sleep(500);
// Make InfoHashTrackable from torrent.
var torrent = Torrent.Load(e.TorrentPath);
var trackable = new InfoHashTrackable(torrent);
// Add to tracker.
lock (Tracker)
Tracker.Add(trackable);
// Save to mappings.
Mappings[e.TorrentPath] = trackable;
// Log.
Console.WriteLine("Added {0}", e.TorrentPath);
}
catch (Exception exception)
{
Debug.WriteLine("Error loading torrent from disk: {0}", exception.Message);
Debug.WriteLine("Stacktrace: {0}", exception.ToString());
}
};
Watcher.TorrentLost += (sender, e) =>
{
try
{
// Get from mappings.
var trackable = Mappings[e.TorrentPath];
// Remove from tracker.
lock (Tracker)
Tracker.Remove(trackable);
// Remove from mappings.
Mappings.TryRemove(e.TorrentPath, out trackable);
// Log.
Console.WriteLine("Removed {0}", e.TorrentPath);
}
catch (Exception exception)
{
Debug.WriteLine("Error uploading torrent from disk: {0}", exception.Message);
Debug.WriteLine("Stacktrace: {0}", exception.ToString());
}
};
// Register close events.
AppDomain.CurrentDomain.ProcessExit += (sender, e) => Tracker.Dispose();
// Run.
listener.Start();
Watcher.Start();
Watcher.ForceScan();
}
