Stufe 2b: Metadaten von TMDB — und ein Testlauf, der 19-mal schneller ist

Titel, Beschreibungen und Bilder kommen jetzt von TMDB. Dazu zwei Fehler, die
erst das Zusammenspiel zeigte.

**Der Anbieter steckt hinter einer Schnittstelle, und das ist kein Vorrat für
einen zweiten.** Es geht darum, dass alles, was darauf aufbaut, *ohne Netz und
ohne Schlüssel* prüfbar bleibt. Ein Projekt, dessen Tests einen fremden Dienst
brauchen, hat am Ende keine Tests: sie scheitern, wenn das WLAN hakt, und
irgendwann schaltet sie jemand ab.

**Ein Fehlschlag bei TMDB ist kein Abbruch.** Kein Netz, Kontingent erschöpft,
ein Anmeldeportal im Hotel-WLAN, das HTML mit Status 200 schickt — in allen
Fällen bleibt der Titel beim Dateinamen und der Scan läuft durch. Die eine
Ausnahme ist ein zurückgewiesener Schlüssel: „nichts gefunden" und „dein
Schlüssel ist falsch" sehen in der Mediathek gleich aus, und ohne diese
Unterscheidung sucht jemand stundenlang. Der Schlüssel steht im Scanbericht.

**Der Schlüssel kommt nie wieder heraus.** Abgefragt wird nur, ob einer da
ist — sonst gäbe die Oberfläche jedem Angemeldeten das TMDB-Kontingent des
Betreibers in die Hand. Geprüft, dass er nicht einmal versehentlich im
Antwortkörper steht.

**Bilder holt die App bei Halo, nicht bei TMDB.** Sonst bräuchte sie Internet
für ein Plakat, das zehn Zentimeter weiter auf der Platte liegt — und TMDB
erführe, wer wann was ansieht. Der Schlüssel ist der Hash der Quelladresse,
also lädt dasselbe Plakat nie zweimal. Dass daraus kein Weg ins Dateisystem
wird, ist eigens geprüft: ohne die Formprüfung wäre
`/api/v1/images/../../config/halo.db` ein Weg, die Datenbank samt aller
Token-Fingerabdrücke herunterzuladen.

---

**Der erste Fehler: nach dem Eintragen der Metadaten legte der nächste Scan
den Film erneut an.** Zugeordnet wurde über den Titel — und den hatte TMDB
gerade von „The Matrix" auf „Matrix" geändert. Beim übernächsten Lauf dasselbe
noch einmal. Das ist die Sorte Fehler, die man erst nach Wochen bemerkt, wenn
jeder Film fünfmal dasteht. Jetzt gibt es `ParsedTitle`: den Titel aus dem
Dateinamen, der sich nie ändert, und nur der entscheidet beim Zuordnen.

**Der zweite Fehler kostete 15 Minuten je Testlauf.** Zwei Tests löschen die
Pfadvariablen, um den Rückfall auf die Voreinstellung zu prüfen — und liessen
sie gelöscht zurück. Jeder danach gestartete Testserver fiel dann auf
`<Projektverzeichnis>/data` zurück, und Dutzende Server teilten sich **eine**
SQLite-Datei, auf die sie der Reihe nach warteten. Dazu wartete jeder Host
beim Herunterfahren die vollen fünf Sekunden.

Gefunden durch Halbieren, nicht durch Raten: einzeln war jede Testklasse
schnell, zusammen nicht. Der Beweis lag am Ende als leeres Verzeichnis
`src/Halo.Api/data` auf der Platte.

**15 Minuten 32 → 49 Sekunden.** 180 Tests grün.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
Scarriffle
2026-10-03 16:52:46 +02:00
co-authored by Claude Opus 5
parent 78b7e3bcb8
commit acfe2668a8
32 changed files with 2575 additions and 38 deletions
+203
View File
@@ -0,0 +1,203 @@
using System.Net;
using System.Text.Json;
using System.Text.Json.Serialization;
using Halo.Core.Metadata;
using Microsoft.Extensions.Logging;
namespace Halo.Metadata;
/// <summary>Fragt TMDB nach Titeln, Beschreibungen und Bildern.</summary>
///
/// <remarks>
/// <para>
/// <b>Ein Fehlschlag ist kein Abbruch.</b> Antwortet TMDB nicht — kein Netz,
/// Kontingent erschöpft, Wartung —, kommt <c>null</c> zurück und der Titel
/// bleibt beim Dateinamen. Ein Scan, der an einem fremden Dienst scheitert,
/// wäre der falsche Entwurf: die Mediathek steht dann leer da, obwohl die
/// Dateien tadellos vorhanden sind.
/// </para>
/// <para>
/// <b>Ein falscher Schlüssel ist dagegen sehr wohl etwas, das jemand erfahren
/// muss</b> — sonst sucht man stundenlang, warum keine Bilder erscheinen.
/// Deshalb nur dafür eine Ausnahme.
/// </para>
/// </remarks>
public sealed class TmdbClient(
HttpClient http,
ITmdbSettingsSource einstellungen,
ILogger<TmdbClient> log) : IMetadataProvider
{
public const string BaseAddress = "https://api.themoviedb.org/3/";
/// <summary>w500 für Plakate, w1280 für Hintergründe — genug für jeden Bildschirm.</summary>
///
/// <remarks>
/// Die Originalgrösse wäre bei einem Bestand mit tausend Titeln mehrere
/// Gigabyte Cache, ohne dass es auf einem Telefon je sichtbar würde.
/// </remarks>
private const string PosterSize = "w500";
private const string BackdropSize = "w1280";
private const string StillSize = "w300";
private static readonly JsonSerializerOptions Json = new(JsonSerializerDefaults.Web);
public async Task<bool> IsConfiguredAsync(CancellationToken ct = default) =>
!string.IsNullOrWhiteSpace((await einstellungen.GetAsync(ct)).ApiKey);
public async Task<MovieMetadata?> FindMovieAsync(string title, int? year, CancellationToken ct = default)
{
var treffer = await SuchenAsync<TmdbMovie>("search/movie", title,
year is { } j ? ("year", j.ToString()) : null, ct);
if (treffer is null) return null;
return new MovieMetadata(
treffer.Id,
treffer.Title ?? title,
JahrAus(treffer.ReleaseDate),
Leer(treffer.Overview),
Bild(treffer.PosterPath, PosterSize),
Bild(treffer.BackdropPath, BackdropSize));
}
public async Task<SeriesMetadata?> FindSeriesAsync(string title, int? year, CancellationToken ct = default)
{
var treffer = await SuchenAsync<TmdbSeries>("search/tv", title,
year is { } j ? ("first_air_date_year", j.ToString()) : null, ct);
if (treffer is null) return null;
return new SeriesMetadata(
treffer.Id,
treffer.Name ?? title,
JahrAus(treffer.FirstAirDate),
Leer(treffer.Overview),
Bild(treffer.PosterPath, PosterSize),
Bild(treffer.BackdropPath, BackdropSize));
}
public async Task<EpisodeMetadata?> FindEpisodeAsync(
int seriesProviderId, int season, int episode, CancellationToken ct = default)
{
var einstellung = await einstellungen.GetAsync(ct);
if (string.IsNullOrWhiteSpace(einstellung.ApiKey)) return null;
var pfad = $"tv/{seriesProviderId}/season/{season}/episode/{episode}" +
$"?api_key={Uri.EscapeDataString(einstellung.ApiKey)}" +
$"&language={Uri.EscapeDataString(einstellung.Language)}";
var folge = await HolenAsync<TmdbEpisode>(pfad, ct);
if (folge is null) return null;
return new EpisodeMetadata(Leer(folge.Name), Leer(folge.Overview), Bild(folge.StillPath, StillSize));
}
private async Task<T?> SuchenAsync<T>(
string pfad, string titel, (string Name, string Wert)? zusatz, CancellationToken ct) where T : class
{
var einstellung = await einstellungen.GetAsync(ct);
if (string.IsNullOrWhiteSpace(einstellung.ApiKey) || string.IsNullOrWhiteSpace(titel)) return null;
var abfrage = $"{pfad}?api_key={Uri.EscapeDataString(einstellung.ApiKey)}" +
$"&language={Uri.EscapeDataString(einstellung.Language)}" +
$"&query={Uri.EscapeDataString(titel)}";
if (zusatz is { } z) abfrage += $"&{z.Name}={Uri.EscapeDataString(z.Wert)}";
var antwort = await HolenAsync<TmdbSearch<T>>(abfrage, ct);
// **Der erste Treffer, nicht der beste.** TMDB sortiert nach
// Beliebtheit, und das ist für einen Titel mit Jahr fast immer richtig.
// Eine eigene Bewertung zu bauen hiesse, TMDBs Rangfolge nachzubauen —
// mit weniger Daten.
return antwort?.Results?.FirstOrDefault();
}
private async Task<T?> HolenAsync<T>(string pfadMitAbfrage, CancellationToken ct) where T : class
{
try
{
using var antwort = await http.GetAsync(pfadMitAbfrage, ct);
if (antwort.StatusCode is HttpStatusCode.Unauthorized or HttpStatusCode.Forbidden)
throw new MetadataCredentialsException(
"TMDB weist den hinterlegten Schlüssel zurück. Prüfe ihn in den Servereinstellungen.");
// 404 heisst bei TMDB schlicht „gibt es nicht" — etwa eine Folge,
// die dort noch nicht eingetragen ist.
if (antwort.StatusCode == HttpStatusCode.NotFound) return null;
if (!antwort.IsSuccessStatusCode)
{
log.LogWarning("TMDB antwortete mit {Code} auf {Pfad}.", (int)antwort.StatusCode, Gekürzt(pfadMitAbfrage));
return null;
}
return await antwort.Content.ReadFromJsonSafeAsync<T>(Json, ct);
}
catch (MetadataCredentialsException) { throw; }
catch (OperationCanceledException) when (ct.IsCancellationRequested) { throw; }
catch (Exception fehler)
{
log.LogWarning(fehler, "TMDB war für {Pfad} nicht erreichbar.", Gekürzt(pfadMitAbfrage));
return null;
}
}
/// <summary>Der Pfad ohne den Schlüssel — der gehört in kein Protokoll.</summary>
private static string Gekürzt(string pfadMitAbfrage)
{
var index = pfadMitAbfrage.IndexOf("api_key=", StringComparison.Ordinal);
return index < 0 ? pfadMitAbfrage : pfadMitAbfrage[..index] + "api_key=…";
}
private static RemoteImage? Bild(string? pfad, string grösse) =>
string.IsNullOrWhiteSpace(pfad) ? null : new RemoteImage($"https://image.tmdb.org/t/p/{grösse}{pfad}");
private static string? Leer(string? wert) => string.IsNullOrWhiteSpace(wert) ? null : wert;
private static int? JahrAus(string? datum) =>
datum is { Length: >= 4 } && int.TryParse(datum[..4], out var jahr) ? jahr : null;
// Nur die Felder, die gebraucht werden. TMDB liefert dreissig weitere.
private sealed record TmdbSearch<T>([property: JsonPropertyName("results")] List<T>? Results);
private sealed record TmdbMovie(
[property: JsonPropertyName("id")] int Id,
[property: JsonPropertyName("title")] string? Title,
[property: JsonPropertyName("release_date")] string? ReleaseDate,
[property: JsonPropertyName("overview")] string? Overview,
[property: JsonPropertyName("poster_path")] string? PosterPath,
[property: JsonPropertyName("backdrop_path")] string? BackdropPath);
private sealed record TmdbSeries(
[property: JsonPropertyName("id")] int Id,
[property: JsonPropertyName("name")] string? Name,
[property: JsonPropertyName("first_air_date")] string? FirstAirDate,
[property: JsonPropertyName("overview")] string? Overview,
[property: JsonPropertyName("poster_path")] string? PosterPath,
[property: JsonPropertyName("backdrop_path")] string? BackdropPath);
private sealed record TmdbEpisode(
[property: JsonPropertyName("name")] string? Name,
[property: JsonPropertyName("overview")] string? Overview,
[property: JsonPropertyName("still_path")] string? StillPath);
}
internal static class HttpContentExtensions
{
/// <summary>Liest JSON und wirft nicht, wenn Unsinn zurückkommt.</summary>
///
/// <remarks>
/// Ein Reverse Proxy oder ein Anmeldeportal im Hotel-WLAN antwortet mit
/// HTML und dem Status 200. Darauf mit einer Ausnahme zu reagieren hiesse,
/// den ganzen Scan an einem fremden Netz scheitern zu lassen.
/// </remarks>
public static async Task<T?> ReadFromJsonSafeAsync<T>(
this HttpContent inhalt, JsonSerializerOptions optionen, CancellationToken ct) where T : class
{
try
{
await using var strom = await inhalt.ReadAsStreamAsync(ct);
return await JsonSerializer.DeserializeAsync<T>(strom, optionen, ct);
}
catch (JsonException) { return null; }
}
}