public static async Task Stage(string connectionString, string topicName, string rushSubscription,
string currencySubscription)
{
var client = await Cleanup(connectionString, topicName, rushSubscription, currencySubscription);
var subscriptionDescription = new CreateSubscriptionOptions(topicName, rushSubscription);
await client.CreateSubscriptionAsync(subscriptionDescription);
subscriptionDescription = new CreateSubscriptionOptions(topicName, currencySubscription);
await client.CreateSubscriptionAsync(subscriptionDescription);
await client.DeleteRuleAsync(topicName, rushSubscription, "$Default");
await client.DeleteRuleAsync(topicName, currencySubscription, "$Default");
var ruleDescription = new CreateRuleOptions
{
Name = "MessagesWithRushlabel",
Filter = new CorrelationRuleFilter
{
Subject = "rush"
},
Action = null
};
await client.CreateRuleAsync(topicName, rushSubscription, ruleDescription);
ruleDescription = new CreateRuleOptions
{
Name = "MessagesWithCurrencyCHF",
Filter = new SqlRuleFilter("currency = 'CHF'"),
Action = new SqlRuleAction("SET currency = 'Złoty'")
};
await client.CreateRuleAsync(topicName, currencySubscription, ruleDescription);
}
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 CreateTopicSubscriptionAsync(CancellationToken cancellationToken)
{
ServiceBusAdministrationClient serviceBusClient = await Settings.GetServiceBusAdminClientAsync();
string entityPath = await Settings.GetEntityPathAsync();
try
{
bool subscriptionExists = await serviceBusClient.SubscriptionExistsAsync(entityPath, SubscriptionName, cancellationToken);
if (subscriptionExists)
{
Logger.LogTrace("Topic subscription with name '{SubscriptionName}' already exists on Service Bus resource", SubscriptionName);
}
else
{
Logger.LogTrace("Creating subscription '{SubscriptionName}' on topic '{TopicPath}'...", SubscriptionName, entityPath);
var subscriptionDescription = new CreateSubscriptionOptions(entityPath, SubscriptionName)
{
UserMetadata = $"Subscription created by Arcus job: '{JobId}' to process Service Bus messages."
};
var ruleDescription = new CreateRuleOptions("Accept-All", new TrueRuleFilter());
await serviceBusClient.CreateSubscriptionAsync(subscriptionDescription, ruleDescription, cancellationToken)
.ConfigureAwait(continueOnCapturedContext: false);
Logger.LogTrace("Subscription '{SubscriptionName}' created on topic '{TopicPath}'", SubscriptionName, entityPath);
}
}
catch (Exception exception)
{
Logger.LogWarning(exception, "Failed to create topic subscription with name '{SubscriptionName}' on Service Bus resource", SubscriptionName);
}
}
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));
}
public Task <Azure.Response <SubscriptionProperties> > CreateLemmasSubscription(string correlationId)
{
var lemmasSubscriptionOptions = new CreateSubscriptionOptions("lemmas", correlationId)
{
// TODO: probably it should be done in some other way
AutoDeleteOnIdle = TimeSpan.FromMinutes(10)
};
var correlationIdRuleOptions = new CreateRuleOptions("CorrelationIdRule", new CorrelationRuleFilter(correlationId));
return(TopicsAdministrationClient.CreateSubscriptionAsync(lemmasSubscriptionOptions, correlationIdRuleOptions));
}
public Task <Azure.Response <SubscriptionProperties> > CreateDictionaryArticlesSubscription(string correlationId)
{
var falseRuleOptions = new CreateRuleOptions("False", new FalseRuleFilter());
var dictionaryArticlesSubscriptionOptions = new CreateSubscriptionOptions("dictionary-articles", correlationId)
{
// TODO: probably it should be done in some other way
AutoDeleteOnIdle = TimeSpan.FromMinutes(10)
};
return(TopicsAdministrationClient.CreateSubscriptionAsync(dictionaryArticlesSubscriptionOptions, falseRuleOptions));
}
public void CanCreateRulePropertiesFromOptions()
{
var options = new CreateRuleOptions("rule")
{
Filter = new SqlRuleFilter("PROPERTY(@propertyName) = @stringPropertyValue"),
Action = new SqlRuleAction("SET a='b'")
};
var properties = new RuleProperties(options);
Assert.AreEqual(options, new CreateRuleOptions(properties));
}
private CreateRuleOptions MapMessageHandlerMappingToCorrelationRuleFilter(MessageHandlerMapping messageSubscription)
{
var filter = new CorrelationRuleFilter
{
Subject = messageSubscription.SubscriptionFilter !.Label
};
AddMessageFilterProperties(messageSubscription, messageSubscription.MessageType, filter);
var newRule = new CreateRuleOptions(messageSubscription.MessageType.Name, filter);
return(newRule);
}
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 void CanCreateRulePropertiesWithCorrelationFilterFromOptions()
{
var options = new CreateRuleOptions("rule")
{
Filter = new CorrelationRuleFilter
{
ApplicationProperties =
{
{ "propertyName", "value" }
}
},
Action = new SqlRuleAction("SET a='b'")
};
var properties = new RuleProperties(options);
Assert.AreEqual(options, new CreateRuleOptions(properties));
}
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 BasicRuleCrudOperations()
{
var topicName = Recording.Random.NewGuid().ToString("D").Substring(0, 8);
var subscriptionName = Recording.Random.NewGuid().ToString("D").Substring(0, 8);
var client = CreateClient();
await client.CreateTopicAsync(topicName);
var rule1 = new CreateRuleOptions
{
Filter = new TrueRuleFilter(),
Name = "rule1"
};
await client.CreateSubscriptionAsync(
new CreateSubscriptionOptions(topicName, subscriptionName),
rule1);
RuleProperties getRule1 = await client.GetRuleAsync(topicName, subscriptionName, "rule1");
Assert.AreEqual(rule1, new CreateRuleOptions(getRule1));
var sqlRuleFilter = new SqlRuleFilter("stringValue = @stringParam AND intValue = @intParam AND longValue = @longParam AND dateValue = @dateParam AND timeSpanValue = @timeSpanParam");
sqlRuleFilter.Parameters.Add("@stringParam", "string");
sqlRuleFilter.Parameters.Add("@intParam", 1);
sqlRuleFilter.Parameters.Add("@longParam", (long)12);
sqlRuleFilter.Parameters.Add("@dateParam", Recording.Now.UtcDateTime);
sqlRuleFilter.Parameters.Add("@timeSpanParam", TimeSpan.FromDays(1));
var rule2 = new CreateRuleOptions
{
Name = "rule2",
Filter = sqlRuleFilter,
Action = new SqlRuleAction("SET a='b'")
};
await client.CreateRuleAsync(topicName, subscriptionName, rule2);
RuleProperties getRule2 = await client.GetRuleAsync(topicName, subscriptionName, "rule2");
Assert.AreEqual(rule2, new CreateRuleOptions(getRule2));
var correlationRuleFilter = new CorrelationRuleFilter()
{
ContentType = "contentType",
CorrelationId = "correlationId",
Subject = "label",
MessageId = "messageId",
ReplyTo = "replyTo",
ReplyToSessionId = "replyToSessionId",
SessionId = "sessionId",
To = "to"
};
correlationRuleFilter.ApplicationProperties.Add("customKey", "customValue");
var rule3 = new CreateRuleOptions()
{
Name = "rule3",
Filter = correlationRuleFilter,
Action = null
};
await client.CreateRuleAsync(topicName, subscriptionName, rule3);
RuleProperties getRule3 = await client.GetRuleAsync(topicName, subscriptionName, "rule3");
Assert.AreEqual(rule3, new CreateRuleOptions(getRule3));
List <RuleProperties> ruleList = new List <RuleProperties>();
await foreach (RuleProperties rule in client.GetRulesAsync(topicName, subscriptionName))
{
ruleList.Add(rule);
}
RuleProperties[] ruleArr = ruleList.ToArray();
Assert.True(ruleArr.Length == 3);
Assert.AreEqual(rule1, new CreateRuleOptions(ruleArr[0]));
Assert.AreEqual(rule2, new CreateRuleOptions(ruleArr[1]));
Assert.AreEqual(rule3, new CreateRuleOptions(ruleArr[2]));
((CorrelationRuleFilter)getRule3.Filter).CorrelationId = "correlationIdModified";
SubscriptionProperties sub = await client.GetSubscriptionAsync(topicName, subscriptionName);
RuleProperties updatedRule3 = await client.UpdateRuleAsync(topicName, subscriptionName, getRule3);
Assert.AreEqual(getRule3, updatedRule3);
bool exists = await client.RuleExistsAsync(topicName, subscriptionName, rule1.Name);
Assert.True(exists);
await client.DeleteRuleAsync(topicName, subscriptionName, "rule1");
Assert.That(
async() =>
await client.GetRuleAsync(topicName, subscriptionName, "rule1"),
Throws.InstanceOf <ServiceBusException>().And.Property(nameof(ServiceBusException.Reason)).EqualTo(ServiceBusFailureReason.MessagingEntityNotFound));
exists = await client.RuleExistsAsync(topicName, subscriptionName, rule1.Name);
Assert.False(exists);
await client.DeleteTopicAsync(topicName);
}
private static bool RuleIsEqual(RuleProperties ruleProperties, CreateRuleOptions ruleOptions) => ruleOptions.Name == ruleProperties.Name && (CorrelationRuleFilter)ruleOptions.Filter == (CorrelationRuleFilter)ruleProperties.Filter;
private static bool NewRuleExists(List <RuleProperties> existingRules, CreateRuleOptions newRule) => existingRules.Any(r => RuleIsEqual(r, newRule));
public async Task AddGetAndRemoveRules()
{
await using (var scope = await ServiceBusScope.CreateWithTopic(enablePartitioning: false, enableSession: false))
{
await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
ServiceBusRuleManager ruleManager = client.CreateRuleManager(scope.TopicName, scope.SubscriptionNames.First());
var sqlRuleName = "sqlRule";
var correlationRuleName = "correlationRule";
var rules = await ruleManager.GetRulesAsync();
Assert.AreEqual(1, rules.Count());
var firstRule = rules[0];
Assert.AreEqual(RuleProperties.DefaultRuleName, firstRule.Name);
Assert.Null(firstRule.Action);
await ruleManager.AddRuleAsync(sqlRuleName, new SqlRuleFilter("price > 10"));
var ruleOptions = new CreateRuleOptions(correlationRuleName)
{
Filter = new CorrelationRuleFilter
{
CorrelationId = "correlationId",
Subject = "label",
MessageId = "messageId",
ApplicationProperties =
{
{ "key1", "value1" }
},
ReplyTo = "replyTo",
ReplyToSessionId = "replyToSessionId",
SessionId = "sessionId",
To = "to"
},
Action = new SqlRuleAction("Set CorrelationId = 'newValue'")
};
await ruleManager.AddRuleAsync(ruleOptions);
rules = await ruleManager.GetRulesAsync();
Assert.AreEqual(3, rules.Count);
var sqlRule = rules.FirstOrDefault(rule => rule.Name.Equals(sqlRuleName));
Assert.NotNull(sqlRule);
Assert.Null(sqlRule.Action);
Assert.IsInstanceOf <SqlRuleFilter>(sqlRule.Filter);
Assert.AreEqual("price > 10", ((SqlRuleFilter)sqlRule.Filter).SqlExpression);
var correlationRule = rules.FirstOrDefault(rule => rule.Name.Equals(correlationRuleName));
Assert.NotNull(correlationRule);
Assert.IsInstanceOf <SqlRuleAction>(correlationRule.Action);
var sqlRuleAction = correlationRule.Action as SqlRuleAction;
Assert.NotNull(sqlRuleAction);
Assert.AreEqual("Set CorrelationId = 'newValue'", sqlRuleAction.SqlExpression);
Assert.IsInstanceOf <CorrelationRuleFilter>(correlationRule.Filter);
var correlationRuleFilter = correlationRule.Filter as CorrelationRuleFilter;
Assert.NotNull(correlationRuleFilter);
Assert.AreEqual("correlationId", correlationRuleFilter.CorrelationId);
Assert.AreEqual("label", correlationRuleFilter.Subject);
Assert.AreEqual("messageId", correlationRuleFilter.MessageId);
Assert.AreEqual("replyTo", correlationRuleFilter.ReplyTo);
Assert.AreEqual("replyToSessionId", correlationRuleFilter.ReplyToSessionId);
Assert.AreEqual("sessionId", correlationRuleFilter.SessionId);
Assert.AreEqual("to", correlationRuleFilter.To);
Assert.NotNull(correlationRuleFilter.ApplicationProperties);
Assert.AreEqual("value1", correlationRuleFilter.ApplicationProperties["key1"]);
await ruleManager.RemoveRuleAsync(RuleProperties.DefaultRuleName);
await ruleManager.RemoveRuleAsync(sqlRuleName);
await ruleManager.RemoveRuleAsync(correlationRuleName);
rules = (await ruleManager.GetRulesAsync()).ToList();
Assert.AreEqual(0, rules.Count);
}
}
