/// <summary>
/// Initializes a new instance of the SiS.Communication.Tcp.ClientContext
/// </summary>
public HttpClientContext()
{
ReceiveBuffer = new RingQueue();
RecvSpeedController = new SpeedController();
SendController = new SpeedController();
SendBuffer = new DynamicBufferStream();
}
public void RingQueueTest()
{
const int size = 3;
var ring = new RingQueue <int>(10);
ring.IsEmpty.Should().BeTrue();
ring.IsFull.Should().BeFalse();
for (int i = 0; i < size; i++)
{
ring.Enqueue(i);
ring.Count.Should().Be(i + 1);
}
ring.Count.Should().Be(size);
ring.IsFull.Should().BeFalse();
ring.LostCount.Should().Be(0);
for (int i = 0; i < size; i++)
{
ring.Count.Should().Be(size - i);
int value = ring.Dequeue();
value.Should().Be(i);
}
ring.IsEmpty.Should().BeTrue();
ring.IsFull.Should().BeFalse();
}
public void RingQueueTryPeekTest()
{
const int maxCount = 2000;
const int size = 20;
var ring = new RingQueue <int>(size);
ring.IsEmpty.Should().BeTrue();
ring.IsFull.Should().BeFalse();
for (int i = 0; i < maxCount; i++)
{
ring.Enqueue(i);
ring.Count.Should().Be(Math.Min(size, i + 1));
}
ring.Count.Should().Be(size);
ring.IsFull.Should().BeTrue();
ring.LostCount.Should().Be(maxCount - size);
for (int i = maxCount - size; i < maxCount; i++)
{
(bool success, int peekValue)rtn = ring.TryPeek();
rtn.success.Should().BeTrue();
int value = ring.Dequeue();
value.Should().Be(rtn.peekValue);
value.Should().Be(i);
}
ring.IsEmpty.Should().BeTrue();
ring.IsFull.Should().BeFalse();
}
public void RingQueue()
{
Action <int> action = i => {
Debug.WriteLine("a:" + i);
Thread.Sleep(1000);
};
var rq = new RingQueue <Action>(5);
for (int i = 1; i < 6; i++)
{
var i1 = i;
rq.Enqueue(() => action(i1));
}
bool isCompleted = false;
rq.ToObservable(NewThreadScheduler.Default).Subscribe(a => a(), () => isCompleted = true);
var ii = 6;
while (!isCompleted)
{
var i1 = ++ii;
rq.Enqueue(() => action(i1));
Thread.Sleep(1000);
}
}
public void RingQueueGetListTest()
{
const int loopCount = 10;
const int size = 1000;
const int batchSize = 250;
var ring = new RingQueue <int>(size);
ring.IsEmpty.Should().BeTrue();
ring.IsFull.Should().BeFalse();
int index = 0;
for (int i = 0; i < loopCount; i++)
{
for (int j = 0; j < batchSize; j++)
{
ring.Enqueue(index);
ring.Count.Should().Be(Math.Min(size, index + 1));
index++;
}
IList <int> list = ring.ToList();
list.Count.Should().Be(Math.Min(size, batchSize * (i + 1)));
}
}
/// <summary>
/// Initializes a new instance of the SiS.Communication.Tcp.ClientContext
/// </summary>
public ClientContext()
{
ReceiveBuffer = new RingQueue();
RecvSpeedController = new SpeedController();
SendController = new SpeedController();
RecvRawMessage = new TcpRawMessage();
}
public void ShouldThrowInvalidOperationExceptionWhenQueueIsFullForEnqueue() {
var queue = new RingQueue<int>(10);
for (int i = 0; i < 10; i++) {
queue.Enqueue(i);
}
Assert.That(() => queue.Enqueue(10), Throws.InvalidOperationException);
}
public WorkerQueue(int maxQueueSize)
{
Verify.Assert(maxQueueSize > 0, $"{maxQueueSize} must be greater than 0");
_queue = new RingQueue <T>(maxQueueSize);
_queueTask = Task.Factory.StartNew(ProcessQueue, TaskCreationOptions.LongRunning);
}
public void RingQueueMaxTest()
{
const int maxCount = 10;
var ring = new RingQueue <int>(maxCount);
ring.IsEmpty.Should().BeTrue();
ring.IsFull.Should().BeFalse();
for (int i = 0; i < maxCount; i++)
{
ring.Enqueue(i);
ring.Count.Should().Be(i + 1);
}
ring.Count.Should().Be(maxCount);
ring.IsFull.Should().BeTrue();
ring.LostCount.Should().Be(0);
for (int i = 0; i < maxCount; i++)
{
int value = ring.Dequeue();
value.Should().Be(i);
}
ring.IsEmpty.Should().BeTrue();
ring.IsFull.Should().BeFalse();
}
public void RingQueueLostTest()
{
const int maxCount = 20;
const int size = 18;
var ring = new RingQueue <int>(size);
ring.IsEmpty.Should().BeTrue();
ring.IsFull.Should().BeFalse();
for (int i = 0; i < maxCount; i++)
{
ring.Enqueue(i);
ring.Count.Should().Be(Math.Min(size, i + 1));
}
ring.Count.Should().Be(size);
ring.IsFull.Should().BeTrue();
ring.LostCount.Should().Be(maxCount - size);
for (int i = maxCount - size; i < maxCount; i++)
{
int value = ring.Dequeue();
value.Should().Be(i);
}
ring.IsEmpty.Should().BeTrue();
ring.IsFull.Should().BeFalse();
}
public void Ts3Client_RingQueueTest3()
{
var q = new RingQueue <int>(100, ushort.MaxValue + 1);
int iSet = 0;
for (int blockSize = 1; blockSize < 100; blockSize++)
{
for (int i = 0; i < blockSize; i++)
{
q.Set(iSet++, i);
}
for (int i = 0; i < blockSize; i++)
{
Assert.True(q.TryDequeue(out var iCheck));
Assert.AreEqual(i, iCheck);
}
}
for (int blockSize = 1; blockSize < 100; blockSize++)
{
q = new RingQueue <int>(100, ushort.MaxValue + 1);
for (int i = 0; i < blockSize; i++)
{
q.Set(i, i);
}
for (int i = 0; i < blockSize; i++)
{
Assert.True(q.TryDequeue(out var iCheck));
Assert.AreEqual(i, iCheck);
}
}
}
static void Main()
{
RingQueue <int> ringQueue = new RingQueue <int>(new DoublingStrategy());
ringQueue.Enqueue(0);
ringQueue.Enqueue(1);
ringQueue.Enqueue(2);
ringQueue.Enqueue(3);
ringQueue.Enqueue(4);
ringQueue.Enqueue(5);
ringQueue.Enqueue(6);
ringQueue.Enqueue(7);
ringQueue.Enqueue(8);
ringQueue.Enqueue(9);
for (int i = 0; i < 4; i++)
{
Console.WriteLine(ringQueue.Dequeue());
}
ringQueue.Enqueue(0);
ringQueue.Enqueue(1);
ringQueue.Enqueue(2);
ringQueue.Enqueue(3);
ringQueue.Enqueue(4);
ringQueue.Enqueue(5);
ringQueue.Enqueue(6);
ringQueue.Enqueue(7);
ringQueue.Enqueue(8);
ringQueue.Enqueue(9);
ringQueue.Enqueue(0);
ringQueue.Enqueue(1);
ringQueue.Enqueue(2);
ringQueue.Enqueue(3);
ringQueue.Enqueue(4);
ringQueue.Enqueue(5);
ringQueue.Enqueue(6);
ringQueue.Enqueue(7);
ringQueue.Enqueue(8);
ringQueue.Enqueue(9);
for (int i = ringQueue.Size; i > 0; i--)
{
Console.WriteLine(ringQueue.Dequeue());
}
ringQueue.Enqueue(1);
for (int i = ringQueue.Size; i > 0; i--)
{
Console.WriteLine(ringQueue.Dequeue());
}
Console.ReadKey();
}
protected PipeBase()
{
_packetSpliter = new SimplePacketSpliter();
_recvQueue = new RingQueue();
if (SynchronizationContext.Current != null)
{
_syncContext = SynchronizationContext.Current;
}
else
{
_syncContext = new SynchronizationContext();
SynchronizationContext.SetSynchronizationContext(_syncContext);
}
}
public void GivenQueuePolicy_WhenEqualMaxAdded_ShouldNoDataLoss()
{
const int max = 10;
var queue = new RingQueue <int>(max);
Enumerable.Range(0, max).ForEach(x => queue.Enqueue(x));
queue.Count.Should().Be(max);
queue.LostCount.Should().Be(0);
Enumerable.Range(0, max)
.Zip(queue, (o, i) => (o, i))
.All(x => x.o == x.i)
.Should().BeTrue();
}
public void GivenQueuePolicy_WhenMoreThenMaxAdded_ShouldHaveDataLoss()
{
const int max = 10;
const int count = 11;
var queue = new RingQueue <int>(max);
Enumerable.Range(0, count).ForEach(x => queue.Enqueue(x));
queue.Count.Should().Be(max);
queue.LostCount.Should().Be(count - max);
Enumerable.Range(1, max)
.Zip(queue, (o, i) => (o, i))
.All(x => x.o == x.i)
.Should().BeTrue();
}
public void GivenRingBuffer_WhenLessThenMaxAdded_NoDataLoss()
{
const int max = 10;
const int count = 5;
var queue = new RingQueue <int>(max);
Enumerable.Range(0, count).ForEach(x => queue.Enqueue(x));
queue.Count.Should().Be(count);
queue.LostCount.Should().Be(0);
Enumerable.Range(0, count)
.Zip(queue, (o, i) => (o, i))
.All(x => x.o == x.i)
.Should().BeTrue();
}
public void Ts3Client_RingQueueTest2()
{
int ov;
var q = new RingQueue <int>(50, ushort.MaxValue + 1);
for (int i = 0; i < ushort.MaxValue - 10; i++)
{
q.Set(i, 42);
q.TryDequeue(out ov);
}
Assert.True(q.IsSet(ushort.MaxValue - 20));
for (int i = ushort.MaxValue - 10; i < ushort.MaxValue + 10; i++)
{
q.Set(i % (ushort.MaxValue + 1), 42);
}
}
public void Ts3Client_RingQueueTest2()
{
var q = new RingQueue <int>(50, ushort.MaxValue + 1);
for (int i = 0; i < ushort.MaxValue - 10; i++)
{
q.Set(i, 42);
q.TryDequeue(out var _);
}
var setStatus = q.IsSet(ushort.MaxValue - 20);
Assert.True(setStatus.HasFlag(ItemSetStatus.Set));
for (int i = ushort.MaxValue - 10; i < ushort.MaxValue + 10; i++)
{
q.Set(i % (ushort.MaxValue + 1), 42);
}
}
public void RingQueueTest2()
{
var q = new RingQueue <int>(50, ushort.MaxValue + 1);
for (int i = 0; i < ushort.MaxValue - 10; i++)
{
q.Set(i, i);
Assert.True(q.TryDequeue(out var iCheck));
Assert.AreEqual(i, iCheck);
}
var setStatus = q.IsSet(ushort.MaxValue - 20);
Assert.True(setStatus.HasFlag(ItemSetStatus.Set));
for (int i = ushort.MaxValue - 10; i < ushort.MaxValue + 10; i++)
{
q.Set(i % (ushort.MaxValue + 1), 42);
}
}
public void Ts3Client_RingQueueTest()
{
var q = new RingQueue <int>(3, 5);
q.Set(0, 42);
Assert.True(q.TryPeekStart(0, out int ov));
Assert.AreEqual(ov, 42);
q.Set(1, 43);
// already set
Assert.Throws <ArgumentOutOfRangeException>(() => q.Set(1, 99));
Assert.True(q.TryPeekStart(0, out ov));
Assert.AreEqual(ov, 42);
Assert.True(q.TryPeekStart(1, out ov));
Assert.AreEqual(ov, 43);
Assert.True(q.TryDequeue(out ov));
Assert.AreEqual(ov, 42);
Assert.True(q.TryPeekStart(0, out ov));
Assert.AreEqual(ov, 43);
Assert.False(q.TryPeekStart(1, out ov));
q.Set(3, 45);
q.Set(2, 44);
// buffer overfull
Assert.Throws <ArgumentOutOfRangeException>(() => q.Set(4, 99));
Assert.True(q.TryDequeue(out ov));
Assert.AreEqual(ov, 43);
Assert.True(q.TryDequeue(out ov));
Assert.AreEqual(ov, 44);
q.Set(4, 46);
// out of mod range
Assert.Throws <ArgumentOutOfRangeException>(() => q.Set(5, 99));
q.Set(0, 47);
Assert.True(q.TryDequeue(out ov));
Assert.AreEqual(ov, 45);
Assert.True(q.TryDequeue(out ov));
Assert.AreEqual(ov, 46);
Assert.True(q.TryDequeue(out ov));
Assert.AreEqual(ov, 47);
q.Set(2, 49);
Assert.False(q.TryDequeue(out ov));
q.Set(1, 48);
Assert.True(q.TryDequeue(out ov));
Assert.AreEqual(ov, 48);
Assert.True(q.TryDequeue(out ov));
Assert.AreEqual(ov, 49);
}
public EventDataBufferObserver(int ringSize = 1000)
{
_eventRing = new RingQueue <EventData>(ringSize);
}
/// <summary>
/// Initializes a new instance of the SiS.Communication.Process.ShareMemoryReader
/// </summary>
/// <param name="uniqueName">An unique name for share memory communication</param>
/// <param name="bufferSize">The buffer size of the share memory</param>
public ShareMemoryReader(string uniqueName, int bufferSize) : base(uniqueName, bufferSize)
{
_recvBuffer = new RingQueue();
}
private void ProcessReceive(SocketAsyncEventArgs sockAsyncArgs)
{
if (!_isRunning)
{
return;
}
long clientID = (long)sockAsyncArgs.UserToken;
if (!_clients.TryGetValue(clientID, out ClientContext clientContext))
{
return;
}
Socket sockClient = clientContext.ClientSocket;
if (sockAsyncArgs.SocketError == SocketError.Success)
{
int recvCount = sockAsyncArgs.BytesTransferred;
if (recvCount > 0)
{
RingQueue clientRingBuffer = clientContext.ReceiveBuffer;
clientRingBuffer.Write(sockAsyncArgs.Buffer, sockAsyncArgs.Offset, recvCount);
//speed limit
if (clientContext.RecvSpeedController != null)
{
clientContext.RecvSpeedController.TryLimit(recvCount);
}
//try get a completed packet
List <DataPacket> messageList = null;
int endPos = 0;
try
{
messageList = _packetSpliter.GetPackets(clientRingBuffer.Buffer, 0, clientRingBuffer.DataLength, clientID, out endPos);
}
catch (NotImplementedException)
{
clientRingBuffer.Clear();
}
catch (Exception ex)
{
TcpRawMessageReceivedEventArgs rawMessage = new TcpRawMessageReceivedEventArgs()
{
Message = null,
Error = ex,
ClientID = clientID
};
OnRawMessageReceived(rawMessage);
}
if (messageList != null)
{
try
{
clientRingBuffer.Remove(endPos);
foreach (DataPacket messageSegment in messageList)
{
clientContext.RecvRawMessage.ClientID = (long)sockClient.Handle;
clientContext.RecvRawMessage.MessageRawData = messageSegment.Data;
clientContext.RecvRawMessage.Tag = messageSegment.Tag;
TcpRawMessageReceivedEventArgs rawMessage = new TcpRawMessageReceivedEventArgs()
{
Message = clientContext.RecvRawMessage,
ClientID = clientID
};
OnRawMessageReceived(rawMessage);
}
}
catch (InvalidPacketException)
{
//invalid data received , indicates the client has made a illegal connection, we should disconnect it.
_logger?.Info("illegal connection detected");
if (_isRunning)
{
CloseClient(true, (long)sockClient.Handle);
}
return;
}
catch (Exception ex)
{
_logger?.Warn("an error has occurred during get packets", ex.Message);
}
}
//in case of the socket is closed, the following statements may cause of exception, so we should use try catch
try
{
if (!clientContext.ClientSocket.ReceiveAsync(sockAsyncArgs))
{
ProcessReceive(sockAsyncArgs);
}
}
catch { }
}
else
{
_logger?.Warn($"sockAsyncArgs got an error: {sockAsyncArgs.SocketError.ToString()}");
if (_isRunning)
{
CloseClient(true, clientID);
}
}
}
else
{
if (_isRunning)
{
CloseClient(true, clientID);
}
}
}
public LogonAttempts(int maxCount)
{
_queue = new RingQueue(maxCount);
}
