using MediaBrowser.Common.IO; using MediaBrowser.Common.Net; using MediaBrowser.Controller.Configuration; using MediaBrowser.Controller.Entities; using MediaBrowser.Controller.Entities.Movies; using MediaBrowser.Controller.IO; using MediaBrowser.Controller.Library; using MediaBrowser.Controller.Persistence; using MediaBrowser.Controller.Providers; using MediaBrowser.Model.Entities; using MediaBrowser.Model.Logging; using MediaBrowser.Model.Providers; using System; using System.Collections.Generic; using System.IO; using System.Linq; using System.Threading; using System.Threading.Tasks; namespace MediaBrowser.Server.Implementations.Providers { /// /// Class ProviderManager /// public class ProviderManager : IProviderManager { /// /// The _logger /// private readonly ILogger _logger; /// /// The _HTTP client /// private readonly IHttpClient _httpClient; /// /// The _directory watchers /// private readonly IDirectoryWatchers _directoryWatchers; /// /// Gets or sets the configuration manager. /// /// The configuration manager. private IServerConfigurationManager ConfigurationManager { get; set; } /// /// Gets the list of currently registered metadata prvoiders /// /// The metadata providers enumerable. private BaseMetadataProvider[] MetadataProviders { get; set; } private IImageProvider[] ImageProviders { get; set; } private readonly IFileSystem _fileSystem; private readonly IItemRepository _itemRepo; /// /// Initializes a new instance of the class. /// /// The HTTP client. /// The configuration manager. /// The directory watchers. /// The log manager. public ProviderManager(IHttpClient httpClient, IServerConfigurationManager configurationManager, IDirectoryWatchers directoryWatchers, ILogManager logManager, IFileSystem fileSystem, IItemRepository itemRepo) { _logger = logManager.GetLogger("ProviderManager"); _httpClient = httpClient; ConfigurationManager = configurationManager; _directoryWatchers = directoryWatchers; _fileSystem = fileSystem; _itemRepo = itemRepo; } /// /// Adds the metadata providers. /// /// The providers. /// The image providers. public void AddParts(IEnumerable providers, IEnumerable imageProviders) { MetadataProviders = providers.OrderBy(e => e.Priority).ToArray(); ImageProviders = imageProviders.OrderByDescending(i => i.Priority).ToArray(); } /// /// Runs all metadata providers for an entity, and returns true or false indicating if at least one was refreshed and requires persistence /// /// The item. /// The cancellation token. /// if set to true [force]. /// if set to true [allow slow providers]. /// Task{System.Boolean}. public async Task ExecuteMetadataProviders(BaseItem item, CancellationToken cancellationToken, bool force = false, bool allowSlowProviders = true) { if (item == null) { throw new ArgumentNullException("item"); } ItemUpdateType? result = null; cancellationToken.ThrowIfCancellationRequested(); var enableInternetProviders = ConfigurationManager.Configuration.EnableInternetProviders; var providerHistories = item.DateLastSaved == default(DateTime) ? new List() : _itemRepo.GetProviderHistory(item.Id).ToList(); // Run the normal providers sequentially in order of priority foreach (var provider in MetadataProviders) { cancellationToken.ThrowIfCancellationRequested(); if (!ProviderSupportsItem(provider, item)) { continue; } // Skip if internet providers are currently disabled if (provider.RequiresInternet && !enableInternetProviders) { continue; } // Skip if is slow and we aren't allowing slow ones if (provider.IsSlow && !allowSlowProviders) { continue; } // Put this check below the await because the needs refresh of the next tier of providers may depend on the previous ones running // This is the case for the fan art provider which depends on the movie and tv providers having run before them if (provider.RequiresInternet && item.DontFetchMeta && provider.EnforceDontFetchMetadata) { continue; } var providerInfo = providerHistories.FirstOrDefault(i => i.ProviderId == provider.Id); if (providerInfo == null) { providerInfo = new BaseProviderInfo { ProviderId = provider.Id }; providerHistories.Add(providerInfo); } try { if (!force && !provider.NeedsRefresh(item, providerInfo)) { continue; } } catch (Exception ex) { _logger.Error("Error determining NeedsRefresh for {0}", ex, item.Path); } var updateType = await FetchAsync(provider, item, providerInfo, force, cancellationToken).ConfigureAwait(false); if (updateType.HasValue) { if (result.HasValue) { result = result.Value | updateType.Value; } else { result = updateType; } } } if (result.HasValue || force) { await _itemRepo.SaveProviderHistory(item.Id, providerHistories, cancellationToken); } return result; } /// /// Providers the supports item. /// /// The provider. /// The item. /// true if XXXX, false otherwise private bool ProviderSupportsItem(BaseMetadataProvider provider, BaseItem item) { 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; } } /// /// Fetches metadata and returns true or false indicating if any work that requires persistence was done /// /// The provider. /// The item. /// The provider information. /// if set to true [force]. /// The cancellation token. /// Task{System.Boolean}. /// item private async Task FetchAsync(BaseMetadataProvider provider, BaseItem item, BaseProviderInfo providerInfo, bool force, CancellationToken cancellationToken) { if (item == null) { throw new ArgumentNullException("item"); } cancellationToken.ThrowIfCancellationRequested(); // Don't clog up the log with these providers if (!(provider is IDynamicInfoProvider)) { _logger.Debug("Running {0} for {1}", provider.GetType().Name, item.Path ?? item.Name ?? "--Unknown--"); } try { var changed = await provider.FetchAsync(item, force, providerInfo, cancellationToken).ConfigureAwait(false); if (changed) { return provider.ItemUpdateType; } return null; } catch (OperationCanceledException ex) { _logger.Debug("{0} canceled for {1}", provider.GetType().Name, item.Name); // If the outer cancellation token is the one that caused the cancellation, throw it if (cancellationToken.IsCancellationRequested && ex.CancellationToken == cancellationToken) { throw; } return null; } catch (Exception ex) { _logger.ErrorException("{0} failed refreshing {1} {2}", ex, provider.GetType().Name, item.Name, item.Path ?? string.Empty); provider.SetLastRefreshed(item, DateTime.UtcNow, providerInfo, ProviderRefreshStatus.Failure); return ItemUpdateType.Unspecified; } } /// /// Saves to library filesystem. /// /// The item. /// The path. /// The data to save. /// The cancellation token. /// Task. /// public async Task SaveToLibraryFilesystem(BaseItem item, string path, Stream dataToSave, CancellationToken cancellationToken) { if (item == null) { throw new ArgumentNullException(); } if (string.IsNullOrEmpty(path)) { throw new ArgumentNullException(); } if (dataToSave == null) { throw new ArgumentNullException(); } if (cancellationToken.IsCancellationRequested) { dataToSave.Dispose(); cancellationToken.ThrowIfCancellationRequested(); } //Tell the watchers to ignore _directoryWatchers.TemporarilyIgnore(path); if (dataToSave.CanSeek) { dataToSave.Position = 0; } try { using (dataToSave) { using (var fs = _fileSystem.GetFileStream(path, FileMode.Create, FileAccess.Write, FileShare.Read, true)) { await dataToSave.CopyToAsync(fs, StreamDefaults.DefaultCopyToBufferSize, cancellationToken).ConfigureAwait(false); } } // If this is ever used for something other than metadata we can add a file type param item.ResolveArgs.AddMetadataFile(path); } finally { //Remove the ignore _directoryWatchers.RemoveTempIgnore(path); } } /// /// Saves the image. /// /// The item. /// The URL. /// The resource pool. /// The type. /// Index of the image. /// The cancellation token. /// Task. public async Task SaveImage(BaseItem item, string url, SemaphoreSlim resourcePool, ImageType type, int? imageIndex, CancellationToken cancellationToken) { var response = await _httpClient.GetResponse(new HttpRequestOptions { CancellationToken = cancellationToken, ResourcePool = resourcePool, Url = url }).ConfigureAwait(false); await SaveImage(item, response.Content, response.ContentType, type, imageIndex, url, cancellationToken) .ConfigureAwait(false); } /// /// Saves the image. /// /// The item. /// The source. /// Type of the MIME. /// The type. /// Index of the image. /// The source URL. /// The cancellation token. /// Task. public Task SaveImage(BaseItem item, Stream source, string mimeType, ImageType type, int? imageIndex, string sourceUrl, CancellationToken cancellationToken) { return new ImageSaver(ConfigurationManager, _directoryWatchers, _fileSystem, _logger).SaveImage(item, source, mimeType, type, imageIndex, sourceUrl, cancellationToken); } /// /// Gets the available remote images. /// /// The item. /// The cancellation token. /// Name of the provider. /// The type. /// Task{IEnumerable{RemoteImageInfo}}. public async Task> GetAvailableRemoteImages(BaseItem item, CancellationToken cancellationToken, string providerName = null, ImageType? type = null) { var providers = GetImageProviders(item); if (!string.IsNullOrEmpty(providerName)) { providers = providers.Where(i => string.Equals(i.Name, providerName, StringComparison.OrdinalIgnoreCase)); } var preferredLanguage = item.GetPreferredMetadataLanguage(); var tasks = providers.Select(i => GetImages(item, cancellationToken, i, preferredLanguage, type)); var results = await Task.WhenAll(tasks).ConfigureAwait(false); return results.SelectMany(i => i); } /// /// Gets the images. /// /// The item. /// The cancellation token. /// The i. /// The preferred language. /// The type. /// Task{IEnumerable{RemoteImageInfo}}. private async Task> GetImages(BaseItem item, CancellationToken cancellationToken, IImageProvider i, string preferredLanguage, ImageType? type = null) { try { if (type.HasValue) { var result = await i.GetImages(item, type.Value, cancellationToken).ConfigureAwait(false); return FilterImages(result, preferredLanguage); } else { var result = await i.GetAllImages(item, cancellationToken).ConfigureAwait(false); return FilterImages(result, preferredLanguage); } } catch (Exception ex) { _logger.ErrorException("{0} failed in GetImages for type {1}", ex, i.GetType().Name, item.GetType().Name); return new List(); } } private IEnumerable FilterImages(IEnumerable images, string preferredLanguage) { if (string.Equals(preferredLanguage, "en", StringComparison.OrdinalIgnoreCase)) { images = images.Where(i => string.IsNullOrEmpty(i.Language) || string.Equals(i.Language, "en", StringComparison.OrdinalIgnoreCase)); } return images; } /// /// Gets the supported image providers. /// /// The item. /// IEnumerable{IImageProvider}. public IEnumerable GetImageProviders(BaseItem item) { return ImageProviders.Where(i => { try { return i.Supports(item); } catch (Exception ex) { _logger.ErrorException("{0} failed in Supports for type {1}", ex, i.GetType().Name, item.GetType().Name); return false; } }); } } }