public static async Task Stage(string connectionString, string destination)
{
var client = new ServiceBusAdministrationClient(connectionString);
if (await client.QueueExistsAsync(destination))
{
await client.DeleteQueueAsync(destination);
}
var queueDescription = new CreateQueueOptions(destination)
{
RequiresDuplicateDetection = true,
DuplicateDetectionHistoryTimeWindow = TimeSpan.FromSeconds(20)
};
await client.CreateQueueAsync(queueDescription);
}
public static async Task Stage(string connectionString, string destination)
{
var client = new ServiceBusAdministrationClient(connectionString);
if (await client.QueueExistsAsync(destination))
{
await client.DeleteQueueAsync(destination);
}
var description = new CreateQueueOptions(destination)
{
DeadLetteringOnMessageExpiration = true, // default false
MaxDeliveryCount = 1
};
await client.CreateQueueAsync(description);
}
private void Initialise()
{
s_logger.LogDebug("Initialising new management client wrapper...");
try
{
_administrationClient = _clientProvider.GetServiceBusAdministrationClient();
}
catch (Exception e)
{
s_logger.LogError(e, "Failed to initialise new management client wrapper.");
throw;
}
s_logger.LogDebug("New management client wrapper initialised.");
}
/// <summary>
///
/// </summary>
/// <param name="serviceScopeFactory"></param>
/// <param name="busOptionsAccessor"></param>
/// <param name="transportOptionsAccessor"></param>
/// <param name="loggerFactory"></param>
public AzureServiceBusTransport(IServiceScopeFactory serviceScopeFactory,
IOptions <EventBusOptions> busOptionsAccessor,
IOptions <AzureServiceBusTransportOptions> transportOptionsAccessor,
ILoggerFactory loggerFactory)
: base(serviceScopeFactory, busOptionsAccessor, transportOptionsAccessor, loggerFactory)
{
var connectionString = TransportOptions.ConnectionString;
managementClient = new ServiceBusAdministrationClient(connectionString);
var sbcOptions = new ServiceBusClientOptions {
TransportType = TransportOptions.TransportType,
};
serviceBusClient = new ServiceBusClient(connectionString, sbcOptions);
}
public AzureServiceBusEventBus(EventBusConfiguration eventBusConfiguration,
IServiceProvider serviceProvider,
IEventBusSubscriptionsManager subscriptionManager,
ILogger <AzureServiceBusEventBus> logger,
ServiceBusSender serviceBusSender,
ServiceBusProcessor serviceBusReceiver,
ServiceBusAdministrationClient serviceBusAdministrationClient)
{
_eventBusConfiguration = eventBusConfiguration ?? throw new ArgumentNullException(nameof(eventBusConfiguration));
_serviceProvider = serviceProvider ?? throw new ArgumentNullException(nameof(serviceProvider));
_subscriptionManager = subscriptionManager ?? throw new ArgumentNullException(nameof(subscriptionManager));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_serviceBusSender = serviceBusSender ?? throw new ArgumentNullException(nameof(serviceBusSender));
_serviceBusReceiver = serviceBusReceiver ?? throw new ArgumentNullException(nameof(serviceBusReceiver));
_serviceBusAdministrationClient = serviceBusAdministrationClient
?? throw new ArgumentNullException(nameof(serviceBusAdministrationClient));
}
public async Task CreateQueue()
{
#if !SNIPPET
string queueName = Guid.NewGuid().ToString("D").Substring(0, 8);
string connectionString = TestEnvironment.ServiceBusConnectionString;
#endif
try
{
#region Snippet:CreateQueue
#if SNIPPET
string connectionString = "<connection_string>";
string queueName = "<queue_name>";
#endif
var client = new ServiceBusAdministrationClient(connectionString);
var options = new CreateQueueOptions(queueName)
{
AutoDeleteOnIdle = TimeSpan.FromDays(7),
DefaultMessageTimeToLive = TimeSpan.FromDays(2),
DuplicateDetectionHistoryTimeWindow = TimeSpan.FromMinutes(1),
EnableBatchedOperations = true,
DeadLetteringOnMessageExpiration = true,
EnablePartitioning = false,
ForwardDeadLetteredMessagesTo = null,
ForwardTo = null,
LockDuration = TimeSpan.FromSeconds(45),
MaxDeliveryCount = 8,
MaxSizeInMegabytes = 2048,
RequiresDuplicateDetection = true,
RequiresSession = true,
UserMetadata = "some metadata"
};
options.AuthorizationRules.Add(new SharedAccessAuthorizationRule(
"allClaims",
new[] { AccessRights.Manage, AccessRights.Send, AccessRights.Listen }));
QueueProperties createdQueue = await client.CreateQueueAsync(options);
#endregion
Assert.AreEqual(options, new CreateQueueOptions(createdQueue));
}
finally
{
await new ServiceBusAdministrationClient(connectionString).DeleteQueueAsync(queueName);
}
}
public static Task Create(ServiceBusAdministrationClient client, CommandArgument endpointName, CommandOption topicName, CommandOption subscriptionName)
{
var topicNameToUse = topicName.HasValue() ? topicName.Value() : Topic.DefaultTopicName;
var subscriptionNameToUse = subscriptionName.HasValue() ? subscriptionName.Value() : endpointName.Value;
var options = new CreateSubscriptionOptions(topicNameToUse, subscriptionNameToUse)
{
LockDuration = TimeSpan.FromMinutes(5),
ForwardTo = endpointName.Value,
EnableDeadLetteringOnFilterEvaluationExceptions = false,
MaxDeliveryCount = int.MaxValue,
EnableBatchedOperations = true,
UserMetadata = endpointName.Value
};
return(client.CreateSubscriptionAsync(options, new CreateRuleOptions("$default", new FalseRuleFilter())));
}
private void CreateTopicAndSubscriptions(string topicName, string[] subscriptions)
{
var busAdmin = new ServiceBusAdministrationClient(Connections.ServiceBusConnectionString);
if (!busAdmin.TopicExistsAsync(topicName).Result.Value)
{
busAdmin.CreateTopicAsync(topicName).Wait();
}
foreach (var subscription in subscriptions)
{
if (!busAdmin.SubscriptionExistsAsync(topicName, subscription).Result.Value)
{
busAdmin.CreateSubscriptionAsync(topicName, subscription).Wait();
}
}
}
private static async Task SendRequestMessageWithResponse()
{
const string requestQueue = "sbq-request-queue";
const string responseQueue = "sbq-response-queue";
var managementClient = new ServiceBusAdministrationClient(Config.Namespace, Config.Credential);
if (!await managementClient.QueueExistsAsync(requestQueue))
{
await managementClient.CreateQueueAsync(requestQueue);
}
if (!await managementClient.QueueExistsAsync(responseQueue))
{
var createQueueOptions = new CreateQueueOptions(responseQueue)
{
RequiresSession = true
};
await managementClient.CreateQueueAsync(createQueueOptions);
}
var responseSessionId = Guid.NewGuid().ToString();
await using var requestClient = new ServiceBusClient(Config.Namespace, Config.Credential);
var sender = requestClient.CreateSender(requestQueue);
var message = new ServiceBusMessage(Encoding.UTF8.GetBytes("This is a simple test message"))
{
ReplyToSessionId = responseSessionId
};
Console.WriteLine("Press any key to send a message. Press Enter to exit.");
await using var responseClient = new ServiceBusClient(Config.Namespace, Config.Credential);
var serviceBusSessionProcessorOptions = new ServiceBusSessionProcessorOptions();
serviceBusSessionProcessorOptions.SessionIds.Add(responseSessionId);
var sessionProcessor = responseClient.CreateSessionProcessor(responseQueue, serviceBusSessionProcessorOptions);
sessionProcessor.ProcessMessageAsync += MessageHandler;
sessionProcessor.ProcessErrorAsync += ErrorHandler;
async Task <long> GetMessageCount(bool deadLetterQueueData)
{
var client = new ServiceBusAdministrationClient(serviceBusHelper.ConnectionString);
if (deadLetterQueueData)
{
if (queueProperties != null)
{
var runtimeInfoResponse = await client.GetQueueRuntimePropertiesAsync(queueProperties.Name)
.ConfigureAwait(false);
return(runtimeInfoResponse.Value.DeadLetterMessageCount);
}
else
{
var runtimeInfoResponse = await client.GetSubscriptionRuntimePropertiesAsync(
subscriptionProperties.TopicName,
subscriptionProperties.SubscriptionName)
.ConfigureAwait(false);
return(runtimeInfoResponse.Value.DeadLetterMessageCount);
}
}
else
{
if (queueProperties != null)
{
var runtimeInfo = await client.GetQueueRuntimePropertiesAsync(queueProperties.Name)
.ConfigureAwait(false);
return(runtimeInfo.Value.ActiveMessageCount);
}
else
{
var runtimeInfo = await client.GetSubscriptionRuntimePropertiesAsync(
subscriptionProperties.TopicName,
subscriptionProperties.SubscriptionName)
.ConfigureAwait(false);
return(runtimeInfo.Value.ActiveMessageCount);
}
}
}
public static async Task <TopicProperties> CreateTopicAsync(string topicName, string connectionString)
{
var client = new ServiceBusAdministrationClient(connectionString);
var topicOptions = new CreateTopicOptions(topicName)
{
DefaultMessageTimeToLive = TimeSpan.FromDays(2),
DuplicateDetectionHistoryTimeWindow = TimeSpan.FromMinutes(1),
EnableBatchedOperations = true,
EnablePartitioning = false,
MaxSizeInMegabytes = 2048,
UserMetadata = "some metadata"
};
topicOptions.AuthorizationRules.Add(new SharedAccessAuthorizationRule(
"allClaims",
new[] { AccessRights.Manage, AccessRights.Send, AccessRights.Listen }));
return(await client.CreateTopicAsync(topicOptions));
}
protected async override Task <long> GetMessageCount(QueueProperties entity, bool deadLetterQueueData)
{
var client = new ServiceBusAdministrationClient(serviceBusHelper.ConnectionString);
if (deadLetterQueueData)
{
var runtimeInfoResponse = await client.GetQueueRuntimePropertiesAsync(entity.Name)
.ConfigureAwait(false);
return(runtimeInfoResponse.Value.DeadLetterMessageCount);
}
else
{
var runtimeInfo = await client.GetQueueRuntimePropertiesAsync(entity.Name)
.ConfigureAwait(false);
return(runtimeInfo.Value.ActiveMessageCount);
}
}
public static async Task ReportNumberOfMessages(string connectionString, string destination)
{
var client = new ServiceBusAdministrationClient(connectionString);
QueueRuntimeProperties info = await client.GetQueueRuntimePropertiesAsync(destination);
long activeMessageCount = info.ActiveMessageCount;
long deadLetterMessageCount = info.DeadLetterMessageCount;
long transferDeadLetterMessageCount = info.TransferDeadLetterMessageCount;
string destinationDeadLetterPath = EntityNameHelper.FormatDeadLetterPath(destination);
string destinationTransferDeadLetterPath = EntityNameHelper.FormatTransferDeadLetterPath(destination);
Console.WriteLine($"#'{activeMessageCount}' messages in '{destination}'");
Console.WriteLine(
$"#'{deadLetterMessageCount}' messages in '{destinationDeadLetterPath}'");
Console.WriteLine(
$"#'{transferDeadLetterMessageCount}' messages in '{destinationTransferDeadLetterPath}'");
}
public async Task StopAsync(CancellationToken cancellationToken)
{
var logs = _host.GetTestLoggerProvider().GetAllLogMessages();
var errors = logs.Where(
p => p.Level == LogLevel.Error &&
// Ignore this error that the SDK logs when cancelling batch receive
!p.FormattedMessage.Contains("ReceiveBatchAsync Exception: System.Threading.Tasks.TaskCanceledException"));
Assert.IsEmpty(errors, string.Join(",", errors.Select(e => e.FormattedMessage)));
var client = new ServiceBusAdministrationClient(ServiceBusTestEnvironment.Instance.ServiceBusConnectionString);
// wait for a few seconds to allow updated counts to propagate
await Task.Delay(TimeSpan.FromSeconds(2));
QueueRuntimeProperties properties = await client.GetQueueRuntimePropertiesAsync(WebJobsServiceBusTestBase._firstQueueScope.QueueName, CancellationToken.None);
Assert.AreEqual(0, properties.TotalMessageCount);
}
public async Task SetupAsync(IHost host)
{
using var scope = host.Services.CreateScope();
var referenceFactory = scope.ServiceProvider.GetRequiredService <IQueueReferenceFactory>();
var policy = referenceFactory.Create <TM>();
var azureConfig = scope.ServiceProvider.GetRequiredService <AzureServiceBusConfiguration>();
var adminClient = new ServiceBusAdministrationClient(azureConfig.ConnectionString);
if (!(await adminClient.TopicExistsAsync(policy.TopicName)))
{
await adminClient.CreateTopicAsync(policy.TopicName);
}
if (!(await adminClient.SubscriptionExistsAsync(policy.TopicName, policy.SubscriptionName)))
{
await adminClient.CreateSubscriptionAsync(policy.TopicName, policy.SubscriptionName);
}
}
public ServiceBusQueue(string connectionString, string topicName, string subscription, ServiceBusReceiveMode receiveMode = ServiceBusReceiveMode.PeekLock, bool createQueueIfItDoesNotExist = true)
: base(connectionString)
{
this.connectionString = connectionString;
this.queueName = topicName;
this.topicName = topicName;
this.subscription = subscription;
this.receiveMode = receiveMode;
this.SubQueue = SubQueue.None;
busAdmin = new ServiceBusAdministrationClient(this.connectionString);
if (createQueueIfItDoesNotExist && !busAdmin.TopicExistsAsync(topicName).Result.Value)
{
busAdmin.CreateTopicAsync(topicName).Wait();
}
if (createQueueIfItDoesNotExist && !string.IsNullOrEmpty(subscription) && !busAdmin.SubscriptionExistsAsync(topicName, subscription).Result.Value)
{
busAdmin.CreateSubscriptionAsync(topicName, subscription).Wait();
}
}
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 SendComplexObjectMessage()
{
const string queueName = "sbq-complex-object-message";
var managementClient = new ServiceBusAdministrationClient(Config.Namespace, Config.Credential);
if (!await managementClient.QueueExistsAsync(queueName))
{
await managementClient.CreateQueueAsync(queueName);
}
await using var client = new ServiceBusClient(Config.Namespace, Config.Credential);
var sender = client.CreateSender(queueName);
var payment = new Payment
{
PaymentId = Guid.NewGuid(),
AccountNumber = "132456789",
Amount = 1337m,
PaymentDate = DateTime.Today.AddDays(1),
Payee = "Mr John Smith"
};
var message = new ServiceBusMessage(JsonSerializer.SerializeToUtf8Bytes(payment));
Console.WriteLine("Press any key to send a message. Press Enter to exit.");
while (Console.ReadKey(true).Key != ConsoleKey.Enter)
{
await sender.SendMessageAsync(message);
Console.WriteLine($"Message Sent for {nameof(SendComplexObjectMessage)}");
}
Console.ReadLine();
await managementClient.DeleteQueueAsync(queueName);
}
private static async Task SendTextMessageWithProperties()
{
const string queueName = "sbq-text-message-with-properties";
var managementClient = new ServiceBusAdministrationClient(Config.Namespace, Config.Credential);
if (!await managementClient.QueueExistsAsync(queueName))
{
await managementClient.CreateQueueAsync(queueName);
}
await using var client = new ServiceBusClient(Config.Namespace, Config.Credential);
var sender = client.CreateSender(queueName);
var message = new ServiceBusMessage
{
Body = new BinaryData("This is a simple test message"),
ContentType = "text/plain",
CorrelationId = Guid.NewGuid().ToString(),
MessageId = Guid.NewGuid().ToString(),
TimeToLive = TimeSpan.FromMinutes(10),
ScheduledEnqueueTime = DateTime.UtcNow,
ApplicationProperties = { { "custom-property", "Custom Value" } }
};
Console.WriteLine("Press any key to send a message. Press Enter to exit.");
while (Console.ReadKey(true).Key != ConsoleKey.Enter)
{
await sender.SendMessageAsync(message);
Console.WriteLine($"Message Sent for {nameof(SendTextMessageWithProperties)}");
}
Console.ReadLine();
await managementClient.DeleteQueueAsync(queueName);
}
public static async Task CreateQueueFromOptionsAsync(ServiceBusOptions options, string queueName)
{
var adminClient = new ServiceBusAdministrationClient(options.ConnectionString);
try
{
await adminClient.CreateQueueAsync(new CreateQueueOptions(queueName)
{
EnablePartitioning = true,
RequiresSession = false,
EnableBatchedOperations = true,
AutoDeleteOnIdle = options.QueueTtl,
DefaultMessageTimeToLive = options.MessageTtl,
MaxSizeInMegabytes = options.MaxQueueSizeMegabytes
});
}
catch (ServiceBusException exception)
when(exception.Reason == ServiceBusFailureReason.MessagingEntityAlreadyExists)
{
// Ignore
}
}
public MessageBusTestsBase()
{
var options = new ServiceBusClientOptions
{
RetryOptions = new()
{
MaxRetries = 10,
Mode = ServiceBusRetryMode.Exponential,
MaxDelay = TimeSpan.FromSeconds(10)
}
};
_serviceBusClient = new ServiceBusClient(Configuration["ConnectionString"], options);
_serviceBusAdminClient = new ServiceBusAdministrationClient(Configuration["ConnectionString"]);
_tenantId = Configuration["TenantId"];
_topic = Configuration["Topic"];
_hostname = Configuration["Hostname"];
_connectionString = Configuration["ConnectionString"];
_serviceBusSender = _serviceBusClient.CreateSender(_topic);
var serviceBusAdminClient = new ServiceBusAdministrationClient(_connectionString);
serviceBusAdminClient.CreateSubscriptionAsync(new(_topic, _subscription));
}
public async Task <Dictionary <string, QueueDetail> > GetAllQueueDetails()
{
var dict = new Dictionary <string, QueueDetail>();
var administrationClient = new ServiceBusAdministrationClient(connectionString);
var queuesRuntimeProperties = administrationClient.GetQueuesRuntimePropertiesAsync().AsPages();
await foreach (var queuePage in queuesRuntimeProperties)
{
foreach (QueueRuntimeProperties currentQueue in queuePage.Values)
{
dict.Add(
currentQueue.Name,
new QueueDetail
{
ActiveMessageCount = currentQueue.ActiveMessageCount,
TotalMessageCount = currentQueue.TotalMessageCount,
DeadLetterMessageCount = currentQueue.DeadLetterMessageCount,
});
}
}
return(dict);
}
private async Task RemoveDefaultFilters()
{
Console.WriteLine($"Starting to remove default filters.");
try
{
var client = new ServiceBusAdministrationClient(ServiceBusConnectionString);
foreach (var subscription in Subscriptions)
{
await client.DeleteRuleAsync(TopicName, subscription, CreateRuleOptions.DefaultRuleName);
Console.WriteLine($"Default filter for {subscription} has been removed.");
}
Console.WriteLine("All default Rules have been removed.\n");
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
await PresentMenu();
}
public async Task SetupAsync(IHost host)
{
using var scope = host.Services.CreateScope();
var referenceFactory = scope.ServiceProvider.GetRequiredService <IQueueReferenceFactory>();
var policy = referenceFactory.Create <TM>();
var azureConfig = scope.ServiceProvider.GetRequiredService <AzureServiceBusConfiguration>();
var adminClient = new ServiceBusAdministrationClient(azureConfig.ConnectionString);
try
{
if (!await adminClient.TopicExistsAsync(policy.TopicName))
{
await adminClient.CreateTopicAsync(new CreateTopicOptions(policy.TopicName)
{
RequiresDuplicateDetection = true
});
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
try
{
if (!await adminClient.SubscriptionExistsAsync(policy.TopicName, policy.SubscriptionName))
{
await adminClient.CreateSubscriptionAsync(policy.TopicName, policy.SubscriptionName);
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
public async Task <HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default)
{
try
{
var connectionKey = $"{_connectionString}_{_topicName}_{_subscriptionName}";
if (!_managementClientConnections.TryGetValue(connectionKey, out var managementClient))
{
managementClient = new ServiceBusAdministrationClient(_connectionString);
if (!_managementClientConnections.TryAdd(connectionKey, managementClient))
{
return(new HealthCheckResult(context.Registration.FailureStatus, description:
"New service bus administration client connection can't be added into dictionary."));
}
}
_ = await managementClient.GetSubscriptionRuntimePropertiesAsync(_topicName, _subscriptionName, cancellationToken);
return(HealthCheckResult.Healthy());
}
catch (Exception ex)
{
return(new HealthCheckResult(context.Registration.FailureStatus, exception: ex));
}
}
private async Task CleanUpCustomFilters()
{
foreach (var subscription in Subscriptions)
{
try
{
var client = new ServiceBusAdministrationClient(ServiceBusConnectionString);
IAsyncEnumerator <RuleProperties> rules = client.GetRulesAsync(TopicName, subscription).GetAsyncEnumerator();
while (await rules.MoveNextAsync())
{
await client.DeleteRuleAsync(TopicName, subscription, rules.Current.Name);
Console.WriteLine($"Rule {rules.Current.Name} has been removed.");
}
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
}
Console.WriteLine("All default filters have been removed.\n");
await PresentMenu();
}
static async Task LeaveStage(string connectionString, string destination)
{
var client = new ServiceBusAdministrationClient(connectionString);
await client.DeleteQueueAsync(destination);
}
public ServiceBusAdministrationClient CreateAdminstrativeConnection()
{
ServiceBusAdministrationClient serviceBusAdministrationClient = new ServiceBusAdministrationClient(azureOptions.Value.ConnectionString);
return(serviceBusAdministrationClient);
}
public async Task DisposeAsync()
{
var adminClient = new ServiceBusAdministrationClient(_sbFixture.Configuration.ConnectionString);
await adminClient.DeleteTopicAsync(_topicName);
}
public static async Task <QueueScope> CreateWithQueue(ServiceBusAdministrationClient adminClient, CreateQueueOptions options)
{
var response = await adminClient.CreateQueueAsync(options).ConfigureAwait(false);
return(new QueueScope(adminClient, options.Name, response.Value));
}
