public async Task ScheduleMessage() { await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false)) { 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); // get the sender ServiceBusSender sender = client.GetSender(queueName); // create a message that we can send ServiceBusMessage message = new ServiceBusMessage(Encoding.Default.GetBytes("Hello world!")); // schedule the message for tomorrow // this prevents the message from being enqueued until tomorrow, but it can still be peeked long seq = await sender.ScheduleMessageAsync( message, DateTimeOffset.Now.AddDays(1)); // get a receiver that we can use to peek the message ServiceBusReceiver receiver = client.GetReceiver(queueName); Assert.IsNotNull(await receiver.PeekAsync()); // cancel the scheduled messaged, thereby deleting from the service await sender.CancelScheduledMessageAsync(seq); Assert.IsNull(await receiver.PeekAsync()); } }
public async Task ScheduleMessage() { await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false)) { 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 that we can send ServiceBusMessage message = new ServiceBusMessage(Encoding.UTF8.GetBytes("Hello world!")); #region Snippet:ServiceBusSchedule long seq = await sender.ScheduleMessageAsync( message, DateTimeOffset.Now.AddDays(1)); #endregion // create a receiver that we can use to peek the message ServiceBusReceiver receiver = client.CreateReceiver(queueName); Assert.IsNotNull(await receiver.PeekAsync()); // cancel the scheduled messaged, thereby deleting from the service #region Snippet:ServiceBusCancelScheduled await sender.CancelScheduledMessageAsync(seq); #endregion Assert.IsNull(await receiver.PeekAsync()); } }
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.CreateSender(scope.QueueName); var sessionId = Guid.NewGuid().ToString(); // send the messages using ServiceBusMessageBatch batch = await sender.CreateBatchAsync(); ServiceBusMessageBatch messagebatch = AddMessages(batch, messageCt, sessionId); await sender.SendAsync(messagebatch); ServiceBusReceiver receiver = await client.CreateSessionReceiverAsync(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 SendAndPeekMessage() { await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false)) { string connectionString = TestEnvironment.ServiceBusConnectionString; string queueName = scope.QueueName; await using var client = new ServiceBusClient(connectionString); // create the sender ServiceBusSender sender = client.CreateSender(queueName); // create a message that we can send ServiceBusMessage message = new ServiceBusMessage(Encoding.UTF8.GetBytes("Hello world!")); // send the message await sender.SendAsync(message); // create a receiver that we can use to receive the message ServiceBusReceiver receiver = client.CreateReceiver(queueName); #region Snippet:ServiceBusPeek ServiceBusReceivedMessage peekedMessage = await receiver.PeekAsync(); #endregion // get the message body as a string string body = Encoding.UTF8.GetString(peekedMessage.Body.ToArray()); Assert.AreEqual(Encoding.UTF8.GetBytes("Hello world!"), peekedMessage.Body.ToArray()); } }
public void PeekMessageExceptionLogsEvents() { var mockLogger = new Mock <ServiceBusEventSource>(); var mockTransportReceiver = new Mock <TransportReceiver>(); var mockConnection = GetMockConnection(mockTransportReceiver); mockTransportReceiver.Setup( transportReceiver => transportReceiver.PeekBatchAtAsync( It.IsAny <long?>(), 1, It.IsAny <CancellationToken>())) .Throws(new Exception()); var receiver = new ServiceBusReceiver(mockConnection.Object, "queueName", false, new ServiceBusReceiverOptions()) { Logger = mockLogger.Object }; Assert.That( async() => await receiver.PeekAsync(), Throws.InstanceOf <Exception>()); mockLogger .Verify( log => log.PeekMessageStart( receiver.Identifier, null, 1), Times.Once); mockLogger .Verify( log => log.PeekMessageException( receiver.Identifier, It.IsAny <string>()), Times.Once); }
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.GetSender(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.SendAsync(GetMessage("sessionId2")); await sender.SendAsync(message); ServiceBusReceiver receiver = await client.GetSessionReceiverAsync(scope.QueueName, sessionId : isSessionSpecified?sessionId1 : null); var session = receiver.GetSessionManager(); if (isSessionSpecified) { Assert.AreEqual(sessionId1, session.SessionId); } ServiceBusReceivedMessage[] receivedMessages = (await receiver.ReceiveBatchAsync(messageCount)).ToArray(); var receivedMessage = receivedMessages.First(); var firstLockedUntilUtcTime = session.LockedUntil; // Sleeping for 10 seconds... await Task.Delay(10000); await session.RenewSessionLockAsync(); Assert.True(session.LockedUntil >= firstLockedUntilUtcTime + TimeSpan.FromSeconds(10)); // Complete Messages await receiver.CompleteAsync(receivedMessage.LockToken); Assert.AreEqual(messageCount, receivedMessages.Length); if (isSessionSpecified) { Assert.AreEqual(message.MessageId, receivedMessage.MessageId); } var peekedMessage = receiver.PeekAsync(); Assert.IsNull(peekedMessage.Result); } }
public async Task PeekSingleMessageLogsEvents(bool specifySeqNumber) { var mockLogger = new Mock <ServiceBusEventSource>(); var mockTransportReceiver = new Mock <TransportReceiver>(); var mockConnection = GetMockConnection(mockTransportReceiver); mockTransportReceiver.Setup( transportReceiver => transportReceiver.PeekBatchAtAsync( It.IsAny <long?>(), It.IsAny <int>(), It.IsAny <CancellationToken>())) .Returns( Task.FromResult((IList <ServiceBusReceivedMessage>) new List <ServiceBusReceivedMessage> { new ServiceBusReceivedMessage() })); var receiver = new ServiceBusReceiver(mockConnection.Object, "queueName", false, new ServiceBusReceiverOptions()) { Logger = mockLogger.Object }; var seqNumber = 5; if (specifySeqNumber) { await receiver.PeekAtAsync(seqNumber); } else { await receiver.PeekAsync(); } mockLogger .Verify( log => log.PeekMessageStart( receiver.Identifier, specifySeqNumber ? (long?)seqNumber : null, 1), Times.Once); mockLogger .Verify( log => log.PeekMessageComplete( receiver.Identifier, 1), Times.Once); }
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.SendAsync(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 TransactionalCancelScheduleRollback() { await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false)) { var options = new ServiceBusClientOptions(); options.RetryOptions.TryTimeout = TimeSpan.FromSeconds(5); options.RetryOptions.MaxRetries = 0; var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString, options); ServiceBusSender sender = client.CreateSender(scope.QueueName); ServiceBusMessage message = GetMessage(); long seq = await sender.ScheduleMessageAsync(message, DateTimeOffset.UtcNow.AddMinutes(1)); using (var ts = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled)) { await sender.CancelScheduledMessageAsync(seq); } ServiceBusReceiver receiver = client.CreateReceiver(scope.QueueName); ServiceBusReceivedMessage msg = await receiver.PeekAsync(); Assert.NotNull(msg); }; }
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.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); 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.CompleteAsync(item); } Assert.AreEqual(messageCount, receivedMessageCount); var peekedMessage = receiver.PeekAsync(); Assert.IsNull(peekedMessage.Result); } }