public static X509Certificate2 GetCertificate(this IServiceConfigurationBuilder serviceConfigurationBuilder, DynamicOptions certificateOptions)
{
if (serviceConfigurationBuilder == null)
{
throw new ArgumentNullException(nameof(serviceConfigurationBuilder));
}
if (certificateOptions == null)
{
throw new ArgumentNullException(nameof(certificateOptions));
}
try
{
var resolverOptions = (ResolverOptions)serviceConfigurationBuilder.InstanceFactory.Create(certificateOptions.Type);
certificateOptions.Options?.Bind(resolverOptions);
var certificate = serviceConfigurationBuilder.CertificateResolver.Resolve(resolverOptions);
return(certificate.Unwrap <X509Certificate2>());
}
catch (Exception exception)
{
throw new InvalidOperationException($"Could not resolve certificate from options with path \"{certificateOptions.Options?.Path}\" and type \"{certificateOptions.Type}\".", exception);
}
}
public static void AddCrypto(this IServiceConfigurationBuilder builder)
{
builder.Services.AddSingleton <ITransactionHasher, TransactionHasher>();
builder.Services.AddSingleton <ITransactionValidator, TransactionValidator>();
builder.Services.AddSingleton <IKeyGenerator, KeyGenerator>();
builder.Services.AddSingleton <ICryptoSigner, CryptoSigner>();
}
public static void AddPubsub(this IServiceConfigurationBuilder builder)
{
builder.Services.AddSingleton<ITransactionPublisher, TransactionPublisher>();
builder.Services.AddSingleton<ITransactionSubscriber, TransactionSubscriber>();
if((string)builder.Configuration.GetValue(typeof(string), "Broker") == "redis")
{
builder.Services.Configure<RedisBrokerOptions>(options => builder.Configuration.GetSection("Redis").Bind(options));
builder.Services.AddSingleton<ITransactionBroker, RedisBroker>();
}
else
{
// TODO: add other broker configs as needed
}
}
public static void AddSwagger(this IServiceConfigurationBuilder builder)
{
using (var provider = builder.Services.BuildServiceProvider())
{
var toggles = provider.GetRequiredService <IFeatureToggleProvider>();
builder.Services.AddSwaggerGen(gen =>
{
var xmlFile = $"{Assembly.GetEntryAssembly().GetName().Name}.xml";
var xmlPath = Path.Combine(AppContext.BaseDirectory, xmlFile);
gen.IncludeXmlComments(xmlPath);
gen.DocumentFilter <DevDocumentFilter>(toggles);
});
}
}
public DevelopmentStartup(IServiceConfigurationBuilder serviceConfigurationBuilder)
{
this.ServiceConfigurationBuilder = serviceConfigurationBuilder ?? throw new ArgumentNullException(nameof(serviceConfigurationBuilder));
}
public static void AddFeatureToggles(this IServiceConfigurationBuilder builder)
{
builder.Services.Configure <FeatureToggleOptions>(options => builder.Configuration.GetSection("FeatureToggles").Bind(options));
builder.Services.AddSingleton <IFeatureToggleProvider, FeatureToggleProvider>();
}
public static void AddRepositories(this IServiceConfigurationBuilder builder)
{
builder.Services.AddSingleton <ITransactionRepository, TransactionRepository>();
}
public static IServiceCollection AddDataDirectory(this IServiceCollection services, IServiceConfigurationBuilder serviceConfigurationBuilder)
{
if (services == null)
{
throw new ArgumentNullException(nameof(services));
}
if (serviceConfigurationBuilder == null)
{
throw new ArgumentNullException(nameof(serviceConfigurationBuilder));
}
var options = new DataDirectoryOptions();
serviceConfigurationBuilder.Configuration.GetSection(ConfigurationKeys.DataDirectoryPath).Bind(options);
var path = options.Path;
if (!Path.IsPathRooted(path))
{
path = Path.Combine(serviceConfigurationBuilder.HostEnvironment.ContentRootPath, path);
}
serviceConfigurationBuilder.ApplicationDomain.SetData(ConfigurationKeys.DataDirectoryPath, path);
return(services);
}
public static IServiceCollection AddCertificateForwarding(this IServiceCollection services, IServiceConfigurationBuilder serviceConfigurationBuilder)
{
if (services == null)
{
throw new ArgumentNullException(nameof(services));
}
if (serviceConfigurationBuilder == null)
{
throw new ArgumentNullException(nameof(serviceConfigurationBuilder));
}
var configurationSection = serviceConfigurationBuilder.Configuration.GetSection(ConfigurationKeys.CertificateForwardingPath);
return(services.AddCertificateForwarding(options =>
{
configurationSection.Bind(options);
}));
}
public static IServiceCollection AddIdentity(this IServiceCollection services, IServiceConfigurationBuilder serviceConfigurationBuilder)
{
if (services == null)
{
throw new ArgumentNullException(nameof(services));
}
if (serviceConfigurationBuilder == null)
{
throw new ArgumentNullException(nameof(serviceConfigurationBuilder));
}
var connectionString = serviceConfigurationBuilder.Configuration.GetConnectionString(serviceConfigurationBuilder.Data.ConnectionStringName);
var databaseProvider = serviceConfigurationBuilder.Data.Provider;
return(databaseProvider switch
{
DatabaseProvider.Sqlite => services.AddIdentity <SqliteIdentity>(optionsBuilder => optionsBuilder.UseSqlite(connectionString)),
DatabaseProvider.SqlServer => services.AddIdentity <SqlServerIdentity>(optionsBuilder => optionsBuilder.UseSqlServer(connectionString)),
_ => throw new InvalidOperationException($"The database-provider \"{databaseProvider}\" is not supported.")
});
public static IServiceCollection AddForwardedHeaders(this IServiceCollection services, IServiceConfigurationBuilder serviceConfigurationBuilder)
{
if (services == null)
{
throw new ArgumentNullException(nameof(services));
}
if (serviceConfigurationBuilder == null)
{
throw new ArgumentNullException(nameof(serviceConfigurationBuilder));
}
return(services.Configure <ForwardedHeadersOptions>(options =>
{
options.AllowedHosts.Clear();
options.KnownNetworks.Clear();
options.KnownProxies.Clear();
var forwardedHeadersSection = serviceConfigurationBuilder.Configuration.GetSection(ConfigurationKeys.ForwardedHeadersPath);
forwardedHeadersSection?.Bind(options);
var extendedOptions = new ExtendedForwardedHeadersOptions();
forwardedHeadersSection?.Bind(extendedOptions);
foreach (var knownNetwork in extendedOptions.KnownNetworks)
{
options.KnownNetworks.Add(new IPNetwork(IPAddress.Parse(knownNetwork.Prefix), knownNetwork.PrefixLength));
}
foreach (var proxy in extendedOptions.KnownProxies)
{
options.KnownProxies.Add(IPAddress.Parse(proxy));
}
}));
}
public static IServiceCollection AddDevelopment(this IServiceCollection services, IServiceConfigurationBuilder serviceConfigurationBuilder)
{
if (services == null)
{
throw new ArgumentNullException(nameof(services));
}
if (serviceConfigurationBuilder == null)
{
throw new ArgumentNullException(nameof(serviceConfigurationBuilder));
}
var developmentStartup = new DevelopmentStartup(serviceConfigurationBuilder);
developmentStartup.ConfigureServices(services);
services.TryAddSingleton <IDevelopmentStartup>(developmentStartup);
return(services);
}
public static void AddSerializers(this IServiceConfigurationBuilder builder)
{
builder.Services.AddSingleton <ITransactionSerializer, TransactionSerializer>();
}
