private void CreateSubscriptions(string topicName, string[] subscriptions)
{
var busAdmin = new ServiceBusAdministrationClient(Connections.ServiceBusConnectionString);
foreach (var subscription in subscriptions)
{
if (!busAdmin.SubscriptionExistsAsync(topicName, subscription).Result.Value)
{
busAdmin.CreateSubscriptionAsync(topicName, subscription).Wait();
}
}
}
async Task EnsureInitializationAsync()
{
if (!await adminClient.TopicExistsAsync(this.TopicName))
{
await adminClient.CreateTopicAsync(new CreateTopicOptions(this.TopicName)); /*Explore more options*/
}
if (!await adminClient.SubscriptionExistsAsync(this.TopicName, this.SubscriptionName))
{
await adminClient.CreateSubscriptionAsync(this.TopicName, this.SubscriptionName);
}
}
public static async Task <SubscriptionProperties> CreateSubscriptionAsync(string topicName, string connectionString, string subscriptionName)
{
var client = new ServiceBusAdministrationClient(connectionString);
var subscriptionOptions = new CreateSubscriptionOptions(topicName, subscriptionName)
{
DefaultMessageTimeToLive = TimeSpan.FromDays(2),
EnableBatchedOperations = true,
UserMetadata = "some metadata"
};
return(await client.CreateSubscriptionAsync(subscriptionOptions));
}
public static async Task CreateSubscription(ServiceBusAdministrationClient client, string topic, string subscription)
{
CheckIsNotGreaterThan(nameof(subscription), subscription.Length, 50);
bool subscriptionExists = await client.SubscriptionExistsAsync(topic, subscription);
if (!subscriptionExists)
{
var options = new CreateSubscriptionOptions(topic, subscription);
_ = await client.CreateSubscriptionAsync(options);
}
}
public async Task CreateTopicAndSubscription()
{
string topicName = Guid.NewGuid().ToString("D").Substring(0, 8);
string subscriptionName = Guid.NewGuid().ToString("D").Substring(0, 8);
string connectionString = TestEnvironment.ServiceBusConnectionString;
var client = new ServiceBusAdministrationClient(connectionString);
try
{
#region Snippet:CreateTopicAndSubscription
//@@ string connectionString = "<connection_string>";
//@@ string topicName = "<topic_name>";
//@@ var client = new ServiceBusManagementClient(connectionString);
var topicOptions = new CreateTopicOptions(topicName)
{
AutoDeleteOnIdle = TimeSpan.FromDays(7),
DefaultMessageTimeToLive = TimeSpan.FromDays(2),
DuplicateDetectionHistoryTimeWindow = TimeSpan.FromMinutes(1),
EnableBatchedOperations = true,
EnablePartitioning = false,
MaxSizeInMegabytes = 2048,
RequiresDuplicateDetection = true,
UserMetadata = "some metadata"
};
topicOptions.AuthorizationRules.Add(new SharedAccessAuthorizationRule(
"allClaims",
new[] { AccessRights.Manage, AccessRights.Send, AccessRights.Listen }));
TopicProperties createdTopic = await client.CreateTopicAsync(topicOptions);
//@@ string subscriptionName = "<subscription_name>";
var subscriptionOptions = new CreateSubscriptionOptions(topicName, subscriptionName)
{
AutoDeleteOnIdle = TimeSpan.FromDays(7),
DefaultMessageTimeToLive = TimeSpan.FromDays(2),
EnableBatchedOperations = true,
UserMetadata = "some metadata"
};
SubscriptionProperties createdSubscription = await client.CreateSubscriptionAsync(subscriptionOptions);
#endregion
Assert.AreEqual(topicOptions, new CreateTopicOptions(createdTopic));
Assert.AreEqual(subscriptionOptions, new CreateSubscriptionOptions(createdSubscription));
}
finally
{
await client.DeleteTopicAsync(topicName);
}
}
protected async Task CreateSubscriptionAsync(string subscription)
{
SubscriptionProperties existingSubscription = null;
try
{
existingSubscription = await _serviceBusAdminClient.GetSubscriptionAsync(_topic, subscription);
}
catch {}
if (existingSubscription is null)
{
await _serviceBusAdminClient.CreateSubscriptionAsync(_topic, subscription);
}
}
static async Task <string> CreateSubscriptionAsync()
{
var subscriptionName = $"{DateTime.UtcNow.ToString("MM-dd-yyyy-HH")}-{Guid.NewGuid()}";
var subscriptionOptions = new CreateSubscriptionOptions(_topicName, subscriptionName)
{
AutoDeleteOnIdle = TimeSpan.FromMinutes(Convert.ToInt32(ConfigurationManager.AppSettings["Azure:ServiceBus:SourceSynchronizer:SubscriptionOptions:AutoDeleteOnIdle"])),
DefaultMessageTimeToLive = TimeSpan.FromMinutes(Convert.ToInt32(ConfigurationManager.AppSettings["Azure:ServiceBus:SourceSynchronizer:SubscriptionOptions:DefaultMessageTimeToLive"])),
EnableBatchedOperations = true,
};
var ruleOptions = new CreateRuleOptions {
Name = "TargetClient", Filter = new SqlRuleFilter($"Client = '{ConfigurationManager.AppSettings["Azure:ServiceBus:SourceSynchronizer:RuleOptions:ClientName"]}'")
};
var createdSubscription = await _sbAdminClient.CreateSubscriptionAsync(subscriptionOptions, ruleOptions);
return(createdSubscription.Value.SubscriptionName);
}
async Task <string> CreateSubscriptionAsync()
{
var subscriptionName = $"{DateTime.UtcNow.ToString("MM-dd-yyyy-HH")}-{Guid.NewGuid()}";
var subscriptionOptions = new CreateSubscriptionOptions(_topicName, subscriptionName)
{
AutoDeleteOnIdle = TimeSpan.FromMinutes(_configuration.GetValue <int>("Azure:ServiceBus:SourceSynchronizer:SubscriptionOptions:AutoDeleteOnIdle")),
DefaultMessageTimeToLive = TimeSpan.FromMinutes(_configuration.GetValue <int>("Azure:ServiceBus:SourceSynchronizer:SubscriptionOptions:DefaultMessageTimeToLive")),
EnableBatchedOperations = true,
//UserMetadata = "TODO:"
};
var ruleOptions = new CreateRuleOptions {
Name = "TargetClient", Filter = new SqlRuleFilter($"Client = '{_configuration.GetValue<string>("Azure:ServiceBus:SourceSynchronizer:RuleOptions:ClientName")}'")
};
var createdSubscription = await _sbAdminClient.CreateSubscriptionAsync(subscriptionOptions, ruleOptions);
return(createdSubscription.Value.SubscriptionName);
}
public static Task Create(ServiceBusAdministrationClient client, CommandArgument endpointName, CommandOption topicName, CommandOption subscriptionName)
{
var topicNameToUse = topicName.HasValue() ? topicName.Value() : Topic.DefaultTopicName;
var subscriptionNameToUse = subscriptionName.HasValue() ? subscriptionName.Value() : endpointName.Value;
var options = new CreateSubscriptionOptions(topicNameToUse, subscriptionNameToUse)
{
LockDuration = TimeSpan.FromMinutes(5),
ForwardTo = endpointName.Value,
EnableDeadLetteringOnFilterEvaluationExceptions = false,
MaxDeliveryCount = int.MaxValue,
EnableBatchedOperations = true,
UserMetadata = endpointName.Value
};
return(client.CreateSubscriptionAsync(options, new CreateRuleOptions("$default", new FalseRuleFilter())));
}
public async Task SetupAsync(IHost host)
{
using var scope = host.Services.CreateScope();
var referenceFactory = scope.ServiceProvider.GetRequiredService <IQueueReferenceFactory>();
var policy = referenceFactory.Create <TM>();
var azureConfig = scope.ServiceProvider.GetRequiredService <AzureServiceBusConfiguration>();
var adminClient = new ServiceBusAdministrationClient(azureConfig.ConnectionString);
if (!(await adminClient.TopicExistsAsync(policy.TopicName)))
{
await adminClient.CreateTopicAsync(policy.TopicName);
}
if (!(await adminClient.SubscriptionExistsAsync(policy.TopicName, policy.SubscriptionName)))
{
await adminClient.CreateSubscriptionAsync(policy.TopicName, policy.SubscriptionName);
}
}
public ServiceBusQueue(string connectionString, string topicName, string subscription, ServiceBusReceiveMode receiveMode = ServiceBusReceiveMode.PeekLock, bool createQueueIfItDoesNotExist = true)
: base(connectionString)
{
this.connectionString = connectionString;
this.queueName = topicName;
this.topicName = topicName;
this.subscription = subscription;
this.receiveMode = receiveMode;
this.SubQueue = SubQueue.None;
busAdmin = new ServiceBusAdministrationClient(this.connectionString);
if (createQueueIfItDoesNotExist && !busAdmin.TopicExistsAsync(topicName).Result.Value)
{
busAdmin.CreateTopicAsync(topicName).Wait();
}
if (createQueueIfItDoesNotExist && !string.IsNullOrEmpty(subscription) && !busAdmin.SubscriptionExistsAsync(topicName, subscription).Result.Value)
{
busAdmin.CreateSubscriptionAsync(topicName, subscription).Wait();
}
}
public async Task SetupAsync(IHost host)
{
using var scope = host.Services.CreateScope();
var referenceFactory = scope.ServiceProvider.GetRequiredService <IQueueReferenceFactory>();
var policy = referenceFactory.Create <TM>();
var azureConfig = scope.ServiceProvider.GetRequiredService <AzureServiceBusConfiguration>();
var adminClient = new ServiceBusAdministrationClient(azureConfig.ConnectionString);
try
{
if (!await adminClient.TopicExistsAsync(policy.TopicName))
{
await adminClient.CreateTopicAsync(new CreateTopicOptions(policy.TopicName)
{
RequiresDuplicateDetection = true
});
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
try
{
if (!await adminClient.SubscriptionExistsAsync(policy.TopicName, policy.SubscriptionName))
{
await adminClient.CreateSubscriptionAsync(policy.TopicName, policy.SubscriptionName);
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
public async Task EnsureTopicSubscription(
string topicName,
string subscriptionName,
CancellationToken cancellationToken = default,
string sqlFilterRule = "1=1")
{
try
{
if (!await _administrationClient.SubscriptionExistsAsync(topicName, subscriptionName, cancellationToken))
{
const string defaultRuleName = "$Default";
var subscriptionOptions = new CreateSubscriptionOptions(topicName, subscriptionName)
{
Status = EntityStatus.Active,
MaxDeliveryCount = 10,
LockDuration = TimeSpan.FromSeconds(60)
};
var filterOptions = new CreateRuleOptions
{
Name = defaultRuleName,
Filter = new SqlRuleFilter(string.IsNullOrWhiteSpace(sqlFilterRule) ? "1=1" : sqlFilterRule)
};
await _administrationClient.CreateSubscriptionAsync(subscriptionOptions, filterOptions, cancellationToken);
}
}
catch (Exception ex)
{
_logger.LogError(ex, "Service Bus ensure topic subscription operation failure");
throw new ServiceBusSubscriberOperationException(
"Service Bus ensure topic subscription operation failure", ex);
}
}
public async Task StartAsync(CancellationToken cancellationToken)
{
if (Subscription == null)
{
if (!await _administrationClient.QueueExistsAsync(QueueOrTopic, cancellationToken))
{
await _administrationClient.CreateQueueAsync(QueueOrTopic, cancellationToken);
}
}
else
{
if (!await _administrationClient.TopicExistsAsync(QueueOrTopic, cancellationToken))
{
await _administrationClient.CreateTopicAsync(QueueOrTopic, cancellationToken);
}
if (!await _administrationClient.SubscriptionExistsAsync(QueueOrTopic, Subscription, cancellationToken))
{
await _administrationClient.CreateSubscriptionAsync(QueueOrTopic, Subscription, cancellationToken);
}
}
await _processor.StartProcessingAsync(cancellationToken);
}
private static async Task RunAsync(string fullyQualifiedNamespace, string connection)
{
if (!string.IsNullOrEmpty(connection))
{
s_client = new ServiceBusClient(Environment.GetEnvironmentVariable(connection));
s_adminClient = new ServiceBusAdministrationClient(Environment.GetEnvironmentVariable(connection));
}
else if (!string.IsNullOrEmpty(fullyQualifiedNamespace))
{
var defaultAzureCredential = new DefaultAzureCredential();
s_client = new ServiceBusClient(fullyQualifiedNamespace, defaultAzureCredential);
s_adminClient = new ServiceBusAdministrationClient(fullyQualifiedNamespace, defaultAzureCredential);
}
else
{
throw new ArgumentException(
"Either a fully qualified namespace or a connection string environment variable must be specified.");
}
Console.WriteLine($"Creating topic {TopicName}");
await s_adminClient.CreateTopicAsync(TopicName);
s_sender = s_client.CreateSender(TopicName);
// First Subscription is already created with default rule. Leave as is.
Console.WriteLine($"Creating subscription {NoFilterSubscriptionName}");
await s_adminClient.CreateSubscriptionAsync(TopicName, NoFilterSubscriptionName);
Console.WriteLine($"SubscriptionName: {NoFilterSubscriptionName}, Removing and re-adding Default Rule");
await s_adminClient.DeleteRuleAsync(TopicName, NoFilterSubscriptionName, RuleProperties.DefaultRuleName);
await s_adminClient.CreateRuleAsync(TopicName, NoFilterSubscriptionName,
new CreateRuleOptions(RuleProperties.DefaultRuleName, new TrueRuleFilter()));
// 2nd Subscription: Add SqlFilter on Subscription 2
// In this scenario, rather than deleting the default rule after creating the subscription,
// we will create the subscription along with our desired rule in a single operation.
// See https://docs.microsoft.com/en-us/azure/service-bus-messaging/topic-filters to learn more about topic filters.
Console.WriteLine($"Creating subscription {SqlFilterOnlySubscriptionName}");
await s_adminClient.CreateSubscriptionAsync(
new CreateSubscriptionOptions(TopicName, SqlFilterOnlySubscriptionName),
new CreateRuleOptions { Name = "RedSqlRule", Filter = new SqlRuleFilter("Color = 'Red'") });
// 3rd Subscription: Add the SqlFilter Rule and Action
// See https://docs.microsoft.com/en-us/azure/service-bus-messaging/topic-filters#actions to learn more about actions.
Console.WriteLine($"Creating subscription {SqlFilterWithActionSubscriptionName}");
await s_adminClient.CreateSubscriptionAsync(
new CreateSubscriptionOptions(TopicName, SqlFilterWithActionSubscriptionName),
new CreateRuleOptions
{
Name = "BlueSqlRule",
Filter = new SqlRuleFilter("Color = 'Blue'"),
Action = new SqlRuleAction("SET Color = 'BlueProcessed'")
});
// 4th Subscription: Add Correlation Filter on Subscription 4
Console.WriteLine($"Creating subscription {CorrelationFilterSubscriptionName}");
await s_adminClient.CreateSubscriptionAsync(
new CreateSubscriptionOptions(TopicName, CorrelationFilterSubscriptionName),
new CreateRuleOptions
{
Name = "ImportantCorrelationRule",
Filter = new CorrelationRuleFilter {
Subject = "Red", CorrelationId = "important"
}
});
// Get Rules on Subscription, called here only for one subscription as example
var rules = s_adminClient.GetRulesAsync(TopicName, CorrelationFilterSubscriptionName);
await foreach (var rule in rules)
{
Console.WriteLine(
$"GetRules:: SubscriptionName: {CorrelationFilterSubscriptionName}, CorrelationFilter Name: {rule.Name}, Rule: {rule.Filter}");
}
// Send messages to Topic
await SendMessagesAsync();
// Receive messages from 'NoFilterSubscription'. Should receive all 9 messages
await ReceiveMessagesAsync(NoFilterSubscriptionName);
// Receive messages from 'SqlFilterOnlySubscription'. Should receive all messages with Color = 'Red' i.e 3 messages
await ReceiveMessagesAsync(SqlFilterOnlySubscriptionName);
// Receive messages from 'SqlFilterWithActionSubscription'. Should receive all messages with Color = 'Blue'
// i.e 3 messages AND all messages should have color set to 'BlueProcessed'
await ReceiveMessagesAsync(SqlFilterWithActionSubscriptionName);
// Receive messages from 'CorrelationFilterSubscription'. Should receive all messages with Color = 'Red' and CorrelationId = "important"
// i.e 1 message
await ReceiveMessagesAsync(CorrelationFilterSubscriptionName);
Console.ResetColor();
Console.WriteLine("=======================================================================");
Console.WriteLine("Completed Receiving all messages. Disposing clients and deleting topic.");
Console.WriteLine("=======================================================================");
Console.WriteLine("Disposing sender");
await s_sender.CloseAsync();
Console.WriteLine("Disposing client");
await s_client.DisposeAsync();
Console.WriteLine("Deleting topic");
// Deleting the topic will handle deleting all the subscriptions as well.
await s_adminClient.DeleteTopicAsync(TopicName);
}
private async Task <Azure.Response <SubscriptionProperties> > CreateSubscriptionAsync() => await _serviceBusAdminClient.CreateSubscriptionAsync(_createSubscriptionOptions);
public async Task StartAsync(CancellationToken cancellationToken)
{
_cancellationToken = cancellationToken;
_client = await _clientFactory.GetReceiverClient <TTopic, IEventSubscription <TTopic> >(_subscription, new ServiceBusProcessorOptions
{
AutoCompleteMessages = false,
MaxAutoLockRenewalDuration = Settings.MessageLockTimeout,
MaxConcurrentCalls = Settings.MaxConcurrentCalls,
PrefetchCount = Settings.PrefetchCount,
ReceiveMode = ServiceBusReceiveMode.PeekLock
}).ConfigureAwait(false);
var topicName = AutoMessageMapper.GetQueueName <TTopic>();
if (!await _managementClient.TopicExistsAsync(topicName, cancellationToken).ConfigureAwait(false))
{
try
{
var serviceBusCreationOptions = GetServiceBusCreationOptions();
await _managementClient.CreateTopicAsync(new CreateTopicOptions(topicName)
{
EnablePartitioning = serviceBusCreationOptions.EnablePartitioning,
EnableBatchedOperations = serviceBusCreationOptions.EnableBatchedOperations,
SupportOrdering = serviceBusCreationOptions.SupportOrdering
}, cancellationToken).ConfigureAwait(false);
}
catch (ServiceBusException e)
{
_log.Error(e, "Failed to create topic {TopicName}", topicName);
throw;
}
}
if (!await _managementClient.SubscriptionExistsAsync(topicName, _subscription.Name, cancellationToken).ConfigureAwait(false))
{
try
{
var serviceBusCreationOptions = GetServiceBusCreationOptions();
await _managementClient.CreateSubscriptionAsync(new CreateSubscriptionOptions(topicName, _subscription.Name)
{
EnableBatchedOperations = serviceBusCreationOptions.EnableBatchedOperations
}, cancellationToken).ConfigureAwait(false);
}
catch (ServiceBusException e)
{
_log.Error(e, "Failed to create subscription {TopicName} {SubscriptionName}", topicName, _subscription.Name);
throw;
}
}
_deadLetterLimit = Settings.DeadLetterDeliveryLimit;
_client.ProcessMessageAsync += ClientOnProcessMessageAsync;
_client.ProcessErrorAsync += ClientOnProcessErrorAsync;
await _client.StartProcessingAsync(cancellationToken);
#pragma warning disable 4014
// ReSharper disable once MethodSupportsCancellation
Task.Run(async() =>
{
_cancellationToken.WaitHandle.WaitOne();
//Cancellation requested
try
{
_log.Information($"Closing ServiceBus channel receiver for {typeof(TTopic).Name}");
await _client.CloseAsync(CancellationToken.None);
}
catch (Exception)
{
//Swallow
}
});
#pragma warning restore 4014
}
