public void CreateIfNotExists()
{
var queueDescriptions = namespaceManager.GetQueues("startswith(path, '" + this.basePath + "') eq TRUE");
for (int i = 0; i < this.partitionCount; i++)
{
CreateQueuePartitionIfNotExists(queueDescriptions, this.GetQueuePartitionName(i));
}
}
public void TestGetQueues()
{
string name = "TestGetQueues";
NamespaceManager ns = NamespaceManager.CreateFromConnectionString(serviceBusConnectionString);
QueueDescription description = ns.CreateQueue(name);
Assert.IsTrue(null != description);
try
{
QueueDescription testQueue = ns.GetQueues().FirstOrDefault(e => e.Path.Equals(name, StringComparison.InvariantCultureIgnoreCase));
Assert.IsNotNull(testQueue);
if (!ns.QueueExists(name, out description))
{
Assert.Fail("Queue did not exist");
}
else
{
Assert.IsTrue(null != description);
}
}
finally
{
ns.DeleteQueue(name);
if (ns.QueueExists(name, out description))
{
Assert.Fail("Queue was not deleted");
}
}
}
/// <summary>
/// Creates all the underlying entities in Service bus and Azure Storage (if specified) for
/// the TaskHubWorker and TaskHubClient's operations. If TaskHub already exists then this is a no-op
/// </summary>
public void CreateHubIfNotExists(TaskHubDescription description)
{
NamespaceManager namespaceManager = NamespaceManager.CreateFromConnectionString(connectionString);
IEnumerable <QueueDescription> queueDescriptions =
namespaceManager.GetQueues("startswith(path, '" + hubName + "') eq TRUE");
List <QueueDescription> descriptions = queueDescriptions.ToList();
if (!descriptions.Any(q => string.Equals(q.Path, orchestratorEntityName)))
{
SafeCreateQueue(namespaceManager, orchestratorEntityName, true,
description.MaxTaskOrchestrationDeliveryCount);
}
if (!descriptions.Any(q => string.Equals(q.Path, workerEntityName)))
{
SafeCreateQueue(namespaceManager, workerEntityName, false, description.MaxTaskActivityDeliveryCount);
}
if (!descriptions.Any(q => string.Equals(q.Path, trackingEntityName)))
{
SafeCreateQueue(namespaceManager, trackingEntityName, true, description.MaxTrackingDeliveryCount);
}
if (!string.IsNullOrEmpty(tableStoreConnectionString))
{
var client = new TableClient(hubName, tableStoreConnectionString);
client.CreateTableIfNotExists();
}
}
/// <summary>
/// Method is used for abandoned subscriptions deleting (subscriptions to temporaries queues on fanout topics).
/// Should be fixed in new Masstransit releases.
/// </summary>
/// <param name="settings">Service bus settings.</param>
private static void DeleteAbandonedSubscriptions(ServiceBusSettings settings)
{
var serviceUri = ServiceBusEnvironment.CreateServiceUri("sb", settings.AzureNamespace, string.Empty);
var tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider("RootManageSharedAccessKey", settings.AzureSharedAccessKey, TokenScope.Namespace);
var namespaceManager = new NamespaceManager(serviceUri, tokenProvider);
var queues = namespaceManager.GetQueues().Select(q => $"{namespaceManager.Address.AbsoluteUri.ToLower()}{q.Path.ToLower()}").ToList();
var toExecute = new List <Action>();
foreach (var topic in namespaceManager.GetTopics().Where(t => t.SubscriptionCount > 0))
{
foreach (var subscription in namespaceManager.GetSubscriptions(topic.Path).Where(s => !string.IsNullOrEmpty(s.ForwardTo)))
{
if (!queues.Contains(subscription.ForwardTo.ToLower()))
{
toExecute.Add(() =>
{
namespaceManager.DeleteSubscription(topic.Path, subscription.Name);
Log.Information("Abandoned subscription removed: {topic} -> {subscription} -> {queue}",
topic.Path, subscription.Name, subscription.ForwardTo);
});
}
Log.Debug("Found abandoned subscription: {topic} -> {subscription} -> {queue}", topic.Path, subscription.Name, subscription.ForwardTo);
}
}
foreach (var execute in toExecute)
{
execute();
}
}
public IEnumerable <QueueSummary> ListQueues()
{
NamespaceManager namespaceManager = CreateNamespaceManager();
var queues = namespaceManager.GetQueues().Select(q => QueueSummary.New(q));
return(queues.OrderBy(q => q.name, StringComparer.CurrentCultureIgnoreCase));
}
public ServiceBusManager(string connectionString)
{
_connectionString = connectionString;
_namespaceManager = NamespaceManager.CreateFromConnectionString(_connectionString);
_nameSpace = _namespaceManager.Address.AbsolutePath.TrimStart('/');
Queues = new ObservableCollection <QueueDescription>(_namespaceManager.GetQueues());
Topics = new ObservableCollection <TopicDescription>(_namespaceManager.GetTopics());
}
public void ListQueues()
{
IEnumerable <QueueDescription> queueDescriptions = m_NamespaceManager.GetQueues();
Console.WriteLine("Listing Queues...");
foreach (var queueDescription in queueDescriptions)
{
Console.WriteLine("\t{0}", queueDescription.Path);
}
Console.WriteLine("Done");
}
public void ListQueues()
{
IEnumerable <QueueDescription> queueDescriptions = m_NamespaceManager.GetQueues();
foreach (QueueDescription item in queueDescriptions)
{
Console.WriteLine("\t{0}", item.Path);
}
Console.WriteLine("Done!");
}
public void Execute(DeleteAllBusEntititesCommand command)
{
foreach (var q in _namespaceManager.GetQueues().ToArray())
{
_namespaceManager.DeleteQueue(q.Path);
}
foreach (var t in _namespaceManager.GetTopics().ToArray())
{
_namespaceManager.DeleteTopic(t.Path);
}
}
public Dictionary <string, int> List()
{
Dictionary <string, int> queueList = new Dictionary <string, int>();
NamespaceManager NM = NamespaceManager.CreateFromConnectionString(_ConStr);
foreach (Microsoft.ServiceBus.Messaging.QueueDescription Q in NM.GetQueues())
{
queueList.Add(Q.Path, (int)Q.MessageCount);
}
return(queueList);
}
public AzureServiceBusMqServerAppHostTests()
{
#if !NETCORE_SUPPORT
NamespaceManager nm = NamespaceManager.CreateFromConnectionString(ConnectionString);
Parallel.ForEach(nm.GetQueues(), qd =>
{
var sbClient = QueueClient.CreateFromConnectionString(ConnectionString, qd.Path, ReceiveMode.ReceiveAndDelete);
BrokeredMessage msg = null;
while ((msg = sbClient.Receive(new TimeSpan(0, 0, 1))) != null)
{
}
});
#endif
}
private void ProcessQueues()
{
var queues = _sourceNamespaceManager.GetQueues();
var destinationQueues = _destinationNamespaceManager.GetQueues().Select(queue => queue.Path);
_activityLogger.Log($"{queues.Count()} queue(s) found");
foreach (var queue in queues)
{
if (IsQueueIgnored(queue.Path))
{
_activityLogger.Log($"Ignoring queue: [{queue}]");
}
else if (!destinationQueues.Contains(queue.Path))
{
_activityLogger.Log($"Skipping queue, which does not exist in destination: [{queue}]");
}
else
{
QueueClient sourceClient = null;
QueueClient destinationClient = null;
try
{
sourceClient = QueueClient.CreateFromConnectionString(_sourceConnectionString, queue.Path);
destinationClient = QueueClient.CreateFromConnectionString(_destinationConnectionString, queue.Path);
if (queue.RequiresSession)
{
_queueMessageForwarder.ProcessSessionQueue(sourceClient, destinationClient);
}
else
{
_queueMessageForwarder.ProcessQueue(sourceClient, destinationClient);
}
}
catch (Exception e)
{
_activityLogger.Log($"! Exception processing [{queue.Path}] queue: {e.Message}\n\n", 0, 2);
}
finally
{
sourceClient?.Close();
destinationClient?.Close();
}
}
}
}
public bool Exists()
{
NamespaceManager NM = NamespaceManager.CreateFromConnectionString(_ConStr);
foreach (Microsoft.ServiceBus.Messaging.QueueDescription Q in NM.GetQueues())
{
if (Q.Path.ToLower().Contains(_ReceivingQueue))
{
return(true);
}
}
return(false);
}
/// <summary>
/// Creates the queue. If the queue already exists then nothing is done.
/// </summary>
/// <param name="nameSpaceManager">The name space manager.</param>
/// <param name="queueName">Name of the queue.</param>
public static void CreateQueue(NamespaceManager nameSpaceManager, string queueName)
{
if (!nameSpaceManager.QueueExists(queueName))
{
var qd = new QueueDescription(queueName)
{
MaxSizeInMegabytes = 5120,
DefaultMessageTimeToLive = new TimeSpan(0, 1, 0)
//IsAnonymousAccessible = true
};
nameSpaceManager.CreateQueue(qd);
nameSpaceManager.GetQueues();
}
}
/// <summary>
/// Hub existence check.
/// </summary>
/// <returns>True if the Task Hub exists, false otherwise.</returns>
public bool HubExists()
{
NamespaceManager namespaceManager = NamespaceManager.CreateFromConnectionString(connectionString);
IEnumerable <QueueDescription> queueDescriptions =
namespaceManager.GetQueues("startswith(path, '" + hubName + "') eq TRUE");
if (!queueDescriptions.Where(q => string.Equals(q.Path, orchestratorEntityName)).Any())
{
return(false);
}
// TODO : what if not all of the hub entities exist?
return(true);
}
public static void RemoveEndpoint(string endpointName)
{
var serviceBusSettings = ConfigurationManager.GetSection(ServiceBusConfigurationSettings.SectionName) as ServiceBusConfigurationSettings;
var serviceBusEndpoint = serviceBusSettings.Endpoints.Get(endpointName);
if (serviceBusEndpoint != null)
{
var credentials = TokenProvider.CreateSharedSecretTokenProvider(serviceBusEndpoint.IssuerName, serviceBusEndpoint.IssuerSecret);
var address = ServiceBusEnvironment.CreateServiceUri("sb", serviceBusEndpoint.ServiceNamespace, String.Empty);
var managementClient = new NamespaceManager(address, credentials);
if (!String.IsNullOrEmpty(serviceBusEndpoint.TopicName) && !String.IsNullOrEmpty(serviceBusEndpoint.SubscriptionName))
{
if (managementClient.GetTopics().Where(t => String.Compare(t.Path, serviceBusEndpoint.TopicName, true) == 0).Count() > 0)
{
if (managementClient.GetSubscriptions(serviceBusEndpoint.TopicName).Where(s => String.Compare(s.Name, serviceBusEndpoint.SubscriptionName, true) == 0).Count() > 0)
{
managementClient.DeleteSubscription(serviceBusEndpoint.TopicName, serviceBusEndpoint.SubscriptionName);
return;
}
}
}
if (!String.IsNullOrEmpty(serviceBusEndpoint.TopicName))
{
if (managementClient.GetTopics().Where(t => String.Compare(t.Path, serviceBusEndpoint.TopicName, true) == 0).Count() > 0)
{
managementClient.DeleteTopic(serviceBusEndpoint.TopicName);
return;
}
}
if (!String.IsNullOrEmpty(serviceBusEndpoint.QueueName))
{
if (managementClient.GetQueues().Where(q => String.Compare(q.Path, serviceBusEndpoint.QueueName, true) == 0).Count() > 0)
{
managementClient.DeleteQueue(serviceBusEndpoint.QueueName);
return;
}
}
}
}
public void Execute(DeleteAllDeadLettersCommand command)
{
var topics = _namespaceManager.GetTopics().ToArray();
foreach (var topic in topics)
{
var subscriptions = _namespaceManager.GetSubscriptions(topic.Path);
foreach (var subscription in subscriptions)
{
_requeueAndRemove.RemoveAll(topic.Path, subscription.Name + DeadLetterQueueSuffix);
}
}
var queues = _namespaceManager.GetQueues().ToArray();
foreach (var queue in queues)
{
_requeueAndRemove.RemoveAll(queue.Path + DeadLetterQueueSuffix);
}
}
public void ListQueues(Property[] inputs, RequiredProperties required, Property[] returns, MethodType methodType, ServiceObject serviceObject)
{
Utilities.ServiceUtilities serviceUtilities = new Utilities.ServiceUtilities(serviceBroker);
serviceObject.Properties.InitResultTable();
NamespaceManager namespaceManager = null;
System.Data.DataRow dr;
try
{
namespaceManager = serviceUtilities.GetNamespaceManager(inputs.Where(p => p.Name.Equals("requesttimeout")).FirstOrDefault());
IEnumerable <QueueDescription> Qs = namespaceManager.GetQueues();
foreach (QueueDescription Queue in Qs)
{
dr = serviceBroker.ServicePackage.ResultTable.NewRow();
foreach (Property prop in returns)
{
switch (prop.Name)
{
case "defaultmessagetimetolive":
dr[prop.Name] = Queue.DefaultMessageTimeToLive.TotalSeconds;
break;
case "duplicatedetectionhistorytimewindow":
dr[prop.Name] = Queue.DuplicateDetectionHistoryTimeWindow.TotalSeconds;
break;
case "enablebatchedoperations":
prop.Value = Queue.EnableBatchedOperations;
break;
case "enabledeadletteringonmessageexpiration":
dr[prop.Name] = Queue.EnableDeadLetteringOnMessageExpiration;
break;
case "isreadonly":
dr[prop.Name] = Queue.IsReadOnly;
break;
case "lockduration":
dr[prop.Name] = Queue.LockDuration.TotalSeconds;
break;
case "maxdeliverycount":
dr[prop.Name] = Queue.MaxDeliveryCount;
break;
case "maxsizeinmegabytes":
dr[prop.Name] = Queue.MaxSizeInMegabytes;
break;
case "messagecount":
dr[prop.Name] = Queue.MessageCount;
break;
case "queue":
dr[prop.Name] = Queue.Path;
break;
case "requiresduplicatedetection":
dr[prop.Name] = Queue.RequiresDuplicateDetection;
break;
case "requiressession":
dr[prop.Name] = Queue.RequiresSession;
break;
case "sizeinbytes":
dr[prop.Name] = Queue.SizeInBytes;
break;
}
}
dr["responsestatus"] = ResponseStatus.Success;
dr["responsestatusdescription"] = "Queues listed";
serviceBroker.ServicePackage.ResultTable.Rows.Add(dr);
}
}
catch (Exception ex)
{
dr = serviceBroker.ServicePackage.ResultTable.NewRow();
dr["responsestatus"] = ResponseStatus.Error;
dr["responsestatusdescription"] = ex.Message;
serviceBroker.ServicePackage.ResultTable.Rows.Add(dr);
return;
}
finally
{
namespaceManager = null;
}
}
private List <ExtendedAuthorizationRule> GetAuthorizationRulesToFilter(AuthorizationRuleFilterOption options)
{
if (!string.IsNullOrEmpty(options.EntityName))
{
return(GetAuthorizationRuleCore(
options.Namespace,
options.EntityName,
options.EntityType,
r => true));
}
else if (options.EntityTypes != null && options.EntityTypes.Count > 0)
{
NamespaceManager namespaceManager = CreateNamespaceManager(options.Namespace);
List <ExtendedAuthorizationRule> rules = new List <ExtendedAuthorizationRule>();
options.EntityTypes = options.EntityTypes.Distinct().ToList();
foreach (ServiceBusEntityType type in options.EntityTypes)
{
switch (type)
{
case ServiceBusEntityType.Queue:
rules.AddRange(namespaceManager.GetQueues()
.SelectMany(e => e.Authorization
.Select(r => CreateExtendedAuthorizationRule(
r,
options.Namespace,
e.Path,
ServiceBusEntityType.Queue))));
break;
case ServiceBusEntityType.Topic:
rules.AddRange(namespaceManager.GetTopics()
.SelectMany(e => e.Authorization
.Select(r => CreateExtendedAuthorizationRule(
r,
options.Namespace,
e.Path,
ServiceBusEntityType.Topic))));
break;
case ServiceBusEntityType.Relay:
rules.AddRange(namespaceManager.GetRelaysAsync().Result
.SelectMany(e => e.Authorization
.Select(r => CreateExtendedAuthorizationRule(
r,
options.Namespace,
e.Path,
ServiceBusEntityType.Relay))));
break;
case ServiceBusEntityType.NotificationHub:
rules.AddRange(namespaceManager.GetNotificationHubs()
.SelectMany(e => e.Authorization
.Select(r => CreateExtendedAuthorizationRule(
r,
options.Namespace,
e.Path,
ServiceBusEntityType.NotificationHub))));
break;
default: throw new InvalidOperationException();
}
}
return(rules);
}
else
{
return(ServiceBusClient.Namespaces.ListAuthorizationRules(options.Namespace)
.AuthorizationRules
.Select(ar => ar.ToSharedAccessAuthorizationRule())
.Select(r => CreateExtendedAuthorizationRule(r, options.Namespace))
.ToList());
}
}
public static IEnumerable <QueueDescription> GetQueues(NamespaceManager nameSpaceManager)
{
var queues = nameSpaceManager.GetQueues();
return(queues);
}
/// <summary>
/// Danger! Danger, Will Robinson!
/// </summary>
private static void RemoveAllExistingNamespaceElements(NamespaceManager namespaceManager, ILogger logger)
{
logger.Debug("Removing all existing namespace elements. IMPORTANT: This should only be done in your regression test suites.");
var tasks = new List<Task>();
var queuePaths = namespaceManager.GetQueues().Select(q => q.Path).ToArray();
queuePaths
.Do(queuePath => tasks.Add(Task.Run(() => namespaceManager.DeleteQueue(queuePath))))
.Done();
var topicPaths = namespaceManager.GetTopics().Select(t => t.Path).ToArray();
topicPaths
.Do(topicPath => tasks.Add(Task.Run(() => namespaceManager.DeleteTopic(topicPath))))
.Done();
tasks.WaitAll();
}
/// <summary>
/// Danger! Danger, Will Robinson!
/// </summary>
private static void RemoveAllExistingNamespaceElements(NamespaceManager namespaceManager)
{
var tasks = new List<Task>();
var queuePaths = namespaceManager.GetQueues().Select(q => q.Path).ToArray();
queuePaths
.Do(queuePath => tasks.Add(Task.Run(() => namespaceManager.DeleteQueue(queuePath))))
.Done();
var topicPaths = namespaceManager.GetTopics().Select(t => t.Path).ToArray();
topicPaths
.Do(topicPath => tasks.Add(Task.Run(() => namespaceManager.DeleteTopic(topicPath))))
.Done();
tasks.WaitAll();
}
public IEnumerable <QueueDescription> ListQueues()
{
return(_servicebusNamespaceManager.GetQueues());
}
