protected override void AfterStart(OpenedQueue queue) { base.AfterStart(queue); SendToQueue(primaryLoadBalancer, new QueryForAllKnownWorkersAndEndpoints()); SendToQueue(primaryLoadBalancer, new QueryReadyForWorkQueueUri()); StartTrackingHeartbeats(); }
public bool TryMoveMessage(OpenedQueue queue, Message message, SubQueue subQueue, out string msgId) { using (var destinationQueue = queue.OpenSiblngQueue(subQueue, QueueAccessMode.Send)) { Message receiveById; try { receiveById = queue.ReceiveById(message.Id); } catch (InvalidOperationException) { msgId = null; return(false); } receiveById.AppSpecific = 0;//reset flag destinationQueue.Send(receiveById); msgId = receiveById.Id; logger.DebugFormat("Moving messgage {0} from {1} to {2}, new id: {3}", message.Id, queue.RootUri, destinationQueue.QueueUrl, receiveById.Id); return(true); } }
protected override void HandlePeekedMessage(OpenedQueue queue, Message message) { foreach (var action in transportActions) { if (action.CanHandlePeekedMessage(message) == false) { continue; } try { if (action.HandlePeekedMessage(this, queue, message)) { return; } } catch (Exception e) { logger.Error("Error when trying to execute action " + action + " on message " + message.Id + ". Message has been removed without handling!", e); queue.ConsumeMessage(message.Id); } } if (consumeInTransaction) { ReceiveMessageInTransaction(queue, message.Id, MessageArrived, MessageProcessingCompleted, BeforeMessageTransactionCommit); } else { ReceiveMessage(queue, message.Id, MessageArrived, MessageProcessingCompleted); } }
protected override void BeforeStart(OpenedQueue queue) { foreach (var messageAction in transportActions) { messageAction.Init(this, queue); } }
protected override void BeforeStart(OpenedQueue queue) { try { queueStrategy.InitializeQueue(Endpoint, QueueType.LoadBalancer); } catch (Exception e) { throw new TransportException( "Could not open queue for load balancer: " + Endpoint + Environment.NewLine + "Queue path: " + MsmqUtil.GetQueuePath(Endpoint), e); } try { ReadUrisFromSubQueue(KnownWorkers, SubQueue.Workers); } catch (Exception e) { throw new InvalidOperationException("Could not read workers subqueue", e); } try { ReadUrisFromSubQueue(KnownEndpoints, SubQueue.Endpoints); } catch (Exception e) { throw new InvalidOperationException("Could not read endpoints subqueue", e); } RemoveAllReadyToWorkMessages(); }
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; } }
public MsmqFlatQueueTestBase() { defaultTestBase = new MsmqTestBase(); testQueueEndPoint = new Endpoint { Uri = new Uri("msmq://localhost/test_queue") }; testQueuePath = MsmqUtil.GetQueuePath(testQueueEndPoint).QueuePath; transactionalTestQueueEndpoint = new Endpoint { Uri = new Uri("msmq://localhost/transactional_test_queue") }; transactionalTestQueuePath = MsmqUtil.GetQueuePath(transactionalTestQueueEndpoint).QueuePath; subscriptionsEndpoint = new Endpoint { Uri = new Uri(testQueueEndPoint.Uri + "#" + subscriptions) }; subscriptionQueuePath = MsmqUtil.GetQueuePath(subscriptionsEndpoint).QueuePath; SetupQueues(); queue = MsmqUtil.GetQueuePath(testQueueEndPoint).Open(); transactionalQueue = MsmqUtil.GetQueuePath(transactionalTestQueueEndpoint).Open(); subscriptions = MsmqUtil.GetQueuePath(subscriptionsEndpoint).Open(QueueAccessMode.SendAndReceive, new XmlMessageFormatter(new[] { typeof (string) })); }
/// <summary> /// Moves the message from the timeout queue to the main queue. /// </summary> /// <param name="queue">The queue.</param> /// <param name="messageId">The message id.</param> public void MoveTimeoutToMainQueue(OpenedQueue queue, string messageId) { using (var timeoutQueue = queue.OpenSubQueue(SubQueue.Timeout, QueueAccessMode.Receive)) { var message = timeoutQueue.ReceiveById(messageId); message.AppSpecific = 0;//reset timeout flag queue.Send(message); } }
public void SendToErrorQueue(OpenedQueue queue, Message message) { using (var errQueue = new MessageQueue(GetErrorsQueuePath())) { // here we assume that the queue transactionalibilty is the same for the error sibling queue // and the main queue! errQueue.Send(message, queue.GetSingleTransactionType()); } }
/// <summary> /// Moves the message from the timeout queue to the main queue. /// </summary> /// <param name="queue">The queue.</param> /// <param name="messageId">The message id.</param> public void MoveTimeoutToMainQueue(OpenedQueue queue, string messageId) { using (var timeoutQueue = queue.OpenSubQueue(SubQueue.Timeout, QueueAccessMode.Receive)) { var message = timeoutQueue.ReceiveById(messageId); message.AppSpecific = 0; //reset timeout flag queue.Send(message); } }
/// <summary> /// Moves the message from the timeout queue to the main queue. /// </summary> /// <param name="queue">The queue.</param> /// <param name="messageId">The message id.</param> public void MoveTimeoutToMainQueue(OpenedQueue queue, string messageId) { using (var destinationQueue = new MessageQueue(GetTimeoutQueuePath(), QueueAccessMode.Receive)) { destinationQueue.MessageReadPropertyFilter.SetAll(); var message = destinationQueue.ReceiveById(messageId); message.AppSpecific = 0;//reset timeout flag queue.Send(message); } }
private void ReceiveMessage(OpenedQueue queue, string messageId, Func <CurrentMessageInformation, bool> messageArrived, Action <CurrentMessageInformation, Exception> messageProcessingCompleted) { var message = queue.TryGetMessageFromQueue(messageId); if (message == null) { return; } ProcessMessage(message, queue, null, messageArrived, null, messageProcessingCompleted); }
public OpenedQueue Open(QueueAccessMode access, IMessageFormatter formatter) { var messageQueue = new MessageQueue(QueuePath, access); if (formatter != null) messageQueue.Formatter = formatter; var openedQueue = new OpenedQueue(this, messageQueue, QueueUri.ToString(),Transactional) { Formatter = formatter }; if (SubQueue != null) return openedQueue.OpenSubQueue(SubQueue.Value, access); return openedQueue; }
public void Init(ITransport transport, IServiceBus bus) { var endpoint = endpointRouter.GetRoutedEndpoint(logQueue); var queueInfo = MsmqUtil.GetQueuePath(endpoint); queueInfo.Create(); queue = queueInfo.Open(QueueAccessMode.Send); transport.MessageArrived += Transport_OnMessageArrived; transport.MessageProcessingFailure += Transport_OnMessageProcessingFailure; transport.MessageProcessingCompleted += Transport_OnMessageProcessingCompleted; transport.MessageSerializationException += Transport_OnMessageSerializationException; transport.MessageSent+=Transport_OnMessageSent; }
public void ReceiveMessageInTransaction(OpenedQueue queue, string messageId, Func <CurrentMessageInformation, bool> messageArrived, Action <CurrentMessageInformation, Exception> messageProcessingCompleted, Action <CurrentMessageInformation> beforeMessageTransactionCommit, Action <CurrentMessageInformation> beforeMessageTransactionRollback) { using (var tx = _transactionStrategy.Begin()) { 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); } }
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 bool TryMoveMessage(OpenedQueue queue, Message message, SubQueue subQueue, out string msgId) { try { queue.MoveToSubQueue(subQueue, message); msgId = message.Id; return true; } catch (TransportException) { msgId = null; return false; } }
public bool TryMoveMessage(OpenedQueue queue, Message message, SubQueue subQueue, out string msgId) { try { queue.MoveToSubQueue(subQueue, message); msgId = message.Id; return(true); } catch (TransportException) { msgId = null; return(false); } }
private void HandleLoadBalancerMessage(OpenedQueue queue, Message message) { foreach (var msg in DeserializeMessages(queue, message, null)) { var work = msg as ReadyToWork; if (work != null) { var copy = ReadyToWorkMessageArrived; if(copy != null) { copy(work); } } } }
private MsmqCurrentMessageInformation CreateMessageInformation(OpenedQueue queue, Message message, object[] messages, object msg) { return(new MsmqCurrentMessageInformation { MessageId = message.GetMessageId(), AllMessages = messages, Message = msg, Queue = queue, TransportMessageId = message.Id, Destination = Endpoint.Uri, Source = MsmqUtil.GetQueueUri(message.ResponseQueue), MsmqMessage = message, TransactionType = queue.GetTransactionType() }); }
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)); }
public void ReceiveMessageInTransaction(OpenedQueue queue, string messageId, Func <CurrentMessageInformation, bool> messageArrived, Action <CurrentMessageInformation, Exception> messageProcessingCompleted, Action <CurrentMessageInformation> beforeMessageTransactionCommit) { 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, messageProcessingCompleted); } }
public OpenedQueue Open(QueueAccessMode access, IMessageFormatter formatter) { var messageQueue = new MessageQueue(QueuePath, access); if (formatter != null) { messageQueue.Formatter = formatter; } var openedQueue = new OpenedQueue(this, messageQueue, QueueUri.ToString(), Transactional) { Formatter = formatter }; if (SubQueue != null) { return(openedQueue.OpenSubQueue(SubQueue.Value, access)); } return(openedQueue); }
/// <summary> /// Gets a listing of all timeout messages. /// </summary> /// <returns></returns> public IEnumerable<TimeoutInfo> GetTimeoutMessages(OpenedQueue queue) { using (var timeoutQueue = queue.OpenSiblngQueue(SubQueue.Timeout, QueueAccessMode.Receive)) { var enumerator2 = timeoutQueue.GetMessageEnumerator2(); while (enumerator2.MoveNext()) { var message = enumerator2.Current; if (message == null) continue; yield return new TimeoutInfo { Id = message.Id, Time = DateTime.FromBinary(BitConverter.ToInt64(message.Extension, 0)) }; } } }
private void RemoveSubscriptionMessageFromQueue(OpenedQueue queue, string type, Uri uri) { subscriptionMessageIds.Write(writer => { var key = new TypeAndUriKey { TypeName = type, Uri = uri }; IList <string> messageIds; if (writer.TryGetValue(key, out messageIds) == false) { return; } foreach (var msgId in messageIds) { queue.ConsumeMessage(msgId); } writer.Remove(key); }); }
/// <summary> /// Gets a listing of all timeout messages. /// </summary> /// <returns></returns> public IEnumerable <TimeoutInfo> GetTimeoutMessages(OpenedQueue queue) { using (var timeoutQueue = queue.OpenSiblngQueue(SubQueue.Timeout, QueueAccessMode.Receive)) { var enumerator2 = timeoutQueue.GetMessageEnumerator2(); while (enumerator2.MoveNext()) { var message = enumerator2.Current; if (message == null || message.Extension.Length < 16) { continue; } yield return(new TimeoutInfo { Id = message.Id, Time = DateTime.FromBinary(BitConverter.ToInt64(message.Extension, 16)) }); } } }
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); } }
private bool?TryPeek(OpenedQueue queue, out Message message) { try { message = queue.Peek(TimeOutForPeek); } catch (MessageQueueException e) { message = null; if (e.MessageQueueErrorCode != MessageQueueErrorCode.IOTimeout) { logger.Error("Could not peek message from queue", e); return(false); } return(null); // nothing found } catch (Exception e) { message = null; logger.Error("Could not peek message from queue", e); return(false); } return(true); }
protected override void AfterStart(OpenedQueue queue) { if (_readyForWorkListener != null) { _readyForWorkListener.ReadyToWorkMessageArrived += readyForWorkMessage => HandleReadyForWork(queue, readyForWorkMessage); _readyForWorkListener.Start(); } if (secondaryLoadBalancer != null) { foreach (var queueUri in KnownEndpoints.GetValues()) { logger.InfoFormat("Notifying {0} that primary load balancer {1} is taking over from secondary", queueUri, Endpoint.Uri ); SendToQueue(queueUri, new Reroute { NewEndPoint = Endpoint.Uri, OriginalEndPoint = Endpoint.Uri }); } SendHeartBeatToSecondaryServer(null); heartBeatTimer.Change(TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(1)); Reroute reroute; if (_readyForWorkListener != null) reroute = new Reroute { NewEndPoint = _readyForWorkListener.Endpoint.Uri, OriginalEndPoint = _readyForWorkListener.Endpoint.Uri }; else reroute = new Reroute { NewEndPoint = Endpoint.Uri, OriginalEndPoint = Endpoint.Uri }; SendToAllWorkers( GenerateMsmqMessageFromMessageBatch(reroute), "Rerouting {1} back to {0}" ); } if (ShouldNotifyWorkersLoaderIsReadyToAcceptWorkOnStartup) NotifyWorkersThatLoaderIsReadyToAcceptWork(); }
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; } }
private void HandleMessageCompletion( Message message, TransactionScope tx, OpenedQueue messageQueue, Exception exception, Action<CurrentMessageInformation, Exception> messageCompleted) { if (exception == null) { try { if (tx != null) { tx.Complete(); tx.Dispose(); } try { if (messageCompleted != null) messageCompleted(currentMessageInformation, exception); } catch (Exception e) { logger.Error("An error occured when raising the MessageCompleted event, the error will NOT affect the message processing", e); } return; } catch (Exception e) { logger.Warn("Failed to complete transaction, moving to error mode", e); exception = e; } } if (message == null) return; try { if (messageCompleted != null) messageCompleted(currentMessageInformation, exception); } catch (Exception e) { logger.Error("An error occured when raising the MessageCompleted event, the error will NOT affect the message processing", e); } try { var copy = MessageProcessingFailure; if (copy != null) copy(currentMessageInformation, exception); } catch (Exception moduleException) { logger.Error("Module failed to process message failure: " + exception.Message, moduleException); } if (messageQueue.IsTransactional == false)// put the item back in the queue { messageQueue.Send(message); } }
private MsmqCurrentMessageInformation CreateMessageInformation(OpenedQueue queue,Message message, object[] messages, object msg) { return new MsmqCurrentMessageInformation { MessageId = message.GetMessageId(), AllMessages = messages, Message = msg, Queue = queue, TransportMessageId = message.Id, Destination = Endpoint.Uri, Source = MsmqUtil.GetQueueUri(message.ResponseQueue), MsmqMessage = message, TransactionType = queue.GetTransactionType() }; }
protected override void HandlePeekedMessage(OpenedQueue queue,Message message) { foreach (var action in transportActions) { if(action.CanHandlePeekedMessage(message)==false) continue; try { if (action.HandlePeekedMessage(this, queue, message)) return; } catch (Exception e) { logger.Error("Error when trying to execute action " + action + " on message " + message.Id + ". Message has been removed without handling!", e); queue.ConsumeMessage(message.Id); } } ReceiveMessageInTransaction(queue, message.Id, MessageArrived, MessageProcessingCompleted); }
public OpenedQueue(OpenedQueue parent, MessageQueue queue, string url) : this(parent.info, queue, url, parent.transactional) { this.parent = parent; }
protected virtual void BeforeStart(OpenedQueue queue) { }
private void HandleReadyForWork(OpenedQueue queue, ReadyToWork work) { logger.DebugFormat("{0} is ready to work", work.Endpoint); var needToAddToQueue = KnownWorkers.Add(work.Endpoint); if (needToAddToQueue) AddWorkerToQueue(queue, work); readyForWork.Enqueue(work.Endpoint); }
private void HandleStandardMessage(OpenedQueue queue, Message message) { var worker = readyForWork.Dequeue(); if (worker == null) // handle message later { queue.Send(message); continuousDeliveryFailures++; if (continuousDeliveryFailures >= 100) { System.Threading.Thread.Sleep(1000); continuousDeliveryFailures = 0; } } else { continuousDeliveryFailures = 0; var workerEndpoint = endpointRouter.GetRoutedEndpoint(worker); using (var workerQueue = MsmqUtil.GetQueuePath(workerEndpoint).Open(QueueAccessMode.Send)) { logger.DebugFormat("Dispatching message '{0}' to {1}", message.Id, workerEndpoint.Uri); workerQueue.Send(message); } } }
public void SendToErrorQueue(OpenedQueue queue, Message message) { queue.Send(message); }
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); } }
protected abstract void HandlePeekedMessage(OpenedQueue queue, Message message);
private void PersistEndpoint(OpenedQueue queue, Message message) { var queueUri = MsmqUtil.GetQueueUri(message.ResponseQueue); if (queueUri == null) return; bool needToPersist = knownEndpoints.Add(queueUri); if (needToPersist == false) return; logger.InfoFormat("Adding new endpoint: {0}", queueUri); var persistedEndPoint = new Message { Formatter = new XmlMessageFormatter(new[] { typeof(string) }), Body = queueUri.ToString(), Label = ("Known end point: " + queueUri).EnsureLabelLength() }; queue.Send(persistedEndPoint.SetSubQueueToSendTo(SubQueue.Endpoints)); SendToQueue(secondaryLoadBalancer, new NewEndpointPersisted { PersistedEndpoint = queueUri }); Raise(SentNewEndpointPersisted); }
protected virtual void AfterStart(OpenedQueue queue) { }
private void HandleLoadBalancerMessage(OpenedQueue queue, Message message) { foreach (var msg in DeserializeMessages(queue, message, null)) { var query = msg as QueryForAllKnownWorkersAndEndpoints; if (query != null) { SendKnownWorkersAndKnownEndpoints(message.ResponseQueue); continue; } var queryReadyForWorkQueueUri = msg as QueryReadyForWorkQueueUri; if (queryReadyForWorkQueueUri != null) { SendReadyForWorkQueueUri(message.ResponseQueue); continue; } var work = msg as ReadyToWork; if (work != null) { HandleReadyForWork(queue, work); } HandleLoadBalancerMessages(msg); } }
public OpenedQueue OpenSubQueue(OpenedQueue queue, SubQueue subQueue, QueueAccessMode accessMode) { return(queue.OpenSubQueue(subQueue, accessMode)); }
private void AddWorkerToQueue(OpenedQueue queue, ReadyToWork work) { var persistedWorker = new Message { Formatter = new XmlMessageFormatter(new[] { typeof(string) }), Body = work.Endpoint.ToString(), Label = ("Known worker: " + work.Endpoint).EnsureLabelLength() }; logger.InfoFormat("New worker: {0}", work.Endpoint); queue.Send(persistedWorker.SetSubQueueToSendTo(SubQueue.Workers)); SendToQueue(secondaryLoadBalancer, new NewWorkerPersisted { Endpoint = work.Endpoint }); Raise(SentNewWorkerPersisted); }
private void RemoveSubscriptionMessageFromQueue(OpenedQueue queue, string type, Uri uri) { subscriptionMessageIds.Write(writer => { var key = new TypeAndUriKey { TypeName = type, Uri = uri }; IList<string> messageIds; if (writer.TryGetValue(key, out messageIds) == false) return; foreach (var msgId in messageIds) { queue.ConsumeMessage(msgId); } writer.Remove(key); }); }
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; } }
public void ReceiveMessageInTransaction(OpenedQueue queue, string messageId, Func<CurrentMessageInformation, bool> messageArrived, Action<CurrentMessageInformation, Exception> messageProcessingCompleted) { 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, messageProcessingCompleted); } }
private bool? TryPeek(OpenedQueue queue, out Message message) { try { message = queue.Peek(TimeOutForPeek); } catch (MessageQueueException e) { message = null; if (e.MessageQueueErrorCode != MessageQueueErrorCode.IOTimeout) { logger.Error("Could not peek message from queue", e); return false; } return null; // nothing found } catch (Exception e) { message = null; logger.Error("Could not peek message from queue", e); return false; } return true; }