private async Task <bool> TryInvokeMessageHandlerAsync(IQueueMessage message)
{
try
{
if (_messageHandler != null)
{
await _messageHandler(message, CancellationToken.None);
return(true);
}
}
catch (Exception ex)
{
var exceptionReceivedHandler = _messageHandlerOptions?.ExceptionReceivedHandler;
if (exceptionReceivedHandler != null)
{
var context = new MessageHandlerExceptionContext(ex);
await exceptionReceivedHandler(context);
}
}
return(false);
}
private static Func <ExceptionReceivedEventArgs, Task> GetExceptionReceivedHandler(
MessageHandlerOptions options)
{
if (options?.ExceptionReceivedHandler == null)
{
return(_ => Task.CompletedTask);
}
Task ExceptionReceivedHandler(ExceptionReceivedEventArgs args)
{
var context = new MessageHandlerExceptionContext(args.Exception);
return(options.ExceptionReceivedHandler(new MessageHandlerExceptionContext(args.Exception)));
}
return(ExceptionReceivedHandler);
}
private async Task OnMessageReceivedAsync(
Func <IMessage, CancellationToken, Task> messageHandler,
MessageHandlerOptions messageHandlerOptions,
BasicDeliverEventArgs eventArgs)
{
var cancellationToken = CancellationToken.None;
var message = new RabbitMQMessage(
eventArgs.Body,
eventArgs.DeliveryTag,
eventArgs.BasicProperties);
try
{
await messageHandler(message, cancellationToken);
if (messageHandlerOptions.AutoComplete)
{
await CompleteAsync(message, cancellationToken);
}
}
catch (Exception ex)
{
try
{
var exceptionHandler = messageHandlerOptions?.ExceptionReceivedHandler;
if (exceptionHandler != null)
{
var context = new MessageHandlerExceptionContext(ex);
await exceptionHandler(context);
}
}
catch
{
}
await AbandonAsync(message, cancellationToken);
}
}
private async Task MessagePumpTaskAsync()
{
while (!_cancellationToken.IsCancellationRequested)
{
IQueueMessage message = null;
var pollingRetryCount = 0;
try
{
await _semaphore.WaitAsync(_cancellationToken).ConfigureAwait(false);
message = await _queueClient.MessageReceiver(_cancellationToken).ConfigureAwait(false);
if (message != null)
{
pollingRetryCount = 0;
Task.Run(async() =>
{
try
{
await _onMessageCallback(message, _cancellationToken).ConfigureAwait(false);
if (_messageHandlerOptions.AutoComplete)
{
await _queueClient.CompleteAsync(message, _cancellationToken).ConfigureAwait(false);
}
}
catch (Exception ex)
{
try
{
var exceptionHandler = _messageHandlerOptions?.ExceptionReceivedHandler;
if (exceptionHandler != null)
{
var context = new MessageHandlerExceptionContext(ex);
await exceptionHandler(context).ConfigureAwait(false);
}
}
catch
{
}
await _queueClient.AbandonAsync(message, _cancellationToken).ConfigureAwait(false);
throw;
}
})
.Ignore();
}
else
{
// Back off from polling when there are no messages in the queue.
var interval = _retryStrategy.GetRetryInterval(++pollingRetryCount);
await Task.Delay(interval);
}
}
finally
{
if (message == null)
{
_semaphore.Release();
}
}
}
}
