public AzureServiceBusAdminClient(string connectionString, CreateSubscriptionOptions createSubscriptionOptions)
{
_connectionString = connectionString;
_createSubscriptionOptions = createSubscriptionOptions;
ThrowIfInvalidCreateSubscriptionOptions(createSubscriptionOptions);
_serviceBusAdminClient = BuildServiceBusAdminClient();
}
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);
}
}
private static void ThrowIfInvalidCreateSubscriptionOptions(CreateSubscriptionOptions createSubscriptionOptions)
{
if (createSubscriptionOptions.RequiresSession)
{
throw new InvalidOperationException("RequiresSession is not yet supported");
}
}
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);
}
}
public static async Task Stage(string connectionString, string topicName, string rushSubscription,
string currencySubscription)
{
var client = await Cleanup(connectionString, topicName, rushSubscription, currencySubscription);
var subscriptionDescription = new CreateSubscriptionOptions(topicName, rushSubscription);
await client.CreateSubscriptionAsync(subscriptionDescription);
subscriptionDescription = new CreateSubscriptionOptions(topicName, currencySubscription);
await client.CreateSubscriptionAsync(subscriptionDescription);
await client.DeleteRuleAsync(topicName, rushSubscription, "$Default");
await client.DeleteRuleAsync(topicName, currencySubscription, "$Default");
var ruleDescription = new CreateRuleOptions
{
Name = "MessagesWithRushlabel",
Filter = new CorrelationRuleFilter
{
Subject = "rush"
},
Action = null
};
await client.CreateRuleAsync(topicName, rushSubscription, ruleDescription);
ruleDescription = new CreateRuleOptions
{
Name = "MessagesWithCurrencyCHF",
Filter = new SqlRuleFilter("currency = 'CHF'"),
Action = new SqlRuleAction("SET currency = 'Złoty'")
};
await client.CreateRuleAsync(topicName, currencySubscription, ruleDescription);
}
public async Task UpdatesSubscriptionCustomOptions()
{
var messageHandlerMappings = new List <MessageHandlerMapping>
{
new MessageHandlerMapping(typeof(AircraftLanded), typeof(AircraftLandedHandler),
BuildSubscriptionFilter <AircraftLanded>()),
};
var subscription = nameof(UpdatesSubscriptionCustomOptions);
await DeleteSubscriptionAsync(subscription);
var initialSubscriptionOptions = new CreateSubscriptionOptions(_topic, subscription)
{
LockDuration = TimeSpan.FromSeconds(60),
MaxDeliveryCount = 5,
DefaultMessageTimeToLive = TimeSpan.FromSeconds(300)
};
var newSubscriptionOptions = new CreateSubscriptionOptions(_topic, subscription)
{
LockDuration = TimeSpan.FromSeconds(30),
MaxDeliveryCount = 5,
DefaultMessageTimeToLive = TimeSpan.FromSeconds(150)
};
await new AzureServiceBusAdminClient(_hostname, _tenantId, initialSubscriptionOptions)
.ConfigureAsync(messageHandlerMappings, new MessageBusOptions());
await AssertSubscriptionOptions(subscription, initialSubscriptionOptions);
await new AzureServiceBusAdminClient(_hostname, _tenantId, newSubscriptionOptions)
.ConfigureAsync(messageHandlerMappings, new MessageBusOptions());
await AssertSubscriptionRules(messageHandlerMappings[0], subscription);
await AssertSubscriptionOptions(subscription, newSubscriptionOptions);
}
private async Task CreateSubscriptionAsync(string topicName, string subscriptionName, AzureServiceBusSubscriptionConfiguration subscriptionConfiguration)
{
s_logger.LogInformation("Creating subscription {ChannelName} for topic {Topic}...", subscriptionName, topicName);
if (!TopicExists(topicName))
{
CreateTopic(topicName);
}
var subscriptionOptions = new CreateSubscriptionOptions(topicName, subscriptionName)
{
MaxDeliveryCount = subscriptionConfiguration.MaxDeliveryCount,
DeadLetteringOnMessageExpiration = subscriptionConfiguration.DeadLetteringOnMessageExpiration,
LockDuration = subscriptionConfiguration.LockDuration,
DefaultMessageTimeToLive = subscriptionConfiguration.DefaultMessageTimeToLive
};
var ruleOptions = string.IsNullOrEmpty(subscriptionConfiguration.SqlFilter)
? new CreateRuleOptions() : new CreateRuleOptions("sqlFilter", new SqlRuleFilter(subscriptionConfiguration.SqlFilter));
try
{
await _administrationClient.CreateSubscriptionAsync(subscriptionOptions, ruleOptions);
}
catch (Exception e)
{
s_logger.LogError(e, "Failed to create subscription {ChannelName} for topic {Topic}.", subscriptionName, topicName);
throw;
}
s_logger.LogInformation("Subscription {ChannelName} for topic {Topic} created.", subscriptionName, topicName);
}
public async Task CreateSubscription(CancellationToken cancellationToken = default)
{
await namespacePermissions.CanManage(cancellationToken).ConfigureAwait(false);
var subscription = new CreateSubscriptionOptions(transportSettings.TopicName, subscriptionName)
{
LockDuration = TimeSpan.FromMinutes(5),
ForwardTo = subscribingQueue,
EnableDeadLetteringOnFilterEvaluationExceptions = false,
MaxDeliveryCount = int.MaxValue,
EnableBatchedOperations = true,
UserMetadata = subscribingQueue
};
try
{
await administrativeClient.CreateSubscriptionAsync(subscription,
new CreateRuleOptions("$default", new FalseRuleFilter()), cancellationToken).ConfigureAwait(false);
}
catch (ServiceBusException sbe) when(sbe.Reason == ServiceBusFailureReason.MessagingEntityAlreadyExists)
{
Logger.Debug($"Default subscription rule for topic {subscription.TopicName} already exists");
}
catch (ServiceBusException sbe) when(sbe.IsTransient) // An operation is in progress.
{
Logger.Info($"Default subscription rule for topic {subscription.TopicName} is already in progress");
}
}
public AzureServiceBusAdminClient(string?hostName, string topic, string subscription,
string tenantId)
{
_hostName = hostName;
_createSubscriptionOptions = new CreateSubscriptionOptions(topic, subscription);
_tenantId = tenantId;
_serviceBusAdminClient = BuildServiceBusAdminClient();
}
public AzureServiceBusAdminClient(string hostName, string tenantId, CreateSubscriptionOptions createSubscriptionOptions)
{
_hostName = hostName;
_tenantId = tenantId;
_createSubscriptionOptions = createSubscriptionOptions;
ThrowIfInvalidCreateSubscriptionOptions(createSubscriptionOptions);
_serviceBusAdminClient = BuildServiceBusAdminClient();
}
public async Task CreateTopicAndSubscription()
{
#if !SNIPPET
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);
#endif
try
{
#region Snippet:CreateTopicAndSubscription
#if SNIPPET
string connectionString = "<connection_string>";
string topicName = "<topic_name>";
var client = new ServiceBusManagementClient(connectionString);
#endif
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);
#if SNIPPET
string subscriptionName = "<subscription_name>";
#endif
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)
{
MaxMessageSizeInKilobytes = topicOptions.MaxMessageSizeInKilobytes
});
Assert.AreEqual(subscriptionOptions, new CreateSubscriptionOptions(createdSubscription));
}
finally
{
await client.DeleteTopicAsync(topicName);
}
}
public Task <Azure.Response <SubscriptionProperties> > CreateLemmasSubscription(string correlationId)
{
var lemmasSubscriptionOptions = new CreateSubscriptionOptions("lemmas", correlationId)
{
// TODO: probably it should be done in some other way
AutoDeleteOnIdle = TimeSpan.FromMinutes(10)
};
var correlationIdRuleOptions = new CreateRuleOptions("CorrelationIdRule", new CorrelationRuleFilter(correlationId));
return(TopicsAdministrationClient.CreateSubscriptionAsync(lemmasSubscriptionOptions, correlationIdRuleOptions));
}
public Task <Azure.Response <SubscriptionProperties> > CreateDictionaryArticlesSubscription(string correlationId)
{
var falseRuleOptions = new CreateRuleOptions("False", new FalseRuleFilter());
var dictionaryArticlesSubscriptionOptions = new CreateSubscriptionOptions("dictionary-articles", correlationId)
{
// TODO: probably it should be done in some other way
AutoDeleteOnIdle = TimeSpan.FromMinutes(10)
};
return(TopicsAdministrationClient.CreateSubscriptionAsync(dictionaryArticlesSubscriptionOptions, falseRuleOptions));
}
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 ServiceBusManagementClient(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));
}
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 void ConstructorThrowsIfRequiresSessionIsTrue()
{
var createSubscriptionOptions = new CreateSubscriptionOptions(_topic, _subscription)
{
LockDuration = TimeSpan.FromSeconds(60),
MaxDeliveryCount = 5,
DefaultMessageTimeToLive = TimeSpan.FromSeconds(300),
RequiresSession = true
};
Assert.Throws <InvalidOperationException>(() => new AzureServiceBusAdminClient(_hostname,
_tenantId, createSubscriptionOptions));
Assert.Throws <InvalidOperationException>(() => new AzureServiceBusAdminClient(_connectionString,
createSubscriptionOptions));
}
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);
}
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())));
}
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 void CanCreateSubscriptionPropertiesFromOptions()
{
var options = new CreateSubscriptionOptions("topic", "subscription")
{
LockDuration = TimeSpan.FromSeconds(60),
RequiresSession = true,
DefaultMessageTimeToLive = TimeSpan.FromSeconds(120),
AutoDeleteOnIdle = TimeSpan.FromMinutes(10),
DeadLetteringOnMessageExpiration = true,
MaxDeliveryCount = 5,
EnableBatchedOperations = true,
Status = EntityStatus.Disabled,
ForwardDeadLetteredMessagesTo = "dlqForward",
ForwardTo = "forward",
UserMetadata = "metadata"
};
var properties = new SubscriptionProperties(options);
Assert.AreEqual(options, new CreateSubscriptionOptions(properties));
}
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 BasicSubscriptionCrudOperations()
{
var topicName = nameof(BasicSubscriptionCrudOperations).ToLower() + Recording.Random.NewGuid().ToString("D").Substring(0, 8);
var subscriptionName = Recording.Random.NewGuid().ToString("D").Substring(0, 8);
var client = CreateClient();
await client.CreateTopicAsync(topicName);
var options = new CreateSubscriptionOptions(topicName, subscriptionName)
{
AutoDeleteOnIdle = TimeSpan.FromHours(1),
DefaultMessageTimeToLive = TimeSpan.FromDays(2),
DeadLetteringOnMessageExpiration = true,
EnableBatchedOperations = false,
ForwardDeadLetteredMessagesTo = null,
ForwardTo = null,
LockDuration = TimeSpan.FromSeconds(45),
MaxDeliveryCount = 8,
RequiresSession = true,
UserMetadata = nameof(BasicSubscriptionCrudOperations)
};
Response <SubscriptionProperties> createdSubscriptionResponse = await client.CreateSubscriptionAsync(options);
Response rawResponse = createdSubscriptionResponse.GetRawResponse();
Assert.NotNull(rawResponse.ClientRequestId);
Assert.IsTrue(rawResponse.ContentStream.CanRead);
Assert.AreEqual(0, rawResponse.ContentStream.Position);
SubscriptionProperties createdSubscription = createdSubscriptionResponse.Value;
Assert.AreEqual(options, new CreateSubscriptionOptions(createdSubscription));
SubscriptionProperties getSubscription = await client.GetSubscriptionAsync(options.TopicName, options.SubscriptionName);
Assert.AreEqual(options, new CreateSubscriptionOptions(getSubscription));
getSubscription.DefaultMessageTimeToLive = TimeSpan.FromDays(3);
getSubscription.MaxDeliveryCount = 9;
SubscriptionProperties updatedSubscription = await client.UpdateSubscriptionAsync(getSubscription);
Assert.AreEqual(getSubscription, updatedSubscription);
bool exists = await client.SubscriptionExistsAsync(topicName, subscriptionName);
Assert.True(exists);
List <SubscriptionProperties> subscriptionList = new List <SubscriptionProperties>();
await foreach (Page <SubscriptionProperties> subscriptionPage in client.GetSubscriptionsAsync(topicName).AsPages())
{
Assert.NotNull(subscriptionPage.GetRawResponse().ClientRequestId);
Assert.IsTrue(subscriptionPage.GetRawResponse().ContentStream.CanRead);
Assert.AreEqual(0, subscriptionPage.GetRawResponse().ContentStream.Position);
subscriptionList.AddRange(subscriptionPage.Values);
}
subscriptionList = subscriptionList.Where(e => e.TopicName.StartsWith(nameof(BasicSubscriptionCrudOperations).ToLower())).ToList();
Assert.True(subscriptionList.Count == 1, $"Expected 1 subscription but {subscriptionList.Count} subscriptions returned");
Assert.AreEqual(subscriptionList.First().TopicName, topicName);
Assert.AreEqual(subscriptionList.First().SubscriptionName, subscriptionName);
await client.DeleteSubscriptionAsync(options.TopicName, options.SubscriptionName);
Assert.That(
async() =>
await client.GetSubscriptionAsync(options.TopicName, options.SubscriptionName),
Throws.InstanceOf <ServiceBusException>().And.Property(nameof(ServiceBusException.Reason)).EqualTo(ServiceBusFailureReason.MessagingEntityNotFound));
await client.DeleteTopicAsync(options.TopicName);
exists = await client.SubscriptionExistsAsync(topicName, subscriptionName);
Assert.False(exists);
}
public async Task BasicSubscriptionCrudOperations()
{
var topicName = nameof(BasicSubscriptionCrudOperations).ToLower() + Guid.NewGuid().ToString("D").Substring(0, 8);
var subscriptionName = Guid.NewGuid().ToString("D").Substring(0, 8);
var client = new ServiceBusManagementClient(TestEnvironment.ServiceBusConnectionString);
await client.CreateTopicAsync(topicName);
var options = new CreateSubscriptionOptions(topicName, subscriptionName)
{
AutoDeleteOnIdle = TimeSpan.FromHours(1),
DefaultMessageTimeToLive = TimeSpan.FromDays(2),
DeadLetteringOnMessageExpiration = true,
EnableBatchedOperations = false,
ForwardDeadLetteredMessagesTo = null,
ForwardTo = null,
LockDuration = TimeSpan.FromSeconds(45),
MaxDeliveryCount = 8,
RequiresSession = true,
UserMetadata = nameof(BasicSubscriptionCrudOperations)
};
SubscriptionProperties createdSubscription = await client.CreateSubscriptionAsync(options);
Assert.AreEqual(options, new CreateSubscriptionOptions(createdSubscription));
SubscriptionProperties getSubscription = await client.GetSubscriptionAsync(options.TopicName, options.SubscriptionName);
Assert.AreEqual(options, new CreateSubscriptionOptions(getSubscription));
getSubscription.DefaultMessageTimeToLive = TimeSpan.FromDays(3);
getSubscription.MaxDeliveryCount = 9;
SubscriptionProperties updatedSubscription = await client.UpdateSubscriptionAsync(getSubscription);
Assert.AreEqual(getSubscription, updatedSubscription);
bool exists = await client.SubscriptionExistsAsync(topicName, subscriptionName);
Assert.True(exists);
List <SubscriptionProperties> subscriptionList = new List <SubscriptionProperties>();
await foreach (SubscriptionProperties subscription in client.GetSubscriptionsAsync(topicName))
{
subscriptionList.Add(subscription);
}
subscriptionList = subscriptionList.Where(e => e.TopicName.StartsWith(nameof(BasicSubscriptionCrudOperations).ToLower())).ToList();
Assert.True(subscriptionList.Count == 1, $"Expected 1 subscription but {subscriptionList.Count} subscriptions returned");
Assert.AreEqual(subscriptionList.First().TopicName, topicName);
Assert.AreEqual(subscriptionList.First().SubscriptionName, subscriptionName);
await client.DeleteSubscriptionAsync(options.TopicName, options.SubscriptionName);
Assert.That(
async() =>
await client.GetSubscriptionAsync(options.TopicName, options.SubscriptionName),
Throws.InstanceOf <ServiceBusException>().And.Property(nameof(ServiceBusException.Reason)).EqualTo(ServiceBusException.FailureReason.MessagingEntityNotFound));
await client.DeleteTopicAsync(options.TopicName);
exists = await client.SubscriptionExistsAsync(topicName, subscriptionName);
Assert.False(exists);
}
protected async Task AssertSubscriptionOptions(string subscription, CreateSubscriptionOptions createSubscriptionOptions)
{
var subscriptionObject = await _serviceBusAdminClient.GetSubscriptionAsync(_topic, subscription);
Assert.Equal(createSubscriptionOptions, new CreateSubscriptionOptions(subscriptionObject.Value));
}
public AzureServiceBusAdminClient(string?connectionString, string topic, string subscription)
{
_connectionString = connectionString;
_createSubscriptionOptions = new CreateSubscriptionOptions(topic, subscription);
_serviceBusAdminClient = BuildServiceBusAdminClient();
}
