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); } } }
async Task InnerReceive(MessageRetrieved retrieved) { try { var message = await retrieved.Unwrap().ConfigureAwait(false); addressing.ApplyMappingToAliases(message.Headers); await receiveStrategy.Receive(retrieved, message).ConfigureAwait(false); } catch (LeaseTimeoutException ex) { Logger.Warn("Dispatching the message took longer than a visibility timeout. The message will reappear in the queue and will be obtained again.", ex); } catch (SerializationException ex) { Logger.Warn(ex.Message, ex); } catch (Exception ex) { Logger.Warn("Azure Storage Queue transport failed pushing a message through pipeline", ex); } finally { concurrencyLimiter.Release(); } }
async Task ProcessMessageSwallowExceptionsAndReleaseConcurrencyLimiter(MessageRetrieved retrieved, CancellationToken processingCancellationToken) { try { var message = await retrieved.Unwrap(processingCancellationToken).ConfigureAwait(false); if (Logger.IsDebugEnabled) { Logger.DebugFormat("Unwrapped message ID: '{0}'", message.Id); } await receiveStrategy.Receive(retrieved, message, processingCancellationToken).ConfigureAwait(false); } catch (Exception ex) when(ex.IsCausedBy(processingCancellationToken)) { Logger.Debug("Message receiving canceled.", ex); } catch (LeaseTimeoutException ex) { Logger.Warn("Dispatching the message took longer than a visibility timeout. The message will reappear in the queue and will be obtained again.", ex); } catch (SerializationException ex) { Logger.Error(ex.Message, ex); } catch (Exception ex) { Logger.Warn("Azure Storage Queue transport failed pushing a message through pipeline", ex); } finally { concurrencyLimiter.Release(); } }
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); } } } }
public override async Task Receive(MessageRetrieved retrieved, MessageWrapper message) { await retrieved.Ack().ConfigureAwait(false); var body = message.Body ?? new byte[0]; try { var pushContext = new MessageContext(message.Id, new Dictionary <string, string>(message.Headers), body, new TransportTransaction(), new CancellationTokenSource(), new ContextBag()); await pipeline(pushContext).ConfigureAwait(false); } catch (Exception ex) { Logger.Warn("Azure Storage Queue transport failed pushing a message through pipeline", ex); var context = CreateErrorContext(retrieved, message, ex, body); // The exception is pushed through the error pipeline in a fire and forget manner. // There's no call to onCriticalError if errorPipe fails. Exceptions are handled on the transport level. await errorPipe(context).ConfigureAwait(false); } }
public abstract Task Receive(MessageRetrieved retrieved, MessageWrapper message);
protected static ErrorContext CreateErrorContext(MessageRetrieved retrieved, MessageWrapper message, Exception ex, byte[] body) { var context = new ErrorContext(ex, message.Headers, message.Id, body, new TransportTransaction(), retrieved.DequeueCount); return(context); }
public abstract Task Receive(MessageRetrieved retrieved, MessageWrapper message, CancellationToken cancellationToken = default);