mmrelay 1.1.4__py3-none-any.whl → 1.2.1__py3-none-any.whl

mmrelay/meshtastic_utils.py

@@ -1,9 +1,12 @@
 import asyncio
 import contextlib
+import inspect
 import io
 import os
+import re
 import threading
 import time
+from concurrent.futures import Future
 from typing import List
 
 import meshtastic.ble_interface
@@ -14,9 +17,11 @@ import serial.tools.list_ports  # Import serial tools for port listing
 from meshtastic.protobuf import mesh_pb2, portnums_pb2
 from pubsub import pub
 
+from mmrelay.config import get_meshtastic_config_value
 from mmrelay.constants.config import (
     CONFIG_KEY_MESHNET_NAME,
     CONFIG_SECTION_MESHTASTIC,
+    DEFAULT_DETECTION_SENSOR,
 )
 from mmrelay.constants.formats import (
     DETECTION_SENSOR_APP,
@@ -75,6 +80,7 @@ matrix_rooms: List[dict] = []
 # Initialize logger for Meshtastic
 logger = get_logger(name="Meshtastic")
 
+
 # Global variables for the Meshtastic connection and event loop management
 meshtastic_client = None
 event_loop = None  # Will be set from main.py
@@ -92,12 +98,106 @@ subscribed_to_messages = False
 subscribed_to_connection_lost = False
 
 
+def _submit_coro(coro, loop=None):
+    """
+    Submit an asyncio coroutine for execution on the appropriate event loop and return a Future representing its result.
+
+    If `loop` (or the module-level `event_loop`) is an open asyncio event loop, the coroutine is scheduled thread-safely via `asyncio.run_coroutine_threadsafe`. If there is a currently running loop in the calling thread, the coroutine is scheduled with that loop's `create_task`. If no running loop exists, the coroutine is executed synchronously with `asyncio.run` and its result (or raised exception) is wrapped in a completed Future. If `coro` is not a coroutine, returns None.
+
+    Parameters:
+        coro: The coroutine object to execute.
+        loop: Optional asyncio event loop to target. If omitted, the module-level `event_loop` is used.
+
+    Returns:
+        A Future-like object representing the coroutine's eventual result, or None if `coro` is not a coroutine.
+    """
+    if not inspect.iscoroutine(coro):
+        # Defensive guard for tests that mistakenly patch async funcs to return None
+        return None
+    loop = loop or event_loop
+    if loop and isinstance(loop, asyncio.AbstractEventLoop) and not loop.is_closed():
+        return asyncio.run_coroutine_threadsafe(coro, loop)
+    # Fallback: schedule on a real loop if present; tests can override this.
+    try:
+        running = asyncio.get_running_loop()
+        return running.create_task(coro)
+    except RuntimeError:
+        # No running loop: run synchronously and wrap the result in a completed Future
+        f = Future()
+        try:
+            result = asyncio.run(coro)
+            f.set_result(result)
+        except Exception as e:
+            f.set_exception(e)
+        return f
+
+
+def _get_device_metadata(client):
+    """
+    Retrieve device metadata from a Meshtastic client.
+
+    Attempts to call client.localNode.getMetadata() to extract a firmware version and capture the raw output. If the client lacks a usable localNode.getMetadata method or parsing fails, returns defaults. The captured raw output is truncated to 4096 characters.
+
+    Returns:
+        dict: {
+            "firmware_version": str,  # parsed firmware version or "unknown"
+            "raw_output": str,        # captured output from getMetadata() (possibly truncated)
+            "success": bool           # True when a firmware_version was successfully parsed
+        }
+    """
+    result = {"firmware_version": "unknown", "raw_output": "", "success": False}
+
+    try:
+        # Preflight: client may be a mock without localNode/getMetadata
+        if not getattr(client, "localNode", None) or not hasattr(
+            client.localNode, "getMetadata"
+        ):
+            logger.debug(
+                "Meshtastic client has no localNode.getMetadata(); skipping metadata retrieval"
+            )
+            return result
+
+        # Capture getMetadata() output to extract firmware version
+        output_capture = io.StringIO()
+        with contextlib.redirect_stdout(output_capture), contextlib.redirect_stderr(
+            output_capture
+        ):
+            client.localNode.getMetadata()
+
+        console_output = output_capture.getvalue()
+        output_capture.close()
+
+        # Cap raw_output length to avoid memory bloat
+        if len(console_output) > 4096:
+            console_output = console_output[:4096] + "…"
+        result["raw_output"] = console_output
+
+        # Parse firmware version from the output using robust regex
+        # Case-insensitive, handles quotes, whitespace, and various formats
+        match = re.search(
+            r"(?i)\bfirmware_version\s*:\s*['\"]?\s*([^\s\r\n'\"]+)\s*['\"]?",
+            console_output,
+        )
+        if match:
+            parsed = match.group(1).strip()
+            if parsed:
+                result["firmware_version"] = parsed
+                result["success"] = True
+
+    except Exception as e:
+        logger.debug(
+            "Could not retrieve device metadata via localNode.getMetadata()", exc_info=e
+        )
+
+    return result
+
+
 def is_running_as_service():
     """
-    Checks whether the application is running as a systemd service.
+    Determine if the application is running as a systemd service.
 
     Returns:
-        bool: True if running under systemd (detected via environment variable or parent process), otherwise False.
+        bool: True if the process is running under systemd, either by detecting the INVOCATION_ID environment variable or by checking if the parent process is systemd; otherwise, False.
     """
     # Check for INVOCATION_ID environment variable (set by systemd)
     if os.environ.get("INVOCATION_ID"):
@@ -128,23 +228,23 @@ def serial_port_exists(port_name):
 
 def connect_meshtastic(passed_config=None, force_connect=False):
     """
-    Establishes a connection to a Meshtastic device using serial, BLE, or TCP, with automatic retries and event subscriptions.
+    Establish and return a Meshtastic client connection (serial, BLE, or TCP), with configurable retries and event subscription.
 
-    If a configuration is provided, updates the global configuration and Matrix room mappings. Prevents concurrent or duplicate connection attempts, validates required configuration fields, and supports both legacy and current connection types. Verifies serial port existence before connecting and handles connection failures with exponential backoff. Subscribes to message and connection lost events upon successful connection.
+    Attempts to (re)connect using the module configuration and updates module-level state on success (meshtastic_client, matrix_rooms, and event subscriptions). Validates required configuration keys, supports the legacy "network" alias for TCP, verifies serial port presence before connecting, and performs exponential backoff on connection failures. Subscribes once to message and connection-lost events when a connection is established.
 
     Parameters:
-        passed_config (dict, optional): Configuration dictionary for the connection.
-        force_connect (bool, optional): If True, forces a new connection even if one already exists.
+        passed_config (dict, optional): Configuration to use for the connection; if provided, replaces the module-level config and may update matrix_rooms.
+        force_connect (bool, optional): If True, forces creating a new connection even if one already exists.
 
     Returns:
-        The connected Meshtastic client instance, or None if connection fails or shutdown is in progress.
+        The connected Meshtastic client instance on success, or None if connection cannot be established or shutdown is in progress.
     """
     global meshtastic_client, shutting_down, reconnecting, config, matrix_rooms
     if shutting_down:
         logger.debug("Shutdown in progress. Not attempting to connect.")
         return None
 
-    if reconnecting:
+    if reconnecting and not force_connect:
         logger.debug("Reconnection already in progress. Not attempting new connection.")
         return None
 
@@ -279,7 +379,20 @@ def connect_meshtastic(passed_config=None, force_connect=False):
                 user_info = nodeInfo.get("user", {}) if nodeInfo else {}
                 short_name = user_info.get("shortName", "unknown")
                 hw_model = user_info.get("hwModel", "unknown")
-                logger.info(f"Connected to {short_name} / {hw_model}")
+
+                # Get firmware version from device metadata
+                metadata = _get_device_metadata(meshtastic_client)
+                firmware_version = metadata["firmware_version"]
+
+                if metadata.get("success"):
+                    logger.info(
+                        f"Connected to {short_name} / {hw_model} / Meshtastic Firmware version {firmware_version}"
+                    )
+                else:
+                    logger.info(f"Connected to {short_name} / {hw_model}")
+                    logger.debug(
+                        "Device firmware version unavailable from getMetadata()"
+                    )
 
                 # Subscribe to message and connection lost events (only once per application run)
                 global subscribed_to_messages, subscribed_to_connection_lost
@@ -338,11 +451,15 @@ def connect_meshtastic(passed_config=None, force_connect=False):
 
 def on_lost_meshtastic_connection(interface=None, detection_source="unknown"):
     """
-    Initiate a reconnection sequence when the Meshtastic connection is lost, unless a shutdown or reconnection is already in progress.
+    Mark the Meshtastic connection as lost, close the current client, and initiate an asynchronous reconnect.
+
+    If a shutdown is in progress or a reconnect is already underway this function returns immediately. Otherwise it:
+    - sets the module-level `reconnecting` flag,
+    - attempts to close and clear the module-level `meshtastic_client` (handles already-closed file descriptors),
+    - schedules the reconnect() coroutine on the global event loop if that loop exists and is open.
 
     Parameters:
-        interface: Optional Meshtastic interface instance, included for compatibility.
-        detection_source (str): Identifier for the source that detected the connection loss, used for debugging.
+        detection_source (str): Identifier for where or how the loss was detected; used in log messages.
     """
     global meshtastic_client, reconnecting, shutting_down, event_loop, reconnect_task
     with meshtastic_lock:
@@ -370,15 +487,20 @@ def on_lost_meshtastic_connection(interface=None, detection_source="unknown"):
                 logger.warning(f"Error closing Meshtastic client: {e}")
         meshtastic_client = None
 
-        if event_loop:
-            reconnect_task = asyncio.run_coroutine_threadsafe(reconnect(), event_loop)
+        if event_loop and not event_loop.is_closed():
+            reconnect_task = event_loop.create_task(reconnect())
 
 
 async def reconnect():
     """
-    Asynchronously attempts to reconnect to the Meshtastic device with exponential backoff, stopping if shutdown is initiated.
-
-    Reconnection starts with a 10-second delay, doubling up to a maximum of 5 minutes between attempts. If not running as a service, a progress bar is shown during the wait. The process stops immediately if shutdown is triggered or reconnection succeeds.
+    Attempt to re-establish a Meshtastic connection with exponential backoff.
+
+    This coroutine repeatedly tries to reconnect by invoking connect_meshtastic(force_connect=True)
+    in a thread executor until a connection is obtained, the global shutting_down flag is set,
+    or the task is cancelled. It begins with DEFAULT_BACKOFF_TIME and doubles the wait after each
+    failed attempt, capping the backoff at 300 seconds. The function ensures the module-level
+    reconnecting flag is cleared before it returns. asyncio.CancelledError is handled (logged)
+    and causes the routine to stop.
     """
     global meshtastic_client, reconnecting, shutting_down
     backoff_time = DEFAULT_BACKOFF_TIME
@@ -418,7 +540,11 @@ async def reconnect():
                         "Shutdown in progress. Aborting reconnection attempts."
                     )
                     break
-                meshtastic_client = connect_meshtastic(force_connect=True)
+                loop = asyncio.get_running_loop()
+                # Pass force_connect=True without overwriting the global config
+                meshtastic_client = await loop.run_in_executor(
+                    None, connect_meshtastic, None, True
+                )
                 if meshtastic_client:
                     logger.info("Reconnected successfully.")
                     break
@@ -435,9 +561,21 @@ async def reconnect():
 
 def on_meshtastic_message(packet, interface):
     """
-    Processes an incoming Meshtastic message and relays it to Matrix rooms or plugins based on message type and configuration.
+    Handle an incoming Meshtastic packet and relay it to Matrix rooms or plugins as configured.
+
+    This function inspects a Meshtastic `packet` (expected as a dict), applies interaction rules (reactions, replies, replies storage, detection-sensor filtering), and either:
+    - relays reactions or replies as appropriate to the mapped Matrix event/room,
+    - relays normal text messages to all Matrix rooms mapped to the message's Meshtastic channel (unless the message is a direct message to the relay node or a plugin handles it),
+    - or dispatches non-text or unhandled packets to plugins for processing.
+
+    Behavior notes:
+    - Uses global configuration and matrix_rooms mappings; returns immediately if configuration or event loop is missing or if shutdown is in progress.
+    - Resolves sender display names from a local DB or node info and persists them when found.
+    - Honors interaction settings for reactions and replies, and the meshtastic `detection_sensor` configuration when handling detection sensor packets.
+    - Uses _submit_coro to schedule Matrix/plugin coroutines on the configured event loop.
+    - Side effects: schedules Matrix relays, may call plugin handlers, and may store sender metadata and message->Matrix mappings via other utilities.
 
-    Handles reactions and replies by relaying them to Matrix if enabled. Normal text messages are relayed to all mapped Matrix rooms unless handled by a plugin or directed to the relay node. Non-text messages are passed to plugins for processing. Messages from unmapped channels, disabled detection sensors, or during shutdown are ignored. Ensures sender information is retrieved or stored as needed.
+    No return value.
     """
     global config, matrix_rooms
 
@@ -543,7 +681,7 @@ def on_meshtastic_message(packet, interface):
             )
 
             # Relay the reaction as emote to Matrix, preserving the original meshnet name
-            asyncio.run_coroutine_threadsafe(
+            _submit_coro(
                 matrix_relay(
                     matrix_room_id,
                     reaction_message,
@@ -583,7 +721,7 @@ def on_meshtastic_message(packet, interface):
             logger.info(f"Relaying Meshtastic reply from {longname} to Matrix")
 
             # Relay the reply to Matrix with proper reply formatting
-            asyncio.run_coroutine_threadsafe(
+            _submit_coro(
                 matrix_relay(
                     matrix_room_id,
                     formatted_message,
@@ -632,9 +770,11 @@ def on_meshtastic_message(packet, interface):
             return
 
         # If detection_sensor is disabled and this is a detection sensor packet, skip it
-        if decoded.get("portnum") == DETECTION_SENSOR_APP and not config[
-            "meshtastic"
-        ].get("detection_sensor", False):
+        if decoded.get(
+            "portnum"
+        ) == DETECTION_SENSOR_APP and not get_meshtastic_config_value(
+            config, "detection_sensor", DEFAULT_DETECTION_SENSOR
+        ):
             logger.debug(
                 "Detection sensor packet received, but detection sensor processing is disabled."
             )
@@ -684,7 +824,7 @@ def on_meshtastic_message(packet, interface):
         for plugin in plugins:
             if not found_matching_plugin:
                 try:
-                    result = asyncio.run_coroutine_threadsafe(
+                    result = _submit_coro(
                         plugin.handle_meshtastic_message(
                             packet, formatted_message, longname, meshnet_name
                         ),
@@ -720,7 +860,7 @@ def on_meshtastic_message(packet, interface):
                 # Storing the message_map (if enabled) occurs inside matrix_relay() now,
                 # controlled by relay_reactions.
                 try:
-                    asyncio.run_coroutine_threadsafe(
+                    _submit_coro(
                         matrix_relay(
                             room["id"],
                             formatted_message,
@@ -745,7 +885,7 @@ def on_meshtastic_message(packet, interface):
         for plugin in plugins:
             if not found_matching_plugin:
                 try:
-                    result = asyncio.run_coroutine_threadsafe(
+                    result = _submit_coro(
                         plugin.handle_meshtastic_message(
                             packet,
                             formatted_message=None,
@@ -766,9 +906,15 @@ def on_meshtastic_message(packet, interface):
 
 async def check_connection():
     """
-    Periodically checks the health of the Meshtastic connection and triggers reconnection if the device becomes unresponsive.
-
-    For non-BLE connections, performs a metadata check at configurable intervals to verify device responsiveness. If the check fails or the firmware version is missing, initiates reconnection unless already in progress. BLE connections are excluded from periodic checks due to real-time disconnection detection. The function runs continuously until shutdown is requested, with health check behavior controlled by configuration.
+    Periodically verify Meshtastic connection health and trigger reconnection when the device is unresponsive.
+
+    Checks run continuously until shutdown. Behavior:
+    - Controlled by config['meshtastic']['health_check']:
+      - 'enabled' (bool, default True) — enable/disable periodic checks.
+      - 'heartbeat_interval' (int, seconds, default 60) — check interval. Backwards-compatible: if 'heartbeat_interval' exists directly under config['meshtastic'], that value is used.
+    - For non-BLE connections, calls _get_device_metadata(client). If metadata parsing fails, performs a fallback probe via client.getMyNodeInfo(); if both fail, on_lost_meshtastic_connection(...) is invoked to start reconnection.
+    - BLE connections are excluded from periodic checks because the underlying library detects disconnections in real time.
+    - No return value; runs as a background coroutine until global shutting_down is True.
     """
     global meshtastic_client, shutting_down, config
 
@@ -807,15 +953,21 @@ async def check_connection():
                     ble_skip_logged = True
             else:
                 try:
-                    output_capture = io.StringIO()
-                    with contextlib.redirect_stdout(
-                        output_capture
-                    ), contextlib.redirect_stderr(output_capture):
-                        meshtastic_client.localNode.getMetadata()
-
-                    console_output = output_capture.getvalue()
-                    if "firmware_version" not in console_output:
-                        raise Exception("No firmware_version in getMetadata output.")
+                    # Use helper function to get device metadata
+                    metadata = _get_device_metadata(meshtastic_client)
+                    if not metadata["success"]:
+                        # Fallback probe: device responding at all?
+                        try:
+                            _ = meshtastic_client.getMyNodeInfo()
+                        except Exception as probe_err:
+                            raise Exception(
+                                "Metadata and nodeInfo probes failed"
+                            ) from probe_err
+                        else:
+                            logger.debug(
+                                "Metadata parse failed but device responded to getMyNodeInfo(); skipping reconnect this cycle"
+                            )
+                            continue
 
                 except Exception as e:
                     # Only trigger reconnection if we're not already reconnecting