DD.WellWorkover.Cloud/AsbCloudInfrastructure/Services/Background/BackgroundWorkerService.cs

using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;

namespace AsbCloudInfrastructure.Services.Background
{
# nullable enable
    public class BackgroundWorkerService : BackgroundService
    {
        private static readonly TimeSpan executePeriod = TimeSpan.FromSeconds(10);
        private static readonly TimeSpan minDelay = TimeSpan.FromSeconds(2);
        private static readonly TimeSpan exceptionHandleTimeout = TimeSpan.FromSeconds(2);
        private readonly IServiceProvider serviceProvider;
        private readonly WorkQueue workQueue = new WorkQueue();

        public BackgroundWorkerService(IServiceProvider serviceProvider)
        {
            this.serviceProvider = serviceProvider;            
        }

        /// <summary>
        /// Добавление задачи в очередь.
        /// Не периодические задачи будут выполняться вперед.
        /// </summary>
        /// <param name="work"></param>
        /// <exception cref="ArgumentException">Id mast be unique</exception>
        public void Push(WorkBase work)
        {
            workQueue.Push(work);
        }

        protected override async Task ExecuteAsync(CancellationToken token)
        {
            while (!token.IsCancellationRequested)
            {
                var dateStart = DateTime.Now;
                var work = workQueue.Pop();
                if (work is null)
                {
                    await Task.Delay(executePeriod, token);
                    continue;
                }

                using (IServiceScope scope = serviceProvider.CreateScope())
                {
                    try
                    {
                        var task = work.ActionAsync(work.Id, scope.ServiceProvider, token);
                        await task.WaitAsync(work.Timeout, token);
                 
                        work.ExecutionTime = DateTime.Now - dateStart;
                        Trace.TraceInformation($"Backgroud work:\"{work.Id}\" done. ExecutionTime: {work.ExecutionTime:hh\\:mm\\:ss\\.fff}");
                    }
                    catch (Exception exception)
                    {
                        Trace.TraceError($"Backgroud work:\"{work.Id}\" throw exception: {exception.Message}");
                        if (work.OnErrorAsync is not null)
                        {
                            using var task = Task.Run(
                                async () => await work.OnErrorAsync(work.Id, exception, token),
                                token);
                            await task.WaitAsync(exceptionHandleTimeout, token);
                        }                        
                    }
                }

                await Task.Delay(minDelay, token);
            }
        }
    }

    /// <summary>
    /// <para>
    /// Очередь работ
    /// </para>
    /// Не периодические задачи будут возвращаться первыми, как самые приоритетные.
    /// </summary>
    public class WorkQueue
    {
        private Queue<WorkBase> Primary = new (8);
        private readonly List<WorkPeriodic> Periodic = new (8);
        internal TimeSpan MaxTimeToNextWork { get; set; } = TimeSpan.FromSeconds(20);

        /// <summary>
        /// Добавление работы.
        /// </summary>
        /// <param name="work"></param>
        /// <exception cref="ArgumentException">Id mast be unique</exception>
        public void Push(WorkBase work)
        {
            if (Periodic.Any(w => w.Id == work.Id))
                throw new ArgumentException("work.Id is not unique", nameof(work));

            if (Primary.Any(w => w.Id == work.Id))
                throw new ArgumentException("work.Id is not unique", nameof(work));

            if (work is WorkPeriodic workPeriodic)
            {
                Periodic.Add(workPeriodic);
                return;
            }

            Primary.Enqueue(work);
        }

        /// <summary>
        /// Удаление работы по ID
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public bool Delete(string id)
        {
            var workPeriodic = Periodic.FirstOrDefault(w => w.Id == id);
            if(workPeriodic is not null)
            {
                Periodic.Remove(workPeriodic);
                return true;
            }

            var work = Primary.FirstOrDefault(w => w.Id == id);
            if (work is not null)
            {
                Primary = new Queue<WorkBase>(Primary.Where(w => w.Id != id));
                return true;
            }

            return false;
        }

        /// <summary>
        /// <para>
        /// Возвращает приоритетную задачу.
        /// </para>
        /// <para>
        /// Если приоритетные закончились, то ищет ближайшую периодическую.
        /// Если до старта ближайшей периодической работы меньше 20 сек,
        /// то этой задаче устанавливается время последнего запуска в now и она возвращается.
        /// Если больше 20 сек, то возвращается null.
        /// </para>
        /// </summary>
        /// <param name="maxTimeToNextWork"></param>
        /// <returns></returns>
        public WorkBase? Pop(TimeSpan? maxTimeToNextWork = null)
        {
            if (Primary.Any())
                return Primary.Dequeue();

            var maxTimeToNextWorkLocal = maxTimeToNextWork ?? MaxTimeToNextWork;
            var work = GetNextPeriodic();
            if (work is null || work.NextStart - DateTime.Now > maxTimeToNextWorkLocal)
                return null;

            work.LastStart = DateTime.Now;
            return work;
        }
        
        private WorkPeriodic? GetNextPeriodic()
        {
            var work = Periodic
                .OrderBy(w => w.NextStart)
                .FirstOrDefault();
            return work;
        }
    }

    public class WorkBase
    {
        /// <summary>
        /// Идентификатор работы. Должен быть уникальным. Используется в логах и передается в колбэки.
        /// </summary>
        public string Id { get; private set; }

        /// <summary>
        /// Делегат работы.
        /// <para>
        /// Параметры:
        ///   <list type="number">
        ///     <item>
        ///         <term>string</term>
        ///         <description>Id Идентификатор работы</description>
        ///     </item>
        ///     <item>
        ///         <term>IServiceProvider</term>
        ///         <description>Поставщик сервисов</description>
        ///     </item>
        ///     <item>
        ///         <term>CancellationToken</term>
        ///         <description>Токен отмены задачи</description>
        ///     </item>
        ///   </list>
        /// </para>
        /// </summary>
        public Func<string, IServiceProvider, CancellationToken, Task> ActionAsync { get; set; }

        /// <summary>
        /// Делегат обработки ошибки.
        /// Не должен выполняться долго.
        /// </summary>
        public Func<string, Exception, CancellationToken, Task>? OnErrorAsync { get; set; }

        /// <summary>
        /// максимально допустимое время выполнения работы
        /// </summary>
        public TimeSpan Timeout { get; set; } = TimeSpan.FromMinutes(1);
        
        /// <summary>
        /// Фактическое время успешного выполнения работы
        /// </summary>
        public TimeSpan? ExecutionTime { get; set; }

        /// <summary>
        /// Время последнего запуска
        /// </summary>
        public DateTime LastStart { get; set; }

        public WorkBase(string id, Func<string, IServiceProvider, CancellationToken, Task> actionAsync)
        {
            Id = id;
            ActionAsync = actionAsync;
        }
    }

    public class WorkPeriodic : WorkBase
    {
        /// <summary>
        /// Период выполнения задачи
        /// </summary>
        public TimeSpan Period { get; set; }

        /// <summary>
        /// Время следующего запуска
        /// </summary>
        public DateTime NextStart => LastStart + Period;

        public WorkPeriodic(string id, Func<string, IServiceProvider, CancellationToken, Task> actionAsync, TimeSpan period)
        :base(id, actionAsync)
        {
            Period = period;
        }
    }
#nullable disable
}