public static async Task Stage(string connectionString, string inputQueue, string destinationQueue)
{
var client = new ServiceBusAdministrationClient(connectionString);
if (await client.QueueExistsAsync(inputQueue))
{
await client.DeleteQueueAsync(inputQueue);
}
await client.CreateQueueAsync(new CreateQueueOptions(inputQueue) { MaxDeliveryCount = 1 });
if (await client.QueueExistsAsync(destinationQueue))
{
await client.DeleteQueueAsync(destinationQueue);
}
await client.CreateQueueAsync(destinationQueue);
}
private static async Task SendTextMessage()
{
const string queueName = "sbq-text-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 message = new ServiceBusMessage(Encoding.UTF8.GetBytes("This is a simple test message"));
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(SendTextMessage)}");
}
Console.ReadLine();
await managementClient.DeleteQueueAsync(queueName);
}
private static async Task ReceiveTextMessage()
{
const string queueName = "sbq-text-message";
var managementClient = new ServiceBusAdministrationClient(Config.Namespace, Config.Credential);
if (!await managementClient.QueueExistsAsync(queueName))
{
await managementClient.CreateQueueAsync(queueName);
}
Console.WriteLine($"Receiving messages for {nameof(ReceiveTextMessage)}...");
await using var client = new ServiceBusClient(Config.Namespace, Config.Credential);
// get the options to use for configuring the processor
var options = new ServiceBusProcessorOptions
{
// By default after the message handler returns, the processor will complete the message
// If we want more fine-grained control over settlement, we can set this to false.
AutoCompleteMessages = false,
// I can also allow for multi-threading
MaxConcurrentCalls = 2
};
// create a processor that we can use to process the messages
var processor = client.CreateProcessor(queueName, options);
processor.ProcessMessageAsync += MessageHandler;
processor.ProcessErrorAsync += ErrorHandler;
private static async Task <ServiceBusAdministrationClient> Cleanup(string connectionString, string inputQueue,
string topicName, string rushSubscription, string currencySubscription)
{
var client = new ServiceBusAdministrationClient(connectionString);
if (await client.SubscriptionExistsAsync(topicName, rushSubscription))
{
await client.DeleteSubscriptionAsync(topicName, rushSubscription);
}
if (await client.SubscriptionExistsAsync(topicName, currencySubscription))
{
await client.DeleteSubscriptionAsync(topicName, currencySubscription);
}
if (await client.TopicExistsAsync(topicName))
{
await client.DeleteTopicAsync(topicName);
}
var topicDescription = new CreateTopicOptions(topicName);
await client.CreateTopicAsync(topicDescription);
if (await client.QueueExistsAsync(inputQueue))
{
await client.DeleteQueueAsync(inputQueue);
}
var queueDescription = new CreateQueueOptions(inputQueue);
await client.CreateQueueAsync(queueDescription);
return(client);
}
private async Task CreateQueueIfNotExistsAsync(string name, CancellationToken cancellationToken)
{
// if entity creation is not enabled, just return
if (!TransportOptions.EnableEntityCreation)
{
Logger.LogTrace("Entity creation is diabled. Queue creation skipped");
return;
}
// If the queue does not exist, create it
Logger.LogDebug("Checking if queue '{QueueName}' exists", name);
if (!await managementClient.QueueExistsAsync(name: name, cancellationToken: cancellationToken))
{
Logger.LogTrace("Queue '{QueueName}' does not exist, preparing creation.", name);
var options = new CreateQueueOptions(name: name)
{
// set the defaults for a queue here
Status = EntityStatus.Active,
MaxDeliveryCount = 10,
};
// Allow for the defaults to be overriden
TransportOptions.SetupQueueOptions?.Invoke(options);
Logger.LogInformation("Creating queue '{QueueName}'", name);
_ = await managementClient.CreateQueueAsync(options : options, cancellationToken : cancellationToken);
}
}
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;
public async Task StartAsync(CancellationToken cancellationToken)
{
_cancellationToken = cancellationToken;
_client = await _clientFactory.GetReceiverClient <T>(new ServiceBusProcessorOptions
{
AutoCompleteMessages = false,
MaxAutoLockRenewalDuration = Settings.MessageLockTimeout,
MaxConcurrentCalls = Settings.MaxConcurrentCalls,
PrefetchCount = Settings.PrefetchCount,
ReceiveMode = ServiceBusReceiveMode.PeekLock
}).ConfigureAwait(false);
var queueName = AutoMessageMapper.GetQueueName <T>();
if (!await _managementClient.QueueExistsAsync(queueName, _cancellationToken).ConfigureAwait(false))
{
try
{
var serviceBusCreationOptions = GetServiceBusCreationOptions();
await _managementClient.CreateQueueAsync(new CreateQueueOptions(queueName)
{
EnablePartitioning = serviceBusCreationOptions.EnablePartitioning,
EnableBatchedOperations = serviceBusCreationOptions.EnableBatchedOperations
}, cancellationToken).ConfigureAwait(false);
}
catch (ServiceBusException e)
{
_log.Error(e, "Failed to create queue {QueueName}", queueName);
throw;
}
}
_deadLetterLimit = Settings.DeadLetterDeliveryLimit;
_client.ProcessMessageAsync += ClientOnProcessMessageAsync;
_client.ProcessErrorAsync += ClientOnProcessErrorAsync;
await _client.StartProcessingAsync(cancellationToken);
#pragma warning disable 4014
// ReSharper disable once MethodSupportsCancellation
Task.Run(async() =>
{
_cancellationToken.WaitHandle.WaitOne();
//Cancellation requested
try
{
_log.Information($"Closing ServiceBus channel receiver for {typeof(T).Name}");
await _client.CloseAsync(CancellationToken.None);
}
catch (Exception)
{
//Swallow
}
});
#pragma warning restore 4014
}
private void CreateServiceBusQueue(string serviceBusQueueName)
{
var busAdmin = new ServiceBusAdministrationClient(Connections.ServiceBusConnectionString);
if (!busAdmin.QueueExistsAsync(serviceBusQueueName).Result.Value)
{
busAdmin.CreateQueueAsync(serviceBusQueueName).Wait();
}
}
private async Task EnsureQueueExistsAsync(string queueName, CancellationToken cancellationToken)
{
if (await _administrationClient.QueueExistsAsync(queueName, cancellationToken))
{
return;
}
await _administrationClient.CreateQueueAsync(queueName, cancellationToken);
}
public static async Task <IAsyncDisposable> Stage(string connectionString, string destination)
{
var client = new ServiceBusAdministrationClient(connectionString);
if (!await client.QueueExistsAsync(destination))
{
await client.CreateQueueAsync(destination);
}
return(new Leave(connectionString, destination));
}
public static async Task Stage(string connectionString, string destination)
{
var client = new ServiceBusAdministrationClient(connectionString);
if (await client.QueueExistsAsync(destination))
{
await client.DeleteQueueAsync(destination);
}
await client.CreateQueueAsync(destination);
}
async Task CheckPermission(CancellationToken cancellationToken)
{
try
{
await administrativeClient.QueueExistsAsync("$nservicebus-verification-queue", cancellationToken).ConfigureAwait(false);
}
catch (UnauthorizedAccessException e)
{
throw new Exception("Management rights are required to run this endpoint. Verify that the SAS policy has the Manage claim.", e);
}
}
public static async Task Hazard(string connectionString, string destinationQueue)
{
var client = new ServiceBusAdministrationClient(connectionString);
if (await client.QueueExistsAsync(destinationQueue))
{
QueueProperties queueProperties = await client.GetQueueAsync(destinationQueue);
queueProperties.Status = EntityStatus.SendDisabled;
await client.UpdateQueueAsync(queueProperties);
}
}
public static async Task Stage(string connectionString)
{
var client = new ServiceBusAdministrationClient(connectionString);
async Task DeleteIfExists(string queueName)
{
if (await client.QueueExistsAsync(queueName))
{
await client.DeleteQueueAsync(queueName);
}
}
await Task.WhenAll(
DeleteIfExists("Hop4"),
DeleteIfExists("Hop3"),
DeleteIfExists("Hop2"),
DeleteIfExists("Hop1"),
DeleteIfExists("Hop0"),
DeleteIfExists("Hop")
);
var description = new CreateQueueOptions("Hop");
await client.CreateQueueAsync(description);
description = new CreateQueueOptions("Hop0");
await client.CreateQueueAsync(description);
description = new CreateQueueOptions("Hop1")
{
ForwardTo = "Hop0"
};
await client.CreateQueueAsync(description);
description = new CreateQueueOptions("Hop2")
{
ForwardTo = "Hop1"
};
await client.CreateQueueAsync(description);
description = new CreateQueueOptions("Hop3")
{
ForwardTo = "Hop2"
};
await client.CreateQueueAsync(description);
description = new CreateQueueOptions("Hop4")
{
ForwardTo = "Hop3"
};
await client.CreateQueueAsync(description);
}
public ServiceBusQueue(string connectionString, string queueName, ServiceBusReceiveMode receiveMode = ServiceBusReceiveMode.PeekLock, bool createQueueIfItDoesNotExist = true)
: base(connectionString)
{
this.connectionString = connectionString;
this.queueName = queueName;
this.receiveMode = receiveMode;
this.SubQueue = SubQueue.None;
busAdmin = new ServiceBusAdministrationClient(this.connectionString);
if (createQueueIfItDoesNotExist && !busAdmin.QueueExistsAsync(queueName).Result.Value)
{
busAdmin.CreateQueueAsync(queueName).Wait();
}
}
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)
{
MaxDeliveryCount = int.MaxValue
};
await client.CreateQueueAsync(description);
}
public async Task EnsureQueue(string queueName, CancellationToken cancellationToken = default)
{
if (!await _administrationClient.QueueExistsAsync(queueName, cancellationToken))
{
var options = new CreateQueueOptions(queueName)
{
Status = EntityStatus.Active,
MaxSizeInMegabytes = 1024,
DefaultMessageTimeToLive = TimeSpan.FromDays(10000),
RequiresSession = queueName.Contains("response", StringComparison.OrdinalIgnoreCase)
};
await _administrationClient.CreateQueueAsync(options, cancellationToken);
}
}
public async Task RunBeforeAllTests()
{
var connectionString = Environment.GetEnvironmentVariable(ServiceBusTriggeredEndpointConfiguration.DefaultServiceBusConnectionName);
Assert.IsNotNull(connectionString, $"Environment variable '{ServiceBusTriggeredEndpointConfiguration.DefaultServiceBusConnectionName}' should be defined to run tests.");
var client = new ServiceBusAdministrationClient(connectionString);
const string errorQueueName = "error";
if (!await client.QueueExistsAsync(errorQueueName))
{
await client.CreateQueueAsync(errorQueueName);
}
}
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)
{
RequiresSession = true
};
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);
}
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);
}
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 async Task StartAsync(CancellationToken cancellationToken)
{
if (Subscription == null)
{
if (!await _administrationClient.QueueExistsAsync(QueueOrTopic, cancellationToken))
{
await _administrationClient.CreateQueueAsync(QueueOrTopic, cancellationToken);
}
}
else
{
if (!await _administrationClient.TopicExistsAsync(QueueOrTopic, cancellationToken))
{
await _administrationClient.CreateTopicAsync(QueueOrTopic, cancellationToken);
}
if (!await _administrationClient.SubscriptionExistsAsync(QueueOrTopic, Subscription, cancellationToken))
{
await _administrationClient.CreateSubscriptionAsync(QueueOrTopic, Subscription, cancellationToken);
}
}
await _processor.StartProcessingAsync(cancellationToken);
}
public async Task <bool> IsQueue(string name)
{
var administrationClient = new ServiceBusAdministrationClient(ConnectionString);
return(await administrationClient.QueueExistsAsync(name).ConfigureAwait(false));
}
private static async Task Main(string[] args)
{
var client = new ServiceBusAdministrationClient(connectionString);
if (!await client.QueueExistsAsync($"{destination}"))
{
await client.CreateQueueAsync($"{destination}");
}
for (int i = 0; i < 100; i++)
{
if (!await client.QueueExistsAsync($"{destination}{i}"))
{
await client.CreateQueueAsync($"{destination}{i}");
}
}
await using var serviceBusClient = new ServiceBusClient(connectionString, new ServiceBusClientOptions
{
RetryOptions = new ServiceBusRetryOptions
{
TryTimeout = TimeSpan.FromSeconds(2)
}
});
await using var sender = serviceBusClient.CreateSender(destination);
await sender.SendMessageAsync(new ServiceBusMessage(UTF8.GetBytes("Deep Dive")));
WriteLine("Message sent");
var processorOptions = new ServiceBusProcessorOptions
{
AutoCompleteMessages = false,
MaxConcurrentCalls = 1,
MaxAutoLockRenewalDuration = TimeSpan.FromMinutes(10),
ReceiveMode = ServiceBusReceiveMode.PeekLock,
PrefetchCount = 10
};
await using var receiver = serviceBusClient.CreateProcessor(destination, processorOptions);
receiver.ProcessMessageAsync += async messageEventArgs =>
{
var message = messageEventArgs.Message;
await Out.WriteLineAsync(
$"Received message with '{message.MessageId}' and content '{UTF8.GetString(message.Body)}'");
// throw new InvalidOperationException();
await messageEventArgs.CompleteMessageAsync(message);
syncEvent.TrySetResult(true);
};
receiver.ProcessErrorAsync += async errorEventArgs =>
{
await Out.WriteLineAsync($"Exception: {errorEventArgs.Exception}");
await Out.WriteLineAsync($"FullyQualifiedNamespace: {errorEventArgs.FullyQualifiedNamespace}");
await Out.WriteLineAsync($"ErrorSource: {errorEventArgs.ErrorSource}");
await Out.WriteLineAsync($"EntityPath: {errorEventArgs.EntityPath}");
};
await receiver.StartProcessingAsync();
await syncEvent.Task;
await receiver.StopProcessingAsync();
}
private static async Task SendComplexObjectMessageWithDuplicateDetection()
{
const string queueName = "sbq-complex-object-message-with-duplicate";
var managementClient = new ServiceBusAdministrationClient(Config.Namespace, Config.Credential);
var createQueueOptions = new CreateQueueOptions(queueName)
{
RequiresDuplicateDetection = true,
DuplicateDetectionHistoryTimeWindow = TimeSpan.FromMinutes(10)
};
if (!await managementClient.QueueExistsAsync(queueName))
{
await managementClient.CreateQueueAsync(createQueueOptions);
}
await using var client = new ServiceBusClient(Config.Namespace, Config.Credential);
var sender = client.CreateSender(queueName);
var payments = new List <Payment>
{
new Payment
{
PaymentId = Guid.NewGuid(),
AccountNumber = "132456789",
Amount = 1337m,
PaymentDate = DateTime.Today.AddDays(1),
Payee = "Mr John Smith"
},
new Payment
{
PaymentId = Guid.NewGuid(),
AccountNumber = "1576321357",
Amount = 6984.56m,
PaymentDate = DateTime.Today.AddDays(3),
Payee = "Mrs Jane Doe"
},
new Payment
{
PaymentId = Guid.NewGuid(),
AccountNumber = "1867817635",
Amount = 13872m,
PaymentDate = DateTime.Today,
Payee = "Mr Robert Smith"
},
new Payment
{
PaymentId = Guid.NewGuid(),
AccountNumber = "1779584565",
Amount = 20000m,
PaymentDate = DateTime.Today.AddDays(9),
Payee = "Mrs James Doe"
},
new Payment
{
PaymentId = Guid.NewGuid(),
AccountNumber = "1657892587",
Amount = 900000m,
PaymentDate = DateTime.Today,
Payee = "Mr William Tell"
}
};
Console.WriteLine("Press any key to send all payment messages. Press Enter to exit.");
while (Console.ReadKey(true).Key != ConsoleKey.Enter)
{
Console.WriteLine($"Total Payments to send: {payments.Count}");
foreach (var payment in payments)
{
var message = new ServiceBusMessage(JsonSerializer.SerializeToUtf8Bytes(payment))
{
MessageId = payment.PaymentId.ToString() // Needed to detect duplicate messages
};
var random = new Random();
if (random.NextDouble() > 0.4) // Randomly simulate sending duplicate messages
{
await sender.SendMessageAsync(message);
Console.WriteLine($"Message Sent for {nameof(SendComplexObjectMessageWithDuplicateDetection)} - Payment ID: {payment.PaymentId}");
}
else
{
await sender.SendMessageAsync(message);
Console.WriteLine($"Message Sent for {nameof(SendComplexObjectMessageWithDuplicateDetection)} - Payment ID: {payment.PaymentId}");
await sender.SendMessageAsync(message);
Console.WriteLine($"Message Sent for {nameof(SendComplexObjectMessageWithDuplicateDetection)} - Payment ID: {payment.PaymentId}");
}
}
}
Console.ReadLine();
await managementClient.DeleteQueueAsync(queueName);
}
