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

mmrelay/db_utils.py

@@ -31,21 +31,26 @@ def clear_db_path_cache():
 # Get the database path
 def get_db_path():
     """
-    Resolves and returns the file path to the SQLite database, using configuration overrides if provided.
+    Return the resolved filesystem path to the SQLite database.
 
-    Prefers the path specified in `config["database"]["path"]`, falls back to `config["db"]["path"]` (legacy), and defaults to `meshtastic.sqlite` in the standard data directory if neither is set. The resolved path is cached and the cache is invalidated if relevant configuration changes. Attempts to create the directory for the database path if it does not exist.
+    Resolution precedence:
+    1. config["database"]["path"] (preferred)
+    2. config["db"]["path"] (legacy)
+    3. Default: "meshtastic.sqlite" inside the application data directory returned by get_data_dir().
+
+    The chosen path is cached and returned quickly on subsequent calls. The cache is invalidated automatically when the relevant parts of `config` change. When a configured path is used, this function will attempt to create the parent directory (and will attempt to create the standard data directory for the default path). Directory creation failures are logged as warnings but do not raise here; actual database connection errors may surface later.
     """
     global config, _cached_db_path, _db_path_logged, _cached_config_hash
 
-    # Create a hash of the relevant config sections to detect changes
+    # Create a deterministic JSON representation of relevant config sections to detect changes
     current_config_hash = None
     if config is not None:
-        # Hash only the database-related config sections
+        # Use only the database-related config sections
         db_config = {
             "database": config.get("database", {}),
             "db": config.get("db", {}),  # Legacy format
         }
-        current_config_hash = hash(str(sorted(db_config.items())))
+        current_config_hash = json.dumps(db_config, sort_keys=True)
 
     # Check if cache is valid (path exists and config hasn't changed)
     if _cached_db_path is not None and current_config_hash == _cached_config_hash:
@@ -88,7 +93,13 @@ def get_db_path():
                 # Ensure the directory exists
                 db_dir = os.path.dirname(custom_path)
                 if db_dir:
-                    os.makedirs(db_dir, exist_ok=True)
+                    try:
+                        os.makedirs(db_dir, exist_ok=True)
+                    except (OSError, PermissionError) as e:
+                        logger.warning(
+                            f"Could not create database directory {db_dir}: {e}"
+                        )
+                        # Continue anyway - the database connection will fail later if needed
 
                 # Cache the path and log only once
                 _cached_db_path = custom_path
@@ -100,7 +111,14 @@ def get_db_path():
                 return custom_path
 
     # Use the standard data directory
-    default_path = os.path.join(get_data_dir(), "meshtastic.sqlite")
+    data_dir = get_data_dir()
+    # Ensure the data directory exists before using it
+    try:
+        os.makedirs(data_dir, exist_ok=True)
+    except (OSError, PermissionError) as e:
+        logger.warning(f"Could not create data directory {data_dir}: {e}")
+        # Continue anyway - the database connection will fail later if needed
+    default_path = os.path.join(data_dir, "meshtastic.sqlite")
     _cached_db_path = default_path
     return default_path
 
@@ -148,8 +166,18 @@ def initialize_database():
             except sqlite3.OperationalError:
                 # Column already exists, or table just created with it
                 pass
-    except sqlite3.Error as e:
-        logger.error(f"Database initialization failed: {e}")
+
+            # Create index on meshtastic_id for performance improvement
+            # This is a no-op if the index already exists.
+            try:
+                cursor.execute(
+                    "CREATE INDEX IF NOT EXISTS idx_message_map_meshtastic_id ON message_map (meshtastic_id)"
+                )
+            except sqlite3.OperationalError:
+                # Index creation failed, continue without it
+                pass
+    except sqlite3.Error:
+        logger.exception("Database initialization failed")
         raise
 
 
@@ -245,13 +273,15 @@ def get_plugin_data(plugin_name):
 # Get the longname for a given Meshtastic ID
 def get_longname(meshtastic_id):
     """
-    Retrieve the long name associated with a given Meshtastic ID.
+    Return the stored long name for a Meshtastic node.
 
+    Retrieves the longname string for the given Meshtastic node identifier from the database.
+    Returns None if no entry exists or if a database error occurs.
     Parameters:
         meshtastic_id (str): The Meshtastic node identifier.
 
     Returns:
-        str or None: The long name if found, otherwise None.
+        str | None: The long name if found, otherwise None.
     """
     try:
         with sqlite3.connect(get_db_path()) as conn:
@@ -261,16 +291,21 @@ def get_longname(meshtastic_id):
             )
             result = cursor.fetchone()
         return result[0] if result else None
-    except sqlite3.Error as e:
-        logger.error(f"Database error retrieving longname for {meshtastic_id}: {e}")
+    except sqlite3.Error:
+        logger.exception(f"Database error retrieving longname for {meshtastic_id}")
         return None
 
 
 def save_longname(meshtastic_id, longname):
     """
-    Insert or update the long name for a given Meshtastic ID in the database.
+    Persist or update the long display name for a Meshtastic node.
+
+    Writes or replaces the row for the given meshtastic_id in the longnames table and commits the change.
+    If a database error occurs it is logged and swallowed (no exception is raised).
 
-    If an entry for the Meshtastic ID already exists, its long name is updated; otherwise, a new entry is created.
+    Parameters:
+        meshtastic_id: Unique identifier for the Meshtastic node (string-like).
+        longname: The full/display name to store for the node (string).
     """
     try:
         with sqlite3.connect(get_db_path()) as conn:
@@ -280,16 +315,22 @@ def save_longname(meshtastic_id, longname):
                 (meshtastic_id, longname),
             )
             conn.commit()
-    except sqlite3.Error as e:
-        logger.error(f"Database error saving longname for {meshtastic_id}: {e}")
+    except sqlite3.Error:
+        logger.exception(f"Database error saving longname for {meshtastic_id}")
 
 
 def update_longnames(nodes):
     """
-    Updates the long names for all users in the provided nodes dictionary.
+    Update stored long names for nodes that contain user information.
+
+    Iterates over the provided mapping of nodes and, for each node that contains a "user" object,
+    extracts the user's Meshtastic ID and `longName` (defaults to "N/A" when missing) and persists it
+    via save_longname. Has no return value; skips nodes without a "user" key.
 
     Parameters:
-        nodes (dict): A dictionary of nodes, each containing user information with Meshtastic IDs and long names.
+        nodes (Mapping): Mapping of node identifiers to node dictionaries. Each node dictionary
+            is expected to contain a "user" dict with at least an "id" key and an optional
+            "longName" key.
     """
     if nodes:
         for node in nodes.values():
@@ -326,9 +367,13 @@ def get_shortname(meshtastic_id):
 
 def save_shortname(meshtastic_id, shortname):
     """
-    Insert or update the short name for a given Meshtastic ID in the database.
+    Insert or update the short name for a Meshtastic node.
+
+    Stores the provided shortname in the shortnames table keyed by meshtastic_id and commits the change. Database errors are logged (with stacktrace) and suppressed; the function does not raise on sqlite3 errors.
 
-    If an entry for the Meshtastic ID already exists, its short name is updated; otherwise, a new entry is created.
+    Parameters:
+        meshtastic_id (str): Node identifier used as the primary key in the shortnames table.
+        shortname (str): Display name to store for the node.
     """
     try:
         with sqlite3.connect(get_db_path()) as conn:
@@ -338,16 +383,18 @@ def save_shortname(meshtastic_id, shortname):
                 (meshtastic_id, shortname),
             )
             conn.commit()
-    except sqlite3.Error as e:
-        logger.error(f"Database error saving shortname for {meshtastic_id}: {e}")
+    except sqlite3.Error:
+        logger.exception(f"Database error saving shortname for {meshtastic_id}")
 
 
 def update_shortnames(nodes):
     """
-    Updates the short names for all users in the provided nodes dictionary.
+    Update stored shortnames for all nodes that include a user entry.
 
-    Parameters:
-        nodes (dict): A dictionary of nodes, each containing user information with Meshtastic IDs and short names.
+    Iterates over the values of the provided nodes mapping; for each node with a "user" object, extracts
+    user["id"] as the Meshtastic ID and user.get("shortName", "N/A") as the shortname, and persists it
+    via save_shortname. Nodes lacking a "user" entry are ignored. This function has no return value and
+    performs database writes via save_shortname.
     """
     if nodes:
         for node in nodes.values():

mmrelay/e2ee_utils.py

@@ -5,6 +5,7 @@ This module provides a unified approach to E2EE status detection, warning messag
 formatting across all components of the meshtastic-matrix-relay application.
 """
 
+import importlib
 import os
 import sys
 from typing import Any, Dict, List, Literal, Optional, TypedDict
@@ -76,9 +77,16 @@ def get_e2ee_status(
 
     # Check dependencies
     try:
-        import olm  # noqa: F401
-        from nio.crypto import OlmDevice  # noqa: F401
-        from nio.store import SqliteStore  # noqa: F401
+        importlib.import_module("olm")
+
+        if os.getenv("MMRELAY_TESTING") != "1":
+            nio_crypto = importlib.import_module("nio.crypto")
+            if not hasattr(nio_crypto, "OlmDevice"):
+                raise ImportError("nio.crypto.OlmDevice is unavailable")
+
+            nio_store = importlib.import_module("nio.store")
+            if not hasattr(nio_store, "SqliteStore"):
+                raise ImportError("nio.store.SqliteStore is unavailable")
 
         status["dependencies_installed"] = True
     except ImportError:

mmrelay/log_utils.py

@@ -1,8 +1,19 @@
 import logging
 from logging.handlers import RotatingFileHandler
 
-from rich.console import Console
-from rich.logging import RichHandler
+# Import Rich components only when not running as a service
+try:
+    from mmrelay.runtime_utils import is_running_as_service
+
+    if not is_running_as_service():
+        from rich.console import Console
+        from rich.logging import RichHandler
+
+        RICH_AVAILABLE = True
+    else:
+        RICH_AVAILABLE = False
+except ImportError:
+    RICH_AVAILABLE = False
 
 # Import parse_arguments only when needed to avoid conflicts with pytest
 from mmrelay.config import get_log_dir
@@ -13,8 +24,8 @@ from mmrelay.constants.messages import (
     LOG_SIZE_BYTES_MULTIPLIER,
 )
 
-# Initialize Rich console
-console = Console()
+# Initialize Rich console only if available
+console = Console() if RICH_AVAILABLE else None
 
 # Define custom log level styles - not used directly but kept for reference
 # Rich 14.0.0+ supports level_styles parameter, but we're using an approach
@@ -144,7 +155,7 @@ def get_logger(name):
         return logger
 
     # Add handler for console logging (with or without colors)
-    if color_enabled:
+    if color_enabled and RICH_AVAILABLE:
         # Use Rich handler with colors
         console_handler = RichHandler(
             rich_tracebacks=True,

mmrelay/main.py

@@ -82,8 +82,8 @@ async def main(config):
 
     matrix_rooms: List[dict] = config["matrix_rooms"]
 
-    # Set the event loop in meshtastic_utils
-    meshtastic_utils.event_loop = asyncio.get_event_loop()
+    loop = asyncio.get_running_loop()
+    meshtastic_utils.event_loop = loop
 
     # Initialize the SQLite database
     initialize_database()
@@ -119,7 +119,9 @@ async def main(config):
     start_message_queue(message_delay=message_delay)
 
     # Connect to Meshtastic
-    meshtastic_utils.meshtastic_client = connect_meshtastic(passed_config=config)
+    meshtastic_utils.meshtastic_client = await asyncio.to_thread(
+        connect_meshtastic, passed_config=config
+    )
 
     # Connect to Matrix
     matrix_client = await connect_matrix(passed_config=config)
@@ -151,12 +153,15 @@ async def main(config):
     shutdown_event = asyncio.Event()
 
     async def shutdown():
+        """
+        Signal the application to begin shutdown.
+        
+        Sets the Meshtastic shutdown flag and triggers the local shutdown event so any coroutines waiting on that event can start their cleanup. This coroutine only signals shutdown; it does not perform client shutdown or resource cleanup itself.
+        """
         matrix_logger.info("Shutdown signal received. Closing down...")
         meshtastic_utils.shutting_down = True  # Set the shutting_down flag
         shutdown_event.set()
 
-    loop = asyncio.get_running_loop()
-
     # Handle signals differently based on the platform
     if sys.platform != WINDOWS_PLATFORM:
         for sig in (signal.SIGINT, signal.SIGTERM):
@@ -177,9 +182,17 @@ async def main(config):
         while not shutdown_event.is_set():
             try:
                 if meshtastic_utils.meshtastic_client:
-                    # Update longnames & shortnames
-                    update_longnames(meshtastic_utils.meshtastic_client.nodes)
-                    update_shortnames(meshtastic_utils.meshtastic_client.nodes)
+                    nodes_snapshot = dict(meshtastic_utils.meshtastic_client.nodes)
+                    await loop.run_in_executor(
+                        None,
+                        update_longnames,
+                        nodes_snapshot,
+                    )
+                    await loop.run_in_executor(
+                        None,
+                        update_shortnames,
+                        nodes_snapshot,
+                    )
                 else:
                     meshtastic_logger.warning("Meshtastic client is not connected.")
 
@@ -217,15 +230,15 @@ async def main(config):
                         matrix_logger.warning(
                             "Matrix sync_forever completed unexpectedly"
                         )
-                    except Exception as e:
+                    except Exception:  # noqa: BLE001 — sync loop must keep retrying
                         # Log the exception and continue to retry
-                        matrix_logger.error(f"Matrix sync failed: {e}")
+                        matrix_logger.exception("Matrix sync failed")
                         # The outer try/catch will handle the retry logic
 
-            except Exception as e:
+            except Exception:  # noqa: BLE001 — keep loop alive for retries
                 if shutdown_event.is_set():
                     break
-                matrix_logger.error(f"Error syncing with Matrix server: {e}")
+                matrix_logger.exception("Error syncing with Matrix server")
                 await asyncio.sleep(5)  # Wait briefly before retrying
     except KeyboardInterrupt:
         await shutdown()
@@ -276,25 +289,30 @@ async def main(config):
             meshtastic_logger.info("Cancelled Meshtastic reconnect task.")
 
         # Cancel any remaining tasks (including the check_conn_task)
-        tasks = [t for t in asyncio.all_tasks(loop) if not t.done()]
-        for task in tasks:
+        current_task = asyncio.current_task()
+        pending_tasks = [
+            task
+            for task in asyncio.all_tasks(loop)
+            if task is not current_task and not task.done()
+        ]
+
+        for task in pending_tasks:
             task.cancel()
-            try:
-                await task
-            except asyncio.CancelledError:
-                pass
+
+        if pending_tasks:
+            await asyncio.gather(*pending_tasks, return_exceptions=True)
 
         matrix_logger.info("Shutdown complete.")
 
 
 def run_main(args):
     """
-    Run the application's top-level startup sequence and invoke the main async runner.
+    Start the application: load configuration, validate required keys, and run the main async runner.
 
-    Performs initial setup (prints banner, optionally sets a custom data directory, loads and applies configuration and logging overrides), validates that required configuration sections are present (required keys differ if credentials.json is present), then runs the main coroutine. Returns an exit code: 0 for successful run or user interrupt, 1 for configuration errors or unhandled exceptions.
+    Loads and applies configuration (optionally overriding logging level from args), initializes module configuration, verifies required configuration sections (required keys are ["meshtastic", "matrix_rooms"] when credentials.json is present, otherwise ["matrix", "meshtastic", "matrix_rooms"]), and executes the main async entrypoint. Returns process exit codes: 0 for successful completion or user interrupt, 1 for configuration errors or unhandled exceptions.
 
     Parameters:
-        args: Parsed command-line arguments (may be None). Recognized options used here include `data_dir` and `log_level`.
+        args: Parsed command-line arguments (may be None). Recognized option used here: `log_level` to override the configured logging level.
 
     Returns:
         int: Exit code (0 on success or user-initiated interrupt, 1 on failure such as invalid config or runtime error).
@@ -302,17 +320,6 @@ def run_main(args):
     # Print the banner at startup
     print_banner()
 
-    # Handle the --data-dir option
-    if args and args.data_dir:
-        import os
-
-        import mmrelay.config
-
-        # Set the global custom_data_dir variable
-        mmrelay.config.custom_data_dir = os.path.abspath(args.data_dir)
-        # Create the directory if it doesn't exist
-        os.makedirs(mmrelay.config.custom_data_dir, exist_ok=True)
-
     # Load configuration
     from mmrelay.config import load_config
 
@@ -405,12 +412,8 @@ def run_main(args):
     except KeyboardInterrupt:
         logger.info("Interrupted by user. Exiting.")
         return 0
-    except Exception as e:
-        import traceback
-
-        logger.error(f"Error running main functionality: {e}")
-        logger.error("Full traceback:")
-        logger.error(traceback.format_exc())
+    except Exception:  # noqa: BLE001 — top-level guard to log and exit cleanly
+        logger.exception("Error running main functionality")
         return 1