public SubscriptionAttributes(SBSubscription subscriptionResource)
{
if (subscriptionResource != null)
{
AccessedAt = subscriptionResource.AccessedAt;
AutoDeleteOnIdle = XmlConvert.ToString((TimeSpan)subscriptionResource.AutoDeleteOnIdle);
DefaultMessageTimeToLive = XmlConvert.ToString((TimeSpan)subscriptionResource.DefaultMessageTimeToLive);
LockDuration = XmlConvert.ToString((TimeSpan)subscriptionResource.LockDuration);
CountDetails = subscriptionResource.CountDetails;
CreatedAt = subscriptionResource.CreatedAt;
DeadLetteringOnMessageExpiration = subscriptionResource.DeadLetteringOnMessageExpiration;
EnableBatchedOperations = subscriptionResource.EnableBatchedOperations;
MaxDeliveryCount = subscriptionResource.MaxDeliveryCount;
MessageCount = subscriptionResource.MessageCount;
RequiresSession = subscriptionResource.RequiresSession;
Status = subscriptionResource.Status;
UpdatedAt = subscriptionResource.UpdatedAt;
Name = subscriptionResource.Name;
#pragma warning disable 612, 618
Location = "";
DeadLetteringOnFilterEvaluationExceptions = false;
EntityAvailabilityStatus = "Available";
IsReadOnly = false;
#pragma warning restore 612, 618
}
}
internal async Task UpdateRules(SBSubscription subscription, CancellationToken token)
{
while (_pending.TryDequeue(out var topicSub))
{
try
{
await AddRule(subscription, topicSub.Topic, token).ConfigureAwait(false);
_subscriptions.TryAdd(topicSub.Topic, topicSub);
}
catch (Exception ex)
{
_logger.LogError(ex, "error while trying to add rule for {topic}", topicSub.Topic);
_pending.Enqueue(topicSub);
throw;
}
}
foreach (var s in _subscriptions)
{
if (s.Value.Disposed)
{
_subscriptions.TryRemove(s.Key, out var _);
await DeleteRule(subscription, s.Key, token);
}
}
}
internal async Task AddRule(SBSubscription subscription, string newTopic, CancellationToken token)
{
_logger.LogInformation("adding rule for {topic} to subscription {subscription}", newTopic, subscription.Name);
var creds = await GetCredentialsAsync(token).ConfigureAwait(false);
var client = new ServiceBusManagementClient(creds)
{
SubscriptionId = _options.SubscriptionId,
};
var filter = new Microsoft.Azure.Management.ServiceBus.Models.SqlFilter(
$"sys.Label='{newTopic}' AND From <> '{subscription.Name}'"
);
var rule = new Rule();
rule.SqlFilter = filter;
await client.Rules.CreateOrUpdateAsync(
resourceGroupName : _options.ResourceGroup,
namespaceName : _options.Namespace,
topicName : _options.Topic,
subscriptionName : subscription.Name,
ruleName : newTopic,
parameters : rule,
cancellationToken : token
).ConfigureAwait(false);
_logger.LogInformation("rule for {topic} added to subscription {subscription}", newTopic, subscription.Name);
}
private async Task CreateSubscription(string topic, ServiceBusSubscriptionModel model)
{
var pars = new SBSubscription
{
DefaultMessageTimeToLive = TimeSpan.FromDays(10),
LockDuration = TimeSpan.FromMinutes(5),
MaxDeliveryCount = 10,
};
SBSubscription createdSubscription = await _client.Subscriptions
.CreateOrUpdateAsync(_identifier.ResourceGroupName,
_identifier.Name,
topic,
model.Name,
pars);
if (model.SqlFilter != null)
{
var filter = new SqlFilter(model.SqlFilter);
var rule = new Rule {
FilterType = FilterType.SqlFilter, SqlFilter = filter
};
await _client.Rules
.CreateOrUpdateAsync(_identifier.ResourceGroupName,
_identifier.Name,
topic,
createdSubscription.Name,
"test",
rule);
}
}
private static async Task CreateSubscription()
{
try
{
if (string.IsNullOrEmpty(namespaceName))
{
throw new Exception("Namespace name is empty!");
}
var token = await GetToken();
var creds = new TokenCredentials(token);
var sbClient = new ServiceBusManagementClient(creds)
{
SubscriptionId = appOptions.SubscriptionId,
};
var subscriptionParams = new SBSubscription
{
MaxDeliveryCount = 10
};
Console.WriteLine("Creating subscription...");
await sbClient.Subscriptions.CreateOrUpdateAsync(resourceGroupName, namespaceName, TopicName, SubscriptionName, subscriptionParams);
Console.WriteLine("Created subscription successfully.");
}
catch (Exception e)
{
Console.WriteLine("Could not create a subscription...");
Console.WriteLine(e.Message);
throw e;
}
}
public async Task <SubscriptionClient> CreateSubscriptionAsync(string topicName, string subscriptionName, string correlationFilter, string correlationRuleName)
{
var serviceBusManagementClient = await CreateServiceBusManagementClientAsync();
var parameters = new SBSubscription();
await serviceBusManagementClient.Subscriptions.CreateOrUpdateAsync(
resourceGroupName : _configuration.ResourceGroupName,
namespaceName : _configuration.ServiceBusName,
topicName : topicName,
subscriptionName : subscriptionName,
parameters : parameters);
var rule = new Rule()
{
CorrelationFilter = new Microsoft.Azure.Management.ServiceBus.Models.CorrelationFilter(correlationFilter)
};
await serviceBusManagementClient.Rules.CreateOrUpdateAsync(
resourceGroupName : _configuration.ResourceGroupName,
namespaceName : _configuration.ServiceBusName,
topicName : topicName,
subscriptionName : subscriptionName,
ruleName : correlationRuleName,
parameters : rule);
var client = new SubscriptionClient(connectionString: _configuration.ConnectionString,
topicPath: topicName,
subscriptionName: subscriptionName);
return(client);
}
private SBSubscription CreateSubscriptionDescription()
{
var sd = new SBSubscription(_options.Topic, _subscriptionName);
if (_options.SubscriptionAutoDeleteOnIdle.HasValue)
{
sd.AutoDeleteOnIdle = _options.SubscriptionAutoDeleteOnIdle.Value;
}
if (_options.SubscriptionDefaultMessageTimeToLive.HasValue)
{
sd.DefaultMessageTimeToLive = _options.SubscriptionDefaultMessageTimeToLive.Value;
}
if (_options.SubscriptionWorkItemTimeout.HasValue)
{
sd.LockDuration = _options.SubscriptionWorkItemTimeout.Value;
}
if (_options.SubscriptionRequiresSession.HasValue)
{
sd.RequiresSession = _options.SubscriptionRequiresSession.Value;
}
if (_options.SubscriptionEnableDeadLetteringOnMessageExpiration.HasValue)
{
sd.DeadLetteringOnMessageExpiration = _options.SubscriptionEnableDeadLetteringOnMessageExpiration.Value;
}
// https://github.com/Azure/azure-service-bus-dotnet/issues/255 - Its a bug and should be fixed in the next release.
//if (_options.SubscriptionEnableDeadLetteringOnFilterEvaluationExceptions.HasValue)
// sd.EnableDeadLetteringOnFilterEvaluationExceptions = _options.SubscriptionEnableDeadLetteringOnFilterEvaluationExceptions.Value;
if (_options.SubscriptionMaxDeliveryCount.HasValue)
{
sd.MaxDeliveryCount = _options.SubscriptionMaxDeliveryCount.Value;
}
if (_options.SubscriptionEnableBatchedOperations.HasValue)
{
sd.EnableBatchedOperations = _options.SubscriptionEnableBatchedOperations.Value;
}
if (_options.SubscriptionStatus.HasValue)
{
sd.Status = _options.SubscriptionStatus.Value;
}
//if (!String.IsNullOrEmpty(_options.SubscriptionForwardTo))
// sd.ForwardTo = _options.SubscriptionForwardTo;
//if (!String.IsNullOrEmpty(_options.SubscriptionForwardDeadLetteredMessagesTo))
// sd.ForwardDeadLetteredMessagesTo = _options.SubscriptionForwardDeadLetteredMessagesTo;
//if (!String.IsNullOrEmpty(_options.SubscriptionUserMetadata))
// sd.UserMetadata = _options.SubscriptionUserMetadata;
return(sd);
}
/// <summary>
/// Creates a Service Bus scope associated with a topic instance, intended to be used in the context
/// of a single test and disposed when the test has completed.
/// </summary>
///
/// <param name="enablePartitioning">When <c>true</c>, partitioning will be enabled on the topic that is created.</param>
/// <param name="enableSession">When <c>true</c>, a session will be enabled on the topic that is created.</param>
/// <param name="topicSubscriptions">The set of subscriptions to create for the topic. If <c>null</c>, a default subscription will be assumed.</param>
/// <param name="forceTopicCreation">When <c>true</c>, forces creation of a new topic even if an environmental override was specified to use an existing one.</param>
/// <param name="caller">The name of the calling method; this is intended to be populated by the runtime.</param>
///
/// <returns>The requested Service Bus <see cref="TopicScope" />.</returns>
///
/// <remarks>
/// If an environmental override was set to use an existing Service Bus queue resource and the <paramref name="forceTopicCreation" /> flag
/// was not set, the existing queue will be assumed with no validation. In this case the <paramref name="enablePartitioning" />,
/// <paramref name="enableSession" />, and <paramref name="topicSubscriptions" /> parameters are also ignored.
/// </remarks>
///
public static async Task <TopicScope> CreateWithTopic(bool enablePartitioning,
bool enableSession,
IEnumerable <string> topicSubscriptions = null,
bool forceTopicCreation = false,
[CallerMemberName] string caller = "")
{
caller = (caller.Length < 16) ? caller : caller.Substring(0, 15);
topicSubscriptions ??= new[] { "default-subscription" };
var azureSubscription = ServiceBusTestEnvironment.Instance.SubscriptionId;
var resourceGroup = ServiceBusTestEnvironment.Instance.ResourceGroup;
var serviceBusNamespace = ServiceBusTestEnvironment.Instance.ServiceBusNamespace;
var token = await AquireManagementTokenAsync().ConfigureAwait(false);
using (var client = new ServiceBusManagementClient(ResourceManagerUri, new TokenCredentials(token))
{
SubscriptionId = azureSubscription
})
{
// If there was an override and the force flag is not set for creation, then build a scope for the
// specified topic. Query the topic resource to build the list of its subscriptions for the scope.
if ((!string.IsNullOrEmpty(ServiceBusTestEnvironment.Instance.OverrideTopicName)) && (!forceTopicCreation))
{
var subscriptionPage = await CreateRetryPolicy <IPage <SBSubscription> >().ExecuteAsync(() => client.Subscriptions.ListByTopicAsync(resourceGroup, serviceBusNamespace, ServiceBusTestEnvironment.Instance.OverrideTopicName)).ConfigureAwait(false);
var existingSubscriptions = new List <string>(subscriptionPage.Select(item => item.Name));
while (!string.IsNullOrEmpty(subscriptionPage.NextPageLink))
{
subscriptionPage = await CreateRetryPolicy <IPage <SBSubscription> >().ExecuteAsync(() => client.Subscriptions.ListByTopicAsync(resourceGroup, serviceBusNamespace, ServiceBusTestEnvironment.Instance.OverrideTopicName)).ConfigureAwait(false);
existingSubscriptions.AddRange(subscriptionPage.Select(item => item.Name));
}
return(new TopicScope(ServiceBusTestEnvironment.Instance.ServiceBusNamespace, ServiceBusTestEnvironment.Instance.OverrideTopicName, existingSubscriptions, false));
}
// Create a new topic specific for the scope being created.
string CreateName() => $"{ Guid.NewGuid().ToString("D").Substring(0, 13) }-{ caller }";
var duplicateDetection = TimeSpan.FromMinutes(10);
var topicParameters = new SBTopic(enablePartitioning: enablePartitioning, duplicateDetectionHistoryTimeWindow: duplicateDetection, maxSizeInMegabytes: 1024);
var topic = await CreateRetryPolicy <SBTopic>().ExecuteAsync(() => client.Topics.CreateOrUpdateAsync(resourceGroup, serviceBusNamespace, CreateName(), topicParameters)).ConfigureAwait(false);
var subscriptionParams = new SBSubscription(requiresSession: enableSession, duplicateDetectionHistoryTimeWindow: duplicateDetection, maxDeliveryCount: 10);
var activeSubscriptions = await Task.WhenAll
(
topicSubscriptions.Select(subscriptionName =>
CreateRetryPolicy <SBSubscription>().ExecuteAsync(() => client.Subscriptions.CreateOrUpdateAsync(resourceGroup, serviceBusNamespace, topic.Name, subscriptionName, subscriptionParams)))
).ConfigureAwait(false);
return(new TopicScope(serviceBusNamespace, topic.Name, activeSubscriptions.Select(item => item.Name).ToList(), true));
}
}
static async Task MainAsync(string[] args)
{
try
{
var wiretapId = Guid.NewGuid().ToString();
var context = new AuthenticationContext($"https://login.microsoftonline.com/{_tenantId}");
var result = await context.AcquireTokenAsync(
"https://management.core.windows.net/",
new ClientCredential(_clientId, _clientSecret)
);
var creds = new TokenCredentials(result.AccessToken);
var sbClient = new ServiceBusManagementClient(creds)
{
SubscriptionId = _subscriptionId
};
var subscriptionParameters = new SBSubscription
{
DeadLetteringOnMessageExpiration = true,
DefaultMessageTimeToLive = TimeSpan.FromSeconds(30),
AutoDeleteOnIdle = TimeSpan.FromMinutes(5)
};
await sbClient.Subscriptions.CreateOrUpdateAsync(_resourceGroupName, _serviceBusNamespace, _createOrderTopic, $"WireTap-{wiretapId}", subscriptionParameters);
await sbClient.Subscriptions.CreateOrUpdateAsync(_resourceGroupName, _serviceBusNamespace, _checkInventoryTopic, $"WireTap-{wiretapId}", subscriptionParameters);
await sbClient.Subscriptions.CreateOrUpdateAsync(_resourceGroupName, _serviceBusNamespace, _inventoryCheckedTopic, $"WireTap-{wiretapId}", subscriptionParameters);
await sbClient.Subscriptions.CreateOrUpdateAsync(_resourceGroupName, _serviceBusNamespace, _paymentProcessedTopic, $"WireTap-{wiretapId}", subscriptionParameters);
_createOrderSubscriptionClient = new SubscriptionClient(_serviceBusConnectionString, _createOrderTopic, $"WireTap-{wiretapId}");
_checkInventorySubscriptionClient = new SubscriptionClient(_serviceBusConnectionString, _checkInventoryTopic, $"WireTap-{wiretapId}");
_inventoryCheckedSubscriptionClient = new SubscriptionClient(_serviceBusConnectionString, _inventoryCheckedTopic, $"WireTap-{wiretapId}");
_paymentProcessedSubscriptionClient = new SubscriptionClient(_serviceBusConnectionString, _paymentProcessedTopic, $"WireTap-{wiretapId}");
RegisterCreateOrderOnMessageHandlerAndReceiveMessages();
RegisterCheckInventoryOnMessageHandlerAndReceiveMessages();
RegisterInventoryCheckedOnMessageHandlerAndReceiveMessages();
RegisterPaymentProcessedOnMessageHandlerAndReceiveMessages();
Console.WriteLine($"Wiretap Created. Listening for messages...");
Console.WriteLine();
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Console.WriteLine();
}
Console.Read();
}
public PSSubscriptionAttributes CreateUpdateSubscription(string resourceGroupName, string namespaceName, string topicName, string subscriptionName, PSSubscriptionAttributes subscription)
{
var parameters = new SBSubscription();
if (subscription.AutoDeleteOnIdle != null)
{
parameters.AutoDeleteOnIdle = (TimeSpan?)AzureServiceBusCmdletBase.ParseTimespan(subscription.AutoDeleteOnIdle);
}
if (subscription.DefaultMessageTimeToLive != null)
{
parameters.DefaultMessageTimeToLive = (TimeSpan?)AzureServiceBusCmdletBase.ParseTimespan(subscription.DefaultMessageTimeToLive);
}
if (subscription.LockDuration != null)
{
parameters.LockDuration = (TimeSpan?)AzureServiceBusCmdletBase.ParseTimespan(subscription.LockDuration);
}
if (subscription.DeadLetteringOnMessageExpiration.HasValue)
{
parameters.DeadLetteringOnMessageExpiration = subscription.DeadLetteringOnMessageExpiration;
}
if (subscription.DeadLetteringOnFilterEvaluationExceptions.HasValue)
{
parameters.DeadLetteringOnFilterEvaluationExceptions = subscription.DeadLetteringOnFilterEvaluationExceptions;
}
if (subscription.EnableBatchedOperations.HasValue)
{
parameters.EnableBatchedOperations = subscription.EnableBatchedOperations;
}
if (subscription.MaxDeliveryCount.HasValue)
{
parameters.MaxDeliveryCount = subscription.MaxDeliveryCount;
}
if (subscription.RequiresSession.HasValue)
{
parameters.RequiresSession = subscription.RequiresSession;
}
if (subscription.Status.HasValue)
{
parameters.Status = subscription.Status;
}
if (!string.IsNullOrEmpty(subscription.ForwardTo))
{
parameters.ForwardTo = subscription.ForwardTo;
}
if (!string.IsNullOrEmpty(subscription.ForwardDeadLetteredMessagesTo))
{
parameters.ForwardDeadLetteredMessagesTo = subscription.ForwardDeadLetteredMessagesTo;
}
var response = Client.Subscriptions.CreateOrUpdate(resourceGroupName, namespaceName, topicName, subscriptionName, parameters);
return(new PSSubscriptionAttributes(response));
}
internal async Task <SBSubscription> InitializeAzureServiceBus(CancellationToken token)
{
_logger.LogInformation("initializing azure service bus backend");
var creds = await GetCredentialsAsync(token).ConfigureAwait(false);
var client = new ServiceBusManagementClient(creds)
{
SubscriptionId = _options.SubscriptionId,
};
var subscriptionParams = new SBSubscription
{
AutoDeleteOnIdle = TimeSpan.FromMinutes(5),
MaxDeliveryCount = 1,
};
_logger.LogInformation("registering subscription");
var subscription = await client.Subscriptions.CreateOrUpdateAsync(
resourceGroupName : _options.ResourceGroup,
namespaceName : _options.Namespace,
topicName : _options.Topic,
subscriptionName : Environment.MachineName,
parameters : subscriptionParams,
cancellationToken : token
).ConfigureAwait(false);
_logger.LogInformation("clearing existing rules");
var allRules = await client.Rules.ListBySubscriptionsAsync(
resourceGroupName : _options.ResourceGroup,
namespaceName : _options.Namespace,
topicName : _options.Topic,
subscriptionName : subscription.Name,
cancellationToken : token
).ConfigureAwait(false);
foreach (var rule in allRules)
{
await client.Rules.DeleteAsync(
resourceGroupName : _options.ResourceGroup,
namespaceName : _options.Namespace,
topicName : _options.Topic,
subscriptionName : subscription.Name,
ruleName : rule.Name,
cancellationToken : token
).ConfigureAwait(false);
}
_logger.LogInformation("azure service bus backplane initialization complete");
return(subscription);
}
public async Task <ActionResult <SBSubscriptionConnectionData> > Get(string Destinatary, string Subscription)
{
SBSubscription sbSubscription = new SBSubscription();
await sbSubscription.CreateServiceBusConnectionStringBuilders();
SBSubscriptionConnectionData sbSubscriptionConnectionData = new SBSubscriptionConnectionData()
{
Endpoint = sbSubscription._ListenServiceBusConnectionStringBuilder.Endpoint,
Topic = sbSubscription._Topic
};
sbSubscriptionConnectionData.Subscription = Subscription;
sbSubscriptionConnectionData.SharedAccessSignatureToken = await sbSubscription.CreateListenSasTokenAsync();
return(sbSubscriptionConnectionData);
}
public async Task CreateOrUpdateSubscriptionAsync(string subscriptionName)
{
var paramerters = new SBSubscription
{
DeadLetteringOnFilterEvaluationExceptions = true,
DeadLetteringOnMessageExpiration = true,
MaxDeliveryCount = 10,
DefaultMessageTimeToLive = new TimeSpan(1, 0, 0)
};
await Client.Subscriptions.CreateOrUpdateAsync
(
ResourceGroup,
Namespace,
_topicName,
subscriptionName,
paramerters
);
}
public async Task CreateSubscription(string subscriptionName, string topicName = "")
{
try
{
using (var sbClient = await GetServiceManagementClient())
{
var subscriptionParams = new SBSubscription
{
Status = EntityStatus.Active,
MaxDeliveryCount = 50,
RequiresSession = true
};
await sbClient.Subscriptions.CreateOrUpdateAsync(appOptions.ResourceGroupName, appOptions.NamespaceName, topicName, subscriptionName, subscriptionParams);
}
}
catch (Exception e)
{
throw e;
}
}
public SubscriptionAttributes(SBSubscription subscriptionResource)
{
if (subscriptionResource != null)
{
AccessedAt = subscriptionResource.AccessedAt;
AutoDeleteOnIdle = XmlConvert.ToString((TimeSpan)subscriptionResource.AutoDeleteOnIdle);
DefaultMessageTimeToLive = XmlConvert.ToString((TimeSpan)subscriptionResource.DefaultMessageTimeToLive);
LockDuration = XmlConvert.ToString((TimeSpan)subscriptionResource.LockDuration);
CountDetails = subscriptionResource.CountDetails;
CreatedAt = subscriptionResource.CreatedAt;
DeadLetteringOnMessageExpiration = subscriptionResource.DeadLetteringOnMessageExpiration;
EnableBatchedOperations = subscriptionResource.EnableBatchedOperations;
MaxDeliveryCount = subscriptionResource.MaxDeliveryCount;
MessageCount = subscriptionResource.MessageCount;
RequiresSession = subscriptionResource.RequiresSession;
Status = subscriptionResource.Status;
UpdatedAt = subscriptionResource.UpdatedAt;
Name = subscriptionResource.Name;
}
}
private async Task EnsureTopicSubscription()
{
var context = new AuthenticationContext($"https://login.microsoftonline.com/{_tenantId}");
var token = await context.AcquireTokenAsync("https://management.azure.com/", new ClientCredential(_clientId, _clientSecret));
var creds = new TokenCredentials(token.AccessToken);
var sbClient = new ServiceBusManagementClient(creds)
{
SubscriptionId = _subscriptionId
};
var subscriptionParameters = new SBSubscription()
{
LockDuration = _lockDurationInSeconds,
MaxDeliveryCount = _maxDeliveryCount,
EnableBatchedOperations = _enableBatchOperations
};
await sbClient.Subscriptions.CreateOrUpdateAsync(_resourceGroup, _namespaceName,
_topicName, _subscriptionName, subscriptionParameters);
}
/// <summary>
/// Creates a Service Bus scope associated with a topic instance, intended to be used in the context
/// of a single test and disposed when the test has completed.
/// </summary>
///
/// <param name="enablePartitioning">When <c>true</c>, partitioning will be enabled on the topic that is created.</param>
/// <param name="enableSession">When <c>true</c>, a session will be enabled on the topic that is created.</param>
/// <param name="topicSubscriptions">The set of subscriptions to create for the topic. If <c>null</c>, a default subscription will be assumed.</param>
/// <param name="forceTopicCreation">When <c>true</c>, forces creation of a new topic even if an environmental override was specified to use an existing one.</param>
/// <param name="caller">The name of the calling method; this is intended to be populated by the runtime.</param>
///
/// <returns>The requested Service Bus <see cref="TopicScope" />.</returns>
///
/// <remarks>
/// If an environmental override was set to use an existing Service Bus queue resource and the <paramref name="forceTopicCreation" /> flag
/// was not set, the existing queue will be assumed with no validation. In this case the <paramref name="enablePartitioning" />,
/// <paramref name="enableSession" />, and <paramref name="topicSubscriptions" /> parameters are also ignored.
/// </remarks>
///
public static async Task <TopicScope> CreateWithTopic(bool enablePartitioning,
bool enableSession,
IEnumerable <string> topicSubscriptions = null,
bool forceTopicCreation = false,
[CallerMemberName] string caller = "")
{
caller = (caller.Length < 16) ? caller : caller.Substring(0, 15);
topicSubscriptions ??= new[] { "default-subscription" };
var azureSubscription = ServiceBusTestEnvironment.Instance.SubscriptionId;
var resourceGroup = ServiceBusTestEnvironment.Instance.ResourceGroup;
var serviceBusNamespace = ServiceBusTestEnvironment.Instance.ServiceBusNamespace;
var token = await AcquireManagementTokenAsync().ConfigureAwait(false);
using (var client = new ServiceBusManagementClient(ResourceManagerUri, new TokenCredentials(token))
{
SubscriptionId = azureSubscription
})
{
// Create a new topic specific for the scope being created.
string CreateName() => $"{ Guid.NewGuid().ToString("D").Substring(0, 13) }-{ caller }";
var duplicateDetection = TimeSpan.FromMinutes(10);
var topicParameters = new SBTopic(enablePartitioning: enablePartitioning, duplicateDetectionHistoryTimeWindow: duplicateDetection, maxSizeInMegabytes: 1024);
var topic = await CreateRetryPolicy <SBTopic>().ExecuteAsync(() => client.Topics.CreateOrUpdateAsync(resourceGroup, serviceBusNamespace, CreateName(), topicParameters)).ConfigureAwait(false);
var subscriptionParams = new SBSubscription(requiresSession: enableSession, duplicateDetectionHistoryTimeWindow: duplicateDetection, maxDeliveryCount: 10);
var activeSubscriptions = await Task.WhenAll
(
topicSubscriptions.Select(subscriptionName =>
CreateRetryPolicy <SBSubscription>().ExecuteAsync(() => client.Subscriptions.CreateOrUpdateAsync(resourceGroup, serviceBusNamespace, topic.Name, subscriptionName, subscriptionParams)))
).ConfigureAwait(false);
return(new TopicScope(serviceBusNamespace, topic.Name, activeSubscriptions.Select(item => item.Name).ToList(), true));
}
}
internal async Task DeleteRule(SBSubscription subscription, string deleteTopic, CancellationToken token)
{
_logger.LogInformation("deleting rule for {topic} from subscription {subscription}", deleteTopic, subscription.Name);
var creds = await GetCredentialsAsync(token).ConfigureAwait(false);
var client = new ServiceBusManagementClient(creds)
{
SubscriptionId = _options.SubscriptionId,
};
await client.Rules.DeleteAsync(
resourceGroupName : _options.ResourceGroup,
namespaceName : _options.Namespace,
topicName : _options.Topic,
subscriptionName : subscription.Name,
ruleName : deleteTopic,
cancellationToken : token
).ConfigureAwait(false);
_logger.LogInformation("rule for {topic} from subscription {subscription}", deleteTopic, subscription.Name);
}
public void SubscriptionsCreateGetUpdateDelete()
{
using (MockContext context = MockContext.Start(this.GetType().FullName))
{
InitializeClients(context);
var location = this.ResourceManagementClient.GetLocationFromProvider();
var resourceGroup = this.ResourceManagementClient.TryGetResourceGroup(location);
if (string.IsNullOrWhiteSpace(resourceGroup))
{
resourceGroup = TestUtilities.GenerateName(ServiceBusManagementHelper.ResourceGroupPrefix);
this.ResourceManagementClient.TryRegisterResourceGroup(location, resourceGroup);
}
var namespaceName = TestUtilities.GenerateName(ServiceBusManagementHelper.NamespacePrefix);
var createNamespaceResponse = this.ServiceBusManagementClient.Namespaces.CreateOrUpdate(resourceGroup, namespaceName,
new SBNamespace()
{
Location = location,
Sku = new SBSku
{
Name = SkuName.Standard,
Tier = SkuTier.Standard
}
});
Assert.NotNull(createNamespaceResponse);
Assert.Equal(createNamespaceResponse.Name, namespaceName);
TestUtilities.Wait(TimeSpan.FromSeconds(5));
// Create a Topic
var topicName = TestUtilities.GenerateName(ServiceBusManagementHelper.TopicPrefix);
var createTopicResponse = this.ServiceBusManagementClient.Topics.CreateOrUpdate(resourceGroup, namespaceName, topicName,
new SBTopic()
{
EnablePartitioning = true
});
Assert.NotNull(createTopicResponse);
Assert.Equal(createTopicResponse.Name, topicName);
// Get the created topic
var getTopicResponse = ServiceBusManagementClient.Topics.Get(resourceGroup, namespaceName, topicName);
Assert.NotNull(getTopicResponse);
Assert.Equal(EntityStatus.Active, getTopicResponse.Status);
Assert.Equal(getTopicResponse.Name, topicName);
// Create Subscription.
var subscriptionName = TestUtilities.GenerateName(ServiceBusManagementHelper.SubscritpitonPrefix);
SBSubscription createSub = new SBSubscription();
createSub.EnableBatchedOperations = true;
createSub.LockDuration = TimeSpan.Parse("00:03:00");
createSub.DefaultMessageTimeToLive = TimeSpan.Parse("00:05:00");
createSub.DeadLetteringOnMessageExpiration = true;
createSub.MaxDeliveryCount = 14;
createSub.Status = EntityStatus.Active;
createSub.AutoDeleteOnIdle = TimeSpan.Parse("00:07:00");
createSub.DeadLetteringOnFilterEvaluationExceptions = true;
var createSubscriptionResponse = ServiceBusManagementClient.Subscriptions.CreateOrUpdate(resourceGroup, namespaceName, topicName, subscriptionName, createSub);
Assert.NotNull(createSubscriptionResponse);
Assert.Equal(createSubscriptionResponse.Name, subscriptionName);
// Get Created Subscription
var subscriptionGetResponse = ServiceBusManagementClient.Subscriptions.Get(resourceGroup, namespaceName, topicName, subscriptionName);
Assert.NotNull(subscriptionGetResponse);
Assert.Equal(EntityStatus.Active, subscriptionGetResponse.Status);
Assert.Equal(subscriptionGetResponse.Name, subscriptionName);
// Get all Subscriptions
var getSubscriptionsListAllResponse = ServiceBusManagementClient.Subscriptions.ListByTopic(resourceGroup, namespaceName, topicName);
Assert.NotNull(getSubscriptionsListAllResponse);
Assert.True(getSubscriptionsListAllResponse.Count() == 1);
Assert.True(getSubscriptionsListAllResponse.All(ns => ns.Id.Contains(resourceGroup)));
// Create a Topic for Auto Forward
var topicName1 = TestUtilities.GenerateName(ServiceBusManagementHelper.TopicPrefix);
var createTopicResponse1 = this.ServiceBusManagementClient.Topics.CreateOrUpdate(resourceGroup, namespaceName, topicName1,
new SBTopic()
{
EnablePartitioning = true
});
Assert.NotNull(createTopicResponse);
Assert.Equal(createTopicResponse1.Name, topicName1);
// Update Subscription.
var updateSubscriptionParameter = new SBSubscription()
{
EnableBatchedOperations = true,
DeadLetteringOnMessageExpiration = true,
ForwardDeadLetteredMessagesTo = topicName1,
ForwardTo = topicName1
};
var updateSubscriptionsResponse = ServiceBusManagementClient.Subscriptions.CreateOrUpdate(resourceGroup, namespaceName, topicName, subscriptionName, updateSubscriptionParameter);
Assert.NotNull(updateSubscriptionsResponse);
Assert.True(updateSubscriptionsResponse.EnableBatchedOperations);
Assert.NotEqual(updateSubscriptionsResponse.UpdatedAt, subscriptionGetResponse.UpdatedAt);
// Get the updated subscription to check the Updated values.
var getSubscriptionsResponse = ServiceBusManagementClient.Subscriptions.Get(resourceGroup, namespaceName, topicName, subscriptionName);
Assert.NotNull(getSubscriptionsResponse);
Assert.Equal(EntityStatus.Active, getSubscriptionsResponse.Status);
Assert.Equal(getSubscriptionsResponse.Name, subscriptionName);
Assert.True(getSubscriptionsResponse.EnableBatchedOperations);
Assert.NotEqual(getSubscriptionsResponse.UpdatedAt, createSubscriptionResponse.UpdatedAt);
// Delete Created Subscription
ServiceBusManagementClient.Subscriptions.Delete(resourceGroup, namespaceName, topicName, subscriptionName);
// Delete Created Topics
ServiceBusManagementClient.Topics.Delete(resourceGroup, namespaceName, topicName);
//Delete Namespace Async
ServiceBusManagementClient.Namespaces.DeleteWithHttpMessagesAsync(resourceGroup, namespaceName, null, new CancellationToken()).ConfigureAwait(false);
}
}
/// <summary>
/// Creates a topic subscription.
/// <see href="https://msdn.microsoft.com/en-us/library/azure/mt639385.aspx" />
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='resourceGroupName'>
/// Name of the Resource group within the Azure subscription.
/// </param>
/// <param name='namespaceName'>
/// The namespace name
/// </param>
/// <param name='topicName'>
/// The topic name.
/// </param>
/// <param name='subscriptionName'>
/// The subscription name.
/// </param>
/// <param name='parameters'>
/// Parameters supplied to create a subscription resource.
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <SBSubscription> CreateOrUpdateAsync(this ISubscriptionsOperations operations, string resourceGroupName, string namespaceName, string topicName, string subscriptionName, SBSubscription parameters, CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.CreateOrUpdateWithHttpMessagesAsync(resourceGroupName, namespaceName, topicName, subscriptionName, parameters, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
public PSSubscriptionAttributes GetSubscription(string resourceGroupName, string namespaceName, string topicName, string subscriptionName)
{
SBSubscription response = Client.Subscriptions.Get(resourceGroupName, namespaceName, topicName, subscriptionName);
return(new PSSubscriptionAttributes(response));
}
/// <summary>
/// Creates a topic subscription.
/// <see href="https://msdn.microsoft.com/en-us/library/azure/mt639385.aspx" />
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='resourceGroupName'>
/// Name of the Resource group within the Azure subscription.
/// </param>
/// <param name='namespaceName'>
/// The namespace name
/// </param>
/// <param name='topicName'>
/// The topic name.
/// </param>
/// <param name='subscriptionName'>
/// The subscription name.
/// </param>
/// <param name='parameters'>
/// Parameters supplied to create a subscription resource.
/// </param>
public static SBSubscription CreateOrUpdate(this ISubscriptionsOperations operations, string resourceGroupName, string namespaceName, string topicName, string subscriptionName, SBSubscription parameters)
{
return(operations.CreateOrUpdateAsync(resourceGroupName, namespaceName, topicName, subscriptionName, parameters).GetAwaiter().GetResult());
}
