updates2mqtt 1.4.2__py3-none-any.whl → 1.5.1__py3-none-any.whl

updates2mqtt/app.py

@@ -14,7 +14,7 @@ import structlog
 import updates2mqtt
 from updates2mqtt.model import Discovery, ReleaseProvider
 
-from .config import Config, load_app_config, load_package_info
+from .config import Config, PackageUpdateInfo, load_app_config, load_package_info
 from .integrations.docker import DockerProvider
 from .mqtt import MqttPublisher
 
@@ -44,9 +44,9 @@ class App:
             sys.exit(1)
         self.cfg: Config = app_config
 
-        structlog.configure(wrapper_class=structlog.make_filtering_bound_logger(getattr(logging, self.cfg.log.level)))
+        structlog.configure(wrapper_class=structlog.make_filtering_bound_logger(getattr(logging, str(self.cfg.log.level))))
         log.debug("Logging initialized", level=self.cfg.log.level)
-        self.common_pkg = load_package_info(PKG_INFO_FILE)
+        self.common_pkg: dict[str, PackageUpdateInfo] = load_package_info(PKG_INFO_FILE)
 
         self.publisher = MqttPublisher(self.cfg.mqtt, self.cfg.node, self.cfg.homeassistant)
 
@@ -62,25 +62,29 @@ class App:
             "App configured",
             node=self.cfg.node.name,
             scan_interval=self.cfg.scan_interval,
+            healthcheck_topic=self.healthcheck_topic,
         )
 
     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)
+            slog = log.bind(source_type=scanner.source_type, session=session)
+            slog.info("Cleaning topics before scan")
             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)
+            slog.info("Scanning ...")
             async with asyncio.TaskGroup() as tg:
-                async for discovery in scanner.scan(session):  # xtype: ignore[attr-defined]
+                # xtype: ignore[attr-defined]
+                async for discovery in scanner.scan(session):
                     tg.create_task(self.on_discovery(discovery), name=f"discovery-{discovery.name}")
             if self.stopped.is_set():
+                slog.debug("Breaking scan loop on stopped event")
                 break
             await self.publisher.clean_topics(scanner, session, force=False)
             self.scan_count += 1
-            log.info("Scan complete", source_type=scanner.source_type)
+            slog.info(f"Scan #{self.scan_count} complete")
         self.last_scan_timestamp = datetime.now(UTC).isoformat()
 
     async def main_loop(self) -> None:
@@ -170,13 +174,15 @@ class App:
     async def healthcheck(self) -> None:
         if not self.publisher.is_available():
             return
+        heartbeat_stamp: str = datetime.now(UTC).isoformat()
+        log.debug("Publishing health check", heartbeat_stamp=heartbeat_stamp)
         self.publisher.publish(
             topic=self.healthcheck_topic,
             payload={
                 "version": updates2mqtt.version,  # pyright: ignore[reportAttributeAccessIssue]
                 "node": self.cfg.node.name,
                 "heartbeat_raw": time.time(),
-                "heartbeat_stamp": datetime.now(UTC).isoformat(),
+                "heartbeat_stamp": heartbeat_stamp,
                 "startup_stamp": self.startup_timestamp,
                 "last_scan_stamp": self.last_scan_timestamp,
                 "scan_count": self.scan_count,
@@ -191,7 +197,7 @@ async def repeated_call(func: Callable, interval: int = 60, *args: Any, **kwargs
             await func(*args, **kwargs)
             await asyncio.sleep(interval)
         except asyncio.CancelledError:
-            log.debug("Periodic task cancelled")
+            log.debug("Periodic task cancelled", func=func)
         except Exception:
             log.exception("Periodic task failed")
 
@@ -202,6 +208,7 @@ def run() -> None:
 
     from .app import App
 
+    # pyright: ignore[reportAttributeAccessIssue]
     log.debug(f"Starting updates2mqtt v{updates2mqtt.version}")  # pyright: ignore[reportAttributeAccessIssue]
     app = App()
 

updates2mqtt/config.py

@@ -1,6 +1,7 @@
 import os
 import typing
 from dataclasses import dataclass, field
+from enum import StrEnum
 from pathlib import Path
 
 import structlog
@@ -9,6 +10,14 @@ from omegaconf import MISSING, DictConfig, MissingMandatoryValue, OmegaConf, Val
 log = structlog.get_logger()
 
 
+class LogLevel(StrEnum):
+    DEBUG = "DEBUG"
+    INFO = "INFO"
+    WARNING = "WARNING"
+    ERROR = "ERROR"
+    CRITICAL = "CRITICAL"
+
+
 @dataclass
 class MqttConfig:
     host: str = "${oc.env:MQTT_HOST,localhost}"
@@ -16,7 +25,7 @@ class MqttConfig:
     password: str = f"${{oc.env:MQTT_PASS,{MISSING}}}"
     port: int = "${oc.decode:${oc.env:MQTT_PORT,1883}}"  # type: ignore[assignment]
     topic_root: str = "updates2mqtt"
-    protocol: str = "3.11"
+    protocol: str = "${oc.env:MQTT_VERSION,3.11}"
 
 
 @dataclass
@@ -33,7 +42,8 @@ class DockerConfig:
     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
+    # Icon to show when browsing entities in Home Assistant
+    device_icon: str = "mdi:docker"
     discover_metadata: dict[str, MetadataSourceConfig] = field(
         default_factory=lambda: {"linuxserver.io": MetadataSourceConfig(enabled=True)}
     )
@@ -50,6 +60,7 @@ class HomeAssistantConfig:
     discovery: HomeAssistantDiscoveryConfig = field(default_factory=HomeAssistantDiscoveryConfig)
     state_topic_suffix: str = "state"
     device_creation: bool = True
+    force_command_topic: bool = False
     area: str | None = None
 
 
@@ -69,14 +80,14 @@ class NodeConfig:
 
 @dataclass
 class LogConfig:
-    level: str = "INFO"
+    level: LogLevel = "${oc.decode:${oc.env:U2M_LOG_LEVEL,INFO}}"  # type: ignore[assignment] # pyright: ignore[reportAssignmentType]
 
 
 @dataclass
 class Config:
-    log: LogConfig = field(default_factory=LogConfig)
+    log: LogConfig = field(default_factory=LogConfig)  # pyright: ignore[reportArgumentType, reportCallIssue]
     node: NodeConfig = field(default_factory=NodeConfig)
-    mqtt: MqttConfig = field(default_factory=MqttConfig)  # pyright: ignore[reportCallIssue, reportArgumentType]
+    mqtt: MqttConfig = field(default_factory=MqttConfig)  # pyright: ignore[reportArgumentType, reportCallIssue]
     homeassistant: HomeAssistantConfig = field(default_factory=HomeAssistantConfig)
     docker: DockerConfig = field(default_factory=DockerConfig)
     scan_interval: int = 60 * 60 * 3
@@ -103,33 +114,47 @@ class IncompleteConfigException(BaseException):
     pass
 
 
-def load_package_info(pkginfo_file_path: Path) -> UpdateInfoConfig:
+def load_package_info(pkginfo_file_path: Path) -> dict[str, PackageUpdateInfo]:
     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)
+    try:
+        # omegaconf broken-ness on optional fields and converting to backclasses
+        pkg_conf: dict[str, PackageUpdateInfo] = {
+            pkg: PackageUpdateInfo(**pkg_cfg) for pkg, pkg_cfg in cfg.common_packages.items()
+        }
+        return pkg_conf
+    except (MissingMandatoryValue, ValidationError) as e:
+        log.error("Configuration error %s", e, path=pkginfo_file_path.as_posix())
+        raise
+
+
+def is_autogen_config() -> bool:
+    env_var: str | None = os.environ.get("U2M_AUTOGEN_CONFIG")
+    return not (env_var and env_var.lower() in ("no", "0", "false"))
 
 
 def load_app_config(conf_file_path: Path, return_invalid: bool = False) -> Config | None:
     base_cfg: DictConfig = OmegaConf.structured(Config)
     if conf_file_path.exists():
         cfg: DictConfig = typing.cast("DictConfig", OmegaConf.merge(base_cfg, OmegaConf.load(conf_file_path)))
-    else:
+    elif is_autogen_config():
         if not conf_file_path.parent.exists():
             try:
                 log.debug(f"Creating config directory {conf_file_path.parent} if not already present")
                 conf_file_path.parent.mkdir(parents=True, exist_ok=True)
             except Exception:
-                log.exception("Unable to create config directory", path=conf_file_path.parent)
+                log.warning("Unable to create config directory", path=conf_file_path.parent)
         try:
             conf_file_path.write_text(OmegaConf.to_yaml(base_cfg))
             log.info(f"Auto-generated a new config file at {conf_file_path}")
         except Exception:
-            log.exception("Unable to write config file", path=conf_file_path)
+            log.warning("Unable to write config file", path=conf_file_path)
+        cfg = base_cfg
+    else:
         cfg = base_cfg
 
     try:

updates2mqtt/hass_formatter.py

@@ -21,60 +21,58 @@ HASS_UPDATE_SCHEMA = [
 def hass_format_config(
     discovery: Discovery,
     object_id: str,
-    node_name: str,
     state_topic: str,
     command_topic: str | None,
+    force_command_topic: bool | None,
     device_creation: bool = True,
     area: str | None = None,
     session: str | None = None,
 ) -> dict[str, Any]:
     config: dict[str, Any] = {
-        "name": f"{discovery.name} {discovery.source_type} on {node_name}",
+        "name": discovery.title,
         "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": f"{node_name} updates2mqtt Agent",
+            "name": f"{discovery.node} updates2mqtt",
             "sw_version": updates2mqtt.version,  # pyright: ignore[reportAttributeAccessIssue]
             "support_url": "https://github.com/rhizomatics/updates2mqtt/issues",
         },
     }
+    if discovery.entity_picture_url:
+        config["entity_picture"] = discovery.entity_picture_url
+    if discovery.device_icon:
+        config["icon"] = discovery.device_icon
     if device_creation:
         config["device"] = {
-            "name": f"{node_name} updates2mqtt Agent",
+            "name": f"{discovery.node} updates2mqtt",
             "sw_version": updates2mqtt.version,  # pyright: ignore[reportAttributeAccessIssue]
             "manufacturer": "rhizomatics",
-            "identifiers": [f"{node_name}.updates2mqtt"],
+            "identifiers": [f"{discovery.node}.updates2mqtt"],
         }
         if area:
             config["device"]["suggested_area"] = area
-    if command_topic:
+    if command_topic and (discovery.can_update or force_command_topic):
         config["command_topic"] = command_topic
-        config["payload_install"] = f"{discovery.source_type}|{discovery.name}|install"
+        if discovery.can_update:
+            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
-    )
+def hass_format_state(discovery: Discovery, session: str, in_progress: bool = False) -> dict[str, Any]:  # noqa: ARG001
     state = {
         "installed_version": discovery.current_version,
         "latest_version": discovery.latest_version,
-        "title": title,
+        "title": discovery.title,
         "in_progress": in_progress,
     }
     if discovery.release_summary:

updates2mqtt/integrations/docker.py

@@ -13,7 +13,7 @@ import structlog
 from docker.models.containers import Container
 from hishel.httpx import SyncCacheClient
 
-from updates2mqtt.config import DockerConfig, DockerPackageUpdateInfo, NodeConfig, PackageUpdateInfo, UpdateInfoConfig
+from updates2mqtt.config import DockerConfig, DockerPackageUpdateInfo, NodeConfig, PackageUpdateInfo
 from updates2mqtt.model import Discovery, ReleaseProvider
 
 from .git_utils import git_check_update_available, git_pull, git_timestamp, git_trust
@@ -37,12 +37,12 @@ def safe_json_dt(t: float | None) -> str | None:
 
 
 class DockerProvider(ReleaseProvider):
-    def __init__(self, cfg: DockerConfig, common_pkg_cfg: UpdateInfoConfig, node_cfg: NodeConfig) -> None:
+    def __init__(self, cfg: DockerConfig, common_pkg_cfg: dict[str, PackageUpdateInfo], node_cfg: NodeConfig) -> None:
         super().__init__("docker")
         self.client: docker.DockerClient = docker.from_env()
         self.cfg: DockerConfig = cfg
         self.node_cfg: NodeConfig = node_cfg
-        self.common_pkgs: dict[str, PackageUpdateInfo] = common_pkg_cfg.common_packages if common_pkg_cfg else {}
+        self.common_pkgs: dict[str, PackageUpdateInfo] = common_pkg_cfg if common_pkg_cfg else {}
         # TODO: refresh discovered packages periodically
         self.discovered_pkgs: dict[str, PackageUpdateInfo] = self.discover_metadata()
 
@@ -87,22 +87,36 @@ class DockerProvider(ReleaseProvider):
     def build(self, discovery: Discovery, compose_path: str) -> bool:
         logger = self.log.bind(container=discovery.name, action="build")
         logger.info("Building")
-        return self.execute_compose(DockerComposeCommand.BUILD, "", compose_path, logger)
+        return self.execute_compose(
+            command=DockerComposeCommand.BUILD,
+            args="",
+            service=discovery.custom.get("compose_service"),
+            cwd=compose_path,
+            logger=logger,
+        )
 
-    def execute_compose(self, command: DockerComposeCommand, args: str, cwd: str | None, logger: structlog.BoundLogger) -> bool:
+    def execute_compose(
+        self, command: DockerComposeCommand, args: str, service: str | None, cwd: str | None, logger: structlog.BoundLogger
+    ) -> bool:
         if not cwd or not Path(cwd).is_dir():
             logger.warn("Invalid compose path, skipped %s", command)
             return False
-        logger.info(f"Executing compose {command} {args}")
+
         cmd: str = "docker-compose" if self.cfg.compose_version == "v1" else "docker compose"
+        logger.info(f"Executing {cmd} {command} {args} {service}")
         cmd = cmd + " " + command.value
         if args:
             cmd = cmd + " " + args
+        if service:
+            cmd = cmd + " " + service
 
-        proc = subprocess.run(cmd, check=False, shell=True, cwd=cwd)
+        proc: subprocess.CompletedProcess[str] = subprocess.run(cmd, check=False, shell=True, cwd=cwd, text=True)
         if proc.returncode == 0:
             logger.info(f"{command} via compose successful")
             return True
+        if proc.stderr and "unknown command: docker compose" in proc.stderr:
+            logger.warning("docker compose set to wrong version, seems like v1 installed")
+            self.cfg.compose_version = "v1"
         logger.warn(
             f"{command} failed: %s",
             proc.returncode,
@@ -112,7 +126,10 @@ class DockerProvider(ReleaseProvider):
     def restart(self, discovery: Discovery) -> bool:
         logger = self.log.bind(container=discovery.name, action="restart")
         compose_path = discovery.custom.get("compose_path")
-        return self.execute_compose(DockerComposeCommand.UP, "--detach --yes", compose_path, logger)
+        compose_service: str | None = discovery.custom.get("compose_service")
+        return self.execute_compose(
+            command=DockerComposeCommand.UP, args="--detach --yes", service=compose_service, cwd=compose_path, logger=logger
+        )
 
     def rescan(self, discovery: Discovery) -> Discovery | None:
         logger = self.log.bind(container=discovery.name, action="rescan")
@@ -172,7 +189,7 @@ class DockerProvider(ReleaseProvider):
                     logger.warn("RepoDigests=%s", image.attrs.get("RepoDigests"))
 
         platform: str = "Unknown"
-        pkg_info: PackageUpdateInfo = self.default_metadata(image_name)
+        pkg_info: PackageUpdateInfo = self.default_metadata(image_name, image_ref=image_ref)
 
         try:
             picture_url = env_override("UPD2MQTT_PICTURE", pkg_info.logo_url)
@@ -197,6 +214,7 @@ class DockerProvider(ReleaseProvider):
                 retries_left = 3
                 while reg_data is None and retries_left > 0 and not self.stopped.is_set():
                     try:
+                        logger.debug("Fetching registry data", image_ref=image_ref)
                         reg_data = self.client.images.get_registry_data(image_ref)
                         latest_version = reg_data.short_id[7:] if reg_data else None
                     except docker.errors.APIError as e:
@@ -221,6 +239,7 @@ class DockerProvider(ReleaseProvider):
             custom["image_ref"] = image_ref
             save_if_set("compose_path", c.labels.get("com.docker.compose.project.working_dir"))
             save_if_set("compose_version", c.labels.get("com.docker.compose.version"))
+            save_if_set("compose_service", c.labels.get("com.docker.compose.service"))
             save_if_set("git_repo_path", c_env.get("UPD2MQTT_GIT_REPO_PATH"))
             save_if_set("apt_pkgs", c_env.get("UPD2MQTT_APT_PKGS"))
 
@@ -260,21 +279,29 @@ class DockerProvider(ReleaseProvider):
                 logger.info(f"Update not available, can_pull:{can_pull}, can_build:{can_build},can_restart{can_restart}")
             if relnotes_url:
                 features.append("RELEASE_NOTES")
+            if can_pull:
+                update_type: str = "Docker Image"
+            elif can_build:
+                update_type = "Docker Build"
+            else:
+                update_type = "Unavailable"
             custom["can_pull"] = can_pull
 
+            logger.debug("Analyze generated discovery", discovery_name=c.name, current_version=local_version)
             return Discovery(
                 self,
                 c.name,
                 session,
+                node=self.node_cfg.name,
                 entity_picture_url=picture_url,
                 release_url=relnotes_url,
                 current_version=local_version,
                 update_policy=update_policy,
                 update_last_attempt=(original_discovery and original_discovery.update_last_attempt) or None,
                 latest_version=latest_version if latest_version != NO_KNOWN_IMAGE else local_version,
-                title_template="Docker image update for {name} on {node}",
                 device_icon=self.cfg.device_icon,
                 can_update=can_update,
+                update_type=update_type,
                 can_build=can_build,
                 can_restart=can_restart,
                 status=(c.status == "running" and "on") or "off",
@@ -283,21 +310,27 @@ class DockerProvider(ReleaseProvider):
             )
         except Exception:
             logger.exception("Docker Discovery Failure", container_attrs=c.attrs)
+        logger.debug("Analyze returned empty discovery")
         return None
 
     async def scan(self, session: str) -> AsyncGenerator[Discovery]:
-        logger = self.log.bind(session=session, action="scan")
+        logger = self.log.bind(session=session, action="scan", source=self.source_type)
         containers = results = 0
+        logger.debug("Starting container scan loop")
         for c in self.client.containers.list():
+            logger.debug("Analyzing container", container=c.name)
             if self.stopped.is_set():
                 logger.info(f"Shutdown detected, aborting scan at {c}")
                 break
             containers = containers + 1
-            result = self.analyze(c, session)
+            result: Discovery | None = self.analyze(c, session)
             if result:
+                logger.debug("Analyzed container", result_name=result.name, custom=result.custom)
                 self.discoveries[result.name] = result
                 results = results + 1
                 yield result
+            else:
+                logger.debug("No result from analysis", container=c.name)
         logger.info("Completed", container_count=containers, result_count=results)
 
     def command(self, discovery_name: str, command: str, on_update_start: Callable, on_update_end: Callable) -> bool:
@@ -348,27 +381,40 @@ class DockerProvider(ReleaseProvider):
             # "platform": discovery.custom.get("platform"),
         }
 
-    def default_metadata(self, image_name: str | None) -> PackageUpdateInfo:
-        relnotes_url: str | None = None
-        picture_url: str | None = self.cfg.default_entity_picture_url
+    def default_metadata(self, image_name: str | None, image_ref: str | None) -> PackageUpdateInfo:
+        def match(pkg: PackageUpdateInfo) -> bool:
+            if pkg is not None and pkg.docker is not None and pkg.docker.image_name is not None:
+                if image_name is not None and image_name == pkg.docker.image_name:
+                    return True
+                if image_ref is not None and image_ref == pkg.docker.image_name:
+                    return True
+            return False
 
-        if image_name is not None:
+        if image_name is not None and image_ref is not None:
             for pkg in self.common_pkgs.values():
-                if pkg.docker is not None and pkg.docker.image_name is not None and pkg.docker.image_name == image_name:
+                if match(pkg):
                     self.log.debug(
-                        "Found common package", pkg=pkg.docker.image_name, logo_url=picture_url, relnotes_url=relnotes_url
+                        "Found common package",
+                        image_name=pkg.docker.image_name,  # type: ignore [union-attr]
+                        logo_url=pkg.logo_url,
+                        relnotes_url=pkg.release_notes_url,
                     )
                     return pkg
             for pkg in self.discovered_pkgs.values():
-                if pkg.docker is not None and pkg.docker.image_name is not None and pkg.docker.image_name == image_name:
+                if match(pkg):
                     self.log.debug(
-                        "Found discovered package", pkg=pkg.docker.image_name, logo_url=picture_url, relnotes_url=relnotes_url
+                        "Found discovered package",
+                        pkg=pkg.docker.image_name,  # type: ignore [union-attr]
+                        logo_url=pkg.logo_url,
+                        relnotes_url=pkg.release_notes_url,
                     )
                     return pkg
 
         self.log.debug("No common or discovered package found", image_name=image_name)
         return PackageUpdateInfo(
-            DockerPackageUpdateInfo(image_name or NO_KNOWN_IMAGE), logo_url=picture_url, release_notes_url=relnotes_url
+            DockerPackageUpdateInfo(image_name or NO_KNOWN_IMAGE),
+            logo_url=self.cfg.default_entity_picture_url,
+            release_notes_url=None,
         )
 
     def discover_metadata(self) -> dict[str, PackageUpdateInfo]:

updates2mqtt/model.py

@@ -14,6 +14,7 @@ class Discovery:
         provider: "ReleaseProvider",
         name: str,
         session: str,
+        node: str,
         entity_picture_url: str | None = None,
         current_version: str | None = None,
         latest_version: str | None = None,
@@ -21,11 +22,12 @@ class Discovery:
         can_build: bool = False,
         can_restart: bool = False,
         status: str = "on",
+        update_type: str | None = "Update",
         update_policy: str | None = None,
         update_last_attempt: float | None = None,
         release_url: str | None = None,
         release_summary: str | None = None,
-        title_template: str = "Update for {name} on {node}",
+        title_template: str = "{discovery.update_type} for {discovery.name} on {discovery.node}",
         device_icon: str | None = None,
         custom: dict[str, Any] | None = None,
         features: list[str] | None = None,
@@ -34,6 +36,7 @@ class Discovery:
         self.source_type: str = provider.source_type
         self.session: str = session
         self.name: str = name
+        self.node: str = node
         self.entity_picture_url: str | None = entity_picture_url
         self.current_version: str | None = current_version
         self.latest_version: str | None = latest_version
@@ -44,6 +47,7 @@ class Discovery:
         self.release_summary: str | None = release_summary
         self.title_template: str | None = title_template
         self.device_icon: str | None = device_icon
+        self.update_type: str | None = update_type
         self.status: str = status
         self.update_policy: str | None = update_policy
         self.update_last_attempt: float | None = update_last_attempt
@@ -54,6 +58,12 @@ class Discovery:
         """Build a custom string representation"""
         return f"Discovery('{self.name}','{self.source_type}',current={self.current_version},latest={self.latest_version})"
 
+    @property
+    def title(self) -> str:
+        if self.title_template:
+            return self.title_template.format(discovery=self)
+        return self.name
+
 
 class ReleaseProvider:
     """Abstract base class for release providers, such as container scanners or package managers API calls"""

updates2mqtt/mqtt.py

@@ -50,9 +50,9 @@ class MqttPublisher:
             elif self.cfg.protocol in ("5", "5.0"):
                 protocol = MQTTProtocolVersion.MQTTv5
             else:
-                self.log.info("No valid MQTT protocol version found (%s), setting to default v3.11", self.cfg.protocol)
+                logger.info("No valid MQTT protocol version found (%s), setting to default v3.11", self.cfg.protocol)
                 protocol = MQTTProtocolVersion.MQTTv311
-            self.log.debug("MQTT protocol set to %r", protocol)
+            logger.debug("MQTT protocol set to %r", protocol)
 
             self.event_loop = event_loop or asyncio.get_event_loop()
             self.client = mqtt.Client(
@@ -68,7 +68,7 @@ class MqttPublisher:
                 keepalive=60,
                 clean_start=MQTT_CLEAN_START_FIRST_ONLY,
             )
-            self.log.info("Client connection requested", result_code=rc)
+            logger.info("Client connection requested", result_code=rc)
 
             self.client.on_connect = self.on_connect
             self.client.on_disconnect = self.on_disconnect
@@ -78,7 +78,7 @@ class MqttPublisher:
 
             self.client.loop_start()
 
-            logger.info("Connected to broker", host=self.cfg.host, port=self.cfg.port)
+            logger.debug("MQTT Publisher loop started", host=self.cfg.host, port=self.cfg.port)
         except Exception as e:
             logger.error("Failed to connect to broker", host=self.cfg.host, port=self.cfg.port, error=str(e))
             raise OSError(f"Connection Failure to {self.cfg.host}:{self.cfg.port} as {self.cfg.user} -- {e}") from e
@@ -101,11 +101,14 @@ class MqttPublisher:
         if rc.getName() == "Not authorized":
             self.fatal_failure.set()
             log.error("Invalid MQTT credentials", result_code=rc)
-
-        self.log.info("Connected to broker", result_code=rc)
-        for topic, provider in self.providers_by_topic.items():
-            self.log.info("(Re)subscribing", topic=topic, provider=provider.source_type)
-            self.client.subscribe(topic)
+            return
+        if rc != 0:
+            self.log.warning("Connection failed to broker", result_code=rc)
+        else:
+            self.log.debug("Connected to broker", result_code=rc)
+            for topic, provider in self.providers_by_topic.items():
+                self.log.debug("(Re)subscribing", topic=topic, provider=provider.source_type)
+                self.client.subscribe(topic)
 
     def on_disconnect(
         self,
@@ -115,7 +118,10 @@ class MqttPublisher:
         rc: ReasonCode,
         _props: Properties | None,
     ) -> None:
-        self.log.info("Disconnected from broker", result_code=rc)
+        if rc == 0:
+            self.log.debug("Disconnected from broker", result_code=rc)
+        else:
+            self.log.warning("Disconnect failure from broker", result_code=rc)
 
     async def clean_topics(
         self, provider: ReleaseProvider, last_scan_session: str | None, wait_time: int = 5, force: bool = False
@@ -229,7 +235,7 @@ class MqttPublisher:
                 updated = provider.command(comp_name, command, on_update_start, on_update_end)
                 discovery = provider.resolve(comp_name)
                 if updated and discovery:
-                    self.publish_hass_state(discovery, updated)
+                    self.publish_hass_state(discovery)
                 else:
                     logger.debug("No change to republish after execution")
             logger.info("Execution ended")
@@ -303,7 +309,6 @@ class MqttPublisher:
             self.state_topic(discovery),
             hass_format_state(
                 discovery,
-                self.node_cfg.name,
                 discovery.session,
                 in_progress=in_progress,
             ),
@@ -311,16 +316,15 @@ class MqttPublisher:
 
     def publish_hass_config(self, discovery: Discovery) -> None:
         object_id = f"{discovery.source_type}_{self.node_cfg.name}_{discovery.name}"
-        command_topic: str | None = self.command_topic(discovery.provider) if discovery.can_update else None
         self.publish(
             self.config_topic(discovery),
             hass_format_config(
                 discovery=discovery,
                 object_id=object_id,
-                node_name=self.node_cfg.name,
                 area=self.hass_cfg.area,
                 state_topic=self.state_topic(discovery),
-                command_topic=command_topic,
+                command_topic=self.command_topic(discovery.provider),
+                force_command_topic=self.hass_cfg.force_command_topic,
                 device_creation=self.hass_cfg.device_creation,
                 session=discovery.session,
             ),

{updates2mqtt-1.4.2.dist-info → updates2mqtt-1.5.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: updates2mqtt
-Version: 1.4.2
+Version: 1.5.1
 Summary: System update and docker image notification and execution over MQTT
 Project-URL: Homepage, https://updates2mqtt.rhizomatics.org.uk
 Project-URL: Repository, https://github.com/rhizomatics/updates2mqtt
@@ -35,7 +35,7 @@ Requires-Dist: structlog>=25.4.0
 Requires-Dist: usingversion>=0.1.2
 Description-Content-Type: text/markdown
 
-![updates2mqtt](/images/updates2mqtt-dark-256x256.png){ align=left }
+![updates2mqtt](images/updates2mqtt-dark-256x256.png){ align=left }
 
 # updates2mqtt
 
@@ -91,15 +91,17 @@ Presently only Docker containers are supported, although others are planned, pro
 |-----------|-------------|----------------------------------------------------------------------------------------------------|
 | Docker    | Scan. Fetch | Fetch is ``docker pull`` only. Restart support only for ``docker-compose`` image based containers. |
   
-## Healthcheck
+## Heartbeat
 
 A heartbeat JSON payload is optionally published periodically to a configurable MQTT topic, defaulting to `healthcheck/{node_name}/updates2mqtt`. It contains the current version of updates2mqtt, the node name, a timestamp, and some basic stats.
 
+## Healthcheck
+
 A `healthcheck.sh` script is included in the Docker image, and can be used as a Docker healthcheck, if the container environment variables are set for `MQTT_HOST`, `MQTT_PORT`, `MQTT_USER` and `MQTT_PASS`. It uses the `mosquitto-clients` Linux package which provides `mosquitto_sub` command to subscribe to topics.
 
 !!! tip
 
-    Check healthcheck is working using `docker inspect --format "{{json .State.Health }}" updates2mqtt | jq`
+    Check healthcheck is working using `docker inspect --format "{{json .State.Health }}" updates2mqtt | jq` (can omit `| jq` if you don't have jsonquery installed, but much easier to read with it)
 
 Another approach is using a restarter service directly in Docker Compose to force a restart, in this case once a day:
 

updates2mqtt-1.5.1.dist-info/RECORD

@@ -0,0 +1,16 @@
+updates2mqtt/__init__.py,sha256=gnmHrLOSYc-N1-c5VG46OpNpoXEybKzYhEvFMm955P8,237
+updates2mqtt/__main__.py,sha256=HBF00oH5fhS33sI_CdbxNlaUvbIzuuGxwnRYdhHqx0M,194
+updates2mqtt/app.py,sha256=pYcNprv7_htqD6wiXX5j24FhPglEeFNdqMfPclq5SfU,8887
+updates2mqtt/config.py,sha256=nlAszykZa7t9nu99RB8g_tIzQxmdfWyilTZJY3Fl4e4,6099
+updates2mqtt/hass_formatter.py,sha256=bj6qpElMqt1DqKlxp4ZjwaCJAD-ed3xsq5ZOg4FbeC8,3216
+updates2mqtt/model.py,sha256=KNsLflgWaRvGrNdq1Vy2QnDLfVSLPWLSt4gBXj9COa4,4170
+updates2mqtt/mqtt.py,sha256=j7nlSka-LqRethZk_rc4Z8iOV7ey28TQFjSfrPeTjv4,14995
+updates2mqtt/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+updates2mqtt/integrations/__init__.py,sha256=KmNTUxvVWvqI7rl4I0xZg7XaCmcMS2O4OSv-ClsWM4Q,109
+updates2mqtt/integrations/docker.py,sha256=Mi3tFjVDbCIsHBgH6UQ3yC5Y7HQk9JgEyH6PQuNJtFU,21263
+updates2mqtt/integrations/git_utils.py,sha256=bPCmQiZpKpMcrGI7xAVmePXHFn8WwjcPNkf7xqDsGQA,2319
+updates2mqtt-1.5.1.dist-info/METADATA,sha256=iPMKAgEFTFZ98pouv3SnTTStP74SEPBuV8jN3QbBpX8,9392
+updates2mqtt-1.5.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+updates2mqtt-1.5.1.dist-info/entry_points.txt,sha256=Hc6NZ2dBevYSUKTJU6NOs8Mw7Vt0S-9lq5FuKb76NCc,54
+updates2mqtt-1.5.1.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+updates2mqtt-1.5.1.dist-info/RECORD,,

updates2mqtt-1.4.2.dist-info/RECORD

@@ -1,16 +0,0 @@
-updates2mqtt/__init__.py,sha256=gnmHrLOSYc-N1-c5VG46OpNpoXEybKzYhEvFMm955P8,237
-updates2mqtt/__main__.py,sha256=HBF00oH5fhS33sI_CdbxNlaUvbIzuuGxwnRYdhHqx0M,194
-updates2mqtt/app.py,sha256=-jAe9HcSSRmq5SZCvlsb8bFq2yVBNZQ0alQ5iRjl3tY,8518
-updates2mqtt/config.py,sha256=G7_5L7Ypc7dl35nnd5dP2AobSA08ZuyEM_ETCTPg_co,5144
-updates2mqtt/hass_formatter.py,sha256=GrVtxqpaXNFaQWXjmOFhOxYwXVjeNjzUwAjFdJdsrwI,3337
-updates2mqtt/model.py,sha256=O6GQFhfQvwQDxlZScFHrpQgFNkUrUAeaGGP6AqNua78,3827
-updates2mqtt/mqtt.py,sha256=I8g-SekY-AIVRcSCZyb7fTGji5a8zT1PJ7d34l7LGyY,14832
-updates2mqtt/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-updates2mqtt/integrations/__init__.py,sha256=KmNTUxvVWvqI7rl4I0xZg7XaCmcMS2O4OSv-ClsWM4Q,109
-updates2mqtt/integrations/docker.py,sha256=Yb0XsrRyNZYAkw_ayd2iYLPFwgeA51Lz9HBVAGq3rs4,19273
-updates2mqtt/integrations/git_utils.py,sha256=bPCmQiZpKpMcrGI7xAVmePXHFn8WwjcPNkf7xqDsGQA,2319
-updates2mqtt-1.4.2.dist-info/METADATA,sha256=1wqWYIbcNbC-SQxk2FiI_SPmw9F-RFwdoOE_vviSXzw,9290
-updates2mqtt-1.4.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-updates2mqtt-1.4.2.dist-info/entry_points.txt,sha256=Hc6NZ2dBevYSUKTJU6NOs8Mw7Vt0S-9lq5FuKb76NCc,54
-updates2mqtt-1.4.2.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-updates2mqtt-1.4.2.dist-info/RECORD,,