private async Task RunImplAsync(CancellationToken stoppingToken)
{
var dispatcher = new MessageDispatcher(
SerializationRegister,
Monitor,
MiddlewareMap,
_loggerFactory,
MessageBackoffStrategy,
MessageContextAccessor);
var subscriptionGroupFactory = new SubscriptionGroupFactory(
dispatcher,
Monitor,
_loggerFactory);
SubscriptionGroups =
subscriptionGroupFactory.Create(_defaultSubscriptionGroupSettings,
_subscriptionGroupSettings);
_log.LogInformation("Starting bus with settings: {@Response}", SubscriptionGroups.Interrogate());
try
{
await SubscriptionGroups.RunAsync(stoppingToken).ConfigureAwait(false);
}
catch (OperationCanceledException)
{
_log.LogDebug("Suppressed an exception of type {ExceptionType} which likely " +
"means the bus is shutting down.", nameof(OperationCanceledException));
// Don't bubble cancellation up to Completion task
}
}
private ISubscriptionGroup CreateSystemUnderTest()
{
var messageBackoffStrategy = Substitute.For <IMessageBackoffStrategy>();
var messageContextAccessor = Substitute.For <IMessageContextAccessor>();
Logger.LogInformation("Creating MessageDispatcher with serialization register type {Type}",
SerializationRegister.GetType().FullName);
var dispatcher = new MessageDispatcher(
SerializationRegister,
Monitor,
MiddlewareMap,
LoggerFactory,
messageBackoffStrategy,
messageContextAccessor);
var defaults = new SubscriptionGroupSettingsBuilder()
.WithDefaultConcurrencyLimit(ConcurrencyLimit);
var subscriptionGroupFactory = new SubscriptionGroupFactory(
dispatcher,
Monitor,
LoggerFactory);
var settings = SetupBusConfig();
return(subscriptionGroupFactory.Create(defaults, settings));
}
public async Task Sqs_Client_Throwing_Exceptions_Continues_To_Request_Messages()
{
// Arrange
int messagesRequested = 0;
int messagesDispatched = 0;
IEnumerable <Message> GetMessages()
{
Interlocked.Increment(ref messagesRequested);
throw new Exception();
}
var queue = new FakeSqsQueue(ct => Task.FromResult(GetMessages()));
var queues = new List <ISqsQueue> {
queue
};
IMessageDispatcher dispatcher =
new FakeDispatcher(() =>
{
Interlocked.Increment(ref messagesDispatched);
});
var defaults = new SubscriptionGroupSettingsBuilder()
.WithDefaultConcurrencyLimit(8);
var settings = new Dictionary <string, SubscriptionGroupConfigBuilder>
{
{ "test", new SubscriptionGroupConfigBuilder("test").AddQueues(queues) },
};
var subscriptionGroupFactory = new SubscriptionGroupFactory(
dispatcher,
MessageMonitor,
LoggerFactory);
ISubscriptionGroup collection = subscriptionGroupFactory.Create(defaults, settings);
var cts = new CancellationTokenSource();
// Act
var runTask = collection.RunAsync(cts.Token);
await Patiently.AssertThatAsync(_outputHelper,
() =>
{
messagesRequested.ShouldBeGreaterThan(1, $"but was {messagesRequested}");
messagesDispatched.ShouldBe(0, $"but was {messagesDispatched}");
});
cts.Cancel();
await runTask.HandleCancellation();
}
public async Task ErrorHandlingAroundSqs_WithCustomPolicy_CanSwallowExceptions()
{
// Arrange
int queueCalledCount = 0;
int dispatchedMessageCount = 0;
var sqsQueue = TestQueue(() => Interlocked.Increment(ref queueCalledCount));
var queues = new List <ISqsQueue> {
sqsQueue
};
var config = new SubscriptionGroupSettingsBuilder()
.WithDefaultConcurrencyLimit(8);
config.WithCustomMiddleware(
new ErrorHandlingMiddleware <GetMessagesContext, IList <Message>, InvalidOperationException>());
var settings = new Dictionary <string, SubscriptionGroupConfigBuilder>
{
{ "test", new SubscriptionGroupConfigBuilder("test").AddQueues(queues) },
};
IMessageDispatcher dispatcher = new FakeDispatcher(() => Interlocked.Increment(ref dispatchedMessageCount));
var groupFactory = new SubscriptionGroupFactory(
dispatcher,
MessageMonitor,
LoggerFactory);
ISubscriptionGroup collection = groupFactory.Create(config, settings);
var cts = new CancellationTokenSource();
var completion = collection.RunAsync(cts.Token);
await Patiently.AssertThatAsync(_outputHelper,
() =>
{
queueCalledCount.ShouldBeGreaterThan(1);
dispatchedMessageCount.ShouldBe(0);
});
cts.Cancel();
// Act and Assert
await completion.HandleCancellation();
}
private ISubscriptionGroup CreateSubscriptionGroup(
IList <ISqsQueue> queues,
IMessageDispatcher dispatcher)
{
var defaults = new SubscriptionGroupSettingsBuilder();
var settings = new Dictionary <string, SubscriptionGroupConfigBuilder>
{
{ "test", new SubscriptionGroupConfigBuilder("test").AddQueues(queues) },
};
var consumerGroupFactory = new SubscriptionGroupFactory(
dispatcher,
MessageMonitor,
LoggerFactory);
return(consumerGroupFactory.Create(defaults, settings));
}
public async Task Message_Processing_Throwing_Exceptions_Continues_To_Request_Messages()
{
// Arrange
int messagesRequested = 0;
int messagesDispatched = 0;
var sqsQueue1 = TestQueue(() => GetErrorMessages(() => messagesRequested++));
var queues = new List <ISqsQueue> {
sqsQueue1
};
IMessageDispatcher dispatcher =
new FakeDispatcher(() => Interlocked.Increment(ref messagesDispatched));
var defaults = new SubscriptionGroupSettingsBuilder()
.WithDefaultConcurrencyLimit(1);
var settings = new Dictionary <string, SubscriptionGroupConfigBuilder>
{
{ "test", new SubscriptionGroupConfigBuilder("test").AddQueues(queues) },
};
var subscriptionGroupFactory = new SubscriptionGroupFactory(
dispatcher,
MessageMonitor,
LoggerFactory);
ISubscriptionGroup collection = subscriptionGroupFactory.Create(defaults, settings);
var cts = new CancellationTokenSource();
// Act
var runTask = collection.RunAsync(cts.Token);
await Patiently.AssertThatAsync(_outputHelper,
() =>
{
messagesRequested.ShouldBeGreaterThan(1);
messagesDispatched.ShouldBe(0);
});
cts.Cancel();
await runTask.HandleCancellation();
}
