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);
}
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);
}
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 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);
}
