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