public BlobMetadataStore(
BlobServiceClient client,
JsonSerializer jsonSerializer,
IOptionsMonitor <BlobContainerConfiguration> namedBlobContainerConfigurationAccessor,
RecyclableMemoryStreamManager recyclableMemoryStreamManager)
{
EnsureArg.IsNotNull(client, nameof(client));
EnsureArg.IsNotNull(jsonSerializer, nameof(jsonSerializer));
EnsureArg.IsNotNull(namedBlobContainerConfigurationAccessor, nameof(namedBlobContainerConfigurationAccessor));
EnsureArg.IsNotNull(recyclableMemoryStreamManager, nameof(recyclableMemoryStreamManager));
BlobContainerConfiguration containerConfiguration = namedBlobContainerConfigurationAccessor.Get(Constants.ContainerConfigurationName);
_container = client.GetBlobContainerClient(containerConfiguration.ContainerName);
_jsonSerializer = jsonSerializer;
_recyclableMemoryStreamManager = recyclableMemoryStreamManager;
}
public BlobFileStore(
BlobServiceClient client,
IOptionsMonitor <BlobContainerConfiguration> namedBlobContainerConfigurationAccessor,
RecyclableMemoryStreamManager recyclableMemoryStreamManager,
BlobDataStoreConfiguration blobDataStoreConfiguration)
{
EnsureArg.IsNotNull(client, nameof(client));
EnsureArg.IsNotNull(namedBlobContainerConfigurationAccessor, nameof(namedBlobContainerConfigurationAccessor));
EnsureArg.IsNotNull(recyclableMemoryStreamManager, nameof(recyclableMemoryStreamManager));
EnsureArg.IsNotNull(blobDataStoreConfiguration, nameof(blobDataStoreConfiguration));
BlobContainerConfiguration containerConfiguration = namedBlobContainerConfigurationAccessor.Get(Constants.ContainerConfigurationName);
_container = client.GetBlobContainerClient(containerConfiguration.ContainerName);
_recyclableMemoryStreamManager = recyclableMemoryStreamManager;
_blobDataStoreConfiguration = blobDataStoreConfiguration;
}
public static void AddFileTypeCheckHandler(
this BlobContainerConfiguration containerConfiguration,
Action <FileTypeCheckHandlerConfiguration> configureAction)
{
var blobProcessHandlers = containerConfiguration.GetConfigurationOrDefault(
DigniteAbpBlobContainerConfigurationNames.BlobProcessHandlers,
new TypeList <IBlobProcessHandler>());
if (blobProcessHandlers.TryAdd <FileTypeCheckHandler>())
{
configureAction(new FileTypeCheckHandlerConfiguration(containerConfiguration));
containerConfiguration.SetConfiguration(
DigniteAbpBlobContainerConfigurationNames.BlobProcessHandlers,
blobProcessHandlers);
}
}
/// <summary>
/// Gets a <see cref="BlobContainerClient"/> using <see cref="BlobContainerConfiguration"/>
/// stored in a tenant.
/// </summary>
/// <param name="blobContainerSource">
/// The <see cref="IBlobContainerSourceFromDynamicConfiguration"/> that provides the underlying
/// ability to supply a <see cref="BlobContainerClient"/> for a
/// <see cref="BlobContainerConfiguration"/>.
/// </param>
/// <param name="tenant">
/// The tenant containing the <see cref="BlobContainerConfiguration"/>.
/// </param>
/// <param name="configurationKey">
/// The key identifying the <see cref="ITenant.Properties"/> entry containing the
/// <see cref="BlobContainerConfiguration"/> to use.
/// </param>
/// <param name="containerName">
/// An optional container name to use. If this is null, the container name specified in the
/// <see cref="BlobContainerConfiguration"/> will be used. In cases where multiple
/// containers are in use, it's common to have one <see cref="BlobContainerConfiguration"/>
/// with a null <see cref="BlobContainerConfiguration.Container"/>, and to specify the
/// container name required when asking for a <see cref="BlobContainerClient"/>.
/// </param>
/// <returns>
/// A value task that produces a <see cref="BlobContainerClient"/>.
/// </returns>
public static async ValueTask <BlobContainerClient> GetBlobContainerClientFromTenantAsync(
this IBlobContainerSourceFromDynamicConfiguration blobContainerSource,
ITenant tenant,
string configurationKey,
string?containerName = null)
{
BlobContainerConfiguration configuration = tenant.GetBlobContainerConfiguration(configurationKey);
if (containerName is not null)
{
configuration = configuration with
{
Container = containerName,
};
}
return(await blobContainerSource.GetStorageContextAsync(configuration).ConfigureAwait(false));
}
public DataStoreTestsFixture()
{
IConfiguration environment = new ConfigurationBuilder()
.AddEnvironmentVariables()
.Build();
_blobContainerConfiguration = new BlobContainerConfiguration {
ContainerName = Guid.NewGuid().ToString()
};
_metadataContainerConfiguration = new BlobContainerConfiguration {
ContainerName = Guid.NewGuid().ToString()
};
_blobDataStoreConfiguration = new BlobDataStoreConfiguration
{
ConnectionString = environment["BlobStore:ConnectionString"] ?? BlobLocalEmulator.ConnectionString,
};
RecyclableMemoryStreamManager = new RecyclableMemoryStreamManager();
}
public DigniteAbpBlobContainer(
string containerName,
BlobContainerConfiguration configuration,
IBlobProvider provider,
ICurrentTenant currentTenant,
ICancellationTokenProvider cancellationTokenProvider,
IBlobNormalizeNamingService blobNormalizeNamingService,
IServiceProvider serviceProvider) : base(
containerName,
configuration,
provider,
currentTenant,
cancellationTokenProvider,
blobNormalizeNamingService,
serviceProvider
)
{
}
protected virtual string NormalizeContainerName(BlobContainerConfiguration configuration, string containerName)
{
if (!configuration.NamingNormalizers.Any())
{
return(containerName);
}
using (var scope = ServiceProvider.CreateScope())
{
foreach (var normalizerType in configuration.NamingNormalizers)
{
var normalizer = scope.ServiceProvider
.GetRequiredService(normalizerType)
.As <IBlobNamingNormalizer>();
containerName = normalizer.NormalizeContainerName(containerName);
}
return(containerName);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="BlobHealthCheck"/> class.
/// </summary>
/// <param name="client">The cloud blob client factory.</param>
/// <param name="configuration">The blob data store configuration.</param>
/// <param name="namedBlobContainerConfigurationAccessor">The IOptions accessor to get a named container configuration version.</param>
/// <param name="containerConfigurationName">Name to get corresponding container configuration.</param>
/// <param name="testProvider">The test provider.</param>
/// <param name="logger">The logger.</param>
public BlobHealthCheck(
BlobServiceClient client,
BlobDataStoreConfiguration configuration,
IOptionsSnapshot <BlobContainerConfiguration> namedBlobContainerConfigurationAccessor,
string containerConfigurationName,
IBlobClientTestProvider testProvider,
ILogger <BlobHealthCheck> logger)
{
EnsureArg.IsNotNull(client, nameof(client));
EnsureArg.IsNotNull(configuration, nameof(configuration));
EnsureArg.IsNotNull(namedBlobContainerConfigurationAccessor, nameof(namedBlobContainerConfigurationAccessor));
EnsureArg.IsNotNullOrWhiteSpace(containerConfigurationName, nameof(containerConfigurationName));
EnsureArg.IsNotNull(testProvider, nameof(testProvider));
EnsureArg.IsNotNull(logger, nameof(logger));
_client = client;
_configuration = configuration;
_blobContainerConfiguration = namedBlobContainerConfigurationAccessor.Get(containerConfigurationName);
_testProvider = testProvider;
_logger = logger;
}
private static BlobContainerConfiguration V3ConfigurationFromLegacy(
ITenant tenant,
string?containerName,
LegacyV2BlobStorageConfiguration legacyConfiguration)
{
BlobContainerConfiguration v3Configuration = LegacyConfigurationConverter.FromV2ToV3(legacyConfiguration);
if (legacyConfiguration.Container is not null)
{
v3Configuration = v3Configuration with
{
Container = string.IsNullOrWhiteSpace(legacyConfiguration.Container)
? containerName is null ? null : AzureStorageBlobContainerNaming.HashAndEncodeBlobContainerName(containerName)
: AzureStorageBlobContainerNaming.HashAndEncodeBlobContainerName(
legacyConfiguration.DisableTenantIdPrefix
? legacyConfiguration.Container
: AzureStorageBlobTenantedContainerNaming.GetTenantedLogicalBlobContainerNameFor(tenant, legacyConfiguration.Container)),
};
}
return(AddContainerNameIfNotInConfig(v3Configuration, containerName));
}
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);
}
public static AliyunBlobProviderConfiguration GetAliyunConfiguration(
this BlobContainerConfiguration containerConfiguration)
{
return(new AliyunBlobProviderConfiguration(containerConfiguration));
}
public static AzureBlobProviderConfiguration GetAzureConfiguration(
this BlobContainerConfiguration containerConfiguration)
{
return(new AzureBlobProviderConfiguration(containerConfiguration));
}
protected virtual IOss GetOssClient(BlobContainerConfiguration blobContainerConfiguration)
{
var aliyunConfig = blobContainerConfiguration.GetAliyunConfiguration();
return(OssClientFactory.Create(aliyunConfig));
}
public static MyCustomBlobProviderConfiguration GetMyCustomBlobProviderConfiguration(
this BlobContainerConfiguration containerConfiguration)
{
return(new MyCustomBlobProviderConfiguration(containerConfiguration));
}
public static FileSystemBlobProviderConfiguration GetFileSystemConfiguration(
this BlobContainerConfiguration containerConfiguration)
{
return(new FileSystemBlobProviderConfiguration(containerConfiguration));
}
public static AuthorizationHandlerConfiguration GetGeneralAuthorizationConfiguration(
this BlobContainerConfiguration containerConfiguration)
{
return(new AuthorizationHandlerConfiguration(containerConfiguration));
}
public static MinioBlobProviderConfiguration GetMinioConfiguration(
this BlobContainerConfiguration containerConfiguration)
{
return(new MinioBlobProviderConfiguration(containerConfiguration));
}
/// <inheritdoc />
public async Task OpenBlobClientAsync(BlobServiceClient client, BlobDataStoreConfiguration configuration, BlobContainerConfiguration blobContainerConfiguration)
{
EnsureArg.IsNotNull(client, nameof(client));
EnsureArg.IsNotNull(configuration, nameof(configuration));
EnsureArg.IsNotNull(blobContainerConfiguration, nameof(blobContainerConfiguration));
_logger.LogInformation("Opening blob client connection to container {containerName}", blobContainerConfiguration.ContainerName);
try
{
await _testProvider.PerformTestAsync(client, configuration, blobContainerConfiguration);
_logger.LogInformation("Established blob client connection to container {containerName}", blobContainerConfiguration.ContainerName);
}
catch (Exception e)
{
_logger.LogCritical(e, "Failed to connect to blob client container {containerName}", blobContainerConfiguration.ContainerName);
throw;
}
}
public static T GetConfiguration <T>(
[NotNull] this BlobContainerConfiguration containerConfiguration,
[NotNull] string name)
{
return((T)containerConfiguration.GetConfiguration(name));
}
public static BlobContainerConfiguration UseDatabase(
this BlobContainerConfiguration containerConfiguration)
{
containerConfiguration.ProviderType = typeof(DatabaseBlobProvider);
return(containerConfiguration);
}
public BlobContainerConfiguration(BlobContainerConfiguration fallbackConfiguration = null)
{
NamingNormalizers = new TypeList <IBlobNamingNormalizer>();
_fallbackConfiguration = fallbackConfiguration;
_properties = new Dictionary <string, object>();
}
/// <inheritdoc/>
public async ValueTask <BlobContainerConfiguration?> MigrateToV3Async(
ITenant tenant,
string v2ConfigurationKey,
string v3ConfigurationKey,
IEnumerable <string>?containerNames,
BlobClientOptions?blobClientOptions,
CancellationToken cancellationToken)
{
if (tenant.Properties.TryGet(v3ConfigurationKey, out BlobContainerConfiguration _))
{
return(null);
}
if (!tenant.Properties.TryGet(v2ConfigurationKey, out LegacyV2BlobStorageConfiguration legacyConfiguration))
{
throw new InvalidOperationException("Tenant did not contain blob storage configuration under specified v2 or v3 keys");
}
if (containerNames == null)
{
if (legacyConfiguration.Container is string containerNameFromConfig)
{
containerNames = new[] { containerNameFromConfig };
}
else
{
throw new InvalidOperationException($"When the configuration does not specify a Container, you must supply a non-null {nameof(containerNames)}");
}
}
string?logicalContainerName = null;
int containerCount = 0;
foreach (string rawContainerName in containerNames)
{
containerCount += 1;
logicalContainerName = rawContainerName;
// BlobContainerConfiguration thisConfig = GetConfigForContainer(tenant, rawContainerName, v3Configuration);
BlobContainerConfiguration thisConfig = V3ConfigurationFromLegacy(tenant, rawContainerName, legacyConfiguration);
PublicAccessType publicAccessType = legacyConfiguration.AccessType switch
{
LegacyV2BlobContainerPublicAccessType.Blob => PublicAccessType.Blob,
LegacyV2BlobContainerPublicAccessType.Container => PublicAccessType.BlobContainer,
_ => PublicAccessType.None,
};
BlobContainerClient result = await this.blobContainerSource.GetStorageContextAsync(
thisConfig,
blobClientOptions,
cancellationToken)
.ConfigureAwait(false);
await result.CreateIfNotExistsAsync(
publicAccessType,
cancellationToken : cancellationToken)
.ConfigureAwait(false);
}
// In cases where the legacy configuration had no Container property, and we were
// passed a containerNames containing exactly one name, we can set the Container
// in the V3 config. But if there were multiple logical container names, we don't
// want to set the Container in the V3 config because the application is likely
// plugging in specific container names at runtime.
if (containerCount > 1)
{
logicalContainerName = null;
}
return(V3ConfigurationFromLegacy(tenant, logicalContainerName, legacyConfiguration));
}
public static TencentCloudBlobProviderConfiguration GetTencentCloudConfiguration(
this BlobContainerConfiguration containerConfiguration)
{
return(new TencentCloudBlobProviderConfiguration(containerConfiguration));
}
public static ImageProcessHandlerConfiguration GetImageResizeConfiguration(
this BlobContainerConfiguration containerConfiguration)
{
return(new ImageProcessHandlerConfiguration(containerConfiguration));
}
public static FileTypeCheckHandlerConfiguration GetFileTypeCheckConfiguration(
this BlobContainerConfiguration containerConfiguration)
{
return(new FileTypeCheckHandlerConfiguration(containerConfiguration));
}
public async Task PerformTestAsync(BlobServiceClient client, BlobDataStoreConfiguration configuration, BlobContainerConfiguration blobContainerConfiguration, CancellationToken cancellationToken = default)
{
EnsureArg.IsNotNull(client, nameof(client));
EnsureArg.IsNotNull(configuration, nameof(configuration));
EnsureArg.IsNotNull(blobContainerConfiguration, nameof(blobContainerConfiguration));
BlobContainerClient blobContainer = client.GetBlobContainerClient(blobContainerConfiguration.ContainerName);
BlockBlobClient blob = blobContainer.GetBlockBlobClient(TestBlobName);
await blob.UploadAsync(
new MemoryStream(Encoding.UTF8.GetBytes(TestBlobContent)),
new BlobHttpHeaders()
{
ContentType = "text/plain",
});
await DownloadBlobContentAsync(blob, cancellationToken);
}
public static BlobSizeLimitHandlerConfiguration GetBlobSizeLimitConfiguration(
this BlobContainerConfiguration containerConfiguration)
{
return(new BlobSizeLimitHandlerConfiguration(containerConfiguration));
}
