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);
}
