fix(ble): cancel the disconnect future when it times out

Follow-up to the teardown-hang fix: when the bounded disconnect wait times
out, cancel the future so a stalled call isn't left running on the event
loop. Adds tests for the timeout, the bounded close() join, and the cancel.

Signed-off-by: Laura Long <lauralonggone@gmail.com>

Author: Laura Long

meshtastic/ble_interface.py

@@ -354,7 +354,13 @@ def async_await(self, coro, timeout=None):  # pylint: disable=C0116
         # On macOS without debug logging, callbacks may not be delivered
         # unless we trigger some I/O. This is a known quirk of CoreBluetooth.
         sys.stdout.flush()
-        result = future.result(timeout)
+        try:
+            result = future.result(timeout)
+        except FutureTimeoutError:
+            # The coroutine is still queued/running on the event loop; cancel it
+            # so a stalled call (e.g. a hung disconnect) is not left pending.
+            future.cancel()
+            raise
         logger.debug("async_await: complete")
         return result
 

meshtastic/tests/test_ble_interface.py

@@ -6,7 +6,7 @@
 import pytest
 from bleak.exc import BleakDBusError, BleakError
 
-from ..ble_interface import BLEClient, BLEInterface
+from ..ble_interface import BLE_DISCONNECT_TIMEOUT, BLEClient, BLEInterface
 
 
 @pytest.mark.unit
@@ -88,11 +88,45 @@ def test_ble_receive_disconnect_mid_read_unwinds_cleanly():
 
 @pytest.mark.unit
 def test_ble_client_disconnect_swallows_stalled_teardown():
-    """BLEClient.disconnect must not propagate a stalled-teardown timeout,
-    so BLEInterface.close() can always finish."""
+    """BLEClient.disconnect must bound the wait with BLE_DISCONNECT_TIMEOUT and
+    not propagate a stalled-teardown timeout, so BLEInterface.close() can always
+    finish."""
     client = object.__new__(BLEClient)
     client.bleak_client = MagicMock()
-    with patch.object(BLEClient, "async_await", side_effect=FutureTimeoutError()):
+    with patch.object(
+        BLEClient, "async_await", side_effect=FutureTimeoutError()
+    ) as async_await:
         client.disconnect()  # must not raise
+    # the wait must actually be bounded, not left unbounded
+    assert async_await.call_args.kwargs["timeout"] == BLE_DISCONNECT_TIMEOUT
     with patch.object(BLEClient, "async_await", side_effect=BleakError("gone")):
         client.disconnect()  # must not raise
+
+
+@pytest.mark.unit
+def test_ble_client_close_bounds_event_thread_join():
+    """BLEClient.close must bound the event-loop thread join so a stuck loop
+    cannot block teardown forever."""
+    client = object.__new__(BLEClient)
+    client._eventThread = MagicMock()
+    # Force a plain (non-async) mock for the coroutine method so we don't create
+    # an un-awaited coroutine when close() calls it.
+    with patch.object(BLEClient, "async_run") as async_run, patch.object(
+        BLEClient, "_stop_event_loop", new=MagicMock()
+    ):
+        client.close()
+    async_run.assert_called_once()
+    client._eventThread.join.assert_called_once_with(timeout=BLE_DISCONNECT_TIMEOUT)
+
+
+@pytest.mark.unit
+def test_ble_client_async_await_cancels_future_on_timeout():
+    """On timeout, async_await must cancel the pending future so a stalled
+    coroutine is not left running on the event loop."""
+    client = object.__new__(BLEClient)
+    future = MagicMock()
+    future.result.side_effect = FutureTimeoutError()
+    with patch.object(BLEClient, "async_run", return_value=future):
+        with pytest.raises(FutureTimeoutError):
+            client.async_await("coro", timeout=BLE_DISCONNECT_TIMEOUT)
+    future.cancel.assert_called_once()