private void ProcessMessage(Message message, IRsbTransaction tx, Func <CurrentMessageInformation, bool> messageRecieved, Action <CurrentMessageInformation, Exception> messageCompleted, Action <CurrentMessageInformation> beforeTransactionCommit, Action <CurrentMessageInformation> beforeTransactionRollback)
{
Exception ex = null;
try
{
//deserialization errors do not count for module events
#pragma warning disable 420
Interlocked.Increment(ref currentlyProccessingCount);
object[] messages = DeserializeMessages(message);
try
{
var messageId = new Guid(message.Headers["id"]);
var source = new Uri(message.Headers["source"]);
foreach (var msg in messages)
{
currentMessageInformation = new RhinoQueueCurrentMessageInformation
{
AllMessages = messages,
Message = msg,
Destination = endpoint,
MessageId = messageId,
Source = source,
TransportMessageId = message.Id.ToString(),
Queue = queue,
TransportMessage = message
};
if (TransportUtil.ProcessSingleMessage(currentMessageInformation, messageRecieved) == false)
{
Discard(currentMessageInformation.Message);
}
}
}
catch (Exception e)
{
ex = e;
logger.Error("Failed to process message", e);
}
}
catch (Exception e)
{
ex = e;
logger.Error("Failed to deserialize message", e);
}
finally
{
var messageHandlingCompletion = new MessageHandlingCompletion(tx, null, ex, messageCompleted, beforeTransactionCommit, beforeTransactionRollback, logger,
MessageProcessingFailure, currentMessageInformation);
messageHandlingCompletion.HandleMessageCompletion();
currentMessageInformation = null;
Interlocked.Decrement(ref currentlyProccessingCount);
#pragma warning restore 420
}
}
public MessageHandlingCompletion(IRsbTransaction tx, Action sendMessageBackToQueue, Exception exception, Action <CurrentMessageInformation, Exception> messageCompleted, Action <CurrentMessageInformation> beforeTransactionCommit, Action <CurrentMessageInformation> beforeTransactionRollback, ILog logger, Action <CurrentMessageInformation, Exception> messageProcessingFailure, CurrentMessageInformation currentMessageInformation)
{
this.tx = tx;
this.sendMessageBackToQueue = sendMessageBackToQueue;
this.exception = exception;
this.messageCompleted = messageCompleted;
this.beforeTransactionCommit = beforeTransactionCommit;
this.beforeTransactionRollback = beforeTransactionRollback;
this.logger = logger;
this.messageProcessingFailure = messageProcessingFailure;
this.currentMessageInformation = currentMessageInformation;
}
private void ProcessMessage(
Message message,
OpenedQueue messageQueue,
IRsbTransaction tx,
Func <CurrentMessageInformation, bool> messageRecieved,
Action <CurrentMessageInformation> beforeMessageTransactionCommit,
Action <CurrentMessageInformation> beforeMessageTransactionRollback,
Action <CurrentMessageInformation, Exception> messageCompleted)
{
Exception ex = null;
currentMessageInformation = CreateMessageInformation(messageQueue, message, null, null);
try
{
//deserialization errors do not count for module events
object[] messages = DeserializeMessages(messageQueue, message, MessageSerializationException);
try
{
foreach (object msg in messages)
{
currentMessageInformation = CreateMessageInformation(messageQueue, message, messages, msg);
if (TransportUtil.ProcessSingleMessage(currentMessageInformation, messageRecieved) == false)
{
Discard(currentMessageInformation.Message);
}
}
}
catch (Exception e)
{
ex = e;
logger.Error("Failed to process message", e);
}
}
catch (Exception e)
{
ex = e;
logger.Error("Failed to deserialize message", e);
}
finally
{
Action sendMessageBackToQueue = null;
if (message != null && (messageQueue.IsTransactional == false || consumeInTransaction == false))
{
sendMessageBackToQueue = () => messageQueue.Send(message);
}
var messageHandlingCompletion = new MessageHandlingCompletion(tx, sendMessageBackToQueue, ex, messageCompleted, beforeMessageTransactionCommit, beforeMessageTransactionRollback, logger, MessageProcessingFailure, currentMessageInformation);
messageHandlingCompletion.HandleMessageCompletion();
currentMessageInformation = null;
}
}
