internal ListenManager(ClientEngine engine)
{
Engine = engine;
_listeners = new MonoTorrentCollection<PeerListener>();
_endCheckEncryptionCallback = ClientEngine.MainLoop.Wrap(EndCheckEncryption);
_handshakeReceivedCallback = (a, b, c) => ClientEngine.MainLoop.Queue(() => OnPeerHandshakeReceived(a, b, c));
}
public CriticalExceptionEventArgs(Exception ex, ClientEngine engine)
{
if (ex == null)
throw new ArgumentNullException("ex");
if (engine == null)
throw new ArgumentNullException("engine");
_engine = engine;
_ex = ex;
}
public ConnectionManager(ClientEngine engine)
{
_engine = engine;
_endCheckEncryptionCallback = ClientEngine.MainLoop.Wrap(EndCheckEncryption);
_endSendMessageCallback = (a, b, c) => ClientEngine.MainLoop.Queue(() => EndSendMessage(a, b, c));
_endCreateConnectionCallback = (a, b, c) => ClientEngine.MainLoop.Queue(() => EndCreateConnection(a, b, c));
IncomingConnectionAcceptedCallback =
(a, b, c) => ClientEngine.MainLoop.Queue(() => IncomingConnectionAccepted(a, b, c));
_handshakeSentCallback = PeerHandshakeSent;
_peerHandshakeReceivedCallback =
(a, b, c) => ClientEngine.MainLoop.Queue(() => PeerHandshakeReceived(a, b, c));
_messageSentCallback = PeerMessageSent;
MessageReceivedCallback = (a, b, c) => ClientEngine.MainLoop.Queue(() => MessageReceived(a, b, c));
_pendingConnects = new List<AsyncConnectState>();
}
public EngineTestRig(string savePath, int piecelength, PieceWriter writer)
{
if(writer == null)
writer = new MemoryWriter(new NullWriter());
listener = new CustomListener();
engine = new ClientEngine(new EngineSettings(), listener, writer);
torrentDict = CreateTorrent(piecelength);
torrent = Torrent.Load(torrentDict);
manager = new TorrentManager(torrent, savePath, new TorrentSettings());
engine.Register(manager);
//manager.Start();
}
internal DiskManager(ClientEngine engine, PieceWriter writer)
{
_bufferedReads = new Queue<BufferedIO>();
_bufferedWrites = new Queue<BufferedIO>();
_cache = new Cache<BufferedIO>(true).Synchronize();
_engine = engine;
ReadLimiter = new RateLimiter();
_readMonitor = new SpeedMonitor();
_writeMonitor = new SpeedMonitor();
WriteLimiter = new RateLimiter();
_writer = writer;
_loopTask = delegate {
if (_disposed)
return;
while (_bufferedWrites.Count > 0 && WriteLimiter.TryProcess(_bufferedWrites.Peek ().buffer.Length / 2048))
{
BufferedIO write;
lock (_bufferLock)
write = _bufferedWrites.Dequeue();
try
{
PerformWrite(write);
_cache.Enqueue (write);
}
catch (Exception ex)
{
if (write.Manager != null)
SetError(write.Manager, Reason.WriteFailure, ex);
}
}
while (_bufferedReads.Count > 0 && ReadLimiter.TryProcess(_bufferedReads.Peek().Count / 2048))
{
BufferedIO read;
lock (_bufferLock)
read = _bufferedReads.Dequeue();
try
{
PerformRead(read);
_cache.Enqueue(read);
}
catch (Exception ex)
{
if (read.Manager != null)
SetError(read.Manager, Reason.ReadFailure, ex);
}
}
};
IOLoop.QueueTimeout(TimeSpan.FromSeconds(1), () =>
{
if (_disposed)
return false;
_readMonitor.Tick();
_writeMonitor.Tick();
_loopTask();
return true;
});
}
TestRig(string savePath, int piecelength, TestWriter writer, string[][] trackers, TorrentFile[] files, bool metadataMode)
{
this.files = files;
this.savePath = savePath;
this.piecelength = piecelength;
this.tier = trackers;
MetadataMode = metadataMode;
MetadataPath = "metadataSave.torrent";
listener = new CustomListener();
engine = new ClientEngine(new EngineSettings(), listener, writer);
Writer = writer;
RecreateManager();
}
private static void StartEngine()
{
int port;
Torrent torrent = null;
// Ask the user what port they want to use for incoming connections
Console.Write(Environment.NewLine + "Choose a listen port: ");
while (!Int32.TryParse(Console.ReadLine(), out port)) { }
// Create the settings which the engine will use
// downloadsPath - this is the path where we will save all the files to
// port - this is the port we listen for connections on
EngineSettings engineSettings = new EngineSettings(_downloadsPath, port);
engineSettings.PreferEncryption = false;
engineSettings.AllowedEncryption = EncryptionTypes.All;
//engineSettings.GlobalMaxUploadSpeed = 30 * 1024;
//engineSettings.GlobalMaxDownloadSpeed = 100 * 1024;
//engineSettings.MaxReadRate = 1 * 1024 * 1024;
// Create the default settings which a torrent will have.
// 4 Upload slots - a good ratio is one slot per 5kB of upload speed
// 50 open connections - should never really need to be changed
// Unlimited download speed - valid range from 0 -> int.Max
// Unlimited upload speed - valid range from 0 -> int.Max
TorrentSettings torrentDefaults = new TorrentSettings(4, 150, 0, 0);
// Create an instance of the engine.
_engine = new ClientEngine(engineSettings);
_engine.ChangeListenEndpoint(new IPEndPoint(IPAddress.Any, port));
byte[] nodes = null;
try
{
nodes = File.ReadAllBytes(_dhtNodeFile);
}
catch
{
Console.WriteLine("No existing dht nodes could be loaded");
}
DhtListener dhtListner = new DhtListener (new IPEndPoint (IPAddress.Any, port));
DhtEngine dht = new DhtEngine (dhtListner);
_engine.RegisterDht(dht);
dhtListner.Start();
_engine.DhtEngine.Start(nodes);
// If the SavePath does not exist, we want to create it.
if (!Directory.Exists(_engine.Settings.SavePath))
Directory.CreateDirectory(_engine.Settings.SavePath);
// If the torrentsPath does not exist, we want to create it
if (!Directory.Exists(_torrentsPath))
Directory.CreateDirectory(_torrentsPath);
BEncodedDictionary fastResume;
try
{
fastResume = BEncodedValue.Decode<BEncodedDictionary>(File.ReadAllBytes(_fastResumeFile));
}
catch
{
fastResume = new BEncodedDictionary();
}
// For each file in the torrents path that is a .torrent file, load it into the engine.
foreach (string file in Directory.GetFiles(_torrentsPath))
{
if (file.EndsWith(".torrent"))
{
try
{
// Load the .torrent from the file into a Torrent instance
// You can use this to do preprocessing should you need to
torrent = Torrent.Load(file);
Console.WriteLine(torrent.InfoHash.ToString());
}
catch (Exception e)
{
Console.Write("Couldn't decode {0}: ", file);
Console.WriteLine(e.Message);
continue;
}
// When any preprocessing has been completed, you create a TorrentManager
// which you then register with the engine.
TorrentManager manager = new TorrentManager(torrent, _downloadsPath, torrentDefaults);
if (fastResume.ContainsKey(torrent.InfoHash.ToHex ()))
manager.LoadFastResume(new FastResume ((BEncodedDictionary)fastResume[torrent.infoHash.ToHex ()]));
_engine.Register(manager);
// Store the torrent manager in our list so we can access it later
torrents.Add(manager);
manager.PeersFound += ManagerPeersFound;
}
}
// If we loaded no torrents, just exist. The user can put files in the torrents directory and start
// the client again
if (torrents.Count == 0)
{
Console.WriteLine("No torrents found in the Torrents directory");
Console.WriteLine("Exiting...");
_engine.Dispose();
return;
}
// For each torrent manager we loaded and stored in our list, hook into the events
// in the torrent manager and start the engine.
foreach (TorrentManager manager in torrents)
{
// Every time a piece is hashed, this is fired.
manager.PieceHashed += delegate(object o, PieceHashedEventArgs e) {
lock (listener)
listener.WriteLine(string.Format("Piece Hashed: {0} - {1}", e.PieceIndex, e.HashPassed ? "Pass" : "Fail"));
};
// Every time the state changes (Stopped -> Seeding -> Downloading -> Hashing) this is fired
manager.TorrentStateChanged += delegate (object o, TorrentStateChangedEventArgs e) {
lock (listener)
listener.WriteLine("OldState: " + e.OldState.ToString() + " NewState: " + e.NewState.ToString());
};
// Every time the tracker's state changes, this is fired
foreach (var tracker in manager.TrackerManager.SelectMany(tier => tier.Trackers))
{
tracker.AnnounceComplete += (sender, e) => listener.WriteLine(string.Format("{0}: {1}", e.Successful,
e.Tracker.ToString()));
}
// Start the torrentmanager. The file will then hash (if required) and begin downloading/seeding
manager.Start();
}
// While the torrents are still running, print out some stats to the screen.
// Details for all the loaded torrent managers are shown.
var i = 0;
var running = true;
var sb = new StringBuilder(1024);
while (running)
{
if ((i++) % 10 == 0)
{
sb.Remove(0, sb.Length);
running = torrents.Exists(delegate(TorrentManager m) { return m.State != TorrentState.Stopped; });
AppendFormat(sb, "Total Download Rate: {0:0.00}kB/sec", _engine.TotalDownloadSpeed / 1024.0);
AppendFormat(sb, "Total Upload Rate: {0:0.00}kB/sec", _engine.TotalUploadSpeed / 1024.0);
AppendFormat(sb, "Disk Read Rate: {0:0.00} kB/s", _engine.DiskManager.ReadRate / 1024.0);
AppendFormat(sb, "Disk Write Rate: {0:0.00} kB/s", _engine.DiskManager.WriteRate / 1024.0);
AppendFormat(sb, "Total Read: {0:0.00} kB", _engine.DiskManager.TotalRead / 1024.0);
AppendFormat(sb, "Total Written: {0:0.00} kB", _engine.DiskManager.TotalWritten / 1024.0);
AppendFormat(sb, "Open Connections: {0}", _engine.ConnectionManager.OpenConnections);
foreach (var manager in torrents)
{
AppendSeperator(sb);
AppendFormat(sb, "State: {0}", manager.State);
AppendFormat(sb, "Name: {0}", manager.Torrent == null ? "MetaDataMode" : manager.Torrent.Name);
AppendFormat(sb, "Progress: {0:0.00}", manager.Progress);
AppendFormat(sb, "Download Speed: {0:0.00} kB/s", manager.Monitor.DownloadSpeed / 1024.0);
AppendFormat(sb, "Upload Speed: {0:0.00} kB/s", manager.Monitor.UploadSpeed / 1024.0);
AppendFormat(sb, "Total Downloaded: {0:0.00} MB", manager.Monitor.DataBytesDownloaded / (1024.0 * 1024.0));
AppendFormat(sb, "Total Uploaded: {0:0.00} MB", manager.Monitor.DataBytesUploaded / (1024.0 * 1024.0));
var tracker = manager.TrackerManager.CurrentTracker;
//AppendFormat(sb, "Tracker Status: {0}", tracker == null ? "<no tracker>" : tracker.State.ToString());
AppendFormat(sb, "Warning Message: {0}", tracker == null ? "<no tracker>" : tracker.WarningMessage);
AppendFormat(sb, "Failure Message: {0}", tracker == null ? "<no tracker>" : tracker.FailureMessage);
if (manager.PieceManager != null)
AppendFormat(sb, "Current Requests: {0}", manager.PieceManager.CurrentRequestCount());
foreach (var peerId in manager.GetPeers())
AppendFormat(sb, "\t{2} - {1:0.00}/{3:0.00}kB/sec - {0}", peerId.Peer.ConnectionUri,
peerId.Monitor.DownloadSpeed / 1024.0,
peerId.AmRequestingPiecesCount,
peerId.Monitor.UploadSpeed/ 1024.0);
AppendFormat(sb, "", null);
if (manager.Torrent != null)
foreach (var file in manager.Torrent.Files)
AppendFormat(sb, "{1:0.00}% - {0}", file.Path, file.BitField.PercentComplete);
}
Console.Clear();
Console.WriteLine(sb.ToString());
listener.ExportTo(Console.Out);
}
Thread.Sleep(500);
}
}
public LocalPeerListener(ClientEngine engine)
: base(new IPEndPoint(IPAddress.Any, 6771))
{
_engine = engine;
}
public LocalPeerListener(ClientEngine engine)
: base(new IPEndPoint(IPAddress.Any, 6771))
{
_engine = engine;
}