public static async Task AddRulesAsync(AzureServiceBusConfiguration configuration)
{
ServiceBusConnectionStringBuilder connectionStringBuilder = new ServiceBusConnectionStringBuilder(configuration.ConnectionString);
foreach (Topic topic1 in configuration.Topics)
{
Topic topic = topic1;
Console.WriteLine("Topic: " + topic.Name + ". Start");
connectionStringBuilder.EntityPath = topic.Name;
foreach (Subscriber subscriber1 in topic.Subscribers)
{
Subscriber subscriber = subscriber1;
Console.WriteLine("Subscriber: " + subscriber.Name + ". Start");
SubscriptionClient subscriptionClient = new SubscriptionClient(connectionStringBuilder, subscriber.Name, ReceiveMode.PeekLock, (RetryPolicy)null);
await ServiceBusSubscriber.AddRules(subscriber, subscriptionClient);
Console.WriteLine("Subscriber: " + subscriber.Name + ". End");
await subscriptionClient.CloseAsync();
subscriptionClient = (SubscriptionClient)null;
subscriber = (Subscriber)null;
}
Console.WriteLine("Topic: " + topic.Name + ". End");
topic = (Topic)null;
}
}
public async Task InitializeEventBusAsync(IConfiguration configuration)
{
AzureServiceBusConfiguration azureAzureServiceBusConfiguration = new AzureServiceBusConfiguration();
configuration
.GetSection(SettingKeyConstants.ServiceBusConfigurationKey)
.Bind(azureAzureServiceBusConfiguration);
ServiceBusConnectionStringBuilder connectionStringBuilder =
new ServiceBusConnectionStringBuilder(azureAzureServiceBusConfiguration.ConnectionString);
foreach (Topic topic in azureAzureServiceBusConfiguration.Topics)
{
Console.WriteLine($"Topic: {topic.Name}. Start");
connectionStringBuilder.EntityPath = topic.Name;
foreach (Subscriber subscriber in topic.Subscribers)
{
Console.WriteLine($"Subscriber: {subscriber.Name}. Start");
SubscriptionClient subscriptionClient =
new SubscriptionClient(connectionStringBuilder, subscriber.Name);
await AddRules(subscriber, subscriptionClient);
Console.WriteLine($"Subscriber: {subscriber.Name}. End");
await subscriptionClient.CloseAsync();
}
Console.WriteLine($"Topic: {topic.Name}. End");
}
}
public AzureTopicAddress(AzureServiceBusConfiguration sbConfiguration, AuthenticationConfiguration authConfigruation, string middlewareName, string middlewareReferenceId)
{
ServiceBusConfiguration = sbConfiguration;
AuthenticationConfiguration = authConfigruation;
TopicName = middlewareName;
SubscriptionName = $"{middlewareName}-{middlewareReferenceId}";
CorrelationFilter = middlewareReferenceId;
}
public void ConfigureBinding_BindingIsNull_Throws()
{
// Arrange
// Act
var config = new AzureServiceBusConfiguration();
// Assert
Assert.Throws<ArgumentNullException>(() => config.ConfigureBinding(null));
}
public ReceivingEndpoint(AzureServiceBusConfiguration configuration,
IServiceBusManagementClient sbManagementClient,
string topicName,
IEnumerable <string> eventMessageTypeNames)
{
this.configuration = configuration;
this.sbManagementClient = sbManagementClient;
this.topicName = topicName;
this.eventMessageTypeNames = eventMessageTypeNames;
}
public void MaxConcurrentRequests_GreaterThenMinConcurrent_IsSet(int maxConcurrentRequest)
{
// Arrange
// Act
var config = new AzureServiceBusConfiguration();
config.MaxConcurrentRequests = maxConcurrentRequest;
// Assert
Assert.Equal(maxConcurrentRequest, config.MaxConcurrentRequests);
}
public async static Task Main(string[] args)
{
var host = new HostBuilder()
.ConfigureServices((hostContext, services) =>
{
services.AddLogging();
var subscriptions = new Subscription[]
{
new AzureServiceBusSubscription <GreetingAsyncEvent>(
typeof(GreetingAsyncEvent),
new SubscriptionName(GreetingEventAsyncMessageMapper.Topic),
new ChannelName("paramore.example.greeting"),
new RoutingKey(GreetingEventAsyncMessageMapper.Topic),
timeoutInMilliseconds: 400,
makeChannels: OnMissingChannel.Validate,
requeueCount: 3,
isAsync: true),
new AzureServiceBusSubscription <GreetingEvent>(
typeof(GreetingEvent),
new SubscriptionName(GreetingEventMessageMapper.Topic),
new ChannelName("paramore.example.greeting"),
new RoutingKey(GreetingEventMessageMapper.Topic),
timeoutInMilliseconds: 400,
makeChannels: OnMissingChannel.Validate,
requeueCount: 3,
isAsync: false)
};
//create the gateway
var asbConfig = new AzureServiceBusConfiguration("Endpoint=sb://fim-development-bus.servicebus.windows.net/;Authentication=Managed Identity", true);
var asbConsumerFactory = new AzureServiceBusConsumerFactory(asbConfig);
services.AddServiceActivator(options =>
{
options.Subscriptions = subscriptions;
options.ChannelFactory = new AzureServiceBusChannelFactory(asbConsumerFactory);
}).UseInMemoryOutbox()
.UseExternalBus(AzureServiceBusMessageProducerFactory.Get(asbConfig))
.AutoFromAssemblies();
services.AddHostedService <ServiceActivatorHostedService>();
})
.ConfigureLogging((hostingContext, logging) => {
logging.SetMinimumLevel(LogLevel.Information);
logging.AddConsole();
})
.UseConsoleLifetime()
.Build();
await host.RunAsync();
}
public void AzureServiceBusConfiguration_BaseAddress_IsSet()
{
// Arrange
string baseAddress = "http://localhost";
// Act
var config = new AzureServiceBusConfiguration(baseAddress);
// Assert
Assert.Equal(new Uri(baseAddress), config.BaseAddress);
}
public static async Task InitializeAsync(
IConfigurationRoot configuration,
string sectionName = "AzureServiceBus")
{
Console.WriteLine("Start Azure Service Bus initialization....");
AzureServiceBusConfiguration azureServiceBusConfiguration = new AzureServiceBusConfiguration();
configuration.GetSection(sectionName).Bind((object)azureServiceBusConfiguration);
await ServiceBusSubscriber.AddRulesAsync(azureServiceBusConfiguration);
Console.WriteLine("End Azure Service Bus initialization....");
}
internal AzureConfiguration(ApplicationConfiguration application)
{
if (application == null)
{
throw new ArgumentNullException(nameof(application));
}
Application = application.Extensibility(extensibility =>
{
_blobStorage = extensibility.Register(() => new AzureBlobStorageConfiguration(application));
_serviceBus = extensibility.Register(() => new AzureServiceBusConfiguration(application));
});
}
public void ConfigureBinding_BindingPassed_ReturnsBindingsParameters()
{
// Arrange
var config = new AzureServiceBusConfiguration();
var binding = new WebHttpRelayBinding();
// Act
var bindingsParameters = config.ConfigureBinding(binding);
var bindingParameter = bindingsParameters.Find<TransportClientEndpointBehavior>();
// Assert
Assert.NotNull(bindingParameter);
}
public IHealthChecksBuilder AddEventBusHealthCheck(IHealthChecksBuilder healthChecksBuilder, IConfiguration configuration)
{
AzureServiceBusConfiguration azureServiceBusConfiguration = new AzureServiceBusConfiguration();
configuration
.GetSection(SettingKeyConstants.ServiceBusConfigurationKey)
.Bind(azureServiceBusConfiguration);
return(healthChecksBuilder.Add(new HealthCheckRegistration(
nameof(AzureServiceBusRulesHealthCheck),
sp => new AzureServiceBusRulesHealthCheck(azureServiceBusConfiguration),
HealthStatus.Unhealthy,
Enumerable.Empty <string>())));
}
public AzureServiceBusRegistry(AzureServiceBusConfiguration configuration)
{
var topicNameFormatterType = Type.GetType(configuration.TopicNameFormatter);
if (topicNameFormatterType == null)
{
throw new Exception($"TopicNameFormatter {configuration.TopicNameFormatter} was not recognized as a valid class");
}
var topicNameFormatter = (ITopicNameFormatter)Activator.CreateInstance(topicNameFormatterType);
For <ITopicNameFormatter>().Singleton().Use(topicNameFormatter);
For <IServiceBusInitialiser>().Singleton().Use <AzureServiceBusInitialiser>();
For <IServiceBus>().Singleton().Use <AzureServiceBus>();
For <IClientFactory>().Singleton().Use <ClientFactory>();
}
public static IBusConfigurator UseAzureServiceBusTransport(this IBusConfigurator busConfigurator,
AzureServiceBusConfiguration config,
Action <IAzureServiceBusConfigurationBuilder> builderFunc = null)
{
//https://docs.microsoft.com/en-us/azure/service-bus-messaging/service-bus-performance-improvements?tabs=net-standard-sdk-2#reusing-factories-and-clients
busConfigurator.Services
.AddSingleton(config)
.AddSingleton(ctx => new ServiceBusClient(config.ConnectionString, new ServiceBusClientOptions()))
.AddSingleton <IQueueReferenceFactory, QueueReferenceFactory>()
.AddSingleton <IServiceBusSenderFactory, ServiceBusSenderFactory>()
.AddSingleton <IPublisher, ServiceBusPublisher>();
builderFunc?.Invoke(new DefaultAzureServiceBusConfigurationBuilder(busConfigurator));
return(busConfigurator);
}
public void AddEventBus(IServiceCollection serviceCollection, IConfiguration configuration)
{
AzureServiceBusConfiguration azureServiceBusConfiguration = new AzureServiceBusConfiguration();
configuration
.GetSection(SettingKeyConstants.ServiceBusConfigurationKey)
.Bind(azureServiceBusConfiguration);
serviceCollection.AddSingleton <IAzureServiceBusPersistentConnection>(sp =>
new AzureServiceBusPersistentConnection(azureServiceBusConfiguration.ConnectionString));
serviceCollection.AddSingleton <IServiceBusClient, AzureServiceBusClient>();
serviceCollection.Configure <AzureServiceBusSubscriptionConfiguration>(configuration.GetSection(nameof(AzureServiceBusSubscriptionConfiguration)));
serviceCollection.AddSingleton(typeof(IServiceBusSubscriptionClient <,>), typeof(AzureServiceBusSubscriptionClient <,>));
}
public async Task StartApplication()
{
MessageBrokerContext.SetEnvironment(Configuration.Environment);
var azureConfiguration = new AzureServiceBusConfiguration
{
ConnectionString = File.ReadAllText($"{AppContext.BaseDirectory}\\ConnectionString.txt")
};
var logInstance = new LoggerConfiguration()
.MinimumLevel.Verbose()
.Enrich.FromLogContext()
.Enrich.WithProperty("Environment", "Testing")
.WriteTo.Seq("http://localhost:5341")
.CreateLogger();
_resolver = ConfigureDependencies.Initialise()
.AddAzureServiceBusTransportProvider(azureConfiguration)
.AddCoreDependencies()
.ScanForHandlers(Assembly.GetExecutingAssembly())
.Build();
var configurationBuilder = _resolver.GetInstance <BusConfigurationBuilder>();
await configurationBuilder
.SubscribeToQueue <TestQueue>()
.SubscribeToEvent <TestEventV1>(Configuration.Subscription1)
.SubscribeToEvent <MultipleSubscribersEventV1>(Configuration.Subscription1)
.SubscribeToEvent <MultipleSubscribersEventV1>(Configuration.Subscription2)
.PublishEvent <TestEventV1>()
.PublishEvent <MultipleSubscribersEventV1>()
.UseLogger(logInstance)
.BuildAsync();
_monitor = _resolver.GetInstance <IMonitor>();
_monitor.Start();
Bus = _resolver.GetInstance <IBus>();
}
static void Main(string[] args)
{
var serviceCollection = new ServiceCollection();
serviceCollection.AddLogging();
var asbConnection = new AzureServiceBusConfiguration("Endpoint=sb://.servicebus.windows.net/;Authentication=Managed Identity", true);
var producer = AzureServiceBusMessageProducerFactory.Get(asbConnection);
serviceCollection.AddBrighter(options =>
{
var outBox = new InMemoryOutbox();
options.BrighterMessaging = new BrighterMessaging(outBox, producer: producer);
}).AutoFromAssemblies();
var serviceProvider = serviceCollection.BuildServiceProvider();
var commandProcessor = serviceProvider.GetService <IAmACommandProcessor>();
bool run = true;
while (run)
{
Console.WriteLine("Sending....");
commandProcessor.Post(new GreetingEvent("Paul"));
commandProcessor.Post(new GreetingAsyncEvent("Paul - Async"));
Console.WriteLine("Press q to Quit or any other key to continue");
var keyPress = Console.ReadKey();
if (keyPress.KeyChar == 'q')
{
run = false;
}
}
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
//string dbConnString = "server=(localdb)\\mssqllocaldb;database=BrighterTests;trusted_connection=yes;MultipleActiveResultSets=True";
string dbConnString = "server=(localdb)\\mssqllocaldb;database=BrighterTests;trusted_connection=yes";
//EF
services.AddDbContext <GreetingsDataContext>(o =>
{
o.UseSqlServer(dbConnString);
});
//Brighter
string asbConnectionString = "Endpoint=sb://.servicebus.windows.net/;Authentication=Managed Identity";
var asbConnection = new AzureServiceBusConfiguration(asbConnectionString, true);
var producer = AzureServiceBusMessageProducerFactory.Get(asbConnection);
var outboxConfig = new MsSqlConfiguration(dbConnString, "BrighterOutbox");
services
.AddBrighter(opt =>
{
opt.PolicyRegistry = new DefaultPolicy();
opt.CommandProcessorLifetime = ServiceLifetime.Scoped;
})
.UseExternalBus(producer)
//.UseMsSqlOutbox(outboxConfig, typeof(MsSqlOutboxSqlAuthConnectionFactory))
.UseMsSqlOutbox(outboxConfig, typeof(MsSqlEntityFrameworkCoreConnectionProvider <GreetingsDataContext>), ServiceLifetime.Scoped)
.MapperRegistry(r =>
{
r.Add(typeof(GreetingEvent), typeof(GreetingEventMessageMapper));
r.Add(typeof(GreetingAsyncEvent), typeof(GreetingEventAsyncMessageMapper));
});
services.AddControllersWithViews();
}
static IHostBuilder CreateHostBuilder(string[] args) =>
Host.CreateDefaultBuilder(args)
.ConfigureAppConfiguration(builder => { builder.AddUserSecrets <Program>(); })
.ConfigureServices((hostContext, services) =>
{
services.AddLogging(cfg => { cfg.AddConsole(); })
.AddOpenSleigh(cfg =>
{
var connStr = hostContext.Configuration.GetConnectionString("AzureServiceBus");
if (string.IsNullOrWhiteSpace(connStr))
{
throw new ArgumentNullException(
"please provide a valid Azure Service Bus connection string");
}
var azureSBCfg = new AzureServiceBusConfiguration(connStr);
cfg.UseAzureServiceBusTransport(azureSBCfg)
.UseInMemoryPersistence();
cfg.AddSaga <MySaga, MySagaState>()
.UseStateFactory <StartSaga>(msg => new MySagaState(msg.CorrelationId))
.UseAzureServiceBusTransport();
});
});
public TopicClientProvider(AzureServiceBusConfiguration configuration)
{
_connectionString = configuration.ConnectionString;
}
public MessageReceiverProvider(AzureServiceBusConfiguration configuration)
{
_connectionString = configuration.ConnectionString;
}
public AzureServiceBusRulesHealthCheck(AzureServiceBusConfiguration rulesConfiguration)
{
_rulesConfiguration =
Guard.Argument(rulesConfiguration, nameof(rulesConfiguration)).NotNull();
}
public static IServiceCollection AddMassTransitBus(this IServiceCollection serviceCollection, AzureServiceBusConfiguration config)
{
serviceCollection.AddMassTransit(
provider => Bus.Factory.CreateUsingAzureServiceBus(cfg =>
{
cfg.Host(config.ConnectionString, configure => { });
}));
return(serviceCollection);
}
public ManagementClientWrapper(AzureServiceBusConfiguration configuration)
{
_managementClient = new ManagementClient(configuration.ConnectionString);
}
public void MaxConcurrentRequests_LessThenMinConcurrent_Throws(int maxConcurrentRequest)
{
// Arrange
// Act
var config = new AzureServiceBusConfiguration();
// Assert
Assert.Throws<ArgumentOutOfRangeException>(() => config.MaxConcurrentRequests = maxConcurrentRequest);
}
public ManagementClientWrapper(AzureServiceBusConfiguration configuration)
{
_configuration = configuration;
Initialise();
}
public MessageBusBuilder(AzureServiceBusConfiguration configuration, IAuthContext authContext)
{
_configuration = configuration;
_authContext = authContext;
CreateServiceBus().Wait();
}
public AzureServiceBus(ILoggerFactory loggerFactory, IConfigService configService)
{
this.logger = loggerFactory.CreateLogger(this.GetType().Name);
this.config = configService.Get <AzureServiceBusConfiguration>("AzureServiceBusConfiguration");
}
public AzureServiceBusManagement(AzureServiceBusConfiguration configuration)
{
this.configuration = configuration;
}
private static AzureServiceBusHttpServer CreateServer()
{
var config = new AzureServiceBusConfiguration();
config.Routes.MapHttpRoute("Default", "{controller}/{action}");
var server = new AzureServiceBusHttpServer(config);
server.OpenAsync().Wait();
return server;
}
