///<summary>Start the Tracker. Start Watching the TORRENT_DIR Directory for new Torrents.</summary>
public MySimpleTracker()
{
tracker = new TrackerServer();
tracker.AllowUnregisteredTorrents = true;
var httpEndpoint = new System.Net.IPEndPoint(System.Net.IPAddress.Any, 10000);
var udpEndpoint = new System.Net.IPEndPoint(System.Net.IPAddress.Any, 10001);
Console.WriteLine("Listening for HTTP requests at: {0}", httpEndpoint);
Console.WriteLine("Listening for UDP requests at: {0}", udpEndpoint);
var listeners = new[] {
TrackerListenerFactory.CreateHttp(httpEndpoint),
TrackerListenerFactory.CreateUdp(udpEndpoint)
};
foreach (var listener in listeners)
{
tracker.RegisterListener(listener);
listener.Start();
}
SetupTorrentWatcher();
while (true)
{
System.Threading.Thread.Sleep(10000);
}
}
public async Task RunAsync()
{
//LoggerFactory.Creator = className => new TextLogger (Console.Out, className);
var seederWriter = new MemoryWriter(new NullWriter(), DataSize);
int port = 37827;
var seeder = new ClientEngine(
new EngineSettingsBuilder {
AllowedEncryption = new[] { EncryptionType.PlainText },
ListenPort = port++
}.ToSettings(),
seederWriter
);
var downloaders = Enumerable.Range(port, 16).Select(p => {
return(new ClientEngine(
new EngineSettingsBuilder {
ListenPort = p, AllowedEncryption = new[] { EncryptionType.PlainText }
}.ToSettings(),
new MemoryWriter(new NullWriter(), DataSize)
));
}).ToArray();
Directory.CreateDirectory(DataDir);
// Generate some fake data on-disk
var buffer = Enumerable.Range(0, 16 * 1024).Select(s => (byte)s).ToArray();
using (var fileStream = File.OpenWrite(Path.Combine(DataDir, "file.data"))) {
for (int i = 0; i < DataSize / buffer.Length; i++)
{
fileStream.Write(buffer, 0, buffer.Length);
}
fileStream.SetLength(DataSize);
}
var trackerListener = TrackerListenerFactory.CreateHttp(IPAddress.Parse("127.0.0.1"), 25611);
var tracker = new MonoTorrent.Tracker.TrackerServer {
AllowUnregisteredTorrents = true
};
tracker.RegisterListener(trackerListener);
trackerListener.Start();
// Create the torrent file for the fake data
var creator = new TorrentCreator();
creator.Announces.Add(new List <string> ());
creator.Announces [0].Add("http://127.0.0.1:25611/announce");
var metadata = await creator.CreateAsync(new TorrentFileSource (DataDir));
// Set up the seeder
await seeder.Register(new TorrentManager (Torrent.Load(metadata), DataDir, new TorrentSettingsBuilder {
UploadSlots = 20
}.ToSettings()));
using (var fileStream = File.OpenRead(Path.Combine(DataDir, "file.data"))) {
while (fileStream.Position < fileStream.Length)
{
var dataRead = new byte[16 * 1024];
int offset = (int)fileStream.Position;
int read = fileStream.Read(dataRead, 0, dataRead.Length);
await seederWriter.WriteAsync(seeder.Torrents[0].Files[0], offset, dataRead, 0, read);
}
}
await seeder.StartAllAsync();
List <Task> tasks = new List <Task> ();
for (int i = 0; i < downloaders.Length; i++)
{
await downloaders[i].Register(new TorrentManager(
Torrent.Load(metadata),
Path.Combine(DataDir, "Downloader" + i)
));
tasks.Add(RepeatDownload(downloaders[i]));
}
while (true)
{
long downTotal = seeder.TotalDownloadSpeed;
long upTotal = seeder.TotalUploadSpeed;
long totalConnections = 0;
long dataDown = seeder.Torrents[0].Monitor.DataBytesDownloaded + seeder.Torrents[0].Monitor.ProtocolBytesDownloaded;
long dataUp = seeder.Torrents[0].Monitor.DataBytesUploaded + seeder.Torrents[0].Monitor.ProtocolBytesUploaded;
foreach (var engine in downloaders)
{
downTotal += engine.TotalDownloadSpeed;
upTotal += engine.TotalUploadSpeed;
dataDown += engine.Torrents[0].Monitor.DataBytesDownloaded + engine.Torrents[0].Monitor.ProtocolBytesDownloaded;
dataUp += engine.Torrents[0].Monitor.DataBytesUploaded + engine.Torrents[0].Monitor.ProtocolBytesUploaded;
totalConnections += engine.ConnectionManager.OpenConnections;
}
Console.Clear();
Console.WriteLine($"Speed Down: {downTotal / 1024 / 1024}MB.");
Console.WriteLine($"Speed Up: {upTotal / 1024 / 1024}MB.");
Console.WriteLine($"Data Down: {dataDown / 1024 / 1024}MB.");
Console.WriteLine($"Data Up: {dataUp / 1024 / 1024}MB.");
Console.WriteLine($"Total Connections: {totalConnections}");
await Task.Delay(3000);
}
}
//-------------------------------------------------------------
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);
}
