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); }