private async Task SendClientHandler(OwnTcpServerConnection connection)
{
uint count = 0;
try
{
while (connection.Client.Connected)
{
OwnTcpSendMessage send = connection.SendQueue.Dequeue();
if (send == null || !connection.Client.Connected)
{
break;
}
if (!send.Message.HasID)
{
send.Message.ID = count++;
}
byte[] data = GetBytes(send.Message).ToArray();
await connection.Stream.WriteAsync(data, 0, data.Length);
await connection.Stream.FlushAsync();
send.SetResult(true);
}
}
catch (Exception e)
{
await CloseConnection(connection);
}
}
public OwnTcpSendMessage Dequeue()
{
lock (queue)
{
while (true)
{
if (queue.Count > 0)
{
break;
}
if (IsEnded)
{
return(null);
}
Monitor.Wait(queue);
}
string topic = queue.Dequeue();
OwnTcpSendMessage message = dict[topic];
dict.Remove(topic);
return(message);
}
}
private async Task ReadClientHandler(OwnTcpServerConnection connection, AsyncQueue <OwnTcpSendMessage> processQueue)
{
try
{
while (connection.Client.Connected)
{
OwnTcpMessage message = await connection.ReadMessage();
if (message == null || !connection.Client.Connected)
{
break;
}
switch (message.Topic)
{
case PingCmd:
await SendAnswer(connection, message.ID, 200);
break;
case SyncCmd:
ByteQueue data = new ByteQueue();
data.Enqueue(Service);
await SendMessageToClient(connection, SyncCmd, message.ID, data);
break;
case CloseCmd:
await CloseConnection(connection, false);
return;
default:
OwnTcpSendMessage processItem = new OwnTcpSendMessage(message);
await processQueue.Enqueue(processItem);
if (await processItem.Task)
{
Task responseTask = message.IsFireAndForget
? Task.CompletedTask
: SendAnswer(connection, message.ID, 200);
await SendMessageToAllOtherClients(connection, message.Topic, message.Payload);
await responseTask;
}
else
{
await CloseConnection(connection);
}
break;
}
}
}
catch (Exception e)
{
await CloseConnection(connection);
}
}
public Task Enqueue(OwnTcpMessage message)
{
lock (queue)
{
OwnTcpSendMessage sendMessage;
if (dict.TryGetValue(message.Topic, out sendMessage))
{
sendMessage.Message = message;
}
else
{
sendMessage = new OwnTcpSendMessage(message);
queue.Enqueue(message.Topic);
dict.Add(message.Topic, sendMessage);
Monitor.Pulse(queue);
}
return(sendMessage.Task);
}
}
private static async Task SendMessagesHandler(OwnTcpClientConnection connection)
{
try
{
uint count = 0;
while (!connection.SendQueue.IsEnded)
{
OwnTcpSendMessage send = connection.SendQueue.Dequeue();
if (connection.SendQueue.IsEnded)
{
break;
}
send.Message.ID = count++;
if (!send.Message.IsFireAndForget)
{
connection.Waits.Add(send.Message.ID, send);
}
byte[] data = GetBytes(send.Message).ToArray();
await connection.Stream.WriteAsync(data, 0, data.Length);
await connection.Stream.FlushAsync();
if (send.Message.IsFireAndForget)
{
send.SetResult(true);
}
if (send.Message.Topic == CloseCmd)
{
break;
}
}
}
catch (Exception e)
{
await connection.CloseAsync(new Exception("SendMessageHandler error", e), false);
}
}
