public static IDicomServerBuilder AddSqlServer(
this IDicomServerBuilder dicomServerBuilder,
IConfiguration configurationRoot,
Action <SqlServerDataStoreConfiguration> configureAction = null)
{
IServiceCollection services = EnsureArg.IsNotNull(dicomServerBuilder, nameof(dicomServerBuilder)).Services;
// Add core SQL services
services
.AddSqlServerConnection(
config =>
{
configurationRoot?.GetSection(SqlServerDataStoreConfiguration.SectionName).Bind(config);
configureAction?.Invoke(config);
})
.AddSqlServerManagement <SchemaVersion>()
.AddSqlServerApi()
.AddBackgroundSqlSchemaVersionResolver();
// Add SQL-specific implementations
services
.AddSqlChangeFeedStore()
.AddSqlIndexDataStores()
.AddSqlQueryStore()
.AddSqlInstanceStores()
.AddSqlExtendedQueryTagStores()
.AddSqlExtendedQueryTagErrorStores()
.AddSqlPartitionStore();
return(dicomServerBuilder);
}
private static IDicomServerBuilder AddStorageDataStore <TStoreConfigurationSection, TIStore, TStore, TLogStore>(
this IDicomServerBuilder serverBuilder, IConfiguration configuration, string healthCheckName)
where TStoreConfigurationSection : class, IStoreConfigurationSection, new()
where TStore : class, TIStore
where TLogStore : TIStore
{
var blobConfig = configuration.GetSection(BlobServiceClientOptions.DefaultSectionName);
var config = new TStoreConfigurationSection();
serverBuilder.Services
.AddSingleton <TStoreConfigurationSection>()
.AddTransient <IStoreConfigurationSection>(sp => sp.GetRequiredService <TStoreConfigurationSection>())
.AddPersistence <TIStore, TStore, TLogStore>()
.AddBlobServiceClient(blobConfig)
.AddBlobContainerInitialization(x => blobConfig
.GetSection(BlobInitializerOptions.DefaultSectionName)
.Bind(x))
.ConfigureContainer(config.ContainerConfigurationName, x => configuration
.GetSection(config.ConfigurationSectionName)
.Bind(x));
serverBuilder
.AddBlobHealthCheck <DicomBlobHealthCheck <TStoreConfigurationSection> >(healthCheckName);
return(serverBuilder);
}
/// <summary>
/// Add services for DICOM background workers.
/// </summary>
/// <param name="serverBuilder">The DICOM server builder instance.</param>
/// <returns>The DICOM server builder instance.</returns>
public static IDicomServerBuilder AddBackgroundWorkers(this IDicomServerBuilder serverBuilder)
{
EnsureArg.IsNotNull(serverBuilder, nameof(serverBuilder));
serverBuilder.Services.AddScoped <DeletedInstanceCleanupWorker>();
serverBuilder.Services.AddHostedService <DeletedInstanceCleanupBackgroundService>();
return(serverBuilder);
}
public static IDicomServerBuilder AddSqlServer(
this IDicomServerBuilder dicomServerBuilder,
IConfiguration configurationRoot,
Action <SqlServerDataStoreConfiguration> configureAction = null)
{
EnsureArg.IsNotNull(dicomServerBuilder, nameof(dicomServerBuilder));
IServiceCollection services = dicomServerBuilder.Services;
services.AddSqlServerBase <SchemaVersion>(configurationRoot);
services.AddSqlServerApi();
var config = new SqlServerDataStoreConfiguration();
configurationRoot?.GetSection("SqlServer").Bind(config);
services.Add(provider =>
{
configureAction?.Invoke(config);
return(config);
})
.Singleton()
.AsSelf();
services.Add(provider => new SchemaInformation((int)SchemaVersion.V1, (int)SchemaVersion.V1))
.Singleton()
.AsSelf();
services.Add <SqlIndexSchema>()
.Singleton()
.AsSelf();
services.Add <SqlIndexDataStore>()
.Scoped()
.AsSelf()
.AsImplementedInterfaces();
// TODO: Ideally, the logger can be registered in the API layer since it's agnostic to the implementation.
// However, the current implementation of the decorate method requires the concrete type to be already registered,
// so we need to register here. Need to some more investigation to see how we might be able to do this.
services.Decorate <IIndexDataStore, LoggingIndexDataStore>();
services.Add <SqlQueryStore>()
.Scoped()
.AsSelf()
.AsImplementedInterfaces();
services.Add <SqlInstanceStore>()
.Scoped()
.AsSelf()
.AsImplementedInterfaces();
services.Add <SqlChangeFeedStore>()
.Scoped()
.AsSelf()
.AsImplementedInterfaces();
return(dicomServerBuilder);
}
internal static IDicomServerBuilder AddBlobHealthCheck <TBlobHealthCheck>(this IDicomServerBuilder serverBuilder, string name)
where TBlobHealthCheck : BlobHealthCheck
{
serverBuilder.Services
.AddHealthChecks()
.AddCheck <TBlobHealthCheck>(name: name);
return(serverBuilder);
}
/// <summary>
/// Adds the metadata store for the DICOM server.
/// </summary>
/// <param name="serverBuilder">The DICOM server builder instance.</param>
/// <param name="configuration">The configuration for the server.</param>
/// <returns>The server builder.</returns>
public static IDicomServerBuilder AddMetadataStorageDataStore(this IDicomServerBuilder serverBuilder, IConfiguration configuration)
{
EnsureArg.IsNotNull(serverBuilder, nameof(serverBuilder));
EnsureArg.IsNotNull(configuration, nameof(configuration));
return(serverBuilder
.AddMetadataPersistence(configuration)
.AddMetadataHealthCheck());
}
/// <summary>
/// Adds the necessary services to support the usage of <see cref="IDicomOperationsClient"/>.
/// </summary>
/// <param name="dicomServerBuilder">A service builder for constructing a DICOM server.</param>
/// <param name="configuration">The root of a configuration containing settings for the client.</param>
/// <returns>The service builder for adding additional services.</returns>
/// <exception cref="ArgumentNullException">
/// <para>
/// <paramref name="dicomServerBuilder"/> or <paramref name="configuration"/> is <see langword="null"/>.
/// </para>
/// <para>-or-</para>
/// <para>
/// <paramref name="configuration"/> is missing a section with the key TBD
/// </para>
/// </exception>
public static IDicomServerBuilder AddAzureFunctionsClient(
this IDicomServerBuilder dicomServerBuilder,
IConfiguration configuration)
{
EnsureArg.IsNotNull(dicomServerBuilder, nameof(dicomServerBuilder));
EnsureArg.IsNotNull(configuration, nameof(configuration));
IServiceCollection services = dicomServerBuilder.Services;
services.TryAddSingleton(GuidFactory.Default);
services.AddDurableClientFactory(x => configuration.GetSection(ConfigSectionName).Bind(x));
services.Replace(ServiceDescriptor.Singleton <IMessageSerializerSettingsFactory, MessageSerializerSettingsFactory>());
services.TryAddScoped <IDicomOperationsClient, DicomAzureFunctionsClient>();
return(dicomServerBuilder);
}
/// <summary>
/// Adds the blob data stores for the DICOM server.
/// </summary>
/// <param name="serverBuilder">The DICOM server builder instance.</param>
/// <param name="configuration">The configuration for the server.</param>
/// <returns>The server builder.</returns>
public static IDicomServerBuilder AddBlobDataStores(this IDicomServerBuilder serverBuilder, IConfiguration configuration)
{
EnsureArg.IsNotNull(serverBuilder, nameof(serverBuilder));
EnsureArg.IsNotNull(configuration, nameof(configuration));
var blobConfig = configuration.GetSection(BlobServiceClientOptions.DefaultSectionName);
serverBuilder.Services
.AddOptions <BlobOperationOptions>()
.Bind(blobConfig.GetSection(nameof(BlobServiceClientOptions.Operations)));
serverBuilder
.AddStorageDataStore <BlobStoreConfigurationSection, IFileStore, BlobFileStore, LoggingFileStore>(
configuration, "DcmHealthCheck")
.AddStorageDataStore <MetadataStoreConfigurationSection, IMetadataStore, BlobMetadataStore, LoggingMetadataStore>(
configuration, "MetadataHealthCheck");
return(serverBuilder);
}
private static IDicomServerBuilder AddMetadataPersistence(this IDicomServerBuilder serverBuilder, IConfiguration configuration)
{
IServiceCollection services = serverBuilder.Services;
services.AddBlobDataStore();
services.Configure <BlobContainerConfiguration>(
Constants.ContainerConfigurationName,
containerConfiguration => configuration.GetSection(DicomServerBlobConfigurationSectionName)
.Bind(containerConfiguration));
services.Add(sp =>
{
ILoggerFactory loggerFactory = sp.GetService <ILoggerFactory>();
IOptionsMonitor <BlobContainerConfiguration> namedBlobContainerConfiguration = sp.GetService <IOptionsMonitor <BlobContainerConfiguration> >();
BlobContainerConfiguration blobContainerConfiguration = namedBlobContainerConfiguration.Get(Constants.ContainerConfigurationName);
return(new BlobContainerInitializer(
blobContainerConfiguration.ContainerName,
loggerFactory.CreateLogger <BlobContainerInitializer>()));
})
.Singleton()
.AsService <IBlobContainerInitializer>();
services.Add <BlobMetadataStore>()
.Scoped()
.AsSelf()
.AsImplementedInterfaces();
// TODO: Ideally, the logger can be registered in the API layer since it's agnostic to the implementation.
// However, the current implementation of the decorate method requires the concrete type to be already registered,
// so we need to register here. Need to some more investigation to see how we might be able to do this.
services.Decorate <IMetadataStore, LoggingMetadataStore>();
return(serverBuilder);
}
private static IDicomServerBuilder AddMetadataHealthCheck(this IDicomServerBuilder serverBuilder)
{
serverBuilder.Services.AddHealthChecks().AddCheck <MetadataHealthCheck>(name: nameof(MetadataHealthCheck));
return(serverBuilder);
}
private static IDicomServerBuilder AddBlobHealthCheck(this IDicomServerBuilder serverBuilder)
{
serverBuilder.Services.AddHealthChecks().AddCheck <DicomBlobHealthCheck>(name: "DcmHealthCheck");
return(serverBuilder);
}
/// <summary>
/// Add services for DICOM hosted services.
/// </summary>
/// <param name="serverBuilder">The DICOM server builder instance.</param>
/// <returns>The DICOM server builder instance.</returns>
public static IDicomServerBuilder AddHostedServices(this IDicomServerBuilder serverBuilder)
{
EnsureArg.IsNotNull(serverBuilder, nameof(serverBuilder));
serverBuilder.Services.AddHostedService <DataPartitionFeatureValidatorService>();
return(serverBuilder);
}
