public bool NeedToHandleMessage(MessageEx message)
{
if (_accountCollection.GetOrCreate(message.AccountTag).Profiles.Any())
{
return true;
}
var conditionalMessageRouter = ObjectFactory.TryGetInstance<ITargetProcessConditionalMessageRouter>();
return conditionalMessageRouter != null && conditionalMessageRouter.Handle(message);
}
public bool Handle(MessageEx message)
{
return message.AccountTag != AccountName.Empty;
}
private bool OnFailedMessageProcessing(MessageEx message)
{
try
{
if (FailedMessageProcessing != null)
{
FailedMessageProcessing(this, null);
}
}
catch (Exception e)
{
Logger.Warn(LoggerContext.New(message.MessageOrigin.Name), "Failed raising 'failed message processing' event.", e);
return false;
}
return true;
}
private bool OnTransportMessageReceived(TransportMessage msg, MessageEx origin)
{
try
{
if (TransportMessageReceived != null)
{
TransportMessageReceived(this, new TransportMessageReceivedEventArgs(msg));
}
Logger.Debug(LoggerContext.New(origin.MessageOrigin.Name, msg), "Transport message received");
}
catch (Exception e)
{
Logger.Warn(LoggerContext.New(origin.MessageOrigin.Name, msg),
"Failed raising 'transport message received' event for message with ID=" + msg.Id, e);
return false;
}
return true;
}
/// <summary>
/// Moves the given message to the configured error queue.
/// </summary>
/// <param name="message"></param>
protected void MoveToErrorQueue(MessageEx message)
{
var m = message.Message;
m.Label = m.Label + string.Format("<{0}>{1}</{0}><{2}>{3}<{2}>", FAILEDQUEUE, message.MessageOrigin.Name, ORIGINALID, m.Id);
if (_errorQueue != null)
{
_errorQueue.Send(m, MessageQueueTransactionType.Single);
}
}
private void ProcessMessage(MessageEx message)
{
var m = message.Message;
_messageId = m.Id;
if (IsTransactional)
{
if (HandledMaxRetries(m.Id))
{
Logger.Error(LoggerContext.New(message.MessageOrigin.Name),
string.Format("Message has failed the maximum number of times allowed, ID={0}.", m.Id));
MoveToErrorQueue(message);
return;
}
}
//exceptions here will cause a rollback - which is what we want.
if (StartedMessageProcessing != null)
{
StartedMessageProcessing(this, null);
}
TransportMessage result = Convert(m);
if (SkipDeserialization)
{
result.BodyStream = m.BodyStream;
}
else
{
try
{
result.Body = Extract(m);
}
catch (TypeNotFoundWhileDeserializationException e)
{
Logger.Warn(LoggerContext.New(message.MessageOrigin.Name, result), "Could not extract message data.", e);
OnFinishedMessageProcessing(message);
return;
}
catch (Exception e)
{
Logger.Error(LoggerContext.New(message.MessageOrigin.Name, result), "Could not extract message data.", e);
MoveToErrorQueue(message);
OnFinishedMessageProcessing(message); // don't care about failures here
return;
}
}
//care about failures here
var exceptionNotThrown = OnTransportMessageReceived(result, message);
//and here
var otherExNotThrown = OnFinishedMessageProcessing(message);
//but need to abort takes precedence - failures aren't counted here,
//so messages aren't moved to the error queue.
if (_needToAbort)
{
throw new AbortHandlingCurrentMessageException();
}
if (!(exceptionNotThrown && otherExNotThrown)) //cause rollback
{
throw new ApplicationException("Exception occured while processing message.");
}
}
private void ReceiveFromQueue(MessageEx message, Action<MessageEx> processMessageAction)
{
var m = message.Message;
if (m == null)
{
Logger.Info(LoggerContext.New(message.MessageOrigin.Name), string.Format("Peek returned null message."));
return;
}
message.DoReceive();
processMessageAction(message);
}
private void Handle(MessageEx message)
{
_needToAbort = false;
_messageId = string.Empty;
try
{
if (IsTransactional)
{
new TransactionWrapper().RunInTransaction(() => ReceiveFromQueue(message, ProcessMessage), IsolationLevel, TransactionTimeout);
ClearFailuresForMessage(_messageId);
}
else
{
ReceiveFromQueue(message, ProcessMessage);
}
}
catch (AbortHandlingCurrentMessageException)
{
//in case AbortHandlingCurrentMessage was called
return;
}
catch (Exception e)
{
Logger.Warn(LoggerContext.New(message.MessageOrigin.Name), "Failed to process message.", e);
if (IsTransactional)
{
IncrementFailuresForMessage(_messageId);
}
OnFailedMessageProcessing(message);
}
}
private void HandleAsync(MessageEx message)
{
_messageId = string.Empty;
ReceiveFromQueue(message, m => ThreadPool.QueueUserWorkItem(state =>
{
try
{
ProcessMessage(m);
}
catch (Exception e)
{
Logger.Warn(LoggerContext.New(message.MessageOrigin.Name), "Failed to process message.", e);
OnFailedMessageProcessing(message);
}
}));
}
private string GetQueueNameToRouteMessageIn(MessageEx m)
{
string accountName = m.AccountTag;
return string.IsNullOrEmpty(accountName) ? null : GetQueueName(accountName);
}
private void HandleAsync(MessageEx message)
{
_messageId = string.Empty;
ReceiveFromQueue(message, m => ThreadPool.QueueUserWorkItem(state =>
{
try
{
ProcessMessage(m);
}
catch
{
OnFailedMessageProcessing(message);
}
}));
}
private string GetQueueNameToRouteMessageIn(MessageEx m)
{
string name = MessageAccountParser.Instance.Parse(m.Message).Name;
return string.IsNullOrEmpty(name) ? null : InputQueue + "." + name;
}
