public Task <ReadOnlyMemory <byte> > OnRfpMessageAsync(RfpIdentifier identifier, ReadOnlyMemory <byte> data, CancellationToken cancellationToken)
{
if (!ShouldHandle(identifier, data))
{
return(Task.FromResult(data));
}
var message = new OmmMessage(MessageDirection.FromRfp, NextMessageId(), identifier, data);
return(OnMessageAsync(message, cancellationToken));
}
private async Task <ReadOnlyMemory <byte> > OnMessageAsync(OmmMessage message, CancellationToken cancellationToken)
{
if (HandleMessage)
{
var reply = await Client.HandleAsync(message, cancellationToken).ConfigureAwait(false);
return(reply.Message);
}
Client.Send(message, cancellationToken);
return(message.Message);
}
public async Task <OmmMessage> HandleAsync(OmmMessage message, CancellationToken cancellationToken)
{
if (!_pending.TryAdd(message.MessageId, message))
{
throw new ArgumentException("message id must be unique", nameof(message));
}
await SendInternalAsync(message, cancellationToken).ConfigureAwait(false);
var result = await message.WaitForReplyAsync(cancellationToken).ConfigureAwait(false);
_pending.TryRemove(message.MessageId, out _);
return(result);
}
private async Task SendInternalAsync(OmmMessage message, CancellationToken cancellationToken)
{
await _writeLock.WaitAsync(cancellationToken).ConfigureAwait(false);
try
{
await message.SendAsync(Socket, cancellationToken).ConfigureAwait(false);
}
finally
{
_writeLock.Release();
}
}
private Task OnSubscriptionMessageAsync(OmmMessage message, CancellationToken cancellationToken)
{
if (!_connections.TryGetValue(message.Rfp, out var connection))
{
return(Task.CompletedTask);
}
switch (message.Direction)
{
case MessageDirection.FromOmm:
return(OnServerMessageAsync(connection, message.Message, cancellationToken));
case MessageDirection.ToOmm:
return(OnClientMessageAsync(connection, message.Message, cancellationToken));
default:
throw new ArgumentOutOfRangeException(nameof(message.Direction), "invalid message direction");
}
}
public void Send(OmmMessage message, CancellationToken cancellationToken)
{
_ = SendInternalAsync(message, cancellationToken);
}
private async Task ReadPipeAsync(PipeReader client, CancellationToken cancellationToken)
{
try
{
var tasks = new List <Task>();
while (!cancellationToken.IsCancellationRequested)
{
var read = client.ReadAsync(cancellationToken);
ReadResult result;
if (read.IsCompleted)
{
result = await read;
}
else
{
var readTask = read.AsTask();
tasks.Add(readTask);
while (!read.IsCompleted)
{
var completed = await Task.WhenAny(tasks).ConfigureAwait(false);
if (!read.IsCompleted)
{
tasks.Remove(completed);
await completed.ConfigureAwait(false);
}
}
tasks.Remove(readTask);
result = await readTask.ConfigureAwait(false);
}
var buffer = result.Buffer;
bool success;
do
{
success = false;
if (buffer.Length < 4)
{
break;
}
var length = BinaryPrimitives.ReadUInt32BigEndian(buffer.Slice(0, 4).ToMemory().Span);
if (buffer.Length >= length + 4)
{
var data = buffer.Slice(4, length).ToMemory();
var message = new OmmMessage(data);
if (message.IsReply)
{
//dispatch reply
if (!_pending.TryGetValue(message.MessageId, out var request))
{
throw new InvalidDataException("unexpected reply");
}
request.Reply = message;
}
else
{
tasks.Add(_messageCallback(message, cancellationToken));
}
buffer = buffer.Slice(4).Slice(length);
success = true;
}
} while (success && buffer.Length >= 4);
if (result.IsCompleted)
{
break;
}
client.AdvanceTo(buffer.Start, buffer.End);
}
client.Complete();
}
catch (OperationCanceledException ex)
{
Console.WriteLine("cancelled in ClientConnection.ReadPipeAsync");
client.Complete(ex);
}
}
