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); }