public void TestNegativeQueueing()
{
var q = new AwaitableQueue <int>();
var hits = new List <int>();
q.Dequeue().ContinueWith(t => {
hits.Add(t.Result);
}, TaskContinuationOptions.ExecuteSynchronously);
q.Dequeue().ContinueWith(t => {
hits.Add(t.Result);
}, TaskContinuationOptions.ExecuteSynchronously);
q.Dequeue().ContinueWith(t => {
hits.Add(t.Result);
}, TaskContinuationOptions.ExecuteSynchronously);
Assert.AreEqual(0, q.Count);
Assert.AreEqual(3, q.PromisedCount);
q.Enqueue(1);
CollectionAssert.AreEqual(new[] { 1 }, hits);
q.Enqueue(2);
CollectionAssert.AreEqual(new[] { 1, 2 }, hits);
q.Enqueue(3);
CollectionAssert.AreEqual(new[] { 1, 2, 3 }, hits);
Assert.AreEqual(0, q.Count);
Assert.AreEqual(0, q.PromisedCount);
}
public void TestNegativeQueueing()
{
var q = new AwaitableQueue<int>();
var hits = new List<int>();
q.Dequeue().ContinueWith(t => {
hits.Add(t.Result);
}, TaskContinuationOptions.ExecuteSynchronously);
q.Dequeue().ContinueWith(t => {
hits.Add(t.Result);
}, TaskContinuationOptions.ExecuteSynchronously);
q.Dequeue().ContinueWith(t => {
hits.Add(t.Result);
}, TaskContinuationOptions.ExecuteSynchronously);
Assert.AreEqual(0, q.Count);
Assert.AreEqual(3, q.PromisedCount);
q.Enqueue(1);
CollectionAssert.AreEqual(new[] { 1 }, hits);
q.Enqueue(2);
CollectionAssert.AreEqual(new[] { 1, 2 }, hits);
q.Enqueue(3);
CollectionAssert.AreEqual(new[] { 1, 2, 3 }, hits);
Assert.AreEqual(0, q.Count);
Assert.AreEqual(0, q.PromisedCount);
}
public async Task TestPositiveQueueing()
{
var q = new AwaitableQueue<int>();
q.Enqueue(1);
q.Enqueue(2);
q.Enqueue(3);
Assert.AreEqual(3, q.Count);
Assert.AreEqual(0, q.PromisedCount);
Assert.AreEqual(1, await q.Dequeue());
Assert.AreEqual(2, await q.Dequeue());
Assert.AreEqual(3, await q.Dequeue());
Assert.AreEqual(0, q.Count);
Assert.AreEqual(0, q.PromisedCount);
}
public async Task TestPositiveQueueing()
{
var q = new AwaitableQueue <int>();
q.Enqueue(1);
q.Enqueue(2);
q.Enqueue(3);
Assert.AreEqual(3, q.Count);
Assert.AreEqual(0, q.PromisedCount);
Assert.AreEqual(1, await q.Dequeue());
Assert.AreEqual(2, await q.Dequeue());
Assert.AreEqual(3, await q.Dequeue());
Assert.AreEqual(0, q.Count);
Assert.AreEqual(0, q.PromisedCount);
}
void startRespThread(int mtype, string muid, string session, byte[] content, AwaitableQueue <byte[]> q)
{
new Thread(() =>
{
byte[] returncontent;
var result = HandleMessage((ServerMessageType)mtype, _keys[session], content, out returncontent);
using (var wms = new MemoryStream())
using (var writer = new BinaryWriter(wms))
{
writer.Write(muid);
writer.Write((int)result);
writer.Write(session);
writer.Write(returncontent.Length);
writer.Write(returncontent);
q.Enqueue(wms.ToArray());
Logger.Log($"Enqueued response to {(ServerMessageType)mtype} {muid}");
}
}).Start();
}
private void ListenThread()
{
Logger.Log("Starting TCP thread.");
if (_isMultiplayer)
{
_listener = new TcpListener(IPAddress.Any, _port);
}
else
{
_listener = new TcpListener(IPAddress.Loopback, _port);
}
_listener.Start();
_serverReady.Set();
while (_isRunning)
{
try
{
var connection = _listener.AcceptTcpClient();
var q = new AwaitableQueue <byte[]>();
_connected.Add(q);
Logger.Log($"New client connection.");
var t = new Thread(() =>
{
string csession = "";
var stream = connection.GetStream();
bool playerJoined = false;
Task.WaitAll(new Task[]
{
((Func <Task>)(async() =>
{
var lenb = new byte[4];
int leni;
byte[] dat = null;
while (connection.Connected)
{
try
{
await stream.ReadAsync(lenb, 0, 4);
leni = BitConverter.ToInt32(lenb, 0);
Logger.Log($"New message incoming. {leni} bytes long");
if (dat?.Length != leni)
{
dat = new byte[leni];
}
await stream.ReadAsync(dat, 0, leni);
Logger.Log("Message received");
using (var ms = new MemoryStream(dat))
using (var reader = new BinaryReader(ms))
{
var muid = reader.ReadString();
var mtype = reader.ReadInt32();
var session = reader.ReadString();
if (_isMultiplayer == false)
{
session = "__SINGLEPLAYER";
}
byte[] content = reader.ReadBytes(reader.ReadInt32());
if (string.IsNullOrWhiteSpace(csession))
{
csession = _keys[session];
}
_playerIds.TryAdd(csession, q);
if (_isMultiplayer)
{
if (!_keys.ContainsKey(session))
{
Logger.Log("Downloading itch.io user profile data to cache...");
var user = getItchUser(session);
Logger.Log($"{user.display_name} ({user.username}) has connected to the server.");
PlayerJoined?.Invoke(_keys[session], user);
}
}
else
{
if (playerJoined == false)
{
playerJoined = true;
var key = _keys[session];
var user = _users[key];
PlayerJoined?.Invoke(key, user);
}
}
startRespThread(mtype, muid, session, content, q);
}
}
catch (IOException ex)
{
Logger.Log(ex.ToString());
break;
}
}
}))(),
((Func <Task>)(async() =>
{
byte[] dat;
while (connection.Connected)
{
try
{
await q.WaitAsync();
Logger.Log($"Writer thread awakened");
while (q.TryDequeue(out dat))
{
await stream.WriteAsync(dat, 0, dat.Length);
Logger.Log($"Wrote {dat.Length} bytes");
}
}
catch (IOException ex)
{
Logger.Log(ex.ToString());
break;
}
}
}))()
});
stream.Dispose();
_connected.Remove(q);
});
t.IsBackground = true;
t.Start();
}
catch (SocketException sex)
{
Logger.Log("Socket exception: " + sex.ToString());
}
}
}
public void Setup()
{
_queue = new AwaitableQueue <int>(_options);
_expected = new Random().Next();
}
