/// <summary>
/// Add InMemory test harness. This can be reolved using <see cref="InMemoryTestHarness"/>.
/// <br/>
/// Ensure the InMemory transport has been added using
/// <see cref="AddInMemoryTransport(EventBusBuilder, Action{InMemoryTransportOptions})"/>
/// before resolving instances of <see cref="InMemoryTestHarness"/>.
/// </summary>
/// <param name="builder"></param>
/// <param name="configure"></param>
/// <returns></returns>
public static EventBusBuilder AddInMemoryTestHarness(this EventBusBuilder builder,
Action <InMemoryTestHarnessOptions> configure = null)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
var services = builder.Services;
// configure the options for InMemory test harness
if (configure != null)
{
services.Configure(configure);
}
// Register the harness
services.AddSingleton <InMemoryTestHarness>();
// Set the delivery delay to zero for instance delivery
services.Configure <InMemoryTransportOptions>(o => o.DeliveryDelay = TimeSpan.Zero);
services.AddSingleton <IPostConfigureOptions <InMemoryTestHarnessOptions>, InMemoryTestHarnessPostConfigureOptions>();
return(builder);
}
public static EventBusBuilder AddEventHandler <TEvent, THandler>(this EventBusBuilder eventBusBuilder)
where THandler : class, IIntegrationEventHandler <TEvent>
where TEvent : IntegrationEvent
{
eventBusBuilder.Services.AddTransient <THandler>();
return(eventBusBuilder);
}
private static IConfigurableEventBus CreateEventBus(EventBusBuilder eventBusBuilder, IServiceProvider serviceProvider)
{
var configuration = serviceProvider.GetRequiredService <IConfiguration>();
var section = configuration.GetSection(eventBusBuilder.ConfigurationName);
var eventBusType = section["Type"].ToString();
var subscriberManager = serviceProvider.GetRequiredService <SubscriberManager>();
foreach (var eventHandlerInfo in eventBusBuilder.EventHandlers)
{
subscriberManager.Add(eventHandlerInfo);
}
if (eventBusType.Equals("RabbitMq", StringComparison.InvariantCultureIgnoreCase))
{
return(CreateRabbitMq(eventBusBuilder, serviceProvider, configuration, subscriberManager));
}
else if (eventBusType.Equals("ServiceBus", StringComparison.InvariantCultureIgnoreCase))
{
return(CreateServiceBus(eventBusBuilder, serviceProvider, subscriberManager));
}
else
{
throw new InvalidOperationException($"The Type '{eventBusType}' of EventBus configuration '{eventBusBuilder.ConfigurationName}' is invalid.");
}
}
public static EventBusBuilder AddAsHostedService(this EventBusBuilder eventBusBuilder)
{
eventBusBuilder.Services.AddTransient <IHostedService, EventBusHostedService>(sp => new EventBusHostedService(eventBusBuilder.ConfigurationName,
sp.GetRequiredService <IEventBusFactory>(),
sp.GetRequiredService <ILoggerFactory>()));
return(eventBusBuilder);
}
public static EventBusBuilder AddEventHandler<TEventHandler>(this EventBusBuilder eventBusBuilder)
where TEventHandler : class, IRawEventHandler<byte[]>
{
eventBusBuilder.Services.AddTransient<TEventHandler>();
eventBusBuilder.EventHandlers.Add(new SubscriberInfo(typeof(byte[]), typeof(TEventHandler)));
return eventBusBuilder;
}
public static EventBusBuilder AddRabbitMq(this EventBusBuilder builder, Action <EventBusRabbitMqOptions> options = null)
{
builder.Service.AddSingleton <IMessagePublisher, RabbitMqMessagePublisher>();
builder.Service.AddSingleton <IMessageSubscribe, RabbitMqMessageSubscribe>();
if (options == null)
{
return(builder);
}
builder.Service.Configure(options);
return(builder);
}
public static EventBusBuilder AddEventBus(this IServiceCollection services)
{
if (services == null)
{
throw new ArgumentNullException(nameof(services));
}
services.TryAddSingleton <IEventBusSubscriptionsManager, InMemoryEventBusSubscriptionsManager>();
services.TryAddSingleton <IEventHandlerFactory, IocEventHandlerFactory>();
var builder = new EventBusBuilder(services);
return(builder);
}
private static IConfigurableEventBus CreateServiceBus(EventBusBuilder eventBusBuilder,
IServiceProvider serviceProvider,
SubscriberManager subscriberManager)
{
var connection = serviceProvider.GetServices <IServiceBusConnection>()
.Single(x => x.Name == eventBusBuilder.ConfigurationName);
return(new ServiceBusEventBus(eventBusBuilder.ConfigurationName,
connection,
subscriberManager,
serviceProvider,
serviceProvider.GetRequiredService <ILoggerFactory>()));
}
public static IServiceCollection AddEventBus(this IServiceCollection services,
Action <IEventBusBuilder> setupAction)
{
if (services == null)
{
throw new ArgumentNullException(nameof(services));
}
IEventBusBuilder builder = new EventBusBuilder(services)
.UseJsonSerializer()
;
setupAction?.Invoke(builder);
return(services);
}
public static EventBusBuilder AddRabbitMq(this EventBusBuilder builder, Action <EventBusRabbitMqOptions> optionAction)
{
optionAction = optionAction ?? throw new AggregateException(nameof(optionAction));
var option = new EventBusRabbitMqOptions();
optionAction.Invoke(option);
builder.Service.AddRabbitMq(options =>
{
options.Connection = option.RabbitMqConnection;
});
builder.Service.TryAddSingleton <IMessagePublisher, RabbitMqMessagePublisher>();
builder.Service.TryAddSingleton <IMessageSubscribe, RabbitMqMessageSubscribe>();
builder.Service.Configure(optionAction);
return(builder);
}
public static IServiceCollection AddEventBus(this IServiceCollection services,
string configurationName,
Action <EventBusBuilder> eventBusBuilderAction)
{
var eventBusBuilder = new EventBusBuilder(configurationName, services);
eventBusBuilderAction.Invoke(eventBusBuilder);
return(services.AddTransient <SubscriberManager>()
.AddSingleton <IEventBusFactory, EventBusFactory>()
.AddSingleton(sp => CreateEventBus(eventBusBuilder, sp))
.AddSingleton <IRabbitMqConnection>(sp => new RabbitMqConnection(eventBusBuilder.ConfigurationName,
sp.GetRequiredService <IConfiguration>()))
.AddTransient <IServiceBusConnection>(sp => new ServiceBusConnection(eventBusBuilder.ConfigurationName,
sp.GetRequiredService <IConfiguration>(),
sp.GetRequiredService <ILoggerFactory>())));
}
/// <summary>
/// Add Azure Queue Storage as the underlying transport for the Event Bus.
/// </summary>
/// <param name="builder"></param>
/// <param name="connectionString">
/// The connection string to the Azure Storage account.
/// Maps to <see cref="AzureQueueStorageTransportOptions.ConnectionString"/>.
/// </param>
/// <param name="configure"></param>
/// <returns></returns>
public static EventBusBuilder AddAzureQueueStorageTransport(this EventBusBuilder builder,
string connectionString,
Action <AzureQueueStorageTransportOptions> configure = null)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (string.IsNullOrWhiteSpace(connectionString))
{
throw new ArgumentException($"'{nameof(connectionString)}' cannot be null or whitespace", nameof(connectionString));
}
return(builder.AddAzureQueueStorageTransport(options =>
{
options.ConnectionString = connectionString;
configure?.Invoke(options);
}));
}
/// <summary>
/// Add Azure Queue Storage as the underlying transport for the Event Bus.
/// </summary>
/// <param name="builder"></param>
/// <param name="configure"></param>
/// <returns></returns>
public static EventBusBuilder AddAzureQueueStorageTransport(this EventBusBuilder builder, Action <AzureQueueStorageTransportOptions> configure)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (configure is null)
{
throw new ArgumentNullException(nameof(configure));
}
var services = builder.Services;
// configure the options for Azure Queue Storage
services.Configure(configure);
services.AddSingleton <IPostConfigureOptions <AzureQueueStorageTransportOptions>, AzureQueueStoragePostConfigureOptions>();
// register the transport
builder.AddTransport <AzureQueueStorageTransport, AzureQueueStorageTransportOptions>();
return(builder);
}
/// <summary>
/// Add InMemory as the underlying transport for the Event Bus.
/// </summary>
/// <param name="builder"></param>
/// <param name="configure"></param>
/// <returns></returns>
public static EventBusBuilder AddInMemoryTransport(this EventBusBuilder builder,
Action <InMemoryTransportOptions> configure = null)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
var services = builder.Services;
// configure the options for InMemory transport
if (configure != null)
{
services.Configure(configure);
}
services.AddSingleton <SequenceNumberGenerator>();
// register the transport
builder.AddTransport <InMemoryTransport, InMemoryTransportOptions>();
return(builder);
}
public static EventBusBuilder AddEventHandlers <TEvent, THandler0, THandler1, THandler2, THandler3>(this EventBusBuilder eventBusBuilder)
where THandler0 : class, IIntegrationEventHandler <TEvent>
where THandler1 : class, IIntegrationEventHandler <TEvent>
where THandler2 : class, IIntegrationEventHandler <TEvent>
where THandler3 : class, IIntegrationEventHandler <TEvent>
where TEvent : IntegrationEvent
{
eventBusBuilder.Services.AddTransient <THandler0>();
eventBusBuilder.Services.AddTransient <THandler1>();
eventBusBuilder.Services.AddTransient <THandler2>();
eventBusBuilder.Services.AddTransient <THandler3>();
return(eventBusBuilder);
}
