static QueueNames()
{
Priority = QueueNames.ResolveQueueNameFn(typeof(T).Name, ".priorityq");
In = QueueNames.ResolveQueueNameFn(typeof(T).Name, ".inq");
Out = QueueNames.ResolveQueueNameFn(typeof(T).Name, ".outq");
Dlq = QueueNames.ResolveQueueNameFn(typeof(T).Name, ".dlq");
}
static QueueNames()
{
var utf8 = new UTF8Encoding(false);
Priority = QueueNames.ResolveQueueNameFn(typeof(T).Name, ".priorityq");
PriorityBytes = utf8.GetBytes(Priority);
In = QueueNames.ResolveQueueNameFn(typeof(T).Name, ".inq");
InBytes = utf8.GetBytes(In);
Out = QueueNames.ResolveQueueNameFn(typeof(T).Name, ".outq");
OutBytes = utf8.GetBytes(Out);
Dlq = QueueNames.ResolveQueueNameFn(typeof(T).Name, ".dlq");
DlqBytes = utf8.GetBytes(Dlq);
}
public void ProcessMessage(IMessageQueueClient mqClient, Message <T> message)
{
this.MqClient = mqClient;
try
{
var response = processMessageFn(message);
var responseEx = response as Exception;
if (responseEx != null)
{
throw responseEx;
}
this.TotalMessagesProcessed++;
//If there's no response publish the request message to its OutQ
if (response == null)
{
var messageOptions = (MessageOption)message.Options;
if (messageOptions.Has(MessageOption.NotifyOneWay))
{
mqClient.Notify(QueueNames <T> .Out, message.ToBytes());
}
}
else
{
//If there is a response send it to the typed response OutQ
var mqReplyTo = message.ReplyTo;
if (mqReplyTo == null)
{
var responseType = response.GetType();
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 '{0}' with client '{1}'"
.Fmt(mqReplyTo, replyClient.GetType().Name), ex);
var responseType = response.GetType();
if (!responseType.IsUserType())
{
return;
}
mqReplyTo = new QueueNames(responseType).In;
}
}
//Otherwise send to our trusty response Queue (inc if replyClient fails)
var responseMessage = MessageFactory.Create(response);
responseMessage.ReplyId = message.Id;
mqClient.Publish(mqReplyTo, responseMessage.ToBytes());
}
}
catch (Exception ex)
{
try
{
TotalMessagesFailed++;
processInExceptionFn(message, ex);
}
catch (Exception exHandlerEx)
{
Log.Error("Message exception handler threw an error", exHandlerEx);
}
}
}
public string GetTempQueueName()
{
return(QueueNames.GetTempQueueName());
}
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 messageOptions = (MessageOption)message.Options;
if (messageOptions.Has(MessageOption.NotifyOneWay))
{
mqClient.Notify(QueueNames <T> .Out, message);
}
}
}
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);
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
{
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 ProcessMessage(IMessageQueueClient mqClient, Message <T> message)
{
this.MqClient = mqClient;
try
{
var response = processMessageFn(message);
var responseEx = response as Exception;
if (responseEx != null)
{
throw responseEx;
}
this.TotalMessagesProcessed++;
//If there's no response publish the request message to its OutQ
if (response == null)
{
var messageOptions = (MessageOption)message.Options;
if (messageOptions.Has(MessageOption.NotifyOneWay))
{
mqClient.Notify(QueueNames <T> .Out, message.ToBytes());
}
}
else
{
var responseType = 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);
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 '{0}' with client '{1}'"
.Fmt(mqReplyTo, 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)
var responseMessage = MessageFactory.Create(response);
responseMessage.ReplyId = message.Id;
mqClient.Publish(mqReplyTo, responseMessage.ToBytes());
}
}
catch (Exception ex)
{
try
{
TotalMessagesFailed++;
processInExceptionFn(message, ex);
}
catch (Exception exHandlerEx)
{
Log.Error("Message exception handler threw an error", exHandlerEx);
}
}
}