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