alteropen/jellyfin
1
0
Fork 0
mirror of https://github.com/jellyfin/jellyfin.git synced 2026-06-03 14:28:46 +01:00
Code Issues Actions 8 Packages Projects Releases Wiki Activity

referenced core plugins, fixed some dashboard issues, extracted library manager

Browse Source
This commit is contained in:
LukePulverenti
2013-02-28 14:32:41 -05:00
parent 4435e83e69
commit af7aa597c3
52 changed files with 557 additions and 337 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
MediaBrowser.Controller/Entities/BaseItem.cs
View File

@@ -95,6 +95,7 @@ namespace MediaBrowser.Controller.Entities
/// The logger
/// </summary>
protected static internal ILogger Logger { get; internal set; }
protected static internal ILibraryManager LibraryManager { get; internal set; }
/// <summary>
/// Returns a <see cref="System.String" /> that represents this instance.
@@ -613,7 +614,7 @@ namespace MediaBrowser.Controller.Entities
return new List<Video> { };
}
return Kernel.Instance.LibraryManager.GetItems<Video>(files, null).Select(video =>
return LibraryManager.ResolvePaths<Video>(files, null).Select(video =>
{
// Try to retrieve it from the db. If we don't find it, use the resolved version
var dbItem = Kernel.Instance.ItemRepository.RetrieveItem(video.Id) as Video;

2
MediaBrowser.Controller/Entities/CollectionFolder.cs
View File

@@ -88,7 +88,7 @@ namespace MediaBrowser.Controller.Entities
}
var ourChildren =
Kernel.Instance.RootFolder.Children.OfType<Folder>()
LibraryManager.RootFolder.Children.OfType<Folder>()
.Where(i => folderIds.Contains(i.Id))
.SelectMany(c => c.Children);

12
MediaBrowser.Controller/Entities/Folder.cs
View File

@@ -317,7 +317,7 @@ namespace MediaBrowser.Controller.Entities
{
try
{
return Kernel.Instance.LibraryManager.GetPerson(i).Result;
return LibraryManager.GetPerson(i).Result;
}
catch (IOException ex)
{
@@ -359,7 +359,7 @@ namespace MediaBrowser.Controller.Entities
{
try
{
return Kernel.Instance.LibraryManager.GetStudio(i).Result;
return LibraryManager.GetStudio(i).Result;
}
catch (IOException ex)
{
@@ -399,7 +399,7 @@ namespace MediaBrowser.Controller.Entities
{
try
{
return Kernel.Instance.LibraryManager.GetGenre(i).Result;
return LibraryManager.GetGenre(i).Result;
}
catch (IOException ex)
{
@@ -440,7 +440,7 @@ namespace MediaBrowser.Controller.Entities
{
try
{
return Kernel.Instance.LibraryManager.GetYear(i).Result;
return LibraryManager.GetYear(i).Result;
}
catch (IOException ex)
{
@@ -768,7 +768,7 @@ namespace MediaBrowser.Controller.Entities
IndexCache.Clear();
//and fire event
Kernel.Instance.LibraryManager.OnLibraryChanged(changedArgs);
LibraryManager.ReportLibraryChanged(changedArgs);
}
progress.Report(15);
@@ -860,7 +860,7 @@ namespace MediaBrowser.Controller.Entities
return new List<BaseItem> { };
}
return Kernel.Instance.LibraryManager.GetItems<BaseItem>(fileSystemChildren, this);
return LibraryManager.ResolvePaths<BaseItem>(fileSystemChildren, this);
}
/// <summary>

2
MediaBrowser.Controller/Entities/Movies/Movie.cs
View File

@@ -181,7 +181,7 @@ namespace MediaBrowser.Controller.Entities.Movies
return new List<Video> { };
}
return Kernel.Instance.LibraryManager.GetItems<Video>(files, null).Select(video =>
return LibraryManager.ResolvePaths<Video>(files, null).Select(video =>
{
// Try to retrieve it from the db. If we don't find it, use the resolved version
var dbItem = Kernel.Instance.ItemRepository.RetrieveItem(video.Id) as Video;

2
MediaBrowser.Controller/Entities/User.cs
View File

@@ -124,7 +124,7 @@ namespace MediaBrowser.Controller.Entities
{
get
{
LazyInitializer.EnsureInitialized(ref _rootFolder, ref _userRootFolderInitialized, ref _userRootFolderSyncLock, () => (UserRootFolder)Kernel.Instance.LibraryManager.GetItem(RootFolderPath));
LazyInitializer.EnsureInitialized(ref _rootFolder, ref _userRootFolderInitialized, ref _userRootFolderSyncLock, () => (UserRootFolder)LibraryManager.ResolvePath(RootFolderPath));
return _rootFolder;
}
private set

2
MediaBrowser.Controller/Entities/UserRootFolder.cs
View File

@@ -15,7 +15,7 @@ namespace MediaBrowser.Controller.Entities
/// <returns>IEnumerable{BaseItem}.</returns>
protected override IEnumerable<BaseItem> GetNonCachedChildren()
{
return base.GetNonCachedChildren().Concat(Kernel.Instance.RootFolder.VirtualChildren);
return base.GetNonCachedChildren().Concat(LibraryManager.RootFolder.VirtualChildren);
}
}
}

19
MediaBrowser.Controller/IO/DirectoryWatchers.cs
View File

@@ -72,11 +72,13 @@ namespace MediaBrowser.Controller.IO
/// </summary>
/// <value>The task manager.</value>
private ITaskManager TaskManager { get; set; }
private ILibraryManager LibraryManager { get; set; }
/// <summary>
/// Initializes a new instance of the <see cref="DirectoryWatchers" /> class.
/// </summary>
public DirectoryWatchers(ILogger logger, ITaskManager taskManager)
public DirectoryWatchers(ILogger logger, ITaskManager taskManager, ILibraryManager libraryManager)
{
if (logger == null)
{
@@ -87,6 +89,7 @@ namespace MediaBrowser.Controller.IO
throw new ArgumentNullException("taskManager");
}
LibraryManager = libraryManager;
TaskManager = taskManager;
Logger = logger;
}
@@ -96,11 +99,11 @@ namespace MediaBrowser.Controller.IO
/// </summary>
internal void Start()
{
Kernel.Instance.LibraryManager.LibraryChanged += Instance_LibraryChanged;
var pathsToWatch = new List<string> { Kernel.Instance.RootFolder.Path };
LibraryManager.LibraryChanged += Instance_LibraryChanged;
var paths = Kernel.Instance.RootFolder.Children.OfType<Folder>()
var pathsToWatch = new List<string> { LibraryManager.RootFolder.Path };
var paths = LibraryManager.RootFolder.Children.OfType<Folder>()
.SelectMany(f =>
{
try
@@ -467,7 +470,7 @@ namespace MediaBrowser.Controller.IO
while (item == null && !string.IsNullOrEmpty(path))
{
item = Kernel.Instance.RootFolder.FindByPath(path);
item = LibraryManager.RootFolder.FindByPath(path);
path = Path.GetDirectoryName(path);
}
@@ -494,7 +497,7 @@ namespace MediaBrowser.Controller.IO
/// </summary>
private void Stop()
{
Kernel.Instance.LibraryManager.LibraryChanged -= Instance_LibraryChanged;
LibraryManager.LibraryChanged -= Instance_LibraryChanged;
FileSystemWatcher watcher;

6
MediaBrowser.Controller/IO/FileSystemManager.cs
View File

@@ -2,6 +2,7 @@
using MediaBrowser.Common.Kernel;
using MediaBrowser.Common.ScheduledTasks;
using MediaBrowser.Controller.Entities;
using MediaBrowser.Controller.Library;
using MediaBrowser.Model.Logging;
using System;
using System.IO;
@@ -34,11 +35,12 @@ namespace MediaBrowser.Controller.IO
/// <param name="kernel">The kernel.</param>
/// <param name="logger">The logger.</param>
/// <param name="taskManager">The task manager.</param>
public FileSystemManager(Kernel kernel, ILogger logger, ITaskManager taskManager)
/// <param name="libraryManager">The library manager.</param>
public FileSystemManager(Kernel kernel, ILogger logger, ITaskManager taskManager, ILibraryManager libraryManager)
: base(kernel)
{
_logger = logger;
DirectoryWatchers = new DirectoryWatchers(logger, taskManager);
DirectoryWatchers = new DirectoryWatchers(logger, taskManager, libraryManager);
}
/// <summary>

96
MediaBrowser.Controller/Kernel.cs
View File

@@ -36,12 +36,6 @@ namespace MediaBrowser.Controller
/// <value>The instance.</value>
public static Kernel Instance { get; private set; }
/// <summary>
/// Gets the library manager.
/// </summary>
/// <value>The library manager.</value>
public LibraryManager LibraryManager { get; private set; }
/// <summary>
/// Gets the image manager.
/// </summary>
@@ -72,40 +66,6 @@ namespace MediaBrowser.Controller
/// <value>The provider manager.</value>
public ProviderManager ProviderManager { get; private set; }
/// <summary>
/// The _root folder
/// </summary>
private AggregateFolder _rootFolder;
/// <summary>
/// The _root folder sync lock
/// </summary>
private object _rootFolderSyncLock = new object();
/// <summary>
/// The _root folder initialized
/// </summary>
private bool _rootFolderInitialized;
/// <summary>
/// Gets the root folder.
/// </summary>
/// <value>The root folder.</value>
public AggregateFolder RootFolder
{
get
{
LazyInitializer.EnsureInitialized(ref _rootFolder, ref _rootFolderInitialized, ref _rootFolderSyncLock, LibraryManager.CreateRootFolder);
return _rootFolder;
}
private set
{
_rootFolder = value;
if (value == null)
{
_rootFolderInitialized = false;
}
}
}
/// <summary>
/// Gets the kernel context.
/// </summary>
@@ -156,13 +116,13 @@ namespace MediaBrowser.Controller
/// Gets the list of currently registered entity resolvers
/// </summary>
/// <value>The entity resolvers enumerable.</value>
internal IEnumerable<IBaseItemResolver> EntityResolvers { get; private set; }
public IEnumerable<IBaseItemResolver> EntityResolvers { get; private set; }
/// <summary>
/// Gets the list of BasePluginFolders added by plugins
/// </summary>
/// <value>The plugin folders.</value>
internal IEnumerable<IVirtualFolderCreator> PluginFolderCreators { get; private set; }
public IEnumerable<IVirtualFolderCreator> PluginFolderCreators { get; private set; }
/// <summary>
/// Gets the list of available user repositories
@@ -210,7 +170,7 @@ namespace MediaBrowser.Controller
/// Gets the list of entity resolution ignore rules
/// </summary>
/// <value>The entity resolution ignore rules.</value>
internal IEnumerable<IResolutionIgnoreRule> EntityResolutionIgnoreRules { get; private set; }
public IEnumerable<IResolutionIgnoreRule> EntityResolutionIgnoreRules { get; private set; }
/// <summary>
/// Gets the active user data repository
@@ -233,7 +193,6 @@ namespace MediaBrowser.Controller
/// <param name="appHost">The app host.</param>
/// <param name="appPaths">The app paths.</param>
/// <param name="xmlSerializer">The XML serializer.</param>
/// <param name="taskManager">The task manager.</param>
/// <param name="logger">The logger.</param>
/// <exception cref="System.ArgumentNullException">isoManager</exception>
public Kernel(IApplicationHost appHost, IServerApplicationPaths appPaths, IXmlSerializer xmlSerializer, ILogger logger)
@@ -255,11 +214,11 @@ namespace MediaBrowser.Controller
protected override void FindParts()
{
// For now there's no real way to inject this properly
BaseItem.LibraryManager = ApplicationHost.Resolve<ILibraryManager>();
User.UserManager = ApplicationHost.Resolve<IUserManager>();
InstallationManager = (InstallationManager)ApplicationHost.CreateInstance(typeof(InstallationManager));
FFMpegManager = (FFMpegManager)ApplicationHost.CreateInstance(typeof(FFMpegManager));
LibraryManager = (LibraryManager)ApplicationHost.CreateInstance(typeof(LibraryManager));
ImageManager = (ImageManager)ApplicationHost.CreateInstance(typeof(ImageManager));
ProviderManager = (ProviderManager)ApplicationHost.CreateInstance(typeof(ProviderManager));
SecurityManager = (PluginSecurityManager)ApplicationHost.CreateInstance(typeof(PluginSecurityManager));
@@ -287,9 +246,6 @@ namespace MediaBrowser.Controller
/// <returns>Task.</returns>
protected override async Task ReloadInternal()
{
// Reset these so that they can be lazy loaded again
RootFolder = null;
await base.ReloadInternal().ConfigureAwait(false);
ReloadResourcePools();
@@ -399,52 +355,10 @@ namespace MediaBrowser.Controller
{
DisposeFileSystemManager();
FileSystemManager = new FileSystemManager(this, Logger, ApplicationHost.Resolve<ITaskManager>());
FileSystemManager = new FileSystemManager(this, Logger, ApplicationHost.Resolve<ITaskManager>(), ApplicationHost.Resolve<ILibraryManager>());
FileSystemManager.StartWatchers();
}
/// <summary>
/// Finds a library item by Id and UserId.
/// </summary>
/// <param name="id">The id.</param>
/// <param name="userId">The user id.</param>
/// <param name="userManager">The user manager.</param>
/// <returns>BaseItem.</returns>
/// <exception cref="System.ArgumentNullException">id</exception>
public BaseItem GetItemById(Guid id, Guid userId, IUserManager userManager)
{
if (id == Guid.Empty)
{
throw new ArgumentNullException("id");
}
if (userId == Guid.Empty)
{
throw new ArgumentNullException("userId");
}
var user = userManager.GetUserById(userId);
var userRoot = user.RootFolder;
return userRoot.FindItemById(id, user);
}
/// <summary>
/// Gets the item by id.
/// </summary>
/// <param name="id">The id.</param>
/// <returns>BaseItem.</returns>
/// <exception cref="System.ArgumentNullException">id</exception>
public BaseItem GetItemById(Guid id)
{
if (id == Guid.Empty)
{
throw new ArgumentNullException("id");
}
return RootFolder.FindItemById(id, null);
}
/// <summary>
/// Completely overwrites the current configuration with a new copy
/// </summary>

34
MediaBrowser.Controller/Library/DtoBuilder.cs
View File

@@ -38,7 +38,7 @@ namespace MediaBrowser.Controller.Library
/// <param name="fields">The fields.</param>
/// <returns>Task{DtoBaseItem}.</returns>
/// <exception cref="System.ArgumentNullException">item</exception>
public async Task<BaseItemDto> GetDtoBaseItem(BaseItem item, List<ItemFields> fields)
public async Task<BaseItemDto> GetDtoBaseItem(BaseItem item, List<ItemFields> fields, ILibraryManager libraryManager)
{
if (item == null)
{
@@ -73,7 +73,7 @@ namespace MediaBrowser.Controller.Library
if (fields.Contains(ItemFields.People))
{
tasks.Add(AttachPeople(dto, item));
tasks.Add(AttachPeople(dto, item, libraryManager));
}
AttachBasicFields(dto, item, fields);
@@ -86,16 +86,17 @@ namespace MediaBrowser.Controller.Library
return dto;
}
/// <summary>
/// Converts a BaseItem to a DTOBaseItem
/// </summary>
/// <param name="item">The item.</param>
/// <param name="user">The user.</param>
/// <param name="fields">The fields.</param>
/// <param name="libraryManager">The library manager.</param>
/// <returns>Task{DtoBaseItem}.</returns>
/// <exception cref="System.ArgumentNullException"></exception>
public async Task<BaseItemDto> GetDtoBaseItem(BaseItem item, User user, List<ItemFields> fields)
/// <exception cref="System.ArgumentNullException">item</exception>
public async Task<BaseItemDto> GetDtoBaseItem(BaseItem item, User user, List<ItemFields> fields, ILibraryManager libraryManager)
{
if (item == null)
{
@@ -134,7 +135,7 @@ namespace MediaBrowser.Controller.Library
if (fields.Contains(ItemFields.People))
{
tasks.Add(AttachPeople(dto, item));
tasks.Add(AttachPeople(dto, item, libraryManager));
}
AttachBasicFields(dto, item, fields);
@@ -558,8 +559,9 @@ namespace MediaBrowser.Controller.Library
/// </summary>
/// <param name="dto">The dto.</param>
/// <param name="item">The item.</param>
/// <param name="libraryManager">The library manager.</param>
/// <returns>Task.</returns>
private async Task AttachPeople(BaseItemDto dto, BaseItem item)
private async Task AttachPeople(BaseItemDto dto, BaseItem item, ILibraryManager libraryManager)
{
if (item.People == null)
{
@@ -575,7 +577,7 @@ namespace MediaBrowser.Controller.Library
{
try
{
return await Kernel.Instance.LibraryManager.GetPerson(c.Name).ConfigureAwait(false);
return await libraryManager.GetPerson(c.Name).ConfigureAwait(false);
}
catch (IOException ex)
{
@@ -662,7 +664,7 @@ namespace MediaBrowser.Controller.Library
/// </summary>
/// <param name="changeEvent">The <see cref="ChildrenChangedEventArgs" /> instance containing the event data.</param>
/// <returns>LibraryUpdateInfo.</returns>
internal static LibraryUpdateInfo GetLibraryUpdateInfo(ChildrenChangedEventArgs changeEvent)
public static LibraryUpdateInfo GetLibraryUpdateInfo(ChildrenChangedEventArgs changeEvent)
{
return new LibraryUpdateInfo
{
@@ -823,7 +825,7 @@ namespace MediaBrowser.Controller.Library
/// <param name="id">The id.</param>
/// <param name="userId">The user id.</param>
/// <returns>BaseItem.</returns>
public static BaseItem GetItemByClientId(string id, IUserManager userManager, Guid? userId = null)
public static BaseItem GetItemByClientId(string id, IUserManager userManager, ILibraryManager libraryManager, Guid? userId = null)
{
var isIdEmpty = string.IsNullOrEmpty(id);
@@ -835,7 +837,7 @@ namespace MediaBrowser.Controller.Library
{
if (userId.HasValue)
{
return GetIndexFolder(id, userId.Value, userManager);
return GetIndexFolder(id, userId.Value, userManager, libraryManager);
}
}
@@ -845,11 +847,11 @@ namespace MediaBrowser.Controller.Library
{
item = isIdEmpty
? userManager.GetUserById(userId.Value).RootFolder
: Kernel.Instance.GetItemById(new Guid(id), userId.Value, userManager);
: libraryManager.GetItemById(new Guid(id), userId.Value);
}
else if (!isIndexFolder)
{
item = Kernel.Instance.GetItemById(new Guid(id));
item = libraryManager.GetItemById(new Guid(id));
}
// If we still don't find it, look within individual user views
@@ -857,7 +859,7 @@ namespace MediaBrowser.Controller.Library
{
foreach (var user in userManager.Users)
{
item = GetItemByClientId(id, userManager, user.Id);
item = GetItemByClientId(id, userManager, libraryManager, user.Id);
if (item != null)
{
@@ -875,7 +877,7 @@ namespace MediaBrowser.Controller.Library
/// <param name="id">The id.</param>
/// <param name="userId">The user id.</param>
/// <returns>BaseItem.</returns>
private static BaseItem GetIndexFolder(string id, Guid userId, IUserManager userManager)
private static BaseItem GetIndexFolder(string id, Guid userId, IUserManager userManager, ILibraryManager libraryManager)
{
var user = userManager.GetUserById(userId);
@@ -885,7 +887,7 @@ namespace MediaBrowser.Controller.Library
var values = id.Split(stringSeparators, StringSplitOptions.None).ToList();
// Get the top folder normally using the first id
var folder = GetItemByClientId(values[0], userManager, userId) as Folder;
var folder = GetItemByClientId(values[0], userManager, libraryManager, userId) as Folder;
values.RemoveAt(0);

145
MediaBrowser.Controller/Library/ILibraryManager.cs Normal file
View File

@@ -0,0 +1,145 @@
using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
using MediaBrowser.Controller.Entities;
using MediaBrowser.Controller.IO;
using MediaBrowser.Model.Entities;
namespace MediaBrowser.Controller.Library
{
public interface ILibraryManager
{
/// <summary>
/// Fires whenever any validation routine adds or removes items. The added and removed items are properties of the args.
/// *** Will fire asynchronously. ***
/// </summary>
event EventHandler<ChildrenChangedEventArgs> LibraryChanged;
/// <summary>
/// Raises the <see cref="E:LibraryChanged" /> event.
/// </summary>
/// <param name="args">The <see cref="ChildrenChangedEventArgs" /> instance containing the event data.</param>
void ReportLibraryChanged(ChildrenChangedEventArgs args);
/// <summary>
/// Resolves the item.
/// </summary>
/// <param name="args">The args.</param>
/// <returns>BaseItem.</returns>
BaseItem ResolveItem(ItemResolveArgs args);
/// <summary>
/// Resolves a path into a BaseItem
/// </summary>
/// <param name="path">The path.</param>
/// <param name="parent">The parent.</param>
/// <param name="fileInfo">The file info.</param>
/// <returns>BaseItem.</returns>
/// <exception cref="System.ArgumentNullException"></exception>
BaseItem ResolvePath(string path, Folder parent = null, WIN32_FIND_DATA? fileInfo = null);
/// <summary>
/// Resolves a set of files into a list of BaseItem
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="files">The files.</param>
/// <param name="parent">The parent.</param>
/// <returns>List{``0}.</returns>
List<T> ResolvePaths<T>(IEnumerable<WIN32_FIND_DATA> files, Folder parent)
where T : BaseItem;
/// <summary>
/// Gets the root folder.
/// </summary>
/// <value>The root folder.</value>
AggregateFolder RootFolder { get; }
/// <summary>
/// Gets a Person
/// </summary>
/// <param name="name">The name.</param>
/// <param name="allowSlowProviders">if set to <c>true</c> [allow slow providers].</param>
/// <returns>Task{Person}.</returns>
Task<Person> GetPerson(string name, bool allowSlowProviders = false);
/// <summary>
/// Gets a Studio
/// </summary>
/// <param name="name">The name.</param>
/// <param name="allowSlowProviders">if set to <c>true</c> [allow slow providers].</param>
/// <returns>Task{Studio}.</returns>
Task<Studio> GetStudio(string name, bool allowSlowProviders = false);
/// <summary>
/// Gets a Genre
/// </summary>
/// <param name="name">The name.</param>
/// <param name="allowSlowProviders">if set to <c>true</c> [allow slow providers].</param>
/// <returns>Task{Genre}.</returns>
Task<Genre> GetGenre(string name, bool allowSlowProviders = false);
/// <summary>
/// Gets a Year
/// </summary>
/// <param name="value">The value.</param>
/// <param name="allowSlowProviders">if set to <c>true</c> [allow slow providers].</param>
/// <returns>Task{Year}.</returns>
/// <exception cref="System.ArgumentOutOfRangeException"></exception>
Task<Year> GetYear(int value, bool allowSlowProviders = false);
/// <summary>
/// Validate and refresh the People sub-set of the IBN.
/// The items are stored in the db but not loaded into memory until actually requested by an operation.
/// </summary>
/// <param name="cancellationToken">The cancellation token.</param>
/// <param name="progress">The progress.</param>
/// <returns>Task.</returns>
Task ValidatePeople(CancellationToken cancellationToken, IProgress<double> progress);
/// <summary>
/// Reloads the root media folder
/// </summary>
/// <param name="progress">The progress.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>Task.</returns>
Task ValidateMediaLibrary(IProgress<double> progress, CancellationToken cancellationToken);
/// <summary>
/// Saves display preferences for a Folder
/// </summary>
/// <param name="user">The user.</param>
/// <param name="folder">The folder.</param>
/// <param name="data">The data.</param>
/// <returns>Task.</returns>
Task SaveDisplayPreferencesForFolder(User user, Folder folder, DisplayPreferences data);
/// <summary>
/// Gets the default view.
/// </summary>
/// <returns>IEnumerable{VirtualFolderInfo}.</returns>
IEnumerable<VirtualFolderInfo> GetDefaultVirtualFolders();
/// <summary>
/// Gets the view.
/// </summary>
/// <param name="user">The user.</param>
/// <returns>IEnumerable{VirtualFolderInfo}.</returns>
IEnumerable<VirtualFolderInfo> GetVirtualFolders(User user);
/// <summary>
/// Gets the item by id.
/// </summary>
/// <param name="id">The id.</param>
/// <returns>BaseItem.</returns>
BaseItem GetItemById(Guid id);
/// <summary>
/// Gets the item by id.
/// </summary>
/// <param name="id">The id.</param>
/// <param name="userId">The user id.</param>
/// <returns>BaseItem.</returns>
BaseItem GetItemById(Guid id, Guid userId);
}
}

562
MediaBrowser.Controller/Library/LibraryManager.cs
View File

@@ -1,562 +0,0 @@
using MediaBrowser.Common.Events;
using MediaBrowser.Common.Extensions;
using MediaBrowser.Common.ScheduledTasks;
using MediaBrowser.Controller.Entities;
using MediaBrowser.Controller.IO;
using MediaBrowser.Controller.Resolvers;
using MediaBrowser.Controller.ScheduledTasks;
using MediaBrowser.Model.Entities;
using MediaBrowser.Model.Logging;
using MoreLinq;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
namespace MediaBrowser.Controller.Library
{
/// <summary>
/// Class LibraryManager
/// </summary>
public class LibraryManager
{
#region LibraryChanged Event
/// <summary>
/// Fires whenever any validation routine adds or removes items. The added and removed items are properties of the args.
/// *** Will fire asynchronously. ***
/// </summary>
public event EventHandler<ChildrenChangedEventArgs> LibraryChanged;
/// <summary>
/// Raises the <see cref="E:LibraryChanged" /> event.
/// </summary>
/// <param name="args">The <see cref="ChildrenChangedEventArgs" /> instance containing the event data.</param>
internal void OnLibraryChanged(ChildrenChangedEventArgs args)
{
EventHelper.QueueEventIfNotNull(LibraryChanged, this, args, _logger);
// Had to put this in a separate method to avoid an implicitly captured closure
SendLibraryChangedWebSocketMessage(args);
}
/// <summary>
/// Sends the library changed web socket message.
/// </summary>
/// <param name="args">The <see cref="ChildrenChangedEventArgs" /> instance containing the event data.</param>
private void SendLibraryChangedWebSocketMessage(ChildrenChangedEventArgs args)
{
// Notify connected ui's
Kernel.ServerManager.SendWebSocketMessage("LibraryChanged", () => DtoBuilder.GetLibraryUpdateInfo(args));
}
#endregion
/// <summary>
/// The _logger
/// </summary>
private readonly ILogger _logger;
/// <summary>
/// The _task manager
/// </summary>
private readonly ITaskManager _taskManager;
private readonly IUserManager _userManager;
/// <summary>
/// Gets or sets the kernel.
/// </summary>
/// <value>The kernel.</value>
private Kernel Kernel { get; set; }
/// <summary>
/// Initializes a new instance of the <see cref="LibraryManager" /> class.
/// </summary>
/// <param name="kernel">The kernel.</param>
/// <param name="logger">The logger.</param>
/// <param name="taskManager">The task manager.</param>
public LibraryManager(Kernel kernel, ILogger logger, ITaskManager taskManager, IUserManager userManager)
{
Kernel = kernel;
_logger = logger;
_taskManager = taskManager;
_userManager = userManager;
kernel.ConfigurationUpdated += kernel_ConfigurationUpdated;
}
/// <summary>
/// Handles the ConfigurationUpdated event of the kernel control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="EventArgs" /> instance containing the event data.</param>
void kernel_ConfigurationUpdated(object sender, EventArgs e)
{
//// Figure out whether or not we should refresh people after the update is finished
//var refreshPeopleAfterUpdate = !oldConfiguration.EnableInternetProviders && config.EnableInternetProviders;
//// This is true if internet providers has just been turned on, or if People have just been removed from InternetProviderExcludeTypes
//if (!refreshPeopleAfterUpdate)
//{
// var oldConfigurationFetchesPeopleImages = oldConfiguration.InternetProviderExcludeTypes == null || !oldConfiguration.InternetProviderExcludeTypes.Contains(typeof(Person).Name, StringComparer.OrdinalIgnoreCase);
// var newConfigurationFetchesPeopleImages = config.InternetProviderExcludeTypes == null || !config.InternetProviderExcludeTypes.Contains(typeof(Person).Name, StringComparer.OrdinalIgnoreCase);
// refreshPeopleAfterUpdate = newConfigurationFetchesPeopleImages && !oldConfigurationFetchesPeopleImages;
//}
Task.Run(() =>
{
// Any number of configuration settings could change the way the library is refreshed, so do that now
_taskManager.CancelIfRunningAndQueue<RefreshMediaLibraryTask>();
_taskManager.CancelIfRunningAndQueue<PeopleValidationTask>();
});
}
/// <summary>
/// Resolves the item.
/// </summary>
/// <param name="args">The args.</param>
/// <returns>BaseItem.</returns>
public BaseItem ResolveItem(ItemResolveArgs args)
{
return Kernel.EntityResolvers.Select(r => r.ResolvePath(args)).FirstOrDefault(i => i != null);
}
/// <summary>
/// Resolves a path into a BaseItem
/// </summary>
/// <param name="path">The path.</param>
/// <param name="parent">The parent.</param>
/// <param name="fileInfo">The file info.</param>
/// <returns>BaseItem.</returns>
/// <exception cref="System.ArgumentNullException"></exception>
public BaseItem GetItem(string path, Folder parent = null, WIN32_FIND_DATA? fileInfo = null)
{
if (string.IsNullOrEmpty(path))
{
throw new ArgumentNullException();
}
fileInfo = fileInfo ?? FileSystem.GetFileData(path);
if (!fileInfo.HasValue)
{
return null;
}
var args = new ItemResolveArgs
{
Parent = parent,
Path = path,
FileInfo = fileInfo.Value
};
// Return null if ignore rules deem that we should do so
if (Kernel.EntityResolutionIgnoreRules.Any(r => r.ShouldIgnore(args)))
{
return null;
}
// Gather child folder and files
if (args.IsDirectory)
{
// When resolving the root, we need it's grandchildren (children of user views)
var flattenFolderDepth = args.IsPhysicalRoot ? 2 : 0;
args.FileSystemDictionary = FileData.GetFilteredFileSystemEntries(args.Path, _logger, flattenFolderDepth: flattenFolderDepth, args: args);
}
// Check to see if we should resolve based on our contents
if (args.IsDirectory && !EntityResolutionHelper.ShouldResolvePathContents(args))
{
return null;
}
return ResolveItem(args);
}
/// <summary>
/// Resolves a set of files into a list of BaseItem
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="files">The files.</param>
/// <param name="parent">The parent.</param>
/// <returns>List{``0}.</returns>
public List<T> GetItems<T>(IEnumerable<WIN32_FIND_DATA> files, Folder parent)
where T : BaseItem
{
var list = new List<T>();
Parallel.ForEach(files, f =>
{
try
{
var item = GetItem(f.Path, parent, f) as T;
if (item != null)
{
lock (list)
{
list.Add(item);
}
}
}
catch (Exception ex)
{
_logger.ErrorException("Error resolving path {0}", ex, f.Path);
}
});
return list;
}
/// <summary>
/// Creates the root media folder
/// </summary>
/// <returns>AggregateFolder.</returns>
/// <exception cref="System.InvalidOperationException">Cannot create the root folder until plugins have loaded</exception>
internal AggregateFolder CreateRootFolder()
{
if (Kernel.Plugins == null)
{
throw new InvalidOperationException("Cannot create the root folder until plugins have loaded");
}
var rootFolderPath = Kernel.ApplicationPaths.RootFolderPath;
var rootFolder = Kernel.ItemRepository.RetrieveItem(rootFolderPath.GetMBId(typeof(AggregateFolder))) as AggregateFolder ?? (AggregateFolder)GetItem(rootFolderPath);
// Add in the plug-in folders
foreach (var child in Kernel.PluginFolderCreators)
{
rootFolder.AddVirtualChild(child.GetFolder());
}
return rootFolder;
}
/// <summary>
/// Gets a Person
/// </summary>
/// <param name="name">The name.</param>
/// <param name="allowSlowProviders">if set to <c>true</c> [allow slow providers].</param>
/// <returns>Task{Person}.</returns>
public Task<Person> GetPerson(string name, bool allowSlowProviders = false)
{
return GetPerson(name, CancellationToken.None, allowSlowProviders);
}
/// <summary>
/// Gets a Person
/// </summary>
/// <param name="name">The name.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <param name="allowSlowProviders">if set to <c>true</c> [allow slow providers].</param>
/// <returns>Task{Person}.</returns>
private Task<Person> GetPerson(string name, CancellationToken cancellationToken, bool allowSlowProviders = false)
{
return GetImagesByNameItem<Person>(Kernel.ApplicationPaths.PeoplePath, name, cancellationToken, allowSlowProviders);
}
/// <summary>
/// Gets a Studio
/// </summary>
/// <param name="name">The name.</param>
/// <param name="allowSlowProviders">if set to <c>true</c> [allow slow providers].</param>
/// <returns>Task{Studio}.</returns>
public Task<Studio> GetStudio(string name, bool allowSlowProviders = false)
{
return GetImagesByNameItem<Studio>(Kernel.ApplicationPaths.StudioPath, name, CancellationToken.None, allowSlowProviders);
}
/// <summary>
/// Gets a Genre
/// </summary>
/// <param name="name">The name.</param>
/// <param name="allowSlowProviders">if set to <c>true</c> [allow slow providers].</param>
/// <returns>Task{Genre}.</returns>
public Task<Genre> GetGenre(string name, bool allowSlowProviders = false)
{
return GetImagesByNameItem<Genre>(Kernel.ApplicationPaths.GenrePath, name, CancellationToken.None, allowSlowProviders);
}
/// <summary>
/// The us culture
/// </summary>
private static readonly CultureInfo UsCulture = new CultureInfo("en-US");
/// <summary>
/// Gets a Year
/// </summary>
/// <param name="value">The value.</param>
/// <param name="allowSlowProviders">if set to <c>true</c> [allow slow providers].</param>
/// <returns>Task{Year}.</returns>
/// <exception cref="System.ArgumentOutOfRangeException"></exception>
public Task<Year> GetYear(int value, bool allowSlowProviders = false)
{
if (value <= 0)
{
throw new ArgumentOutOfRangeException();
}
return GetImagesByNameItem<Year>(Kernel.ApplicationPaths.YearPath, value.ToString(UsCulture), CancellationToken.None, allowSlowProviders);
}
/// <summary>
/// The images by name item cache
/// </summary>
private readonly ConcurrentDictionary<string, object> ImagesByNameItemCache = new ConcurrentDictionary<string, object>(StringComparer.OrdinalIgnoreCase);
/// <summary>
/// Generically retrieves an IBN item
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="path">The path.</param>
/// <param name="name">The name.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <param name="allowSlowProviders">if set to <c>true</c> [allow slow providers].</param>
/// <returns>Task{``0}.</returns>
/// <exception cref="System.ArgumentNullException"></exception>
private Task<T> GetImagesByNameItem<T>(string path, string name, CancellationToken cancellationToken, bool allowSlowProviders = true)
where T : BaseItem, new()
{
if (string.IsNullOrEmpty(path))
{
throw new ArgumentNullException();
}
if (string.IsNullOrEmpty(name))
{
throw new ArgumentNullException();
}
var key = Path.Combine(path, FileSystem.GetValidFilename(name));
var obj = ImagesByNameItemCache.GetOrAdd(key, keyname => CreateImagesByNameItem<T>(path, name, cancellationToken, allowSlowProviders));
return obj as Task<T>;
}
/// <summary>
/// Creates an IBN item based on a given path
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="path">The path.</param>
/// <param name="name">The name.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <param name="allowSlowProviders">if set to <c>true</c> [allow slow providers].</param>
/// <returns>Task{``0}.</returns>
/// <exception cref="System.IO.IOException">Path not created: + path</exception>
private async Task<T> CreateImagesByNameItem<T>(string path, string name, CancellationToken cancellationToken, bool allowSlowProviders = true)
where T : BaseItem, new()
{
cancellationToken.ThrowIfCancellationRequested();
_logger.Debug("Creating {0}: {1}", typeof(T).Name, name);
path = Path.Combine(path, FileSystem.GetValidFilename(name));
var fileInfo = FileSystem.GetFileData(path);
var isNew = false;
if (!fileInfo.HasValue)
{
Directory.CreateDirectory(path);
fileInfo = FileSystem.GetFileData(path);
if (!fileInfo.HasValue)
{
throw new IOException("Path not created: " + path);
}
isNew = true;
}
cancellationToken.ThrowIfCancellationRequested();
var id = path.GetMBId(typeof(T));
var item = Kernel.ItemRepository.RetrieveItem(id) as T;
if (item == null)
{
item = new T
{
Name = name,
Id = id,
DateCreated = fileInfo.Value.CreationTimeUtc,
DateModified = fileInfo.Value.LastWriteTimeUtc,
Path = path
};
isNew = true;
}
cancellationToken.ThrowIfCancellationRequested();
// Set this now so we don't cause additional file system access during provider executions
item.ResetResolveArgs(fileInfo);
await item.RefreshMetadata(cancellationToken, isNew, allowSlowProviders: allowSlowProviders).ConfigureAwait(false);
cancellationToken.ThrowIfCancellationRequested();
return item;
}
/// <summary>
/// Validate and refresh the People sub-set of the IBN.
/// The items are stored in the db but not loaded into memory until actually requested by an operation.
/// </summary>
/// <param name="cancellationToken">The cancellation token.</param>
/// <param name="progress">The progress.</param>
/// <returns>Task.</returns>
internal async Task ValidatePeople(CancellationToken cancellationToken, IProgress<double> progress)
{
// Clear the IBN cache
ImagesByNameItemCache.Clear();
const int maxTasks = 250;
var tasks = new List<Task>();
var includedPersonTypes = new[] { PersonType.Actor, PersonType.Director };
var people = Kernel.RootFolder.RecursiveChildren
.Where(c => c.People != null)
.SelectMany(c => c.People.Where(p => includedPersonTypes.Contains(p.Type)))
.DistinctBy(p => p.Name, StringComparer.OrdinalIgnoreCase)
.ToList();
var numComplete = 0;
foreach (var person in people)
{
if (tasks.Count > maxTasks)
{
await Task.WhenAll(tasks).ConfigureAwait(false);
tasks.Clear();
// Safe cancellation point, when there are no pending tasks
cancellationToken.ThrowIfCancellationRequested();
}
// Avoid accessing the foreach variable within the closure
var currentPerson = person;
tasks.Add(Task.Run(async () =>
{
cancellationToken.ThrowIfCancellationRequested();
try
{
await GetPerson(currentPerson.Name, cancellationToken, allowSlowProviders: true).ConfigureAwait(false);
}
catch (IOException ex)
{
_logger.ErrorException("Error validating IBN entry {0}", ex, currentPerson.Name);
}
// Update progress
lock (progress)
{
numComplete++;
double percent = numComplete;
percent /= people.Count;
progress.Report(100 * percent);
}
}));
}
await Task.WhenAll(tasks).ConfigureAwait(false);
progress.Report(100);
_logger.Info("People validation complete");
}
/// <summary>
/// Reloads the root media folder
/// </summary>
/// <param name="progress">The progress.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>Task.</returns>
internal async Task ValidateMediaLibrary(IProgress<double> progress, CancellationToken cancellationToken)
{
_logger.Info("Validating media library");
await Kernel.RootFolder.RefreshMetadata(cancellationToken).ConfigureAwait(false);
// Start by just validating the children of the root, but go no further
await Kernel.RootFolder.ValidateChildren(new Progress<double> { }, cancellationToken, recursive: false);
// Validate only the collection folders for each user, just to make them available as quickly as possible
var userCollectionFolderTasks = _userManager.Users.AsParallel().Select(user => user.ValidateCollectionFolders(new Progress<double> { }, cancellationToken));
await Task.WhenAll(userCollectionFolderTasks).ConfigureAwait(false);
// Now validate the entire media library
await Kernel.RootFolder.ValidateChildren(progress, cancellationToken, recursive: true).ConfigureAwait(false);
foreach (var user in _userManager.Users)
{
await user.ValidateMediaLibrary(new Progress<double> { }, cancellationToken).ConfigureAwait(false);
}
}
/// <summary>
/// Saves display preferences for a Folder
/// </summary>
/// <param name="user">The user.</param>
/// <param name="folder">The folder.</param>
/// <param name="data">The data.</param>
/// <returns>Task.</returns>
public Task SaveDisplayPreferencesForFolder(User user, Folder folder, DisplayPreferences data)
{
// Need to update all items with the same DisplayPrefsId
foreach (var child in Kernel.RootFolder.GetRecursiveChildren(user)
.OfType<Folder>()
.Where(i => i.DisplayPrefsId == folder.DisplayPrefsId))
{
child.AddOrUpdateDisplayPrefs(user, data);
}
return Kernel.DisplayPreferencesRepository.SaveDisplayPrefs(folder, CancellationToken.None);
}
/// <summary>
/// Gets the default view.
/// </summary>
/// <returns>IEnumerable{VirtualFolderInfo}.</returns>
public IEnumerable<VirtualFolderInfo> GetDefaultVirtualFolders()
{
return GetView(Kernel.ApplicationPaths.DefaultUserViewsPath);
}
/// <summary>
/// Gets the view.
/// </summary>
/// <param name="user">The user.</param>
/// <returns>IEnumerable{VirtualFolderInfo}.</returns>
public IEnumerable<VirtualFolderInfo> GetVirtualFolders(User user)
{
return GetView(user.RootFolderPath);
}
/// <summary>
/// Gets the view.
/// </summary>
/// <param name="path">The path.</param>
/// <returns>IEnumerable{VirtualFolderInfo}.</returns>
private IEnumerable<VirtualFolderInfo> GetView(string path)
{
return Directory.EnumerateDirectories(path, "*", SearchOption.TopDirectoryOnly)
.Select(dir => new VirtualFolderInfo
{
Name = Path.GetFileName(dir),
Locations = Directory.EnumerateFiles(dir, "*.lnk", SearchOption.TopDirectoryOnly).Select(FileSystem.ResolveShortcut).ToList()
});
}
}
}

2
MediaBrowser.Controller/MediaBrowser.Controller.csproj
View File

@@ -113,6 +113,7 @@
<Compile Include="IServerApplicationPaths.cs" />
<Compile Include="Library\ChildrenChangedEventArgs.cs" />
<Compile Include="Library\DtoBuilder.cs" />
<Compile Include="Library\ILibraryManager.cs" />
<Compile Include="Library\IUserManager.cs" />
<Compile Include="Library\Profiler.cs" />
<Compile Include="Localization\AURatingsDictionary.cs" />
@@ -181,7 +182,6 @@
<Compile Include="Library\ItemResolveArgs.cs" />
<Compile Include="IO\DirectoryWatchers.cs" />
<Compile Include="IO\FileData.cs" />
<Compile Include="Library\LibraryManager.cs" />
<Compile Include="Kernel.cs" />
<Compile Include="Properties\AssemblyInfo.cs" />
<Compile Include="Providers\BaseMetadataProvider.cs" />

14
MediaBrowser.Controller/ScheduledTasks/PeopleValidationTask.cs
View File

@@ -1,4 +1,5 @@
using MediaBrowser.Common.ScheduledTasks;
using MediaBrowser.Controller.Library;
using System;
using System.Collections.Generic;
using System.Threading;
@@ -11,15 +12,18 @@ namespace MediaBrowser.Controller.ScheduledTasks
/// </summary>
public class PeopleValidationTask : IScheduledTask
{
private readonly Kernel _kernel;
/// <summary>
/// The _library manager
/// </summary>
private readonly ILibraryManager _libraryManager;
/// <summary>
/// Initializes a new instance of the <see cref="PeopleValidationTask" /> class.
/// </summary>
/// <param name="kernel">The kernel.</param>
public PeopleValidationTask(Kernel kernel)
/// <param name="libraryManager">The library manager.</param>
public PeopleValidationTask(ILibraryManager libraryManager)
{
_kernel = kernel;
_libraryManager = libraryManager;
}
/// <summary>
@@ -44,7 +48,7 @@ namespace MediaBrowser.Controller.ScheduledTasks
/// <returns>Task.</returns>
public Task Execute(CancellationToken cancellationToken, IProgress<double> progress)
{
return _kernel.LibraryManager.ValidatePeople(cancellationToken, progress);
return _libraryManager.ValidatePeople(cancellationToken, progress);
}
/// <summary>

13
MediaBrowser.Controller/ScheduledTasks/RefreshMediaLibraryTask.cs
View File

@@ -1,4 +1,5 @@
using MediaBrowser.Common.ScheduledTasks;
using MediaBrowser.Controller.Library;
using MediaBrowser.Model.Tasks;
using System;
using System.Collections.Generic;
@@ -13,17 +14,17 @@ namespace MediaBrowser.Controller.ScheduledTasks
public class RefreshMediaLibraryTask : IScheduledTask
{
/// <summary>
/// The _kernel
/// The _library manager
/// </summary>
private readonly Kernel _kernel;
private readonly ILibraryManager _libraryManager;
/// <summary>
/// Initializes a new instance of the <see cref="RefreshMediaLibraryTask" /> class.
/// </summary>
/// <param name="kernel">The kernel.</param>
public RefreshMediaLibraryTask(Kernel kernel)
/// <param name="libraryManager">The library manager.</param>
public RefreshMediaLibraryTask(ILibraryManager libraryManager)
{
_kernel = kernel;
_libraryManager = libraryManager;
}
/// <summary>
@@ -54,7 +55,7 @@ namespace MediaBrowser.Controller.ScheduledTasks
progress.Report(0);
return _kernel.LibraryManager.ValidateMediaLibrary(progress, cancellationToken);
return _libraryManager.ValidateMediaLibrary(progress, cancellationToken);
}
/// <summary>