/// <summary> /// Creates a <see cref="T:Microsoft.Azure.WebJobs.Host.Queues.QueueProcessor" /> using the specified options. /// </summary> /// <param name="queueProcessorOptions">The <see cref="T:Microsoft.Azure.WebJobs.Host.Queues.QueueProcessorOptions" /> to use.</param> /// <returns> /// A <see cref="T:Microsoft.Azure.WebJobs.Host.Queues.QueueProcessor" /> instance. /// </returns> public QueueProcessor Create(QueueProcessorOptions queueProcessorOptions) { queueProcessorOptions.Options.MaxDequeueCount = 5; queueProcessorOptions.Options.VisibilityTimeout = TimeSpan.FromSeconds(5); return(new CustomQueueProcessor(queueProcessorOptions)); }
public QueueProcessor Create(QueueProcessorOptions queueProcessorOptions) { QueuesOptions overrideOptions = null; switch (queueProcessorOptions.Queue.Name) { case QueueName1: ActualQueuesOptions1 = queueProcessorOptions.Options; // defaults break; case QueueName2: ActualQueuesOptions2 = queueProcessorOptions.Options; overrideOptions = ExpectedQueuesOptions2; break; case QueueName3: ActualQueuesOptions3 = queueProcessorOptions.Options; overrideOptions = ExpectedQueuesOptions3; break; } if (overrideOptions != null) { queueProcessorOptions.Options.BatchSize = overrideOptions.BatchSize; queueProcessorOptions.Options.MaxDequeueCount = overrideOptions.MaxDequeueCount; queueProcessorOptions.Options.MaxPollingInterval = overrideOptions.MaxPollingInterval; queueProcessorOptions.Options.MessageEncoding = overrideOptions.MessageEncoding; queueProcessorOptions.Options.NewBatchThreshold = overrideOptions.NewBatchThreshold; queueProcessorOptions.Options.VisibilityTimeout = overrideOptions.VisibilityTimeout; } return(new QueueProcessor(queueProcessorOptions)); }
public void SetUp() { _mockQueue = new Mock <QueueClient>(new Uri("https://test.queue.core.windows.net/testqueue"), null); _mockQueue.Setup(x => x.Name).Returns("testqueue"); _mockTriggerExecutor = new Mock <ITriggerExecutor <QueueMessage> >(MockBehavior.Strict); Mock <IWebJobsExceptionHandler> mockExceptionDispatcher = new Mock <IWebJobsExceptionHandler>(MockBehavior.Strict); _loggerFactory = new LoggerFactory(); _loggerProvider = new TestLoggerProvider(); _loggerFactory.AddProvider(_loggerProvider); QueuesOptions queuesOptions = new QueuesOptions(); QueueProcessorOptions context = new QueueProcessorOptions(_mockQueue.Object, _loggerFactory, queuesOptions); _mockQueueProcessor = new Mock <QueueProcessor>(MockBehavior.Strict, context); QueuesOptions queueConfig = new QueuesOptions { MaxDequeueCount = 5 }; _listener = new QueueListener(_mockQueue.Object, null, _mockTriggerExecutor.Object, mockExceptionDispatcher.Object, _loggerFactory, null, queueConfig, _mockQueueProcessor.Object, new FunctionDescriptor { Id = "TestFunction" }); _queueMessage = QueuesModelFactory.QueueMessage("TestId", "TestPopReceipt", "TestMessage", 0); }
public async Task CompleteProcessingMessageAsync_Failure_AppliesVisibilityTimeout() { var queuesOptions = new QueuesOptions { // configure a non-zero visibility timeout VisibilityTimeout = TimeSpan.FromMinutes(5) }; Mock <QueueClient> queueClientMock = new Mock <QueueClient>(); TimeSpan updatedVisibilityTimeout = TimeSpan.Zero; queueClientMock.Setup(x => x.UpdateMessageAsync(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <TimeSpan>(), It.IsAny <CancellationToken>())) .Callback((string messageId, string popReceipt, string messageText, TimeSpan visibilityTimeout, CancellationToken cancellationToken) => { updatedVisibilityTimeout = visibilityTimeout; }) .ReturnsAsync(Response.FromValue(QueuesModelFactory.UpdateReceipt("x", DateTimeOffset.UtcNow.AddMinutes(5)), null)); QueueProcessorOptions context = new QueueProcessorOptions(queueClientMock.Object, null, queuesOptions, _poisonQueue); QueueProcessor localProcessor = new QueueProcessor(context); string messageContent = Guid.NewGuid().ToString(); await _queue.SendMessageAsync(messageContent); var functionResult = new FunctionResult(false); QueueMessage message = (await _queue.ReceiveMessagesAsync(1)).Value.FirstOrDefault(); await localProcessor.CompleteProcessingMessageAsync(message, functionResult, CancellationToken.None); Assert.AreEqual(queuesOptions.VisibilityTimeout, updatedVisibilityTimeout); }
/// <inheritdoc/> public virtual QueueProcessor Create(QueueProcessorOptions context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } return(new QueueProcessor(context)); }
public void SetUp() { _queueServiceClient = _fixture.QueueClient; _queue = _fixture.Queue; _poisonQueue = _fixture.PoisonQueue; _queuesOptions = new QueuesOptions(); QueueProcessorOptions context = new QueueProcessorOptions(_queue, null, _queuesOptions); _processor = new QueueProcessor(context); }
public async Task CompleteProcessingMessageAsync_MaxDequeueCountExceeded_MovesMessageToPoisonQueue() { ILoggerFactory loggerFactory = new LoggerFactory(); var provider = new TestLoggerProvider(); loggerFactory.AddProvider(provider); QueueProcessorOptions context = new QueueProcessorOptions(_queue, loggerFactory, _queuesOptions, _poisonQueue); QueueProcessor localProcessor = new QueueProcessor(context); bool poisonMessageHandlerCalled = false; localProcessor.MessageAddedToPoisonQueueAsync += (sender, e) => { Assert.AreSame(sender, localProcessor); Assert.AreSame(_poisonQueue, e.PoisonQueue); Assert.NotNull(e.Message); poisonMessageHandlerCalled = true; return(Task.CompletedTask); }; string messageContent = Guid.NewGuid().ToString(); QueueMessage message = null; await _queue.SendMessageAsync(messageContent); FunctionResult result = new FunctionResult(false); for (int i = 0; i < context.Options.MaxDequeueCount; i++) { message = (await _queue.ReceiveMessagesAsync(1)).Value.FirstOrDefault(); await localProcessor.CompleteProcessingMessageAsync(message, result, CancellationToken.None); } message = (await _queue.ReceiveMessagesAsync(1)).Value.FirstOrDefault(); Assert.Null(message); QueueMessage poisonMessage = (await _poisonQueue.ReceiveMessagesAsync(1)).Value.FirstOrDefault(); Assert.NotNull(poisonMessage); Assert.AreEqual(messageContent, poisonMessage.MessageText); Assert.True(poisonMessageHandlerCalled); var categories = provider.GetAllLogMessages().Select(p => p.Category); CollectionAssert.Contains(categories, "Microsoft.Azure.WebJobs.Host.Queues.QueueProcessor"); }
public void Constructor_DefaultsValues() { var options = new QueuesOptions { BatchSize = 32, MaxDequeueCount = 2, NewBatchThreshold = 100, VisibilityTimeout = TimeSpan.FromSeconds(30), MaxPollingInterval = TimeSpan.FromSeconds(15) }; QueueProcessorOptions context = new QueueProcessorOptions(_queue, null, options); QueueProcessor localProcessor = new QueueProcessor(context); Assert.AreEqual(options.BatchSize, localProcessor.QueuesOptions.BatchSize); Assert.AreEqual(options.MaxDequeueCount, localProcessor.QueuesOptions.MaxDequeueCount); Assert.AreEqual(options.NewBatchThreshold, localProcessor.QueuesOptions.NewBatchThreshold); Assert.AreEqual(options.VisibilityTimeout, localProcessor.QueuesOptions.VisibilityTimeout); Assert.AreEqual(options.MaxPollingInterval, localProcessor.QueuesOptions.MaxPollingInterval); }
public void Constructor_DefaultsValues() { QueueClient queue = new QueueClient(new Uri("https://test.queue.core.windows.net/testqueue")); QueueClient poisonQueue = new QueueClient(new Uri("https://test.queue.core.windows.net/poisonqueue")); ILoggerFactory loggerFactory = new LoggerFactory(); loggerFactory.AddProvider(new TestLoggerProvider()); QueuesOptions queuesOptions = new QueuesOptions(); QueueProcessorOptions context = new QueueProcessorOptions(queue, loggerFactory, queuesOptions, poisonQueue); Assert.AreSame(queue, context.Queue); Assert.AreSame(poisonQueue, context.PoisonQueue); Assert.NotNull(context.Logger); Assert.AreEqual(queuesOptions.BatchSize, context.Options.BatchSize); Assert.AreEqual(queuesOptions.NewBatchThreshold, context.Options.NewBatchThreshold); Assert.AreEqual(queuesOptions.MaxDequeueCount, context.Options.MaxDequeueCount); Assert.AreEqual(queuesOptions.MaxPollingInterval, context.Options.MaxPollingInterval); }
public async Task BeginProcessingMessageAsync_MaxDequeueCountExceeded_MovesMessageToPoisonQueue() { QueueProcessorOptions context = new QueueProcessorOptions(_queue, null, _queuesOptions, _poisonQueue); QueueProcessor localProcessor = new QueueProcessor(context); bool poisonMessageHandlerCalled = false; localProcessor.MessageAddedToPoisonQueueAsync += (sender, e) => { Assert.AreSame(sender, localProcessor); Assert.AreSame(_poisonQueue, e.PoisonQueue); Assert.NotNull(e.Message); poisonMessageHandlerCalled = true; return(Task.CompletedTask); }; string messageContent = Guid.NewGuid().ToString(); await _queue.SendMessageAsync(messageContent); QueueMessage messageFromCloud = (await _queue.ReceiveMessagesAsync(1)).Value.FirstOrDefault(); for (int i = 0; i < context.Options.MaxDequeueCount; i++) { await _queue.UpdateMessageAsync(messageFromCloud.MessageId, messageFromCloud.PopReceipt, visibilityTimeout : TimeSpan.FromMilliseconds(0)); messageFromCloud = (await _queue.ReceiveMessagesAsync(1)).Value.FirstOrDefault(); } Assert.AreEqual(6, messageFromCloud.DequeueCount); bool continueProcessing = await localProcessor.BeginProcessingMessageAsync(messageFromCloud, CancellationToken.None); Assert.False(continueProcessing); QueueMessage poisonMessage = (await _poisonQueue.ReceiveMessagesAsync(1)).Value.FirstOrDefault(); Assert.NotNull(poisonMessage); Assert.AreEqual(messageContent, poisonMessage.MessageText); Assert.True(poisonMessageHandlerCalled); }
internal static QueueProcessor CreateQueueProcessor(QueueClient queue, QueueClient poisonQueue, ILoggerFactory loggerFactory, IQueueProcessorFactory queueProcessorFactory, QueuesOptions queuesOptions, IMessageEnqueuedWatcher sharedWatcher) { QueueProcessorOptions context = new QueueProcessorOptions(queue, loggerFactory, queuesOptions, poisonQueue); QueueProcessor queueProcessor = null; if (HostQueueNames.IsHostQueue(queue.Name)) { // We only delegate to the processor factory for application queues, // not our built in control queues queueProcessor = new QueueProcessor(context); } else { queueProcessor = queueProcessorFactory.Create(context); } QueueListener.RegisterSharedWatcherWithQueueProcessor(queueProcessor, sharedWatcher); return(queueProcessor); }
public async Task CompleteProcessingMessageAsync_MaxDequeueCountExceeded_MovesMessageToPoisonQueue() { QueueProcessorOptions context = new QueueProcessorOptions(_queue, null, _queuesOptions, _poisonQueue); QueueProcessor localProcessor = new QueueProcessor(context); bool poisonMessageHandlerCalled = false; localProcessor.MessageAddedToPoisonQueue += (sender, e) => { Assert.AreSame(sender, localProcessor); Assert.AreSame(_poisonQueue, e.PoisonQueue); Assert.NotNull(e.Message); poisonMessageHandlerCalled = true; }; string messageContent = Guid.NewGuid().ToString(); QueueMessage message = null; await _queue.SendMessageAsync(messageContent); FunctionResult result = new FunctionResult(false); for (int i = 0; i < context.Options.MaxDequeueCount; i++) { message = (await _queue.ReceiveMessagesAsync(1)).Value.FirstOrDefault(); await localProcessor.CompleteProcessingMessageAsync(message, result, CancellationToken.None); } message = (await _queue.ReceiveMessagesAsync(1)).Value.FirstOrDefault(); Assert.Null(message); QueueMessage poisonMessage = (await _poisonQueue.ReceiveMessagesAsync(1)).Value.FirstOrDefault(); Assert.NotNull(poisonMessage); Assert.AreEqual(messageContent, poisonMessage.MessageText); Assert.True(poisonMessageHandlerCalled); }
public CustomQueueProcessor(QueueProcessorOptions queueProcessorOptions) : base(queueProcessorOptions) { }
public CustomQueueProcess(QueueProcessorOptions options) : base(options) { }
public QueueProcessor Create(QueueProcessorOptions context) { return(new TestQueueProcessor(context)); }
public TestQueueProcessor(QueueProcessorOptions context) : base(context) { }
/// <inheritdoc/> public QueueProcessor Create(QueueProcessorOptions queueProcessorOptions) { queueProcessorOptions.Options.BatchSize = 4; return(new CustomQueueProcess(queueProcessorOptions)); }