feat(dal, core, workloadBuilderWorker): Сервисы по работе с очередями (задачиами). Заготовка WorkloadBuilderWorker

2026-04-21 16:54:39 +10:00
parent 2a6fd7177d
commit 001c09edaa
22 changed files with 762 additions and 4 deletions
--- a/PARR.Core/Services/Task/Handlers/BaseTaskHandler.cs
+++ b/PARR.Core/Services/Task/Handlers/BaseTaskHandler.cs
@@ -0,0 +1,258 @@
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+using PARR.Core.Repositories.Interfaces.TaskRepositories;
+using PARR.Domain.Entities.TaskEntities;
+using PARR.Domain.Enums;
+
+namespace PARR.Core.Services.Task.Handlers
+{
+    /// <summary>
+    /// Базовый класс для всех обработчиков задач.
+    /// Реализует шаблонный метод ProcessAsync с общей логикой:
+    /// - Атомарный захват задачи
+    /// - Обработка исключений
+    /// - Обновление статусов
+    /// - Запись ошибок
+    /// - Логика retry
+    /// </summary>
+    public abstract class BaseTaskHandler
+    {
+        protected readonly ITaskRepository taskRepository;
+        protected readonly ITaskErrorRepository taskErrorRepository;
+        protected readonly ILogger<BaseTaskHandler> logger;
+
+        protected BaseTaskHandler(ITaskRepository taskRepository, ITaskErrorRepository taskErrorRepository, ILogger<BaseTaskHandler> logger)
+        {
+            this.taskRepository = taskRepository;
+            this.taskErrorRepository = taskErrorRepository;
+            this.logger = logger;
+        }
+
+        /// <summary>
+        /// Тип задачи, который обрабатывает этот хендлер. 
+        /// Должен быть переопределен в конкретном классе.
+        /// </summary>
+        public abstract TaskTypeEnum SupportedType { get; }
+
+
+        public async Task<HandlerResult> ProcessAsync(Guid taskId)
+        {
+            //todo: может принимать не taskId, а модель TaskMessage
+
+            logger.LogInformation("Начало обработки задачи {TaskId} (тип {Type})", taskId, SupportedType);
+
+            // Загружаем задачу из БД (с конфигурацией типа)
+            var task = await LoadTaskAsync(taskId);
+
+            if (task == null)
+            {
+                logger.LogWarning("Задача {TaskId} не найдена в БД", taskId);
+                return HandlerResult.Failure("Не найдена задача");
+            }
+
+            // Атомарный захват задачи (Pending -> Processing)
+            var captured = await TryCaptureTaskAsync(task);
+            if (!captured)
+            {
+                logger.LogWarning("Не удалось захватить задачу {TaskId} (уже обрабатывается)", taskId);
+                return HandlerResult.Failure("Задача уже обрабатывается");
+            }
+
+            // Выполняем основную логику (реализация в наследнике)
+            try
+            {
+                var result = await ExecuteInternalAsync(task);
+
+                if (result.IsSuccess)
+                    await HandleSuccessAsync(task, result);
+                else
+                    await HandleErrorAsync(task, result.Exception);
+
+                return result;
+            }
+            catch (Exception ex)
+            {
+                logger.LogError(ex, "Непредвиденная ошибка при обработке задачи {TaskId}", taskId);
+                await HandleErrorAsync(task, ex);
+                return HandlerResult.Failure(ex.Message, ex);
+            }
+        }
+
+
+        private async Task<TaskItem?> LoadTaskAsync(Guid taskId)
+        {
+            return await taskRepository.Get()
+                            .Include(t => t.TaskType)
+                            .Include(t => t.TaskStatus)
+                            .FirstOrDefaultAsync(t => t.Id == taskId);
+        }
+
+
+        /// <summary>
+        /// Атомарный захват задачи: Pending -> Processing.
+        /// Возвращает true, если удалось захватить.
+        /// </summary>
+        /// <param name="task"></param>
+        /// <returns></returns>
+        private async Task<bool> TryCaptureTaskAsync(TaskItem task)
+        {
+            if (task.StatusCode != TaskItemStatusEnum.Pending)
+                return false;
+
+            // Атомарный захват задачи
+            var affectedRows = await taskRepository.TaskCaptureAsync(task.Id);
+
+            if (affectedRows > 0)
+            {
+                // Смог захватить задачу
+                // Обновим локальное состояние
+                task.StatusCode = TaskItemStatusEnum.Processing;
+                task.DateModified = DateTimeOffset.UtcNow;
+
+                return true;
+            }
+
+            return false;
+        }
+
+
+        /// <summary>
+        /// Обработка успешного выполнения
+        /// </summary>
+        /// <param name="task"></param>
+        /// <param name="result"></param>
+        /// <returns></returns>
+        private async System.Threading.Tasks.Task HandleSuccessAsync(TaskItem task, HandlerResult result)
+        {
+            logger.LogInformation("Задача {TaskId} успешно выполнена", task.Id);
+
+            task.StatusCode = TaskItemStatusEnum.Success;
+            task.ProcessedAt = DateTimeOffset.UtcNow;
+            task.DateModified = DateTimeOffset.UtcNow;
+
+            //todo: если есть результат, его можно сохранить, если надо
+            if (!string.IsNullOrEmpty(result.ResultData))
+            {
+                //task.ResultPayload = result.ResultData;
+            }
+
+            // Хук для наследников (например отправка уведомлений)
+            await OnSuccessAsync(task, result);
+
+            var commitResult = await taskRepository.CommitAsync();
+
+            //todo: тут можно обработать commitResult
+        }
+
+
+        /// <summary>
+        /// Обработка ошибки: запись в TaskErrors, проверка MaxRetries.
+        /// </summary>
+        /// <param name="task"></param>
+        /// <param name="ex"></param>
+        /// <returns></returns>
+        private async System.Threading.Tasks.Task HandleErrorAsync(TaskItem task, Exception? ex)
+        {
+            var attemptNumber = task.RetryCount + 1;
+            var errorMessage = ex?.Message ?? "Неизвестная ошибка";
+            var stackTrace = ex?.StackTrace;
+
+            logger.LogError(ex, "Ошибка при обработке задачи {TaskId} (попытка {Attempt})", task.Id, attemptNumber);
+
+            // Записываем ошибку в историю
+            var taskError = new TaskError
+            {
+                Id = Guid.NewGuid(),
+                TaskId = task.Id,
+                AttemptNumber = attemptNumber,
+                ErrorMessage = errorMessage,
+                StackTrace = stackTrace
+            };
+
+            await taskErrorRepository.CreateAsync(taskError);
+
+            // Хук для наследников, например отправка уведомления
+            await OnErrorAsync(task, ex, attemptNumber);
+
+            // Проверяем лимит попыток
+            var maxRetries = task.TaskType?.MaxRetries ?? 3;// дефолт 3
+
+            if (attemptNumber >= maxRetries)
+            {
+                // Лимит исчерпан, финальный Filed
+                logger.LogError("Превышен лимит попыток ({Max} для задачи {TaskId})", maxRetries, task.Id);
+
+                task.StatusCode = TaskItemStatusEnum.Failed;
+                task.ProcessedAt = DateTimeOffset.UtcNow;
+                task.DateModified = DateTimeOffset.UtcNow;
+            }
+            else
+            {
+                // Остались попытки, временный Failed
+                logger.LogInformation("Задача {TaskId} будет повторена (попытка {Attempt} из {Max})", task.Id, attemptNumber, maxRetries);
+
+                // Временно
+                task.StatusCode = TaskItemStatusEnum.Failed;
+                task.DateModified = DateTimeOffset.UtcNow;
+            }
+
+            task.RetryCount = attemptNumber;
+
+            //todo: может обработать commitResult?
+            var commitResult = await taskRepository.CommitAsync();
+
+            // Если есть попытки - отправляем в очередь на retry
+            if (attemptNumber < maxRetries)
+                await ScheduleRetryAsync(task);
+        }
+
+
+        /// <summary>
+        /// Планирование повторной попытки (отправка в очередь с задержкой)
+        /// </summary>
+        /// <param name="task"></param>
+        /// <returns></returns>
+        protected virtual async System.Threading.Tasks.Task ScheduleRetryAsync(TaskItem task)
+        {
+            // Здесь нужна интеграция с ITaskQueueService
+            // Для этого можно использовать событие или callback
+            // В простой реализации — выбрасываем событие, которое ловит воркер
+
+            // Вариант: сохранить флаг, а воркер после ProcessAsync проверит и отправит
+            // Это будет реализовано в BackgroundService
+
+            //todo:!!!!!!!!!
+            await System.Threading.Tasks.Task.Delay(50);
+        }
+
+
+        /// <summary>
+        /// Абстрактный метод - логика конкретного типа задачи.
+        /// Релизация в наследнике.
+        /// </summary>
+        /// <param name="task"></param>
+        /// <returns></returns>
+        protected abstract Task<HandlerResult> ExecuteInternalAsync(TaskItem task);
+
+
+        /// <summary>
+        /// Хук после успешного выполнения (можно переопределить в наследнике).
+        /// </summary>
+        /// <param name="task"></param>
+        /// <param name="result"></param>
+        /// <returns></returns>
+        protected virtual System.Threading.Tasks.Task OnSuccessAsync(TaskItem task, HandlerResult result) => System.Threading.Tasks.Task.CompletedTask;
+
+
+        /// <summary>
+        /// Хук при ошибке (можно переопределить в наследнике).
+        /// </summary>
+        /// <param name="task"></param>
+        /// <param name="ex"></param>
+        /// <param name="attemptNumber"></param>
+        /// <returns></returns>
+        protected virtual System.Threading.Tasks.Task OnErrorAsync(TaskItem task, Exception? ex, int attemptNumber) => System.Threading.Tasks.Task.CompletedTask;
+
+
+    }
+}
--- a/PARR.Core/Services/Task/Handlers/Factory/ITaskHandlerFactory.cs
+++ b/PARR.Core/Services/Task/Handlers/Factory/ITaskHandlerFactory.cs
@@ -0,0 +1,23 @@
+using PARR.Domain.Enums;
+
+namespace PARR.Core.Services.Task.Handlers.Factory
+{
+    /// <summary>
+    /// Фабрика обработчиков
+    /// </summary>
+    public interface ITaskHandlerFactory
+    {
+        /// <summary>
+        /// Получить обработчик для типа задачи
+        /// </summary>
+        /// <param name="taskType"></param>
+        /// <returns></returns>
+        BaseTaskHandler GetHandler(TaskTypeEnum taskType);
+
+        /// <summary>
+        /// Все зарегистрированные типы.
+        /// </summary>
+        /// <returns></returns>
+        IEnumerable<TaskTypeEnum> GetSupportedTypes();
+    }
+}
--- a/PARR.Core/Services/Task/Handlers/Factory/TaskHandlerFactory.cs
+++ b/PARR.Core/Services/Task/Handlers/Factory/TaskHandlerFactory.cs
@@ -0,0 +1,33 @@
+using Microsoft.Extensions.DependencyInjection;
+using PARR.Domain.Enums;
+
+namespace PARR.Core.Services.Task.Handlers.Factory
+{
+    public class TaskHandlerFactory : ITaskHandlerFactory
+    {
+        private readonly IServiceProvider serviceProvider;
+        private readonly Dictionary<TaskTypeEnum, Type> handlers;
+
+        public TaskHandlerFactory(IServiceProvider serviceProvider, IEnumerable<BaseTaskHandler> handlers)
+        {
+            this.serviceProvider = serviceProvider;
+            this.handlers = handlers.ToDictionary(t => t.SupportedType, t => t.GetType());
+        }
+
+        public BaseTaskHandler GetHandler(TaskTypeEnum taskType)
+        {
+            if (!handlers.TryGetValue(taskType, out var handlerType))
+            {
+                throw new InvalidOperationException($"Не зарегистрирован обработчик для типа {taskType}");
+            }
+
+            return (BaseTaskHandler)serviceProvider.GetRequiredService(handlerType);
+        }
+
+        public IEnumerable<TaskTypeEnum> GetSupportedTypes()
+        {
+            return handlers.Keys;
+        }
+
+    }
+}
--- a/PARR.Core/Services/Task/Handlers/HandlerResult.cs
+++ b/PARR.Core/Services/Task/Handlers/HandlerResult.cs
@@ -0,0 +1,49 @@
+namespace PARR.Core.Services.Task.Handlers
+{
+    /// <summary>
+    /// Результат выполнения задачи обработчиком. 
+    /// Используется для преедачи данных между BaseTaskHandler и конкретными хендлерами.
+    /// </summary>
+    public class HandlerResult
+    {
+        // TODO: может его перенести в Domain
+
+        /// <summary>
+        /// Успешно ли выполнено
+        /// </summary>
+        public bool IsSuccess { get; set; }
+
+        /// <summary>
+        /// Данные результата (JSON, если нужно сохранить в БД)
+        /// </summary>
+        public string? ResultData { get; set; }
+
+
+        /// <summary>
+        /// Сообщение об ошибке (если IsSuccess = false)
+        /// </summary>
+        public string? ErrorMessage { get; set; }
+
+        /// <summary>
+        /// Исключение
+        /// </summary>
+        public Exception? Exception { get; set; }
+
+
+        /// <summary>
+        /// Создать успешный результат
+        /// </summary>
+        /// <param name="resultData"></param>
+        /// <returns></returns>
+        public static HandlerResult Success(string? resultData = null) => new() { IsSuccess = true, ResultData = resultData };
+
+        /// <summary>
+        /// Создать результат с ошибкой
+        /// </summary>
+        /// <param name="errorMessage"></param>
+        /// <param name="ex"></param>
+        /// <returns></returns>
+        public static HandlerResult Failure(string errorMessage, Exception? ex = null) => new() { IsSuccess = false, ErrorMessage = errorMessage, Exception = ex };
+
+    }
+}
--- a/PARR.Core/Services/Task/Handlers/WorkloadReportHandler.cs
+++ b/PARR.Core/Services/Task/Handlers/WorkloadReportHandler.cs
@@ -0,0 +1,37 @@
+using Microsoft.Extensions.Logging;
+using PARR.Core.Repositories.Interfaces.TaskRepositories;
+using PARR.Domain.Entities.TaskEntities;
+using PARR.Domain.Enums;
+
+namespace PARR.Core.Services.Task.Handlers
+{
+    /// <summary>
+    /// Обработчик задачаи формирования отчета по загруженности (формирование КЭШ).
+    /// </summary>
+    public class WorkloadReportHandler : BaseTaskHandler
+    {
+
+        public WorkloadReportHandler(ITaskRepository taskRepository, ITaskErrorRepository taskErrorRepository, ILogger<WorkloadReportHandler> logger)
+            : base(taskRepository, taskErrorRepository, logger) { }
+
+        public override TaskTypeEnum SupportedType => TaskTypeEnum.Workload;
+
+        protected override async Task<HandlerResult> ExecuteInternalAsync(TaskItem task)
+        {
+            logger.LogInformation("Генерация КЭШ для workload, taskId: {TaskId}", task.Id);
+
+            // 1. Десериализуем Payload
+            //var payload = string.IsNullOrEmpty(task.Payload)
+            //   ? new ReportPayload()
+            //   : JsonSerializer.Deserialize<ReportPayload>(task.Payload);
+
+            //todo: тут логика построения отчета
+
+            await System.Threading.Tasks.Task.CompletedTask;
+
+            // return HandlerResult.Success();
+
+            return HandlerResult.Failure("Тут капец какая ошибка! Просто жуть", new Exception("А это я создал эксепшен!!!"));
+        }
+    }
+}
--- a/PARR.Core/Services/Workload/Implementations/WorkloadCacheBuilderService.cs
+++ b/PARR.Core/Services/Workload/Implementations/WorkloadCacheBuilderService.cs
@@ -0,0 +1,84 @@
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using PARR.Core.Common.Interfaces;
+using PARR.Core.Common.Interfaces.RabbitServices;
+using PARR.Core.Services.Task.Handlers;
+using PARR.Core.Services.Task.Handlers.Factory;
+using PARR.Core.Services.Workload.Interfaces;
+using PARR.Domain.Common.Rabbit.Messages;
+using PARR.Domain.Enums;
+using PARR.Domain.Settings;
+
+namespace PARR.Core.Services.Workload.Implementations
+{
+    internal class WorkloadCacheBuilderService : IWorkloadCacheBuilderService
+    {
+        private readonly ILogger<WorkloadCacheBuilderService> logger;
+        private readonly IRabbitService rabbitService;
+        private readonly ITransformService transformService;
+        private readonly IServiceProvider serviceProvider;
+
+        public WorkloadCacheBuilderService(
+            ILogger<WorkloadCacheBuilderService> logger,
+            IRabbitService rabbitService,
+            ITransformService transformService,
+            IServiceProvider serviceProvider
+            )
+        {
+            this.logger = logger;
+            this.rabbitService = rabbitService;
+            this.transformService = transformService;
+            this.serviceProvider = serviceProvider;
+        }
+
+
+        public async System.Threading.Tasks.Task ProcessMessagesAsync(IMqSettings mqSettings)
+        {
+            // этот метод вызывается в воркере
+
+            var isConnected = await rabbitService.InitConsumerAsync(mqSettings, async (msg) =>
+            {
+                logger.LogInformation($"Получили запрос: {msg}");
+
+                var queueMessage = transformService.GetModelFromJson<TaskMessage>(msg);
+                if (queueMessage == null)
+                    return;
+
+                // Проверим тип сообщения, что он соответствует текущему сервису
+                if (queueMessage.TypeCode != TaskTypeEnum.Workload)
+                {
+                    logger.LogError("Несоответствие типа: в очереди {Queue} получена задача типа {Actual}", mqSettings.QueueName, queueMessage.TypeCode);
+                    return;
+                }
+
+                using (var scope = serviceProvider.CreateScope())
+                {
+                    var handlerFactory = scope.ServiceProvider.GetRequiredService<ITaskHandlerFactory>();
+                    var handler = handlerFactory.GetHandler(queueMessage.TypeCode);
+
+                    var result = await handler.ProcessAsync(queueMessage.TaskId);
+
+                    // Если ошибка и есть retry — отправляем в очередь с задержкой
+                    if (!result.IsSuccess && handler is BaseTaskHandler baseHandler)
+                    {
+                        // TODO:
+                        // Если ошибка и есть retry — отправляем в очередь с задержкой
+                        // (это упрощенная реализация, в идеале — через ITaskQueueService)
+
+                        // Здесь нужна логика retry с задержкой
+                        // Можно реализовать через отдельный сервис
+                    }
+                }
+            });
+
+            if (!isConnected)
+                throw new Exception("Ошибка при подключении к RabbitMq");
+        }
+
+        public async System.Threading.Tasks.Task StopProcessingAsync()
+        {
+            await rabbitService.DisposeAsync();
+        }
+
+    }
+}
--- a/PARR.Core/Services/Workload/Interfaces/IWorkloadCacheBuilderService.cs
+++ b/PARR.Core/Services/Workload/Interfaces/IWorkloadCacheBuilderService.cs
@@ -0,0 +1,11 @@
+using PARR.Core.Common.Interfaces.RabbitServices.Workers;
+
+namespace PARR.Core.Services.Workload.Interfaces
+{
+    public interface IWorkloadCacheBuilderService : IMessageConsumer
+    {
+
+    }
+}
+
+