Generated response

Infrastructure/Jobs/TempUploadsCleanupJob.cs

@@ -0,0 +1,70 @@
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+using Musify.Application.Abstractions.Infrastructure;
+using Musify.Application.Configuration;
+
+namespace Musify.Infrastructure.Jobs
+{
+    public class TempUploadsCleanupJob(
+        IServiceScopeFactory scopeFactory,
+        ILogger<TempUploadsCleanupJob> logger,
+        ApplicationStorageConfiguration storageConfiguration,
+        UploadIntentConfiguration uploadIntentConfiguration)
+        : BackgroundService
+    {
+        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
+        {
+            logger.LogInformation("TempUploadsCleanupJob started (interval: {Interval}s, prefix: {Prefix})",
+                uploadIntentConfiguration.TempCleanupJobIntervalSeconds,
+                uploadIntentConfiguration.TempRootPrefix);
+
+            while (!stoppingToken.IsCancellationRequested)
+            {
+                try
+                {
+                    await RunAsync(stoppingToken);
+                }
+                catch (Exception exception) when (exception is not OperationCanceledException)
+                {
+                    logger.LogError(exception, "Error in TempUploadsCleanupJob");
+                }
+
+                await Task.Delay(TimeSpan.FromSeconds(uploadIntentConfiguration.TempCleanupJobIntervalSeconds), stoppingToken);
+            }
+        }
+
+        async Task RunAsync(CancellationToken cancellationToken)
+        {
+            await using var scope = scopeFactory.CreateAsyncScope();
+            var storageService = scope.ServiceProvider.GetRequiredService<IStorageService>();
+
+            var cutoff = DateTime.UtcNow.AddDays(-uploadIntentConfiguration.TempUploadsRetentionDays);
+            var deleted = 0;
+            var errors = 0;
+
+            await foreach (var (key, lastModified) in storageService.ListObjectsAsync(
+                storageConfiguration.Bucket,
+                uploadIntentConfiguration.TempRootPrefix,
+                cancellationToken))
+            {
+                if (lastModified >= cutoff)
+                    continue;
+
+                try
+                {
+                    await storageService.RemoveFileAsync(storageConfiguration.Bucket, key, cancellationToken);
+                    deleted++;
+                }
+                catch (Exception exception)
+                {
+                    errors++;
+                    logger.LogWarning(exception, "Failed to delete orphaned temp object {Key}", key);
+                }
+            }
+
+            if (deleted > 0 || errors > 0)
+                logger.LogInformation("TempUploadsCleanupJob: deleted {Deleted} orphaned objects, {Errors} errors", deleted, errors);
+        }
+    }
+}

Infrastructure/Jobs/UploadIntentExpirationJob.cs

@@ -0,0 +1,75 @@
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+using Musify.Application.Abstractions.Infrastructure;
+using Musify.Application.Configuration;
+using Musify.Domain.Entities;
+
+namespace Musify.Infrastructure.Jobs
+{
+    public class UploadIntentExpirationJob(
+        IServiceScopeFactory scopeFactory,
+        ILogger<UploadIntentExpirationJob> logger,
+        UploadIntentConfiguration uploadIntentConfiguration)
+        : BackgroundService
+    {
+        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
+        {
+            logger.LogInformation("UploadIntentExpirationJob started (interval: {Interval}s)", uploadIntentConfiguration.ExpirationJobIntervalSeconds);
+
+            while (!stoppingToken.IsCancellationRequested)
+            {
+                try
+                {
+                    await RunAsync(stoppingToken);
+                }
+                catch (Exception exception) when (exception is not OperationCanceledException)
+                {
+                    logger.LogError(exception, "Error in UploadIntentExpirationJob");
+                }
+
+                await Task.Delay(TimeSpan.FromSeconds(uploadIntentConfiguration.ExpirationJobIntervalSeconds), stoppingToken);
+            }
+        }
+
+        async Task RunAsync(CancellationToken cancellationToken)
+        {
+            await using var scope = scopeFactory.CreateAsyncScope();
+            var database = scope.ServiceProvider.GetRequiredService<IDatabase>();
+
+            var now = DateTime.UtcNow;
+
+            // Mark expired intents
+            var expiredIntents = await database.UploadIntents
+                .Where(i => i.Status == UploadIntentStatus.Issued && i.ExpiresAt < now)
+                .ToListAsync(cancellationToken);
+
+            if (expiredIntents.Count > 0)
+            {
+                foreach (var intent in expiredIntents)
+                    intent.Status = UploadIntentStatus.Expired;
+
+                await database.SaveChangesAsync(cancellationToken);
+                logger.LogInformation("Marked {Count} upload intents as Expired", expiredIntents.Count);
+            }
+
+            // Delete old Expired intents past retention window
+            if (uploadIntentConfiguration.ExpiredIntentsRetentionDays >= 0)
+            {
+                var retentionCutoff = now.AddDays(-uploadIntentConfiguration.ExpiredIntentsRetentionDays);
+
+                var oldExpiredIntents = await database.UploadIntents
+                    .Where(i => i.Status == UploadIntentStatus.Expired && i.ExpiresAt < retentionCutoff)
+                    .ToListAsync(cancellationToken);
+
+                if (oldExpiredIntents.Count > 0)
+                {
+                    database.UploadIntents.RemoveRange(oldExpiredIntents);
+                    await database.SaveChangesAsync(cancellationToken);
+                    logger.LogInformation("Deleted {Count} old Expired upload intents past retention window", oldExpiredIntents.Count);
+                }
+            }
+        }
+    }
+}