示例#1
0
 private static async Task ReceiveMessageFromAzureBus(ClientRequest request)
 {
     try
     {
         //new CreateConnection(request.ConnectionString, request.TopicName, request.SubscriptionName);
         new TopicReceiver().RegisterOnMessageHandlerAndReceiveMessages(null);
         await subscriptionClient.CloseAsync();
     }
     catch (Exception ex)
     {
         throw;
     }
 }
示例#2
0
        public override async Task StopAsync(CancellationToken stoppingToken)
        {
            await _client.CloseAsync();

            _logger.LogInformation(
                "Azure Service Bus connection was closed!");
        }
        static async Task MainAsync()
        {
            const int numberOfMessages = 10;

            topicClient              = new TopicClient(ServiceBusConnectionString, TopicName);
            firstSubscriptionClient  = new SubscriptionClient(ServiceBusConnectionString, TopicName, FirstSubscriptionName);
            secondSubscriptionClient = new SubscriptionClient(ServiceBusConnectionString, TopicName, SecondSubscriptionName);

            Console.WriteLine("======================================================");
            Console.WriteLine("Press any key to exit after receiving all the messages.");
            Console.WriteLine("======================================================");

            // Register Subscription's MessageHandler and receive messages in a loop
            RegisterOnMessageHandlerAndReceiveMessages();

            // Send Messages
            await SendMessagesAsync(numberOfMessages);

            Console.ReadKey();

            await firstSubscriptionClient.CloseAsync();

            await secondSubscriptionClient.CloseAsync();

            await topicClient.CloseAsync();
        }
        static async Task Main(string[] args)
        {
            var builder = new ConfigurationBuilder();

            // tell the builder to look for the appsettings.json file
            builder
            .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
            .AddUserSecrets <Program>();

            Configuration = builder.Build();

            // Create a Subscription Client here
            subscriptionClient = new SubscriptionClient(Configuration["ConnectionString"], TopicName, SubscriptionName);

            Console.WriteLine("======================================================");
            Console.WriteLine("Press ENTER key to exit after receiving all the messages.");
            Console.WriteLine("======================================================");

            // Register subscription message handler and receive messages in a loop
            RegisterMessageHandler();

            Console.Read();

            // Close the subscription here
            await subscriptionClient.CloseAsync();
        }
示例#5
0
        static async Task MainAsync()
        {
            subscriptionClient = new SubscriptionClient(ServiceBusConnectionString, TopicName, SubscriptionName);

            Console.WriteLine("======================================================");
            Console.WriteLine("Press ENTER key to exit after receiving all the messages.");
            Console.WriteLine("======================================================");

            var messageHandlerOptions = new MessageHandlerOptions(ExceptionReceivedHandler)
            {
                // Maximum number of concurrent calls to the callback ProcessMessagesAsync(), set to 1 for simplicity.
                // Set it according to how many messages the application wants to process in parallel.
                MaxConcurrentCalls = 1,

                // Indicates whether MessagePump should automatically complete the messages after returning from User Callback.
                // False below indicates the Complete will be handled by the User Callback as in `ProcessMessagesAsync` below.
                AutoComplete = false
            };

            // Register the function that processes messages.
            subscriptionClient.RegisterMessageHandler(ProcessMessagesAsync, messageHandlerOptions);

            Console.ReadKey();

            await subscriptionClient.CloseAsync();
        }
示例#6
0
 private static async Task MainAsync()
 {
     _subscriptionClient = new SubscriptionClient(ServiceBusConnectionString, TopicName, SubscriptionName);
     RegisterMessageHandler();
     Console.ReadKey();
     await _subscriptionClient.CloseAsync();
 }
示例#7
0
 /// <summary>
 /// Closes the connection to the service bus and notifies the observers.
 /// </summary>
 /// <returns>Awaitable result of CloseAsync.</returns>
 public async ValueTask DisposeAsync()
 {
     if (_subscriptionClient != null)
     {
         await _subscriptionClient.CloseAsync();
     }
 }
        public async void TryReconnect()
        {
            if (MessagesListedBySession.Count == 0 && _sessionsInitializedCount >= _concurrentSessions)
            {
                _sessionsInitializedCount = 0;
                try {
                    await subscriptionClient.CloseAsync();
                } catch (Exception ex) {
                    if (!(logger is null))
                    {
                        logger.LogWarning(ex.Message);
                    }
                }
                subscriptionClient = new SubscriptionClient(ServiceBusConnectionString, TopicName, SubscriptionName);

                var sessionOptions = new SessionHandlerOptions(ExceptionReceivedHandler)
                {
                    AutoComplete          = false,
                    MaxConcurrentSessions = _concurrentSessions,
                    MaxAutoRenewDuration  = TimeSpan.FromSeconds(10)
                };

                subscriptionClient.PrefetchCount = 250;
                subscriptionClient.RegisterSessionHandler(OnMessage, sessionOptions);
            }
        }
示例#9
0
        public async Task CloseAsync(CancellationToken cancellationToken)
        {
            if (_log.IsDebugEnabled)
            {
                _log.DebugFormat("Closing client: {0}", InputAddress);
            }

            try
            {
                if (_subscriptionClient != null && !_subscriptionClient.IsClosedOrClosing)
                {
                    await _subscriptionClient.CloseAsync().ConfigureAwait(false);
                }

                if (_log.IsDebugEnabled)
                {
                    _log.DebugFormat("Closed client: {0}", InputAddress);
                }
            }
            catch (Exception exception)
            {
                if (_log.IsWarnEnabled)
                {
                    _log.Warn($"Exception closing the client: {InputAddress}", exception);
                }
            }
        }
示例#10
0
        protected override Task <NimbusMessage> Fetch(CancellationToken cancellationToken)
        {
            return(Task.Run(async() =>
            {
                await _receiveSemaphore.WaitAsync(_pollInterval, cancellationToken);

                if (cancellationToken.IsCancellationRequested)
                {
                    await _subscriptionClient.CloseAsync();
                    return null;
                }

                if (_messages.Count == 0)
                {
                    return null;
                }

                var message = _messages.Take();

                var nimbusMessage = await _brokeredMessageFactory.BuildNimbusMessage(message);
                nimbusMessage.Properties[MessagePropertyKeys.RedeliveryToSubscriptionName] = _subscriptionName;

                return nimbusMessage;
            },
                            cancellationToken).ConfigureAwaitFalse());
        }
示例#11
0
 private async Task Stop()
 {
     if (_subscriptionClient != null && !_subscriptionClient.IsClosedOrClosing)
     {
         await _subscriptionClient.CloseAsync();
     }
 }
示例#12
0
        public async ValueTask DisposeAsync()
        {
            await _subscriptionClient.CloseAsync().ConfigureAwait(false);

            _messageResult.TrySetCanceled();
            Dispose();
        }
        public override async Task StopAsync(CancellationToken stoppingToken)
        {
            await _client.CloseAsync();

            _logger.LogInformation(
                "Conexao com o Azure Service Bus fechada!");
        }
示例#14
0
        static async Task <int> Main(string[] args)
        {
            Console.WriteLine("Starting...");

            if (String.IsNullOrEmpty(ServiceBusConnectionString))
            {
                Console.WriteLine($"Please set {ENV_CONN_STR} in your environment");
                return(1);
            }

            if (String.IsNullOrEmpty(SubscriptionName))
            {
                Console.WriteLine($"Please set {ENV_SUBSCRIPTION} in your environment");
                return(1);
            }
            subscriptionClient = new SubscriptionClient(ServiceBusConnectionString, TopicName, SubscriptionName);

            Console.WriteLine("======================================================");
            Console.WriteLine("Press ENTER key to exit after receiving all the messages.");
            Console.WriteLine("======================================================");

            // Register subscription message handler and receive messages in a loop
            RegisterOnMessageHandlerAndReceiveMessages();

            Console.ReadKey();

            await subscriptionClient.CloseAsync();

            return(0);
        }
示例#15
0
        static async Task MainAsync()
        {
            string ServiceBusConnectionString = "Endpoint=sb://licenseplatepublisher.servicebus.windows.net/;SharedAccessKeyName=ConsumeReads;SharedAccessKey=VNcJZVQAVMazTAfrssP6Irzlg/pKwbwfnOqMXqROtCQ=";
            string TopicName        = "licenseplateread";
            string SubscriptionName = "fbS8qDfztJHYbf2G";

            subscriptionClient = new SubscriptionClient(ServiceBusConnectionString, TopicName, SubscriptionName);

            updateVoitures_Recherche();
            ServiceBusConnectionString = "Endpoint=sb://licenseplatepublisher.servicebus.windows.net/;SharedAccessKeyName=listeneronly;SharedAccessKey=w+ifeMSBq1AQkedLCpMa8ut5c6bJzJxqHuX9Jx2XGOk=";
            TopicName        = "wantedplatelistupdate";
            SubscriptionName = "8wQLDabncqUFjdTk";

            subscriptionClient_notif = new SubscriptionClient(ServiceBusConnectionString, TopicName, SubscriptionName);



            //liste voitures recherches


            // Console.WriteLine($"Received message: UserInfo:{resp}");


            // Register subscription message handler and receive messages in a loop.
            RegisterOnMessageHandlerAndReceiveMessages();

            Console.ReadKey();

            await subscriptionClient.CloseAsync();

            await subscriptionClient_notif.CloseAsync();
        }
示例#16
0
        static async Task Main(string[] args)
        {
            if (args.Length != 3)
            {
                Console.WriteLine("Usage: dotnet Events.CreditCardProcessor.dll [Connection-String] [Topic-Name] [Subscription-Name]");
                return;
            }

            var connectionString = args[0];
            var topicName        = args[1];
            var subscriptionName = args[2];

            _client = new SubscriptionClient(connectionString, topicName, subscriptionName);

            Console.WriteLine("======================================================");
            Console.WriteLine("Press ENTER key to exit after receiving all the messages.");
            Console.WriteLine("======================================================");

            // Register the queue message handler and receive messages in a loop
            RegisterOnMessageHandlerAndReceiveMessages();

            Console.ReadKey();

            await _client.CloseAsync();
        }
示例#17
0
        static async Task MainAsync()
        {
            topicClient = new TopicClient(ServiceBusConnectionString, TopicName);

            empCreateFilterSubscriptionClient = new SubscriptionClient(ServiceBusConnectionString, TopicName, "EmployeeCreate");
            empDeleteFilterSubscriptionClient = new SubscriptionClient(ServiceBusConnectionString, TopicName, "EmployeeDelete");


            // Receive messages from 'allMessagesSubscriptionName'. Should receive all 9 messages
            await ReceiveMsg(empCreateFilterSubscriptionClient);

            // Receive messages from 'sqlFilterOnlySubscriptionName'. Should receive all messages with Color = 'Red' i.e 3 messages
            await ReceiveMsg(empDeleteFilterSubscriptionClient);

            Console.WriteLine("=========================================================");
            Console.WriteLine("Completed Receiving all messages... Press any key to exit");
            Console.WriteLine("=========================================================");

            Console.ReadKey();

            await empCreateFilterSubscriptionClient.CloseAsync();

            await empDeleteFilterSubscriptionClient.CloseAsync();

            await topicClient.CloseAsync();
        }
示例#18
0
        static void Main(string[] args)
        {
            subscriptionClient = new SubscriptionClient(ServiceBusConnectionString, TopicName, SubscriptionName);

            Console.WriteLine("Press ENTER key to exit after receiving all the messages.");

            // Configure the message handler options in terms of exception handling, number of concurrent messages to deliver, etc.
            var messageHandlerOptions = new MessageHandlerOptions(ExceptionReceivedHandler)
            {
                // Maximum number of concurrent calls to the callback
                // ProcessMessagesAsync(), set to 1 for simplicity.
                // Set it according to how many messages the application wants to
                // process in parallel.
                MaxConcurrentCalls = 1,

                // Indicates whether the message pump should automatically complete
                // the messages after returning from user callback.
                // False below indicates the user callback handles the complete
                // operation as in ProcessMessagesAsync().
                AutoComplete = false
            };

            // Register the function that processes messages.
            subscriptionClient.RegisterMessageHandler(ProcessMessagesAsync, messageHandlerOptions);

            Console.ReadKey();

            subscriptionClient.CloseAsync();
        }
示例#19
0
        static void Main(string[] args)
        {
            string sbConnectionString = "Endpoint=sb://mobilerecharge.servicebus.windows.net/;SharedAccessKeyName=RootManageSharedAccessKey;SharedAccessKey=KVb9ubc9XaV0dT/1dMj/JGvVvUZ64U21IBI=";
            string sbTopic            = "offers";
            string sbSubscription     = "akki5677";

            try
            {
                subscriptionClient = new SubscriptionClient(sbConnectionString, sbTopic, sbSubscription);

                var messageHandlerOptions = new MessageHandlerOptions(ExceptionReceivedHandler)
                {
                    MaxConcurrentCalls = 1,
                    AutoComplete       = false
                };
                subscriptionClient.RegisterMessageHandler(ReceiveMessagesAsync, messageHandlerOptions);
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
            finally
            {
                Console.ReadKey();
                subscriptionClient.CloseAsync();
            }
        }
示例#20
0
        public async Task ReceiveMessageAsync(string topic = null, string subscription = null)
        {
            // Configure the message handler options in terms of exception handling, number of concurrent messages to deliver, etc.
            var messageHandlerOptions = new MessageHandlerOptions(ExceptionReceivedHandler)
            {
                // Maximum number of concurrent calls to the callback ProcessMessagesAsync(), set to 1 for simplicity.
                // Set it according to how many messages the application wants to process in parallel.
                MaxConcurrentCalls = 1,

                // Indicates whether the message pump should automatically complete the messages after returning from user callback.
                // False below indicates the complete operation is handled by the user callback as in ProcessMessagesAsync().
                AutoComplete = false
            };

            if (string.IsNullOrEmpty(topic))
            {
                // Register the message handler function
                _queueClient.RegisterMessageHandler(ProcessMessagesAsync, messageHandlerOptions);
                Console.Read();
                await _queueClient.CloseAsync();
            }
            else
            {
                _subscriptionClient = new SubscriptionClient(_config["serviceBus"], topic, subscription);
                _subscriptionClient.RegisterMessageHandler(ProcessTopicMessagesAsync, messageHandlerOptions);
                Console.ReadLine();
                await _subscriptionClient.CloseAsync();
            }
        }
示例#21
0
        public async void RunTaskLoop(CancellationToken cancellationToken)
        {
            var messageHandlerOptions = new MessageHandlerOptions(ExceptionReceivedHandler)
            {
                MaxConcurrentCalls = 20,
                AutoComplete       = false
            };

            _subClient.RegisterMessageHandler(HandleMessageAsync, messageHandlerOptions);

            while (!cancellationToken.IsCancellationRequested)
            {
                try
                {
                    if (DateTimeOffset.Now - _apiClient.LastLogin > TokenValidity)
                    {
                        await _apiClient.LoginAsync();
                    }
                    await Task.Delay(1000, cancellationToken);
                }
                catch (OperationCanceledException)
                {
                    break;
                }
            }

            await _subClient.CloseAsync();
        }
示例#22
0
        private static async Task MainAsync()
        {
            const int numberOfMessages = 10;

            _topicClient = new TopicClient(ServiceBusConnectionString, TopicName);

            await SendMessagesAsync(numberOfMessages);

            _subscriptionClient1 = new SubscriptionClient(ServiceBusConnectionString, TopicName, SubscriptionName);
            _subscriptionClient2 = new SubscriptionClient(ServiceBusConnectionString, TopicName, SubscriptionName);

            Console.WriteLine("======================================================");
            Console.WriteLine("Press any key to exit after receiving all the messages.");
            Console.WriteLine("======================================================");

            RegisterOnMessageHandlerAndReceiveMessages1();
            RegisterOnMessageHandlerAndReceiveMessages2();

            Console.ReadKey();

            await _subscriptionClient1.CloseAsync();

            await _subscriptionClient2.CloseAsync();

            await _topicClient.CloseAsync();
        }
示例#23
0
        public static async Task Main(string[] args)
        {
            const int numberOfMessages = 10;

            topicClient = new TopicClient(ServiceBusConnectionString, TopicName);

            subscriptionClient = new SubscriptionClient(ServiceBusConnectionString, TopicName, SubscriptionName);


            Console.WriteLine("======================================================");
            Console.WriteLine("Press ENTER key to exit after sending all the messages.");
            Console.WriteLine("======================================================");

            // Send messages.

            // await SendMessagesAsync(numberOfMessages);

            Console.ReadKey();

            await topicClient.CloseAsync();

            // Register subscription message handler and receive messages in a loop
            RegisterOnMessageHandlerAndReceiveMessages();

            Console.ReadKey();

            await subscriptionClient.CloseAsync();
        }
示例#24
0
        static void Main(string[] args)
        {
            string sbConnectionString = "Endpoint=sb://mobilerechargeservicebus.servicebus.windows.net/;SharedAccessKeyName=TopicAccessPolicy;SharedAccessKey=2c65KcZEHGlyzrzxgkuf8ku4gfv5FdugVbvP7Hz5yBc=";
            string sbTopic            = "rechargetopic";
            string sbSubscription     = "jitu007";

            try
            {
                subscriptionClient = new SubscriptionClient(sbConnectionString, sbTopic, sbSubscription);

                var messageHandlerOptions = new MessageHandlerOptions(ExceptionReceivedHandler)
                {
                    MaxConcurrentCalls = 1,
                    AutoComplete       = false
                };
                subscriptionClient.RegisterMessageHandler(ReceiveMessagesAsync, messageHandlerOptions);
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
            finally
            {
                Console.ReadKey();
                subscriptionClient.CloseAsync();
            }
        }
        async static Task Main(string[] args)
        {
            _logger = new LoggerConfiguration()
                      .WriteTo.Console()
                      .CreateLogger();
            _logger.Information("Testando o consumo de mensagens com Azure Service Bus");

            _logger.Information("Carregando configurações...");
            var builder = new ConfigurationBuilder()
                          .SetBasePath(Directory.GetCurrentDirectory())
                          .AddJsonFile($"appsettings.json");
            var configuration = builder.Build();

            string nomeTopic    = configuration["AzureServiceBus:Topic"];
            string subscription = configuration["AzureServiceBus:Subscription"];

            _subscriptionClient = new SubscriptionClient(
                configuration["AzureServiceBus:ConnectionString"],
                nomeTopic, subscription);

            _logger.Information($"Topic = {nomeTopic}");
            _logger.Information($"Subscription = {nomeTopic}");

            _conexaoRedis =
                ConnectionMultiplexer.Connect(configuration["BaseCotacoes"]);

            _logger.Information("Aguardando mensagens...");
            _logger.Information("Pressione Enter para encerrar");
            RegisterOnMessageHandlerAndReceiveMessages();

            Console.ReadLine();
            await _subscriptionClient.CloseAsync();

            _logger.Warning("Encerrando o processamento de mensagens!");
        }
示例#26
0
        static async Task Main(string[] args)
        {
            if (UseQueue)
            {
                queueClient = new QueueClient(ServiceBusConnectionString, QueueName)
                {
                    PrefetchCount = 0
                };
            }
            else
            {
                subscriptionClient = new SubscriptionClient(ServiceBusConnectionString, TopicName, SubscriptionName)
                {
                    PrefetchCount = 0
                };
            }

            string type = UseQueue ? "QUEUE" : "SUBSCRIPTION";

            Console.WriteLine("======================================================");
            Console.WriteLine($"LISTENING ({type}) . Press ENTER key to exit");
            Console.WriteLine("======================================================");

            RegisterOnMessageHandlerAndReceiveMessages();

            Console.ReadKey();
            if (UseQueue)
            {
                await queueClient.CloseAsync();
            }
            else
            {
                await subscriptionClient.CloseAsync();
            }
        }
        public async Task Subscribe()
        {
            try
            {
                _subscriptionMesssage = GetSubscriptions();
                if (_subscriptionMesssage != null)
                {
                    _subscriptionClient = new SubscriptionClient(_subscriptionMesssage.PrimaryConnectionString
                                                                 , _subscriptionMesssage.TopicName, _subscriptionMesssage.SubscriptionName);
                    // Console.WriteLine("======================================================");
                    // Console.WriteLine("Press ENTER key to exit after receiving all the messages.");
                    // Console.WriteLine("======================================================");

                    // Register subscription message handler and receive messages in a loop
                    RegisterOnMessageHandlerAndReceiveMessages();
                }
            }
            catch (Exception ex)
            {
                _logger.LogError("Error - Subscription {Details}", ex);
            }
            finally
            {
                Console.ReadKey();
                await _subscriptionClient.CloseAsync();
            }
        }
示例#28
0
        static async Task MainAsync()
        {
            try
            {
                subscriptionClient = new SubscriptionClient(serviceBusConnectionString, topicName, subscriptionName);

                //var builder = new ServiceBusConnectionStringBuilder(serviceBusConnectionString);
                ////subscriptionClient = new SubscriptionClient(serviceBusConnectionString, topicName, subscriptionClient);
                //subscriptionClient = new SubscriptionClient(builder, subscriptionName);
                //subscriptionClient = new SubscriptionClient()

                Console.WriteLine("======================================================");
                Console.WriteLine("Press ENTER key to exit after receiving all the messages.");
                Console.WriteLine("======================================================");

                // Register subscription message handler and receive messages in a loop
                RegisterOnMessageHandlerAndReceiveMessages();



                Console.ReadKey();

                await subscriptionClient.CloseAsync();
            }
            catch (Exception ex)
            {
                int p = 90;
            }
        }
示例#29
0
        static async Task MainAsync()
        {
            const int numberOfMessages = 10;

            topicClient        = new TopicClient(ServiceBusConnectionString, TopicName);
            subscriptionClient = new SubscriptionClient(ServiceBusConnectionString, TopicName, SubscriptionName);

            // Ensure default rule exists
            await subscriptionClient.RemoveRuleAsync(RuleDescription.DefaultRuleName);

            await subscriptionClient.AddRuleAsync(new RuleDescription(RuleDescription.DefaultRuleName, new TrueFilter()));

            Console.WriteLine("======================================================");
            Console.WriteLine("Press any key to exit after receiving all the messages.");
            Console.WriteLine("======================================================");

            // Register Subscription's MessageHandler and receive messages in a loop
            RegisterOnMessageHandlerAndReceiveMessages();

            // Send Messages
            await SendMessagesAsync(numberOfMessages);

            Console.ReadKey();

            await subscriptionClient.CloseAsync();

            await topicClient.CloseAsync();
        }
        public async void TryReconnect()
        {
            if (MessagesListedByGroup.Count == 0 && _sessionsInitializedCount >= _concurrentSessions)
            {
                _sessionsInitializedCount    = 0;
                _processedSessionsDictionary = new ConcurrentDictionary <string, short>();
                try {
                    await subscriptionClient.CloseAsync();
                } catch (Exception ex) {
                    if (!(logger is null))
                    {
                        logger.LogWarning(ex.Message);
                    }
                }
                subscriptionClient = new SubscriptionClient(ServiceBusConnectionString, TopicName, SubscriptionName);

                var sessionOptions = new MessageHandlerOptions(ExceptionReceivedHandler)
                {
                    AutoComplete         = false,
                    MaxConcurrentCalls   = _concurrentSessions,
                    MaxAutoRenewDuration = TimeSpan.FromMinutes(_messageLockMinutes)
                                           //MessageWaitTimeout = TimeSpan.FromSeconds(30)
                };

                subscriptionClient.PrefetchCount = 0;
                subscriptionClient.RegisterMessageHandler(OnMessage, sessionOptions);
            }
        }