public ClientEngine(EngineSettings settings, PeerListener listener, PieceWriter writer)
{
Check.Settings(settings);
Check.Listener(listener);
Check.Writer(writer);
this.listener = listener;
this.settings = settings;
this.connectionManager = new ConnectionManager(this);
RegisterDht(new NullDhtEngine());
this.diskManager = new DiskManager(this, writer);
this.listenManager = new ListenManager(this);
MainLoop.QueueTimeout(TimeSpan.FromMilliseconds(TickLength), delegate {
if (IsRunning && !disposed)
{
LogicTick();
}
return(!disposed);
});
this.torrents = new List <TorrentManager>();
this.torrentsReadonly = new ReadOnlyCollection <TorrentManager> (torrents);
CreateRateLimiters();
this.peerId = GeneratePeerId();
localPeerListener = new LocalPeerListener(this);
localPeerManager = new LocalPeerManager();
LocalPeerSearchEnabled = SupportsLocalPeerDiscovery;
listenManager.Register(listener);
// This means we created the listener in the constructor
if (listener.Endpoint.Port == 0)
{
listener.ChangeEndpoint(new IPEndPoint(IPAddress.Any, settings.ListenPort));
}
}
public void RepeatedTask()
{
//Console.WriteLine("Starting");
ManualResetEvent handle = new ManualResetEvent(false);
loop.QueueTimeout(TimeSpan.FromMilliseconds(0), delegate {
this.count++;
if (count == 3)
{
handle.Set();
return(false);
}
return(true);
});
Assert.IsTrue(handle.WaitOne(5000, true), "#1: Executed {0} times", count);
Assert.AreEqual(3, count, "#2");
}
public void RepeatedTask()
{
//Console.WriteLine("Starting");
ManualResetEvent handle = new ManualResetEvent(false);
loop.QueueTimeout(TimeSpan.FromMilliseconds(0), delegate {
this.count++;
if (count == 3)
{
handle.Set();
return(false);
}
return(true);
});
#if NETSTANDARD1_5
Assert.True(handle.WaitOne(5000), $"#1: Executed {count} times");
#else
Assert.True(handle.WaitOne(5000, true), $"#1: Executed {count} times");
#endif
Assert.Equal(3, count);
}
internal DiskManager(ClientEngine engine, PieceWriter writer)
{
this.bufferedReads = new Queue <BufferedIO>();
this.bufferedWrites = new Queue <BufferedIO>();
this.cache = new Cache <BufferedIO>(true).Synchronize();
this.engine = engine;
this.readLimiter = new RateLimiter();
this.readMonitor = new SpeedMonitor();
this.writeMonitor = new SpeedMonitor();
this.writeLimiter = new RateLimiter();
this.writer = writer;
LoopTask = delegate {
if (disposed)
{
return;
}
while (this.bufferedWrites.Count > 0 && writeLimiter.TryProcess(bufferedWrites.Peek().buffer.Length / 2048))
{
BufferedIO write;
lock (bufferLock)
write = this.bufferedWrites.Dequeue();
try
{
PerformWrite(write);
cache.Enqueue(write);
}
catch (Exception ex)
{
if (write.Manager != null)
{
SetError(write.Manager, Reason.WriteFailure, ex);
}
}
}
while (this.bufferedReads.Count > 0 && readLimiter.TryProcess(bufferedReads.Peek().Count / 2048))
{
BufferedIO read;
lock (bufferLock)
read = this.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), delegate {
if (disposed)
{
return(false);
}
readMonitor.Tick();
writeMonitor.Tick();
LoopTask();
return(true);
});
}
