python-aidot-cameras 0.15.2__tar.gz → 0.15.3__tar.gz

{python_aidot_cameras-0.15.2/python_aidot_cameras.egg-info → python_aidot_cameras-0.15.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot-cameras
-Version: 0.15.2
+Version: 0.15.3
 Summary: Control AiDot/Leedarson WiFi lights and cameras (WebRTC streaming, two-way audio, PTZ, controls)
 Author-email: cbrightly <chris.brightly@gmail.com>
 License-Expression: MIT

{python_aidot_cameras-0.15.2 → python_aidot_cameras-0.15.3}/aidot_cameras/camera/sdes.py

@@ -177,6 +177,24 @@ class SdesSession:
             "audio_pt": self._first_audio_pt[0],
         }
 
+    def _drained_stderr_tail(self) -> bytes:
+        """The stderr the drain thread already consumed, for the teardown log.
+
+        The serve's stderr is drained continuously on a daemon thread (see
+        ``_start_serve_stderr_drain`` in sdes_open) so an un-drained pipe cannot
+        fill and stall ffmpeg.  A consequence is that by teardown the pipe is at
+        EOF and stop()'s ``stderr.read()`` returns nothing, which would leave
+        ``_log_ffmpeg_stderr`` with an empty buffer and silently drop the
+        teardown diagnostic - the mid-stream ffmpeg error it exists to surface
+        included.  Fall back to the bounded tail the drainer kept.  Returns
+        ``b""`` when there is no drainer or it captured nothing, which
+        ``_log_ffmpeg_stderr`` already treats as "nothing to say".
+        """
+        tail = getattr(self._proc, "_aidot_stderr_tail", None)
+        if not tail:
+            return b""
+        return "\n".join(tail).encode("utf-8", "replace")
+
     def _log_ffmpeg_stderr(self, stderr_bytes: bytes) -> None:
         """Log ffmpeg's captured stderr at a level that matches what happened.
 
@@ -285,7 +303,7 @@ class SdesSession:
                 self._proc.stderr.close()
             except Exception:
                 _LOGGER.debug("swallowed exception in %s", 'stop', exc_info=True)
-        self._log_ffmpeg_stderr(stderr_bytes)
+        self._log_ffmpeg_stderr(stderr_bytes or self._drained_stderr_tail())
         import os
         try:
             os.unlink(self._sdp_path)

{python_aidot_cameras-0.15.2 → python_aidot_cameras-0.15.3}/aidot_cameras/camera/sdes_open.py

@@ -38,6 +38,38 @@ from .protocol import (
 
 _LOGGER = logging.getLogger(__name__)
 
+
+def _start_serve_stderr_drain(proc, *, maxlines: int = 40) -> None:
+    """Drain a serve ffmpeg's stderr continuously into a bounded tail on the proc.
+
+    The serve is spawned with ``stderr=PIPE`` but the bridge loop only polls the
+    process and reads its RTP sockets - it never reads stderr.  An un-drained
+    ``PIPE`` fills its ~64KB kernel buffer and then blocks ffmpeg on its next
+    stderr write, stalling the serve; and when ffmpeg exits non-zero the reason is
+    otherwise lost (the RTSP-push ANNOUNCE error in particular).  Read it on a
+    daemon thread that ends at EOF when the process exits, keeping the last
+    ``maxlines`` lines on ``proc._aidot_stderr_tail`` for the exit logger.
+    """
+    import collections
+    import threading
+
+    tail = collections.deque(maxlen=maxlines)
+    proc._aidot_stderr_tail = tail
+    if proc.stderr is None:
+        return
+
+    def _drain() -> None:
+        try:
+            for _line in iter(proc.stderr.readline, b""):
+                tail.append(_line.decode("utf-8", "replace").rstrip())
+        except Exception:
+            pass
+
+    threading.Thread(
+        target=_drain, daemon=True, name="aidot-sdes-serve-stderr"
+    ).start()
+
+
 # Strong references to detached per-session helper tasks, so the event loop
 # cannot garbage-collect one mid-flight.  Entries remove themselves on done.
 _SDES_BACKGROUND_TASKS: set = set()
@@ -2803,6 +2835,15 @@ class _SdesOpenMixin:
                                 _log_br.getLogger(__name__).log(
                                     _br_level, _br_msg, _br_rc
                                 )
+                                if _br_level >= _log_br.WARNING:
+                                    _serr_tail = getattr(
+                                        _br_proc, "_aidot_stderr_tail", None)
+                                    if _serr_tail:
+                                        _log_br.getLogger(__name__).warning(
+                                            "SDES serve ffmpeg stderr (last %d"
+                                            " lines):\n%s", len(_serr_tail),
+                                            "\n".join(_serr_tail),
+                                        )
                             if _bridge_should_break(
                                 _br_rc, _br_teardown_requested
                             ):
@@ -4462,6 +4503,7 @@ class _SdesOpenMixin:
                 stdout=subprocess.DEVNULL,
                 stderr=subprocess.PIPE,
             )
+            _start_serve_stderr_drain(proc)
             _proc_holder[0] = proc
             _cl(_reap, proc)   # kill ffmpeg if the open is cancelled before hand-off
         except FileNotFoundError:
@@ -4745,6 +4787,7 @@ class _SdesOpenMixin:
                             stdout=subprocess.DEVNULL,
                             stderr=subprocess.PIPE,
                         )
+                        _start_serve_stderr_drain(proc)
                         # Point the shared holder at the live proc immediately.
                         # The bridge thread polls _proc_holder[0]; if it still
                         # sees the terminated old proc it logs "stream ended",

{python_aidot_cameras-0.15.2 → python_aidot_cameras-0.15.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-aidot-cameras"
-version = "0.15.2"
+version = "0.15.3"
 description = "Control AiDot/Leedarson WiFi lights and cameras (WebRTC streaming, two-way audio, PTZ, controls)"
 readme = "README.md"
 license = "MIT"

{python_aidot_cameras-0.15.2 → python_aidot_cameras-0.15.3/python_aidot_cameras.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot-cameras
-Version: 0.15.2
+Version: 0.15.3
 Summary: Control AiDot/Leedarson WiFi lights and cameras (WebRTC streaming, two-way audio, PTZ, controls)
 Author-email: cbrightly <chris.brightly@gmail.com>
 License-Expression: MIT

{python_aidot_cameras-0.15.2 → python_aidot_cameras-0.15.3}/python_aidot_cameras.egg-info/SOURCES.txt

@@ -138,6 +138,7 @@ tests/test_sdes_idle_release.py
 tests/test_sdes_open_cleanup.py
 tests/test_sdes_serve_audio.py
 tests/test_sdes_serve_cmd.py
+tests/test_sdes_serve_stderr_drain.py
 tests/test_sdes_sprop.py
 tests/test_sdes_talk.py
 tests/test_sdes_teardown_exit_log.py

python_aidot_cameras-0.15.3/tests/test_sdes_serve_stderr_drain.py

@@ -0,0 +1,161 @@
+"""Tests for the SDES serve ffmpeg stderr drain.
+
+The serve is spawned with ``stderr=PIPE`` but the bridge loop never reads it, so an
+un-drained pipe can fill and stall ffmpeg and a non-zero exit loses its reason.
+``_start_serve_stderr_drain`` reads the pipe on a daemon thread and keeps a bounded
+tail on ``proc._aidot_stderr_tail`` for the exit logger.
+"""
+
+import asyncio
+import io
+import logging
+import time
+
+from aidot_cameras.camera.sdes import SdesSession
+from aidot_cameras.camera.sdes_open import _start_serve_stderr_drain
+
+
+class _FakeProc:
+    """Minimal stand-in exposing a readable ``stderr``, like ``subprocess.Popen``."""
+
+    def __init__(self, data: bytes) -> None:
+        self.stderr = io.BytesIO(data)
+
+
+def _tail(proc) -> list:
+    """The captured stderr tail (attribute is set dynamically by the drainer)."""
+    return list(getattr(proc, "_aidot_stderr_tail"))
+
+
+def _wait_until(pred, timeout: float = 2.0) -> None:
+    deadline = time.monotonic() + timeout
+    while not pred():
+        if time.monotonic() > deadline:
+            break
+        time.sleep(0.01)
+
+
+def test_stderr_drain_captures_lines() -> None:
+    proc = _FakeProc(b"line one\nline two\nline three\n")
+    _start_serve_stderr_drain(proc)
+    _wait_until(lambda: _tail(proc)[-1:] == ["line three"])
+    assert _tail(proc) == ["line one", "line two", "line three"]
+
+
+def test_stderr_drain_is_bounded_to_the_tail() -> None:
+    data = b"".join(f"l{i}\n".encode() for i in range(100))
+    proc = _FakeProc(data)
+    _start_serve_stderr_drain(proc, maxlines=10)
+    _wait_until(lambda: _tail(proc)[-1:] == ["l99"])
+    assert _tail(proc) == [f"l{i}" for i in range(90, 100)]
+
+
+def test_stderr_none_is_safe() -> None:
+    class _NoStderr:
+        stderr = None
+
+    proc = _NoStderr()
+    _start_serve_stderr_drain(proc)  # must not raise
+    assert _tail(proc) == []
+
+
+class _TornDownProc:
+    """A serve proc whose stderr pipe the drainer already emptied.
+
+    ``stop()`` reads ``stderr`` after the process is gone; with the drain thread
+    running that read returns nothing, so the teardown diagnostic has to come
+    from the tail the drainer kept.
+    """
+
+    def __init__(self, tail: list) -> None:
+        self._alive = True
+        self.returncode = 0
+        self.stderr = self
+        self._aidot_stderr_tail = tail
+
+    def poll(self):
+        return None if self._alive else self.returncode
+
+    def terminate(self):
+        self._alive = False
+
+    def wait(self, timeout=None):
+        self._alive = False
+        return self.returncode
+
+    def kill(self):
+        self._alive = False
+
+    def read(self):  # stderr.read() - the drainer got there first
+        return b""
+
+
+class _FakeSock:
+    def close(self) -> None:
+        pass
+
+
+class _FakeQ:
+    def put_nowait(self, _x) -> None:
+        pass
+
+
+def _stopped_session(tail: list) -> None:
+    """Run the real ``SdesSession.stop()`` against a drained serve proc."""
+    session = SdesSession(
+        proc=_TornDownProc(tail),
+        sdp_path="/tmp/aidot_test_does_not_exist.sdp",
+        outgoing_q=_FakeQ(),
+        mqtt_fut=None,
+        audio_sock=_FakeSock(),
+        video_sock=_FakeSock(),
+        cmd_chan=[None],
+        talk_state=None,
+    )
+    asyncio.run(session.stop())
+
+
+def test_teardown_logs_the_drained_tail_when_the_pipe_is_empty(caplog) -> None:
+    # Without the fallback this diagnostic is lost entirely: the drain thread
+    # consumed the pipe, so stop()'s stderr.read() has nothing left to log.
+    caplog.set_level(logging.DEBUG, logger="aidot_cameras.camera.sdes")
+    _stopped_session(["frame= 120 fps=20", "Error writing trailer: Broken pipe"])
+    warnings = [
+        r for r in caplog.records
+        if r.levelno == logging.WARNING and "ffmpeg SDES stderr" in r.getMessage()
+    ]
+    assert warnings, "a mid-stream ffmpeg error must still reach the log"
+    assert "Error writing trailer: Broken pipe" in warnings[0].getMessage()
+
+
+def test_teardown_tail_still_demotes_the_expected_no_media_shape(caplog) -> None:
+    # The tail feeds the SAME classifier, so a camera that never sent media does
+    # not start warning once per retry just because the stderr route changed.
+    caplog.set_level(logging.DEBUG, logger="aidot_cameras.camera.sdes")
+    _stopped_session(["Output file is empty, nothing was encoded"])
+    assert not [
+        r for r in caplog.records
+        if r.levelno == logging.WARNING and "ffmpeg SDES stderr" in r.getMessage()
+    ]
+    assert [
+        r for r in caplog.records
+        if r.levelno == logging.DEBUG and "ffmpeg SDES stderr" in r.getMessage()
+    ]
+
+
+def test_teardown_without_a_tail_logs_nothing(caplog) -> None:
+    caplog.set_level(logging.DEBUG, logger="aidot_cameras.camera.sdes")
+    _stopped_session([])
+    assert not [
+        r for r in caplog.records if "ffmpeg SDES stderr" in r.getMessage()
+    ]
+
+
+def test_undecodable_bytes_do_not_crash_the_drain() -> None:
+    proc = _FakeProc(b"good\n\xff\xfe bad bytes\ndone\n")
+    _start_serve_stderr_drain(proc)
+    _wait_until(lambda: _tail(proc)[-1:] == ["done"])
+    tail = _tail(proc)
+    assert tail[0] == "good"
+    assert tail[-1] == "done"
+    assert len(tail) == 3