updates2mqtt 1.3.4__py3-none-any.whl

updates2mqtt/__init__.py

@@ -0,0 +1,5 @@
+"""Detect component version change availability and broadcast on MQTT topic, suitable for HomeAssistant autodetect"""
+
+from usingversion import getattr_with_version
+
+__getattr__ = getattr_with_version("updates2mqtt", __file__, __name__)

updates2mqtt/__main__.py

@@ -0,0 +1,6 @@
+"""Detect component version change availability and broadcast on MQTT topic, suitable for HomeAssistant autodetect"""
+
+if __name__ == "__main__":
+    from updates2mqtt.app import run
+
+    run()

updates2mqtt/app.py

@@ -0,0 +1,203 @@
+import asyncio
+import logging
+import sys
+import time
+import uuid
+from collections.abc import Callable
+from datetime import UTC, datetime
+from pathlib import Path
+from threading import Event
+from typing import Any
+
+import structlog
+
+import updates2mqtt
+from updates2mqtt.model import Discovery, ReleaseProvider
+
+from .config import Config, load_app_config, load_package_info
+from .integrations.docker import DockerProvider
+from .mqtt import MqttClient
+
+log = structlog.get_logger()
+
+CONF_FILE = Path("conf/config.yaml")
+PKG_INFO_FILE = Path("./common_packages.yaml")
+UPDATE_INTERVAL = 60 * 60 * 4
+
+# #TODO:
+#  - Set install in progress
+#  - Support apt
+#  - Retry on registry fetch fail
+#  - Fetcher in subproc or thread
+#  - Clear command message after install
+#  - use git hash as alt to img ref for builds, or daily builds
+
+
+class App:
+    def __init__(self) -> None:
+        self.startup_timestamp: str = datetime.now(UTC).isoformat()
+        self.last_scan_timestamp: str | None = None
+        app_config: Config | None = load_app_config(CONF_FILE)
+        if app_config is None:
+            log.error(f"Invalid configuration at {CONF_FILE}, exiting")
+            sys.exit(1)
+        self.cfg: Config = app_config
+
+        structlog.configure(wrapper_class=structlog.make_filtering_bound_logger(getattr(logging, self.cfg.log.level)))
+        log.debug("Logging initialized", level=self.cfg.log.level)
+        self.common_pkg = load_package_info(PKG_INFO_FILE)
+
+        self.publisher = MqttClient(self.cfg.mqtt, self.cfg.node, self.cfg.homeassistant)
+
+        self.scanners: list[ReleaseProvider] = []
+        self.scan_count: int = 0
+        self.last_scan: str | None = None
+        if self.cfg.docker.enabled:
+            self.scanners.append(DockerProvider(self.cfg.docker, self.common_pkg, self.cfg.node))
+        self.stopped = Event()
+        self.healthcheck_topic = self.cfg.node.healthcheck.topic_template.format(node_name=self.cfg.node.name)
+
+        log.info(
+            "App configured",
+            node=self.cfg.node.name,
+            scan_interval=self.cfg.scan_interval,
+        )
+
+    async def scan(self) -> None:
+        session = uuid.uuid4().hex
+        for scanner in self.scanners:
+            log.info("Cleaning topics before scan", source_type=scanner.source_type)
+            if self.scan_count == 0:
+                await self.publisher.clean_topics(scanner, None, force=True)
+            if self.stopped.is_set():
+                break
+            log.info("Scanning", source=scanner.source_type, session=session)
+            async with asyncio.TaskGroup() as tg:
+                async for discovery in scanner.scan(session):  # type: ignore[attr-defined]
+                    tg.create_task(self.on_discovery(discovery), name=f"discovery-{discovery.name}")
+            if self.stopped.is_set():
+                break
+            await self.publisher.clean_topics(scanner, session, force=False)
+            self.scan_count += 1
+            log.info("Scan complete", source_type=scanner.source_type)
+        self.last_scan_timestamp = datetime.now(UTC).isoformat()
+
+    async def run(self) -> None:
+        log.debug("Starting run loop")
+        self.publisher.start()
+
+        if self.cfg.node.healthcheck.enabled:
+            await self.healthcheck()  # initial eager healthcheck
+            log.info(
+                f"Setting up healthcheck every {self.cfg.node.healthcheck.interval} seconds to topic {self.healthcheck_topic}"
+            )
+            self.healthcheck_loop_task = asyncio.create_task(
+                repeated_call(self.healthcheck, interval=self.cfg.node.healthcheck.interval)
+            )
+
+        for scanner in self.scanners:
+            self.publisher.subscribe_hass_command(scanner)
+
+        while not self.stopped.is_set():
+            await self.scan()
+            if not self.stopped.is_set():
+                await asyncio.sleep(self.cfg.scan_interval)
+            else:
+                log.info("Stop requested, exiting run loop and skipping sleep")
+        log.debug("Exiting run loop")
+
+    async def on_discovery(self, discovery: Discovery) -> None:
+        dlog = log.bind(name=discovery.name)
+        try:
+            if self.cfg.homeassistant.discovery.enabled:
+                self.publisher.publish_hass_config(discovery)
+
+            self.publisher.publish_hass_state(discovery)
+            if discovery.update_policy == "Auto":
+                # TODO: review auto update, trigger by version, use update interval as throttle
+                elapsed: float = (
+                    time.time() - discovery.update_last_attempt if discovery.update_last_attempt is not None else -1
+                )
+                if elapsed == -1 or elapsed > UPDATE_INTERVAL:
+                    dlog.info(
+                        "Initiate auto update (last:%s, elapsed:%s, max:%s)",
+                        discovery.update_last_attempt,
+                        elapsed,
+                        UPDATE_INTERVAL,
+                    )
+                    self.publisher.local_message(discovery, "install")
+                else:
+                    dlog.info("Skipping auto update")
+        except asyncio.CancelledError:
+            dlog.info("Discovery handling cancelled")
+        except Exception:
+            dlog.exception("Discovery handling failed")
+            raise
+
+    async def interrupt_tasks(self) -> None:
+        running_tasks = [t for t in asyncio.all_tasks() if t is not asyncio.current_task()]
+        log.info(f"Cancelling {len(running_tasks)} tasks")
+        for t in running_tasks:
+            log.debug("Cancelling task", task=t.get_name())
+            t.cancel()
+        await asyncio.gather(*running_tasks, return_exceptions=True)
+        log.debug("Cancellation task completed")
+
+    def shutdown(self, *args) -> None:  # noqa: ANN002
+        log.info("Shutting down on SIGTERM: %s", args)
+        self.stopped.set()
+        for scanner in self.scanners:
+            scanner.stop()
+        interrupt_task = asyncio.get_event_loop().create_task(self.interrupt_tasks(), eager_start=True)  # type: ignore[call-arg] # pyright: ignore[reportCallIssue]
+        for t in asyncio.all_tasks():
+            log.debug("Tasks waiting = %s", t)
+        self.publisher.stop()
+        log.debug("Interrupt: %s", interrupt_task.done())
+        log.info("Shutdown handling complete")
+
+    async def healthcheck(self) -> None:
+        self.publisher.publish(
+            topic=self.healthcheck_topic,
+            payload={
+                "version": updates2mqtt.version,
+                "node": self.cfg.node.name,
+                "heartbeat_raw": time.time(),
+                "heartbeat_stamp": datetime.now(UTC).isoformat(),
+                "startup_stamp": self.startup_timestamp,
+                "last_scan_stamp": self.last_scan_timestamp,
+                "scan_count": self.scan_count,
+            },
+        )
+
+
+async def repeated_call(func: Callable, interval: int = 60, *args: Any, **kwargs: Any) -> None:
+    # run a task periodically indefinitely
+    while True:
+        try:
+            await func(*args, **kwargs)
+            await asyncio.sleep(interval)
+        except asyncio.CancelledError:
+            log.exception("Periodic task cancelled")
+        except Exception:
+            log.exception("Periodic task failed")
+
+
+def run() -> None:
+    import asyncio
+    import signal
+
+    from .app import App
+
+    log.debug(f"Starting updates2mqtt v{updates2mqtt.version}")
+    app = App()
+
+    signal.signal(signal.SIGTERM, app.shutdown)
+    try:
+        asyncio.run(app.run(), debug=False)
+        log.debug("App exited gracefully")
+    except asyncio.CancelledError:
+        log.debug("App exited on cancelled task")
+
+
+if __name__ == "__main__":
+    run()

updates2mqtt/config.py

@@ -0,0 +1,135 @@
+import os
+import typing
+from dataclasses import dataclass, field
+from pathlib import Path
+
+import structlog
+from omegaconf import MISSING, MissingMandatoryValue, OmegaConf, ValidationError
+
+log = structlog.get_logger()
+
+
+@dataclass
+class MqttConfig:
+    host: str = "localhost"
+    user: str = MISSING
+    password: str = MISSING
+    port: int = 1883
+    topic_root: str = "updates2mqtt"
+
+
+@dataclass
+class MetadataSourceConfig:
+    enabled: bool = True
+    cache_ttl: int = 60 * 60 * 24 * 7  # 1 week
+
+
+@dataclass
+class DockerConfig:
+    enabled: bool = True
+    allow_pull: bool = True
+    allow_restart: bool = True
+    allow_build: bool = True
+    compose_version: str = "v2"
+    default_entity_picture_url: str = "https://www.docker.com/wp-content/uploads/2022/03/Moby-logo.png"
+    device_icon: str = "mdi:docker"  # Icon to show when browsing entities in Home Assistant
+    discover_metadata: dict[str, MetadataSourceConfig] = field(
+        default_factory=lambda: {"linuxserver.io": MetadataSourceConfig(enabled=True)}
+    )
+
+
+@dataclass
+class HomeAssistantDiscoveryConfig:
+    prefix: str = "homeassistant"
+    enabled: bool = True
+
+
+@dataclass
+class HomeAssistantConfig:
+    discovery: HomeAssistantDiscoveryConfig = field(default_factory=HomeAssistantDiscoveryConfig)
+    state_topic_suffix: str = "state"
+
+
+@dataclass
+class HealthCheckConfig:
+    enabled: bool = True
+    interval: int = 300  # Interval in seconds to publish healthcheck message, 0 to disable
+    topic_template: str = "healthcheck/{node_name}/updates2mqtt"
+
+
+@dataclass
+class NodeConfig:
+    name: str = field(default_factory=lambda: os.uname().nodename.replace(".local", ""))
+    git_path: str = "/usr/bin/git"
+    healthcheck: HealthCheckConfig = field(default_factory=HealthCheckConfig)
+
+
+@dataclass
+class LogConfig:
+    level: str = "INFO"
+
+
+@dataclass
+class Config:
+    log: LogConfig = field(default_factory=LogConfig)
+    node: NodeConfig = field(default_factory=NodeConfig)
+    mqtt: MqttConfig = field(default_factory=MqttConfig)
+    homeassistant: HomeAssistantConfig = field(default_factory=HomeAssistantConfig)
+    docker: DockerConfig = field(default_factory=DockerConfig)
+    scan_interval: int = 60 * 60 * 3
+
+
+@dataclass
+class DockerPackageUpdateInfo:
+    image_name: str = MISSING
+
+
+@dataclass
+class PackageUpdateInfo:
+    docker: DockerPackageUpdateInfo | None = field(default_factory=DockerPackageUpdateInfo)
+    logo_url: str | None = None
+    release_notes_url: str | None = None
+
+
+@dataclass
+class UpdateInfoConfig:
+    common_packages: dict[str, PackageUpdateInfo] = field(default_factory=lambda: {})
+
+
+def load_package_info(pkginfo_file_path: Path) -> UpdateInfoConfig:
+    if pkginfo_file_path.exists():
+        log.debug("Loading common package update info", path=pkginfo_file_path)
+        cfg = OmegaConf.load(pkginfo_file_path)
+    else:
+        log.warn("No common package update info found", path=pkginfo_file_path)
+        cfg = OmegaConf.structured(UpdateInfoConfig)
+    OmegaConf.set_readonly(cfg, True)
+    return typing.cast("UpdateInfoConfig", cfg)
+
+
+def load_app_config(conf_file_path: Path) -> Config | None:
+    initializing: bool = False
+    base_cfg = OmegaConf.structured(Config)
+    if conf_file_path.exists():
+        cfg = OmegaConf.merge(base_cfg, OmegaConf.load(conf_file_path))
+    else:
+        initializing = True
+        try:
+            log.debug("Creating config directory if not already present", path=conf_file_path)
+            conf_file_path.parent.mkdir(parents=True, exist_ok=True)
+        except Exception:
+            log.exception("Unable to create config directory", path=conf_file_path.parent)
+        try:
+            conf_file_path.write_text(OmegaConf.to_yaml(base_cfg))
+        except Exception:
+            log.exception("Unable to write config file", path=conf_file_path)
+        cfg = base_cfg
+
+    try:
+        # Validate that all required fields are present, throw exception now rather than when config first used
+        OmegaConf.to_container(cfg, throw_on_missing=not initializing)
+        OmegaConf.set_readonly(cfg, True)
+        return typing.cast("Config", cfg)
+    except (MissingMandatoryValue, ValidationError) as e:
+        log.error("Configuration error: %s", e, path=conf_file_path)
+        return None

updates2mqtt/hass_formatter.py

@@ -0,0 +1,75 @@
+from typing import Any
+
+import structlog
+
+import updates2mqtt
+from updates2mqtt.model import Discovery
+
+log = structlog.get_logger()
+HASS_UPDATE_SCHEMA = [
+    "installed_version",
+    "latest_version",
+    "title",
+    "release_summary",
+    "release_url",
+    "entity_picture",
+    "in_progress",
+    "update_percentage",
+]
+
+
+def hass_format_config(
+    discovery: Discovery, object_id: str, node_name: str, state_topic: str, command_topic: str | None, session: str
+) -> dict[str, Any]:
+    config = {
+        "name": f"{discovery.name} {discovery.source_type} on {node_name}",
+        "device_class": None,  # not firmware, so defaults to null
+        "unique_id": object_id,
+        "state_topic": state_topic,
+        "source_session": session,
+        "supported_features": discovery.features,
+        "entity_picture": discovery.entity_picture_url,
+        "icon": discovery.device_icon,
+        "can_update": discovery.can_update,
+        "can_build": discovery.can_build,
+        "can_restart": discovery.can_restart,
+        "update_policy": discovery.update_policy,
+        "latest_version_topic": state_topic,
+        "latest_version_template": "{{value_json.latest_version}}",
+        "origin": {
+            "name": "updates2mqtt",
+            "sw_version": updates2mqtt.version,
+            "support_url": "https://github.com/rhizomatics/updates2mqtt/issues",
+        },
+    }
+    if command_topic:
+        config["command_topic"] = command_topic
+        config["payload_install"] = f"{discovery.source_type}|{discovery.name}|install"
+    if discovery.custom.get("git_repo_path"):
+        config["git_repo_path"] = discovery.custom["git_repo_path"]
+    config.update(discovery.provider.hass_config_format(discovery))
+    return config
+
+
+def hass_format_state(discovery: Discovery, node_name: str, session: str, in_progress: bool = False) -> dict[str, Any]:  # noqa: ARG001
+    title: str = (
+        discovery.title_template.format(name=discovery.name, node=node_name) if discovery.title_template else discovery.name
+    )
+    state = {
+        "installed_version": discovery.current_version,
+        "latest_version": discovery.latest_version,
+        "title": title,
+        "in_progress": in_progress,
+    }
+    if discovery.release_summary:
+        state["release_summary"] = discovery.release_summary
+    if discovery.release_url:
+        state["release_url"] = discovery.release_url
+    custom_state = discovery.provider.hass_state_format(discovery)
+    if custom_state:
+        state.update(custom_state)
+    invalid_keys = [k for k in state if k not in HASS_UPDATE_SCHEMA]
+    if invalid_keys:
+        log.warning(f"Invalid keys in state: {invalid_keys}")
+        state = {k: v for k, v in state.items() if k in HASS_UPDATE_SCHEMA}
+    return state

updates2mqtt/integrations/__init__.py

@@ -0,0 +1 @@
+"""System integrations to detect component version availability and optionally execute update and restart"""