wabbajack/Wabbajack.Server/Services/AbstractService.cs

using System;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.Logging;
using Wabbajack.BuildServer;
using Wabbajack.Common;

namespace Wabbajack.Server.Services
{
    public interface IStartable
    {
        public Task Start();
    }

    public interface IReportingService
    {
        public TimeSpan Delay { get; }
        public DateTime LastStart { get; }
        public DateTime LastEnd { get; }
        
        public (String, DateTime)[] ActiveWorkStatus { get; }

        
    }
    
    public abstract class AbstractService<TP, TR> : IStartable, IReportingService
    {
        protected AppSettings _settings;
        private TimeSpan _delay;
        protected ILogger<TP> _logger;
        protected QuickSync _quickSync;

        public TimeSpan Delay => _delay;
        public DateTime LastStart { get; private set; }
        public DateTime LastEnd { get; private set; }
        public (String, DateTime)[] ActiveWorkStatus { get; private set; }= { };

        public AbstractService(ILogger<TP> logger, AppSettings settings, QuickSync quickSync, TimeSpan delay)
        {
            _settings = settings;
            _delay = delay;
            _logger = logger;
            _quickSync = quickSync;

        }

        public virtual async Task Setup()
        {
            
        }

        public async Task Start()
        {
            await Setup();
            await _quickSync.Register(this);
                    
            while (true)
            {
                await _quickSync.ResetToken<TP>();
                try
                {
                    _logger.LogInformation($"Running: {GetType().Name}");
                    ActiveWorkStatus = Array.Empty<(String, DateTime)>();
                    LastStart = DateTime.UtcNow;
                    await Execute();
                    LastEnd = DateTime.UtcNow;
                }
                catch (Exception ex)
                {
                    _logger.LogError(ex, "Running Service Loop");
                }

                var token = await _quickSync.GetToken<TP>();
                try
                {
                    await Task.Delay(_delay, token);
                }
                catch (TaskCanceledException)
                {
                            
                }
            }
        }

        public abstract Task<TR> Execute();
        
        protected void ReportStarting(string value)
        {
            lock (this)
            {
                ActiveWorkStatus = ActiveWorkStatus.Append((value, DateTime.UtcNow)).ToArray();
            }
        }

        protected void ReportEnding(string value)
        {
            lock (this)
            {
                ActiveWorkStatus = ActiveWorkStatus.Where(x => x.Item1 != value).ToArray();
            }
        }
    }
    
    public static class AbstractServiceExtensions 
    {
        public static void UseService<T>(this IApplicationBuilder b)
        {
            var poll = (IStartable)b.ApplicationServices.GetService(typeof(T));
            poll.Start();
        }
    
    }
    
    
}