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

630 lines
21 KiB
C#
Raw Normal View History

using System;
2013-02-21 01:33:05 +00:00
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
2016-11-11 04:25:21 +00:00
using MediaBrowser.Controller.Configuration;
using MediaBrowser.Controller.Entities;
using MediaBrowser.Controller.Library;
using MediaBrowser.Controller.Plugins;
2016-10-25 19:02:04 +00:00
using MediaBrowser.Model.IO;
2016-11-04 18:56:47 +00:00
using MediaBrowser.Model.System;
2016-10-23 19:47:34 +00:00
using MediaBrowser.Model.Tasks;
using Microsoft.Extensions.Logging;
2013-02-21 01:33:05 +00:00
namespace Emby.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 affected paths
/// </summary>
private readonly List<FileRefresher> _activeRefreshers = new List<FileRefresher>();
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>
2019-02-06 19:38:42 +00:00
private static readonly HashSet<string> _alwaysIgnoreFiles = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
2014-02-26 04:38:21 +00:00
{
"small.jpg",
2014-02-26 04:38:21 +00:00
"albumart.jpg",
// WMC temp recording directories that will constantly be written to
"TempRec",
2016-09-25 18:39:13 +00:00
"TempSBE"
2014-02-26 04:38:21 +00:00
};
2019-02-06 19:38:42 +00:00
private static readonly string[] _alwaysIgnoreSubstrings = new string[]
{
// Synology
2016-09-25 18:39:13 +00:00
"eaDir",
"#recycle",
".wd_tv",
".actors"
};
2019-02-06 19:38:42 +00:00
private static readonly HashSet<string> _alwaysIgnoreExtensions = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
2016-08-16 17:08:37 +00:00
{
// thumbs.db
".db",
// bts sync files
2016-08-17 05:29:05 +00:00
".bts",
".sync"
2016-08-16 17:08:37 +00:00
};
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(nameof(path));
}
TemporarilyIgnore(path);
}
2016-02-24 18:45:20 +00:00
public bool IsPathLocked(string path)
{
2017-08-23 16:45:58 +00:00
// This method is not used by the core but it used by auto-organize
2016-02-24 18:45:20 +00:00
var lockedPaths = _tempIgnoredPaths.Keys.ToList();
return lockedPaths.Any(i => _fileSystem.AreEqual(i, path) || _fileSystem.ContainsSubPath(i, path));
2016-02-24 18:45:20 +00:00
}
2014-01-29 05:17:58 +00:00
public async void ReportFileSystemChangeComplete(string path, bool refreshPath)
{
if (string.IsNullOrEmpty(path))
{
throw new ArgumentNullException(nameof(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
2016-07-22 05:17:09 +00:00
await Task.Delay(45000).ConfigureAwait(false);
2014-01-29 05:17:58 +00:00
_tempIgnoredPaths.TryRemove(path, out var val);
if (refreshPath)
{
2016-09-15 20:30:46 +00:00
try
{
ReportFileSystemChanged(path);
}
catch (Exception ex)
{
2018-12-20 12:11:26 +00:00
Logger.LogError(ex, "Error in ReportFileSystemChanged for {path}", path);
2016-09-15 20:30:46 +00:00
}
}
}
2013-02-21 01:33:05 +00:00
/// <summary>
/// Gets or sets the logger.
/// </summary>
/// <value>The logger.</value>
private ILogger Logger { 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;
2016-11-04 19:51:59 +00:00
private readonly IEnvironmentInfo _environmentInfo;
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>
2019-01-25 21:41:43 +00:00
public LibraryMonitor(
ILoggerFactory loggerFactory,
ILibraryManager libraryManager,
IServerConfigurationManager configurationManager,
IFileSystem fileSystem,
IEnvironmentInfo environmentInfo)
2013-02-21 01:33:05 +00:00
{
LibraryManager = libraryManager;
Logger = loggerFactory.CreateLogger(GetType().Name);
2013-03-04 05:43:06 +00:00
ConfigurationManager = configurationManager;
2014-01-29 01:46:04 +00:00
_fileSystem = fileSystem;
2016-11-04 19:51:59 +00:00
_environmentInfo = environmentInfo;
2013-02-21 01:33:05 +00:00
}
2013-04-28 13:24:20 +00:00
2019-01-25 21:41:43 +00:00
private bool IsLibraryMonitorEnabled(BaseItem item)
2014-01-29 20:30:26 +00:00
{
if (item is BasePluginFolder)
{
return false;
}
2016-08-24 20:46:26 +00:00
var options = LibraryManager.GetLibraryOptions(item);
2016-09-11 07:33:53 +00:00
if (options != null)
2014-01-29 20:30:26 +00:00
{
2016-08-24 20:46:26 +00:00
return options.EnableRealtimeMonitor;
2014-01-29 20:30:26 +00:00
}
2016-08-24 20:46:26 +00:00
2016-09-11 07:33:53 +00:00
return false;
2014-01-29 20:30:26 +00:00
}
2016-08-24 20:46:26 +00:00
public void Start()
2013-02-21 01:33:05 +00:00
{
LibraryManager.ItemAdded += LibraryManager_ItemAdded;
LibraryManager.ItemRemoved += LibraryManager_ItemRemoved;
2016-08-24 20:46:26 +00:00
var pathsToWatch = new List<string> { };
2013-02-21 01:33:05 +00:00
var paths = LibraryManager
.RootFolder
.Children
2019-01-25 21:41:43 +00:00
.Where(IsLibraryMonitorEnabled)
.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);
}
}
2016-08-24 20:46:26 +00:00
private void StartWatching(BaseItem item)
{
2019-01-25 21:41:43 +00:00
if (IsLibraryMonitorEnabled(item))
2016-08-24 20:46:26 +00:00
{
StartWatchingPath(item.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)
{
2017-11-26 04:48:12 +00:00
if (e.Parent 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)
{
2017-11-26 04:48:12 +00:00
if (e.Parent is AggregateFolder)
{
2016-08-24 20:46:26 +00:00
StartWatching(e.Item);
}
}
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>
2019-01-13 20:37:13 +00:00
/// <exception cref="ArgumentNullException">path</exception>
2013-02-21 01:33:05 +00:00
private static bool ContainsParentFolder(IEnumerable<string> lst, string path)
{
2018-09-12 17:26:21 +00:00
if (string.IsNullOrEmpty(path))
2013-02-21 01:33:05 +00:00
{
throw new ArgumentNullException(nameof(path));
2013-02-21 01:33:05 +00:00
}
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);
2016-03-27 21:11:27 +00:00
return path.Equals(compare, StringComparison.OrdinalIgnoreCase) || (path.StartsWith(compare, StringComparison.OrdinalIgnoreCase) && path[compare.Length] == Path.DirectorySeparatorChar);
2013-02-21 01:33:05 +00:00
});
}
/// <summary>
/// Starts the watching path.
/// </summary>
/// <param name="path">The path.</param>
private void StartWatchingPath(string path)
{
if (!Directory.Exists(path))
2017-02-03 20:52:56 +00:00
{
// Seeing a crash in the mono runtime due to an exception being thrown on a different thread
Logger.LogInformation("Skipping realtime monitor for {0} because the path does not exist", path);
2017-02-03 20:52:56 +00:00
return;
}
2017-05-08 18:05:47 +00:00
if (_environmentInfo.OperatingSystem != MediaBrowser.Model.System.OperatingSystem.Windows)
{
if (path.StartsWith("\\\\", StringComparison.OrdinalIgnoreCase) || path.StartsWith("smb://", StringComparison.OrdinalIgnoreCase))
{
// not supported
return;
}
}
2018-09-12 17:26:21 +00:00
if (_environmentInfo.OperatingSystem == MediaBrowser.Model.System.OperatingSystem.Android)
{
// causing crashing
return;
}
2017-02-03 20:52:56 +00:00
// Already being watched
if (_fileSystemWatchers.ContainsKey(path))
{
return;
}
2013-02-21 01:33:05 +00:00
// 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
2018-09-12 17:26:21 +00:00
newWatcher.InternalBufferSize = 65536;
2016-01-06 22:47:32 +00:00
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;
2017-10-01 17:26:09 +00:00
newWatcher.Deleted += watcher_Changed;
2014-03-27 19:30:21 +00:00
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.LogInformation("Watching directory " + path);
2013-05-05 13:40:44 +00:00
}
else
{
2018-09-12 17:26:21 +00:00
DisposeWatcher(newWatcher, false);
2013-05-05 13:40:44 +00:00
}
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
{
2018-12-20 12:11:26 +00:00
Logger.LogError(ex, "Error watching path: {path}", path);
2013-02-21 01:33:05 +00:00
}
});
}
/// <summary>
/// Stops the watching path.
/// </summary>
/// <param name="path">The path.</param>
private void StopWatchingPath(string path)
{
if (_fileSystemWatchers.TryGetValue(path, out var watcher))
2013-02-21 01:33:05 +00:00
{
2018-09-12 17:26:21 +00:00
DisposeWatcher(watcher, true);
2013-02-21 01:33:05 +00:00
}
}
/// <summary>
/// Disposes the watcher.
/// </summary>
2018-09-12 17:26:21 +00:00
private void DisposeWatcher(FileSystemWatcher watcher, bool removeFromList)
2013-02-21 01:33:05 +00:00
{
2014-10-13 20:14:53 +00:00
try
{
using (watcher)
{
2018-12-20 12:11:26 +00:00
Logger.LogInformation("Stopping directory watching for path {path}", watcher.Path);
2013-02-21 01:33:05 +00:00
2018-09-12 17:26:21 +00:00
watcher.Created -= watcher_Changed;
watcher.Deleted -= watcher_Changed;
watcher.Renamed -= watcher_Changed;
watcher.Changed -= watcher_Changed;
watcher.Error -= watcher_Error;
try
{
watcher.EnableRaisingEvents = false;
}
catch (InvalidOperationException)
{
// Seeing this under mono on linux sometimes
// Collection was modified; enumeration operation may not execute.
}
2014-10-13 20:14:53 +00:00
}
}
2018-09-12 17:26:21 +00:00
catch (NotImplementedException)
{
// the dispose method on FileSystemWatcher is sometimes throwing NotImplementedException on Xamarin Android
}
2014-10-13 20:14:53 +00:00
catch
{
2015-07-28 19:42:24 +00:00
2014-10-13 20:14:53 +00:00
}
finally
{
2018-09-12 17:26:21 +00:00
if (removeFromList)
{
RemoveWatcherFromList(watcher);
}
2014-10-13 20:14:53 +00:00
}
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)
{
_fileSystemWatchers.TryRemove(watcher.Path, out var 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
2018-12-20 12:11:26 +00:00
Logger.LogError(ex, "Error in Directory watcher for: {path}", dw.Path);
2013-02-21 01:33:05 +00:00
2018-09-12 17:26:21 +00:00
DisposeWatcher(dw, true);
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
{
//logger.LogDebug("Changed detected of type " + e.ChangeType + " to " + e.FullPath);
2014-03-27 19:30:21 +00:00
2016-09-20 19:43:27 +00:00
var path = e.FullPath;
ReportFileSystemChanged(path);
}
catch (Exception ex)
{
2018-12-20 12:11:26 +00:00
Logger.LogError(ex, "Exception in ReportFileSystemChanged. Path: {FullPath}", e.FullPath);
}
}
public void ReportFileSystemChanged(string path)
{
if (string.IsNullOrEmpty(path))
{
throw new ArgumentNullException(nameof(path));
}
2014-01-29 20:30:26 +00:00
var filename = Path.GetFileName(path);
2018-09-12 17:26:21 +00:00
2016-08-24 20:46:26 +00:00
var monitorPath = !string.IsNullOrEmpty(filename) &&
2019-02-06 20:31:41 +00:00
!_alwaysIgnoreFiles.Contains(filename) &&
!_alwaysIgnoreExtensions.Contains(Path.GetExtension(path)) &&
_alwaysIgnoreSubstrings.All(i => path.IndexOf(i, StringComparison.OrdinalIgnoreCase) == -1);
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
{
2017-05-04 07:00:52 +00:00
if (_fileSystem.AreEqual(i, path))
{
2018-12-20 12:11:26 +00:00
Logger.LogDebug("Ignoring change to {path}", path);
return true;
}
if (_fileSystem.ContainsSubPath(i, path))
{
2018-12-20 12:11:26 +00:00
Logger.LogDebug("Ignoring change to {path}", path);
return true;
}
// Go up a level
var parent = Path.GetDirectoryName(i);
if (!string.IsNullOrEmpty(parent))
{
2017-05-04 07:00:52 +00:00
if (_fileSystem.AreEqual(parent, path))
{
2018-12-20 12:11:26 +00:00
Logger.LogDebug("Ignoring change to {path}", 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
CreateRefresher(path);
2014-03-10 02:33:49 +00:00
}
2013-02-21 01:33:05 +00:00
}
private void CreateRefresher(string path)
2014-04-02 21:55:19 +00:00
{
var parentPath = Path.GetDirectoryName(path);
lock (_activeRefreshers)
2014-04-02 21:55:19 +00:00
{
var refreshers = _activeRefreshers.ToList();
foreach (var refresher in refreshers)
2014-04-02 21:55:19 +00:00
{
// Path is already being refreshed
2017-05-04 07:00:52 +00:00
if (_fileSystem.AreEqual(path, refresher.Path))
{
refresher.RestartTimer();
return;
}
// Parent folder is already being refreshed
if (_fileSystem.ContainsSubPath(refresher.Path, path))
2014-04-02 21:55:19 +00:00
{
refresher.AddPath(path);
return;
2014-04-02 21:55:19 +00:00
}
// New path is a parent
if (_fileSystem.ContainsSubPath(path, refresher.Path))
{
refresher.ResetPath(path, null);
return;
}
2014-04-02 21:55:19 +00:00
2016-05-27 03:46:21 +00:00
// They are siblings. Rebase the refresher to the parent folder.
if (string.Equals(parentPath, Path.GetDirectoryName(refresher.Path), StringComparison.Ordinal))
{
refresher.ResetPath(parentPath, path);
return;
}
2013-05-07 18:57:27 +00:00
}
2013-04-28 13:24:20 +00:00
2019-02-06 19:38:42 +00:00
var newRefresher = new FileRefresher(path, ConfigurationManager, LibraryManager, Logger);
newRefresher.Completed += NewRefresher_Completed;
_activeRefreshers.Add(newRefresher);
2013-12-30 02:41:22 +00:00
}
2013-02-21 01:33:05 +00:00
}
private void NewRefresher_Completed(object sender, EventArgs e)
2013-02-21 01:33:05 +00:00
{
var refresher = (FileRefresher)sender;
DisposeRefresher(refresher);
2013-02-21 01:33:05 +00:00
}
/// <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
{
2018-09-12 17:26:21 +00:00
DisposeWatcher(watcher, false);
2013-02-21 01:33:05 +00:00
}
2013-08-13 14:41:45 +00:00
_fileSystemWatchers.Clear();
DisposeRefreshers();
}
private void DisposeRefresher(FileRefresher refresher)
{
lock (_activeRefreshers)
{
refresher.Dispose();
_activeRefreshers.Remove(refresher);
}
}
private void DisposeRefreshers()
{
lock (_activeRefreshers)
{
foreach (var refresher in _activeRefreshers.ToList())
{
refresher.Dispose();
}
_activeRefreshers.Clear();
}
2013-02-21 01:33:05 +00:00
}
2017-04-02 00:36:06 +00:00
private bool _disposed;
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);
}
/// <summary>
/// Releases unmanaged and - optionally - managed resources.
/// </summary>
2019-02-01 20:56:50 +00:00
/// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
protected virtual void Dispose(bool disposing)
2013-02-21 01:33:05 +00:00
{
2019-02-01 20:56:50 +00:00
if (_disposed)
{
return;
}
if (disposing)
2013-02-21 01:33:05 +00:00
{
Stop();
}
2019-02-01 20:56:50 +00:00
_disposed = true;
2013-02-21 01:33:05 +00:00
}
}
2015-08-27 01:31:54 +00:00
public class LibraryMonitorStartup : IServerEntryPoint
{
private readonly ILibraryMonitor _monitor;
public LibraryMonitorStartup(ILibraryMonitor monitor)
{
_monitor = monitor;
}
2019-01-27 14:40:37 +00:00
public Task RunAsync()
2015-08-27 01:31:54 +00:00
{
_monitor.Start();
2019-01-27 14:40:37 +00:00
return Task.CompletedTask;
2015-08-27 01:31:54 +00:00
}
public void Dispose()
{
}
}
2013-02-21 01:33:05 +00:00
}