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