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); }