public async Task <Dictionary <string, QueueDetail> > GetQueueDetails(params string[] names)
        {
            if (names == null || names.Length == 0)
            {
                throw new ArgumentNullException("names");
            }

            var dict = new Dictionary <string, QueueDetail>();
            var administrationClient = new ServiceBusAdministrationClient(connectionString);

            foreach (var name in names)
            {
                try
                {
                    var runtimeProperty = await administrationClient.GetQueueRuntimePropertiesAsync(name);

                    dict.Add(name, new QueueDetail()
                    {
                        ActiveMessageCount     = runtimeProperty.Value.ActiveMessageCount,
                        TotalMessageCount      = runtimeProperty.Value.TotalMessageCount,
                        DeadLetterMessageCount = runtimeProperty.Value.DeadLetterMessageCount,
                    });
                }
                catch (Exception ex)
                {
                    dict.Add(name, new QueueDetail
                    {
                        Message = ex.Message,
                    });
                }
            }

            return(dict);
        }
Beispiel #2
0
        public static async Task ReportNumberOfMessages(string connectionString, string destination)
        {
            var client = new ServiceBusAdministrationClient(connectionString);

            QueueRuntimeProperties info = await client.GetQueueRuntimePropertiesAsync(destination);

            Console.WriteLine($"#'{info.ActiveMessageCount}' messages in '{destination}'");
        }
        async Task <long> GetMessageCount(bool deadLetterQueueData)
        {
            var client = new ServiceBusAdministrationClient(serviceBusHelper.ConnectionString);

            if (deadLetterQueueData)
            {
                if (queueProperties != null)
                {
                    var runtimeInfoResponse = await client.GetQueueRuntimePropertiesAsync(queueProperties.Name)
                                              .ConfigureAwait(false);

                    return(runtimeInfoResponse.Value.DeadLetterMessageCount);
                }
                else
                {
                    var runtimeInfoResponse = await client.GetSubscriptionRuntimePropertiesAsync(
                        subscriptionProperties.TopicName,
                        subscriptionProperties.SubscriptionName)
                                              .ConfigureAwait(false);

                    return(runtimeInfoResponse.Value.DeadLetterMessageCount);
                }
            }
            else
            {
                if (queueProperties != null)
                {
                    var runtimeInfo = await client.GetQueueRuntimePropertiesAsync(queueProperties.Name)
                                      .ConfigureAwait(false);

                    return(runtimeInfo.Value.ActiveMessageCount);
                }
                else
                {
                    var runtimeInfo = await client.GetSubscriptionRuntimePropertiesAsync(
                        subscriptionProperties.TopicName,
                        subscriptionProperties.SubscriptionName)
                                      .ConfigureAwait(false);

                    return(runtimeInfo.Value.ActiveMessageCount);
                }
            }
        }
        protected async override Task <long> GetMessageCount(QueueProperties entity, bool deadLetterQueueData)
        {
            var client = new ServiceBusAdministrationClient(serviceBusHelper.ConnectionString);

            if (deadLetterQueueData)
            {
                var runtimeInfoResponse = await client.GetQueueRuntimePropertiesAsync(entity.Name)
                                          .ConfigureAwait(false);

                return(runtimeInfoResponse.Value.DeadLetterMessageCount);
            }
            else
            {
                var runtimeInfo = await client.GetQueueRuntimePropertiesAsync(entity.Name)
                                  .ConfigureAwait(false);

                return(runtimeInfo.Value.ActiveMessageCount);
            }
        }
        public async Task <QueueDetail> GetQueueDetail(string name)
        {
            var administrationClient = new ServiceBusAdministrationClient(connectionString);
            var runtimeProperty      = await administrationClient.GetQueueRuntimePropertiesAsync(name);

            return(new QueueDetail()
            {
                ActiveMessageCount = runtimeProperty.Value.ActiveMessageCount,
                TotalMessageCount = runtimeProperty.Value.TotalMessageCount,
                DeadLetterMessageCount = runtimeProperty.Value.DeadLetterMessageCount,
            });
        }
        public async Task StopAsync(CancellationToken cancellationToken)
        {
            var logs   = _host.GetTestLoggerProvider().GetAllLogMessages();
            var errors = logs.Where(
                p => p.Level == LogLevel.Error &&
                // Ignore this error that the SDK logs when cancelling batch receive
                !p.FormattedMessage.Contains("ReceiveBatchAsync Exception: System.Threading.Tasks.TaskCanceledException"));

            Assert.IsEmpty(errors, string.Join(",", errors.Select(e => e.FormattedMessage)));

            var client = new ServiceBusAdministrationClient(ServiceBusTestEnvironment.Instance.ServiceBusConnectionString);

            // wait for a few seconds to allow updated counts to propagate
            await Task.Delay(TimeSpan.FromSeconds(2));

            QueueRuntimeProperties properties = await client.GetQueueRuntimePropertiesAsync(WebJobsServiceBusTestBase._firstQueueScope.QueueName, CancellationToken.None);

            Assert.AreEqual(0, properties.TotalMessageCount);
        }
        public static async Task ReportNumberOfMessages(string connectionString, string destination)
        {
            var client = new ServiceBusAdministrationClient(connectionString);

            QueueRuntimeProperties info = await client.GetQueueRuntimePropertiesAsync(destination);

            long activeMessageCount             = info.ActiveMessageCount;
            long deadLetterMessageCount         = info.DeadLetterMessageCount;
            long transferDeadLetterMessageCount = info.TransferDeadLetterMessageCount;

            string destinationDeadLetterPath         = EntityNameHelper.FormatDeadLetterPath(destination);
            string destinationTransferDeadLetterPath = EntityNameHelper.FormatTransferDeadLetterPath(destination);

            Console.WriteLine($"#'{activeMessageCount}' messages in '{destination}'");
            Console.WriteLine(
                $"#'{deadLetterMessageCount}' messages in '{destinationDeadLetterPath}'");
            Console.WriteLine(
                $"#'{transferDeadLetterMessageCount}' messages in '{destinationTransferDeadLetterPath}'");
        }
Beispiel #8
0
        private static async Task Main(string[] args)
        {
            await Prepare.Stage(connectionString, inputQueue, topicName, subscriptionName);

            await using var serviceBusClient = new ServiceBusClient(connectionString);
            await using var queueSender      = serviceBusClient.CreateSender(inputQueue);
            await queueSender.SendMessageAsync(new ServiceBusMessage("Kick off"));

            await using var topicSender = serviceBusClient.CreateSender(topicName);
            await topicSender.SendMessageAsync(new ServiceBusMessage("Kick off"));

            var client = new ServiceBusAdministrationClient(connectionString);

            NamespaceProperties namespaceInfo = await client.GetNamespacePropertiesAsync();

            WriteLine($"Namespace Information about '{namespaceInfo.Name}'");
            WriteLine($"{nameof(namespaceInfo.Alias)}: {namespaceInfo.Alias}");
            WriteLine($"{nameof(namespaceInfo.CreatedTime)}: {namespaceInfo.CreatedTime}");
            WriteLine($"{nameof(namespaceInfo.MessagingSku)}: {namespaceInfo.MessagingSku}");
            WriteLine($"{nameof(namespaceInfo.MessagingUnits)}: {namespaceInfo.MessagingUnits}");
            WriteLine($"{nameof(namespaceInfo.ModifiedTime)}: {namespaceInfo.ModifiedTime}");
            WriteLine($"{nameof(namespaceInfo.Name)}: {namespaceInfo.Name}");
            WriteLine($"{nameof(namespaceInfo.MessagingUnits)}: {namespaceInfo.MessagingUnits}");
            WriteLine();

            QueueRuntimeProperties inputQueueInfo = await client.GetQueueRuntimePropertiesAsync(inputQueue);

            WriteLine($"Queue Information about '{inputQueue}'");
            WriteLine($"{nameof(inputQueueInfo.AccessedAt)}: {inputQueueInfo.AccessedAt}");
            WriteLine($"{nameof(inputQueueInfo.CreatedAt)}: {inputQueueInfo.CreatedAt}");
            WriteLine($"{nameof(inputQueueInfo.TotalMessageCount)}: {inputQueueInfo.TotalMessageCount}");
            WriteLine($"{nameof(inputQueueInfo.ActiveMessageCount)}: {inputQueueInfo.ActiveMessageCount}");
            WriteLine($"{nameof(inputQueueInfo.DeadLetterMessageCount)}: {inputQueueInfo.DeadLetterMessageCount}");
            WriteLine($"{nameof(inputQueueInfo.ScheduledMessageCount)}: {inputQueueInfo.ScheduledMessageCount}");
            WriteLine($"{nameof(inputQueueInfo.TransferDeadLetterMessageCount)}: {inputQueueInfo.TransferDeadLetterMessageCount}");
            WriteLine($"{nameof(inputQueueInfo.TransferMessageCount)}: {inputQueueInfo.TransferMessageCount}");
            WriteLine($"{nameof(inputQueueInfo.Name)}: {inputQueueInfo.Name}");
            WriteLine($"{nameof(inputQueueInfo.SizeInBytes)}: {inputQueueInfo.SizeInBytes}");
            WriteLine($"{nameof(inputQueueInfo.UpdatedAt)}: {inputQueueInfo.UpdatedAt}");
            WriteLine();

            TopicRuntimeProperties topicInfo = await client.GetTopicRuntimePropertiesAsync(topicName);

            WriteLine($"TopicInformation Information about '{topicName}'");
            WriteLine($"{nameof(topicInfo.AccessedAt)}: {topicInfo.AccessedAt}");
            WriteLine($"{nameof(topicInfo.CreatedAt)}: {topicInfo.CreatedAt}");
            WriteLine($"{nameof(topicInfo.ScheduledMessageCount)}: {topicInfo.ScheduledMessageCount}");
            WriteLine($"{nameof(topicInfo.SubscriptionCount)}: {topicInfo.SubscriptionCount}");
            WriteLine($"{nameof(topicInfo.Name)}: {topicInfo.Name}");
            WriteLine($"{nameof(topicInfo.SizeInBytes)}: {topicInfo.SizeInBytes}");
            WriteLine($"{nameof(topicInfo.SubscriptionCount)}: {topicInfo.SubscriptionCount}");
            WriteLine($"{nameof(topicInfo.UpdatedAt)}: {topicInfo.UpdatedAt}");
            WriteLine();

            SubscriptionRuntimeProperties subscriptionInfo = await client.GetSubscriptionRuntimePropertiesAsync(topicName, subscriptionName);

            WriteLine($"Subscription Information about '{subscriptionName}'");
            WriteLine($"{nameof(subscriptionInfo.AccessedAt)}: {subscriptionInfo.AccessedAt}");
            WriteLine($"{nameof(subscriptionInfo.CreatedAt)}: {subscriptionInfo.CreatedAt}");
            WriteLine($"{nameof(subscriptionInfo.TotalMessageCount)}: {subscriptionInfo.TotalMessageCount}");
            WriteLine($"{nameof(inputQueueInfo.TotalMessageCount)}: {inputQueueInfo.TotalMessageCount}");
            WriteLine($"{nameof(inputQueueInfo.ActiveMessageCount)}: {inputQueueInfo.ActiveMessageCount}");
            WriteLine($"{nameof(inputQueueInfo.DeadLetterMessageCount)}: {inputQueueInfo.DeadLetterMessageCount}");
            WriteLine($"{nameof(inputQueueInfo.ScheduledMessageCount)}: {inputQueueInfo.ScheduledMessageCount}");
            WriteLine($"{nameof(inputQueueInfo.TransferDeadLetterMessageCount)}: {inputQueueInfo.TransferDeadLetterMessageCount}");
            WriteLine($"{nameof(inputQueueInfo.TransferMessageCount)}: {inputQueueInfo.TransferMessageCount}");
            WriteLine($"{nameof(subscriptionInfo.SubscriptionName)}: {subscriptionInfo.SubscriptionName}");
            WriteLine($"{nameof(subscriptionInfo.TopicName)}: {subscriptionInfo.TopicName}");
            WriteLine($"{nameof(subscriptionInfo.UpdatedAt)}: {subscriptionInfo.UpdatedAt}");
            WriteLine();

            ReadLine();
        }