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

327 lines
10 KiB
C#
Raw Normal View History

2016-05-26 04:11:27 +00:00
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
2016-10-25 19:02:04 +00:00
using MediaBrowser.Model.IO;
using MediaBrowser.Common.Events;
2016-10-25 19:02:04 +00:00
using MediaBrowser.Common.IO;
2016-05-26 04:11:27 +00:00
using MediaBrowser.Controller.Configuration;
using MediaBrowser.Controller.Entities;
2016-10-25 19:02:04 +00:00
using MediaBrowser.Controller.IO;
2016-05-26 04:11:27 +00:00
using MediaBrowser.Controller.Library;
2016-10-22 02:08:34 +00:00
using MediaBrowser.Model.Extensions;
2016-05-26 04:11:27 +00:00
using MediaBrowser.Model.Logging;
2016-11-04 19:51:59 +00:00
using MediaBrowser.Model.System;
2016-10-23 19:47:34 +00:00
using MediaBrowser.Model.Tasks;
using MediaBrowser.Model.Threading;
2016-05-26 04:11:27 +00:00
2016-11-04 18:56:47 +00:00
namespace Emby.Server.Implementations.IO
2016-05-26 04:11:27 +00:00
{
public class FileRefresher : IDisposable
{
private ILogger Logger { get; set; }
private ITaskManager TaskManager { get; set; }
private ILibraryManager LibraryManager { get; set; }
private IServerConfigurationManager ConfigurationManager { get; set; }
private readonly IFileSystem _fileSystem;
private readonly List<string> _affectedPaths = new List<string>();
private ITimer _timer;
private readonly ITimerFactory _timerFactory;
2016-05-26 04:11:27 +00:00
private readonly object _timerLock = new object();
public string Path { get; private set; }
public event EventHandler<EventArgs> Completed;
2016-11-04 19:51:59 +00:00
private readonly IEnvironmentInfo _environmentInfo;
2016-05-26 04:11:27 +00:00
2016-11-04 19:51:59 +00:00
public FileRefresher(string path, IFileSystem fileSystem, IServerConfigurationManager configurationManager, ILibraryManager libraryManager, ITaskManager taskManager, ILogger logger, ITimerFactory timerFactory, IEnvironmentInfo environmentInfo)
2016-05-26 04:11:27 +00:00
{
logger.Debug("New file refresher created for {0}", path);
Path = path;
2016-05-26 04:11:27 +00:00
_fileSystem = fileSystem;
ConfigurationManager = configurationManager;
LibraryManager = libraryManager;
TaskManager = taskManager;
Logger = logger;
_timerFactory = timerFactory;
2016-11-04 19:51:59 +00:00
_environmentInfo = environmentInfo;
2016-07-03 02:47:39 +00:00
AddPath(path);
2016-05-26 04:11:27 +00:00
}
private void AddAffectedPath(string path)
{
if (string.IsNullOrWhiteSpace(path))
{
throw new ArgumentNullException("path");
}
if (!_affectedPaths.Contains(path, StringComparer.Ordinal))
{
_affectedPaths.Add(path);
}
}
public void AddPath(string path)
{
if (string.IsNullOrWhiteSpace(path))
{
throw new ArgumentNullException("path");
}
lock (_timerLock)
{
AddAffectedPath(path);
}
RestartTimer();
}
public void RestartTimer()
2016-05-26 04:11:27 +00:00
{
2016-08-11 03:56:01 +00:00
if (_disposed)
{
return;
}
2016-05-26 04:11:27 +00:00
lock (_timerLock)
{
2016-09-17 06:08:38 +00:00
if (_disposed)
{
return;
}
2016-05-26 04:11:27 +00:00
if (_timer == null)
{
_timer = _timerFactory.Create(OnTimerCallback, null, TimeSpan.FromSeconds(ConfigurationManager.Configuration.LibraryMonitorDelay), TimeSpan.FromMilliseconds(-1));
2016-05-26 04:11:27 +00:00
}
else
{
_timer.Change(TimeSpan.FromSeconds(ConfigurationManager.Configuration.LibraryMonitorDelay), TimeSpan.FromMilliseconds(-1));
}
}
}
public void ResetPath(string path, string affectedFile)
{
lock (_timerLock)
{
Logger.Debug("Resetting file refresher from {0} to {1}", Path, path);
Path = path;
AddAffectedPath(path);
if (!string.IsNullOrWhiteSpace(affectedFile))
{
AddAffectedPath(affectedFile);
}
}
RestartTimer();
}
2016-05-26 04:11:27 +00:00
private async void OnTimerCallback(object state)
{
2016-06-11 15:56:15 +00:00
List<string> paths;
lock (_timerLock)
{
paths = _affectedPaths.ToList();
}
2016-05-26 04:11:27 +00:00
// Extend the timer as long as any of the paths are still being written to.
2016-06-11 15:56:15 +00:00
if (paths.Any(IsFileLocked))
2016-05-26 04:11:27 +00:00
{
Logger.Info("Timer extended.");
RestartTimer();
return;
}
Logger.Debug("Timer stopped.");
DisposeTimer();
EventHelper.FireEventIfNotNull(Completed, this, EventArgs.Empty, Logger);
2016-05-26 04:11:27 +00:00
try
{
2016-06-11 15:56:15 +00:00
await ProcessPathChanges(paths.ToList()).ConfigureAwait(false);
2016-05-26 04:11:27 +00:00
}
catch (Exception ex)
{
Logger.ErrorException("Error processing directory changes", ex);
}
}
private async Task ProcessPathChanges(List<string> paths)
{
var itemsToRefresh = paths
2016-09-20 19:43:27 +00:00
.Distinct(StringComparer.OrdinalIgnoreCase)
2016-05-26 04:11:27 +00:00
.Select(GetAffectedBaseItem)
.Where(item => item != null)
2016-09-20 19:43:27 +00:00
.DistinctBy(i => i.Id)
2016-05-26 04:11:27 +00:00
.ToList();
foreach (var p in paths)
{
Logger.Info(p + " reports change.");
}
// If the root folder changed, run the library task so the user can see it
if (itemsToRefresh.Any(i => i is AggregateFolder))
{
LibraryManager.ValidateMediaLibrary(new Progress<double>(), CancellationToken.None);
2016-05-26 04:11:27 +00:00
return;
}
foreach (var item in itemsToRefresh)
{
Logger.Info(item.Name + " (" + item.Path + ") will be refreshed.");
try
{
await item.ChangedExternally().ConfigureAwait(false);
}
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?
Logger.ErrorException("Error refreshing {0}", ex, item.Name);
}
catch (Exception ex)
{
Logger.ErrorException("Error refreshing {0}", ex, item.Name);
}
}
}
/// <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.FindByPath(path, null);
path = System.IO.Path.GetDirectoryName(path);
2016-05-26 04:11:27 +00:00
}
if (item != null)
{
// If the item has been deleted find the first valid parent that still exists
while (!_fileSystem.DirectoryExists(item.Path) && !_fileSystem.FileExists(item.Path))
{
item = item.GetParent();
if (item == null)
{
break;
}
}
}
return item;
}
private bool IsFileLocked(string path)
{
2016-11-04 19:51:59 +00:00
if (_environmentInfo.OperatingSystem != OperatingSystem.Windows)
{
// Causing lockups on linux
return false;
}
2016-05-26 04:11:27 +00:00
try
{
var data = _fileSystem.GetFileSystemInfo(path);
if (!data.Exists
|| data.IsDirectory
// Opening a writable stream will fail with readonly files
2016-10-25 19:02:04 +00:00
|| data.IsReadOnly)
2016-05-26 04:11:27 +00:00
{
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
2016-10-25 19:02:04 +00:00
? FileAccessMode.ReadWrite
: FileAccessMode.Read;
2016-05-26 04:11:27 +00:00
try
{
2016-10-25 19:02:04 +00:00
using (_fileSystem.GetFileStream(path, FileOpenMode.Open, requestedFileAccess, FileShareMode.ReadWrite))
2016-05-26 04:11:27 +00:00
{
//file is not locked
return false;
}
}
//catch (DirectoryNotFoundException)
//{
// // File may have been deleted
// return false;
//}
2016-05-26 04:11:27 +00:00
catch (FileNotFoundException)
{
// File may have been deleted
return false;
}
catch (UnauthorizedAccessException)
{
Logger.Debug("No write permission for: {0}.", path);
return false;
}
2016-05-26 04:11:27 +00:00
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;
}
}
private void DisposeTimer()
2016-05-26 04:11:27 +00:00
{
lock (_timerLock)
{
if (_timer != null)
{
_timer.Dispose();
2016-09-17 06:08:38 +00:00
_timer = null;
2016-05-26 04:11:27 +00:00
}
}
}
2016-08-11 03:56:01 +00:00
private bool _disposed;
2016-05-26 04:11:27 +00:00
public void Dispose()
{
2016-08-11 03:56:01 +00:00
_disposed = true;
2016-05-26 04:11:27 +00:00
DisposeTimer();
}
}
}