| public static Parse ( string address ) : MsmqAddress, | ||
| address | string | |
| Результат | MsmqAddress, | |
public async Task ShouldRemoveSubscriptionsInNonTransactionalMode()
{
var address = MsmqAddress.Parse("MsmqSubscriptionStorageQueueTests.PersistNonTransactional");
var queuePath = address.PathWithoutPrefix;
if (MessageQueue.Exists(queuePath))
{
MessageQueue.Delete(queuePath);
}
MessageQueue.Create(queuePath, false);
using (var queue = new MessageQueue(queuePath))
{
queue.Send(new Message
{
Label = "subscriber",
Body = typeof(MyMessage).AssemblyQualifiedName
}, MessageQueueTransactionType.None);
}
var storage = new MsmqSubscriptionStorage(new MsmqSubscriptionStorageQueue(address, false));
storage.Init();
await storage.Unsubscribe(new Subscriber("subscriber", "subscriber"), new MessageType(typeof(MyMessage)), new ContextBag());
using (var queue = new MessageQueue(queuePath))
{
CollectionAssert.IsEmpty(queue.GetAllMessages());
}
}
static bool DoesOldDefaultQueueExists()
{
const string oldDefaultSubscriptionsQueue = "NServiceBus.Subscriptions";
var path = MsmqAddress.Parse(oldDefaultSubscriptionsQueue).PathWithoutPrefix;
return(MessageQueue.Exists(path));
}
/// <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.GetOrDefault <string>("MsmqSubscriptionPersistence.QueueName");
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);
}
context.Container.ConfigureComponent(b =>
{
var queue = new MsmqSubscriptionStorageQueue(MsmqAddress.Parse(queueName));
return(new MsmqSubscriptionStorage(queue));
}, DependencyLifecycle.SingleInstance);
}
public async Task ShouldRemoveSubscriptionsInTransactionalMode()
{
var address = MsmqAddress.Parse(TestQueueName);
var queuePath = address.PathWithoutPrefix;
MessageQueue.Create(queuePath, true);
using (var queue = new MessageQueue(queuePath))
{
queue.Send(new Message
{
Label = "subscriber",
Body = typeof(MyMessage).AssemblyQualifiedName
}, MessageQueueTransactionType.Single);
}
var storage = new MsmqSubscriptionStorage(new MsmqSubscriptionStorageQueue(address, true));
await storage.Unsubscribe(new Subscriber("subscriber", "subscriber"), new MessageType(typeof(MyMessage)), new ContextBag());
using (var queue = new MessageQueue(queuePath))
{
CollectionAssert.IsEmpty(queue.GetAllMessages());
}
}
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);
var bindings = new QueueBindings();
bindings.BindReceiving(testQueueNameForReceiving);
creator.CreateQueueIfNecessary(bindings, WindowsIdentity.GetCurrent().Name);
var existingQueue = GetQueue(testQueueNameForReceiving);
MessageQueueAccessRights?nullBecauseRevoked;
AccessControlEntryType? accessControlEntryType;
Assert.False(existingQueue.TryGetPermissions(LocalEveryoneGroupName, out nullBecauseRevoked, out accessControlEntryType));
Assert.False(existingQueue.TryGetPermissions(LocalAnonymousLogonName, out nullBecauseRevoked, out accessControlEntryType));
Assert.IsNull(accessControlEntryType);
}
void DeleteQueueIfPresent(string queueName)
{
var path = MsmqAddress.Parse(queueName).PathWithoutPrefix;
if (MessageQueue.Exists(path))
{
MessageQueue.Delete(path);
}
}
protected override void Setup(FeatureConfigurationContext context)
{
var configuredQueueName = DetermineStorageQueueName(context.Settings);
context.Settings.Get <QueueBindings>().BindSending(configuredQueueName);
var transportSettings = context.Settings.Get <TransportDefinition>() as MsmqTransport;
var queue = new MsmqSubscriptionStorageQueue(MsmqAddress.Parse(configuredQueueName), transportSettings.UseTransactionalQueues);
var storage = new MsmqSubscriptionStorage(queue);
context.Services.AddSingleton <ISubscriptionStorage>(storage);
}
public void If_machine_name_is_local_ip_is_remote_should_be_false()
{
var machinename = "YOUR MACHINE NAME";
try
{
Dns.GetHostAddresses(machinename);
}
catch
{
Assert.Ignore($"Add `127.0.0.1 {machinename}` to hosts file for this test to run.");
}
Assert.IsFalse(MsmqAddress.Parse("replyToAddress@" + machinename).IsRemote());
}
protected override void Setup(FeatureConfigurationContext context)
{
var configuredQueueName = DetermineStorageQueueName(context.Settings);
context.Settings.Get <QueueBindings>().BindSending(configuredQueueName);
var msmqSettings = new MsmqSettings(context.Settings);
context.Container.ConfigureComponent(b =>
{
var queue = new MsmqSubscriptionStorageQueue(MsmqAddress.Parse(configuredQueueName), msmqSettings.UseTransactionalQueues);
return(new MsmqSubscriptionStorage(queue));
}, DependencyLifecycle.SingleInstance);
}
public static void CheckQueue(string address)
{
var msmqAddress = MsmqAddress.Parse(address);
MessageQueue messageQueue;
if (!MsmqUtilities.TryOpenQueue(msmqAddress, out messageQueue))
{
Logger.Warn($"Unable to open the queue at address '{address}'. Make sure the queue exists, and the address is correct. Processing will still continue.");
return;
}
using (messageQueue)
{
WarnIfPublicAccess(messageQueue);
}
}
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 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 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");
}
}
bool QueueExists(string queueName)
{
var path = MsmqAddress.Parse(queueName).PathWithoutPrefix;
return(MessageQueue.Exists(path));
}
MessageQueue GetQueue(string queueName)
{
var path = MsmqAddress.Parse(queueName).PathWithoutPrefix;
return(new MessageQueue(path));
}
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());
}
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();
}
}
/// <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 Setup()
{
// Create queue "NServiceBus.Subscriptions" to simulate the presence of the old default queue.
queuePath = MsmqAddress.Parse(oldDefaultQueue).PathWithoutPrefix;
MsmqHelpers.CreateQueue(queuePath);
}
