Added S3 support and healthcheck

MarkGentHe1 · MarkGentHe1 · commit 91d33f02da53 · 2025-09-19T16:07:22.000+01:00
diff --git a/compose/start-localstack.sh b/compose/start-localstack.sh
@@ -8,6 +8,23 @@ export AWS_SECRET_ACCESS_KEY=test
 
 set -e
 
+# S3 buckets
+echo "Bootstrapping S3 setup..."
+
+## Create 'test-comparison-reports-bucket' Bucket
+existing_bucket=$(awslocal s3api list-buckets \
+  --query "Buckets[?Name=='test-comparison-reports-bucket'].Name" \
+  --output text)
+
+if [ "$existing_bucket" == "test-comparison-reports-bucket" ]; then
+  echo "S3 bucket already exists: test-comparison-reports-bucket"
+else
+  awslocal s3api create-bucket --bucket test-comparison-reports-bucket --region eu-west-2 \
+    --create-bucket-configuration LocationConstraint=eu-west-2 \
+    --endpoint-url=http://localhost:4566
+  echo "S3 bucket created: test-comparison-reports-bucket"
+fi
+
 echo "Bootstrapping SQS setup..."
 
 # Create SQS resources
diff --git a/docker-compose.override.yml b/docker-compose.override.yml
@@ -7,6 +7,7 @@ services:
       - ASPNETCORE_HTTP_PORTS=8080
       - AWS__ServiceURL=http://localstack-emulator:4566
       - Mongo__DatabaseUri=mongodb://mongodb:27017
+      - StorageConfiguration__ComparisonReportsStorage__BucketName=test-comparison-reports-bucket
       - QueueConsumerOptions__IntakeEventQueueOptions__QueueUrl=http://sqs.eu-west-2.127.0.0.1:4566/000000000000/ls_keeper_data_intake_queue
     ports:
       - "8080"
diff --git a/src/KeeperData.Api/Program.cs b/src/KeeperData.Api/Program.cs
@@ -3,7 +3,6 @@
 using KeeperData.Infrastructure.Telemetry.Logging;
 using Serilog;
 using System.Diagnostics.CodeAnalysis;
-using System.Text.Json.Serialization;
 
 var app = CreateWebApplication(args);
 await app.RunAsync();
diff --git a/src/KeeperData.Api/Setup/ServiceCollectionExtensions.cs b/src/KeeperData.Api/Setup/ServiceCollectionExtensions.cs
@@ -2,6 +2,7 @@
 using KeeperData.Application.Setup;
 using KeeperData.Infrastructure.Database.Setup;
 using KeeperData.Infrastructure.Messaging.Setup;
+using KeeperData.Infrastructure.Storage.Setup;
 using System.Text.Json.Serialization;
 
 namespace KeeperData.Api.Setup;
@@ -39,7 +40,7 @@ public static void ConfigureApi(this IServiceCollection services, IConfiguration
 
         services.AddMessagingDependencies(configuration);
 
-        // services.AddStorageDependencies(configuration);
+        services.AddStorageDependencies(configuration);
     }
 
     private static void ConfigureHealthChecks(this IServiceCollection services)
diff --git a/src/KeeperData.Api/appsettings.json b/src/KeeperData.Api/appsettings.json
@@ -16,6 +16,12 @@
       "Disabled": false
     }
   },
+  "StorageConfiguration": {
+    "ComparisonReportsStorage": {
+      "HealthcheckEnabled": true,
+      "BucketName": "Set in cdp-app-config (or for local development using docker-compose.override.yml)"
+    }
+  },
   "AllowedHosts": "*",
   "TraceHeader": "x-cdp-request-id",
   "Serilog": {
diff --git a/src/KeeperData.Core/Storage/IStorageClient.cs b/src/KeeperData.Core/Storage/IStorageClient.cs
@@ -0,0 +1,6 @@
+namespace KeeperData.Core.Storage;
+
+public interface IStorageClient
+{
+    string ClientName { get; }
+}
diff --git a/src/KeeperData.Core/Storage/IStorageReader.cs b/src/KeeperData.Core/Storage/IStorageReader.cs
@@ -0,0 +1,5 @@
+namespace KeeperData.Core.Storage;
+
+public interface IStorageReader<T> where T : IStorageClient, new()
+{
+}
diff --git a/src/KeeperData.Infrastructure/Storage/Clients/ComparisonReportsStorageClient.cs b/src/KeeperData.Infrastructure/Storage/Clients/ComparisonReportsStorageClient.cs
@@ -0,0 +1,8 @@
+using KeeperData.Core.Storage;
+
+namespace KeeperData.Infrastructure.Storage.Clients;
+
+public class ComparisonReportsStorageClient : IStorageClient
+{
+    public string ClientName => GetType().Name;
+}
diff --git a/src/KeeperData.Infrastructure/Storage/Configuration/StorageConfiguration.cs b/src/KeeperData.Infrastructure/Storage/Configuration/StorageConfiguration.cs
@@ -0,0 +1,6 @@
+namespace KeeperData.Infrastructure.Storage.Configuration;
+
+public record StorageConfiguration
+{
+    public StorageConfigurationDetails ComparisonReportsStorage { get; init; } = new();
+}
diff --git a/src/KeeperData.Infrastructure/Storage/Configuration/StorageConfigurationDetails.cs b/src/KeeperData.Infrastructure/Storage/Configuration/StorageConfigurationDetails.cs
@@ -0,0 +1,7 @@
+namespace KeeperData.Infrastructure.Storage.Configuration;
+
+public record StorageConfigurationDetails
+{
+    public bool HealthcheckEnabled { get; init; }
+    public string BucketName { get; init; } = string.Empty;
+}
diff --git a/src/KeeperData.Infrastructure/Storage/Factories/IS3ClientFactory.cs b/src/KeeperData.Infrastructure/Storage/Factories/IS3ClientFactory.cs
@@ -0,0 +1,30 @@
+using Amazon.S3;
+using KeeperData.Core.Storage;
+
+namespace KeeperData.Infrastructure.Storage.Factories;
+
+public interface IS3ClientFactory
+{
+    IAmazonS3 GetClient<T>()
+        where T : IStorageClient, new();
+
+    IAmazonS3 GetClient(string clientName);
+
+    string GetClientBucketName<T>()
+        where T : IStorageClient, new();
+
+    string GetClientBucketName(string clientName);
+
+    IEnumerable<string> GetRegisteredClientNames();
+
+    bool HasStorageClient(string storageClientName);
+
+    void AddClient<T>(string defaultBucketName, AmazonS3Config amazonS3Config)
+        where T : IStorageClient, new();
+
+    void AddClientWithCredentials<T>(string defaultBucketName, string accessKeyRef, string secretKeyRef, AmazonS3Config amazonS3Config)
+        where T : IStorageClient, new();
+
+    void RegisterMockClient<T>(string bucketName, IAmazonS3 mockClient)
+        where T : IStorageClient, new();
+}
diff --git a/src/KeeperData.Infrastructure/Storage/Factories/Implementations/S3ClientFactory.cs b/src/KeeperData.Infrastructure/Storage/Factories/Implementations/S3ClientFactory.cs
@@ -0,0 +1,96 @@
+using Amazon.S3;
+using KeeperData.Core.Storage;
+
+namespace KeeperData.Infrastructure.Storage.Factories.Implementations;
+
+public class S3ClientFactory : IS3ClientFactory
+{
+    private readonly Dictionary<string, (IAmazonS3 Client, string BucketName)> _clients = [];
+
+    public IAmazonS3 GetClient<T>()
+        where T : IStorageClient, new()
+    {
+        var instance = new T();
+        var storageClientName = instance.ClientName;
+
+        if (!_clients.TryGetValue(storageClientName, out var client))
+            throw new KeyNotFoundException($"No S3 client registered for name '{storageClientName}'");
+
+        return client.Client;
+    }
+
+    public IAmazonS3 GetClient(string clientName)
+    {
+        if (!_clients.TryGetValue(clientName, out var client))
+            throw new KeyNotFoundException($"No S3 client registered for name '{clientName}'");
+
+        return client.Client;
+    }
+
+    public string GetClientBucketName<T>()
+        where T : IStorageClient, new()
+    {
+        var instance = new T();
+        var storageClientName = instance.ClientName;
+
+        if (!_clients.TryGetValue(storageClientName, out var client))
+            throw new KeyNotFoundException($"No S3 client registered for name '{storageClientName}'");
+
+        return client.BucketName;
+    }
+
+    public string GetClientBucketName(string clientName)
+    {
+        if (!_clients.TryGetValue(clientName, out var client))
+            throw new KeyNotFoundException($"No S3 client registered for name '{clientName}'");
+
+        return client.BucketName;
+    }
+
+    public IEnumerable<string> GetRegisteredClientNames() => _clients.Keys;
+
+    public bool HasStorageClient(string storageClientName) => _clients.ContainsKey(storageClientName);
+
+    public void AddClient<T>(string defaultBucketName, AmazonS3Config amazonS3Config)
+        where T : IStorageClient, new()
+    {
+        var instance = new T();
+        var storageClientName = instance.ClientName;
+
+        if (!HasStorageClient(storageClientName))
+        {
+            var newClient = new AmazonS3Client(amazonS3Config);
+            _clients[storageClientName] = (newClient, defaultBucketName);
+        }
+    }
+
+    public void AddClientWithCredentials<T>(string defaultBucketName, string accessKeyRef, string secretKeyRef, AmazonS3Config amazonS3Config)
+        where T : IStorageClient, new()
+    {
+        var instance = new T();
+        var storageClientName = instance.ClientName;
+
+        if (!HasStorageClient(storageClientName))
+        {
+            var accessKey = Environment.GetEnvironmentVariable(accessKeyRef);
+            var secretKey = Environment.GetEnvironmentVariable(secretKeyRef);
+
+            if (string.IsNullOrWhiteSpace(defaultBucketName))
+                throw new InvalidOperationException($"Missing bucket name for '{storageClientName}'");
+
+            if (string.IsNullOrWhiteSpace(accessKey) || string.IsNullOrWhiteSpace(secretKey))
+                throw new InvalidOperationException($"Missing AWS credentials for '{storageClientName}'");
+
+            var newClient = new AmazonS3Client(accessKey, secretKey, amazonS3Config);
+            _clients[storageClientName] = (newClient, defaultBucketName);
+        }
+    }
+
+    public void RegisterMockClient<T>(string bucketName, IAmazonS3 mockClient)
+        where T : IStorageClient, new()
+    {
+        var instance = new T();
+        var name = instance.ClientName;
+        _clients[name] = (mockClient, bucketName);
+    }
+}
diff --git a/src/KeeperData.Infrastructure/Storage/Readers/ComparisonReportsStorageReader.cs b/src/KeeperData.Infrastructure/Storage/Readers/ComparisonReportsStorageReader.cs
@@ -0,0 +1,18 @@
+using Amazon.S3;
+using KeeperData.Core.Storage;
+using KeeperData.Infrastructure.Storage.Clients;
+using KeeperData.Infrastructure.Storage.Factories;
+using System.Diagnostics.CodeAnalysis;
+
+namespace KeeperData.Infrastructure.Storage.Readers;
+
+/// <summary>
+/// Wiring up the IS3ClientFactory and ComparisonReportsStorageClient into an ComparisonReportsStorageReader.
+/// </summary>
+/// <param name="s3ClientFactory">A single <see cref="IS3ClientFactory"/> reference.</param>
+[ExcludeFromCodeCoverage]
+public class ComparisonReportsStorageReader(IS3ClientFactory s3ClientFactory) : IStorageReader<ComparisonReportsStorageClient>
+{
+    private readonly IAmazonS3 _s3Client = s3ClientFactory.GetClient<ComparisonReportsStorageClient>();
+    private readonly string _bucketName = s3ClientFactory.GetClientBucketName<ComparisonReportsStorageClient>();
+}
diff --git a/src/KeeperData.Infrastructure/Storage/Setup/AwsS3HealthCheck.cs b/src/KeeperData.Infrastructure/Storage/Setup/AwsS3HealthCheck.cs
@@ -0,0 +1,85 @@
+using Amazon.S3;
+using Amazon.S3.Model;
+using KeeperData.Infrastructure.Storage.Factories;
+using Microsoft.Extensions.Diagnostics.HealthChecks;
+using Microsoft.Extensions.Logging;
+
+namespace KeeperData.Infrastructure.Storage.Setup;
+
+public class AwsS3HealthCheck(IS3ClientFactory s3ClientFactory, ILogger<AwsS3HealthCheck> logger) : IHealthCheck
+{
+    private readonly IS3ClientFactory _s3ClientFactory = s3ClientFactory;
+
+    public async Task<HealthCheckResult> CheckHealthAsync(
+        HealthCheckContext context,
+        CancellationToken cancellationToken = default)
+    {
+        var results = new Dictionary<string, object>();
+        var unhealthyClients = new List<string>();
+
+        foreach (var clientName in _s3ClientFactory.GetRegisteredClientNames())
+        {
+            var client = _s3ClientFactory.GetClient(clientName);
+            var bucketName = _s3ClientFactory.GetClientBucketName(clientName);
+
+            try
+            {
+                var request = new ListObjectsV2Request
+                {
+                    BucketName = bucketName
+                };
+
+                var response = await client.ListObjectsV2Async(request, cancellationToken);
+
+                if (response.HttpStatusCode == System.Net.HttpStatusCode.OK)
+                {
+                    results[clientName] = new
+                    {
+                        Bucket = bucketName,
+                        Status = "Healthy"
+                    };
+                }
+                else
+                {
+                    results[clientName] = new
+                    {
+                        Bucket = bucketName,
+                        Status = $"Degraded (Status: {response.HttpStatusCode})"
+                    };
+                    unhealthyClients.Add(bucketName);
+                }
+            }
+            catch (AmazonS3Exception ex) when (ex.StatusCode == System.Net.HttpStatusCode.NotFound)
+            {
+                logger.LogError("AmazonS3Exception recieved when testing {bucketName}, with {message}.", bucketName, ex.Message);
+
+                results[clientName] = new
+                {
+                    Bucket = bucketName,
+                    Status = "Unhealthy (Bucket not found)",
+                    Exception = ex.Message
+                };
+                unhealthyClients.Add(bucketName);
+            }
+            catch (Exception ex)
+            {
+                logger.LogError("Exception recieved when testing {bucketName}, with {message}.", bucketName, ex.Message);
+
+                results[clientName] = new
+                {
+                    Bucket = bucketName,
+                    Status = "Unhealthy (Exception)",
+                    Exception = ex.Message
+                };
+                unhealthyClients.Add(bucketName);
+            }
+        }
+
+        if (unhealthyClients.Count == 0)
+        {
+            return HealthCheckResult.Healthy("All S3 buckets are reachable", results);
+        }
+
+        return HealthCheckResult.Unhealthy($"Some S3 buckets failed: {string.Join(", ", unhealthyClients)}", data: results);
+    }
+}
diff --git a/src/KeeperData.Infrastructure/Storage/Setup/ServiceCollectionExtensions.cs b/src/KeeperData.Infrastructure/Storage/Setup/ServiceCollectionExtensions.cs
diff --git a/tests/KeeperData.Api.Tests.Component/AppWebApplicationFactory.cs b/tests/KeeperData.Api.Tests.Component/AppWebApplicationFactory.cs
diff --git a/tests/KeeperData.Infrastructure.Tests.Unit/Storage/Factories/S3ClientFactoryTests.cs b/tests/KeeperData.Infrastructure.Tests.Unit/Storage/Factories/S3ClientFactoryTests.cs
diff --git a/tests/KeeperData.Infrastructure.Tests.Unit/Storage/Setup/AwsS3HealthCheckTests.cs b/tests/KeeperData.Infrastructure.Tests.Unit/Storage/Setup/AwsS3HealthCheckTests.cs

-Original file line number
+Diff line change
@@ @@ -0,0 +1,5 @@ @@
 +namespace KeeperData.Core.Storage;
++
 +public interface IStorageReader<T> where T : IStorageClient, new()
 +{
 +}