public async Task AddRule(RuleDescription rule)
{
var newRule = (SqlFilter)rule.Filter;
_log.LogInformation($"Creating rule {rule.Name} for subscriber {_client.SubscriptionName}");
await _client.AddRuleAsync(rule).ConfigureAwait(false);
}
public async Task CreatetopicprioritySubscription(string topicname)
{
var client = new ManagementClient(sbconnection);
bool topicExists = await client.TopicExistsAsync(topicname).ConfigureAwait(false);
string[] subscriptionarray = new string[] { "highprioritysubscription", "lowprioritysubscription" };
if (topicExists)
{
foreach (var item in subscriptionarray)
{
if (item == "highprioritysubscription")
{
SubscriptionDescription subName = new SubscriptionDescription(topicname, item);
subName.Status = 0;
RuleDescription subscriptionRule = new RuleDescription();
subscriptionRule.Filter = new SqlFilter("Priority >= 10");
var result01 = await client.CreateSubscriptionAsync(subName, subscriptionRule).ConfigureAwait(false);
}
else
{
SubscriptionDescription subName = new SubscriptionDescription(topicname, item);
subName.Status = 0;
RuleDescription subscriptionRule = new RuleDescription();
subscriptionRule.Filter = new SqlFilter("Priority < 10");
var result01 = await client.CreateSubscriptionAsync(subName, subscriptionRule).ConfigureAwait(false);
}
}
}
}
private void button3_Click(object sender, EventArgs e)
{
var connectionString = textBox1.Text; //System.Configuration.ConfigurationManager.AppSettings["Microsoft.ServiceBus.ConnectionString"];
var topicName = textBox2.Text; //System.Configuration.ConfigurationManager.AppSettings["TopicName"];
var subscriptionName = textBox3.Text; //System.Configuration.ConfigurationManager.AppSettings["SubscriptionName"];
RuleDescription rule = new RuleDescription();
SqlFilter sqlFilter = new SqlFilter(textBox5.Text); //textBox5.Text = "eventDestination LIKE '%ALCO%'";
rule.Filter = sqlFilter;
rule.Name = "$Default";
//NamespaceManager namespaceManager = NamespaceManager.CreateFromConnectionString(connectionString);
//var rules = namespaceManager.GetRules(topicName, subscriptionName);
var subscriptionClient = SubscriptionClient.CreateFromConnectionString(connectionString, topicName, subscriptionName, ReceiveMode.PeekLock);
try
{
subscriptionClient.RemoveRule("$Default");
//subscriptionClient.RemoveRule("$EventDestination");
}
catch
{
//Ignore
}
subscriptionClient.AddRule("$Default", sqlFilter);
}
public async Task <object> CreatetopicCorrelationFilterSubscription(string topicname)
{
var client = new ManagementClient(sbconnection);
bool topicExists = await client.TopicExistsAsync(topicname).ConfigureAwait(false);
if (topicExists)
{
SubscriptionDescription subName = new SubscriptionDescription(topicname, "CorrelationFilterSubscription");
subName.Status = 0;
RuleDescription subscriptionRule = new RuleDescription();
subscriptionRule.Filter = new CorrelationFilter
{
Label = "Correlationfiltersample",
ReplyTo = "x",
ContentType = "Finanical",
};
var result01 = await client.CreateSubscriptionAsync(subName, subscriptionRule).ConfigureAwait(false);
return(result01);
}
else
{
return("Unable to create CorrelationFilter Subscription!!");
}
}
private void CreateServiceBusMessagingEntities()
{
var wasServiceBusConnectionString = CloudConfigurationManager.GetSetting("Microsoft.ServiceBus.ConnectionString.WarehouseAvailableStock");
var wasSubscriptionName = CloudConfigurationManager.GetSetting("Microsoft.ServiceBus.ConnectionString.WarehouseAvailableStock.StockQuantitySubscription");
//var vccSubscriptionName = CloudConfigurationManager.GetSetting("Microsoft.ServiceBus.ConnectionString.WarehouseAvailableStock.VariantSkuMapSubscription");
var wasTopicPath = CloudConfigurationManager.GetSetting("Microsoft.ServiceBus.ConnectionString.WarehouseAvailableStock.TopicPath");
var stockQuantityServiceBusConnectionString = CloudConfigurationManager.GetSetting("Microsoft.ServiceBus.ConnectionString.StockQuantity");
var discardedEventsSubscriptionName = CloudConfigurationManager.GetSetting("Microsoft.ServiceBus.ConnectionString.StockQuantity.DiscardedEventsSubscription");
var stockQuantityTopicPath = CloudConfigurationManager.GetSetting("Microsoft.ServiceBus.ConnectionString.StockQuantity.TopicPath");
var discardedEventSubscriptionClient = SubscriptionClient.CreateFromConnectionString(stockQuantityServiceBusConnectionString, stockQuantityTopicPath, discardedEventsSubscriptionName);
// Set up Subscription Rules & Filters
var isDiscardedRuleDescription = new RuleDescription("IsDiscarded");
isDiscardedRuleDescription.Filter = new SqlFilter("IsDiscarded = 1");
discardedEventSubscriptionClient.RemoveRule(RuleDescription.DefaultRuleName);
discardedEventSubscriptionClient.RemoveRule(isDiscardedRuleDescription.Name);
discardedEventSubscriptionClient.AddRule(isDiscardedRuleDescription);
_maximumConcurrency = Convert.ToInt16(CloudConfigurationManager.GetSetting("MaximumConcurrency"));
_warehouseAvailableStockChangedReceiver = new WarehouseAvailableStockChangedReceiver(_maximumConcurrency, wasServiceBusConnectionString, wasSubscriptionName, wasTopicPath, _topicClient, _stockQuantityAggregateStore, _skuVariantCacheManager, _telemetryClient);
//_variantCopyCompletedReceiver = new VariantCopyCompletedReceiver(3, wasServiceBusConnectionString, vccSubscriptionName, wasTopicPath, _topicClient, _stockQuantityAggregateStore, _telemetryClient);
}
public JsonResult CreateTopic(string topicName)
{
bool success;
try
{
var topic = this.namespaceManager.CreateTopic(topicName);
var allMessagesSubscription = this.namespaceManager.CreateSubscription(topic.Path, "AllMessages");
var urgentMessagesSubscription = this.namespaceManager.CreateSubscription(topic.Path, "UrgentMessages", new SqlFilter("Urgent = '1'"));
var ruleDescription = new RuleDescription()
{
Filter = new SqlFilter("Important= '1' OR Priority = 'High'"),
Action = new SqlRuleAction("set Priority= 'High'")
};
var highPriorityMessagesSubscription = this.namespaceManager.CreateSubscription(topic.Path, "HighPriorityMessages", ruleDescription);
success = true;
}
catch (Exception)
{
success = false;
}
return(this.Json(success, JsonRequestBehavior.AllowGet));
}
private Rule MapRule(RuleDescription r)
{
if (r.Filter is SqlFilter)
{
return(new Rule
{
Name = r.Name,
FilterType = "SqlFilter",
Text = (r.Filter as SqlFilter).SqlExpression,
CreatedAt = r.CreatedAt
});
}
if (r.Filter is CorrelationFilter)
{
return(new Rule
{
Name = r.Name,
FilterType = "CorrelationFilter",
Text = "TODO",
CreatedAt = r.CreatedAt
});
}
return(new Rule
{
Name = r.Name,
CreatedAt = r.CreatedAt,
Text = "Unknown",
FilterType = "UnknownFilterType"
});
}
private async Task <SubscriptionDescription> GetOrCreateSubscription(string endpointName, CancellationToken cancellationToken)
{
var manageClient = new ManagementClient(connectionString);
SubscriptionDescription subscriptionDescription;
if (!await manageClient.SubscriptionExistsAsync(TopicPath, endpointName, cancellationToken))
{
subscriptionDescription = new SubscriptionDescription(TopicPath, endpointName)
{
ForwardTo = endpointName,
UserMetadata = endpointName,
EnableBatchedOperations = true,
MaxDeliveryCount = Int32.MaxValue,
EnableDeadLetteringOnFilterEvaluationExceptions = false,
LockDuration = TimeSpan.FromMinutes(5)
};
var defaultRule = new RuleDescription("$default")
{
Filter = new SqlFilter("1=0")
};
await manageClient.CreateSubscriptionAsync(
subscriptionDescription, defaultRule, cancellationToken);
}
else
{
subscriptionDescription =
await manageClient.GetSubscriptionAsync(TopicPath, endpointName, cancellationToken);
}
return(subscriptionDescription);
}
public static Task <IActionResult> Run(
[HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req,
ILogger log)
{
string connectionStringServiceBus = "Endpoint=sb://plenttdata.servicebus.windows.net/;SharedAccessKeyName=RootManageSharedAccessKey;SharedAccessKey=H04PgzviylO3hman4MOuXfSWPHgrCUDOKd5835UQYas=";
string topicName = "pletopic";
string SubscriptionName = "plesubscription";
subscriptionClient = new SubscriptionClient(connectionStringServiceBus, topicName, SubscriptionName);
Console.WriteLine("======================================================");
Console.WriteLine("Press any key to exit after receiving all the messages.");
Console.WriteLine("======================================================");
var newRule = new RuleDescription("FilteredRule", new SqlFilter("From LIKE '%manhduc'"));
subscriptionClient.AddRuleAsync(newRule);
topicClient = new TopicClient(connectionStringServiceBus, topicName);
RegisterMessageHandlerAndReceiveMessages();
Console.ReadKey();
topicClient.CloseAsync().Wait();
return(null);
}
private static async Task UpdateSubscriptionRules <TPayload>(
ManagementClient managementClient,
string channelName,
string subscriptionName,
RuleDescription ruleDescription,
IMessageFactory <TPayload> messageFactory)
where TPayload : class, IReceivedServiceBusMessage
{
var currentRules = await managementClient.GetRulesAsync(channelName, subscriptionName);
if (currentRules.All(rule => ParseRuleName(rule) < messageFactory.CurrentVersion))
{
// First we add a rule so new messages can qualify
await managementClient.CreateRuleAsync(channelName, subscriptionName, ruleDescription)
.IgnoreRaceConditionException <MessagingEntityAlreadyExistsException>();
// Remove each rule that are older than the one we just added
currentRules = await managementClient.GetRulesAsync(channelName, subscriptionName);
foreach (var rule in currentRules)
{
if (ParseRuleName(rule) < messageFactory.CurrentVersion)
{
await managementClient.DeleteRuleAsync(channelName, subscriptionName, rule.Name)
.IgnoreRaceConditionException <MessagingEntityNotFoundException>();
}
}
}
}
private static void TryAddRule(SubscriptionClient client, RuleDescription rule)
{
// try / catch is because there could be other processes initializing at the same time.
try {
client.AddRule(rule);
} catch (MessagingEntityAlreadyExistsException) { }
}
public static AmqpMap GetRuleDescriptionMap(RuleDescription description)
{
var ruleDescriptionMap = new AmqpMap();
switch (description.Filter)
{
case SqlFilter sqlFilter:
var filterMap = GetSqlFilterMap(sqlFilter);
ruleDescriptionMap[ManagementConstants.Properties.SqlFilter] = filterMap;
break;
case CorrelationFilter correlationFilter:
var correlationFilterMap = GetCorrelationFilterMap(correlationFilter);
ruleDescriptionMap[ManagementConstants.Properties.CorrelationFilter] = correlationFilterMap;
break;
default:
throw new NotSupportedException(
Resources.RuleFilterNotSupported.FormatForUser(
description.Filter.GetType(),
nameof(SqlFilter),
nameof(CorrelationFilter)));
}
var amqpAction = GetRuleActionMap(description.Action as SqlRuleAction);
ruleDescriptionMap[ManagementConstants.Properties.SqlRuleAction] = amqpAction;
ruleDescriptionMap[ManagementConstants.Properties.RuleName] = description.Name;
return(ruleDescriptionMap);
}
public async Task SqlFilterParams()
{
var client = new ServiceBusManagementClient(TestEnvironment.ServiceBusConnectionString);
var topicName = Guid.NewGuid().ToString("D").Substring(0, 8);
var subscriptionName = Guid.NewGuid().ToString("D").Substring(0, 8);
await client.CreateTopicAsync(topicName);
await client.CreateSubscriptionAsync(topicName, subscriptionName);
SqlRuleFilter sqlFilter = new SqlRuleFilter(
"PROPERTY(@propertyName) = @stringPropertyValue " +
"AND PROPERTY(intProperty) = @intPropertyValue " +
"AND PROPERTY(longProperty) = @longPropertyValue " +
"AND PROPERTY(boolProperty) = @boolPropertyValue " +
"AND PROPERTY(doubleProperty) = @doublePropertyValue ")
{
Parameters =
{
{ "@propertyName", "MyProperty" },
{ "@stringPropertyValue", "string" },
{ "@intPropertyValue", 3 },
{ "@longPropertyValue", 3L },
{ "@boolPropertyValue", true },
{ "@doublePropertyValue", 3.0 },
}
};
RuleDescription rule = await client.CreateRuleAsync(topicName, subscriptionName, new RuleDescription("rule1", sqlFilter));
Assert.AreEqual(sqlFilter, rule.Filter);
await client.DeleteTopicAsync(topicName);
}
public async Task BlockUsers(IEnumerable <string> users)
{
if (!users.Any())
{
return;
}
string sqlExpression = null;
foreach (var user in users)
{
if (sqlExpression == null)
{
sqlExpression += $"sys.Label <> '{user}'";
}
else
{
sqlExpression += $" AND sys.Label <> '{user}'";
}
}
var blockUsersRule = new RuleDescription
{
Name = "BlockUsers_SqlFilter",
Filter = new SqlFilter(sqlExpression)
};
await Subscription.AddRule(Name, MyUsername, blockUsersRule);
}
private static async Task AddRules(Subscriber subscriber, SubscriptionClient subscriptionClient)
{
foreach (string label in subscriber.Labels)
{
RuleDescription ruleDescription = new RuleDescription
{
Name = label,
Filter = new CorrelationFilter {
Label = label
}
};
try
{
await RemoveDefaultRuleAsync(subscriptionClient);
Console.WriteLine(
$"Trying to add the following rule: Name: {label}, Label: {label}");
await subscriptionClient.AddRuleAsync(ruleDescription);
Console.WriteLine("Rule was successfully added");
}
catch (ServiceBusException e)
when(e.Message != null && e.Message.Contains("already exists", StringComparison.InvariantCulture))
{
Console.WriteLine("The rule already exists");
}
catch (Exception e)
{
Console.WriteLine($"Some error occurred: {e.Message}");
throw;
}
}
}
public ProjectSourceCodeFilesRelatedRule(
RuleDescription description,
ISourceCodeFileContentCheck fileContentCheck)
{
_fileContentCheck = fileContentCheck;
_ruleDescription = description;
}
public SubscriptionConsumeTopologySpecification(TopicDescription topicDescription, SubscriptionDescription subscriptionDescription, RuleDescription rule, Filter filter)
{
_topicDescription = topicDescription;
_subscriptionDescription = subscriptionDescription;
_rule = rule;
_filter = filter;
}
public static AmqpMap GetRuleDescriptionMap(RuleDescription description)
{
AmqpMap ruleDescriptionMap = new AmqpMap();
if (description.Filter is SqlFilter)
{
AmqpMap filterMap = GetSqlFilterMap(description.Filter as SqlFilter);
ruleDescriptionMap[ManagementConstants.Properties.SqlFilter] = filterMap;
}
else if (description.Filter is CorrelationFilter)
{
AmqpMap correlationFilterMap = GetCorrelationFilterMap(description.Filter as CorrelationFilter);
ruleDescriptionMap[ManagementConstants.Properties.CorrelationFilter] = correlationFilterMap;
}
else
{
throw new NotSupportedException(
Resources.RuleFilterNotSupported.FormatForUser(
description.Filter.GetType(),
nameof(SqlFilter),
nameof(CorrelationFilter)));
}
AmqpMap amqpAction = GetRuleActionMap(description.Action as SqlRuleAction);
ruleDescriptionMap[ManagementConstants.Properties.SqlRuleAction] = amqpAction;
return(ruleDescriptionMap);
}
protected override void InstantiateReceiving(IDictionary <int, SubscriptionClient> serviceBusReceivers, string topicName, string topicSubscriptionName)
{
base.InstantiateReceiving(serviceBusReceivers, topicName, topicSubscriptionName);
// https://docs.microsoft.com/en-us/azure/application-insights/app-insights-analytics-reference#summarize-operator
// http://www.summa.com/blog/business-blog/everything-you-need-to-know-about-azure-service-bus-brokered-messaging-part-2#rulesfiltersactions
// https://github.com/Azure-Samples/azure-servicebus-messaging-samples/tree/master/TopicFilters
SubscriptionClient client = serviceBusReceivers[0];
try
{
client.RemoveRule("CqrsConfiguredFilter");
}
catch (MessagingEntityNotFoundException)
{
}
string filter = ConfigurationManager.GetSetting(FilterKeyConfigurationKey);
if (!string.IsNullOrWhiteSpace(filter))
{
RuleDescription ruleDescription = new RuleDescription
(
"CqrsConfiguredFilter",
new SqlFilter(filter)
);
client.AddRuleAsync(ruleDescription);
}
}
public async Task OnAddRuleAsync(RuleDescription description)
{
try
{
var amqpRequestMessage = AmqpRequestMessage.CreateRequest(
ManagementConstants.Operations.AddRuleOperation,
this.ServiceBusConnection.OperationTimeout,
null);
amqpRequestMessage.Map[ManagementConstants.Properties.RuleName] = description.Name;
amqpRequestMessage.Map[ManagementConstants.Properties.RuleDescription] =
AmqpMessageConverter.GetRuleDescriptionMap(description);
AmqpResponseMessage response =
await
((AmqpMessageReceiver)this.InnerReceiver).ExecuteRequestResponseAsync(amqpRequestMessage)
.ConfigureAwait(false);
if (response.StatusCode != AmqpResponseStatusCode.OK)
{
throw response.ToMessagingContractException();
}
}
catch (Exception exception)
{
throw AmqpExceptionHelper.GetClientException(exception);
}
}
/// <summary>
/// Adds a rule to the current subscription to filter the messages reaching from topic to the subscription.
/// </summary>
///
/// <param name="description">The rule description that provides the rule to add.</param>
/// <param name="cancellationToken">An optional <see cref="CancellationToken"/> instance to signal the request to cancel the operation.</param>
///
/// <remarks>
/// You can add rules to the subscription that decides which messages from the topic should reach the subscription.
/// A default <see cref="TrueFilter"/> rule named <see cref="RuleDescription.DefaultRuleName"/> is always added while creation of the Subscription.
/// You can add multiple rules with distinct names to the same subscription.
/// Multiple filters combine with each other using logical OR condition. i.e., If any filter succeeds, the message is passed on to the subscription.
/// </remarks>
///
/// <returns>A task instance that represents the asynchronous add rule operation.</returns>
public virtual async Task AddRuleAsync(
RuleDescription description,
CancellationToken cancellationToken = default)
{
Argument.AssertNotClosed(IsDisposed, nameof(ServiceBusRuleManager));
Argument.AssertNotNull(description, nameof(description));
cancellationToken.ThrowIfCancellationRequested <TaskCanceledException>();
EntityNameFormatter.CheckValidRuleName(description.Name);
ServiceBusEventSource.Log.AddRuleStart(Identifier, description.Name);
try
{
await InnerRuleManager.AddRuleAsync(
description,
cancellationToken).ConfigureAwait(false);
}
catch (Exception exception)
{
ServiceBusEventSource.Log.AddRuleException(Identifier, exception);
throw;
}
cancellationToken.ThrowIfCancellationRequested <TaskCanceledException>();
ServiceBusEventSource.Log.AddRuleComplete(Identifier);
}
private static async Task CreateTopicIfNotExist(ManagementClient mc, string name, ILogger log)
{
if (!await mc.TopicExistsAsync(name))
{
await mc.CreateTopicAsync(name);
log.LogInformation($"Created topic {name}");
}
else
{
log.LogInformation($"Skipped topic {name}");
}
if (!await mc.SubscriptionExistsAsync(name, "bridge"))
{
var sd = new SubscriptionDescription(name, "bridge")
{
ForwardTo = "bridge"
};
var rl = new RuleDescription("bridge")
{
Filter = new SqlFilter("xbridge is null"),
Action = new SqlRuleAction($"set xbridge=1; set sys.to='{name}'")
};
await mc.CreateSubscriptionAsync(sd, rl);
log.LogInformation($"Created bridge subscription on {name}");
}
else
{
log.LogInformation($"Skipped bridge subscription on {name}");
}
}
static async Task Main(string[] args)
{
managementClient = new ManagementClient(ServiceBusConnectionString);
await CreateTopicIfNotExistsAsync(TopicName);
await CreateSubscriptionIfNotExistsAsync(TopicName, "EvenNumbers");
subscriptionClient = new SubscriptionClient(ServiceBusConnectionString, TopicName, "EvenNumbers");
await RemoveDefaultRuleAsync();
var isEvenFilter = CreateFilter("IsEven", true);
var ruleDescription = new RuleDescription("MyFilter", isEvenFilter);
await AddRuleIfNotExistsAsync(ruleDescription);
var messageHandlerOptions = new MessageHandlerOptions(ExceptionReceivedHandler)
{
MaxConcurrentCalls = 1,
AutoComplete = false
};
subscriptionClient.RegisterMessageHandler(ProcessMessagesAsync, messageHandlerOptions);
Console.ReadKey();
}
public async Task Subscribe(Type eventType, ContextBag context)
{
await CheckForManagePermissions().ConfigureAwait(false);
var ruleName = eventType.FullName.Length > maxNameLength?ruleShortener(eventType.FullName) : eventType.FullName;
var sqlExpression = $"[{Headers.EnclosedMessageTypes}] LIKE '%{eventType.FullName}%'";
var rule = new RuleDescription(ruleName, new SqlFilter(sqlExpression));
var client = new ManagementClient(connectionStringBuilder, tokenProvider);
try
{
var existingRule = await client.GetRuleAsync(topicPath, subscriptionName, rule.Name).ConfigureAwait(false);
if (existingRule.Filter.ToString() != rule.Filter.ToString())
{
rule.Action = existingRule.Action;
await client.UpdateRuleAsync(topicPath, subscriptionName, rule).ConfigureAwait(false);
}
}
catch (MessagingEntityNotFoundException)
{
try
{
await client.CreateRuleAsync(topicPath, subscriptionName, rule).ConfigureAwait(false);
}
catch (MessagingEntityAlreadyExistsException)
{
}
}
await client.CloseAsync().ConfigureAwait(false);
}
/// <summary>Adds the subscriber.</summary>
/// <param name="routingKey">The routing key.</param>
public void AddSubscriber(string routingKey)
{
ManagementClient client = new ManagementClient(_connectionString);
if (!client.SubscriptionExistsAsync(_topicName, _topicSubscription).Result)
{
SubscriptionDescription subscriptionDescription = new SubscriptionDescription(_topicName, _topicSubscription)
{
LockDuration = TimeSpan.FromMinutes(5)
};
if (!string.IsNullOrWhiteSpace(routingKey))
{
RuleDescription ruleDescription = new RuleDescription
{
Filter = new Microsoft.Azure.ServiceBus.SqlFilter(routingKey)
};
client.CreateSubscriptionAsync(subscriptionDescription, ruleDescription);
}
else
{
client.CreateSubscriptionAsync(subscriptionDescription);
}
}
}
public async Task SetupSubscriptionRules()
{
var exitstingRules = await _subscriptionClient.GetRulesAsync();
var subscriptionRuleName = _subscriptionName + "-rule";
if (exitstingRules != null)
{
exitstingRules
.Where(r => r.Name != subscriptionRuleName)
.ToList()
.ForEach(async r => await _subscriptionClient.RemoveRuleAsync(r.Name));
if (exitstingRules.Any(r => r.Name == subscriptionRuleName))
{
return;
}
}
var corrFilter = new CorrelationFilter();
corrFilter.Properties.Add(_filterProperty, true);
var rule = new RuleDescription
{
Filter = corrFilter,
Name = subscriptionRuleName
};
await _subscriptionClient.AddRuleAsync(rule);
}
public bool Create(IDictionary <string, object> apiRequestModel)
{
bool result = false;
if (null != apiRequestModel)
{
SubscriptionModel subscriptionRequest = apiRequestModel.ToEntity <SubscriptionModel>();
if (null != subscriptionRequest)
{
Logger.LogMessage(string.Format("Checking if Subscription with name {0} already exists under Topic with name {0}...", subscriptionRequest.Name, subscriptionRequest.TopicName));
if (!CheckIfExists(subscriptionRequest.TopicName, subscriptionRequest.Name))
{
Logger.LogMessage(string.Format(CultureInfo.InvariantCulture, "Creating Subscription with name {0} under Topic {1} in service bus namespace", subscriptionRequest.Name, subscriptionRequest.TopicName));
SubscriptionDescription subscriptionDescription = GenerateSubscriptionDescription(subscriptionRequest);
RuleDescription ruleDescription = GenerateRuleDescription(subscriptionRequest);
if (null == ruleDescription)
{
nameSpaceManager.CreateSubscription(subscriptionDescription);
}
else
{
nameSpaceManager.CreateSubscription(subscriptionDescription, ruleDescription);
}
Logger.LogMessage(string.Format(CultureInfo.InvariantCulture, "Subscription with name {0} created under Topic with name {1} in service bus namespace", subscriptionRequest.Name, subscriptionRequest.TopicName));
result = true;
}
}
}
return(result);
}
public void ApplyTo(ISourceCodeFileInNamespace sourceCodeFile, RuleDescription description,
IAnalysisReportInProgress report)
{
sourceCodeFile.CheckMethodsHavingCorrectAttributes(
report,
_ruleDto.ClassNameInclusionPattern,
_ruleDto.MethodNameInclusionPattern, description);
}
/// <summary>
/// Adds a rule to the current subscription to filter the messages reaching from topic to the subscription.
/// </summary>
/// <param name="description">The rule description that provides the rule to add.</param>
/// <param name="cancellationToken"></param>
/// <returns>A task instance that represents the asynchronous add rule operation.</returns>
/// <remarks>
/// You can add rules to the subscription that decides which messages from the topic should reach the subscription.
/// A default <see cref="TrueFilter"/> rule named <see cref="RuleDescription.DefaultRuleName"/> is always added while creation of the Subscription.
/// You can add multiple rules with distinct names to the same subscription.
/// Multiple filters combine with each other using logical OR condition. i.e., If any filter succeeds, the message is passed on to the subscription.
/// </remarks>
public virtual async Task AddRuleAsync(
RuleDescription description,
CancellationToken cancellationToken = default)
{
await Task.Delay(1).ConfigureAwait(false);
throw new NotImplementedException();
}
public RuleViolation PathRuleViolation(RuleDescription description,
IReadOnlyList <IDependencyPathBasedRuleTarget> violationPath)
{
return(RuleViolation.Create(
description,
"Violating path: ",
_reportFragmentsFormat.ApplyToPath(violationPath)));
}
public JsonResult CreateTopic(string topicName)
{
var topic = this.namespaceManager.CreateTopic(topicName);
var allMessagesSubscription = this.namespaceManager.CreateSubscription(topic.Path, "AllMessages");
var urgentMessagesSubscription = this.namespaceManager.CreateSubscription(topic.Path, "UrgentMessages", new SqlFilter("Urgent = '1'"));
var ruleDescription = new RuleDescription()
{
Filter = new SqlFilter("Important= '1' OR Priority = 'High'"),
Action = new SqlRuleAction("set Priority= 'High'")
};
var highPriorityMessagesSubscription = this.namespaceManager.CreateSubscription(topic.Path, "HighPriorityMessages", ruleDescription);
return this.Json(topicName, JsonRequestBehavior.AllowGet);
}
private void btnAction_Click(object sender, EventArgs e)
{
try
{
if (serviceBusHelper == null ||
ruleWrapper == null ||
ruleWrapper.SubscriptionDescription == null)
{
return;
}
if (btnAction.Text == RemoveText &&
ruleWrapper.SubscriptionDescription != null &&
!string.IsNullOrEmpty(ruleWrapper.SubscriptionDescription.Name) &&
ruleWrapper.RuleDescription != null &&
!string.IsNullOrEmpty(ruleWrapper.RuleDescription.Name))
{
var deleteForm = new DeleteForm(ruleWrapper.RuleDescription.Name, RuleEntity.ToLower());
if (deleteForm.ShowDialog() == DialogResult.OK)
{
serviceBusHelper.RemoveRule(ruleWrapper.SubscriptionDescription, ruleWrapper.RuleDescription);
}
return;
}
if (btnAction.Text == AddText)
{
if (string.IsNullOrEmpty(txtName.Text))
{
writeToLog(NameCannotBeNull);
return;
}
var ruleDescription = new RuleDescription(txtName.Text);
if (!string.IsNullOrEmpty(txtSqlFilterExpression.Text))
{
ruleDescription.Filter = new SqlFilter(txtSqlFilterExpression.Text);
}
if (!string.IsNullOrEmpty(txtSqlFilterAction.Text))
{
ruleDescription.Action = new SqlRuleAction(txtSqlFilterAction.Text);
}
ruleWrapper.RuleDescription = serviceBusHelper.AddRule(ruleWrapper.SubscriptionDescription, ruleDescription);
InitializeData();
}
}
catch (Exception ex)
{
HandleException(ex);
}
}
public void Setup(string subscription, string priority)
{
var namespaceManager = NamespaceManager.CreateFromConnectionString(this.serviceBusConnectionString);
// Setup the topic.
if (!namespaceManager.TopicExists(this.topicName))
{
try
{
namespaceManager.CreateTopic(this.topicName);
}
catch (MessagingEntityAlreadyExistsException)
{
Trace.TraceInformation("Messaging entity already created: " + this.topicName);
}
catch (MessagingException ex)
{
var webException = ex.InnerException as WebException;
if (webException != null)
{
var response = webException.Response as HttpWebResponse;
// It's likely the conflicting operation being performed by the service bus is another queue create operation
// If we don't have a web response with status code 'Conflict' it's another exception
if (response == null || response.StatusCode != HttpStatusCode.Conflict)
{
throw;
}
Trace.TraceWarning("MessagingException HttpStatusCode.Conflict - Queue likely already exists or is being created or deleted for path: {0}", this.topicName);
}
}
}
this.topicClient = TopicClient.CreateFromConnectionString(this.serviceBusConnectionString, this.topicName);
this.topicClient.RetryPolicy = RetryPolicy.Default;
// Setup the subscription.
if (!string.IsNullOrEmpty(subscription))
{
if (!namespaceManager.SubscriptionExists(this.topicName, subscription))
{
// Setup the filter for the subscription based on the priority.
var filter = new SqlFilter("Priority = '" + priority + "'");
var ruleDescription = new RuleDescription
{
Name = "PriorityFilter",
Filter = filter
};
try
{
namespaceManager.CreateSubscription(this.topicName, subscription, ruleDescription);
}
catch (MessagingEntityAlreadyExistsException)
{
Trace.TraceInformation("Messaging entity already created: " + subscription);
}
catch (MessagingException ex)
{
var webException = ex.InnerException as WebException;
if (webException != null)
{
var response = webException.Response as HttpWebResponse;
// It's likely the conflicting operation being performed by the service bus is another queue create operation
// If we don't have a web response with status code 'Conflict' it's another exception
if (response == null || response.StatusCode != HttpStatusCode.Conflict)
{
throw;
}
Trace.TraceWarning("MessagingException HttpStatusCode.Conflict - subscription likely already exists or is being created or deleted for path: {0}", subscription);
}
}
}
this.subscriptionClient = SubscriptionClient.CreateFromConnectionString(this.serviceBusConnectionString, this.topicName, subscription);
this.subscriptionClient.RetryPolicy = RetryPolicy.Default;
}
}
private void btnCreateDelete_Click(object sender, EventArgs e)
{
try
{
if (serviceBusHelper == null ||
subscriptionWrapper == null ||
subscriptionWrapper.TopicDescription == null)
{
return;
}
if (btnCreateDelete.Text == DeleteText &&
subscriptionWrapper.SubscriptionDescription != null &&
!string.IsNullOrWhiteSpace(subscriptionWrapper.SubscriptionDescription.Name))
{
using (var deleteForm = new DeleteForm(subscriptionWrapper.SubscriptionDescription.Name, SubscriptionEntity.ToLower()))
{
if (deleteForm.ShowDialog() == DialogResult.OK)
{
serviceBusHelper.DeleteSubscription(subscriptionWrapper.SubscriptionDescription);
}
}
return;
}
if (btnCreateDelete.Text == CreateText)
{
if (string.IsNullOrWhiteSpace(txtName.Text))
{
writeToLog(NameCannotBeNull);
return;
}
var subscriptionDescription = new SubscriptionDescription(subscriptionWrapper.TopicDescription.Path, txtName.Text);
if (!string.IsNullOrWhiteSpace(txtUserMetadata.Text))
{
subscriptionDescription.UserMetadata = txtUserMetadata.Text;
}
if (!string.IsNullOrWhiteSpace(txtForwardTo.Text))
{
subscriptionDescription.ForwardTo = txtForwardTo.Text;
}
if (!string.IsNullOrWhiteSpace(txtForwardDeadLetteredMessagesTo.Text))
{
subscriptionDescription.ForwardDeadLetteredMessagesTo = txtForwardDeadLetteredMessagesTo.Text;
}
if (!string.IsNullOrWhiteSpace(txtMaxDeliveryCount.Text))
{
int value;
if (int.TryParse(txtMaxDeliveryCount.Text, out value))
{
subscriptionDescription.MaxDeliveryCount = value;
}
else
{
writeToLog(MaxDeliveryCountMustBeANumber);
return;
}
}
var days = 0;
var hours = 0;
var minutes = 0;
var seconds = 0;
var milliseconds = 0;
if (!string.IsNullOrWhiteSpace(txtDefaultMessageTimeToLiveDays.Text) ||
!string.IsNullOrWhiteSpace(txtDefaultMessageTimeToLiveHours.Text) ||
!string.IsNullOrWhiteSpace(txtDefaultMessageTimeToLiveMinutes.Text) ||
!string.IsNullOrWhiteSpace(txtDefaultMessageTimeToLiveSeconds.Text) ||
!string.IsNullOrWhiteSpace(txtDefaultMessageTimeToLiveMilliseconds.Text))
{
if (!string.IsNullOrWhiteSpace(txtDefaultMessageTimeToLiveDays.Text))
{
if (!int.TryParse(txtDefaultMessageTimeToLiveDays.Text, out days))
{
writeToLog(DefaultMessageTimeToLiveDaysMustBeANumber);
return;
}
}
if (!string.IsNullOrWhiteSpace(txtDefaultMessageTimeToLiveHours.Text))
{
if (!int.TryParse(txtDefaultMessageTimeToLiveHours.Text, out hours))
{
writeToLog(DefaultMessageTimeToLiveHoursMustBeANumber);
return;
}
}
if (!string.IsNullOrWhiteSpace(txtDefaultMessageTimeToLiveMinutes.Text))
{
if (!int.TryParse(txtDefaultMessageTimeToLiveMinutes.Text, out minutes))
{
writeToLog(DefaultMessageTimeToLiveMinutesMustBeANumber);
return;
}
}
if (!string.IsNullOrWhiteSpace(txtDefaultMessageTimeToLiveSeconds.Text))
{
if (!int.TryParse(txtDefaultMessageTimeToLiveSeconds.Text, out seconds))
{
writeToLog(DefaultMessageTimeToLiveSecondsMustBeANumber);
return;
}
}
if (!string.IsNullOrWhiteSpace(txtDefaultMessageTimeToLiveMilliseconds.Text))
{
if (!int.TryParse(txtDefaultMessageTimeToLiveMilliseconds.Text, out milliseconds))
{
writeToLog(DefaultMessageTimeToLiveMillisecondsMustBeANumber);
return;
}
}
subscriptionDescription.DefaultMessageTimeToLive = new TimeSpan(days, hours, minutes, seconds, milliseconds);
}
days = 0;
hours = 0;
minutes = 0;
seconds = 0;
milliseconds = 0;
if (!string.IsNullOrWhiteSpace(txtLockDurationDays.Text) ||
!string.IsNullOrWhiteSpace(txtLockDurationHours.Text) ||
!string.IsNullOrWhiteSpace(txtLockDurationMinutes.Text) ||
!string.IsNullOrWhiteSpace(txtLockDurationSeconds.Text) ||
!string.IsNullOrWhiteSpace(txtLockDurationMilliseconds.Text))
{
if (!string.IsNullOrWhiteSpace(txtLockDurationDays.Text))
{
if (!int.TryParse(txtLockDurationDays.Text, out days))
{
writeToLog(LockDurationDaysMustBeANumber);
return;
}
}
if (!string.IsNullOrWhiteSpace(txtLockDurationHours.Text))
{
if (!int.TryParse(txtLockDurationHours.Text, out hours))
{
writeToLog(LockDurationHoursMustBeANumber);
return;
}
}
if (!string.IsNullOrWhiteSpace(txtLockDurationMinutes.Text))
{
if (!int.TryParse(txtLockDurationMinutes.Text, out minutes))
{
writeToLog(LockDurationMinutesMustBeANumber);
return;
}
}
if (!string.IsNullOrWhiteSpace(txtLockDurationSeconds.Text))
{
if (!int.TryParse(txtLockDurationSeconds.Text, out seconds))
{
writeToLog(LockDurationSecondsMustBeANumber);
return;
}
}
if (!string.IsNullOrWhiteSpace(txtLockDurationMilliseconds.Text))
{
if (!int.TryParse(txtLockDurationMilliseconds.Text, out milliseconds))
{
writeToLog(LockDurationMillisecondsMustBeANumber);
return;
}
}
subscriptionDescription.LockDuration = new TimeSpan(days, hours, minutes, seconds, milliseconds);
}
days = 0;
hours = 0;
minutes = 0;
seconds = 0;
milliseconds = 0;
if (!string.IsNullOrWhiteSpace(txtAutoDeleteOnIdleDays.Text) ||
!string.IsNullOrWhiteSpace(txtAutoDeleteOnIdleHours.Text) ||
!string.IsNullOrWhiteSpace(txtAutoDeleteOnIdleMinutes.Text) ||
!string.IsNullOrWhiteSpace(txtAutoDeleteOnIdleSeconds.Text) ||
!string.IsNullOrWhiteSpace(txtAutoDeleteOnIdleMilliseconds.Text))
{
if (!string.IsNullOrWhiteSpace(txtAutoDeleteOnIdleDays.Text))
{
if (!int.TryParse(txtAutoDeleteOnIdleDays.Text, out days))
{
writeToLog(AutoDeleteOnIdleDaysMustBeANumber);
return;
}
}
if (!string.IsNullOrWhiteSpace(txtAutoDeleteOnIdleHours.Text))
{
if (!int.TryParse(txtAutoDeleteOnIdleHours.Text, out hours))
{
writeToLog(AutoDeleteOnIdleHoursMustBeANumber);
return;
}
}
if (!string.IsNullOrWhiteSpace(txtAutoDeleteOnIdleMinutes.Text))
{
if (!int.TryParse(txtAutoDeleteOnIdleMinutes.Text, out minutes))
{
writeToLog(AutoDeleteOnIdleMinutesMustBeANumber);
return;
}
}
if (!string.IsNullOrWhiteSpace(txtAutoDeleteOnIdleSeconds.Text))
{
if (!int.TryParse(txtAutoDeleteOnIdleSeconds.Text, out seconds))
{
writeToLog(AutoDeleteOnIdleSecondsMustBeANumber);
return;
}
}
if (!string.IsNullOrWhiteSpace(txtAutoDeleteOnIdleMilliseconds.Text))
{
if (!int.TryParse(txtAutoDeleteOnIdleMilliseconds.Text, out milliseconds))
{
writeToLog(AutoDeleteOnIdleMillisecondsMustBeANumber);
return;
}
}
subscriptionDescription.AutoDeleteOnIdle = new TimeSpan(days, hours, minutes, seconds, milliseconds);
}
subscriptionDescription.EnableBatchedOperations = checkedListBox.GetItemChecked(EnableBatchedOperationsIndex);
subscriptionDescription.EnableDeadLetteringOnFilterEvaluationExceptions = checkedListBox.GetItemChecked(EnableDeadLetteringOnFilterEvaluationExceptionsIndex);
subscriptionDescription.EnableDeadLetteringOnMessageExpiration = checkedListBox.GetItemChecked(EnableDeadLetteringOnMessageExpirationIndex);
subscriptionDescription.RequiresSession = checkedListBox.GetItemChecked(RequiresSessionIndex);
var ruleDescription = new RuleDescription();
if (!string.IsNullOrWhiteSpace(txtFilter.Text))
{
ruleDescription.Filter = new SqlFilter(txtFilter.Text);
}
if (!string.IsNullOrWhiteSpace(txtAction.Text))
{
ruleDescription.Action = new SqlRuleAction(txtAction.Text);
}
subscriptionWrapper.SubscriptionDescription = serviceBusHelper.CreateSubscription(subscriptionWrapper.TopicDescription,
subscriptionDescription,
ruleDescription);
InitializeData();
}
}
catch (Exception ex)
{
HandleException(ex);
}
}
private static void SetupEntities(SampleScenario scenario)
{
switch (scenario)
{
case SampleScenario.Duplicate:
if (!nsm.QueueExists(DUPLICATE_QUEUE))
{
nsm.CreateQueue(new QueueDescription(DUPLICATE_QUEUE)
{
RequiresDuplicateDetection = true,
DuplicateDetectionHistoryTimeWindow = new TimeSpan(0, 0, 30)
}
);
}
break;
case SampleScenario.AutoForward:
string oldQueue = "oldqueue";
if (!nsm.QueueExists(oldQueue))
{
nsm.CreateQueue(new QueueDescription(oldQueue)
{
ForwardTo = "dupequeue"
}
);
}
break;
case SampleScenario.SubscriptionActions:
if (!nsm.TopicExists(ACTIONS_TOPIC))
{
var td = nsm.CreateTopic(ACTIONS_TOPIC);
var sd = new SubscriptionDescription(ACTIONS_TOPIC, ACTIONS_SUBSCRIPTION);
var sc = SubscriptionClient.Create(ACTIONS_TOPIC, ACTIONS_SUBSCRIPTION);
nsm.CreateSubscription(sd);
var rules = nsm.GetRules(ACTIONS_TOPIC, ACTIONS_SUBSCRIPTION);
foreach (var rule in rules)
sc.RemoveRule(rule.Name);
var rd = new RuleDescription("default",
new SqlFilter("NOT EXISTS(stage)"))
{ Action = new SqlRuleAction("set stage = 1") };
sc.AddRule(rd);
}
break;
default:
break;
}
}
/// <summary>
/// Adds a subscription to this topic, with a default pass-through filter added.
/// </summary>
/// <param name="topicDescription">A topic belonging to the current service namespace base.</param>
/// <param name="subscriptionDescription">Metadata of the subscription to be created.</param>
/// <param name="ruleDescription">The metadata describing the properties of the rule to be associated with the subscription.</param>
/// <returns>Returns a newly-created SubscriptionDescription object.</returns>
public SubscriptionDescription CreateSubscription(TopicDescription topicDescription,
SubscriptionDescription subscriptionDescription,
RuleDescription ruleDescription)
{
if (topicDescription == null)
{
throw new ArgumentException(TopicDescriptionCannotBeNull);
}
if (subscriptionDescription == null)
{
throw new ArgumentException(DescriptionCannotBeNull);
}
if (ruleDescription == null)
{
throw new ArgumentException(RuleDescriptionCannotBeNull);
}
var subscription = RetryHelper.RetryFunc(() => namespaceManager.CreateSubscription(subscriptionDescription, ruleDescription), writeToLog);
WriteToLogIf(traceEnabled, string.Format(CultureInfo.CurrentCulture, SubscriptionCreated, subscription.Name, topicDescription.Path));
OnCreate(new ServiceBusHelperEventArgs(new SubscriptionWrapper(subscription, topicDescription), EntityType.Subscription));
return subscription;
}
/// <summary>
/// Removes the rule passed as a argument.
/// </summary>
/// <param name="subscriptionDescription">A subscription belonging to the current service namespace base.</param>
/// <param name="rule">The rule to remove.</param>
public void RemoveRule(SubscriptionDescription subscriptionDescription, RuleDescription rule)
{
if (subscriptionDescription == null)
{
throw new ArgumentException(SubscriptionDescriptionCannotBeNull);
}
if (rule == null)
{
throw new ArgumentException(RuleCannotBeNull);
}
var subscriptionClient = MessagingFactory.CreateSubscriptionClient(subscriptionDescription.TopicPath,
subscriptionDescription.Name);
RetryHelper.RetryAction(() => subscriptionClient.RemoveRule(rule.Name), writeToLog);
WriteToLogIf(traceEnabled, string.Format(CultureInfo.CurrentCulture, RuleDeleted, rule.Name, subscriptionClient.Name));
OnDelete(new ServiceBusHelperEventArgs(new RuleWrapper(rule, subscriptionDescription), EntityType.Rule));
}
/// <summary>
/// Adds a rule to this subscription, with a default pass-through filter added.
/// </summary>
/// <param name="subscriptionDescription">The subscription to add the rule to.</param>
/// <param name="ruleDescription">Metadata of the rule to be created.</param>
/// <returns>Returns a newly-created RuleDescription object.</returns>
public RuleDescription AddRule(SubscriptionDescription subscriptionDescription, RuleDescription ruleDescription)
{
if (subscriptionDescription == null)
{
throw new ArgumentException(SubscriptionDescriptionCannotBeNull);
}
if (ruleDescription == null)
{
throw new ArgumentException(RuleDescriptionCannotBeNull);
}
var subscriptionClient = RetryHelper.RetryFunc(() => MessagingFactory.CreateSubscriptionClient(subscriptionDescription.TopicPath,
subscriptionDescription.Name),
writeToLog);
RetryHelper.RetryAction(() => subscriptionClient.AddRule(ruleDescription), writeToLog);
Func<IEnumerable<RuleDescription>> func = (() => namespaceManager.GetRules(subscriptionDescription.TopicPath, subscriptionDescription.Name));
var rules = RetryHelper.RetryFunc(func, writeToLog);
var rule = rules.FirstOrDefault(r => r.Name == ruleDescription.Name);
WriteToLogIf(traceEnabled, string.Format(CultureInfo.CurrentCulture, RuleCreated, ruleDescription.Name, subscriptionDescription.Name));
OnCreate(new ServiceBusHelperEventArgs(new RuleWrapper(rule, subscriptionDescription), EntityType.Rule));
return rule;
}
private Rule MapRule(RuleDescription r)
{
if (r.Filter is SqlFilter)
{
return new Rule
{
Name = r.Name,
FilterType = "SqlFilter",
Text = (r.Filter as SqlFilter).SqlExpression,
CreatedAt = r.CreatedAt
};
}
if (r.Filter is CorrelationFilter)
{
return new Rule
{
Name = r.Name,
FilterType = "CorrelationFilter",
Text = "TODO",
CreatedAt = r.CreatedAt
};
}
return new Rule
{
Name = r.Name,
CreatedAt = r.CreatedAt,
Text = "Unknown",
FilterType = "UnknownFilterType"
};
}
/// <summary>
/// Initializes a new instance of the RuleWrapper class.
/// </summary>
/// <param name="rule">A rule.</param>
/// <param name="subscription">A subscription.</param>
public RuleWrapper(RuleDescription rule, SubscriptionDescription subscription)
{
RuleDescription = rule;
SubscriptionDescription = subscription;
}
private static void TryAddRule(SubscriptionClient client, RuleDescription rule)
{
// try / catch is because there could be other processes initializing at the same time.
try
{
client.AddRule(rule);
}
catch (MessagingEntityAlreadyExistsException) { }
}
