mmrelay 1.0__py3-none-any.whl

mmrelay/config_checker.py

@@ -0,0 +1,133 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+import os
+
+import yaml
+from yaml.loader import SafeLoader
+
+
+def get_config_paths():
+    """
+    Get a list of possible configuration file paths.
+
+    Returns:
+        list: A list of possible configuration file paths
+    """
+    from mmrelay.config import get_config_paths as get_paths
+
+    return get_paths()
+
+
+def check_config():
+    """
+    Check if the configuration file is valid.
+
+    Returns:
+        bool: True if the configuration is valid, False otherwise.
+    """
+    config_paths = get_config_paths()
+    config_path = None
+
+    # Try each config path in order until we find one that exists
+    for path in config_paths:
+        if os.path.isfile(path):
+            config_path = path
+            print(f"Found configuration file at: {config_path}")
+            try:
+                with open(config_path, "r") as f:
+                    config = yaml.load(f, Loader=SafeLoader)
+
+                # Check if config is empty
+                if not config:
+                    print("Error: Configuration file is empty or invalid")
+                    return False
+
+                # Check matrix section
+                if "matrix" not in config:
+                    print("Error: Missing 'matrix' section in config")
+                    return False
+
+                matrix_section = config["matrix"]
+                required_matrix_fields = ["homeserver", "access_token", "bot_user_id"]
+                missing_matrix_fields = [
+                    field
+                    for field in required_matrix_fields
+                    if field not in matrix_section
+                ]
+
+                if missing_matrix_fields:
+                    print(
+                        f"Error: Missing required fields in 'matrix' section: {', '.join(missing_matrix_fields)}"
+                    )
+                    return False
+
+                # Check matrix_rooms section
+                if "matrix_rooms" not in config or not config["matrix_rooms"]:
+                    print("Error: Missing or empty 'matrix_rooms' section in config")
+                    return False
+
+                if not isinstance(config["matrix_rooms"], list):
+                    print("Error: 'matrix_rooms' must be a list")
+                    return False
+
+                for i, room in enumerate(config["matrix_rooms"]):
+                    if not isinstance(room, dict):
+                        print(
+                            f"Error: Room {i+1} in 'matrix_rooms' must be a dictionary"
+                        )
+                        return False
+
+                    if "id" not in room:
+                        print(
+                            f"Error: Room {i+1} in 'matrix_rooms' is missing the 'id' field"
+                        )
+                        return False
+
+                # Check meshtastic section
+                if "meshtastic" not in config:
+                    print("Error: Missing 'meshtastic' section in config")
+                    return False
+
+                meshtastic_section = config["meshtastic"]
+                if "connection_type" not in meshtastic_section:
+                    print("Error: Missing 'connection_type' in 'meshtastic' section")
+                    return False
+
+                connection_type = meshtastic_section["connection_type"]
+                if connection_type not in ["tcp", "serial", "ble"]:
+                    print(
+                        f"Error: Invalid 'connection_type': {connection_type}. Must be 'tcp', 'serial', or 'ble'"
+                    )
+                    return False
+
+                # Check connection-specific fields
+                if (
+                    connection_type == "serial"
+                    and "serial_port" not in meshtastic_section
+                ):
+                    print("Error: Missing 'serial_port' for 'serial' connection type")
+                    return False
+
+                if connection_type == "tcp" and "host" not in meshtastic_section:
+                    print("Error: Missing 'host' for 'tcp' connection type")
+                    return False
+
+                if connection_type == "ble" and "ble_address" not in meshtastic_section:
+                    print("Error: Missing 'ble_address' for 'ble' connection type")
+                    return False
+
+                print("Configuration file is valid!")
+                return True
+            except yaml.YAMLError as e:
+                print(f"Error parsing YAML in {config_path}: {e}")
+                return False
+            except Exception as e:
+                print(f"Error checking configuration: {e}")
+                return False
+
+    print("Error: No configuration file found in any of the following locations:")
+    for path in config_paths:
+        print(f"  - {path}")
+    print("\nRun 'mmrelay --generate-config' to generate a sample configuration file.")
+    return False

mmrelay/db_utils.py

@@ -0,0 +1,309 @@
+import json
+import os
+import sqlite3
+
+from mmrelay.config import get_data_dir
+from mmrelay.log_utils import get_logger
+
+# Global config variable that will be set from main.py
+config = None
+
+logger = get_logger(name="db_utils")
+
+
+# Get the database path
+def get_db_path():
+    """
+    Returns the path to the SQLite database file.
+    By default, uses the standard data directory (~/.mmrelay/data).
+    Can be overridden by setting 'path' under 'database' in config.yaml.
+    """
+    global config
+
+    # Check if config is available
+    if config is not None:
+        # Check if database path is specified in config (preferred format)
+        if "database" in config and "path" in config["database"]:
+            custom_path = config["database"]["path"]
+            if custom_path:
+                # Ensure the directory exists
+                db_dir = os.path.dirname(custom_path)
+                if db_dir:
+                    os.makedirs(db_dir, exist_ok=True)
+                logger.info(f"Using database path from config: {custom_path}")
+                return custom_path
+
+        # Check legacy format (db section)
+        if "db" in config and "path" in config["db"]:
+            custom_path = config["db"]["path"]
+            if custom_path:
+                # Ensure the directory exists
+                db_dir = os.path.dirname(custom_path)
+                if db_dir:
+                    os.makedirs(db_dir, exist_ok=True)
+                logger.warning(
+                    "Using 'db.path' configuration (legacy). 'database.path' is now the preferred format and 'db.path' will be deprecated in a future version."
+                )
+                return custom_path
+
+    # Use the standard data directory
+    return os.path.join(get_data_dir(), "meshtastic.sqlite")
+
+
+# Initialize SQLite database
+def initialize_database():
+    db_path = get_db_path()
+    # Check if database exists
+    if os.path.exists(db_path):
+        logger.info(f"Loading database from: {db_path}")
+    else:
+        logger.info(f"Creating new database at: {db_path}")
+    with sqlite3.connect(db_path) as conn:
+        cursor = conn.cursor()
+        # Updated table schema: matrix_event_id is now PRIMARY KEY, meshtastic_id is not necessarily unique
+        cursor.execute(
+            "CREATE TABLE IF NOT EXISTS longnames (meshtastic_id TEXT PRIMARY KEY, longname TEXT)"
+        )
+        cursor.execute(
+            "CREATE TABLE IF NOT EXISTS shortnames (meshtastic_id TEXT PRIMARY KEY, shortname TEXT)"
+        )
+        cursor.execute(
+            "CREATE TABLE IF NOT EXISTS plugin_data (plugin_name TEXT, meshtastic_id TEXT, data TEXT, PRIMARY KEY (plugin_name, meshtastic_id))"
+        )
+        # Changed the schema for message_map: matrix_event_id is now primary key
+        # Added a new column 'meshtastic_meshnet' to store the meshnet origin of the message.
+        # If table already exists, we try adding the column if it doesn't exist.
+        cursor.execute(
+            "CREATE TABLE IF NOT EXISTS message_map (meshtastic_id INTEGER, matrix_event_id TEXT PRIMARY KEY, matrix_room_id TEXT, meshtastic_text TEXT, meshtastic_meshnet TEXT)"
+        )
+
+        # Attempt to add meshtastic_meshnet column if it's missing (for upgrades)
+        # This is a no-op if the column already exists.
+        # If user runs fresh, it will already be there from CREATE TABLE IF NOT EXISTS.
+        try:
+            cursor.execute("ALTER TABLE message_map ADD COLUMN meshtastic_meshnet TEXT")
+        except sqlite3.OperationalError:
+            # Column already exists, or table just created with it
+            pass
+
+        conn.commit()
+
+
+def store_plugin_data(plugin_name, meshtastic_id, data):
+    with sqlite3.connect(get_db_path()) as conn:
+        cursor = conn.cursor()
+        cursor.execute(
+            "INSERT OR REPLACE INTO plugin_data (plugin_name, meshtastic_id, data) VALUES (?, ?, ?) ON CONFLICT (plugin_name, meshtastic_id) DO UPDATE SET data = ?",
+            (plugin_name, meshtastic_id, json.dumps(data), json.dumps(data)),
+        )
+        conn.commit()
+
+
+def delete_plugin_data(plugin_name, meshtastic_id):
+    with sqlite3.connect(get_db_path()) as conn:
+        cursor = conn.cursor()
+        cursor.execute(
+            "DELETE FROM plugin_data WHERE plugin_name=? AND meshtastic_id=?",
+            (plugin_name, meshtastic_id),
+        )
+        conn.commit()
+
+
+# Get the data for a given plugin and Meshtastic ID
+def get_plugin_data_for_node(plugin_name, meshtastic_id):
+    with sqlite3.connect(get_db_path()) as conn:
+        cursor = conn.cursor()
+        cursor.execute(
+            "SELECT data FROM plugin_data WHERE plugin_name=? AND meshtastic_id=?",
+            (
+                plugin_name,
+                meshtastic_id,
+            ),
+        )
+        result = cursor.fetchone()
+    return json.loads(result[0] if result else "[]")
+
+
+# Get the data for a given plugin
+def get_plugin_data(plugin_name):
+    with sqlite3.connect(get_db_path()) as conn:
+        cursor = conn.cursor()
+        cursor.execute(
+            "SELECT data FROM plugin_data WHERE plugin_name=? ",
+            (plugin_name,),
+        )
+        return cursor.fetchall()
+
+
+# Get the longname for a given Meshtastic ID
+def get_longname(meshtastic_id):
+    with sqlite3.connect(get_db_path()) as conn:
+        cursor = conn.cursor()
+        cursor.execute(
+            "SELECT longname FROM longnames WHERE meshtastic_id=?", (meshtastic_id,)
+        )
+        result = cursor.fetchone()
+    return result[0] if result else None
+
+
+def save_longname(meshtastic_id, longname):
+    with sqlite3.connect(get_db_path()) as conn:
+        cursor = conn.cursor()
+        cursor.execute(
+            "INSERT OR REPLACE INTO longnames (meshtastic_id, longname) VALUES (?, ?)",
+            (meshtastic_id, longname),
+        )
+        conn.commit()
+
+
+def update_longnames(nodes):
+    if nodes:
+        for node in nodes.values():
+            user = node.get("user")
+            if user:
+                meshtastic_id = user["id"]
+                longname = user.get("longName", "N/A")
+                save_longname(meshtastic_id, longname)
+
+
+def get_shortname(meshtastic_id):
+    with sqlite3.connect(get_db_path()) as conn:
+        cursor = conn.cursor()
+        cursor.execute(
+            "SELECT shortname FROM shortnames WHERE meshtastic_id=?", (meshtastic_id,)
+        )
+        result = cursor.fetchone()
+    return result[0] if result else None
+
+
+def save_shortname(meshtastic_id, shortname):
+    with sqlite3.connect(get_db_path()) as conn:
+        cursor = conn.cursor()
+        cursor.execute(
+            "INSERT OR REPLACE INTO shortnames (meshtastic_id, shortname) VALUES (?, ?)",
+            (meshtastic_id, shortname),
+        )
+        conn.commit()
+
+
+def update_shortnames(nodes):
+    if nodes:
+        for node in nodes.values():
+            user = node.get("user")
+            if user:
+                meshtastic_id = user["id"]
+                shortname = user.get("shortName", "N/A")
+                save_shortname(meshtastic_id, shortname)
+
+
+def store_message_map(
+    meshtastic_id,
+    matrix_event_id,
+    matrix_room_id,
+    meshtastic_text,
+    meshtastic_meshnet=None,
+):
+    """
+    Stores a message map in the database.
+
+    :param meshtastic_id: The Meshtastic message ID (integer or None)
+    :param matrix_event_id: The Matrix event ID (string, primary key)
+    :param matrix_room_id: The Matrix room ID (string)
+    :param meshtastic_text: The text of the Meshtastic message
+    :param meshtastic_meshnet: The name of the meshnet this message originated from.
+                               This helps us identify remote vs local mesh origins.
+    """
+    with sqlite3.connect(get_db_path()) as conn:
+        cursor = conn.cursor()
+        logger.debug(
+            f"Storing message map: meshtastic_id={meshtastic_id}, matrix_event_id={matrix_event_id}, matrix_room_id={matrix_room_id}, meshtastic_text={meshtastic_text}, meshtastic_meshnet={meshtastic_meshnet}"
+        )
+        cursor.execute(
+            "INSERT OR REPLACE INTO message_map (meshtastic_id, matrix_event_id, matrix_room_id, meshtastic_text, meshtastic_meshnet) VALUES (?, ?, ?, ?, ?)",
+            (
+                meshtastic_id,
+                matrix_event_id,
+                matrix_room_id,
+                meshtastic_text,
+                meshtastic_meshnet,
+            ),
+        )
+        conn.commit()
+
+
+def get_message_map_by_meshtastic_id(meshtastic_id):
+    with sqlite3.connect(get_db_path()) as conn:
+        cursor = conn.cursor()
+        cursor.execute(
+            "SELECT matrix_event_id, matrix_room_id, meshtastic_text, meshtastic_meshnet FROM message_map WHERE meshtastic_id=?",
+            (meshtastic_id,),
+        )
+        result = cursor.fetchone()
+        logger.debug(
+            f"Retrieved message map by meshtastic_id={meshtastic_id}: {result}"
+        )
+        if result:
+            # result = (matrix_event_id, matrix_room_id, meshtastic_text, meshtastic_meshnet)
+            return result[0], result[1], result[2], result[3]
+        return None
+
+
+def get_message_map_by_matrix_event_id(matrix_event_id):
+    with sqlite3.connect(get_db_path()) as conn:
+        cursor = conn.cursor()
+        cursor.execute(
+            "SELECT meshtastic_id, matrix_room_id, meshtastic_text, meshtastic_meshnet FROM message_map WHERE matrix_event_id=?",
+            (matrix_event_id,),
+        )
+        result = cursor.fetchone()
+        logger.debug(
+            f"Retrieved message map by matrix_event_id={matrix_event_id}: {result}"
+        )
+        if result:
+            # result = (meshtastic_id, matrix_room_id, meshtastic_text, meshtastic_meshnet)
+            return result[0], result[1], result[2], result[3]
+        return None
+
+
+def wipe_message_map():
+    """
+    Wipes all entries from the message_map table.
+    Useful when database.msg_map.wipe_on_restart or db.msg_map.wipe_on_restart is True,
+    ensuring no stale data remains.
+    """
+    with sqlite3.connect(get_db_path()) as conn:
+        cursor = conn.cursor()
+        cursor.execute("DELETE FROM message_map")
+        conn.commit()
+    logger.info("message_map table wiped successfully.")
+
+
+def prune_message_map(msgs_to_keep):
+    """
+    Prune the message_map table to keep only the most recent msgs_to_keep entries
+    in order to prevent database bloat.
+    We use the matrix_event_id's insertion order as a heuristic.
+    Note: matrix_event_id is a string, so we rely on the rowid or similar approach.
+
+    Approach:
+    - Count total rows.
+    - If total > msgs_to_keep, delete oldest entries based on rowid.
+    """
+    with sqlite3.connect(get_db_path()) as conn:
+        cursor = conn.cursor()
+        # Count total entries
+        cursor.execute("SELECT COUNT(*) FROM message_map")
+        total = cursor.fetchone()[0]
+
+        if total > msgs_to_keep:
+            # Delete oldest entries by rowid since matrix_event_id is primary key but not necessarily numeric.
+            # rowid is auto-incremented and reflects insertion order.
+            to_delete = total - msgs_to_keep
+            cursor.execute(
+                "DELETE FROM message_map WHERE rowid IN (SELECT rowid FROM message_map ORDER BY rowid ASC LIMIT ?)",
+                (to_delete,),
+            )
+            conn.commit()
+            logger.info(
+                f"Pruned {to_delete} old message_map entries, keeping last {msgs_to_keep}."
+            )

mmrelay/log_utils.py

@@ -0,0 +1,107 @@
+import logging
+import os
+from logging.handlers import RotatingFileHandler
+
+from mmrelay.cli import parse_arguments
+from mmrelay.config import get_log_dir
+
+# Global config variable that will be set from main.py
+config = None
+
+
+def get_logger(name):
+    logger = logging.getLogger(name=name)
+
+    # Default to INFO level if config is not available
+    log_level = logging.INFO
+
+    # Try to get log level from config
+    global config
+    if config is not None and "logging" in config and "level" in config["logging"]:
+        log_level = getattr(logging, config["logging"]["level"].upper())
+
+    logger.setLevel(log_level)
+    logger.propagate = False
+
+    # Add stream handler (console logging)
+    stream_handler = logging.StreamHandler()
+    stream_handler.setFormatter(
+        logging.Formatter(
+            fmt="%(asctime)s %(levelname)s:%(name)s:%(message)s",
+            datefmt="%Y-%m-%d %H:%M:%S %z",
+        )
+    )
+    logger.addHandler(stream_handler)
+
+    # Check command line arguments for log file path
+    args = parse_arguments()
+
+    # Check if file logging is enabled
+    if (
+        config is not None
+        and config.get("logging", {}).get("log_to_file", False)
+        or args.logfile
+    ):
+        # Priority: 1. Command line arg, 2. Config file, 3. Default location (~/.mmrelay/logs)
+        if args.logfile:
+            log_file = args.logfile
+        else:
+            config_log_file = (
+                config.get("logging", {}).get("filename")
+                if config is not None
+                else None
+            )
+
+            if config_log_file:
+                # Use the log file specified in config
+                log_file = config_log_file
+            else:
+                # Default to standard log directory
+                log_file = os.path.join(get_log_dir(), "mmrelay.log")
+
+        # Create log directory if it doesn't exist
+        log_dir = os.path.dirname(log_file)
+        if log_dir:  # Ensure non-empty directory paths exist
+            os.makedirs(log_dir, exist_ok=True)
+
+        # Log which file we're using (only for the first logger)
+        if name == "M<>M Relay":
+            # Create a basic logger to log the log file path
+            # This is needed because we can't use the logger we're creating to log its own creation
+            basic_logger = logging.getLogger("LogSetup")
+            basic_logger.setLevel(logging.INFO)
+            basic_handler = logging.StreamHandler()
+            basic_handler.setFormatter(
+                logging.Formatter(
+                    fmt="%(asctime)s %(levelname)s:%(name)s:%(message)s",
+                    datefmt="%Y-%m-%d %H:%M:%S %z",
+                )
+            )
+            basic_logger.addHandler(basic_handler)
+            basic_logger.info(f"Writing logs to: {log_file}")
+
+        # Create a file handler for logging
+        try:
+            # Set up size-based log rotation
+            max_bytes = 10 * 1024 * 1024  # Default 10 MB
+            backup_count = 1  # Default to 1 backup
+
+            if config is not None and "logging" in config:
+                max_bytes = config["logging"].get("max_log_size", max_bytes)
+                backup_count = config["logging"].get("backup_count", backup_count)
+            file_handler = RotatingFileHandler(
+                log_file, maxBytes=max_bytes, backupCount=backup_count, encoding="utf-8"
+            )
+        except Exception as e:
+            print(f"Error creating log file at {log_file}: {e}")
+            return logger  # Return logger without file handler
+
+        file_handler.setFormatter(
+            logging.Formatter(
+                fmt="%(asctime)s %(levelname)s:%(name)s:%(message)s",
+                datefmt="%Y-%m-%d %H:%M:%S %z",
+            )
+        )
+        logger.addHandler(file_handler)
+
+    return logger