jellyfin/MediaBrowser.Common.Implementations/ScheduledTasks/TaskManager.cs

303 lines
9.7 KiB
C#
Raw Normal View History

2013-09-23 18:53:06 +00:00
using MediaBrowser.Common.Configuration;
2013-03-07 05:34:00 +00:00
using MediaBrowser.Common.Events;
2013-02-24 21:53:54 +00:00
using MediaBrowser.Common.ScheduledTasks;
2014-05-08 20:09:53 +00:00
using MediaBrowser.Model.Events;
2013-02-24 21:53:54 +00:00
using MediaBrowser.Model.Logging;
using MediaBrowser.Model.Serialization;
using MediaBrowser.Model.Tasks;
using System;
2015-03-27 04:17:04 +00:00
using System.Collections.Concurrent;
2013-02-24 21:53:54 +00:00
using System.Collections.Generic;
using System.Linq;
2013-09-23 18:53:06 +00:00
using System.Threading.Tasks;
2015-10-04 04:23:11 +00:00
using CommonIO;
2015-09-13 23:07:54 +00:00
using MediaBrowser.Common.IO;
2015-10-25 15:48:44 +00:00
using Microsoft.Win32;
2013-02-24 21:53:54 +00:00
namespace MediaBrowser.Common.Implementations.ScheduledTasks
{
/// <summary>
/// Class TaskManager
/// </summary>
public class TaskManager : ITaskManager
{
2014-05-10 17:28:03 +00:00
public event EventHandler<GenericEventArgs<IScheduledTaskWorker>> TaskExecuting;
public event EventHandler<TaskCompletionEventArgs> TaskCompleted;
2013-03-07 05:34:00 +00:00
2013-02-24 21:53:54 +00:00
/// <summary>
/// Gets the list of Scheduled Tasks
/// </summary>
/// <value>The scheduled tasks.</value>
public IScheduledTaskWorker[] ScheduledTasks { get; private set; }
2013-02-24 21:53:54 +00:00
/// <summary>
/// The _task queue
/// </summary>
2015-03-27 04:17:04 +00:00
private readonly ConcurrentQueue<Tuple<Type, TaskExecutionOptions>> _taskQueue =
new ConcurrentQueue<Tuple<Type, TaskExecutionOptions>>();
2013-02-24 21:53:54 +00:00
/// <summary>
/// Gets or sets the json serializer.
2013-02-24 21:53:54 +00:00
/// </summary>
/// <value>The json serializer.</value>
private IJsonSerializer JsonSerializer { get; set; }
2013-02-24 21:53:54 +00:00
/// <summary>
/// Gets or sets the application paths.
2013-02-24 21:53:54 +00:00
/// </summary>
/// <value>The application paths.</value>
private IApplicationPaths ApplicationPaths { get; set; }
2013-02-24 21:53:54 +00:00
/// <summary>
/// Gets the logger.
2013-02-24 21:53:54 +00:00
/// </summary>
/// <value>The logger.</value>
private ILogger Logger { get; set; }
2015-09-13 23:07:54 +00:00
private readonly IFileSystem _fileSystem;
2013-02-24 21:53:54 +00:00
/// <summary>
/// Initializes a new instance of the <see cref="TaskManager" /> class.
/// </summary>
/// <param name="applicationPaths">The application paths.</param>
/// <param name="jsonSerializer">The json serializer.</param>
/// <param name="logger">The logger.</param>
/// <exception cref="System.ArgumentException">kernel</exception>
2015-09-13 23:07:54 +00:00
public TaskManager(IApplicationPaths applicationPaths, IJsonSerializer jsonSerializer, ILogger logger, IFileSystem fileSystem)
2013-02-24 21:53:54 +00:00
{
ApplicationPaths = applicationPaths;
JsonSerializer = jsonSerializer;
Logger = logger;
2015-09-13 23:07:54 +00:00
_fileSystem = fileSystem;
2013-02-24 21:53:54 +00:00
ScheduledTasks = new IScheduledTaskWorker[] { };
2015-10-25 15:48:44 +00:00
BindToSystemEvent();
}
private void BindToSystemEvent()
{
try
{
SystemEvents.PowerModeChanged += SystemEvents_PowerModeChanged;
}
catch
{
}
}
void SystemEvents_PowerModeChanged(object sender, PowerModeChangedEventArgs e)
{
foreach (var task in ScheduledTasks)
{
task.ReloadTriggerEvents();
}
2013-02-24 21:53:54 +00:00
}
/// <summary>
/// Cancels if running and queue.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="options">Task options.</param>
public void CancelIfRunningAndQueue<T>(TaskExecutionOptions options)
2013-02-24 21:53:54 +00:00
where T : IScheduledTask
{
2013-03-07 05:34:00 +00:00
var task = ScheduledTasks.First(t => t.ScheduledTask.GetType() == typeof(T));
((ScheduledTaskWorker)task).CancelIfRunning();
QueueScheduledTask<T>(options);
2013-02-24 21:53:54 +00:00
}
2015-03-07 17:19:44 +00:00
public void CancelIfRunningAndQueue<T>()
where T : IScheduledTask
{
CancelIfRunningAndQueue<T>(new TaskExecutionOptions());
}
2013-09-23 18:53:06 +00:00
/// <summary>
/// Cancels if running
/// </summary>
/// <typeparam name="T"></typeparam>
public void CancelIfRunning<T>()
where T : IScheduledTask
{
var task = ScheduledTasks.First(t => t.ScheduledTask.GetType() == typeof(T));
((ScheduledTaskWorker)task).CancelIfRunning();
}
2013-02-24 21:53:54 +00:00
/// <summary>
/// Queues the scheduled task.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="options">Task options</param>
public void QueueScheduledTask<T>(TaskExecutionOptions options)
2013-02-24 21:53:54 +00:00
where T : IScheduledTask
{
2015-09-04 01:34:57 +00:00
var scheduledTask = ScheduledTasks.FirstOrDefault(t => t.ScheduledTask.GetType() == typeof(T));
if (scheduledTask == null)
{
Logger.Error("Unable to find scheduled task of type {0} in QueueScheduledTask.", typeof(T).Name);
}
else
{
QueueScheduledTask(scheduledTask, options);
}
2013-02-24 21:53:54 +00:00
}
2015-03-07 17:19:44 +00:00
public void QueueScheduledTask<T>()
where T : IScheduledTask
{
QueueScheduledTask<T>(new TaskExecutionOptions());
}
2015-10-25 15:48:44 +00:00
2013-02-24 21:53:54 +00:00
/// <summary>
/// Queues the scheduled task.
/// </summary>
/// <param name="task">The task.</param>
/// <param name="options">The task options.</param>
public void QueueScheduledTask(IScheduledTask task, TaskExecutionOptions options)
2013-02-24 21:53:54 +00:00
{
2015-09-04 01:34:57 +00:00
var scheduledTask = ScheduledTasks.FirstOrDefault(t => t.ScheduledTask.GetType() == task.GetType());
if (scheduledTask == null)
{
Logger.Error("Unable to find scheduled task of type {0} in QueueScheduledTask.", task.GetType().Name);
}
else
{
QueueScheduledTask(scheduledTask, options);
}
}
2013-03-07 05:34:00 +00:00
/// <summary>
/// Queues the scheduled task.
/// </summary>
/// <param name="task">The task.</param>
/// <param name="options">The task options.</param>
private void QueueScheduledTask(IScheduledTaskWorker task, TaskExecutionOptions options)
{
var type = task.ScheduledTask.GetType();
2013-02-24 21:53:54 +00:00
2015-03-27 04:17:04 +00:00
Logger.Info("Queueing task {0}", type.Name);
2013-02-24 21:53:54 +00:00
lock (_taskQueue)
{
if (task.State == TaskState.Idle)
2013-02-24 21:53:54 +00:00
{
Execute(task, options);
2013-02-24 21:53:54 +00:00
return;
}
2015-03-27 04:17:04 +00:00
_taskQueue.Enqueue(new Tuple<Type, TaskExecutionOptions>(type, options));
2013-02-24 21:53:54 +00:00
}
}
/// <summary>
/// Adds the tasks.
/// </summary>
/// <param name="tasks">The tasks.</param>
public void AddTasks(IEnumerable<IScheduledTask> tasks)
{
var myTasks = ScheduledTasks.ToList();
2014-05-10 17:28:03 +00:00
var list = tasks.ToList();
2015-09-13 23:07:54 +00:00
myTasks.AddRange(list.Select(t => new ScheduledTaskWorker(t, ApplicationPaths, this, JsonSerializer, Logger, _fileSystem)));
2013-02-24 21:53:54 +00:00
ScheduledTasks = myTasks.ToArray();
}
/// <summary>
/// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
/// </summary>
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
/// <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)
{
task.Dispose();
}
}
2013-03-07 05:34:00 +00:00
public void Cancel(IScheduledTaskWorker task)
{
((ScheduledTaskWorker)task).Cancel();
}
public Task Execute(IScheduledTaskWorker task, TaskExecutionOptions options)
2013-03-07 05:34:00 +00:00
{
return ((ScheduledTaskWorker)task).Execute(options);
2013-03-07 05:34:00 +00:00
}
/// <summary>
/// Called when [task executing].
/// </summary>
/// <param name="task">The task.</param>
2014-05-10 17:28:03 +00:00
internal void OnTaskExecuting(IScheduledTaskWorker task)
2013-03-07 05:34:00 +00:00
{
2014-05-14 00:46:45 +00:00
EventHelper.FireEventIfNotNull(TaskExecuting, this, new GenericEventArgs<IScheduledTaskWorker>
2014-05-10 17:28:03 +00:00
{
Argument = task
}, Logger);
2013-03-07 05:34:00 +00:00
}
/// <summary>
/// Called when [task completed].
/// </summary>
/// <param name="task">The task.</param>
/// <param name="result">The result.</param>
2014-05-10 17:28:03 +00:00
internal void OnTaskCompleted(IScheduledTaskWorker task, TaskResult result)
2013-03-07 05:34:00 +00:00
{
2014-05-14 00:46:45 +00:00
EventHelper.FireEventIfNotNull(TaskCompleted, task, new TaskCompletionEventArgs
2014-05-10 17:28:03 +00:00
{
Result = result,
Task = task
}, Logger);
ExecuteQueuedTasks();
}
/// <summary>
/// Executes the queued tasks.
/// </summary>
private void ExecuteQueuedTasks()
{
// Execute queued tasks
lock (_taskQueue)
{
2015-03-27 04:17:04 +00:00
var list = new List<Tuple<Type, TaskExecutionOptions>>();
Tuple<Type, TaskExecutionOptions> item;
while (_taskQueue.TryDequeue(out item))
{
2015-03-27 04:17:04 +00:00
if (list.All(i => i.Item1 != item.Item1))
{
list.Add(item);
}
}
foreach (var enqueuedType in list)
{
var scheduledTask = ScheduledTasks.First(t => t.ScheduledTask.GetType() == enqueuedType.Item1);
if (scheduledTask.State == TaskState.Idle)
{
2015-03-27 04:17:04 +00:00
Execute(scheduledTask, enqueuedType.Item2);
}
}
}
2013-03-07 05:34:00 +00:00
}
2013-02-24 21:53:54 +00:00
}
}