Merge remote-tracking branch 'upstream/master' into api-upload-subtitle

1 files changed, 98 insertions, 89 deletions

diff --git a/Emby.Server.Implementations/ScheduledTasks/ScheduledTaskWorker.cs b/Emby.Server.Implementations/ScheduledTasks/ScheduledTaskWorker.cs
index 5b188d962..bc01f9543 100644
--- a/Emby.Server.Implementations/ScheduledTasks/ScheduledTaskWorker.cs
+++ b/Emby.Server.Implementations/ScheduledTasks/ScheduledTaskWorker.cs
@@ -1,14 +1,15 @@
+#pragma warning disable CS1591
+
 using System;
 using System.Globalization;
 using System.IO;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using Jellyfin.Data.Events;
 using MediaBrowser.Common.Configuration;
 using MediaBrowser.Common.Extensions;
 using MediaBrowser.Common.Progress;
-using MediaBrowser.Model.Events;
-using MediaBrowser.Model.IO;
 using MediaBrowser.Model.Serialization;
 using MediaBrowser.Model.Tasks;
 using Microsoft.Extensions.Logging;
@@ -16,42 +17,57 @@ using Microsoft.Extensions.Logging;
 namespace Emby.Server.Implementations.ScheduledTasks
 {
     /// <summary>
-    /// Class ScheduledTaskWorker
+    /// Class ScheduledTaskWorker.
     /// </summary>
     public class ScheduledTaskWorker : IScheduledTaskWorker
     {
-        public event EventHandler<GenericEventArgs<double>> TaskProgress;
-
-        /// <summary>
-        /// Gets the scheduled task.
-        /// </summary>
-        /// <value>The scheduled task.</value>
-        public IScheduledTask ScheduledTask { get; private set; }
-
         /// <summary>
         /// Gets or sets the json serializer.
         /// </summary>
         /// <value>The json serializer.</value>
-        private IJsonSerializer JsonSerializer { get; set; }
+        private readonly IJsonSerializer _jsonSerializer;
 
         /// <summary>
         /// Gets or sets the application paths.
         /// </summary>
         /// <value>The application paths.</value>
-        private IApplicationPaths ApplicationPaths { get; set; }
+        private readonly IApplicationPaths _applicationPaths;
 
         /// <summary>
-        /// Gets the logger.
+        /// Gets or sets the logger.
         /// </summary>
         /// <value>The logger.</value>
-        private ILogger Logger { get; set; }
+        private readonly ILogger _logger;
 
         /// <summary>
-        /// Gets the task manager.
+        /// Gets or sets the task manager.
         /// </summary>
         /// <value>The task manager.</value>
-        private ITaskManager TaskManager { get; set; }
-        private readonly IFileSystem _fileSystem;
+        private readonly ITaskManager _taskManager;
+
+        /// <summary>
+        /// The _last execution result sync lock.
+        /// </summary>
+        private readonly object _lastExecutionResultSyncLock = new object();
+
+        private bool _readFromFile = false;
+
+        /// <summary>
+        /// The _last execution result.
+        /// </summary>
+        private TaskResult _lastExecutionResult;
+
+        private Task _currentTask;
+
+        /// <summary>
+        /// The _triggers.
+        /// </summary>
+        private Tuple<TaskTriggerInfo, ITaskTrigger>[] _triggers;
+
+        /// <summary>
+        /// The _id.
+        /// </summary>
+        private string _id;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="ScheduledTaskWorker" /> class.
@@ -70,50 +86,52 @@ namespace Emby.Server.Implementations.ScheduledTasks
         /// or
         /// jsonSerializer
         /// or
-        /// logger
+        /// logger.
         /// </exception>
-        public ScheduledTaskWorker(IScheduledTask scheduledTask, IApplicationPaths applicationPaths, ITaskManager taskManager, IJsonSerializer jsonSerializer, ILogger logger, IFileSystem fileSystem)
+        public ScheduledTaskWorker(IScheduledTask scheduledTask, IApplicationPaths applicationPaths, ITaskManager taskManager, IJsonSerializer jsonSerializer, ILogger logger)
         {
             if (scheduledTask == null)
             {
                 throw new ArgumentNullException(nameof(scheduledTask));
             }
+
             if (applicationPaths == null)
             {
                 throw new ArgumentNullException(nameof(applicationPaths));
             }
+
             if (taskManager == null)
             {
                 throw new ArgumentNullException(nameof(taskManager));
             }
+
             if (jsonSerializer == null)
             {
                 throw new ArgumentNullException(nameof(jsonSerializer));
             }
+
             if (logger == null)
             {
                 throw new ArgumentNullException(nameof(logger));
             }
 
             ScheduledTask = scheduledTask;
-            ApplicationPaths = applicationPaths;
-            TaskManager = taskManager;
-            JsonSerializer = jsonSerializer;
-            Logger = logger;
-            _fileSystem = fileSystem;
+            _applicationPaths = applicationPaths;
+            _taskManager = taskManager;
+            _jsonSerializer = jsonSerializer;
+            _logger = logger;
 
             InitTriggerEvents();
         }
 
-        private bool _readFromFile = false;
-        /// <summary>
-        /// The _last execution result
-        /// </summary>
-        private TaskResult _lastExecutionResult;
+        public event EventHandler<GenericEventArgs<double>> TaskProgress;
+
         /// <summary>
-        /// The _last execution result sync lock
+        /// Gets the scheduled task.
         /// </summary>
-        private readonly object _lastExecutionResultSyncLock = new object();
+        /// <value>The scheduled task.</value>
+        public IScheduledTask ScheduledTask { get; private set; }
+
         /// <summary>
         /// Gets the last execution result.
         /// </summary>
@@ -132,19 +150,21 @@ namespace Emby.Server.Implementations.ScheduledTasks
                         {
                             try
                             {
-                                _lastExecutionResult = JsonSerializer.DeserializeFromFile<TaskResult>(path);
+                                _lastExecutionResult = _jsonSerializer.DeserializeFromFile<TaskResult>(path);
                             }
                             catch (Exception ex)
                             {
-                                Logger.LogError(ex, "Error deserializing {File}", path);
+                                _logger.LogError(ex, "Error deserializing {File}", path);
                             }
                         }
+
                         _readFromFile = true;
                     }
                 }
 
                 return _lastExecutionResult;
             }
+
             private set
             {
                 _lastExecutionResult = value;
@@ -154,7 +174,7 @@ namespace Emby.Server.Implementations.ScheduledTasks
 
                 lock (_lastExecutionResultSyncLock)
                 {
-                    JsonSerializer.SerializeToFile(value, path);
+                    _jsonSerializer.SerializeToFile(value, path);
                 }
             }
         }
@@ -178,7 +198,7 @@ namespace Emby.Server.Implementations.ScheduledTasks
         public string Category => ScheduledTask.Category;
 
         /// <summary>
-        /// Gets the current cancellation token
+        /// Gets or sets the current cancellation token.
         /// </summary>
         /// <value>The current cancellation token source.</value>
         private CancellationTokenSource CurrentCancellationTokenSource { get; set; }
@@ -215,12 +235,7 @@ namespace Emby.Server.Implementations.ScheduledTasks
         public double? CurrentProgress { get; private set; }
 
         /// <summary>
-        /// The _triggers.
-        /// </summary>
-        private Tuple<TaskTriggerInfo, ITaskTrigger>[] _triggers;
-
-        /// <summary>
-        /// Gets the triggers that define when the task will run.
+        /// Gets or sets the triggers that define when the task will run.
         /// </summary>
         /// <value>The triggers.</value>
         private Tuple<TaskTriggerInfo, ITaskTrigger>[] InternalTriggers
@@ -249,7 +264,7 @@ namespace Emby.Server.Implementations.ScheduledTasks
         /// Gets the triggers that define when the task will run.
         /// </summary>
         /// <value>The triggers.</value>
-        /// <exception cref="ArgumentNullException">value</exception>
+        /// <exception cref="ArgumentNullException"><c>value</c> is <c>null</c>.</exception>
         public TaskTriggerInfo[] Triggers
         {
             get
@@ -257,6 +272,7 @@ namespace Emby.Server.Implementations.ScheduledTasks
                 var triggers = InternalTriggers;
                 return triggers.Select(i => i.Item1).ToArray();
             }
+
             set
             {
                 if (value == null)
@@ -274,11 +290,6 @@ namespace Emby.Server.Implementations.ScheduledTasks
         }
 
         /// <summary>
-        /// The _id
-        /// </summary>
-        private string _id;
-
-        /// <summary>
         /// Gets the unique id.
         /// </summary>
         /// <value>The unique id.</value>
@@ -318,9 +329,9 @@ namespace Emby.Server.Implementations.ScheduledTasks
 
                 trigger.Stop();
 
-                trigger.Triggered -= trigger_Triggered;
-                trigger.Triggered += trigger_Triggered;
-                trigger.Start(LastExecutionResult, Logger, Name, isApplicationStartup);
+                trigger.Triggered -= OnTriggerTriggered;
+                trigger.Triggered += OnTriggerTriggered;
+                trigger.Start(LastExecutionResult, _logger, Name, isApplicationStartup);
             }
         }
 
@@ -329,7 +340,7 @@ namespace Emby.Server.Implementations.ScheduledTasks
         /// </summary>
         /// <param name="sender">The source of the event.</param>
         /// <param name="e">The <see cref="EventArgs" /> instance containing the event data.</param>
-        async void trigger_Triggered(object sender, EventArgs e)
+        private async void OnTriggerTriggered(object sender, EventArgs e)
         {
             var trigger = (ITaskTrigger)sender;
 
@@ -340,21 +351,19 @@ namespace Emby.Server.Implementations.ScheduledTasks
                 return;
             }
 
-            Logger.LogInformation("{0} fired for task: {1}", trigger.GetType().Name, Name);
+            _logger.LogInformation("{0} fired for task: {1}", trigger.GetType().Name, Name);
 
             trigger.Stop();
 
-            TaskManager.QueueScheduledTask(ScheduledTask, trigger.TaskOptions);
+            _taskManager.QueueScheduledTask(ScheduledTask, trigger.TaskOptions);
 
             await Task.Delay(1000).ConfigureAwait(false);
 
-            trigger.Start(LastExecutionResult, Logger, Name, false);
+            trigger.Start(LastExecutionResult, _logger, Name, false);
         }
 
-        private Task _currentTask;
-
         /// <summary>
-        /// Executes the task
+        /// Executes the task.
         /// </summary>
         /// <param name="options">Task options.</param>
         /// <returns>Task.</returns>
@@ -388,11 +397,11 @@ namespace Emby.Server.Implementations.ScheduledTasks
 
             CurrentCancellationTokenSource = new CancellationTokenSource();
 
-            Logger.LogInformation("Executing {0}", Name);
+            _logger.LogInformation("Executing {0}", Name);
 
-            ((TaskManager)TaskManager).OnTaskExecuting(this);
+            ((TaskManager)_taskManager).OnTaskExecuting(this);
 
-            progress.ProgressChanged += progress_ProgressChanged;
+            progress.ProgressChanged += OnProgressChanged;
 
             TaskCompletionStatus status;
             CurrentExecutionStartTime = DateTime.UtcNow;
@@ -416,7 +425,7 @@ namespace Emby.Server.Implementations.ScheduledTasks
             }
             catch (Exception ex)
             {
-                Logger.LogError(ex, "Error");
+                _logger.LogError(ex, "Error");
 
                 failureException = ex;
 
@@ -426,7 +435,7 @@ namespace Emby.Server.Implementations.ScheduledTasks
             var startTime = CurrentExecutionStartTime;
             var endTime = DateTime.UtcNow;
 
-            progress.ProgressChanged -= progress_ProgressChanged;
+            progress.ProgressChanged -= OnProgressChanged;
             CurrentCancellationTokenSource.Dispose();
             CurrentCancellationTokenSource = null;
             CurrentProgress = null;
@@ -439,20 +448,17 @@ namespace Emby.Server.Implementations.ScheduledTasks
         /// </summary>
         /// <param name="sender">The sender.</param>
         /// <param name="e">The e.</param>
-        void progress_ProgressChanged(object sender, double e)
+        private void OnProgressChanged(object sender, double e)
         {
             e = Math.Min(e, 100);
 
             CurrentProgress = e;
 
-            TaskProgress?.Invoke(this, new GenericEventArgs<double>
-            {
-                Argument = e
-            });
+            TaskProgress?.Invoke(this, new GenericEventArgs<double>(e));
         }
 
         /// <summary>
-        /// Stops the task if it is currently executing
+        /// Stops the task if it is currently executing.
         /// </summary>
         /// <exception cref="InvalidOperationException">Cannot cancel a Task unless it is in the Running state.</exception>
         public void Cancel()
@@ -472,7 +478,7 @@ namespace Emby.Server.Implementations.ScheduledTasks
         {
             if (State == TaskState.Running)
             {
-                Logger.LogInformation("Attempting to cancel Scheduled Task {0}", Name);
+                _logger.LogInformation("Attempting to cancel Scheduled Task {0}", Name);
                 CurrentCancellationTokenSource.Cancel();
             }
         }
@@ -483,7 +489,7 @@ namespace Emby.Server.Implementations.ScheduledTasks
         /// <returns>System.String.</returns>
         private string GetScheduledTasksConfigurationDirectory()
         {
-            return Path.Combine(ApplicationPaths.ConfigurationDirectoryPath, "ScheduledTasks");
+            return Path.Combine(_applicationPaths.ConfigurationDirectoryPath, "ScheduledTasks");
         }
 
         /// <summary>
@@ -492,7 +498,7 @@ namespace Emby.Server.Implementations.ScheduledTasks
         /// <returns>System.String.</returns>
         private string GetScheduledTasksDataDirectory()
         {
-            return Path.Combine(ApplicationPaths.DataPath, "ScheduledTasks");
+            return Path.Combine(_applicationPaths.DataPath, "ScheduledTasks");
         }
 
         /// <summary>
@@ -531,7 +537,7 @@ namespace Emby.Server.Implementations.ScheduledTasks
             TaskTriggerInfo[] list = null;
             if (File.Exists(path))
             {
-                list = JsonSerializer.DeserializeFromFile<TaskTriggerInfo[]>(path);
+                list = _jsonSerializer.DeserializeFromFile<TaskTriggerInfo[]>(path);
             }
 
             // Return defaults if file doesn't exist.
@@ -567,7 +573,7 @@ namespace Emby.Server.Implementations.ScheduledTasks
 
             Directory.CreateDirectory(Path.GetDirectoryName(path));
 
-            JsonSerializer.SerializeToFile(triggers, path);
+            _jsonSerializer.SerializeToFile(triggers, path);
         }
 
         /// <summary>
@@ -576,11 +582,12 @@ namespace Emby.Server.Implementations.ScheduledTasks
         /// <param name="startTime">The start time.</param>
         /// <param name="endTime">The end time.</param>
         /// <param name="status">The status.</param>
+        /// <param name="ex">The exception.</param>
         private void OnTaskCompleted(DateTime startTime, DateTime endTime, TaskCompletionStatus status, Exception ex)
         {
             var elapsedTime = endTime - startTime;
 
-            Logger.LogInformation("{0} {1} after {2} minute(s) and {3} seconds", Name, status, Math.Truncate(elapsedTime.TotalMinutes), elapsedTime.Seconds);
+            _logger.LogInformation("{0} {1} after {2} minute(s) and {3} seconds", Name, status, Math.Truncate(elapsedTime.TotalMinutes), elapsedTime.Seconds);
 
             var result = new TaskResult
             {
@@ -601,7 +608,7 @@ namespace Emby.Server.Implementations.ScheduledTasks
 
             LastExecutionResult = result;
 
-            ((TaskManager)TaskManager).OnTaskCompleted(this, result);
+            ((TaskManager)_taskManager).OnTaskCompleted(this, result);
         }
 
         /// <summary>
@@ -610,6 +617,7 @@ namespace Emby.Server.Implementations.ScheduledTasks
         public void Dispose()
         {
             Dispose(true);
+            GC.SuppressFinalize(this);
         }
 
         /// <summary>
@@ -630,34 +638,35 @@ namespace Emby.Server.Implementations.ScheduledTasks
                 {
                     try
                     {
-                        Logger.LogInformation(Name + ": Cancelling");
+                        _logger.LogInformation(Name + ": Cancelling");
                         token.Cancel();
                     }
                     catch (Exception ex)
                     {
-                        Logger.LogError(ex, "Error calling CancellationToken.Cancel();");
+                        _logger.LogError(ex, "Error calling CancellationToken.Cancel();");
                     }
                 }
+
                 var task = _currentTask;
                 if (task != null)
                 {
                     try
                     {
-                        Logger.LogInformation(Name + ": Waiting on Task");
+                        _logger.LogInformation(Name + ": Waiting on Task");
                         var exited = Task.WaitAll(new[] { task }, 2000);
 
                         if (exited)
                         {
-                            Logger.LogInformation(Name + ": Task exited");
+                            _logger.LogInformation(Name + ": Task exited");
                         }
                         else
                         {
-                            Logger.LogInformation(Name + ": Timed out waiting for task to stop");
+                            _logger.LogInformation(Name + ": Timed out waiting for task to stop");
                         }
                     }
                     catch (Exception ex)
                     {
-                        Logger.LogError(ex, "Error calling Task.WaitAll();");
+                        _logger.LogError(ex, "Error calling Task.WaitAll();");
                     }
                 }
 
@@ -665,14 +674,15 @@ namespace Emby.Server.Implementations.ScheduledTasks
                 {
                     try
                     {
-                        Logger.LogDebug(Name + ": Disposing CancellationToken");
+                        _logger.LogDebug(Name + ": Disposing CancellationToken");
                         token.Dispose();
                     }
                     catch (Exception ex)
                     {
-                        Logger.LogError(ex, "Error calling CancellationToken.Dispose();");
+                        _logger.LogError(ex, "Error calling CancellationToken.Dispose();");
                     }
                 }
+
                 if (wassRunning)
                 {
                     OnTaskCompleted(startTime, DateTime.UtcNow, TaskCompletionStatus.Aborted, null);
@@ -681,12 +691,11 @@ namespace Emby.Server.Implementations.ScheduledTasks
         }
 
         /// <summary>
-        /// Converts a TaskTriggerInfo into a concrete BaseTaskTrigger
+        /// Converts a TaskTriggerInfo into a concrete BaseTaskTrigger.
         /// </summary>
         /// <param name="info">The info.</param>
         /// <returns>BaseTaskTrigger.</returns>
-        /// <exception cref="ArgumentNullException"></exception>
-        /// <exception cref="ArgumentException">Invalid trigger type:  + info.Type</exception>
+        /// <exception cref="ArgumentException">Invalid trigger type:  + info.Type.</exception>
         private ITaskTrigger GetTrigger(TaskTriggerInfo info)
         {
             var options = new TaskOptions
@@ -751,14 +760,14 @@ namespace Emby.Server.Implementations.ScheduledTasks
         }
 
         /// <summary>
-        /// Disposes each trigger
+        /// Disposes each trigger.
         /// </summary>
         private void DisposeTriggers()
         {
             foreach (var triggerInfo in InternalTriggers)
             {
                 var trigger = triggerInfo.Item2;
-                trigger.Triggered -= trigger_Triggered;
+                trigger.Triggered -= OnTriggerTriggered;
                 trigger.Stop();
             }
         }