public void Queue_should_dequeue_item_once() { var queue = new OutgoingQueue<int>(10); queue.Enqueue(1); queue.Enqueue(2); Assert.Equal(new[] { 1 }, queue.Dequeue(1, TimeSpan.Zero, CancellationToken.None)); Assert.Equal(new[] { 2 }, queue.Dequeue(1, TimeSpan.Zero, CancellationToken.None)); }
public void Queue_should_dequeue_item_once() { var queue = new OutgoingQueue <int>(10); queue.Enqueue(1); queue.Enqueue(2); Assert.Equal(new[] { 1 }, queue.Dequeue(1, TimeSpan.Zero, CancellationToken.None)); Assert.Equal(new[] { 2 }, queue.Dequeue(1, TimeSpan.Zero, CancellationToken.None)); }
public override void SendNextPackets() { //check sending acks if (_mustSendAcks) { _mustSendAcks = false; NetUtils.DebugWrite("[RR]SendAcks"); Monitor.Enter(_outgoingAcks); Peer.SendRawData(_outgoingAcks); Monitor.Exit(_outgoingAcks); } long currentTime = DateTime.UtcNow.Ticks; Monitor.Enter(_pendingPackets); //get packets from queue Monitor.Enter(OutgoingQueue); while (OutgoingQueue.Count > 0) { int relate = NetUtils.RelativeSequenceNumber(_localSeqence, _localWindowStart); if (relate < _windowSize) { PendingPacket pendingPacket = _pendingPackets[_localSeqence % _windowSize]; pendingPacket.Sended = false; pendingPacket.Packet = OutgoingQueue.Dequeue(); pendingPacket.Packet.Sequence = (ushort)_localSeqence; _localSeqence = (_localSeqence + 1) % NetConstants.MaxSequence; } else //Queue filled { break; } } Monitor.Exit(OutgoingQueue); //send double resendDelay = Peer.ResendDelay; for (int pendingSeq = _localWindowStart; pendingSeq != _localSeqence; pendingSeq = (pendingSeq + 1) % NetConstants.MaxSequence) { PendingPacket currentPacket = _pendingPackets[pendingSeq % _windowSize]; if (currentPacket.Packet == null) { continue; } if (currentPacket.Sended) //check send time { double packetHoldTime = currentTime - currentPacket.TimeStamp; if (packetHoldTime < resendDelay * TimeSpan.TicksPerMillisecond) { continue; } NetUtils.DebugWrite("[RC]Resend: {0} > {1}", (int)packetHoldTime, resendDelay); } currentPacket.TimeStamp = currentTime; currentPacket.Sended = true; Peer.SendRawData(currentPacket.Packet); } Monitor.Exit(_pendingPackets); }
public ArraySegment <byte> GetNextChunk() { int chunky = 0; if (RemainingBytes >= Chunksizes) { chunky = Chunksizes; } else { chunky = RemainingBytes; } Array.Copy(CurrentOutGoingQueuedMessage, outgoing.buffer, chunky); outgoing.MessageLength = chunky; outgoing.MessageNumber = (ushort)CurrentOutgoingMessageNumber; outgoing.TotalMessages = (ushort)TotalOutgoingMessages; outgoing.ChannelNumber = ChannelNumber; outgoing.Encode(); CurrentOutgoingMessageNumber++; if (CurrentOutgoingMessageNumber > TotalOutgoingMessages) { CurrentOutgoingMessageNumber = 0; TotalOutgoingMessages = 0; if (OutgoingQueue.Count > 0) { SetupOutGoing(OutgoingQueue.Dequeue()); } } return(new ArraySegment <byte>(outgoing.buffer, 0, outgoing.buffer.Length)); }
public ArraySegment <byte> GetNextChunk() { int chunky = 0; if (RemainingBytes >= Chunksizes) { chunky = Chunksizes; } else { chunky = RemainingBytes; } outgoing.Encode(CurrentOutGoingQueuedMessage, chunky, CurrentOutgoingMessageNumber, TotalOutgoingMessages, ChannelNumber); CurrentOutgoingMessageNumber++; if (CurrentOutgoingMessageNumber > TotalOutgoingMessages) { CurrentOutgoingMessageNumber = 0; TotalOutgoingMessages = 0; if (OutgoingQueue.Count > 0) { SetupOutGoing(OutgoingQueue.Dequeue()); } } return(outgoing.GetEncodedMessage()); // return new ArraySegment<byte>(outgoing.buffer,0,outgoing.buffer.Length); }
private async Task ExchangeOut() { await Task.Yield(); await RegisterMonitors(); while (!_cancellation.IsCancellationRequested) { try { var bucket = _outgoingQueue.Dequeue(_config.ExchangeOutBucketSize, _config.UploadRetryInterval, _cancellation.Token); if (bucket.Length > 0) { await UploadChangesAsync(bucket); } } catch (OperationCanceledException) { return; } catch (Exception e) { Logger.Error($"Unable to exchange data: {e.Message}", e); await Task.Delay(_config.UploadRetryInterval, _cancellation.Token); } } }
public override void SendNextPackets() { lock (OutgoingQueue) { while (OutgoingQueue.Count > 0) { NetPacket packet = OutgoingQueue.Dequeue(); Peer.SendUserData(packet); Peer.Recycle(packet); } } }
public void Queue_should_override_old_items_if_limit_is_reached() { var maxCapacity = 10; var queue = new OutgoingQueue<int>(maxCapacity); var all = Enumerable.Range(0, maxCapacity * 2).ToArray(); foreach (var i in all) queue.Enqueue(i); var actual = queue.Dequeue(queue.Count, TimeSpan.Zero, CancellationToken.None); var expected = all.Skip(all.Length - maxCapacity).ToArray(); Assert.Equal(expected, actual); }
protected override bool SendNextPackets() { if (_reliable && OutgoingQueue.Count == 0) { long currentTime = DateTime.UtcNow.Ticks; long packetHoldTime = currentTime - _lastPacketSendTime; if (packetHoldTime >= Peer.ResendDelay * TimeSpan.TicksPerMillisecond) { var packet = _lastPacket; if (packet != null) { _lastPacketSendTime = currentTime; Peer.SendUserData(packet); } } } else { lock (OutgoingQueue) { while (OutgoingQueue.Count > 0) { NetPacket packet = OutgoingQueue.Dequeue(); _localSequence = (_localSequence + 1) % NetConstants.MaxSequence; packet.Sequence = (ushort)_localSequence; packet.ChannelId = _id; Peer.SendUserData(packet); if (_reliable && OutgoingQueue.Count == 0) { _lastPacketSendTime = DateTime.UtcNow.Ticks; _lastPacket = packet; } else { Peer.NetManager.NetPacketPool.Recycle(packet); } } } } if (_reliable && _mustSendAck) { _mustSendAck = false; _ackPacket.Sequence = _remoteSequence; Peer.SendUserData(_ackPacket); } return(_lastPacket != null); }
public override void SendNextPackets() { lock (OutgoingQueue) { while (OutgoingQueue.Count > 0) { NetPacket packet = OutgoingQueue.Dequeue(); _localSequence = (_localSequence + 1) % NetConstants.MaxSequence; packet.Sequence = (ushort)_localSequence; Peer.SendRawData(packet); Peer.Recycle(packet); } } }
protected override bool SendNextPackets() { if (_mustSendAcks) { _mustSendAcks = false; NetDebug.Write("[RR]SendAcks"); lock (_outgoingAcks) Peer.SendUserData(_outgoingAcks); } long currentTime = DateTime.UtcNow.Ticks; bool hasPendingPackets = false; lock (_pendingPackets) { //get packets from queue lock (OutgoingQueue) { while (OutgoingQueue.Count > 0) { int relate = NetUtils.RelativeSequenceNumber(_localSeqence, _localWindowStart); if (relate >= _windowSize) { break; } var netPacket = OutgoingQueue.Dequeue(); netPacket.Sequence = (ushort)_localSeqence; netPacket.ChannelId = _id; _pendingPackets[_localSeqence % _windowSize].Init(netPacket); _localSeqence = (_localSeqence + 1) % NetConstants.MaxSequence; } } //send for (int pendingSeq = _localWindowStart; pendingSeq != _localSeqence; pendingSeq = (pendingSeq + 1) % NetConstants.MaxSequence) { // Please note: TrySend is invoked on a mutable struct, it's important to not extract it into a variable here bool hasPacket; _pendingPackets[pendingSeq % _windowSize].TrySend(currentTime, Peer, out hasPacket); if (hasPacket) { hasPendingPackets = true; } } } return(hasPendingPackets || _mustSendAcks || OutgoingQueue.Count > 0); }
public void Queue_should_return_immediately_a_bucket_if_there_is_enough_elements_to_fill_it() { var maxCapacity = 1000; var bucketSize = 500; var queue = new OutgoingQueue<int>(maxCapacity); for (var i = 0; i < maxCapacity; i++) queue.Enqueue(i); var watch = Stopwatch.StartNew(); var items = queue.Dequeue(bucketSize, TimeSpan.FromSeconds(2), CancellationToken.None); watch.Stop(); Assert.Equal(bucketSize, items.Length); Assert.True(watch.Elapsed < TimeSpan.FromSeconds(1), "watch.Elapsed < TimeSpan.FromSeconds(1)"); }
public void Queue_should_return_available_items_if_timeout_reached() { var bucketSize = 500; var queue = new OutgoingQueue<int>(bucketSize + 1); var availableItemsCount = bucketSize - 1; for (var i = 0; i < availableItemsCount; i++) queue.Enqueue(i); var timeout = TimeSpan.FromMilliseconds(500); var watch = Stopwatch.StartNew(); var items = queue.Dequeue(bucketSize, timeout, CancellationToken.None); watch.Stop(); Assert.Equal(availableItemsCount, items.Length); Assert.True(watch.Elapsed > (timeout - AcceptableTimeDelta).Duration(), $"Expected full timeout! Elapsed time: {watch.Elapsed}"); }
public void Queue_should_override_old_items_if_limit_is_reached() { var maxCapacity = 10; var queue = new OutgoingQueue <int>(maxCapacity); var all = Enumerable.Range(0, maxCapacity * 2).ToArray(); foreach (var i in all) { queue.Enqueue(i); } var actual = queue.Dequeue(queue.Count, TimeSpan.Zero, CancellationToken.None); var expected = all.Skip(all.Length - maxCapacity).ToArray(); Assert.Equal(expected, actual); }
public void Queue_should_return_available_items_if_cancelled() { var bucketSize = 500; var queue = new OutgoingQueue<int>(bucketSize + 1); var availableItemsCount = bucketSize - 1; for (var i = 0; i < availableItemsCount; i++) queue.Enqueue(i); var timeout = TimeSpan.FromMilliseconds(500); var watch = Stopwatch.StartNew(); var maxWaitTime = TimeSpan.FromSeconds(5); var items = queue.Dequeue(bucketSize, maxWaitTime, new CancellationTokenSource(timeout).Token); watch.Stop(); Assert.Equal(availableItemsCount, items.Length); Assert.True((watch.Elapsed - timeout).Duration() < maxWaitTime, $"Expected task cancellation before {maxWaitTime}"); }
public override void SendNextPackets() { if (_mustSendAcks) { _mustSendAcks = false; NetDebug.Write("[RR]SendAcks"); lock (_outgoingAcks) { Peer.SendUserData(_outgoingAcks); } } var currentTime = DateTime.UtcNow.Ticks; lock (_pendingPackets) { //get packets from queue lock (OutgoingQueue) { while (OutgoingQueue.Count > 0) { var relate = NetUtils.RelativeSequenceNumber(_localSeqence, _localWindowStart); if (relate >= _windowSize) { break; } var netPacket = OutgoingQueue.Dequeue(); netPacket.Sequence = (ushort)_localSeqence; netPacket.ChannelId = _id; _pendingPackets[_localSeqence % _windowSize].Init(netPacket); _localSeqence = (_localSeqence + 1) % NetConstants.MaxSequence; } } //send for (var pendingSeq = _localWindowStart; pendingSeq != _localSeqence; pendingSeq = (pendingSeq + 1) % NetConstants.MaxSequence) { _pendingPackets[pendingSeq % _windowSize].TrySend(currentTime, Peer); } } }
public void Queue_should_return_immediately_a_bucket_if_there_is_enough_elements_to_fill_it() { var maxCapacity = 1000; var bucketSize = 500; var queue = new OutgoingQueue <int>(maxCapacity); for (var i = 0; i < maxCapacity; i++) { queue.Enqueue(i); } var watch = Stopwatch.StartNew(); var items = queue.Dequeue(bucketSize, TimeSpan.FromSeconds(2), CancellationToken.None); watch.Stop(); Assert.Equal(bucketSize, items.Length); Assert.True(watch.Elapsed < TimeSpan.FromSeconds(1), "watch.Elapsed < TimeSpan.FromSeconds(1)"); }
public void Queue_should_return_available_items_if_timeout_reached() { var bucketSize = 500; var queue = new OutgoingQueue <int>(bucketSize + 1); var availableItemsCount = bucketSize - 1; for (var i = 0; i < availableItemsCount; i++) { queue.Enqueue(i); } var timeout = TimeSpan.FromMilliseconds(500); var watch = Stopwatch.StartNew(); var items = queue.Dequeue(bucketSize, timeout, CancellationToken.None); watch.Stop(); Assert.Equal(availableItemsCount, items.Length); Assert.True(watch.Elapsed > (timeout - AcceptableTimeDelta).Duration(), $"Expected full timeout! Elapsed time: {watch.Elapsed}"); }
public override void SendNextPackets() { if (_reliable && OutgoingQueue.Count == 0) { NetPacket packet = _lastPacket; if (packet != null) { Peer.SendUserData(packet); } } else { lock (OutgoingQueue) { while (OutgoingQueue.Count > 0) { NetPacket packet = OutgoingQueue.Dequeue(); _localSequence = (_localSequence + 1) % NetConstants.MaxSequence; packet.Sequence = (ushort)_localSequence; packet.ChannelId = _id; Peer.SendUserData(packet); if (_reliable && OutgoingQueue.Count == 0) { _lastPacket = packet; } else { Peer.Recycle(packet); } } } } if (_reliable && _mustSendAck) { _mustSendAck = false; _ackPacket.Sequence = _remoteSequence; Peer.SendUserData(_ackPacket); } }
public override void SendNextPackets() { //check sending acks if (_mustSendAcks) { _mustSendAcks = false; NetDebug.Write("[RR]SendAcks"); Monitor.Enter(_outgoingAcks); Peer.SendUserData(_outgoingAcks); Monitor.Exit(_outgoingAcks); } long currentTime = DateTime.UtcNow.Ticks; Monitor.Enter(_pendingPackets); //get packets from queue Monitor.Enter(OutgoingQueue); while (OutgoingQueue.Count > 0) { int relate = NetUtils.RelativeSequenceNumber(_localSeqence, _localWindowStart); if (relate < _windowSize) { var netPacket = OutgoingQueue.Dequeue(); netPacket.Sequence = (ushort)_localSeqence; netPacket.ChannelId = _id; _pendingPackets[_localSeqence % _windowSize].Init(netPacket); _localSeqence = (_localSeqence + 1) % NetConstants.MaxSequence; } else //Queue filled { break; } } Monitor.Exit(OutgoingQueue); //send for (int pendingSeq = _localWindowStart; pendingSeq != _localSeqence; pendingSeq = (pendingSeq + 1) % NetConstants.MaxSequence) { _pendingPackets[pendingSeq % _windowSize].TrySend(currentTime, Peer); } Monitor.Exit(_pendingPackets); }
public void Queue_should_return_available_items_if_cancelled() { var bucketSize = 500; var queue = new OutgoingQueue <int>(bucketSize + 1); var availableItemsCount = bucketSize - 1; for (var i = 0; i < availableItemsCount; i++) { queue.Enqueue(i); } var timeout = TimeSpan.FromMilliseconds(500); var watch = Stopwatch.StartNew(); var maxWaitTime = TimeSpan.FromSeconds(5); var items = queue.Dequeue(bucketSize, maxWaitTime, new CancellationTokenSource(timeout).Token); watch.Stop(); Assert.Equal(availableItemsCount, items.Length); Assert.True((watch.Elapsed - timeout).Duration() < maxWaitTime, $"Expected task cancellation before {maxWaitTime}"); }
private void WriteStats() { try { Logger.Info("Starting stats writer thread..."); while (true) { var item = _statsQueue.Dequeue(1, TimeSpan.FromMilliseconds(250), CancellationToken.None).FirstOrDefault(); if (item == null) { continue; } InsertStatistics(item.Item1.Id, item.Item3); _metricsForwarderCoordinator.HandleMetricsForwarding(item.Item1, item.Item2, item.Item3); } } catch (ThreadInterruptedException) { Logger.Info("Exiting stats writer thread..."); } }