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...");
}
}
