Merge pull request #6897 from abpframework/liangshiwei/blob-patch-1

Normalize ContainerName

framework/src/Volo.Abp.BlobStoring.Aliyun/Volo/Abp/BlobStoring/Aliyun/AliyunBlobProvider.cs

@@ -10,13 +10,16 @@ namespace Volo.Abp.BlobStoring.Aliyun
     {
         protected IOssClientFactory OssClientFactory { get; }
         protected IAliyunBlobNameCalculator AliyunBlobNameCalculator { get; }
+        protected IBlobNormalizeNamingService BlobNormalizeNamingService { get; }
 
         public AliyunBlobProvider(
             IOssClientFactory ossClientFactory,
-            IAliyunBlobNameCalculator aliyunBlobNameCalculator)
+            IAliyunBlobNameCalculator aliyunBlobNameCalculator,
+            IBlobNormalizeNamingService blobNormalizeNamingService)
         {
             OssClientFactory = ossClientFactory;
             AliyunBlobNameCalculator = aliyunBlobNameCalculator;
+            BlobNormalizeNamingService = blobNormalizeNamingService;
         }
 
         protected virtual IOss GetOssClient(BlobContainerConfiguration blobContainerConfiguration)
@@ -88,15 +91,15 @@ namespace Volo.Abp.BlobStoring.Aliyun
             return memoryStream;
         }
 
-        private static string GetContainerName(BlobProviderArgs args)
+        protected virtual string GetContainerName(BlobProviderArgs args)
         {
             var configuration = args.Configuration.GetAliyunConfiguration();
             return configuration.ContainerName.IsNullOrWhiteSpace()
                 ? args.ContainerName
-                : configuration.ContainerName;
+                : BlobNormalizeNamingService.NormalizeContainerName(args.Configuration, configuration.ContainerName);
         }
 
-        private bool BlobExists(IOss ossClient,string containerName, string blobName)
+        protected  virtual bool BlobExists(IOss ossClient,string containerName, string blobName)
         {
             // Make sure Blob Container exists.
             return ossClient.DoesBucketExist(containerName) &&

framework/src/Volo.Abp.BlobStoring.Aliyun/Volo/Abp/BlobStoring/Aliyun/AliyunBlobProviderConfiguration.cs

@@ -82,7 +82,7 @@ namespace Volo.Abp.BlobStoring.Aliyun
         public string ContainerName
         {
             get => _containerConfiguration.GetConfigurationOrDefault<string>(AliyunBlobProviderConfigurationNames.ContainerName);
-            set => _containerConfiguration.SetConfiguration(AliyunBlobProviderConfigurationNames.ContainerName, Check.NotNullOrWhiteSpace(value, nameof(value)));
+            set => _containerConfiguration.SetConfiguration(AliyunBlobProviderConfigurationNames.ContainerName, value);
         }
 
         /// <summary>

framework/src/Volo.Abp.BlobStoring.Aws/Volo/Abp/BlobStoring/Aws/AwsBlobProvider.cs

@@ -12,12 +12,16 @@ namespace Volo.Abp.BlobStoring.Aws
     {
         protected IAwsBlobNameCalculator AwsBlobNameCalculator { get; }
         protected IAmazonS3ClientFactory AmazonS3ClientFactory { get; }
+        protected IBlobNormalizeNamingService BlobNormalizeNamingService { get; }
 
-        public AwsBlobProvider(IAwsBlobNameCalculator awsBlobNameCalculator,
+        public AwsBlobProvider(
-            IAmazonS3ClientFactory amazonS3ClientFactory)
+            IAwsBlobNameCalculator awsBlobNameCalculator,
+            IAmazonS3ClientFactory amazonS3ClientFactory,
+            IBlobNormalizeNamingService blobNormalizeNamingService)
         {
             AwsBlobNameCalculator = awsBlobNameCalculator;
             AmazonS3ClientFactory = amazonS3ClientFactory;
+            BlobNormalizeNamingService = blobNormalizeNamingService;
         }
 
         public override async Task SaveAsync(BlobProviderSaveArgs args)
@@ -111,7 +115,7 @@ namespace Volo.Abp.BlobStoring.Aws
             return await AmazonS3ClientFactory.GetAmazonS3Client(configuration);
         }
 
-        private async Task<bool> BlobExistsAsync(AmazonS3Client amazonS3Client, string containerName, string blobName)
+        protected virtual async Task<bool> BlobExistsAsync(AmazonS3Client amazonS3Client, string containerName, string blobName)
         {
             // Make sure Blob Container exists.
             if (!await AmazonS3Util.DoesS3BucketExistV2Async(amazonS3Client, containerName))
@@ -147,12 +151,12 @@ namespace Volo.Abp.BlobStoring.Aws
             }
         }
 
-        private static string GetContainerName(BlobProviderArgs args)
+        protected virtual string GetContainerName(BlobProviderArgs args)
         {
             var configuration = args.Configuration.GetAwsConfiguration();
             return configuration.ContainerName.IsNullOrWhiteSpace()
                 ? args.ContainerName
-                : configuration.ContainerName;
+                : BlobNormalizeNamingService.NormalizeContainerName(args.Configuration, configuration.ContainerName);
         }
     }
 }

framework/src/Volo.Abp.BlobStoring.Aws/Volo/Abp/BlobStoring/Aws/AwsBlobProviderConfiguration.cs

@@ -82,7 +82,7 @@ namespace Volo.Abp.BlobStoring.Aws
         public string ContainerName
         {
             get => _containerConfiguration.GetConfigurationOrDefault<string>(AwsBlobProviderConfigurationNames.ContainerName);
-            set => _containerConfiguration.SetConfiguration(AwsBlobProviderConfigurationNames.ContainerName, Check.NotNullOrWhiteSpace(value, nameof(value)));
+            set => _containerConfiguration.SetConfiguration(AwsBlobProviderConfigurationNames.ContainerName, value);
         }
 
         /// <summary>

framework/src/Volo.Abp.BlobStoring.Azure/Volo/Abp/BlobStoring/Azure/AzureBlobProvider.cs

@@ -9,10 +9,14 @@ namespace Volo.Abp.BlobStoring.Azure
     public class AzureBlobProvider : BlobProviderBase, ITransientDependency
     {
         protected IAzureBlobNameCalculator AzureBlobNameCalculator { get; }
+        protected IBlobNormalizeNamingService BlobNormalizeNamingService { get; }
 
-        public AzureBlobProvider(IAzureBlobNameCalculator azureBlobNameCalculator)
+        public AzureBlobProvider(
+            IAzureBlobNameCalculator azureBlobNameCalculator,
+            IBlobNormalizeNamingService blobNormalizeNamingService)
         {
             AzureBlobNameCalculator = azureBlobNameCalculator;
+            BlobNormalizeNamingService = blobNormalizeNamingService;
         }
 
         public override async Task SaveAsync(BlobProviderSaveArgs args)
@@ -87,22 +91,22 @@ namespace Volo.Abp.BlobStoring.Azure
             await blobContainerClient.CreateIfNotExistsAsync();
         }
 
-        private async Task<bool> BlobExistsAsync(BlobProviderArgs args, string blobName)
+        protected virtual async Task<bool> BlobExistsAsync(BlobProviderArgs args, string blobName)
         {
             // Make sure Blob Container exists.
             return await ContainerExistsAsync(GetBlobContainerClient(args)) &&
                    (await GetBlobClient(args, blobName).ExistsAsync()).Value;
         }
 
-        private static string GetContainerName(BlobProviderArgs args)
+        protected virtual string GetContainerName(BlobProviderArgs args)
         {
             var configuration = args.Configuration.GetAzureConfiguration();
             return configuration.ContainerName.IsNullOrWhiteSpace()
                 ? args.ContainerName
-                : configuration.ContainerName;
+                : BlobNormalizeNamingService.NormalizeContainerName(args.Configuration, configuration.ContainerName);
         }
 
-        private static async Task<bool> ContainerExistsAsync(BlobContainerClient blobContainerClient)
+        protected virtual async Task<bool> ContainerExistsAsync(BlobContainerClient blobContainerClient)
         {
             return (await blobContainerClient.ExistsAsync()).Value;
         }

framework/src/Volo.Abp.BlobStoring.Azure/Volo/Abp/BlobStoring/Azure/AzureBlobProviderConfiguration.cs

@@ -17,7 +17,7 @@
         public string ContainerName
         {
             get => _containerConfiguration.GetConfigurationOrDefault<string>(AzureBlobProviderConfigurationNames.ContainerName);
-            set => _containerConfiguration.SetConfiguration(AzureBlobProviderConfigurationNames.ContainerName, Check.NotNullOrWhiteSpace(value, nameof(value)));
+            set => _containerConfiguration.SetConfiguration(AzureBlobProviderConfigurationNames.ContainerName, value);
         }
 
         /// <summary>

framework/src/Volo.Abp.BlobStoring.Minio/Volo/Abp/BlobStoring/Minio/MinioBlobContainerConfigurationExtensions.cs

@@ -15,6 +15,7 @@ namespace Volo.Abp.BlobStoring.Minio
             Action<MinioBlobProviderConfiguration> minioConfigureAction)
         {
             containerConfiguration.ProviderType = typeof(MinioBlobProvider);
+            containerConfiguration.NamingNormalizers.TryAdd<MinioBlobNamingNormalizer>();
 
             minioConfigureAction(new MinioBlobProviderConfiguration(containerConfiguration));
 

framework/src/Volo.Abp.BlobStoring.Minio/Volo/Abp/BlobStoring/Minio/MinioBlobProvider.cs

@@ -10,10 +10,14 @@ namespace Volo.Abp.BlobStoring.Minio
     public class MinioBlobProvider : BlobProviderBase, ITransientDependency
     {
         protected IMinioBlobNameCalculator MinioBlobNameCalculator { get; }
+        protected IBlobNormalizeNamingService BlobNormalizeNamingService { get; }
 
-        public MinioBlobProvider(IMinioBlobNameCalculator minioBlobNameCalculator)
+        public MinioBlobProvider(
+            IMinioBlobNameCalculator minioBlobNameCalculator,
+            IBlobNormalizeNamingService blobNormalizeNamingService)
         {
             MinioBlobNameCalculator = minioBlobNameCalculator;
+            BlobNormalizeNamingService = blobNormalizeNamingService;
         }
 
         public override async Task SaveAsync(BlobProviderSaveArgs args)
@@ -108,7 +112,7 @@ namespace Volo.Abp.BlobStoring.Minio
             }
         }
 
-        private async Task<bool> BlobExistsAsync(MinioClient client, string containerName , string blobName)
+        protected virtual async Task<bool> BlobExistsAsync(MinioClient client, string containerName , string blobName)
         {
             // Make sure Blob Container exists.
             if (await client.BucketExistsAsync(containerName))
@@ -133,13 +137,13 @@ namespace Volo.Abp.BlobStoring.Minio
             return false;
         }
 
-        private static string GetContainerName(BlobProviderArgs args)
+        protected virtual string GetContainerName(BlobProviderArgs args)
         {
             var configuration = args.Configuration.GetMinioConfiguration();
 
             return configuration.BucketName.IsNullOrWhiteSpace()
                 ? args.ContainerName
-                : configuration.BucketName;
+                : BlobNormalizeNamingService.NormalizeContainerName(args.Configuration, configuration.BucketName);
         }
     }
 }

framework/src/Volo.Abp.BlobStoring.Minio/Volo/Abp/BlobStoring/Minio/MinioBlobProviderConfiguration.cs

@@ -5,7 +5,7 @@
         public string BucketName
         {
             get => _containerConfiguration.GetConfigurationOrDefault<string>(MinioBlobProviderConfigurationNames.BucketName);
-            set => _containerConfiguration.SetConfiguration(MinioBlobProviderConfigurationNames.BucketName, Check.NotNullOrWhiteSpace(value, nameof(value)));
+            set => _containerConfiguration.SetConfiguration(MinioBlobProviderConfigurationNames.BucketName, value);
         }
 
         /// <summary>

framework/src/Volo.Abp.BlobStoring/Volo/Abp/BlobStoring/BlobContainer.cs

@@ -1,9 +1,7 @@
 using System;
 using System.IO;
-using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
-using Microsoft.Extensions.DependencyInjection;
 using Volo.Abp.MultiTenancy;
 using Volo.Abp.Threading;
 
@@ -88,12 +86,15 @@ namespace Volo.Abp.BlobStoring
 
         protected IServiceProvider ServiceProvider { get; }
 
+        protected IBlobNormalizeNamingService BlobNormalizeNamingService { get; }
+
         public BlobContainer(
             string containerName,
             BlobContainerConfiguration configuration,
             IBlobProvider provider,
             ICurrentTenant currentTenant,
             ICancellationTokenProvider cancellationTokenProvider,
+            IBlobNormalizeNamingService blobNormalizeNamingService,
             IServiceProvider serviceProvider)
         {
             ContainerName = containerName;
@@ -101,6 +102,7 @@ namespace Volo.Abp.BlobStoring
             Provider = provider;
             CurrentTenant = currentTenant;
             CancellationTokenProvider = cancellationTokenProvider;
+            BlobNormalizeNamingService = blobNormalizeNamingService;
             ServiceProvider = serviceProvider;
         }
 
@@ -112,13 +114,13 @@ namespace Volo.Abp.BlobStoring
         {
             using (CurrentTenant.Change(GetTenantIdOrNull()))
             {
-                var (normalizedContainerName, normalizedBlobName) = NormalizeNaming(ContainerName, name);
+                var blobNormalizeNaming = BlobNormalizeNamingService.NormalizeNaming(Configuration, ContainerName, name);
 
                 await Provider.SaveAsync(
                     new BlobProviderSaveArgs(
-                        normalizedContainerName,
+                        blobNormalizeNaming.ContainerName,
                         Configuration,
-                        normalizedBlobName,
+                        blobNormalizeNaming.BlobName,
                         stream,
                         overrideExisting,
                         CancellationTokenProvider.FallbackToProvider(cancellationToken)
@@ -133,14 +135,14 @@ namespace Volo.Abp.BlobStoring
         {
             using (CurrentTenant.Change(GetTenantIdOrNull()))
             {
-                var (normalizedContainerName, normalizedBlobName) =
+                var blobNormalizeNaming =
-                    NormalizeNaming(ContainerName, name);
+                    BlobNormalizeNamingService.NormalizeNaming(Configuration, ContainerName, name);
 
                 return await Provider.DeleteAsync(
                     new BlobProviderDeleteArgs(
-                        normalizedContainerName,
+                        blobNormalizeNaming.ContainerName,
                         Configuration,
-                        normalizedBlobName,
+                        blobNormalizeNaming.BlobName,
                         CancellationTokenProvider.FallbackToProvider(cancellationToken)
                     )
                 );
@@ -153,14 +155,14 @@ namespace Volo.Abp.BlobStoring
         {
             using (CurrentTenant.Change(GetTenantIdOrNull()))
             {
-                var (normalizedContainerName, normalizedBlobName) =
+                var blobNormalizeNaming =
-                    NormalizeNaming(ContainerName, name);
+                    BlobNormalizeNamingService.NormalizeNaming(Configuration, ContainerName, name);
 
                 return await Provider.ExistsAsync(
                     new BlobProviderExistsArgs(
-                        normalizedContainerName,
+                        blobNormalizeNaming.ContainerName,
                         Configuration,
-                        normalizedBlobName,
+                        blobNormalizeNaming.BlobName,
                         CancellationTokenProvider.FallbackToProvider(cancellationToken)
                     )
                 );
@@ -189,14 +191,14 @@ namespace Volo.Abp.BlobStoring
         {
             using (CurrentTenant.Change(GetTenantIdOrNull()))
             {
-                var (normalizedContainerName, normalizedBlobName) =
+                var blobNormalizeNaming =
-                    NormalizeNaming(ContainerName, name);
+                    BlobNormalizeNamingService.NormalizeNaming(Configuration, ContainerName, name);
 
                 return await Provider.GetOrNullAsync(
                     new BlobProviderGetArgs(
-                        normalizedContainerName,
+                        blobNormalizeNaming.ContainerName,
                         Configuration,
-                        normalizedBlobName,
+                        blobNormalizeNaming.BlobName,
                         CancellationTokenProvider.FallbackToProvider(cancellationToken)
                     )
                 );
@@ -212,28 +214,5 @@ namespace Volo.Abp.BlobStoring
 
             return CurrentTenant.Id;
         }
-        
-        protected virtual (string, string) NormalizeNaming(string containerName,  string blobName)
-        {
-            if (!Configuration.NamingNormalizers.Any())
-            {
-                return (containerName, blobName);
-            }
-
-            using (var scope = ServiceProvider.CreateScope())
-            {
-                foreach (var normalizerType in Configuration.NamingNormalizers)
-                {
-                    var normalizer = scope.ServiceProvider
-                        .GetRequiredService(normalizerType)
-                        .As<IBlobNamingNormalizer>();
-
-                    containerName = normalizer.NormalizeContainerName(containerName);
-                    blobName = normalizer.NormalizeBlobName(blobName);
-                }
-
-                return (containerName, blobName);
-            }
-        }
     }
 }

framework/src/Volo.Abp.BlobStoring/Volo/Abp/BlobStoring/BlobContainerFactory.cs

@@ -17,18 +17,22 @@ namespace Volo.Abp.BlobStoring
 
         protected IServiceProvider ServiceProvider { get; }
 
+        protected IBlobNormalizeNamingService BlobNormalizeNamingService { get; }
+
         public BlobContainerFactory(
             IBlobContainerConfigurationProvider configurationProvider,
             ICurrentTenant currentTenant,
             ICancellationTokenProvider cancellationTokenProvider,
             IBlobProviderSelector providerSelector,
-            IServiceProvider serviceProvider)
+            IServiceProvider serviceProvider,
+            IBlobNormalizeNamingService blobNormalizeNamingService)
         {
             ConfigurationProvider = configurationProvider;
             CurrentTenant = currentTenant;
             CancellationTokenProvider = cancellationTokenProvider;
             ProviderSelector = providerSelector;
             ServiceProvider = serviceProvider;
+            BlobNormalizeNamingService = blobNormalizeNamingService;
         }
 
         public virtual IBlobContainer Create(string name)
@@ -41,6 +45,7 @@ namespace Volo.Abp.BlobStoring
                 ProviderSelector.Get(name),
                 CurrentTenant,
                 CancellationTokenProvider,
+                BlobNormalizeNamingService,
                 ServiceProvider
             );
         }

framework/src/Volo.Abp.BlobStoring/Volo/Abp/BlobStoring/BlobNormalizeNaming.cs

@@ -0,0 +1,15 @@
+namespace Volo.Abp.BlobStoring
+{
+    public class BlobNormalizeNaming
+    {
+        public string ContainerName { get; }
+
+        public string BlobName { get; }
+
+        public BlobNormalizeNaming(string containerName, string blobName)
+        {
+            ContainerName = containerName;
+            BlobName = blobName;
+        }
+    }
+}

framework/src/Volo.Abp.BlobStoring/Volo/Abp/BlobStoring/BlobNormalizeNamingService.cs

@@ -0,0 +1,64 @@
+using System;
+using System.Linq;
+using Microsoft.Extensions.DependencyInjection;
+using Volo.Abp.DependencyInjection;
+
+namespace Volo.Abp.BlobStoring
+{
+    public class BlobNormalizeNamingService : IBlobNormalizeNamingService, ITransientDependency
+    {
+        protected IServiceProvider ServiceProvider { get; }
+
+        public BlobNormalizeNamingService(IServiceProvider serviceProvider)
+        {
+            ServiceProvider = serviceProvider;
+        }
+
+        public BlobNormalizeNaming NormalizeNaming(
+            BlobContainerConfiguration configuration,
+            string containerName,
+            string blobName)
+        {
+
+            if (!configuration.NamingNormalizers.Any())
+            {
+                return new BlobNormalizeNaming(containerName, blobName);
+            }
+
+            using (var scope = ServiceProvider.CreateScope())
+            {
+                foreach (var normalizerType in configuration.NamingNormalizers)
+                {
+                    var normalizer = scope.ServiceProvider
+                        .GetRequiredService(normalizerType)
+                        .As<IBlobNamingNormalizer>();
+
+                    containerName = containerName.IsNullOrWhiteSpace()? containerName: normalizer.NormalizeContainerName(containerName);
+                    blobName = blobName.IsNullOrWhiteSpace()? blobName: normalizer.NormalizeBlobName(blobName);
+                }
+
+                return new BlobNormalizeNaming(containerName, blobName);
+            }
+        }
+
+        public string NormalizeContainerName(BlobContainerConfiguration configuration, string containerName)
+        {
+            if (!configuration.NamingNormalizers.Any())
+            {
+                return containerName;
+            }
+
+            return NormalizeNaming(configuration, containerName, null).ContainerName;
+        }
+
+        public string NormalizeBlobName(BlobContainerConfiguration configuration, string blobName)
+        {
+            if (!configuration.NamingNormalizers.Any())
+            {
+                return blobName;
+            }
+
+            return NormalizeNaming(configuration, null, blobName).BlobName;
+        }
+    }
+}

framework/src/Volo.Abp.BlobStoring/Volo/Abp/BlobStoring/BlobProviderBase.cs

@@ -13,4 +13,4 @@ namespace Volo.Abp.BlobStoring
 
         public abstract Task<Stream> GetOrNullAsync(BlobProviderGetArgs args);
     }
-}
+}

framework/src/Volo.Abp.BlobStoring/Volo/Abp/BlobStoring/IBlobNormalizeNamingService.cs

@@ -0,0 +1,11 @@
+namespace Volo.Abp.BlobStoring
+{
+    public interface IBlobNormalizeNamingService
+    {
+        BlobNormalizeNaming NormalizeNaming(BlobContainerConfiguration configuration, string containerName, string blobName);
+
+        string NormalizeContainerName(BlobContainerConfiguration configuration, string containerName);
+
+        string NormalizeBlobName(BlobContainerConfiguration configuration, string blobName);
+    }
+}