public async Task DeleteQueueIfExists(string queueName)
{
if (await _namespaceManager.QueueExistsAsync(queueName))
{
await _namespaceManager.DeleteQueueAsync(queueName);
}
}
private static async Task DeployDataWorkerQueue(TextWriter writer, bool recreate = false)
{
// "dumpling-service data-worker queue path"
// "dumpling-service bus connection string"
var dataworkerQueuePath = NearbyConfig.Settings["dumpling-service data-worker queue path"];
var servicebusConnString = NearbyConfig.Settings["dumpling-service bus connection string"];
NamespaceManager manager = NamespaceManager.CreateFromConnectionString(servicebusConnString);
CreationDelegate createQueue = async() =>
{
writer.WriteLine("creating new dataworker queue");
await manager.CreateQueueAsync(dataworkerQueuePath);
};
var exists = await manager.QueueExistsAsync(dataworkerQueuePath);
if (exists && recreate)
{
writer.WriteLine("dataworker queue exists; deleting current instance");
await manager.DeleteQueueAsync(dataworkerQueuePath);
createQueue();
}
else if (!exists)
{
createQueue();
}
else
{
writer.WriteLine($"'{dataworkerQueuePath}' exists already and we're not recreating");
}
}
async Task CleanupSagaTopologyAsync(NamespaceManager namespaceManager, IEnumerable <QueueDescription> queues)
{
Console.WriteLine("Cleanup");
foreach (var queueDescription in queues.Reverse())
{
await namespaceManager.DeleteQueueAsync(queueDescription.Path);
}
}
public async Task ServiceBus_Node_DoesNotExhaustConnections()
{
var connectionString = Environment.GetEnvironmentVariable("AzureWebJobsServiceBus");
NamespaceManager manager = NamespaceManager.CreateFromConnectionString(connectionString);
// Start with an empty queue
await manager.DeleteQueueAsync("node");
// Pre-create the queue as we can end up with 409s if a bunch of requests
// try to create the queue at once
await manager.CreateQueueAsync("node");
int i = 0, j = 0, lastConnectionCount = 0, lastConnectionLimit = 0;
using (var client = CreateClient())
{
// make this longer as we'll start seeing long timeouts from Service Bus upon failure.
client.Timeout = TimeSpan.FromMinutes(5);
// max connections in dynamic is currently 300
for (i = 0; i < 25; i++)
{
List <Task <HttpResponseMessage> > requestTasks = new List <Task <HttpResponseMessage> >();
for (j = 0; j < 25; j++)
{
requestTasks.Add(client.GetAsync($"api/ServiceBusNode?code={_fixture.FunctionDefaultKey}"));
}
await Task.WhenAll(requestTasks);
foreach (var requestTask in requestTasks)
{
HttpResponseMessage response = await requestTask;
JObject result = await response.Content.ReadAsAsync <JObject>();
if (response.IsSuccessStatusCode)
{
// store these off for error details
lastConnectionCount = (int)result["connections"];
lastConnectionLimit = (int)result["connectionLimit"];
// make sure we have the correct limit
Assert.Equal(300, lastConnectionLimit);
}
Assert.True(response.IsSuccessStatusCode, $"Error: {response.StatusCode}, Last successful response: Connections: {lastConnectionCount}, ConnectionLimit: {lastConnectionLimit}");
}
}
}
QueueDescription queueDescription = manager.GetQueue("node");
Assert.Equal(i * j, queueDescription.MessageCountDetails.ActiveMessageCount);
}
/// <summary>
/// Scorches the entire namespace that the <see cref="NamespaceManager"/> is connected to.
/// Currently this wipes out all queues and topics. This is used mostly by integration tests, to guarantee that
/// both queue and topic creation processes are in place and working as intended.
/// </summary>
/// <param name="nsm">The <see cref="NamespaceManager"/> we are using to scorch the namespace.</param>
/// <returns>The async <see cref="Task"/> wrapper.</returns>
public static async Task ScorchNamespace(this NamespaceManager nsm)
{
foreach (var queue in await nsm.GetQueuesAsync())
{
await nsm.DeleteQueueAsync(queue.Path);
}
foreach (var topic in await nsm.GetTopicsAsync())
{
await nsm.DeleteTopicAsync(topic.Path);
}
}
/// <summary>
/// Delete a Message Queue, if it exists, and indicate if the attempt was successful.
/// </summary>
public bool DeleteQueue()
{
string queueName = EnvironmentType.MessageQueueName();
bool queueExists = QueueExists;
if (queueExists)
{
_namespaceManager.DeleteQueueAsync(queueName).Wait();
queueExists = QueueExists;
}
return(!queueExists);
}
public override async Task DeleteQueueAsync()
{
if (await _namespaceManager.QueueExistsAsync(_options.Name).AnyContext())
{
await _namespaceManager.DeleteQueueAsync(_options.Name).AnyContext();
}
_queueClient = null;
_enqueuedCount = 0;
_dequeuedCount = 0;
_completedCount = 0;
_abandonedCount = 0;
_workerErrorCount = 0;
}
public Task DeleteQueueAsync(QueueName name)
{
if (name.IsSimpleQueue)
{
return(_namespaceManager.DeleteQueueAsync(name.TopicName));
}
else
{
if (name.IsTopic)
{
return(_namespaceManager.DeleteTopicAsync(name.TopicName));
}
else
{
return(_namespaceManager.DeleteSubscriptionAsync(name.TopicName,
name.SubscriptionName));
}
}
}
public override async Task DeleteQueueAsync()
{
if (await _namespaceManager.QueueExistsAsync(_queueName).AnyContext())
{
await _namespaceManager.DeleteQueueAsync(_queueName).AnyContext();
}
_queueDescription = new QueueDescription(_queueName)
{
MaxDeliveryCount = _retries + 1,
LockDuration = _workItemTimeout
};
await _namespaceManager.CreateQueueAsync(_queueDescription).AnyContext();
_enqueuedCount = 0;
_dequeuedCount = 0;
_completedCount = 0;
_abandonedCount = 0;
_workerErrorCount = 0;
}
public T SendAndRespond <T>(BrokeredMessage requestMessage)
{
var replyTo = Guid.NewGuid().ToString().Substring(0, 6);
requestMessage.ReplyTo = replyTo;
_namespaceMgr.CreateQueue(replyTo);
var replyQueue = QueueClient.Create(replyTo);
Send(requestMessage);
//wait for response on the response queue
var responseMessage = replyQueue.Receive();
var body = responseMessage.GetBody <Stream>();
var streamReader = new StreamReader(body);
var response = JsonConvert.DeserializeObject <T>(streamReader.ReadToEnd());
responseMessage.Complete();
_namespaceMgr.DeleteQueueAsync(replyTo);
return(response);
}
static async Task DeleteEntities(NamespaceManager namespaceManager)
{
var queryQueues = namespaceManager.GetQueuesAsync();
var queryTopics = namespaceManager.GetTopicsAsync();
await Task.WhenAll(queryQueues, queryTopics)
.ConfigureAwait(false);
const int maxRetryAttempts = 5;
var deleteQueues = (await queryQueues).Select(queueDescription => TryWithRetries(queueDescription.Path, namespaceManager.DeleteQueueAsync(queueDescription.Path), maxRetryAttempts));
await Task.WhenAll(deleteQueues)
.ConfigureAwait(false);
var deleteTopics = (await queryTopics).Select(topicDescription => TryWithRetries(topicDescription.Path, namespaceManager.DeleteTopicAsync(topicDescription.Path), maxRetryAttempts));
await Task.WhenAll(deleteTopics)
.ConfigureAwait(false);
}
public Task DeleteQueue(string path)
{
return(manager.DeleteQueueAsync(path));
}
public async Task Run(string namespaceAddress, string manageToken)
{
Console.WriteLine("\nCreating topology\n");
this.sharedAccessRuleKey = SharedAccessAuthorizationRule.GenerateRandomKey();
var namespaceManageTokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(manageToken);
// Create namespace manager and create destination queue with a SAS rule that allows sending to that queue.
var namespaceManager = new NamespaceManager(namespaceAddress, namespaceManageTokenProvider);
var targetQueue = new QueueDescription("TargetQueue")
{
Authorization = { new SharedAccessAuthorizationRule("SendKey", this.sharedAccessRuleKey, new[] { AccessRights.Send }) },
};
targetQueue = (await namespaceManager.QueueExistsAsync(targetQueue.Path))
? await namespaceManager.UpdateQueueAsync(targetQueue)
: await namespaceManager.CreateQueueAsync(targetQueue);
var topic = new TopicDescription("SourceTopic")
{
Authorization = { new SharedAccessAuthorizationRule("SendKey", this.sharedAccessRuleKey, new[] { AccessRights.Send }) }
};
topic = (await namespaceManager.TopicExistsAsync(topic.Path))
? await namespaceManager.UpdateTopicAsync(topic)
: await namespaceManager.CreateTopicAsync(topic);
var forwardingSubscription = namespaceManager.CreateSubscription(
new SubscriptionDescription(topic.Path, "Sub1")
{
ForwardTo = targetQueue.Path
});
var forwardingQueue = new QueueDescription("SourceQueue")
{
ForwardTo = targetQueue.Path,
Authorization =
{
new SharedAccessAuthorizationRule(
"SendKey",
this.sharedAccessRuleKey,
new[] {AccessRights.Send})
}
};
forwardingQueue = (await namespaceManager.QueueExistsAsync(forwardingQueue.Path))
? await namespaceManager.UpdateQueueAsync(forwardingQueue)
: await namespaceManager.CreateQueueAsync(forwardingQueue);
Console.WriteLine("\nSending messages\n");
var topicFactory = MessagingFactory.Create(namespaceAddress, TokenProvider.CreateSharedAccessSignatureTokenProvider("SendKey", this.sharedAccessRuleKey));
var topicSender = await topicFactory.CreateMessageSenderAsync(topic.Path);
await topicSender.SendAsync(CreateMessage("M1"));
var queueFactory = MessagingFactory.Create(namespaceAddress, TokenProvider.CreateSharedAccessSignatureTokenProvider("SendKey", this.sharedAccessRuleKey));
var queueSender = await queueFactory.CreateMessageSenderAsync(forwardingQueue.Path);
await queueSender.SendAsync(CreateMessage("M1"));
var messagingFactory = MessagingFactory.Create(namespaceAddress, namespaceManageTokenProvider);
var targetQueueReceiver = messagingFactory.CreateQueueClient(targetQueue.Path);
while (true)
{
var message = await targetQueueReceiver.ReceiveAsync(TimeSpan.FromSeconds(10));
if (message != null)
{
await this.PrintReceivedMessage(message);
await message.CompleteAsync();
}
else
{
break;
}
}
await targetQueueReceiver.CloseAsync();
Console.WriteLine("\nPress ENTER to delete topics and exit\n");
Console.ReadLine();
messagingFactory.Close();
Task.WaitAll(
namespaceManager.DeleteQueueAsync(targetQueue.Path),
namespaceManager.DeleteQueueAsync(forwardingQueue.Path),
namespaceManager.DeleteTopicAsync(topic.Path));
}
async Task CleanupSagaTopologyAsync(NamespaceManager namespaceManager, IEnumerable<QueueDescription> queues)
{
Console.WriteLine("Cleanup");
foreach (var queueDescription in queues.Reverse())
{
await namespaceManager.DeleteQueueAsync(queueDescription.Path);
}
}
public async Task Run(string namespaceAddress, string manageToken)
{
Console.WriteLine("\nCreating topology\n");
this.sharedAccessRuleKey = SharedAccessAuthorizationRule.GenerateRandomKey();
var namespaceManageTokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(manageToken);
// Create namespace manager and create destination queue with a SAS rule that allows sending to that queue.
var namespaceManager = new NamespaceManager(namespaceAddress, namespaceManageTokenProvider);
var targetQueue = new QueueDescription("TargetQueue")
{
Authorization = { new SharedAccessAuthorizationRule("SendKey", this.sharedAccessRuleKey, new[] { AccessRights.Send }) },
};
targetQueue = (await namespaceManager.QueueExistsAsync(targetQueue.Path))
? await namespaceManager.UpdateQueueAsync(targetQueue)
: await namespaceManager.CreateQueueAsync(targetQueue);
var topic = new TopicDescription("SourceTopic")
{
Authorization = { new SharedAccessAuthorizationRule("SendKey", this.sharedAccessRuleKey, new[] { AccessRights.Send }) }
};
topic = (await namespaceManager.TopicExistsAsync(topic.Path))
? await namespaceManager.UpdateTopicAsync(topic)
: await namespaceManager.CreateTopicAsync(topic);
var forwardingSubscription = namespaceManager.CreateSubscription(
new SubscriptionDescription(topic.Path, "Sub1")
{
ForwardTo = targetQueue.Path
});
var forwardingQueue = new QueueDescription("SourceQueue")
{
ForwardTo = targetQueue.Path,
Authorization =
{
new SharedAccessAuthorizationRule(
"SendKey",
this.sharedAccessRuleKey,
new[] { AccessRights.Send })
}
};
forwardingQueue = (await namespaceManager.QueueExistsAsync(forwardingQueue.Path))
? await namespaceManager.UpdateQueueAsync(forwardingQueue)
: await namespaceManager.CreateQueueAsync(forwardingQueue);
Console.WriteLine("\nSending messages\n");
var topicFactory = MessagingFactory.Create(namespaceAddress, TokenProvider.CreateSharedAccessSignatureTokenProvider("SendKey", this.sharedAccessRuleKey));
var topicSender = await topicFactory.CreateMessageSenderAsync(topic.Path);
await topicSender.SendAsync(CreateMessage("M1"));
var queueFactory = MessagingFactory.Create(namespaceAddress, TokenProvider.CreateSharedAccessSignatureTokenProvider("SendKey", this.sharedAccessRuleKey));
var queueSender = await queueFactory.CreateMessageSenderAsync(forwardingQueue.Path);
await queueSender.SendAsync(CreateMessage("M1"));
var messagingFactory = MessagingFactory.Create(namespaceAddress, namespaceManageTokenProvider);
var targetQueueReceiver = messagingFactory.CreateQueueClient(targetQueue.Path);
while (true)
{
var message = await targetQueueReceiver.ReceiveAsync(TimeSpan.FromSeconds(10));
if (message != null)
{
await this.PrintReceivedMessage(message);
await message.CompleteAsync();
}
else
{
break;
}
}
await targetQueueReceiver.CloseAsync();
Console.WriteLine("\nPress ENTER to delete topics and exit\n");
Console.ReadLine();
messagingFactory.Close();
Task.WaitAll(
namespaceManager.DeleteQueueAsync(targetQueue.Path),
namespaceManager.DeleteQueueAsync(forwardingQueue.Path),
namespaceManager.DeleteTopicAsync(topic.Path));
}
public async Task DeleteQueueAsync(string name)
{
var cleansedName = CreateQueueName(name);
await _manager.DeleteQueueAsync(cleansedName);
}
public async Task DeleteAsync()
{
await RetryPolicy.ExecuteAsync(() => NamespaceManager.DeleteQueueAsync(Client.Path));
}
/// <summary>
/// Delete Queue
/// </summary>
/// <returns></returns>
public virtual async Task Delete()
{
await manager.DeleteQueueAsync(this.name);
}
