Tenant removal (Lombiq Technologies: OCORE-96)

src/OrchardCore.Cms.Web/appsettings.json

@@ -60,6 +60,7 @@
     //  },
     //  "BasePath": "/media",
     //  "CreateBucket": true,
+    //  "RemoveBucket": true, // Whether the 'Bucket' is deleted if the tenant is removed, false by default.
     //  "BucketName": ""
     //},
     // See https://docs.orchardcore.net/en/latest/docs/reference/modules/Media.Azure/#configuration to configure media storage in Azure Blob Storage.
@@ -69,6 +70,7 @@
     //  "ContainerName": "somecontainer", // Set to the Azure Blob container name. Templatable, refer docs.
     //  "BasePath": "some/base/path", // Optionally, set to a path to store media in a subdirectory inside your container. Templatable, refer docs.
     //  "CreateContainer": true // Activates an event to create the container if it does not already exist.
+    //  "RemoveContainer": true // Whether the 'Container' is deleted if the tenant is removed, false by default.
     //},
     // See https://stackexchange.github.io/StackExchange.Redis/Configuration.html
     //"OrchardCore_Redis": {
@@ -235,6 +237,9 @@
     //},
     //"OrchardCore_Localization_CultureOptions": {
     //  "IgnoreSystemSettings": true
+    //},
+    //"OrchardCore_Tenants": {
+    //  "TenantRemovalAllowed": true // Whether tenant removal is allowed, false by default.
     //}
   }
 }

src/OrchardCore.Modules/OrchardCore.Media.AmazonS3/AwsStorageOptionsExtension.cs

@@ -1,10 +1,8 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.ComponentModel.DataAnnotations;
-using Amazon;
 using Amazon.Extensions.NETCore.Setup;
 using Amazon.Runtime;
-using Amazon.Runtime.CredentialManagement;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Logging;
 using OrchardCore.Environment.Shell.Configuration;
@@ -42,6 +40,7 @@ public static AwsStorageOptions BindConfiguration(this AwsStorageOptions options
         options.BucketName = section.GetValue(nameof(options.BucketName), String.Empty);
         options.BasePath = section.GetValue(nameof(options.BasePath), String.Empty);
         options.CreateBucket = section.GetValue(nameof(options.CreateBucket), false);
+        options.RemoveBucket = section.GetValue(nameof(options.RemoveBucket), false);
 
         try
         {

src/OrchardCore.Modules/OrchardCore.Media.AmazonS3/MediaS3BucketTenantEvents.cs

@@ -0,0 +1,134 @@
+using System;
+using System.Threading.Tasks;
+using Amazon.S3;
+using Amazon.S3.Model;
+using Amazon.S3.Util;
+using Microsoft.Extensions.Localization;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+using OrchardCore.Environment.Shell;
+using OrchardCore.Environment.Shell.Removing;
+using OrchardCore.FileStorage.AmazonS3;
+using OrchardCore.Modules;
+
+namespace OrchardCore.Media.AmazonS3;
+
+public class MediaS3BucketTenantEvents : ModularTenantEvents
+{
+    private readonly ShellSettings _shellSettings;
+    private readonly AwsStorageOptions _options;
+    private readonly IAmazonS3 _amazonS3Client;
+    private readonly IStringLocalizer S;
+    private readonly ILogger _logger;
+
+    public MediaS3BucketTenantEvents(
+        ShellSettings shellSettings,
+        IAmazonS3 amazonS3Client,
+        IOptions<AwsStorageOptions> options,
+        IStringLocalizer<MediaS3BucketTenantEvents> localizer,
+        ILogger<MediaS3BucketTenantEvents> logger)
+    {
+        _shellSettings = shellSettings;
+        _amazonS3Client = amazonS3Client;
+        _options = options.Value;
+        S = localizer;
+        _logger = logger;
+    }
+
+    public override async Task ActivatingAsync()
+    {
+        if (!_options.CreateBucket ||
+            _shellSettings.State == Environment.Shell.Models.TenantState.Uninitialized ||
+            String.IsNullOrEmpty(_options.BucketName))
+        {
+            return;
+        }
+
+        _logger.LogDebug("Testing Amazon S3 Bucket {BucketName} existence", _options.BucketName);
+
+        try
+        {
+            var bucketExists = await AmazonS3Util.DoesS3BucketExistV2Async(_amazonS3Client, _options.BucketName);
+            if (bucketExists)
+            {
+                _logger.LogInformation("Amazon S3 Bucket {BucketName} already exists.", _options.BucketName);
+
+                return;
+            }
+
+            var bucketRequest = new PutBucketRequest
+            {
+                BucketName = _options.BucketName,
+                UseClientRegion = true
+            };
+
+            // Trying to create bucket.
+            var response = await _amazonS3Client.PutBucketAsync(bucketRequest);
+
+            if (!response.IsSuccessful())
+            {
+                _logger.LogError("Unable to create Amazon S3 Bucket {BucketName}", _options.BucketName);
+
+                return;
+            }
+
+            // Blocking public access for the newly created bucket.
+            var blockConfiguration = new PublicAccessBlockConfiguration
+            {
+                BlockPublicAcls = true,
+                BlockPublicPolicy = true,
+                IgnorePublicAcls = true,
+                RestrictPublicBuckets = true
+            };
+
+            await _amazonS3Client.PutPublicAccessBlockAsync(new PutPublicAccessBlockRequest
+            {
+                PublicAccessBlockConfiguration = blockConfiguration,
+                BucketName = _options.BucketName
+            });
+
+            _logger.LogDebug("Amazon S3 Bucket {BucketName} created.", _options.BucketName);
+        }
+        catch (AmazonS3Exception ex)
+        {
+            _logger.LogError(ex, "Unable to create Amazon S3 Bucket.");
+        }
+    }
+
+    public override async Task RemovingAsync(ShellRemovingContext context)
+    {
+        if (!_options.RemoveBucket || String.IsNullOrEmpty(_options.BucketName))
+        {
+            return;
+        }
+
+        try
+        {
+            var bucketExists = await AmazonS3Util.DoesS3BucketExistV2Async(_amazonS3Client, _options.BucketName);
+            if (!bucketExists)
+            {
+                return;
+            }
+
+            var bucketRequest = new DeleteBucketRequest
+            {
+                BucketName = _options.BucketName,
+                UseClientRegion = true
+            };
+
+            // Trying to delete bucket.
+            var response = await _amazonS3Client.DeleteBucketAsync(bucketRequest);
+            if (!response.IsSuccessful())
+            {
+                _logger.LogError("Failed to remove the Amazon S3 Bucket {BucketName}", _options.BucketName);
+                context.ErrorMessage = S["Failed to remove the Amazon S3 Bucket '{0}'.", _options.BucketName];
+            }
+        }
+        catch (AmazonS3Exception ex)
+        {
+            _logger.LogError(ex, "Failed to remove the Amazon S3 Bucket {BucketName}", _options.BucketName);
+            context.ErrorMessage = S["Failed to remove the Amazon S3 Bucket '{0}'.", _options.BucketName];
+            context.Error = ex;
+        }
+    }
+}

src/OrchardCore.Modules/OrchardCore.Media.AmazonS3/Startup.cs

@@ -69,16 +69,15 @@ public override void ConfigureServices(IServiceCollection services)
                 var shellSettings = serviceProvider.GetRequiredService<ShellSettings>();
                 var logger = serviceProvider.GetRequiredService<ILogger<DefaultMediaFileStoreCacheFileProvider>>();
 
-                var mediaCachePath = GetMediaCachePath(hostingEnvironment,
-                    DefaultMediaFileStoreCacheFileProvider.AssetsCachePath, shellSettings);
+                var mediaCachePath = GetMediaCachePath(
+                    hostingEnvironment, shellSettings, DefaultMediaFileStoreCacheFileProvider.AssetsCachePath);
 
                 if (!Directory.Exists(mediaCachePath))
                 {
                     Directory.CreateDirectory(mediaCachePath);
                 }
 
-                return new DefaultMediaFileStoreCacheFileProvider(logger, mediaOptions.AssetsRequestPath,
-                    mediaCachePath);
+                return new DefaultMediaFileStoreCacheFileProvider(logger, mediaOptions.AssetsRequestPath, mediaCachePath);
             });
 
             // Replace the default media file provider with the media cache file provider.
@@ -103,15 +102,13 @@ public override void ConfigureServices(IServiceCollection services)
                 var amazonS3Client = serviceProvider.GetService<IAmazonS3>();
 
                 var fileStore = new AwsFileStore(clock, storeOptions, amazonS3Client);
-
-                var mediaUrlBase =
-                    $"/{fileStore.Combine(shellSettings.RequestUrlPrefix, mediaOptions.AssetsRequestPath)}";
+                var mediaUrlBase = $"/{fileStore.Combine(shellSettings.RequestUrlPrefix, mediaOptions.AssetsRequestPath)}";
 
                 var originalPathBase = serviceProvider.GetRequiredService<IHttpContextAccessor>().HttpContext
                     ?.Features.Get<ShellContextFeature>()
                     ?.OriginalPathBase;
 
-                if (originalPathBase.HasValue && !String.IsNullOrWhiteSpace(originalPathBase.Value))
+                if (originalPathBase.HasValue)
                 {
                     mediaUrlBase = fileStore.Combine(originalPathBase.Value, mediaUrlBase);
                 }
@@ -126,12 +123,10 @@ public override void ConfigureServices(IServiceCollection services)
 
             services.AddSingleton<IMediaEventHandler, DefaultMediaFileStoreCacheEventHandler>();
 
-            services.AddScoped<IModularTenantEvents, CreateMediaS3BucketEvent>();
+            services.AddScoped<IModularTenantEvents, MediaS3BucketTenantEvents>();
         }
     }
 
-    private string GetMediaCachePath(IWebHostEnvironment hostingEnvironment,
-        string assetsPath, ShellSettings shellSettings)
-        => PathExtensions.Combine(hostingEnvironment.WebRootPath,
-            assetsPath, shellSettings.Name);
+    private static string GetMediaCachePath(IWebHostEnvironment hostingEnvironment, ShellSettings shellSettings, string assetsPath)
+        => PathExtensions.Combine(hostingEnvironment.WebRootPath, shellSettings.Name, assetsPath);
 }