public void Should_use_the_non_durable_setting() { var options = new DispatchOptions(new UnicastAddressTag("destination"), DispatchConsistency.Default, new List <DeliveryConstraint> { new NonDurableDelivery() }); Assert.False(MsmqUtilities.Convert(new OutgoingMessage("message id", new Dictionary <string, string>(), new byte[0]), options).Recoverable); Assert.True(MsmqUtilities.Convert(new OutgoingMessage("message id", new Dictionary <string, string>(), new byte[0]), new DispatchOptions(new UnicastAddressTag("destination"), DispatchConsistency.Default, new List <DeliveryConstraint>())).Recoverable); }
public void Should_fetch_the_replyToAddress_from_responsequeue_for_backwards_compatibility() { var message = MsmqUtilities.Convert(new OutgoingMessage("message id", new Dictionary <string, string>(), new byte[0]), new DispatchOptions(new UnicastAddressTag("destination"), DispatchConsistency.Default)); message.ResponseQueue = new MessageQueue(new MsmqAddress("local", Environment.MachineName).FullPath); var headers = MsmqUtilities.ExtractHeaders(message); Assert.AreEqual("local@" + Environment.MachineName, headers[Headers.ReplyToAddress]); }
public void Should_fetch_the_replyToAddress_from_responsequeue_for_backwards_compatibility() { Message message = MsmqUtilities.Convert( new OutgoingMessage("message id", new Dictionary <string, string>(), new byte[0])); message.ResponseQueue = new MessageQueue(new MsmqAddress("local", RuntimeEnvironment.MachineName).FullPath); Dictionary <string, string> headers = MsmqUtilities.ExtractHeaders(message); Assert.AreEqual("local@" + RuntimeEnvironment.MachineName, headers[Headers.ReplyToAddress]); }
public void Should_use_the_TTBR_in_the_send_options_if_set() { var options = new DispatchOptions(new UnicastAddressTag("destination"), DispatchConsistency.Default, new List <DeliveryConstraint> { new DiscardIfNotReceivedBefore(TimeSpan.FromDays(1)) }); var message = MsmqUtilities.Convert(new OutgoingMessage("message id", new Dictionary <string, string>(), new byte[0]), options); Assert.AreEqual(TimeSpan.FromDays(1), message.TimeToBeReceived); }
public void Should_set_messageIntent_if_header_not_present() { Message message = MsmqUtilities.Convert( new OutgoingMessage("message id", new Dictionary <string, string> (), new byte[0])); message.AppSpecific = 3; //Send = 1, Publish = 2, Subscribe = 3, Unsubscribe = 4 and Reply = 5 Dictionary <string, string> headers = MsmqUtilities.ExtractHeaders(message); Assert.AreEqual("Subscribe", headers[Headers.MessageIntent]); }
public void Should_use_the_TTBR_in_the_send_options_if_set() { var deliveryConstraints = new List <DeliveryConstraint> { new DiscardIfNotReceivedBefore(TimeSpan.FromDays(1)) }; var message = MsmqUtilities.Convert(new OutgoingMessage("message id", new Dictionary <string, string>(), new byte[0]), deliveryConstraints); Assert.AreEqual(TimeSpan.FromDays(1), message.TimeToBeReceived); }
public void Should_use_the_non_durable_setting() { var nonDurableDeliveryConstraint = new List <DeliveryConstraint> { new NonDurableDelivery() }; var durableDeliveryConstraint = new List <DeliveryConstraint>(); Assert.False(MsmqUtilities.Convert(new OutgoingMessage("message id", new Dictionary <string, string>(), new byte[0]), nonDurableDeliveryConstraint).Recoverable); Assert.True(MsmqUtilities.Convert(new OutgoingMessage("message id", new Dictionary <string, string>(), new byte[0]), durableDeliveryConstraint).Recoverable); }
public void Should_fetch_the_replytoaddress_from_responsequeue_for_backwards_compatibility() { var transportMessage = new TransportMessage(); var message = MsmqUtilities.Convert(transportMessage); message.ResponseQueue = new MessageQueue(MsmqUtilities.GetReturnAddress("local", "destination")); var result = MsmqUtilities.Convert(message); Assert.AreEqual("local@" + Environment.MachineName, result.Headers[Headers.ReplyToAddress]); }
public void Should_convert_a_message_back_even_if_special_characters_are_contained_in_the_headers() { var expected = $"Can u see this '{(char)0x19}' character."; var message = MsmqUtilities.Convert(new OutgoingMessage("message id", new Dictionary <string, string> { { "NServiceBus.ExceptionInfo.Message", expected } }, new byte[0]), new DispatchProperties()); var headers = MsmqUtilities.ExtractHeaders(message); Assert.AreEqual(expected, headers["NServiceBus.ExceptionInfo.Message"]); }
public void Should_convert_a_message_back_even_if_special_characters_are_contained_in_the_headers() { var expected = String.Format("Can u see this '{0}' character!", (char)0x19); var transportMessage = new TransportMessage(); transportMessage.Headers.Add("NServiceBus.ExceptionInfo.Message", expected); var message = MsmqUtilities.Convert(transportMessage); var result = MsmqUtilities.Convert(message); Assert.AreEqual(expected, result.Headers["NServiceBus.ExceptionInfo.Message"]); }
void ISendMessages.Send(TransportMessage message, Address address) { var queuePath = MsmqUtilities.GetFullPath(address); try { using (var q = new MessageQueue(queuePath, QueueAccessMode.Send)) { var toSend = MsmqUtilities.Convert(message); toSend.UseDeadLetterQueue = UseDeadLetterQueue; toSend.UseJournalQueue = UseJournalQueue; if (message.ReplyToAddress != null) { toSend.ResponseQueue = new MessageQueue(MsmqUtilities.GetReturnAddress(message.ReplyToAddress.ToString(), address.ToString())); } q.Send(toSend, GetTransactionTypeForSend()); message.Id = toSend.Id; } } catch (MessageQueueException ex) { string msg = string.Empty; if (ex.MessageQueueErrorCode == MessageQueueErrorCode.QueueNotFound) { if (address == null) { msg = "Failed to send message."; } else { msg = string.Format("Failed to send message to address: {0}@{1}", address.Queue, address.Machine); } } throw new QueueNotFoundException(address, msg, ex); } catch (Exception ex) { if (address == null) { throw new FailedToSendMessageException("Failed to send message.", ex); } else { throw new FailedToSendMessageException(string.Format("Failed to send message to address: {0}@{1}", address.Queue, address.Machine), ex); } } }
public void Should_not_override_replyToAddress() { Message message = MsmqUtilities.Convert( new OutgoingMessage("message id", new Dictionary <string, string> { { Headers.ReplyToAddress, "SomeAddress" } }, new byte[0])); message.ResponseQueue = new MessageQueue(new MsmqAddress("local", RuntimeEnvironment.MachineName).FullPath); Dictionary <string, string> headers = MsmqUtilities.ExtractHeaders(message); Assert.AreEqual("SomeAddress", headers[Headers.ReplyToAddress]); }
public void Should_convert_a_message_back_even_if_special_characters_are_contained_in_the_headers() { var expected = $"Can u see this '{(char) 0x19}' character."; var options = new DispatchOptions(new UnicastAddressTag("destination"), DispatchConsistency.Default); var message = MsmqUtilities.Convert(new OutgoingMessage("message id", new Dictionary <string, string> { { "NServiceBus.ExceptionInfo.Message", expected } }, new byte[0]), options); var headers = MsmqUtilities.ExtractHeaders(message); Assert.AreEqual(expected, headers["NServiceBus.ExceptionInfo.Message"]); }
public void Should_not_override_messageIntent() { var message = MsmqUtilities.Convert( new OutgoingMessage("message id", new Dictionary <string, string> { { Headers.MessageIntent, MessageIntentEnum.Send.ToString() } }, new byte[0]), new DispatchProperties()); message.AppSpecific = 3; //Send = 1, Publish = 2, Subscribe = 3, Unsubscribe = 4 and Reply = 5 var headers = MsmqUtilities.ExtractHeaders(message); Assert.AreEqual("Send", headers[Headers.MessageIntent]); }
public static Address GetReplyToAddress(TransportMessage message) { var failedQ = GetHeader(message, Faults.FaultsHeaderKeys.FailedQ); if (string.IsNullOrEmpty(failedQ)) { failedQ = MessageHelpers.GetFailedQueueFromLabel(MsmqUtilities.Convert(message)); } if (string.IsNullOrEmpty(failedQ)) { throw new Exception("Could not find address"); } return(Address.Parse(failedQ)); }
public void Should_convert_message_headers_that_contain_nulls_at_the_end() { var expected = "Hello World"; Console.Out.WriteLine(sizeof(char)); var message = MsmqUtilities.Convert(new OutgoingMessage("message id", new Dictionary <string, string> { { "NServiceBus.ExceptionInfo.Message", expected } }, new byte[0]), new DispatchProperties()); var bufferWithNulls = new byte[message.Extension.Length + (10 * sizeof(char))]; Buffer.BlockCopy(message.Extension, 0, bufferWithNulls, 0, bufferWithNulls.Length - (10 * sizeof(char))); message.Extension = bufferWithNulls; var headers = MsmqUtilities.ExtractHeaders(message); Assert.AreEqual(expected, headers["NServiceBus.ExceptionInfo.Message"]); }
void ISendMessages.Send(TransportMessage message, Address address) { var queuePath = MsmqUtilities.GetFullPath(address); try { using (var q = new MessageQueue(queuePath, false, true, QueueAccessMode.Send)) { using (Message toSend = MsmqUtilities.Convert(message)) { toSend.UseDeadLetterQueue = UseDeadLetterQueue; toSend.UseJournalQueue = UseJournalQueue; if (message.ReplyToAddress != null) { toSend.ResponseQueue = new MessageQueue(MsmqUtilities.GetReturnAddress(message.ReplyToAddress.ToString(), address.ToString())); } q.Send(toSend, GetTransactionTypeForSend()); message.Id = toSend.Id; } } } catch (MessageQueueException ex) { if (ex.MessageQueueErrorCode == MessageQueueErrorCode.QueueNotFound) { var msg = address == null ? "Failed to send message. Target address is null." : string.Format("Failed to send message to address: [{0}]", address); throw new QueueNotFoundException(address, msg, ex); } ThrowFailedToSendException(address, ex); } catch (Exception ex) { ThrowFailedToSendException(address, ex); } }
public void Should_convert_message_headers_that_contain_nulls_at_the_end() { var expected = "Hello World!"; var transportMessage = new TransportMessage(); transportMessage.Headers.Add("NServiceBus.ExceptionInfo.Message", expected); Console.Out.WriteLine(sizeof(char)); var message = MsmqUtilities.Convert(transportMessage); var bufferWithNULLs = new byte[message.Extension.Length + (10 * sizeof(char))]; Buffer.BlockCopy(message.Extension, 0, bufferWithNULLs, 0, bufferWithNULLs.Length - (10 * sizeof(char))); message.Extension = bufferWithNULLs; var result = MsmqUtilities.Convert(message); Assert.AreEqual(expected, result.Headers["NServiceBus.ExceptionInfo.Message"]); }
public void Should_deserialize_if_trailing_bogus_data() { var expected = "Hello World"; var message = MsmqUtilities.Convert(new OutgoingMessage("message id", new Dictionary <string, string> { { "NServiceBus.ExceptionInfo.Message", expected } }, new byte[0]), new DispatchProperties()); var r = new Random(); var bufferWithNulls = new byte[message.Extension.Length + (10 * sizeof(char))]; r.NextBytes(bufferWithNulls); Buffer.BlockCopy(message.Extension, 0, bufferWithNulls, 0, bufferWithNulls.Length - (10 * sizeof(char))); message.Extension = bufferWithNulls; var headers = MsmqUtilities.ExtractHeaders(message); Assert.AreEqual(expected, headers["NServiceBus.ExceptionInfo.Message"]); }
void ISendMessages.Send(TransportMessage message, Address address) { var queuePath = MsmqUtilities.GetFullPath(address); using (var q = new MessageQueue(queuePath, QueueAccessMode.Send)) { var toSend = MsmqUtilities.Convert(message); toSend.UseDeadLetterQueue = UseDeadLetterQueue; toSend.UseJournalQueue = UseJournalQueue; if (message.ReplyToAddress != null) { toSend.ResponseQueue = new MessageQueue(MsmqUtilities.GetReturnAddress(message.ReplyToAddress.ToString(), address.ToString())); } try { q.Send(toSend, GetTransactionTypeForSend()); } catch (MessageQueueException ex) { if (ex.MessageQueueErrorCode == MessageQueueErrorCode.QueueNotFound) { throw new QueueNotFoundException { Queue = address } } ; throw; } message.Id = toSend.Id; } }
//public void ReturnMessageToSource(string id) //{ // using (TransactionScope scope = new TransactionScope()) // { // Message m = queue.ReceiveById(id, TimeSpan.FromSeconds(5), MessageQueueTransactionType.Automatic); // using (MessageQueue q = new MessageQueue(failedQueue)) // { // q.Send(m, MessageQueueTransactionType.Automatic); // } // scope.Complete(); // } //} /// <summary> /// May throw a timeout exception if a message with the given id cannot be found. /// </summary> /// <param name="messageId"></param> public void ReturnMessageToSourceQueue() { using (var scope = new TransactionScope()) { try { var message = queue.Receive(MessageQueueTransactionType.Automatic); var tm = MsmqUtilities.Convert(message); string failedQ; if (tm.Headers.ContainsKey(NServiceBus.Faults.FaultsHeaderKeys.FailedQ)) { failedQ = tm.Headers[NServiceBus.Faults.FaultsHeaderKeys.FailedQ]; } else // try to bring failedQ from label, v2.6 style. { failedQ = GetFailedQueueFromLabel(message); if (!string.IsNullOrEmpty(failedQ)) { message.Label = GetLabelWithoutFailedQueue(message); } } if (string.IsNullOrEmpty(failedQ)) { Console.WriteLine("ERROR: Message does not have a header (or label) indicating from which queue it came. Cannot be automatically returned to queue."); return; } using (var q = new MessageQueue(MsmqUtilities.GetFullPath(Address.Parse(failedQ)))) q.Send(message, MessageQueueTransactionType.Automatic); Console.WriteLine("Success."); scope.Complete(); } catch (MessageQueueException ex) { Console.WriteLine("cannot send error: " + ex.Message); //if (ex.MessageQueueErrorCode == MessageQueueErrorCode.IOTimeout) //{ // Console.WriteLine(NoMessageFoundErrorFormat, messageId); // foreach (var m in queue.GetAllMessages()) // { // var tm = MsmqUtilities.Convert(m); // if (tm.Headers.ContainsKey(TransportHeaderKeys.OriginalId)) // { // if (messageId != tm.Headers[TransportHeaderKeys.OriginalId]) // continue; // Console.WriteLine("Found message - going to return to queue."); // using (var tx = new TransactionScope()) // { // using (var q = new MessageQueue( // MsmqUtilities.GetFullPath( // Address.Parse(tm.Headers[NServiceBus.Faults.FaultsHeaderKeys.FailedQ])))) // q.Send(m, MessageQueueTransactionType.Automatic); // queue.ReceiveByLookupId(MessageLookupAction.Current, m.LookupId, // MessageQueueTransactionType.Automatic); // tx.Complete(); // } // Console.WriteLine("Success."); // scope.Complete(); // return; // } // } //} } } }
void RetryMessageImportById(string messageID) { // Try to get the batchErrorLock, if we can't then exit, // the message will trigger a retry next time on the next batch read. // Retrymessage may be fired again for the same message until the batches drain so this // prevents the message being processed twice, if (Monitor.TryEnter(batchErrorLockObj)) { try { Logger.DebugFormat("Drain stop running batch importers"); stopping = true; var runningTasks = batchTaskTracker.Active(); Task.WaitAll(runningTasks); var commitTransaction = false; using (var queueReceiver = CreateReceiver()) using (var msmqTransaction = new MessageQueueTransaction()) { msmqTransaction.Begin(); Logger.DebugFormat("Retry import of messageID - {0}", messageID); try { Message message; TransportMessage transportMessage; try { message = queueReceiver.ReceiveById(messageID); performanceCounters.MessageDequeued(); } catch (Exception exception) { importFailuresHandler.FailedToReceive(exception); //logs and increments circuit breaker return; } try { transportMessage = MsmqUtilities.Convert(message); } catch (Exception convertException) { importFailuresHandler.FailedToReceive(convertException); //logs and increments circuit breaker serviceControlErrorQueue.Send(message, msmqTransaction); // Send unconvertable message to SC's ErrorQueue so it's not lost commitTransaction = true; // Can't convert the messsage, so commit to get message out of the queue return; } try { var importSuccessfullyProcessedMessage = new ImportSuccessfullyProcessedMessage(transportMessage); foreach (var enricher in enrichers) { enricher.Enrich(importSuccessfullyProcessedMessage); } using (var session = store.OpenSession()) { var auditMessage = new ProcessedMessage(importSuccessfullyProcessedMessage); session.Store(auditMessage); session.SaveChanges(); } performanceCounters.MessageProcessed(); if (Settings.ForwardAuditMessages == true) { Forwarder.Send(transportMessage, Settings.AuditLogQueue); } commitTransaction = true; } catch (Exception importException) { importFailuresHandler.Log(transportMessage, importException); //Logs and Writes failure transport message to Raven } } finally { if (commitTransaction) { msmqTransaction.Commit(); } } } } finally { Monitor.Exit(batchErrorLockObj); //Restart Batch mode stopping = false; Logger.Debug("Ready to BeginPeek again"); queuePeeker.BeginPeek(); } } }
public void Should_use_durable_setting() { Assert.True(MsmqUtilities.Convert(new OutgoingMessage("message id", new Dictionary <string, string>(), new byte[0]), new DispatchProperties()).Recoverable); }
void BatchImporter() { String failedMessageID = null; try { Logger.DebugFormat("Batch job started", Task.CurrentId); var moreMessages = 0; using (var queueReceiver = CreateReceiver()) { do { if (moreMessages > RampUpConcurrencyMagicNumber) { if (TryStartNewBatchImporter()) { Logger.Debug("We have too many messages, starting another batch importer"); moreMessages = 0; //Reset to 0 so we only ramp up once per BatchImporter } } moreMessages++; using (var msmqTransaction = new MessageQueueTransaction()) { msmqTransaction.Begin(); using (var bulkInsert = store.BulkInsert(options: new BulkInsertOptions { CheckForUpdates = true })) { for (var idx = 0; idx < BatchSize; idx++) { Message message = null; TransportMessage transportMessage; try { message = queueReceiver.Receive(receiveTimeout, msmqTransaction); performanceCounters.MessageDequeued(); transportMessage = MsmqUtilities.Convert(message); } catch (MessageQueueException mqe) { if (mqe.MessageQueueErrorCode == MessageQueueErrorCode.IOTimeout) { moreMessages = 0; break; } throw; } catch (Exception) { if (message != null) { failedMessageID = message.Id; } throw; } try { var importSuccessfullyProcessedMessage = new ImportSuccessfullyProcessedMessage(transportMessage); foreach (var enricher in enrichers) { enricher.Enrich(importSuccessfullyProcessedMessage); } var auditMessage = new ProcessedMessage(importSuccessfullyProcessedMessage); bulkInsert.Store(auditMessage); performanceCounters.MessageProcessed(); if (Settings.ForwardAuditMessages == true) { Forwarder.Send(transportMessage, Settings.AuditLogQueue); } } catch (Exception) { if (message != null) { failedMessageID = message.Id; } throw; } } } msmqTransaction.Commit(); } } while (moreMessages > 0 && !stopping); } Logger.Debug("Stopping batch importer"); } finally { if (!String.IsNullOrEmpty(failedMessageID)) { // Call RetryMessageImportById outside the Task as it checks for running tasks ThreadPool.QueueUserWorkItem(state => RetryMessageImportById(failedMessageID)); } countDownEvent.Decrement(); } }
/// <summary> /// May throw a timeout exception if a message with the given id cannot be found. /// </summary> public void ReturnMessageToSourceQueue(string messageId) { using (var scope = new TransactionScope()) { try { var message = queue.ReceiveById(messageId, TimeoutDuration, MessageQueueTransactionType.Automatic); var tm = MsmqUtilities.Convert(message); string failedQ; if (!tm.Headers.TryGetValue(FaultsHeaderKeys.FailedQ, out failedQ)) { Console.WriteLine("ERROR: Message does not have a header indicating from which queue it came. Cannot be automatically returned to queue."); return; } using (var q = new MessageQueue(MsmqUtilities.GetFullPath(Address.Parse(failedQ)))) { q.Send(message, MessageQueueTransactionType.Automatic); } Console.WriteLine("Success."); scope.Complete(); } catch (MessageQueueException ex) { if (ex.MessageQueueErrorCode == MessageQueueErrorCode.IOTimeout) { Console.WriteLine(NoMessageFoundErrorFormat, messageId); uint messageCount = 0; foreach (var m in queue.GetAllMessages()) { messageCount++; var tm = MsmqUtilities.Convert(m); var originalId = GetOriginalId(tm); if (string.IsNullOrEmpty(originalId) || messageId != originalId) { if (messageCount % ProgressInterval == 0) { Console.Write("."); } continue; } Console.WriteLine(); Console.WriteLine("Found message - going to return to queue."); using (var tx = new TransactionScope()) { var failedQueue = tm.Headers[FaultsHeaderKeys.FailedQ]; using (var q = new MessageQueue(MsmqUtilities.GetFullPath(Address.Parse(failedQueue)))) { q.Send(m, MessageQueueTransactionType.Automatic); } queue.ReceiveByLookupId(MessageLookupAction.Current, m.LookupId, MessageQueueTransactionType.Automatic); tx.Complete(); } Console.WriteLine("Success."); scope.Complete(); return; } Console.WriteLine(); Console.WriteLine(NoMessageFoundInHeadersErrorFormat, messageId); } } } }
/// <summary> /// May throw a timeout exception if a message with the given id cannot be found. /// </summary> /// <param name="messageId"></param> public void ReturnMessageToSourceQueue(string messageId) { using (var scope = new TransactionScope()) { try { var message = queue.ReceiveById(messageId, TimeoutDuration, MessageQueueTransactionType.Automatic); var tm = MsmqUtilities.Convert(message); string failedQ; if (tm.Headers.ContainsKey(Faults.FaultsHeaderKeys.FailedQ)) { failedQ = tm.Headers[Faults.FaultsHeaderKeys.FailedQ]; } else // try to bring failedQ from label, v2.6 style. { failedQ = GetFailedQueueFromLabel(message); if (!string.IsNullOrEmpty(failedQ)) { message.Label = GetLabelWithoutFailedQueue(message); } } if (string.IsNullOrEmpty(failedQ)) { Console.WriteLine("ERROR: Message does not have a header (or label) indicating from which queue it came. Cannot be automatically returned to queue."); return; } using (var q = new MessageQueue(MsmqUtilities.GetFullPath(Address.Parse(failedQ)))) q.Send(message, MessageQueueTransactionType.Automatic); Console.WriteLine("Success."); scope.Complete(); } catch (MessageQueueException ex) { if (ex.MessageQueueErrorCode == MessageQueueErrorCode.IOTimeout) { Console.WriteLine(NoMessageFoundErrorFormat, messageId); foreach (var m in queue.GetAllMessages()) { var tm = MsmqUtilities.Convert(m); string originalId = null; if (tm.Headers.ContainsKey("NServiceBus.OriginalId")) { originalId = tm.Headers["NServiceBus.OriginalId"]; } if (string.IsNullOrEmpty(originalId) && tm.Headers.ContainsKey("CorrId")) { originalId = tm.Headers["CorrId"]; } if (string.IsNullOrEmpty(originalId) || messageId != originalId) { continue; } Console.WriteLine("Found message - going to return to queue."); using (var tx = new TransactionScope()) { using (var q = new MessageQueue( MsmqUtilities.GetFullPath( Address.Parse(tm.Headers[Faults.FaultsHeaderKeys.FailedQ])))) q.Send(m, MessageQueueTransactionType.Automatic); queue.ReceiveByLookupId(MessageLookupAction.Current, m.LookupId, MessageQueueTransactionType.Automatic); tx.Complete(); } Console.WriteLine("Success."); scope.Complete(); return; } } } } }
/// <summary> /// May throw a timeout exception if a message with the given id cannot be found. /// </summary> /// <param name="messageId"></param> public void ReturnMessageToSourceQueue(string messageId) { using (var scope = new TransactionScope()) { try { var message = queue.ReceiveById(messageId, TimeoutDuration, MessageQueueTransactionType.Automatic); var tm = MsmqUtilities.Convert(message); if (!tm.Headers.ContainsKey(Faults.HeaderKeys.FailedQ)) { Console.WriteLine("ERROR: Message does not have a header indicating from which queue it came. Cannot be automatically returned to queue."); return; } using (var q = new MessageQueue(MsmqUtilities.GetFullPath(Address.Parse(tm.Headers[Faults.HeaderKeys.FailedQ])))) q.Send(message, MessageQueueTransactionType.Automatic); Console.WriteLine("Success."); scope.Complete(); } catch (MessageQueueException ex) { if (ex.MessageQueueErrorCode == MessageQueueErrorCode.IOTimeout) { Console.WriteLine(NoMessageFoundErrorFormat, messageId); foreach (var m in queue.GetAllMessages()) { var tm = MsmqUtilities.Convert(m); if (tm.Headers.ContainsKey(Faults.HeaderKeys.OriginalId)) { if (messageId != tm.Headers[Faults.HeaderKeys.OriginalId]) { continue; } Console.WriteLine("Found message - going to return to queue."); using (var tx = new TransactionScope(TransactionScopeOption.RequiresNew)) { using (var q = new MessageQueue( MsmqUtilities.GetFullPath( Address.Parse(tm.Headers[Faults.HeaderKeys.FailedQ])))) q.Send(m, MessageQueueTransactionType.Automatic); queue.ReceiveByLookupId(MessageLookupAction.Current, m.LookupId, MessageQueueTransactionType.Automatic); tx.Complete(); } Console.WriteLine("Success."); scope.Complete(); return; } } } } } }