private Task RunReceiverTaskAsync(ITransmissionConnectionFactory streamFactory, Func <IMessagingReceiveProcessor, Task> action)
{
return(TaskRunner.RunInBackground(async() =>
{
using (var serverStream = await streamFactory.CreateAsync().ConfigureAwait(false))
{
var receiver = new MessagingReceiveProcessor(serverStream, SerializationProvider.GetDeserializer(TransportHeaderPool.Instance));
await action(receiver).ConfigureAwait(false);
await receiver.In.Completion.ConfigureAwait(false);
Log.Trace("Completing server stream for connection {0}", serverStream.Id);
serverStream.Out.TryComplete();
await serverStream.Completion.ConfigureAwait(false);
}
}));
}
private Task RunSenderTaskAsync(ITransmissionConnectionFactory streamFactory, Func <IMessagingSendProcessor, Task> action)
{
return(TaskRunner.RunInBackground(async() =>
{
using (var serverStream = await streamFactory.CreateAsync().ConfigureAwait(false))
{
var sender = new MessagingSendProcessor(serverStream, SerializationProvider.GetSerializer());
await action(sender).ConfigureAwait(false);
sender.Out.TryComplete();
await sender.Out.Completion.ConfigureAwait(false);
Log.Trace("Waiting for completion of connection {0}", serverStream.Id);
await serverStream.Completion.ConfigureAwait(false);
}
}));
}
public async ValueTask <ITransportConnection> CreateAsync(CancellationToken cancellationToken = default(CancellationToken))
{
var transmissionConnection = await _transmissionConnectionFactory.CreateAsync(cancellationToken).ConfigureAwait(false);
try
{
var sender = new TransportSendProcessor(transmissionConnection, TransportHeaderPool.Instance, _serializer);
var receiver = new TransportReceiveProcessor(transmissionConnection, _deserializer);
var connection = new TransportConnection(sender, receiver, TransportHeaderPool.Instance);
Log.Trace("New connection created: {0}", connection.Id);
return(connection);
}
catch (Exception ex)
{
Log.Trace("Connection failed: {0}", ex.FormatTypeAndMessage());
transmissionConnection.Dispose();
throw;
}
}
public void StreamFailure()
{
var receiverTask = TaskRunner.RunInBackground(async() =>
{
MessagingReceiveProcessor receiver;
using (var serverStream = await _server.CreateAsync().ConfigureAwait(false))
{
receiver = new MessagingReceiveProcessor(serverStream, SerializationProvider.GetDeserializer(TransportHeaderPool.Instance));
var maybeMessage = await receiver.In.TryReadSafeAsync().ConfigureAwait(false);
}
await receiver.In.ConsumeAsync(x => x.Dispose()).ConfigureAwait(false);
});
var senderTask = TaskRunner.RunInBackground(async() =>
{
MessagingSendProcessor sender;
using (var clientStream = await _clientFactory.CreateAsync().ConfigureAwait(false))
{
sender = new MessagingSendProcessor(clientStream, SerializationProvider.GetSerializer());
var result = true;
while (result)
{
var transportMessage = new TransportMessage(
TransportHeaderPool.Instance.CreateFrameHeader(UniqueId.Generate(), true, 64),
new Maybe <IPooledBuffer>(PooledBuffer.Get(Random.GetRandomBytes(64))));
result = await sender.Out.TryWriteAsync(transportMessage).ConfigureAwait(false);
}
}
Log.Trace("Awaiting completion of sender {0}", sender.Id);
await sender.Out.Completion.ConfigureAwait(false);
});
Should.Throw <Exception>(() => receiverTask, TimeSpan.FromSeconds(1));
Log.Trace(receiverTask.Exception.ExtractInner(), "Received exception on receiving");
Should.Throw <Exception>(() => senderTask, TimeSpan.FromSeconds(1));
Log.Trace(senderTask.Exception.ExtractInner(), "Received exception on sending");
}