public async Task Peek()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false))
{
await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
var messageCt = 10;
ServiceBusSender sender = client.GetSender(scope.QueueName);
using ServiceBusMessageBatch batch = await sender.CreateBatchAsync();
IEnumerable <ServiceBusMessage> sentMessages = AddMessages(batch, messageCt).AsEnumerable <ServiceBusMessage>();
await sender.SendBatchAsync(batch);
await using var receiver = client.GetReceiver(scope.QueueName);
Dictionary <string, string> sentMessageIdToLabel = new Dictionary <string, string>();
foreach (ServiceBusMessage message in sentMessages)
{
sentMessageIdToLabel.Add(message.MessageId, Encoding.Default.GetString(message.Body.ToArray()));
}
var ct = 0;
while (ct < messageCt)
{
foreach (ServiceBusReceivedMessage peekedMessage in await receiver.PeekBatchAsync(
maxMessages: messageCt))
{
var peekedText = Encoding.Default.GetString(peekedMessage.Body.ToArray());
ct++;
}
}
Assert.AreEqual(messageCt, ct);
}
}
public async Task PeekIncrementsSequenceNumber(int messageCt)
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: true))
{
await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
ServiceBusSender sender = client.GetSender(scope.QueueName);
var sessionId = Guid.NewGuid().ToString();
// send the messages
using ServiceBusMessageBatch batch = await sender.CreateBatchAsync();
ServiceBusMessageBatch messagebatch = AddMessages(batch, messageCt, sessionId);
await sender.SendBatchAsync(messagebatch);
ServiceBusReceiver receiver = await client.GetSessionReceiverAsync(scope.QueueName);
long seq = 0;
for (int i = 0; i < messageCt; i++)
{
ServiceBusReceivedMessage msg = await receiver.PeekAsync();
Assert.IsTrue(msg.SequenceNumber > seq);
if (seq > 0)
{
Assert.IsTrue(msg.SequenceNumber == seq + 1);
}
seq = msg.SequenceNumber;
}
}
}
public async Task LockSameSessionShouldThrow()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: true))
{
await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
ServiceBusSender sender = client.GetSender(scope.QueueName);
int messageCt = 10;
var sessionId = Guid.NewGuid().ToString();
// send the messages
using ServiceBusMessageBatch batch = await sender.CreateBatchAsync();
ServiceBusMessageBatch messageBatch = AddMessages(batch, messageCt, sessionId);
await sender.SendBatchAsync(messageBatch);
ServiceBusReceiver receiver1 = await client.GetSessionReceiverAsync(
scope.QueueName,
sessionId : sessionId);
Assert.That(
async() =>
await GetNoRetryClient().GetSessionReceiverAsync(
scope.QueueName,
sessionId: sessionId),
Throws.InstanceOf <ServiceBusException>().And.Property(nameof(ServiceBusException.Reason)).EqualTo(ServiceBusException.FailureReason.SessionCannotBeLocked));
}
}
public async Task ReceiveMessagesInPeekLockMode()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false))
{
await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
var messageCount = 10;
ServiceBusSender sender = client.GetSender(scope.QueueName);
using ServiceBusMessageBatch batch = await sender.CreateBatchAsync();
IEnumerable <ServiceBusMessage> messages = AddMessages(batch, messageCount).AsEnumerable <ServiceBusMessage>();
await sender.SendBatchAsync(batch);
var receiver = client.GetReceiver(scope.QueueName);
var receivedMessageCount = 0;
var messageEnum = messages.GetEnumerator();
foreach (var item in await receiver.ReceiveBatchAsync(messageCount))
{
receivedMessageCount++;
messageEnum.MoveNext();
Assert.AreEqual(messageEnum.Current.MessageId, item.MessageId);
Assert.AreEqual(item.DeliveryCount, 1);
}
Assert.AreEqual(messageCount, receivedMessageCount);
messageEnum.Reset();
foreach (var item in await receiver.PeekBatchAsync(messageCount))
{
messageEnum.MoveNext();
Assert.AreEqual(messageEnum.Current.MessageId, item.MessageId);
}
}
}
public async Task ReceiveMessagesInReceiveAndDeleteMode()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false))
{
await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
var messageCount = 10;
ServiceBusSender sender = client.GetSender(scope.QueueName);
using ServiceBusMessageBatch batch = await sender.CreateBatchAsync();
IEnumerable <ServiceBusMessage> messages = AddMessages(batch, messageCount).AsEnumerable <ServiceBusMessage>();
await sender.SendBatchAsync(batch);
var clientOptions = new ServiceBusReceiverOptions()
{
ReceiveMode = ReceiveMode.ReceiveAndDelete,
};
var receiver = client.GetReceiver(scope.QueueName, clientOptions);
var receivedMessageCount = 0;
var messageEnum = messages.GetEnumerator();
foreach (var item in await receiver.ReceiveBatchAsync(messageCount).ConfigureAwait(false))
{
messageEnum.MoveNext();
Assert.AreEqual(messageEnum.Current.MessageId, item.MessageId);
receivedMessageCount++;
}
Assert.AreEqual(messageCount, receivedMessageCount);
var peekedMessage = receiver.PeekAsync();
Assert.IsNull(peekedMessage.Result);
}
}
public async Task CompleteMessages()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false))
{
await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
var messageCount = 10;
ServiceBusSender sender = client.GetSender(scope.QueueName);
using ServiceBusMessageBatch batch = await sender.CreateBatchAsync();
IEnumerable <ServiceBusMessage> messages = AddMessages(batch, messageCount).AsEnumerable <ServiceBusMessage>();
await sender.SendBatchAsync(batch);
var receiver = client.GetReceiver(scope.QueueName);
var messageEnum = messages.GetEnumerator();
var remainingMessages = messageCount;
while (remainingMessages > 0)
{
foreach (var item in await receiver.ReceiveBatchAsync(remainingMessages))
{
remainingMessages--;
messageEnum.MoveNext();
Assert.AreEqual(messageEnum.Current.MessageId, item.MessageId);
await receiver.CompleteAsync(item.LockToken);
}
}
Assert.AreEqual(0, remainingMessages);
var peekedMessage = receiver.PeekAsync();
Assert.IsNull(peekedMessage.Result);
}
}
public async Task Receive_Event(int numThreads)
{
await using (var scope = await ServiceBusScope.CreateWithQueue(
enablePartitioning: false,
enableSession: false))
{
await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
ServiceBusSender sender = client.GetSender(scope.QueueName);
// use double the number of threads so we can make sure we test that we don't
// retrieve more messages than expected when there are more messages available
using ServiceBusMessageBatch batch = await sender.CreateBatchAsync();
ServiceBusMessageBatch messageBatch = AddMessages(batch, numThreads * 2);
await sender.SendBatchAsync(messageBatch);
await using var processor = client.GetProcessor(scope.QueueName);
int messageCt = 0;
TaskCompletionSource <bool>[] completionSources = Enumerable
.Range(0, numThreads)
.Select(index => new TaskCompletionSource <bool>(TaskCreationOptions.RunContinuationsAsynchronously))
.ToArray();
var completionSourceIndex = -1;
processor.ProcessMessageAsync += ProcessMessage;
processor.ProcessErrorAsync += ExceptionHandler;
processor.MaxConcurrentCalls = numThreads;
await processor.StartProcessingAsync();
async Task ProcessMessage(ProcessMessageEventArgs args)
{
try
{
var receiver = args.Receiver;
var message = args.Message;
await receiver.CompleteAsync(message);
Interlocked.Increment(ref messageCt);
}
finally
{
var setIndex = Interlocked.Increment(ref completionSourceIndex);
completionSources[setIndex].SetResult(true);
}
}
await Task.WhenAll(completionSources.Select(source => source.Task));
await processor.StopProcessingAsync();
// we complete each thread after one message being processed, so the total number of messages
// processed should equal the number of threads
Assert.AreEqual(numThreads, messageCt);
}
}
public async Task AbandonMessages(bool useSpecificSession)
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: true))
{
await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
ServiceBusSender sender = client.GetSender(scope.QueueName);
var messageCount = 10;
var sessionId = "sessionId1";
using ServiceBusMessageBatch batch = await sender.CreateBatchAsync();
IEnumerable <ServiceBusMessage> messages = AddMessages(batch, messageCount, sessionId).AsEnumerable <ServiceBusMessage>();
await sender.SendBatchAsync(batch);
ServiceBusReceiver receiver = await client.GetSessionReceiverAsync(
scope.QueueName,
sessionId : useSpecificSession?sessionId : null);
var messageEnum = messages.GetEnumerator();
var remainingMessages = messageCount;
IList <ServiceBusReceivedMessage> receivedMessages = new List <ServiceBusReceivedMessage>();
while (remainingMessages > 0)
{
foreach (var msg in await receiver.ReceiveBatchAsync(remainingMessages))
{
remainingMessages--;
messageEnum.MoveNext();
Assert.AreEqual(messageEnum.Current.MessageId, msg.MessageId);
Assert.AreEqual(messageEnum.Current.SessionId, msg.SessionId);
receivedMessages.Add(msg);
Assert.AreEqual(msg.DeliveryCount, 1);
}
}
Assert.AreEqual(0, remainingMessages);
// don't abandon in the receive loop
// as this would make the message available to be immediately received again
foreach (var msg in receivedMessages)
{
await receiver.AbandonAsync(msg);
}
messageEnum.Reset();
var receivedMessageCount = 0;
foreach (var item in await receiver.PeekBatchAsync(messageCount))
{
receivedMessageCount++;
messageEnum.MoveNext();
Assert.AreEqual(messageEnum.Current.MessageId, item.MessageId);
Assert.AreEqual(messageEnum.Current.SessionId, item.SessionId);
}
Assert.AreEqual(messageCount, receivedMessageCount);
}
}
public async Task CanStopProcessingFromHandler(int numThreads)
{
await using (var scope = await ServiceBusScope.CreateWithQueue(
enablePartitioning: false,
enableSession: false))
{
await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
ServiceBusSender sender = client.GetSender(scope.QueueName);
int numMessages = 100;
using ServiceBusMessageBatch batch = await sender.CreateBatchAsync();
ServiceBusMessageBatch messageBatch = AddMessages(batch, numMessages);
await sender.SendBatchAsync(messageBatch);
var options = new ServiceBusProcessorOptions
{
MaxConcurrentCalls = numThreads,
ReceiveMode = ReceiveMode.ReceiveAndDelete
};
var processor = client.GetProcessor(scope.QueueName, options);
int messageProcessedCt = 0;
// stop processing halfway through
int stopAfterMessagesCt = numMessages / 2;
TaskCompletionSource <bool> tcs = new TaskCompletionSource <bool>(TaskCreationOptions.RunContinuationsAsynchronously);
processor.ProcessMessageAsync += ProcessMessage;
processor.ProcessErrorAsync += ExceptionHandler;
await processor.StartProcessingAsync();
Task ProcessMessage(ProcessMessageEventArgs args)
{
var currentCt = Interlocked.Increment(ref messageProcessedCt);
if (currentCt == stopAfterMessagesCt)
{
// awaiting here would cause a deadlock
_ = processor.StopProcessingAsync();
tcs.SetResult(true);
}
return(Task.CompletedTask);
}
await tcs.Task;
var receiver = GetNoRetryClient().GetReceiver(scope.QueueName);
var receivedMessages = await receiver.ReceiveBatchAsync(numMessages);
// can't assert on the exact amount processed due to threads that
// are already in flight when calling StopProcessingAsync, but we can at least verify that there are remaining messages
Assert.IsTrue(receivedMessages.Count > 0);
Assert.IsTrue(messageProcessedCt < numMessages);
}
}
public async Task DeadLetterMessages(bool useSpecificSession)
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: true))
{
await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
ServiceBusSender sender = client.GetSender(scope.QueueName);
var messageCount = 10;
var sessionId = "sessionId1";
using ServiceBusMessageBatch batch = await sender.CreateBatchAsync();
IEnumerable <ServiceBusMessage> messages = AddMessages(batch, messageCount, sessionId).AsEnumerable <ServiceBusMessage>();
await sender.SendBatchAsync(batch);
var receiver = await client.GetSessionReceiverAsync(
scope.QueueName,
sessionId : useSpecificSession?sessionId : null);
var remainingMessages = messageCount;
var messageEnum = messages.GetEnumerator();
foreach (var item in await receiver.ReceiveBatchAsync(remainingMessages))
{
remainingMessages--;
messageEnum.MoveNext();
Assert.AreEqual(messageEnum.Current.MessageId, item.MessageId);
Assert.AreEqual(messageEnum.Current.SessionId, item.SessionId);
await receiver.MoveToDeadLetterQueueAsync(item.LockToken);
}
Assert.AreEqual(0, remainingMessages);
var peekedMessage = receiver.PeekAsync();
Assert.IsNull(peekedMessage.Result);
// TODO: System.InvalidOperationException : Cannot create a MessageSession for a sub-queue.
// messageEnum.Reset();
// receivedMessageCount = 0;
// string deadLetterQueuePath = EntityNameFormatter.FormatDeadLetterPath(scope.QueueName);
// var deadLetterReceiver = new ServiceBusReceiverClient(TestEnvironment.ServiceBusConnectionString, deadLetterQueuePath, sessionOptions);
// foreach (var item in await deadLetterReceiver.ReceiveBatchAsync(messageCount))
// {
// receivedMessageCount++;
// messageEnum.MoveNext();
// Assert.AreEqual(messageEnum.Current.MessageId, item.MessageId);
// Assert.AreEqual(messageEnum.Current.SessionId, item.SessionId);
// await deadLetterReceiver.CompleteAsync(item.SystemProperties.LockToken);
// }
// Assert.AreEqual(messageCount, receivedMessageCount);
// var deadLetterMessage = deadLetterReceiver.PeekAsync();
// Assert.IsNull(deadLetterMessage.Result);
}
}
public async Task Receive_StopProcessing(int numThreads)
{
await using (var scope = await ServiceBusScope.CreateWithQueue(
enablePartitioning: false,
enableSession: false))
{
await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
ServiceBusSender sender = client.GetSender(scope.QueueName);
int numMessages = 50;
using ServiceBusMessageBatch batch = await sender.CreateBatchAsync();
ServiceBusMessageBatch messageBatch = AddMessages(batch, numMessages);
await sender.SendBatchAsync(messageBatch);
await using var processor = client.GetProcessor(scope.QueueName);
int messageProcessedCt = 0;
// stop processing halfway through
int stopAfterMessagesCt = numMessages / 2;
TaskCompletionSource <bool> tcs = new TaskCompletionSource <bool>(TaskCreationOptions.RunContinuationsAsynchronously);
processor.ProcessMessageAsync += ProcessMessage;
processor.ProcessErrorAsync += ExceptionHandler;
processor.MaxConcurrentCalls = numThreads;
await processor.StartProcessingAsync();
async Task ProcessMessage(ProcessMessageEventArgs args)
{
Interlocked.Increment(ref messageProcessedCt);
if (messageProcessedCt == stopAfterMessagesCt)
{
await processor.StopProcessingAsync();
tcs.SetResult(true);
}
}
await tcs.Task;
var remainingCt = 0;
var receiver = client.GetReceiver(scope.QueueName);
foreach (ServiceBusMessage message in await receiver.ReceiveBatchAsync(numMessages))
{
remainingCt++;
}
// can't assert on the exact amount processed due to threads that
// are already in flight when calling StopProcessingAsync, but we can at least verify that there are remaining messages
Assert.IsTrue(remainingCt > 0);
Assert.IsTrue(messageProcessedCt < numMessages);
}
}
public async Task PeekSession(long?sequenceNumber, string partitionKey)
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: true))
{
await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
ServiceBusSender sender = client.GetSender(scope.QueueName);
var messageCt = 10;
var sessionId = Guid.NewGuid().ToString();
// send the messages
using ServiceBusMessageBatch batch = await sender.CreateBatchAsync();
IEnumerable <ServiceBusMessage> sentMessages = AddMessages(batch, messageCt, sessionId, partitionKey).AsEnumerable <ServiceBusMessage>();
await sender.SendBatchAsync(batch);
Dictionary <string, ServiceBusMessage> sentMessageIdToMsg = new Dictionary <string, ServiceBusMessage>();
foreach (ServiceBusMessage message in sentMessages)
{
sentMessageIdToMsg.Add(message.MessageId, message);
}
var receiver = await client.GetSessionReceiverAsync(
scope.QueueName,
null,
sessionId);
sequenceNumber ??= 1;
// verify peeked == send
var ct = 0;
foreach (ServiceBusReceivedMessage peekedMessage in await receiver.PeekBatchAtAsync(
sequenceNumber: (long)sequenceNumber,
maxMessages: messageCt))
{
var peekedText = Encoding.Default.GetString(peekedMessage.Body.ToArray());
var sentMsg = sentMessageIdToMsg[peekedMessage.MessageId];
sentMessageIdToMsg.Remove(peekedMessage.MessageId);
Assert.AreEqual(Encoding.Default.GetString(sentMsg.Body.ToArray()), peekedText);
Assert.AreEqual(sentMsg.PartitionKey, peekedMessage.PartitionKey);
Assert.IsTrue(peekedMessage.SequenceNumber >= sequenceNumber);
TestContext.Progress.WriteLine($"{peekedMessage.Label}: {peekedText}");
ct++;
}
if (sequenceNumber == 1)
{
Assert.AreEqual(messageCt, ct);
}
}
}
public async Task CanSendAMessageBatch()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false))
{
await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
ServiceBusSender sender = client.GetSender(scope.QueueName);
using ServiceBusMessageBatch batch = await sender.CreateBatchAsync();
ServiceBusMessageBatch messageBatch = AddMessages(batch, 3);
await sender.SendBatchAsync(messageBatch);
}
}
public async Task CanSendAnEmptyBodyMessageBatch()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false))
{
await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
ServiceBusSender sender = client.GetSender(scope.QueueName);
using ServiceBusMessageBatch batch = await sender.CreateBatchAsync();
batch.TryAdd(new ServiceBusMessage(Array.Empty <byte>()));
await sender.SendBatchAsync(batch);
}
}
public async Task TryAddReturnsFalseIfSizeExceed()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false))
{
await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
ServiceBusSender sender = client.GetSender(scope.QueueName);
using ServiceBusMessageBatch batch = await sender.CreateBatchAsync();
// Actual limit is 262144 bytes for a single message.
Assert.That(() => batch.TryAdd(new ServiceBusMessage(new byte[200000])), Is.True, "A message was rejected by the batch; all messages should be accepted.");
Assert.That(() => batch.TryAdd(new ServiceBusMessage(new byte[200000])), Is.False, "A message was rejected by the batch; message size exceed.");
await sender.SendBatchAsync(batch);
}
}
public async Task DeadLetterMessages()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false))
{
await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
var messageCount = 10;
ServiceBusSender sender = client.GetSender(scope.QueueName);
using ServiceBusMessageBatch batch = await sender.CreateBatchAsync();
IEnumerable <ServiceBusMessage> messages = AddMessages(batch, messageCount).AsEnumerable <ServiceBusMessage>();
await sender.SendBatchAsync(batch);
var receiver = client.GetReceiver(scope.QueueName);
var receivedMessageCount = 0;
var messageEnum = messages.GetEnumerator();
foreach (var item in await receiver.ReceiveBatchAsync(messageCount))
{
receivedMessageCount++;
messageEnum.MoveNext();
Assert.AreEqual(messageEnum.Current.MessageId, item.MessageId);
await receiver.DeadLetterAsync(item);
}
Assert.AreEqual(messageCount, receivedMessageCount);
var peekedMessage = receiver.PeekAsync();
Assert.IsNull(peekedMessage.Result);
messageEnum.Reset();
receivedMessageCount = 0;
string deadLetterQueuePath = EntityNameFormatter.FormatDeadLetterPath(scope.QueueName);
var deadLetterReceiver = client.GetReceiver(deadLetterQueuePath);
foreach (var item in await deadLetterReceiver.ReceiveBatchAsync(messageCount))
{
receivedMessageCount++;
messageEnum.MoveNext();
Assert.AreEqual(messageEnum.Current.MessageId, item.MessageId);
await deadLetterReceiver.CompleteAsync(item);
}
Assert.AreEqual(messageCount, receivedMessageCount);
var deadLetterMessage = deadLetterReceiver.PeekAsync();
Assert.IsNull(deadLetterMessage.Result);
}
}
public async Task CanSendLargeMessageBatch()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false))
{
await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
ServiceBusSender sender = client.GetSender(scope.QueueName);
using ServiceBusMessageBatch batch = await sender.CreateBatchAsync();
// Actual limit is 262144 bytes for a single message.
batch.TryAdd(new ServiceBusMessage(new byte[100000 / 3]));
batch.TryAdd(new ServiceBusMessage(new byte[100000 / 3]));
batch.TryAdd(new ServiceBusMessage(new byte[100000 / 3]));
await sender.SendBatchAsync(batch);
}
}
public async Task ReceiveFromSpecificSession()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: true))
{
string connectionString = TestEnvironment.ServiceBusConnectionString;
string queueName = scope.QueueName;
#region Snippet:ServiceBusReceiveFromSpecificSession
//@@ string connectionString = "<connection_string>";
//@@ string queueName = "<queue_name>";
// since ServiceBusClient implements IAsyncDisposable we create it with "await using"
await using var client = new ServiceBusClient(connectionString);
// get the sender
ServiceBusSender sender = client.GetSender(queueName);
// create a message batch that we can send
ServiceBusMessageBatch messageBatch = await sender.CreateBatchAsync();
messageBatch.TryAdd(
new ServiceBusMessage(Encoding.UTF8.GetBytes("First"))
{
SessionId = "Session1"
});
messageBatch.TryAdd(
new ServiceBusMessage(Encoding.UTF8.GetBytes("Second"))
{
SessionId = "Session2"
});
// send the message batch
await sender.SendBatchAsync(messageBatch);
// Get a receiver specifying a particular session
ServiceBusSessionReceiver receiver = await client.GetSessionReceiverAsync(
queueName,
sessionId : "Session2");
// the received message is a different type as it contains some service set properties
ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveAsync();
Console.WriteLine(receivedMessage.SessionId);
#endregion
Assert.AreEqual(Encoding.Default.GetBytes("Second"), receivedMessage.Body.ToArray());
Assert.AreEqual("Session2", receivedMessage.SessionId);
}
}
public async Task AbandonMessages(bool useSpecificSession)
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: true))
{
await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
ServiceBusSender sender = client.GetSender(scope.QueueName);
var messageCount = 10;
var sessionId = "sessionId1";
using ServiceBusMessageBatch batch = await sender.CreateBatchAsync();
IEnumerable <ServiceBusMessage> messages = AddMessages(batch, messageCount, sessionId).AsEnumerable <ServiceBusMessage>();
await sender.SendBatchAsync(batch);
ServiceBusReceiver receiver = await client.GetSessionReceiverAsync(
scope.QueueName,
sessionId : useSpecificSession?sessionId : null);
var receivedMessageCount = 0;
var messageEnum = messages.GetEnumerator();
foreach (var item in await receiver.ReceiveBatchAsync(messageCount))
{
receivedMessageCount++;
messageEnum.MoveNext();
Assert.AreEqual(messageEnum.Current.MessageId, item.MessageId);
Assert.AreEqual(messageEnum.Current.SessionId, item.SessionId);
await receiver.AbandonAsync(item);
Assert.AreEqual(item.DeliveryCount, 1);
}
Assert.AreEqual(messageCount, receivedMessageCount);
messageEnum.Reset();
receivedMessageCount = 0;
foreach (var item in await receiver.PeekBatchAsync(messageCount))
{
receivedMessageCount++;
messageEnum.MoveNext();
Assert.AreEqual(messageEnum.Current.MessageId, item.MessageId);
Assert.AreEqual(messageEnum.Current.SessionId, item.SessionId);
}
Assert.AreEqual(messageCount, receivedMessageCount);
}
}
public async Task SendAndReceiveMessageBatch()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false))
{
string connectionString = TestEnvironment.ServiceBusConnectionString;
string queueName = scope.QueueName;
#region Snippet:ServiceBusSendAndReceiveBatch
//@@ string connectionString = "<connection_string>";
//@@ string queueName = "<queue_name>";
// since ServiceBusClient implements IAsyncDisposable we create it with "await using"
await using var client = new ServiceBusClient(connectionString);
// get the sender
ServiceBusSender sender = client.GetSender(queueName);
// create a message batch that we can send
ServiceBusMessageBatch messageBatch = await sender.CreateBatchAsync();
messageBatch.TryAdd(new ServiceBusMessage(Encoding.UTF8.GetBytes("First")));
messageBatch.TryAdd(new ServiceBusMessage(Encoding.UTF8.GetBytes("Second")));
// send the message batch
await sender.SendBatchAsync(messageBatch);
// get a receiver that we can use to receive the messages
ServiceBusReceiver receiver = client.GetReceiver(queueName);
// the received message is a different type as it contains some service set properties
IList <ServiceBusReceivedMessage> receivedMessages = await receiver.ReceiveBatchAsync(maxMessages : 2);
foreach (ServiceBusReceivedMessage receivedMessage in receivedMessages)
{
// get the message body as a string
string body = Encoding.Default.GetString(receivedMessage.Body.ToArray());
Console.WriteLine(body);
}
#endregion
var sentMessagesEnum = messageBatch.AsEnumerable <ServiceBusMessage>().GetEnumerator();
foreach (ServiceBusReceivedMessage receivedMessage in receivedMessages)
{
sentMessagesEnum.MoveNext();
Assert.AreEqual(sentMessagesEnum.Current.Body.ToArray(), receivedMessage.Body.ToArray());
}
}
}
public async Task DeferMessages(bool useSpecificSession)
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: true))
{
await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
ServiceBusSender sender = client.GetSender(scope.QueueName);
var messageCount = 10;
var sessionId = "sessionId1";
using ServiceBusMessageBatch batch = await sender.CreateBatchAsync();
IEnumerable <ServiceBusMessage> messages = AddMessages(batch, messageCount, sessionId).AsEnumerable <ServiceBusMessage>();
await sender.SendBatchAsync(batch);
var receiver = await client.GetSessionReceiverAsync(
scope.QueueName,
sessionId : useSpecificSession?sessionId : null);
var remainingMessages = messageCount;
var messageEnum = messages.GetEnumerator();
IList <long> sequenceNumbers = new List <long>();
while (remainingMessages > 0)
{
foreach (var item in await receiver.ReceiveBatchAsync(remainingMessages))
{
remainingMessages--;
messageEnum.MoveNext();
Assert.AreEqual(messageEnum.Current.MessageId, item.MessageId);
Assert.AreEqual(messageEnum.Current.SessionId, item.SessionId);
sequenceNumbers.Add(item.SequenceNumber);
await receiver.DeferAsync(item.LockToken);
}
}
Assert.AreEqual(0, remainingMessages);
IList <ServiceBusReceivedMessage> deferedMessages = await receiver.ReceiveDeferredMessageBatchAsync(sequenceNumbers);
var messageList = messages.ToList();
Assert.AreEqual(messageList.Count, deferedMessages.Count);
for (int i = 0; i < messageList.Count; i++)
{
Assert.AreEqual(messageList[i].MessageId, deferedMessages[i].MessageId);
}
}
}
public async Task SendBatchManagesLockingTheBatch()
{
using var cancellationSource = new CancellationTokenSource();
cancellationSource.CancelAfter(TimeSpan.FromSeconds(15));
var completionSource = new TaskCompletionSource <bool>(TaskCreationOptions.RunContinuationsAsynchronously);
var mockTransportBatch = new Mock <TransportMessageBatch>();
var batch = new ServiceBusMessageBatch(mockTransportBatch.Object);
var mockTransportSender = new Mock <TransportSender>();
var mockConnection = new Mock <ServiceBusConnection>();
mockConnection
.Setup(connection => connection.RetryOptions)
.Returns(new ServiceBusRetryOptions());
mockConnection
.Setup(connection => connection.CreateTransportSender(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <ServiceBusRetryPolicy>()))
.Returns(mockTransportSender.Object);
mockConnection
.Setup(connection => connection.ThrowIfClosed());
mockTransportBatch
.Setup(transport => transport.TryAdd(It.IsAny <ServiceBusMessage>()))
.Returns(true);
mockTransportSender
.Setup(transport => transport.SendBatchAsync(It.IsAny <ServiceBusMessageBatch>(), It.IsAny <CancellationToken>()))
.Returns(async() => await Task.WhenAny(completionSource.Task, Task.Delay(Timeout.Infinite, cancellationSource.Token)));
Assert.That(batch.TryAdd(new ServiceBusMessage(Array.Empty <byte>())), Is.True, "The batch should not be locked before sending.");
var sender = new ServiceBusSender("dummy", null, mockConnection.Object);
var sendTask = sender.SendBatchAsync(batch);
Assert.That(() => batch.TryAdd(new ServiceBusMessage(Array.Empty <byte>())), Throws.InstanceOf <InvalidOperationException>(), "The batch should be locked while sending.");
completionSource.TrySetResult(true);
await sendTask;
Assert.That(cancellationSource.IsCancellationRequested, Is.False, "The cancellation token should not have been signaled.");
Assert.That(batch.TryAdd(new ServiceBusMessage(Array.Empty <byte>())), Is.True, "The batch should not be locked after sending.");
cancellationSource.Cancel();
}
public async Task ReceiveMessagesInReceiveAndDeleteMode()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: true))
{
await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
ServiceBusSender sender = client.CreateSender(scope.QueueName);
var messageCount = 10;
var sessionId = "sessionId1";
using ServiceBusMessageBatch batch = await sender.CreateBatchAsync();
IEnumerable <ServiceBusMessage> messages = AddMessages(batch, messageCount, sessionId).AsEnumerable <ServiceBusMessage>();
await sender.SendBatchAsync(batch);
var clientOptions = new ServiceBusReceiverOptions()
{
ReceiveMode = ReceiveMode.ReceiveAndDelete
};
ServiceBusReceiver receiver = await client.CreateSessionReceiverAsync(
scope.QueueName,
clientOptions,
sessionId);
var remainingMessages = messageCount;
var messageEnum = messages.GetEnumerator();
while (remainingMessages > 0)
{
foreach (var item in await receiver.ReceiveBatchAsync(remainingMessages))
{
messageEnum.MoveNext();
Assert.AreEqual(messageEnum.Current.MessageId, item.MessageId);
Assert.AreEqual(messageEnum.Current.SessionId, item.SessionId);
remainingMessages--;
}
}
Assert.AreEqual(0, remainingMessages);
var peekedMessage = receiver.PeekAsync();
Assert.IsNull(peekedMessage.Result);
}
}
public async Task RoundRobinSessions()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: true))
{
await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
ServiceBusSender sender = client.GetSender(scope.QueueName);
var messageCt = 10;
HashSet <string> sessions = new HashSet <string>()
{
"1", "2", "3"
};
// send the messages
foreach (string session in sessions)
{
using ServiceBusMessageBatch batch = await sender.CreateBatchAsync();
ServiceBusMessageBatch messageBatch = AddMessages(batch, messageCt, session);
await sender.SendBatchAsync(messageBatch);
}
// create receiver not scoped to a specific session
for (int i = 0; i < 10; i++)
{
ServiceBusReceiver receiver = await client.GetSessionReceiverAsync(scope.QueueName);
var session = receiver.GetSessionManager();
foreach (ServiceBusReceivedMessage peekedMessage in await receiver.PeekBatchAtAsync(
sequenceNumber: 1,
maxMessages: 10))
{
var sessionId = session.SessionId;
Assert.AreEqual(sessionId, peekedMessage.SessionId);
}
// Close the receiver client when we are done with it. Since the sessionClient doesn't own the underlying connection, the connection remains open, but the session link will be closed.
await receiver.DisposeAsync();
}
}
}
public async Task DeferMessages()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false))
{
await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
var messageCount = 10;
ServiceBusSender sender = client.GetSender(scope.QueueName);
using ServiceBusMessageBatch batch = await sender.CreateBatchAsync();
IEnumerable <ServiceBusMessage> messages = AddMessages(batch, messageCount).AsEnumerable <ServiceBusMessage>();
await sender.SendBatchAsync(batch);
var receiver = client.GetReceiver(scope.QueueName);
var receivedMessageCount = 0;
var messageEnum = messages.GetEnumerator();
IList <long> sequenceNumbers = new List <long>();
foreach (var item in await receiver.ReceiveBatchAsync(messageCount))
{
receivedMessageCount++;
messageEnum.MoveNext();
Assert.AreEqual(messageEnum.Current.MessageId, item.MessageId);
sequenceNumbers.Add(item.SequenceNumber);
await receiver.DeferAsync(item);
}
Assert.AreEqual(messageCount, receivedMessageCount);
IList <ServiceBusReceivedMessage> deferedMessages = await receiver.ReceiveDeferredMessageBatchAsync(sequenceNumbers);
var messageList = messages.ToList();
Assert.AreEqual(messageList.Count, deferedMessages.Count);
for (int i = 0; i < messageList.Count; i++)
{
Assert.AreEqual(messageList[i].MessageId, deferedMessages[i].MessageId);
}
}
}
public async Task LockSameSessionShouldThrow()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: true))
{
await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
ServiceBusSender sender = client.GetSender(scope.QueueName);
int messageCt = 10;
var sessionId = Guid.NewGuid().ToString();
// send the messages
using ServiceBusMessageBatch batch = await sender.CreateBatchAsync();
ServiceBusMessageBatch messageBatch = AddMessages(batch, messageCt, sessionId);
await sender.SendBatchAsync(messageBatch);
var options = new ServiceBusReceiverOptions
{
RetryOptions = new ServiceBusRetryOptions
{
TryTimeout = TimeSpan.FromSeconds(5),
MaximumRetries = 0
}
};
ServiceBusReceiver receiver1 = await client.GetSessionReceiverAsync(
scope.QueueName,
options,
sessionId);
Assert.That(
async() =>
await client.GetSessionReceiverAsync(
scope.QueueName,
options,
sessionId),
Throws.Exception);
}
}
public async Task ProcessEvent(int numThreads, bool autoComplete)
{
await using (var scope = await ServiceBusScope.CreateWithQueue(
enablePartitioning: false,
enableSession: false))
{
await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
ServiceBusSender sender = client.GetSender(scope.QueueName);
// use double the number of threads so we can make sure we test that we don't
// retrieve more messages than expected when there are more messages available
using ServiceBusMessageBatch batch = await sender.CreateBatchAsync();
var messageSendCt = numThreads * 2;
ServiceBusMessageBatch messageBatch = AddMessages(batch, messageSendCt);
await sender.SendBatchAsync(messageBatch);
var options = new ServiceBusProcessorOptions
{
MaxConcurrentCalls = numThreads,
AutoComplete = autoComplete,
MaxReceiveWaitTime = TimeSpan.FromSeconds(30)
};
var processor = client.GetProcessor(scope.QueueName, options);
int messageCt = 0;
TaskCompletionSource <bool>[] completionSources = Enumerable
.Range(0, numThreads)
.Select(index => new TaskCompletionSource <bool>(TaskCreationOptions.RunContinuationsAsynchronously))
.ToArray();
var completionSourceIndex = -1;
processor.ProcessMessageAsync += ProcessMessage;
processor.ProcessErrorAsync += ExceptionHandler;
await processor.StartProcessingAsync();
async Task ProcessMessage(ProcessMessageEventArgs args)
{
try
{
var message = args.Message;
if (!autoComplete)
{
var lockedUntil = message.LockedUntil;
await args.RenewMessageLockAsync(message);
Assert.That(message.LockedUntil > lockedUntil);
await args.CompleteAsync(message, args.CancellationToken);
}
Interlocked.Increment(ref messageCt);
}
finally
{
var setIndex = Interlocked.Increment(ref completionSourceIndex);
if (setIndex < numThreads)
{
completionSources[setIndex].SetResult(true);
}
}
}
await Task.WhenAll(completionSources.Select(source => source.Task));
await processor.StopProcessingAsync();
// we complete each task after one message being processed, so the total number of messages
// processed should equal the number of threads, but it's possible that we may process a few more per thread.
Assert.IsTrue(messageCt >= numThreads);
Assert.IsTrue(messageCt < messageSendCt);
}
}
public async Task ProcessSessionMessages()
{
await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: true))
{
string connectionString = TestEnvironment.ServiceBusConnectionString;
string queueName = scope.QueueName;
await using var client = GetClient();
#region Snippet:ServiceBusProcessSessionMessages
//@@ string connectionString = "<connection_string>";
//@@ string queueName = "<queue_name>";
// since ServiceBusClient implements IAsyncDisposable we create it with "await using"
//@@ await using var client = new ServiceBusClient(connectionString);
// get the sender
ServiceBusSender sender = client.GetSender(queueName);
// create a message batch that we can send
ServiceBusMessageBatch messageBatch = await sender.CreateBatchAsync();
messageBatch.TryAdd(
new ServiceBusMessage(Encoding.UTF8.GetBytes("First"))
{
SessionId = "Session1"
});
messageBatch.TryAdd(
new ServiceBusMessage(Encoding.UTF8.GetBytes("Second"))
{
SessionId = "Session2"
});
// send the message batch
await sender.SendBatchAsync(messageBatch);
// 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 I want more fine-grained control over settlement, I can set this to false.
AutoComplete = false,
// I can also allow for multi-threading
MaxConcurrentCalls = 2
};
// get a session processor that we can use to process the messages
ServiceBusSessionProcessor processor = client.GetSessionProcessor(queueName, options);
// since the message handler will run in a background thread, in order to prevent
// this sample from terminating immediately, we can use a task completion source that
// we complete from within the message handler.
TaskCompletionSource <bool> tcs = new TaskCompletionSource <bool>(TaskCreationOptions.RunContinuationsAsynchronously);
processor.ProcessMessageAsync += MessageHandler;
processor.ProcessErrorAsync += ErrorHandler;
async Task MessageHandler(ProcessSessionMessageEventArgs args)
{
string body = Encoding.Default.GetString(args.Message.Body.ToArray());
Console.WriteLine(body);
// we can evaluate application logic and use that to determine how to settle the message.
await args.CompleteAsync(args.Message);
// we can also set arbitrary session state using this receiver
// the state is specific to the session, and not any particular message
await args.SetSessionStateAsync(Encoding.Default.GetBytes("some state"));
tcs.SetResult(true);
}
Task ErrorHandler(ProcessErrorEventArgs args)
{
// the error source tells me at what point in the processing an error occurred
Console.WriteLine(args.ErrorSource);
// the fully qualified namespace is available
Console.WriteLine(args.FullyQualifiedNamespace);
// as well as the entity path
Console.WriteLine(args.EntityPath);
Console.WriteLine(args.Exception.ToString());
return(Task.CompletedTask);
}
await processor.StartProcessingAsync();
// await our task completion source task so that the message handler will be invoked at least once.
await tcs.Task;
// stop processing once the task completion source was completed.
await processor.StopProcessingAsync();
#endregion
}
}
public async Task MaxAutoLockRenewalDurationRespected(int numThreads, int autoLockRenewalDuration)
{
var lockDuration = TimeSpan.FromSeconds(10);
await using (var scope = await ServiceBusScope.CreateWithQueue(
enablePartitioning: false,
enableSession: false,
lockDuration: lockDuration))
{
await using var client = GetClient();
ServiceBusSender sender = client.GetSender(scope.QueueName);
using ServiceBusMessageBatch batch = await sender.CreateBatchAsync();
var messageSendCt = numThreads;
ServiceBusMessageBatch messageBatch = AddMessages(batch, messageSendCt);
await sender.SendBatchAsync(messageBatch);
var options = new ServiceBusProcessorOptions
{
MaxConcurrentCalls = numThreads,
AutoComplete = false,
MaxAutoLockRenewalDuration = TimeSpan.FromSeconds(autoLockRenewalDuration)
};
var processor = client.GetProcessor(scope.QueueName, options);
int messageCt = 0;
TaskCompletionSource <bool>[] completionSources = Enumerable
.Range(0, numThreads)
.Select(index => new TaskCompletionSource <bool>(TaskCreationOptions.RunContinuationsAsynchronously))
.ToArray();
var completionSourceIndex = -1;
processor.ProcessMessageAsync += ProcessMessage;
processor.ProcessErrorAsync += ExceptionHandler;
await processor.StartProcessingAsync();
async Task ProcessMessage(ProcessMessageEventArgs args)
{
try
{
var message = args.Message;
var lockedUntil = message.LockedUntil;
await Task.Delay(lockDuration.Add(TimeSpan.FromSeconds(1)));
if (!args.CancellationToken.IsCancellationRequested)
{
// only do the assertion if cancellation wasn't requested as otherwise
// the exception we would get is a TaskCanceledException rather than ServiceBusException
Assert.AreEqual(lockedUntil, message.LockedUntil);
Assert.That(
async() => await args.CompleteAsync(message, args.CancellationToken),
Throws.InstanceOf <ServiceBusException>().And.Property(nameof(ServiceBusException.Reason)).EqualTo(ServiceBusException.FailureReason.MessageLockLost));
Interlocked.Increment(ref messageCt);
}
}
finally
{
var setIndex = Interlocked.Increment(ref completionSourceIndex);
if (setIndex < numThreads)
{
completionSources[setIndex].SetResult(true);
}
}
}
await Task.WhenAll(completionSources.Select(source => source.Task));
await processor.StopProcessingAsync();
Assert.AreEqual(numThreads, messageCt);
}
}
public async Task AutoLockRenewalWorks(int numThreads)
{
var lockDuration = TimeSpan.FromSeconds(10);
await using (var scope = await ServiceBusScope.CreateWithQueue(
enablePartitioning: false,
enableSession: false,
lockDuration: lockDuration))
{
await using var client = GetClient();
ServiceBusSender sender = client.GetSender(scope.QueueName);
using ServiceBusMessageBatch batch = await sender.CreateBatchAsync();
var messageSendCt = numThreads;
ServiceBusMessageBatch messageBatch = AddMessages(batch, messageSendCt);
await sender.SendBatchAsync(messageBatch);
var options = new ServiceBusProcessorOptions
{
MaxConcurrentCalls = numThreads,
AutoComplete = false
};
var processor = client.GetProcessor(scope.QueueName, options);
int messageCt = 0;
TaskCompletionSource <bool>[] completionSources = Enumerable
.Range(0, numThreads)
.Select(index => new TaskCompletionSource <bool>(TaskCreationOptions.RunContinuationsAsynchronously))
.ToArray();
var completionSourceIndex = -1;
processor.ProcessMessageAsync += ProcessMessage;
processor.ProcessErrorAsync += ExceptionHandler;
await processor.StartProcessingAsync();
async Task ProcessMessage(ProcessMessageEventArgs args)
{
try
{
var message = args.Message;
var lockedUntil = message.LockedUntil;
await Task.Delay(lockDuration);
Assert.That(message.LockedUntil > lockedUntil, $"{lockedUntil},{DateTime.UtcNow}");
await args.CompleteAsync(message, args.CancellationToken);
Interlocked.Increment(ref messageCt);
}
finally
{
var setIndex = Interlocked.Increment(ref completionSourceIndex);
if (setIndex < numThreads)
{
completionSources[setIndex].SetResult(true);
}
}
}
await Task.WhenAll(completionSources.Select(source => source.Task));
await processor.StopProcessingAsync();
Assert.AreEqual(numThreads, messageCt);
}
}
