public async Task TransactionalSendRollback(bool partitioned, bool sessionEnabled) { await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: partitioned, enableSession: sessionEnabled)) { var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString); ServiceBusSender sender = client.CreateSender(scope.QueueName); ServiceBusMessage message = GetMessage( sessionEnabled ? "sessionId" : null, partitioned ? "sessionId" : null); using (var ts = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled)) { await sender.SendMessageAsync(message); // not completing the transaction } ServiceBusReceiver receiver = sessionEnabled ? await client.AcceptSessionAsync( scope.QueueName, "sessionId") : client.CreateReceiver(scope.QueueName); ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveMessageAsync(TimeSpan.FromSeconds(5)); Assert.IsNull(receivedMessage); }; }
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.CreateSender(scope.QueueName); int messageCt = 10; var sessionId = Guid.NewGuid().ToString(); // send the messages using ServiceBusMessageBatch batch = await sender.CreateMessageBatchAsync(); ServiceBusMessageBatch messageBatch = AddMessages(batch, messageCt, sessionId); await sender.SendMessagesAsync(messageBatch); ServiceBusReceiver receiver1 = await client.AcceptSessionAsync( scope.QueueName, sessionId); Assert.That( async() => await GetNoRetryClient().AcceptSessionAsync( scope.QueueName, sessionId), Throws.InstanceOf <ServiceBusException>().And.Property(nameof(ServiceBusException.Reason)).EqualTo(ServiceBusFailureReason.SessionCannotBeLocked)); } }
public async Task CanAcceptMultipleSessionsUsingSameOptionsTopic(bool acceptSpecificSession) { await using (var scope = await ServiceBusScope.CreateWithTopic(enablePartitioning: false, enableSession: true)) { await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString); ServiceBusSender sender = client.CreateSender(scope.TopicName); var msgs = new List <ServiceBusMessage>(); for (int i = 0; i < 20; i++) { msgs.Add(new ServiceBusMessage() { SessionId = i.ToString() }); } await sender.SendMessagesAsync(msgs); var options = new ServiceBusSessionReceiverOptions { ReceiveMode = ServiceBusReceiveMode.ReceiveAndDelete }; var tasks = new List <Task>(); for (int i = 0; i < 20; i++) { if (acceptSpecificSession) { tasks.Add(client.AcceptSessionAsync(scope.TopicName, scope.SubscriptionNames.First(), i.ToString(), options)); } else { tasks.Add(client.AcceptNextSessionAsync(scope.TopicName, scope.SubscriptionNames.First(), options)); } } await Task.WhenAll(tasks); } }
public async Task ReceiverThrowsAfterSessionLockLost(bool isSessionSpecified) { await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: true, lockDuration: TimeSpan.FromSeconds(5))) { await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString); ServiceBusSender sender = client.CreateSender(scope.QueueName); await sender.SendMessagesAsync(ServiceBusTestUtilities.GetMessages(3, "sessionId1")); // send another session message before the one we are interested in to make sure that when isSessionSpecified=true, it is being respected await sender.SendMessagesAsync(ServiceBusTestUtilities.GetMessages(3, "sessionId2")); ServiceBusSessionReceiver receiver = await client.AcceptSessionAsync( scope.QueueName, isSessionSpecified? "sessionId1" : null); if (isSessionSpecified) { Assert.AreEqual("sessionId1", receiver.SessionId); } var message = await receiver.ReceiveMessageAsync(); Assert.AreEqual(receiver.SessionId, message.SessionId); var sessionId = receiver.SessionId; await Task.Delay((receiver.SessionLockedUntil - DateTime.UtcNow) + TimeSpan.FromSeconds(5)); Assert.IsTrue(receiver.IsClosed); Assert.That(async() => await receiver.ReceiveMessageAsync(), Throws.InstanceOf <ServiceBusException>().And.Property(nameof(ServiceBusException.Reason)) .EqualTo(ServiceBusFailureReason.SessionLockLost)); Assert.That(async() => await receiver.SetSessionStateAsync(null), Throws.InstanceOf <ServiceBusException>().And.Property(nameof(ServiceBusException.Reason)) .EqualTo(ServiceBusFailureReason.SessionLockLost)); Assert.That(async() => await receiver.GetSessionStateAsync(), Throws.InstanceOf <ServiceBusException>().And.Property(nameof(ServiceBusException.Reason)) .EqualTo(ServiceBusFailureReason.SessionLockLost)); Assert.That(async() => await receiver.CompleteMessageAsync(message), Throws.InstanceOf <ServiceBusException>().And.Property(nameof(ServiceBusException.Reason)) .EqualTo(ServiceBusFailureReason.SessionLockLost)); Assert.That(async() => await receiver.CompleteMessageAsync(message), Throws.InstanceOf <ServiceBusException>().And.Property(nameof(ServiceBusException.Reason)) .EqualTo(ServiceBusFailureReason.SessionLockLost)); Assert.That(async() => await receiver.DeadLetterMessageAsync(message), Throws.InstanceOf <ServiceBusException>().And.Property(nameof(ServiceBusException.Reason)) .EqualTo(ServiceBusFailureReason.SessionLockLost)); Assert.That(async() => await receiver.DeferMessageAsync(message), Throws.InstanceOf <ServiceBusException>().And.Property(nameof(ServiceBusException.Reason)) .EqualTo(ServiceBusFailureReason.SessionLockLost)); } }
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.CreateSender(scope.QueueName); var messageCount = 10; var sessionId = "sessionId1"; using ServiceBusMessageBatch batch = await sender.CreateMessageBatchAsync(); IEnumerable <ServiceBusMessage> messages = AddMessages(batch, messageCount, sessionId).AsEnumerable <ServiceBusMessage>(); await sender.SendMessagesAsync(batch); ServiceBusReceiver receiver = await client.AcceptSessionAsync( scope.QueueName, 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.ReceiveMessagesAsync(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.AbandonMessageAsync(msg); } messageEnum.Reset(); var receivedMessageCount = 0; foreach (var item in await receiver.PeekMessagesAsync(messageCount)) { receivedMessageCount++; messageEnum.MoveNext(); Assert.AreEqual(messageEnum.Current.MessageId, item.MessageId); Assert.AreEqual(messageEnum.Current.SessionId, item.SessionId); } Assert.AreEqual(messageCount, receivedMessageCount); } }
private async Task <ServiceBusReceiver> GetServiceBusReceiver( string queueOrTopicName, string subscriptionName = default, ServiceBusSubscriberReceiveOptions options = default, CancellationToken cancellationToken = default) { var(sessionId, _, connectToDeadLetterQueue) = (options?.SessionId, ServiceBusSubscriberReceiveMessageTypes.Payload, options?.ConnectToDeadLetterQueue ?? false); if (string.IsNullOrWhiteSpace(subscriptionName)) { if (string.IsNullOrWhiteSpace(sessionId)) { return(_client.CreateReceiver( queueOrTopicName, new ServiceBusReceiverOptions { SubQueue = connectToDeadLetterQueue ? SubQueue.DeadLetter : SubQueue.None })); } return(await _client.AcceptSessionAsync( queueOrTopicName, sessionId, cancellationToken : cancellationToken)); } if (string.IsNullOrWhiteSpace(sessionId)) { return(_client.CreateReceiver( queueOrTopicName, subscriptionName, new ServiceBusReceiverOptions { SubQueue = connectToDeadLetterQueue ? SubQueue.DeadLetter : SubQueue.None })); } return(await _client.AcceptSessionAsync( queueOrTopicName, subscriptionName, sessionId, cancellationToken : cancellationToken)); }
public async Task PeekSession(long?sequenceNumber) { await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: true, enableSession: true)) { await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString); ServiceBusSender sender = client.CreateSender(scope.QueueName); var messageCt = 10; var sessionId = Guid.NewGuid().ToString(); // send the messages using ServiceBusMessageBatch batch = await sender.CreateMessageBatchAsync(); IEnumerable <ServiceBusMessage> sentMessages = AddMessages(batch, messageCt, sessionId, sessionId) .AsEnumerable <ServiceBusMessage>(); await sender.SendMessagesAsync(batch); Dictionary <string, ServiceBusMessage> sentMessageIdToMsg = new Dictionary <string, ServiceBusMessage>(); foreach (ServiceBusMessage message in sentMessages) { sentMessageIdToMsg.Add(message.MessageId, message); } var receiver = await client.AcceptSessionAsync( scope.QueueName, sessionId); sequenceNumber ??= 1; // verify peeked == send var ct = 0; foreach (ServiceBusReceivedMessage peekedMessage in await receiver.PeekMessagesAsync( messageCt, sequenceNumber)) { var peekedText = peekedMessage.Body.ToString(); var sentMsg = sentMessageIdToMsg[peekedMessage.MessageId]; sentMessageIdToMsg.Remove(peekedMessage.MessageId); Assert.AreEqual(sentMsg.Body.ToString(), peekedText); Assert.AreEqual(sentMsg.SessionId, peekedMessage.SessionId); Assert.IsTrue(peekedMessage.SequenceNumber >= sequenceNumber); ct++; } if (sequenceNumber == 1) { Assert.AreEqual(messageCt, ct); } } }
public async Task RenewSessionLock(bool isSessionSpecified) { 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 = 1; var sessionId1 = "sessionId1"; ServiceBusMessage message = GetMessage(sessionId1); // send another session message before the one we are interested in to make sure that when isSessionSpecified=true, it is being respected await sender.SendMessageAsync(GetMessage("sessionId2")); await sender.SendMessageAsync(message); ServiceBusSessionReceiver receiver = await client.AcceptSessionAsync( scope.QueueName, isSessionSpecified?sessionId1 : null); if (isSessionSpecified) { Assert.AreEqual(sessionId1, receiver.SessionId); } ServiceBusReceivedMessage[] receivedMessages = (await receiver.ReceiveMessagesAsync(messageCount)).ToArray(); var receivedMessage = receivedMessages.First(); var firstLockedUntilUtcTime = receiver.SessionLockedUntil; // Sleeping for 10 seconds... await Task.Delay(10000); await receiver.RenewSessionLockAsync(); Assert.True(receiver.SessionLockedUntil >= firstLockedUntilUtcTime + TimeSpan.FromSeconds(10)); // Complete Messages await receiver.CompleteMessageAsync(receivedMessage.LockToken); Assert.AreEqual(messageCount, receivedMessages.Length); if (isSessionSpecified) { Assert.AreEqual(message.MessageId, receivedMessage.MessageId); } var peekedMessage = receiver.PeekMessageAsync(); Assert.IsNull(peekedMessage.Result); } }
public async Task GetAndSetSessionStateTest(bool isSessionSpecified) { 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 sessionId = "test-sessionId"; ServiceBusMessage message = GetMessage(sessionId); await sender.SendMessageAsync(message); ServiceBusSessionReceiver receiver = await client.AcceptSessionAsync( scope.QueueName, isSessionSpecified?sessionId : null); ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveMessageAsync(); Assert.AreEqual(message.MessageId, receivedMessage.MessageId); Assert.AreEqual(message.SessionId, receivedMessage.SessionId); Assert.AreEqual(message.Body.ToArray(), receivedMessage.Body.ToArray()); var sessionStateString = "Received Message From Session!"; var sessionState = new BinaryData(sessionStateString); await receiver.SetSessionStateAsync(sessionState); var returnedSessionState = await receiver.GetSessionStateAsync(); var returnedSessionStateString = returnedSessionState.ToString(); Assert.AreEqual(sessionStateString, returnedSessionStateString); // Complete message using Session Receiver await receiver.CompleteMessageAsync(receivedMessage); var peekedMessage = receiver.PeekMessageAsync(); Assert.IsNull(peekedMessage.Result); sessionStateString = "Completed Message On Session!"; sessionState = new BinaryData(sessionStateString); await receiver.SetSessionStateAsync(sessionState); returnedSessionState = await receiver.GetSessionStateAsync(); returnedSessionStateString = returnedSessionState.ToString(); Assert.AreEqual(sessionStateString, returnedSessionStateString); } }
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.CreateSender(scope.QueueName); var messageCount = 10; var sessionId = "sessionId1"; using ServiceBusMessageBatch batch = await sender.CreateMessageBatchAsync(); IEnumerable <ServiceBusMessage> messages = AddMessages(batch, messageCount, sessionId).AsEnumerable <ServiceBusMessage>(); await sender.SendMessagesAsync(batch); var receiver = await client.AcceptSessionAsync( scope.QueueName, 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.ReceiveMessagesAsync(remainingMessages)) { remainingMessages--; messageEnum.MoveNext(); Assert.AreEqual(messageEnum.Current.MessageId, item.MessageId); Assert.AreEqual(messageEnum.Current.SessionId, item.SessionId); sequenceNumbers.Add(item.SequenceNumber); await receiver.DeferMessageAsync(item.LockToken); } } Assert.AreEqual(0, remainingMessages); IReadOnlyList <ServiceBusReceivedMessage> deferedMessages = await receiver.ReceiveDeferredMessagesAsync(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 ReceiveFromSpecificSession() { await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: true)) { string connectionString = TestEnvironment.ServiceBusConnectionString; string queueName = scope.QueueName; // since ServiceBusClient implements IAsyncDisposable we create it with "await using" await using var client = new ServiceBusClient(connectionString); // create the sender ServiceBusSender sender = client.CreateSender(queueName); // create a message batch that we can send ServiceBusMessageBatch messageBatch = await sender.CreateMessageBatchAsync(); messageBatch.TryAddMessage( new ServiceBusMessage(Encoding.UTF8.GetBytes("First")) { SessionId = "Session1" }); messageBatch.TryAddMessage( new ServiceBusMessage(Encoding.UTF8.GetBytes("Second")) { SessionId = "Session2" }); // send the message batch await sender.SendMessagesAsync(messageBatch); #region Snippet:ServiceBusReceiveFromSpecificSession // create a receiver specifying a particular session ServiceBusSessionReceiver receiver = await client.AcceptSessionAsync( queueName, "Session2"); // the received message is a different type as it contains some service set properties ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveMessageAsync(); Console.WriteLine(receivedMessage.SessionId); #endregion Assert.AreEqual(Encoding.UTF8.GetBytes("Second"), receivedMessage.Body.ToBytes().ToArray()); Assert.AreEqual("Session2", receivedMessage.SessionId); } }
public static async Task <ServiceBusReceivedMessage> GetMessageFromSessionAsync(string connectionString, string queueName, string sessionId) { await using var client = new ServiceBusClient(connectionString); ServiceBusSessionReceiver receiver = null; if (string.IsNullOrEmpty(sessionId)) { receiver = await client.AcceptNextSessionAsync(queueName); } else { receiver = await client.AcceptSessionAsync(queueName, sessionId); } // the received message is a different type as it contains some service set properties return(await receiver.ReceiveMessageAsync()); }
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.CreateMessageBatchAsync(); IEnumerable <ServiceBusMessage> messages = AddMessages(batch, messageCount, sessionId).AsEnumerable <ServiceBusMessage>(); await sender.SendMessagesAsync(batch); var clientOptions = new ServiceBusSessionReceiverOptions { ReceiveMode = ServiceBusReceiveMode.ReceiveAndDelete }; ServiceBusReceiver receiver = await client.AcceptSessionAsync( scope.QueueName, sessionId, clientOptions); var remainingMessages = messageCount; var messageEnum = messages.GetEnumerator(); while (remainingMessages > 0) { foreach (var item in await receiver.ReceiveMessagesAsync(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.PeekMessageAsync(); Assert.IsNull(peekedMessage.Result); } }
public async Task GetChildClientFromClosedParentClientThrows(bool useSessions) { await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: true, enableSession: useSessions)) { var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString); var sender = client.CreateSender(scope.QueueName); var message = GetMessage(useSessions ? "sessionId" : null); await sender.SendMessageAsync(message); await sender.DisposeAsync(); ServiceBusReceiver receiver; if (!useSessions) { receiver = client.CreateReceiver(scope.QueueName); } else { receiver = await client.AcceptNextSessionAsync(scope.QueueName); } var receivedMessage = await receiver.ReceiveMessageAsync().ConfigureAwait(false); Assert.AreEqual(message.Body.ToString(), receivedMessage.Body.ToString()); await client.DisposeAsync(); Assert.IsTrue(client.IsClosed); if (!useSessions) { Assert.Throws <ObjectDisposedException>(() => client.CreateReceiver(scope.QueueName)); Assert.Throws <ObjectDisposedException>(() => client.CreateReceiver(scope.QueueName, scope.QueueName)); Assert.Throws <ObjectDisposedException>(() => client.CreateSender(scope.QueueName)); } else { Assert.ThrowsAsync <ObjectDisposedException>(async() => await client.AcceptNextSessionAsync(scope.QueueName)); Assert.ThrowsAsync <ObjectDisposedException>(async() => await client.AcceptSessionAsync( scope.QueueName, "sessionId")); } Assert.Throws <ObjectDisposedException>(() => client.CreateProcessor(scope.QueueName)); } }
public async Task CompleteMessages(bool useSpecificSession) { 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.CreateMessageBatchAsync(); IEnumerable <ServiceBusMessage> messages = ServiceBusTestUtilities.AddMessages(batch, messageCount, sessionId).AsReadOnly <ServiceBusMessage>(); await sender.SendMessagesAsync(batch); ServiceBusReceiver receiver = await client.AcceptSessionAsync( scope.QueueName, useSpecificSession?sessionId : null); var messageEnum = messages.GetEnumerator(); var remainingMessages = messageCount; while (remainingMessages > 0) { foreach (var item in await receiver.ReceiveMessagesAsync(remainingMessages)) { remainingMessages--; messageEnum.MoveNext(); Assert.AreEqual(messageEnum.Current.MessageId, item.MessageId); Assert.AreEqual(messageEnum.Current.SessionId, item.SessionId); await receiver.CompleteMessageAsync(item); } } Assert.AreEqual(0, remainingMessages); var peekedMessage = receiver.PeekMessageAsync(); Assert.IsNull(peekedMessage.Result); } }
public async Task DeadLetterMessagesSubscription(bool useSpecificSession) { await using (var scope = await ServiceBusScope.CreateWithTopic(enablePartitioning: false, enableSession: true)) { await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString); ServiceBusSender sender = client.CreateSender(scope.TopicName); var messageCount = 10; var sessionId = "sessionId1"; using ServiceBusMessageBatch batch = await sender.CreateMessageBatchAsync(); IEnumerable <ServiceBusMessage> messages = AddMessages(batch, messageCount, sessionId).AsEnumerable <ServiceBusMessage>(); await sender.SendMessagesAsync(batch); var topicName = scope.TopicName; var subscriptionName = scope.SubscriptionNames.First(); var receiver = await client.AcceptSessionAsync( topicName : topicName, subscriptionName : subscriptionName, useSpecificSession?sessionId : null); var remainingMessages = messageCount; var messageEnum = messages.GetEnumerator(); while (remainingMessages > 0) { foreach (var item in await receiver.ReceiveMessagesAsync(remainingMessages)) { remainingMessages--; messageEnum.MoveNext(); Assert.AreEqual(messageEnum.Current.MessageId, item.MessageId); Assert.AreEqual(messageEnum.Current.SessionId, item.SessionId); var props = new Dictionary <string, object>(); // these should be ignored by DeadLetter property getters as they are not strings props[AmqpMessageConstants.DeadLetterReasonHeader] = DateTime.UtcNow; props[AmqpMessageConstants.DeadLetterErrorDescriptionHeader] = DateTime.UtcNow; await receiver.DeadLetterMessageAsync(item.LockToken, props); } } Assert.AreEqual(0, remainingMessages); var peekedMessage = receiver.PeekMessageAsync(); Assert.IsNull(peekedMessage.Result); messageEnum.Reset(); remainingMessages = messageCount; var deadLetterReceiver = client.CreateReceiver(topicName, subscriptionName, new ServiceBusReceiverOptions { SubQueue = SubQueue.DeadLetter }); while (remainingMessages > 0) { foreach (var msg in await deadLetterReceiver.ReceiveMessagesAsync(remainingMessages)) { remainingMessages--; messageEnum.MoveNext(); Assert.AreEqual(messageEnum.Current.MessageId, msg.MessageId); Assert.AreEqual(messageEnum.Current.SessionId, msg.SessionId); Assert.IsNull(msg.DeadLetterErrorDescription); Assert.IsNull(msg.DeadLetterReason); Assert.IsNotNull(msg.ApplicationProperties[AmqpMessageConstants.DeadLetterReasonHeader]); Assert.IsNotNull(msg.ApplicationProperties[AmqpMessageConstants.DeadLetterErrorDescriptionHeader]); await deadLetterReceiver.CompleteMessageAsync(msg.LockToken); } } Assert.AreEqual(0, remainingMessages); var deadLetterMessage = await deadLetterReceiver.PeekMessageAsync(); Assert.IsNull(deadLetterMessage); } }
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.CreateSender(scope.QueueName); var messageCount = 10; var sessionId = "sessionId1"; using ServiceBusMessageBatch batch = await sender.CreateMessageBatchAsync(); IEnumerable <ServiceBusMessage> messages = AddMessages(batch, messageCount, sessionId).AsEnumerable <ServiceBusMessage>(); await sender.SendMessagesAsync(batch); var receiver = await client.AcceptSessionAsync( scope.QueueName, useSpecificSession?sessionId : null); var remainingMessages = messageCount; var messageEnum = messages.GetEnumerator(); while (remainingMessages > 0) { foreach (var item in await receiver.ReceiveMessagesAsync(remainingMessages)) { remainingMessages--; messageEnum.MoveNext(); Assert.AreEqual(messageEnum.Current.MessageId, item.MessageId); Assert.AreEqual(messageEnum.Current.SessionId, item.SessionId); await receiver.DeadLetterMessageAsync(item.LockToken, "testReason", "testDescription"); } } Assert.AreEqual(0, remainingMessages); var peekedMessage = receiver.PeekMessageAsync(); Assert.IsNull(peekedMessage.Result); messageEnum.Reset(); remainingMessages = messageCount; var deadLetterReceiver = client.CreateReceiver(scope.QueueName, new ServiceBusReceiverOptions { SubQueue = SubQueue.DeadLetter }); while (remainingMessages > 0) { foreach (var msg in await deadLetterReceiver.ReceiveMessagesAsync(remainingMessages)) { remainingMessages--; messageEnum.MoveNext(); Assert.AreEqual(messageEnum.Current.MessageId, msg.MessageId); Assert.AreEqual(messageEnum.Current.SessionId, msg.SessionId); Assert.AreEqual("testReason", msg.DeadLetterReason); Assert.AreEqual("testDescription", msg.DeadLetterErrorDescription); await deadLetterReceiver.CompleteMessageAsync(msg.LockToken); } } Assert.AreEqual(0, remainingMessages); var deadLetterMessage = await deadLetterReceiver.PeekMessageAsync(); Assert.IsNull(deadLetterMessage); } }
public async Task ReceiverCanReconnectToSameSession(bool isSessionSpecified) { await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: true, lockDuration: TimeSpan.FromSeconds(5))) { await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString); ServiceBusSender sender = client.CreateSender(scope.QueueName); await sender.SendMessagesAsync(GetMessages(3, "sessionId1")); // send another session message before the one we are interested in to make sure that when isSessionSpecified=true, it is being respected await sender.SendMessagesAsync(GetMessages(3, "sessionId2")); ServiceBusSessionReceiver receiver = await client.AcceptSessionAsync( scope.QueueName, isSessionSpecified? "sessionId1" : null); if (isSessionSpecified) { Assert.AreEqual("sessionId1", receiver.SessionId); } var firstMessage = await receiver.ReceiveMessageAsync(); Assert.AreEqual(receiver.SessionId, firstMessage.SessionId); var sessionId = receiver.SessionId; await Task.Delay((receiver.SessionLockedUntil - DateTime.UtcNow) + TimeSpan.FromSeconds(5)); var secondMessage = await receiver.ReceiveMessageAsync(); Assert.AreEqual(sessionId, receiver.SessionId); Assert.AreEqual(receiver.SessionId, secondMessage.SessionId); // Even though the receiver has re-established the session link, since the first message was // received before we reconnected, the message won't be able to be settled. This is analogous // to the case of reconnecting a regular non-session link and getting a MessageLockLost error. Assert.That( async() => await receiver.CompleteMessageAsync(firstMessage), Throws.InstanceOf <ServiceBusException>().And.Property(nameof(ServiceBusException.Reason)).EqualTo(ServiceBusFailureReason.SessionLockLost)); await Task.Delay((receiver.SessionLockedUntil - DateTime.UtcNow) + TimeSpan.FromSeconds(5)); // If another receiver accepts the session after the lock is lost, we expect a SessionCannotBeLocked error, // when we try to receive again with our initial receiver. ServiceBusSessionReceiver secondReceiver = await client.AcceptSessionAsync( scope.QueueName, sessionId); try { await receiver.ReceiveMessageAsync(); } catch (ServiceBusException ex) when(ex.Reason == ServiceBusFailureReason.SessionCannotBeLocked) { return; } catch (Exception ex) { Assert.Fail($"Expected exception not thrown: {ex}"); } Assert.Fail("No exception thrown!"); } }