internal ConnectionMonitor(int averagingPeriod)
{
_dataDown = new SpeedMonitor(averagingPeriod);
_dataUp = new SpeedMonitor(averagingPeriod);
_protocolDown = new SpeedMonitor(averagingPeriod);
_protocolUp = new SpeedMonitor(averagingPeriod);
}
internal DiskManager(EngineSettings settings, IPieceWriter writer)
{
ReadLimiter = new RateLimiter();
ReadMonitor = new SpeedMonitor();
ReadQueue = new Queue <BufferedIO>();
WriteLimiter = new RateLimiter();
WriteMonitor = new SpeedMonitor();
WriteQueue = new Queue <BufferedIO>();
UpdateTimer = ValueStopwatch.StartNew();
Settings = settings ?? throw new ArgumentNullException(nameof(settings));
Writer = writer ?? throw new ArgumentNullException(nameof(writer));
}
public Download(string savePath, TorrentManager manager)
{
this.manager = manager;
this.swarmSpeed = new SpeedMonitor(30);
SavePath = savePath;
GLib.Timeout.Add(1000, delegate {
swarmSpeed.Tick();
return(true);
});
manager.PieceHashed += delegate(object sender, PieceHashedEventArgs e) {
hashProgress = (double)e.PieceIndex / manager.Torrent.Pieces.Count;
};
manager.TorrentStateChanged += delegate(object sender, TorrentStateChangedEventArgs e) {
hashProgress = 0;
if (Active)
{
Gtk.Application.Invoke(delegate {
switch (e.NewState)
{
case TorrentState.Downloading:
State = State.Downloading;
break;
case TorrentState.Hashing:
State = State.Hashing;
break;
case TorrentState.Paused:
State = State.Paused;
break;
case TorrentState.Seeding:
State = State.Seeding;
break;
case TorrentState.Stopped:
State = State.Stopped;
Active = false;
break;
}
});
}
};
}
private static void ObserverPatternDemo()
{
Speedometer mySpeedometer = new Speedometer();
SpeedMonitor monitor = new SpeedMonitor(mySpeedometer);
GearBox gearBox = new GearBox(mySpeedometer);
//Set Current Speed property to a value
mySpeedometer.CurrentSpeed = 10;
mySpeedometer.CurrentSpeed = 20;
mySpeedometer.CurrentSpeed = 25;
mySpeedometer.CurrentSpeed = 30;
mySpeedometer.CurrentSpeed = 35;
}
internal DiskManager(ClientEngine engine, PieceWriter writer)
{
this.bufferedReads = new Queue <BufferedIO>();
this.bufferedWrites = new Queue <BufferedIO>();
this.engine = engine;
this.ReadLimiter = new RateLimiter();
this.readMonitor = new SpeedMonitor();
this.writeMonitor = new SpeedMonitor();
this.WriteLimiter = new RateLimiter();
this.Writer = writer;
IOLoop.QueueTimeout(TimeSpan.FromSeconds(1), () => {
readMonitor.Tick();
writeMonitor.Tick();
WriteLimiter.UpdateChunks(engine.Settings.MaxWriteRate, WriteRate);
ReadLimiter.UpdateChunks(engine.Settings.MaxReadRate, ReadRate);
ProcessBufferedIO();
return(!Disposed);
});
}
public static async Task SendAsync(IConnection connection, byte [] buffer, int offset, int count, IRateLimiter rateLimiter, SpeedMonitor peerMonitor, SpeedMonitor managerMonitor)
{
await IOLoop;
while (count > 0)
{
int transferred;
bool unlimited = rateLimiter?.Unlimited ?? true;
var shouldRead = unlimited ? count : Math.Min(ChunkLength, count);
if (rateLimiter != null && !unlimited && !rateLimiter.TryProcess(shouldRead))
{
var tcs = new TaskCompletionSource <int> ();
await IOLoop;
sendQueue.Enqueue(new QueuedIO(connection, buffer, offset, shouldRead, rateLimiter, tcs));
transferred = await tcs.Task.ConfigureAwait(false);
}
else
{
transferred = await connection.SendAsync(buffer, offset, shouldRead).ConfigureAwait(false);
}
if (transferred == 0)
{
throw new Exception("Socket is dead");
}
peerMonitor?.AddDelta(transferred);
managerMonitor?.AddDelta(transferred);
offset += transferred;
count -= transferred;
}
}
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);
});
}
public RequestMonitor()
{
announces = new SpeedMonitor();
scrapes = new SpeedMonitor();
}
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)
{
Logger.Log(null, "Write error: {0}", ex.Message);
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)
{
Logger.Log(null, "Read error: {0}", ex.Message);
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);
});
}
public InternetSpeedMonitorViewModel()
{
_speedMonitor = new SpeedMonitor();
SetTimer();
}
public static async Task SendAsync(IConnection connection, byte [] buffer, int offset, int count, IRateLimiter rateLimiter, SpeedMonitor peerMonitor, SpeedMonitor managerMonitor)
{
await IOLoop;
int remaining = count;
while (remaining > 0)
{
int transferred;
if (rateLimiter != null && !rateLimiter.Unlimited && !rateLimiter.TryProcess(Math.Min(ChunkLength, remaining)))
{
var tcs = new TaskCompletionSource <int> ();
await IOLoop;
sendQueue.Enqueue(new QueuedIO(connection, buffer, offset, Math.Min(ChunkLength, remaining), rateLimiter, tcs));
transferred = await tcs.Task.ConfigureAwait(false);
}
else
{
transferred = await connection.SendAsync(buffer, offset, remaining).ConfigureAwait(false);
}
if (transferred == 0)
{
throw new Exception("Socket is dead");
}
peerMonitor?.AddDelta(transferred);
managerMonitor?.AddDelta(transferred);
offset += transferred;
remaining -= transferred;
}
}
public static async ReusableTask SendAsync(IPeerConnection connection, SocketMemory buffer, IRateLimiter rateLimiter, SpeedMonitor peerMonitor, SpeedMonitor managerMonitor)
{
await MainLoop.SwitchToThreadpool();
while (buffer.Length > 0)
{
int transferred;
bool unlimited = rateLimiter?.Unlimited ?? true;
int shouldRead = unlimited ? buffer.Length : Math.Min(ChunkLength, buffer.Length);
if (rateLimiter != null && !unlimited && !rateLimiter.TryProcess(shouldRead))
{
var tcs = new ReusableTaskCompletionSource <int> ();
lock (sendQueue)
sendQueue.Enqueue(new QueuedIO(connection, buffer.Slice(0, shouldRead), rateLimiter, tcs));
transferred = await tcs.Task.ConfigureAwait(false);
}
else
{
transferred = await connection.SendAsync(buffer.Slice(0, shouldRead)).ConfigureAwait(false);
}
if (transferred == 0)
{
throw new ConnectionClosedException("Socket send returned 0, indicating the connection has been closed.");
}
peerMonitor?.AddDelta(transferred);
managerMonitor?.AddDelta(transferred);
buffer = buffer.Slice(transferred);
}
}
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;
});
}
public RequestMonitor()
{
Announces = new SpeedMonitor();
Scrapes = new SpeedMonitor();
}
public static async ReusableTask ReceiveAsync(IConnection connection, ByteBuffer buffer, int offset, int count, IRateLimiter rateLimiter, SpeedMonitor peerMonitor, SpeedMonitor managerMonitor)
{
await MainLoop.SwitchToThreadpool();
while (count > 0)
{
int transferred;
bool unlimited = rateLimiter?.Unlimited ?? true;
int shouldRead = unlimited ? count : Math.Min(ChunkLength, count);
if (rateLimiter != null && !unlimited && !rateLimiter.TryProcess(shouldRead))
{
var tcs = new ReusableTaskCompletionSource <int> ();
lock (receiveQueue)
receiveQueue.Enqueue(new QueuedIO(connection, buffer, offset, shouldRead, rateLimiter, tcs));
transferred = await tcs.Task.ConfigureAwait(false);
}
else
{
transferred = await connection.ReceiveAsync(buffer, offset, shouldRead).ConfigureAwait(false);
}
if (transferred == 0)
{
throw new ConnectionClosedException("Socket receive returned 0, indicating the connection has been closed.");
}
peerMonitor?.AddDelta(transferred);
managerMonitor?.AddDelta(transferred);
offset += transferred;
count -= transferred;
}
}
