public static IServiceCollection AddSciter <TPrimaryHost>(
this IServiceCollection services,
Action <SciterHostOptions> hostOptions = null,
Action <SciterWindowOptions> windowOptions = null)
where TPrimaryHost : SciterHost
{
services
//.AddSingleton<HostEventHandlerRegistry>((provider) => HostEventHandlerRegistry.Instance)
.AddSingleton <IHostWindowResolver, HostWindowResolver>()
.AddSingleton <INamedBehaviorResolver, NamedBehaviorResolver>()
.AddHostWindow <TPrimaryHost>()
.AddHostEventHandler <TPrimaryHost>();
services.AddTransient <TPrimaryHost>(
provider =>
{
using var scope = provider.CreateScope();
var scopedServiceProvider = scope.ServiceProvider;
var sciterHostOptions = new SciterHostOptions(scopedServiceProvider);
var sciterWindowOptions = new SciterWindowOptions(scopedServiceProvider);
hostOptions?.Invoke(sciterHostOptions);
/*THost result;
*
* if (typeof(THost).Implements<SciterArchiveHost>())
* {
* var archiveAttribute = typeof(THost)
* .GetCustomAttributes<SciterHostArchiveAttribute>(inherit: true).FirstOrDefault();
*
* result = ActivatorUtilities.CreateInstance<THost>(provider);
*
* //Archive = new SciterArchive(archiveAttribute?.BaseUrl ?? SciterArchive.DEFAULT_ARCHIVE_URI)
* // .Open();
* }
* else
* {
* result = ActivatorUtilities.CreateInstance<THost>(provider);
* }*/
if (sciterHostOptions.ArchiveUri != null)
{
}
var result = ActivatorUtilities.CreateInstance <TPrimaryHost>(scopedServiceProvider);
var archives = scopedServiceProvider.GetServices <LazySciterArchive>();
foreach (var archive in archives)
{
archive.Open();
result.AttachedArchives.TryAdd(archive.Uri.Scheme, archive);
if (archive.InitScripts?.Any() != true)
{
continue;
}
foreach (var initScript in archive.InitScripts)
{
var byteArray = Encoding.UTF8.GetBytes($"include \"{initScript}\";");
var pinnedArray = GCHandle.Alloc(byteArray, GCHandleType.Pinned);
var pointer = pinnedArray.AddrOfPinnedObject();
Sciter.SciterApi.SciterSetOption(IntPtr.Zero, SciterXDef.SCITER_RT_OPTIONS.SCITER_SET_INIT_SCRIPT,
pointer);
pinnedArray.Free();
}
}
var namedBehaviorResolver = scopedServiceProvider.GetService <INamedBehaviorResolver>();
if (namedBehaviorResolver != null)
{
result.SetBehaviorResolver(namedBehaviorResolver);
}
var hostWindowResolver = scopedServiceProvider.GetService <IHostWindowResolver>();
var sciterWindow = hostWindowResolver?.GetWindow(typeof(TPrimaryHost));
if (sciterWindow != null && windowOptions != null)
{
windowOptions?.Invoke(sciterWindowOptions);
if (!string.IsNullOrWhiteSpace(sciterWindowOptions?.Title))
{
sciterWindow.SetTitle(sciterWindowOptions.Title);
}
if (sciterWindowOptions.Height.HasValue && sciterWindowOptions.Width.HasValue)
{
//sciterWindow.SetDimensions();
}
switch (sciterWindowOptions.Position)
{
case SciterWindowPosition.CenterScreen:
sciterWindow.CenterWindow();
break;
case SciterWindowPosition.Custom:
break;
case SciterWindowPosition.Default:
default:
break;
;
}
}
result?.SetupWindow(sciterWindow);
//result?.Window.TryLoadPage(uri: new Uri("this://app/index.html"));
HostEventHandlerRegistry.Instance
.TryGetValue(typeof(TPrimaryHost), out var hostEventHandlerType);
if (hostEventHandlerType != null && scopedServiceProvider
.GetService(hostEventHandlerType) is SciterEventHandler hostEventHandler)
{
result?.AttachEventHandler(hostEventHandler);
}
//Must load the `Home Page` after setting up the Window and attaching the Hosts' EventHandler
if (sciterHostOptions.HomePageUri != null)
{
var homePageUri = sciterHostOptions.HomePageUri;
if (result is SciterArchiveHost && !sciterHostOptions.HomePageUri.IsAbsoluteUri && sciterHostOptions.ArchiveUri != null)
{
homePageUri = new Uri(sciterHostOptions.ArchiveUri, sciterHostOptions.HomePageUri);
}
result?.Window.TryLoadPage(uri: homePageUri);
}
result
?.OnCreated
?.Invoke(result, new HostCreatedEventArgs(sciterWindow));
return(result);
});
services.AddTransient <SciterHost, TPrimaryHost>(provider => provider.GetRequiredService <TPrimaryHost>());
services.AddSingleton <SciterApplication>(provider =>
ActivatorUtilities.CreateInstance <SciterApplication>(provider, provider.GetRequiredService <TPrimaryHost>()));
return(services);
}
private static object CreateInstance(this IServiceProvider provider, Type type, params object[] arguments)
{
return(ActivatorUtilities.CreateInstance(provider, type, arguments));
}
public static IServiceCollection AddTriggeredDbContextFactory <TContext>(this IServiceCollection serviceCollection, Action <DbContextOptionsBuilder>?optionsAction = null, ServiceLifetime lifetime = ServiceLifetime.Singleton)
where TContext : DbContext
{
serviceCollection.AddDbContextFactory <TContext>(options => {
optionsAction?.Invoke(options);
options.UseTriggers();
}, lifetime);
var serviceDescriptor = serviceCollection.FirstOrDefault(x => x.ServiceType == typeof(IDbContextFactory <TContext>));
if (serviceDescriptor?.ImplementationType != null)
{
var triggeredFactoryType = typeof(TriggeredDbContextFactory <,>).MakeGenericType(typeof(TContext), serviceDescriptor.ImplementationType);
serviceCollection.TryAdd(ServiceDescriptor.Describe(
serviceType: serviceDescriptor.ImplementationType,
implementationType: serviceDescriptor.ImplementationType,
lifetime: serviceDescriptor.Lifetime
));
serviceCollection.Replace(ServiceDescriptor.Describe(
serviceType: typeof(IDbContextFactory <TContext>),
implementationFactory: serviceProvider => ActivatorUtilities.CreateInstance(serviceProvider, triggeredFactoryType, serviceProvider.GetService(serviceDescriptor.ImplementationType), serviceProvider),
lifetime: ServiceLifetime.Scoped
));
}
return(serviceCollection);
}
public static T Create <T>(this Plugin plugin, IServiceProvider serviceProvider) where T : class
{
return(ActivatorUtilities.CreateInstance(serviceProvider, plugin) as T);
}
public static object Create(this Plugin plugin, IServiceProvider serviceProvider)
{
return(ActivatorUtilities.CreateInstance(serviceProvider, plugin));
}
/// <summary>
/// Adds essential DotVVM services to the specified <see cref="IServiceCollection" />.
/// </summary>
/// <param name="services">The <see cref="IServiceCollection" /> to add services to.</param>
/// <param name="allowDebugServices">If the vs-diagnostics services should be registered</param>
public static IServiceCollection RegisterDotVVMServices(IServiceCollection services, bool allowDebugServices = true)
{
services.AddOptions();
if (allowDebugServices)
{
services.AddDiagnosticServices();
}
services.TryAddSingleton <IDotvvmViewBuilder, DefaultDotvvmViewBuilder>();
services.TryAddSingleton <IViewModelSerializer, DefaultViewModelSerializer>();
services.TryAddSingleton <IViewModelLoader, DefaultViewModelLoader>();
services.TryAddSingleton <IViewModelValidationMetadataProvider, AttributeViewModelValidationMetadataProvider>();
services.TryAddSingleton <IValidationRuleTranslator, ViewModelValidationRuleTranslator>();
services.TryAddSingleton <IViewModelValidator, ViewModelValidator>();
services.TryAddSingleton <IViewModelSerializationMapper, ViewModelSerializationMapper>();
services.TryAddSingleton <IViewModelParameterBinder, AttributeViewModelParameterBinder>();
services.TryAddSingleton <IOutputRenderer, DefaultOutputRenderer>();
services.TryAddSingleton <IDotvvmPresenter, DotvvmPresenter>();
services.TryAddSingleton <IMarkupFileLoader, AggregateMarkupFileLoader>();
services.TryAddSingleton <IControlBuilderFactory, DefaultControlBuilderFactory>();
services.TryAddSingleton <IControlResolver, DefaultControlResolver>();
services.TryAddSingleton <IControlTreeResolver, DefaultControlTreeResolver>();
services.TryAddSingleton <IAbstractTreeBuilder, ResolvedTreeBuilder>();
services.TryAddSingleton <Func <ControlUsageValidationVisitor> >(s => () => ActivatorUtilities.CreateInstance <ControlUsageValidationVisitor>(s));
services.TryAddSingleton <IViewCompiler, DefaultViewCompiler>();
services.TryAddSingleton <IBindingCompiler, BindingCompiler>();
services.TryAddSingleton <IBindingExpressionBuilder, BindingExpressionBuilder>();
services.TryAddSingleton <BindingCompilationService, BindingCompilationService>();
services.TryAddSingleton <DataPager.CommonBindings>();
services.TryAddSingleton <IControlUsageValidator, DefaultControlUsageValidator>();
services.TryAddSingleton <ILocalResourceUrlManager, LocalResourceUrlManager>();
services.TryAddSingleton <IResourceHashService, DefaultResourceHashService>();
services.TryAddSingleton <StaticCommandBindingCompiler, StaticCommandBindingCompiler>();
services.TryAddSingleton <JavascriptTranslator, JavascriptTranslator>();
services.TryAddSingleton <IHttpRedirectService, DefaultHttpRedirectService>();
services.TryAddScoped <AggregateRequestTracer, AggregateRequestTracer>();
services.TryAddScoped <ResourceManager, ResourceManager>();
services.TryAddSingleton(s => DotvvmConfiguration.CreateDefault(s));
services.TryAddSingleton(s => s.GetRequiredService <DotvvmConfiguration>().Markup);
services.TryAddSingleton(s => s.GetRequiredService <DotvvmConfiguration>().Resources);
services.TryAddSingleton(s => s.GetRequiredService <DotvvmConfiguration>().RouteTable);
services.TryAddSingleton(s => s.GetRequiredService <DotvvmConfiguration>().Runtime);
services.TryAddSingleton(s => s.GetRequiredService <DotvvmConfiguration>().Security);
services.TryAddSingleton(s => s.GetRequiredService <DotvvmConfiguration>().Styles);
services.ConfigureWithServices <BindingCompilationOptions>((o, s) => {
o.TransformerClasses.Add(ActivatorUtilities.CreateInstance <BindingPropertyResolvers>(s));
});
services.ConfigureWithServices <ViewCompilerConfiguration>((o, s) => {
var requiredResourceControl = s.GetRequiredService <IControlResolver>().ResolveControl(new ResolvedTypeDescriptor(typeof(RequiredResource)));
o.TreeVisitors.Add(() => new BindingRequiredResourceVisitor((ControlResolverMetadata)requiredResourceControl));
o.TreeVisitors.Add(() => ActivatorUtilities.CreateInstance <StylingVisitor>(s));
o.TreeVisitors.Add(() => ActivatorUtilities.CreateInstance <DataContextPropertyAssigningVisitor>(s));
o.TreeVisitors.Add(() => new LifecycleRequirementsAssigningVisitor());
});
return(services);
}
/// <summary>
/// Instantiates a new object of the specified type, but with support for constructor injection.
/// </summary>
public static TResult CreateInstance <TResult>(this IServiceProvider provider, Type type) where TResult : class
{
return((TResult)ActivatorUtilities.CreateInstance(provider, type));
}
/// <summary>
/// Adds a <see cref="IMessageHandler{TMessage,TMessageContext}" /> implementation to process the messages from an Azure Service Bus.
/// resources.
/// </summary>
/// <typeparam name="TMessageHandler">The type of the implementation.</typeparam>
/// <typeparam name="TMessage">The type of the message that the message handler will process.</typeparam>
/// <typeparam name="TMessageContext">The type of the context in which the message handler will process the message.</typeparam>
/// <param name="services">The collection of services to use in the application.</param>
/// <param name="messageContextFilter">The function that determines if the message handler should handle the message based on the context.</param>
/// <param name="messageBodyFilter">The filter to restrict the message processing based on the incoming message body.</param>
/// <exception cref="ArgumentNullException">Thrown when the <paramref name="services"/>, <paramref name="messageContextFilter"/>, or <paramref name="messageBodyFilter"/> is <c>null</c>.</exception>
public static MessageHandlerCollection WithMessageHandler <TMessageHandler, TMessage, TMessageContext>(
this MessageHandlerCollection services,
Func <TMessageContext, bool> messageContextFilter,
Func <TMessage, bool> messageBodyFilter)
where TMessageHandler : class, IMessageHandler <TMessage, TMessageContext>
where TMessage : class
where TMessageContext : MessageContext
{
Guard.NotNull(services, nameof(services), "Requires a set of services to add the message handler");
Guard.NotNull(messageContextFilter, nameof(messageContextFilter), "Requires a filter to restrict the message processing within a certain message context");
Guard.NotNull(messageBodyFilter, nameof(messageBodyFilter), "Requires a filter to restrict the message processing based on the incoming message body");
return(WithMessageHandler <TMessageHandler, TMessage, TMessageContext>(
services, messageContextFilter, messageBodyFilter, serviceProvider => ActivatorUtilities.CreateInstance <TMessageHandler>(serviceProvider)));
}
/// <summary> /// Adds and configures a IMultiTenantStrategy to the applicationusing default dependency injection. /// </summary> /// <param name="lifetime">The service lifetime.</param> /// <param name="parameters">a paramter list for any constructor paramaters not covered by dependency injection.</param> /// <returns>The same MultiTenantBuilder passed into the method.</returns> public FinbuckeMultiTenantBuilder WithStrategy <T>(ServiceLifetime lifetime, params object[] parameters) where T : IMultiTenantStrategy => WithStrategy(lifetime, sp => ActivatorUtilities.CreateInstance <T>(sp, parameters));
/// <summary>
/// Adds and configures a IMultiTenantStore to the application using default dependency injection.
/// </summary>>
/// <param name="lifetime">The service lifetime.</param>
/// <param name="parameters">a paramter list for any constructor paramaters not covered by dependency injection.</param>
/// <returns>The same MultiTenantBuilder passed into the method.</returns>
public FinbuckleMultiTenantBuilder <TTenantInfo> WithStore <TStore>(ServiceLifetime lifetime, params object[] parameters)
where TStore : IMultiTenantStore <TTenantInfo>
=> WithStore <TStore>(lifetime, sp => ActivatorUtilities.CreateInstance <TStore>(sp, parameters));
//https://stackoverflow.com/questions/53884417/net-core-di-ways-of-passing-parameters-to-constructor public static T ResolveWith <T>(this IServiceProvider provider, params object[] parameters) where T : class => ActivatorUtilities.CreateInstance <T>(provider, parameters);
public static IServiceCollection AddFluentMigratorCore(
[NotNull] this IServiceCollection services)
{
if (services == null)
{
throw new ArgumentNullException(nameof(services));
}
services
// Add support for options
.AddOptions()
// Add loggins support
.AddLogging()
// The default assembly loader factory
.AddSingleton <AssemblyLoaderFactory>()
// Assembly loader engines
.AddSingleton <IAssemblyLoadEngine, AssemblyNameLoadEngine>()
.AddSingleton <IAssemblyLoadEngine, AssemblyFileLoadEngine>()
// Defines the assemblies that are used to find migrations, profiles, maintenance code, etc...
.AddSingleton <IAssemblySource, AssemblySource>()
// Configure the loader for migrations that should be executed during maintenance steps
.AddSingleton <IMaintenanceLoader, MaintenanceLoader>()
// Add the default embedded resource provider
.AddSingleton <IEmbeddedResourceProvider>(sp => new DefaultEmbeddedResourceProvider(sp.GetRequiredService <IAssemblySource>().Assemblies))
// The default set of conventions to be applied to migration expressions
.AddSingleton <IConventionSet, DefaultConventionSet>()
// Configure the runner conventions
.AddSingleton <IMigrationRunnerConventionsAccessor, AssemblySourceMigrationRunnerConventionsAccessor>()
.AddSingleton(sp => sp.GetRequiredService <IMigrationRunnerConventionsAccessor>().MigrationRunnerConventions)
// The IStopWatch implementation used to show query timing
.AddSingleton <IStopWatch, StopWatch>()
// Source for migrations
#pragma warning disable 618
.AddScoped <IMigrationSource, MigrationSource>()
.AddScoped(
sp => sp.GetRequiredService <IMigrationSource>() as IFilteringMigrationSource
?? ActivatorUtilities.CreateInstance <MigrationSource>(sp))
#pragma warning restore 618
// Source for profiles
.AddScoped <IProfileSource, ProfileSource>()
// Configure the accessor for the version table metadata
.AddScoped <IVersionTableMetaDataAccessor, AssemblySourceVersionTableMetaDataAccessor>()
// Configure the default version table metadata
.AddScoped(sp => sp.GetRequiredService <IVersionTableMetaDataAccessor>().VersionTableMetaData ?? ActivatorUtilities.CreateInstance <DefaultVersionTableMetaData>(sp))
// Configure the migration information loader
.AddScoped <IMigrationInformationLoader, DefaultMigrationInformationLoader>()
// Provide a way to get the migration generator selected by its options
.AddScoped <IGeneratorAccessor, SelectingGeneratorAccessor>()
// Provide a way to get the migration accessor selected by its options
.AddScoped <IProcessorAccessor, SelectingProcessorAccessor>()
// IQuerySchema is the base interface for the IMigrationProcessor
.AddScoped <IQuerySchema>(sp => sp.GetRequiredService <IProcessorAccessor>().Processor)
// The profile loader needed by the migration runner
.AddScoped <IProfileLoader, ProfileLoader>()
// Some services especially for the migration runner implementation
.AddScoped <IMigrationExpressionValidator, DefaultMigrationExpressionValidator>()
.AddScoped <MigrationValidator>()
.AddScoped <MigrationScopeHandler>()
// The connection string readers
#if NETFRAMEWORK
.AddScoped <INetConfigManager, NetConfigManager>()
#pragma warning disable 612
.AddScoped <IConnectionStringReader, AppConfigConnectionStringReader>()
#pragma warning restore 612
#endif
.AddScoped <IConnectionStringReader, ConfigurationConnectionStringReader>()
// The connection string accessor that evaluates the readers
.AddScoped <IConnectionStringAccessor, ConnectionStringAccessor>()
.AddScoped <IVersionLoader>(
sp =>
{
var options = sp.GetRequiredService <IOptions <RunnerOptions> >();
var connAccessor = sp.GetRequiredService <IConnectionStringAccessor>();
var hasConnection = !string.IsNullOrEmpty(connAccessor.ConnectionString);
if (options.Value.NoConnection || !hasConnection)
{
return(ActivatorUtilities.CreateInstance <ConnectionlessVersionLoader>(sp));
}
return(ActivatorUtilities.CreateInstance <VersionLoader>(sp));
})
// Configure the runner
.AddScoped <IMigrationRunner, MigrationRunner>()
// Configure the task executor
.AddScoped <TaskExecutor>()
// Migration context
.AddTransient <IMigrationContext>(
sp =>
{
var querySchema = sp.GetRequiredService <IQuerySchema>();
var options = sp.GetRequiredService <IOptions <RunnerOptions> >();
var connectionStringAccessor = sp.GetRequiredService <IConnectionStringAccessor>();
var connectionString = connectionStringAccessor.ConnectionString;
#pragma warning disable 612
var appContext = options.Value.ApplicationContext;
#pragma warning restore 612
return(new MigrationContext(querySchema, sp, appContext, connectionString));
});
return(services);
}
public ConnectionlessProcessorAccessor(IServiceProvider serviceProvider)
{
Processor = ActivatorUtilities.CreateInstance <ConnectionlessProcessor>(serviceProvider);
}
/// <summary>
/// Adds a <see cref="IMessageHandler{TMessage, TMessageContext}" /> implementation to process the messages from an Azure Service Bus.
/// resources.
/// </summary>
/// <typeparam name="TMessageHandler">The type of the implementation.</typeparam>
/// <typeparam name="TMessage">The type of the message that the message handler will process.</typeparam>
/// <typeparam name="TMessageContext">The type of the context in which the message handler will process the message.</typeparam>
/// <param name="services">The collection of services to use in the application.</param>
/// <param name="messageContextFilter">The function that determines if the message handler should handle the message based on the context.</param>
/// <param name="messageBodySerializerImplementationFactory">The function that creates the <see cref="IMessageBodySerializer"/> implementation.</param>
public static MessageHandlerCollection WithMessageHandler <TMessageHandler, TMessage, TMessageContext>(
this MessageHandlerCollection services,
Func <TMessageContext, bool> messageContextFilter,
Func <IServiceProvider, IMessageBodySerializer> messageBodySerializerImplementationFactory)
where TMessageHandler : class, IMessageHandler <TMessage, TMessageContext>
where TMessage : class
where TMessageContext : MessageContext
{
Guard.NotNull(services, nameof(services), "Requires a set of services to add the message handler");
Guard.NotNull(messageContextFilter, nameof(messageContextFilter), "Requires a filter to restrict the message processing within a certain message context");
Guard.NotNull(messageBodySerializerImplementationFactory, nameof(messageBodySerializerImplementationFactory), "Requires a function to create an custom message body serializer to deserialize the incoming message for the message handler");
return(services.WithMessageHandler <TMessageHandler, TMessage, TMessageContext>(
messageContextFilter, messageBodySerializerImplementationFactory, serviceProvider => ActivatorUtilities.CreateInstance <TMessageHandler>(serviceProvider)));
}
public static IServiceCollection AddHealthChecksUI(this IServiceCollection services, string databaseName = "healthchecksdb", Action <Settings> setupSettings = null)
{
var configuration = services.BuildServiceProvider()
.GetService <IConfiguration>();
services
.AddOptions()
.Configure <Settings>(settings =>
{
configuration.BindUISettings(settings);
setupSettings?.Invoke(settings);
})
.Configure <KubernetesDiscoverySettings>(settings =>
{
configuration.Bind(Keys.HEALTHCHECKSUI_KUBERNETES_DISCOVERY_SETTING_KEY, settings);
})
.Configure <DockerDiscoverySettings>(settings =>
{
configuration.Bind(Keys.HEALTHCHECKSUI_DOCKER_DISCOVERY_SETTING_KEY, settings);
})
.AddSingleton <IHostedService, HealthCheckCollectorHostedService>()
.AddScoped <IHealthCheckFailureNotifier, WebHookFailureNotifier>()
.AddScoped <IHealthCheckReportCollector, HealthCheckReportCollector>()
.AddHttpClient(Keys.HEALTH_CHECK_HTTP_CLIENT_NAME)
.ConfigurePrimaryHttpMessageHandler(sp =>
{
var settings = sp.GetService <IOptions <Settings> >();
return(settings.Value.ApiEndpointHttpHandler?.Invoke(sp) ?? new HttpClientHandler());
}).Services
.AddHttpClient(Keys.HEALTH_CHECK_WEBHOOK_HTTP_CLIENT_NAME)
.ConfigurePrimaryHttpMessageHandler(sp =>
{
var settings = sp.GetService <IOptions <Settings> >();
return(settings.Value.WebHooksEndpointHttpHandler?.Invoke(sp) ?? new HttpClientHandler());
});
var healthCheckSettings = services.BuildServiceProvider()
.GetService <IOptions <Settings> >()
.Value ?? new Settings();
var kubernetesDiscoverySettings = services.BuildServiceProvider()
.GetService <IOptions <KubernetesDiscoverySettings> >()
.Value ?? new KubernetesDiscoverySettings();
var dockerDiscoverySettings = services.BuildServiceProvider()
.GetService <IOptions <DockerDiscoverySettings> >()
.Value ?? new DockerDiscoverySettings();
services.AddDbContext <HealthChecksDb>(db =>
{
var connectionString = healthCheckSettings.HealthCheckDatabaseConnectionString;
if (string.IsNullOrWhiteSpace(connectionString))
{
var contentRoot = configuration[HostDefaults.ContentRootKey];
var path = Path.Combine(contentRoot, databaseName);
connectionString = $"Data Source={path}";
}
else
{
connectionString = Environment.ExpandEnvironmentVariables(connectionString);
}
db.UseSqlite(connectionString);
});
if (kubernetesDiscoverySettings.Enabled)
{
services.AddSingleton(kubernetesDiscoverySettings)
.AddHostedService <KubernetesDiscoveryHostedService>()
.AddHttpClient(Keys.K8S_DISCOVERY_HTTP_CLIENT_NAME, (provider, client) => client.ConfigureKubernetesClient(provider))
.ConfigureKubernetesMessageHandler()
.Services
.AddHttpClient(Keys.K8S_CLUSTER_SERVICE_HTTP_CLIENT_NAME);
}
if (dockerDiscoverySettings.Enabled)
{
services.AddHostedService <DockerDiscoveryHostedService>()
.AddScoped <IDiscoveryRegistryService, DiscoveryRegistryService>()
.AddSingleton <IDockerDiscoveryService>(x =>
{
var config = x.GetRequiredService <IOptions <DockerDiscoverySettings> >().Value;
var uri = new Uri(config.Endpoint);
var labelPrefix = $"{config.ServicesLabelPrefix}.";
return(ActivatorUtilities.CreateInstance <DockerDiscoveryService>(x, uri, labelPrefix));
})
.AddHttpClient(Keys.DISCOVERY_SERVICE_HTTP_CLIENT_NAME);
}
var serviceProvider = services.BuildServiceProvider();
CreateDatabase(serviceProvider).Wait();
return(services);
}
/// <summary>
/// Enables multiple existing health checks to be evaluated only when a specific condition occurs,
/// that is described by a type implementing <see cref="IConditionalHealthCheckPolicy"/>
/// and which will be executed on every health check request.
/// </summary>
/// <remarks>
/// The instance of this type is created with every request and its dependencies are resolved by <see cref="IServiceProvider"/>.
/// If the constructor has more arguments then these can be passed via the <paramref name="conditionalHealthCheckPolicyCtorArgs"/> parameter.
/// </remarks>
/// <typeparam name="T">The type implementing <see cref="IConditionalHealthCheckPolicy"/>.</typeparam>
/// <param name="builder">The builder used to register health checks.</param>
/// <param name="names">
/// The list of names of the existing health checks, ie. "Redis", "redis", "S3", "My Health Check".
/// The health checks must be previously registered using the other <see cref="IHealthChecksBuilder" /> extensions, like AddRedis, AddRabbitMQ, AddCheck, etc.
/// You can use the static <see cref="Registrations"/> class that contains a list of well-known names,
/// otherwise specify the name of the previously added health check.
/// </param>
/// <param name="conditionalHealthCheckPolicyCtorArgs"></param>
/// <param name="options">A list of options to override the default behavior. See <see cref="ConditionalHealthCheckOptions"/> for extra details.</param>
/// <returns>The same builder used to register health checks.</returns>
/// <exception cref="ArgumentException">When the name of the health check is not provided, ie. is null or is an empty string.</exception>
/// <exception cref="InvalidOperationException">When the health check identified by the previously given name is not registered yet.</exception>
public static IHealthChecksBuilder CheckOnlyWhen <T>(this IHealthChecksBuilder builder,
string[] names,
ConditionalHealthCheckOptions?options = null,
params object[] conditionalHealthCheckPolicyCtorArgs)
where T : IConditionalHealthCheckPolicy
=> builder.CheckOnlyWhen(names, (sp, _, __) => Task.FromResult(ActivatorUtilities.CreateInstance <T>(sp, conditionalHealthCheckPolicyCtorArgs)), options);
