public bool HandleError(Exception exception)
{
var errorChannel = ResolveErrorChannel(exception);
var sent = false;
if (errorChannel != null)
{
try
{
MessagingTemplate.Send(errorChannel, ErrorMessageStrategy.BuildErrorMessage(exception, null));
sent = true;
}
catch (Exception errorDeliveryError)
{
_logger?.LogWarning("Error message was not delivered.", errorDeliveryError);
}
}
if (!sent)
{
var failedMessage = (exception is MessagingException) ? ((MessagingException)exception).FailedMessage : null;
if (failedMessage != null)
{
_logger?.LogError("failure occurred in messaging task with message: " + failedMessage, exception);
}
else
{
_logger?.LogError("failure occurred in messaging task", exception);
}
}
return(sent);
}
protected virtual IMessage BuildReturnedMessage(IMessage message, int replyCode, string replyText, string exchange, string returnedRoutingKey, IMessageConverter converter)
{
var returnedObject = converter.FromMessage(message, null);
var builder = PrepareMessageBuilder(returnedObject);
// TODO: Map < String, ?> headers = getHeaderMapper().toHeadersFromReply(message.getMessageProperties());
if (ErrorMessageStrategy == null)
{
builder.CopyHeadersIfAbsent(message.Headers)
.SetHeader(RabbitMessageHeaders.RETURN_REPLY_CODE, replyCode)
.SetHeader(RabbitMessageHeaders.RETURN_REPLY_TEXT, replyText)
.SetHeader(RabbitMessageHeaders.RETURN_EXCHANGE, exchange)
.SetHeader(RabbitMessageHeaders.RETURN_ROUTING_KEY, returnedRoutingKey);
}
var returnedMessage = builder.Build();
if (ErrorMessageStrategy != null)
{
returnedMessage = ErrorMessageStrategy.BuildErrorMessage(
new ReturnedRabbitMessageException(returnedMessage, replyCode, replyText, exchange, returnedRoutingKey),
null);
}
return(returnedMessage);
}
private IMessage BuildConfirmMessage(bool ack, string cause, CorrelationDataWrapper wrapper, object userCorrelationData)
{
if (ErrorMessageStrategy == null || ack)
{
var headers = new Dictionary <string, object>
{
{ RabbitMessageHeaders.PUBLISH_CONFIRM, ack }
};
if (!ack && !string.IsNullOrEmpty(cause))
{
headers.Add(RabbitMessageHeaders.PUBLISH_CONFIRM_NACK_CAUSE, cause);
}
return(PrepareMessageBuilder(userCorrelationData)
.CopyHeaders(headers)
.Build());
}
else
{
return(ErrorMessageStrategy.BuildErrorMessage(
new NackedRabbitMessageException(wrapper.Message, wrapper.UserData, cause), null));
}
}
public override bool Poll(IMessageHandler handler, Type type)
{
var message = Receive(type);
if (message == null)
{
return(false);
}
var ackCallback = StaticMessageHeaderAccessor.GetAcknowledgmentCallback(message);
try
{
if (RetryTemplate == null)
{
Handle(message, handler);
}
else
{
RetryTemplate.Execute((ctx) => Handle(message, handler), _recoveryCallback);
}
return(true);
}
catch (MessagingException e)
{
if (RetryTemplate == null && !ShouldRequeue(e))
{
_messagingTemplate.Send(ErrorChannel, ErrorMessageStrategy.BuildErrorMessage(e, _attributesHolder.Value));
return(true);
}
else if (!ackCallback.IsAcknowledged && ShouldRequeue(e))
{
AckUtils.Requeue(ackCallback);
return(true);
}
else
{
AckUtils.AutoNack(ackCallback);
}
if (e.FailedMessage.Equals(message))
{
throw;
}
throw new MessageHandlingException(message, e);
}
catch (Exception e)
{
AckUtils.AutoNack(ackCallback);
if (e is MessageHandlingException && ((MessageHandlingException)e).FailedMessage.Equals(message))
{
throw;
}
throw new MessageHandlingException(message, e);
}
finally
{
AckUtils.AutoAck(ackCallback);
}
}
