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.SendAsync(message);

                await sender.DisposeAsync();

                ServiceBusReceiver receiver;
                if (!useSessions)
                {
                    receiver = client.CreateReceiver(scope.QueueName);
                }
                else
                {
                    receiver = await client.CreateSessionReceiverAsync(scope.QueueName);
                }
                var receivedMessage = await receiver.ReceiveAsync().ConfigureAwait(false);

                Assert.True(Encoding.UTF8.GetString(receivedMessage.Body.ToArray()) == Encoding.UTF8.GetString(message.Body.ToArray()));

                await client.DisposeAsync();

                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.CreateSessionReceiverAsync(scope.QueueName));
                    Assert.ThrowsAsync <ObjectDisposedException>(async() => await client.CreateSessionReceiverAsync(scope.QueueName, sessionId: scope.QueueName));
                }
                Assert.Throws <ObjectDisposedException>(() => client.CreateProcessor(scope.QueueName));
            }
        }
        public async Task GetChildClientFromParentSucceedsOnOpenConnection(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.SendAsync(message);

                await sender.DisposeAsync();

                ServiceBusReceiver receiver;
                if (!useSessions)
                {
                    receiver = client.CreateReceiver(scope.QueueName);
                }
                else
                {
                    receiver = await client.CreateSessionReceiverAsync(scope.QueueName);
                }
                var receivedMessage = await receiver.ReceiveAsync().ConfigureAwait(false);

                Assert.AreEqual(message.Body.AsString(), receivedMessage.Body.AsString());

                if (!useSessions)
                {
                    client.CreateReceiver(scope.QueueName);
                    client.CreateReceiver(scope.QueueName, scope.QueueName);
                    client.CreateSender(scope.QueueName);
                }
                else
                {
                    // close old receiver so we can get session lock
                    await receiver.DisposeAsync();

                    await client.CreateSessionReceiverAsync(scope.QueueName);
                }
                client.CreateProcessor(scope.QueueName);
            }
        }
Exemple #3
0
        public static async Task Main(string[] args)
        {
            var builder = new ConfigurationBuilder()
                          .SetBasePath(Directory.GetCurrentDirectory())
                          .AddJsonFile("appSettings.json", optional: true, reloadOnChange: true)
                          .AddEnvironmentVariables();

            IConfigurationRoot Configuration = builder.Build();

            var publisherConnectionString = Configuration.GetConnectionString("SubscriberConnectionString");

            var topicName = Configuration["TopicName"];

            Console.WriteLine(topicName);


            var serviceBusPubClient = new ServiceBusClient(publisherConnectionString);

            var serviceBusReceiverOptions = new ServiceBusReceiverOptions()
            {
                ReceiveMode = ServiceBusReceiveMode.ReceiveAndDelete
            };
            var subNameA = "sub-a";
            var subNameB = "sub-b";
            ServiceBusReceiver serviceBusReceiverSubA = serviceBusPubClient.CreateReceiver(topicName, subNameA, serviceBusReceiverOptions);
            ServiceBusReceiver serviceBusReceiverSubB = serviceBusPubClient.CreateReceiver(topicName, subNameB, serviceBusReceiverOptions);

            IList <Task> receivers = new List <Task>();

            receivers.Add(ReceivedMessagesAsync(serviceBusReceiverSubA, subNameA));
            receivers.Add(ReceivedMessagesAsync(serviceBusReceiverSubB, subNameB));

            await Task.WhenAll(receivers);

            await serviceBusReceiverSubA.CloseAsync();

            await serviceBusReceiverSubB.CloseAsync();

            Console.WriteLine("All messages received");
            Console.ReadLine();
        }
Exemple #4
0
        public SenderReceiverTest(TOptions options) : base(options)
        {
            var queue = Environment.GetEnvironmentVariable("SERVICEBUS_QUEUE");

            if (string.IsNullOrEmpty(queue))
            {
                throw new InvalidOperationException("Undefined environment variable SERVICEBUS_QUEUE");
            }

            ServiceBusSender   = ServiceBusClient.CreateSender(queue);
            ServiceBusReceiver = ServiceBusClient.CreateReceiver(queue);
        }
        private async Task ProcessMessages(CancellationToken stoppingToken)
        {
            ServiceBusReceiver receiver = _sBusClient.CreateReceiver(queueName);

            await foreach (var message in receiver.ReceiveMessagesAsync(stoppingToken))
            {
                _logger.LogInformation("Message received");
                _logger.LogInformation($"Message ID=> {message.MessageId}");
                _logger.LogInformation($"Message Body=> {message.Body.ToString()}");
                await receiver.CompleteMessageAsync(message, stoppingToken);
            }
        }
        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);

            var concurrencyOptions             = new OptionsWrapper <ConcurrencyOptions>(new ConcurrencyOptions());
            var mockConcurrencyThrottleManager = new Mock <IConcurrencyThrottleManager>(MockBehavior.Strict);
            var concurrencyManager             = new ConcurrencyManager(concurrencyOptions, _loggerFactory, mockConcurrencyThrottleManager.Object);

            _listener = new ServiceBusListener(
                _functionId,
                ServiceBusEntityType.Queue,
                _entityPath,
                false,
                _serviceBusOptions.AutoCompleteMessages,
                _mockExecutor.Object,
                _serviceBusOptions,
                _connection,
                _mockProvider.Object,
                _loggerFactory,
                false,
                _mockClientFactory.Object,
                concurrencyManager);

            _scaleMonitor = (ServiceBusScaleMonitor)_listener.GetMonitor();
        }
Exemple #7
0
        public static async Task DeadLetterMessageAsync(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();

            // dead-letter the message, thereby preventing the message from being received again without receiving from the dead letter queue.
            await receiver.DeadLetterMessageAsync(receivedMessage);
        }
        private async Task ProcessMessages(string platform, CancellationToken stoppingToken)
        {
            await using ServiceBusReceiver receiver = _sBusClient.CreateReceiver(topicName, platform);

            await foreach (var message in receiver.ReceiveMessagesAsync(stoppingToken))
            {
                _logger.LogInformation("New show message received for {Platform}", platform);
                _logger.LogInformation($"Show Message ID=> {message.MessageId}");
                _logger.LogInformation($"Show Message Body=> {message.Body.ToString()}");
                await receiver.CompleteMessageAsync(message, stoppingToken);
            }
        }
 protected override ServiceBusReceiver CreateServiceBusReceiver(SubscriptionProperties entity, ServiceBusClient client, bool purgeDeadLetterQueueInstead)
 {
     return(client.CreateReceiver(
                entity.TopicName,
                entity.SubscriptionName,
                new ServiceBusReceiverOptions
     {
         PrefetchCount = 50,
         ReceiveMode = ServiceBusReceiveMode.ReceiveAndDelete,
         SubQueue = purgeDeadLetterQueueInstead ? SubQueue.DeadLetter : SubQueue.None
     }));
 }
Exemple #10
0
        private static async Task ReadMessages()
        {
            var receiver = _client.CreateReceiver(_queueName,
                                                  new ServiceBusReceiverOptions()
            {
                ReceiveMode = ServiceBusReceiveMode.ReceiveAndDelete
            });

            Console.WriteLine("Receiving messages from queue");

            var messages = await receiver.ReceiveMessagesAsync(16)
                           .ConfigureAwait(false);

            Console.WriteLine("Printing messages:");
            foreach (var item in messages)
            {
                Console.Write($"Body: {item.Body} - ");
            }
            Console.WriteLine($"Message count: {messages.Count}");
            Console.WriteLine("Receiving messages from queue done");
        }
Exemple #11
0
        public async Task CrossEntityTransaction()
        {
            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);

            #region Snippet:ServiceBusCrossEntityTransaction
#if SNIPPET
            string connectionString = "<connection_string>";
            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");
#else
            await using var client = new ServiceBusClient(
                            TestEnvironment.ServiceBusConnectionString,
                            new ServiceBusClientOptions
            {
                EnableCrossEntityTransactions = true
            });
            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);
#endif

            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(TimeSpan.FromSeconds(5));

            Assert.IsNull(receivedMessage);
        }
Exemple #12
0
        public static async Task <ServiceBusReceivedMessage> GetDeadLetterMessageAsync(string connectionString, string queueName)
        {
            await using var client = new ServiceBusClient(connectionString);

            // receive the dead lettered message with receiver scoped to the dead letter queue.
            ServiceBusReceiver receiver = client.CreateReceiver(queueName, new ServiceBusReceiverOptions
            {
                SubQueue = SubQueue.DeadLetter
            });

            // the received message is a different type as it contains some service set properties
            return(await receiver.ReceiveMessageAsync());
        }
        public override async Task GlobalSetupAsync()
        {
            await base.GlobalSetupAsync().ConfigureAwait(false);

            QueueScope = await ServiceBusScope.CreateWithQueue(
                enablePartitioning : false,
                enableSession : _useSessions,
                lockDuration : TimeSpan.FromMinutes(5));

            Client   = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
            Sender   = Client.CreateSender(QueueScope.QueueName);
            Receiver = Client.CreateReceiver(QueueScope.QueueName);
        }
Exemple #14
0
        public ServiceBusListenerTests()
        {
            _mockExecutor = new Mock <ITriggeredFunctionExecutor>(MockBehavior.Strict);

            _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
            {
                ProcessErrorAsync = 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);

            var concurrencyOptions = new OptionsWrapper <ConcurrencyOptions>(new ConcurrencyOptions());

            _mockConcurrencyThrottleManager = new Mock <IConcurrencyThrottleManager>(MockBehavior.Strict);
            var concurrencyManager = new ConcurrencyManager(concurrencyOptions, _loggerFactory, _mockConcurrencyThrottleManager.Object);

            _listener = new ServiceBusListener(
                _functionId,
                ServiceBusEntityType.Queue,
                _entityPath,
                false,
                config.AutoCompleteMessages,
                _mockExecutor.Object,
                config,
                "connection",
                _mockMessagingProvider.Object,
                _loggerFactory,
                false,
                _mockClientFactory.Object,
                concurrencyManager);
            _listener.Started = true;
        }
        public async Task DeadLetterMessage()
        {
            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("Hello world!");

                // send the message
                await sender.SendMessageAsync(message);

                // create a receiver that we can use to receive and settle the message
                ServiceBusReceiver receiver = client.CreateReceiver(queueName);

                #region Snippet:ServiceBusDeadLetterMessage
                ServiceBusReceivedMessage receivedMessage = await receiver.ReceiveMessageAsync();

                // dead-letter the message, thereby preventing the message from being received again without receiving from the dead letter queue.
                await receiver.DeadLetterMessageAsync(receivedMessage);

                // receive the dead lettered message with receiver scoped to the dead letter queue.
                ServiceBusReceiver dlqReceiver = client.CreateReceiver(queueName, new ServiceBusReceiverOptions
                {
                    SubQueue = SubQueue.DeadLetter
                });
                ServiceBusReceivedMessage dlqMessage = await dlqReceiver.ReceiveMessageAsync();

                #endregion
                Assert.IsNotNull(dlqMessage);
            }
        }
Exemple #16
0
            protected internal override MessageProcessor CreateMessageProcessor(ServiceBusClient client, string entityPath, ServiceBusProcessorOptions options)
            {
                // override the options computed from ServiceBusOptions
                options.MaxConcurrentCalls         = 3;
                options.MaxAutoLockRenewalDuration = TimeSpan.FromMinutes(MaxAutoRenewDurationMin);

                var processor = client.CreateProcessor(entityPath, options);
                var receiver  = client.CreateReceiver(entityPath);

                // TODO decide whether it makes sense to still default error handler when there is a custom provider
                // currently user needs to set it.
                processor.ProcessErrorAsync += args => Task.CompletedTask;
                return(new CustomMessageProcessor(processor, _logger));
            }
        public void CompleteProcessingMessageAsync_Failure_PropagatesException()
        {
            ServiceBusReceivedMessage message = ServiceBusModelFactory.ServiceBusReceivedMessage();
            var            functionException  = new InvalidOperationException("Kaboom!");
            FunctionResult result             = new FunctionResult(functionException);
            var            client             = new ServiceBusClient("Endpoint = sb://test.servicebus.windows.net/;SharedAccessKeyName=RootManageSharedAccessKey;SharedAccessKey=abc123=");
            var            actions            = new ServiceBusMessageActions(client.CreateReceiver("test-entity"));
            var            ex = Assert.ThrowsAsync <InvalidOperationException>(async() =>
            {
                await _processor.CompleteProcessingMessageAsync(actions, message, result, CancellationToken.None);
            });

            Assert.AreSame(functionException, ex);
        }
Exemple #18
0
        public async Task AbandonMessages()
        {
            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.CreateSender(scope.QueueName);
                using ServiceBusMessageBatch batch = await sender.CreateMessageBatchAsync();

                IEnumerable <ServiceBusMessage> messages = AddMessages(batch, messageCount).AsEnumerable <ServiceBusMessage>();

                await sender.SendMessagesAsync(batch);

                var receiver = client.CreateReceiver(scope.QueueName);

                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);
                        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(messageCount, receivedMessageCount);
            }
        }
        private async Task ReceiveMessages(string subscription)
        {
            await using var client = new ServiceBusClient(ServiceBusConnectionString);
            ServiceBusReceiver receiver = client.CreateReceiver(TopicName, subscription);

            // In reality you would not break out of the loop like in this example but would keep looping. The receiver keeps the connection open
            // to the broker for the specified amount of seconds and the broker returns messages as soon as they arrive. The client then initiates
            // a new connection. So in reality you would not want to break out of the loop.
            // Also note that the code shows how to batch receive, which you would do for performance reasons. For convenience you can also always
            // use the regular receive pump which we show in our Quick Start and in other github samples.
            while (true)
            {
                try
                {
                    //IList<Message> messages = await receiver.ReceiveAsync(10, TimeSpan.FromSeconds(2));
                    // Note the extension class which is serializing an deserializing messages and testing messages is null or 0.
                    // If you think you did not receive all messages, just press M and receive again via the menu.
                    IReadOnlyList <ServiceBusReceivedMessage> messages = await receiver.ReceiveMessagesAsync(maxMessages : 100);

                    if (messages.Any())
                    {
                        foreach (ServiceBusReceivedMessage message in messages)
                        {
                            lock (Console.Out)
                            {
                                Item item = message.As <Item>();
                                IReadOnlyDictionary <string, object> myUserProperties = message.ApplicationProperties;
                                Console.WriteLine($"StoreId={myUserProperties["StoreId"]}");
                                if (message.Subject != null)
                                {
                                    Console.WriteLine($"Subject={message.Subject}");
                                }
                                Console.WriteLine(
                                    $"Item data: Price={item.GetPrice()}, Color={item.GetColor()}, Category={item.GetItemCategory()}");
                            }

                            await receiver.CompleteMessageAsync(message);
                        }
                    }
                    else
                    {
                        break;
                    }
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.ToString());
                }
            }
        }
        public async Task Capture_Transaction_When_Receive_From_Queue()
        {
            await using var scope = await QueueScope.CreateWithQueue(_adminClient);

            var sender   = _client.CreateSender(scope.QueueName);
            var receiver = _client.CreateReceiver(scope.QueueName);

            await sender.SendMessageAsync(
                new ServiceBusMessage("test message")).ConfigureAwait(false);

            await receiver.ReceiveMessageAsync(TimeSpan.FromSeconds(30)).ConfigureAwait(false);

            if (!_sender.WaitForTransactions(TimeSpan.FromMinutes(2)))
            {
                throw new Exception("No transaction received in timeout");
            }

            _sender.Transactions.Should().HaveCount(1);
            var transaction = _sender.FirstTransaction;

            transaction.Name.Should().Be($"{ServiceBus.SegmentName} RECEIVE from {scope.QueueName}");
            transaction.Type.Should().Be(ApiConstants.TypeMessaging);
        }
Exemple #21
0
        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.CreateSender(scope.QueueName);
                using ServiceBusMessageBatch batch = await sender.CreateMessageBatchAsync();

                IEnumerable <ServiceBusMessage> messages = AddMessages(batch, messageCount).AsEnumerable <ServiceBusMessage>();

                await sender.SendMessagesAsync(batch);

                var          receiver          = client.CreateReceiver(scope.QueueName);
                var          messageEnum       = messages.GetEnumerator();
                IList <long> sequenceNumbers   = new List <long>();
                var          remainingMessages = messageCount;

                while (remainingMessages > 0)
                {
                    foreach (var item in await receiver.ReceiveMessagesAsync(remainingMessages))
                    {
                        remainingMessages--;
                        messageEnum.MoveNext();
                        Assert.AreEqual(messageEnum.Current.MessageId, item.MessageId);
                        sequenceNumbers.Add(item.SequenceNumber);
                        await receiver.DeferMessageAsync(item.LockToken);
                    }
                }
                Assert.AreEqual(0, remainingMessages);

                IReadOnlyList <ServiceBusReceivedMessage> deferredMessages = await receiver.ReceiveDeferredMessagesAsync(sequenceNumbers);

                var messageList = messages.ToList();
                Assert.AreEqual(messageList.Count, deferredMessages.Count);
                for (int i = 0; i < messageList.Count; i++)
                {
                    Assert.AreEqual(messageList[i].MessageId, deferredMessages[i].MessageId);
                    Assert.AreEqual(messageList[i].Body.ToBytes().ToArray(), deferredMessages[i].Body.ToBytes().ToArray());
                }

                // verify that looking up a non-existent sequence number will throw
                sequenceNumbers.Add(45);
                Assert.That(
                    async() => await receiver.ReceiveDeferredMessagesAsync(sequenceNumbers),
                    Throws.InstanceOf <ServiceBusException>().And.Property(nameof(ServiceBusException.Reason)).EqualTo(ServiceBusFailureReason.MessageNotFound));
            }
        }
        public async Task CanSendReceivedMessage()
        {
            await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false))
            {
                var client = new ServiceBusClient(
                    TestEnvironment.FullyQualifiedNamespace,
                    GetTokenCredential());
                await using var sender             = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString).CreateSender(scope.QueueName);
                using ServiceBusMessageBatch batch = await sender.CreateBatchAsync();

                var messageCt = 10;
                IEnumerable <ServiceBusMessage> messages = AddMessages(batch, messageCt).AsEnumerable <ServiceBusMessage>();
                await sender.SendBatchAsync(batch);

                var receiver = client.CreateReceiver(scope.QueueName, new ServiceBusReceiverOptions()
                {
                    ReceiveMode = ReceiveMode.ReceiveAndDelete
                });

                var remainingMessages = messageCt;
                IList <ServiceBusReceivedMessage> receivedMessages = new List <ServiceBusReceivedMessage>();
                while (remainingMessages > 0)
                {
                    foreach (var msg in await receiver.ReceiveBatchAsync(messageCt))
                    {
                        remainingMessages--;
                        receivedMessages.Add(msg);
                    }
                }
                foreach (ServiceBusReceivedMessage msg in receivedMessages)
                {
                    await sender.SendAsync(ServiceBusMessage.CreateFrom(msg));
                }

                var messageEnum = receivedMessages.GetEnumerator();

                remainingMessages = messageCt;
                while (remainingMessages > 0)
                {
                    foreach (var msg in await receiver.ReceiveBatchAsync(remainingMessages))
                    {
                        remainingMessages--;
                        messageEnum.MoveNext();
                        Assert.AreEqual(messageEnum.Current.MessageId, msg.MessageId);
                    }
                }
                Assert.AreEqual(0, remainingMessages);
            }
        }
Exemple #23
0
        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 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());
                }
            }
        }
Exemple #25
0
        private static async Task <int> Main(string[] args)
        {
            if (args.Length == 0)
            {
                Console.Error.WriteLine("An Azure Service Bus connection string must be passed as the first argument");
                return(1);
            }

            Agent.Subscribe(new AzureMessagingServiceBusDiagnosticsSubscriber());

            var connectionString = args[0];
            var adminClient      = new ServiceBusAdministrationClient(connectionString);
            var client           = new ServiceBusClient(connectionString);

            var queueName = Guid.NewGuid().ToString("D");

            Console.WriteLine($"Creating queue {queueName}");

            var response = await adminClient.CreateQueueAsync(queueName).ConfigureAwait(false);

            var sender = client.CreateSender(queueName);

            Console.WriteLine("Sending messages to queue");

            await Agent.Tracer.CaptureTransaction("Send AzureServiceBus Messages", "messaging", async() =>
            {
                for (var i = 0; i < 10; i++)
                {
                    await sender.SendMessageAsync(new ServiceBusMessage($"test message {i}")).ConfigureAwait(false);
                }
            });

            var receiver = client.CreateReceiver(queueName);

            Console.WriteLine("Receiving messages from queue");

            var messages = await receiver.ReceiveMessagesAsync(9)
                           .ConfigureAwait(false);

            Console.WriteLine("Receiving message from queue");

            var message = await receiver.ReceiveMessageAsync()
                          .ConfigureAwait(false);

            Console.WriteLine("Press any key to continue...");
            Console.ReadKey();

            return(0);
        }
Exemple #26
0
        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);
        }
Exemple #27
0
        public async Task ReceiverThrowsWhenUsingSessionEntity()
        {
            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);
                ServiceBusMessage sentMessage = GetMessage("sessionId");
                await sender.SendMessageAsync(sentMessage);

                var receiver = client.CreateReceiver(scope.QueueName);
                Assert.That(
                    async() => await receiver.ReceiveMessageAsync(),
                    Throws.InstanceOf <InvalidOperationException>());
            }
        }
        public void ReceiveValidatesMaxMessageCount()
        {
            var account = Encoding.Default.GetString(GetRandomBuffer(12));
            var fullyQualifiedNamespace = new UriBuilder($"{account}.servicebus.windows.net/").Host;
            var connString = $"Endpoint=sb://{fullyQualifiedNamespace};SharedAccessKeyName=RootManageSharedAccessKey;SharedAccessKey={Encoding.Default.GetString(GetRandomBuffer(64))}";
            var client     = new ServiceBusClient(connString);
            var receiver   = client.CreateReceiver("queueName");

            Assert.That(
                async() => await receiver.ReceiveMessagesAsync(0),
                Throws.InstanceOf <ArgumentOutOfRangeException>());
            Assert.That(
                async() => await receiver.ReceiveMessagesAsync(-1),
                Throws.InstanceOf <ArgumentOutOfRangeException>());
        }
Exemple #29
0
        public async Task DeferMessagesArray()
        {
            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.CreateSender(scope.QueueName);
                using ServiceBusMessageBatch batch = await sender.CreateMessageBatchAsync();

                IEnumerable <ServiceBusMessage> messages = AddMessages(batch, messageCount).AsEnumerable <ServiceBusMessage>();

                await sender.SendMessagesAsync(batch);

                var    receiver          = client.CreateReceiver(scope.QueueName);
                var    messageEnum       = messages.GetEnumerator();
                long[] sequenceNumbers   = new long[messageCount];
                var    remainingMessages = messageCount;
                int    idx = 0;
                while (remainingMessages > 0)
                {
                    foreach (var item in await receiver.ReceiveMessagesAsync(remainingMessages))
                    {
                        remainingMessages--;
                        messageEnum.MoveNext();
                        Assert.AreEqual(messageEnum.Current.MessageId, item.MessageId);
                        sequenceNumbers[idx++] = item.SequenceNumber;
                        await receiver.DeferMessageAsync(item.LockToken);
                    }
                }
                Assert.AreEqual(0, remainingMessages);

                IReadOnlyList <ServiceBusReceivedMessage> deferredMessages = await receiver.ReceiveDeferredMessagesAsync(sequenceNumbers);

                var messageList = messages.ToList();
                Assert.AreEqual(messageList.Count, deferredMessages.Count);
                for (int i = 0; i < messageList.Count; i++)
                {
                    Assert.AreEqual(messageList[i].MessageId, deferredMessages[i].MessageId);
                    Assert.AreEqual(messageList[i].Body.ToArray(), deferredMessages[i].Body.ToArray());
                }

                // verify that an empty array can be passed
                deferredMessages = await receiver.ReceiveDeferredMessagesAsync(Array.Empty <long>());

                Assert.IsEmpty(deferredMessages);
            }
        }
Exemple #30
0
        public async Task SendSessionMessageToNonSessionfulEntityShouldNotThrow()
        {
            await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: false, enableSession: false))
            {
                await using var client = new ServiceBusClient(TestEnvironment.ServiceBusConnectionString);
                var sender = client.CreateSender(scope.QueueName);
                // this is apparently supported. The session is ignored by the service but can be used
                // as additional app data. Not recommended.
                await sender.SendMessageAsync(GetMessage("sessionId"));

                var receiver = client.CreateReceiver(scope.QueueName);
                var msg      = await receiver.ReceiveMessageAsync();

                Assert.AreEqual("sessionId", msg.SessionId);
            }
        }