/// <inheritdoc cref="IOutboxReader.AcknowledgeAsync(OutboxStoredMessage)" />
public async Task AcknowledgeAsync(OutboxStoredMessage outboxMessage)
{
if (await RemoveMessageAsync(outboxMessage).ConfigureAwait(false))
{
await DbContext.SaveChangesAsync().ConfigureAwait(false);
}
}
private async Task ProcessMessageAsync(
OutboxStoredMessage message,
IOutboxReader outboxReader,
IServiceProvider serviceProvider)
{
try
{
var endpoint = GetTargetEndpoint(message.MessageType, message.EndpointName, serviceProvider);
await ProduceMessageAsync(message.Content, message.Headers, endpoint).ConfigureAwait(false);
await outboxReader.AcknowledgeAsync(message).ConfigureAwait(false);
}
catch (Exception ex)
{
_logger.LogErrorWithMessageInfo(
IntegrationEventIds.ErrorProducingOutboxStoredMessage,
ex,
"Failed to produce the message in the outbox.",
new OutboundEnvelope(message.Content, message.Headers, new LoggingEndpoint(message.EndpointName)));
await outboxReader.RetryAsync(message).ConfigureAwait(false);
// Rethrow if message order has to be preserved, otherwise go ahead with next message in the queue
if (_enforceMessageOrder)
{
throw;
}
}
}
private async Task ProcessMessageAsync(
OutboxStoredMessage message,
ConcurrentBag <OutboxStoredMessage> failedMessages,
IOutboxReader outboxReader,
IServiceProvider serviceProvider)
{
try
{
var endpoint = GetTargetEndpoint(message.MessageType, message.EndpointName, serviceProvider);
await ProduceMessageAsync(
message.Content,
message.Headers,
endpoint,
message.ActualEndpointName ?? endpoint.Name,
_ =>
{
Interlocked.Decrement(ref _pendingProduceOperations);
},
exception =>
{
failedMessages.Add(message);
Interlocked.Decrement(ref _pendingProduceOperations);
_logger.LogErrorProducingOutboxStoredMessage(
new OutboundEnvelope(
message.Content,
message.Headers,
new LoggingEndpoint(message.EndpointName)),
exception);
})
.ConfigureAwait(false);
}
catch (Exception ex)
{
failedMessages.Add(message);
Interlocked.Decrement(ref _pendingProduceOperations);
_logger.LogErrorProducingOutboxStoredMessage(
new OutboundEnvelope(
message.Content,
message.Headers,
new LoggingEndpoint(message.EndpointName)),
ex);
await outboxReader.RetryAsync(message).ConfigureAwait(false);
// Rethrow if message order has to be preserved, otherwise go ahead with next message in the queue
if (_enforceMessageOrder)
{
throw;
}
}
}
private async Task <bool> RemoveMessageAsync(OutboxStoredMessage outboxMessage)
{
if (outboxMessage is not DbOutboxStoredMessage dbOutboxMessage)
{
throw new InvalidOperationException("A DbOutboxStoredMessage is expected.");
}
var entity = await DbSet.FindAsync(dbOutboxMessage.Id).ConfigureAwait(false);
if (entity == null)
{
return(false);
}
DbSet.Remove(entity);
return(true);
}
/// <inheritdoc cref="IOutboxReader.AcknowledgeAsync" />
public async Task AcknowledgeAsync(OutboxStoredMessage outboxMessage)
{
if (!(outboxMessage is DbOutboxStoredMessage dbOutboxMessage))
{
throw new InvalidOperationException("A DbOutboxStoredMessage is expected.");
}
var entity = await DbSet.FindAsync(dbOutboxMessage.Id).ConfigureAwait(false);
if (entity == null)
{
return;
}
DbSet.Remove(entity);
await DbContext.SaveChangesAsync().ConfigureAwait(false);
}
/// <inheritdoc cref="IOutboxReader.RetryAsync(OutboxStoredMessage)" />
public Task RetryAsync(OutboxStoredMessage outboxMessage)
{
// Nothing to do, the message is retried if not acknowledged
return(Task.CompletedTask);
}
public Task RetryAsync(OutboxStoredMessage outboxMessage) => throw new NotSupportedException();
public Task AcknowledgeAsync(OutboxStoredMessage outboxMessage) => Task.CompletedTask;