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