protected object[] DeserializeMessages(OpenedQueue messageQueue, Message transportMessage, Action <CurrentMessageInformation, Exception> messageSerializationException)
{
try
{
return(messageSerializer.Deserialize(transportMessage.BodyStream));
}
catch (Exception e)
{
try
{
logger.Error("Error when serializing message", e);
if (messageSerializationException != null)
{
var information = new MsmqCurrentMessageInformation
{
MsmqMessage = transportMessage,
Queue = messageQueue,
Message = transportMessage,
Source = messageQueue.RootUri,
MessageId = transportMessage.GetMessageId(),
Headers = transportMessage.Extension.DeserializeHeaders(),
};
messageSerializationException(information, e);
}
}
catch (Exception moduleEx)
{
logger.Error("Error when notifying about serialization exception", moduleEx);
}
throw;
}
}
private void ProcessMessage(
Message message,
OpenedQueue messageQueue,
TransactionScope 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;
}
}
public void RaiseMessageSerializationException(OpenedQueue queue, Message msg, string errorMessage)
{
var copy = MessageSerializationException;
if (copy == null)
{
return;
}
var messageInformation = new MsmqCurrentMessageInformation
{
MsmqMessage = msg,
Queue = queue,
Message = null,
Source = queue.RootUri,
MessageId = Guid.Empty
};
copy(messageInformation, new SerializationException(errorMessage));
}
protected object[] DeserializeMessages(OpenedQueue messageQueue, Message transportMessage, Action<CurrentMessageInformation, Exception> messageSerializationException)
{
try
{
return messageSerializer.Deserialize(transportMessage.BodyStream);
}
catch (Exception e)
{
try
{
logger.Error("Error when serializing message", e);
if (messageSerializationException != null)
{
var information = new MsmqCurrentMessageInformation
{
MsmqMessage = transportMessage,
Queue = messageQueue,
Message = transportMessage,
Source = messageQueue.RootUri,
MessageId = transportMessage.GetMessageId(),
Headers = transportMessage.Extension.DeserializeHeaders(),
};
messageSerializationException(information, e);
}
}
catch (Exception moduleEx)
{
logger.Error("Error when notifying about serialization exception", moduleEx);
}
throw;
}
}
private void ProcessMessage(
Message message,
OpenedQueue messageQueue,
TransactionScope tx,
Func<CurrentMessageInformation, bool> messageRecieved,
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
{
HandleMessageCompletion(message, tx, messageQueue, ex, messageCompleted);
currentMessageInformation = null;
}
}
public void RaiseMessageSerializationException(OpenedQueue queue, Message msg, string errorMessage)
{
var copy = MessageSerializationException;
if (copy == null)
return;
var messageInformation = new MsmqCurrentMessageInformation
{
MsmqMessage = msg,
Queue = queue,
Message = null,
Source = queue.RootUri,
MessageId = Guid.Empty
};
copy(messageInformation, new SerializationException(errorMessage));
}
private void ProcessMessage(
Message message,
OpenedQueue messageQueue,
TransactionScope 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;
}
}
private object[] DeserializeMessages(MessageQueue messageQueue, Message transportMessage)
{
object[] messages;
try
{
messages = serializer.Deserialize(transportMessage.BodyStream);
}
catch (Exception e)
{
try
{
logger.Error("Error when serializing message", e);
Action<CurrentMessageInformation, Exception> copy = MessageSerializationException;
if (copy != null)
{
var information = new MsmqCurrentMessageInformation
{
MsmqMessage = transportMessage,
Queue = messageQueue,
CorrelationId = CorrelationId.Parse(transportMessage.CorrelationId),
Message = transportMessage,
Source = MsmqUtil.GetQueueUri(messageQueue),
MessageId = CorrelationId.Parse(transportMessage.Id)
};
copy(information, e);
}
}
catch (Exception moduleEx)
{
logger.Error("Error when notifying about serialization exception", moduleEx);
}
throw;
}
return messages;
}
public void ProcessMessage(Message message,
MessageQueue messageQueue,
TransactionScope tx,
Action<CurrentMessageInformation> messageRecieved,
Action<CurrentMessageInformation, Exception> messageCompleted)
{
Exception ex = null;
currentMessageInformation = CreateMessageInformation(message, null, null);
try
{
//deserialization errors do not count for module events
object[] messages = DeserializeMessages(messageQueue, message);
try
{
foreach (object msg in messages)
{
currentMessageInformation = CreateMessageInformation(message, messages, msg);
if (messageRecieved != null)
messageRecieved(currentMessageInformation);
}
}
catch (Exception e)
{
ex = e;
logger.Error("Failed to process message", e);
}
finally
{
if (messageCompleted != null)
messageCompleted(currentMessageInformation, ex);
}
}
catch (Exception e)
{
ex = e;
logger.Error("Failed to deserialize message", e);
}
finally
{
HandleMessageCompletion(message, tx, messageQueue, ex);
currentMessageInformation = null;
}
}
