Keep DNS retry safe for WebSockets and preserve saved user edits

conductarr-client/src/main/kotlin/org/justinvisser/wolfskin/conductarr/DnsConnectionRetry.kt

@@ -34,7 +34,8 @@ class DnsConnectionRetry(private val dns: PersistentDns) : Interceptor, EventLis
     }
 
     override fun intercept(chain: Interceptor.Chain): Response {
-        val attempt = attempts.getValue(chain.call())
+        // OkHttp deliberately disables event listeners on its derived WebSocket client.
+        val attempt = attempts[chain.call()] ?: return chain.proceed(chain.request())
         return try {
             chain.proceed(chain.request())
         } catch (failure: IOException) {

conductarr-client/src/main/kotlin/org/justinvisser/wolfskin/conductarr/PersistentDns.kt

@@ -71,7 +71,7 @@ class PersistentDns(
         executor.execute {
             try {
                 synchronized(host.resolutionLock) { resolve(hostname, host) }
-            } catch (_: UnknownHostException) {
+            } catch (_: Exception) {
                 // Failed refreshes do not extend the lifetime of the last successful answer.
                 host.refreshAfter = nowMillis() + FAILURE_BACKOFF_MILLIS
             } finally {

conductarr-client/src/test/kotlin/org/justinvisser/wolfskin/conductarr/DnsConnectionRetryTest.kt

@@ -0,0 +1,68 @@
+// SPDX-License-Identifier: GPL-2.0-only
+package org.justinvisser.wolfskin.conductarr
+
+import java.net.InetAddress
+import java.util.concurrent.CompletableFuture
+import java.util.concurrent.Executors
+import java.util.concurrent.TimeUnit
+import java.util.concurrent.atomic.AtomicReference
+import mockwebserver3.MockResponse
+import mockwebserver3.MockWebServer
+import okhttp3.Dispatcher
+import okhttp3.Dns
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.Response
+import okhttp3.WebSocket
+import okhttp3.WebSocketListener
+import org.junit.Assert.*
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.TemporaryFolder
+
+/** OkHttp's listener-free WebSocket client must retain a working upgrade and message path. */
+class DnsConnectionRetryTest {
+    @get:Rule val directory = TemporaryFolder()
+
+    @Test fun derivedClientOpensWebSocketWithoutAnUncaughtDispatcherException() {
+        val opened = CompletableFuture<Int>()
+        val message = CompletableFuture<String>()
+        val uncaught = AtomicReference<Throwable?>()
+        val executor = Executors.newCachedThreadPool { task ->
+            Thread(task, "dns-websocket-test").apply {
+                uncaughtExceptionHandler = Thread.UncaughtExceptionHandler { _, failure ->
+                    uncaught.set(failure)
+                    opened.completeExceptionally(failure)
+                    message.completeExceptionally(failure)
+                }
+            }
+        }
+        MockWebServer().use { server ->
+            server.enqueue(MockResponse.Builder().webSocketUpgrade(object : WebSocketListener() {
+                override fun onOpen(webSocket: WebSocket, response: Response) { webSocket.send("ready") }
+            }).build())
+            server.start()
+            val dns = PersistentDns({ directory.root.resolve("dns.json") }, Dns { listOf(InetAddress.getByName("127.0.0.1")) })
+            val client = DnsConnectionRetry.configure(OkHttpClient.Builder(), dns)
+                .dispatcher(Dispatcher(executor)).build().newBuilder().build()
+            val socket = client.newWebSocket(Request.Builder().url(server.url("/events")).build(), object : WebSocketListener() {
+                override fun onOpen(webSocket: WebSocket, response: Response) { opened.complete(response.code) }
+                override fun onMessage(webSocket: WebSocket, text: String) { message.complete(text) }
+                override fun onFailure(webSocket: WebSocket, t: Throwable, response: Response?) {
+                    opened.completeExceptionally(t)
+                    message.completeExceptionally(t)
+                }
+            })
+            try {
+                assertEquals(101, opened.get(5, TimeUnit.SECONDS).toInt())
+                assertEquals("ready", message.get(5, TimeUnit.SECONDS))
+                assertNull(uncaught.get())
+                println("WEBSOCKET SMOKE: derived cached-DNS client opened HTTP 101, received ready, no uncaught dispatcher exception")
+            } finally {
+                socket.cancel()
+                client.connectionPool.evictAll()
+                executor.shutdownNow()
+            }
+        }
+    }
+}

conductarr-client/src/test/kotlin/org/justinvisser/wolfskin/conductarr/PersistentDnsTest.kt

@@ -94,6 +94,22 @@ class PersistentDnsTest {
         assertEquals(1, queued.size)
     }
 
+    @Test fun unexpectedRefreshExceptionKeepsTheLastAnswerAndAllowsAnotherRefresh() {
+        var failing = false
+        val dns = cache(Dns { if (failing) throw IllegalStateException("resolver unavailable"); answer })
+        dns.lookup("jellyfin.test")
+        now += 120_000
+        failing = true
+        assertEquals(listOf(old), dns.lookup("jellyfin.test"))
+        queued.removeFirst().run()
+        now += 2_001
+        failing = false
+        answer = listOf(fresh)
+        assertEquals(listOf(old), dns.lookup("jellyfin.test"))
+        queued.removeFirst().run()
+        assertEquals(listOf(fresh), dns.lookup("jellyfin.test"))
+    }
+
     @Test fun failedCachedAddressForcesFreshResolutionAndRetriesBeforeSendingPost() {
         MockWebServer().use { server ->
             server.start()