// This method gets called by the runtime. Use this method to add services to the container.
// For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
public void ConfigureServices(IServiceCollection services)
{
services.AddControllers(configure =>
{
configure.Filters.Add(typeof(GlobalExceptionFilter));
});
services.AddCors(options =>
{
options.AddPolicy("AllowAnyOrigin", builder => builder
.AllowAnyOrigin()
.AllowAnyMethod()
.AllowAnyHeader());
});
services.AddDateTimeProvider();
services.AddApplicationServices();
var storageOptions = new StorageOptions();
var messageBrokerOptions = new MessageBrokerOptions();
Configuration.GetSection("Storage").Bind(storageOptions);
Configuration.GetSection("MessageBroker").Bind(messageBrokerOptions);
services.AddStorageModule(storageOptions, messageBrokerOptions, Configuration.GetConnectionString("ClassifiedAds"));
services.AddAuthentication(IdentityServerAuthenticationDefaults.AuthenticationScheme)
.AddIdentityServerAuthentication(options =>
{
options.Authority = Configuration["IdentityServerAuthentication:Authority"];
options.ApiName = Configuration["IdentityServerAuthentication.ApiName"];
options.RequireHttpsMetadata = Configuration["IdentityServerAuthentication.RequireHttpsMetadata"] == "true";
});
}
// This method gets called by the runtime. Use this method to add services to the container.
// For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
public void ConfigureServices(IServiceCollection services)
{
if (string.Equals(Configuration["CheckDependency:Enabled"], "true", System.StringComparison.OrdinalIgnoreCase))
{
NetworkPortCheck.Wait(Configuration["CheckDependency:Host"], 5);
}
var messageBrokerOptions = new MessageBrokerOptions {
Provider = "Fake"
};
services.AddAuditLogModule(Configuration["ConnectionStrings:ClassifiedAds"],
typeof(Startup).GetTypeInfo().Assembly.GetName().Name)
.AddIdentityModule(Configuration["ConnectionStrings:ClassifiedAds"],
typeof(Startup).GetTypeInfo().Assembly.GetName().Name)
.AddNotificationModule(messageBrokerOptions, Configuration["ConnectionStrings:ClassifiedAds"],
typeof(Startup).GetTypeInfo().Assembly.GetName().Name)
.AddProductModule(Configuration["ConnectionStrings:ClassifiedAds"],
typeof(Startup).GetTypeInfo().Assembly.GetName().Name)
.AddStorageModule(new StorageOptions(),
messageBrokerOptions,
Configuration["ConnectionStrings:ClassifiedAds"],
typeof(Startup).GetTypeInfo().Assembly.GetName().Name)
.AddApplicationServices();
services.AddIdentityServer()
.AddTokenProviderModule(Configuration.GetConnectionString("ClassifiedAds"),
typeof(Startup).GetTypeInfo().Assembly.GetName().Name);
}
public ActiveMQBroker(IOptions <MessageBrokerOptions> options)
{
this.syncLock = new object();
this.serializationManager = new JsonSerializationManager();
this.messageBrokerOptions = options.Value;
this.serializationManager = new JsonSerializationManager();
this.connectionFactory = new ConnectionFactory();
this.connectionFactory.UserName = this.messageBrokerOptions.MessageBrokerUsername;
this.connectionFactory.Password = this.messageBrokerOptions.MessageBrokerPassword;
this.connectionFactory.BrokerUri = new Uri($"{this.messageBrokerOptions.MessageBrokerHost}");
}
public ChangeFeedReceiver(IMessagingInfrastructureProvider infrastructureProvider,
MessageBrokerOptions messageBrokerOptions,
ILogger <BrokeredMessageReceiver <TProcessorCommand> > logger,
IServiceScopeFactory serviceFactory,
IMaxReceivesExceededAction recoveryAction,
ICriticalFailureNotifier criticalFailureNotifier,
IRecoveryStrategy recoveryStrategy,
IReceivedMessageDispatcher receivedMessageDispatcher)
: base(infrastructureProvider, messageBrokerOptions, logger, recoveryAction, criticalFailureNotifier, recoveryStrategy, receivedMessageDispatcher)
{
_serviceFactory = serviceFactory ?? throw new ArgumentNullException(nameof(serviceFactory));
}
public RabbitMQBroker(IOptions <MessageBrokerOptions> options)
{
this.syncLock = new object();
this.messageBrokerOptions = options.Value;
this.serializationManager = new JsonSerializationManager();
channels = new Dictionary <string, IModel>();
this.connectionFactory = new ConnectionFactory();
this.connectionFactory.AutomaticRecoveryEnabled = true;
this.connectionFactory.UserName = this.messageBrokerOptions.MessageBrokerUsername;
this.connectionFactory.Password = this.messageBrokerOptions.MessageBrokerPassword;
this.connectionFactory.HostName = this.messageBrokerOptions.MessageBrokerHost;
}
// This method gets called by the runtime. Use this method to add services to the container.
// For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
public void ConfigureServices(IServiceCollection services)
{
services.AddDateTimeProvider();
services.AddApplicationServices();
var messageBrokerOptions = new MessageBrokerOptions();
var notificationOptions = new NotificationOptions();
Configuration.GetSection("MessageBroker").Bind(messageBrokerOptions);
Configuration.GetSection("Notification").Bind(notificationOptions);
services.AddNotificationModule(messageBrokerOptions, notificationOptions, Configuration.GetConnectionString("ClassifiedAds"));
}
public SqlServiceBrokerReceiver(SqlServiceBrokerOptions ssbOptions,
MessageBrokerOptions messageBrokerOptions,
ILogger <SqlServiceBrokerReceiver> logger,
IBodyConverterFactory bodyConverterFactory,
IServiceScopeFactory serviceFactory)
{
_ssbOptions = ssbOptions ?? throw new ArgumentNullException(nameof(ssbOptions));
_logger = logger;
_bodyConverterFactory = bodyConverterFactory;
_transactionMode = messageBrokerOptions?.TransactionMode ?? TransactionMode.ReceiveOnly;
_localReceiverDeliveryAttempts = new ConcurrentDictionary <Guid, int>();
_serviceFactory = serviceFactory;
}
public ServiceBusReceiver(ServiceBusOptions serviceBusOptions,
MessageBrokerOptions messageBrokerOptions,
ILogger <ServiceBusReceiver> logger,
IBodyConverterFactory bodyConverterFactory)
{
if (serviceBusOptions is null)
{
throw new ArgumentNullException(nameof(serviceBusOptions));
}
_syncLock = new object();
ServiceBusConnectionBuilder = new ServiceBusConnectionStringBuilder(serviceBusOptions.ConnectionString);
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_bodyConverterFactory = bodyConverterFactory ?? throw new ArgumentNullException(nameof(bodyConverterFactory));
_tokenProvider = serviceBusOptions.TokenProvider;
_retryPolcy = serviceBusOptions.Policy;
_prefetchCount = serviceBusOptions.PrefetchCount;
_receiveMode = messageBrokerOptions?.TransactionMode == TransactionMode.None ? ReceiveMode.ReceiveAndDelete : ReceiveMode.PeekLock;
}
/// <summary>
/// Creates a brokered message receiver that receives messages of <typeparamref name="TMessage"/>
/// </summary>
/// <param name="infrastructureProvider">The message broker infrastructure</param>
/// <param name="serviceFactory">The service scope factory used to create a new scope when a message is received from the messaging infrastructure.</param>
/// <param name="logger">Provides logging capability</param>
public BrokeredMessageReceiver(IMessagingInfrastructureProvider infrastructureProvider,
MessageBrokerOptions messageBrokerOptions,
ILogger <BrokeredMessageReceiver <TMessage> > logger,
IMaxReceivesExceededAction recoveryAction,
ICriticalFailureNotifier criticalFailureNotifier,
IRecoveryStrategy recoveryStrategy,
IReceivedMessageDispatcher receivedMessageDispatcher)
{
if (infrastructureProvider is null)
{
throw new ArgumentNullException(nameof(infrastructureProvider));
}
_infrastructureProvider = infrastructureProvider;
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_failedRecoveryAction = recoveryAction;
_criticalFailureNotifier = criticalFailureNotifier ?? throw new ArgumentNullException(nameof(criticalFailureNotifier));
_messageBrokerOptions = messageBrokerOptions ?? throw new ArgumentNullException(nameof(messageBrokerOptions));
_recoveryStrategy = recoveryStrategy ?? throw new ArgumentNullException(nameof(recoveryStrategy));
_receivedMessageDispatcher = receivedMessageDispatcher ?? throw new ArgumentNullException(nameof(receivedMessageDispatcher));
}
/// <summary>
/// Initializes a <see cref="ChatterBuilder"/> and registers all dependencies.
/// Registers all <see cref="BrokeredMessageReceiver{TMessage}"/> and automatically starts receiving if configured to do so.
/// Registers all routers.
/// </summary>
/// <param name="builder">A <see cref="IChatterBuilder"/> used registration and setup</param>
/// <param name="assemblies">The assemblies that are required for registering receivers</param>
/// <returns>An instance of <see cref="IChatterBuilder"/>.</returns>
public static IChatterBuilder AddMessageBrokers(this IChatterBuilder builder, IEnumerable <Assembly> assemblies, Action <MessageBrokerOptionsBuilder> optionsBuilder = null)
{
var messageBrokerOptionsBuilder = builder.Services.AddMessageBrokerOptions();
optionsBuilder?.Invoke(messageBrokerOptionsBuilder);
MessageBrokerOptions options = messageBrokerOptionsBuilder.Build();
builder.Services.AddScoped <IBrokeredMessageDispatcher, BrokeredMessageDispatcher>();
builder.Services.AddScoped <IForwardMessages, ForwardingRouter>();
builder.Services.AddScoped <IRouteCompensationMessages, CompensateRouter>();
builder.Services.AddScoped <IReplyRouter, ReplyRouter>();
builder.Services.AddScoped <IOutboxProcessor, OutboxProcessor>();
builder.Services.AddIfNotRegistered <IBrokeredMessageOutbox, InMemoryBrokeredMessageOutbox>(ServiceLifetime.Scoped);
builder.Services.AddIfNotRegistered <IBrokeredMessageInbox, InMemoryBrokeredMessageInbox>(ServiceLifetime.Scoped);
if (options?.Reliability?.RouteMessagesToOutbox ?? false)
{
builder.Services.AddScoped <IRouteBrokeredMessages, OutboxBrokeredMessageRouter>();
if (options?.Reliability?.EnableOutboxPollingProcessor ?? false)
{
builder.Services.AddHostedService <BrokeredMessageOutboxProcessor>();
}
}
else
{
builder.Services.AddScoped <IRouteBrokeredMessages, BrokeredMessageRouter>();
}
builder.Services.Decorate <IMessageDispatcher, RoutingSlipMessageDispatcherDecorator>(); //TODO: we'll only want to add this if routing slips are added
builder.AddReceivers(assemblies);
builder.Services.AddScoped <IBodyConverterFactory, BodyConverterFactory>();
builder.Services.AddScoped <IBrokeredMessageBodyConverter, JsonBodyConverter>();
return(builder);
}
public static IServiceCollection AddNotificationModule(this IServiceCollection services, MessageBrokerOptions messageBrokerOptions, NotificationOptions notificationOptions, string connectionString, string migrationsAssembly = "")
{
services
.AddDbContext <NotificationDbContext>(options => options.UseSqlServer(connectionString, sql =>
{
if (!string.IsNullOrEmpty(migrationsAssembly))
{
sql.MigrationsAssembly(migrationsAssembly);
}
}))
.AddScoped <IRepository <EmailMessage, Guid>, Repository <EmailMessage, Guid> >()
.AddScoped <IRepository <SmsMessage, Guid>, Repository <SmsMessage, Guid> >()
.AddScoped(typeof(IEmailMessageRepository), typeof(EmailMessageRepository))
.AddScoped(typeof(ISmsMessageRepository), typeof(SmsMessageRepository))
.AddScoped <IEmailMessageService, EmailMessageService>();
services
.AddScoped <EmailMessageService>()
.AddScoped <SmsMessageService>();
DomainEvents.RegisterHandlers(Assembly.GetExecutingAssembly(), services);
services.AddMessageHandlers(Assembly.GetExecutingAssembly());
services
.AddMessageBusSender <EmailMessageCreatedEvent>(messageBrokerOptions)
.AddMessageBusSender <SmsMessageCreatedEvent>(messageBrokerOptions);
services.AddNotificationServices(notificationOptions);
return(services);
}
public static IServiceCollection AddStorageModule(this IServiceCollection services, StorageOptions storageOptions, MessageBrokerOptions messageBrokerOptions, string connectionString, string migrationsAssembly = "")
{
services.AddDbContext <StorageDbContext>(options => options.UseSqlServer(connectionString, sql =>
{
if (!string.IsNullOrEmpty(migrationsAssembly))
{
sql.MigrationsAssembly(migrationsAssembly);
}
}))
.AddScoped <IRepository <FileEntry, Guid>, Repository <FileEntry, Guid> >();
DomainEvents.RegisterHandlers(Assembly.GetExecutingAssembly(), services);
services.AddMessageHandlers(Assembly.GetExecutingAssembly());
if (storageOptions.UsedAzure())
{
services.AddSingleton <IFileStorageManager>(new AzureBlobStorageManager(storageOptions.Azure.ConnectionString, storageOptions.Azure.Container));
}
else if (storageOptions.UsedAmazon())
{
services.AddSingleton <IFileStorageManager>(
new AmazonS3StorageManager(
storageOptions.Amazon.AccessKeyID,
storageOptions.Amazon.SecretAccessKey,
storageOptions.Amazon.BucketName,
storageOptions.Amazon.RegionEndpoint));
}
else
{
services.AddSingleton <IFileStorageManager>(new LocalFileStorageManager(storageOptions.Local.Path));
}
if (messageBrokerOptions.UsedRabbitMQ())
{
services.AddSingleton <IMessageSender <FileUploadedEvent> >(new RabbitMQSender <FileUploadedEvent>(new RabbitMQSenderOptions
{
HostName = messageBrokerOptions.RabbitMQ.HostName,
UserName = messageBrokerOptions.RabbitMQ.UserName,
Password = messageBrokerOptions.RabbitMQ.Password,
ExchangeName = messageBrokerOptions.RabbitMQ.ExchangeName,
RoutingKey = messageBrokerOptions.RabbitMQ.RoutingKey_FileUploaded,
}));
services.AddSingleton <IMessageSender <FileDeletedEvent> >(new RabbitMQSender <FileDeletedEvent>(new RabbitMQSenderOptions
{
HostName = messageBrokerOptions.RabbitMQ.HostName,
UserName = messageBrokerOptions.RabbitMQ.UserName,
Password = messageBrokerOptions.RabbitMQ.Password,
ExchangeName = messageBrokerOptions.RabbitMQ.ExchangeName,
RoutingKey = messageBrokerOptions.RabbitMQ.RoutingKey_FileDeleted,
}));
}
else if (messageBrokerOptions.UsedKafka())
{
services.AddSingleton <IMessageSender <FileUploadedEvent> >(new KafkaSender <FileUploadedEvent>(
messageBrokerOptions.Kafka.BootstrapServers,
messageBrokerOptions.Kafka.Topic_FileUploaded));
services.AddSingleton <IMessageSender <FileDeletedEvent> >(new KafkaSender <FileDeletedEvent>(
messageBrokerOptions.Kafka.BootstrapServers,
messageBrokerOptions.Kafka.Topic_FileDeleted));
}
else if (messageBrokerOptions.UsedAzureQueue())
{
services.AddSingleton <IMessageSender <FileUploadedEvent> >(new AzureQueueSender <FileUploadedEvent>(
connectionString: messageBrokerOptions.AzureQueue.ConnectionString,
queueName: messageBrokerOptions.AzureQueue.QueueName_FileUploaded));
services.AddSingleton <IMessageSender <FileDeletedEvent> >(new AzureQueueSender <FileDeletedEvent>(
connectionString: messageBrokerOptions.AzureQueue.ConnectionString,
queueName: messageBrokerOptions.AzureQueue.QueueName_FileDeleted));
}
else if (messageBrokerOptions.UsedAzureServiceBus())
{
services.AddSingleton <IMessageSender <FileUploadedEvent> >(new AzureServiceBusSender <FileUploadedEvent>(
connectionString: messageBrokerOptions.AzureServiceBus.ConnectionString,
queueName: messageBrokerOptions.AzureServiceBus.QueueName_FileUploaded));
services.AddSingleton <IMessageSender <FileDeletedEvent> >(new AzureServiceBusSender <FileDeletedEvent>(
connectionString: messageBrokerOptions.AzureServiceBus.ConnectionString,
queueName: messageBrokerOptions.AzureServiceBus.QueueName_FileDeleted));
}
else if (messageBrokerOptions.UsedAzureEventGrid())
{
services.AddSingleton <IMessageSender <FileUploadedEvent> >(new AzureEventGridSender <FileUploadedEvent>(
messageBrokerOptions.AzureEventGrid.DomainEndpoint,
messageBrokerOptions.AzureEventGrid.DomainKey,
messageBrokerOptions.AzureEventGrid.Topic_FileUploaded));
services.AddSingleton <IMessageSender <FileDeletedEvent> >(new AzureEventGridSender <FileDeletedEvent>(
messageBrokerOptions.AzureEventGrid.DomainEndpoint,
messageBrokerOptions.AzureEventGrid.DomainKey,
messageBrokerOptions.AzureEventGrid.Topic_FileDeleted));
}
else if (messageBrokerOptions.UsedAzureEventHub())
{
services.AddSingleton <IMessageSender <FileUploadedEvent> >(new AzureEventHubSender <FileUploadedEvent>(
messageBrokerOptions.AzureEventHub.ConnectionString,
messageBrokerOptions.AzureEventHub.Hub_FileUploaded));
services.AddSingleton <IMessageSender <FileDeletedEvent> >(new AzureEventHubSender <FileDeletedEvent>(
messageBrokerOptions.AzureEventHub.ConnectionString,
messageBrokerOptions.AzureEventHub.Hub_FileDeleted));
}
return(services);
}
public static IServiceCollection AddStorageModule(this IServiceCollection services, StorageOptions storageOptions, MessageBrokerOptions messageBrokerOptions, string connectionString, string migrationsAssembly = "")
{
services.AddDbContext <StorageDbContext>(options => options.UseSqlServer(connectionString, sql =>
{
if (!string.IsNullOrEmpty(migrationsAssembly))
{
sql.MigrationsAssembly(migrationsAssembly);
}
}))
.AddScoped <IRepository <FileEntry, Guid>, Repository <FileEntry, Guid> >();
DomainEvents.RegisterHandlers(Assembly.GetExecutingAssembly(), services);
services.AddMessageHandlers(Assembly.GetExecutingAssembly());
if (storageOptions.UsedAzure())
{
services.AddSingleton <IFileStorageManager>(new AzureBlobStorageManager(storageOptions.Azure.ConnectionString, storageOptions.Azure.Container));
}
else if (storageOptions.UsedAmazon())
{
services.AddSingleton <IFileStorageManager>(
new AmazonS3StorageManager(
storageOptions.Amazon.AccessKeyID,
storageOptions.Amazon.SecretAccessKey,
storageOptions.Amazon.BucketName,
storageOptions.Amazon.RegionEndpoint));
}
else if (storageOptions.UsedLocal())
{
services.AddSingleton <IFileStorageManager>(new LocalFileStorageManager(storageOptions.Local.Path));
}
else if (storageOptions.UsedFake())
{
services.AddSingleton <IFileStorageManager>(new FakeStorageManager());
}
services.AddMessageBusSender <FileUploadedEvent>(messageBrokerOptions);
services.AddMessageBusSender <FileDeletedEvent>(messageBrokerOptions);
return(services);
}
public static IServiceCollection AddMessageBusReceiver <T>(this IServiceCollection services, MessageBrokerOptions options)
{
if (options.UsedRabbitMQ())
{
services.AddRabbitMQReceiver <T>(options.RabbitMQ);
}
else if (options.UsedKafka())
{
services.AddKafkaReceiver <T>(options.Kafka);
}
else if (options.UsedAzureQueue())
{
services.AddAzureQueueReceiver <T>(options.AzureQueue);
}
else if (options.UsedAzureServiceBus())
{
services.AddAzureServiceBusReceiver <T>(options.AzureServiceBus);
}
else if (options.UsedAzureEventHub())
{
services.AddAzureEventHubReceiver <T>(options.AzureEventHub);
}
else if (options.UsedFake())
{
services.AddFakeReceiver <T>();
}
return(services);
}
public static IServiceCollection AddMessageBusSender <T>(this IServiceCollection services, MessageBrokerOptions options, IHealthChecksBuilder healthChecksBuilder = null, HashSet <string> checkDulicated = null)
{
if (options.UsedRabbitMQ())
{
services.AddRabbitMQSender <T>(options.RabbitMQ);
if (healthChecksBuilder != null)
{
var name = "Message Broker (RabbitMQ)";
if (checkDulicated == null || !checkDulicated.Contains(name))
{
healthChecksBuilder.AddRabbitMQ(
rabbitMQConnectionString: options.RabbitMQ.ConnectionString,
name: name,
failureStatus: HealthStatus.Degraded);
}
checkDulicated?.Add(name);
}
}
else if (options.UsedKafka())
{
services.AddKafkaSender <T>(options.Kafka);
if (healthChecksBuilder != null)
{
var name = "Message Broker (Kafka)";
if (checkDulicated == null || !checkDulicated.Contains(name))
{
healthChecksBuilder.AddKafka(
setup =>
{
setup.BootstrapServers = options.Kafka.BootstrapServers;
setup.MessageTimeoutMs = 5000;
},
name: name,
failureStatus: HealthStatus.Degraded);
}
checkDulicated?.Add(name);
}
}
else if (options.UsedAzureQueue())
{
services.AddAzureQueueSender <T>(options.AzureQueue);
if (healthChecksBuilder != null)
{
healthChecksBuilder.AddAzureQueueStorage(connectionString: options.AzureQueue.ConnectionString,
queueName: options.AzureQueue.QueueNames[typeof(T).Name],
name: $"Message Broker (Azure Queue) {typeof(T).Name}",
failureStatus: HealthStatus.Degraded);
}
}
else if (options.UsedAzureServiceBus())
{
services.AddAzureServiceBusSender <T>(options.AzureServiceBus);
if (healthChecksBuilder != null)
{
healthChecksBuilder.AddAzureServiceBusQueue(
connectionString: options.AzureServiceBus.ConnectionString,
queueName: options.AzureServiceBus.QueueNames[typeof(T).Name],
name: $"Message Broker (Azure Service Bus) {typeof(T).Name}",
failureStatus: HealthStatus.Degraded);
}
}
else if (options.UsedAzureEventGrid())
{
services.AddAzureEventGridSender <T>(options.AzureEventGrid);
// TODO: Add Health Check
}
else if (options.UsedAzureEventHub())
{
services.AddAzureEventHubSender <T>(options.AzureEventHub);
// TODO: Add Health Check
}
else if (options.UsedFake())
{
services.AddFakeSender <T>();
}
return(services);
}
public static IServiceCollection AddMessageBusReceiver <T>(this IServiceCollection services, MessageBrokerOptions options)
{
services.AddKafkaReceiver <T>(options.Kafka);
return(services);
}
// This method gets called by the runtime. Use this method to add services to the container.
// For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
public void ConfigureServices(IServiceCollection services)
{
if (string.Equals(Configuration["CheckDependency:Enabled"], "true", System.StringComparison.OrdinalIgnoreCase))
{
NetworkPortCheck.Wait(Configuration["CheckDependency:Host"], 5);
}
services.AddDateTimeProvider();
var messageBrokerOptions = new MessageBrokerOptions
{
Provider = "Fake",
};
var notificationOptions = new NotificationOptions
{
Email = new EmailOptions {
Provider = "Fake"
},
Sms = new SmsOptions {
Provider = "Fake"
},
Web = new WebOptions {
Provider = "Fake"
},
};
services.AddAuditLogModule(new Modules.AuditLog.ConfigurationOptions.AuditLogModuleOptions
{
ConnectionStrings = new Modules.AuditLog.ConfigurationOptions.ConnectionStringsOptions
{
Default = Configuration["ConnectionStrings:ClassifiedAds"],
MigrationsAssembly = typeof(Startup).GetTypeInfo().Assembly.GetName().Name,
},
})
.AddConfigurationModule(new ConfigurationModuleOptions
{
ConnectionStrings = new Modules.Configuration.ConfigurationOptions.ConnectionStringsOptions
{
Default = Configuration["ConnectionStrings:ClassifiedAds"],
MigrationsAssembly = typeof(Startup).GetTypeInfo().Assembly.GetName().Name,
},
})
.AddIdentityModule(new IdentityModuleOptions
{
ConnectionStrings = new Modules.Identity.ConfigurationOptions.ConnectionStringsOptions
{
Default = Configuration["ConnectionStrings:ClassifiedAds"],
MigrationsAssembly = typeof(Startup).GetTypeInfo().Assembly.GetName().Name,
},
})
.AddNotificationModule(new Modules.Notification.ConfigurationOptions.NotificationModuleOptions
{
ConnectionStrings = new Modules.Notification.ConfigurationOptions.ConnectionStringsOptions
{
Default = Configuration["ConnectionStrings:ClassifiedAds"],
MigrationsAssembly = typeof(Startup).GetTypeInfo().Assembly.GetName().Name,
},
MessageBroker = messageBrokerOptions,
Notification = notificationOptions,
})
.AddProductModule(new Modules.Product.ConfigurationOptions.ProductModuleOptions
{
ConnectionStrings = new Modules.Product.ConfigurationOptions.ConnectionStringsOptions
{
Default = Configuration["ConnectionStrings:ClassifiedAds"],
MigrationsAssembly = typeof(Startup).GetTypeInfo().Assembly.GetName().Name,
},
})
.AddStorageModule(new Modules.Storage.ConfigurationOptions.StorageModuleOptions
{
ConnectionStrings = new Modules.Storage.ConfigurationOptions.ConnectionStringsOptions
{
Default = Configuration["ConnectionStrings:ClassifiedAds"],
MigrationsAssembly = typeof(Startup).GetTypeInfo().Assembly.GetName().Name,
},
Storage = new StorageOptions(),
MessageBroker = messageBrokerOptions,
})
.AddApplicationServices();
services.AddIdentityServer()
.AddTokenProviderModule(Configuration.GetConnectionString("ClassifiedAds"),
typeof(Startup).GetTypeInfo().Assembly.GetName().Name);
}
/// <summary>
/// Adds and configured Chatter message broker related capabilities
/// </summary>
/// <param name="builder">A <see cref="IChatterBuilder"/> used for registration and setup</param>
/// <param name="receiverHandlerSourceBuilder">An optional builder used to define an <see cref="AssemblySourceFilter"/>. Assemblies will be used to find <see cref="IBrokeredMessageReceiver{TMessage}"/> for registration. Will override any assemblies located via <see cref="AssemblySourceFilter"/> created during Chatter cqrs configuration.</param>
/// <param name="optionsBuilder">A delegate that uses a <see cref="MessageBrokerOptionsBuilder"/> to construct <see cref="MessageBrokerOptions"/></param>
/// <returns>An <see cref="IChatterBuilder"/> used to configure Chatter capabilities</returns>
public static IChatterBuilder AddMessageBrokers(this IChatterBuilder builder, Action <MessageBrokerOptionsBuilder> optionsBuilder = null, Action <AssemblySourceFilterBuilder> receiverHandlerSourceBuilder = null)
{
var filter = builder.AssemblySourceFilter;
if (receiverHandlerSourceBuilder != null)
{
var filterBuilder = AssemblySourceFilterBuilder.New();
receiverHandlerSourceBuilder(filterBuilder);
filter = filterBuilder.Build();
}
var assemblies = filter.Apply();
var messageBrokerOptionsBuilder = builder.Services.AddMessageBrokerOptions(builder.Configuration);
optionsBuilder?.Invoke(messageBrokerOptionsBuilder);
MessageBrokerOptions options = messageBrokerOptionsBuilder.Build();
builder.Services.AddSingleton <IMessagingInfrastructureProvider, MessagingInfrastructureProvider>();
builder.Services.Replace <IExternalDispatcher, BrokeredMessageDispatcher>(ServiceLifetime.Scoped);
builder.Services.AddScoped <IBrokeredMessageReceiverFactory, BrokeredMessageReceiverFactory>();
builder.Services.AddScoped <IBrokeredMessageDispatcher, BrokeredMessageDispatcher>();
builder.Services.AddIfNotRegistered <IBrokeredMessagePathBuilder, DefaultBrokeredMessagePathBuilder>(ServiceLifetime.Scoped);
builder.Services.AddIfNotRegistered <IBrokeredMessageAttributeDetailProvider, BrokeredMessageAttributeProvider>(ServiceLifetime.Scoped);
builder.Services.AddIfNotRegistered <ICircuitBreaker, CircuitBreaker>(ServiceLifetime.Scoped);
builder.Services.AddIfNotRegistered <ICircuitBreakerStateStore, InMemoryCircuitBreakerStateStore>(ServiceLifetime.Scoped);
builder.Services.AddIfNotRegistered <IMaxReceivesExceededAction, ErrorQueueDispatcher>(ServiceLifetime.Scoped);
builder.Services.AddIfNotRegistered <IRetryDelayStrategy, NoDelayRetry>(ServiceLifetime.Scoped);
builder.Services.AddIfNotRegistered <ICriticalFailureNotifier, CriticalFailureEventDispatcher>(ServiceLifetime.Scoped);
builder.Services.AddIfNotRegistered <IMessageIdGenerator, GuidIdGenerator>(ServiceLifetime.Scoped);
builder.Services.AddScoped <IForwardMessages, ForwardingRouter>();
builder.Services.AddScoped <IReplyRouter, ReplyRouter>();
builder.Services.AddScoped <IOutboxProcessor, OutboxProcessor>();
builder.Services.AddIfNotRegistered <IBrokeredMessageOutbox, InMemoryBrokeredMessageOutbox>(ServiceLifetime.Scoped);
builder.Services.AddIfNotRegistered <IBrokeredMessageInbox, InMemoryBrokeredMessageInbox>(ServiceLifetime.Scoped);
builder.Services.AddSingleton <IRetryExceptionPredicatesProvider, DefaultExceptionsPredicateProvider>();
builder.Services.AddSingleton <IRetryExceptionEvaluator, RetryExceptionEvaluator>();
builder.Services.AddSingleton <ICircuitBreakerExceptionEvaluator, CircuitBreakerExceptionEvaluator>();
builder.Services.AddSingleton <ICircuitBreakerExceptionPredicatesProvider, DefaultExceptionsPredicateProvider>();
builder.Services.AddScoped <IRetryStrategy, RetryStrategy>();
builder.Services.AddScoped <IRecoveryStrategy, RetryWithCircuitBreakerStrategy>();
builder.Services.AddScoped <IReceivedMessageDispatcher, ScopedReceivedMessageDispatcher>();
if (options?.Reliability?.EnableOutboxPollingProcessor ?? false)
{
builder.Services.AddHostedService <BrokeredMessageOutboxProcessor>();
}
if (options?.Reliability?.RouteMessagesToOutbox ?? false)
{
builder.Services.AddIfNotRegistered <IRouteBrokeredMessages, OutboxBrokeredMessageRouter>(ServiceLifetime.Scoped);
}
else
{
builder.Services.AddIfNotRegistered <IRouteBrokeredMessages, BrokeredMessageRouter>(ServiceLifetime.Scoped);
}
builder.AddAllReceivers(assemblies);
builder.Services.AddScoped <IBodyConverterFactory, BodyConverterFactory>();
builder.Services.AddScoped <IBrokeredMessageBodyConverter, TextPlainBodyConverter>();
builder.Services.AddScoped <IBrokeredMessageBodyConverter, JsonBodyConverter>();
return(builder);
}
public static IServiceCollection AddStorageModule(this IServiceCollection services, StorageOptions storageOptions, MessageBrokerOptions messageBrokerOptions, string connectionString, string migrationsAssembly = "")
{
services.AddDbContext <StorageDbContext>(options => options.UseSqlServer(connectionString, sql =>
{
if (!string.IsNullOrEmpty(migrationsAssembly))
{
sql.MigrationsAssembly(migrationsAssembly);
}
}))
.AddScoped <IRepository <FileEntry, Guid>, Repository <FileEntry, Guid> >();
DomainEvents.RegisterHandlers(Assembly.GetExecutingAssembly(), services);
services.AddMessageHandlers(Assembly.GetExecutingAssembly());
services.AddSingleton <IHttpContextAccessor, HttpContextAccessor>();
services.AddScoped <ICurrentUser, CurrentWebUser>();
services.AddStorageManager(storageOptions);
services.AddMessageBusSender <FileUploadedEvent>(messageBrokerOptions)
.AddMessageBusSender <FileDeletedEvent>(messageBrokerOptions)
.AddMessageBusReceiver <FileUploadedEvent>(messageBrokerOptions)
.AddMessageBusReceiver <FileDeletedEvent>(messageBrokerOptions);
return(services);
}
public static IServiceCollection AddMessageBusSender <TKey, TValue>(this IServiceCollection services, MessageBrokerOptions options)
{
switch (options.Provider)
{
case "RabbitMQ":
services.AddRabbitMQSender <TKey, TValue>(options.RabbitMQ);
break;
case "Kafka":
services.AddKafkaSender <TKey, TValue>(options.Kafka);
break;
case "AzureQueue":
services.AddAzureQueueSender <TKey, TValue>(options.AzureQueue);
break;
case "AzureServiceBus":
services.AddAzureServiceBusSender <TKey, TValue>(options.AzureServiceBus);
break;
case "AzureEventHub":
services.AddAzureEventHubSender <TKey, TValue>(options.AzureEventHub);
break;
case "Fake":
services.AddFakeSender <TKey, TValue>();
break;
}
return(services);
}
