public static async ValueTask <T> ReadAsync <T>(this IReadableChannel <T> channel, CancellationToken cancellationToken = default) { var result = await channel.TryReadAsync(cancellationToken).ConfigureAwait(false); if (!result.HasValue) { throw new OperationCanceledException(); } return(result.Value); }
private async Task ProcessAsync() { try { TaskRunner.RunInBackground(() => _appLifecycleManager.StartAsync()).IgnoreAwait(Log, "Exception on app lifecycle manager initialization"); while (true) { var transportConnectionResult = await _incomingConnections.TryReadAsync().ConfigureAwait(false); if (transportConnectionResult.HasValue) { var transportConnection = transportConnectionResult.Value; _activeConnections.TryAdd(transportConnection.Id, transportConnection); TaskRunner .RunInBackground(ProcessConnectionAsync, transportConnection) .ContinueWithSynchronously((Action <Task, object>)OnConnectionProcessed, transportConnection) .IgnoreAwait(Log); } else { Log.Trace("Transport connection listening completed"); break; } } } catch (Exception ex) { var activeConnections = _activeConnections.Values.ToArray(); _activeConnections.Clear(); foreach (var activeConnection in activeConnections) { activeConnection.TryTerminate(ex); } throw; } finally { var activeConnections = _activeConnections.Values.ToArray(); _activeConnections.Clear(); if (activeConnections.Length > 0) { Log.Info("Terminating {0} active connections", activeConnections.Length); foreach (var activeConnection in activeConnections) { Log.Trace("Terminating connection {0}", activeConnection); activeConnection.TryTerminate(); } await Task.WhenAll(activeConnections.Select(x => x.Completion.IgnoreExceptions())).ConfigureAwait(false); Log.Info("Terminated {0} active connections", activeConnections.Length); } } }
public static async ValueTask <T> ReadAsync <T>(this IReadableChannel <T> channel) { var result = await channel.TryReadAsync().ConfigureAwait(false); if (!result.HasValue) { await channel.Completion.ConfigureAwait(false); throw new OperationCanceledException(); } return(result.Value); }
public static async ValueTask <T> FirstAsync <T>( this IReadableChannel <T> channel, CancellationToken cancellationToken = default) { while (!cancellationToken.IsCancellationRequested) { var item = await channel.TryReadAsync(cancellationToken); cancellationToken.ThrowIfCancellationRequested(); if (item.HasValue) { return(item.Value); } } throw new Exception("There is no first element in sequence"); }
private static async Task PropagateAsync(IReadableChannel <TransportMessageFrame> channel1, IWritableChannel <TransportMessageFrame> channel2) { try { while (true) { var result = await channel1.TryReadAsync().ConfigureAwait(false); if (!result.HasValue) { break; } await channel2.WriteAsync(result.Value).ConfigureAwait(false); } channel2.TryComplete(); } catch (Exception ex) { channel2.TryTerminate(ex); } }
public static async Task ConsumeAsync <T>( this IReadableChannel <T> channel, Func <T, Task> handleAsync, Func <Task> onCompletedAsync = null, Func <Exception, Task> onTerminatedAsync = null) { try { while (true) { if (!channel.TryReadSafe(out T item)) { var result = await channel.TryReadAsync().ConfigureAwait(false); if (!result.HasValue) { break; } item = result.Value; } await handleAsync(item).ConfigureAwait(false); } if (onCompletedAsync != null) { await onCompletedAsync().ConfigureAwait(false); } } catch (Exception ex) { if (onTerminatedAsync != null) { await onTerminatedAsync(ex).ConfigureAwait(false); } else { throw; } } }
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"); }