protected async void ReceiveMessages(Func <Message, CancellationToken, Task> handler)
        {
            var serviceBusConfiguration = _configuration.GetSection("serviceBus").Get <ServiceBusConfiguration>();
            var subscriptionClient      = new SubscriptionClient(serviceBusConfiguration.ConnectionString, _topic, _subscriptionName);

            var rules = await subscriptionClient.GetRulesAsync();

            if (rules.Any(x => x.Name == "$Default"))
            {
                await subscriptionClient.RemoveRuleAsync("$Default");
            }

            if (!rules.Any(x => x.Name == "filter-store"))
            {
                await subscriptionClient.AddRuleAsync(new RuleDescription
                {
                    Filter = new CorrelationFilter {
                        Label = _storeId
                    },
                    Name = "filter-store"
                });
            }

            var mo = new MessageHandlerOptions(ExceptionHandle)
            {
                AutoComplete = true
            };

            subscriptionClient.RegisterMessageHandler(handler, mo);
        }
예제 #2
0
        private bool CheckSubscriptionExists(string _SubscriptionName, ITopicClient _TopicClient, out Microsoft.Azure.ServiceBus.ISubscriptionClient _SubscriptionClient)
        {
            _SubscriptionClient = null;

            if (AzureNamespaceManager == null)
            {
                return(false);
            }

            try
            {
                using (var GetTopicTask = AzureNamespaceManager.Topics.GetByNameAsync(_SubscriptionName))
                {
                    GetTopicTask.Wait();
                    if (GetTopicTask.Result != null && GetTopicTask.Result.Name != null && GetTopicTask.Result.Name.Length > 0)
                    {
                        var TopicManager = GetTopicTask.Result;
                        using (var GetSubscriptionTask = TopicManager.Subscriptions.GetByNameAsync(_SubscriptionName))
                        {
                            GetSubscriptionTask.Wait();
                            if (GetSubscriptionTask.Result != null && GetSubscriptionTask.Result.Name != null && GetSubscriptionTask.Result.Name.Length > 0)
                            {
                                _SubscriptionClient = new Microsoft.Azure.ServiceBus.SubscriptionClient(ServiceBusNamespaceConnectionString, _TopicClient.Path, _SubscriptionName);
                                return(true);
                            }
                        }
                    }
                }
            }
            catch (Exception) { }

            return(false);
        }
예제 #3
0
        private void ReceiveMessages()
        {
            _subscriptionClient = new SubscriptionClient(_serviceBusConfiguration.ConnectionString, _topicName, SubscriptionName);

            var mo = new MessageHandlerOptions(ExceptionHandle)
            {
                AutoComplete = true
            };

            _subscriptionClient.RegisterMessageHandler(Handle, mo);
        }
예제 #4
0
        private static void ReceiveMessages()
        {
            var subscriptionClient = new SubscriptionClient(_serviceBusConfiguration.ConnectionString, TopicName, SubscriptionName);
            var mo = new MessageHandlerOptions(ExceptionHandle)
            {
                AutoComplete = true
            };

            subscriptionClient.RegisterMessageHandler(Handle, mo);
            Console.ReadLine();
        }
예제 #5
0
        public static void Main(string[] args)
        {
            var appConfig = GetAppConfig();

            Console.WriteLine("==> Config: " + appConfig);
            var subConnectionString = new ServiceBusConnectionStringBuilder(appConfig.SubEndpoint);
            var subClient           = new Microsoft.Azure.ServiceBus.SubscriptionClient(subConnectionString, appConfig.SubscriptionName);

            subClient.RegisterMessageHandler(HandleMessage, ErrorHandler);
            CreateHostBuilder(args).Build().Run();
        }
예제 #6
0
        private void ATestTopicAndATestSubscription()
        {
            testTopicClient        = new TopicClient(ServiceBusConnectionString, TopicName);
            testSubscriptionClient = new SubscriptionClient(ServiceBusConnectionString, TopicName, SubscriptionName);

            // create test subscription
            namespaceManager = NamespaceManager.CreateFromConnectionString(ServiceBusConnectionString);
            namespaceManager.CreateSubscription(TopicName, TEST_MESSAGE_SUB);

            options = new OnMessageOptions()
            {
                AutoComplete = false, AutoRenewTimeout = TimeSpan.FromMinutes(1),
            };
        }
        public bool CreateIfNotExistSubscriptionToPublishSubscribeChannel(string connectionstring, string path, string subscription, string origin, bool all)
        {
            var configuration = JsonConvert.DeserializeObject <ServiceBusConfiguration>(connectionstring);

            var serviceBusNamespace = GetServiceBusNamespace(configuration);

            if (serviceBusNamespace != null)
            {
                try
                {
                    var topic = serviceBusNamespace.Topics.GetByName(path);

                    try
                    {
                        topic.Subscriptions.GetByName(subscription);

                        return(false);
                    }
                    catch (CloudException ex)
                    {
                        if (ex.Response.StatusCode == HttpStatusCode.NotFound)
                        {
                            topic.Subscriptions.Define(subscription)
                            .WithDefaultMessageTTL(TimeSpan.FromDays(14))
                            .WithMessageLockDurationInSeconds(300)
                            .Create();

                            var subs = new Microsoft.Azure.ServiceBus.SubscriptionClient(configuration.ConnectionString, path, subscription);

                            if (!all)
                            {
                                subs.RemoveRuleAsync("$Default").GetAwaiter().GetResult();

                                var ruledescriptor = new RuleDescription("$Default", new SqlFilter($"origin='{origin}'"));

                                subs.AddRuleAsync(ruledescriptor).GetAwaiter().GetResult();
                            }

                            return(true);
                        }
                    }
                }
                catch (Exception)
                {
                    return(false);
                }
            }

            return(false);
        }
예제 #8
0
        private bool EnsureSubscriptionExists(string _SubscriptionName, ITopicClient _TopicClient, out Microsoft.Azure.ServiceBus.ISubscriptionClient _SubscriptionClient, Action <string> _ErrorMessageAction)
        {
            bool bExists = CheckSubscriptionExists(_SubscriptionName, _TopicClient, out _SubscriptionClient);

            if (!bExists)
            {
                if (AzureNamespaceManager == null)
                {
                    return(false);
                }

                try
                {
                    using (var GetTopicTask = AzureNamespaceManager.Topics.GetByNameAsync(_SubscriptionName))
                    {
                        GetTopicTask.Wait();
                        if (GetTopicTask.Result != null && GetTopicTask.Result.Name != null && GetTopicTask.Result.Name.Length > 0)
                        {
                            var TopicManager = GetTopicTask.Result;
                            using (var CreateSubscriptionTask = TopicManager.Subscriptions.Define(_SubscriptionName).CreateAsync())
                            {
                                CreateSubscriptionTask.Wait();
                                if (CreateSubscriptionTask.Result != null && CreateSubscriptionTask.Result.Name != null && CreateSubscriptionTask.Result.Name.Length > 0)
                                {
                                    _SubscriptionClient = new Microsoft.Azure.ServiceBus.SubscriptionClient(ServiceBusNamespaceConnectionString, _TopicClient.Path, _SubscriptionName);
                                    bExists             = true;
                                }
                            }
                        }
                    }
                }
                catch (Exception e)
                {
                    bExists = false;
                    _ErrorMessageAction?.Invoke("BPubSubServiceAzure->EnsureSubscriptionExists->Callback: " + e.Message + ", Trace: " + e.StackTrace);
                    if (e.InnerException != null && e.InnerException != e)
                    {
                        _ErrorMessageAction?.Invoke("BPubSubServiceAzure->EnsureSubscriptionExists->Inner: " + e.InnerException.Message + ", Trace: " + e.InnerException.StackTrace);
                    }
                }
            }
            return(bExists);
        }
예제 #9
0
        private static async void ReceiveMessages()
        {
            var subscriptionClient = new SubscriptionClient(serviceBusConfiguration.ConnectionString, Topic, SubscriptionName);
            await subscriptionClient.RemoveRuleAsync("$Default");

            await subscriptionClient.AddRuleAsync(new RuleDescription
            {
                Filter = new CorrelationFilter {
                    Label = _storeId
                },
                Name = "filter-store"
            });

            var mo = new MessageHandlerOptions(ExceptionHandle)
            {
                AutoComplete = true
            };

            subscriptionClient.RegisterMessageHandler(Handle, mo);
        }
        private async void ReceiveMessages()
        {
            var subscriptionClient = new SubscriptionClient(serviceBusConfiguration.ConnectionString, TopicProduction, SubscriptionName);

            //by default a 1=1 rule is added when subscription is created, so we need to remove it
            await subscriptionClient.RemoveRuleAsync("$Default");

            await subscriptionClient.AddRuleAsync(new RuleDescription
            {
                Filter = new CorrelationFilter {
                    Label = _storeId
                },
                Name = "filter-store"
            });

            var mo = new MessageHandlerOptions(ExceptionHandle)
            {
                AutoComplete = true
            };

            subscriptionClient.RegisterMessageHandler(Handle, mo);
        }
예제 #11
0
        private async void GetOrder()
        {
            string connectionString   = _configuration["serviceBus:connectionString"];
            var    subscriptionClient = new Microsoft.Azure.ServiceBus.SubscriptionClient(connectionString, "newOrder", "mySubscrition");
            await subscriptionClient.RemoveRuleAsync("$Default");

            await subscriptionClient.AddRuleAsync(new RuleDescription
            {
                Filter = new CorrelationFilter
                {
                    Label = "LosAngeles"
                },
                Name = "filter-store"
            });

            var mo = new MessageHandlerOptions(ExceptionHandle)
            {
                AutoComplete = true
            };

            subscriptionClient.RegisterMessageHandler(Handle, mo);
        }
예제 #12
0
        internal static AzureInboundMessage <TContent> LoadFromBrokeredMessage(Microsoft.Azure.ServiceBus.Message inboundMessage,
                                                                               SubscriptionType subscriptioType, IMessageSerializer serializer, Microsoft.Azure.ServiceBus.SubscriptionClient subscription)
        {
            var content = serializer.Deserialize <TContent>(inboundMessage.Body);

            var msg = new AzureInboundMessage <TContent>
            {
                innerMessage      = inboundMessage,
                azureSubscription = subscription,
                Content           = content,
                subscriptionIsReceiveAndDelete = subscriptioType == SubscriptionType.ReceiveAndDelete,
                //This probably isnt necessary
                CorrelationId = inboundMessage.CorrelationId,
                ReceivedTime  = DateTimeOffset.UtcNow,
                MessageId     = inboundMessage.MessageId,
            };

            return(msg);
        }
예제 #13
0
 public static SubscriptionClient Create(ServiceBusEntityConnection topicConnection, string subscriptionName)
 {
     return(SubscriptionClient.Create(topicConnection, subscriptionName, ReceiveMode.PeekLock));
 }
예제 #14
0
 public static SubscriptionClient Create(ServiceBusNamespaceConnection namespaceConnection, string topicPath, string subscriptionName)
 {
     return(SubscriptionClient.Create(namespaceConnection, topicPath, subscriptionName, ReceiveMode.PeekLock));
 }
예제 #15
0
        public async Task Run(string connectionString)
        {
            // Start senders and receivers:
            Console.WriteLine("\nLaunching senders and receivers...");


            var topicClient = new TopicClient(connectionString, TopicName);

            Console.WriteLine("Preparing to send messages to {0}...", topicClient.Path);

            // Send messages to queue:
            Console.WriteLine("Sending messages to topic {0}", topicClient.Path);

            var rand = new Random();

            for (var i = 0; i < 100; ++i)
            {
                var msg = new Message()
                {
                    TimeToLive     = TimeSpan.FromMinutes(2),
                    UserProperties =
                    {
                        { "Priority", rand.Next(1, 4) }
                    }
                };

                await topicClient.SendAsync(msg);

                this.OutputMessageInfo("Sent: ", msg);
            }

            Console.WriteLine();


            // All messages sent
            Console.WriteLine("\nSender complete.");

            // start receive
            Console.WriteLine("Receiving messages by priority ...");
            var subClient1 = new Microsoft.Azure.ServiceBus.SubscriptionClient(connectionString,
                                                                               TopicName, "Priority1Subscription", ReceiveMode.PeekLock);
            var subClient2 = new Microsoft.Azure.ServiceBus.SubscriptionClient(connectionString,
                                                                               TopicName, "Priority2Subscription", ReceiveMode.PeekLock);
            var subClient3 = new Microsoft.Azure.ServiceBus.SubscriptionClient(connectionString,
                                                                               TopicName, "PriorityGreaterThan2Subscription", ReceiveMode.PeekLock);


            Func <SubscriptionClient, Message, CancellationToken, Task> callback = (c, message, ct) =>
            {
                this.OutputMessageInfo("Received: ", message);
                return(Task.CompletedTask);
            };

            subClient1.RegisterMessageHandler((m, c) => callback(subClient1, m, c),
                                              new MessageHandlerOptions(LogMessageHandlerException)
            {
                MaxConcurrentCalls = 10, AutoComplete = true
            });
            subClient2.RegisterMessageHandler((m, c) => callback(subClient1, m, c),
                                              new MessageHandlerOptions(LogMessageHandlerException)
            {
                MaxConcurrentCalls = 5, AutoComplete = true
            });
            subClient3.RegisterMessageHandler((m, c) => callback(subClient1, m, c),
                                              new MessageHandlerOptions(LogMessageHandlerException)
            {
                MaxConcurrentCalls = 1, AutoComplete = true
            });

            Task.WaitAny(
                Task.Run(() => Console.ReadKey()),
                Task.Delay(TimeSpan.FromSeconds(10)));

            await Task.WhenAll(subClient1.CloseAsync(), subClient2.CloseAsync(), subClient3.CloseAsync());
        }
예제 #16
0
        public static MessagingOptions UseServiceBusBroker(
            this MessagingOptions options,
            Action <IMessageBroker> brokerAction = null,
            string topicName        = null,
            string subscriptionName = null,
            int?retries             = null,
            TimeSpan?expiration     = null,
            string section          = "naos:messaging:serviceBus")
        {
            EnsureArg.IsNotNull(options, nameof(options));
            EnsureArg.IsNotNull(options.Context, nameof(options.Context));

            subscriptionName ??= options.Context.Descriptor.Name.ToLower();
            var configuration = options.Context.Configuration.GetSection(section).Get <ServiceBusConfiguration>();

            if (configuration?.Enabled == true)
            {
                configuration.EntityPath = topicName ?? $"{Environment.GetEnvironmentVariable(EnvironmentKeys.Environment) ?? "Production"}-Naos.Messaging";
                options.Context.Services.AddSingleton <IServiceBusProvider>(sp =>
                {
                    return(new ServiceBusProvider(
                               sp.GetRequiredService <ILogger <ServiceBusProvider> >(),
                               SdkContext.AzureCredentialsFactory.FromServicePrincipal(configuration.ClientId, configuration.ClientSecret, configuration.TenantId, AzureEnvironment.AzureGlobalCloud),
                               configuration));
                });

                options.Context.Services.AddSingleton <Microsoft.Azure.ServiceBus.ISubscriptionClient>(sp =>
                {
                    var logger   = sp.GetRequiredService <ILogger <ServiceBusMessageBroker> >();
                    var provider = sp.GetRequiredService <IServiceBusProvider>();
                    provider.EnsureTopicSubscription(provider.ConnectionStringBuilder.EntityPath, subscriptionName);

                    var client = new Microsoft.Azure.ServiceBus.SubscriptionClient(provider.ConnectionStringBuilder, subscriptionName);
                    try
                    {
                        client
                        .RemoveRuleAsync(RuleDescription.DefaultRuleName)
                        .GetAwaiter()
                        .GetResult();
                    }
                    catch (MessagingEntityNotFoundException)
                    {
                        // do nothing, default rule not found
                    }

                    client.RegisterMessageHandler(
                        async(m, t) =>
                    {
                        //this.logger.LogInformation("message received (id={MessageId}, name={MessageName})", message.MessageId, message.Label);
                        if (await ServiceBusMessageBroker.ProcessMessage(
                                logger,
                                (ITracer)sp.CreateScope().ServiceProvider.GetService(typeof(ITracer)),
                                sp.GetRequiredService <ISubscriptionMap>(),
                                new ServiceProviderMessageHandlerFactory(sp),
                                DefaultSerializer.Create,
                                subscriptionName,
                                (IMediator)sp.CreateScope().ServiceProvider.GetService(typeof(IMediator)),
                                m).AnyContext())
                        {
                            // complete message so it is not received again
                            await client.CompleteAsync(m.SystemProperties.LockToken).AnyContext();
                        }
                    },
                        new MessageHandlerOptions(args =>
                    {
                        var context = args.ExceptionReceivedContext;
                        logger.LogWarning($"{{LogKey:l}} servicebus handler error: topic={context?.EntityPath}, action={context?.Action}, endpoint={context?.Endpoint}, {args.Exception?.Message}, {args.Exception?.StackTrace}", LogKeys.AppMessaging);
                        return(Task.CompletedTask);
                    })
                    {
                        MaxConcurrentCalls   = 10,
                        AutoComplete         = false,
                        MaxAutoRenewDuration = new TimeSpan(0, 5, 0)
                    });

                    return(client);
                });

                options.Context.Services.AddScoped <IMessageBroker>(sp => // TODO: scoped with ITracer injected
                {
                    var broker = new ServiceBusMessageBroker(o => o
                                                             .LoggerFactory(sp.GetRequiredService <ILoggerFactory>())
                                                             .Tracer(sp.GetService <ITracer>())
                                                             .Mediator(sp.GetService <IMediator>())
                                                             .Provider(sp.GetRequiredService <IServiceBusProvider>())                          // singleton
                                                             .Client(sp.GetRequiredService <Microsoft.Azure.ServiceBus.ISubscriptionClient>()) // singleton
                                                             .HandlerFactory(new ServiceProviderMessageHandlerFactory(sp))
                                                             .Subscriptions(sp.GetRequiredService <ISubscriptionMap>())                        // singleton
                                                             .SubscriptionName(subscriptionName)                                               //AppDomain.CurrentDomain.FriendlyName, // PRODUCT.CAPABILITY
                                                                                                                                               //.MessageScope(options.Context.Descriptor.Name)
                                                             .Retries(retries)
                                                             .Expiration(expiration)
                                                             .FilterScope(Environment.GetEnvironmentVariable(EnvironmentKeys.IsLocal).ToBool()
                                ? Environment.MachineName.Humanize().Dehumanize().ToLower()
                                : string.Empty));

                    brokerAction?.Invoke(broker);
                    return(broker);
                }); // scope the messagebus messages to the local machine, so local events are handled locally

                options.Context.Services.AddHealthChecks()
                .AddAzureServiceBusTopic(configuration.ConnectionString, configuration.EntityPath, "messaging-broker-servicebus");

                options.Context.Messages.Add($"naos services builder: messaging added (broker={nameof(ServiceBusMessageBroker)})");
            }
            else
            {
                throw new NaosException("no messaging servicebus is enabled");
            }

            return(options);
        }