public async Task Should_recreate_consumers_on_connection_recovery()
{
var endpoint = GetUniqueEndpoint();
var consumersAttached = new CountdownEvent(2);
var testHandler = new TestHandler(@event =>
{
switch (@event.Id)
{
case EventId.LinkRemoteOpen when @event.Context is Attach attach && !attach.Role:
consumersAttached.Signal();
break;
}
});
var host1 = CreateOpenedContainerHost(endpoint, testHandler);
var connection = await CreateConnection(endpoint);
await connection.CreateConsumerAsync("a1", RoutingType.Anycast);
await connection.CreateConsumerAsync("a1", RoutingType.Anycast);
Assert.True(consumersAttached.Wait(Timeout));
consumersAttached.Reset();
host1.Dispose();
var host2 = CreateOpenedContainerHost(endpoint, testHandler);
Assert.True(consumersAttached.Wait(Timeout));
await DisposeUtil.DisposeAll(connection, host2);
}
public async Task Should_be_able_to_receive_message_when_connection_restored_after_receive_called()
{
var host1 = CreateOpenedContainerHost();
var host2 = CreateContainerHost();
var connection = await CreateConnection(new[] { host1.Endpoint, host2.Endpoint });
var consumer = await connection.CreateConsumerAsync("a1", RoutingType.Anycast);
var cts = new CancellationTokenSource(Timeout);
var receiveTask = consumer.ReceiveAsync(cts.Token);
host2.Open();
host1.Dispose();
var messageSource = host2.CreateMessageSource("a1");
messageSource.Enqueue(new Message("foo"));
var message = await receiveTask;
Assert.NotNull(message);
Assert.Equal("foo", message.GetBody <string>());
await DisposeUtil.DisposeAll(consumer, connection, host2);
}
public async Task Should_trigger_ConnectionRecovered_when_connection_recovered()
{
var host1 = CreateOpenedContainerHost();
var host2 = CreateOpenedContainerHost();
var connection = await CreateConnection(new[] { host1.Endpoint, host2.Endpoint });
var connectionRecovered = new AutoResetEvent(false);
Endpoint fallbackEndpoint = null;
connection.ConnectionRecovered += (sender, args) =>
{
fallbackEndpoint = args.Endpoint;
connectionRecovered.Set();
};
Assert.True(connection.IsOpened);
host1.Dispose();
Assert.True(connectionRecovered.WaitOne(Timeout));
Assert.Equal(host2.Endpoint, fallbackEndpoint);
await DisposeUtil.DisposeAll(connection, host2);
}
public async Task Should_be_able_to_SendAsync_message_when_SendAsync_invoked_before_connection_restored()
{
var endpoint = GetUniqueEndpoint();
var host1 = CreateOpenedContainerHost(endpoint);
var connection = await CreateConnection(endpoint);
var producer = await connection.CreateProducerAsync("a1", RoutingType.Anycast);
await DisposeHostAndWaitUntilConnectionNotified(host1, connection);
var cts = new CancellationTokenSource(Timeout);
var produceTask = producer.SendAsync(new Message("foo"), cts.Token);
var host2 = CreateOpenedContainerHost(endpoint);
var messageProcessor = host2.CreateMessageProcessor("a1");
await produceTask;
var message = messageProcessor.Dequeue(Timeout);
Assert.NotNull(message);
Assert.Equal("foo", message.GetBody <string>());
await DisposeUtil.DisposeAll(connection, host2);
}
public async Task Should_be_able_to_Send_message_when_Send_invoked_before_connection_restored()
{
var endpoint = GetUniqueEndpoint();
var host1 = CreateOpenedContainerHost(endpoint);
var connectionClosed = new ManualResetEvent(false);
var connection = await CreateConnection(endpoint);
connection.ConnectionClosed += (_, args) => connectionClosed.Set();
var producer = await connection.CreateProducerAsync("a1", RoutingType.Anycast);
host1.Dispose();
// make sure that the connection was closed, as we don't want to send a message to host1
Assert.True(connectionClosed.WaitOne(Timeout));
// run on another thread as we don't want to block here
var produceTask = Task.Run(() => producer.Send(new Message("foo")));
var host2 = CreateContainerHost(endpoint);
var messageProcessor = host2.CreateMessageProcessor("a1");
host2.Open();
await produceTask;
var message = messageProcessor.Dequeue(Timeout);
Assert.NotNull(message);
Assert.Equal("foo", message.GetBody <string>());
await DisposeUtil.DisposeAll(connection, host2);
}
public async Task Should_reconnect_when_broker_is_available_after_outage_is_over()
{
var endpoint = GetUniqueEndpoint();
var connectionOpened = new ManualResetEvent(false);
var testHandler = new TestHandler(@event =>
{
switch (@event.Id)
{
case EventId.ConnectionRemoteOpen:
connectionOpened.Set();
break;
}
});
var host1 = CreateOpenedContainerHost(endpoint, testHandler);
var connection = await CreateConnection(endpoint);
Assert.NotNull(connection);
Assert.True(connectionOpened.WaitOne(Timeout));
host1.Dispose();
connectionOpened.Reset();
var host2 = CreateOpenedContainerHost(endpoint, testHandler);
Assert.True(connectionOpened.WaitOne(Timeout));
await DisposeUtil.DisposeAll(connection, host2);
}
public async Task Should_not_recreate_disposed_consumers()
{
var endpoint = GetUniqueEndpoint();
var consumerAttached = new ManualResetEvent(false);
var testHandler = new TestHandler(@event =>
{
switch (@event.Id)
{
case EventId.LinkRemoteOpen when @event.Context is Attach attach && !attach.Role:
consumerAttached.Set();
break;
}
});
var host1 = CreateOpenedContainerHost(endpoint, testHandler);
var connection = await CreateConnection(endpoint);
var consumer = await connection.CreateConsumerAsync("a1", RoutingType.Anycast);
Assert.True(consumerAttached.WaitOne(Timeout));
await consumer.DisposeAsync();
consumerAttached.Reset();
host1.Dispose();
var host2 = CreateOpenedContainerHost(endpoint, testHandler);
Assert.False(consumerAttached.WaitOne(ShortTimeout));
await DisposeUtil.DisposeAll(connection, host2);
}
public async Task Should_be_able_to_Send_message_when_connection_restored()
{
var(producer, messageProcessor, host, connection) = await CreateReattachedProducer();
producer.Send(new Message("foo"));
var message = messageProcessor.Dequeue(Timeout);
Assert.NotNull(message);
Assert.Equal("foo", message.GetBody <string>());
await DisposeUtil.DisposeAll(producer, connection, host);
}
public async Task Should_be_able_to_receive_messages_when_connection_restored()
{
var(consumer, messageSource, host, connection) = await CreateReattachedConsumer();
messageSource.Enqueue(new Message("foo"));
var cts = new CancellationTokenSource(Timeout);
var message = await consumer.ReceiveAsync(cts.Token);
Assert.NotNull(message);
Assert.Equal("foo", message.GetBody <string>());
await DisposeUtil.DisposeAll(consumer, connection, host);
}
public void Dispose()
{
var disposeActions = new List <Action>
{
_reopener.Dispose,
_committer.Dispose,
Manager.Dispose,
() => _writer.Dispose(true)
};
disposeActions.AddRange(_threads.Select(t => (Action)t.Join));
DisposeUtil.PostponeExceptions(disposeActions.ToArray());
}
public async Task Should_connect_to_first_endpoint_when_auto_recovering_disabled()
{
var(host1, connectedToHost1) = CreateHost();
var(host2, connectedToHost2) = CreateHost();
var connectionFactory = CreateConnectionFactory();
connectionFactory.AutomaticRecoveryEnabled = false;
var connection = await connectionFactory.CreateAsync(new[] { host1.Endpoint, host2.Endpoint });
Assert.True(connection.IsOpened);
Assert.True(connectedToHost1.WaitOne(Timeout));
Assert.False(connectedToHost2.WaitOne(ShortTimeout));
await DisposeUtil.DisposeAll(connection, host1, host2);
}
public async Task Should_be_able_to_receive_and_reject_messages_when_connection_restored()
{
var(consumer, messageSource, host, connection) = await CreateReattachedConsumer();
messageSource.Enqueue(new Message("foo"));
var cts = new CancellationTokenSource(Timeout);
var message = await consumer.ReceiveAsync(cts.Token);
consumer.Reject(message);
var dispositionContext = messageSource.GetNextDisposition(Timeout);
Assert.IsType <Modified>(dispositionContext.DeliveryState);
Assert.True(dispositionContext.Settled);
await DisposeUtil.DisposeAll(consumer, connection, host);
}
public async Task Should_reconnect_to_the_second_endpoint_after_first_endpoint_disconnected()
{
var(host1, connectedToHost1) = CreateHost();
var(host2, connectedToHost2) = CreateHost();
var connection = await CreateConnection(new[] { host1.Endpoint, host2.Endpoint });
Assert.True(connection.IsOpened);
Assert.True(connectedToHost1.WaitOne(Timeout));
Assert.False(connectedToHost2.WaitOne(ShortTimeout));
host1.Dispose();
Assert.True(connectedToHost2.WaitOne(Timeout));
Assert.False(connectedToHost1.WaitOne(ShortTimeout));
Assert.True(connection.IsOpened);
await DisposeUtil.DisposeAll(connection, host2);
}
public void Dispose()
{
DisposeUtil.DisposeFields(this);
}
public ValueTask DisposeAsync()
{
return(DisposeUtil.DisposeAll(_receiverLink, _senderLink));
}
