Drei Zähler für dieselbe Sache, und keiner davon offensichtlich falsch

Während eines Scans stand in der Mediathek 20, in der Verwaltung 14 und
in der Seitenleiste 0. Die Verwaltung frischte alle fünf Runden auf, die
Seitenleiste erst am Ende des Laufs. Jetzt laufen beide auf demselben
Takt, alle drei Runden.

Dazu: während ein Lauf läuft, sind Scannen, Metadaten auffrischen,
Zurücksetzen und Entfernen gesperrt — die ersten beiden prallen am
Server ab und sind nur verwirrend, die anderen beiden löschen Zeilen,
während der Lauf welche schreibt. Umbenennen und Prüfung bleiben
bedienbar. Die Sperre richtet sich nach dem Zustand, den der Server
meldet, nicht nach dem Klick: wer die Seite neu lädt, während ein Lauf
läuft, findet sie ebenfalls gesperrt vor.

Die Reihenfolge der Mediatheken wird jetzt in der Seitenleiste
umsortiert, über „Seitenleiste bearbeiten" neben der Überschrift. Sie
wirkt dort, also gehört der Griff dorthin — vorher schob man in den
Einstellungen und musste danach nachsehen, ob es das war, was man
wollte.

Der Zuordnungsdialog zeigt die Herkunft: Ordner, Zahl der Dateien und
ein paar Namen. Liegt eine Zuordnung völlig daneben, sagt der angezeigte
Titel nichts mehr darüber, welche Datei gemeint ist.

Und SQLite läuft jetzt im WAL-Modus. In der Vorgabe sperrt ein Schreiber
die ganze Datei: solange der Scan schrieb, kam keine Leseanfrage durch.
Genau so sah es aus — Bilddialog und Protokoll liefen während eines
Laufs sporadisch ins Leere.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

server/src/Flaro.Api/Endpoints/MatchEndpoints.cs

@@ -25,6 +25,48 @@ public static class MatchEndpoints
 {
     public static void MapMatching(this IEndpointRouteBuilder app)
     {
+        // **Woher dieser Titel kommt.**
+        //
+        // Steht im Dialog über der Suche. Wenn eine Zuordnung völlig daneben
+        // liegt — „Dark Shadows" von 1966 statt „Dark" —, sagt der angezeigte
+        // Titel nichts mehr darüber, welche Datei da eigentlich gemeint ist.
+        // Der Ordner sagt es, und zwar sofort.
+        app.MapGet("/api/v1/{art:regex(^movies|series$)}/{id:guid}/herkunft", async (
+            string art, Guid id, FlaroContext db) =>
+        {
+            var dateien = art == "movies"
+                ? db.MediaFiles.AsNoTracking().Where(f => f.MovieId == id)
+                : db.MediaFiles.AsNoTracking().Where(f => f.EpisodeId != null
+                    && db.Episodes.Any(e => e.Id == f.EpisodeId && e.SeriesId == id));
+
+            // **Gezählt wird vollständig, gezeigt nur eine Handvoll.** Hier
+            // stand erst ein `Take(50)` vor dem Zählen — bei 1200 Folgen
+            // behauptete der Dialog dann „50 Dateien". Eine Zahl, die bei
+            // genau dem Titel falsch wird, bei dem man hinsieht.
+            //
+            // **Ein Zug, dann im Speicher.** Der Ordner aus einem Pfad zu
+            // schneiden lässt sich nicht nach SQL übersetzen — der Versuch
+            // endete in einem 500er. Die Pfade eines einzelnen Titels sind
+            // auch bei 1200 Folgen ein paar hundert Kilobyte; das ist
+            // billiger als eine Abfrage, die nicht läuft.
+            var pfade = await dateien.Select(f => f.Path).ToListAsync();
+            if (pfade.Count == 0) return Results.Ok(new Herkunft(null, 0, []));
+
+            var ordner = pfade
+                .Select(p => Path.GetDirectoryName(p) ?? "")
+                .Distinct(StringComparer.Ordinal)
+                .ToList();
+
+            return Results.Ok(new Herkunft(
+                ordner.Count == 1 ? ordner[0] : GemeinsamerAnfang(ordner),
+                pfade.Count,
+                pfade.Order(StringComparer.Ordinal)
+                    .Take(6)
+                    .Select(Path.GetFileName)
+                    .Where(n => n is not null)
+                    .ToList()!));
+        }).RequireAuthorization(FlaroPolicies.Administrator);
+
         app.MapGet("/api/v1/movies/{id:guid}/matches", async (
             Guid id, FlaroContext db, IMetadataProvider anbieter, string? query, int? year) =>
         {
@@ -85,4 +127,36 @@ public static class MatchEndpoints
             return Results.Ok(new MatchState(serie.TmdbId, serie.ImdbId, serie.MatchLocked, serie.Title, serie.Year));
         }).RequireAuthorization(FlaroPolicies.Administrator);
     }
+
+    /// <summary>Der längste Pfad, mit dem alle anfangen — oder <c>null</c>.</summary>
+    ///
+    /// <remarks>
+    /// Verglichen wird nach Ordnerbestandteilen, nicht nach Zeichen: sonst
+    /// ergäben <c>/media/Serien/Dark</c> und <c>/media/Serien/Darkwing</c> den
+    /// gemeinsamen Anfang <c>/media/Serien/Dark</c>, und der bezeichnet einen
+    /// Ordner, in dem nur eines von beidem liegt.
+    /// </remarks>
+    private static string? GemeinsamerAnfang(IReadOnlyList<string> pfade)
+    {
+        if (pfade.Count == 0) return null;
+
+        var teile = pfade.Select(p => p.Split('/', StringSplitOptions.RemoveEmptyEntries)).ToList();
+        var gemeinsam = new List<string>();
+
+        for (var i = 0; i < teile[0].Length; i++)
+        {
+            var stueck = teile[0][i];
+            if (teile.Any(t => i >= t.Length || t[i] != stueck)) break;
+            gemeinsam.Add(stueck);
+        }
+
+        return gemeinsam.Count == 0 ? null : "/" + string.Join('/', gemeinsam);
+    }
 }
+
+/// <summary>Woher ein Titel im Dateisystem stammt.</summary>
+///
+/// <param name="Ordner">Der gemeinsame Ordner aller Dateien; <c>null</c>, wenn es keinen gibt.</param>
+/// <param name="Dateien">Wie viele Dateien an diesem Titel hängen.</param>
+/// <param name="Beispiele">Ein paar Dateinamen — mehr braucht niemand zum Wiedererkennen.</param>
+public sealed record Herkunft(string? Ordner, int Dateien, IReadOnlyList<string> Beispiele);

server/src/Flaro.Api/Program.cs

@@ -20,7 +20,15 @@ pfade.EnsureExists();
 builder.Services.AddSingleton(pfade);
 builder.Services.AddSingleton(TimeProvider.System);
 
-builder.Services.AddDbContext<FlaroContext>(o => o.UseSqlite($"Data Source={pfade.DatabaseFile}"));
+// **Mit Wartezeit statt sofortigem Abbruch.**
+//
+// SQLite lässt genau einen Schreiber zu. Ohne `Default Timeout` scheitert
+// jeder, der dazwischenkommt, auf der Stelle mit „database is locked" —
+// während eines Scans über tausende Dateien ist das jede zweite Anfrage aus
+// der Oberfläche. Dreissig Sekunden sind grosszügig; gebraucht werden
+// Millisekunden.
+builder.Services.AddDbContext<FlaroContext>(o =>
+    o.UseSqlite($"Data Source={pfade.DatabaseFile};Default Timeout=30"));
 
 builder.Services
     .AddAuthentication(TokenAuthenticationHandler.SchemeName)
@@ -124,7 +132,28 @@ var app = builder.Build();
 // hochfährt, soll nicht erst eine Migration von Hand anstossen müssen.
 using (var bereich = app.Services.CreateScope())
 {
-    await bereich.ServiceProvider.GetRequiredService<FlaroContext>().Database.MigrateAsync();
+    var db = bereich.ServiceProvider.GetRequiredService<FlaroContext>();
+
+    // **WAL, und zwar vor der Migration.**
+    //
+    // In der Vorgabe („delete") sperrt ein Schreiber die ganze Datei: solange
+    // der Scan schreibt, kommt *keine* Leseanfrage durch. Genau so sah es in
+    // der Oberfläche aus — Bilddialog und Protokoll liefen während eines
+    // Laufs sporadisch ins Leere. Mit WAL lesen beliebig viele weiter,
+    // während einer schreibt.
+    //
+    // Die Einstellung hält sich in der Datei; einmal gesetzt bleibt sie. Sie
+    // trotzdem bei jedem Start zu setzen kostet nichts und deckt den Fall ab,
+    // dass jemand mit einer frischen Datei kommt.
+    await db.Database.ExecuteSqlRawAsync("PRAGMA journal_mode=WAL;");
+
+    // Ohne das wartet SQLite nach jeder Schreibung auf die Platte. Mit WAL
+    // ist „normal" die übliche Wahl: ein Absturz des Prozesses kostet nichts,
+    // nur ein Stromausfall mitten im Schreiben könnte die letzte Transaktion
+    // kosten — und die ist bei einem Medienserver ein Scanfortschritt.
+    await db.Database.ExecuteSqlRawAsync("PRAGMA synchronous=NORMAL;");
+
+    await db.Database.MigrateAsync();
 }
 
 app.UseExceptionHandler();