Staged

2026-03-22 04:02:30 +01:00
parent 6ab9a3d2c2
commit 678419814a
23 changed files with 1318 additions and 70 deletions
@@ -0,0 +1,7 @@
+namespace Musify.Infrastructure.Messaging.Activities.Arguments
+{
+    public record DownloadFileFromBucketArguments(
+        string BucketName,
+        string KeyName,
+        string DestinationPath);
+}
@@ -1,6 +1,6 @@
 namespace Musify.Infrastructure.Messaging.Activities.Arguments
 {
-    public record RemoveFileArguments(
+    public record RemoveFileFromBucketArguments(
        string BucketName,
        string KeyName);
 }
@@ -0,0 +1,4 @@
+namespace Musify.Infrastructure.Messaging.Activities.Arguments
+{
+    public record TranscodeDashAudioArguments(string SourceFilePath, string DestinationFolderName);
+}
@@ -0,0 +1,7 @@
+namespace Musify.Infrastructure.Messaging.Activities.Arguments
+{
+    public record TransferFilesToBucketArguments(
+        string FolderPath,
+        string DestinationBucketName,
+        string DestinationKeyName);
+}
@@ -1,39 +0,0 @@
-using MassTransit;
-using Microsoft.Extensions.Logging;
-using Musify.Application.Contracts.Infrastructure;
-using Musify.Infrastructure.Messaging.Activities.Arguments;
-
-namespace Musify.Infrastructure.Messaging.Activities
-{
-    public class CopyFilesActivity(IStorageHandler storageHandler, ILogger<CopyFilesActivity> logger)
-        : IExecuteActivity<CopyFileArguments[]>
-    {
-        public async Task<ExecutionResult> Execute(ExecuteContext<CopyFileArguments[]> executeContext)
-        {
-            foreach (var file in executeContext.Arguments)
-            {
-                var copyFileResult = await storageHandler.CopyFileAsync(
-                    file.SourceBucketName,
-                    file.SourceKeyName,
-                    file.DestinationBucketName,
-                    file.SourceKeyName,
-                    executeContext.CancellationToken);
-
-                if (!copyFileResult.IsSuccess)
-                {
-                    string errorMessage = string.Join("; ", copyFileResult.Errors);
-                    logger.LogError(
-                        "Failed to copy file from {SourceBucket}/{SourceKey} to {DestinationBucket}/{DestinationKey}. Error: {ErrorMessage}",
-                        file.SourceBucketName,
-                        file.SourceKeyName,
-                        file.DestinationBucketName,
-                        file.DestinationKeyName,
-                        errorMessage);
-                    throw new Exception(errorMessage);
-                }
-            }
-
-            return executeContext.Completed();
-        }
-    }
-}
@@ -0,0 +1,41 @@
+using MassTransit;
+using Microsoft.Extensions.Logging;
+using Musify.Application.Contracts.Infrastructure;
+using Musify.Infrastructure.Messaging.Activities.Arguments;
+using Musify.Infrastructure.Messaging.Activities.Logs;
+
+namespace Musify.Infrastructure.Messaging.Activities
+{
+    public class DownloadFileFromBucketActivity(IStorageHandler storageHandler, ILogger<DownloadFileFromBucketActivity> logger)
+        : IExecuteActivity<DownloadFileFromBucketArguments>
+    {
+        public const string ExecuteEndpointName = "Download-File-From-Bucket";
+
+        public async Task<ExecutionResult> Execute(ExecuteContext<DownloadFileFromBucketArguments> executeContext)
+        {
+            var getFile = await storageHandler.GetFileAsync(
+                executeContext.Arguments.BucketName,
+                executeContext.Arguments.KeyName,
+                executeContext.CancellationToken);
+
+            if (!getFile.IsSuccess)
+            {
+                var error = string.Join("; ", getFile.Errors);
+                logger.LogError("Failed to download file from bucket. Bucket: {BucketName}, Key: {KeyName}",
+                    executeContext.Arguments.BucketName,
+                    executeContext.Arguments.KeyName);
+                throw new Exception(error);
+            }
+
+            using var fileStream = getFile.Value;
+            if (fileStream.CanSeek)
+                fileStream.Position = 0;
+
+            var fileName = Path.GetFileName(executeContext.Arguments.KeyName);
+            using var destinationStream = File.Create($"D:\\tempsFilesDev\\{fileName}");
+            await fileStream.CopyToAsync(destinationStream, executeContext.CancellationToken);
+
+            return executeContext.Completed();
+        }
+    }
+}
@@ -6,15 +6,15 @@ using Musify.Infrastructure.Messaging.Activities.Arguments;

 namespace Musify.Infrastructure.Messaging.Activities
 {
-    public class RemoveFilesActivity(
+    public class RemoveFileFromBucketActivity(
        IStorageHandler storageHandler,
-        ILogger<RemoveFilesActivity> logger,
+        ILogger<RemoveFileFromBucketActivity> logger,
        IProcessTrackingStore processTrackingStore)
-        : IExecuteActivity<RemoveFileArguments>
+        : IExecuteActivity<RemoveFileFromBucketArguments>
    {
        public const string ExecuteEndpointName = "Remove-File";

-        public async Task<ExecutionResult> Execute(ExecuteContext<RemoveFileArguments> executeContext)
+        public async Task<ExecutionResult> Execute(ExecuteContext<RemoveFileFromBucketArguments> executeContext)
        {
            var processId = await processTrackingStore.GetOrCreateProcessAsync(
                "RoutingSlip",
@@ -25,7 +25,7 @@ namespace Musify.Infrastructure.Messaging.Activities

            var stepId = await processTrackingStore.StartStepAsync(
                processId,
-                nameof(RemoveFilesActivity),
+                nameof(RemoveFileFromBucketActivity),
                ProcessStepComponentType.Activity,
                0,
                executeContext.CancellationToken);
@@ -0,0 +1,49 @@
+using MassTransit;
+using Microsoft.Extensions.Logging;
+using Musify.Application.Contracts.Infrastructure;
+using Musify.Infrastructure.Configuration;
+using Musify.Infrastructure.Messaging.Activities.Arguments;
+using Musify.Infrastructure.Messaging.Activities.Logs;
+
+namespace Musify.Infrastructure.Messaging.Activities
+{
+    public class TranscodeDashAudioActivity(IAudioTranscoder audioTranscoder, ILogger<TranscodeDashAudioActivity> logger,
+        AudioTranscoderConfiguration audioTranscoderConfiguration)
+        : IExecuteActivity<TranscodeDashAudioArguments>
+    {
+        public const string ExecuteEndpointName = "Transcode-Dash-Audio";
+
+        public async Task<ExecutionResult> Execute(ExecuteContext<TranscodeDashAudioArguments> executeContext)
+        {
+            var workingDirectory = Path.Combine(
+                audioTranscoderConfiguration.Routes.WorkingDirectory,
+                executeContext.Arguments.DestinationFolderName);
+
+            try
+            {
+                await using var fileStream = File.OpenRead(executeContext.Arguments.SourceFilePath);
+
+                var result = await audioTranscoder.TranscodeToDashAsync(
+                    fileStream,
+                    executeContext.Arguments.DestinationFolderName,
+                    audioTranscoderConfiguration.TranscodingTimeout,
+                    executeContext.CancellationToken);
+
+                if (!result.IsSuccess)
+                {
+                    var errors = string.Join(";  ", result.Errors); 
+                    logger.LogError("transcoding failed for file {SourceFilePath}. Error: {ErrorMessage}",
+                        executeContext.Arguments.SourceFilePath, errors);
+                    throw new Exception(errors);
+                }
+
+                return executeContext.Completed();
+            }
+            catch (Exception exception)
+            {
+                logger.LogError(exception, "Error during transcoding activity.");
+                throw;
+            }
+        }
+    }
+}
@@ -0,0 +1,31 @@
+using MassTransit;
+using Microsoft.Extensions.Logging;
+using Musify.Application.Contracts.Infrastructure;
+using Musify.Infrastructure.Messaging.Activities.Arguments;
+
+namespace Musify.Infrastructure.Messaging.Activities
+{
+    public class TransferFilesToBucket(IStorageHandler storageHandler, ILogger<TransferFilesToBucket> logger)
+        : IExecuteActivity<TransferFilesToBucketArguments>
+    {
+        public const string ExecuteEndpointName = "Transfer-Files-To-Bucket";
+
+        public async Task<ExecutionResult> Execute(ExecuteContext<TransferFilesToBucketArguments> executeContext)
+        {
+            var transferFilesResult = await storageHandler.TransferFilesAsync(
+                executeContext.Arguments.FolderPath,
+                executeContext.Arguments.DestinationBucketName,
+                executeContext.Arguments.DestinationKeyName,
+                executeContext.CancellationToken);
+
+            if (!transferFilesResult.IsSuccess)
+            {
+                var errors = string.Join("; ", transferFilesResult.Errors);
+                logger.LogError($"An error occurred while transferring files to bucket: {errors}");
+                throw new Exception(errors);
+            }
+
+            return executeContext.Completed();
+        }
+    }
+}
@@ -16,8 +16,8 @@ namespace Musify.Infrastructure.Messaging.Consumers

            routingSlipBuilder.AddActivity(
                "RemoveFile",
-                BuildExecuteUri(RemoveFilesActivity.ExecuteEndpointName),
-                new RemoveFileArguments(
+                BuildExecuteUri(RemoveFileFromBucketActivity.ExecuteEndpointName),
+                new RemoveFileFromBucketArguments(
                    consumeContext.Message.BucketName,
                    consumeContext.Message.KeyName));

@@ -0,0 +1,54 @@
+using MassTransit;
+using Musify.Application.Events;
+using Musify.Infrastructure.Configuration;
+using Musify.Infrastructure.Messaging.Activities;
+using Musify.Infrastructure.Messaging.Activities.Arguments;
+
+namespace Musify.Infrastructure.Messaging.Consumers
+{
+    public class TranscodeAudioFromTrackConsumer(IBus bus, AudioTranscoderConfiguration audioTranscoderConfiguration)
+        : IConsumer<TranscodeAudioFromTrackEvent>
+    {
+        public const string QueueName = "Transcode-Audio-From-Track";
+
+        public async Task Consume(ConsumeContext<TranscodeAudioFromTrackEvent> consumeContext)
+        {
+            var routingSlipBuilder = new RoutingSlipBuilder(NewId.NextGuid());
+
+            var folderName = Guid.NewGuid().ToString();
+            var workingDirectory = Path.Combine("D:\\tempsFilesDev\\");
+
+            routingSlipBuilder.AddActivity(
+                "DownloadFile",
+                BuildExecuteUri(DownloadFileFromBucketActivity.ExecuteEndpointName),
+                new DownloadFileFromBucketArguments(
+                    consumeContext.Message.SourceBucketName,
+                    consumeContext.Message.SourceKeyName,
+                    workingDirectory)
+                );
+            var fileName = Path.GetFileName(consumeContext.Message.SourceKeyName);
+
+            routingSlipBuilder.AddActivity(
+                "TranscodeAudio",
+                BuildExecuteUri(TranscodeDashAudioActivity.ExecuteEndpointName),
+                new TranscodeDashAudioArguments(
+                    $"D:\\tempsFilesDev\\{fileName}",
+                    "D:\\tempsFilesDev\\")
+                );
+
+            routingSlipBuilder.AddActivity(
+                "UploadFile",
+                BuildExecuteUri(TransferFilesToBucket.ExecuteEndpointName),
+                new TransferFilesToBucketArguments(
+                    workingDirectory,
+                    consumeContext.Message.DestinationBucketName,
+                    consumeContext.Message.DestinationKeyName)
+                );
+
+            var routingSlip = routingSlipBuilder.Build();
+            await bus.Execute(routingSlip);
+        }
+
+        static Uri BuildExecuteUri(string endpointName) => new($"queue:{endpointName}_execute");
+    }
+}
@@ -43,8 +43,8 @@ namespace Musify.Infrastructure.Messaging.Consumers

            routingSlipBuilder.AddActivity(
                "DeleteOriginal",
-                BuildExecuteUri(RemoveFilesActivity.ExecuteEndpointName),
-                new RemoveFileArguments(
+                BuildExecuteUri(RemoveFileFromBucketActivity.ExecuteEndpointName),
+                new RemoveFileFromBucketArguments(
                    consumeContext.Message.BucketName,
                    consumeContext.Message.OriginalPictureKeyName)
                );
@@ -43,8 +43,8 @@ namespace Musify.Infrastructure.Messaging.Consumers

            routingSlipBuilder.AddActivity(
                "DeleteOriginal",
-                BuildExecuteUri(RemoveFilesActivity.ExecuteEndpointName),
-                new RemoveFileArguments(
+                BuildExecuteUri(RemoveFileFromBucketActivity.ExecuteEndpointName),
+                new RemoveFileFromBucketArguments(
                    consumeContext.Message.BucketName,
                    consumeContext.Message.OriginalPictureKeyName)
                );
@@ -3,6 +3,7 @@ using Microsoft.Extensions.DependencyInjection;
 using Musify.Infrastructure.Configuration;
 using Musify.Infrastructure.Messaging.Activities;
 using Musify.Infrastructure.Messaging.Activities.Arguments;
+using Musify.Infrastructure.Messaging.Activities.Logs;
 using Musify.Infrastructure.Messaging.Consumers;
 using Musify.Infrastructure.Messaging.Filters;

@@ -29,9 +30,15 @@ namespace Musify.Infrastructure.Messaging
            {
                options.AddConsumer<UpdatePlayListPictureConsumer>();
                options.AddConsumer<RemoveFileConsumer>();
+                options.AddConsumer<TranscodeAudioFromTrackConsumer>();
+                options.AddConsumer<UpdateTrackPictureConsumer>();
+
                options.AddExecuteActivity<ResizePictureActivity, ResizePictureArgument>();
-                options.AddExecuteActivity<RemoveFilesActivity, RemoveFileArguments>();
+                options.AddExecuteActivity<RemoveFileFromBucketActivity, RemoveFileFromBucketArguments>();
                options.AddExecuteActivity<UpdatePlayListPictureActivity, UpdatePlayListPictureArguments>();
+                options.AddExecuteActivity<UpdateTrackPictureActivity, UpdateTrackPictureArguments>();
+                options.AddExecuteActivity<DownloadFileFromBucketActivity, DownloadFileFromBucketArguments>();
+                options.AddExecuteActivity<TranscodeDashAudioActivity, TranscodeDashAudioArguments>();

                options.UsingRabbitMq((busRegistrationContext, busFactoryConfigurator) =>
                {
@@ -51,20 +58,45 @@ namespace Musify.Infrastructure.Messaging
                        endpointConfigurator.ConfigureConsumer<RemoveFileConsumer>(busRegistrationContext);
                    } );

+                    busFactoryConfigurator.ReceiveEndpoint(TranscodeAudioFromTrackConsumer.QueueName, endpointConfigurator =>
+                    {
+                        endpointConfigurator.ConfigureConsumer<TranscodeAudioFromTrackConsumer>(busRegistrationContext);
+                    } );
+
+                    busFactoryConfigurator.ReceiveEndpoint(UpdateTrackPictureConsumer.QueueName, endpointConfigurator =>
+                    {
+                        endpointConfigurator.ConfigureConsumer<UpdateTrackPictureConsumer>(busRegistrationContext);
+                    } );
+
                    ConfigureExecuteActivityEndpoint<ResizePictureActivity, ResizePictureArgument>(
                        busFactoryConfigurator,
                        busRegistrationContext,
                        ResizePictureActivity.ExecuteEndpointName);

-                    ConfigureExecuteActivityEndpoint<RemoveFilesActivity, RemoveFileArguments>(
+                    ConfigureExecuteActivityEndpoint<RemoveFileFromBucketActivity, RemoveFileFromBucketArguments>(
                        busFactoryConfigurator,
                        busRegistrationContext,
-                        RemoveFilesActivity.ExecuteEndpointName);
+                        RemoveFileFromBucketActivity.ExecuteEndpointName);

                    ConfigureExecuteActivityEndpoint<UpdatePlayListPictureActivity, UpdatePlayListPictureArguments>(
                        busFactoryConfigurator,
                        busRegistrationContext,
                        UpdatePlayListPictureActivity.ExecuteEndpointName);
+
+                    ConfigureExecuteActivityEndpoint<UpdateTrackPictureActivity, UpdateTrackPictureArguments>(
+                        busFactoryConfigurator,
+                        busRegistrationContext,
+                        UpdateTrackPictureActivity.ExecuteEndpointName);
+
+                    ConfigureExecuteActivityEndpoint<DownloadFileFromBucketActivity, DownloadFileFromBucketArguments>(
+                        busFactoryConfigurator,
+                        busRegistrationContext,
+                        DownloadFileFromBucketActivity.ExecuteEndpointName);
+
+                    ConfigureExecuteActivityEndpoint<TranscodeDashAudioActivity, TranscodeDashAudioArguments>(
+                        busFactoryConfigurator,
+                        busRegistrationContext,
+                        TranscodeDashAudioActivity.ExecuteEndpointName);
                } );
            } );

@@ -94,5 +126,24 @@ namespace Musify.Infrastructure.Messaging
                endpointConfigurator.ExecuteActivityHost<TActivity, TArguments>(busRegistrationContext);
            } );
        }
+
+        static void ConfigureActivityEndpoints<TActivity, TArguments, TLog>(
+            IRabbitMqBusFactoryConfigurator busFactoryConfigurator,
+            IBusRegistrationContext busRegistrationContext,
+            string endpointName)
+            where TActivity : class, IActivity<TArguments, TLog>
+            where TArguments : class
+            where TLog : class
+        {
+            busFactoryConfigurator.ReceiveEndpoint($"{endpointName}_execute", endpointConfigurator =>
+            {
+                endpointConfigurator.ExecuteActivityHost<TActivity, TArguments>(busRegistrationContext);
+            } );
+
+            busFactoryConfigurator.ReceiveEndpoint($"{endpointName}_compensate", endpointConfigurator =>
+            {
+                endpointConfigurator.CompensateActivityHost<TActivity, TLog>(busRegistrationContext);
+            } );
+        }
    }
 }