python-aidot-cameras 0.12.11__tar.gz → 0.12.12__tar.gz

{python_aidot_cameras-0.12.11/python_aidot_cameras.egg-info → python_aidot_cameras-0.12.12}/PKG-INFO

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

@@ -148,6 +148,13 @@ _BG_TASKS: set = set()
 # means refetching is not helping, so back off rather than loop.
 _MQTT_CREDENTIAL_REFETCH_FLOOR = 30.0
 
+# How often the "is anyone watching" question may actually reach go2rtc. The
+# watchdog loops tick twice a second; asking that often opens a fresh HTTP
+# session per camera per tick against the service that also has to serve the
+# video. Idle release is measured in minutes, so seconds of staleness here costs
+# nothing.
+_VIEWER_CHECK_INTERVAL_S = 10.0
+
 
 def _spawn_bg(coro):
     _t = asyncio.ensure_future(coro)
@@ -2937,6 +2944,10 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
         register, deregister and viewer-count paths cannot drift apart."""
         return f"aidot_{self.device_id[:12]}"
 
+    # Cached answer to "is anyone watching", so the watchdog loops can ask on
+    # every tick without hammering go2rtc.
+    _viewer_cache: "tuple[float, Optional[bool]]" = (0.0, None)
+
     async def _viewer_present(self, port: int) -> "Optional[bool]":
         """Is anyone ACTUALLY watching?  True / False / None (unknown).
 
@@ -2952,6 +2963,17 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
         Falls back to the TCP-table check when go2rtc is not in use, and returns
         None (never release) if neither can answer.
         """
+        # THROTTLE FIRST.  The DTLS watchdog calls this every 0.5s and the SDES
+        # one on a similar cadence, and the go2rtc query below opens a fresh HTTP
+        # session each time - so an unthrottled check is two requests per second
+        # per camera, forever, against the very service that has to serve the
+        # video.  On a small fleet that is enough load to stop go2rtc answering
+        # at all, which looks exactly like "no video anywhere".
+        _now_mono = time.monotonic()
+        _last, _cached = self._viewer_cache
+        if _now_mono - _last < _VIEWER_CHECK_INTERVAL_S:
+            return _cached
+
         name = self._go2rtc_stream_name()
         base = self._go2rtc_url
         if not base:
@@ -2968,6 +2990,7 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
                     "no go2rtc url and the serve is an RTSP push to a shared "
                     "port; cannot tell whether anyone is watching",
                 )
+                self._viewer_cache = (_now_mono, None)
                 return None
         if base and name:
             try:
@@ -2977,10 +3000,14 @@ class CameraMixin(_CameraControlsMixin, _WebRTCOpenMixin, _SdesOpenMixin):
                 async with aiohttp.ClientSession() as _s:
                     viewers = await Go2rtcClient(_s, base).viewer_count(name)
                 if viewers is not None:
-                    return viewers > 0
+                    _answer = viewers > 0
+                    self._viewer_cache = (_now_mono, _answer)
+                    return _answer
             except Exception as exc:
                 _LOGGER.debug("go2rtc viewer check failed: %s", exc)
-        return self._sdes_serve_consumer_present(port)
+        _answer = self._sdes_serve_consumer_present(port)
+        self._viewer_cache = (_now_mono, _answer)
+        return _answer
 
     async def _sdes_keepalive_loop(self) -> None:
         """Keep the cold-start serve relay alive around the SDES keepalive loop.

{python_aidot_cameras-0.12.11 → python_aidot_cameras-0.12.12}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-aidot-cameras"
-version = "0.12.11"
+version = "0.12.12"
 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.11 → python_aidot_cameras-0.12.12/python_aidot_cameras.egg-info}/PKG-INFO

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

@@ -137,5 +137,6 @@ tests/test_terminal_ack.py
 tests/test_token_file_robustness.py
 tests/test_token_refresh.py
 tests/test_upstream_compat.py
+tests/test_viewer_check_throttle.py
 tests/test_viewer_presence.py
 tests/test_wait_or_event.py

python_aidot_cameras-0.12.12/tests/test_viewer_check_throttle.py

@@ -0,0 +1,71 @@
+"""The viewer check must not be asked of go2rtc on every watchdog tick.
+
+The DTLS watchdog loops twice a second, and the go2rtc query opens a fresh HTTP
+session per call - so an unthrottled check is two requests per second per camera,
+forever, aimed at the very service that also has to serve the video. On a small
+fleet that was enough to stop go2rtc answering at all, which presents as no video
+anywhere. Idle release is measured in minutes, so a few seconds of staleness in
+the answer costs nothing.
+"""
+import asyncio
+import time
+
+import aidot_cameras.camera.client as cc
+from aidot_cameras.device_client import CameraDeviceClient
+
+
+def _client(answer):
+    c = CameraDeviceClient.__new__(CameraDeviceClient)
+    c._go2rtc_url = None
+    c._keepalive_rtsp_url = "http://127.0.0.1:18931/x.ts"
+    c.device_id = "abc123abc123def"
+    c._viewer_cache = (0.0, None)
+    calls = []
+
+    def _probe(port):
+        calls.append(port)
+        return answer
+
+    c._sdes_serve_consumer_present = _probe
+    return c, calls
+
+
+def test_repeated_calls_hit_the_backend_once():
+    c, calls = _client(True)
+
+    async def go():
+        for _ in range(40):          # 40 watchdog ticks
+            await c._viewer_present(18931)
+    asyncio.run(go())
+    assert len(calls) == 1, f"backend hit {len(calls)} times, expected 1"
+
+
+def test_the_cached_answer_is_returned_verbatim():
+    for answer in (True, False, None):
+        c, _ = _client(answer)
+
+        async def go():
+            first = await c._viewer_present(18931)
+            second = await c._viewer_present(18931)
+            return first, second
+        first, second = asyncio.run(go())
+        assert first == answer and second == answer
+
+
+def test_the_cache_expires_so_the_answer_can_change():
+    c, calls = _client(True)
+
+    async def go():
+        await c._viewer_present(18931)
+        # Pretend the interval has elapsed.
+        stamp, cached = c._viewer_cache
+        c._viewer_cache = (stamp - cc._VIEWER_CHECK_INTERVAL_S - 1, cached)
+        await c._viewer_present(18931)
+    asyncio.run(go())
+    assert len(calls) == 2
+
+
+def test_the_interval_is_long_enough_to_matter():
+    # The watchdog ticks every 0.5s; anything under a couple of seconds would
+    # still be a request storm.
+    assert cc._VIEWER_CHECK_INTERVAL_S >= 5.0