private async Task CreateCustomFilters() { try { for (int i = 0; i < Subscriptions.Length; i++) { var client = new ServiceBusAdministrationClient(ServiceBusConnectionString); string[] filters = SubscriptionFilters[Subscriptions[i]]; if (filters[0] != "") { int count = 0; foreach (var myFilter in filters) { count++; string action = SubscriptionAction[Subscriptions[i]]; if (action != "") { await client.CreateRuleAsync(TopicName, Subscriptions[i], new CreateRuleOptions { Filter = new SqlRuleFilter(myFilter), Action = new SqlRuleAction(action), Name = $"MyRule{count}" }); } else { await client.CreateRuleAsync(TopicName, Subscriptions[i], new CreateRuleOptions { Filter = new SqlRuleFilter(myFilter), Name = $"MyRule{count}" }); } } } Console.WriteLine($"Filters and actions for {Subscriptions[i]} have been created."); } Console.WriteLine("All filters and actions have been created.\n"); } catch (Exception ex) { Console.WriteLine(ex.ToString()); } await PresentMenu(); }
public async Task SubscribeAsync <T, TH>(bool subscribeToQueueMessages) where T : IntegrationEvent where TH : IIntegrationEventHandler <T> { var eventName = typeof(T).Name; var containsKey = _subscriptionManager.HasSubscriptionsForEvent <T>(); if (!containsKey) { try { if (!subscribeToQueueMessages) { await _serviceBusAdministrationClient.CreateRuleAsync(_eventBusConfiguration.TopicName, _eventBusConfiguration.Subscription, new CreateRuleOptions { Filter = new CorrelationRuleFilter { Subject = eventName }, Name = eventName }); } } catch (ServiceBusException) { _logger.LogWarning("The messaging entity '{eventName}' already exists.", eventName); } } _logger.LogInformation("Subscribing to event '{EventName}' with '{EventHandler}'", eventName, typeof(TH).Name); _subscriptionManager.AddSubscription <T, TH>(); }
async Task SubscribeEvent(ServiceBusAdministrationClient client, Type eventType, CancellationToken cancellationToken) { var ruleName = transportSettings.SubscriptionRuleNamingConvention(eventType); var sqlExpression = $"[{Headers.EnclosedMessageTypes}] LIKE '%{eventType.FullName}%'"; var rule = new CreateRuleOptions(ruleName, new SqlRuleFilter(sqlExpression)); try { var existingRule = await client.GetRuleAsync(transportSettings.TopicName, subscriptionName, rule.Name, cancellationToken).ConfigureAwait(false); if (existingRule.Value.Filter.ToString() != rule.Filter.ToString()) { existingRule.Value.Action = rule.Action; await client.UpdateRuleAsync(transportSettings.TopicName, subscriptionName, existingRule, cancellationToken).ConfigureAwait(false); } } catch (ServiceBusException sbe) when(sbe.Reason == ServiceBusFailureReason.MessagingEntityNotFound) { try { await client.CreateRuleAsync(transportSettings.TopicName, subscriptionName, rule, cancellationToken).ConfigureAwait(false); } catch (ServiceBusException createSbe) when(createSbe.Reason == ServiceBusFailureReason.MessagingEntityAlreadyExists) { } } }
private async Task AddNewRulesAsync(List <CreateRuleOptions> newRules, List <RuleProperties> existingRules) { foreach (var newRule in newRules.Where(n => !NewRuleExists(existingRules, n))) { await _serviceBusAdminClient.CreateRuleAsync(_createSubscriptionOptions.TopicName, _createSubscriptionOptions.SubscriptionName, newRule); } }
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 static Task Create(ServiceBusAdministrationClient client, CommandArgument endpointName, CommandOption topicName, CommandOption subscriptionName, CommandArgument eventType, CommandOption ruleName) { var topicNameToUse = topicName.HasValue() ? topicName.Value() : Topic.DefaultTopicName; var subscriptionNameToUse = subscriptionName.HasValue() ? subscriptionName.Value() : endpointName.Value; var eventToSubscribeTo = eventType.Value; var ruleNameToUse = ruleName.HasValue() ? ruleName.Value() : eventToSubscribeTo; var description = new CreateRuleOptions(ruleNameToUse, new SqlRuleFilter($"[NServiceBus.EnclosedMessageTypes] LIKE '%{eventToSubscribeTo}%'")); return(client.CreateRuleAsync(topicNameToUse, subscriptionNameToUse, description)); }
private static async Task SetupRule(this ServiceBusAdministrationClient admin, string topic, string subscription, string @event) { if (!(await admin.RuleExistsAsync(topic, subscription, @event)).Value) { await admin.CreateRuleAsync(topic, subscription, new CreateRuleOptions(@event, new CorrelationRuleFilter { Subject = @event })); } }
protected async Task CreateSubscriptionRulesAsync(List <MessageHandlerMapping> messageHandlerMappings, string subscription) { await _serviceBusAdminClient.DeleteRuleAsync(_topic, subscription, "$Default"); foreach (var messageHandlerMapping in messageHandlerMappings) { var correlationRuleFilter = BuildCorrelationRuleFilter(messageHandlerMappings[0].SubscriptionFilter); await _serviceBusAdminClient.CreateRuleAsync(_topic, subscription, new CreateRuleOptions(nameof(AircraftLanded), correlationRuleFilter)); } }
public static async Task CreateSubscription(string connectionString, string topic, string subscription, string subscriptionFilter) { CheckIsNotNullOrWhitespace(nameof(subscriptionFilter), subscriptionFilter); Debug.WriteLine($"CHECK: {subscriptionFilter}"); string filterClause = $"{SUBSCRIPTION_FILTER} IN ('{subscriptionFilter.ToLower()}')"; var client = new ServiceBusAdministrationClient(connectionString); await CreateSubscription(client, topic, subscription); await client.DeleteRuleAsync(topic, subscription, CreateRuleOptions.DefaultRuleName); var rule = new SqlRuleFilter(filterClause); await client.CreateRuleAsync(topic, subscription, new CreateRuleOptions(SUBSCRIPTION_FILTER, rule)); }
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); }