1111

FileService.Application/StorageContracts/UploadRuntimeCache.cs

@@ -33,6 +33,23 @@ namespace FileService.Application.StorageContracts
 
         public Dictionary<int, UploadPart> Parts { get; init; } = new();
 
+        public UploadRuntimeCache(string taskId, string providerCode, 
+            string uploadSessionId, string bucket, string region, 
+            string objectKey, long fileSize, int totalPartCount, 
+            DateTimeOffset? expireAt = null)
+        {
+            TaskId = taskId;
+            ProviderCode = providerCode;
+            UploadSessionId = uploadSessionId;
+            Bucket = bucket;
+            Region = region;
+            ObjectKey = objectKey;
+            FileSize = fileSize;
+            TotalPartCount = totalPartCount;
+            ExpireAt = expireAt ?? DateTime.MaxValue;
+            CreatedAt = DateTime.Now;
+        }
+
         public void AddOrUpdatePart(UploadPart part)
         {
             Parts[part.PartNumber] = part;

FileService.Application/UploadFileTask/UploadFileTaskService.cs

@@ -14,26 +14,23 @@ using System.Threading.Tasks;
 
 namespace FileService.Application.UploadFileTask
 {
-    public class UploadFileTaskService
+    public class UploadFileTaskService(IUploadTaskReposity reposity, 
+        IMapper mapper, IObjectStorageRouter router, 
+        IOptions<StorageOptions> options, IStorageRedisCache redis)
     {
-        private readonly IUploadTaskReposity reposity;
-        private readonly IMapper mapper;
-        private readonly IObjectStorageRouter router;
-        private readonly IOptions<StorageOptions> options;
-
-        public UploadFileTaskService(IUploadTaskReposity reposity, IMapper mapper, IObjectStorageRouter router, IOptions<StorageOptions> options)
-        {
-            this.reposity = reposity;
-            this.mapper = mapper;
-            this.router = router;
-            this.options = options;
-        }
+        private readonly IUploadTaskReposity reposity = reposity;
+        private readonly IMapper mapper = mapper;
+        private readonly IObjectStorageRouter router = router;
+        private readonly IOptions<StorageOptions> options = options;
+        private readonly IStorageRedisCache redis = redis;
 
         public async Task<Result<TaskInitResponse>> InitTaskAsync(UploadTaskInitCommand command)
         {
             CancellationToken cancellationToken = CancellationToken.None;
             var task = command.ToUploadTask();
-            var storage = router.Route(options.Value.ProviderCode);
+
+            var storageOption = options.Value.Providers[options.Value.DefaultProviderCode];
+            var storage = router.Route(storageOption.ProviderCode);
             var initRes = await storage.InitUploadAsync(new StorageContracts.InitiateUploadCommand(
                 ProviderCode: options.Value.ProviderCode,
                 Bucket: options.Value.Bucket,
@@ -45,6 +42,20 @@ namespace FileService.Application.UploadFileTask
 
             var res = mapper.Map<TaskInitResponse>(initRes);
             res.TaskId = task.Id;
+            reposity.Create(task);
+
+            await redis.SetAsync(new StorageContracts.UploadRuntimeCache(
+                    taskId: task.Id.ToString(),
+                    providerCode: storage.ProviderCode,
+                    uploadSessionId: res.UploadSessionId,
+                    bucket: storageOption.Bucket,
+                    region: storageOption.Region,
+                    objectKey: storageOption.Endpoint,
+                    fileSize: task.FileSize,
+                    totalPartCount: (int)(task.FileSize % storageOption.DefaultPartSizeBytes > 0 ?
+                        (task.FileSize / storageOption.DefaultPartSizeBytes) + 1 : 
+                        task.FileSize / storageOption.DefaultPartSizeBytes)
+                ));
 
             return Result.Success(res);