src/Services/NotificationService.EmailService/Workers/EmailWorker.cs - master - VFlov/NotificationService_1

src/Services/NotificationService.EmailService/Workers/EmailWorker.cs
161 строка6 KB
VFlov
Update
25 дек 2025, 21:02
25 дек 2025, 21:02cf3965d
using NotificationService.Shared.Constants;
using NotificationService.Shared.Interfaces;
using NotificationService.Shared.Models;
using System.Diagnostics;

namespace NotificationService.EmailService.Workers;

/// <summary>
/// Background worker для обработки email уведомлений из очереди
/// </summary>
public class EmailWorker : BackgroundService
{
    private readonly ILogger<EmailWorker> _logger;
    private readonly IServiceProvider _serviceProvider;

    public EmailWorker(ILogger<EmailWorker> logger, IServiceProvider serviceProvider)
    {
        _logger = logger ?? throw new ArgumentNullException(nameof(logger));
        _serviceProvider = serviceProvider ?? throw new ArgumentNullException(nameof(serviceProvider));
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        _logger.LogInformation("Email Worker starting...");

        try
        {
            using var scope = _serviceProvider.CreateScope();
            var messageQueue = scope.ServiceProvider.GetRequiredService<IMessageQueue>();
            var repository = scope.ServiceProvider.GetRequiredService<INotificationRepository>();
            var emailSender = scope.ServiceProvider.GetRequiredService<INotificationSender>();

            _logger.LogInformation("Email Worker started successfully, subscribing to queue: {Queue}", QueueNames.EmailQueue);

            await messageQueue.SubscribeAsync<NotificationMessage>(
                QueueNames.EmailQueue,
                async (message) => await ProcessMessageAsync(message, repository, emailSender, stoppingToken),
                stoppingToken);

            await Task.Delay(Timeout.Infinite, stoppingToken);
        }
        catch (Exception ex)
        {
            _logger.LogCritical(ex, "Email Worker failed to start");
            throw;
        }
    }

    private async Task<bool> ProcessMessageAsync(
        NotificationMessage message,
        INotificationRepository repository,
        INotificationSender emailSender,
        CancellationToken cancellationToken)
    {
        var stopwatch = Stopwatch.StartNew();

        try
        {
            if (message == null)
            {
                _logger.LogWarning("Received null message from queue");
                return false;
            }

            _logger.LogInformation(
                "Processing email notification - Id: {Id}, Recipient: {Recipient}",
                message.Id, message.Recipient);

            // Получаем запись из БД
            var record = await repository.GetByIdAsync(message.Id, cancellationToken);
            if (record == null)
            {
                _logger.LogWarning(
                    "Notification record not found in database - Id: {Id}",
                    message.Id);
                return false;
            }

            // Обновляем статус на Processing
            record.Status = NotificationStatus.Processing;
            await repository.UpdateAsync(record, cancellationToken);

            _logger.LogDebug(
                "Sending email notification - Id: {Id}",
                message.Id);

            // Отправляем
            var success = await emailSender.SendAsync(message, cancellationToken);

            stopwatch.Stop();

            // Обновляем финальный статус
            if (success)
            {
                record.Status = NotificationStatus.Sent;
                record.SentAt = DateTime.UtcNow;
                record.ErrorMessage = null;
                
                _logger.LogInformation(
                    "Email notification sent successfully - Id: {Id}, Duration: {Duration}ms",
                    message.Id, stopwatch.ElapsedMilliseconds);
            }
            else
            {
                record.RetryCount++;
                
                if (record.RetryCount < message.MaxRetries)
                {
                    record.Status = NotificationStatus.Retry;
                    _logger.LogWarning(
                        "Email notification failed, will retry - Id: {Id}, RetryCount: {RetryCount}/{MaxRetries}, Duration: {Duration}ms",
                        message.Id, record.RetryCount, message.MaxRetries, stopwatch.ElapsedMilliseconds);
                }
                else
                {
                    record.Status = NotificationStatus.Failed;
                    record.ErrorMessage = "Failed to send email after maximum retries";
                    
                    _logger.LogError(
                        "Email notification failed permanently - Id: {Id}, MaxRetries: {MaxRetries}, Duration: {Duration}ms",
                        message.Id, message.MaxRetries, stopwatch.ElapsedMilliseconds);
                }
            }

            await repository.UpdateAsync(record, cancellationToken);
            return success;
        }
        catch (Exception ex)
        {
            stopwatch.Stop();
            
            _logger.LogError(ex,
                "Error processing email notification - Id: {Id}, Duration: {Duration}ms",
                message?.Id, stopwatch.ElapsedMilliseconds);
            
            // Пытаемся обновить статус в БД
            if (message != null)
            {
                try
                {
                    var record = await repository.GetByIdAsync(message.Id, cancellationToken);
                    if (record != null)
                    {
                        record.Status = NotificationStatus.Failed;
                        record.ErrorMessage = ex.Message;
                        record.RetryCount++;
                        await repository.UpdateAsync(record, cancellationToken);
                    }
                }
                catch (Exception updateEx)
                {
                    _logger.LogError(updateEx,
                        "Failed to update notification record after error - Id: {Id}",
                        message.Id);
                }
            }

            return false;
        }
    }
}