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