protected virtual ISendToEndpoints BuildPoisonEndpoint(IComponentContext c)
{
// ignore address provided, always send to the configured poison address
var address = new MsmqAddress(this.poisonAddress);
return new MsmqSenderEndpoint(
addr => MsmqConnector.OpenSend(address, PoisonEndpointEnlist),
c.Resolve<ISerializeMessages>());
}
public void If_both_addresses_are_specified_via_ip_it_should_not_convert()
{
var address = new MsmqAddress("replyToAddress", "202.171.13.141");
var returnAddress = address.MakeCompatibleWith(new MsmqAddress("someQueue", "202.171.13.140"), _ =>
{
throw new Exception("Should not call the lookup method");
});
Assert.AreEqual("202.171.13.141", returnAddress.Machine);
}
public static string GetFullPath(MsmqAddress value)
{
IPAddress ipAddress;
if (IPAddress.TryParse(value.Machine, out ipAddress))
{
return PREFIX_TCP + GetFullPathWithoutPrefix(value);
}
return PREFIX + GetFullPathWithoutPrefix(value);
}
public static string GetReturnAddress(string replyToString, string destinationMachine)
{
var replyToAddress = MsmqAddress.Parse(replyToString);
IPAddress targetIpAddress;
//see if the target is an IP address, if so, get our own local ip address
if (IPAddress.TryParse(destinationMachine, out targetIpAddress))
{
if (string.IsNullOrEmpty(localIp))
{
localIp = LocalIpAddress(targetIpAddress);
}
return(PREFIX_TCP + localIp + PRIVATE + replyToAddress.Queue);
}
return(PREFIX + GetFullPathWithoutPrefix(replyToAddress));
}
public void Should_give_everyone_and_anonymous_access_rights_when_creating_queues()
{
var path = MsmqAddress.Parse(testQueueNameForReceiving).PathWithoutPrefix;
using (var queue = MessageQueue.Create(path))
{
Assert.True(queue.TryGetPermissions(LocalEveryoneGroupName, out var everyoneAccessRights, out var accessControlEntryTypeForEveryone));
Assert.True(everyoneAccessRights.HasValue, $"{LocalEveryoneGroupName} should have access rights");
Assert.True(everyoneAccessRights.Value.HasFlag(MessageQueueAccessRights.GenericWrite), $"{LocalEveryoneGroupName} should have GenericWrite access by default");
Assert.True(accessControlEntryTypeForEveryone == AccessControlEntryType.Allow);
Assert.True(queue.TryGetPermissions(LocalAnonymousLogonName, out var anonymousAccessRights, out var accessControlEntryTypeForAnonymous));
Assert.True(anonymousAccessRights.HasValue, $"{LocalAnonymousLogonName} should have access rights");
Assert.True(anonymousAccessRights.Value.HasFlag(MessageQueueAccessRights.WriteMessage), $"{LocalAnonymousLogonName} should have write access by default");
Assert.True(accessControlEntryTypeForAnonymous == AccessControlEntryType.Allow);
}
}
public void Should_not_add_everyone_and_anonymous_to_already_existing_queues()
{
var path = MsmqAddress.Parse(testQueueNameForReceiving).PathWithoutPrefix;
using (var queue = MessageQueue.Create(path))
{
queue.SetPermissions(LocalEveryoneGroupName, MessageQueueAccessRights.GenericWrite, AccessControlEntryType.Revoke);
queue.SetPermissions(LocalAnonymousLogonName, MessageQueueAccessRights.WriteMessage, AccessControlEntryType.Revoke);
}
var creator = new MsmqQueueCreator(true, WindowsIdentity.GetCurrent().Name);
creator.CreateQueueIfNecessary(new[] { testQueueNameForReceiving });
var existingQueue = GetQueue(testQueueNameForReceiving);
Assert.False(existingQueue.TryGetPermissions(LocalEveryoneGroupName, out _, out _));
Assert.False(existingQueue.TryGetPermissions(LocalAnonymousLogonName, out _, out _));
}
public MsmqSubscriptionStorageQueue(MsmqAddress queueAddress, bool useTransactionalQueue)
{
transactionTypeToUseForSend = useTransactionalQueue ? MessageQueueTransactionType.Single : MessageQueueTransactionType.None;
var messageReadPropertyFilter = new MessagePropertyFilter
{
Id = true,
Body = true,
Label = true,
ArrivedTime = true
};
queue = new MessageQueue(queueAddress.FullPath)
{
Formatter = new XmlMessageFormatter(new[]
{
typeof(string)
}),
MessageReadPropertyFilter = messageReadPropertyFilter
};
}
/// <summary>
/// Invoked if the feature is activated.
/// </summary>
/// <param name="context">The feature context.</param>
protected internal override void Setup(FeatureConfigurationContext context)
{
var queueName = context.Settings.GetConfiguredMsmqPersistenceSubscriptionQueue();
var cfg = context.Settings.GetConfigSection <MsmqSubscriptionStorageConfig>();
if (string.IsNullOrEmpty(queueName))
{
if (cfg == null)
{
Logger.Warn("Could not find configuration section for Msmq Subscription Storage and no name was specified for this endpoint. Going to default the subscription queue");
queueName = "NServiceBus.Subscriptions";
}
else
{
queueName = cfg.Queue;
}
}
if (queueName != null)
{
context.Settings.Get <QueueBindings>().BindSending(queueName);
}
var useTransactionalStorageQueue = true;
MsmqSettings msmqSettings;
if (context.Settings.TryGet(out msmqSettings))
{
useTransactionalStorageQueue = msmqSettings.UseTransactionalQueues;
}
context.Container.ConfigureComponent(b =>
{
var queue = new MsmqSubscriptionStorageQueue(MsmqAddress.Parse(queueName), useTransactionalStorageQueue);
return(new MsmqSubscriptionStorage(queue));
}, DependencyLifecycle.SingleInstance);
}
public void Should_give_everyone_and_anonymous_access_rights_when_creating_queues()
{
var testQueueName = "MsmqQueueCreatorTests.MsmqDefaultPermissions";
DeleteQueueIfPresent(testQueueName);
var path = MsmqAddress.Parse(testQueueName).PathWithoutPrefix;
using (var queue = MessageQueue.Create(path))
{
MessageQueueAccessRights?everyoneAccessRights;
Assert.True(queue.TryGetPermissions(LocalEveryoneGroupName, out everyoneAccessRights));
Assert.True(everyoneAccessRights.HasValue, "User should have access rights");
Assert.AreEqual(MessageQueueAccessRights.GenericWrite, everyoneAccessRights, "Msmq should give 'everyone' write access by default");
MessageQueueAccessRights?anonymousAccessRights;
Assert.True(queue.TryGetPermissions(LocalAnonymousLogonName, out anonymousAccessRights));
Assert.True(anonymousAccessRights.HasValue, "User should have access rights");
Assert.AreEqual(MessageQueueAccessRights.WriteMessage, anonymousAccessRights, "Msmq should give 'anonymous' write access by default");
}
}
/// <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 headers = MsmqUtilities.ExtractHeaders(message);
string failedQ;
if (!headers.TryGetValue(Headers.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(MsmqAddress.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 headers = MsmqUtilities.ExtractHeaders(m);
var originalId = GetOriginalId(headers);
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 = headers[Headers.FailedQ];
using (var q = new MessageQueue(MsmqUtilities.GetFullPath(MsmqAddress.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);
}
}
}
}
public void If_machine_is_looplocal_is_specified_is_remote_should_be_false(string machine)
{
Assert.IsFalse(MsmqAddress.Parse("replyToAddress@" + machine).IsRemote());
}
public void If_local_machine_name_is_remote_should_be_false()
{
Assert.IsFalse(MsmqAddress.Parse("replyToAddress@" + Environment.MachineName).IsRemote());
}
MessageQueue GetQueue(string queueName)
{
var path = MsmqAddress.Parse(queueName).PathWithoutPrefix;
return(new MessageQueue(path));
}
bool QueueExists(string queueName)
{
var path = MsmqAddress.Parse(queueName).PathWithoutPrefix;
return(MessageQueue.Exists(path));
}
public static string GetFullPathWithoutPrefix(MsmqAddress address)
{
return(GetFullPathWithoutPrefix(address.Queue, address.Machine));
}
public void If_reference_address_is_specified_via_ip_and_this_is_specified_via_host_name_it_should_convert_to_ip()
{
var address = new MsmqAddress("replyToAddress", "replyToMachine");
var returnAddress = address.MakeCompatibleWith(new MsmqAddress("someQueue", "202.171.13.140"), _ => "10.10.10.10");
Assert.AreEqual("10.10.10.10", returnAddress.Machine);
}
public void Setup()
{
// Create queue "NServiceBus.Subscriptions" to simulate the presence of the old default queue.
queuePath = MsmqAddress.Parse(oldDefaultQueue).PathWithoutPrefix;
MsmqHelpers.CreateQueue(queuePath);
}
static void Main(string[] args)
{
var errorManager = new ErrorManager();
string inputQueue = null;
string messageId = null;
if (args != null && args.Length > 0)
{
inputQueue = args[0];
}
if (args != null && args.Length > 1)
{
messageId = args[1];
}
var script = true;
if (inputQueue == null)
{
Console.WriteLine("NServiceBus ReturnToSource for MSMQ");
Console.WriteLine("by Particular Software Ltd. \n");
Console.WriteLine("Please enter the error queue you would like to use:");
inputQueue = Console.ReadLine();
if (string.IsNullOrWhiteSpace(inputQueue))
{
Console.WriteLine("No error queue specified");
Console.WriteLine("\nPress 'Enter' to exit.");
Console.ReadLine();
return;
}
script = false;
}
var errorQueueAddress = MsmqAddress.Parse(inputQueue);
if (!IsLocalIpAddress(errorQueueAddress.Machine))
{
Console.WriteLine("Input queue [{0}] resides on a remote machine: [{1}].", errorQueueAddress.Queue, errorQueueAddress.Machine);
Console.WriteLine("Due to networking load, it is advised to refrain from using ReturnToSourceQueue on a remote error queue, unless the error queue resides on a clustered machine.");
if (!script)
{
Console.WriteLine(
"Press 'y' if the error queue resides on a Clustered Machine, otherwise press any key to exit.");
if (Console.ReadKey().Key.ToString().ToLower() != "y")
{
return;
}
}
Console.WriteLine(string.Empty);
errorManager.ClusteredQueue = true;
}
if (messageId == null)
{
Console.WriteLine("Please enter the id of the message you'd like to return to its source queue, or 'all' to do so for all messages in the queue.");
messageId = Console.ReadLine();
}
errorManager.InputQueue = errorQueueAddress;
Console.WriteLine("Attempting to return message to source queue. Queue: [{0}], message id: [{1}]. Please stand by.",
errorQueueAddress, messageId);
try
{
if (messageId == "all")
{
errorManager.ReturnAll();
}
else
{
errorManager.ReturnMessageToSourceQueue(messageId);
}
if (args == null || args.Length == 0)
{
Console.WriteLine("Press 'Enter' to exit.");
Console.ReadLine();
}
}
catch (Exception e)
{
Console.WriteLine("Could not return message to source queue. Reason: " + e.Message);
Console.WriteLine(e.StackTrace);
Console.WriteLine("\nPress 'Enter' to exit.");
Console.ReadLine();
}
}
public static string GetFullPathWithoutPrefix(MsmqAddress address)
{
return GetFullPathWithoutPrefix(address.Queue, address.Machine);
}
