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

updates2mqtt/integrations/docker.py

@@ -1,22 +1,39 @@
-import datetime
 import subprocess
 import time
 import typing
 from collections.abc import AsyncGenerator, Callable
 from enum import Enum
+from http import HTTPStatus
 from pathlib import Path
+from threading import Event
 from typing import Any, cast
 
 import docker
 import docker.errors
 import structlog
+from docker.auth import resolve_repository_name
 from docker.models.containers import Container
-from hishel.httpx import SyncCacheClient
 
-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
+from updates2mqtt.config import (
+    NO_KNOWN_IMAGE,
+    DockerConfig,
+    NodeConfig,
+    PackageUpdateInfo,
+    PublishPolicy,
+    UpdatePolicy,
+)
+from updates2mqtt.integrations.docker_enrich import (
+    AuthError,
+    CommonPackageEnricher,
+    DefaultPackageEnricher,
+    LabelEnricher,
+    LinuxServerIOPackageEnricher,
+    PackageEnricher,
+    SourceReleaseEnricher,
+)
+from updates2mqtt.model import Discovery, ReleaseProvider, Selection, VersionPolicy, select_version
+
+from .git_utils import git_check_update_available, git_iso_timestamp, git_local_version, git_pull, git_trust
 
 if typing.TYPE_CHECKING:
     from docker.models.images import Image, RegistryData
@@ -24,7 +41,6 @@ if typing.TYPE_CHECKING:
 # distinguish docker build from docker pull?
 
 log = structlog.get_logger()
-NO_KNOWN_IMAGE = "UNKNOWN"
 
 
 class DockerComposeCommand(Enum):
@@ -36,15 +52,94 @@ def safe_json_dt(t: float | None) -> str | None:
     return time.strftime("%Y-%m-%dT%H:%M:%S.0000", time.gmtime(t)) if t else None
 
 
+class ContainerCustomization:
+    """Local customization of a Docker container, by label or env var"""
+
+    label_prefix: str = "updates2mqtt."
+    env_prefix: str = "UPD2MQTT_"
+
+    def __init__(self, container: Container) -> None:
+        self.update: str = "PASSIVE"
+        self.git_repo_path: str | None = None
+        self.picture: str | None = None
+        self.relnotes: str | None = None
+        self.ignore: bool = False
+        self.version_policy: VersionPolicy | None = None
+        self.registry_token: str | None = None
+
+        if not container.attrs or container.attrs.get("Config") is None:
+            return
+        env_pairs: list[str] = container.attrs.get("Config", {}).get("Env")
+        if env_pairs:
+            c_env: dict[str, str] = dict(env.split("=", maxsplit=1) for env in env_pairs if "==" not in env)
+        else:
+            c_env = {}
+
+        for attr in dir(self):
+            if "__" not in attr:
+                label = f"{self.label_prefix}{attr.lower()}"
+                env_var = f"{self.env_prefix}{attr.upper()}"
+                v: Any = None
+                if label in container.labels:
+                    # precedence to labels
+                    v = container.labels.get(label)
+                    log.debug(
+                        "%s set from label %s=%s",
+                        attr,
+                        label,
+                        v,
+                        integration="docker",
+                        container=container.name,
+                        action="customize",
+                    )
+                elif env_var in c_env:
+                    v = c_env[env_var]
+                    log.debug(
+                        "%s set from env var %s=%s",
+                        attr,
+                        env_var,
+                        v,
+                        integration="docker",
+                        container=container.name,
+                        action="customize",
+                    )
+                if v is not None:
+                    if isinstance(getattr(self, attr), bool):
+                        setattr(self, attr, v.upper() in ("TRUE", "YES", "1"))
+                    elif isinstance(getattr(self, attr), VersionPolicy):
+                        setattr(self, attr, VersionPolicy[v.upper()])
+                    else:
+                        setattr(self, attr, v)
+
+        self.update = self.update.upper()
+
+
 class DockerProvider(ReleaseProvider):
-    def __init__(self, cfg: DockerConfig, common_pkg_cfg: dict[str, PackageUpdateInfo], node_cfg: NodeConfig) -> None:
-        super().__init__("docker")
+    def __init__(
+        self,
+        cfg: DockerConfig,
+        node_cfg: NodeConfig,
+        self_bounce: Event | None = None,
+    ) -> None:
+        super().__init__(node_cfg, "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 if common_pkg_cfg else {}
+
         # TODO: refresh discovered packages periodically
-        self.discovered_pkgs: dict[str, PackageUpdateInfo] = self.discover_metadata()
+        self.pause_api_until: dict[str, float] = {}
+        self.api_throttle_pause: int = cfg.default_api_backoff
+        self.self_bounce: Event | None = self_bounce
+        self.pkg_enrichers: list[PackageEnricher] = [
+            CommonPackageEnricher(self.cfg),
+            LinuxServerIOPackageEnricher(self.cfg),
+            DefaultPackageEnricher(self.cfg),
+        ]
+        self.label_enricher = LabelEnricher()
+        self.release_enricher = SourceReleaseEnricher()
+
+    def initialize(self) -> None:
+        for enricher in self.pkg_enrichers:
+            enricher.initialize()
 
     def update(self, discovery: Discovery) -> bool:
         logger: Any = self.log.bind(container=discovery.name, action="update")
@@ -70,23 +165,30 @@ class DockerProvider(ReleaseProvider):
         elif discovery.can_build:
             compose_path: str | None = discovery.custom.get("compose_path")
             git_repo_path: str | None = discovery.custom.get("git_repo_path")
+            logger.debug("can_build check", git_repo=git_repo_path)
             if not compose_path or not git_repo_path:
                 logger.warn("No compose path or git repo path configured, skipped build")
                 return
-            if compose_path and not Path(git_repo_path).is_absolute():
-                full_repo_path: Path = Path(compose_path) / git_repo_path
-            else:
-                full_repo_path = Path(git_repo_path)
-            if git_check_update_available(full_repo_path, Path(self.node_cfg.git_path)):
-                git_pull(full_repo_path, Path(self.node_cfg.git_path))
-            if compose_path:
-                self.build(discovery, compose_path)
+
+            full_repo_path: Path = self.full_repo_path(compose_path, git_repo_path)
+            if git_pull(full_repo_path, Path(self.node_cfg.git_path)):
+                if compose_path:
+                    self.build(discovery, compose_path)
+                else:
+                    logger.warn("No compose path configured, skipped build")
             else:
-                logger.warn("No compose path configured, skipped build")
+                logger.debug("Skipping git_pull, no update")
+
+    def full_repo_path(self, compose_path: str, git_repo_path: str) -> Path:
+        if compose_path is None or git_repo_path is None:
+            raise ValueError("Unexpected null paths")
+        if compose_path and not Path(git_repo_path).is_absolute():
+            return Path(compose_path) / git_repo_path
+        return Path(git_repo_path)
 
     def build(self, discovery: Discovery, compose_path: str) -> bool:
         logger = self.log.bind(container=discovery.name, action="build")
-        logger.info("Building")
+        logger.info("Building", compose_path=compose_path)
         return self.execute_compose(
             command=DockerComposeCommand.BUILD,
             args="",
@@ -125,6 +227,12 @@ class DockerProvider(ReleaseProvider):
 
     def restart(self, discovery: Discovery) -> bool:
         logger = self.log.bind(container=discovery.name, action="restart")
+        if self.self_bounce is not None and (
+            "ghcr.io/rhizomatics/updates2mqtt" in discovery.custom.get("image_ref", "")
+            or discovery.custom.get("git_repo_path", "").endswith("updates2mqtt")
+        ):
+            logger.warning("Attempting to self-bounce")
+            self.self_bounce.set()
         compose_path = discovery.custom.get("compose_path")
         compose_service: str | None = discovery.custom.get("compose_service")
         return self.execute_compose(
@@ -136,7 +244,7 @@ class DockerProvider(ReleaseProvider):
         try:
             c: Container = self.client.containers.get(discovery.name)
             if c:
-                rediscovery = self.analyze(c, discovery.session, original_discovery=discovery)
+                rediscovery = self.analyze(c, discovery.session, previous_discovery=discovery)
                 if rediscovery:
                     self.discoveries[rediscovery.name] = rediscovery
                     return rediscovery
@@ -147,10 +255,21 @@ class DockerProvider(ReleaseProvider):
             logger.exception("Docker API error retrieving container")
         return None
 
-    def analyze(self, c: Container, session: str, original_discovery: Discovery | None = None) -> Discovery | None:
+    def check_throttle(self, repo_id: str) -> bool:
+        if self.pause_api_until.get(repo_id) is not None:
+            if self.pause_api_until[repo_id] < time.time():
+                del self.pause_api_until[repo_id]
+                self.log.info("%s throttling wait complete", repo_id)
+            else:
+                self.log.debug("%s throttling has %s secs left", repo_id, self.pause_api_until[repo_id] - time.time())
+                return True
+        return False
+
+    def analyze(self, c: Container, session: str, previous_discovery: Discovery | None = None) -> Discovery | None:
         logger = self.log.bind(container=c.name, action="analyze")
-        image_ref = None
-        image_name = None
+
+        image_ref: str | None = None
+        image_name: str | None = None
         local_versions = None
         if c.attrs is None or not c.attrs:
             logger.warn("No container attributes found, discovery rejected")
@@ -159,17 +278,13 @@ class DockerProvider(ReleaseProvider):
             logger.warn("No container name found, discovery rejected")
             return None
 
-        def env_override(env_var: str, default: Any) -> Any | None:
-            return default if c_env.get(env_var) is None else c_env.get(env_var)
-
-        env_str = c.attrs.get("Config", {}).get("Env")
-        c_env = dict(env.split("=", maxsplit=1) for env in env_str if "==" not in env)
-        ignore_container: str | None = env_override("UPD2MQTT_IGNORE", "FALSE")
-        if ignore_container and ignore_container.upper() in ("1", "TRUE"):
+        customization: ContainerCustomization = ContainerCustomization(c)
+        if customization.ignore:
             logger.info("Container ignored due to UPD2MQTT_IGNORE setting")
             return None
 
         image: Image | None = c.image
+        repo_id: str = "DEFAULT"
         if image is not None and image.tags and len(image.tags) > 0:
             image_ref = image.tags[0]
         else:
@@ -177,6 +292,7 @@ class DockerProvider(ReleaseProvider):
         if image_ref is None:
             logger.warn("No image or image attributes found")
         else:
+            repo_id, _ = resolve_repository_name(image_ref)
             try:
                 image_name = image_ref.split(":")[0]
             except Exception as e:
@@ -188,12 +304,24 @@ class DockerProvider(ReleaseProvider):
                     logger.warn("Cannot determine local version: %s", e)
                     logger.warn("RepoDigests=%s", image.attrs.get("RepoDigests"))
 
+        selection = Selection(self.cfg.image_ref_select, image_ref)
+        publish_policy: PublishPolicy = PublishPolicy.MQTT if not selection.result else PublishPolicy.HOMEASSISTANT
+        version_policy: VersionPolicy = VersionPolicy.AUTO if not customization.version_policy else customization.version_policy
+
+        if customization.update == "AUTO":
+            logger.debug("Auto update policy detected")
+            update_policy: UpdatePolicy = UpdatePolicy.AUTO
+        else:
+            update_policy = UpdatePolicy.PASSIVE
+
         platform: str = "Unknown"
         pkg_info: PackageUpdateInfo = self.default_metadata(image_name, image_ref=image_ref)
 
         try:
-            picture_url = env_override("UPD2MQTT_PICTURE", pkg_info.logo_url)
-            relnotes_url = env_override("UPD2MQTT_RELNOTES", pkg_info.release_notes_url)
+            picture_url: str | None = customization.picture or pkg_info.logo_url
+            relnotes_url: str | None = customization.relnotes or pkg_info.release_notes_url
+            release_summary: str | None = None
+
             if image is not None and image.attrs is not None:
                 platform = "/".join(
                     filter(
@@ -207,47 +335,103 @@ class DockerProvider(ReleaseProvider):
                 )
 
             reg_data: RegistryData | None = None
-            latest_version: str | None = NO_KNOWN_IMAGE
-            local_version: str | None = NO_KNOWN_IMAGE
+            latest_digest: str | None = NO_KNOWN_IMAGE
+            latest_version: str | None = None
+
+            registry_throttled: bool = self.check_throttle(repo_id)
 
-            if image_ref and local_versions:
+            if image_ref and local_versions and not registry_throttled:
                 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
+                        logger.debug(
+                            "Registry Data: id:%s,image:%s, attrs:%s",
+                            reg_data.id,
+                            reg_data.image_name,
+                            reg_data.attrs,
+                        )
+                        latest_digest = reg_data.short_id[7:] if reg_data else None
+
                     except docker.errors.APIError as e:
+                        if e.status_code == HTTPStatus.TOO_MANY_REQUESTS:
+                            retry_secs: int
+                            try:
+                                retry_secs = int(e.response.headers.get("Retry-After", self.api_throttle_pause))  # type: ignore[union-attr]
+                            except:  # noqa: E722
+                                retry_secs = self.api_throttle_pause
+                            logger.warn("Docker Registry throttling requests for %s seconds, %s", retry_secs, e.explanation)
+                            self.pause_api_until[repo_id] = time.time() + retries_left
+                            return None
                         retries_left -= 1
                         if retries_left == 0 or e.is_client_error():
                             logger.warn("Failed to fetch registry data: [%s] %s", e.errno, e.explanation)
                         else:
                             logger.debug("Failed to fetch registry data, retrying: %s", e)
 
+            installed_digest: str | None = NO_KNOWN_IMAGE
+            installed_version: str | None = None
             if local_versions:
                 # might be multiple RepoDigests if image has been pulled multiple times with diff manifests
-                local_version = latest_version if latest_version in local_versions else local_versions[0]
+                installed_digest = latest_digest if latest_digest in local_versions else local_versions[0]
+                logger.debug(f"Setting local digest to {installed_digest}, local_versions:{local_versions}")
 
-            def save_if_set(key: str, val: datetime.datetime | str | None) -> None:
+            def save_if_set(key: str, val: str | None) -> None:
                 if val is not None:
                     custom[key] = val
 
             image_ref = image_ref or ""
 
-            custom: dict[str, str | datetime.datetime | bool] = {}
+            custom: dict[str, str | bool | int | list[str] | dict[str, Any] | None] = {}
             custom["platform"] = platform
             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"))
-
-            if c_env.get("UPD2MQTT_UPDATE") == "AUTO":
-                logger.debug("Auto update policy detected")
-                update_policy = "Auto"
+            custom["installed_digest"] = installed_digest
+            custom["latest_digest"] = latest_digest
+            custom["repo_id"] = repo_id
+            custom["git_repo_path"] = customization.git_repo_path
+
+            if c.labels:
+                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("documentation_url", c.labels.get("org.opencontainers.image.documentation"))
+                save_if_set("description", c.labels.get("org.opencontainers.image.description"))
+                save_if_set("current_image_created", c.labels.get("org.opencontainers.image.created"))
+                save_if_set("current_image_version", c.labels.get("org.opencontainers.image.version"))
+                save_if_set("vendor", c.labels.get("org.opencontainers.image.vendor"))
+                installed_version = c.labels.get("org.opencontainers.image.version")
             else:
-                update_policy = "Passive"
+                logger.debug("No annotations found on local container")
+                # save_if_set("apt_pkgs", c_env.get("UPD2MQTT_APT_PKGS"))
+
+            if latest_digest is None or latest_digest == NO_KNOWN_IMAGE or registry_throttled:
+                logger.debug(
+                    "Skipping image manifest enrichment",
+                    latest_digest=latest_digest,
+                    image_ref=image_ref,
+                    platform=platform,
+                    throttled=registry_throttled,
+                )
+            else:
+                os, arch = platform.split("/")[:2] if "/" in platform else (platform, "Unknown")
+                try:
+                    annotations: dict[str, str] = self.label_enricher.fetch_annotations(
+                        image_ref, os, arch, token=customization.registry_token
+                    )
+                except AuthError as e:
+                    logger.warning("Authentication error prevented Docker Registry entichment: %s", e)
+                    annotations = {}
+
+                if annotations:
+                    save_if_set("latest_image_created", annotations.get("org.opencontainers.image.created"))
+                    save_if_set("source", annotations.get("org.opencontainers.image.source"))
+                    save_if_set("documentation_url", annotations.get("org.opencontainers.image.documentation"))
+                    save_if_set("description", annotations.get("org.opencontainers.image.description"))
+                    save_if_set("latest_image_version", annotations.get("org.opencontainers.image.version"))
+                    save_if_set("vendor", annotations.get("org.opencontainers.image.vendor"))
+                    latest_version = annotations.get("org.opencontainers.image.version")
+                    custom.update(self.release_enricher.enrich(annotations) or {})
 
             if custom.get("git_repo_path") and custom.get("compose_path"):
                 full_repo_path: Path = Path(cast("str", custom.get("compose_path"))).joinpath(
@@ -255,21 +439,46 @@ class DockerProvider(ReleaseProvider):
                 )
 
                 git_trust(full_repo_path, Path(self.node_cfg.git_path))
-                save_if_set("git_local_timestamp", git_timestamp(full_repo_path, Path(self.node_cfg.git_path)))
+                save_if_set("git_local_timestamp", git_iso_timestamp(full_repo_path, Path(self.node_cfg.git_path)))
             features: list[str] = []
             can_pull: bool = (
                 self.cfg.allow_pull
                 and image_ref is not None
                 and image_ref != ""
-                and (local_version != NO_KNOWN_IMAGE or latest_version != NO_KNOWN_IMAGE)
+                and (installed_digest != NO_KNOWN_IMAGE or latest_digest != NO_KNOWN_IMAGE)
             )
-            can_build: bool = self.cfg.allow_build and custom.get("git_repo_path") is not None
+            if self.cfg.allow_pull and not can_pull:
+                logger.debug(
+                    f"Pull unavailable, image_ref:{image_ref},installed_digest:{installed_digest},latest_digest:{latest_digest}"
+                )
+
+            can_build: bool = False
+            if self.cfg.allow_build:
+                can_build = custom.get("git_repo_path") is not None and custom.get("compose_path") is not None
+                if not can_build:
+                    if custom.get("git_repo_path") is not None:
+                        logger.debug(
+                            "Local build ignored for git_repo_path=%s because no compose_path", custom.get("git_repo_path")
+                        )
+                else:
+                    full_repo_path = self.full_repo_path(
+                        cast("str", custom.get("compose_path")), cast("str", custom.get("git_repo_path"))
+                    )
+                    if installed_digest is None or installed_digest == NO_KNOWN_IMAGE:
+                        installed_digest = git_local_version(full_repo_path, Path(self.node_cfg.git_path)) or NO_KNOWN_IMAGE
+
+                    behind_count: int = git_check_update_available(full_repo_path, Path(self.node_cfg.git_path))
+                    if behind_count > 0:
+                        if installed_digest is not None and installed_digest.startswith("git:"):
+                            latest_digest = f"{installed_digest}+{behind_count}"
+                            logger.info("Git update available, generating version %s", latest_digest)
+                    else:
+                        logger.debug(f"Git update not available, local repo:{full_repo_path}")
+
             can_restart: bool = self.cfg.allow_restart and custom.get("compose_path") is not None
+
             can_update: bool = False
-            if self.cfg.allow_pull and not can_pull and not can_build:
-                logger.info(
-                    f"Pull not available, image_ref:{image_ref},local_version:{local_version},latest_version:{latest_version}"
-                )
+
             if can_pull or can_build or can_restart:
                 # public install-neutral capabilities and Home Assistant features
                 can_update = True
@@ -280,25 +489,35 @@ class DockerProvider(ReleaseProvider):
             if relnotes_url:
                 features.append("RELEASE_NOTES")
             if can_pull:
-                update_type: str = "Docker Image"
+                update_type = "Docker Image"
             elif can_build:
                 update_type = "Docker Build"
             else:
                 update_type = "Unavailable"
             custom["can_pull"] = can_pull
+            # can_pull,can_build etc are only info flags
+            # the HASS update process is driven by comparing current and available versions
 
-            logger.debug("Analyze generated discovery", discovery_name=c.name, current_version=local_version)
-            return Discovery(
+            public_installed_version = select_version(
+                version_policy, installed_version, installed_digest, other_version=latest_version, other_digest=latest_digest
+            )
+            public_latest_version = select_version(
+                version_policy, latest_version, latest_digest, other_version=installed_version, other_digest=installed_digest
+            )
+
+            discovery: Discovery = Discovery(
                 self,
                 c.name,
                 session,
                 node=self.node_cfg.name,
                 entity_picture_url=picture_url,
                 release_url=relnotes_url,
-                current_version=local_version,
+                release_summary=release_summary,
+                current_version=public_installed_version,
+                publish_policy=publish_policy,
                 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,
+                version_policy=version_policy,
+                latest_version=public_latest_version,
                 device_icon=self.cfg.device_icon,
                 can_update=can_update,
                 update_type=update_type,
@@ -307,15 +526,25 @@ class DockerProvider(ReleaseProvider):
                 status=(c.status == "running" and "on") or "off",
                 custom=custom,
                 features=features,
+                throttled=registry_throttled,
+                previous=previous_discovery,
             )
+            logger.debug("Analyze generated discovery: %s", discovery)
+            return discovery
         except Exception:
             logger.exception("Docker Discovery Failure", container_attrs=c.attrs)
         logger.debug("Analyze returned empty discovery")
         return None
 
+    # def version(self, c: Container, version_type: str):
+    #    metadata_version: str = c.labels.get("org.opencontainers.image.version")
+    #    metadata_revision: str = c.labels.get("org.opencontainers.image.revision")
+
     async def scan(self, session: str) -> AsyncGenerator[Discovery]:
         logger = self.log.bind(session=session, action="scan", source=self.source_type)
-        containers = results = 0
+        containers: int = 0
+        results: int = 0
+        throttled: int = 0
         logger.debug("Starting container scan loop")
         for c in self.client.containers.list():
             logger.debug("Analyzing container", container=c.name)
@@ -328,14 +557,15 @@ class DockerProvider(ReleaseProvider):
                 logger.debug("Analyzed container", result_name=result.name, custom=result.custom)
                 self.discoveries[result.name] = result
                 results = results + 1
+                throttled += 1 if result.throttled else 0
                 yield result
             else:
                 logger.debug("No result from analysis", container=c.name)
-        logger.info("Completed", container_count=containers, result_count=results)
+        logger.info("Completed", container_count=containers, throttled_count=throttled, result_count=results)
 
     def command(self, discovery_name: str, command: str, on_update_start: Callable, on_update_end: Callable) -> bool:
         logger = self.log.bind(container=discovery_name, action="command", command=command)
-        logger.info("Executing")
+        logger.info("Executing Command")
         discovery: Discovery | None = None
         updated: bool = False
         try:
@@ -368,87 +598,9 @@ class DockerProvider(ReleaseProvider):
     def resolve(self, discovery_name: str) -> Discovery | None:
         return self.discoveries.get(discovery_name)
 
-    def hass_state_format(self, discovery: Discovery) -> dict:  # noqa: ARG002
-        # disable since hass mqtt update has strict json schema for message
-        return {
-            # "docker_image_ref": discovery.custom.get("image_ref"),
-            # "last_update_attempt": safe_json_dt(discovery.update_last_attempt),
-            # "can_pull": discovery.custom.get("can_pull"),
-            # "can_build": discovery.custom.get("can_build"),
-            # "can_restart": discovery.custom.get("can_restart"),
-            # "git_repo_path": discovery.custom.get("git_repo_path"),
-            # "compose_path": discovery.custom.get("compose_path"),
-            # "platform": discovery.custom.get("platform"),
-        }
-
     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 and image_ref is not None:
-            for pkg in self.common_pkgs.values():
-                if match(pkg):
-                    self.log.debug(
-                        "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 match(pkg):
-                    self.log.debug(
-                        "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=self.cfg.default_entity_picture_url,
-            release_notes_url=None,
-        )
-
-    def discover_metadata(self) -> dict[str, PackageUpdateInfo]:
-        pkgs: dict[str, PackageUpdateInfo] = {}
-        cfg = self.cfg.discover_metadata.get("linuxserver.io")
-        if cfg and cfg.enabled:
-            linuxserver_metadata(pkgs, cache_ttl=cfg.cache_ttl)
-        return pkgs
-
-
-def linuxserver_metadata_api(cache_ttl: int) -> dict:
-    """Fetch and cache linuxserver.io API call for image metadata"""
-    try:
-        with SyncCacheClient(headers=[("cache-control", f"max-age={cache_ttl}")]) as client:
-            log.debug(f"Fetching linuxserver.io metadata from API, cache_ttl={cache_ttl}")
-            req = client.get("https://api.linuxserver.io/api/v1/images?include_config=false&include_deprecated=false")
-            return req.json()
-    except Exception:
-        log.exception("Failed to fetch linuxserver.io metadata")
-        return {}
-
-
-def linuxserver_metadata(discovered_pkgs: dict[str, PackageUpdateInfo], cache_ttl: int) -> None:
-    """Fetch linuxserver.io metadata for all their images via their API"""
-    repos: list = linuxserver_metadata_api(cache_ttl).get("data", {}).get("repositories", {}).get("linuxserver", [])
-    added = 0
-    for repo in repos:
-        image_name = repo.get("name")
-        if image_name and image_name not in discovered_pkgs:
-            discovered_pkgs[image_name] = PackageUpdateInfo(
-                DockerPackageUpdateInfo(f"lscr.io/linuxserver/{image_name}"),
-                logo_url=repo["project_logo"],
-                release_notes_url=f"{repo['github_url']}/releases",
-            )
-            added += 1
-            log.debug("Added linuxserver.io package", pkg=image_name)
-    log.info(f"Added {added} linuxserver.io package details")
+        for enricher in self.pkg_enrichers:
+            pkg_info = enricher.enrich(image_name, image_ref, self.log)
+            if pkg_info is not None:
+                return pkg_info
+        raise ValueError("No enricher could provide metadata, not even default enricher")