public async Task ReceiveSingleMessageLogsEvents() { var mockLogger = new Mock <ServiceBusEventSource>(); var mockTransportReceiver = new Mock <TransportReceiver>(); var mockConnection = GetMockConnection(mockTransportReceiver); mockTransportReceiver.Setup( transportReceiver => transportReceiver.ReceiveMessagesAsync( 1, It.IsAny <TimeSpan?>(), It.IsAny <CancellationToken>())) .Returns( Task.FromResult((IReadOnlyList <ServiceBusReceivedMessage>) new List <ServiceBusReceivedMessage> { new ServiceBusReceivedMessage() })); var receiver = new ServiceBusReceiver( mockConnection.Object, "queueName", false, new ServiceBusPlugin[] { }, new ServiceBusReceiverOptions()) { Logger = mockLogger.Object }; await receiver.ReceiveMessageAsync(); mockLogger .Verify( log => log.ReceiveMessageStart( receiver.Identifier, 1), Times.Once); mockLogger .Verify( log => log.ReceiveMessageComplete( receiver.Identifier, 1), Times.Once); mockLogger .Verify( log => log.MaxMessagesExceedsPrefetch( receiver.Identifier, receiver.PrefetchCount, 1), Times.Never); }
public async Task TransactionalSendVia() { await using (var scopeA = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false)) { var scopeB = await ServiceBusScope.CreateWithQueue(enablePartitioning : false, enableSession : false); string connectionString = TestEnvironment.ServiceBusConnectionString; string queueA = scopeA.QueueName; string queueB = scopeB.QueueName; await using var client = GetClient(); #region Snippet:ServiceBusTransactionalSendVia //@@ string connectionString = "<connection_string>"; //@@ string queueA = "<queue_name>"; //@@ string queueB = "<other_queue_name>"; // since ServiceBusClient implements IAsyncDisposable we create it with "await using" //@@ await using var client = new ServiceBusClient(connectionString); ServiceBusSender senderA = client.CreateSender(queueA); await senderA.SendAsync(new ServiceBusMessage(Encoding.UTF8.GetBytes("First"))); ServiceBusSender senderBViaA = client.CreateSender(queueB, new ServiceBusSenderOptions { ViaQueueOrTopicName = queueA }); ServiceBusReceiver receiverA = client.CreateReceiver(queueA); ServiceBusReceivedMessage firstMessage = await receiverA.ReceiveAsync(); using (var ts = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled)) { await receiverA.CompleteAsync(firstMessage); await senderBViaA.SendAsync(new ServiceBusMessage(Encoding.UTF8.GetBytes("Second"))); ts.Complete(); } #endregion ServiceBusReceivedMessage secondMessage = await receiverA.ReceiveAsync(TimeSpan.FromSeconds(5)); Assert.Null(secondMessage); ServiceBusReceiver receiverB = client.CreateReceiver(queueB); secondMessage = await receiverB.ReceiveAsync(TimeSpan.FromSeconds(5)); Assert.NotNull(secondMessage); await receiverB.CompleteAsync(secondMessage); }; }
public async Task SendAndReceiveMessageBatch() { await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false)) { #region Snippet:ServiceBusInitializeSend #if SNIPPET string connectionString = "<connection_string>"; string queueName = "<queue_name>"; #else string connectionString = TestEnvironment.ServiceBusConnectionString; string queueName = scope.QueueName; #endif // 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); #region Snippet:ServiceBusSendAndReceiveBatch IList <ServiceBusMessage> messages = new List <ServiceBusMessage>(); messages.Add(new ServiceBusMessage("First")); messages.Add(new ServiceBusMessage("Second")); // send the messages await sender.SendMessagesAsync(messages); #endregion #endregion #region Snippet:ServiceBusReceiveBatch // create a receiver that we can use to receive the messages ServiceBusReceiver receiver = client.CreateReceiver(queueName); // the received message is a different type as it contains some service set properties IReadOnlyList <ServiceBusReceivedMessage> receivedMessages = await receiver.ReceiveMessagesAsync(maxMessages : 2); foreach (ServiceBusReceivedMessage receivedMessage in receivedMessages) { // get the message body as a string string body = receivedMessage.Body.ToString(); Console.WriteLine(body); } #endregion var sentMessagesEnum = messages.GetEnumerator(); foreach (ServiceBusReceivedMessage receivedMessage in receivedMessages) { sentMessagesEnum.MoveNext(); Assert.AreEqual(sentMessagesEnum.Current.Body.ToString(), receivedMessage.Body.ToString()); } } }
public async Task ForwardingEntity() { // queueName--Fwd to--> destinationName--fwd dlq to-- > dqlDestinationName var queueName = Recording.Random.NewGuid().ToString("D").Substring(0, 8); var destinationName = Recording.Random.NewGuid().ToString("D").Substring(0, 8); var dlqDestinationName = Recording.Random.NewGuid().ToString("D").Substring(0, 8); var mgmtClient = CreateClient(); await mgmtClient.CreateQueueAsync(dlqDestinationName); await mgmtClient.CreateQueueAsync( new CreateQueueOptions(destinationName) { ForwardDeadLetteredMessagesTo = dlqDestinationName }); await mgmtClient.CreateQueueAsync( new CreateQueueOptions(queueName) { ForwardTo = destinationName }); await using var sbClient = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString); ServiceBusSender sender = sbClient.CreateSender(queueName); await sender.SendMessageAsync(new ServiceBusMessage() { MessageId = "mid" }); ServiceBusReceiver receiver = sbClient.CreateReceiver(destinationName); ServiceBusReceivedMessage msg = await receiver.ReceiveMessageAsync(); Assert.NotNull(msg); Assert.AreEqual("mid", msg.MessageId); await receiver.DeadLetterMessageAsync(msg.LockToken); receiver = sbClient.CreateReceiver(dlqDestinationName); msg = await receiver.ReceiveMessageAsync(); Assert.NotNull(msg); Assert.AreEqual("mid", msg.MessageId); await receiver.CompleteMessageAsync(msg.LockToken); await mgmtClient.DeleteQueueAsync(queueName); await mgmtClient.DeleteQueueAsync(destinationName); await mgmtClient.DeleteQueueAsync(dlqDestinationName); }
public async Task TransactionGroup() { await using var client = new ServiceBusClient( TestEnvironment.ServiceBusConnectionString, new ServiceBusClientOptions { EnableCrossEntityTransactions = true }); await using var queueA = await ServiceBusScope.CreateWithQueue(enablePartitioning : false, enableSession : false); await using var queueB = await ServiceBusScope.CreateWithQueue(enablePartitioning : false, enableSession : false); await using var topicC = await ServiceBusScope.CreateWithTopic(enablePartitioning : false, enableSession : false); // The first sender won't be part of our transaction and is // used only to populate the queue. ServiceBusSender senderA = client.CreateSender(queueA.QueueName); await senderA.SendMessageAsync(new ServiceBusMessage()); ServiceBusReceiver receiverA = client.CreateReceiver(queueA.QueueName); ServiceBusSender senderB = client.CreateSender(queueB.QueueName); ServiceBusSender senderC = client.CreateSender(topicC.TopicName); #region Snippet:ServiceBusTransactionGroup //@@ var options = new ServiceBusClientOptions { EnableCrossEntityTransactions = true }; //@@ await using var client = new ServiceBusClient(connectionString, options); //@@ ServiceBusReceiver receiverA = client.CreateReceiver("queueA"); //@@ ServiceBusSender senderB = client.CreateSender("queueB"); //@@ ServiceBusSender senderC = client.CreateSender("topicC"); ServiceBusReceivedMessage receivedMessage = await receiverA.ReceiveMessageAsync(); using (var ts = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled)) { await receiverA.CompleteMessageAsync(receivedMessage); await senderB.SendMessageAsync(new ServiceBusMessage()); await senderC.SendMessageAsync(new ServiceBusMessage()); ts.Complete(); } #endregion receivedMessage = await receiverA.ReceiveMessageAsync(); Assert.IsNull(receivedMessage); }
public async Task PeekBatchOfMessagesLogsEvents(bool specifySeqNumber) { var mockLogger = new Mock <ServiceBusEventSource>(); var maxMessages = 4; var mockTransportReceiver = new Mock <TransportReceiver>(); var mockConnection = GetMockConnection(mockTransportReceiver); mockTransportReceiver.Setup( transportReceiver => transportReceiver.PeekMessagesAsync( It.IsAny <long?>(), maxMessages, It.IsAny <CancellationToken>())) .Returns( Task.FromResult((IReadOnlyList <ServiceBusReceivedMessage>) new List <ServiceBusReceivedMessage> { new ServiceBusReceivedMessage(), new ServiceBusReceivedMessage() })); var receiver = new ServiceBusReceiver( mockConnection.Object, "queueName", false, new ServiceBusPlugin[] { }, new ServiceBusReceiverOptions()) { Logger = mockLogger.Object }; var seqNumber = 5; IReadOnlyList <ServiceBusReceivedMessage> msgs; msgs = await receiver.PeekMessagesAsync(maxMessages, specifySeqNumber?seqNumber : (long?)null); mockLogger .Verify( log => log.PeekMessageStart( receiver.Identifier, specifySeqNumber ? (long?)seqNumber : null, // the amount requested maxMessages), Times.Once); mockLogger .Verify( log => log.PeekMessageComplete( receiver.Identifier, // the amount we actually received msgs.Count), Times.Once); }
public void CreateEventArgs_WithServiceBusReceiver_GetsServiceBusReceiverSucceeds() { // Arrange Order order = OrderGenerator.Generate(); ServiceBusReceivedMessage message = order.AsServiceBusReceivedMessage(); var expectedReceiver = Mock.Of <ServiceBusReceiver>(); // Act var eventArgs = new ProcessMessageEventArgs(message, expectedReceiver, CancellationToken.None); // Assert ServiceBusReceiver actualReceiver = eventArgs.GetServiceBusReceiver(); Assert.Equal(expectedReceiver, actualReceiver); }
public static async Task <long> DeferMessageAsync(string connectionString, string queueName) { await using var client = new ServiceBusClient(connectionString); // create a receiver that we can use to receive the message ServiceBusReceiver receiver = client.CreateReceiver(queueName); ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveMessageAsync(); // defer the message, thereby preventing the message from being received again without using // the received deferred message API. await receiver.DeferMessageAsync(receivedMessage); return(receivedMessage.SequenceNumber); }
public static async Task TopicNoSessions( [ServiceBusTrigger(TopicNameKey, FirstSubscriptionNameKey)] ServiceBusReceivedMessage msg, ServiceBusReceiver messageReceiver, CancellationToken cancellationToken, ILogger logger) { logger.LogInformation($"DrainModeValidationFunctions.NoSessions: message data {msg.Body}"); _drainValidationPreDelay.Set(); await DrainModeHelper.WaitForCancellation(cancellationToken); Assert.True(cancellationToken.IsCancellationRequested); await messageReceiver.CompleteMessageAsync(msg); _drainValidationPostDelay.Set(); }
public void Setup() { _mockExecutor = new Mock <ITriggeredFunctionExecutor>(MockBehavior.Strict); _client = new ServiceBusClient(_testConnection); ServiceBusProcessorOptions processorOptions = new ServiceBusProcessorOptions(); ServiceBusProcessor messageProcessor = _client.CreateProcessor(_entityPath); ServiceBusReceiver receiver = _client.CreateReceiver(_entityPath); _mockMessageProcessor = new Mock <MessageProcessor>(MockBehavior.Strict, messageProcessor); var configuration = ConfigurationUtilities.CreateConfiguration(new KeyValuePair <string, string>(_connection, _testConnection)); _serviceBusOptions = new ServiceBusOptions(); _mockProvider = new Mock <MessagingProvider>(new OptionsWrapper <ServiceBusOptions>(_serviceBusOptions)); _mockClientFactory = new Mock <ServiceBusClientFactory>( configuration, Mock.Of <AzureComponentFactory>(), _mockProvider.Object, new AzureEventSourceLogForwarder(new NullLoggerFactory()), new OptionsWrapper <ServiceBusOptions>(_serviceBusOptions)); _mockProvider .Setup(p => p.CreateMessageProcessor(_client, _entityPath, It.IsAny <ServiceBusProcessorOptions>())) .Returns(_mockMessageProcessor.Object); _mockProvider .Setup(p => p.CreateClient(_testConnection, It.IsAny <ServiceBusClientOptions>())) .Returns(_client); _loggerFactory = new LoggerFactory(); _loggerProvider = new TestLoggerProvider(); _loggerFactory.AddProvider(_loggerProvider); _listener = new ServiceBusListener( _functionId, ServiceBusEntityType.Queue, _entityPath, false, _serviceBusOptions.AutoCompleteMessages, _mockExecutor.Object, _serviceBusOptions, _connection, _mockProvider.Object, _loggerFactory, false, _mockClientFactory.Object); _scaleMonitor = (ServiceBusScaleMonitor)_listener.GetMonitor(); }
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; 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); await receiver.AbandonAsync(item.LockToken); Assert.AreEqual(item.DeliveryCount, 1); } } Assert.AreEqual(0, remainingMessages); 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 ReceiveMessagesWhenQueueEmpty() { await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: true)) { await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString, new ServiceBusClientOptions { RetryOptions = { // very high TryTimeout TryTimeout = TimeSpan.FromSeconds(120) } }); var messageCount = 2; var sessionId = "sessionId1"; ServiceBusSender sender = client.CreateSender(scope.QueueName); using ServiceBusMessageBatch batch = await sender.CreateMessageBatchAsync(); IEnumerable <ServiceBusMessage> messages = AddMessages(batch, messageCount, sessionId).AsEnumerable <ServiceBusMessage>(); await sender.SendMessagesAsync(batch); ServiceBusReceiver receiver = await client.AcceptNextSessionAsync( scope.QueueName, new ServiceBusSessionReceiverOptions { PrefetchCount = 100 }); var remainingMessages = messageCount; while (remainingMessages > 0) { foreach (var message in await receiver.ReceiveMessagesAsync(remainingMessages)) { await receiver.CompleteMessageAsync(message); remainingMessages--; } } using var cancellationTokenSource = new CancellationTokenSource(TimeSpan.FromSeconds(3)); var start = DateTime.UtcNow; Assert.ThrowsAsync <TaskCanceledException>(async() => await receiver.ReceiveMessagesAsync(1, cancellationToken: cancellationTokenSource.Token)); var stop = DateTime.UtcNow; Assert.That(stop - start, Is.EqualTo(TimeSpan.FromSeconds(3)).Within(TimeSpan.FromSeconds(3))); } }
private static async Task ReceiveMessageAsync(string connectionString, string queueName) { // create a Service Bus client await using (ServiceBusClient client = new ServiceBusClient(connectionString)) { // create a sender for the queue ServiceBusReceiver receiver = client.CreateReceiver(queueName, new ServiceBusReceiverOptions() { ReceiveMode = ServiceBusReceiveMode.PeekLock }); // receive the message Console.WriteLine($"Sent a single message to the queue: {queueName}"); } }
/// <summary> /// Initialize a received item with all Sql Transactional Outbox data. The resulting item will /// allow for specific handling of the Message Acknowledgement/Rejection/Dead-lettering if the correct Reciever is provided. /// NOTE: With Azure Functions there is no client when used with Function Bindings because this is handled /// by the Azure Functions framework when the Message is returned, so this should be a No-op if null/not-specified! /// </summary> /// <param name="azureServiceBusMessage"></param> /// <param name="outboxItemFactory"></param> /// <param name="azureServiceBusReceiverClient"></param> public AzureServiceBusReceivedItem( ServiceBusReceivedMessage azureServiceBusMessage, ISqlTransactionalOutboxItemFactory <TUniqueIdentifier, TPayloadBody> outboxItemFactory, //Client is OPTIONAL; necessary when processing will be handled by AzureFunctions framework bindings, etc. ServiceBusReceiver azureServiceBusReceiverClient = null ) { //Provide access to the original Azure Service Bus Message for customized Advanced functionality. this.AzureServiceBusMessage = azureServiceBusMessage.AssertNotNull(nameof(azureServiceBusMessage)); this.ServiceBusReceiver = azureServiceBusReceiverClient; this.OutboxItemFactory = outboxItemFactory.AssertNotNull(nameof(outboxItemFactory)); bool isFifoProcessingEnabled = azureServiceBusReceiverClient is ServiceBusSessionReceiver; this.InitAzureServiceBusOutboxReceivedItem(isFifoProcessingEnabled); }
public MessageServiceAzureServiceBus(ApplicationSettings applicationSettings) { _applicationSettings = applicationSettings; // Create a ServiceBusClient that will authenticate using a connection string string connectionString = _applicationSettings.QueueConnectionString; string queueName = _applicationSettings.QueueName; // since ServiceBusClient implements IAsyncDisposable we create it with "await using" var options = new ServiceBusClientOptions { EnableCrossEntityTransactions = true }; var client = new ServiceBusClient(connectionString, options); // Create the sender and receiver _sender = client.CreateSender(queueName); _receiver = client.CreateReceiver(queueName); }
// Passes service bus message from a queue to another queue public async Task SBQueue2SBQueue( [ServiceBusTrigger(FirstQueueNameKey)] string start, int deliveryCount, ServiceBusReceiver messageReceiver, string lockToken, [ServiceBus(SecondQueueNameKey)] ServiceBusSender messageSender) { Assert.AreEqual(_firstQueueScope.QueueName, messageReceiver.EntityPath); Assert.AreEqual(1, deliveryCount); // verify the message receiver and token are valid // TODO lockToken overload not supported in new SDK //await messageReceiver.RenewLockAsync(lockToken); var message = SBQueue2SBQueue_GetOutputMessage(start); await messageSender.SendMessageAsync(message); }
public async Task SendAndReceiveMessageSafeBatch() { await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false)) { string connectionString = TestEnvironment.ServiceBusConnectionString; string queueName = scope.QueueName; //@@ 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); // create the sender ServiceBusSender sender = client.CreateSender(queueName); // create a message batch that we can send #region Snippet:ServiceBusSendAndReceiveSafeBatch 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.SendAsync(messageBatch); #endregion // create a receiver that we can use to receive the messages ServiceBusReceiver receiver = client.CreateReceiver(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.UTF8.GetString(receivedMessage.Body.ToArray()); Console.WriteLine(body); } var sentMessagesEnum = messageBatch.AsEnumerable <ServiceBusMessage>().GetEnumerator(); foreach (ServiceBusReceivedMessage receivedMessage in receivedMessages) { sentMessagesEnum.MoveNext(); Assert.AreEqual(sentMessagesEnum.Current.Body.ToArray(), receivedMessage.Body.ToArray()); } } }
public void DeadLetterMessageExceptionLogsEvents() { var mockLogger = new Mock <ServiceBusEventSource>(); var mockTransportReceiver = new Mock <TransportReceiver>(); var mockConnection = GetMockConnection(mockTransportReceiver); mockTransportReceiver.Setup( transportReceiver => transportReceiver.DeadLetterAsync( It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <IDictionary <string, object> >(), It.IsAny <CancellationToken>())) .Throws(new Exception()); var receiver = new ServiceBusReceiver( mockConnection.Object, "queueName", false, new ServiceBusPlugin[] { }, new ServiceBusReceiverOptions()) { Logger = mockLogger.Object }; var msg = new ServiceBusReceivedMessage() { LockTokenGuid = Guid.NewGuid() }; Assert.That( async() => await receiver.DeadLetterMessageAsync(msg), Throws.InstanceOf <Exception>()); mockLogger .Verify( log => log.DeadLetterMessageStart( receiver.Identifier, 1, msg.LockToken), Times.Once); mockLogger .Verify( log => log.DeadLetterMessageException( 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 ReceiveBatchOfMessagesLogsEvents() { var mockLogger = new Mock <ServiceBusEventSource>(); var maxMessages = 4; var mockTransportReceiver = new Mock <TransportReceiver>(); var mockConnection = GetMockConnection(mockTransportReceiver); mockTransportReceiver.Setup( transportReceiver => transportReceiver.ReceiveMessagesAsync( maxMessages, It.IsAny <TimeSpan?>(), It.IsAny <CancellationToken>())) .Returns( Task.FromResult((IList <ServiceBusReceivedMessage>) new List <ServiceBusReceivedMessage> { new ServiceBusReceivedMessage(), new ServiceBusReceivedMessage() })); var receiver = new ServiceBusReceiver( mockConnection.Object, "queueName", false, new ServiceBusPlugin[] { }, new ServiceBusReceiverOptions()) { Logger = mockLogger.Object }; var msgs = await receiver.ReceiveMessagesAsync(maxMessages : maxMessages); mockLogger .Verify( log => log.ReceiveMessageStart( receiver.Identifier, // the amount requested maxMessages), Times.Once); mockLogger .Verify( log => log.ReceiveMessageComplete( receiver.Identifier, // the amount we actually received msgs.Count), Times.Once); }
public async Task TransactionCommitWorksUsingSendersAndReceiversFromSameClients() { await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false)) { var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString); ServiceBusSender sender = client.CreateSender(scope.QueueName); ServiceBusReceiver receiver = client.CreateReceiver(scope.QueueName); ServiceBusMessage message1 = GetMessage(); ServiceBusMessage message2 = GetMessage(); await sender.SendAsync(message1); ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveAsync(); Assert.NotNull(receivedMessage); Assert.AreEqual(message1.Body.ToString(), receivedMessage.Body.ToString()); using (var ts = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled)) { await receiver.CompleteAsync(receivedMessage); await sender.SendAsync(message2); ts.Complete(); } // Adding delay since transaction Commit/Rollback is an asynchronous operation. // Operating on the same message should not be done. await Task.Delay(TimeSpan.FromSeconds(2)); // Assert that complete did succeed Assert.That( async() => await receiver.CompleteAsync(receivedMessage), Throws.InstanceOf <ServiceBusException>() .And.Property(nameof(ServiceBusException.Reason)) .EqualTo(ServiceBusException.FailureReason.MessageLockLost)); // Assert that send did succeed receivedMessage = await receiver.ReceiveAsync(); Assert.NotNull(receivedMessage); Assert.AreEqual(message2.Body.ToString(), receivedMessage.Body.ToString()); await receiver.CompleteAsync(receivedMessage); } }
private async Task ProcessMessageAsync(ProcessMessageEventArgs args) { ServiceBusReceivedMessage message = args?.Message; if (message is null) { Logger.LogWarning("Received message on Azure Service Bus message pump '{JobId}' was null, skipping", JobId); return; } if (_isHostShuttingDown) { Logger.LogWarning("Abandoning message with ID '{MessageId}' as the Azure Service Bus message pump is shutting down", message.MessageId); await args.AbandonMessageAsync(message); return; } if (String.IsNullOrEmpty(message.CorrelationId)) { Logger.LogTrace("No operation ID was found on the message '{MessageId}' during processing in the Azure Service Bus message pump '{JobId}'", message.MessageId, JobId); } AzureServiceBusMessageContext messageContext = message.GetMessageContext(JobId); MessageCorrelationInfo correlationInfo = message.GetCorrelationInfo(Settings.Options.Correlation?.TransactionIdPropertyName ?? PropertyNames.TransactionId); ServiceBusReceiver receiver = args.GetServiceBusReceiver(); using (IServiceScope serviceScope = ServiceProvider.CreateScope()) { var correlationInfoAccessor = serviceScope.ServiceProvider.GetService <ICorrelationInfoAccessor <MessageCorrelationInfo> >(); if (correlationInfoAccessor is null) { Logger.LogTrace("No message correlation configured in Azure Service Bus message pump '{JobId}' while processing message '{MessageId}'", JobId, message.MessageId); await _messageRouter.RouteMessageAsync(receiver, args.Message, messageContext, correlationInfo, args.CancellationToken); } else { correlationInfoAccessor.SetCorrelationInfo(correlationInfo); using (LogContext.Push(new MessageCorrelationInfoEnricher(correlationInfoAccessor))) { await _messageRouter.RouteMessageAsync(receiver, args.Message, messageContext, correlationInfo, args.CancellationToken); } } } }
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 <ServiceBusReceivedMessage> ReceiveMessageAsync(string queueName) { string connectionString = ConfigurationManager.AppSettings["StorageConnectionString"]; // create a Service Bus client await using (ServiceBusClient client = new ServiceBusClient(connectionString)) { // create a sender for the queue ServiceBusReceiver receiver = client.CreateReceiver(queueName, new ServiceBusReceiverOptions { ReceiveMode = ServiceBusReceiveMode.ReceiveAndDelete }); ServiceBusReceivedMessage message = await receiver.ReceiveMessageAsync(); return(message); } }
public static async Task TopicNoSessionsBatch( [ServiceBusTrigger(TopicNameKey, FirstSubscriptionNameKey)] ServiceBusReceivedMessage[] array, ServiceBusReceiver messageReceiver, CancellationToken cancellationToken, ILogger logger) { Assert.True(array.Length > 0); logger.LogInformation($"DrainModeTestJobBatch.TopicNoSessionsBatch: received {array.Length} messages"); _drainValidationPreDelay.Set(); await DrainModeHelper.WaitForCancellation(cancellationToken); Assert.True(cancellationToken.IsCancellationRequested); foreach (ServiceBusReceivedMessage msg in array) { await messageReceiver.CompleteMessageAsync(msg); } _drainValidationPostDelay.Set(); }
/// <summary> /// Delete Messages /// </summary> /// <returns></returns> public async Task DeleteMessagesAsync() { var a = new Appsettings(); await using var queueClient = new ServiceBusClient(Appsettings.app("ServiceBus", "PrimaryConnectionString")); try { // create a receiver that we can use to receive the message ServiceBusReceiver receiver = queueClient.CreateReceiver(Appsettings.app("ServiceBus", "QueueName")); ServiceBusReceivedMessage peekedMessage = await receiver.ReceiveMessageAsync(); await receiver.CompleteMessageAsync(peekedMessage); } catch (Exception ex) { Console.WriteLine(ex.Message); } }
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 ServiceBusListenerTests() { _mockExecutor = new Mock <ITriggeredFunctionExecutor>(MockBehavior.Strict); var client = new ServiceBusClient(_testConnection); ServiceBusProcessor processor = client.CreateProcessor(_entityPath); ServiceBusReceiver receiver = client.CreateReceiver(_entityPath); var configuration = ConfigurationUtilities.CreateConfiguration(new KeyValuePair <string, string>("connection", _testConnection)); ServiceBusOptions config = new ServiceBusOptions { ExceptionHandler = ExceptionReceivedHandler }; _mockMessageProcessor = new Mock <MessageProcessor>(MockBehavior.Strict, processor); _mockMessagingProvider = new Mock <MessagingProvider>(new OptionsWrapper <ServiceBusOptions>(config)); _mockClientFactory = new Mock <ServiceBusClientFactory>(configuration, Mock.Of <AzureComponentFactory>(), _mockMessagingProvider.Object, new AzureEventSourceLogForwarder(new NullLoggerFactory()), new OptionsWrapper <ServiceBusOptions>(new ServiceBusOptions())); _mockMessagingProvider .Setup(p => p.CreateMessageProcessor(It.IsAny <ServiceBusClient>(), _entityPath, It.IsAny <ServiceBusProcessorOptions>())) .Returns(_mockMessageProcessor.Object); _mockMessagingProvider .Setup(p => p.CreateBatchMessageReceiver(It.IsAny <ServiceBusClient>(), _entityPath, default)) .Returns(receiver); _loggerFactory = new LoggerFactory(); _loggerProvider = new TestLoggerProvider(); _loggerFactory.AddProvider(_loggerProvider); _listener = new ServiceBusListener( _functionId, ServiceBusEntityType.Queue, _entityPath, false, config.AutoCompleteMessages, _mockExecutor.Object, config, "connection", _mockMessagingProvider.Object, _loggerFactory, false, _mockClientFactory.Object); }
static async Task Main(string[] args) { string connectionString = "Endpoint = sb://trialbus.servicebus.windows.net/;SharedAccessKeyName=RootManageSharedAccessKey;SharedAccessKey=xN4pYhOcgxH5UL+0cUeguN5hjsi/1gFtGZkS6nZy/2Q="; string queueName = "demoqueue"; await using ServiceBusClient client = new ServiceBusClient(connectionString); // create a receiver that we can use to receive the message ServiceBusReceiver receiver = client.CreateReceiver(queueName); // the received message is a different type as it contains some service set properties ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveMessageAsync(); // get the message body as a string string body = receivedMessage.Body.ToString(); Console.WriteLine(body); }
public static async Task ReceivedMessagesAsync(ServiceBusReceiver serviceBusReceiver, string subscriber) { while (true) { var receivedMessage = await serviceBusReceiver.ReceiveMessagesAsync(1, TimeSpan.FromSeconds(1)); if (receivedMessage == null || receivedMessage.Count == 0) { break; } foreach (var message in receivedMessage) { var body = message.Body.ToString(); var msgPropNumber = message.ApplicationProperties["MsgProp"]; Console.WriteLine($"{subscriber}\t{msgPropNumber}\t{body}"); } } }