public override async Task Receive(MessageRetrieved retrieved, MessageWrapper message)
{
var body = message.Body ?? new byte[0];
try
{
using (var tokenSource = new CancellationTokenSource())
{
var pushContext = new MessageContext(message.Id, new Dictionary <string, string>(message.Headers), body, new TransportTransaction(), tokenSource, new ContextBag());
await pipeline(pushContext).ConfigureAwait(false);
if (tokenSource.IsCancellationRequested)
{
// if the pipeline cancelled the execution, nack the message to go back to the queue
await retrieved.Nack().ConfigureAwait(false);
}
else
{
// the pipeline hasn't been cancelled, the message should be acked
await retrieved.Ack().ConfigureAwait(false);
}
}
}
catch (LeaseTimeoutException)
{
// The lease has expired and cannot be used any longer to Ack or Nack the message.
// see original issue: https://github.com/Azure/azure-storage-net/issues/285
throw;
}
catch (Exception ex)
{
var context = CreateErrorContext(retrieved, message, ex, body);
ErrorHandleResult immediateRetry;
try
{
immediateRetry = await errorPipe(context).ConfigureAwait(false);
}
catch (Exception e)
{
Logger.Warn("The error pipeline wasn't able to handle the exception.", e);
await retrieved.Nack().ConfigureAwait(false);
return;
}
if (immediateRetry == ErrorHandleResult.RetryRequired)
{
// For an immediate retry, the error is logged and the message is returned to the queue to preserve the DequeueCount.
// There is no in memory retry as scale-out scenarios would be handled improperly.
Logger.Warn("Azure Storage Queue transport failed pushing a message through pipeline. The message will be requeued", ex);
await retrieved.Nack().ConfigureAwait(false);
}
else
{
// Just acknowledge the message as it's handled by the core retry.
await retrieved.Ack().ConfigureAwait(false);
}
}
}
public override async Task Receive(MessageRetrieved retrieved, MessageWrapper message, CancellationToken cancellationToken = default)
{
Logger.DebugFormat("Pushing received message (ID: '{0}') through pipeline.", message.Id);
var body = message.Body ?? new byte[0];
var contextBag = new ContextBag();
try
{
var pushContext = new MessageContext(message.Id, new Dictionary <string, string>(message.Headers), body, new TransportTransaction(), contextBag);
await onMessage(pushContext, cancellationToken).ConfigureAwait(false);
await retrieved.Ack(cancellationToken).ConfigureAwait(false);
}
catch (LeaseTimeoutException)
{
// The lease has expired and cannot be used any longer to Ack or Nack the message.
// see original issue: https://github.com/Azure/azure-storage-net/issues/285
throw;
}
catch (Exception ex) when(!ex.IsCausedBy(cancellationToken))
{
var context = CreateErrorContext(retrieved, message, ex, body, contextBag);
try
{
var errorHandleResult = await onError(context, cancellationToken).ConfigureAwait(false);
if (errorHandleResult == ErrorHandleResult.RetryRequired)
{
// For an immediate retry, the error is logged and the message is returned to the queue to preserve the DequeueCount.
// There is no in memory retry as scale-out scenarios would be handled improperly.
Logger.Warn("Azure Storage Queue transport failed pushing a message through pipeline. The message will be requeued", ex);
await retrieved.Nack(cancellationToken).ConfigureAwait(false);
}
else
{
// Just acknowledge the message as it's handled by the core retry.
await retrieved.Ack(cancellationToken).ConfigureAwait(false);
}
}
catch (Exception onErrorEx) when(!onErrorEx.IsCausedBy(cancellationToken))
{
criticalErrorAction($"Failed to execute recoverability policy for message with native ID: `{message.Id}`", onErrorEx, cancellationToken);
try
{
await retrieved.Nack(cancellationToken).ConfigureAwait(false);
}
catch (Exception nackEx) when(!nackEx.IsCausedBy(cancellationToken))
{
Logger.Warn($"Failed to release visibility timeout after message with native ID `{message.Id}` failed to execute recoverability policy. The message will be available again when the visibility timeout expires.", nackEx);
}
}
}
}