public void SendOneWay(string queueName, object requestDto)
{
Publish(queueName, MessageFactory.Create(requestDto));
}
public void ProcessMessage(IMessageQueueClient mqClient, IMessage <T> message)
{
this.MqClient = mqClient;
bool msgHandled = false;
try
{
var response = processMessageFn(message);
var responseEx = response as Exception;
if (responseEx == null)
{
var responseStatus = response.GetResponseStatus();
var isError = responseStatus?.ErrorCode != null;
if (isError)
{
responseEx = new MessagingException(responseStatus, response);
}
}
if (responseEx != null)
{
TotalMessagesFailed++;
if (message.ReplyTo != null)
{
var replyClient = ReplyClientFactory(message.ReplyTo);
if (replyClient != null)
{
replyClient.SendOneWay(message.ReplyTo, response);
}
else
{
var responseDto = response.GetResponseDto();
mqClient.Publish(message.ReplyTo, MessageFactory.Create(responseDto));
}
return;
}
msgHandled = true;
processInExceptionFn(this, message, responseEx);
return;
}
this.TotalMessagesProcessed++;
//If there's no response publish the request message to its OutQ
if (response == null)
{
if (message.ReplyTo != null)
{
response = message.GetBody();
}
else
{
var publishOutqResponses = PublishToOutqWhitelist == null;
if (!publishOutqResponses)
{
var inWhitelist = PublishToOutqWhitelist.Contains(QueueNames <T> .Out);
if (!inWhitelist)
{
return;
}
}
var messageOptions = (MessageOption)message.Options;
if (messageOptions.Has(MessageOption.NotifyOneWay))
{
mqClient.Notify(QueueNames <T> .Out, message);
}
}
}
response = response.GetResponseDto();
if (response != null)
{
var responseMessage = response as IMessage;
var responseType = responseMessage != null
? (responseMessage.Body != 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;
if (mqReplyTo == null)
{
//Disable default handling of MQ Responses if whitelist exists and Response not in whitelist
var publishAllResponses = PublishResponsesWhitelist == null;
if (!publishAllResponses)
{
var inWhitelist = PublishResponsesWhitelist.Any(
publishResponse =>
responseType.GetOperationName() == publishResponse ||
responseType.Name == publishResponse);
if (!inWhitelist)
{
return;
}
}
// Leave as-is to work around a Mono 2.6.7 compiler bug
if (!responseType.IsUserType())
{
return;
}
mqReplyTo = new QueueNames(responseType).In;
}
var replyClient = ReplyClientFactory(mqReplyTo);
if (replyClient != null)
{
try
{
replyClient.SendOneWay(mqReplyTo, response);
return;
}
catch (Exception ex)
{
Log.Error($"Could not send response to '{mqReplyTo}' with client '{replyClient.GetType().GetOperationName()}'", ex);
// Leave as-is to work around a Mono 2.6.7 compiler bug
if (!responseType.IsUserType())
{
return;
}
mqReplyTo = new QueueNames(responseType).In;
}
}
//Otherwise send to our trusty response Queue (inc if replyClient fails)
if (responseMessage == null)
{
responseMessage = MessageFactory.Create(response);
}
responseMessage.ReplyId = message.Id;
mqClient.Publish(mqReplyTo, responseMessage);
}
}
catch (Exception ex)
{
try
{
if (ex is AggregateException)
{
ex = ex.UnwrapIfSingleException();
}
TotalMessagesFailed++;
msgHandled = true;
processInExceptionFn(this, message, ex);
}
catch (Exception exHandlerEx)
{
Log.Error("Message exception handler threw an error", exHandlerEx);
}
}
finally
{
if (!msgHandled)
{
mqClient.Ack(message);
}
this.TotalNormalMessagesReceived++;
LastMessageProcessed = DateTime.UtcNow;
}
}
public void SendOneWay(object requestDto)
{
Publish(MessageFactory.Create(requestDto));
}