jellyfin/MediaBrowser.Server.Implementations/IO/LibraryMonitor.cs

764 lines
25 KiB
C#
Raw Normal View History

2015-07-29 03:42:03 +00:00
using MediaBrowser.Common.IO;
using MediaBrowser.Common.ScheduledTasks;
2013-03-04 05:43:06 +00:00
using MediaBrowser.Controller.Configuration;
2013-02-21 01:33:05 +00:00
using MediaBrowser.Controller.Entities;
using MediaBrowser.Controller.Library;
2015-08-27 01:31:54 +00:00
using MediaBrowser.Controller.Plugins;
using MediaBrowser.Model.Configuration;
2013-02-21 01:33:05 +00:00
using MediaBrowser.Model.Logging;
using MediaBrowser.Server.Implementations.ScheduledTasks;
2013-09-19 15:13:34 +00:00
using Microsoft.Win32;
2013-02-21 01:33:05 +00:00
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
2015-10-04 04:23:11 +00:00
using CommonIO;
using MediaBrowser.Controller;
2013-02-21 01:33:05 +00:00
namespace MediaBrowser.Server.Implementations.IO
2013-02-21 01:33:05 +00:00
{
public class LibraryMonitor : ILibraryMonitor
2013-02-21 01:33:05 +00:00
{
/// <summary>
/// The file system watchers
/// </summary>
2013-09-19 15:13:34 +00:00
private readonly ConcurrentDictionary<string, FileSystemWatcher> _fileSystemWatchers = new ConcurrentDictionary<string, FileSystemWatcher>(StringComparer.OrdinalIgnoreCase);
2013-02-21 01:33:05 +00:00
/// <summary>
/// The update timer
/// </summary>
private Timer _updateTimer;
2013-02-21 01:33:05 +00:00
/// <summary>
/// The affected paths
/// </summary>
private readonly ConcurrentDictionary<string, string> _affectedPaths = new ConcurrentDictionary<string, string>();
2013-02-21 01:33:05 +00:00
/// <summary>
/// A dynamic list of paths that should be ignored. Added to during our own file sytem modifications.
/// </summary>
2013-04-28 13:24:20 +00:00
private readonly ConcurrentDictionary<string, string> _tempIgnoredPaths = new ConcurrentDictionary<string, string>(StringComparer.OrdinalIgnoreCase);
2013-02-21 01:33:05 +00:00
/// <summary>
/// Any file name ending in any of these will be ignored by the watchers
/// </summary>
2014-02-26 04:38:21 +00:00
private readonly IReadOnlyList<string> _alwaysIgnoreFiles = new List<string>
{
"thumbs.db",
"small.jpg",
"albumart.jpg",
// WMC temp recording directories that will constantly be written to
"TempRec",
"TempSBE"
};
2013-02-21 01:33:05 +00:00
/// <summary>
/// The timer lock
/// </summary>
private readonly object _timerLock = new object();
2013-02-21 01:33:05 +00:00
/// <summary>
/// Add the path to our temporary ignore list. Use when writing to a path within our listening scope.
/// </summary>
/// <param name="path">The path.</param>
private void TemporarilyIgnore(string path)
2013-02-21 01:33:05 +00:00
{
_tempIgnoredPaths[path] = path;
2013-02-21 01:33:05 +00:00
}
public void ReportFileSystemChangeBeginning(string path)
{
if (string.IsNullOrEmpty(path))
{
throw new ArgumentNullException("path");
}
TemporarilyIgnore(path);
}
2016-02-24 18:45:20 +00:00
public bool IsPathLocked(string path)
{
var lockedPaths = _tempIgnoredPaths.Keys.ToList();
return lockedPaths.Any(i => string.Equals(i, path, StringComparison.OrdinalIgnoreCase) || _fileSystem.ContainsSubPath(i, path));
}
2014-01-29 05:17:58 +00:00
public async void ReportFileSystemChangeComplete(string path, bool refreshPath)
{
if (string.IsNullOrEmpty(path))
{
throw new ArgumentNullException("path");
}
2015-06-03 05:30:14 +00:00
// This is an arbitraty amount of time, but delay it because file system writes often trigger events long after the file was actually written to.
2015-05-24 18:33:28 +00:00
// Seeing long delays in some situations, especially over the network, sometimes up to 45 seconds
2015-06-03 05:30:14 +00:00
// But if we make this delay too high, we risk missing legitimate changes, such as user adding a new file, or hand-editing metadata
2015-10-26 05:29:32 +00:00
await Task.Delay(25000).ConfigureAwait(false);
2014-01-29 05:17:58 +00:00
string val;
_tempIgnoredPaths.TryRemove(path, out val);
if (refreshPath)
{
ReportFileSystemChanged(path);
}
}
2013-02-21 01:33:05 +00:00
/// <summary>
/// Gets or sets the logger.
/// </summary>
/// <value>The logger.</value>
private ILogger Logger { get; set; }
2013-02-23 07:57:11 +00:00
/// <summary>
/// Gets or sets the task manager.
/// </summary>
/// <value>The task manager.</value>
private ITaskManager TaskManager { get; set; }
private ILibraryManager LibraryManager { get; set; }
2013-03-04 05:43:06 +00:00
private IServerConfigurationManager ConfigurationManager { get; set; }
2014-01-29 01:46:04 +00:00
private readonly IFileSystem _fileSystem;
2015-10-04 03:38:46 +00:00
private readonly IServerApplicationHost _appHost;
2013-02-21 01:33:05 +00:00
/// <summary>
/// Initializes a new instance of the <see cref="LibraryMonitor" /> class.
2013-02-21 01:33:05 +00:00
/// </summary>
2015-10-04 03:38:46 +00:00
public LibraryMonitor(ILogManager logManager, ITaskManager taskManager, ILibraryManager libraryManager, IServerConfigurationManager configurationManager, IFileSystem fileSystem, IServerApplicationHost appHost)
2013-02-21 01:33:05 +00:00
{
2013-02-23 07:57:11 +00:00
if (taskManager == null)
{
throw new ArgumentNullException("taskManager");
}
2013-02-21 20:26:35 +00:00
LibraryManager = libraryManager;
2013-02-23 07:57:11 +00:00
TaskManager = taskManager;
Logger = logManager.GetLogger(GetType().Name);
2013-03-04 05:43:06 +00:00
ConfigurationManager = configurationManager;
2014-01-29 01:46:04 +00:00
_fileSystem = fileSystem;
2015-10-04 03:38:46 +00:00
_appHost = appHost;
2013-09-19 15:13:34 +00:00
SystemEvents.PowerModeChanged += SystemEvents_PowerModeChanged;
}
/// <summary>
/// Handles the PowerModeChanged event of the SystemEvents control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="PowerModeChangedEventArgs"/> instance containing the event data.</param>
void SystemEvents_PowerModeChanged(object sender, PowerModeChangedEventArgs e)
2014-01-29 20:30:26 +00:00
{
Restart();
}
private void Restart()
2013-09-19 15:13:34 +00:00
{
Stop();
Start();
2013-02-21 01:33:05 +00:00
}
2013-04-28 13:24:20 +00:00
private bool EnableLibraryMonitor
{
get
{
switch (ConfigurationManager.Configuration.EnableLibraryMonitor)
{
case AutoOnOff.Auto:
return Environment.OSVersion.Platform == PlatformID.Win32NT;
case AutoOnOff.Enabled:
return true;
default:
return false;
}
}
}
2014-01-29 20:30:26 +00:00
public void Start()
{
if (EnableLibraryMonitor)
2014-01-29 20:30:26 +00:00
{
StartInternal();
}
}
2013-02-21 01:33:05 +00:00
/// <summary>
/// Starts this instance.
/// </summary>
2014-01-29 20:30:26 +00:00
private void StartInternal()
2013-02-21 01:33:05 +00:00
{
LibraryManager.ItemAdded += LibraryManager_ItemAdded;
LibraryManager.ItemRemoved += LibraryManager_ItemRemoved;
var pathsToWatch = new List<string> { LibraryManager.RootFolder.Path };
2013-02-21 01:33:05 +00:00
var paths = LibraryManager
.RootFolder
.Children
.OfType<Folder>()
.SelectMany(f => f.PhysicalLocations)
.Distinct(StringComparer.OrdinalIgnoreCase)
.OrderBy(i => i)
.ToList();
2013-02-21 01:33:05 +00:00
foreach (var path in paths)
{
if (!ContainsParentFolder(pathsToWatch, path))
{
pathsToWatch.Add(path);
}
}
foreach (var path in pathsToWatch)
{
StartWatchingPath(path);
}
}
/// <summary>
/// Handles the ItemRemoved event of the LibraryManager control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="ItemChangeEventArgs"/> instance containing the event data.</param>
void LibraryManager_ItemRemoved(object sender, ItemChangeEventArgs e)
{
2015-11-11 14:56:31 +00:00
if (e.Item.GetParent() is AggregateFolder)
{
StopWatchingPath(e.Item.Path);
}
}
/// <summary>
/// Handles the ItemAdded event of the LibraryManager control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="ItemChangeEventArgs"/> instance containing the event data.</param>
void LibraryManager_ItemAdded(object sender, ItemChangeEventArgs e)
{
2015-11-11 14:56:31 +00:00
if (e.Item.GetParent() is AggregateFolder)
{
StartWatchingPath(e.Item.Path);
}
}
2013-02-21 01:33:05 +00:00
/// <summary>
/// Examine a list of strings assumed to be file paths to see if it contains a parent of
/// the provided path.
/// </summary>
/// <param name="lst">The LST.</param>
/// <param name="path">The path.</param>
/// <returns><c>true</c> if [contains parent folder] [the specified LST]; otherwise, <c>false</c>.</returns>
/// <exception cref="System.ArgumentNullException">path</exception>
private static bool ContainsParentFolder(IEnumerable<string> lst, string path)
{
if (string.IsNullOrEmpty(path))
{
throw new ArgumentNullException("path");
}
path = path.TrimEnd(Path.DirectorySeparatorChar);
return lst.Any(str =>
{
//this should be a little quicker than examining each actual parent folder...
var compare = str.TrimEnd(Path.DirectorySeparatorChar);
return (path.Equals(compare, StringComparison.OrdinalIgnoreCase) || (path.StartsWith(compare, StringComparison.OrdinalIgnoreCase) && path[compare.Length] == Path.DirectorySeparatorChar));
});
}
/// <summary>
/// Starts the watching path.
/// </summary>
/// <param name="path">The path.</param>
private void StartWatchingPath(string path)
{
// Creating a FileSystemWatcher over the LAN can take hundreds of milliseconds, so wrap it in a Task to do them all in parallel
Task.Run(() =>
{
2014-03-27 19:30:21 +00:00
try
{
var newWatcher = new FileSystemWatcher(path, "*")
{
2016-01-06 22:47:32 +00:00
IncludeSubdirectories = true
2014-03-27 19:30:21 +00:00
};
2013-02-21 01:33:05 +00:00
2016-01-06 22:47:32 +00:00
if (Environment.OSVersion.Platform == PlatformID.Win32NT)
{
newWatcher.InternalBufferSize = 32767;
}
2014-03-31 02:33:10 +00:00
newWatcher.NotifyFilter = NotifyFilters.CreationTime |
NotifyFilters.DirectoryName |
NotifyFilters.FileName |
NotifyFilters.LastWrite |
NotifyFilters.Size |
NotifyFilters.Attributes;
2013-02-21 01:33:05 +00:00
2014-03-27 19:30:21 +00:00
newWatcher.Created += watcher_Changed;
newWatcher.Deleted += watcher_Changed;
newWatcher.Renamed += watcher_Changed;
newWatcher.Changed += watcher_Changed;
newWatcher.Error += watcher_Error;
2013-02-21 01:33:05 +00:00
2013-05-05 13:40:44 +00:00
if (_fileSystemWatchers.TryAdd(path, newWatcher))
{
newWatcher.EnableRaisingEvents = true;
Logger.Info("Watching directory " + path);
}
else
{
2014-03-16 16:43:05 +00:00
Logger.Info("Unable to add directory watcher for {0}. It already exists in the dictionary.", path);
2013-05-05 13:40:44 +00:00
newWatcher.Dispose();
}
2013-02-21 01:33:05 +00:00
}
2014-03-27 19:30:21 +00:00
catch (Exception ex)
2013-02-21 01:33:05 +00:00
{
Logger.ErrorException("Error watching path: {0}", ex, path);
}
});
}
/// <summary>
/// Stops the watching path.
/// </summary>
/// <param name="path">The path.</param>
private void StopWatchingPath(string path)
{
2013-05-05 13:40:44 +00:00
FileSystemWatcher watcher;
2013-02-21 01:33:05 +00:00
2013-05-05 13:40:44 +00:00
if (_fileSystemWatchers.TryGetValue(path, out watcher))
2013-02-21 01:33:05 +00:00
{
DisposeWatcher(watcher);
}
}
/// <summary>
/// Disposes the watcher.
/// </summary>
/// <param name="watcher">The watcher.</param>
private void DisposeWatcher(FileSystemWatcher watcher)
{
2014-10-13 20:14:53 +00:00
try
{
using (watcher)
{
Logger.Info("Stopping directory watching for path {0}", watcher.Path);
2013-02-21 01:33:05 +00:00
2014-10-13 20:14:53 +00:00
watcher.EnableRaisingEvents = false;
}
}
catch
{
2015-07-28 19:42:24 +00:00
2014-10-13 20:14:53 +00:00
}
finally
{
RemoveWatcherFromList(watcher);
}
2013-05-05 13:40:44 +00:00
}
2013-02-21 01:33:05 +00:00
2013-05-05 13:40:44 +00:00
/// <summary>
/// Removes the watcher from list.
/// </summary>
/// <param name="watcher">The watcher.</param>
private void RemoveWatcherFromList(FileSystemWatcher watcher)
{
FileSystemWatcher removed;
2013-02-21 01:33:05 +00:00
2013-05-05 13:40:44 +00:00
_fileSystemWatchers.TryRemove(watcher.Path, out removed);
2013-02-21 01:33:05 +00:00
}
/// <summary>
/// Handles the Error event of the watcher control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="ErrorEventArgs" /> instance containing the event data.</param>
2013-09-19 15:13:34 +00:00
void watcher_Error(object sender, ErrorEventArgs e)
2013-02-21 01:33:05 +00:00
{
var ex = e.GetException();
2013-04-28 13:24:20 +00:00
var dw = (FileSystemWatcher)sender;
2013-02-21 01:33:05 +00:00
2013-04-28 13:24:20 +00:00
Logger.ErrorException("Error in Directory watcher for: " + dw.Path, ex);
2013-02-21 01:33:05 +00:00
2013-09-19 15:13:34 +00:00
DisposeWatcher(dw);
2015-07-28 19:42:24 +00:00
2015-07-29 03:42:03 +00:00
if (ConfigurationManager.Configuration.EnableLibraryMonitor == AutoOnOff.Auto)
2015-07-28 19:42:24 +00:00
{
Logger.Info("Disabling realtime monitor to prevent future instability");
2015-07-29 03:42:03 +00:00
ConfigurationManager.Configuration.EnableLibraryMonitor = AutoOnOff.Disabled;
Stop();
2015-07-28 19:42:24 +00:00
}
2013-02-21 01:33:05 +00:00
}
/// <summary>
/// Handles the Changed event of the watcher control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="FileSystemEventArgs" /> instance containing the event data.</param>
void watcher_Changed(object sender, FileSystemEventArgs e)
{
try
{
2014-03-29 15:40:32 +00:00
Logger.Debug("Changed detected of type " + e.ChangeType + " to " + e.FullPath);
2014-03-27 19:30:21 +00:00
ReportFileSystemChanged(e.FullPath);
}
catch (Exception ex)
{
2014-03-29 15:40:32 +00:00
Logger.ErrorException("Exception in ReportFileSystemChanged. Path: {0}", ex, e.FullPath);
}
}
public void ReportFileSystemChanged(string path)
{
if (string.IsNullOrEmpty(path))
{
throw new ArgumentNullException("path");
}
2014-01-29 20:30:26 +00:00
var filename = Path.GetFileName(path);
2014-03-27 19:30:21 +00:00
var monitorPath = !(!string.IsNullOrEmpty(filename) && _alwaysIgnoreFiles.Contains(filename, StringComparer.OrdinalIgnoreCase));
2014-03-27 19:30:21 +00:00
// Ignore certain files
2013-05-19 23:44:05 +00:00
var tempIgnorePaths = _tempIgnoredPaths.Keys.ToList();
// If the parent of an ignored path has a change event, ignore that too
if (tempIgnorePaths.Any(i =>
2013-05-19 23:44:05 +00:00
{
if (string.Equals(i, path, StringComparison.OrdinalIgnoreCase))
{
Logger.Debug("Ignoring change to {0}", path);
return true;
}
if (_fileSystem.ContainsSubPath(i, path))
{
Logger.Debug("Ignoring change to {0}", path);
return true;
}
// Go up a level
var parent = Path.GetDirectoryName(i);
if (!string.IsNullOrEmpty(parent))
{
if (string.Equals(parent, path, StringComparison.OrdinalIgnoreCase))
{
Logger.Debug("Ignoring change to {0}", path);
return true;
}
}
return false;
}))
{
2014-03-27 19:30:21 +00:00
monitorPath = false;
2013-05-19 23:44:05 +00:00
}
2014-03-27 19:30:21 +00:00
if (monitorPath)
{
// Avoid implicitly captured closure
var affectedPath = path;
_affectedPaths.AddOrUpdate(path, path, (key, oldValue) => affectedPath);
}
2013-02-21 01:33:05 +00:00
2014-04-02 21:55:19 +00:00
RestartTimer();
}
private void RestartTimer()
{
lock (_timerLock)
2013-02-21 01:33:05 +00:00
{
if (_updateTimer == null)
2013-02-21 01:33:05 +00:00
{
_updateTimer = new Timer(TimerStopped, null, TimeSpan.FromSeconds(ConfigurationManager.Configuration.LibraryMonitorDelay), TimeSpan.FromMilliseconds(-1));
2013-02-21 01:33:05 +00:00
}
else
{
_updateTimer.Change(TimeSpan.FromSeconds(ConfigurationManager.Configuration.LibraryMonitorDelay), TimeSpan.FromMilliseconds(-1));
2013-02-21 01:33:05 +00:00
}
}
}
/// <summary>
/// Timers the stopped.
/// </summary>
/// <param name="stateInfo">The state info.</param>
private async void TimerStopped(object stateInfo)
{
2014-04-02 21:55:19 +00:00
// Extend the timer as long as any of the paths are still being written to.
if (_affectedPaths.Any(p => IsFileLocked(p.Key)))
{
Logger.Info("Timer extended.");
RestartTimer();
return;
}
Logger.Debug("Timer stopped.");
2013-02-21 01:33:05 +00:00
DisposeTimer();
2013-02-21 01:33:05 +00:00
var paths = _affectedPaths.Keys.ToList();
_affectedPaths.Clear();
2013-02-21 01:33:05 +00:00
2014-03-10 02:33:49 +00:00
try
{
await ProcessPathChanges(paths).ConfigureAwait(false);
}
catch (Exception ex)
{
Logger.ErrorException("Error processing directory changes", ex);
}
2013-02-21 01:33:05 +00:00
}
2014-04-02 21:55:19 +00:00
private bool IsFileLocked(string path)
{
if (Environment.OSVersion.Platform != PlatformID.Win32NT)
{
// Causing lockups on linux
return false;
}
2014-04-02 21:55:19 +00:00
try
{
var data = _fileSystem.GetFileSystemInfo(path);
if (!data.Exists
|| data.IsDirectory
2014-04-02 21:55:19 +00:00
// Opening a writable stream will fail with readonly files
|| data.Attributes.HasFlag(FileAttributes.ReadOnly))
{
return false;
}
}
catch (IOException)
{
return false;
}
catch (Exception ex)
{
Logger.ErrorException("Error getting file system info for: {0}", ex, path);
return false;
}
// In order to determine if the file is being written to, we have to request write access
// But if the server only has readonly access, this is going to cause this entire algorithm to fail
// So we'll take a best guess about our access level
var requestedFileAccess = ConfigurationManager.Configuration.SaveLocalMeta
? FileAccess.ReadWrite
: FileAccess.Read;
2014-04-02 21:55:19 +00:00
try
{
using (_fileSystem.GetFileStream(path, FileMode.Open, requestedFileAccess, FileShare.ReadWrite))
2014-04-02 21:55:19 +00:00
{
if (_updateTimer != null)
{
//file is not locked
return false;
}
}
}
catch (DirectoryNotFoundException)
{
// File may have been deleted
return false;
}
catch (FileNotFoundException)
{
// File may have been deleted
return false;
}
catch (IOException)
{
//the file is unavailable because it is:
//still being written to
//or being processed by another thread
//or does not exist (has already been processed)
Logger.Debug("{0} is locked.", path);
return true;
}
catch (Exception ex)
{
Logger.ErrorException("Error determining if file is locked: {0}", ex, path);
return false;
}
return false;
}
private void DisposeTimer()
2013-02-21 01:33:05 +00:00
{
lock (_timerLock)
2013-02-21 01:33:05 +00:00
{
if (_updateTimer != null)
2013-05-07 18:57:27 +00:00
{
_updateTimer.Dispose();
_updateTimer = null;
2013-05-07 18:57:27 +00:00
}
2013-02-21 01:33:05 +00:00
}
}
/// <summary>
/// Processes the path changes.
/// </summary>
/// <param name="paths">The paths.</param>
/// <returns>Task.</returns>
private async Task ProcessPathChanges(List<string> paths)
{
2015-05-05 23:19:47 +00:00
var itemsToRefresh = paths
2013-02-21 01:33:05 +00:00
.Select(GetAffectedBaseItem)
.Where(item => item != null)
.Distinct()
.ToList();
foreach (var p in paths)
{
Logger.Info(p + " reports change.");
}
2013-02-21 01:33:05 +00:00
// If the root folder changed, run the library task so the user can see it
if (itemsToRefresh.Any(i => i is AggregateFolder))
{
2013-02-23 07:57:11 +00:00
TaskManager.CancelIfRunningAndQueue<RefreshMediaLibraryTask>();
2013-02-21 01:33:05 +00:00
return;
}
2013-12-30 02:41:22 +00:00
foreach (var item in itemsToRefresh)
2013-02-21 01:33:05 +00:00
{
2013-12-30 02:41:22 +00:00
Logger.Info(item.Name + " (" + item.Path + ") will be refreshed.");
2013-04-28 13:24:20 +00:00
2013-02-21 01:33:05 +00:00
try
{
2013-12-30 02:41:22 +00:00
await item.ChangedExternally().ConfigureAwait(false);
2013-02-21 01:33:05 +00:00
}
catch (IOException ex)
{
// For now swallow and log.
// Research item: If an IOException occurs, the item may be in a disconnected state (media unavailable)
// Should we remove it from it's parent?
2013-12-30 02:41:22 +00:00
Logger.ErrorException("Error refreshing {0}", ex, item.Name);
2013-02-21 01:33:05 +00:00
}
2013-03-27 22:13:46 +00:00
catch (Exception ex)
{
2013-12-30 02:41:22 +00:00
Logger.ErrorException("Error refreshing {0}", ex, item.Name);
2013-03-27 22:13:46 +00:00
}
2013-12-30 02:41:22 +00:00
}
2013-02-21 01:33:05 +00:00
}
/// <summary>
/// Gets the affected base item.
/// </summary>
/// <param name="path">The path.</param>
/// <returns>BaseItem.</returns>
private BaseItem GetAffectedBaseItem(string path)
{
BaseItem item = null;
while (item == null && !string.IsNullOrEmpty(path))
{
item = LibraryManager.RootFolder.FindByPath(path);
2013-02-21 01:33:05 +00:00
path = Path.GetDirectoryName(path);
}
if (item != null)
{
// If the item has been deleted find the first valid parent that still exists
2015-09-13 21:32:02 +00:00
while (!_fileSystem.DirectoryExists(item.Path) && !_fileSystem.FileExists(item.Path))
2013-02-21 01:33:05 +00:00
{
2015-11-11 14:56:31 +00:00
item = item.GetParent();
2013-02-21 01:33:05 +00:00
if (item == null)
{
break;
}
}
}
return item;
}
/// <summary>
/// Stops this instance.
/// </summary>
public void Stop()
2013-02-21 01:33:05 +00:00
{
LibraryManager.ItemAdded -= LibraryManager_ItemAdded;
LibraryManager.ItemRemoved -= LibraryManager_ItemRemoved;
2013-02-21 01:33:05 +00:00
2013-05-05 13:40:44 +00:00
foreach (var watcher in _fileSystemWatchers.Values.ToList())
2013-02-21 01:33:05 +00:00
{
2016-02-26 14:50:44 +00:00
watcher.Created -= watcher_Changed;
watcher.Deleted -= watcher_Changed;
watcher.Renamed -= watcher_Changed;
2013-02-21 01:33:05 +00:00
watcher.Changed -= watcher_Changed;
2016-02-26 14:50:44 +00:00
try
{
watcher.EnableRaisingEvents = false;
}
catch (InvalidOperationException)
{
// Seeing this under mono on linux sometimes
// Collection was modified; enumeration operation may not execute.
}
2013-02-21 01:33:05 +00:00
watcher.Dispose();
}
DisposeTimer();
2013-02-21 01:33:05 +00:00
2013-08-13 14:41:45 +00:00
_fileSystemWatchers.Clear();
_affectedPaths.Clear();
2013-02-21 01:33:05 +00:00
}
/// <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)
{
if (dispose)
{
Stop();
}
}
}
2015-08-27 01:31:54 +00:00
public class LibraryMonitorStartup : IServerEntryPoint
{
private readonly ILibraryMonitor _monitor;
public LibraryMonitorStartup(ILibraryMonitor monitor)
{
_monitor = monitor;
}
public void Run()
{
_monitor.Start();
}
public void Dispose()
{
}
}
2013-02-21 01:33:05 +00:00
}