Drei Fehler aus dem ersten Praxistest

Anmelde-Adresse wurde doppelt kodiert
  URLComponents.fragment kodiert beim Setzen erneut, aus %5B wurde
  %255B. Plex antwortete mit „Diese Anfrage konnte nicht abgeschlossen
  werden". Die Adresse wird jetzt von Hand zusammengesetzt.

Verbindungssuche hing bis zu anderthalb Minuten
  probeTimeout war deklariert, aber nirgends angewendet — es galt der
  URLSession-Standard von 60 Sekunden. Zusammen mit der Prüfung Rang
  für Rang kostete eine schweigende lokale Adresse die volle Zeit,
  bevor der direkte Weg überhaupt begann. Jetzt laufen alle Adressen
  gleichzeitig, mit Zeitgrenze, und die Rangordnung entscheidet unter
  den erreichbaren.

Kein Zurück während des Ladens
  Die Kopfzeile mit dem Schließen-Knopf wurde nur im Zustand .playing
  gezeichnet. Bei langsamer Verbindung saß man ohne Ausweg vor einem
  Ladekreis. Sie liegt jetzt als eigene Ebene darüber und erscheint
  auch beim Vorbereiten — samt Titel, damit erkennbar bleibt, worauf
  gewartet wird.

Sechs neue Tests, darunter drei, die die Zeitgrenze der
Verbindungssuche an einer schweigenden Adresse nachstellen.

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

Packages/FlixyKit/Sources/PlexKit/Discovery/PlexConnectionSelector.swift

@@ -2,11 +2,16 @@ import Foundation
 
 /// Sucht den besten erreichbaren Weg zu einem Server.
 ///
-/// Geht die Wege nach Rang durch — erst lokal, dann direkt von außen, zuletzt
-/// über die Vermittlung von Plex. Innerhalb eines Rangs laufen die Versuche
-/// gleichzeitig, weil sie sich gegenseitig nicht ausschließen und ein
-/// unerreichbarer Weg sonst die volle Zeitüberschreitung kostet, bevor der
-/// nächste überhaupt beginnt.
+/// Alle Adressen werden **gleichzeitig** geprüft, nicht Rang für Rang. Der
+/// Unterschied ist erheblich: geht man die Ränge nacheinander durch, kostet
+/// eine nicht erreichbare lokale Adresse erst die volle Zeitgrenze, bevor der
+/// direkte Weg überhaupt beginnt. Aus zwei Wartezeiten wird so eine.
+///
+/// Die Rangordnung bleibt trotzdem: gewinnt eine lokale Adresse, wird sofort
+/// abgebrochen — besser kann es nicht werden. Sonst wird gesammelt und am Ende
+/// die beste erreichbare genommen. Ein reines „wer zuerst antwortet" wäre
+/// falsch, weil die Vermittlung von Plex sich oft am schnellsten meldet und
+/// zugleich die langsamste Leitung hat.
 public struct PlexConnectionSelector: Sendable {
     private let identity: PlexClientIdentity
     private let transport: any PlexTransport
@@ -15,7 +20,7 @@ public struct PlexConnectionSelector: Sendable {
     public init(
         identity: PlexClientIdentity,
         transport: any PlexTransport = URLSession.shared,
-        probeTimeout: Duration = .seconds(5)
+        probeTimeout: Duration = .seconds(4)
     ) {
         self.identity = identity
         self.transport = transport
@@ -23,48 +28,36 @@ public struct PlexConnectionSelector: Sendable {
     }
 
     public func selectConnection(for resource: PlexResource) async -> PlexConnection? {
-        guard let token = resource.accessToken else { return nil }
+        guard let token = resource.accessToken, !resource.connections.isEmpty else { return nil }
 
-        let tiers = Dictionary(grouping: resource.connections, by: \.tier)
-        for tier in tiers.keys.sorted() {
-            guard let candidates = tiers[tier] else { continue }
-            if let winner = await race(candidates, token: token, expecting: resource.clientIdentifier) {
-                return winner
-            }
-        }
-        return nil
-    }
-
-    /// Lässt die Wege eines Rangs gegeneinander antreten; der erste, der sich
-    /// korrekt ausweist, gewinnt.
-    private func race(
-        _ connections: [PlexConnection],
-        token: String,
-        expecting clientIdentifier: String
-    ) async -> PlexConnection? {
-        await withTaskGroup(of: PlexConnection?.self) { group in
-            for connection in connections {
+        return await withTaskGroup(of: PlexConnection?.self) { group in
+            for connection in resource.connections {
                 group.addTask {
-                    await probe(connection, token: token, expecting: clientIdentifier) ? connection : nil
+                    await reachable(connection, token: token, expecting: resource.clientIdentifier)
+                        ? connection
+                        : nil
                 }
             }
 
-            for await result in group {
-                if let result {
-                    // Die übrigen Versuche interessieren nicht mehr. Ohne das
-                    // Abbrechen liefe eine unerreichbare Adresse noch bis zur
-                    // Zeitüberschreitung weiter und hielte die Aufgabe offen.
+            var best: PlexConnection?
+            for await candidate in group {
+                guard let candidate else { continue }
+                if best.map({ candidate.tier < $0.tier }) ?? true {
+                    best = candidate
+                }
+                // Eine lokale Adresse ist nicht zu schlagen. Auf die übrigen
+                // zu warten würde die Anmeldung nur verzögern.
+                if best?.tier == 0 {
                     group.cancelAll()
-                    return result
+                    break
                 }
             }
-            return nil
+            return best
         }
     }
 
-    /// Fragt `/identity` ab — der einzige Endpunkt, der ohne Token antwortet
-    /// und die Kennung des Servers nennt.
-    private func probe(
+    /// Fragt `/identity` ab und gleicht die Server-Kennung ab.
+    private func reachable(
         _ connection: PlexConnection,
         token: String,
         expecting clientIdentifier: String
@@ -79,18 +72,42 @@ public struct PlexConnectionSelector: Sendable {
         )
 
         do {
-            let identityResponse = try await client.send(
-                PlexRequest(path: "/identity"),
-                as: PlexIdentity.self
-            )
-            // Der Abgleich der Kennung ist keine Förmlichkeit: eine veraltete
+            let response = try await withTimeout(probeTimeout) {
+                try await client.send(
+                    PlexRequest(path: "/identity", timeout: probeTimeout),
+                    as: PlexIdentity.self
+                )
+            }
+            // Der Abgleich ist keine Förmlichkeit: eine veraltete
             // plex.direct-Adresse kann auf einen fremden Server zeigen, und
             // ohne Prüfung würde die App fremde Mediatheken anzeigen.
-            return identityResponse.machineIdentifier == clientIdentifier
+            return response?.machineIdentifier == clientIdentifier
         } catch {
             return false
         }
     }
+
+    /// Bricht ab, wenn die Arbeit zu lange dauert.
+    ///
+    /// Zusätzlich zur Zeitgrenze der Anfrage selbst, damit die Grenze auch bei
+    /// einem Transport greift, der sie nicht beachtet — in den Tests etwa.
+    /// Liefert `nil`, wenn die Zeit abgelaufen ist.
+    private func withTimeout<T: Sendable>(
+        _ duration: Duration,
+        _ operation: @escaping @Sendable () async throws -> T
+    ) async throws -> T? {
+        try await withThrowingTaskGroup(of: T?.self) { group in
+            group.addTask { try await operation() }
+            group.addTask {
+                try? await Task.sleep(for: duration)
+                return nil
+            }
+
+            let first = try await group.next() ?? nil
+            group.cancelAll()
+            return first
+        }
+    }
 }
 
 /// Die Antwort von `/identity`.