public MessageReceiveBuffer(
int prefetch,
int bufferSize,
TimeSpan readTimeout,
TimeSpan sqsWaitTime,
ISqsQueue sqsQueue,
MiddlewareBase <ReceiveMessagesContext, IList <Message> > sqsMiddleware,
IMessageMonitor monitor,
ILogger <IMessageReceiveBuffer> logger,
IMessageBackoffStrategy messageBackoffStrategy = null)
{
_prefetch = prefetch;
_bufferSize = bufferSize;
_readTimeout = readTimeout;
_sqsWaitTime = sqsWaitTime;
if (sqsQueue == null)
{
throw new ArgumentNullException(nameof(sqsQueue));
}
_sqsQueueReader = new SqsQueueReader(sqsQueue);
_sqsMiddleware = sqsMiddleware ?? throw new ArgumentNullException(nameof(sqsMiddleware));
_monitor = monitor ?? throw new ArgumentNullException(nameof(monitor));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_backoffStrategyName = messageBackoffStrategy?.GetType()?.Name;
_channel = Channel.CreateBounded <IQueueMessageContext>(bufferSize);
if (messageBackoffStrategy != null)
{
_requestMessageAttributeNames.Add(MessageSystemAttributeName.ApproximateReceiveCount);
}
}
private static ISqsQueue TestQueue(Action spy = null)
{
async Task <ReceiveMessageResponse> GetMessages()
{
await Task.Delay(50);
spy?.Invoke();
var messages = new List <Message>
{
new TestMessage(),
};
return(new ReceiveMessageResponse
{
Messages = messages,
});
}
ISqsQueue sqsQueueMock = Substitute.For <ISqsQueue>();
sqsQueueMock.Uri.Returns(new Uri("http://test.com"));
sqsQueueMock
.Client.ReceiveMessageAsync(Arg.Any <ReceiveMessageRequest>(), Arg.Any <CancellationToken>())
.Returns(_ => GetMessages());
return(sqsQueueMock);
}
public async Task Messages_Not_Dispatched_After_Cancellation()
{
var cts = new CancellationTokenSource();
int dispatchedBeforeCancelled = 0;
int dispatchedAfterCancelled = 0;
ISqsQueue sqsQueue = TestQueue();
IMessageDispatcher dispatcher = new FakeDispatcher(() =>
{
if (cts.Token.IsCancellationRequested)
{
dispatchedAfterCancelled++;
}
else
{
dispatchedBeforeCancelled++;
}
});
var bus = CreateSubscriptionGroup(new[] { sqsQueue }, dispatcher);
var runTask = bus.RunAsync(cts.Token);
cts.CancelAfter(TimeoutPeriod);
await Assert.ThrowsAnyAsync <OperationCanceledException>(async() => await runTask);
dispatchedBeforeCancelled.ShouldBeGreaterThan(0);
dispatchedAfterCancelled.ShouldBe(0);
}
public async Task Sqs_Queue_Is_Not_Polled_After_Cancellation()
{
var cts = new CancellationTokenSource();
int callCountBeforeCancelled = 0;
int callCountAfterCancelled = 0;
ISqsQueue sqsQueue = TestQueue(() =>
{
if (cts.Token.IsCancellationRequested)
{
callCountAfterCancelled++;
}
else
{
callCountBeforeCancelled++;
}
});
IMessageDispatcher dispatcher = new FakeDispatcher();
var bus = CreateSubscriptionGroup(new[] { sqsQueue }, dispatcher);
var runTask = bus.RunAsync(cts.Token);
cts.CancelAfter(TimeoutPeriod);
await Assert.ThrowsAnyAsync <OperationCanceledException>(() => runTask);
callCountBeforeCancelled.ShouldBeGreaterThan(0);
callCountAfterCancelled.ShouldBeLessThanOrEqualTo(1);
}
protected override void Given()
{
_queue = CreateSuccessfulTestQueue("TestQueue", ExceptionOnFirstCall());
Queues.Add(_queue);
SerializationRegister.DefaultDeserializedMessage =
() => throw new TestException("Test from WhenThereAreExceptionsInMessageProcessing");
}
protected override void Given()
{
base.Given();
_futureHandler1 = () => _handler1;
_futureHandler2 = () => _handler2;
_queue = Substitute.For <ISqsQueue>();
_handler1 = Substitute.For <IHandlerAsync <Message> >();
_handler2 = Substitute.For <IHandlerAsync <Message2> >();
}
/// <summary>
/// Adds an <see cref="ISqsQueue"/> to be consumed by this <see cref="ISubscriptionGroup"/>.
/// </summary>
/// <param name="sqsQueue">The queue to be consumed, assumed to already be created and ready.</param>
/// <returns>This builder object.</returns>
public SubscriptionGroupConfigBuilder AddQueue(ISqsQueue sqsQueue)
{
if (sqsQueue == null)
{
throw new ArgumentNullException(nameof(sqsQueue));
}
_sqsQueues.Add(sqsQueue);
return(this);
}
protected override void Given()
{
Handler = new ExactlyOnceHandler();
_queue = CreateSuccessfulTestQueue("TestQueue", new TestMessage());
Queues.Add(_queue);
MessageLock = new FakeMessageLock();
}
private void GivenInternal()
{
SqsClient = Substitute.For <IAmazonSQS>();
Queue = Substitute.For <ISqsQueue>();
Queue.Uri.Returns(new Uri("http://test.com"));
Queue.Client.Returns(SqsClient);
Monitor = Substitute.For <IMessageMonitor>();
SqsMiddleware = new DelegateMiddleware <GetMessagesContext, IList <Amazon.SQS.Model.Message> >();
Given();
}
protected override void Given()
{
base.Given();
_handler1 = Substitute.For <IHandlerAsync <Message> >();
_handler2 = Substitute.For <IHandlerAsync <Message2> >();
_futureHandler1 = new DelegateMessageHandlingMiddleware <Message>(m => _handler1.Handle(m));
_futureHandler2 = new DelegateMessageHandlingMiddleware <Message2>(m => _handler2.Handle(m));
_queue = Substitute.For <ISqsQueue>();
}
protected override void Given()
{
_queue = CreateSuccessfulTestQueue(Guid.NewGuid().ToString(), new TestMessage());
Queues.Add(_queue);
MessageLock = new FakeMessageLock();
_handler = new ExactlyOnceSignallingHandler();
Handler = _handler;
}
private async Task ApplyTagsAsync(ISqsQueue queue, Dictionary <string, string> tags, CancellationToken cancellationToken)
{
if (tags == null || !tags.Any())
{
return;
}
await queue.TagQueueAsync(queue.Uri.ToString(), tags, cancellationToken).ConfigureAwait(false);
Logger.LogInformation("Added {TagCount} tags to queue {QueueName}",
tags.Count, QueueName);
}
private IMessageReceiveBuffer CreateMessageReceiveBuffer(
ISqsQueue sqsQueue,
int bufferSize = 10)
{
return(new MessageReceiveBuffer(
10,
bufferSize,
TimeSpan.FromSeconds(1),
TimeSpan.FromSeconds(1),
sqsQueue,
new DelegateMiddleware <GetMessagesContext, IList <Message> >(),
Substitute.For <IMessageMonitor>(),
LoggerFactory.CreateLogger <MessageReceiveBuffer>()));
}
protected override void Given()
{
_queue = CreateSuccessfulTestQueue("TestQueue", async() => await ExceptionOnFirstCall());
_queue
.RegionSystemName
.Returns("RegionSystemName");
Queues.Add(_queue);
Handler.Handle(null).ReturnsForAnyArgs(true);
SerializationRegister
.DeserializeMessage(Arg.Any <string>())
.Returns(x => throw new TestException("Test from WhenThereAreExceptionsInMessageProcessing"));
}
public async Task Add_Different_Handler_Per_Queue()
{
// Arrange
string group1 = "group1";
string group2 = "group2";
string queueName1 = "queue1";
string queueName2 = "queue2";
JustSaying.JustSayingBus bus = CreateBus();
var handler1 = new InspectableHandler <TestJustSayingMessage>();
var handler2 = new InspectableHandler <TestJustSayingMessage>();
bus.AddMessageHandler(queueName1, () => handler1);
bus.AddMessageHandler(queueName2, () => handler2);
ISqsQueue queue1 = TestQueue(bus.SerializationRegister, queueName1);
ISqsQueue queue2 = TestQueue(bus.SerializationRegister, queueName2);
bus.AddQueue(group1, queue1);
bus.AddQueue(group2, queue2);
using var cts = new CancellationTokenSource();
// Act
await bus.StartAsync(cts.Token);
await Patiently.AssertThatAsync(_outputHelper,
() =>
{
handler1.ReceivedMessages.Count.ShouldBeGreaterThan(0);
handler2.ReceivedMessages.Count.ShouldBeGreaterThan(0);
});
cts.Cancel();
await bus.Completion;
foreach (var message in handler1.ReceivedMessages)
{
message.QueueName.ShouldBe(queueName1);
}
foreach (var message in handler2.ReceivedMessages)
{
message.QueueName.ShouldBe(queueName2);
}
bus.Dispose();
}
private IMessageReceiveBuffer CreateMessageReceiveBuffer(
ISqsQueue sqsQueue,
int prefetch = 10,
int receiveBufferSize = 10)
{
return(new MessageReceiveBuffer(
prefetch,
receiveBufferSize,
TimeSpan.FromSeconds(1),
TimeSpan.FromSeconds(1),
sqsQueue,
new DelegateMiddleware <ReceiveMessagesContext, IList <Message> >(),
MessageMonitor,
LoggerFactory.CreateLogger <MessageReceiveBuffer>()));
}
protected override void Given()
{
int retryCount = 1;
_client = Substitute.For <IAmazonSQS>();
var response = GenerateResponseMessage(MessageTypeString, Guid.NewGuid());
_client.ReceiveMessageAsync(
Arg.Any <ReceiveMessageRequest>(),
Arg.Any <CancellationToken>())
.Returns(
x => Task.FromResult(response),
x => Task.FromResult(new ReceiveMessageResponse()));
_client.GetQueueUrlAsync(Arg.Any <string>())
.Returns(x =>
{
if (x.Arg <string>() == "some-queue-name")
{
return new GetQueueUrlResponse
{
QueueUrl = "https://testqueues.com/some-queue-name"
}
}
;
throw new QueueDoesNotExistException("some-queue-name not found");
});
_client.GetQueueAttributesAsync(Arg.Any <GetQueueAttributesRequest>())
.Returns(new GetQueueAttributesResponse()
{
Attributes = new Dictionary <string, string> {
{ "QueueArn", "something:some-queue-name" }
}
});
var queue = new SqsQueueByName(RegionEndpoint.EUWest1, "some-queue-name", _client, retryCount, LoggerFactory);
queue.ExistsAsync().Wait();
_queue = queue;
Queues.Add(_queue);
Handler.Handle(null)
.ReturnsForAnyArgs(true).AndDoes(ci => Interlocked.Increment(ref _callCount));
}
private async Task ApplyTagsAsync(ISqsQueue queue, Dictionary <string, string> tags)
{
if (tags is null || !tags.Any())
{
return;
}
var tagRequest = new TagQueueRequest
{
QueueUrl = queue.Uri.ToString(),
Tags = tags
};
await queue.Client.TagQueueAsync(tagRequest).ConfigureAwait(false);
Logger.LogInformation("Added {TagCount} tags to queue {QueueName}", tagRequest.Tags.Count, QueueName);
}
public async Task Add_Different_Handler_Per_Queue()
{
// Arrange
string group1 = "group1";
string group2 = "group2";
string region = "region";
string queueName1 = "queue1";
string queueName2 = "queue2";
JustSaying.JustSayingBus bus = CreateBus();
ISqsQueue queue1 = TestQueue(bus.SerializationRegister, queueName1);
ISqsQueue queue2 = TestQueue(bus.SerializationRegister, queueName2);
bus.AddQueue(region, group1, queue1);
bus.AddQueue(region, group2, queue2);
var handledBy1 = new List <TestJustSayingMessage>();
var handledBy2 = new List <TestJustSayingMessage>();
bus.AddMessageHandler(queueName1, () => new TestHandler <TestJustSayingMessage>(x => handledBy1.Add(x)));
bus.AddMessageHandler(queueName2, () => new TestHandler <TestJustSayingMessage>(x => handledBy2.Add(x)));
var cts = new CancellationTokenSource();
cts.CancelAfter(TimeoutPeriod);
// Act
await bus.StartAsync(cts.Token);
await cts.Token.WaitForCancellation();
// Assert
handledBy1.Count.ShouldBeGreaterThan(0);
foreach (var message in handledBy1)
{
message.QueueName.ShouldBe(queueName1);
}
handledBy2.Count.ShouldBeGreaterThan(0);
foreach (var message in handledBy2)
{
message.QueueName.ShouldBe(queueName2);
}
}
public void AddQueue(string subscriptionGroup, ISqsQueue queue)
{
if (string.IsNullOrWhiteSpace(subscriptionGroup))
{
throw new ArgumentException("Cannot be null or empty.", nameof(subscriptionGroup));
}
if (queue == null)
{
throw new ArgumentNullException(nameof(queue));
}
SubscriptionGroupConfigBuilder builder = _subscriptionGroupSettings.GetOrAdd(
subscriptionGroup,
_ => new SubscriptionGroupConfigBuilder(subscriptionGroup));
builder.AddQueue(queue);
}
protected override void Given()
{
ConcurrencyLimit = 1;
_queue = CreateSuccessfulTestQueue("TestQueue", () =>
{
Interlocked.Increment(ref _callCount);
return(new List <Message> {
new TestMessage()
});
});
Queues.Add(_queue);
Handler.Handle(null).ReturnsForAnyArgs(true);
SerializationRegister
.DeserializeMessage(Arg.Any <string>())
.Returns(x => throw new TestException("Test from WhenThereAreExceptionsInMessageProcessing"));
}
protected override void Given()
{
base.Given();
_client1 = CreateSubstituteClient();
_client2 = CreateSubstituteClient();
_queue1 = Substitute.For <ISqsQueue>();
_queue1.QueueName.Returns("queue1");
_queue1.Uri.Returns(new Uri("http://test.com"));
_queue1.Client.Returns(_client1);
_queue2 = Substitute.For <ISqsQueue>();
_queue2.QueueName.Returns("queue2");
_queue2.Uri.Returns(new Uri("http://test.com"));
_queue2.Client.Returns(_client2);
}
protected override void Given()
{
_queue = CreateSuccessfulTestQueue("TestQueue", new TestMessage());
Queues.Add(_queue);
var messageLockResponse = new MessageLockResponse
{
DoIHaveExclusiveLock = true
};
MessageLock = Substitute.For <IMessageLockAsync>();
MessageLock.TryAquireLockAsync(Arg.Any <string>(), Arg.Any <TimeSpan>())
.Returns(messageLockResponse);
_handler = new ExplicitExactlyOnceSignallingHandler(_tcs);
Handler = _handler;
}
private static ISqsQueue TestQueue(
IMessageSerializationRegister messageSerializationRegister,
string queueName,
Action spy = null)
{
async Task <ReceiveMessageResponse> GetMessages()
{
spy?.Invoke();
await Task.Delay(30);
var message = new TestJustSayingMessage
{
QueueName = queueName,
};
var messages = new List <Message>
{
new TestMessage {
Body = messageSerializationRegister.Serialize(message, false)
},
};
return(new ReceiveMessageResponse {
Messages = messages
});
}
IAmazonSQS sqsClientMock = Substitute.For <IAmazonSQS>();
sqsClientMock
.ReceiveMessageAsync(Arg.Any <ReceiveMessageRequest>(), Arg.Any <CancellationToken>())
.Returns(_ => GetMessages());
ISqsQueue sqsQueueMock = Substitute.For <ISqsQueue>();
sqsQueueMock.Uri.Returns(new Uri("http://test.com"));
sqsQueueMock.Client.Returns(sqsClientMock);
sqsQueueMock.QueueName.Returns(queueName);
sqsQueueMock.Uri.Returns(new Uri("http://foo.com"));
return(sqsQueueMock);
}
protected override void Given()
{
ConcurrencyLimit = 1;
_queue = CreateSuccessfulTestQueue("TestQueue",
EnumerableExtensions.GenerateInfinite(() =>
{
Interlocked.Increment(ref _callCount);
return(new ReceiveMessageResponse()
{
Messages = new List <Message> {
new TestMessage()
}
});
}));
Queues.Add(_queue);
SerializationRegister.DefaultDeserializedMessage = () =>
throw new TestException("Test from WhenThereAreExceptionsInMessageProcessing");
}
protected override void Given()
{
ConcurrencyLimit = 1;
IEnumerable <Message> GetMessages(CancellationToken cancellationToken)
{
while (!cancellationToken.IsCancellationRequested)
{
Interlocked.Increment(ref _callCount);
yield return(new TestMessage());
}
}
_queue = CreateSuccessfulTestQueue("TestQueue", ct => Task.FromResult(GetMessages(ct)));
Queues.Add(_queue);
SerializationRegister.DefaultDeserializedMessage = () =>
throw new TestException("Test from WhenThereAreExceptionsInMessageProcessing");
}
private static ISqsQueue TestQueue(Func <Task <List <Message> > > getMessages)
{
ISqsQueue sqsQueueMock = Substitute.For <ISqsQueue>();
sqsQueueMock.Uri.Returns(new Uri("http://test.com"));
sqsQueueMock
.Client
.ReceiveMessageAsync(Arg.Any <ReceiveMessageRequest>(), Arg.Any <CancellationToken>())
.Returns(async _ =>
{
List <Message> messages = await getMessages();
return(new ReceiveMessageResponse
{
Messages = messages,
});
});
return(sqsQueueMock);
}
private static ISqsQueue TestQueue(Action spy = null)
{
async Task <ReceiveMessageResponse> GetMessages()
{
await Task.Delay(TimeSpan.FromMilliseconds(5)).ConfigureAwait(false);
spy?.Invoke();
throw new InvalidOperationException();
}
ISqsQueue sqsQueueMock = Substitute.For <ISqsQueue>();
sqsQueueMock.Uri.Returns(new Uri("http://test.com"));
sqsQueueMock
.Client
.ReceiveMessageAsync(Arg.Any <ReceiveMessageRequest>(), Arg.Any <CancellationToken>())
.Returns(async _ => await GetMessages());
return(sqsQueueMock);
}
protected override void Given()
{
_queue = CreateSuccessfulTestQueue(Guid.NewGuid().ToString(), new TestMessage());
Queues.Add(_queue);
_messageLock = new FakeMessageLock();
var serviceResolver = new InMemoryServiceResolver(sc =>
sc.AddSingleton <IMessageLockAsync>(_messageLock)
.AddSingleton <IHandlerAsync <SimpleMessage> >(Handler)
.AddLogging(x => x.AddXUnit(OutputHelper)));
var middlewareBuilder = new HandlerMiddlewareBuilder(serviceResolver, serviceResolver);
var middleware = middlewareBuilder.Configure(pipe =>
{
pipe.UseExactlyOnce <SimpleMessage>("a-unique-lock-key");
pipe.UseHandler <SimpleMessage>();
}).Build();
Middleware = middleware;
}
protected override void Given()
{
int retryCount = 1;
_client = new FakeAmazonSqs(() =>
{
return(new[] { GenerateResponseMessages(MessageTypeString, Guid.NewGuid()) }
.Concat(new ReceiveMessageResponse().Infinite()));
});
var queue = new SqsQueueByName(RegionEndpoint.EUWest1,
"some-queue-name",
_client,
retryCount,
LoggerFactory);
queue.ExistsAsync().Wait();
_queue = queue;
Queues.Add(_queue);
}
