private TransactionOptions GetTransactionOptions()
{
return(new TransactionOptions
{
IsolationLevel = Transaction.Current == null ? queueIsolationLevel : Transaction.Current.IsolationLevel,
Timeout = TransportUtil.GetTransactionTimeout(),
});
}
private void ProcessMessage(
Message message,
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
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 SqlQueueCurrentMessageInformation
{
AllMessages = messages,
Message = msg,
Destination = queueEndpoint,
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 SqlMessageHandlingCompletion(_sqlQueueManager, null, ex, messageCompleted, beforeTransactionCommit, beforeTransactionRollback, logger,
MessageProcessingFailure, currentMessageInformation);
messageHandlingCompletion.HandleMessageCompletion();
currentMessageInformation = null;
}
}
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
}
}
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 ReceiveMessageInTransaction(OpenedQueue queue, string messageId, Func <CurrentMessageInformation, bool> messageArrived, Action <CurrentMessageInformation, Exception> messageProcessingCompleted, Action <CurrentMessageInformation> beforeMessageTransactionCommit, Action <CurrentMessageInformation> beforeMessageTransactionRollback)
{
var transactionOptions = new TransactionOptions
{
IsolationLevel = queueIsolationLevel,
Timeout = TransportUtil.GetTransactionTimeout(),
};
using (var tx = new TransactionScope(TransactionScopeOption.Required, transactionOptions))
{
var message = queue.TryGetMessageFromQueue(messageId);
if (message == null)
{
return; // someone else got our message, better luck next time
}
ProcessMessage(message, queue, tx, messageArrived, beforeMessageTransactionCommit, beforeMessageTransactionRollback, messageProcessingCompleted);
}
}
protected override void HandlePeekedMessage(OpenedQueue queue, Message message)
{
try
{
using (var tx = new TransactionScope(TransactionScopeOption.Required, TransportUtil.GetTransactionTimeout()))
{
message = queue.TryGetMessageFromQueue(message.Id);
if (message == null)
{
return;
}
if ((MessageType)message.AppSpecific == MessageType.LoadBalancerMessageMarker)
{
HandleLoadBalancerMessage(queue, message);
}
tx.Complete();
}
}
catch (Exception e)
{
logger.Error("Fail to process load balanced message properly", e);
}
}
protected override void HandlePeekedMessage(OpenedQueue queue, Message message)
{
try
{
using (var tx = new TransactionScope(TransactionScopeOption.Required, TransportUtil.GetTransactionTimeout()))
{
message = queue.TryGetMessageFromQueue(message.Id);
if (message == null)
{
return;
}
PersistEndpoint(queue, message);
switch ((MessageType)message.AppSpecific)
{
case MessageType.ShutDownMessageMarker:
//silently cnsume the message
break;
case MessageType.LoadBalancerMessageMarker:
HandleLoadBalancerMessage(queue, message);
break;
case MessageType.AdministrativeMessageMarker:
SendToAllWorkers(message, "Dispatching administrative message from {0} to load balancer {1}");
break;
default:
HandleStandardMessage(queue, message);
break;
}
tx.Complete();
}
}
catch (Exception e)
{
logger.Error("Fail to process load balanced message properly", e);
}
}
/// <summary>
/// Constructs the new service handler
/// </summary>
public ServiceHandler(Hl7ServiceDefinition serviceDefinition)
{
this.m_serviceDefinition = serviceDefinition;
this.m_transport = TransportUtil.CreateTransport(this.m_serviceDefinition.Address.Scheme);
this.m_transport.MessageReceived += new EventHandler <Hl7MessageReceivedEventArgs>(m_transport_MessageReceived);
}
