public async Task Should_not_update_properties_of_an_existing_system_queue()
{
var queuePath = "errorQ";
var namespaceManager = new NamespaceManagerAdapter(NamespaceManager.CreateFromConnectionString(AzureServiceBusConnectionString.Value));
await namespaceManager.DeleteQueue(queuePath).ConfigureAwait(false);
if (!await namespaceManager.QueueExists(queuePath).ConfigureAwait(false))
{
await namespaceManager.CreateQueue(new QueueDescription(queuePath)).ConfigureAwait(false);
}
var settings = new DefaultConfigurationValues().Apply(new SettingsHolder());
settings.Set(WellKnownConfigurationKeys.Core.RecoverabilityNumberOfImmediateRetries, 2);
var queueBindings = new QueueBindings();
queueBindings.BindSending(queuePath);
settings.Set <QueueBindings>(queueBindings);
var extensions = new TransportExtensions <AzureServiceBusTransport>(settings);
extensions.Queues().MaxDeliveryCount(2);
var creator = new AzureServiceBusQueueCreator(settings);
await creator.Create(queuePath, namespaceManager);
var real = await namespaceManager.GetQueue(queuePath);
Assert.That(real.MaxDeliveryCount, Is.EqualTo(10));
//cleanup
await namespaceManager.DeleteQueue(queuePath);
}
public void Should_set_replyto_address_to_destination_if_multiple_available_with_respect_to_secured_connection_strings_setting(bool shouldSecureConnectionString, string expectedReplyToAddress)
{
var settings = new DefaultConfigurationValues().Apply(new SettingsHolder());
var converter = new DefaultBatchedOperationsToBrokeredMessagesConverter(settings);
settings.Set(WellKnownConfigurationKeys.Topology.Addressing.UseNamespaceAliasesInsteadOfConnectionStrings, shouldSecureConnectionString);
var namespaces = new NamespaceConfigurations(new List <NamespaceInfo>
{
new NamespaceInfo("alias1", "Endpoint=sb://name-x.servicebus.windows.net;SharedAccessKeyName=keyname;SharedAccessKey=key"),
new NamespaceInfo("alias2", "Endpoint=sb://name-y.servicebus.windows.net;SharedAccessKeyName=keyname;SharedAccessKey=key")
});
settings.Set(WellKnownConfigurationKeys.Topology.Addressing.Namespaces, namespaces);
var headers = new Dictionary <string, string>()
{
{ Headers.ReplyToAddress, "MyQueue" }
};
var batchedOperation = new BatchedOperation
{
Message = new OutgoingMessage("SomeId", headers, new byte[0]),
DeliveryConstraints = new List <DeliveryConstraint>()
};
var brokeredMessage = converter.Convert(batchedOperation, new RoutingOptions()
{
DestinationNamespace = new RuntimeNamespaceInfo("alias2", "Endpoint=sb://name-y.servicebus.windows.net;SharedAccessKeyName=keyname;SharedAccessKey=key")
});
Assert.That(brokeredMessage.ReplyTo, Is.EqualTo(expectedReplyToAddress));
}
public void Replaces_factories_when_closed()
{
var settings = new DefaultConfigurationValues().Apply(new SettingsHolder());
settings.Set(WellKnownConfigurationKeys.Connectivity.MessagingFactories.NumberOfMessagingFactoriesPerNamespace, 1); // pool size of 1 simplifies the test
var creator = new InterceptedFactoryCreator();
var lifecycleManager = new MessagingFactoryLifeCycleManager(creator, settings);
var first = (InterceptedFactory)lifecycleManager.Get(AzureServiceBusConnectionString.Value);
first.Close();
var second = (InterceptedFactory)lifecycleManager.Get(AzureServiceBusConnectionString.Value);
Assert.AreEqual(2, creator.InvocationCount);
Assert.AreNotEqual(first, second);
}
public void Replaces_receivers_when_closed()
{
var settings = new DefaultConfigurationValues().Apply(new SettingsHolder());
settings.Set(WellKnownConfigurationKeys.Connectivity.NumberOfClientsPerEntity, 1); // pool size of 1 simplifies the test
var creator = new InterceptedMessageReceiverCreator();
var lifecycleManager = new MessageReceiverLifeCycleManager(creator, settings);
var first = (InterceptedMessageReceiver)lifecycleManager.Get("myqueue", AzureServiceBusConnectionString.Value);
first.Close();
var second = (InterceptedMessageReceiver)lifecycleManager.Get("myqueue", AzureServiceBusConnectionString.Value);
Assert.AreEqual(2, creator.InvocationCount);
Assert.AreNotEqual(first, second);
}
public async Task Should_dispatch_multiple_batches()
{
// cleanup
await TestUtility.Delete("myqueue", "myqueue2");
// default settings
var settings = new DefaultConfigurationValues().Apply(new SettingsHolder());
settings.Set("NServiceBus.SharedQueue", "myqueue");
var namespacesDefinition = settings.Get <NamespaceConfigurations>(WellKnownConfigurationKeys.Topology.Addressing.Namespaces);
namespacesDefinition.Add("namespace", AzureServiceBusConnectionString.Value, NamespacePurpose.Partitioning);
// setup the infrastructure
var namespaceManagerCreator = new NamespaceManagerCreator(settings);
var namespaceManagerLifeCycleManager = new NamespaceManagerLifeCycleManager(namespaceManagerCreator);
var messagingFactoryCreator = new MessagingFactoryCreator(namespaceManagerLifeCycleManager, settings);
var messagingFactoryLifeCycleManager = new MessagingFactoryLifeCycleManager(messagingFactoryCreator, settings);
var messageSenderCreator = new MessageSenderCreator(messagingFactoryLifeCycleManager, settings);
var clientLifecycleManager = new MessageSenderLifeCycleManager(messageSenderCreator, settings);
var router = new DefaultOutgoingBatchRouter(new DefaultBatchedOperationsToBrokeredMessagesConverter(settings), clientLifecycleManager, settings, new ThrowOnOversizedBrokeredMessages());
// create the queue
var creator = new AzureServiceBusQueueCreator(settings);
var namespaceManager = namespaceManagerLifeCycleManager.Get("namespace");
await creator.Create("myqueue", namespaceManager);
await creator.Create("myqueue2", namespaceManager);
// perform the test
var dispatcher = new Dispatcher(router, new FakeBatcher());
await dispatcher.Dispatch(new TransportOperations(), new TransportTransaction(), new ContextBag());
//validate
var queue = await namespaceManager.GetQueue("myqueue");
Assert.IsTrue(queue.MessageCount == 2, $"'myqueue' was expected to have 2 message, but it didn't ({queue.MessageCount} found)");
queue = await namespaceManager.GetQueue("myqueue2");
Assert.IsTrue(queue.MessageCount == 2, $"'myqueue2' was expected to have 2 message, but it didn't ({queue.MessageCount} found)");
}
public async Task AutoRenewTimout_will_extend_lock_for_processing_to_finish()
{
var cts = new CancellationTokenSource(TimeSpan.FromSeconds(60));
// default settings
var settings = new DefaultConfigurationValues().Apply(new SettingsHolder());
var namespacesDefinition = settings.Get <NamespaceConfigurations>(WellKnownConfigurationKeys.Topology.Addressing.Namespaces);
namespacesDefinition.Add("namespace", AzureServiceBusConnectionString.Value, NamespacePurpose.Partitioning);
// set lock duration on a queue to 20 seconds and emulate message processing that takes longer than that, but less than AutoRenewTimeout
settings.Set(WellKnownConfigurationKeys.Topology.Resources.Queues.LockDuration, TimeSpan.FromSeconds(20));
// setup the infrastructure
var namespaceManagerCreator = new NamespaceManagerCreator(settings);
var namespaceManagerLifeCycleManager = new NamespaceManagerLifeCycleManager(namespaceManagerCreator);
var messagingFactoryCreator = new MessagingFactoryCreator(namespaceManagerLifeCycleManager, settings);
var messagingFactoryLifeCycleManager = new MessagingFactoryLifeCycleManager(messagingFactoryCreator, settings);
var messageReceiverCreator = new MessageReceiverCreator(messagingFactoryLifeCycleManager, settings);
var clientEntityLifeCycleManager = new MessageReceiverLifeCycleManager(messageReceiverCreator, settings);
var creator = new AzureServiceBusQueueCreator(settings);
var brokeredMessageConverter = new DefaultBrokeredMessagesToIncomingMessagesConverter(settings, new PassThroughMapper(settings));
// create the queue
var namespaceManager = namespaceManagerLifeCycleManager.Get("namespace");
await creator.Create("autorenewtimeout", namespaceManager);
var receivedMessages = 0;
var completed = new AsyncManualResetEvent(false);
// sending messages to the queue
var senderFactory = new MessageSenderCreator(messagingFactoryLifeCycleManager, settings);
var sender = await senderFactory.Create("autorenewtimeout", null, "namespace");
var messageToSend = new BrokeredMessage(Encoding.UTF8.GetBytes("Whatever"))
{
MessageId = Guid.NewGuid().ToString()
};
await sender.Send(messageToSend);
// sending messages to the queue is done
var notifier = new MessageReceiverNotifier(clientEntityLifeCycleManager, brokeredMessageConverter, settings);
notifier.Initialize(new EntityInfo {
Path = "autorenewtimeout", Namespace = new RuntimeNamespaceInfo("namespace", AzureServiceBusConnectionString.Value)
},
async(message, context) =>
{
if (message.MessageId == messageToSend.MessageId)
{
Interlocked.Increment(ref receivedMessages);
if (receivedMessages > 1)
{
Assert.Fail("Callback should only receive one message once, but it did more than that.");
}
await Task.Delay(TimeSpan.FromSeconds(30));
completed.Set();
}
}, null, null, 10);
var sw = new Stopwatch();
sw.Start();
notifier.Start();
await completed.WaitAsync(cts.Token).IgnoreCancellation();
await Task.Delay(TimeSpan.FromSeconds(10));
sw.Stop();
await notifier.Stop();
Assert.AreEqual(1, receivedMessages, $"Expected to receive message once, but got {receivedMessages}.");
Console.WriteLine($"Callback processing took {sw.ElapsedMilliseconds} milliseconds");
//cleanup
await namespaceManager.DeleteQueue("autorenewtimeout");
}
public async Task Can_receive_messages_with_prefetch_fast()
{
var cts = new CancellationTokenSource(TimeSpan.FromSeconds(60));
// default settings
var settings = new DefaultConfigurationValues().Apply(new SettingsHolder());
var namespacesDefinition = settings.Get <NamespaceConfigurations>(WellKnownConfigurationKeys.Topology.Addressing.Namespaces);
namespacesDefinition.Add("namespace", AzureServiceBusConnectionString.Value, NamespacePurpose.Partitioning);
settings.Set(WellKnownConfigurationKeys.Connectivity.MessageReceivers.PrefetchCount, 500);
settings.Set(WellKnownConfigurationKeys.Connectivity.MessageReceivers.ReceiveMode, ReceiveMode.PeekLock);
settings.Set(WellKnownConfigurationKeys.Connectivity.SendViaReceiveQueue, true);
// setup the infrastructure
var namespaceManagerCreator = new NamespaceManagerCreator(settings);
var namespaceManagerLifeCycleManager = new NamespaceManagerLifeCycleManager(namespaceManagerCreator);
var messagingFactoryCreator = new MessagingFactoryCreator(namespaceManagerLifeCycleManager, settings);
var messagingFactoryLifeCycleManager = new MessagingFactoryLifeCycleManager(messagingFactoryCreator, settings);
var messageReceiverCreator = new MessageReceiverCreator(messagingFactoryLifeCycleManager, settings);
var clientEntityLifeCycleManager = new MessageReceiverLifeCycleManager(messageReceiverCreator, settings);
var creator = new AzureServiceBusQueueCreator(settings);
var brokeredMessageConverter = new DefaultBrokeredMessagesToIncomingMessagesConverter(settings, new PassThroughMapper(settings));
// create the queue
var namespaceManager = namespaceManagerLifeCycleManager.Get("namespace");
var queue = await creator.Create("myqueue", namespaceManager);
var receivedMessages = 0;
var completed = new AsyncManualResetEvent(false);
// sending messages to the queue
var senderFactory = new MessageSenderCreator(messagingFactoryLifeCycleManager, settings);
var sender = await senderFactory.Create("myqueue", null, "namespace");
var counter = 0;
var tasks = new List <Task>();
for (var j = 0; j < 10; j++)
{
var batch = new List <BrokeredMessage>();
for (var i = 0; i < 100; i++)
{
batch.Add(new BrokeredMessage(Encoding.UTF8.GetBytes("Whatever" + counter)));
counter++;
}
tasks.Add(sender.RetryOnThrottleAsync(s => s.SendBatch(batch), s => s.SendBatch(batch.Select(x => x.Clone())), TimeSpan.FromSeconds(10), 5));
}
await Task.WhenAll(tasks);
var faulted = tasks.Count(task => task.IsFaulted);
var expected = 1000 - faulted;
// sending messages to the queue is done
var notifier = new MessageReceiverNotifier(clientEntityLifeCycleManager, brokeredMessageConverter, settings);
notifier.Initialize(new EntityInfo {
Path = "myqueue", Namespace = new RuntimeNamespaceInfo("namespace", AzureServiceBusConnectionString.Value)
},
(message, context) =>
{
var numberOfMessages = Interlocked.Increment(ref receivedMessages);
if (numberOfMessages == expected)
{
completed.Set();
}
return(TaskEx.Completed);
}, null, null, 32);
var sw = new Stopwatch();
sw.Start();
notifier.Start();
await completed.WaitAsync(cts.Token).IgnoreCancellation();
sw.Stop();
await notifier.Stop();
Assert.IsTrue(receivedMessages == expected);
Console.WriteLine($"Receiving {receivedMessages} messages took {sw.ElapsedMilliseconds} milliseconds");
Console.WriteLine("Total of {0} msgs / second", (double)receivedMessages / sw.ElapsedMilliseconds * 1000);
// make sure messages are autocompleted
Assert.That(queue.MessageCount, Is.EqualTo(0), "Messages where not completed!");
//cleanup
await namespaceManager.DeleteQueue("myqueue");
}