public static async Task <bool> TryWriteAsync <T>(this IWriteOnlyChannel <T> channel, T item)
{
var result = await channel.TryWriteSafeAsync(item).ConfigureAwait(false);
if (!result)
{
await channel.Completion.ConfigureAwait(false);
}
return(result);
}
public static async Task WriteAsync <T>(this IWriteOnlyChannel <T> channel, T item)
{
var result = await channel.TryWriteAsync(item).ConfigureAwait(false);
if (!result)
{
await channel.Completion.ConfigureAwait(false);
throw new OperationCanceledException();
}
}
private async Task SendAsync(IPooledBuffer message, IWriteOnlyChannel <IPooledBuffer> output)
{
try
{
await output.WriteAsync(message).ConfigureAwait(false);
}
catch
{
message.Dispose();
throw;
}
}
private async Task SendAsync(TransportMessage message, IWriteOnlyChannel <TransportMessage> output)
{
try
{
_log.Trace("Sending {0}", message);
await output.WriteAsync(message).ConfigureAwait(false);
}
catch
{
message.Dispose();
throw;
}
}
public TransportChannel(
UniqueId connectionId,
UniqueId channelId,
IWriteOnlyChannel <ChannelMessage> output,
IChannelHeaderFactory headerFactory)
{
ConnectionId = connectionId;
Id = channelId;
_log = LogManager.GetLogger <TransportChannel>($"{connectionId}.{channelId}");
_incomingMessageHandler = new TransportChannelHeaderHandler <Task, ChannelMessage>(HandleIncomingAsync, HandleIncomingAsync, HandleIncomingAsync);
_sendProcessor = new TransportChannelSendProcessor(connectionId, channelId, output, headerFactory);
Completion = Task.WhenAll(_sendProcessor.Completion, _receiveBuffer.In.Completion).LogCompletion(_log);
}
private async Task CloseConnectionAsync(Exception error, IWriteOnlyChannel <TransportMessage> output)
{
ITransportConnectionCloseHeader closeHeader;
if (error is OperationCanceledException)
{
closeHeader = _transportHeaderFactory.CreateConnectionCloseHeader(CompletionHeader.Canceled);
}
else
{
closeHeader = _transportHeaderFactory.CreateConnectionCloseHeader(CompletionHeader.Failed(GetErrorHeader(error)));
}
await SendAsync(new TransportMessage(closeHeader), output).ConfigureAwait(false);
}
public TransportChannelSendProcessor(
UniqueId connectionId,
UniqueId channelId,
IWriteOnlyChannel <ChannelMessage> @out,
IChannelHeaderFactory headerFactory)
{
ChannelId = channelId;
_log = LogManager.GetLogger <TransportChannelSendProcessor>($"{connectionId.ToString()}.{channelId.ToString()}");
_headerFactory = headerFactory;
_out = @out;
_buffer.Out.PropagateTerminationFrom(_out.Completion);
Completion = TaskRunner.RunInBackground(ProcessAsync).LogCompletion(_log);
Completion.PropagateCompletionToPromise(_initialized);
}
private async Task SendAsync(TransportMessage message, IWriteOnlyChannel <IPooledBuffer> output)
{
_log.Debug("Sending message: {0}", message);
using (var header = message.Header)
{
var serializedHeader = _serializer.Serialize(header);
await SendAsync(serializedHeader, output).ConfigureAwait(false);
if (message.Payload.HasValue)
{
var payload = message.Payload.Value;
await SendAsync(payload, output).ConfigureAwait(false);
}
}
}
private async Task ListenAsync(IWriteOnlyChannel <ITransportChannel> output, CancellationToken cancellationToken)
{
while (true)
{
var result = await _connection.IncomingChannels.TryReadAsync().ConfigureAwait(false);
if (!result.HasValue)
{
break;
}
var channel = result.Value;
_log.Trace("New invocation received: {0}", channel.Id);
if (!await output.TryWriteAsync(channel).ConfigureAwait(false))
{
channel.Out.TryTerminate();
break;
}
}
}
private async Task ReceiveLoopAsync(IWriteOnlyChannel <IPooledBuffer> received, CancellationToken cancellationToken)
{
try
{
while (true)
{
_log.Trace("Awaiting next message {0}", _receiveCount);
var length = await ReadLengthAsync(cancellationToken).ConfigureAwait(false);
if (length == EndMessage)
{
_log.Trace("Completing receiving datagrams because <END> message received");
break;
}
_log.Trace("Reading message {0} of length {1}", _receiveCount, length);
var datagram = await PooledBuffer
.Get(_stream, length, cancellationToken)
.ConfigureAwait(false);
try
{
await received.WriteAsync(datagram).ConfigureAwait(false);
}
catch
{
datagram.Dispose();
throw;
}
_log.Trace("Received message {0} of length {1}", _receiveCount, length);
_receiveCount++;
}
}
catch
{
Out.TryTerminate();
throw;
}
}
private static async Task GreetingDuplexStreaming(
IReadableChannel <GreetingRequest> requestStream,
IWriteOnlyChannel <GreetingResponse> responseStream,
MethodCallContext context)
{
Console.WriteLine("Received duplex streaming request from {{{0}}}", context);
var greeting = "Hello!";
await responseStream.WriteAsync(new GreetingResponse { Greeting = greeting }).ConfigureAwait(false);
Console.WriteLine("Sent: {0}", greeting);
while (await requestStream.WaitForNextSafeAsync().ConfigureAwait(false))
{
while (requestStream.TryReadSafe(out var request))
{
Console.WriteLine("Received: {0}", request.Name);
greeting = $"Hello, {request.Name}!";
await responseStream
.WriteAsync(new GreetingResponse { Greeting = greeting })
.ConfigureAwait(false);
Console.WriteLine("Sent: {0}", greeting);
}
}
Console.WriteLine("Request stream completed");
greeting = "Good Bye!";
await responseStream
.WriteAsync(new GreetingResponse { Greeting = greeting })
.ConfigureAwait(false);
Console.WriteLine("Sent: {0}", greeting);
greeting = "See you again!";
await responseStream
.WriteAsync(new GreetingResponse { Greeting = greeting })
.ConfigureAwait(false);
Console.WriteLine("Sent: {0}", greeting);
Console.WriteLine("Completed");
}
private static async Task GreetingServerStreaming(
GreetingRequest request,
IWriteOnlyChannel <GreetingResponse> responseStream,
MethodCallContext context)
{
Console.WriteLine("Received server streaming request from {{{0}}}", context);
Console.WriteLine("Received: {0}", request.Name);
var greeting = $"Hello, {request.Name}!";
await responseStream
.WriteAsync(new GreetingResponse { Greeting = greeting })
.ConfigureAwait(false);
Console.WriteLine("Sent: {0}", greeting);
await Task.Delay(500).ConfigureAwait(false);
greeting = $"Hello again, {request.Name}!";
await responseStream
.WriteAsync(new GreetingResponse { Greeting = greeting })
.ConfigureAwait(false);
Console.WriteLine("Sent: {0}", greeting);
Console.WriteLine("Completed");
}
private async Task ReceiveLoopAsync(IWriteOnlyChannel <TransportMessage> output, CancellationToken cancellationToken)
{
while (true)
{
var maybeData = await _connection.TryReadAsync().ConfigureAwait(false);
if (!maybeData.HasValue)
{
break;
}
ITransportHeader header;
using (var serializedHeader = maybeData.Value)
{
header = _deserializer.Deserialize(maybeData.Value);
}
try
{
var body = Maybe <IPooledBuffer> .Nothing;
var expectedBodyLength = GetBodyLengthHandler.Instance.Handle(header);
if (expectedBodyLength.HasValue)
{
body = await _connection.TryReadAsync().ConfigureAwait(false);
if (!body.HasValue)
{
break;
}
if (body.Value.Count != expectedBodyLength.Value)
{
try
{
throw new InvalidOperationException($"Received body length {body.Value.Count} does not equal to the specified in header: {header}");
}
finally
{
body.Value.Dispose();
}
}
}
try
{
var transportMessage = new TransportMessage(header, body);
_log.Debug("Message received: {0}", transportMessage);
await output.WriteAsync(transportMessage).ConfigureAwait(false);
}
catch
{
if (body.HasValue)
{
body.Value.Dispose();
}
throw;
}
}
catch
{
header.Dispose();
throw;
}
}
_log.Debug("Incoming messages completed");
}
private Task SendAsync(ChannelMessage message, IWriteOnlyChannel <TransportMessage> output)
{
return(SendAsync((TransportMessage)message, output));
}
private async Task CloseConnectionAsync(IWriteOnlyChannel <TransportMessage> output)
{
var closeHeader = _transportHeaderFactory.CreateConnectionCloseHeader(CompletionHeader.Completed);
await SendAsync(new TransportMessage(closeHeader), output).ConfigureAwait(false);
}
private async Task OpenConnectionAsync(IWriteOnlyChannel <TransportMessage> output)
{
var openHeader = _transportHeaderFactory.CreateConnectionOpenHeader(InstanceId);
await SendAsync(new TransportMessage(openHeader), output).ConfigureAwait(false);
}
