public async Task DeadLetter()
{
var headers = new Dictionary <string, object> {
{ MessageHeaders.Reason, "dead-letter" }
};
await _receiverClient.DeadLetterAsync(_message.SystemProperties.LockToken, headers).ConfigureAwait(false);
_deadLettered = true;
}
private async Task InvokeMessageHandlers(IReceiverClient receiver, ApolloQueue queue, ServiceBusMessage message, CancellationToken?token)
{
if (message == null)
{
return;
}
if (Handlers.TryGetValue(queue, out var handlers))
{
var status = MessageStatus.Unhandled;
foreach (var handler in handlers.Where(h => h.PassesFilter(message)))
{
try
{
if (token?.IsCancellationRequested ?? false)
{
return;
}
status = handler.HandleMessage(queue, message, token);
if (status.HasFlag(MessageStatus.Handled))
{
break;
}
}
catch (Exception ex)
{
Logger.Error($"Encountered an error in {handler.OnMessageReceived.Method.DeclaringType?.Name ?? "<Unknown>"}.{handler.OnMessageReceived.Method.Name} while handling a message labelled {message.Label}", ex);
}
}
if (status.HasFlag(MessageStatus.MarkedForDeletion))
{
await receiver.CompleteAsync(message.InnerMessage.SystemProperties.LockToken);
}
else if (string.IsNullOrWhiteSpace(message.ResponseTo))
{
await receiver.DeadLetterAsync(message.InnerMessage.SystemProperties.LockToken, $"{State[ApolloConstants.RegisteredAsKey]} does not have a plugin which can handle this message");
}
else
{
await receiver.DeadLetterAsync(message.InnerMessage.SystemProperties.LockToken, $"{State[ApolloConstants.RegisteredAsKey]} is not expecting or longer waiting for this response");
}
}
else
{
Logger.Error($"Received a message on queue {queue} without having any handlers registered for that queue! (This should not be possible and implies that something has gone wrong)");
}
}
private async Task OnMessageReceived(Message message, CancellationToken cancellation)
{
if (_pendingRequests.TryGetValue(message.CorrelationId, out TaskCompletionSource <Message> tcs))
{
tcs.TrySetResult(message);
}
else
{
await _receiver.DeadLetterAsync(message.SystemProperties.LockToken);
}
}
public static async Task SafeDeadLetterAsync(this Message message, string subscription, IReceiverClient session, string reason, string description, Action <bool> callback, ILogger logger, Stopwatch roundtripStopwatch)
{
await SafeMessagingActionAsync(
session.DeadLetterAsync(message.SystemProperties.LockToken),
message,
callback,
"An error occurred while dead-lettering message {0} in subscription {1} with processing time {3} (scheduling {4} request {5} roundtrip {6}). Error message: {2}",
message.MessageId,
subscription,
logger,
roundtripStopwatch);
}
public async Task When_DeadLetter_Message_Delegate_LockToken_To_ReceiverClient_DeadLetterAsync()
{
//Dummy message
var message = CreateFakeMessage();
await _sut.OpenAsync(CancellationToken.None);
await _sut.DeadLetter(message);
A.CallTo(() =>
_receiverClient.DeadLetterAsync(message.SystemProperties.LockToken,
A <IDictionary <string, object> > ._))
.MustHaveHappenedOnceExactly();
}
public async Task DeadLetterAsync(QueueMessage message, string reason, string errorDescription, CancellationToken cancellationToken = default)
{
if (_autoComplete)
{
return;
}
if (!_messageIdToBrokeredMessage.TryRemove(message.Id, out Message bm))
{
return;
}
await _receiverClient.DeadLetterAsync(bm.MessageId).ConfigureAwait(false);
}
public async Task RejectAsync(bool requeue = false)
{
try
{
if (requeue)
{
await _receiverClient.AbandonAsync(_message.SystemProperties.LockToken);
}
else
{
await _receiverClient.DeadLetterAsync(_message.SystemProperties.LockToken);
}
}
catch (Exception ex)
{
throw new MessageException("Failed to reject the message.", ex);
}
}
private static async Task <T> GetMessageBodyAsync <T>(IReceiverClient client)
{
string body = null;
client.RegisterMessageHandler(async(msg, token) =>
{
Message message = msg;
if (message != null)
{
body = Encoding.UTF8.GetString(message.Body);
if (body.Contains("spoiled", StringComparison.OrdinalIgnoreCase))
{
await client.DeadLetterAsync(msg.SystemProperties.LockToken);
}
else
{
await client.CompleteAsync(msg.SystemProperties.LockToken);
}
}
}, new MessageHandlerOptions(ExceptionReceivedHandler)
{
MaxConcurrentCalls = 1,
AutoComplete = false
});
await client.UnregisterMessageHandlerAsync(TimeSpan.FromMilliseconds(2000));
await client.CloseAsync();
if (body != null)
{
return(JsonSerializer.Deserialize <T>(body));
}
return(default);
public virtual async Task AddToDeadLetterQueue(Message message)
{
await receiver.DeadLetterAsync(message.SystemProperties.LockToken);
}
public static Task DeadLetterByDeliveryLimitAsync(this Message message, IReceiverClient client, int deliveryLimit)
{
return(client.DeadLetterAsync(message.SystemProperties.LockToken, "MaxDeliveryCountExceeded", $"DeliveryCount exceeded limit of {deliveryLimit}"));
}