private void ReceiveMessages(string filterName = null, string filter = null)
{
var subscriptionClient = new SubscriptionClient
(_serviceBusConfiguration.ConnectionString, _topicName, _subscriptionName);
var mo = new MessageHandlerOptions(ExceptionHandle)
{
AutoComplete = true
};
if (filterName != null && filter != null)
{
const string defaultRule = "$default";
if (subscriptionClient.GetRulesAsync().Result.Any(x => x.Name == defaultRule))
{
subscriptionClient.RemoveRuleAsync(defaultRule).Wait();
}
if (subscriptionClient.GetRulesAsync().Result.All(x => x.Name != filterName))
{
subscriptionClient.AddRuleAsync(new RuleDescription
{
Filter = new CorrelationFilter {
Label = filter
},
Name = filterName
}).Wait();
}
}
subscriptionClient.RegisterMessageHandler(Handle, mo);
}
public async Task RemoveDefaultSubscriptionRuleAsync()
{
var rules = await _subscriptionClient.GetRulesAsync();
var ruleDescription = rules.SingleOrDefault(x => x.Name.Equals(RuleDescription.DefaultRuleName));
if (ruleDescription != null)
{
await _subscriptionClient.RemoveRuleAsync(RuleDescription.DefaultRuleName);
}
}
public async Task <HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default)
{
try
{
// Check if there is a previous result in the cache that has not expired yet.
if (_cache.TryGetValue("result", out HealthCheckResult result))
{
return(result);
}
// This is the only way I can see to check if the subscription queue is available.
SubscriptionClient subscriptionClient = new SubscriptionClient(new ServiceBusConnectionStringBuilder(_topicconnectionstring), _subscriptionname, ReceiveMode.PeekLock, RetryPolicy.NoRetry);
await subscriptionClient.GetRulesAsync();
// Subscription is available.
// Let's cache the result for 5 minutes, as it is very slow and once up, the state shouldn't change very much.
result = HealthCheckResult.Healthy();
_cache.Set("result", result, TimeSpan.FromMinutes(5));
return(result);
}
catch (Microsoft.Azure.ServiceBus.MessagingEntityNotFoundException)
{
// Let's cache the result for 1 minute, as it is very slow and we want to know fairly quickly once it is up.
HealthCheckResult result = new HealthCheckResult(context.Registration.FailureStatus, "the subscription doesn't exist");
_cache.Set("result", result, TimeSpan.FromMinutes(1));
return(result);
}
catch (Exception ex)
{
// Let's cache the result for 1 minute, as it is very slow and we want to know fairly quickly once it is up.
HealthCheckResult result = new HealthCheckResult(context.Registration.FailureStatus, exception: ex);
_cache.Set("result", result, TimeSpan.FromMinutes(1));
return(result);
}
}
private async Task RemoveDefaultFilters()
{
Console.WriteLine($"Starting to remove default filters.");
try
{
foreach (var subscription in Subscriptions)
{
SubscriptionClient s = new SubscriptionClient(ServiceBusConnectionString, TopicName, subscription);
var rules = (await s.GetRulesAsync()).Where(r => r.Name == RuleDescription.DefaultRuleName);
if (rules.Any())
{
await s.RemoveRuleAsync(RuleDescription.DefaultRuleName);
Console.WriteLine($"Default filter for {subscription} has been removed.");
}
await s.CloseAsync();
}
Console.WriteLine("All default Rules have been removed.\n");
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
await PresentMenu();
}
public async Task ReceiverAsync(string topic, string filter, string subscription, TopicType type)
{
await CreateTopicAsync(_option.ConnectionString, topic);
await CreateSubscriptionAsync(_option.ConnectionString, topic, subscription);
var subscriptionClient = new SubscriptionClient(_option.ConnectionString, topic, subscription);
var rules = await subscriptionClient.GetRulesAsync();
if (rules.Any(r => r.Name.Equals("$Default")))
{
//by default a 1=1 rule is added when subscription is created, so we need to remove it
await subscriptionClient.RemoveRuleAsync("$Default");
}
if (!rules.Any(r => r.Name.Equals("filter-store")))
{
await subscriptionClient.AddRuleAsync(_rule);
}
var mo = new MessageHandlerOptions(ExceptionHandle)
{
MaxConcurrentCalls = 5,
AutoComplete = false
};
if (type == TopicType.Product)
{
subscriptionClient.RegisterMessageHandler(HandleProduct, mo);
}
else
{
subscriptionClient.RegisterMessageHandler(HandleArea, mo);
}
}
public async Task SubscriptionsEventsAreNotCapturedWhenDiagnosticsIsDisabled()
{
await ServiceBusScope.UsingTopicAsync(partitioned : false, sessionEnabled : false, async (topicName, subscriptionName) =>
{
var subscriptionClient = new SubscriptionClient(TestUtility.NamespaceConnectionString, topicName, subscriptionName, ReceiveMode.ReceiveAndDelete);
var eventQueue = this.CreateEventQueue();
var entityName = $"{topicName}/Subscriptions/{subscriptionName}";
try
{
using (var listener = this.CreateEventListener(entityName, eventQueue))
using (var subscription = this.SubscribeToEvents(listener))
{
listener.Disable();
var ruleName = Guid.NewGuid().ToString();
await subscriptionClient.AddRuleAsync(ruleName, new TrueFilter());
await subscriptionClient.GetRulesAsync();
await subscriptionClient.RemoveRuleAsync(ruleName);
Assert.True(eventQueue.IsEmpty, "There were events present when none were expected");
}
}
finally
{
await subscriptionClient.CloseAsync();
}
});
}
private static async Task <bool> CheckRulesAsync(
Subscriber subscriber, SubscriptionClient subscriptionClient)
{
IEnumerable <RuleDescription> rules = await subscriptionClient.GetRulesAsync();
return(subscriber.Labels.All(sr => rules.Any(r => r.Name == sr)));
}
private async void ReceiveMessages(string topicName)
{
serviceBusConfiguration = _configuration.GetSection("serviceBus").Get <ServiceBusConfiguration>();
var subscriptionClient = new SubscriptionClient(serviceBusConfiguration.ConnectionString, topicName, SubscriptionName);
try
{
var rules = await subscriptionClient.GetRulesAsync();
if (rules.Any(x => x.Name == "$Default"))
{
//await subscriptionClient.RemoveRuleAsync("$Default");
}
var messageHandlerOptions = new MessageHandlerOptions(ExceptionHandle)
{
AutoComplete = true
};
_logService.SendMessagesAsync("Order Changed Received in Production");
subscriptionClient.RegisterMessageHandler(Handle, messageHandlerOptions);
}
catch (Exception)
{
}
}
private async Task CleanUpCustomFilters()
{
foreach (var subscription in Subscriptions)
{
try
{
SubscriptionClient s = new SubscriptionClient(ServiceBusConnectionString, TopicName, subscription);
IEnumerable <RuleDescription> rules = await s.GetRulesAsync();
foreach (RuleDescription r in rules)
{
await s.RemoveRuleAsync(r.Name);
Console.WriteLine($"Rule {r.Name} has been removed.");
}
await s.CloseAsync();
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
}
Console.WriteLine("All default filters have been removed.\n");
await PresentMenu();
}
public void Subscribe(IEnumerable <string> topics)
{
if (topics == null)
{
throw new ArgumentNullException(nameof(topics));
}
ConnectAsync().GetAwaiter().GetResult();
var allRuleNames = _consumerClient.GetRulesAsync().GetAwaiter().GetResult().Select(x => x.Name);
foreach (var newRule in topics.Except(allRuleNames))
{
CheckValidSubscriptionName(newRule);
_consumerClient.AddRuleAsync(new RuleDescription
{
Filter = new CorrelationFilter {
Label = newRule
},
Name = newRule
}).GetAwaiter().GetResult();
_logger.LogInformation($"Azure Service Bus add rule: {newRule}");
}
foreach (var oldRule in allRuleNames.Except(topics))
{
_consumerClient.RemoveRuleAsync(oldRule).GetAwaiter().GetResult();
_logger.LogInformation($"Azure Service Bus remove rule: {oldRule}");
}
}
public void Subscribe(string eventName)
{
try
{
if (_subscriptionClient.GetRulesAsync().GetAwaiter().GetResult().Any(rule => rule.Name == eventName))
{
_logger.LogWarning("The messaging entity {eventName} already exists.", eventName);
return;
}
_subscriptionClient.AddRuleAsync(new RuleDescription
{
Filter = new CorrelationFilter {
Label = eventName
},
Name = eventName
}).GetAwaiter().GetResult();
}
catch (ServiceBusException)
{
_logger.LogWarning("The messaging entity {eventName} already exists.", eventName);
}
_logger.LogInformation("Subscribing to event {EventName}", eventName);
}
public static async Task RemoveDefaultFiltersIfExists(this SubscriptionClient subscription)
{
var rules = await subscription.GetRulesAsync();
if (rules.Any(r => r.Name == RuleDescription.DefaultRuleName))
{
await subscription.RemoveRuleAsync(RuleDescription.DefaultRuleName);
}
}
private static async Task CleanUpRules(SubscriptionClient client, string ruleName)
{
var rules = await client.GetRulesAsync();
if (rules.FirstOrDefault(r => r.Name == ruleName) != null)
{
await client.RemoveRuleAsync(ruleName);
}
}
private async Task RemoveDefaultFilters()
{
try
{
var rules = await _subscriptionClient.GetRulesAsync();
foreach (var rule in rules)
{
if (rule.Name == RuleDescription.DefaultRuleName)
{
await _subscriptionClient.RemoveRuleAsync(RuleDescription.DefaultRuleName);
}
}
}
catch (Exception ex)
{
_logger.LogWarning(ex.ToString());
}
}
private void UpdateRules(SubscriptionClient subscriptionClient, AzureBusTopicSettings settings)
{
subscriptionClient.GetRulesAsync()
.Result
.ToList()
.ForEach(x => subscriptionClient.RemoveRuleAsync(x.Name).Wait());
settings.AzureSubscriptionRules
.ToList()
.ForEach(x => subscriptionClient.AddRuleAsync(x.Key, x.Value).Wait());
}
static async Task RemoveDefaultRuleAsync()
{
var rules = await subscriptionClient.GetRulesAsync();
var defaultRule = rules.SingleOrDefault(rule => rule.Name == RuleDescription.DefaultRuleName);
if (defaultRule != null)
{
await subscriptionClient.RemoveRuleAsync(defaultRule.Name);
}
}
private static async Task AddRule(SubscriptionClient client, string correlationFilter, string ruleName)
{
var rules = await client.GetRulesAsync();
if (rules.FirstOrDefault(r => r.Name == ruleName) == null)
{
await client.AddRuleAsync(new RuleDescription
{
Filter = new CorrelationFilter(correlationFilter),
Name = ruleName
});
}
}
public static async Task AddRule(string topicName, string subName, RuleDescription ruleDescription)
{
var subClient = new SubscriptionClient(SBConnectionString, topicName, subName);
// remove old rules
foreach (var rule in await subClient.GetRulesAsync())
{
await subClient.RemoveRuleAsync(rule.Name);
}
// add rule
await subClient.AddRuleAsync(ruleDescription);
}
public async Task <HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default(CancellationToken))
{
return(await Task.Run(() =>
{
IDictionary <string, Object> data = new Dictionary <string, object>();
data.Add("type", "ServiceBusHealthCheck");
// data.Add("connectionString", this.connectionString);
data.Add("topicName", this.topicName);
try
{
if (serviceBusHealthCheckType == ServiceBusHealthCheckType.Receive)
{
data.Add("subscriptionName", this.subscriptionName);
var subscriptionClient = new SubscriptionClient(ListenConnectionString, topicName, subscriptionName);
var clientid = subscriptionClient.ClientId;
data.Add("clientid", clientid);
var rulestask = subscriptionClient.GetRulesAsync();
rulestask.Wait();
data.Add("rules", string.Join(",", rulestask.Result));
}
else
{
var topicClient = new QueueClient(SendConnectionString, topicName);
var clientid = topicClient.ClientId;
data.Add("clientid", clientid);
var list = topicClient.Path;
Message mes = new Message();
mes.Body = System.Text.Encoding.UTF8.GetBytes("TestMessage");
var sendtask = topicClient.ScheduleMessageAsync(mes, DateTime.Now.AddDays(100));
sendtask.Wait();
var cancell = topicClient.CancelScheduledMessageAsync(sendtask.Result);
cancell.Wait();
}
string description = $"ServiceBus namespace {nameSpace}.servicebus.windows.net is healthy";
ReadOnlyDictionary <string, Object> rodata = new ReadOnlyDictionary <string, object>(data);
return HealthCheckResult.Healthy(description, rodata);
}
catch (Exception ex)
{
string description = "ServiceBus is failed with exception " + ex.Message;
ReadOnlyDictionary <string, Object> rodata = new ReadOnlyDictionary <string, object>(data);
return HealthCheckResult.Unhealthy(description, data: rodata);
}
}));
}
public static async Task AddFilterAsyc(this SubscriptionClient subscription, RuleDescription rule)
{
if (rule == null)
{
throw new ArgumentNullException(nameof(rule));
}
var rules = await subscription.GetRulesAsync();
if (!rules.Any(r => r.Name == rule.Name))
{
await subscription.AddRuleAsync(rule);
}
}
public static async Task RemoveFilterAsyc(this SubscriptionClient subscription, string ruleName)
{
if (String.IsNullOrWhiteSpace(ruleName))
{
throw new ArgumentNullException(nameof(ruleName));
}
var rules = await subscription.GetRulesAsync();
if (rules.Any(r => r.Name == ruleName))
{
await subscription.RemoveRuleAsync(ruleName);
}
}
private async Task BuildSubscription(string connectionString, string[] messagesTypes, string handlerFullName)
{
var topicName = _config.EffectiveTopicName;
var client = new SubscriptionClient(connectionString, topicName, _config.SubscriberName);
var ruleApplier = new RuleApplier(_ruleApplierLog, client);
var ruleBuilder = new RuleBuilder(ruleApplier, _subscriptionRuleVersionResolver, _config.SubscriberName);
var rulesForCurrentSoftwareVersion = ruleBuilder.GenerateSubscriptionRules(messagesTypes, handlerFullName, _config.OmitSpecificSubscriberFilter).ToArray();
var rulesCurrentlyDefinedInServiceBus = await client.GetRulesAsync().ConfigureAwait(false);
_log.LogInformation($"Validating subscription '{_config.SubscriberName}' rules on topic '{topicName}'...");
await ruleBuilder.ApplyRuleChanges(rulesForCurrentSoftwareVersion, rulesCurrentlyDefinedInServiceBus.ToArray(), messagesTypes).ConfigureAwait(false);
}
private static async Task CreateSubscriptionFilters()
{
var client = new SubscriptionClient(ServiceBusConnectionString, TopicName, SubscriptionName);
var rules = await client.GetRulesAsync();
// Remove default filter
foreach (var rule in rules)
{
await client.RemoveRuleAsync(rule.Name);
}
// Add InformCourier rule
var filter = new SqlFilter("ProcessWarehouse = 1");
await client.AddRuleAsync("ProcessWarehouse", filter);
}
public async Task AddRemoveGetFireEvents()
{
await ServiceBusScope.UsingTopicAsync(partitioned : false, sessionEnabled : false, async (topicName, subscriptionName) =>
{
var subscriptionClient = new SubscriptionClient(TestUtility.NamespaceConnectionString, topicName, subscriptionName, ReceiveMode.ReceiveAndDelete);
var eventQueue = this.CreateEventQueue();
var entityName = $"{topicName}/Subscriptions/{subscriptionName}";
try
{
using (var listener = this.CreateEventListener(entityName, eventQueue))
using (var subscription = this.SubscribeToEvents(listener))
{
listener.Enable((name, queue, id) => name.Contains("Rule"));
var ruleName = Guid.NewGuid().ToString();
await subscriptionClient.AddRuleAsync(ruleName, new TrueFilter());
await subscriptionClient.GetRulesAsync();
await subscriptionClient.RemoveRuleAsync(ruleName);
Assert.True(eventQueue.TryDequeue(out var addRuleStart));
AssertAddRuleStart(entityName, addRuleStart.eventName, addRuleStart.payload, addRuleStart.activity);
Assert.True(eventQueue.TryDequeue(out var addRuleStop));
AssertAddRuleStop(entityName, addRuleStop.eventName, addRuleStop.payload, addRuleStop.activity, addRuleStart.activity);
Assert.True(eventQueue.TryDequeue(out var getRulesStart));
AssertGetRulesStart(entityName, getRulesStart.eventName, getRulesStart.payload, getRulesStart.activity);
Assert.True(eventQueue.TryDequeue(out var getRulesStop));
AssertGetRulesStop(entityName, getRulesStop.eventName, getRulesStop.payload, getRulesStop.activity, getRulesStart.activity);
Assert.True(eventQueue.TryDequeue(out var removeRuleStart));
AssertRemoveRuleStart(entityName, removeRuleStart.eventName, removeRuleStart.payload, removeRuleStart.activity);
Assert.True(eventQueue.TryDequeue(out var removeRuleStop));
AssertRemoveRuleStop(entityName, removeRuleStop.eventName, removeRuleStop.payload, removeRuleStop.activity, removeRuleStart.activity);
Assert.True(eventQueue.IsEmpty, "There were events present when none were expected");
}
}
finally
{
await subscriptionClient.CloseAsync();
}
});
}
private async Task checkSubscriptionFiltersAsync(SubscriptionClient subscriptionClient, AzureTopicAttribute topicAttribute)
{
IEnumerable <RuleDescription> rules = await subscriptionClient.GetRulesAsync();
// Delete default rule.
if (rules.Any(r => r.Name == RuleDescription.DefaultRuleName))
{
await subscriptionClient.RemoveRuleAsync(RuleDescription.DefaultRuleName);
}
string ruleName = "RouteKey";
if (!rules.Any(r => r.Name == ruleName))
{
var filter = new SqlFilter($"{ruleName}='{topicAttribute.RouteKey}'");
// Add rule for RouteKey.
await subscriptionClient.AddRuleAsync(ruleName, filter);
}
}
static async Task Main(string[] args)
{
var connectionString = "Endpoint=sb://etl-sb-poc.servicebus.windows.net/;SharedAccessKeyName=RootPolicy;SharedAccessKey=6U0k6rYLz6GqwxKFTFDmNPn4E8pgFSQIx1ljTTJ8oAI=";
var topicName = "configuration-topic";
var subscriptionName = "client-service-configuration";
var client = new SubscriptionClient(connectionString, topicName, subscriptionName);
try
{
var rules = await client.GetRulesAsync();
if (rules.All(r => r.Name != "client-service-configuration-filter"))
{
var filter = new SqlFilter("MessageType IN ('ClientConfigurationMessage')");
await client.AddRuleAsync("client-service-configuration-filter", filter);
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
static async Task TopicReceiver()
{
var topicName = "myfirsttopic";
var subscriptionName = "myfirstsubscription";
var receiver = new SubscriptionClient(NamespaceConnectionString, topicName, subscriptionName);
(await receiver.GetRulesAsync())
.ToList()
.ForEach(async r => await receiver.RemoveRuleAsync(r.Name));
await receiver.AddRuleAsync(new RuleDescription("firstRule", new SqlFilter("user.Type='No'")));
receiver.RegisterMessageHandler(async(message, cancelationToken) => {
Console.WriteLine($"Message: {Encoding.UTF8.GetString(message.Body)}");
await receiver.CompleteAsync(message.SystemProperties.LockToken);
}, new MessageHandlerOptions(async args => {})
{
AutoComplete = false
});
Console.ReadKey();
await receiver.CloseAsync();
}
private static async Task CreateSubscriptionRules()
{
try
{
var processPaymentInventoryCheckedClient = new SubscriptionClient(CloudConfigurationManager.GetSetting("ServiceBusConnectionString"),
CloudConfigurationManager.GetSetting("InventoryCheckedTopic"),
CloudConfigurationManager.GetSetting("ProcessPaymentSubscription"));
var sendEmailInventoryCheckedClient = new SubscriptionClient(CloudConfigurationManager.GetSetting("ServiceBusConnectionString"),
CloudConfigurationManager.GetSetting("InventoryCheckedTopic"),
CloudConfigurationManager.GetSetting("SendEmailSubscription"));
var updateInventoryPaymentProcessedClient = new SubscriptionClient(CloudConfigurationManager.GetSetting("ServiceBusConnectionString"),
CloudConfigurationManager.GetSetting("PaymentProcessedTopic"),
CloudConfigurationManager.GetSetting("UpdateInventorySubscription"));
var rules = await processPaymentInventoryCheckedClient.GetRulesAsync();
await CleanUpRules(processPaymentInventoryCheckedClient, "$Default");
await AddRule(processPaymentInventoryCheckedClient, "Verified", "VerifiedInventory-ProcessPayment");
await CleanUpRules(sendEmailInventoryCheckedClient, "$Default");
await AddRule(sendEmailInventoryCheckedClient, "Insufficient", "InsufficientInventory-SendEmail");
await CleanUpRules(updateInventoryPaymentProcessedClient, "$Default");
await AddRule(updateInventoryPaymentProcessedClient, "Verified", "VerifiedPayment-UpdateInventory");
await processPaymentInventoryCheckedClient.CloseAsync();
await sendEmailInventoryCheckedClient.CloseAsync();
await updateInventoryPaymentProcessedClient.CloseAsync();
}
catch (Exception ex)
{
throw ex;
}
}
private static async Task ReadMessage(string topicName, string correlationId)
{
string subscriptionName = "ReplySubscription";
var subscriptionClient = new SubscriptionClient(_connectionString, topicName, subscriptionName);
var rules = await subscriptionClient.GetRulesAsync();
if (rules.Any(a => a.Name == "OnlyToMe"))
{
await subscriptionClient.RemoveRuleAsync("OnlyToMe");
}
if (rules.Any(a => a.Name == RuleDescription.DefaultRuleName))
{
await subscriptionClient.RemoveRuleAsync(RuleDescription.DefaultRuleName);
}
var filter = new CorrelationFilter();
filter.To = "MyUniqueClientName";
var ruleDescription = new RuleDescription("OnlyToMe", filter);
await subscriptionClient.AddRuleAsync(ruleDescription);
var messageHandlerOptions = new MessageHandlerOptions(ExceptionHandler)
{
AutoComplete = false
};
subscriptionClient.RegisterMessageHandler(
(message, cancellationToken) => handleMessage(correlationId, subscriptionClient, message, cancellationToken),
messageHandlerOptions);
await _taskCompletionSource.Task;
await subscriptionClient.UnregisterMessageHandlerAsync(
new TimeSpan(0, 0, 20));
}
static async Task MainAsync()
{
topicClient = new TopicClient(ServiceBusConnectionString, TopicName);
allMessagessubscriptionClient = new SubscriptionClient(ServiceBusConnectionString, TopicName, allMessagesSubscriptionName);
sqlFilterOnlySubscriptionClient = new SubscriptionClient(ServiceBusConnectionString, TopicName, sqlFilterOnlySubscriptionName);
sqlFilterWithActionSubscriptionClient = new SubscriptionClient(ServiceBusConnectionString, TopicName, sqlFilterWithActionSubscriptionName);
correlationFilterSubscriptionClient = new SubscriptionClient(ServiceBusConnectionString, TopicName, correlationFilterSubscriptionName);
// First Subscription is already created with default rule. Leave as is.
// 2nd Subscription: Add SqlFilter on Subscription 2
// Delete Default Rule.
// Add the required SqlFilter Rule
// Note: Does not apply to this sample but if there are multiple rules configured for a
// single subscription, then one message is delivered to the subscription when any of the
// rule matches. If more than one rules match and if there is no `SqlRuleAction` set for the
// rule, then only one message will be delivered to the subscription. If more than one rules
// match and there is a `SqlRuleAction` specified for the rule, then one message per `SqlRuleAction`
// is delivered to the subscription.
Console.WriteLine($"SubscriptionName: {sqlFilterOnlySubscriptionName}, Removing Default Rule and Adding SqlFilter");
await sqlFilterOnlySubscriptionClient.RemoveRuleAsync(RuleDescription.DefaultRuleName);
await sqlFilterOnlySubscriptionClient.AddRuleAsync(new RuleDescription
{
Filter = new SqlFilter("Color = 'Red'"),
Name = "RedSqlRule"
});
// 3rd Subscription: Add SqlFilter and SqlRuleAction on Subscription 3
// Delete Default Rule
// Add the required SqlFilter Rule and Action
Console.WriteLine($"SubscriptionName: {sqlFilterWithActionSubscriptionName}, Removing Default Rule and Adding SqlFilter and SqlRuleAction");
await sqlFilterWithActionSubscriptionClient.RemoveRuleAsync(RuleDescription.DefaultRuleName);
await sqlFilterWithActionSubscriptionClient.AddRuleAsync(new RuleDescription
{
Filter = new SqlFilter("Color = 'Blue'"),
Action = new SqlRuleAction("SET Color = 'BlueProcessed'"),
Name = "BlueSqlRule"
});
// 4th Subscription: Add Correlation Filter on Subscription 4
Console.WriteLine($"SubscriptionName: {sqlFilterWithActionSubscriptionName}, Removing Default Rule and Adding CorrelationFilter");
await correlationFilterSubscriptionClient.RemoveRuleAsync(RuleDescription.DefaultRuleName);
await correlationFilterSubscriptionClient.AddRuleAsync(new RuleDescription
{
Filter = new CorrelationFilter()
{
Label = "Red", CorrelationId = "important"
},
Name = "ImportantCorrelationRule"
});
// Get Rules on Subscription, called here only for one subscription as example
var rules = (await correlationFilterSubscriptionClient.GetRulesAsync()).ToList();
Console.WriteLine($"GetRules:: SubscriptionName: {correlationFilterSubscriptionName}, CorrelationFilter Name: {rules[0].Name}, Rule: {rules[0].Filter}");
// Send messages to Topic
await SendMessagesAsync();
// Receive messages from 'allMessagesSubscriptionName'. Should receive all 9 messages
await ReceiveMessagesAsync(allMessagesSubscriptionName);
// Receive messages from 'sqlFilterOnlySubscriptionName'. Should receive all messages with Color = 'Red' i.e 3 messages
await ReceiveMessagesAsync(sqlFilterOnlySubscriptionName);
// Receive messages from 'sqlFilterWithActionSubscriptionClient'. 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 'correlationFilterSubscriptionName'. Should receive all messages with Color = 'Red' and CorrelationId = "important"
// i.e 1 message
await ReceiveMessagesAsync(correlationFilterSubscriptionName);
Console.WriteLine("=========================================================");
Console.WriteLine("Completed Receiving all messages... Press any key to exit");
Console.WriteLine("=========================================================");
Console.ReadKey();
await allMessagessubscriptionClient.CloseAsync();
await sqlFilterOnlySubscriptionClient.CloseAsync();
await sqlFilterWithActionSubscriptionClient.CloseAsync();
await correlationFilterSubscriptionClient.CloseAsync();
await topicClient.CloseAsync();
}
