fix(client): align delete_stream poll window with 300s server drain

librtmp2-server now waits up to 300s (DELETE_DRAIN_TIMEOUT) before
finalizing an async stream delete. The panel client still defaulted to
35s, so operators deleting live streams saw a false failure while the
server was still draining normally.

Raise DELETE_STREAM_DRAIN_WAIT_SECONDS to 305 and bump the Docker
Gunicorn --timeout to 330 so the synchronous delete route can wait out
the full server drain window.

Co-authored-by: Alexander Wagner <info@alexanderwagnerdev.com>

Author: cursoragent

.cursor/bug-scan-progress.md

@@ -1,18 +1,39 @@
 # Bug scan progress
 
-Last scanned: app.py — 2026-07-15
+Last scanned: lrtmp2_client.py — 2026-08-12
 
 ## Module checklist
 
 - [x] `app.py` — Flask routes, auth, session handling, stream CRUD
-- [ ] `lrtmp2_client.py` — librtmp2-server REST API client
+- [x] `lrtmp2_client.py` — librtmp2-server REST API client
 - [ ] `config.py` — startup validation and environment configuration
 - [ ] `templates/` — Jinja2 templates (XSS, CSRF forms)
 - [ ] `static/js/` — frontend JavaScript (DOM injection, fetch logic)
 
 (`templates/`/`static/js/` were actually scanned 2026-07-05/06, see findings
 below — checkboxes just hadn't been ticked.)
 
+## Findings (2026-08-12 lrtmp2_client.py pass)
+
+- **Bug (fixed):** `delete_stream()` default `wait_timeout=35` was sized for an
+  obsolete 30s librtmp2-server RTMP drain window. Current server
+  `DELETE_DRAIN_TIMEOUT` is **300s** (`librtmp2-server` `src/http.rs`): during
+  drain the stream stays in `GET /api/v1/streams` with `enabled=false` until
+  finalize. Scenario: operator deletes a live stream with long-lived RTMP
+  sessions; server returns HTTP 202 and keeps draining; after 35s the panel
+  raises `Lrtmp2ApiError` ("stream is still present…") even though the delete
+  is still progressing normally on the server for up to five more minutes.
+  Impact: false failure during incident response — operator believes the revoke
+  failed and may stop monitoring while publish/play keys remain valid until
+  drain completes. Fixed by defaulting `wait_timeout` to 305s
+  (`DELETE_STREAM_DRAIN_WAIT_SECONDS`) and raising the Docker Gunicorn
+  `--timeout` to 330s so the synchronous delete route can outlast the server
+  drain.
+- Reviewed but not a bug: network/JSON errors wrapped as `Lrtmp2ApiError`;
+  path segments URL-encoded; Bearer token only in Authorization header;
+  `delete_stream` 202 polling until stream disappears; `cluster_remove_node`
+  surfaces 404; per-call timeouts; no shared mutable request state.
+
 ## Findings (2026-07-15 app.py pass)
 
 - **Bug (fixed):** `delete_stream()` moved deletes into a daemon background

Dockerfile

@@ -37,4 +37,4 @@ HEALTHCHECK --interval=30s --timeout=5s --retries=3 \
     CMD wget -qO- http://localhost:8000/login || exit 1
 
 ENTRYPOINT ["entrypoint.sh"]
-CMD ["gunicorn", "--bind", "0.0.0.0:8000", "--worker-class", "gthread", "--threads", "4", "--timeout", "60", "app:app"]
+CMD ["gunicorn", "--bind", "0.0.0.0:8000", "--worker-class", "gthread", "--threads", "4", "--timeout", "330", "app:app"]

lrtmp2_client.py

@@ -8,6 +8,11 @@ class Lrtmp2ApiError(Exception):
     pass
 
 
+# librtmp2-server's production DELETE_DRAIN_TIMEOUT is 300s (src/http.rs).
+# The panel must outlast that window when polling list_streams after HTTP 202.
+DELETE_STREAM_DRAIN_WAIT_SECONDS = 305
+
+
 def _api_error(resp, operation):
     """Return a user-safe error; log details only in the exception message prefix."""
     msg = f"{operation} failed (HTTP {resp.status_code})"
@@ -110,16 +115,22 @@ def create_stream(
             json=payload,
         )
 
-    def delete_stream(self, stream_id, wait_timeout=35, poll_interval=0.5):
+    def delete_stream(
+        self,
+        stream_id,
+        wait_timeout=DELETE_STREAM_DRAIN_WAIT_SECONDS,
+        poll_interval=0.5,
+    ):
         """Delete a stream. librtmp2-server may accept the request with `202`
         and finish the delete asynchronously (draining active RTMP sessions
         first) — poll until the stream actually disappears from the list so
         callers can rely on the stream being gone once this returns, rather
-        than racing the background delete. librtmp2-server waits up to 30s for
-        active RTMP sessions to drain before giving up, so the default
-        wait_timeout is 35s. If the stream is still listed after that window,
-        raises Lrtmp2ApiError so the panel can surface the incomplete delete
-        instead of silently redirecting while the stream remains.
+        than racing the background delete. librtmp2-server waits up to 300s for
+        active RTMP sessions to drain before abandoning local roles and
+        finalizing, so the default wait_timeout is 305s. If the stream is
+        still listed after that window, raises Lrtmp2ApiError so the panel can
+        surface the incomplete delete instead of silently redirecting while the
+        stream remains.
         """
         resp = self._request(
             requests.delete,

tests/test_delete_runtime.py

@@ -19,7 +19,7 @@ def test_container_uses_threaded_gunicorn_for_long_running_deletes():
     assert command[0] == "gunicorn"
     assert command[command.index("--worker-class") + 1] == "gthread"
     assert command[command.index("--threads") + 1] == "4"
-    assert command[command.index("--timeout") + 1] == "60"
+    assert command[command.index("--timeout") + 1] == "330"
 
 
 def test_delete_stream_logs_api_failure(monkeypatch):

tests/test_lrtmp2_client.py

@@ -3,7 +3,11 @@
 import pytest
 import requests
 
-from lrtmp2_client import Lrtmp2ApiError, Lrtmp2Client
+from lrtmp2_client import (
+    DELETE_STREAM_DRAIN_WAIT_SECONDS,
+    Lrtmp2ApiError,
+    Lrtmp2Client,
+)
 
 
 def test_health_sends_bearer_token():
@@ -43,6 +47,14 @@ def test_create_player_posts_optional_fields():
     assert payload["play_key"] == "play_key_with_sufficient_length_here01"
 
 
+def test_delete_stream_default_wait_matches_server_drain_window():
+    import inspect
+
+    sig = inspect.signature(Lrtmp2Client.delete_stream)
+    assert sig.parameters["wait_timeout"].default == DELETE_STREAM_DRAIN_WAIT_SECONDS
+    assert DELETE_STREAM_DRAIN_WAIT_SECONDS == 305
+
+
 def test_delete_stream_treats_404_as_success():
     client = Lrtmp2Client("http://example.test", "tok")
     with patch("lrtmp2_client.requests.delete") as mock_delete: