public async Task HandleEvent <TEvent>(Envelope <TEvent> @event, IMessageProperties properties = null)
{
var eventHandler = _services.GetService <IEventHandler <TEvent> >();
await eventHandler.Handle(@event, properties);
}
private Task <Acknowledgement> TryHandleAsync <TMessage>(TMessage message, object correlationContext, IMessageProperties messageProperties,
Func <IServiceProvider, TMessage, object, Task> handle)
{
var currentRetry = 0;
var messageName = message.GetMessageName();
var retryPolicy = Policy
.Handle <Exception>()
.WaitAndRetryAsync(_retries, i => TimeSpan.FromSeconds(_retryInterval));
return(retryPolicy.ExecuteAsync <Acknowledgement>(async() =>
{
try
{
var retryMessage = string.Empty;
if (_loggerEnabled)
{
retryMessage = currentRetry == 0
? string.Empty
: $"Retry: {currentRetry}'.";
var preLogMessage = $"Handling a message: '{messageName}' [id: '{messageProperties.MessageId}'] " +
$"with correlation id: '{messageProperties.CorrelationId}'. {retryMessage}";
_logger.LogInformation(preLogMessage);
}
await handle(_serviceProvider, message, correlationContext);
if (_loggerEnabled)
{
var postLogMessage = $"Handled a message: '{messageName}' [id: '{messageProperties.MessageId}'] " +
$"with correlation id: '{messageProperties.CorrelationId}'. {retryMessage}";
_logger.LogInformation(postLogMessage);
}
return new Ack();
}
catch (Exception ex)
{
currentRetry++;
_logger.LogError(ex, ex.Message);
var rejectedEvent = _exceptionToMessageMapper.Map(ex, message);
if (rejectedEvent is null)
{
var errorMessage = $"Unable to handle a message: '{messageName}' [id: '{messageProperties.MessageId}'] " +
$"with correlation id: '{messageProperties.CorrelationId}', " +
$"retry {currentRetry - 1}/{_retries}...";
if (currentRetry > 1)
{
_logger.LogError(errorMessage);
}
if (currentRetry - 1 < _retries)
{
throw new Exception(errorMessage, ex);
}
var error = $"Handling a message: '{messageName}' [id: '{messageProperties.MessageId}'] " +
$"with correlation id: '{messageProperties.CorrelationId}' failed.";
_logger.LogError(error);
return new Nack(_requeueFailedMessages);
}
var rejectedEventName = rejectedEvent.GetType().Name.ToSnakeCase();
await _busPublisher.PublishAsync(rejectedEvent, correlationId: messageProperties.CorrelationId,
messageContext: correlationContext);
if (_loggerEnabled)
{
_logger.LogWarning($"Published a rejected event: '{rejectedEventName}' " +
$"for the message: '{messageName}' [id: '{messageProperties.MessageId}'] with correlation id: '{messageProperties.CorrelationId}'.");
}
_logger.LogError($"Handling a message: '{messageName}' [id: '{messageProperties.MessageId}'] " +
$"with correlation id: '{messageProperties.CorrelationId}' failed and rejected event: " +
$"'{rejectedEventName}' was published.", ex);
return new Ack();
}
}));
}
/// <inheritdoc />
public async Task PublishDirect(object message, string queueName, IMessageProperties properties, bool mandatory)
{
await Publish(message, properties, null, queueName, mandatory);
}
/// <inheritdoc />
public async Task <ConsumeResult> Consume(string exchange, string routingKey, IMessageProperties properties, byte[] body)
{
object message = null;
try
{
message = messageSerializer.Deserialize(body, properties);
if (message == null)
{
throw new ArgumentException("Message body could not be deserialized into a message object", nameof(body));
}
return(await DispatchMessage(message, new MessageContextData
{
Exchange = exchange,
RoutingKey = routingKey,
Properties = properties
}));
}
catch (Exception dispatchException)
{
using (var emptyContext = new MessageContext
{
Config = config,
Queue = queueName,
Exchange = exchange,
RoutingKey = routingKey,
Message = message,
Properties = properties,
Binding = null
})
{
var exceptionContext = new ExceptionStrategyContext(emptyContext, dispatchException);
HandleException(exceptionContext);
return(exceptionContext.ConsumeResult);
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="T:System.Object"/> class.
/// </summary>
public Message(byte[] body, IMessageProperties messageProperties)
{
this.body = body;
this.messageProperties = messageProperties;
}
public Task Handle(Envelope <Greeting> @event, IMessageProperties props = null)
{
Console.WriteLine($"Message received (#{@event.Sequence}): {@event.Payload.Gratulation}, {@event.Payload.Sender} - source BC: {@event.SourceBC}");
return(Task.CompletedTask);
}
