jellyfin/MediaBrowser.Providers/Manager/ProviderManager.cs

1116 lines
41 KiB
C#
Raw Normal View History

2016-03-27 21:11:27 +00:00
using MediaBrowser.Common.Net;
2015-01-24 04:50:45 +00:00
using MediaBrowser.Controller;
2013-03-04 05:43:06 +00:00
using MediaBrowser.Controller.Configuration;
2013-02-21 01:33:05 +00:00
using MediaBrowser.Controller.Entities;
2014-02-02 13:36:31 +00:00
using MediaBrowser.Controller.Entities.Audio;
using MediaBrowser.Controller.Entities.Movies;
using MediaBrowser.Controller.Entities.TV;
using MediaBrowser.Controller.Library;
using MediaBrowser.Controller.LiveTv;
using MediaBrowser.Controller.Providers;
2014-02-02 13:36:31 +00:00
using MediaBrowser.Model.Configuration;
using MediaBrowser.Model.Entities;
2013-02-21 21:39:53 +00:00
using MediaBrowser.Model.Logging;
using MediaBrowser.Model.Providers;
2013-02-21 01:33:05 +00:00
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
2017-06-23 16:04:45 +00:00
using MediaBrowser.Common.Progress;
2016-10-25 19:02:04 +00:00
using MediaBrowser.Model.IO;
2017-05-21 07:25:49 +00:00
using MediaBrowser.Controller.Dto;
2017-06-23 16:04:45 +00:00
using MediaBrowser.Model.Events;
2016-04-25 00:36:10 +00:00
using MediaBrowser.Model.Serialization;
2017-04-30 02:37:51 +00:00
using Priority_Queue;
2017-08-19 19:43:35 +00:00
using MediaBrowser.Model.Extensions;
2013-02-21 01:33:05 +00:00
namespace MediaBrowser.Providers.Manager
2013-02-21 01:33:05 +00:00
{
/// <summary>
/// Class ProviderManager
/// </summary>
2015-03-14 04:50:23 +00:00
public class ProviderManager : IProviderManager, IDisposable
2013-02-21 01:33:05 +00:00
{
2013-02-21 21:39:53 +00:00
/// <summary>
/// The _logger
/// </summary>
private readonly ILogger _logger;
2013-02-25 00:13:45 +00:00
/// <summary>
/// The _HTTP client
/// </summary>
private readonly IHttpClient _httpClient;
/// <summary>
/// The _directory watchers
/// </summary>
private readonly ILibraryMonitor _libraryMonitor;
/// <summary>
/// Gets or sets the configuration manager.
/// </summary>
/// <value>The configuration manager.</value>
2013-03-04 05:43:06 +00:00
private IServerConfigurationManager ConfigurationManager { get; set; }
2013-03-07 05:34:00 +00:00
2013-10-30 21:33:27 +00:00
private IImageProvider[] ImageProviders { get; set; }
private readonly IFileSystem _fileSystem;
2013-10-30 21:33:27 +00:00
private IMetadataService[] _metadataServices = { };
2014-01-31 19:55:21 +00:00
private IMetadataProvider[] _metadataProviders = { };
2014-02-02 13:36:31 +00:00
private IEnumerable<IMetadataSaver> _savers;
2015-01-24 04:50:45 +00:00
private readonly IServerApplicationPaths _appPaths;
2016-04-25 00:36:10 +00:00
private readonly IJsonSerializer _json;
2014-02-21 18:48:15 +00:00
private IExternalId[] _externalIds;
2015-03-14 04:50:23 +00:00
private readonly Func<ILibraryManager> _libraryManagerFactory;
2016-11-08 18:44:23 +00:00
private readonly IMemoryStreamFactory _memoryStreamProvider;
2017-06-06 06:13:49 +00:00
private CancellationTokenSource _disposeCancellationTokenSource = new CancellationTokenSource();
2015-03-14 04:50:23 +00:00
2017-06-23 16:04:45 +00:00
public event EventHandler<GenericEventArgs<BaseItem>> RefreshStarted;
public event EventHandler<GenericEventArgs<BaseItem>> RefreshCompleted;
public event EventHandler<GenericEventArgs<Tuple<BaseItem, double>>> RefreshProgress;
2013-02-21 01:33:05 +00:00
/// <summary>
/// Initializes a new instance of the <see cref="ProviderManager" /> class.
/// </summary>
2013-02-25 00:13:45 +00:00
/// <param name="httpClient">The HTTP client.</param>
/// <param name="configurationManager">The configuration manager.</param>
/// <param name="libraryMonitor">The directory watchers.</param>
/// <param name="logManager">The log manager.</param>
/// <param name="fileSystem">The file system.</param>
2016-11-08 18:44:23 +00:00
public ProviderManager(IHttpClient httpClient, IServerConfigurationManager configurationManager, ILibraryMonitor libraryMonitor, ILogManager logManager, IFileSystem fileSystem, IServerApplicationPaths appPaths, Func<ILibraryManager> libraryManagerFactory, IJsonSerializer json, IMemoryStreamFactory memoryStreamProvider)
2013-02-21 01:33:05 +00:00
{
_logger = logManager.GetLogger("ProviderManager");
2013-02-25 00:13:45 +00:00
_httpClient = httpClient;
2013-03-04 05:43:06 +00:00
ConfigurationManager = configurationManager;
_libraryMonitor = libraryMonitor;
_fileSystem = fileSystem;
2015-01-24 04:50:45 +00:00
_appPaths = appPaths;
2015-03-14 04:50:23 +00:00
_libraryManagerFactory = libraryManagerFactory;
2016-04-25 00:36:10 +00:00
_json = json;
2016-10-06 18:55:01 +00:00
_memoryStreamProvider = memoryStreamProvider;
2013-02-21 01:33:05 +00:00
}
/// <summary>
/// Adds the metadata providers.
2013-02-21 01:33:05 +00:00
/// </summary>
public void AddParts(IEnumerable<IImageProvider> imageProviders, IEnumerable<IMetadataService> metadataServices,
IEnumerable<IMetadataProvider> metadataProviders, IEnumerable<IMetadataSaver> metadataSavers,
2016-10-07 15:08:13 +00:00
IEnumerable<IExternalId> externalIds)
2013-02-21 01:33:05 +00:00
{
2014-01-31 19:55:21 +00:00
ImageProviders = imageProviders.ToArray();
_metadataServices = metadataServices.OrderBy(i => i.Order).ToArray();
2014-01-31 19:55:21 +00:00
_metadataProviders = metadataProviders.ToArray();
2014-02-21 18:48:15 +00:00
_externalIds = externalIds.OrderBy(i => i.Name).ToArray();
2015-08-02 19:08:55 +00:00
_savers = metadataSavers.Where(i =>
{
var configurable = i as IConfigurableProvider;
return configurable == null || configurable.IsEnabled;
}).ToArray();
}
2015-03-14 15:38:16 +00:00
public Task<ItemUpdateType> RefreshSingleItem(IHasMetadata item, MetadataRefreshOptions options, CancellationToken cancellationToken)
{
var service = _metadataServices.FirstOrDefault(i => i.CanRefresh(item));
if (service != null)
{
return service.RefreshMetadata(item, options, cancellationToken);
}
_logger.Error("Unable to find a metadata service for item of type " + item.GetType().Name);
return Task.FromResult(ItemUpdateType.None);
2013-02-21 01:33:05 +00:00
}
2017-08-07 21:06:13 +00:00
public async Task SaveImage(IHasMetadata item, string url, ImageType type, int? imageIndex, CancellationToken cancellationToken)
{
var response = await _httpClient.GetResponse(new HttpRequestOptions
{
CancellationToken = cancellationToken,
2016-10-31 18:39:41 +00:00
Url = url,
BufferContent = false
}).ConfigureAwait(false);
2014-02-03 17:44:13 +00:00
await SaveImage(item, response.Content, response.ContentType, type, imageIndex, cancellationToken)
.ConfigureAwait(false);
}
2017-08-07 21:06:13 +00:00
public Task SaveImage(IHasMetadata item, Stream source, string mimeType, ImageType type, int? imageIndex, CancellationToken cancellationToken)
{
2016-10-06 18:55:01 +00:00
return new ImageSaver(ConfigurationManager, _libraryMonitor, _fileSystem, _logger, _memoryStreamProvider).SaveImage(item, source, mimeType, type, imageIndex, cancellationToken);
}
2013-10-30 21:33:27 +00:00
2017-08-07 21:06:13 +00:00
public Task SaveImage(IHasMetadata item, string source, string mimeType, ImageType type, int? imageIndex, bool? saveLocallyWithMedia, CancellationToken cancellationToken)
2015-04-08 15:45:30 +00:00
{
2015-06-21 21:31:21 +00:00
if (string.IsNullOrWhiteSpace(source))
{
throw new ArgumentNullException("source");
}
2016-10-25 19:02:04 +00:00
var fileStream = _fileSystem.GetFileStream(source, FileOpenMode.Open, FileAccessMode.Read, FileShareMode.ReadWrite, true);
2015-04-08 15:45:30 +00:00
2016-10-17 16:35:29 +00:00
return new ImageSaver(ConfigurationManager, _libraryMonitor, _fileSystem, _logger, _memoryStreamProvider).SaveImage(item, fileStream, mimeType, type, imageIndex, saveLocallyWithMedia, cancellationToken);
2015-04-08 15:45:30 +00:00
}
2017-08-07 21:06:13 +00:00
public async Task<IEnumerable<RemoteImageInfo>> GetAvailableRemoteImages(IHasMetadata item, RemoteImageQuery query, CancellationToken cancellationToken)
2013-10-30 21:33:27 +00:00
{
2014-02-12 03:46:27 +00:00
var providers = GetRemoteImageProviders(item, query.IncludeDisabledProviders);
2014-02-12 03:46:27 +00:00
if (!string.IsNullOrEmpty(query.ProviderName))
{
2014-02-12 03:46:27 +00:00
var providerName = query.ProviderName;
providers = providers.Where(i => string.Equals(i.Name, providerName, StringComparison.OrdinalIgnoreCase));
}
var preferredLanguage = item.GetPreferredMetadataLanguage();
2013-10-30 21:33:27 +00:00
2014-06-24 04:18:02 +00:00
var languages = new List<string>();
if (!query.IncludeAllLanguages && !string.IsNullOrWhiteSpace(preferredLanguage))
{
languages.Add(preferredLanguage);
}
2014-02-12 03:46:27 +00:00
2014-06-24 04:18:02 +00:00
var tasks = providers.Select(i => GetImages(item, cancellationToken, i, languages, query.ImageType));
2013-12-30 02:41:22 +00:00
var results = await Task.WhenAll(tasks).ConfigureAwait(false);
return results.SelectMany(i => i.ToList());
2013-12-30 02:41:22 +00:00
}
/// <summary>
/// Gets the images.
/// </summary>
/// <param name="item">The item.</param>
/// <param name="cancellationToken">The cancellation token.</param>
2014-02-13 05:11:54 +00:00
/// <param name="provider">The provider.</param>
2014-06-24 04:18:02 +00:00
/// <param name="preferredLanguages">The preferred languages.</param>
2013-12-30 02:41:22 +00:00
/// <param name="type">The type.</param>
/// <returns>Task{IEnumerable{RemoteImageInfo}}.</returns>
2017-08-07 21:06:13 +00:00
private async Task<IEnumerable<RemoteImageInfo>> GetImages(IHasMetadata item, CancellationToken cancellationToken, IRemoteImageProvider provider, List<string> preferredLanguages, ImageType? type = null)
2013-12-30 02:41:22 +00:00
{
try
2013-10-30 21:33:27 +00:00
{
2014-02-13 05:11:54 +00:00
var result = await provider.GetImages(item, cancellationToken).ConfigureAwait(false);
2013-12-30 02:41:22 +00:00
if (type.HasValue)
2013-10-30 21:33:27 +00:00
{
2014-02-13 05:11:54 +00:00
result = result.Where(i => i.Type == type.Value);
2013-10-30 21:33:27 +00:00
}
2014-02-12 03:46:27 +00:00
2014-06-24 04:18:02 +00:00
if (preferredLanguages.Count > 0)
2014-02-19 05:21:03 +00:00
{
result = result.Where(i => string.IsNullOrEmpty(i.Language) ||
preferredLanguages.Contains(i.Language, StringComparer.OrdinalIgnoreCase) ||
string.Equals(i.Language, "en", StringComparison.OrdinalIgnoreCase));
2014-02-19 05:21:03 +00:00
}
return result;
2013-12-30 02:41:22 +00:00
}
2014-02-26 04:38:21 +00:00
catch (OperationCanceledException)
{
return new List<RemoteImageInfo>();
}
2013-12-30 02:41:22 +00:00
catch (Exception ex)
{
2014-02-13 05:11:54 +00:00
_logger.ErrorException("{0} failed in GetImageInfos for type {1}", ex, provider.GetType().Name, item.GetType().Name);
2013-12-30 02:41:22 +00:00
return new List<RemoteImageInfo>();
}
2013-10-30 21:33:27 +00:00
}
2014-01-31 19:55:21 +00:00
/// <summary>
/// Gets the supported image providers.
/// </summary>
/// <param name="item">The item.</param>
/// <returns>IEnumerable{IImageProvider}.</returns>
2017-08-07 21:06:13 +00:00
public IEnumerable<ImageProviderInfo> GetRemoteImageProviderInfo(IHasMetadata item)
2014-01-31 19:55:21 +00:00
{
2014-02-11 04:55:01 +00:00
return GetRemoteImageProviders(item, true).Select(i => new ImageProviderInfo
2014-01-31 19:55:21 +00:00
{
2014-02-11 04:55:01 +00:00
Name = i.Name,
2017-08-19 19:43:35 +00:00
SupportedImages = i.GetSupportedImages(item).ToArray()
2014-01-31 19:55:21 +00:00
});
}
2017-08-07 21:06:13 +00:00
public IEnumerable<IImageProvider> GetImageProviders(IHasMetadata item, ImageRefreshOptions refreshOptions)
2013-10-30 21:33:27 +00:00
{
return GetImageProviders(item, GetMetadataOptions(item), refreshOptions, false);
2014-02-11 04:55:01 +00:00
}
2017-08-07 21:06:13 +00:00
private IEnumerable<IImageProvider> GetImageProviders(IHasMetadata item, MetadataOptions options, ImageRefreshOptions refreshOptions, bool includeDisabled)
2014-02-11 04:55:01 +00:00
{
2014-02-19 05:21:03 +00:00
// Avoid implicitly captured closure
var currentOptions = options;
2017-01-21 20:27:07 +00:00
return ImageProviders.Where(i => CanRefresh(i, item, options, refreshOptions, includeDisabled))
2014-02-11 04:55:01 +00:00
.OrderBy(i =>
2013-10-30 21:33:27 +00:00
{
2014-02-11 04:55:01 +00:00
// See if there's a user-defined order
if (!(i is ILocalImageProvider))
2013-10-30 21:33:27 +00:00
{
2014-02-19 05:21:03 +00:00
var index = Array.IndexOf(currentOptions.ImageFetcherOrder, i.Name);
2014-02-11 04:55:01 +00:00
if (index != -1)
{
return index;
}
2013-10-30 21:33:27 +00:00
}
2014-02-11 04:55:01 +00:00
// Not configured. Just return some high number to put it at the end.
return 100;
})
.ThenBy(GetOrder);
2014-01-31 19:55:21 +00:00
}
public IEnumerable<IMetadataProvider<T>> GetMetadataProviders<T>(IHasMetadata item)
where T : IHasMetadata
2014-02-02 13:36:31 +00:00
{
2014-02-10 18:39:41 +00:00
var options = GetMetadataOptions(item);
2016-11-17 18:18:19 +00:00
return GetMetadataProvidersInternal<T>(item, options, false, false, true);
2014-02-02 13:36:31 +00:00
}
2016-11-17 18:18:19 +00:00
private IEnumerable<IMetadataProvider<T>> GetMetadataProvidersInternal<T>(IHasMetadata item, MetadataOptions options, bool includeDisabled, bool forceEnableInternetMetadata, bool checkIsOwnedItem)
2014-02-02 13:36:31 +00:00
where T : IHasMetadata
2014-01-31 19:55:21 +00:00
{
2014-02-19 05:21:03 +00:00
// Avoid implicitly captured closure
var currentOptions = options;
2014-02-12 03:46:27 +00:00
2014-02-19 05:21:03 +00:00
return _metadataProviders.OfType<IMetadataProvider<T>>()
2016-11-17 18:18:19 +00:00
.Where(i => CanRefresh(i, item, currentOptions, includeDisabled, forceEnableInternetMetadata, checkIsOwnedItem))
2014-02-19 05:21:03 +00:00
.OrderBy(i => GetConfiguredOrder(i, options))
.ThenBy(GetDefaultOrder);
2014-01-31 19:55:21 +00:00
}
2017-08-07 21:06:13 +00:00
private IEnumerable<IRemoteImageProvider> GetRemoteImageProviders(IHasMetadata item, bool includeDisabled)
2014-01-31 19:55:21 +00:00
{
2014-02-11 04:55:01 +00:00
var options = GetMetadataOptions(item);
2017-01-21 20:27:07 +00:00
return GetImageProviders(item, options, new ImageRefreshOptions(new DirectoryService(_logger, _fileSystem)), includeDisabled).OfType<IRemoteImageProvider>();
}
2016-11-17 18:18:19 +00:00
private bool CanRefresh(IMetadataProvider provider, IHasMetadata item, MetadataOptions options, bool includeDisabled, bool forceEnableInternetMetadata, bool checkIsOwnedItem)
{
2014-02-11 04:55:01 +00:00
if (!includeDisabled)
{
2014-02-19 05:21:03 +00:00
// If locked only allow local providers
if (item.IsLocked && !(provider is ILocalMetadataProvider) && !(provider is IForcedProvider))
{
return false;
}
2014-02-11 04:55:01 +00:00
if (provider is IRemoteMetadataProvider)
{
2016-11-17 18:18:19 +00:00
if (!forceEnableInternetMetadata && !item.IsInternetMetadataEnabled())
2014-02-27 03:57:37 +00:00
{
return false;
}
2014-02-11 04:55:01 +00:00
if (Array.IndexOf(options.DisabledMetadataFetchers, provider.Name) != -1)
{
return false;
}
}
2014-01-31 19:55:21 +00:00
}
2014-02-10 20:11:46 +00:00
if (!item.SupportsLocalMetadata && provider is ILocalMetadataProvider)
2014-01-31 19:55:21 +00:00
{
return false;
}
// If this restriction is ever lifted, movie xml providers will have to be updated to prevent owned items like trailers from reading those files
2015-09-06 16:02:41 +00:00
if (checkIsOwnedItem && item.IsOwnedItem)
{
if (provider is ILocalMetadataProvider || provider is IRemoteMetadataProvider)
{
return false;
}
}
2014-01-31 19:55:21 +00:00
return true;
}
2017-08-07 21:06:13 +00:00
private bool CanRefresh(IImageProvider provider, IHasMetadata item, MetadataOptions options, ImageRefreshOptions refreshOptions, bool includeDisabled)
2014-02-11 04:55:01 +00:00
{
if (!includeDisabled)
{
2014-02-19 05:21:03 +00:00
// If locked only allow local providers
if (item.IsLocked && !(provider is ILocalImageProvider))
{
2017-01-21 20:27:07 +00:00
if (refreshOptions.ImageRefreshMode != ImageRefreshMode.FullRefresh)
{
return false;
}
2014-02-19 05:21:03 +00:00
}
2014-02-19 16:24:06 +00:00
if (provider is IRemoteImageProvider || provider is IDynamicImageProvider)
2014-02-11 04:55:01 +00:00
{
2014-08-19 01:42:53 +00:00
if (Array.IndexOf(options.DisabledImageFetchers, provider.Name) != -1)
2014-02-27 03:57:37 +00:00
{
return false;
}
2014-08-19 01:42:53 +00:00
if (provider is IRemoteImageProvider)
2014-02-11 04:55:01 +00:00
{
2016-11-17 18:18:19 +00:00
if (!refreshOptions.ForceEnableInternetMetadata && !item.IsInternetMetadataEnabled())
2014-08-19 01:42:53 +00:00
{
return false;
}
2014-02-11 04:55:01 +00:00
}
}
}
try
{
return provider.Supports(item);
}
catch (Exception ex)
{
_logger.ErrorException("{0} failed in Supports for type {1}", ex, provider.GetType().Name, item.GetType().Name);
return false;
}
}
2014-01-31 19:55:21 +00:00
/// <summary>
/// Gets the order.
/// </summary>
/// <param name="provider">The provider.</param>
/// <returns>System.Int32.</returns>
2014-02-10 18:39:41 +00:00
private int GetOrder(IImageProvider provider)
2014-01-31 19:55:21 +00:00
{
var hasOrder = provider as IHasOrder;
if (hasOrder == null)
{
return 0;
}
return hasOrder.Order;
}
2014-02-19 05:21:03 +00:00
private int GetConfiguredOrder(IMetadataProvider provider, MetadataOptions options)
{
// See if there's a user-defined order
if (provider is ILocalMetadataProvider)
{
var index = Array.IndexOf(options.LocalMetadataReaderOrder, provider.Name);
if (index != -1)
{
return index;
}
}
// See if there's a user-defined order
if (provider is IRemoteMetadataProvider)
{
var index = Array.IndexOf(options.MetadataFetcherOrder, provider.Name);
if (index != -1)
{
return index;
}
}
// Not configured. Just return some high number to put it at the end.
return 100;
}
2014-02-19 16:24:06 +00:00
2014-02-19 05:21:03 +00:00
private int GetDefaultOrder(IMetadataProvider provider)
2014-01-31 19:55:21 +00:00
{
var hasOrder = provider as IHasOrder;
2014-02-10 18:39:41 +00:00
if (hasOrder != null)
2014-01-31 19:55:21 +00:00
{
2014-02-10 18:39:41 +00:00
return hasOrder.Order;
2014-01-31 19:55:21 +00:00
}
2014-02-10 18:39:41 +00:00
return 0;
2013-10-30 21:33:27 +00:00
}
2014-02-02 13:36:31 +00:00
2017-08-19 19:43:35 +00:00
public MetadataPluginSummary[] GetAllMetadataPlugins()
2014-02-02 13:36:31 +00:00
{
2017-08-19 19:43:35 +00:00
return new MetadataPluginSummary[]
2014-02-07 20:30:41 +00:00
{
GetPluginSummary<Game>(),
GetPluginSummary<GameSystem>(),
GetPluginSummary<Movie>(),
GetPluginSummary<BoxSet>(),
GetPluginSummary<Book>(),
GetPluginSummary<Series>(),
GetPluginSummary<Season>(),
GetPluginSummary<Episode>(),
GetPluginSummary<Person>(),
GetPluginSummary<MusicAlbum>(),
GetPluginSummary<MusicArtist>(),
GetPluginSummary<Audio>(),
GetPluginSummary<Genre>(),
GetPluginSummary<Studio>(),
GetPluginSummary<GameGenre>(),
GetPluginSummary<MusicGenre>(),
GetPluginSummary<MusicVideo>(),
GetPluginSummary<Video>(),
GetPluginSummary<LiveTvChannel>(),
GetPluginSummary<LiveTvProgram>(),
GetPluginSummary<LiveTvVideoRecording>(),
GetPluginSummary<LiveTvAudioRecording>()
};
2014-02-02 13:36:31 +00:00
}
private MetadataPluginSummary GetPluginSummary<T>()
where T : BaseItem, new()
{
// Give it a dummy path just so that it looks like a file system item
var dummy = new T()
{
2015-09-06 16:02:41 +00:00
Path = Path.Combine(_appPaths.InternalMetadataPath, "dummy"),
ParentId = Guid.NewGuid()
2014-02-02 13:36:31 +00:00
};
2014-02-10 18:39:41 +00:00
var options = GetMetadataOptions(dummy);
2014-02-02 13:36:31 +00:00
var summary = new MetadataPluginSummary
{
ItemType = typeof(T).Name
};
2017-01-21 20:27:07 +00:00
var imageProviders = GetImageProviders(dummy, options, new ImageRefreshOptions(new DirectoryService(_logger, _fileSystem)), true).ToList();
2014-02-02 13:36:31 +00:00
2017-08-19 19:43:35 +00:00
var pluginList = summary.Plugins.ToList();
AddMetadataPlugins(pluginList, dummy, options);
AddImagePlugins(pluginList, dummy, imageProviders);
summary.Plugins = pluginList.ToArray(pluginList.Count);
2014-02-02 13:36:31 +00:00
2014-02-24 03:27:13 +00:00
var supportedImageTypes = imageProviders.OfType<IRemoteImageProvider>()
2014-02-02 13:36:31 +00:00
.SelectMany(i => i.GetSupportedImages(dummy))
.ToList();
2014-02-24 03:27:13 +00:00
supportedImageTypes.AddRange(imageProviders.OfType<IDynamicImageProvider>()
.SelectMany(i => i.GetSupportedImages(dummy)));
2017-08-19 19:43:35 +00:00
summary.SupportedImageTypes = supportedImageTypes.Distinct().ToArray();
2014-02-02 13:36:31 +00:00
return summary;
}
2014-02-10 18:39:41 +00:00
private void AddMetadataPlugins<T>(List<MetadataPlugin> list, T item, MetadataOptions options)
2014-02-02 13:36:31 +00:00
where T : IHasMetadata
{
2016-11-17 18:18:19 +00:00
var providers = GetMetadataProvidersInternal<T>(item, options, true, false, false).ToList();
2014-02-02 13:36:31 +00:00
// Locals
list.AddRange(providers.Where(i => (i is ILocalMetadataProvider)).Select(i => new MetadataPlugin
{
Name = i.Name,
Type = MetadataPluginType.LocalMetadataProvider
}));
// Fetchers
list.AddRange(providers.Where(i => (i is IRemoteMetadataProvider)).Select(i => new MetadataPlugin
2014-02-02 13:36:31 +00:00
{
Name = i.Name,
Type = MetadataPluginType.MetadataFetcher
}));
2014-03-02 15:42:21 +00:00
// Savers
list.AddRange(_savers.Where(i => IsSaverEnabledForItem(i, item, ItemUpdateType.MetadataEdit, true)).OrderBy(i => i.Name).Select(i => new MetadataPlugin
2014-02-02 13:36:31 +00:00
{
Name = i.Name,
Type = MetadataPluginType.MetadataSaver
}));
2014-02-02 13:36:31 +00:00
}
private void AddImagePlugins<T>(List<MetadataPlugin> list, T item, List<IImageProvider> imageProviders)
2017-08-07 21:06:13 +00:00
where T : IHasMetadata
2014-02-02 13:36:31 +00:00
{
// Locals
list.AddRange(imageProviders.Where(i => (i is ILocalImageProvider)).Select(i => new MetadataPlugin
{
Name = i.Name,
Type = MetadataPluginType.LocalImageProvider
}));
2015-03-14 20:00:32 +00:00
var enableInternet = item.IsInternetMetadataEnabled();
2014-02-27 03:57:37 +00:00
2014-02-02 13:36:31 +00:00
// Fetchers
2014-07-27 22:01:29 +00:00
list.AddRange(imageProviders.Where(i => i is IDynamicImageProvider || (enableInternet && i is IRemoteImageProvider)).Select(i => new MetadataPlugin
2014-02-02 13:36:31 +00:00
{
Name = i.Name,
Type = MetadataPluginType.ImageFetcher
}));
}
2017-08-07 21:06:13 +00:00
public MetadataOptions GetMetadataOptions(IHasMetadata item)
{
var type = item.GetType().Name;
2014-02-10 18:39:41 +00:00
return ConfigurationManager.Configuration.MetadataOptions
.FirstOrDefault(i => string.Equals(i.ItemType, type, StringComparison.OrdinalIgnoreCase)) ??
new MetadataOptions();
}
2014-02-10 18:39:41 +00:00
2017-05-26 06:48:54 +00:00
private Task _completedTask = Task.FromResult(true);
2014-02-02 13:36:31 +00:00
/// <summary>
/// Saves the metadata.
/// </summary>
/// <param name="item">The item.</param>
/// <param name="updateType">Type of the update.</param>
/// <returns>Task.</returns>
public Task SaveMetadata(IHasMetadata item, ItemUpdateType updateType)
2014-02-02 13:36:31 +00:00
{
2017-05-26 06:48:54 +00:00
SaveMetadata(item, updateType, _savers);
return _completedTask;
}
/// <summary>
/// Saves the metadata.
/// </summary>
/// <param name="item">The item.</param>
/// <param name="updateType">Type of the update.</param>
/// <param name="savers">The savers.</param>
/// <returns>Task.</returns>
public Task SaveMetadata(IHasMetadata item, ItemUpdateType updateType, IEnumerable<string> savers)
{
2017-05-26 06:48:54 +00:00
SaveMetadata(item, updateType, _savers.Where(i => savers.Contains(i.Name, StringComparer.OrdinalIgnoreCase)));
return _completedTask;
}
/// <summary>
/// Saves the metadata.
/// </summary>
/// <param name="item">The item.</param>
/// <param name="updateType">Type of the update.</param>
/// <param name="savers">The savers.</param>
/// <returns>Task.</returns>
2017-05-26 06:48:54 +00:00
private void SaveMetadata(IHasMetadata item, ItemUpdateType updateType, IEnumerable<IMetadataSaver> savers)
{
foreach (var saver in savers.Where(i => IsSaverEnabledForItem(i, item, updateType, false)))
2014-02-02 13:36:31 +00:00
{
_logger.Debug("Saving {0} to {1}.", item.Path ?? item.Name, saver.Name);
2014-02-10 18:39:41 +00:00
var fileSaver = saver as IMetadataFileSaver;
2014-02-02 13:36:31 +00:00
if (fileSaver != null)
{
2014-02-08 20:02:35 +00:00
string path = null;
try
{
2014-02-08 20:02:35 +00:00
path = fileSaver.GetSavePath(item);
}
catch (Exception ex)
{
_logger.ErrorException("Error in {0} GetSavePath", ex, saver.Name);
continue;
}
2014-02-02 13:36:31 +00:00
try
{
_libraryMonitor.ReportFileSystemChangeBeginning(path);
saver.Save(item, CancellationToken.None);
}
catch (Exception ex)
{
_logger.ErrorException("Error in metadata saver", ex);
}
finally
{
_libraryMonitor.ReportFileSystemChangeComplete(path, false);
}
2014-02-02 13:36:31 +00:00
}
else
2014-02-02 13:36:31 +00:00
{
try
{
saver.Save(item, CancellationToken.None);
}
catch (Exception ex)
{
_logger.ErrorException("Error in metadata saver", ex);
}
2014-02-02 13:36:31 +00:00
}
}
}
2014-02-08 20:02:35 +00:00
/// <summary>
/// Determines whether [is saver enabled for item] [the specified saver].
/// </summary>
/// <param name="saver">The saver.</param>
/// <param name="item">The item.</param>
/// <param name="updateType">Type of the update.</param>
/// <param name="includeDisabled">if set to <c>true</c> [include disabled].</param>
/// <returns><c>true</c> if [is saver enabled for item] [the specified saver]; otherwise, <c>false</c>.</returns>
2014-02-27 03:57:37 +00:00
private bool IsSaverEnabledForItem(IMetadataSaver saver, IHasMetadata item, ItemUpdateType updateType, bool includeDisabled)
2014-02-08 20:02:35 +00:00
{
var options = GetMetadataOptions(item);
2014-02-08 20:02:35 +00:00
try
{
2014-06-04 03:34:36 +00:00
var isEnabledFor = saver.IsEnabledFor(item, updateType);
2014-02-27 03:57:37 +00:00
if (!includeDisabled)
{
2014-04-08 04:17:18 +00:00
if (options.DisabledMetadataSavers.Contains(saver.Name, StringComparer.OrdinalIgnoreCase))
2014-02-27 03:57:37 +00:00
{
return false;
}
2014-06-04 03:34:36 +00:00
2014-04-08 04:17:18 +00:00
if (!item.IsSaveLocalMetadataEnabled())
2014-02-27 03:57:37 +00:00
{
2014-04-08 04:17:18 +00:00
if (updateType >= ItemUpdateType.MetadataEdit)
{
var fileSaver = saver as IMetadataFileSaver;
// Manual edit occurred
// Even if save local is off, save locally anyway if the metadata file already exists
if (fileSaver == null || !isEnabledFor || !_fileSystem.FileExists(fileSaver.GetSavePath(item)))
2014-04-08 04:17:18 +00:00
{
return false;
}
}
else
{
// Manual edit did not occur
// Since local metadata saving is disabled, consider it disabled
return false;
}
2014-02-27 03:57:37 +00:00
}
}
2014-06-04 03:34:36 +00:00
return isEnabledFor;
2014-02-08 20:02:35 +00:00
}
catch (Exception ex)
{
_logger.ErrorException("Error in {0}.IsEnabledFor", ex, saver.Name);
return false;
}
}
2014-02-19 05:21:03 +00:00
public async Task<IEnumerable<RemoteSearchResult>> GetRemoteSearchResults<TItemType, TLookupType>(RemoteSearchQuery<TLookupType> searchInfo,
2014-02-19 16:24:06 +00:00
CancellationToken cancellationToken)
where TItemType : BaseItem, new()
where TLookupType : ItemLookupInfo
{
// Give it a dummy path just so that it looks like a file system item
var dummy = new TItemType
{
2015-09-06 16:02:41 +00:00
Path = Path.Combine(_appPaths.InternalMetadataPath, "dummy"),
ParentId = Guid.NewGuid()
2014-02-19 16:24:06 +00:00
};
2015-07-09 05:52:25 +00:00
dummy.SetParent(new Folder());
2014-02-19 16:24:06 +00:00
var options = GetMetadataOptions(dummy);
2016-11-17 18:18:19 +00:00
var providers = GetMetadataProvidersInternal<TItemType>(dummy, options, searchInfo.IncludeDisabledProviders, false, false)
2014-02-19 16:24:06 +00:00
.OfType<IRemoteSearchProvider<TLookupType>>();
2014-02-19 05:21:03 +00:00
2014-02-19 16:24:06 +00:00
if (!string.IsNullOrEmpty(searchInfo.SearchProviderName))
{
providers = providers.Where(i => string.Equals(i.Name, searchInfo.SearchProviderName, StringComparison.OrdinalIgnoreCase));
}
2014-03-01 22:34:27 +00:00
if (string.IsNullOrWhiteSpace(searchInfo.SearchInfo.MetadataLanguage))
{
searchInfo.SearchInfo.MetadataLanguage = ConfigurationManager.Configuration.PreferredMetadataLanguage;
}
if (string.IsNullOrWhiteSpace(searchInfo.SearchInfo.MetadataCountryCode))
{
searchInfo.SearchInfo.MetadataCountryCode = ConfigurationManager.Configuration.MetadataCountryCode;
}
var resultList = new List<RemoteSearchResult>();
2014-02-19 16:24:06 +00:00
foreach (var provider in providers)
{
2014-11-05 03:41:14 +00:00
try
{
var results = await GetSearchResults(provider, searchInfo.SearchInfo, cancellationToken).ConfigureAwait(false);
2014-02-19 16:24:06 +00:00
foreach (var result in results)
2014-11-05 03:41:14 +00:00
{
2016-04-25 00:36:10 +00:00
var existingMatch = resultList.FirstOrDefault(i => i.ProviderIds.Any(p => string.Equals(result.GetProviderId(p.Key), p.Value, StringComparison.OrdinalIgnoreCase)));
2016-04-25 00:36:10 +00:00
if (existingMatch == null)
{
2016-04-25 00:36:10 +00:00
resultList.Add(result);
}
else
{
foreach (var providerId in result.ProviderIds)
{
2016-04-25 00:36:10 +00:00
if (!existingMatch.ProviderIds.ContainsKey(providerId.Key))
{
2016-04-25 00:36:10 +00:00
existingMatch.ProviderIds.Add(providerId.Key, providerId.Value);
}
}
2016-04-25 00:36:10 +00:00
if (string.IsNullOrWhiteSpace(existingMatch.ImageUrl))
{
existingMatch.ImageUrl = result.ImageUrl;
}
}
2014-11-05 03:41:14 +00:00
}
}
catch (Exception ex)
2014-02-19 16:24:06 +00:00
{
2014-11-05 03:41:14 +00:00
// Logged at lower levels
2014-02-19 16:24:06 +00:00
}
}
2016-04-25 00:36:10 +00:00
//_logger.Debug("Returning search results {0}", _json.SerializeToString(resultList));
return resultList;
2014-02-19 16:24:06 +00:00
}
2014-02-21 18:48:15 +00:00
2014-03-02 15:42:21 +00:00
private async Task<IEnumerable<RemoteSearchResult>> GetSearchResults<TLookupType>(IRemoteSearchProvider<TLookupType> provider, TLookupType searchInfo,
CancellationToken cancellationToken)
where TLookupType : ItemLookupInfo
{
var results = await provider.GetSearchResults(searchInfo, cancellationToken).ConfigureAwait(false);
var list = results.ToList();
foreach (var item in list)
{
item.SearchProviderName = provider.Name;
}
return list;
}
2014-03-01 22:34:27 +00:00
public Task<HttpResponseInfo> GetSearchImage(string providerName, string url, CancellationToken cancellationToken)
{
var provider = _metadataProviders.OfType<IRemoteSearchProvider>().FirstOrDefault(i => string.Equals(i.Name, providerName, StringComparison.OrdinalIgnoreCase));
if (provider == null)
{
throw new ArgumentException("Search provider not found.");
}
return provider.GetImageResponse(url, cancellationToken);
}
2014-02-21 18:48:15 +00:00
public IEnumerable<IExternalId> GetExternalIds(IHasProviderIds item)
{
return _externalIds.Where(i =>
{
try
{
return i.Supports(item);
}
catch (Exception ex)
{
_logger.ErrorException("Error in {0}.Suports", ex, i.GetType().Name);
return false;
}
});
}
2016-05-29 06:03:09 +00:00
public IEnumerable<ExternalUrl> GetExternalUrls(BaseItem item)
2014-02-21 18:48:15 +00:00
{
return GetExternalIds(item)
.Select(i =>
{
if (string.IsNullOrEmpty(i.UrlFormatString))
{
return null;
}
2014-02-21 21:44:10 +00:00
2014-02-21 18:48:15 +00:00
var value = item.GetProviderId(i.Key);
if (string.IsNullOrEmpty(value))
{
return null;
}
return new ExternalUrl
{
Name = i.Name,
Url = string.Format(i.UrlFormatString, value)
};
2016-05-29 06:03:09 +00:00
}).Where(i => i != null).Concat(item.GetRelatedUrls());
2014-02-21 18:48:15 +00:00
}
2014-02-21 21:44:10 +00:00
public IEnumerable<ExternalIdInfo> GetExternalIdInfos(IHasProviderIds item)
{
return GetExternalIds(item)
.Select(i => new ExternalIdInfo
{
Name = i.Name,
Key = i.Key,
UrlFormatString = i.UrlFormatString
});
}
2015-03-14 04:50:23 +00:00
2017-06-23 16:04:45 +00:00
private Dictionary<Guid, double> _activeRefreshes = new Dictionary<Guid, double>();
public Dictionary<Guid, Guid> GetRefreshQueue()
{
lock (_refreshQueueLock)
{
var dict = new Dictionary<Guid, Guid>();
foreach (var item in _refreshQueue)
{
dict[item.Item1] = item.Item1;
}
return dict;
}
}
public void OnRefreshStart(BaseItem item)
{
//_logger.Info("OnRefreshStart {0}", item.Id.ToString("N"));
var id = item.Id;
lock (_activeRefreshes)
{
_activeRefreshes[id] = 0;
}
if (RefreshStarted != null)
{
RefreshStarted(this, new GenericEventArgs<BaseItem>(item));
}
}
public void OnRefreshComplete(BaseItem item)
{
//_logger.Info("OnRefreshComplete {0}", item.Id.ToString("N"));
lock (_activeRefreshes)
{
_activeRefreshes.Remove(item.Id);
}
if (RefreshCompleted != null)
{
RefreshCompleted(this, new GenericEventArgs<BaseItem>(item));
}
}
public double? GetRefreshProgress(Guid id)
{
lock (_activeRefreshes)
{
double value;
if (_activeRefreshes.TryGetValue(id, out value))
{
return value;
}
return null;
}
}
public void OnRefreshProgress(BaseItem item, double progress)
{
//_logger.Info("OnRefreshProgress {0} {1}", item.Id.ToString("N"), progress);
var id = item.Id;
lock (_activeRefreshes)
{
if (_activeRefreshes.ContainsKey(id))
{
_activeRefreshes[id] = progress;
if (RefreshProgress != null)
{
RefreshProgress(this, new GenericEventArgs<Tuple<BaseItem, double>>(new Tuple<BaseItem, double>(item, progress)));
}
}
else
{
throw new Exception(string.Format("Refresh for item {0} {1} is not in progress", item.GetType().Name, item.Id.ToString("N")));
}
}
}
2017-04-30 02:37:51 +00:00
private readonly SimplePriorityQueue<Tuple<Guid, MetadataRefreshOptions>> _refreshQueue =
new SimplePriorityQueue<Tuple<Guid, MetadataRefreshOptions>>();
2015-03-14 04:50:23 +00:00
2016-10-27 07:58:33 +00:00
private readonly object _refreshQueueLock = new object();
private bool _isProcessingRefreshQueue;
2015-03-14 04:50:23 +00:00
2017-04-30 02:37:51 +00:00
public void QueueRefresh(Guid id, MetadataRefreshOptions options, RefreshPriority priority)
2015-03-14 04:50:23 +00:00
{
if (_disposed)
{
return;
}
2017-04-30 02:37:51 +00:00
_refreshQueue.Enqueue(new Tuple<Guid, MetadataRefreshOptions>(id, options), (int)priority);
2015-03-14 04:50:23 +00:00
2016-10-27 07:58:33 +00:00
lock (_refreshQueueLock)
2015-03-14 04:50:23 +00:00
{
2016-10-27 07:58:33 +00:00
if (!_isProcessingRefreshQueue)
2015-03-14 04:50:23 +00:00
{
2016-10-27 07:58:33 +00:00
_isProcessingRefreshQueue = true;
2017-05-27 07:19:09 +00:00
Task.Run(StartProcessingRefreshQueue);
2015-03-14 04:50:23 +00:00
}
}
}
2016-10-27 07:58:33 +00:00
private async Task StartProcessingRefreshQueue()
2015-03-14 04:50:23 +00:00
{
Tuple<Guid, MetadataRefreshOptions> refreshItem;
var libraryManager = _libraryManagerFactory();
2017-06-06 06:13:49 +00:00
if (_disposed)
{
return;
}
var cancellationToken = _disposeCancellationTokenSource.Token;
while (_refreshQueue.TryDequeue(out refreshItem))
2015-03-14 04:50:23 +00:00
{
if (_disposed)
{
return;
}
2015-10-04 18:10:50 +00:00
try
2015-03-14 04:50:23 +00:00
{
2015-10-04 18:10:50 +00:00
var item = libraryManager.GetItemById(refreshItem.Item1);
if (item != null)
2015-03-14 15:38:16 +00:00
{
2015-07-18 02:52:27 +00:00
// Try to throttle this a little bit.
await Task.Delay(100).ConfigureAwait(false);
2017-05-27 07:19:09 +00:00
if (refreshItem.Item2.ValidateChildren)
{
var folder = item as Folder;
if (folder != null)
{
2017-06-23 16:04:45 +00:00
await folder.ValidateChildren(new SimpleProgress<double>(), cancellationToken).ConfigureAwait(false);
2017-05-27 07:19:09 +00:00
}
}
2015-03-14 15:38:16 +00:00
var artist = item as MusicArtist;
var task = artist == null
2017-06-06 06:13:49 +00:00
? RefreshItem(item, refreshItem.Item2, cancellationToken)
: RefreshArtist(artist, refreshItem.Item2, cancellationToken);
2015-03-14 15:38:16 +00:00
await task.ConfigureAwait(false);
}
2015-10-04 18:10:50 +00:00
}
2017-06-06 06:13:49 +00:00
catch (OperationCanceledException)
{
break;
}
2015-10-04 18:10:50 +00:00
catch (Exception ex)
{
_logger.ErrorException("Error refreshing item", ex);
2015-03-14 04:50:23 +00:00
}
2015-03-14 15:38:16 +00:00
}
2016-10-27 07:58:33 +00:00
lock (_refreshQueueLock)
{
_isProcessingRefreshQueue = false;
}
2015-03-14 15:38:16 +00:00
}
private async Task RefreshItem(BaseItem item, MetadataRefreshOptions options, CancellationToken cancellationToken)
{
2017-06-06 06:13:49 +00:00
await item.RefreshMetadata(options, cancellationToken).ConfigureAwait(false);
2015-03-14 15:38:16 +00:00
2017-01-06 04:38:03 +00:00
// Collection folders don't validate their children so we'll have to simulate that here
var collectionFolder = item as CollectionFolder;
if (collectionFolder != null)
{
2017-06-06 06:13:49 +00:00
await RefreshCollectionFolderChildren(options, collectionFolder, cancellationToken).ConfigureAwait(false);
2017-01-06 04:38:03 +00:00
}
else
2015-03-14 15:38:16 +00:00
{
2017-01-06 04:38:03 +00:00
var folder = item as Folder;
2015-03-14 15:38:16 +00:00
2017-01-06 04:38:03 +00:00
if (folder != null)
2015-03-14 15:38:16 +00:00
{
2017-06-23 16:04:45 +00:00
await folder.ValidateChildren(new SimpleProgress<double>(), cancellationToken, options).ConfigureAwait(false);
2015-03-14 04:50:23 +00:00
}
}
2015-03-14 15:38:16 +00:00
}
2015-03-14 04:50:23 +00:00
2017-06-06 06:13:49 +00:00
private async Task RefreshCollectionFolderChildren(MetadataRefreshOptions options, CollectionFolder collectionFolder, CancellationToken cancellationToken)
2015-03-14 15:38:16 +00:00
{
2017-06-23 16:04:45 +00:00
foreach (var child in collectionFolder.GetPhysicalFolders().ToList())
2015-03-14 15:38:16 +00:00
{
2017-06-06 06:13:49 +00:00
await child.RefreshMetadata(options, cancellationToken).ConfigureAwait(false);
2015-03-14 15:38:16 +00:00
if (child.IsFolder)
{
var folder = (Folder)child;
2017-06-23 16:04:45 +00:00
await folder.ValidateChildren(new SimpleProgress<double>(), cancellationToken, options, true).ConfigureAwait(false);
2015-03-14 15:38:16 +00:00
}
}
}
2017-06-06 06:13:49 +00:00
private async Task RefreshArtist(MusicArtist item, MetadataRefreshOptions options, CancellationToken cancellationToken)
2015-03-14 15:38:16 +00:00
{
2017-01-21 20:27:07 +00:00
var albums = _libraryManagerFactory()
.GetItemList(new InternalItemsQuery
{
IncludeItemTypes = new[] { typeof(MusicAlbum).Name },
2017-05-21 07:25:49 +00:00
ArtistIds = new[] { item.Id.ToString("N") },
DtoOptions = new DtoOptions(false)
{
EnableImages = false
}
2017-01-21 20:27:07 +00:00
})
.OfType<MusicAlbum>()
.ToList();
2015-03-14 15:38:16 +00:00
var musicArtists = albums
2016-03-14 01:34:24 +00:00
.Select(i => i.MusicArtist)
.Where(i => i != null)
2015-03-14 15:38:16 +00:00
.ToList();
2017-06-23 16:04:45 +00:00
var musicArtistRefreshTasks = musicArtists.Select(i => i.ValidateChildren(new SimpleProgress<double>(), cancellationToken, options, true));
2015-03-14 15:38:16 +00:00
await Task.WhenAll(musicArtistRefreshTasks).ConfigureAwait(false);
try
{
2017-06-06 06:13:49 +00:00
await item.RefreshMetadata(options, cancellationToken).ConfigureAwait(false);
2015-03-14 15:38:16 +00:00
}
catch (Exception ex)
{
_logger.ErrorException("Error refreshing library", ex);
}
}
public Task RefreshFullItem(IHasMetadata item, MetadataRefreshOptions options,
CancellationToken cancellationToken)
{
return RefreshItem((BaseItem)item, options, cancellationToken);
2015-03-14 04:50:23 +00:00
}
private bool _disposed;
public void Dispose()
{
_disposed = true;
2017-06-06 06:13:49 +00:00
if (!_disposeCancellationTokenSource.IsCancellationRequested)
{
_disposeCancellationTokenSource.Cancel();
}
2017-09-05 19:49:02 +00:00
GC.SuppressFinalize(this);
2015-03-14 04:50:23 +00:00
}
2013-02-21 01:33:05 +00:00
}
2014-02-12 03:46:27 +00:00
}