private static async Task Setup(this ServiceBusAdministrationClient admin, string topic)
{
if (!(await admin.TopicExistsAsync(topic)).Value)
{
await admin.CreateTopicAsync(new CreateTopicOptions(topic));
}
}
private async Task CreateTopicIfNotExistsAsync(string name, CancellationToken cancellationToken)
{
// if entity creation is not enabled, just return
if (!TransportOptions.EnableEntityCreation)
{
Logger.LogTrace("Entity creation is diabled. Topic creation skipped");
return;
}
// If the topic does not exist, create it
Logger.LogDebug("Checking if topic '{TopicName}' exists", name);
if (!await managementClient.TopicExistsAsync(name: name, cancellationToken: cancellationToken))
{
Logger.LogTrace("Topic '{TopicName}' does not exist, preparing creation.", name);
var options = new CreateTopicOptions(name: name)
{
// set the defaults for a topic here
Status = EntityStatus.Active,
EnablePartitioning = false,
RequiresDuplicateDetection = BusOptions.EnableDeduplication,
DuplicateDetectionHistoryTimeWindow = BusOptions.DuplicateDetectionDuration,
};
// Allow for the defaults to be overriden
TransportOptions.SetupTopicOptions?.Invoke(options);
Logger.LogInformation("Creating topic '{TopicName}'", name);
_ = await managementClient.CreateTopicAsync(options : options, cancellationToken : cancellationToken);
}
}
public static async Task <TopicScope> CreateWithTopic(ServiceBusAdministrationClient adminClient)
{
var topicName = Guid.NewGuid().ToString("D");
var response = await adminClient.CreateTopicAsync(topicName).ConfigureAwait(false);
return(new TopicScope(adminClient, topicName, null));
}
public static async Task SetupTopicAsync(this ServiceBusAdministrationClient client, string topicName)
{
if (!await client.TopicExistsAsync(topicName))
{
await client.CreateTopicAsync(topicName);
}
}
private static async Task SendTextMessageToTopic()
{
const string topicName = "sbt-text-message";
var managementClient = new ServiceBusAdministrationClient(Config.Namespace, Config.Credential);
if (!await managementClient.TopicExistsAsync(topicName))
{
await managementClient.CreateTopicAsync(topicName);
}
await using var client = new ServiceBusClient(Config.Namespace, Config.Credential);
var sender = client.CreateSender(topicName);
var message = new ServiceBusMessage(Encoding.UTF8.GetBytes("This is a simple test message"));
Console.WriteLine("Press any key to send a message. Press Enter to exit.");
while (Console.ReadKey(true).Key != ConsoleKey.Enter)
{
await sender.SendMessageAsync(message);
Console.WriteLine($"Message Sent for {nameof(SendTextMessageToTopic)}");
}
Console.ReadLine();
await managementClient.DeleteQueueAsync(topicName);
}
private static async Task <ServiceBusAdministrationClient> Cleanup(string connectionString, string inputQueue,
string topicName, string rushSubscription, string currencySubscription)
{
var client = new ServiceBusAdministrationClient(connectionString);
if (await client.SubscriptionExistsAsync(topicName, rushSubscription))
{
await client.DeleteSubscriptionAsync(topicName, rushSubscription);
}
if (await client.SubscriptionExistsAsync(topicName, currencySubscription))
{
await client.DeleteSubscriptionAsync(topicName, currencySubscription);
}
if (await client.TopicExistsAsync(topicName))
{
await client.DeleteTopicAsync(topicName);
}
var topicDescription = new CreateTopicOptions(topicName);
await client.CreateTopicAsync(topicDescription);
if (await client.QueueExistsAsync(inputQueue))
{
await client.DeleteQueueAsync(inputQueue);
}
var queueDescription = new CreateQueueOptions(inputQueue);
await client.CreateQueueAsync(queueDescription);
return(client);
}
private async Task EnsureTopicExistsAsync(string topicName, CancellationToken cancellationToken)
{
if (!await _administrationClient.TopicExistsAsync(topicName, cancellationToken))
{
await _administrationClient.CreateTopicAsync(topicName, cancellationToken);
}
}
public static async Task Main()
{
try
{
Console.WriteLine("Creating the Service Bus Administration Client object");
adminClient = new ServiceBusAdministrationClient(connectionString);
Console.WriteLine($"Creating the topic {topicName}");
await adminClient.CreateTopicAsync(topicName);
Console.WriteLine($"Creating the subscription {subscriptionAllOrders} for the topic with a SQL filter ");
// Create a True Rule filter with an expression that always evaluates to true
// It's equivalent to using SQL rule filter with 1=1 as the expression
await adminClient.CreateSubscriptionAsync(
new CreateSubscriptionOptions(topicName, subscriptionAllOrders),
new CreateRuleOptions("AllOrders", new TrueRuleFilter()));
Console.WriteLine($"Creating the subscription {subscriptionColorBlueSize10Orders} with a SQL filter");
// Create a SQL filter with color set to blue and quantity to 10
await adminClient.CreateSubscriptionAsync(
new CreateSubscriptionOptions(topicName, subscriptionColorBlueSize10Orders),
new CreateRuleOptions("BlueSize10Orders", new SqlRuleFilter("color='blue' AND quantity=10")));
Console.WriteLine($"Creating the subscription {subscriptionColorRed} with a SQL filter");
// Create a SQL filter with color equals to red and a SQL action with a set of statements
await adminClient.CreateSubscriptionAsync(topicName, subscriptionColorRed);
// remove the $Default rule
await adminClient.DeleteRuleAsync(topicName, subscriptionColorRed, "$Default");
// now create the new rule. notice that user. prefix is used for the user/application property
await adminClient.CreateRuleAsync(topicName, subscriptionColorRed, new CreateRuleOptions
{
Name = "RedOrdersWithAction",
Filter = new SqlRuleFilter("user.color='red'"),
Action = new SqlRuleAction("SET quantity = quantity / 2; REMOVE priority;SET sys.CorrelationId = 'low';")
}
);
Console.WriteLine($"Creating the subscription {subscriptionHighPriorityRedOrders} with a correlation filter");
// Create a correlation filter with color set to Red and priority set to High
await adminClient.CreateSubscriptionAsync(
new CreateSubscriptionOptions(topicName, subscriptionHighPriorityRedOrders),
new CreateRuleOptions("HighPriorityRedOrders", new CorrelationRuleFilter()
{
Subject = "red", CorrelationId = "high"
} ));
// delete resources
//await adminClient.DeleteTopicAsync(topicName);
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
}
public async Task CreateTopicAsync()
{
var connString = _configuration.GetValue <string>("Azure:ServiceBus:SourceSynchronizer:ConnString");
var sbAdminClient = new ServiceBusAdministrationClient(connString);
if (!await sbAdminClient.TopicExistsAsync(_topicName))
{
await sbAdminClient.CreateTopicAsync(_topicName);
}
}
public async Task GetUpdateDeleteTopicAndSubscription()
{
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);
var topicOptions = new CreateTopicOptions(topicName);
var subscriptionOptions = new CreateSubscriptionOptions(topicName, subscriptionName);
await client.CreateTopicAsync(topicOptions);
await client.CreateSubscriptionAsync(subscriptionOptions);
#region Snippet:GetTopic
TopicProperties topic = await client.GetTopicAsync(topicName);
#endregion
#region Snippet:GetSubscription
SubscriptionProperties subscription = await client.GetSubscriptionAsync(topicName, subscriptionName);
#endregion
#region Snippet:UpdateTopic
topic.UserMetadata = "some metadata";
TopicProperties updatedTopic = await client.UpdateTopicAsync(topic);
#endregion
Assert.AreEqual("some metadata", updatedTopic.UserMetadata);
#region Snippet:UpdateSubscription
subscription.UserMetadata = "some metadata";
SubscriptionProperties updatedSubscription = await client.UpdateSubscriptionAsync(subscription);
#endregion
Assert.AreEqual("some metadata", updatedSubscription.UserMetadata);
// need to delete the subscription before the topic, as deleting
// the topic would automatically delete the subscription
#region Snippet:DeleteSubscription
await client.DeleteSubscriptionAsync(topicName, subscriptionName);
#endregion
Assert.That(
async() =>
await client.GetSubscriptionAsync(topicName, subscriptionName),
Throws.InstanceOf <ServiceBusException>().And.Property(nameof(ServiceBusException.Reason)).EqualTo(ServiceBusFailureReason.MessagingEntityNotFound));
#region Snippet:DeleteTopic
await client.DeleteTopicAsync(topicName);
#endregion
Assert.That(
async() =>
await client.GetTopicAsync(topicName),
Throws.InstanceOf <ServiceBusException>().And.Property(nameof(ServiceBusException.Reason)).EqualTo(ServiceBusFailureReason.MessagingEntityNotFound));
}
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);
}
}
private ServiceBusSender GetServiceBusTopicSender(string topicName)
{
var busAdmin = new ServiceBusAdministrationClient(Connections.ServiceBusConnectionString);
if (!busAdmin.TopicExistsAsync(topicName).Result.Value)
{
busAdmin.CreateTopicAsync(topicName).Wait();
}
ServiceBusClient client = new ServiceBusClient(Connections.ServiceBusConnectionString);
return(client.CreateSender(topicName));
}
public static Task Create(ServiceBusAdministrationClient client, CommandOption topicName, CommandOption <int> size, CommandOption partitioning)
{
var topicNameToUse = topicName.HasValue() ? topicName.Value() : DefaultTopicName;
var options = new CreateTopicOptions(topicNameToUse)
{
EnableBatchedOperations = true,
EnablePartitioning = partitioning.HasValue(),
MaxSizeInMegabytes = (size.HasValue() ? size.ParsedValue : 5) * 1024
};
return(client.CreateTopicAsync(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);
}
}
public async Task CreateQueues(string[] queues, CancellationToken cancellationToken = default)
{
await namespacePermissions.CanManage(cancellationToken).ConfigureAwait(false);
var topic = new CreateTopicOptions(transportSettings.TopicName)
{
EnableBatchedOperations = true,
EnablePartitioning = transportSettings.EnablePartitioning,
MaxSizeInMegabytes = maxSizeInMb
};
try
{
await administrativeClient.CreateTopicAsync(topic, cancellationToken).ConfigureAwait(false);
}
catch (ServiceBusException sbe) when(sbe.Reason == ServiceBusFailureReason.MessagingEntityAlreadyExists)
{
Logger.Info($"Topic {topic.Name} already exists");
}
catch (ServiceBusException sbe) when(sbe.IsTransient) // An operation is in progress.
{
Logger.Info($"Topic creation for {topic.Name} is already in progress");
}
foreach (var address in queues)
{
var queue = new CreateQueueOptions(address)
{
EnableBatchedOperations = true,
LockDuration = TimeSpan.FromMinutes(5),
MaxDeliveryCount = int.MaxValue,
MaxSizeInMegabytes = maxSizeInMb,
EnablePartitioning = transportSettings.EnablePartitioning
};
try
{
await administrativeClient.CreateQueueAsync(queue, cancellationToken).ConfigureAwait(false);
}
catch (ServiceBusException sbe) when(sbe.Reason == ServiceBusFailureReason.MessagingEntityAlreadyExists)
{
Logger.Debug($"Queue {queue.Name} already exists");
}
catch (ServiceBusException sbe) when(sbe.IsTransient) // An operation is in progress.
{
Logger.Info($"Queue creation for {queue.Name} is already in progress");
}
}
}
/// <summary>
/// Create a Topic
/// </summary>
/// <param name="topic">The name of the Topic</param>
public void CreateTopic(string topic)
{
s_logger.LogInformation("Creating topic {Topic}...", topic);
try
{
_administrationClient.CreateTopicAsync(topic).GetAwaiter().GetResult();
}
catch (Exception e)
{
s_logger.LogError(e, "Failed to create topic {Topic}.", topic);
throw;
}
s_logger.LogInformation("Topic {Topic} created.", topic);
}
private void CreateTopicAndSubscriptions(string topicName, string[] subscriptions)
{
var busAdmin = new ServiceBusAdministrationClient(Connections.ServiceBusConnectionString);
if (!busAdmin.TopicExistsAsync(topicName).Result.Value)
{
busAdmin.CreateTopicAsync(topicName).Wait();
}
foreach (var subscription in subscriptions)
{
if (!busAdmin.SubscriptionExistsAsync(topicName, subscription).Result.Value)
{
busAdmin.CreateSubscriptionAsync(topicName, subscription).Wait();
}
}
}
public static async Task <TopicProperties> CreateTopicAsync(string topicName, string connectionString)
{
var client = new ServiceBusAdministrationClient(connectionString);
var topicOptions = new CreateTopicOptions(topicName)
{
DefaultMessageTimeToLive = TimeSpan.FromDays(2),
DuplicateDetectionHistoryTimeWindow = TimeSpan.FromMinutes(1),
EnableBatchedOperations = true,
EnablePartitioning = false,
MaxSizeInMegabytes = 2048,
UserMetadata = "some metadata"
};
topicOptions.AuthorizationRules.Add(new SharedAccessAuthorizationRule(
"allClaims",
new[] { AccessRights.Manage, AccessRights.Send, AccessRights.Listen }));
return(await client.CreateTopicAsync(topicOptions));
}
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 EnsureTopic(string topicName, CancellationToken cancellationToken = default)
{
try
{
if (!await _administrationClient.TopicExistsAsync(topicName, cancellationToken))
{
var options = new CreateTopicOptions(topicName)
{
Status = EntityStatus.Active,
MaxSizeInMegabytes = 1024,
DefaultMessageTimeToLive = TimeSpan.FromDays(10000)
};
await _administrationClient.CreateTopicAsync(options, cancellationToken);
}
}
catch (Exception ex)
{
_logger.LogError(ex, "Service Bus ensure topic operation failure");
throw new ServiceBusPublisherOperationException("Service Bus ensure topic operation failure", ex);
}
}
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 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);
}
public static async Task EnsureTopicExists(string connectionString, string topic)
{
var sbClient = new ServiceBusAdministrationClient(connectionString);
_ = await sbClient.CreateTopicAsync(topic);
}
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);
}
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
}
