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 CreateSubscriptionIfNotExistsAsync(string topicName, string subscriptionName, CancellationToken cancellationToken)
{
// if entity creation is not enabled, just return
if (!TransportOptions.EnableEntityCreation)
{
Logger.LogTrace("Entity creation is diabled. Subscription creation skipped");
return;
}
// If the subscription does not exist, create it
Logger.LogDebug("Checking if subscription '{SubscriptionName}' under topic '{TopicName}' exists",
subscriptionName,
topicName);
if (!await managementClient.SubscriptionExistsAsync(topicName, subscriptionName, cancellationToken))
{
Logger.LogTrace("Subscription '{SubscriptionName}' under topic '{TopicName}' does not exist, preparing creation.",
subscriptionName,
topicName);
var options = new CreateSubscriptionOptions(topicName: topicName, subscriptionName: subscriptionName)
{
// set the defaults for a subscription here
Status = EntityStatus.Active,
MaxDeliveryCount = 10,
};
// Allow for the defaults to be overriden
TransportOptions.SetupSubscriptionOptions?.Invoke(options);
Logger.LogInformation("Creating subscription '{SubscriptionName}' under topic '{TopicName}'",
subscriptionName,
topicName);
await managementClient.CreateSubscriptionAsync(options : options, cancellationToken : cancellationToken);
}
}
private static async Task Setup(this ServiceBusAdministrationClient admin, string topic, string subscription)
{
if (!(await admin.SubscriptionExistsAsync(topic, subscription)).Value)
{
await admin.CreateSubscriptionAsync(topic, subscription);
}
}
private async Task CreateTopicSubscriptionAsync(CancellationToken cancellationToken)
{
ServiceBusAdministrationClient serviceBusClient = await Settings.GetServiceBusAdminClientAsync();
string entityPath = await Settings.GetEntityPathAsync();
try
{
bool subscriptionExists = await serviceBusClient.SubscriptionExistsAsync(entityPath, SubscriptionName, cancellationToken);
if (subscriptionExists)
{
Logger.LogTrace("Topic subscription with name '{SubscriptionName}' already exists on Service Bus resource", SubscriptionName);
}
else
{
Logger.LogTrace("Creating subscription '{SubscriptionName}' on topic '{TopicPath}'...", SubscriptionName, entityPath);
var subscriptionDescription = new CreateSubscriptionOptions(entityPath, SubscriptionName)
{
UserMetadata = $"Subscription created by Arcus job: '{JobId}' to process Service Bus messages."
};
var ruleDescription = new CreateRuleOptions("Accept-All", new TrueRuleFilter());
await serviceBusClient.CreateSubscriptionAsync(subscriptionDescription, ruleDescription, cancellationToken)
.ConfigureAwait(continueOnCapturedContext: false);
Logger.LogTrace("Subscription '{SubscriptionName}' created on topic '{TopicPath}'", SubscriptionName, entityPath);
}
}
catch (Exception exception)
{
Logger.LogWarning(exception, "Failed to create topic subscription with name '{SubscriptionName}' on Service Bus resource", SubscriptionName);
}
}
async Task DeleteSubscriptionAsync()
{
if (await _sbAdminClient.SubscriptionExistsAsync(_topicName, _subscriptionName))
{
await _sbAdminClient.DeleteSubscriptionAsync(_topicName, _subscriptionName);
}
}
private async Task DeleteTopicSubscriptionAsync(CancellationToken cancellationToken)
{
ServiceBusAdministrationClient serviceBusClient = await Settings.GetServiceBusAdminClientAsync();
string entityPath = await Settings.GetEntityPathAsync();
try
{
bool subscriptionExists = await serviceBusClient.SubscriptionExistsAsync(entityPath, SubscriptionName, cancellationToken);
if (subscriptionExists)
{
Logger.LogTrace("Deleting subscription '{SubscriptionName}' on topic '{Path}'...", SubscriptionName, entityPath);
await serviceBusClient.DeleteSubscriptionAsync(entityPath, SubscriptionName, cancellationToken);
Logger.LogTrace("Subscription '{SubscriptionName}' deleted on topic '{Path}'", SubscriptionName, entityPath);
}
else
{
Logger.LogTrace("Cannot delete topic subscription with name '{SubscriptionName}' because no subscription exists on Service Bus resource", SubscriptionName);
}
}
catch (Exception exception)
{
Logger.LogWarning(exception, "Failed to delete topic subscription with name '{SubscriptionName}' on Service Bus resource", SubscriptionName);
}
}
/// <summary>
/// Check if a Subscription Exists for a Topic.
/// </summary>
/// <param name="topicName">The name of the Topic.</param>
/// <param name="subscriptionName">The name of the Subscription</param>
/// <returns>True if the subscription exists on the specified Topic.</returns>
public bool SubscriptionExists(string topicName, string subscriptionName)
{
s_logger.LogDebug("Checking if subscription {ChannelName} for topic {Topic} exists...", subscriptionName, topicName);
bool result;
try
{
result = _administrationClient.SubscriptionExistsAsync(topicName, subscriptionName).Result;
}
catch (Exception e)
{
s_logger.LogError(e, "Failed to check if subscription {ChannelName} for topic {Topic} exists.", subscriptionName, topicName);
throw;
}
if (result)
{
s_logger.LogDebug("Subscription {ChannelName} for topic {Topic} exists.", subscriptionName, topicName);
}
else
{
s_logger.LogWarning("Subscription {ChannelName} for topic {Topic} does not exist.", subscriptionName, topicName);
}
return(result);
}
public static async Task SetupSubscriptionAsync(this ServiceBusAdministrationClient client, string topicName, string subscriptionName)
{
await client.SetupTopicAsync(topicName);
if (!await client.SubscriptionExistsAsync(topicName, subscriptionName))
{
await client.CreateSubscriptionAsync(topicName, subscriptionName);
}
}
public static async Task DeleteSubscription(string connectionString, string topic, string subscription)
{
var client = new ServiceBusAdministrationClient(connectionString);
bool subscriptionExists = await client.SubscriptionExistsAsync(topic, subscription);
if (subscriptionExists)
{
await client.DeleteSubscriptionAsync(topic, subscription);
}
}
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 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 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 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 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)
{
_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
}
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();
}
}