python-aidot-cameras 0.12.15__tar.gz → 0.12.16__tar.gz

{python_aidot_cameras-0.12.15/python_aidot_cameras.egg-info → python_aidot_cameras-0.12.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot-cameras
-Version: 0.12.15
+Version: 0.12.16
 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.12.15 → python_aidot_cameras-0.12.16}/aidot_cameras/camera/client.py

@@ -3057,11 +3057,30 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
         # lifetime; an integration reload / restart re-probes the fast path.
         _fast_failed = bool(getattr(self, "_fast_path_unavailable", False))
 
+        # Reuse ONE peerid across the retries of this loop instead of minting a
+        # fresh one per attempt. A fresh peerid = a new camera-side session, and
+        # the camera frees old ones only slowly, so mint-per-retry stacks up
+        # sessions on a failing battery camera faster than they drain (measured:
+        # this is how the L2 wedged into a wake-then-sleep loop). Mirrors the
+        # official app, which resends within one session. Rotate to a fresh
+        # peerid after a session that actually delivered media (so the next view
+        # is a clean session) or after _PEERID_MAX_REUSE consecutive dead
+        # attempts (so a poisoned peerid can't wedge us permanently).
+        _PEERID_MAX_REUSE = 3
+        _loop_peer_id = self.generate_webrtc_peer_id(live_type=2, stream_id=0,
+                                                     sdes=True)
+        _peer_reuses = 0
+
         while self._streaming_active:
             if self._serve_relay is not None:
                 # Clear any stale backend from a prior session; the open below
                 # points the relay at this session's fresh internal ffmpeg port.
                 self._serve_relay.set_backend(None)
+            if _peer_reuses >= _PEERID_MAX_REUSE:
+                _loop_peer_id = self.generate_webrtc_peer_id(
+                    live_type=2, stream_id=0, sdes=True)
+                _peer_reuses = 0
+            _peer_reuses += 1
             _use_fast = self._adaptive_next_fast(_adaptive, _fast_failed)
             if _adaptive:
                 self._fast_attempt_override = _use_fast
@@ -3069,10 +3088,31 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
                 session = await self.async_open_webrtc_stream(
                     rtsp_push_url=self._keepalive_rtsp_url,
                     timeout=(_FAST_OPEN_TIMEOUT if _use_fast else 120.0),
+                    reuse_peer_id=_loop_peer_id,
                 )
             except asyncio.CancelledError:
                 self._fast_attempt_override = None
                 return
+            except AidotCameraBusy as busy:
+                # The camera itself said it has no free session (-50002 max
+                # concurrent streams / -50015). Each retry mints a NEW peerid and
+                # so registers ANOTHER camera-side session, which the camera only
+                # releases slowly - so retrying on the short backoff makes the
+                # shortage worse and can wedge a battery camera into a
+                # wake-then-sleep loop that serves nothing. Wait out the release
+                # window instead. (The DTLS loops have always done this; the SDES
+                # loop silently did not.)
+                self._fast_attempt_override = None
+                _LOGGER.warning(
+                    "SDES keepalive: camera %s refused the stream (%s) - "
+                    "backing off %.0fs so its sessions can be released",
+                    self.device_id, busy, _MAX_DELAY,
+                )
+                try:
+                    await asyncio.sleep(_MAX_DELAY)
+                except asyncio.CancelledError:
+                    return
+                continue
             except Exception as exc:
                 self._fast_attempt_override = None
                 if _use_fast:
@@ -3197,6 +3237,13 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
             # Adaptive bookkeeping: a fast attempt that never delivered media
             # latches the loop onto the full relay path for its remaining opens.
             _healthy = session.last_media_monotonic > 0.0
+            if _healthy:
+                # A session that delivered media is a real, cleanly-used session;
+                # the next open should be a fresh one rather than re-offering on a
+                # peerid the camera has already finished with.
+                _loop_peer_id = self.generate_webrtc_peer_id(
+                    live_type=2, stream_id=0, sdes=True)
+                _peer_reuses = 0
             if _use_fast and not _healthy and not _fast_failed:
                 _LOGGER.info(
                     "SDES adaptive[%s]: fast attempt delivered no media - "

{python_aidot_cameras-0.12.15 → python_aidot_cameras-0.12.16}/aidot_cameras/camera/webrtc_open.py

@@ -159,6 +159,7 @@ class _WebRTCOpenMixin:
         rtsp_push_url: Optional[str] = None,
         talk_pcm_provider: "Optional[Callable[[], Optional[bytes]]]" = None,
         talk: bool = False,
+        reuse_peer_id: Optional[str] = None,
     ) -> "WebRTCSession":
         """Open a liveType=2 WebRTC stream via MQTT signaling.
 
@@ -497,7 +498,14 @@ class _WebRTCOpenMixin:
         _dtls_fallback_ok = str(_cam_props.get("isDTLS", "1")) != "0"
 
         device_id = self.device_id
-        peer_id   = self.generate_webrtc_peer_id(
+        # A fresh peerid mints a NEW camera-side session, and the camera releases
+        # old ones only slowly (~3-4 min measured), so minting one on every retry
+        # of a failing loop stacks up sessions faster than they drain and can wedge
+        # a battery camera. The official app instead reuses one peerid and resends
+        # the same offer within a single session. ``reuse_peer_id`` lets a caller
+        # (the SDES keepalive loop) hold one peerid across retries; None keeps the
+        # historical mint-per-attempt behaviour for every other caller.
+        peer_id   = reuse_peer_id or self.generate_webrtc_peer_id(
             live_type=2, stream_id=stream_id, sdes=use_sdes
         )
         loop      = asyncio.get_running_loop()
@@ -1212,7 +1220,26 @@ class _WebRTCOpenMixin:
         # Branch: SDES-SRTP cameras use ffmpeg; DTLS cameras use aiortc
         # ------------------------------------------------------------------ #
         if use_sdes:
+            def _raise_if_camera_refused():
+                """Surface a terminal webrtcResp ack on the SDES path too.
+
+                GAP D was only wired into the DTLS branch: the shared message
+                handler records -50002 (max concurrent streams) / -50015 into
+                ``terminal_error_fut`` for BOTH transports, but only the DTLS
+                connect ever read it.  So when a battery camera answered "no
+                free session", the SDES keepalive loop treated it as a generic
+                failure and retried on the short backoff - hammering the very
+                camera that had just said it was full, and registering yet
+                another peerid each time.  Raising AidotCameraBusy lets the
+                loop back off for the camera's release window instead.
+                """
+                if terminal_error_fut.done():
+                    _code, _desc = terminal_error_fut.result()
+                    _status(f"camera refused the stream (code={_code}) - not retrying")
+                    raise AidotCameraBusy(_code, _desc)
+
             try:
+                _raise_if_camera_refused()
                 _sdes_session = await self._open_sdes_stream(
                     peer_id=peer_id,
                     user_id=user_id,
@@ -1248,7 +1275,13 @@ class _WebRTCOpenMixin:
                 # DTLS-fallback path below keeps the slot for its own hand-off.)
                 self._release_stream_drain_to_session()
                 return _sdes_session
+            except AidotCameraBusy:
+                raise
             except CameraMixin._SdesNoAnswerError:
+                # A terminal refusal that lands while we were waiting surfaces
+                # as a no-answer; check before spending a DTLS fallback on a
+                # camera that has already told us it has no free session.
+                _raise_if_camera_refused()
                 # Camera reported enableSdes='1' but did not respond to our SDES
                 # offer.  iOS telemetry shows models such as LK.IPC.A001064 can
                 # have an incorrectly set enableSdes property while actually

{python_aidot_cameras-0.12.15 → python_aidot_cameras-0.12.16}/pyproject.toml

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

{python_aidot_cameras-0.12.15 → python_aidot_cameras-0.12.16/python_aidot_cameras.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot-cameras
-Version: 0.12.15
+Version: 0.12.16
 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.12.15 → python_aidot_cameras-0.12.16}/python_aidot_cameras.egg-info/SOURCES.txt

@@ -106,6 +106,7 @@ tests/test_no_undefined_names.py
 tests/test_offline_keepalive_pause.py
 tests/test_open_fail_logger.py
 tests/test_open_gate_delay.py
+tests/test_peerid_reuse.py
 tests/test_persistent_mqtt.py
 tests/test_persistent_mqtt_robustness.py
 tests/test_playback_tls.py
@@ -123,6 +124,7 @@ tests/test_sdes_serve_cmd.py
 tests/test_sdes_sprop.py
 tests/test_sdes_talk.py
 tests/test_sdes_teardown_exit_log.py
+tests/test_sdes_terminal_ack.py
 tests/test_sdes_watchdog.py
 tests/test_sdp_payload_type_narrowing.py
 tests/test_security_hardening.py

python_aidot_cameras-0.12.16/tests/test_peerid_reuse.py

@@ -0,0 +1,69 @@
+"""The SDES keepalive loop reuses one peerid across retries instead of minting
+a fresh one every attempt.
+
+A fresh peerid registers a NEW camera-side session, and the camera releases old
+ones only slowly (~3-4 min measured), so minting one per retry on a failing loop
+stacks up sessions faster than they drain - which is how a battery A001513 gets
+wedged into a wake-then-sleep loop that serves nothing. The official app reuses a
+peerid and resends within one session. This locks:
+  - the impl accepts reuse_peer_id and uses it verbatim when given;
+  - it still mints a fresh one when not given (unchanged for every other caller);
+  - the SDES keepalive loop holds one across retries and rotates it after a
+    media-delivering session or a reuse cap.
+"""
+import inspect
+import os
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+import aidot_cameras.camera.client as cc
+
+
+def _impl_signature():
+    for cls in vars(cc).values():
+        if isinstance(cls, type) and "_async_open_webrtc_stream_impl" in cls.__dict__:
+            return inspect.signature(cls.__dict__["_async_open_webrtc_stream_impl"])
+    raise AssertionError("impl not found")
+
+
+def _fn_source(qualname):
+    for cls in vars(cc).values():
+        if isinstance(cls, type) and qualname in cls.__dict__:
+            return inspect.getsource(cls.__dict__[qualname])
+    raise AssertionError(f"{qualname} not found")
+
+
+def test_impl_accepts_reuse_peer_id_defaulting_to_none():
+    p = _impl_signature().parameters.get("reuse_peer_id")
+    assert p is not None, "impl must accept reuse_peer_id"
+    assert p.default is None, "default None preserves mint-per-call for other callers"
+
+
+def test_impl_uses_reuse_peer_id_verbatim_when_given():
+    src = _fn_source("_async_open_webrtc_stream_impl")
+    # peer_id = reuse_peer_id or generate_webrtc_peer_id(...)
+    assert "reuse_peer_id or" in src, (
+        "when a peerid is supplied it must be used as-is, not regenerated")
+
+
+def test_sdes_keepalive_loop_holds_and_rotates_one_peerid():
+    src = _fn_source("_sdes_keepalive_loop_inner")
+    assert "reuse_peer_id=" in src, "the SDES loop must pass a reused peerid"
+    assert "_loop_peer_id" in src
+    # rotate after a media-delivering session and after a reuse cap
+    assert "_PEERID_MAX_REUSE" in src, "must cap consecutive reuses"
+    assert src.count("generate_webrtc_peer_id") >= 2, (
+        "must be able to rotate to a fresh peerid (initial + rotation)")
+
+
+def test_generate_peer_id_is_unique_per_call():
+    gen = None
+    for cls in vars(cc).values():
+        if isinstance(cls, type) and "generate_webrtc_peer_id" in cls.__dict__:
+            gen = cls.generate_webrtc_peer_id
+            break
+    assert gen is not None
+    a = gen(live_type=2, stream_id=0, sdes=True)
+    b = gen(live_type=2, stream_id=0, sdes=True)
+    assert a != b and a.endswith("_2_0_1") and b.endswith("_2_0_1")

python_aidot_cameras-0.12.16/tests/test_sdes_terminal_ack.py

@@ -0,0 +1,73 @@
+"""A terminal webrtcResp ack must be honoured on the SDES path, not just DTLS.
+
+The shared message handler records -50002 ("max concurrent streams") and -50015
+into ``terminal_error_fut`` for BOTH transports, but only the DTLS connect ever
+read it. So when a battery camera answered "no free session", the SDES keepalive
+loop saw a generic failure and retried on the short backoff - hammering the very
+camera that had just said it was full, and minting a NEW peerid (= another
+camera-side session, released only slowly) on every attempt. That is how a
+battery A001513 gets wedged into a wake-then-sleep loop that serves nothing.
+
+These tests lock the two halves of the fix: the codes are classified as
+terminal, and the SDES keepalive loop treats AidotCameraBusy as "back off for
+the release window" rather than "retry immediately".
+"""
+import inspect
+import os
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from aidot_cameras.camera.protocol import (
+    _WEBRTC_TERMINAL_ACK_CODES,
+    _terminal_webrtc_ack,
+)
+import aidot_cameras.camera.client as cc
+import aidot_cameras.camera.webrtc_open as wo
+
+
+def test_session_exceed_codes_are_terminal():
+    assert -50002 in _WEBRTC_TERMINAL_ACK_CODES
+    assert -50015 in _WEBRTC_TERMINAL_ACK_CODES
+
+
+def test_terminal_ack_parses_session_exceed():
+    msg = {"method": "webrtcResp", "ack": {"code": -50002, "desc": "SESSION_EXCEED"}}
+    got = _terminal_webrtc_ack(msg)
+    assert got is not None
+    assert got[0] == -50002
+
+
+def test_transient_ack_is_not_terminal():
+    # -50019 ("not ready") is benign: mains cameras emit it and recover via ICE.
+    msg = {"method": "webrtcResp", "ack": {"code": -50019, "desc": "not ready"}}
+    assert _terminal_webrtc_ack(msg) is None
+
+
+def _fn_source(mod, qualname):
+    """Source of a method by name, without relying on file offsets."""
+    for cls in vars(mod).values():
+        if isinstance(cls, type):
+            fn = cls.__dict__.get(qualname)
+            if fn is not None:
+                return inspect.getsource(fn)
+    raise AssertionError(f"{qualname} not found in {mod.__name__}")
+
+
+def test_sdes_open_path_checks_the_terminal_future():
+    # The SDES branch must consult terminal_error_fut; before the fix it never did.
+    src = _fn_source(wo, "_async_open_webrtc_stream_impl")
+    sdes_branch = src[src.rindex("if use_sdes:"):]
+    assert "terminal_error_fut" in sdes_branch, (
+        "SDES branch must read terminal_error_fut (GAP D was DTLS-only)")
+    assert "AidotCameraBusy" in sdes_branch
+
+
+def test_sdes_keepalive_loop_backs_off_on_camera_busy():
+    loop_src = _fn_source(cc, "_sdes_keepalive_loop_inner")
+    assert "except AidotCameraBusy" in loop_src, (
+        "the SDES keepalive loop must honour a camera refusal instead of "
+        "retrying on the short backoff")
+    busy_at = loop_src.index("except AidotCameraBusy")
+    assert "_MAX_DELAY" in loop_src[busy_at:busy_at + 1600], (
+        "a camera refusal must wait out the long release window")