python-aidot-cameras 0.7.35__tar.gz → 0.8.0__tar.gz

{python_aidot_cameras-0.7.35/src/python_aidot_cameras.egg-info → python_aidot_cameras-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-aidot-cameras
-Version: 0.7.35
+Version: 0.8.0
 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.7.35 → python_aidot_cameras-0.8.0}/pyproject.toml

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

{python_aidot_cameras-0.7.35 → python_aidot_cameras-0.8.0}/src/aidot/camera/client.py

@@ -584,6 +584,7 @@ class CameraMixin(_CameraControlsMixin):
         self._streaming_active: bool = False
         self._stream_session: Optional[Any] = None
         self._stream_task: Optional["asyncio.Task[None]"] = None
+        self._stream_mqtt_drain: Optional["asyncio.Future"] = None
         self._last_frame_time: float = 0.0
         self._keepalive_rtsp_url: Optional[str] = None  # local serve URL (go2rtc pulls)
         self._go2rtc_url: Optional[str] = None           # go2rtc API base (prefer-go2rtc)
@@ -1339,6 +1340,20 @@ class CameraMixin(_CameraControlsMixin):
                 subscribe_topics=sub_topics,
                 timeout=timeout,
             )
+            if _st and _st.get("error"):
+                # Persistent connection unavailable - fall back to a fresh per-op
+                # connect so the command isn't silently dropped (and isn't falsely
+                # reported as sent on the empty result the persistent path returns).
+                _LOGGER.debug(
+                    "_mqtt_device_cmd: persistent MQTT failed (%s); falling back "
+                    "to a per-op session for %s", _st.get("error"), device_id,
+                )
+                messages = await _mqtt_session(
+                    mqtt_url, mqtt_user, mqtt_pwd, client_id,
+                    subscribe_topics=sub_topics,
+                    publish_items=publish_items,
+                    duration=timeout,
+                )
         else:
             messages = await _mqtt_session(
                 mqtt_url, mqtt_user, mqtt_pwd, client_id,
@@ -1582,6 +1597,20 @@ class CameraMixin(_CameraControlsMixin):
                 subscribe_topics=sub_topics,
                 timeout=timeout,
             )
+            if _st and _st.get("error"):
+                # Persistent connection unavailable - fall back to a fresh per-op
+                # connect so a transient outage doesn't masquerade as "no attrs".
+                _LOGGER.debug(
+                    "async_get_camera_attributes: persistent MQTT failed (%s); "
+                    "falling back to a per-op session for %s",
+                    _st.get("error"), device_id,
+                )
+                messages = await _mqtt_session(
+                    mqtt_url, mqtt_user, mqtt_pwd, client_id,
+                    subscribe_topics=sub_topics,
+                    publish_items=publish_items,
+                    duration=timeout,
+                )
         else:
             messages = await _mqtt_session(
                 mqtt_url, mqtt_user, mqtt_pwd, client_id,
@@ -1981,6 +2010,37 @@ class CameraMixin(_CameraControlsMixin):
                 await task
             except (asyncio.CancelledError, Exception):
                 _LOGGER.debug("camera %s: swallowed exception", 'async_stop_streaming', exc_info=True)
+        # Reap a persistent-MQTT stream drain that no session stopped (e.g. an
+        # open cancelled mid-handshake) so its handler is removed from the shared
+        # connection and its blocked executor thread is released.
+        await self._reap_stream_drain()
+
+    async def _reap_stream_drain(self):
+        """Stop and reap the persistent-MQTT stream drain task, if any.
+
+        The drain blocks an executor thread on ``outgoing_q.get`` until a ``None``
+        sentinel arrives. A normal stop pushes that sentinel from the
+        WebRTCSession/SdesSession; but if no session took ownership (open
+        cancelled mid-handshake) or a new open replaced this one, we must push it
+        ourselves - cancelling the future alone cannot interrupt the blocked
+        thread, leaking it (and its handler on the shared connection) forever."""
+        drain = getattr(self, "_stream_mqtt_drain", None)
+        outq = getattr(self, "_stream_mqtt_outq", None)
+        self._stream_mqtt_drain = None
+        self._stream_mqtt_outq = None
+        if drain is None:
+            return
+        if outq is not None:
+            try:
+                outq.put_nowait(None)   # release the executor thread in outgoing_q.get
+            except Exception:
+                _LOGGER.debug("camera %s: swallowed exception", '_reap_stream_drain', exc_info=True)
+        if not drain.done():
+            drain.cancel()
+        try:
+            await drain
+        except (asyncio.CancelledError, Exception):
+            _LOGGER.debug("camera %s: swallowed exception", '_reap_stream_drain', exc_info=True)
 
     async def async_start_motion_polling(
         self, callback: Callable, interval: float = 30.0, lookback_s: int = 600,
@@ -2833,19 +2893,28 @@ class CameraMixin(_CameraControlsMixin):
         pm = li.get("_persistent_mqtt")
         if pm is not None:
             return pm
-        smarthome_auth = await self._async_get_smarthome_auth()
-        mqtt_user = (smarthome_auth or {}).get("mqttUser") or str(self.user_id)
-        mqtt_pwd  = (smarthome_auth or {}).get("mqttPassword") or ""
-        client_id = (self._user_info.get("mqttClientId") or f"app-{mqtt_user}")
-        mqtt_url = await self._async_get_mqtt_url()
-        if not mqtt_url:
-            return None
-        from .protocol import _PersistentMqtt
-        pm = li.get("_persistent_mqtt")  # re-check under the brief await gap
-        if pm is None:
+        # Serialize get-or-create. Without this, two concurrent first-callers
+        # (e.g. a command publish racing a stream open) both pass the None-check
+        # above, both await below, and both build a _PersistentMqtt - the second
+        # clobbering the first and orphaning a connection on the single-client_id
+        # broker. dict.setdefault is atomic (no await between create and insert),
+        # so every caller for this account shares the one lock.
+        lock = li.setdefault("_persistent_mqtt_lock", asyncio.Lock())
+        async with lock:
+            pm = li.get("_persistent_mqtt")  # re-check under the lock
+            if pm is not None:
+                return pm
+            smarthome_auth = await self._async_get_smarthome_auth()
+            mqtt_user = (smarthome_auth or {}).get("mqttUser") or str(self.user_id)
+            mqtt_pwd  = (smarthome_auth or {}).get("mqttPassword") or ""
+            client_id = (self._user_info.get("mqttClientId") or f"app-{mqtt_user}")
+            mqtt_url = await self._async_get_mqtt_url()
+            if not mqtt_url:
+                return None
+            from .protocol import _PersistentMqtt
             pm = _PersistentMqtt(mqtt_url, mqtt_user, mqtt_pwd, client_id)
             li["_persistent_mqtt"] = pm
-        return pm
+            return pm
 
     @staticmethod
     def _adaptive_next_fast(adaptive: bool, fast_failed: bool) -> bool:
@@ -4226,6 +4295,10 @@ class CameraMixin(_CameraControlsMixin):
         # (the stream's mqtt_cid IS the authorized mqttClientId, so it's the same
         # connection) - subscribe + register a handler + drain outgoing_q through
         # it, and DON'T tear the connection down on stop (matching the app).
+        # A prior open may have left a drain running (e.g. a reopen with no
+        # async_stop_streaming between them); reap it before starting a new one
+        # so we don't orphan its executor thread + handler on the shared conn.
+        await self._reap_stream_drain()
         _pm_stream = (await self._get_persistent_mqtt()
                       if self._resolve_persistent_mqtt() else None)
         if _pm_stream is not None:
@@ -4243,6 +4316,13 @@ class CameraMixin(_CameraControlsMixin):
                     _pm_stream.remove_handler(_on_mqtt_message)
 
             mqtt_fut = asyncio.ensure_future(_pm_stream_drain())
+            # Track the drain AND its queue so teardown (or a replacing open) can
+            # reap it even if this open is cancelled before a WebRTCSession takes
+            # ownership.  _reap_stream_drain pushes the outgoing_q sentinel to
+            # release the thread blocked on outgoing_q.get and removes the handler
+            # from the shared persistent connection.
+            self._stream_mqtt_drain = mqtt_fut
+            self._stream_mqtt_outq = outgoing_q
             _on_mqtt_ready({"connected": True, "rc": 0, "rc_str": "persistent"})
         else:
             mqtt_fut = loop.run_in_executor(

{python_aidot_cameras-0.7.35 → python_aidot_cameras-0.8.0}/src/aidot/camera/protocol.py

@@ -1378,10 +1378,16 @@ class _PersistentMqtt:
         q = _queue.Queue()
         with self._lock:
             self._collectors.append(q)
+            c = self._client   # snapshot: a concurrent close() may null self._client
         collected = []
         try:
-            for pt, pp in (publish_items or []):
-                self._client.publish(pt, pp)
+            if c is None:
+                return [], {"error": "persistent mqtt closed"}
+            try:
+                for pt, pp in (publish_items or []):
+                    c.publish(pt, pp)
+            except Exception as exc:
+                return [], {"error": f"persistent mqtt publish failed: {exc}"}
             deadline = _time.monotonic() + timeout
             while True:
                 remaining = deadline - _time.monotonic()

{python_aidot_cameras-0.7.35 → python_aidot_cameras-0.8.0}/src/aidot/camera/sdes.py

@@ -186,6 +186,13 @@ class SdesSession:
             await _stop_loop.run_in_executor(None, lambda: self._proc.wait(5))
         except Exception:
             self._proc.kill()
+            # Reap the SIGKILL'd child: this is a raw subprocess.Popen with no
+            # asyncio child-watcher to auto-reap it, so without a follow-up wait()
+            # it lingers as a zombie under rapid keepalive reconnect churn.
+            try:
+                await _stop_loop.run_in_executor(None, lambda: self._proc.wait(5))
+            except Exception:
+                _LOGGER.debug("camera %s: swallowed exception", 'stop', exc_info=True)
         # Read drained stderr in the executor with a hard timeout: proc.stderr.read()
         # blocks until EOF, which never arrives if the killed process is still a
         # zombie / stuck in uninterruptible I/O - doing it inline would hang the
@@ -199,6 +206,13 @@ class SdesSession:
             )
         except Exception:   # incl. asyncio.TimeoutError - never let teardown hang here
             _LOGGER.debug("camera %s: swallowed exception", 'stop', exc_info=True)
+            # On timeout the executor thread is still blocked in stderr.read() on
+            # a wedged ffmpeg; close the pipe so that read returns instead of
+            # pinning a default-pool thread for the life of the process.
+            try:
+                self._proc.stderr.close()
+            except Exception:
+                _LOGGER.debug("camera %s: swallowed exception", 'stop', exc_info=True)
         if stderr_bytes:
             _LOGGER.warning("ffmpeg SDES stderr:\n%s", stderr_bytes.decode(errors="replace"))
         import os

{python_aidot_cameras-0.7.35 → python_aidot_cameras-0.8.0}/src/aidot/const.py

@@ -169,7 +169,6 @@ DEFAULT_COUNTRY_CODE = "US"
 CONF_APP_ID = "Appid"
 CONF_TERMINAL = "Terminal"
 CONF_LOGIN_RESPONSE = "login_response"
-CONF_LOGIN_INFO = "login_info"
 CONF_SELECTED_HOUSE = "selected_house"
 CONF_DEVICE_LIST = "device_list"
 CONF_PRODUCT_LIST = "product_list"

{python_aidot_cameras-0.7.35 → python_aidot_cameras-0.8.0/src/python_aidot_cameras.egg-info}/PKG-INFO

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

@@ -44,6 +44,7 @@ tests/test_live_stream_param.py
 tests/test_motion_poll.py
 tests/test_no_undefined_names.py
 tests/test_persistent_mqtt.py
+tests/test_persistent_mqtt_robustness.py
 tests/test_post_merge_hardening.py
 tests/test_sdes_adaptive.py
 tests/test_sdes_fast_liveplay.py
@@ -57,6 +58,7 @@ tests/test_serve_relay.py
 tests/test_speak.py
 tests/test_stream_cap.py
 tests/test_stream_idle.py
+tests/test_stream_teardown.py
 tests/test_talk.py
 tests/test_terminal_ack.py
 tests/test_token_refresh.py

python_aidot_cameras-0.8.0/tests/test_persistent_mqtt_robustness.py

@@ -0,0 +1,127 @@
+"""Regression tests for persistent-MQTT robustness fixes (pre-0.8.0 review).
+
+Covers three confirmed defects in the default-on persistent-MQTT path:
+  * _request_sync must not raise when a concurrent close() nulls self._client,
+    nor when publish() raises - it returns an error tuple so callers fall back.
+  * _get_persistent_mqtt must create exactly ONE connection per account even
+    under concurrent first-callers (double-checked-locking race).
+  * _reap_stream_drain must release the executor thread blocked on outgoing_q
+    (cancellation alone cannot) and run the drain's finally (handler removal).
+"""
+import asyncio
+import os
+import queue
+import sys
+
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "src"))
+
+import aidot.camera.protocol as proto
+import aidot.camera.client as cc
+from aidot.camera.protocol import _PersistentMqtt
+
+_CAM = next(v for v in vars(cc).values()
+            if isinstance(v, type) and "_get_persistent_mqtt" in v.__dict__)
+
+
+def _cam():
+    return _CAM.__new__(_CAM)
+
+
+# --- finding 3: _request_sync hardened against a concurrent close()/publish --- #
+
+def test_request_sync_returns_error_when_client_nulled(monkeypatch):
+    pm = _PersistentMqtt("wss://h:8443/mqtt", "u", "p", "cid")
+    monkeypatch.setattr(pm, "_ensure_started_sync", lambda timeout=15.0: True)
+    pm._client = None   # simulate close() nulling the client after the started-check
+    messages, st = pm._request_sync([("t", "pp")], ["a/#"], None, 0.05)
+    assert messages == []
+    assert st.get("error")            # truthy error tuple, NOT an AttributeError
+    assert pm._collectors == []       # transient collector still cleaned up
+
+
+def test_request_sync_returns_error_when_publish_raises(monkeypatch):
+    pm = _PersistentMqtt("wss://h:8443/mqtt", "u", "p", "cid")
+    monkeypatch.setattr(pm, "_ensure_started_sync", lambda timeout=15.0: True)
+
+    class _BadClient:
+        def publish(self, *a):
+            raise RuntimeError("boom")
+
+    pm._client = _BadClient()
+    messages, st = pm._request_sync([("t", "pp")], [], None, 0.05)
+    assert messages == []
+    assert "boom" in (st.get("error") or "")
+    assert pm._collectors == []
+
+
+# --- finding 4: get-or-create is single-flight under concurrency ------------- #
+
+def test_get_persistent_mqtt_one_instance_under_concurrency(monkeypatch):
+    cam = _cam()
+    cam._user_info = {"mqttClientId": "cid"}
+    created = []
+
+    async def _auth():
+        return {"mqttUser": "u", "mqttPassword": "p"}
+
+    async def _url():
+        await asyncio.sleep(0)   # yield so both callers interleave past the first check
+        return "wss://h:8443/mqtt"
+
+    cam._async_get_smarthome_auth = _auth
+    cam._async_get_mqtt_url = _url
+
+    orig = proto._PersistentMqtt
+
+    def _counting(*a, **k):
+        obj = orig(*a, **k)
+        created.append(obj)
+        return obj
+
+    monkeypatch.setattr(proto, "_PersistentMqtt", _counting)
+
+    async def _run():
+        return await asyncio.gather(cam._get_persistent_mqtt(),
+                                    cam._get_persistent_mqtt())
+
+    a, b = asyncio.run(_run())
+    assert a is b is not None
+    assert len(created) == 1           # the race previously built two
+
+
+# --- finding 1: reaping releases the executor-blocked drain ------------------ #
+
+def test_reap_stream_drain_releases_blocked_drain():
+    cam = _cam()
+    outq = queue.Queue()
+    saw = []
+
+    async def _drain():
+        loop = asyncio.get_running_loop()
+        try:
+            while True:
+                out = await loop.run_in_executor(None, outq.get)
+                if out is None:        # sentinel from _reap_stream_drain
+                    return
+        finally:
+            saw.append("finally")      # in prod this removes the handler
+
+    async def _run():
+        fut = asyncio.ensure_future(_drain())
+        await asyncio.sleep(0.05)      # let it block on outgoing_q.get
+        cam._stream_mqtt_drain = fut
+        cam._stream_mqtt_outq = outq
+        await cam._reap_stream_drain()
+        return fut
+
+    fut = asyncio.run(_run())
+    assert fut.done()
+    assert "finally" in saw            # drain's cleanup ran (not leaked)
+    assert cam._stream_mqtt_drain is None and cam._stream_mqtt_outq is None
+
+
+def test_reap_stream_drain_noop_when_nothing_tracked():
+    cam = _cam()
+    # No drain tracked: must be a clean no-op, not raise.
+    asyncio.run(cam._reap_stream_drain())
+    assert getattr(cam, "_stream_mqtt_drain", None) is None

python_aidot_cameras-0.8.0/tests/test_stream_teardown.py

@@ -0,0 +1,75 @@
+"""Unit test: async_stop_streaming reaps an orphaned persistent-MQTT drain.
+
+If a stream open is cancelled before a WebRTCSession takes ownership of the
+drain task, the drain would otherwise block forever on outgoing_q.get with its
+handler still registered. async_stop_streaming must cancel it (its finally then
+removes the handler). No camera needed.
+"""
+import asyncio
+import os
+import sys
+
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "src"))
+
+import aidot.camera.client as cc
+
+_CAM = next(v for v in vars(cc).values()
+            if isinstance(v, type) and "async_stop_streaming" in v.__dict__)
+
+
+def _bare_client():
+    c = _CAM.__new__(_CAM)
+    c._streaming_active = True
+    c._serve_ready = asyncio.Event()
+    c._go2rtc_task = None
+    c._stream_session = None
+    c._stream_task = None
+    c._stream_mqtt_drain = None
+
+    async def _noop_deregister():
+        return None
+    c._deregister_go2rtc = _noop_deregister
+    return c
+
+
+def test_orphaned_drain_is_cancelled():
+    async def _run():
+        c = _bare_client()
+        handler_removed = {"v": False}
+
+        async def _drain():
+            try:
+                await asyncio.Event().wait()      # blocks forever, like outgoing_q.get
+            finally:
+                handler_removed["v"] = True       # the real finally calls remove_handler
+        c._stream_mqtt_drain = asyncio.ensure_future(_drain())
+        await asyncio.sleep(0)                     # let the drain start blocking
+
+        await c.async_stop_streaming()
+
+        assert c._stream_mqtt_drain is None        # cleared
+        assert handler_removed["v"] is True        # drain's finally ran (handler removed)
+    asyncio.run(_run())
+
+
+def test_no_drain_is_safe():
+    async def _run():
+        c = _bare_client()                         # _stream_mqtt_drain is None
+        await c.async_stop_streaming()             # must not raise
+        assert c._streaming_active is False
+    asyncio.run(_run())
+
+
+if __name__ == "__main__":
+    import traceback
+    _fail = 0
+    for _k, _v in sorted(globals().items()):
+        if _k.startswith("test_"):
+            try:
+                _v()
+                print(f"PASS {_k}")
+            except Exception:
+                _fail += 1
+                print(f"FAIL {_k}")
+                traceback.print_exc()
+    raise SystemExit(1 if _fail else 0)