boneio 1.6.0.dev17__tar.gz → 1.6.0.dev18__tar.gz

{boneio-1.6.0.dev17/boneio.egg-info → boneio-1.6.0.dev18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boneio
-Version: 1.6.0.dev17
+Version: 1.6.0.dev18
 Summary: Python App for BoneIO
 Author-email: Paweł Szafer <pszafer@gmail.com>
 License: GNU General Public License v3.0

{boneio-1.6.0.dev17 → boneio-1.6.0.dev18}/boneio/core/recovery.py

@@ -231,10 +231,12 @@ class StartupFailures:
     def allow_one_retry(self) -> None:
         """Let the next start run normally, but only that one.
 
-        Called when the owner leaves recovery. Clearing the count outright
-        would cost three more crashes - most of a minute each on a BeagleBone
-        - before the panel came back if the fix did not work; one below the
-        threshold gives the fix a single try.
+        Called when the owner leaves recovery, and when recovery cannot run
+        at all (no ``web`` section, no account to sign in with): without a
+        panel, another normal start is the only way out of the loop.
+        Clearing the count outright would cost three more crashes - most of
+        a minute each on a BeagleBone - before the panel came back if the fix
+        did not work; one below the threshold gives the fix a single try.
         """
         data = self._read()
         if self.count >= CRASH_LOOP_THRESHOLD:

boneio-1.6.0.dev18/boneio/core/utils/logger.py

@@ -0,0 +1,346 @@
+import logging
+import os
+import sys
+import threading
+from logging import Formatter
+from typing import IO
+from logging.handlers import RotatingFileHandler
+
+from colorlog import ColoredFormatter
+
+from boneio.const import PAHO, PYMODBUS
+from boneio.version import __version__
+
+_LOGGER = logging.getLogger(__name__)
+_nameToLevel = {
+    "CRITICAL": logging.CRITICAL,
+    "FATAL": logging.FATAL,
+    "ERROR": logging.ERROR,
+    "WARN": logging.WARNING,
+    "WARNING": logging.WARNING,
+    "INFO": logging.INFO,
+    "DEBUG": logging.DEBUG,
+    "NOTSET": logging.NOTSET,
+}
+
+
+#: The one logger pymodbus 3.x writes through (its ``Log`` class).
+PYMODBUS_INTERNAL_LOGGER = "pymodbus.logging"
+
+
+class _PymodbusNoResponseFilter(logging.Filter):
+    """Drop pymodbus's own report of a device that did not answer.
+
+    pymodbus logs "No response received after N retries" at ERROR and then
+    raises ModbusIOException, which boneio.modbus.client catches and reports
+    itself — with the device and register, and rate-limited, WARNING once and
+    INFO after. Without this the same timeout is logged twice per poll and the
+    pymodbus copy stays at ERROR forever. Everything else pymodbus logs is
+    left alone.
+
+    pymodbus replaces the second identical message in a row with
+    "Repeating....", so that is dropped too, but only straight after a dropped
+    no-response line; after anything else it is the only trace of a repeat.
+    """
+
+    def __init__(self) -> None:
+        """Initialize the filter."""
+        super().__init__()
+        self._dropped_last = False
+
+    def filter(self, record: logging.LogRecord) -> bool:
+        """Return False for the duplicated no-response message."""
+        msg = str(record.msg)
+        if msg.startswith("No response received after"):
+            self._dropped_last = True
+            return False
+        # pymodbus appends the last frames it sent to an error, so the marker
+        # is a prefix, not the whole message.
+        if msg.startswith("Repeating....") and self._dropped_last:
+            return False
+        self._dropped_last = False
+        return True
+
+
+_PYMODBUS_NO_RESPONSE_FILTER = _PymodbusNoResponseFilter()
+
+
+def _configure_pymodbus_filter(log_config: dict, debug: int) -> None:
+    """Install the no-response filter unless the operator asked for pymodbus.
+
+    An explicit ``logger.logs`` entry for pymodbus, or ``-dd``, means somebody
+    wants to see what pymodbus says, so the filter stays off. Removed first
+    because this runs again on every config reload.
+    """
+    internal = logging.getLogger(PYMODBUS_INTERNAL_LOGGER)
+    internal.removeFilter(_PYMODBUS_NO_RESPONSE_FILTER)
+    configured = (log_config or {}).get("logs") or {}
+    explicit = any(
+        name == PYMODBUS or name.startswith(PYMODBUS + ".") for name in configured
+    )
+    if not explicit and debug <= 1:
+        internal.addFilter(_PYMODBUS_NO_RESPONSE_FILTER)
+
+
+def configure_logger(log_config: dict, debug: int) -> None:
+    """Configure logger based on config yaml."""
+    _configure_pymodbus_filter(log_config, debug)
+
+    def debug_logger():
+        # Always suppress hypercorn access logs (they spam INFO level)
+        logging.getLogger("hypercorn.access").setLevel(logging.WARNING)
+        
+        if debug == 0:
+            logging.getLogger().setLevel(logging.INFO)
+        if debug > 0:
+            logging.getLogger().setLevel(logging.DEBUG)
+            logging.getLogger(PAHO).setLevel(logging.WARN)
+            logging.getLogger(PYMODBUS).setLevel(logging.WARN)
+            logging.getLogger("pymodbus.client").setLevel(logging.WARN)
+            _LOGGER.info("Debug mode active")
+            _LOGGER.debug(f"Lib version is {__version__}")
+        if debug > 1:
+            logging.getLogger(PAHO).setLevel(logging.DEBUG)
+            logging.getLogger(PYMODBUS).setLevel(logging.DEBUG)
+            logging.getLogger("pymodbus.client").setLevel(logging.DEBUG)
+            logging.getLogger("hypercorn.error").setLevel(logging.DEBUG)
+
+    if not log_config:
+        debug_logger()
+        return
+    default = log_config.get("default", "").upper()
+    if default in _nameToLevel:
+        _LOGGER.info("Setting default log level to %s", default)
+        logging.getLogger().setLevel(_nameToLevel[default])
+        if debug == 0:
+            debug = -1
+    for k, v in log_config.get("logs", {}).items():
+        logger = logging.getLogger(k)
+        val = v.upper()
+        if val in _nameToLevel and logger:
+            _LOGGER.info("Setting %s log level to %s", k, val)
+            logger.setLevel(_nameToLevel[val])
+    debug_logger()
+
+
+"""Shared logging configuration for BoneIO."""
+
+
+_nameToLevel = {
+    "CRITICAL": logging.CRITICAL,
+    "FATAL": logging.FATAL,
+    "ERROR": logging.ERROR,
+    "WARN": logging.WARNING,
+    "WARNING": logging.WARNING,
+    "INFO": logging.INFO,
+    "DEBUG": logging.DEBUG,
+    "NOTSET": logging.NOTSET,
+}
+
+def get_log_level(level_name: str) -> int:
+    """Convert string log level to logging constant."""
+    return _nameToLevel.get(level_name.upper(), logging.INFO)
+
+def is_running_under_systemd():
+    """Check if the process is running under systemd."""
+    return os.getenv('JOURNAL_STREAM') is not None
+
+def is_journal_stream(stream: IO | None) -> bool:
+    """Whether ``stream`` is the one systemd connected to the journal.
+
+    systemd sets JOURNAL_STREAM to "device:inode" of the socket it gave the
+    service as stdout/stderr (systemd.exec(5)). The variable alone is not
+    enough: a child of boneIO inherits it with its stderr piped elsewhere, and
+    there a level prefix would be noise in somebody else's output.
+    """
+    value = os.environ.get("JOURNAL_STREAM")
+    if not value or stream is None:
+        return False
+    try:
+        device, inode = (int(part) for part in value.split(":"))
+        st = os.fstat(stream.fileno())
+    except (ValueError, OSError, AttributeError):
+        # io.UnsupportedOperation (no real fd, e.g. pytest's capture) is
+        # both an OSError and a ValueError.
+        return False
+    return (st.st_dev, st.st_ino) == (device, inode)
+
+
+def syslog_priority(levelno: int) -> int:
+    """Map a logging level to the syslog priority journald files it under."""
+    if levelno >= logging.CRITICAL:
+        return 2
+    if levelno >= logging.ERROR:
+        return 3
+    if levelno >= logging.WARNING:
+        return 4
+    if levelno >= logging.INFO:
+        return 6
+    return 7
+
+
+class JournalLevelFormatter(Formatter):
+    """Prefix every line of a record with its level for journald.
+
+    journald reads what a service writes to stdout/stderr line by line and
+    files each line at PRIORITY=6 unless it starts with "<N>" (the sd-daemon
+    prefix; SyslogLevelPrefix= is on by default). boneIO wrote plain text, so
+    its warnings, errors and tracebacks were all "info" to the journal - and
+    never reached the serial console, which since 1.6.25 shows warning and
+    above. A traceback is one record but many lines, and journald makes each
+    line a separate entry, so every line gets the prefix, not just the first.
+    journald strips it again; the stored message is unchanged.
+
+    Only the formatted text is prefixed. The record, including the traceback
+    text the base class caches on it, is left alone for the other handlers.
+    """
+
+    def __init__(self, inner: Formatter) -> None:
+        """Wrap ``inner``, which does the actual formatting."""
+        super().__init__()
+        self._inner = inner
+
+    def format(self, record: logging.LogRecord) -> str:
+        """Format with the inner formatter and prefix each line."""
+        prefix = f"<{syslog_priority(record.levelno)}>"
+        text = self._inner.format(record)
+        return "\n".join(prefix + line for line in text.split("\n"))
+
+
+def get_log_formatter(color: bool = True, stream: IO | None = None) -> Formatter:
+    """Get log formatter with optional color support.
+
+    Args:
+        color: Colour the output by level.
+        stream: Stream the handler writes to. When it is the journal, the
+            formatter tells journald each line's level and drops the colours:
+            journald keeps a message with escape codes as a byte array rather
+            than text, the level now travels in PRIORITY (journalctl colours
+            by it), and the prefix has to be the first thing on the line.
+    """
+    if is_journal_stream(stream):
+        return JournalLevelFormatter(
+            Formatter("%(levelname)s (%(threadName)s) [%(name)s] %(message)s")
+        )
+
+    # When running under systemd, omit timestamp since journald adds it
+    if is_running_under_systemd():
+        log_format = "%(levelname)s (%(threadName)s) [%(name)s] %(message)s"
+    else:
+        log_format = "%(asctime)s %(levelname)s (%(threadName)s) [%(name)s] %(message)s"
+    
+    date_format = "%Y-%m-%d %H:%M:%S"
+    
+    if color:
+        colored_format = "%(log_color)s" + log_format + "%(reset)s"
+        return ColoredFormatter(
+            fmt=colored_format,
+            datefmt=date_format,
+            reset=True,
+            log_colors={
+                "DEBUG": "cyan",
+                "INFO": "green",
+                "WARNING": "yellow",
+                "ERROR": "red",
+                "CRITICAL": "red",
+            },
+        )
+    return Formatter(log_format, datefmt=date_format)
+
+
+def install_excepthooks() -> None:
+    """Send exceptions nobody caught through logging instead of bare stderr.
+
+    Python prints an uncaught exception straight to stderr, which under
+    systemd means one journal entry per traceback line, all at "info" - so
+    the one message that explains why boneIO died never reached the serial
+    console. Through logging it gets the level prefix like everything else.
+    An exception in the main thread ends the process and is CRITICAL; one
+    that ends another thread is ERROR, since boneIO carries on without it.
+    Ctrl+C keeps Python's usual short output, and a thread ending with
+    SystemExit stays silent, as it is by default.
+    """
+    logger = logging.getLogger("boneio")
+
+    def _log_uncaught(exc_type, exc_value, exc_traceback) -> None:
+        if issubclass(exc_type, KeyboardInterrupt):
+            sys.__excepthook__(exc_type, exc_value, exc_traceback)
+            return
+        try:
+            logger.critical(
+                "Uncaught exception, boneIO is exiting",
+                exc_info=(exc_type, exc_value, exc_traceback),
+            )
+        except Exception:  # noqa: BLE001 - the traceback must come out somehow
+            sys.__excepthook__(exc_type, exc_value, exc_traceback)
+
+    def _log_uncaught_in_thread(args: threading.ExceptHookArgs) -> None:
+        if args.exc_type is SystemExit:
+            return
+        try:
+            logger.error(
+                "Uncaught exception in thread %s",
+                args.thread.name if args.thread is not None else "unknown",
+                exc_info=(args.exc_type, args.exc_value, args.exc_traceback),
+            )
+        except Exception:  # noqa: BLE001
+            threading.__excepthook__(args)
+
+    sys.excepthook = _log_uncaught
+    threading.excepthook = _log_uncaught_in_thread
+
+
+def setup_logging(debug_level: int = 0) -> None:
+    """Setup logging configuration."""
+    log_format = "%(asctime)s %(levelname)s (%(threadName)s) [%(name)s] %(message)s"
+    date_format = "%Y-%m-%d %H:%M:%S"
+    
+    # Set up basic configuration for console output
+    logging.basicConfig(
+        level=logging.INFO if debug_level == 0 else logging.DEBUG,
+        format=log_format,
+        datefmt=date_format
+    )
+    
+    # Create console handler
+    console_handler = logging.StreamHandler()
+    console_handler.setLevel(logging.INFO if debug_level == 0 else logging.DEBUG)
+    
+    # Create formatter for console handler. basicConfig's handler writes to
+    # stderr; the formatter needs to know whether that is the journal.
+    root_handler = logging.getLogger().handlers[0]
+    console_formatter = get_log_formatter(
+        color=True, stream=getattr(root_handler, "stream", None)
+    )
+    console_handler.setFormatter(console_formatter)
+    
+    # Add console handler to root logger
+    root_handler.setFormatter(console_formatter)
+    install_excepthooks()
+    
+    # If debug level > 1, also log to file with rotation
+    if debug_level > 1:
+        # Get the config directory path
+        # config_dir = os.path.dirname(os.path.abspath(os.environ.get("BONEIO_CONFIG", "/tmp")))
+        new_config_dir = "/tmp"
+        log_file = os.path.join(new_config_dir, "boneio.log")
+        
+        # Create rotating file handler (10MB max size, keep 3 backup files)
+        file_handler = RotatingFileHandler(
+            log_file,
+            maxBytes=10 * 1024 * 1024,  # 10MB
+            backupCount=3,
+            encoding='utf-8'
+        )
+        
+        # Set formatter for file handler
+        formatter = logging.Formatter(log_format, date_format)
+        file_handler.setFormatter(formatter)
+        
+        # Set level for file handler
+        file_handler.setLevel(logging.DEBUG)
+        
+        # Add handler to root logger
+        logging.getLogger().addHandler(file_handler)
+        
+        logging.info("File logging enabled at: %s", log_file)

{boneio-1.6.0.dev17 → boneio-1.6.0.dev18}/boneio/hardware/display/early_oled.py

@@ -208,6 +208,11 @@ def draw_crash(exception: BaseException, device: Any | None = None) -> None:
     This function ALWAYS works, even after handoff() — crashes must be
     visible to the user regardless of which component owns the screen.
 
+    It also marks the display to survive the exit. Every caller returns 1
+    straight after drawing, and luma's atexit hook would otherwise blank
+    the panel a moment later - the message was up for about a second, then
+    the cabinet showed a black screen until systemd's next start.
+
     Args:
         exception: The exception that caused the crash.
         device: Optional device override; uses singleton if not provided.
@@ -223,6 +228,7 @@ def draw_crash(exception: BaseException, device: Any | None = None) -> None:
             detail=exc_msg,
             device=device,
         )
+        keep_on_exit(device)
     finally:
         _taken_over = was_taken_over
 
@@ -274,6 +280,23 @@ def draw_recovery(title: str, message: str, url: str | None = None, device: Any
         _LOGGER.debug("Failed to draw recovery notice on OLED: %s", err)
 
 
+def keep_on_exit(device: Any | None = None) -> None:
+    """Leave whatever is on the display there when the process exits.
+
+    luma registers an atexit hook that switches the panel off and clears it
+    unless the device is marked ``persist``. Right for a clean shutdown, but
+    a message drawn just before a deliberate exit - one systemd will follow
+    with another start - would otherwise vanish with the process and leave
+    the cabinet with a black screen instead of the reason.
+
+    Args:
+        device: Optional device override; uses singleton if not provided.
+    """
+    dev = device or _early_device
+    if dev is not None:
+        dev.persist = True
+
+
 def clear_display(device: Any | None = None) -> None:
     """Clear the OLED display (turn all pixels off).
 

{boneio-1.6.0.dev17 → boneio-1.6.0.dev18}/boneio/hardware/gpio/input/manager.py

@@ -14,6 +14,7 @@ from gpiod import LineSettings
 from gpiod.line import Bias, Direction, Edge
 
 from boneio.const import PINS
+from boneio.hardware.udev_wait import RETRY_SECONDS, NodeWait, is_not_ready
 
 if TYPE_CHECKING:
     from boneio.components.input.detectors import BinarySensorDetector, MultiClickDetector
@@ -52,6 +53,8 @@ class GpioManager:
         if debounce_ms > self.MAX_DEBOUNCE_MS:
             raise ValueError(f"debounce_ms={debounce_ms} exceeds BeagleBone hardware limit of {self.MAX_DEBOUNCE_MS}ms")
         self._loop = loop
+        # Awaited between attempts to open a chip; a test swaps in a fake clock.
+        self._sleep = asyncio.sleep
         self._debounce_ms = debounce_ms
         self._inputs: list[GpioInputDefinition] = []
         self._requests: dict[int, gpiod.LineRequest] = {}
@@ -176,6 +179,41 @@ class GpioManager:
 
         return successful_lines, failed_lines
 
+    async def _request_lines_when_ready(
+        self, chip: int, consumer: str, config: dict[tuple[int, ...], LineSettings]
+    ) -> gpiod.LineRequest:
+        """Request the chip's lines, waiting for udev if it has to.
+
+        On the first boot of a fresh image boneIO can get here before udev
+        has handed /dev/gpiochip* to the gpio group. One attempt used to be
+        all there was: the chip was logged as failed and skipped, and its
+        inputs stayed dead until someone restarted boneIO by hand. Now a
+        missing or not yet accessible chip is retried once a second within
+        the startup budget shared with the I2C bus
+        (:mod:`boneio.hardware.udev_wait`). The sleep is awaited, so the event
+        loop keeps running. When the budget runs out, or on any other error,
+        the original error is raised and start() reports and skips the chip
+        as before.
+        """
+        path = f"/dev/gpiochip{chip}"
+        node = NodeWait(path, _LOGGER)
+        while True:
+            try:
+                request = gpiod.request_lines(
+                    path,
+                    consumer=consumer,
+                    config=config,  # type: ignore[arg-type]
+                )
+            except OSError as err:
+                if node.retry(err):
+                    await self._sleep(RETRY_SECONDS)
+                    continue
+                if node.waiting and is_not_ready(err):
+                    _LOGGER.error("%s still not accessible after %.0f s", path, node.elapsed)
+                raise
+            node.opened()
+            return request
+
     async def start(self, debug_mode: bool = False) -> None:
         """Start monitoring GPIO inputs.
 
@@ -250,11 +288,7 @@ class GpioManager:
 
             # Request all lines at once (fast mode or after debug validation)
             try:
-                request = gpiod.request_lines(
-                    f"/dev/gpiochip{chip}",
-                    consumer=consumer,
-                    config=config,  # type: ignore[arg-type]
-                )
+                request = await self._request_lines_when_ready(chip, consumer, config)
                 self._requests[chip] = request
                 _LOGGER.info("✓ Successfully configured chip %d with %d lines", chip, len(config))
             except OSError as err:

{boneio-1.6.0.dev17 → boneio-1.6.0.dev18}/boneio/hardware/i2c/bus.py

@@ -8,11 +8,14 @@ from __future__ import annotations
 
 import logging
 import threading
+import time
 from contextlib import suppress
 from typing import Optional
 
 from smbus2 import SMBus, i2c_msg
 
+from boneio.hardware.udev_wait import RETRY_SECONDS, STARTUP_WAIT_SECONDS, NodeWait, is_not_ready
+
 _LOGGER = logging.getLogger(__name__)
 
 
@@ -29,18 +32,56 @@ class SMBus2I2C:
         bus_number: I2C bus number (typically 2 for BeagleBone Black)
     """
 
-    def __init__(self, bus_number: int = 2):
+    def __init__(self, bus_number: int = 2, startup_wait: float = STARTUP_WAIT_SECONDS):
         """Initialize I2C bus wrapper.  
         
         Args:
             bus_number: I2C bus number (default 2 for BBB I2C-2)
+            startup_wait: Seconds to keep retrying while the device node is
+                missing or not accessible yet, within the startup budget it
+                shares with the GPIO chips, see
+                :data:`boneio.hardware.udev_wait.STARTUP_WAIT_SECONDS`.
         """
         self._bus_number = bus_number
         self._bus: SMBus | None = None
         self._lock = threading.RLock()  # Reentrant lock for thread safety
-        self._open_bus()
+        self._open_bus_when_ready(startup_wait)
         _LOGGER.info("Initialized I2C wrapper on bus %d (smbus2)", bus_number)
 
+    def _open_bus_when_ready(self, wait: float) -> None:
+        """Open the bus for the first time, waiting for udev if it has to.
+
+        Only construction waits. A reopen later on (``__enter__``,
+        ``try_lock``) runs on the event loop, where blocking for a minute
+        would stall everything else; there the device node has long been set
+        up, so a failure is a real one.
+
+        Only "not there" and "not ours yet" are waited out - the two states
+        udev leaves the node in before its rule has run. Anything else fails
+        at once, as before, and so does the last attempt: the original error
+        is re-raised, so the crash reads the same as it always did.
+        """
+        path = f"/dev/i2c-{self._bus_number}"
+        # The clock is looked up here, not in NodeWait, so a test that swaps
+        # this module's ``time`` moves the deadline and the sleep together.
+        node = NodeWait(path, _LOGGER, wait=wait, clock=time.monotonic)
+        while True:
+            try:
+                # Not _open_bus(): that logs an ERROR per failure, and a wait
+                # would fill the journal with them.
+                self._bus = SMBus(self._bus_number)
+                break
+            except OSError as err:
+                if node.retry(err):
+                    time.sleep(RETRY_SECONDS)
+                    continue
+                if node.waiting and is_not_ready(err):
+                    _LOGGER.error("%s still not accessible after %.0f s: %s", path, node.elapsed, err)
+                else:
+                    _LOGGER.error(f"Failed to open I2C bus {self._bus_number}: {err}")
+                raise
+        node.opened()
+
     def _open_bus(self) -> None:
         """Open I2C bus if not already open."""
         if self._bus is None: