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); }
private void ReceiveMessages() { _subscriptionClient = new SubscriptionClient(_serviceBusConfiguration.ConnectionString, _topicName, SubscriptionName); var mo = new MessageHandlerOptions(ExceptionHandle) { AutoComplete = true }; _subscriptionClient.RegisterMessageHandler(Handle, mo); }
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(); }
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(); }
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); }
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); }
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()); }
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); }