/// <inheritdoc />
public void Nak(IMqMessage message, bool requeue, Exception exception = null)
{
var queueName = requeue
? message.ToInQueueName()
: message.ToDlqQueueName();
this.Publish(queueName, message);
}
public void Can_serialize_IMqMessage_into_typed_Message()
{
var dto = new Incr {
Value = 1
};
var iMsg = MqMessageFactory.Create(dto);
var jsonBytes = MqMessageExtensions.ToJsonBytes((object)iMsg);
IMqMessage <Incr> typedMessage = MqMessageExtensions.FromJsonBytes <MqMessage <Incr> >(jsonBytes);
Assert.That(typedMessage.GetBody().Value, Is.EqualTo(dto.Value));
}
public virtual void Publish(string queueName, string exchange, IMqMessage message)
{
var props = this.Channel.CreateBasicProperties();
props.Persistent = true;
props.PopulateFromMessage(message);
this.PublishMessageFilter?.Invoke(queueName, props, message);
var messageBytes = MqMessageExtensions.ToJsonBytes(message.Body);
this.PublishMessage(exchange ?? MqQueueNames.Exchange, queueName, props, messageBytes);
}
private void DefaultInExceptionHandler(IMqMessageHandler mqHandler, IMqMessage <T> message, Exception ex)
{
this._logger.Error(ex, "Message exception handler threw an error.");
var requeue = !(ex is UnRetryableMqMessagingException) &&
message.RetryAttempts < this._retryCount;
if (requeue)
{
message.RetryAttempts++;
this.TotalRetries++;
}
message.Error = new MqErrorStatus(ex);
mqHandler.MqClient.Nak(message, requeue, ex);
}
public static void PopulateFromMessage(this IBasicProperties props, IMqMessage message)
{
props.MessageId = message.Id.ToString();
props.Timestamp = new AmqpTimestamp(message.CreatedDate.ToUnixTime());
props.Priority = (byte)message.Priority;
props.ContentType = Const.Json;
if (message.Body != null)
{
props.Type = message.Body.GetType().Name;
}
if (message.ReplyTo != null)
{
props.ReplyTo = message.ReplyTo;
}
if (message.ReplyId != null)
{
props.CorrelationId = message.ReplyId.Value.ToString();
}
if (message.Error != null)
{
if (props.Headers == null)
{
props.Headers = new Dictionary <string, object>();
}
props.Headers[nameof(IMqMessage.Error)] = message.Error.ToJson();
}
if (message.Meta != null)
{
if (props.Headers == null)
{
props.Headers = new Dictionary <string, object>();
}
foreach (var entry in message.Meta)
{
props.Headers[entry.Key] = entry.Value;
}
}
}
/// <inheritdoc />
public virtual void Nak(IMqMessage message, bool requeue, Exception exception = null)
{
try {
if (requeue)
{
var deliveryTag = ulong.Parse(message.Tag);
this.Channel.BasicNack(deliveryTag, false, true);
}
else
{
this.Publish(message.ToDlqQueueName(), MqQueueNames.ExchangeDlq, message);
this.Ack(message);
}
} catch (Exception) {
var deliveryTag = ulong.Parse(message.Tag);
this.Channel.BasicNack(deliveryTag, false, requeue);
}
}
/// <inheritdoc />
public virtual void Ack(IMqMessage message)
{
var deliveryTag = ulong.Parse(message.Tag);
this.Channel.BasicAck(deliveryTag, false);
}
public void ProcessMessage(IMqMessageQueueClient mqClient, IMqMessage <T> message)
{
this.MqClient = mqClient;
var msgHandled = false;
try {
var response = this._processMessageFn(message);
if (response is Exception responseEx)
{
this.TotalMessagesFailed++;
if (message.ReplyTo != null)
{
var responseDto = response;
mqClient.Publish(message.ReplyTo, MqMessageFactory.Create(responseDto));
return;
}
if (responseEx is AggregateException)
{
responseEx = responseEx.UnwrapIfSingleException();
}
msgHandled = true;
this._processInExceptionFn(this, message, responseEx);
return;
}
this.TotalMessagesProcessed++;
// If there's no response, do nothing
if (response != null)
{
var responseMessage = response as IMqMessage;
var responseType = responseMessage != null
? responseMessage.Body?.GetType() ?? typeof(object)
: response.GetType();
// If there's no explicit ReplyTo, send it to the typed Response InQ by default
var mqReplyTo = message.ReplyTo ?? new MqQueueNames(responseType).Direct;
// Otherwise send to our trusty response Queue
if (responseMessage == null)
{
responseMessage = MqMessageFactory.Create(response);
}
responseMessage.ReplyId = message.Id;
mqClient.Publish(mqReplyTo, responseMessage);
}
} catch (Exception ex) {
try {
if (ex is AggregateException)
{
ex = ex.UnwrapIfSingleException();
}
this.TotalMessagesFailed++;
msgHandled = true;
this._processInExceptionFn(this, message, ex);
} catch (Exception exHandlerEx) {
this._logger.Error(exHandlerEx, "Message exception handler threw an error.");
}
} finally {
if (!msgHandled)
{
mqClient.Ack(message);
}
this.TotalNormalMessagesReceived++;
this.LastMessageProcessed = DateTime.Now;
}
}
/// <inheritdoc />
public void Notify(string queueName, IMqMessage message)
{
var messageBytes = message.ToJsonBytes();
this._factory.PublishMessage(queueName, messageBytes);
}
public void Publish(string queueName, IMqMessage message)
{
this._parent._transientMessageService.MessageQueueFactory
.PublishMessage(queueName, message.ToJsonBytes());
}
/// <inheritdoc />
public void Publish <T>(IMqMessage <T> message)
{
this.Publish(MqQueueNames <T> .Direct, message);
}
public void PublishMessage <T>(string queueName, IMqMessage <T> message)
{
this.PublishMessage(queueName, message.ToJsonBytes());
}
public virtual void Notify(IMqMessage message)
{
this.Notify(new MqQueueNames(message.Body.GetType()).Topic, message);
}
/// <inheritdoc />
public void Publish <T>(IMqMessage <T> message)
{
this._factory.PublishMessage(MqQueueNames <T> .Direct, message);
}
/// <inheritdoc />
public virtual void Notify(string queueName, IMqMessage message)
{
this.Publish(queueName, MqQueueNames.ExchangeTopic, message);
}
/// <inheritdoc />
public void Ack(IMqMessage message)
{
}
public virtual void Publish(string queueName, IMqMessage message)
{
this.Publish(queueName, MqQueueNames.Exchange, message);
}
