Merge pull request #14028 from Shadowghost/cleanup-tasks

Cleanup Tasks and Validators

1 files changed, 189 insertions, 190 deletions

diff --git a/Emby.Server.Implementations/ScheduledTasks/TaskManager.cs b/Emby.Server.Implementations/ScheduledTasks/TaskManager.cs
index a5e4104ff..4ec2c9c78 100644
--- a/Emby.Server.Implementations/ScheduledTasks/TaskManager.cs
+++ b/Emby.Server.Implementations/ScheduledTasks/TaskManager.cs
@@ -8,255 +8,254 @@ using MediaBrowser.Common.Configuration;
 using MediaBrowser.Model.Tasks;
 using Microsoft.Extensions.Logging;
 
-namespace Emby.Server.Implementations.ScheduledTasks
+namespace Emby.Server.Implementations.ScheduledTasks;
+
+/// <summary>
+/// Class TaskManager.
+/// </summary>
+public class TaskManager : ITaskManager
 {
     /// <summary>
-    /// Class TaskManager.
+    /// The _task queue.
     /// </summary>
-    public class TaskManager : ITaskManager
-    {
-        /// <summary>
-        /// The _task queue.
-        /// </summary>
-        private readonly ConcurrentQueue<Tuple<Type, TaskOptions>> _taskQueue =
-            new ConcurrentQueue<Tuple<Type, TaskOptions>>();
-
-        private readonly IApplicationPaths _applicationPaths;
-        private readonly ILogger<TaskManager> _logger;
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="TaskManager" /> class.
-        /// </summary>
-        /// <param name="applicationPaths">The application paths.</param>
-        /// <param name="logger">The logger.</param>
-        public TaskManager(
-            IApplicationPaths applicationPaths,
-            ILogger<TaskManager> logger)
-        {
-            _applicationPaths = applicationPaths;
-            _logger = logger;
+    private readonly ConcurrentQueue<Tuple<Type, TaskOptions>> _taskQueue =
+        new ConcurrentQueue<Tuple<Type, TaskOptions>>();
 
-            ScheduledTasks = Array.Empty<IScheduledTaskWorker>();
-        }
+    private readonly IApplicationPaths _applicationPaths;
+    private readonly ILogger<TaskManager> _logger;
 
-        /// <inheritdoc />
-        public event EventHandler<GenericEventArgs<IScheduledTaskWorker>>? TaskExecuting;
+    /// <summary>
+    /// Initializes a new instance of the <see cref="TaskManager" /> class.
+    /// </summary>
+    /// <param name="applicationPaths">The application paths.</param>
+    /// <param name="logger">The logger.</param>
+    public TaskManager(
+        IApplicationPaths applicationPaths,
+        ILogger<TaskManager> logger)
+    {
+        _applicationPaths = applicationPaths;
+        _logger = logger;
 
-        /// <inheritdoc />
-        public event EventHandler<TaskCompletionEventArgs>? TaskCompleted;
+        ScheduledTasks = [];
+    }
 
-        /// <inheritdoc />
-        public IReadOnlyList<IScheduledTaskWorker> ScheduledTasks { get; private set; }
+    /// <inheritdoc />
+    public event EventHandler<GenericEventArgs<IScheduledTaskWorker>>? TaskExecuting;
 
-        /// <inheritdoc />
-        public void CancelIfRunningAndQueue<T>(TaskOptions options)
-            where T : IScheduledTask
-        {
-            var task = ScheduledTasks.First(t => t.ScheduledTask.GetType() == typeof(T));
-            ((ScheduledTaskWorker)task).CancelIfRunning();
+    /// <inheritdoc />
+    public event EventHandler<TaskCompletionEventArgs>? TaskCompleted;
 
-            QueueScheduledTask<T>(options);
-        }
+    /// <inheritdoc />
+    public IReadOnlyList<IScheduledTaskWorker> ScheduledTasks { get; private set; }
 
-        /// <inheritdoc />
-        public void CancelIfRunningAndQueue<T>()
-               where T : IScheduledTask
-        {
-            CancelIfRunningAndQueue<T>(new TaskOptions());
-        }
+    /// <inheritdoc />
+    public void CancelIfRunningAndQueue<T>(TaskOptions options)
+        where T : IScheduledTask
+    {
+        var task = ScheduledTasks.First(t => t.ScheduledTask.GetType() == typeof(T));
+        ((ScheduledTaskWorker)task).CancelIfRunning();
 
-        /// <inheritdoc />
-        public void CancelIfRunning<T>()
-                 where T : IScheduledTask
-        {
-            var task = ScheduledTasks.First(t => t.ScheduledTask.GetType() == typeof(T));
-            ((ScheduledTaskWorker)task).CancelIfRunning();
-        }
+        QueueScheduledTask<T>(options);
+    }
 
-        /// <inheritdoc />
-        public void QueueScheduledTask<T>(TaskOptions options)
+    /// <inheritdoc />
+    public void CancelIfRunningAndQueue<T>()
             where T : IScheduledTask
-        {
-            var scheduledTask = ScheduledTasks.FirstOrDefault(t => t.ScheduledTask.GetType() == typeof(T));
+    {
+        CancelIfRunningAndQueue<T>(new TaskOptions());
+    }
 
-            if (scheduledTask is null)
-            {
-                _logger.LogError("Unable to find scheduled task of type {0} in QueueScheduledTask.", typeof(T).Name);
-            }
-            else
-            {
-                QueueScheduledTask(scheduledTask, options);
-            }
-        }
+    /// <inheritdoc />
+    public void CancelIfRunning<T>()
+                where T : IScheduledTask
+    {
+        var task = ScheduledTasks.First(t => t.ScheduledTask.GetType() == typeof(T));
+        ((ScheduledTaskWorker)task).CancelIfRunning();
+    }
 
-        /// <inheritdoc />
-        public void QueueScheduledTask<T>()
-            where T : IScheduledTask
-        {
-            QueueScheduledTask<T>(new TaskOptions());
-        }
+    /// <inheritdoc />
+    public void QueueScheduledTask<T>(TaskOptions options)
+        where T : IScheduledTask
+    {
+        var scheduledTask = ScheduledTasks.FirstOrDefault(t => t.ScheduledTask.GetType() == typeof(T));
 
-        /// <inheritdoc />
-        public void QueueIfNotRunning<T>()
-            where T : IScheduledTask
+        if (scheduledTask is null)
         {
-            var task = ScheduledTasks.First(t => t.ScheduledTask.GetType() == typeof(T));
-
-            if (task.State != TaskState.Running)
-            {
-                QueueScheduledTask<T>(new TaskOptions());
-            }
+            _logger.LogError("Unable to find scheduled task of type {Type} in QueueScheduledTask.", typeof(T).Name);
         }
-
-        /// <inheritdoc />
-        public void Execute<T>()
-            where T : IScheduledTask
+        else
         {
-            var scheduledTask = ScheduledTasks.FirstOrDefault(t => t.ScheduledTask.GetType() == typeof(T));
+            QueueScheduledTask(scheduledTask, options);
+        }
+    }
 
-            if (scheduledTask is null)
-            {
-                _logger.LogError("Unable to find scheduled task of type {0} in Execute.", typeof(T).Name);
-            }
-            else
-            {
-                var type = scheduledTask.ScheduledTask.GetType();
+    /// <inheritdoc />
+    public void QueueScheduledTask<T>()
+        where T : IScheduledTask
+    {
+        QueueScheduledTask<T>(new TaskOptions());
+    }
 
-                _logger.LogDebug("Queuing task {0}", type.Name);
+    /// <inheritdoc />
+    public void QueueIfNotRunning<T>()
+        where T : IScheduledTask
+    {
+        var task = ScheduledTasks.First(t => t.ScheduledTask.GetType() == typeof(T));
 
-                lock (_taskQueue)
-                {
-                    if (scheduledTask.State == TaskState.Idle)
-                    {
-                        Execute(scheduledTask, new TaskOptions());
-                    }
-                }
-            }
+        if (task.State != TaskState.Running)
+        {
+            QueueScheduledTask<T>(new TaskOptions());
         }
+    }
 
-        /// <inheritdoc />
-        public void QueueScheduledTask(IScheduledTask task, TaskOptions options)
-        {
-            var scheduledTask = ScheduledTasks.FirstOrDefault(t => t.ScheduledTask.GetType() == task.GetType());
+    /// <inheritdoc />
+    public void Execute<T>()
+        where T : IScheduledTask
+    {
+        var scheduledTask = ScheduledTasks.FirstOrDefault(t => t.ScheduledTask.GetType() == typeof(T));
 
-            if (scheduledTask is null)
-            {
-                _logger.LogError("Unable to find scheduled task of type {0} in QueueScheduledTask.", task.GetType().Name);
-            }
-            else
-            {
-                QueueScheduledTask(scheduledTask, options);
-            }
+        if (scheduledTask is null)
+        {
+            _logger.LogError("Unable to find scheduled task of type {Type} in Execute.", typeof(T).Name);
         }
-
-        /// <summary>
-        /// Queues the scheduled task.
-        /// </summary>
-        /// <param name="task">The task.</param>
-        /// <param name="options">The task options.</param>
-        private void QueueScheduledTask(IScheduledTaskWorker task, TaskOptions options)
+        else
         {
-            var type = task.ScheduledTask.GetType();
+            var type = scheduledTask.ScheduledTask.GetType();
 
-            _logger.LogDebug("Queuing task {0}", type.Name);
+            _logger.LogDebug("Queuing task {Name}", type.Name);
 
             lock (_taskQueue)
             {
-                if (task.State == TaskState.Idle)
+                if (scheduledTask.State == TaskState.Idle)
                 {
-                    Execute(task, options);
-                    return;
+                    Execute(scheduledTask, new TaskOptions());
                 }
-
-                _taskQueue.Enqueue(new Tuple<Type, TaskOptions>(type, options));
             }
         }
+    }
 
-        /// <inheritdoc />
-        public void AddTasks(IEnumerable<IScheduledTask> tasks)
-        {
-            var list = tasks.Select(t => new ScheduledTaskWorker(t, _applicationPaths, this, _logger));
+    /// <inheritdoc />
+    public void QueueScheduledTask(IScheduledTask task, TaskOptions options)
+    {
+        var scheduledTask = ScheduledTasks.FirstOrDefault(t => t.ScheduledTask.GetType() == task.GetType());
 
-            ScheduledTasks = ScheduledTasks.Concat(list).ToArray();
+        if (scheduledTask is null)
+        {
+            _logger.LogError("Unable to find scheduled task of type {Type} in QueueScheduledTask.", task.GetType().Name);
         }
-
-        /// <inheritdoc />
-        public void Dispose()
+        else
         {
-            Dispose(true);
-            GC.SuppressFinalize(this);
+            QueueScheduledTask(scheduledTask, options);
         }
+    }
+
+    /// <summary>
+    /// Queues the scheduled task.
+    /// </summary>
+    /// <param name="task">The task.</param>
+    /// <param name="options">The task options.</param>
+    private void QueueScheduledTask(IScheduledTaskWorker task, TaskOptions options)
+    {
+        var type = task.ScheduledTask.GetType();
+
+        _logger.LogDebug("Queuing task {Name}", type.Name);
 
-        /// <summary>
-        /// Releases unmanaged and - optionally - managed resources.
-        /// </summary>
-        /// <param name="dispose"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
-        protected virtual void Dispose(bool dispose)
+        lock (_taskQueue)
         {
-            foreach (var task in ScheduledTasks)
+            if (task.State == TaskState.Idle)
             {
-                task.Dispose();
+                Execute(task, options);
+                return;
             }
-        }
 
-        /// <inheritdoc />
-        public void Cancel(IScheduledTaskWorker task)
-        {
-            ((ScheduledTaskWorker)task).Cancel();
+            _taskQueue.Enqueue(new Tuple<Type, TaskOptions>(type, options));
         }
+    }
 
-        /// <inheritdoc />
-        public Task Execute(IScheduledTaskWorker task, TaskOptions options)
-        {
-            return ((ScheduledTaskWorker)task).Execute(options);
-        }
+    /// <inheritdoc />
+    public void AddTasks(IEnumerable<IScheduledTask> tasks)
+    {
+        var list = tasks.Select(t => new ScheduledTaskWorker(t, _applicationPaths, this, _logger));
+
+        ScheduledTasks = ScheduledTasks.Concat(list).ToArray();
+    }
+
+    /// <inheritdoc />
+    public void Dispose()
+    {
+        Dispose(true);
+        GC.SuppressFinalize(this);
+    }
 
-        /// <summary>
-        /// Called when [task executing].
-        /// </summary>
-        /// <param name="task">The task.</param>
-        internal void OnTaskExecuting(IScheduledTaskWorker task)
+    /// <summary>
+    /// Releases unmanaged and - optionally - managed resources.
+    /// </summary>
+    /// <param name="dispose"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
+    protected virtual void Dispose(bool dispose)
+    {
+        foreach (var task in ScheduledTasks)
         {
-            TaskExecuting?.Invoke(this, new GenericEventArgs<IScheduledTaskWorker>(task));
+            task.Dispose();
         }
+    }
 
-        /// <summary>
-        /// Called when [task completed].
-        /// </summary>
-        /// <param name="task">The task.</param>
-        /// <param name="result">The result.</param>
-        internal void OnTaskCompleted(IScheduledTaskWorker task, TaskResult result)
-        {
-            TaskCompleted?.Invoke(task, new TaskCompletionEventArgs(task, result));
+    /// <inheritdoc />
+    public void Cancel(IScheduledTaskWorker task)
+    {
+        ((ScheduledTaskWorker)task).Cancel();
+    }
 
-            ExecuteQueuedTasks();
-        }
+    /// <inheritdoc />
+    public Task Execute(IScheduledTaskWorker task, TaskOptions options)
+    {
+        return ((ScheduledTaskWorker)task).Execute(options);
+    }
+
+    /// <summary>
+    /// Called when [task executing].
+    /// </summary>
+    /// <param name="task">The task.</param>
+    internal void OnTaskExecuting(IScheduledTaskWorker task)
+    {
+        TaskExecuting?.Invoke(this, new GenericEventArgs<IScheduledTaskWorker>(task));
+    }
+
+    /// <summary>
+    /// Called when [task completed].
+    /// </summary>
+    /// <param name="task">The task.</param>
+    /// <param name="result">The result.</param>
+    internal void OnTaskCompleted(IScheduledTaskWorker task, TaskResult result)
+    {
+        TaskCompleted?.Invoke(task, new TaskCompletionEventArgs(task, result));
+
+        ExecuteQueuedTasks();
+    }
 
-        /// <summary>
-        /// Executes the queued tasks.
-        /// </summary>
-        private void ExecuteQueuedTasks()
+    /// <summary>
+    /// Executes the queued tasks.
+    /// </summary>
+    private void ExecuteQueuedTasks()
+    {
+        lock (_taskQueue)
         {
-            lock (_taskQueue)
-            {
-                var list = new List<Tuple<Type, TaskOptions>>();
+            var list = new List<Tuple<Type, TaskOptions>>();
 
-                while (_taskQueue.TryDequeue(out var item))
+            while (_taskQueue.TryDequeue(out var item))
+            {
+                if (list.All(i => i.Item1 != item.Item1))
                 {
-                    if (list.All(i => i.Item1 != item.Item1))
-                    {
-                        list.Add(item);
-                    }
+                    list.Add(item);
                 }
+            }
 
-                foreach (var enqueuedType in list)
-                {
-                    var scheduledTask = ScheduledTasks.First(t => t.ScheduledTask.GetType() == enqueuedType.Item1);
+            foreach (var enqueuedType in list)
+            {
+                var scheduledTask = ScheduledTasks.First(t => t.ScheduledTask.GetType() == enqueuedType.Item1);
 
-                    if (scheduledTask.State == TaskState.Idle)
-                    {
-                        Execute(scheduledTask, enqueuedType.Item2);
-                    }
+                if (scheduledTask.State == TaskState.Idle)
+                {
+                    Execute(scheduledTask, enqueuedType.Item2);
                 }
             }
         }