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; } }