ScheduledTaskWorker.cs 18 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548
  1. using MediaBrowser.Common.Extensions;
  2. using MediaBrowser.Common.Kernel;
  3. using MediaBrowser.Common.ScheduledTasks;
  4. using MediaBrowser.Model.Logging;
  5. using MediaBrowser.Model.Serialization;
  6. using MediaBrowser.Model.Tasks;
  7. using System;
  8. using System.Collections.Generic;
  9. using System.IO;
  10. using System.Linq;
  11. using System.Threading;
  12. using System.Threading.Tasks;
  13. namespace MediaBrowser.Common.Implementations.ScheduledTasks
  14. {
  15. /// <summary>
  16. /// Class ScheduledTaskWorker
  17. /// </summary>
  18. public class ScheduledTaskWorker : IScheduledTaskWorker
  19. {
  20. /// <summary>
  21. /// Gets or sets the scheduled task.
  22. /// </summary>
  23. /// <value>The scheduled task.</value>
  24. public IScheduledTask ScheduledTask { get; private set; }
  25. /// <summary>
  26. /// Gets or sets the json serializer.
  27. /// </summary>
  28. /// <value>The json serializer.</value>
  29. private IJsonSerializer JsonSerializer { get; set; }
  30. /// <summary>
  31. /// Gets or sets the application paths.
  32. /// </summary>
  33. /// <value>The application paths.</value>
  34. private IApplicationPaths ApplicationPaths { get; set; }
  35. /// <summary>
  36. /// Gets the logger.
  37. /// </summary>
  38. /// <value>The logger.</value>
  39. private ILogger Logger { get; set; }
  40. /// <summary>
  41. /// Gets the task manager.
  42. /// </summary>
  43. /// <value>The task manager.</value>
  44. private ITaskManager TaskManager { get; set; }
  45. /// <summary>
  46. /// Gets or sets the server manager.
  47. /// </summary>
  48. /// <value>The server manager.</value>
  49. private IServerManager ServerManager { get; set; }
  50. /// <summary>
  51. /// Initializes a new instance of the <see cref="ScheduledTaskWorker" /> class.
  52. /// </summary>
  53. /// <param name="scheduledTask">The scheduled task.</param>
  54. /// <param name="applicationPaths">The application paths.</param>
  55. /// <param name="taskManager">The task manager.</param>
  56. /// <param name="jsonSerializer">The json serializer.</param>
  57. /// <param name="logger">The logger.</param>
  58. /// <param name="serverManager">The server manager.</param>
  59. public ScheduledTaskWorker(IScheduledTask scheduledTask, IApplicationPaths applicationPaths, ITaskManager taskManager, IJsonSerializer jsonSerializer, ILogger logger, IServerManager serverManager)
  60. {
  61. ScheduledTask = scheduledTask;
  62. ApplicationPaths = applicationPaths;
  63. TaskManager = taskManager;
  64. JsonSerializer = jsonSerializer;
  65. Logger = logger;
  66. ServerManager = serverManager;
  67. ReloadTriggerEvents(true);
  68. }
  69. /// <summary>
  70. /// The _last execution result
  71. /// </summary>
  72. private TaskResult _lastExecutionResult;
  73. /// <summary>
  74. /// The _last execution resultinitialized
  75. /// </summary>
  76. private bool _lastExecutionResultinitialized;
  77. /// <summary>
  78. /// The _last execution result sync lock
  79. /// </summary>
  80. private object _lastExecutionResultSyncLock = new object();
  81. /// <summary>
  82. /// Gets the last execution result.
  83. /// </summary>
  84. /// <value>The last execution result.</value>
  85. public TaskResult LastExecutionResult
  86. {
  87. get
  88. {
  89. LazyInitializer.EnsureInitialized(ref _lastExecutionResult, ref _lastExecutionResultinitialized, ref _lastExecutionResultSyncLock, () =>
  90. {
  91. try
  92. {
  93. return JsonSerializer.DeserializeFromFile<TaskResult>(GetHistoryFilePath());
  94. }
  95. catch (IOException)
  96. {
  97. // File doesn't exist. No biggie
  98. return null;
  99. }
  100. });
  101. return _lastExecutionResult;
  102. }
  103. private set
  104. {
  105. _lastExecutionResult = value;
  106. _lastExecutionResultinitialized = value != null;
  107. }
  108. }
  109. /// <summary>
  110. /// Gets the name.
  111. /// </summary>
  112. /// <value>The name.</value>
  113. public string Name
  114. {
  115. get { return ScheduledTask.Name; }
  116. }
  117. /// <summary>
  118. /// Gets the description.
  119. /// </summary>
  120. /// <value>The description.</value>
  121. public string Description
  122. {
  123. get { return ScheduledTask.Description; }
  124. }
  125. /// <summary>
  126. /// Gets the category.
  127. /// </summary>
  128. /// <value>The category.</value>
  129. public string Category
  130. {
  131. get { return ScheduledTask.Category; }
  132. }
  133. /// <summary>
  134. /// Gets the current cancellation token
  135. /// </summary>
  136. /// <value>The current cancellation token source.</value>
  137. private CancellationTokenSource CurrentCancellationTokenSource { get; set; }
  138. /// <summary>
  139. /// Gets or sets the current execution start time.
  140. /// </summary>
  141. /// <value>The current execution start time.</value>
  142. private DateTime CurrentExecutionStartTime { get; set; }
  143. /// <summary>
  144. /// Gets the state.
  145. /// </summary>
  146. /// <value>The state.</value>
  147. public TaskState State
  148. {
  149. get
  150. {
  151. if (CurrentCancellationTokenSource != null)
  152. {
  153. return CurrentCancellationTokenSource.IsCancellationRequested
  154. ? TaskState.Cancelling
  155. : TaskState.Running;
  156. }
  157. return TaskState.Idle;
  158. }
  159. }
  160. /// <summary>
  161. /// Gets the current progress.
  162. /// </summary>
  163. /// <value>The current progress.</value>
  164. public double? CurrentProgress { get; private set; }
  165. /// <summary>
  166. /// The _triggers
  167. /// </summary>
  168. private IEnumerable<ITaskTrigger> _triggers;
  169. /// <summary>
  170. /// The _triggers initialized
  171. /// </summary>
  172. private bool _triggersInitialized;
  173. /// <summary>
  174. /// The _triggers sync lock
  175. /// </summary>
  176. private object _triggersSyncLock = new object();
  177. /// <summary>
  178. /// Gets the triggers that define when the task will run
  179. /// </summary>
  180. /// <value>The triggers.</value>
  181. /// <exception cref="System.ArgumentNullException">value</exception>
  182. public IEnumerable<ITaskTrigger> Triggers
  183. {
  184. get
  185. {
  186. LazyInitializer.EnsureInitialized(ref _triggers, ref _triggersInitialized, ref _triggersSyncLock, () => LoadTriggers());
  187. return _triggers;
  188. }
  189. set
  190. {
  191. if (value == null)
  192. {
  193. throw new ArgumentNullException("value");
  194. }
  195. // Cleanup current triggers
  196. if (_triggers != null)
  197. {
  198. DisposeTriggers();
  199. }
  200. _triggers = value.ToList();
  201. _triggersInitialized = true;
  202. ReloadTriggerEvents(false);
  203. SaveTriggers(_triggers);
  204. }
  205. }
  206. /// <summary>
  207. /// The _id
  208. /// </summary>
  209. private Guid? _id;
  210. /// <summary>
  211. /// Gets the unique id.
  212. /// </summary>
  213. /// <value>The unique id.</value>
  214. public Guid Id
  215. {
  216. get
  217. {
  218. if (!_id.HasValue)
  219. {
  220. _id = ScheduledTask.GetType().FullName.GetMD5();
  221. }
  222. return _id.Value;
  223. }
  224. }
  225. /// <summary>
  226. /// Reloads the trigger events.
  227. /// </summary>
  228. /// <param name="isApplicationStartup">if set to <c>true</c> [is application startup].</param>
  229. private void ReloadTriggerEvents(bool isApplicationStartup)
  230. {
  231. foreach (var trigger in Triggers)
  232. {
  233. trigger.Stop();
  234. trigger.Triggered -= trigger_Triggered;
  235. trigger.Triggered += trigger_Triggered;
  236. trigger.Start(isApplicationStartup);
  237. }
  238. }
  239. /// <summary>
  240. /// Handles the Triggered event of the trigger control.
  241. /// </summary>
  242. /// <param name="sender">The source of the event.</param>
  243. /// <param name="e">The <see cref="EventArgs" /> instance containing the event data.</param>
  244. async void trigger_Triggered(object sender, EventArgs e)
  245. {
  246. var trigger = (ITaskTrigger)sender;
  247. Logger.Info("{0} fired for task: {1}", trigger.GetType().Name, Name);
  248. trigger.Stop();
  249. TaskManager.QueueScheduledTask(ScheduledTask);
  250. await Task.Delay(1000).ConfigureAwait(false);
  251. trigger.Start(false);
  252. }
  253. /// <summary>
  254. /// Executes the task
  255. /// </summary>
  256. /// <returns>Task.</returns>
  257. /// <exception cref="System.InvalidOperationException">Cannot execute a Task that is already running</exception>
  258. public async Task Execute()
  259. {
  260. // Cancel the current execution, if any
  261. if (CurrentCancellationTokenSource != null)
  262. {
  263. throw new InvalidOperationException("Cannot execute a Task that is already running");
  264. }
  265. CurrentCancellationTokenSource = new CancellationTokenSource();
  266. Logger.Info("Executing {0}", Name);
  267. var progress = new Progress<double>();
  268. progress.ProgressChanged += progress_ProgressChanged;
  269. TaskCompletionStatus status;
  270. CurrentExecutionStartTime = DateTime.UtcNow;
  271. ServerManager.SendWebSocketMessage("ScheduledTaskBeginExecute", Name);
  272. try
  273. {
  274. await System.Threading.Tasks.Task.Run(async () => await ScheduledTask.Execute(CurrentCancellationTokenSource.Token, progress).ConfigureAwait(false)).ConfigureAwait(false);
  275. status = TaskCompletionStatus.Completed;
  276. }
  277. catch (OperationCanceledException)
  278. {
  279. status = TaskCompletionStatus.Cancelled;
  280. }
  281. catch (Exception ex)
  282. {
  283. Logger.ErrorException("Error", ex);
  284. status = TaskCompletionStatus.Failed;
  285. }
  286. var startTime = CurrentExecutionStartTime;
  287. var endTime = DateTime.UtcNow;
  288. ServerManager.SendWebSocketMessage("ScheduledTaskEndExecute", LastExecutionResult);
  289. progress.ProgressChanged -= progress_ProgressChanged;
  290. CurrentCancellationTokenSource.Dispose();
  291. CurrentCancellationTokenSource = null;
  292. CurrentProgress = null;
  293. OnTaskCompleted(startTime, endTime, status);
  294. }
  295. /// <summary>
  296. /// Progress_s the progress changed.
  297. /// </summary>
  298. /// <param name="sender">The sender.</param>
  299. /// <param name="e">The e.</param>
  300. void progress_ProgressChanged(object sender, double e)
  301. {
  302. CurrentProgress = e;
  303. }
  304. /// <summary>
  305. /// Stops the task if it is currently executing
  306. /// </summary>
  307. /// <exception cref="System.InvalidOperationException">Cannot cancel a Task unless it is in the Running state.</exception>
  308. public void Cancel()
  309. {
  310. if (State != TaskState.Running)
  311. {
  312. throw new InvalidOperationException("Cannot cancel a Task unless it is in the Running state.");
  313. }
  314. CancelIfRunning();
  315. }
  316. /// <summary>
  317. /// Cancels if running.
  318. /// </summary>
  319. public void CancelIfRunning()
  320. {
  321. if (State == TaskState.Running)
  322. {
  323. Logger.Info("Attempting to cancel Scheduled Task {0}", Name);
  324. CurrentCancellationTokenSource.Cancel();
  325. }
  326. }
  327. /// <summary>
  328. /// The _scheduled tasks configuration directory
  329. /// </summary>
  330. private string _scheduledTasksConfigurationDirectory;
  331. /// <summary>
  332. /// Gets the scheduled tasks configuration directory.
  333. /// </summary>
  334. /// <value>The scheduled tasks configuration directory.</value>
  335. private string ScheduledTasksConfigurationDirectory
  336. {
  337. get
  338. {
  339. if (_scheduledTasksConfigurationDirectory == null)
  340. {
  341. _scheduledTasksConfigurationDirectory = Path.Combine(ApplicationPaths.ConfigurationDirectoryPath, "ScheduledTasks");
  342. if (!Directory.Exists(_scheduledTasksConfigurationDirectory))
  343. {
  344. Directory.CreateDirectory(_scheduledTasksConfigurationDirectory);
  345. }
  346. }
  347. return _scheduledTasksConfigurationDirectory;
  348. }
  349. }
  350. /// <summary>
  351. /// The _scheduled tasks data directory
  352. /// </summary>
  353. private string _scheduledTasksDataDirectory;
  354. /// <summary>
  355. /// Gets the scheduled tasks data directory.
  356. /// </summary>
  357. /// <value>The scheduled tasks data directory.</value>
  358. private string ScheduledTasksDataDirectory
  359. {
  360. get
  361. {
  362. if (_scheduledTasksDataDirectory == null)
  363. {
  364. _scheduledTasksDataDirectory = Path.Combine(ApplicationPaths.DataPath, "ScheduledTasks");
  365. if (!Directory.Exists(_scheduledTasksDataDirectory))
  366. {
  367. Directory.CreateDirectory(_scheduledTasksDataDirectory);
  368. }
  369. }
  370. return _scheduledTasksDataDirectory;
  371. }
  372. }
  373. /// <summary>
  374. /// Gets the history file path.
  375. /// </summary>
  376. /// <value>The history file path.</value>
  377. private string GetHistoryFilePath()
  378. {
  379. return Path.Combine(ScheduledTasksDataDirectory, Id + ".js");
  380. }
  381. /// <summary>
  382. /// Gets the configuration file path.
  383. /// </summary>
  384. /// <returns>System.String.</returns>
  385. private string GetConfigurationFilePath()
  386. {
  387. return Path.Combine(ScheduledTasksConfigurationDirectory, Id + ".js");
  388. }
  389. /// <summary>
  390. /// Loads the triggers.
  391. /// </summary>
  392. /// <returns>IEnumerable{BaseTaskTrigger}.</returns>
  393. private IEnumerable<ITaskTrigger> LoadTriggers()
  394. {
  395. try
  396. {
  397. return JsonSerializer.DeserializeFromFile<IEnumerable<TaskTriggerInfo>>(GetConfigurationFilePath())
  398. .Select(ScheduledTaskHelpers.GetTrigger)
  399. .ToList();
  400. }
  401. catch (IOException)
  402. {
  403. // File doesn't exist. No biggie. Return defaults.
  404. return ScheduledTask.GetDefaultTriggers();
  405. }
  406. }
  407. /// <summary>
  408. /// Saves the triggers.
  409. /// </summary>
  410. /// <param name="triggers">The triggers.</param>
  411. private void SaveTriggers(IEnumerable<ITaskTrigger> triggers)
  412. {
  413. JsonSerializer.SerializeToFile(triggers.Select(ScheduledTaskHelpers.GetTriggerInfo), GetConfigurationFilePath());
  414. }
  415. /// <summary>
  416. /// Called when [task completed].
  417. /// </summary>
  418. /// <param name="startTime">The start time.</param>
  419. /// <param name="endTime">The end time.</param>
  420. /// <param name="status">The status.</param>
  421. private void OnTaskCompleted(DateTime startTime, DateTime endTime, TaskCompletionStatus status)
  422. {
  423. var elapsedTime = endTime - startTime;
  424. Logger.Info("{0} {1} after {2} minute(s) and {3} seconds", Name, status, Math.Truncate(elapsedTime.TotalMinutes), elapsedTime.Seconds);
  425. var result = new TaskResult
  426. {
  427. StartTimeUtc = startTime,
  428. EndTimeUtc = endTime,
  429. Status = status,
  430. Name = Name,
  431. Id = Id
  432. };
  433. JsonSerializer.SerializeToFile(result, GetHistoryFilePath());
  434. LastExecutionResult = result;
  435. }
  436. /// <summary>
  437. /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
  438. /// </summary>
  439. public void Dispose()
  440. {
  441. Dispose(true);
  442. GC.SuppressFinalize(this);
  443. }
  444. /// <summary>
  445. /// Releases unmanaged and - optionally - managed resources.
  446. /// </summary>
  447. /// <param name="dispose"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
  448. protected virtual void Dispose(bool dispose)
  449. {
  450. if (dispose)
  451. {
  452. DisposeTriggers();
  453. if (State == TaskState.Running)
  454. {
  455. OnTaskCompleted(CurrentExecutionStartTime, DateTime.UtcNow, TaskCompletionStatus.Aborted);
  456. }
  457. if (CurrentCancellationTokenSource != null)
  458. {
  459. CurrentCancellationTokenSource.Dispose();
  460. }
  461. }
  462. }
  463. /// <summary>
  464. /// Disposes each trigger
  465. /// </summary>
  466. private void DisposeTriggers()
  467. {
  468. foreach (var trigger in Triggers)
  469. {
  470. trigger.Triggered -= trigger_Triggered;
  471. trigger.Stop();
  472. }
  473. }
  474. }
  475. }