public static ISopiBuilder AddClients(this ISopiBuilder builder)
{
var config = builder.Config;
builder.Log("Adding Auth0 Config");
builder.Services.AddAuth0ClientOptions(config);
builder.Log("Adding AzureAd Config");
builder.Services.AddAzureAdClientOptions(config);
builder.Log($"Auth Config Value: {builder.Options.Auth}");
switch (builder.Options.Auth)
{
case SopiOptions.AuthAuth0:
builder.Log("Adding Auth0 Token Provider");
builder.Services.AddAuth0TokenProvider();
break;
case SopiOptions.AuthAzureAd:
builder.Log("Adding AzureAd Token Provider");
builder.Services.AddAzureAdTokenProvider();
break;
default:
throw new InvalidOperationException($"Invalid Auth: {builder.Options.Auth}");
}
return(builder);
}
public static ISopiBuilder AddMessageBus(this ISopiBuilder builder)
{
var config = builder.Config;
builder.Services.AddCachingOptions();
builder.Log($"MessageBus Config Value: {builder.Options.MessageBus}");
switch (builder.Options.MessageBus)
{
case SopiOptions.MessageBusRedis:
builder.Log("Adding Redis Message Bus");
builder.AddRedisMessageBus();
break;
case SopiOptions.MessageBusAzureServiceBus:
builder.Log("Adding AzureServiceBus Message Bus");
builder.AddAzureMessageBus(c => config.Bind("AzureServiceBus", c));
break;
//case SopiOptions.MessageBusRabbitMq:
// builder.Log("Adding RabbitMQ Message Bus");
// builder.AddRabbitMqMessageBus(c => config.Bind("RabbitMQ", c));
// break;
default:
builder.Log("Adding InMemory Bus");
builder.AddInMemoryMessageBus();
break;
}
return(builder);
}
public static ISopiBuilder AddMongoDbEntityStore(this ISopiBuilder builder,
Action <MongoDbOptions> configureOptions)
{
builder.Services
.AddMongoDbEntityStoreOptions(configureOptions)
.AddMongoDbEntityStore();
builder.Services.PostConfigure <SopiOptions>(c =>
{
c.EntityStore = SopiOptions.EntityStoreMongoDb;
});
//var options = new MongoDbOptions();
//configureOptions(options);
//options.DatabaseId = builder.Options.CreateDatabaseId();
//var url = new MongoServerAddress(options.Server, options.Port);
//var settings = new MongoClientSettings
//{
// Server = url,
// ConnectTimeout = TimeSpan.FromSeconds(0.5),
// HeartbeatTimeout = TimeSpan.FromSeconds(0.5),
// ServerSelectionTimeout = TimeSpan.FromSeconds(0.5),
// SocketTimeout = TimeSpan.FromSeconds(0.5)
//};
//builder.GetHealthChecksBuilder()
// .AddMongoDb(settings,
// options.DatabaseId,
// "mongodb-entitystore");
return(builder);
}
public static ISopiBuilder AddPlatformServices(this ISopiBuilder builder)
{
var services = builder.Services;
services.AddOptions();
//builder.AddHealthChecks()
// ;
services.AddSingleton <SopiApplicationLifetime>()
.AddSingleton <ISopiApplicationLifetime>(p => p.GetRequiredService <SopiApplicationLifetime>())
;
services.AddSingleton(
resolver => resolver.GetRequiredService <IOptions <SopiOptions> >().Value);
services.AddSingleton <ILockProvider>(pr =>
new CacheLockProvider(pr.GetRequiredService <ICacheClient>(),
pr.GetRequiredService <IMessageBus>(),
pr.GetRequiredService <ILoggerFactory>()
));
services
.AddSingleton <ICacheAdapter, CacheAdapter>()
.AddDefaultMessageBusAdapter()
;
return(builder);
}
public static ISopiBuilder AddDomainEventStore(this ISopiBuilder builder,
Action <EventStoreOptions> configureOptions)
{
var opt = new EventStoreOptions();
configureOptions.Invoke(opt);
builder.Services.AddEventStoreConnection(configureOptions);
builder.Services.PostConfigure <SopiOptions>(c =>
{
c.DomainEventStore = SopiOptions.DomainEventStoreEventStore;
});
//var options = new EventStoreOptions();
//configureOptions(options);
//builder.GetHealthChecksBuilder()
// .Add(new HealthCheckRegistration(
// "eventstore",
// provider => new SopiEventStoreHealthCheck(provider.GetRequiredService<EventStoreConnectionProvider>()),
// null,
// null));
return(builder);
}
public static ISopiBuilder AddStorage(this ISopiBuilder builder)
{
var config = builder.Config;
builder.Log($"Storage Config Value: {builder.Options.Storage}");
switch (builder.Options.Storage)
{
case SopiOptions.StorageFolder:
builder.Log("Adding Folder Storage");
builder.AddFolderStorage(c => config.Bind("FolderStorage", c));
break;
case SopiOptions.StorageAzureStorage:
builder.Log("Adding Azure Storage");
builder.AddAzureStorage(c => config.Bind("AzureStorage", c));
break;
default:
builder.Log("Adding InMemory Storage");
builder.AddInMemoryStorage();
break;
}
return(builder);
}
public static ISopiBuilder AddAuthentication(this ISopiBuilder builder)
{
builder.Log($"Sopi Auth Config Value: {builder.Options.Auth}");
switch (builder.Options.Auth)
{
case SopiOptions.AuthAuth0:
{
builder.Log("Adding Auth0 Config");
builder.Services.ConfigureAuth0(builder.Config, builder.Log);
//builder.AddFeature("SwaggerClientOptions", swag);
break;
}
case SopiOptions.AuthAzureAd:
{
builder.Log("Adding AzureAd Config");
builder.Services.ConfigureAzureAd(builder.Config, builder.Log);
//builder.AddFeature("SwaggerClientOptions", swag);
break;
}
default:
throw new InvalidOperationException($"Invalid Auth: {builder.Options.Auth}");
}
return(builder);
}
public static T GetFeature <T>(this ISopiBuilder builder, string key)
{
if (!builder.Features.ContainsKey(key))
{
throw new InvalidOperationException("Feature Key not found");
}
return((T)builder.Features[key]);
}
public static ISopiBuilder AddInMemoryStorage(this ISopiBuilder builder)
{
builder.Services.AddSingleton <IFileStorage>(p =>
new InMemoryFileStorage(optionsBuilder => optionsBuilder
.LoggerFactory(p.GetRequiredService <ILoggerFactory>()))
);
return(builder);
}
public static ISopiBuilder AddDefaultTelemetry(this ISopiBuilder builder)
{
var services = builder.Services;
services
// .AddDefaultTelemetryAdapter()
.AddDefaultMessageBusAdapter();
return(builder);
}
public static ISopiBuilder AddInMemoryEntityStore(this ISopiBuilder builder)
{
builder.Services.AddInMemoryEntityStore();
builder.Services.PostConfigure <SopiOptions>(c =>
{
c.EntityStore = SopiOptions.InMemory;
});
return(builder);
}
public static ISopiBuilder AddFeature <T>(this ISopiBuilder builder, string key, T item)
{
//var key = typeof(T).FullName;
if (!builder.Features.ContainsKey(key))
{
builder.Features.Add(key, item);
}
return(builder);
}
public static ISopiBuilder AddConfiguration(this ISopiBuilder builder, IConfiguration config)
{
builder.Config = config;
builder.Services.Configure <SopiOptions>(config.Bind);
builder.Options = new SopiOptions();
config.Bind(builder.Options);
return(builder);
}
public static ISopiBuilder AddProjectionServices(this ISopiBuilder builder)
{
builder.Services.AddProjectionServices(c => builder.Config.Bind("Projection", c));
if (builder.Options.DomainEventStore == SopiOptions.DomainEventStoreEventStore)
{
builder.Services.AddEventStoreProjectionServices();
}
return(builder);
}
public static ISopiBuilder AddInMemoryMessageBus(this ISopiBuilder builder)
{
builder.Services.AddInMemoryMessageBus();
builder.Services.PostConfigure <SopiOptions>(c =>
{
c.MessageBus = SopiOptions.InMemory;
});
return(builder);
}
public static ISopiBuilder AddInMemoryCacheClient(this ISopiBuilder builder)
{
var services = builder.Services;
services.AddInMemoryCacheClient();
builder.Services.PostConfigure <SopiOptions>(c =>
{
c.CacheClient = SopiOptions.InMemory;
});
return(builder);
}
public static ISopiBuilder AddAzureMessageBus(this ISopiBuilder builder, Action <AzureServiceBusMessageBusOptions> configureOptions)
{
var services = builder.Services;
services
.AddOptions()
.Configure(configureOptions);
services.AddSingleton <IMessageBus>(p =>
{
var opt = p.GetRequiredService <IOptions <AzureServiceBusMessageBusOptions> >();
var topic = opt.Value.Topic;
if (string.IsNullOrEmpty(topic))
{
topic = builder.Options.AppId;
}
var subscrName = opt.Value.SubscriptionName;
if (string.IsNullOrEmpty(subscrName))
{
subscrName = builder.Options.AppId;
}
var ttl = opt.Value.SubscriptionDefaultMessageTimeToLive.GetValueOrDefault(TimeSpan.FromHours(4));
var b = new AzureServiceBusMessageBusOptionsBuilder();
b.ConnectionString(opt.Value.ConnectionString)
.LoggerFactory(p.GetRequiredService <ILoggerFactory>())
.Topic(topic)
.SubscriptionName(subscrName)
.SubscriptionDefaultMessageTimeToLive(ttl)
;
return(new AzureServiceBusMessageBus(b.Build()));
});
builder.Services.PostConfigure <SopiOptions>(c =>
{
c.MessageBus = SopiOptions.MessageBusAzureServiceBus;
});
services
.AddSingleton <IMessageSubscriber>(c => c.GetRequiredService <IMessageBus>())
.AddSingleton <IMessagePublisher>(c => c.GetRequiredService <IMessageBus>())
.AddSingleton <IQueueFactory, AzureServiceBusQueueFactory>()
;
return(builder);
}
public static ISopiBuilder AddEventStore(this ISopiBuilder builder)
{
var config = builder.Config;
builder.Log($"DomainEventStore Config Value: {builder.Options.DomainEventStore}");
switch (builder.Options.DomainEventStore)
{
case SopiOptions.DomainEventStoreEventStore:
builder.Log("Adding AddDomainEventStore");
builder.AddDomainEventStore(c => config.Bind("EventStore", c));
break;
}
return(builder);
}
public static ISopiBuilder AddEntityStore(this ISopiBuilder builder)
{
var config = builder.Config;
builder.Log($"EntityStore Config Value: {builder.Options.EntityStore}");
switch (builder.Options.EntityStore)
{
case SopiOptions.EntityStoreMongoDb:
builder.Log("Adding MongoDb EntityStore");
builder.AddMongoDbEntityStore(c => config.Bind("MongoDb", c));
builder.Services.PostConfigure <MongoDbOptions>(options =>
{
if (string.IsNullOrEmpty(options.DatabaseId))
{
builder.Log("Configuring MongoDb EntityStore Options");
options.DatabaseId = builder.Options.CreateDatabaseId();
builder.Log($"New MongoDb DatabaseId {options.DatabaseId}");
}
});
break;
case SopiOptions.EntityStoreAzureCosmosDb:
builder.Log("Adding AzureCosmosDb EntityStore");
builder.AddAzureCosmosDbEntityStore(c => config.Bind("AzureCosmosDb", c));
builder.Services.PostConfigure <AzureCosmosDbOptions>(options =>
{
if (string.IsNullOrEmpty(options.CollectionId))
{
builder.Log("Configuring AzureCosmosDb EntityStore Options");
options.CollectionId = builder.Options.CreateDatabaseId();
builder.Log($"New AzureCosmosDb CollectionId {options.CollectionId}");
}
});
break;
default:
builder.Log("Adding InMemory EntityStore");
builder.AddInMemoryEntityStore();
break;
}
return(builder);
}
public static ISopiBuilder AddFolderStorage(this ISopiBuilder builder, Action <FolderFileStorageOptions> configureOptions)
{
var opt = new FolderFileStorageOptions();
configureOptions.Invoke(opt);
builder.Services.AddSingleton <IFileStorage>(p =>
new FolderFileStorage(optionsBuilder => optionsBuilder
.LoggerFactory(p.GetRequiredService <ILoggerFactory>())
.Folder(opt.Folder))
);
return(builder);
}
public static ISopiBuilder AddRedisMessageBus(this ISopiBuilder builder)
{
var services = builder.Services;
services.AddRedisMessageBus("Fliegel365");
builder.Services.PostConfigure <SopiOptions>(c =>
{
c.MessageBus = SopiOptions.MessageBusRedis;
});
//var options = new RedisOptions();
//configureOptions(options);
//builder.GetHealthChecksBuilder()
// .AddRedis(options.ConnectionString, "redis-bus");
return(builder);
}
public static ISopiBuilder AddAzureStorage(this ISopiBuilder builder, Action <AzureFileStorageOptions> configureOptions)
{
var opt = new AzureFileStorageOptions();
configureOptions.Invoke(opt);
builder.Services.AddSingleton <IFileStorage>(p =>
new AzureFileStorage(optionsBuilder => optionsBuilder
.LoggerFactory(p.GetRequiredService <ILoggerFactory>())
.ConnectionString(opt.ConnectionString)
.ContainerName(opt.ContainerName)
)
);
//builder.GetHealthChecksBuilder()
// .AddAzureBlobStorage(opt.ConnectionString, "azure-storage");
return(builder);
}
public static ISopiBuilder AddDomainServices(this ISopiBuilder builder)
{
builder.Services
.AddDomainServices(c => builder.Config.Bind("Repository", c))
.AddSingleton <ISagaServices, SagaServices>()
;
if (builder.Options.DomainEventStore == SopiOptions.DomainEventStoreEventStore)
{
builder.Services.AddEventStoreDomainServices()
.AddEventStorePersistentSubscription();
}
else
{
builder.Services.AddInMemoryDomainServices()
.AddSingleton <IPersistentSubscriptionFactory, NullPersistentSubscriptionFactory>();
}
return(builder);
}
public static ISopiBuilder AddSystemServicesByConfiguration(this ISopiBuilder builder)
{
if (builder.Options.AnyRedis())
{
builder.Services
.AddRedisOptions(builder.Config)
.AddRedis()
;
}
builder
.AddMessageBus()
.AddEntityStore()
.AddCacheClient()
.AddStorage()
.AddEventStore()
;
return(builder);
}
//private static string CreateDatabaseId(ISopiBuilder builder)
//{
// var options = new CacheOptions();
// builder.Config.Bind("Caching", options);
// if (!string.IsNullOrEmpty(options.CacheScope))
// return options.CacheScope;
// return builder.Options.CreateDatabaseId();
//}
public static ISopiBuilder AddCacheClient(this ISopiBuilder builder)
{
var config = builder.Config;
builder.Services.AddCachingOptions(c => config.Bind("Caching"));
builder.Log($"Sopi CacheClient Config Value: {builder.Options.CacheClient}");
switch (builder.Options.CacheClient)
{
case SopiOptions.CacheRedis:
builder.Log("Adding Redis CacheClient");
builder.Services.AddRedisCacheClient();
break;
default:
builder.Log("Adding InMemory CacheClient");
builder.AddInMemoryCacheClient();
break;
}
return(builder);
}
public static ISopiBuilder AddMvcServices(this ISopiBuilder builder, Action <IMvcBuilder> mvcBuilderAction = null)
{
var services = builder.Services;
var mvc = services.AddMvc()
//.AddJsonOptions(options =>
//{
// // options.SerializerSettings.NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore;
//})
.SetCompatibilityVersion(CompatibilityVersion.Latest)
//.AddNewtonsoftJson()
;
mvcBuilderAction?.Invoke(mvc);
builder.AddFeature("MvcBuilder", mvc);
services.AddCors(o => o.AddDefaultPolicy(pb =>
{
if (builder.Options.AllowedOrigins == "*")
{
pb.AllowAnyOrigin();
}
else
{
pb.WithOrigins(builder.Options.AllowedOrigins.Split(';'));
pb.AllowCredentials();
}
pb.AllowAnyHeader();
pb.AllowAnyMethod();
}));
return(builder);
}
public static ISopiBuilder AddAzureCosmosDbEntityStore(this ISopiBuilder builder,
Action <AzureCosmosDbOptions> configureOptions)
{
builder.Services.AddAzureCosmosDbEntityStore(configureOptions);
builder.Services.PostConfigure <SopiOptions>(c =>
{
c.EntityStore = SopiOptions.EntityStoreAzureCosmosDb;
});
//var options = new AzureCosmosDbOptions();
//configureOptions(options);
//options.CollectionId = CreateDatabaseId(builder);
//builder.GetHealthChecksBuilder()
// .AddDocumentDb(setup =>
// {
// setup.PrimaryKey = options.AuthKey;
// setup.UriEndpoint = options.EndpointUrl;
// },
// "azurecosmosdb-entitystore");
return(builder);
}
public static ISopiBuilder AddMessageBusOptions(this ISopiBuilder builder)
{
return(builder.AddMessageBusOptions(c => builder.Config.Bind("MessageBus", c)));
}
public static ISopiBuilder AddMessageBusOptions(this ISopiBuilder builder,
Action <MessageBusOptions> configureOptions)
{
builder.Services.Configure(configureOptions);
return(builder);
}
public static ISopiBuilder AddLifetimeOptions(this ISopiBuilder builder)
{
return(builder.AddLifetimeOptions(c => builder.Config.Bind("Lifetime", c)));
}
