Release 0.2.5: harden proxy and streamline metadata fetching
Remove obsolete rule formats, batch SQLite work, preserve artwork source URLs, and coordinate refresh workers with maintenance. Add regression coverage and document backup format changes.
This commit is contained in:
1 parent
7eb62b156e
commit
e36775f1a3
49 files changed
+2126
-1813
No files matched your search
@@ -1,4 +1,3 @@
|
||||
using System.Net.Http.Headers;
|
||||
using System.Security.Cryptography;
|
||||
using Jellyfin.Plugin.Multilang.Data;
|
||||
|
||||
@@ -18,8 +17,6 @@ public sealed class AssetStorageService
|
||||
|
||||
public async Task<string?> StoreAsync(
|
||||
string itemId,
|
||||
string lang,
|
||||
string kind,
|
||||
string sourceUrl,
|
||||
bool localStorage,
|
||||
CancellationToken cancellationToken)
|
||||
@@ -30,22 +27,17 @@ public sealed class AssetStorageService
|
||||
if (!localStorage)
|
||||
return sourceUrl;
|
||||
|
||||
var relative = BuildRelativePath(itemId, lang, kind, sourceUrl);
|
||||
var relative = BuildRelativePath(itemId, sourceUrl);
|
||||
var expectedUrl = TranslationStore.LocalAssetUrlPrefix + relative.Replace('\\', '/');
|
||||
if (_store.GetAssetPath(itemId, lang, kind) is { } existing &&
|
||||
existing.Equals(expectedUrl, StringComparison.OrdinalIgnoreCase) &&
|
||||
_store.TryNormalizeLocalAssetPath(existing, out var existingPath) &&
|
||||
File.Exists(existingPath))
|
||||
{
|
||||
return existing;
|
||||
}
|
||||
|
||||
var destination = Path.GetFullPath(Path.Combine(_store.AssetsDirectory, relative));
|
||||
var root = Path.GetFullPath(_store.AssetsDirectory) + Path.DirectorySeparatorChar;
|
||||
if (!destination.StartsWith(root, StringComparison.OrdinalIgnoreCase))
|
||||
throw new InvalidOperationException("Resolved asset path escaped the Multilang assets directory.");
|
||||
|
||||
Directory.CreateDirectory(Path.GetDirectoryName(destination) ?? _store.AssetsDirectory);
|
||||
if (File.Exists(destination))
|
||||
return expectedUrl;
|
||||
|
||||
Directory.CreateDirectory(Path.GetDirectoryName(destination)!);
|
||||
await DownloadAsync(sourceUrl, destination, cancellationToken).ConfigureAwait(false);
|
||||
return expectedUrl;
|
||||
}
|
||||
@@ -101,11 +93,11 @@ public sealed class AssetStorageService
|
||||
File.Move(temp, destination, overwrite: true);
|
||||
}
|
||||
|
||||
private static string BuildRelativePath(string itemId, string lang, string kind, string sourceUrl)
|
||||
private static string BuildRelativePath(string itemId, string sourceUrl)
|
||||
{
|
||||
var extension = ExtensionFromUrl(sourceUrl);
|
||||
var hash = Convert.ToHexString(SHA256.HashData(System.Text.Encoding.UTF8.GetBytes(sourceUrl))).ToLowerInvariant()[..16];
|
||||
return Path.Combine(SafeSegment(itemId), SafeSegment(lang), SafeSegment(kind) + "-" + hash + extension);
|
||||
return Path.Combine(SafeSegment(itemId), hash + extension);
|
||||
}
|
||||
|
||||
private static string SafeSegment(string value)
|
||||
@@ -133,6 +125,6 @@ public sealed class AssetStorageService
|
||||
".png" => "image/png",
|
||||
".webp" => "image/webp",
|
||||
".gif" => "image/gif",
|
||||
_ => MediaTypeHeaderValue.Parse("application/octet-stream").MediaType ?? "application/octet-stream"
|
||||
_ => "application/octet-stream"
|
||||
};
|
||||
}
|
||||
@@ -1,3 +1,4 @@
|
||||
using Jellyfin.Plugin.Multilang.Rules;
|
||||
using System.Globalization;
|
||||
using System.IO.Compression;
|
||||
using System.Text.Json;
|
||||
@@ -142,6 +143,14 @@ public sealed class MultilangBackupService
|
||||
|
||||
using var zip = ZipFile.OpenRead(zipPath);
|
||||
ValidateManifest(zip);
|
||||
var dbPath = Path.Combine(tempDir, DatabaseName);
|
||||
var dbEntry = options.TranslationsDatabase ? zip.GetEntry(DatabaseName) : null;
|
||||
if (dbEntry is not null)
|
||||
{
|
||||
dbEntry.ExtractToFile(dbPath);
|
||||
TranslationStore.ValidateTranslationBackup(dbPath);
|
||||
}
|
||||
|
||||
var importedConfig = false;
|
||||
var importedUsers = 0;
|
||||
var ignoredUsers = 0;
|
||||
@@ -173,21 +182,13 @@ public sealed class MultilangBackupService
|
||||
continue;
|
||||
}
|
||||
|
||||
_store.SaveUserRules(userId, payload.Rules);
|
||||
_store.SaveUserRules(userId, UserRulesNormalizer.Normalize(payload.Rules, currentConfiguration.Languages));
|
||||
importedUsers++;
|
||||
}
|
||||
}
|
||||
|
||||
if (options.TranslationsDatabase)
|
||||
{
|
||||
var dbEntry = zip.GetEntry(DatabaseName);
|
||||
if (dbEntry is not null)
|
||||
{
|
||||
var dbPath = Path.Combine(tempDir, DatabaseName);
|
||||
dbEntry.ExtractToFile(dbPath, overwrite: true);
|
||||
database = _store.ImportTranslationDatabase(dbPath, GetLiveItemIds(), GetAllowedLanguages(currentConfiguration));
|
||||
}
|
||||
}
|
||||
if (dbEntry is not null)
|
||||
database = _store.ImportTranslationDatabase(dbPath, GetLiveItemIds(), GetAllowedLanguages(currentConfiguration));
|
||||
|
||||
if (options.DownloadedAssets)
|
||||
{
|
||||
@@ -268,7 +269,7 @@ public sealed class MultilangBackupService
|
||||
if (payload?.Rules is null)
|
||||
return new BackupImportResult(false, 0, 0, 0, 0, 0, 0, 0, 0, [], false);
|
||||
|
||||
_store.SaveUserRules(current, payload.Rules);
|
||||
_store.SaveUserRules(current, UserRulesNormalizer.Normalize(payload.Rules, Plugin.Instance?.Configuration.Languages));
|
||||
return new BackupImportResult(false, 1, 0, 0, 0, 0, 0, 0, 0, [], false);
|
||||
}
|
||||
finally
|
||||
|
||||
@@ -10,7 +10,7 @@ public sealed class ItemsProxyCache
|
||||
|
||||
public required string Url { get; init; }
|
||||
|
||||
public required HashSet<string> ItemIds { get; init; }
|
||||
public required int ItemCount { get; init; }
|
||||
|
||||
public required string Body { get; init; }
|
||||
|
||||
@@ -21,6 +21,7 @@ public sealed class ItemsProxyCache
|
||||
public required long DurationMs { get; init; }
|
||||
|
||||
public required long SizeBytes { get; init; }
|
||||
public bool Micro { get; init; }
|
||||
}
|
||||
|
||||
private sealed class RecentRequest
|
||||
@@ -50,49 +51,43 @@ public sealed class ItemsProxyCache
|
||||
|
||||
private readonly object _lock = new();
|
||||
private readonly Dictionary<string, Entry> _entries = new(StringComparer.Ordinal);
|
||||
private readonly Dictionary<string, Entry> _microEntries = new(StringComparer.Ordinal);
|
||||
private readonly Dictionary<string, string> _userPolicies = new(StringComparer.Ordinal);
|
||||
private readonly Queue<RecentRequest> _recentRequests = new();
|
||||
private long _totalBytes;
|
||||
private long _generation;
|
||||
public long Generation { get { lock (_lock) return _generation; } }
|
||||
private const int MaxRecentRequests = 100;
|
||||
private const int MaxMicroEntries = 50;
|
||||
private static readonly TimeSpan MicroTtl = TimeSpan.FromSeconds(3);
|
||||
|
||||
public long ObserveUserPolicy(string userId, string policy)
|
||||
{
|
||||
lock (_lock)
|
||||
{
|
||||
if (_userPolicies.TryGetValue(userId, out var previous) && previous != policy)
|
||||
ClearUser(userId);
|
||||
_userPolicies[userId] = policy;
|
||||
return _generation;
|
||||
}
|
||||
}
|
||||
|
||||
public void ClearAll()
|
||||
{
|
||||
lock (_lock)
|
||||
{
|
||||
_entries.Clear();
|
||||
_microEntries.Clear();
|
||||
_totalBytes = 0;
|
||||
_generation++;
|
||||
}
|
||||
}
|
||||
|
||||
public void InvalidateItems(IEnumerable<string> itemIds)
|
||||
public void ClearUser(string userId)
|
||||
{
|
||||
var ids = itemIds
|
||||
.Where(id => !string.IsNullOrWhiteSpace(id))
|
||||
.Select(id => id.Trim().ToLowerInvariant())
|
||||
.ToHashSet(StringComparer.OrdinalIgnoreCase);
|
||||
if (ids.Count == 0)
|
||||
return;
|
||||
|
||||
lock (_lock)
|
||||
{
|
||||
foreach (var key in _entries.Values
|
||||
.Where(e => e.ItemIds.Overlaps(ids))
|
||||
.Select(e => e.Key)
|
||||
.ToArray())
|
||||
{
|
||||
_generation++;
|
||||
foreach (var key in _entries.Values.Where(e => e.UserId == userId).Select(e => e.Key).ToArray())
|
||||
Remove(key);
|
||||
}
|
||||
|
||||
foreach (var key in _microEntries.Values
|
||||
.Where(e => e.ItemIds.Overlaps(ids))
|
||||
.Select(e => e.Key)
|
||||
.ToArray())
|
||||
{
|
||||
_microEntries.Remove(key);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -103,23 +98,16 @@ public sealed class ItemsProxyCache
|
||||
PurgeExpired(ttl);
|
||||
if (!_entries.TryGetValue(key, out var entry))
|
||||
{
|
||||
PurgeExpired(_microEntries, MicroTtl);
|
||||
if (!_microEntries.TryGetValue(key, out var microEntry))
|
||||
{
|
||||
response = default;
|
||||
return false;
|
||||
}
|
||||
|
||||
response = new CachedItemsProxyResponse(microEntry.Body, microEntry.ContentType, microEntry.ItemIds.Count, microEntry.SizeBytes);
|
||||
return true;
|
||||
response = default;
|
||||
return false;
|
||||
}
|
||||
|
||||
response = new CachedItemsProxyResponse(entry.Body, entry.ContentType, entry.ItemIds.Count, entry.SizeBytes);
|
||||
response = new CachedItemsProxyResponse(entry.Body, entry.ContentType, entry.ItemCount, entry.SizeBytes);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
public bool Store(string key, string userId, string url, IEnumerable<string> itemIds, string body, string contentType, long durationMs, long maxBytes, TimeSpan ttl)
|
||||
public bool Store(string key, string userId, string url, int itemCount, string body, string contentType, long durationMs, long maxBytes, TimeSpan ttl, long? generation = null, bool micro = false)
|
||||
{
|
||||
if (maxBytes <= 0 || ttl <= TimeSpan.Zero)
|
||||
return false;
|
||||
@@ -130,76 +118,40 @@ public sealed class ItemsProxyCache
|
||||
|
||||
lock (_lock)
|
||||
{
|
||||
if (generation.HasValue && generation != _generation)
|
||||
return false;
|
||||
PurgeExpired(ttl);
|
||||
Remove(key);
|
||||
|
||||
if (micro && _entries.Values.Count(e => e.Micro) >= MaxMicroEntries)
|
||||
Remove(_entries.Values.Where(e => e.Micro).MinBy(e => e.CreatedUtc)!.Key);
|
||||
|
||||
while (_totalBytes + sizeBytes > maxBytes && _entries.Count > 0)
|
||||
{
|
||||
var victim = _entries.Values.OrderBy(e => e.CreatedUtc).First();
|
||||
Remove(victim.Key);
|
||||
}
|
||||
|
||||
if (_totalBytes + sizeBytes > maxBytes)
|
||||
return false;
|
||||
|
||||
_entries[key] = new Entry
|
||||
{
|
||||
Key = key,
|
||||
UserId = userId,
|
||||
Url = url,
|
||||
ItemIds = itemIds
|
||||
.Where(id => !string.IsNullOrWhiteSpace(id))
|
||||
.Select(id => id.Trim().ToLowerInvariant())
|
||||
.ToHashSet(StringComparer.OrdinalIgnoreCase),
|
||||
ItemCount = itemCount,
|
||||
Body = body,
|
||||
ContentType = contentType,
|
||||
CreatedUtc = DateTimeOffset.UtcNow,
|
||||
DurationMs = durationMs,
|
||||
SizeBytes = sizeBytes
|
||||
SizeBytes = sizeBytes,
|
||||
Micro = micro
|
||||
};
|
||||
_totalBytes += sizeBytes;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
public bool StoreMicro(string key, string userId, string url, IEnumerable<string> itemIds, string body, string contentType, long durationMs, long maxBytes)
|
||||
{
|
||||
if (maxBytes <= 0)
|
||||
return false;
|
||||
|
||||
var sizeBytes = System.Text.Encoding.UTF8.GetByteCount(body);
|
||||
if (sizeBytes > maxBytes)
|
||||
return false;
|
||||
|
||||
lock (_lock)
|
||||
{
|
||||
PurgeExpired(_microEntries, MicroTtl);
|
||||
_microEntries.Remove(key);
|
||||
|
||||
while (_microEntries.Count >= MaxMicroEntries)
|
||||
{
|
||||
var victim = _microEntries.Values.OrderBy(e => e.CreatedUtc).First();
|
||||
_microEntries.Remove(victim.Key);
|
||||
}
|
||||
|
||||
_microEntries[key] = new Entry
|
||||
{
|
||||
Key = key,
|
||||
UserId = userId,
|
||||
Url = url,
|
||||
ItemIds = itemIds
|
||||
.Where(id => !string.IsNullOrWhiteSpace(id))
|
||||
.Select(id => id.Trim().ToLowerInvariant())
|
||||
.ToHashSet(StringComparer.OrdinalIgnoreCase),
|
||||
Body = body,
|
||||
ContentType = contentType,
|
||||
CreatedUtc = DateTimeOffset.UtcNow,
|
||||
DurationMs = durationMs,
|
||||
SizeBytes = sizeBytes
|
||||
};
|
||||
return true;
|
||||
}
|
||||
}
|
||||
public bool StoreMicro(string key, string userId, string url, int itemCount, string body, string contentType, long durationMs, long maxBytes, long? generation = null, TimeSpan? ttl = null)
|
||||
=> Store(key, userId, url, itemCount, body, contentType, durationMs, maxBytes, ttl ?? TimeSpan.FromMinutes(1), generation, micro: true);
|
||||
|
||||
public object[] GetEntries()
|
||||
{
|
||||
@@ -207,6 +159,7 @@ public sealed class ItemsProxyCache
|
||||
{
|
||||
var now = DateTimeOffset.UtcNow;
|
||||
return _entries.Values
|
||||
.Where(e => !e.Micro)
|
||||
.OrderByDescending(e => e.CreatedUtc)
|
||||
.Select(e => new
|
||||
{
|
||||
@@ -215,7 +168,7 @@ public sealed class ItemsProxyCache
|
||||
AgeSeconds = (long)(now - e.CreatedUtc).TotalSeconds,
|
||||
e.DurationMs,
|
||||
e.SizeBytes,
|
||||
ItemCount = e.ItemIds.Count
|
||||
ItemCount = e.ItemCount
|
||||
})
|
||||
.Cast<object>()
|
||||
.ToArray();
|
||||
@@ -288,26 +241,16 @@ public sealed class ItemsProxyCache
|
||||
return;
|
||||
|
||||
var now = DateTimeOffset.UtcNow;
|
||||
foreach (var key in _entries.Values.Where(e => now - e.CreatedUtc > ttl).Select(e => e.Key).ToArray())
|
||||
foreach (var key in _entries.Values.Where(e => now - e.CreatedUtc > (e.Micro ? MicroTtl : ttl)).Select(e => e.Key).ToArray())
|
||||
Remove(key);
|
||||
}
|
||||
|
||||
private static void PurgeExpired(Dictionary<string, Entry> entries, TimeSpan ttl)
|
||||
{
|
||||
if (ttl <= TimeSpan.Zero || entries.Count == 0)
|
||||
return;
|
||||
|
||||
var now = DateTimeOffset.UtcNow;
|
||||
foreach (var key in entries.Values.Where(e => now - e.CreatedUtc > ttl).Select(e => e.Key).ToArray())
|
||||
entries.Remove(key);
|
||||
}
|
||||
|
||||
private void Remove(string key)
|
||||
{
|
||||
if (!_entries.Remove(key, out var existing))
|
||||
return;
|
||||
|
||||
_totalBytes = Math.Max(0, _totalBytes - existing.SizeBytes);
|
||||
_totalBytes -= existing.SizeBytes;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,35 @@
|
||||
using Jellyfin.Data.Events;
|
||||
using Jellyfin.Database.Implementations.Entities;
|
||||
using MediaBrowser.Controller.Library;
|
||||
using Microsoft.Extensions.Hosting;
|
||||
|
||||
namespace Jellyfin.Plugin.Multilang.Services;
|
||||
|
||||
public sealed class ItemsProxyInvalidationService(
|
||||
ILibraryManager library, IUserManager users, IUserDataManager userData, ItemsProxyCache cache) : IHostedService
|
||||
{
|
||||
public Task StartAsync(CancellationToken cancellationToken)
|
||||
{
|
||||
library.ItemAdded += LibraryChanged;
|
||||
library.ItemUpdated += LibraryChanged;
|
||||
library.ItemRemoved += LibraryChanged;
|
||||
users.OnUserUpdated += UserChanged;
|
||||
userData.UserDataSaved += UserDataChanged;
|
||||
return Task.CompletedTask;
|
||||
}
|
||||
|
||||
public Task StopAsync(CancellationToken cancellationToken)
|
||||
{
|
||||
library.ItemAdded -= LibraryChanged;
|
||||
library.ItemUpdated -= LibraryChanged;
|
||||
library.ItemRemoved -= LibraryChanged;
|
||||
users.OnUserUpdated -= UserChanged;
|
||||
userData.UserDataSaved -= UserDataChanged;
|
||||
return Task.CompletedTask;
|
||||
}
|
||||
|
||||
// Membership and native filters can change even when an item wasn't in a cached result.
|
||||
private void LibraryChanged(object? sender, ItemChangeEventArgs args) => cache.ClearAll();
|
||||
private void UserChanged(object? sender, GenericEventArgs<User> args) => cache.ClearUser(args.Argument.Id.ToString("N"));
|
||||
private void UserDataChanged(object? sender, UserDataSaveEventArgs args) => cache.ClearUser(args.UserId.ToString("N"));
|
||||
}
|
||||
@@ -60,8 +60,7 @@ public sealed class ItemsProxyPrecacheService
|
||||
{
|
||||
try
|
||||
{
|
||||
var port = _configurationManager.GetNetworkConfiguration().InternalHttpPort;
|
||||
var baseUri = new Uri(_applicationHost.GetLocalApiUrl("127.0.0.1", "http", port).TrimEnd('/') + "/");
|
||||
var baseUri = LocalApiUri;
|
||||
var views = await GetJsonAsync(new Uri(baseUri, $"Users/{userId}/Views"), token).ConfigureAwait(false);
|
||||
var items = views["Items"]?.AsArray() ?? [];
|
||||
var targets = items
|
||||
@@ -86,7 +85,7 @@ public sealed class ItemsProxyPrecacheService
|
||||
|
||||
using var request = new HttpRequestMessage(HttpMethod.Get, new Uri(baseUri, endpoint));
|
||||
AddTokenHeaders(request, token);
|
||||
using var response = await _httpClientFactory.CreateClient().SendAsync(request, CancellationToken.None).ConfigureAwait(false);
|
||||
using var response = await _httpClientFactory.CreateClient("Multilang.Jellyfin").SendAsync(request, CancellationToken.None).ConfigureAwait(false);
|
||||
if (!response.IsSuccessStatusCode)
|
||||
_logger.LogWarning("Multilang pre-cache failed user={UserId} library={LibraryId} status={StatusCode}", userId, target.Id, (int)response.StatusCode);
|
||||
}
|
||||
@@ -106,7 +105,7 @@ public sealed class ItemsProxyPrecacheService
|
||||
{
|
||||
using var request = new HttpRequestMessage(HttpMethod.Get, uri);
|
||||
AddTokenHeaders(request, token);
|
||||
using var response = await _httpClientFactory.CreateClient().SendAsync(request, CancellationToken.None).ConfigureAwait(false);
|
||||
using var response = await _httpClientFactory.CreateClient("Multilang.Jellyfin").SendAsync(request, CancellationToken.None).ConfigureAwait(false);
|
||||
response.EnsureSuccessStatusCode();
|
||||
var body = await response.Content.ReadAsStringAsync(CancellationToken.None).ConfigureAwait(false);
|
||||
return JsonNode.Parse(body)?.AsObject() ?? throw new InvalidOperationException("Jellyfin views response was not a JSON object.");
|
||||
@@ -118,4 +117,7 @@ public sealed class ItemsProxyPrecacheService
|
||||
request.Headers.TryAddWithoutValidation("X-Emby-Token", token);
|
||||
request.Headers.TryAddWithoutValidation("X-MediaBrowser-Token", token);
|
||||
}
|
||||
|
||||
public Uri LocalApiUri => new(_applicationHost.GetLocalApiUrl("127.0.0.1", "http",
|
||||
_configurationManager.GetNetworkConfiguration().InternalHttpPort).TrimEnd('/') + "/");
|
||||
}
|
||||
@@ -15,28 +15,23 @@ public sealed record ItemsProxyRequest(
|
||||
|
||||
public static class ItemsProxyRequestBuilder
|
||||
{
|
||||
public static ItemsProxyRequest? Build(HttpRequest request, string rawUrl, string token, string userId, bool multilangEnabled)
|
||||
private const string BrowseFields = "PrimaryImageAspectRatio,MediaSourceCount,SortName,Overview,Genres,GenreItems";
|
||||
public static ItemsProxyRequest? Build(HttpRequest request, string rawUrl, string userId, bool multilangEnabled)
|
||||
{
|
||||
var baseUri = $"{request.Scheme}://{request.Host}{request.PathBase}";
|
||||
var baseAddress = new Uri(baseUri);
|
||||
var uri = new Uri(baseAddress, rawUrl.StartsWith('/') ? rawUrl : "/" + rawUrl);
|
||||
if ((rawUrl.StartsWith("http://", StringComparison.OrdinalIgnoreCase) ||
|
||||
rawUrl.StartsWith("https://", StringComparison.OrdinalIgnoreCase)) &&
|
||||
Uri.TryCreate(rawUrl, UriKind.Absolute, out var absolute))
|
||||
{
|
||||
if (!absolute.Scheme.Equals(Uri.UriSchemeHttp, StringComparison.OrdinalIgnoreCase) &&
|
||||
!absolute.Scheme.Equals(Uri.UriSchemeHttps, StringComparison.OrdinalIgnoreCase))
|
||||
return null;
|
||||
var baseAddress = new Uri($"{request.Scheme}://{request.Host}{request.PathBase}/");
|
||||
if (rawUrl.Contains('\\') || !Uri.TryCreate(baseAddress, rawUrl, out var uri) ||
|
||||
uri.Scheme != baseAddress.Scheme || uri.Authority != baseAddress.Authority ||
|
||||
uri.UserInfo.Length > 0 || uri.Fragment.Length > 0)
|
||||
return null;
|
||||
|
||||
if (!absolute.Host.Equals(baseAddress.Host, StringComparison.OrdinalIgnoreCase) ||
|
||||
absolute.Port != baseAddress.Port)
|
||||
return null;
|
||||
|
||||
uri = absolute;
|
||||
}
|
||||
|
||||
var path = NormalizeUpstreamPath(uri.AbsolutePath, userId);
|
||||
var builder = new UriBuilder(uri) { Path = path };
|
||||
var pathBase = request.PathBase.Value ?? string.Empty;
|
||||
if (!uri.AbsolutePath.StartsWith(pathBase + "/", StringComparison.OrdinalIgnoreCase))
|
||||
return null;
|
||||
var route = uri.AbsolutePath[pathBase.Length..];
|
||||
if (!IsSupportedRoute(route))
|
||||
return null;
|
||||
var path = NormalizeUpstreamPath(route, userId);
|
||||
var builder = new UriBuilder(uri) { Path = pathBase + path };
|
||||
var query = QueryHelpers.ParseQuery(builder.Query);
|
||||
var rawControls = new ItemsProxyControls(
|
||||
GetQueryString(query, "SortBy"),
|
||||
@@ -48,36 +43,25 @@ public static class ItemsProxyRequestBuilder
|
||||
GetQueryString(query, "GenreIds"));
|
||||
var hasLocalGenreFilter = multilangEnabled && ParseLocalGenreIds(rawControls.GenreIds).Length > 0;
|
||||
var useLocalControls = multilangEnabled && ShouldUseLocalControls(path, query, hasLocalGenreFilter);
|
||||
if (useLocalControls)
|
||||
query["Fields"] = string.Join(',', (BrowseFields + "," + GetQueryString(query, "Fields"))
|
||||
.Split(',', StringSplitOptions.TrimEntries | StringSplitOptions.RemoveEmptyEntries)
|
||||
.Distinct(StringComparer.OrdinalIgnoreCase).OrderBy(field => field, StringComparer.OrdinalIgnoreCase));
|
||||
var controls = useLocalControls
|
||||
? rawControls
|
||||
: new ItemsProxyControls(string.Empty, string.Empty, string.Empty, 0, 0, rawControls.ClientLocale, rawControls.GenreIds);
|
||||
var localCacheKey = string.Join('|',
|
||||
controls.SortBy,
|
||||
controls.SortOrder,
|
||||
controls.NameStartsWith,
|
||||
controls.StartIndex.ToString(CultureInfo.InvariantCulture),
|
||||
controls.Limit.ToString(CultureInfo.InvariantCulture),
|
||||
controls.ClientLocale,
|
||||
controls.GenreIds);
|
||||
: new ItemsProxyControls(string.Empty, string.Empty, string.Empty, 0, 0, rawControls.ClientLocale, rawControls.GenreIds, ApplyLocalPaging: false);
|
||||
var pairs = query
|
||||
.Where(kv => !IsLocalProxyQuery(kv.Key, hasLocalGenreFilter, useLocalControls))
|
||||
.SelectMany(kv => kv.Value.Select(v => KeyValuePair.Create<string, string?>(kv.Key, v ?? string.Empty)))
|
||||
.ToList();
|
||||
pairs.Add(KeyValuePair.Create<string, string?>("userId", userId));
|
||||
if (hasLocalGenreFilter)
|
||||
{
|
||||
pairs.Add(KeyValuePair.Create<string, string?>("EnableImageTypes", "Primary,Backdrop,Banner,Thumb"));
|
||||
pairs.Add(KeyValuePair.Create<string, string?>("Fields", "Genres,GenreItems"));
|
||||
}
|
||||
|
||||
var cacheQuery = QueryHelpers.AddQueryString(string.Empty, pairs).TrimStart('?');
|
||||
pairs.Add(KeyValuePair.Create<string, string?>("api_key", token));
|
||||
builder.Query = QueryHelpers.AddQueryString(string.Empty, pairs).TrimStart('?');
|
||||
var cacheQuery = QueryHelpers.AddQueryString(string.Empty, pairs.OrderBy(p => p.Key, StringComparer.OrdinalIgnoreCase)).TrimStart('?');
|
||||
builder.Query = cacheQuery;
|
||||
var normalizedForCache = builder.Path + (cacheQuery.Length > 0 ? "?" + cacheQuery : string.Empty);
|
||||
return new ItemsProxyRequest(
|
||||
builder.Uri,
|
||||
controls,
|
||||
$"{userId}|{normalizedForCache}|{localCacheKey}",
|
||||
$"{userId}|{normalizedForCache}",
|
||||
normalizedForCache,
|
||||
IsGenresPath(path),
|
||||
GenreMediaFromQuery(query));
|
||||
@@ -92,6 +76,22 @@ public static class ItemsProxyRequestBuilder
|
||||
.Distinct()
|
||||
.ToArray();
|
||||
|
||||
private static bool IsSupportedRoute(string path)
|
||||
{
|
||||
var parts = path.ToLowerInvariant().Split('/', StringSplitOptions.RemoveEmptyEntries);
|
||||
if (parts.Length >= 3 && parts[0] == "users" && Guid.TryParse(parts[1], out _))
|
||||
parts = parts[2..];
|
||||
return parts switch
|
||||
{
|
||||
["items"] or ["genres"] => true,
|
||||
["items", "latest" or "resume" or "nextup"] => true,
|
||||
["items" or "genres", var id] => Guid.TryParse(id, out _),
|
||||
["shows", "nextup"] => true,
|
||||
["shows", var id, "seasons" or "episodes"] => Guid.TryParse(id, out _),
|
||||
_ => false
|
||||
};
|
||||
}
|
||||
|
||||
private static bool ShouldUseLocalControls(
|
||||
string normalizedPath,
|
||||
IReadOnlyDictionary<string, StringValues> query,
|
||||
@@ -136,17 +136,14 @@ public static class ItemsProxyRequestBuilder
|
||||
key.Equals("Limit", StringComparison.OrdinalIgnoreCase) ||
|
||||
key.Equals("NameStartsWith", StringComparison.OrdinalIgnoreCase))) ||
|
||||
(hasGenreFilter && (key.Equals("GenreIds", StringComparison.OrdinalIgnoreCase) ||
|
||||
key.Equals("EnableTotalRecordCount", StringComparison.OrdinalIgnoreCase) ||
|
||||
key.Equals("EnableImageTypes", StringComparison.OrdinalIgnoreCase) ||
|
||||
key.Equals("Fields", StringComparison.OrdinalIgnoreCase)));
|
||||
key.Equals("EnableTotalRecordCount", StringComparison.OrdinalIgnoreCase)));
|
||||
|
||||
private static string NormalizeUpstreamPath(string path, string userId)
|
||||
{
|
||||
var segments = path.Split('/', StringSplitOptions.RemoveEmptyEntries).ToList();
|
||||
if (segments.Count >= 2 &&
|
||||
segments[0].Equals("Users", StringComparison.OrdinalIgnoreCase) &&
|
||||
segments[1].Length == 32 &&
|
||||
segments[1].All(Uri.IsHexDigit))
|
||||
Guid.TryParse(segments[1], out _))
|
||||
{
|
||||
segments[1] = userId;
|
||||
return "/" + string.Join('/', segments);
|
||||
|
||||
@@ -12,7 +12,8 @@ public sealed record ItemsProxyControls(
|
||||
int StartIndex,
|
||||
int Limit,
|
||||
string ClientLocale,
|
||||
string GenreIds);
|
||||
string GenreIds,
|
||||
bool ApplyLocalPaging = true);
|
||||
|
||||
public static class ItemsProxySorting
|
||||
{
|
||||
@@ -33,6 +34,8 @@ public static class ItemsProxySorting
|
||||
|
||||
public static void Apply(JsonNode root, ItemsProxyControls controls, CultureInfo culture, Func<JsonObject, string[]> titleArticlesForItem)
|
||||
{
|
||||
if (!controls.ApplyLocalPaging)
|
||||
return;
|
||||
if (!TryGetItemsArray(root, out var itemsArray))
|
||||
return;
|
||||
|
||||
|
||||
@@ -22,6 +22,9 @@ public readonly record struct ItemsProxyCategoryMatch(
|
||||
UserCategoryRule? Effective,
|
||||
bool DuplicateLabelResolved);
|
||||
|
||||
public sealed record ItemsProxyResolutionAttempt(
|
||||
string Action, string Source, string LookupKey, bool HasValue, bool Chosen, string? Value, string Reason);
|
||||
|
||||
public sealed class ItemsProxyTransformer
|
||||
{
|
||||
private readonly TranslationStore _store;
|
||||
@@ -157,8 +160,6 @@ public sealed class ItemsProxyTransformer
|
||||
{
|
||||
foreach (var action in GetAllActionTokens(category.FieldActionLists))
|
||||
AddLanguageAction(langs, action);
|
||||
foreach (var action in (category.FieldActions ?? []).Values)
|
||||
AddLanguageAction(langs, action);
|
||||
}
|
||||
|
||||
foreach (var action in GetAllActionTokens(rules.FallbackFieldActions))
|
||||
@@ -184,29 +185,28 @@ public sealed class ItemsProxyTransformer
|
||||
}
|
||||
|
||||
public FactsData GetClassificationFacts(UserRulesDocument rules, FactsData facts)
|
||||
=> GetClassificationFacts(rules, new Dictionary<string, FactsData> { [facts.ItemId] = facts })[facts.ItemId];
|
||||
|
||||
private IReadOnlyDictionary<string, FactsData> GetClassificationFacts(UserRulesDocument rules, IReadOnlyDictionary<string, FactsData> facts)
|
||||
{
|
||||
if (rules.TrustTmdbCollections ||
|
||||
!facts.Kind.Equals("collection", StringComparison.OrdinalIgnoreCase) ||
|
||||
!Guid.TryParseExact(facts.ItemId, "N", out var itemGuid))
|
||||
{
|
||||
if (rules.TrustTmdbCollections)
|
||||
return facts;
|
||||
}
|
||||
var children = facts.Values.Where(fact => fact.Kind == "collection")
|
||||
.ToDictionary(fact => fact.ItemId, fact =>
|
||||
(_libraryManager.GetItemById(Guid.Parse(fact.ItemId)) as Folder)?.GetLinkedChildren()
|
||||
.OfType<MediaBrowser.Controller.Entities.Movies.Movie>()
|
||||
.Select(child => TranslationStore.ToItemId32(child.Id)).ToArray() ?? []);
|
||||
var childFacts = _store.GetFactsForItems(children.Values.SelectMany(ids => ids));
|
||||
var result = new Dictionary<string, FactsData>(facts, StringComparer.OrdinalIgnoreCase);
|
||||
foreach (var (id, ids) in children)
|
||||
result[id] = AggregateCollectionFacts(facts[id], ids.Where(childFacts.ContainsKey).Select(id => childFacts[id]).ToArray());
|
||||
return result;
|
||||
}
|
||||
|
||||
var item = _libraryManager.GetItemById(itemGuid);
|
||||
var children = (item as Folder)?.GetLinkedChildren()
|
||||
.Where(child => child.GetType().Name.Equals("Movie", StringComparison.OrdinalIgnoreCase))
|
||||
.ToArray() ?? [];
|
||||
|
||||
var childIds = children.Select(child => TranslationStore.ToItemId32(child.Id)).ToArray();
|
||||
if (childIds.Length == 0)
|
||||
return facts;
|
||||
|
||||
var childFacts = _store.GetFactsForItems(childIds).Values
|
||||
.Where(child => child.Kind.Equals("movie", StringComparison.OrdinalIgnoreCase))
|
||||
.ToArray();
|
||||
public static FactsData AggregateCollectionFacts(FactsData facts, FactsData[] childFacts)
|
||||
{
|
||||
if (childFacts.Length == 0)
|
||||
return facts;
|
||||
|
||||
return facts with
|
||||
{
|
||||
OriginalLanguage = SharedSingle(childFacts.Select(child => child.OriginalLanguage)),
|
||||
@@ -228,74 +228,61 @@ public sealed class ItemsProxyTransformer
|
||||
if (actions is not null && actions.TryGetValue(field, out var list))
|
||||
return list;
|
||||
|
||||
return category is not null && category.FieldActions is not null
|
||||
? LegacyActionToList(field, category.FieldActions)
|
||||
: [JellyfinAction];
|
||||
return [JellyfinAction];
|
||||
}
|
||||
|
||||
public static ItemsProxyResolvedText ResolveField(
|
||||
string field,
|
||||
IReadOnlyList<string> actions,
|
||||
FactsData facts,
|
||||
Dictionary<string, Dictionary<string, string>>? byLang)
|
||||
string field, IReadOnlyList<string> actions, FactsData facts,
|
||||
Dictionary<string, Dictionary<string, string>>? byLang,
|
||||
Action<ItemsProxyResolutionAttempt>? trace = null)
|
||||
{
|
||||
foreach (var action in actions)
|
||||
{
|
||||
if (action.Equals(JellyfinAction, StringComparison.OrdinalIgnoreCase))
|
||||
return new ItemsProxyResolvedText(false, null);
|
||||
if (field.Equals(TitleField, StringComparison.OrdinalIgnoreCase) &&
|
||||
action.Equals(OriginalAction, StringComparison.OrdinalIgnoreCase) &&
|
||||
!string.IsNullOrWhiteSpace(facts.OriginalTitle))
|
||||
return new ItemsProxyResolvedText(true, facts.OriginalTitle, facts.OriginalLanguage);
|
||||
if (action.Equals(OriginalAction, StringComparison.OrdinalIgnoreCase))
|
||||
{
|
||||
var originalValue = GetTranslatedField(byLang, OriginalAction, field);
|
||||
if (!string.IsNullOrWhiteSpace(originalValue))
|
||||
return new ItemsProxyResolvedText(true, originalValue, facts.OriginalLanguage);
|
||||
continue;
|
||||
trace?.Invoke(new(action, JellyfinAction, "", true, true, null, "Use Jellyfin value"));
|
||||
return new(false, null);
|
||||
}
|
||||
|
||||
if (!action.StartsWith(LanguagePrefix, StringComparison.OrdinalIgnoreCase))
|
||||
var original = action.Equals(OriginalAction, StringComparison.OrdinalIgnoreCase);
|
||||
if (!original && !action.StartsWith(LanguagePrefix, StringComparison.OrdinalIgnoreCase))
|
||||
continue;
|
||||
|
||||
var value = GetTranslatedField(byLang, action[LanguagePrefix.Length..], field);
|
||||
if (!string.IsNullOrWhiteSpace(value))
|
||||
return new ItemsProxyResolvedText(true, value, action[LanguagePrefix.Length..]);
|
||||
var lang = original ? OriginalAction : action[LanguagePrefix.Length..];
|
||||
var originalTitle = original && field == TitleField && !string.IsNullOrWhiteSpace(facts.OriginalTitle);
|
||||
var value = originalTitle ? facts.OriginalTitle : GetTranslatedField(byLang, lang, field);
|
||||
var found = !string.IsNullOrWhiteSpace(value);
|
||||
trace?.Invoke(new(action, originalTitle ? "OriginalTitle" : "Translation",
|
||||
originalTitle ? "facts.original_title" : lang + "/" + field,
|
||||
found, found, value, found ? "Value found" : "Value missing or empty"));
|
||||
if (found)
|
||||
return new(true, value, original ? facts.OriginalLanguage : lang);
|
||||
}
|
||||
|
||||
return field.Equals(TitleField, StringComparison.OrdinalIgnoreCase)
|
||||
? new ItemsProxyResolvedText(false, null)
|
||||
: new ItemsProxyResolvedText(true, string.Empty);
|
||||
return field == TitleField ? new(false, null) : new(true, string.Empty);
|
||||
}
|
||||
|
||||
public static ItemsProxyResolvedAsset ResolveAsset(
|
||||
string kind,
|
||||
IReadOnlyList<string> actions,
|
||||
Dictionary<string, Dictionary<string, string>>? byKind)
|
||||
string kind, IReadOnlyList<string> actions,
|
||||
Dictionary<string, Dictionary<string, string>>? byKind,
|
||||
Action<ItemsProxyResolutionAttempt>? trace = null)
|
||||
{
|
||||
foreach (var action in actions)
|
||||
{
|
||||
if (action.Equals(JellyfinAction, StringComparison.OrdinalIgnoreCase))
|
||||
return new ItemsProxyResolvedAsset(false, null);
|
||||
if (action.Equals(OriginalAction, StringComparison.OrdinalIgnoreCase))
|
||||
{
|
||||
var originalValue = GetAsset(byKind, kind, OriginalAction);
|
||||
if (!string.IsNullOrWhiteSpace(originalValue))
|
||||
return new ItemsProxyResolvedAsset(true, originalValue);
|
||||
continue;
|
||||
trace?.Invoke(new(action, JellyfinAction, "", true, true, null, "Use Jellyfin image"));
|
||||
return new(false, null);
|
||||
}
|
||||
|
||||
if (!action.StartsWith(LanguagePrefix, StringComparison.OrdinalIgnoreCase))
|
||||
var original = action.Equals(OriginalAction, StringComparison.OrdinalIgnoreCase);
|
||||
if (!original && !action.StartsWith(LanguagePrefix, StringComparison.OrdinalIgnoreCase))
|
||||
continue;
|
||||
|
||||
var value = GetAsset(byKind, kind, action[LanguagePrefix.Length..]);
|
||||
if (!string.IsNullOrWhiteSpace(value))
|
||||
return new ItemsProxyResolvedAsset(true, value);
|
||||
var lang = original ? OriginalAction : action[LanguagePrefix.Length..];
|
||||
var value = GetAsset(byKind, kind, lang);
|
||||
var found = !string.IsNullOrWhiteSpace(value);
|
||||
trace?.Invoke(new(action, "Asset", kind + "/" + lang, found, found, value,
|
||||
found ? "Asset found" : "Asset missing"));
|
||||
if (found)
|
||||
return new(true, value);
|
||||
}
|
||||
|
||||
return kind.Equals(PosterKind, StringComparison.OrdinalIgnoreCase)
|
||||
? new ItemsProxyResolvedAsset(false, null)
|
||||
: new ItemsProxyResolvedAsset(true, string.Empty);
|
||||
return kind == PosterKind ? new(false, null) : new(true, string.Empty);
|
||||
}
|
||||
|
||||
public static string? GetTranslatedField(
|
||||
@@ -373,6 +360,7 @@ public sealed class ItemsProxyTransformer
|
||||
var langs = GetNeededLanguages(rules);
|
||||
var translations = _store.GetTranslations(ids, langs);
|
||||
var assets = _store.GetAssets(ids, langs);
|
||||
var classification = GetClassificationFacts(rules, factsByItem);
|
||||
var titleLanguages = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
|
||||
var movieGenreNames = _store.GetGenreNames("movie", clientLocale);
|
||||
var tvGenreNames = _store.GetGenreNames("tv", clientLocale);
|
||||
@@ -384,7 +372,7 @@ public sealed class ItemsProxyTransformer
|
||||
continue;
|
||||
|
||||
translations.TryGetValue(itemId, out var byLang);
|
||||
var classificationFacts = GetClassificationFacts(rules, facts);
|
||||
var classificationFacts = classification[itemId];
|
||||
var category = PickCategoryMatch(rules, classificationFacts).Effective;
|
||||
|
||||
var title = ResolveField(TitleField, GetActionList(rules, category, TitleField), facts, byLang);
|
||||
@@ -583,15 +571,6 @@ public sealed class ItemsProxyTransformer
|
||||
langs.Add(action[LanguagePrefix.Length..]);
|
||||
}
|
||||
|
||||
private static string[] LegacyActionToList(string field, IReadOnlyDictionary<string, string>? legacyActions)
|
||||
{
|
||||
if (legacyActions is null || !legacyActions.TryGetValue(field, out var action))
|
||||
return [JellyfinAction];
|
||||
if (string.IsNullOrWhiteSpace(action) || action.Equals(FallbackAction, StringComparison.OrdinalIgnoreCase))
|
||||
return [JellyfinAction];
|
||||
return [action];
|
||||
}
|
||||
|
||||
private static string SharedSingle(IEnumerable<string> values)
|
||||
{
|
||||
var unique = values
|
||||
|
||||
@@ -32,8 +32,9 @@ public sealed class FanartClient
|
||||
var url = $"https://webservice.fanart.tv/v3/movies/{Uri.EscapeDataString(tmdbId)}?api_key={Uri.EscapeDataString(apiKey)}";
|
||||
using var request = new HttpRequestMessage(HttpMethod.Get, url);
|
||||
using var response = await ProviderHttp.SendWithRetryAsync(http, request, cancellationToken).ConfigureAwait(false);
|
||||
if (!response.IsSuccessStatusCode)
|
||||
if (response.StatusCode == System.Net.HttpStatusCode.NotFound)
|
||||
return null;
|
||||
response.EnsureSuccessStatusCode();
|
||||
|
||||
await using var stream = await response.Content.ReadAsStreamAsync(cancellationToken).ConfigureAwait(false);
|
||||
using var doc = await System.Text.Json.JsonDocument.ParseAsync(stream, cancellationToken: cancellationToken).ConfigureAwait(false);
|
||||
|
||||
@@ -6,6 +6,7 @@ public sealed class FetchRateLimiter
|
||||
{
|
||||
private readonly TimeSpan _minimumSpacing;
|
||||
private long _lastStartTicks;
|
||||
private readonly SemaphoreSlim _admission = new(1, 1);
|
||||
|
||||
public FetchRateLimiter(TimeSpan minimumSpacing)
|
||||
{
|
||||
@@ -14,15 +15,18 @@ public sealed class FetchRateLimiter
|
||||
|
||||
public async Task WaitAsync(CancellationToken cancellationToken)
|
||||
{
|
||||
var last = Interlocked.Read(ref _lastStartTicks);
|
||||
if (last != 0)
|
||||
await _admission.WaitAsync(cancellationToken).ConfigureAwait(false);
|
||||
try
|
||||
{
|
||||
var elapsed = TimeSpan.FromSeconds((Stopwatch.GetTimestamp() - last) / (double)Stopwatch.Frequency);
|
||||
var remaining = _minimumSpacing - elapsed;
|
||||
if (remaining > TimeSpan.Zero)
|
||||
await Task.Delay(remaining, cancellationToken).ConfigureAwait(false);
|
||||
}
|
||||
if (_lastStartTicks != 0)
|
||||
{
|
||||
var remaining = _minimumSpacing - Stopwatch.GetElapsedTime(_lastStartTicks);
|
||||
if (remaining > TimeSpan.Zero)
|
||||
await Task.Delay(remaining, cancellationToken).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
Interlocked.Exchange(ref _lastStartTicks, Stopwatch.GetTimestamp());
|
||||
_lastStartTicks = Stopwatch.GetTimestamp();
|
||||
}
|
||||
finally { _admission.Release(); }
|
||||
}
|
||||
}
|
||||
@@ -39,29 +39,33 @@ public static class ProviderHttp
|
||||
public static async Task<HttpResponseMessage> SendWithRetryAsync(
|
||||
HttpClient http,
|
||||
HttpRequestMessage request,
|
||||
CancellationToken cancellationToken)
|
||||
CancellationToken cancellationToken,
|
||||
FetchRateLimiter? rateLimiter = null)
|
||||
{
|
||||
const int maxAttempts = 3;
|
||||
for (var attempt = 1; attempt <= maxAttempts; attempt++)
|
||||
{
|
||||
try
|
||||
{
|
||||
var response = await http.SendAsync(Clone(request), cancellationToken).ConfigureAwait(false);
|
||||
if (rateLimiter is not null)
|
||||
await rateLimiter.WaitAsync(cancellationToken).ConfigureAwait(false);
|
||||
using var attemptRequest = Clone(request);
|
||||
var response = await http.SendAsync(attemptRequest, cancellationToken).ConfigureAwait(false);
|
||||
Record(request, "HTTP " + (int)response.StatusCode, attempt);
|
||||
if (response.IsSuccessStatusCode || Classify(response.StatusCode) == ProviderFailureKind.Terminal || attempt == maxAttempts)
|
||||
{
|
||||
Record(request, "HTTP " + (int)response.StatusCode, attempt);
|
||||
return response;
|
||||
}
|
||||
|
||||
var delay = GetRetryDelay(response, attempt);
|
||||
response.Dispose();
|
||||
await Task.Delay(delay, cancellationToken).ConfigureAwait(false);
|
||||
await Task.Delay(delay < TimeSpan.Zero ? TimeSpan.Zero : delay, cancellationToken).ConfigureAwait(false);
|
||||
}
|
||||
catch (Exception ex)
|
||||
catch (Exception ex) when (!cancellationToken.IsCancellationRequested && ex is HttpRequestException or OperationCanceledException)
|
||||
{
|
||||
Record(request, ex.GetType().Name, attempt);
|
||||
if (attempt >= maxAttempts)
|
||||
{
|
||||
Record(request, ex.GetType().Name, attempt);
|
||||
throw;
|
||||
}
|
||||
|
||||
|
||||
@@ -23,11 +23,10 @@ public sealed class TmdbClient
|
||||
if (string.IsNullOrWhiteSpace(apiKey))
|
||||
throw new InvalidOperationException("TMDb API key is required.");
|
||||
|
||||
await rateLimiter.WaitAsync(cancellationToken).ConfigureAwait(false);
|
||||
var http = _httpClientFactory.CreateClient();
|
||||
var url = $"https://api.themoviedb.org/3/{BuildPath(item)}?api_key={Uri.EscapeDataString(apiKey)}&language={Uri.EscapeDataString(language)}";
|
||||
using var request = new HttpRequestMessage(HttpMethod.Get, url);
|
||||
using var response = await ProviderHttp.SendWithRetryAsync(http, request, cancellationToken).ConfigureAwait(false);
|
||||
using var response = await ProviderHttp.SendWithRetryAsync(http, request, cancellationToken, rateLimiter).ConfigureAwait(false);
|
||||
if (response.StatusCode == HttpStatusCode.NotFound)
|
||||
return null;
|
||||
response.EnsureSuccessStatusCode();
|
||||
@@ -58,11 +57,10 @@ public sealed class TmdbClient
|
||||
if (item.Kind is "tvepisode")
|
||||
return new TmdbImages([], [], []);
|
||||
|
||||
await rateLimiter.WaitAsync(cancellationToken).ConfigureAwait(false);
|
||||
var http = _httpClientFactory.CreateClient();
|
||||
var url = $"https://api.themoviedb.org/3/{BuildPath(item)}/images?api_key={Uri.EscapeDataString(apiKey)}";
|
||||
using var request = new HttpRequestMessage(HttpMethod.Get, url);
|
||||
using var response = await ProviderHttp.SendWithRetryAsync(http, request, cancellationToken).ConfigureAwait(false);
|
||||
using var response = await ProviderHttp.SendWithRetryAsync(http, request, cancellationToken, rateLimiter).ConfigureAwait(false);
|
||||
if (response.StatusCode == HttpStatusCode.NotFound)
|
||||
return null;
|
||||
response.EnsureSuccessStatusCode();
|
||||
|
||||
@@ -0,0 +1,220 @@
|
||||
using Jellyfin.Plugin.Multilang.Configuration;
|
||||
using Jellyfin.Plugin.Multilang.Data;
|
||||
using Jellyfin.Plugin.Multilang.Services.Assets;
|
||||
using Jellyfin.Plugin.Multilang.Services.Providers;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using static Jellyfin.Plugin.Multilang.MultilangConstants;
|
||||
|
||||
namespace Jellyfin.Plugin.Multilang.Services.Refresh;
|
||||
|
||||
public sealed class ItemFetcher(
|
||||
TranslationStore store, TmdbClient tmdb, FanartClient fanart,
|
||||
AssetStorageService storage, ILogger<ItemFetcher> logger)
|
||||
{
|
||||
private readonly FetchRateLimiter _limiter = new(TimeSpan.FromMilliseconds(250));
|
||||
|
||||
private static string Scope(RefreshItemInfo item)
|
||||
=> $"{item.Kind}:{item.TmdbId}:{item.SeasonNumber}:{item.EpisodeNumber}";
|
||||
|
||||
public static bool NeedsFetch(FetchState? state, string scope, bool dataMissing, bool full, long cutoff)
|
||||
=> full || state is null || state.Scope != scope ||
|
||||
(dataMissing && (state.Complete || state.CheckedAt <= cutoff)) ||
|
||||
(!state.Complete && state.CheckedAt <= cutoff);
|
||||
|
||||
public bool NeedsLocalWork(string itemId, PluginConfiguration cfg)
|
||||
=> cfg.AssetStorageMode == "local" && store.GetStoredAssets(itemId).Any(asset => asset.SourceUrl.Length > 0 &&
|
||||
(!store.TryNormalizeLocalAssetPath(asset.Path, out var path) || !File.Exists(path)));
|
||||
|
||||
public bool NeedsRefresh(RefreshItemInfo item, PluginConfiguration cfg)
|
||||
{
|
||||
var states = store.GetFetchStates(item.ItemId);
|
||||
var languages = Languages(cfg);
|
||||
var texts = store.GetTranslations([item.ItemId], languages.Append(OriginalAction)).GetValueOrDefault(item.ItemId) ?? [];
|
||||
var cutoff = MissingCutoff(cfg);
|
||||
var original = store.GetFacts(item.ItemId)?.OriginalLanguage ?? "";
|
||||
foreach (var lang in languages)
|
||||
if (NeedsMetadata(item, lang, lang, texts, states, false, cutoff))
|
||||
return true;
|
||||
if (original.Length > 0 && !languages.Any(lang => SameLanguage(lang, original)) &&
|
||||
NeedsMetadata(item, OriginalAction, original, texts, states, false, cutoff))
|
||||
return true;
|
||||
|
||||
if (original.Length > 0 && languages.Any(lang => SameLanguage(lang, original)) && !texts.ContainsKey(OriginalAction))
|
||||
return true;
|
||||
var assets = store.GetStoredAssets(item.ItemId);
|
||||
if (cfg.AssetStorageMode == "local" && assets.Any(asset => asset.SourceUrl.Length > 0 &&
|
||||
(!store.TryNormalizeLocalAssetPath(asset.Path, out var path) || !File.Exists(path))))
|
||||
return true;
|
||||
var providers = Providers(item, cfg);
|
||||
var scope = ArtworkScope(item, languages, original, providers);
|
||||
return providers.Any(provider => NeedsFetch(states.GetValueOrDefault("artwork:" + provider), scope,
|
||||
ArtworkMissing(assets, languages.Append(OriginalAction).Where(lang => lang != OriginalAction || original.Length > 0), providers, provider), false, cutoff));
|
||||
}
|
||||
|
||||
public async Task<bool> RefreshAsync(RefreshItemInfo item, PluginConfiguration cfg, RefreshJobType job, CancellationToken ct)
|
||||
{
|
||||
var full = job == RefreshJobType.Full;
|
||||
var localOnly = job == RefreshJobType.Aggregate;
|
||||
var states = store.GetFetchStates(item.ItemId);
|
||||
var languages = Languages(cfg);
|
||||
var texts = store.GetTranslations([item.ItemId], languages.Append(OriginalAction)).GetValueOrDefault(item.ItemId) ?? [];
|
||||
var cutoff = MissingCutoff(cfg);
|
||||
var fetched = 0;
|
||||
async Task FetchMetadata(string storedLanguage, string requestedLanguage)
|
||||
{
|
||||
if (localOnly || !NeedsMetadata(item, storedLanguage, requestedLanguage, texts, states, full, cutoff))
|
||||
return;
|
||||
var metadata = await tmdb.FetchMetadataAsync(item, requestedLanguage, cfg.TmdbApiKey, _limiter, ct).ConfigureAwait(false);
|
||||
var complete = metadata is not null && metadata.Title.Length > 0 && metadata.Overview.Length > 0 &&
|
||||
(item.Kind != "movie" || metadata.Tagline.Length > 0);
|
||||
store.SaveMetadata(item, storedLanguage, metadata,
|
||||
new(Scope(item) + ":" + requestedLanguage, TranslationStore.NowUnixUtc(), complete), full,
|
||||
item.Kind is "movie" or "tv" || storedLanguage == languages[0]);
|
||||
if (metadata is not null)
|
||||
Interlocked.Increment(ref fetched);
|
||||
if (cfg.EnableLogging)
|
||||
logger.LogInformation("TMDb metadata {Result} item={ItemId} lang={Language} storedAs={StoredLanguage}",
|
||||
metadata is null ? "404" : "fetched", item.ItemId, requestedLanguage, storedLanguage);
|
||||
}
|
||||
|
||||
await Parallel.ForEachAsync(languages, new ParallelOptions { MaxDegreeOfParallelism = 4, CancellationToken = ct },
|
||||
async (lang, _) => await FetchMetadata(lang, lang).ConfigureAwait(false)).ConfigureAwait(false);
|
||||
var original = store.GetFacts(item.ItemId)?.OriginalLanguage ?? "";
|
||||
if (original.Length > 0)
|
||||
{
|
||||
var configured = languages.FirstOrDefault(lang => SameLanguage(lang, original));
|
||||
if (configured is not null)
|
||||
store.CopyOriginalTranslations(item.ItemId, configured);
|
||||
else
|
||||
await FetchMetadata(OriginalAction, original).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
var artworkFetched = await RefreshArtwork(item, cfg, languages, original, states, full, localOnly, cutoff, ct).ConfigureAwait(false);
|
||||
if (!localOnly)
|
||||
store.MarkFactsChecked(item, TranslationStore.NowUnixUtc(), full ? TranslationStore.NowUnixUtc() : 0);
|
||||
return fetched > 0 || artworkFetched;
|
||||
}
|
||||
|
||||
private static bool NeedsMetadata(RefreshItemInfo item, string storedLanguage, string requestedLanguage,
|
||||
Dictionary<string, Dictionary<string, string>> texts, Dictionary<string, FetchState> states, bool full, long cutoff)
|
||||
{
|
||||
var fields = texts.GetValueOrDefault(storedLanguage);
|
||||
var missing = fields is null || TextFields.Any(field => !fields.ContainsKey(field) ||
|
||||
((field != TaglineField || item.Kind == "movie") && string.IsNullOrWhiteSpace(fields[field])));
|
||||
return NeedsFetch(states.GetValueOrDefault("metadata:" + storedLanguage),
|
||||
Scope(item) + ":" + requestedLanguage, missing, full, cutoff);
|
||||
}
|
||||
|
||||
private async Task<bool> RefreshArtwork(RefreshItemInfo item, PluginConfiguration cfg, string[] languages,
|
||||
string original, Dictionary<string, FetchState> states, bool full, bool localOnly, long cutoff, CancellationToken ct)
|
||||
{
|
||||
if (localOnly)
|
||||
{
|
||||
if (cfg.AssetStorageMode != "local")
|
||||
return false;
|
||||
var assets = store.GetStoredAssets(item.ItemId);
|
||||
var repaired = new List<StoredAsset>();
|
||||
foreach (var asset in assets)
|
||||
{
|
||||
var path = asset.SourceUrl.Length == 0 ? asset.Path
|
||||
: await storage.StoreAsync(item.ItemId, asset.SourceUrl, true, ct).ConfigureAwait(false);
|
||||
repaired.Add(asset with { Path = path! });
|
||||
}
|
||||
store.SaveArtwork(item.ItemId, repaired, new Dictionary<string, FetchState>());
|
||||
return true;
|
||||
}
|
||||
var providers = Providers(item, cfg);
|
||||
var priority = providers.Select((provider, index) => (provider, index)).ToDictionary(p => p.provider, p => p.index);
|
||||
var wanted = languages.ToDictionary(lang => lang, BaseLanguage, StringComparer.OrdinalIgnoreCase);
|
||||
if (original.Length > 0)
|
||||
wanted[OriginalAction] = BaseLanguage(original);
|
||||
var previous = store.GetStoredAssets(item.ItemId);
|
||||
var selected = previous.Where(asset => wanted.ContainsKey(asset.Language) && priority.ContainsKey(asset.Provider))
|
||||
.ToDictionary(asset => (asset.Language, asset.Kind));
|
||||
var updates = new Dictionary<string, FetchState>();
|
||||
var scope = ArtworkScope(item, languages, original, providers);
|
||||
foreach (var provider in providers)
|
||||
{
|
||||
var kinds = ArtworkKinds(provider);
|
||||
var keys = wanted.Keys.SelectMany(lang => kinds.Select(kind => (Language: lang, Kind: kind))).ToArray();
|
||||
var missing = keys.Any(key => !selected.TryGetValue(key, out var asset) || priority[asset.Provider] > priority[provider]);
|
||||
if (localOnly || !NeedsFetch(states.GetValueOrDefault("artwork:" + provider), scope, missing, full, cutoff))
|
||||
continue;
|
||||
|
||||
Dictionary<string, Dictionary<string, string>> images;
|
||||
if (provider == "tmdb")
|
||||
{
|
||||
var response = await tmdb.FetchImagesAsync(item, cfg.TmdbApiKey, _limiter, ct).ConfigureAwait(false);
|
||||
images = new() { [PosterKind] = response?.Posters ?? [], [LogoKind] = response?.Logos ?? [], [BackdropKind] = response?.Backdrops ?? [] };
|
||||
}
|
||||
else
|
||||
{
|
||||
var response = await fanart.FetchMovieImagesAsync(item.TmdbId, cfg.FanartApiKey, ct).ConfigureAwait(false);
|
||||
images = new() { [PosterKind] = response?.Posters ?? [], [LogoKind] = response?.Logos ?? [], [BannerKind] = response?.Banners ?? [], [ThumbKind] = response?.Thumbs ?? [] };
|
||||
}
|
||||
|
||||
var complete = true;
|
||||
foreach (var key in keys)
|
||||
{
|
||||
selected.TryGetValue(key, out var existing);
|
||||
var url = images[key.Kind].GetValueOrDefault(wanted[key.Language]);
|
||||
if (string.IsNullOrWhiteSpace(url))
|
||||
{
|
||||
complete = false;
|
||||
if (existing?.Provider == provider)
|
||||
selected.Remove(key);
|
||||
}
|
||||
else if (existing is null || priority[provider] <= priority[existing.Provider])
|
||||
{
|
||||
// Keep an existing local path until the scheduled storage-mode cleanup.
|
||||
var path = existing?.SourceUrl == url ? existing.Path : url;
|
||||
selected[key] = new(key.Language, key.Kind, path, url, provider);
|
||||
}
|
||||
}
|
||||
updates["artwork:" + provider] = new(scope, TranslationStore.NowUnixUtc(), complete);
|
||||
if (cfg.EnableLogging && cfg.VerboseLogging)
|
||||
logger.LogInformation("Artwork fetched item={ItemId} provider={Provider} languages={Languages}",
|
||||
item.ItemId, provider, string.Join(",", wanted.Keys));
|
||||
}
|
||||
|
||||
var changed = updates.Count > 0;
|
||||
if (cfg.AssetStorageMode == "local")
|
||||
{
|
||||
foreach (var key in selected.Keys.ToArray())
|
||||
{
|
||||
var asset = selected[key];
|
||||
var path = await storage.StoreAsync(item.ItemId, asset.SourceUrl, true, ct).ConfigureAwait(false);
|
||||
selected[key] = asset with { Path = path! };
|
||||
changed |= path != asset.Path;
|
||||
}
|
||||
}
|
||||
var result = selected.Values.ToArray();
|
||||
if (changed || !previous.OrderBy(a => a.Language).ThenBy(a => a.Kind).SequenceEqual(result.OrderBy(a => a.Language).ThenBy(a => a.Kind)))
|
||||
store.SaveArtwork(item.ItemId, result, updates);
|
||||
return changed;
|
||||
}
|
||||
|
||||
private static string[] ArtworkKinds(string provider)
|
||||
=> provider == "tmdb" ? [PosterKind, LogoKind, BackdropKind] : [PosterKind, LogoKind, BannerKind, ThumbKind];
|
||||
|
||||
private static bool ArtworkMissing(IEnumerable<StoredAsset> assets, IEnumerable<string> languages, string[] providers, string provider)
|
||||
{
|
||||
var available = assets.Where(asset => Array.IndexOf(providers, asset.Provider) is var rank && rank >= 0 && rank <= Array.IndexOf(providers, provider))
|
||||
.Select(asset => (asset.Language, asset.Kind)).ToHashSet();
|
||||
return languages.Any(lang => ArtworkKinds(provider).Any(kind => !available.Contains((lang, kind))));
|
||||
}
|
||||
|
||||
private static string[] Providers(RefreshItemInfo item, PluginConfiguration cfg)
|
||||
=> item.Kind == "tvepisode" ? [] : cfg.Providers.Where(p => p.ArtworkOrder >= 0)
|
||||
.OrderBy(p => p.ArtworkOrder).Select(p => p.Id.Trim().ToLowerInvariant())
|
||||
.Where(p => p == "tmdb" || (p == "fanart" && item.Kind == "movie" && !string.IsNullOrWhiteSpace(cfg.FanartApiKey))).ToArray();
|
||||
|
||||
private static string ArtworkScope(RefreshItemInfo item, string[] languages, string original, string[] providers)
|
||||
=> Scope(item) + "|" + string.Join(",", languages.Order(StringComparer.OrdinalIgnoreCase)) + "|" + original + "|" + string.Join(",", providers);
|
||||
private static long MissingCutoff(PluginConfiguration cfg)
|
||||
=> TranslationStore.NowUnixUtc() - (long)TimeSpan.FromDays(Math.Max(0, cfg.WaitDaysForMissingData)).TotalSeconds;
|
||||
private static string[] Languages(PluginConfiguration cfg)
|
||||
=> cfg.Languages.Select(lang => lang.Trim()).Where(lang => lang.Length > 0).Distinct(StringComparer.OrdinalIgnoreCase).ToArray();
|
||||
private static string BaseLanguage(string lang) => lang.Split('-')[0].ToLowerInvariant();
|
||||
private static bool SameLanguage(string left, string right) => BaseLanguage(left) == BaseLanguage(right);
|
||||
}
|
||||
@@ -3,7 +3,7 @@ using System.Diagnostics;
|
||||
|
||||
namespace Jellyfin.Plugin.Multilang.Services.Refresh;
|
||||
|
||||
public sealed class RefreshCoordinator
|
||||
public sealed class RefreshCoordinator : IDisposable
|
||||
{
|
||||
private sealed class QueueEntry
|
||||
{
|
||||
@@ -20,22 +20,23 @@ public sealed class RefreshCoordinator
|
||||
public required TaskCompletionSource<bool> Completion { get; init; }
|
||||
|
||||
public long Sequence { get; init; }
|
||||
public bool Active { get; set; }
|
||||
}
|
||||
|
||||
private readonly object _lock = new();
|
||||
private readonly Dictionary<string, QueueEntry> _entries = new(StringComparer.OrdinalIgnoreCase);
|
||||
private readonly Queue<RefreshRecentItem> _recent = new();
|
||||
private readonly SemaphoreSlim _signal = new(0, int.MaxValue);
|
||||
private readonly ItemsProxyCache _itemsProxyCache;
|
||||
private long _sequence;
|
||||
private QueueEntry? _active;
|
||||
private readonly CancellationTokenSource _stop = new();
|
||||
|
||||
public SemaphoreSlim ScanMutex { get; } = new(1, 1);
|
||||
|
||||
public RefreshCoordinator(ItemsProxyCache itemsProxyCache)
|
||||
public RefreshCoordinator(int concurrency = MultilangConstants.RefreshConcurrency)
|
||||
{
|
||||
_itemsProxyCache = itemsProxyCache;
|
||||
_ = Task.Run(WorkerLoop);
|
||||
ArgumentOutOfRangeException.ThrowIfLessThan(concurrency, 1);
|
||||
for (var i = 0; i < concurrency; i++)
|
||||
_ = Task.Run(WorkerLoop);
|
||||
}
|
||||
|
||||
public Task<bool> EnqueueAsync(
|
||||
@@ -53,6 +54,7 @@ public sealed class RefreshCoordinator
|
||||
|
||||
lock (_lock)
|
||||
{
|
||||
ObjectDisposedException.ThrowIf(_stop.IsCancellationRequested, this);
|
||||
if (_entries.TryGetValue(itemId, out var existing))
|
||||
{
|
||||
if (jobType > existing.JobType)
|
||||
@@ -64,7 +66,7 @@ public sealed class RefreshCoordinator
|
||||
if (sourceTier > existing.SourceTier)
|
||||
existing.SourceTier = sourceTier;
|
||||
|
||||
return existing.Completion.Task;
|
||||
return cancellationToken.CanBeCanceled ? existing.Completion.Task.WaitAsync(cancellationToken) : existing.Completion.Task;
|
||||
}
|
||||
|
||||
var entry = new QueueEntry
|
||||
@@ -80,7 +82,7 @@ public sealed class RefreshCoordinator
|
||||
|
||||
_entries.Add(itemId, entry);
|
||||
_signal.Release();
|
||||
return entry.Completion.Task;
|
||||
return cancellationToken.CanBeCanceled ? entry.Completion.Task.WaitAsync(cancellationToken) : entry.Completion.Task;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -88,7 +90,8 @@ public sealed class RefreshCoordinator
|
||||
{
|
||||
while (true)
|
||||
{
|
||||
await _signal.WaitAsync().ConfigureAwait(false);
|
||||
try { await _signal.WaitAsync(_stop.Token).ConfigureAwait(false); }
|
||||
catch (OperationCanceledException) { return; }
|
||||
|
||||
QueueEntry? entry;
|
||||
lock (_lock)
|
||||
@@ -102,12 +105,24 @@ public sealed class RefreshCoordinator
|
||||
var error = string.Empty;
|
||||
try
|
||||
{
|
||||
lock (_lock)
|
||||
_active = entry;
|
||||
|
||||
ok = await entry.Work(entry.JobType, CancellationToken.None).ConfigureAwait(false);
|
||||
if (ok)
|
||||
_itemsProxyCache.InvalidateItems([entry.ItemId]);
|
||||
while (true)
|
||||
{
|
||||
RefreshJobType executing;
|
||||
Func<RefreshJobType, CancellationToken, Task<bool>> work;
|
||||
lock (_lock)
|
||||
{
|
||||
executing = entry.JobType;
|
||||
work = entry.Work;
|
||||
}
|
||||
ok |= await work(executing, _stop.Token).ConfigureAwait(false);
|
||||
lock (_lock)
|
||||
{
|
||||
if (entry.JobType > executing)
|
||||
continue;
|
||||
_entries.Remove(entry.ItemId);
|
||||
break;
|
||||
}
|
||||
}
|
||||
entry.Completion.TrySetResult(ok);
|
||||
}
|
||||
catch (Exception ex)
|
||||
@@ -120,9 +135,8 @@ public sealed class RefreshCoordinator
|
||||
sw.Stop();
|
||||
lock (_lock)
|
||||
{
|
||||
if (ReferenceEquals(_active, entry))
|
||||
_active = null;
|
||||
_entries.Remove(entry.ItemId);
|
||||
if (_entries.TryGetValue(entry.ItemId, out var current) && ReferenceEquals(current, entry))
|
||||
_entries.Remove(entry.ItemId);
|
||||
_recent.Enqueue(new RefreshRecentItem(
|
||||
entry.ItemId,
|
||||
entry.SourceTier.ToString(),
|
||||
@@ -144,11 +158,14 @@ public sealed class RefreshCoordinator
|
||||
if (_entries.Count == 0)
|
||||
return null;
|
||||
|
||||
return _entries.Values
|
||||
var entry = _entries.Values
|
||||
.Where(e => !e.Active)
|
||||
.OrderByDescending(e => e.SourceTier)
|
||||
.ThenBy(e => e.WorkClass)
|
||||
.ThenBy(e => e.Sequence)
|
||||
.First();
|
||||
.FirstOrDefault();
|
||||
if (entry is not null) entry.Active = true;
|
||||
return entry;
|
||||
}
|
||||
|
||||
public RefreshQueueDiagnostics GetDiagnostics()
|
||||
@@ -156,7 +173,7 @@ public sealed class RefreshCoordinator
|
||||
lock (_lock)
|
||||
{
|
||||
var queued = _entries.Values
|
||||
.Where(e => !ReferenceEquals(e, _active))
|
||||
.Where(e => !e.Active)
|
||||
.OrderByDescending(e => e.SourceTier)
|
||||
.ThenBy(e => e.WorkClass)
|
||||
.ThenBy(e => e.Sequence)
|
||||
@@ -166,7 +183,7 @@ public sealed class RefreshCoordinator
|
||||
return new RefreshQueueDiagnostics(
|
||||
queued.Length,
|
||||
queued,
|
||||
_active is null ? null : ToDiagnostics(_active),
|
||||
_entries.Values.Where(e => e.Active).Select(ToDiagnostics).ToArray(),
|
||||
_recent.Reverse().ToArray());
|
||||
}
|
||||
}
|
||||
@@ -178,4 +195,15 @@ public sealed class RefreshCoordinator
|
||||
entry.WorkClass.ToString(),
|
||||
entry.JobType.ToString(),
|
||||
entry.Sequence);
|
||||
|
||||
public void Dispose()
|
||||
{
|
||||
_stop.Cancel();
|
||||
lock (_lock)
|
||||
{
|
||||
foreach (var entry in _entries.Values)
|
||||
entry.Completion.TrySetCanceled();
|
||||
_entries.Clear();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -53,7 +53,7 @@ public sealed record RefreshRecentItem(
|
||||
public sealed record RefreshQueueDiagnostics(
|
||||
int QueuedCount,
|
||||
RefreshQueueEntry[] Queued,
|
||||
RefreshQueueEntry? Active,
|
||||
RefreshQueueEntry[] ActiveItems,
|
||||
RefreshRecentItem[] Recent);
|
||||
|
||||
public sealed record RefreshScanDiagnostics(
|
||||
|
||||
@@ -2,7 +2,6 @@ using System.Diagnostics;
|
||||
using Jellyfin.Data.Enums;
|
||||
using Jellyfin.Plugin.Multilang.Configuration;
|
||||
using Jellyfin.Plugin.Multilang.Data;
|
||||
using Jellyfin.Plugin.Multilang.Services.Assets;
|
||||
using Jellyfin.Plugin.Multilang.Services.Providers;
|
||||
using static Jellyfin.Plugin.Multilang.MultilangConstants;
|
||||
using MediaBrowser.Controller.Entities;
|
||||
@@ -16,9 +15,7 @@ public sealed class RefreshService
|
||||
{
|
||||
private readonly ILibraryManager _libraryManager;
|
||||
private readonly TranslationStore _store;
|
||||
private readonly TmdbClient _tmdbClient;
|
||||
private readonly FanartClient _fanartClient;
|
||||
private readonly AssetStorageService _assetStorage;
|
||||
private readonly ItemFetcher _fetcher;
|
||||
private readonly RefreshCoordinator _coordinator;
|
||||
private readonly ILogger<RefreshService> _logger;
|
||||
private readonly object _diagnosticsLock = new();
|
||||
@@ -27,17 +24,13 @@ public sealed class RefreshService
|
||||
public RefreshService(
|
||||
ILibraryManager libraryManager,
|
||||
TranslationStore store,
|
||||
TmdbClient tmdbClient,
|
||||
FanartClient fanartClient,
|
||||
AssetStorageService assetStorage,
|
||||
ItemFetcher fetcher,
|
||||
RefreshCoordinator coordinator,
|
||||
ILogger<RefreshService> logger)
|
||||
{
|
||||
_libraryManager = libraryManager;
|
||||
_store = store;
|
||||
_tmdbClient = tmdbClient;
|
||||
_fanartClient = fanartClient;
|
||||
_assetStorage = assetStorage;
|
||||
_fetcher = fetcher;
|
||||
_coordinator = coordinator;
|
||||
_logger = logger;
|
||||
}
|
||||
@@ -151,7 +144,6 @@ public sealed class RefreshService
|
||||
UpdateRunningScan();
|
||||
var items = GetAllItemsWithTmdbId();
|
||||
var now = TranslationStore.NowUnixUtc();
|
||||
var missingCutoff = now - (long)TimeSpan.FromDays(Math.Max(0, cfg.WaitDaysForMissingData)).TotalSeconds;
|
||||
var fullCutoff = now - (long)TimeSpan.FromDays(Math.Max(0, cfg.WaitDaysForExistingData)).TotalSeconds;
|
||||
var ordered = items.OrderBy(i => i.WorkClass).ToList();
|
||||
itemCount = ordered.Count;
|
||||
@@ -162,7 +154,14 @@ public sealed class RefreshService
|
||||
// Run local housekeeping only from full-library scans. ItemsProxy browsing may enqueue
|
||||
// missing items, but it must not delete local assets just because the admin briefly
|
||||
// changed artwork storage mode.
|
||||
var localCleanup = _store.CleanupForConfiguration(liveIds, NormalizeLanguages(cfg.Languages), IsLocalAssetStorage(cfg));
|
||||
LocalCleanupResult localCleanup;
|
||||
using (await _store.EnterMaintenanceAsync(cancellationToken).ConfigureAwait(false))
|
||||
{
|
||||
cfg = Plugin.Instance?.Configuration ?? throw new InvalidOperationException("Plugin unavailable.");
|
||||
if (Plugin.Instance.Uninstalling)
|
||||
throw new OperationCanceledException("Plugin is being uninstalled.");
|
||||
localCleanup = _store.CleanupForConfiguration(liveIds, NormalizeLanguages(cfg.Languages), IsLocalAssetStorage(cfg));
|
||||
}
|
||||
if (localCleanup.TranslationsDeleted > 0 || localCleanup.AssetsDeleted > 0 || localCleanup.GenresDeleted > 0 || localCleanup.AssetFilesDeleted > 0)
|
||||
{
|
||||
_logger.LogInformation(
|
||||
@@ -176,72 +175,90 @@ public sealed class RefreshService
|
||||
_logger.LogInformation("Multilang refresh started mode={Mode} source={Source} items={Items} new={New} deleted={Deleted}", jobType, runSource, ordered.Count, newCount, deletedCount);
|
||||
var index = 0;
|
||||
UpdateRunningScan();
|
||||
foreach (var item in ordered)
|
||||
{
|
||||
cancellationToken.ThrowIfCancellationRequested();
|
||||
index++;
|
||||
SetCurrent(item, index, "checking");
|
||||
var status = _store.GetFactsStatus(item.ItemId);
|
||||
var isNew = !status.Exists;
|
||||
var missingConfiguredData = jobType == RefreshJobType.Missing && status.Exists && ItemNeedsMissingRefresh(item, cfg, langs: null);
|
||||
var due = jobType == RefreshJobType.Full
|
||||
? !status.Exists || status.FullCheckedAt < fullCutoff
|
||||
: !status.Exists || status.MissingCheckedAt < missingCutoff || missingConfiguredData;
|
||||
|
||||
if (!due)
|
||||
var completed = 0;
|
||||
var scanLock = new object();
|
||||
foreach (var group in ordered.GroupBy(item => item.WorkClass))
|
||||
await Parallel.ForEachAsync(group,
|
||||
new ParallelOptions { MaxDegreeOfParallelism = RefreshConcurrency, CancellationToken = cancellationToken },
|
||||
async (item, ct) =>
|
||||
{
|
||||
skippedNotDueCount++;
|
||||
if (cfg.VerboseLogging && cfg.EnableLogging)
|
||||
ct.ThrowIfCancellationRequested();
|
||||
var scanIndex = Interlocked.Increment(ref index);
|
||||
var status = _store.GetFactsStatus(item.ItemId);
|
||||
var isNew = !status.Exists;
|
||||
var fullDue = jobType == RefreshJobType.Full && (!status.Exists || status.FullCheckedAt < fullCutoff);
|
||||
var due = fullDue || (jobType == RefreshJobType.Missing
|
||||
? !status.Exists || _fetcher.NeedsRefresh(item, cfg)
|
||||
: _fetcher.NeedsLocalWork(item.ItemId, cfg));
|
||||
|
||||
if (!due)
|
||||
{
|
||||
_logger.LogInformation(
|
||||
"Multilang refresh skip [{Index}/{Total}] item={ItemId} name=\"{Name}\" kind={Kind} reason=not-due",
|
||||
index,
|
||||
ordered.Count,
|
||||
item.ItemId,
|
||||
item.DisplayName,
|
||||
item.Kind);
|
||||
Interlocked.Increment(ref skippedNotDueCount);
|
||||
if (cfg.VerboseLogging && cfg.EnableLogging)
|
||||
{
|
||||
_logger.LogInformation(
|
||||
"Multilang refresh skip [{Index}/{Total}] item={ItemId} name=\"{Name}\" kind={Kind} reason=not-due",
|
||||
scanIndex,
|
||||
ordered.Count,
|
||||
item.ItemId,
|
||||
item.DisplayName,
|
||||
item.Kind);
|
||||
}
|
||||
|
||||
lock (scanLock)
|
||||
{
|
||||
SetCurrent(item, completed + 1, "skipped-not-due");
|
||||
progress.Report(++completed * 100.0 / Math.Max(1, ordered.Count));
|
||||
UpdateRunningScan();
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
progress.Report(index * 100.0 / Math.Max(1, ordered.Count));
|
||||
UpdateRunningScan("skipped-not-due");
|
||||
continue;
|
||||
}
|
||||
var actualJobType = fullDue || !status.Exists ? RefreshJobType.Full
|
||||
: jobType == RefreshJobType.Full ? RefreshJobType.Aggregate : RefreshJobType.Missing;
|
||||
Interlocked.Increment(ref dueCount);
|
||||
Log(
|
||||
cfg.EnableLogging,
|
||||
LogLevel.Information,
|
||||
"Multilang refresh fetch [{Index}/{Total}] item={ItemId} name=\"{Name}\" kind={Kind} tmdb={TmdbId} mode={Mode} new={New}",
|
||||
scanIndex,
|
||||
ordered.Count,
|
||||
item.ItemId,
|
||||
item.DisplayName,
|
||||
item.Kind,
|
||||
item.TmdbId,
|
||||
actualJobType,
|
||||
isNew);
|
||||
|
||||
var scanIndex = index;
|
||||
var actualJobType = jobType == RefreshJobType.Full || !status.Exists ? RefreshJobType.Full : RefreshJobType.Missing;
|
||||
dueCount++;
|
||||
SetCurrent(item, scanIndex, "fetching");
|
||||
Log(
|
||||
cfg.EnableLogging,
|
||||
LogLevel.Information,
|
||||
"Multilang refresh fetch [{Index}/{Total}] item={ItemId} name=\"{Name}\" kind={Kind} tmdb={TmdbId} mode={Mode} new={New}",
|
||||
scanIndex,
|
||||
ordered.Count,
|
||||
item.ItemId,
|
||||
item.DisplayName,
|
||||
item.Kind,
|
||||
item.TmdbId,
|
||||
actualJobType,
|
||||
isNew);
|
||||
var ok = await _coordinator.EnqueueAsync(
|
||||
item.ItemId,
|
||||
RefreshSourceTier.Background,
|
||||
item.WorkClass,
|
||||
actualJobType,
|
||||
async (actualJobType, ct) => await RefreshItemCoreAsync(item, actualJobType, ct).ConfigureAwait(false),
|
||||
ct).ConfigureAwait(false);
|
||||
lock (scanLock)
|
||||
{
|
||||
if (ok)
|
||||
refreshedCount++;
|
||||
else
|
||||
skippedNoDataCount++;
|
||||
|
||||
var ok = await _coordinator.EnqueueAsync(
|
||||
item.ItemId,
|
||||
RefreshSourceTier.Background,
|
||||
item.WorkClass,
|
||||
actualJobType,
|
||||
async (actualJobType, ct) => await RefreshItemCoreAsync(item, cfg, actualJobType, scanIndex, ordered.Count, ct).ConfigureAwait(false),
|
||||
cancellationToken).ConfigureAwait(false);
|
||||
if (ok)
|
||||
refreshedCount++;
|
||||
else
|
||||
skippedNoDataCount++;
|
||||
progress.Report(++completed * 100.0 / Math.Max(1, ordered.Count));
|
||||
SetCurrent(item, completed, ok ? "refreshed" : "skipped-no-data");
|
||||
UpdateRunningScan();
|
||||
}
|
||||
}).ConfigureAwait(false);
|
||||
|
||||
progress.Report(index * 100.0 / Math.Max(1, ordered.Count));
|
||||
UpdateRunningScan(ok ? "refreshed" : "skipped-no-data");
|
||||
using (await _store.EnterMaintenanceAsync(cancellationToken).ConfigureAwait(false))
|
||||
{
|
||||
if (Plugin.Instance!.Uninstalling)
|
||||
throw new OperationCanceledException("Plugin is being uninstalled.");
|
||||
_store.CleanupUnreferencedAssetFiles();
|
||||
_store.SetLastScanStarted(now);
|
||||
}
|
||||
|
||||
sw.Stop();
|
||||
_store.SetLastScanStarted(now);
|
||||
CompleteScan(true, string.Empty);
|
||||
_logger.LogInformation(
|
||||
"Multilang refresh complete mode={Mode} source={Source} elapsed={ElapsedMs}ms items={Items} due={Due} refreshed={Refreshed} skippedNotDue={SkippedNotDue} skippedNoData={SkippedNoData} new={New} deleted={Deleted}",
|
||||
@@ -268,7 +285,8 @@ public sealed class RefreshService
|
||||
}
|
||||
}
|
||||
|
||||
public async Task RefreshItemAsync(Guid itemId, bool includeChildren, CancellationToken cancellationToken)
|
||||
public async Task RefreshItemAsync(Guid itemId, bool includeChildren, CancellationToken cancellationToken,
|
||||
Jellyfin.Database.Implementations.Entities.User user)
|
||||
{
|
||||
var cfg = Plugin.Instance?.Configuration ?? throw new InvalidOperationException("Plugin configuration unavailable.");
|
||||
ValidateRefreshConfiguration(cfg);
|
||||
@@ -279,43 +297,46 @@ public sealed class RefreshService
|
||||
return;
|
||||
}
|
||||
|
||||
var items = BuildItemInfos(GetItemAndChildren(root, includeChildren)).ToList();
|
||||
var items = BuildItemInfos(GetItemAndChildren(root, includeChildren)
|
||||
.Where(item => item.IsVisibleStandalone(user))).ToList();
|
||||
var total = items.Count;
|
||||
var index = 0;
|
||||
_logger.LogInformation("Manual Multilang refresh started item={ItemId} name={Name} items={Items} includeChildren={IncludeChildren}", itemId, root.Name ?? string.Empty, total, includeChildren);
|
||||
foreach (var item in items)
|
||||
{
|
||||
index++;
|
||||
var scanIndex = index;
|
||||
Log(
|
||||
cfg.EnableLogging,
|
||||
LogLevel.Information,
|
||||
"Manual Multilang refresh fetch [{Index}/{Total}] item={ItemId} name=\"{Name}\" kind={Kind} tmdb={TmdbId}",
|
||||
scanIndex,
|
||||
total,
|
||||
item.ItemId,
|
||||
item.DisplayName,
|
||||
item.Kind,
|
||||
item.TmdbId);
|
||||
foreach (var group in items.OrderBy(item => item.WorkClass).GroupBy(item => item.WorkClass))
|
||||
await Parallel.ForEachAsync(group,
|
||||
new ParallelOptions { MaxDegreeOfParallelism = RefreshConcurrency, CancellationToken = cancellationToken },
|
||||
async (item, ct) =>
|
||||
{
|
||||
var scanIndex = Interlocked.Increment(ref index);
|
||||
Log(
|
||||
cfg.EnableLogging,
|
||||
LogLevel.Information,
|
||||
"Manual Multilang refresh fetch [{Index}/{Total}] item={ItemId} name=\"{Name}\" kind={Kind} tmdb={TmdbId}",
|
||||
scanIndex,
|
||||
total,
|
||||
item.ItemId,
|
||||
item.DisplayName,
|
||||
item.Kind,
|
||||
item.TmdbId);
|
||||
|
||||
var ok = await _coordinator.EnqueueAsync(
|
||||
item.ItemId,
|
||||
RefreshSourceTier.Manual,
|
||||
item.WorkClass,
|
||||
RefreshJobType.Full,
|
||||
async (actualJobType, ct) => await RefreshItemCoreAsync(item, cfg, actualJobType, scanIndex, total, ct).ConfigureAwait(false),
|
||||
cancellationToken).ConfigureAwait(false);
|
||||
Log(
|
||||
cfg.EnableLogging,
|
||||
ok ? LogLevel.Information : LogLevel.Warning,
|
||||
"Manual Multilang refresh item {Status} [{Index}/{Total}] item={ItemId} name=\"{Name}\" kind={Kind}",
|
||||
ok ? "complete" : "skipped",
|
||||
scanIndex,
|
||||
total,
|
||||
item.ItemId,
|
||||
item.DisplayName,
|
||||
item.Kind);
|
||||
}
|
||||
var ok = await _coordinator.EnqueueAsync(
|
||||
item.ItemId,
|
||||
RefreshSourceTier.Manual,
|
||||
item.WorkClass,
|
||||
RefreshJobType.Full,
|
||||
async (actualJobType, ct) => await RefreshItemCoreAsync(item, actualJobType, ct).ConfigureAwait(false),
|
||||
ct).ConfigureAwait(false);
|
||||
Log(
|
||||
cfg.EnableLogging,
|
||||
ok ? LogLevel.Information : LogLevel.Warning,
|
||||
"Manual Multilang refresh item {Status} [{Index}/{Total}] item={ItemId} name=\"{Name}\" kind={Kind}",
|
||||
ok ? "complete" : "skipped",
|
||||
scanIndex,
|
||||
total,
|
||||
item.ItemId,
|
||||
item.DisplayName,
|
||||
item.Kind);
|
||||
}).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
public bool EnqueueOnTheFlyMissing(IEnumerable<string> itemIds)
|
||||
@@ -365,7 +386,7 @@ public sealed class RefreshService
|
||||
sourceTier,
|
||||
info.WorkClass,
|
||||
RefreshJobType.Full,
|
||||
async (actualJobType, ct) => await RefreshItemCoreAsync(info, cfg, actualJobType, 0, 0, ct).ConfigureAwait(false),
|
||||
async (actualJobType, ct) => await RefreshItemCoreAsync(info, actualJobType, ct).ConfigureAwait(false),
|
||||
CancellationToken.None)
|
||||
.ContinueWith(
|
||||
task =>
|
||||
@@ -388,245 +409,16 @@ public sealed class RefreshService
|
||||
|
||||
private async Task<bool> RefreshItemCoreAsync(
|
||||
RefreshItemInfo item,
|
||||
PluginConfiguration cfg,
|
||||
RefreshJobType jobType,
|
||||
int scanIndex,
|
||||
int totalItems,
|
||||
CancellationToken cancellationToken)
|
||||
{
|
||||
var langs = NormalizeLanguages(cfg.Languages);
|
||||
if (langs.Length == 0)
|
||||
throw new InvalidOperationException("No Multilang languages are configured.");
|
||||
|
||||
if (cfg.VerboseLogging && cfg.EnableLogging)
|
||||
_logger.LogInformation("[{Index}/{Total}] Fetching item={ItemId} name=\"{Name}\" kind={Kind} tmdb={TmdbId}", scanIndex, totalItems, item.ItemId, item.DisplayName, item.Kind, item.TmdbId);
|
||||
|
||||
var now = TranslationStore.NowUnixUtc();
|
||||
var limiter = new FetchRateLimiter(TimeSpan.FromMilliseconds(250));
|
||||
var wroteAny = false;
|
||||
TmdbMetadata? firstMeta = null;
|
||||
var fetchedMetadata = new Dictionary<string, TmdbMetadata>(StringComparer.OrdinalIgnoreCase);
|
||||
foreach (var lang in langs)
|
||||
{
|
||||
var meta = await _tmdbClient.FetchMetadataAsync(item, lang, cfg.TmdbApiKey, limiter, cancellationToken).ConfigureAwait(false);
|
||||
if (meta is null)
|
||||
{
|
||||
Log(cfg.EnableLogging, LogLevel.Information, "[{Index}/{Total}] TMDb 404, skipping item={ItemId} name=\"{Name}\" tmdb={TmdbId} kind={Kind}", scanIndex, totalItems, item.ItemId, item.DisplayName, item.TmdbId, item.Kind);
|
||||
_store.MarkFactsChecked(item, now, jobType == RefreshJobType.Full ? now : 0);
|
||||
return false;
|
||||
}
|
||||
|
||||
Log(cfg.VerboseLogging && cfg.EnableLogging, LogLevel.Information, "[{Index}/{Total}] TMDb metadata ok item={ItemId} lang={Lang}", scanIndex, totalItems, item.ItemId, lang);
|
||||
_store.UpsertTranslation(item.ItemId, lang, TitleField, meta.Title);
|
||||
_store.UpsertTranslation(item.ItemId, lang, OverviewField, meta.Overview);
|
||||
_store.UpsertTranslation(item.ItemId, lang, TaglineField, meta.Tagline);
|
||||
StoreGenres(item, lang, meta);
|
||||
fetchedMetadata[lang] = meta;
|
||||
firstMeta ??= meta;
|
||||
if (!wroteAny)
|
||||
{
|
||||
_store.UpsertFacts(item, meta, now, jobType == RefreshJobType.Full ? now : 0);
|
||||
wroteAny = true;
|
||||
}
|
||||
}
|
||||
|
||||
var artworkLanguages = langs;
|
||||
if (firstMeta is not null && !string.IsNullOrWhiteSpace(firstMeta.OriginalLanguage))
|
||||
{
|
||||
var originalLang = firstMeta.OriginalLanguage.Trim();
|
||||
var existingLang = langs.FirstOrDefault(lang => SameLanguageBase(lang, originalLang));
|
||||
Log(
|
||||
cfg.EnableLogging,
|
||||
LogLevel.Information,
|
||||
"[{Index}/{Total}] Original language item={ItemId} lang={OriginalLang} metadataSource={Source}",
|
||||
scanIndex,
|
||||
totalItems,
|
||||
item.ItemId,
|
||||
originalLang,
|
||||
existingLang is not null ? "configured-language:" + existingLang : "extra-fetch");
|
||||
var originalMeta = existingLang is not null
|
||||
? fetchedMetadata[existingLang]
|
||||
: await _tmdbClient.FetchMetadataAsync(item, originalLang, cfg.TmdbApiKey, limiter, cancellationToken).ConfigureAwait(false);
|
||||
|
||||
if (originalMeta is not null)
|
||||
{
|
||||
_store.UpsertTranslation(item.ItemId, OriginalAction, TitleField, originalMeta.Title);
|
||||
_store.UpsertTranslation(item.ItemId, OriginalAction, OverviewField, originalMeta.Overview);
|
||||
_store.UpsertTranslation(item.ItemId, OriginalAction, TaglineField, originalMeta.Tagline);
|
||||
StoreGenres(item, OriginalAction, originalMeta);
|
||||
Log(
|
||||
cfg.VerboseLogging && cfg.EnableLogging,
|
||||
LogLevel.Information,
|
||||
"[{Index}/{Total}] Original metadata stored item={ItemId} lang={OriginalLang} titlePresent={TitlePresent} overviewPresent={OverviewPresent} taglinePresent={TaglinePresent}",
|
||||
scanIndex,
|
||||
totalItems,
|
||||
item.ItemId,
|
||||
originalLang,
|
||||
!string.IsNullOrWhiteSpace(originalMeta.Title),
|
||||
!string.IsNullOrWhiteSpace(originalMeta.Overview),
|
||||
!string.IsNullOrWhiteSpace(originalMeta.Tagline));
|
||||
}
|
||||
else
|
||||
{
|
||||
Log(
|
||||
cfg.EnableLogging,
|
||||
LogLevel.Warning,
|
||||
"[{Index}/{Total}] Original metadata unavailable item={ItemId} lang={OriginalLang}",
|
||||
scanIndex,
|
||||
totalItems,
|
||||
item.ItemId,
|
||||
originalLang);
|
||||
}
|
||||
|
||||
artworkLanguages = AppendOriginalLanguage(langs, originalLang);
|
||||
Log(
|
||||
cfg.VerboseLogging && cfg.EnableLogging,
|
||||
LogLevel.Information,
|
||||
"[{Index}/{Total}] Artwork language set item={ItemId} langs={Languages}",
|
||||
scanIndex,
|
||||
totalItems,
|
||||
item.ItemId,
|
||||
string.Join(",", artworkLanguages));
|
||||
}
|
||||
|
||||
await StoreArtworkAsync(item, cfg, artworkLanguages, limiter, now, cancellationToken).ConfigureAwait(false);
|
||||
|
||||
Log(cfg.EnableLogging, LogLevel.Information, "Multilang refresh item complete item={ItemId} kind={Kind} tmdb={TmdbId} mode={Mode}", item.ItemId, item.Kind, item.TmdbId, jobType);
|
||||
return true;
|
||||
}
|
||||
|
||||
private void StoreGenres(RefreshItemInfo item, string lang, TmdbMetadata metadata)
|
||||
{
|
||||
var media = GenreMediaFor(item.Kind);
|
||||
if (media is null)
|
||||
return;
|
||||
|
||||
foreach (var genre in metadata.Genres)
|
||||
_store.UpsertGenre(genre.Id, media, lang, genre.Name);
|
||||
}
|
||||
|
||||
private static string? GenreMediaFor(string kind)
|
||||
=> kind.Equals("movie", StringComparison.OrdinalIgnoreCase) ||
|
||||
kind.Equals("collection", StringComparison.OrdinalIgnoreCase)
|
||||
? "movie"
|
||||
: kind.Equals("tv", StringComparison.OrdinalIgnoreCase) ||
|
||||
kind.Equals("tvseason", StringComparison.OrdinalIgnoreCase) ||
|
||||
kind.Equals("tvepisode", StringComparison.OrdinalIgnoreCase)
|
||||
? "tv"
|
||||
: null;
|
||||
|
||||
private async Task StoreArtworkAsync(
|
||||
RefreshItemInfo item,
|
||||
PluginConfiguration cfg,
|
||||
string[] languages,
|
||||
FetchRateLimiter limiter,
|
||||
long updatedAt,
|
||||
CancellationToken cancellationToken)
|
||||
{
|
||||
if (item.Kind is "tvepisode")
|
||||
return;
|
||||
|
||||
var providers = cfg.Providers
|
||||
.Where(p => p.ArtworkOrder >= 0)
|
||||
.OrderBy(p => p.ArtworkOrder)
|
||||
.Select(p => p.Id.Trim().ToLowerInvariant())
|
||||
.ToArray();
|
||||
if (providers.Length == 0)
|
||||
return;
|
||||
|
||||
TmdbImages? tmdbImages = null;
|
||||
FanartImages? fanartImages = null;
|
||||
var written = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
|
||||
|
||||
foreach (var provider in providers)
|
||||
{
|
||||
cancellationToken.ThrowIfCancellationRequested();
|
||||
|
||||
if (provider.Equals("tmdb", StringComparison.OrdinalIgnoreCase))
|
||||
{
|
||||
tmdbImages ??= await _tmdbClient.FetchImagesAsync(item, cfg.TmdbApiKey, limiter, cancellationToken).ConfigureAwait(false);
|
||||
if (tmdbImages is null)
|
||||
continue;
|
||||
|
||||
await StoreImageMapAsync(item.ItemId, languages, PosterKind, tmdbImages.Posters, cfg, updatedAt, written, cancellationToken).ConfigureAwait(false);
|
||||
await StoreImageMapAsync(item.ItemId, languages, LogoKind, tmdbImages.Logos, cfg, updatedAt, written, cancellationToken).ConfigureAwait(false);
|
||||
await StoreImageMapAsync(item.ItemId, languages, BackdropKind, tmdbImages.Backdrops, cfg, updatedAt, written, cancellationToken).ConfigureAwait(false);
|
||||
Log(cfg.VerboseLogging && cfg.EnableLogging, LogLevel.Information, "TMDb artwork stored item={ItemId} langs={Languages}", item.ItemId, string.Join(",", languages));
|
||||
continue;
|
||||
}
|
||||
|
||||
if (provider.Equals("fanart", StringComparison.OrdinalIgnoreCase) && item.Kind.Equals("movie", StringComparison.OrdinalIgnoreCase))
|
||||
{
|
||||
fanartImages ??= await _fanartClient.FetchMovieImagesAsync(item.TmdbId, cfg.FanartApiKey, cancellationToken).ConfigureAwait(false);
|
||||
if (fanartImages is null)
|
||||
continue;
|
||||
|
||||
await StoreImageMapAsync(item.ItemId, languages, PosterKind, fanartImages.Posters, cfg, updatedAt, written, cancellationToken).ConfigureAwait(false);
|
||||
await StoreImageMapAsync(item.ItemId, languages, LogoKind, fanartImages.Logos, cfg, updatedAt, written, cancellationToken).ConfigureAwait(false);
|
||||
await StoreImageMapAsync(item.ItemId, languages, BannerKind, fanartImages.Banners, cfg, updatedAt, written, cancellationToken).ConfigureAwait(false);
|
||||
await StoreImageMapAsync(item.ItemId, languages, ThumbKind, fanartImages.Thumbs, cfg, updatedAt, written, cancellationToken).ConfigureAwait(false);
|
||||
Log(cfg.VerboseLogging && cfg.EnableLogging, LogLevel.Information, "Fanart artwork stored item={ItemId} langs={Languages}", item.ItemId, string.Join(",", languages));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private async Task StoreImageMapAsync(
|
||||
string itemId,
|
||||
IEnumerable<string> languages,
|
||||
string kind,
|
||||
IReadOnlyDictionary<string, string> images,
|
||||
PluginConfiguration cfg,
|
||||
long updatedAt,
|
||||
HashSet<string> written,
|
||||
CancellationToken cancellationToken)
|
||||
{
|
||||
foreach (var lang in languages)
|
||||
{
|
||||
var storeLang = lang.StartsWith(OriginalAction + ":", StringComparison.OrdinalIgnoreCase)
|
||||
? OriginalAction
|
||||
: lang;
|
||||
var key = kind + ":" + storeLang;
|
||||
if (written.Contains(key))
|
||||
continue;
|
||||
|
||||
var iso = ToIso639(lang);
|
||||
if (!images.TryGetValue(iso, out var url) || string.IsNullOrWhiteSpace(url))
|
||||
continue;
|
||||
|
||||
var storedPath = await _assetStorage.StoreAsync(itemId, storeLang, kind, url, IsLocalAssetStorage(cfg), cancellationToken).ConfigureAwait(false);
|
||||
if (string.IsNullOrWhiteSpace(storedPath))
|
||||
continue;
|
||||
|
||||
_store.UpsertAsset(itemId, storeLang, kind, storedPath, updatedAt);
|
||||
written.Add(key);
|
||||
}
|
||||
}
|
||||
|
||||
private bool ItemNeedsMissingRefresh(RefreshItemInfo item, PluginConfiguration cfg, string[]? langs)
|
||||
{
|
||||
langs ??= NormalizeLanguages(cfg.Languages);
|
||||
if (_store.HasMissingConfiguredTranslations(item.ItemId, langs))
|
||||
return true;
|
||||
|
||||
var assetPresence = _store.GetAssetPresence(item.ItemId, langs.Append(OriginalAction));
|
||||
return IsLocalAssetStorage(cfg) && assetPresence.AnyRemote;
|
||||
}
|
||||
|
||||
private static string[] AppendOriginalLanguage(string[] languages, string originalLanguage)
|
||||
=> languages
|
||||
.Concat([OriginalAction + ":" + originalLanguage])
|
||||
.Distinct(StringComparer.OrdinalIgnoreCase)
|
||||
.ToArray();
|
||||
|
||||
private static bool SameLanguageBase(string left, string right)
|
||||
=> ToIso639(left).Equals(ToIso639(right), StringComparison.OrdinalIgnoreCase);
|
||||
|
||||
private static string ToIso639(string language)
|
||||
{
|
||||
if (language.StartsWith(OriginalAction + ":", StringComparison.OrdinalIgnoreCase))
|
||||
language = language[(OriginalAction.Length + 1)..];
|
||||
var index = language.IndexOf('-', StringComparison.Ordinal);
|
||||
return (index > 0 ? language[..index] : language).Trim().ToLowerInvariant();
|
||||
using var lease = await _store.EnterRefreshAsync(cancellationToken).ConfigureAwait(false);
|
||||
var plugin = Plugin.Instance ?? throw new InvalidOperationException("Plugin unavailable.");
|
||||
if (plugin.Uninstalling)
|
||||
throw new OperationCanceledException("Plugin is being uninstalled.");
|
||||
var cfg = plugin.Configuration;
|
||||
ValidateRefreshConfiguration(cfg);
|
||||
return await _fetcher.RefreshAsync(item, cfg, jobType, cancellationToken).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
private List<RefreshItemInfo> GetAllItemsWithTmdbId()
|
||||
|
||||
Reference in new issue
Block a user