private Task RunSenderTaskAsync(Func <ValueTask <ITransmissionConnection> > connectionFactory, Func <IMessagingSendProcessor, Task> action)
{
return(TaskRunner.RunInBackground(async() =>
{
using (var connection = await connectionFactory().ConfigureAwait(false))
{
var sender = new MessagingSendProcessor(connection, SerializationProvider.GetSerializer());
await action(sender).ConfigureAwait(false);
sender.Out.TryComplete();
await sender.Out.Completion.ConfigureAwait(false);
Log.Trace("Waiting for completion of connection {0}", connection.Id);
await connection.Completion.ConfigureAwait(false);
}
}));
}
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");
}
public void SendTransportMessageFromClientToServer()
{
RunWith10SecTimeout(async() =>
{
using (var clientConnection = await _client.ConnectAsync(BrokerWorkingDir))
using (var serverConnection = await _server.In.ReadAsync())
{
var clientSender = new MessagingSendProcessor(clientConnection, SerializationProvider.GetSerializer());
var serverReceiver = new MessagingReceiveProcessor(serverConnection, SerializationProvider.GetDeserializer(TransportHeaderPool.Instance));
var connectionOpen = new TransportMessage(TransportHeaderPool.Instance.CreateConnectionOpenHeader(UniqueId.Generate()));
var connectionClose = new TransportMessage(TransportHeaderPool.Instance.CreateConnectionCloseHeader(CompletionHeader.Completed));
await clientSender.Out.WriteAsync(connectionOpen);
await clientSender.Out.WriteAsync(connectionClose);
clientSender.Out.TryComplete();
var received1 = await serverReceiver.In.ReadAsync();
var received2 = await serverReceiver.In.ReadAsync();
Should.CompleteIn(serverReceiver.In.Completion, Timeout1Sec);
received1.Header.ShouldBeAssignableTo <ITransportConnectionOpenHeader>();
received2.Header.ShouldBeAssignableTo <ITransportConnectionCloseHeader>();
}
});
}
