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

updates2mqtt/integrations/docker_enrich.py

@@ -0,0 +1,344 @@
+import re
+from typing import Any
+
+import structlog
+from docker.auth import resolve_repository_name
+from hishel.httpx import SyncCacheClient
+from httpx import Response
+from omegaconf import MissingMandatoryValue, OmegaConf, ValidationError
+
+from updates2mqtt.config import (
+    NO_KNOWN_IMAGE,
+    PKG_INFO_FILE,
+    DockerConfig,
+    DockerPackageUpdateInfo,
+    PackageUpdateInfo,
+    UpdateInfoConfig,
+)
+
+log = structlog.get_logger()
+
+
+class PackageEnricher:
+    def __init__(self, docker_cfg: DockerConfig) -> None:
+        self.pkgs: dict[str, PackageUpdateInfo] = {}
+        self.cfg: DockerConfig = docker_cfg
+        self.log: Any = structlog.get_logger().bind(integration="docker")
+
+    def initialize(self) -> None:
+        pass
+
+    def enrich(self, image_name: str | None, image_ref: str | None, log: Any) -> PackageUpdateInfo | None:
+        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.pkgs.values():
+                if match(pkg):
+                    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
+        return None
+
+
+class DefaultPackageEnricher(PackageEnricher):
+    def enrich(self, image_name: str | None, image_ref: str | None, log: Any) -> PackageUpdateInfo | None:
+        log.debug("Default pkg info", image_name=image_name, image_ref=image_ref)
+        return PackageUpdateInfo(
+            DockerPackageUpdateInfo(image_name or NO_KNOWN_IMAGE),
+            logo_url=self.cfg.default_entity_picture_url,
+            release_notes_url=None,
+        )
+
+
+class CommonPackageEnricher(PackageEnricher):
+    def initialize(self) -> None:
+        if PKG_INFO_FILE.exists():
+            log.debug("Loading common package update info", path=PKG_INFO_FILE)
+            cfg = OmegaConf.load(PKG_INFO_FILE)
+        else:
+            log.warn("No common package update info found", path=PKG_INFO_FILE)
+            cfg = OmegaConf.structured(UpdateInfoConfig)
+        try:
+            # omegaconf broken-ness on optional fields and converting to backclasses
+            self.pkgs: dict[str, PackageUpdateInfo] = {
+                pkg: PackageUpdateInfo(**pkg_cfg) for pkg, pkg_cfg in cfg.common_packages.items()
+            }
+        except (MissingMandatoryValue, ValidationError) as e:
+            log.error("Configuration error %s", e, path=PKG_INFO_FILE.as_posix())
+            raise
+
+
+class LinuxServerIOPackageEnricher(PackageEnricher):
+    def initialize(self) -> None:
+        cfg = self.cfg.discover_metadata.get("linuxserver.io")
+        if cfg is None or not cfg.enabled:
+            return
+
+        try:
+            with SyncCacheClient(headers=[("cache-control", f"max-age={cfg.cache_ttl}")]) as client:
+                log.debug(f"Fetching linuxserver.io metadata from API, cache_ttl={cfg.cache_ttl}")
+                response: Response = client.get(
+                    "https://api.linuxserver.io/api/v1/images?include_config=false&include_deprecated=false"
+                )
+                if response.status_code != 200:
+                    log.error("Failed to fetch linuxserver.io metadata, non-200 response", status_code=response.status_code)
+                    return
+                api_data: Any = response.json()
+                repos: list = api_data.get("data", {}).get("repositories", {}).get("linuxserver", [])
+        except Exception:
+            log.exception("Failed to fetch linuxserver.io metadata")
+            return
+
+        added = 0
+        for repo in repos:
+            image_name = repo.get("name")
+            if image_name and image_name not in self.pkgs:
+                self.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")
+
+
+def fetch_url(
+    url: str, cache_ttl: int = 300, bearer_token: str | None = None, response_type: str | None = None
+) -> Response | None:
+    try:
+        headers = [("cache-control", f"max-age={cache_ttl}")]
+        if bearer_token:
+            headers.append(("Authorization", f"Bearer {bearer_token}"))
+        if response_type:
+            headers.append(("Accept", response_type))
+        with SyncCacheClient(headers=headers) as client:
+            log.debug(f"Fetching URL {url}, cache_ttl={cache_ttl}")
+            response: Response = client.get(url)
+            if not response.is_success:
+                log.debug("URL %s fetch returned non-success status: %s", url, response.status_code)
+            return response
+    except Exception as e:
+        log.debug("URL %s failed to fetch: %s", url, e)
+    return None
+
+
+def validate_url(url: str, cache_ttl: int = 300) -> bool:
+    response: Response | None = fetch_url(url, cache_ttl=cache_ttl)
+    return response is not None and response.is_success
+
+
+SOURCE_PLATFORM_GITHUB = "GitHub"
+SOURCE_PLATFORMS = {SOURCE_PLATFORM_GITHUB: r"https://github.com/.*"}
+DIFF_URL_TEMPLATES = {
+    SOURCE_PLATFORM_GITHUB: "{source}/commit/{revision}",
+}
+RELEASE_URL_TEMPLATES = {SOURCE_PLATFORM_GITHUB: "{source}/releases/tag/{version}"}
+
+
+class SourceReleaseEnricher:
+    def __init__(self) -> None:
+        self.log: Any = structlog.get_logger().bind(integration="docker")
+
+    def enrich(self, annotations: dict[str, str]) -> dict[str, str]:
+        results: dict[str, str] = {}
+        image_version: str | None = annotations.get("org.opencontainers.image.version")
+        image_digest: str | None = annotations.get("org.opencontainers.image.revision")
+        source = annotations.get("org.opencontainers.image.source")
+        source_platforms = [platform for platform, pattern in SOURCE_PLATFORMS.items() if re.match(pattern, source or "")]
+        if not source_platforms:
+            self.log.debug("No known source platform found on container", source=source)
+            return results
+        source_platform = source_platforms[0]
+
+        if source:
+            template_vars: dict[str, str | None] = {
+                "source": source,
+                "version": image_version,
+                "revision": image_digest,
+            }
+            diff_url = DIFF_URL_TEMPLATES[source_platform].format(**template_vars)
+            if validate_url(diff_url):
+                results["diff_url"] = diff_url
+
+            release_url = RELEASE_URL_TEMPLATES[source_platform].format(**template_vars)
+
+            if validate_url(release_url):
+                results["release_url"] = release_url
+
+        if source_platform == SOURCE_PLATFORM_GITHUB and source:
+            base_api = source.replace("https://github.com", "https://api.github.com/repos")
+            api_response: Response | None = fetch_url(f"{base_api}/releases/tags/{image_version}")
+            if api_response and api_response.is_success:
+                api_results: Any = httpx_json_content(api_response, {})
+                results["release_summary"] = api_results.get("body")  # ty:ignore[possibly-missing-attribute]
+                reactions = api_results.get("reactions")  # ty:ignore[possibly-missing-attribute]
+                if reactions:
+                    results["net_score"] = reactions.get("+1", 0) - reactions.get("-1", 0)
+            else:
+                self.log.debug(
+                    "Failed to fetch GitHub release info",
+                    url=f"{base_api}/releases/tags/{image_version}",
+                    status_code=(api_response and api_response.status_code) or None,
+                )
+        return results
+
+
+class AuthError(Exception):
+    pass
+
+
+REGISTRIES = {
+    # registry: (auth_host, api_host, service)
+    "docker.io": ("auth.docker.io", "registry-1.docker.io", "registry.docker.io"),
+    "mcr.microsoft.com": (None, "mcr.microsoft.com", "mcr.microsoft.com"),
+    "ghcr.io": ("ghcr.io", "ghcr.io", "ghcr.io"),
+    "lscr.io": ("ghcr.io", "lscr.io", "ghcr.io"),
+    "codeberg.org": ("codeberg.org", "codeberg.org", "container_registry"),
+}
+
+
+def httpx_json_content(response: Response, default: Any = None) -> Any | None:
+    if response and "json" in response.headers.get("content-type"):
+        try:
+            return response.json()
+        except Exception:
+            log.debug("Failed to parse JSON response: %s", response.text)
+    return default
+
+
+class LabelEnricher:
+    def __init__(self) -> None:
+        self.log: Any = structlog.get_logger().bind(integration="docker")
+
+    def fetch_token(self, auth_host: str, service: str, image_name: str) -> str | None:
+        logger = self.log.bind(image_name=image_name, action="auth_registry")
+        auth_url: str = f"https://{auth_host}/token?scope=repository:{image_name}:pull&service={service}"
+        response: Response | None = fetch_url(auth_url, cache_ttl=30)
+        if response and response.is_success:
+            api_data = httpx_json_content(response, {})
+            token: str | None = api_data.get("token") if api_data else None
+            if token:
+                return token
+            logger.warning("No token found in response")
+            raise AuthError(f"No token found in response for {image_name}")
+
+        logger.debug(
+            "Non-success response fetching token: %s",
+            (response and response.status_code) or None,
+        )
+        if response and response.status_code == 404:
+            response = fetch_url(f"https://{auth_host}/v2/")
+        if response and response.status_code == 401:
+            auth = response.headers.get("www-authenticate")
+            if not auth:
+                logger.debug("No www-authenticate header found in 401 response")
+                raise AuthError(f"No www-authenticate header found on 401 for {image_name}")
+            match = re.search(r'realm="([^"]+)",service="([^"]+)",scope="([^"]+)"', auth)
+            if not match:
+                logger.debug("No realm/service/scope found in www-authenticate header")
+                raise AuthError(f"No realm/service/scope found on 401 headers for {image_name}")
+
+            realm, service, scope = match.groups()
+            auth_url = f"{realm}?service={service}&scope={scope}"
+            response = fetch_url(auth_url)
+            if response and response.is_success:
+                token_data = response.json()
+                logger.debug("Fetched registry token")
+                return token_data.get("token")
+
+        logger.debug("Failed to fetch registry token")
+        raise AuthError(f"Failed to fetch token for {image_name}")
+
+    def fetch_annotations(
+        self,
+        image_ref: str,
+        os: str,
+        arch: str,
+        token: str | None = None,
+        mutable_cache_ttl: int = 600,
+        immutable_cache_ttl: int = 86400,
+    ) -> dict[str, str]:
+        logger = self.log.bind(image_ref=image_ref, action="enrich_registry")
+        annotations: dict[str, str] = {}
+        if token:
+            logger.debug("Using provided token to fetch manifest for image %s", image_ref)
+        registry, ref = resolve_repository_name(image_ref)
+        default_host = (registry, registry, registry)
+        auth_host: str | None = REGISTRIES.get(registry, default_host)[0]
+        api_host: str | None = REGISTRIES.get(registry, default_host)[1]
+        service: str = REGISTRIES.get(registry, default_host)[2]
+        img_name = ref.split(":")[0] if ":" in ref else ref
+        img_name = img_name if "/" in img_name else f"library/{img_name}"
+        if auth_host is not None and token is None:
+            token = self.fetch_token(auth_host, service, img_name)
+
+        img_tag = ref.split(":")[1] if ":" in ref else "latest"
+        img_tag = img_tag.split("@")[0] if "@" in img_tag else img_tag
+        response: Response | None = fetch_url(
+            f"https://{api_host}/v2/{img_name}/manifests/{img_tag}",
+            cache_ttl=mutable_cache_ttl,
+            bearer_token=token,
+            response_type="application/vnd.oci.image.index.v1+json",
+        )
+        if response is None:
+            logger.debug("Empty response for manifest for image")
+            return annotations
+        if not response.is_success:
+            api_data = httpx_json_content(response, {})
+            logger.warning(
+                "Failed to fetch manifest: %s",
+                api_data.get("errors") if api_data else response.text,
+            )
+            return annotations
+        index = response.json()
+        logger.debug(
+            "INDEX %s manifests, %s annotations",
+            len(index.get("manifests", [])),
+            len(index.get("annotations", [])),
+        )
+        annotations = index.get("annotations", {})
+        for m in index.get("manifests", []):
+            platform_info = m.get("platform", {})
+            if platform_info.get("os") == os and platform_info.get("architecture") == arch:
+                digest = m.get("digest")
+                media_type = m.get("mediaType")
+                response = fetch_url(
+                    f"https://{api_host}/v2/{img_name}/manifests/{digest}",
+                    cache_ttl=immutable_cache_ttl,
+                    bearer_token=token,
+                    response_type=media_type,
+                )
+                if response and response.is_success:
+                    api_data = httpx_json_content(response, None)
+                    if api_data:
+                        logger.debug(
+                            "MANIFEST %s layers, %s annotations",
+                            len(api_data.get("layers", [])),
+                            len(api_data.get("annotations", [])),
+                        )
+                        if api_data.get("annotations"):
+                            annotations.update(api_data.get("annotations", {}))
+                        else:
+                            logger.debug("No annotations found in manifest: %s", api_data)
+
+        if not annotations:
+            logger.debug("No annotations found from registry data")
+        return annotations
+
+
+r"""
+https://ghcr.io/token\?scope\="repository:rhizomatics/updates2mqtt:pull"
+https://ghcr.io/v2/rhizomatics/updates2mqtt/manifests/sha256:2c8edc1f9400ef02a93c3b754d4419082ceb5d049178c3a3968e3fd56caf7f29 Accept:application/vnd.oci.image.index.v1+json Accept:application/vnd.oci.image.manifest.v1+json Accept:application/vnd.docker.distribution.manifest.v2+json
+https://ghcr.io/v2/rhizomatics/updates2mqtt/manifests/latest Accept:application/vnd.oci.image.index.v1+json Accept:application/vnd.oci.image.manifest.v1+json Accept:appli
+"""  # noqa: E501

updates2mqtt/model.py

@@ -1,10 +1,33 @@
+import datetime as dt
 import json
+import re
+import time
 from abc import abstractmethod
 from collections.abc import AsyncGenerator, Callable
+from enum import StrEnum
 from threading import Event
 from typing import Any
 
 import structlog
+from tzlocal import get_localzone
+
+from updates2mqtt.config import NO_KNOWN_IMAGE, NodeConfig, PublishPolicy, Selector, UpdatePolicy
+
+
+def timestamp(time_value: float | None) -> str | None:
+    if time_value is None:
+        return None
+    try:
+        return dt.datetime.fromtimestamp(time_value, tz=get_localzone()).isoformat()
+    except:  # noqa: E722
+        return None
+
+
+class VersionPolicy(StrEnum):
+    AUTO = "AUTO"
+    VERSION = "VERSION"
+    DIGEST = "DIGEST"
+    VERSION_DIGEST = "VERSION_DIGEST"
 
 
 class Discovery:
@@ -23,9 +46,10 @@ class Discovery:
         can_build: bool = False,
         can_restart: bool = False,
         status: str = "on",
+        publish_policy: PublishPolicy = PublishPolicy.HOMEASSISTANT,
         update_type: str | None = "Update",
-        update_policy: str | None = None,
-        update_last_attempt: float | None = None,
+        update_policy: UpdatePolicy = UpdatePolicy.PASSIVE,
+        version_policy: VersionPolicy = VersionPolicy.AUTO,
         release_url: str | None = None,
         release_summary: str | None = None,
         title_template: str = "{discovery.update_type} for {discovery.name} on {discovery.node}",
@@ -33,6 +57,7 @@ class Discovery:
         custom: dict[str, Any] | None = None,
         features: list[str] | None = None,
         throttled: bool = False,
+        previous: "Discovery|None" = None,
     ) -> None:
         self.provider: ReleaseProvider = provider
         self.source_type: str = provider.source_type
@@ -51,11 +76,24 @@ class Discovery:
         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
+        self.publish_policy: PublishPolicy = publish_policy
+        self.update_policy: UpdatePolicy = update_policy
+        self.version_policy: VersionPolicy = version_policy
+        self.update_last_attempt: float | None = None
         self.custom: dict[str, Any] = custom or {}
         self.features: list[str] = features or []
         self.throttled: bool = throttled
+        self.scan_count: int
+        self.first_timestamp: float
+        self.last_timestamp: float = time.time()
+
+        if previous:
+            self.update_last_attempt = previous.update_last_attempt
+            self.first_timestamp = previous.first_timestamp
+            self.scan_count = previous.scan_count + 1
+        else:
+            self.first_timestamp = time.time()
+            self.scan_count = 1
 
     def __repr__(self) -> str:
         """Build a custom string representation"""
@@ -76,16 +114,49 @@ class Discovery:
             return self.title_template.format(discovery=self)
         return self.name
 
+    def as_dict(self) -> dict[str, str | list | dict | bool | int | None]:
+        return {
+            "name": self.name,
+            "node": self.node,
+            "provider": {"source_type": self.provider.source_type},
+            "first_scan": {"timestamp": timestamp(self.first_timestamp)},
+            "last_scan": {"timestamp": timestamp(self.last_timestamp), "session": self.session, "throttled": self.throttled},
+            "scan_count": self.scan_count,
+            "installed_version": self.current_version,
+            "latest_version": self.latest_version,
+            "title": self.title,
+            "release_summary": self.release_summary,
+            "release_url": self.release_url,
+            "entity_picture_url": self.entity_picture_url,
+            "can_update": self.can_update,
+            "can_build": self.can_build,
+            "can_restart": self.can_restart,
+            "device_icon": self.device_icon,
+            "update_type": self.update_type,
+            "status": self.status,
+            "features": self.features,
+            "update_policy": self.update_policy,
+            "publish_policy": self.publish_policy,
+            "version_policy": self.version_policy,
+            "update": {"last_attempt": timestamp(self.update_last_attempt), "in_progress": False},
+            self.source_type: self.custom,
+        }
+
 
 class ReleaseProvider:
     """Abstract base class for release providers, such as container scanners or package managers API calls"""
 
-    def __init__(self, source_type: str = "base") -> None:
+    def __init__(self, node_cfg: NodeConfig, source_type: str = "base") -> None:
         self.source_type: str = source_type
         self.discoveries: dict[str, Discovery] = {}
+        self.node_cfg: NodeConfig = node_cfg
         self.log: Any = structlog.get_logger().bind(integration=self.source_type)
         self.stopped = Event()
 
+    def initialize(self) -> None:
+        """Initialize any loops or background tasks, make any startup API calls"""
+        pass
+
     def stop(self) -> None:
         """Stop any loops or background tasks"""
         self.log.info("Asking release provider to stop", source_type=self.source_type)
@@ -106,18 +177,9 @@ class ReleaseProvider:
     @abstractmethod
     async def scan(self, session: str) -> AsyncGenerator[Discovery]:
         """Scan for components to monitor"""
-        raise NotImplementedError
         # force recognition as an async generator
-        if False:  # type: ignore[unreachable]
-            yield 0
-
-    def hass_config_format(self, discovery: Discovery) -> dict:
-        _ = discovery
-        return {}
-
-    def hass_state_format(self, discovery: Discovery) -> dict:
-        _ = discovery
-        return {}
+        if False:
+            yield 0  # type: ignore[unreachable]
 
     @abstractmethod
     def command(self, discovery_name: str, command: str, on_update_start: Callable, on_update_end: Callable) -> bool:
@@ -126,3 +188,59 @@ class ReleaseProvider:
     @abstractmethod
     def resolve(self, discovery_name: str) -> Discovery | None:
         """Resolve a discovered component by name"""
+
+
+class Selection:
+    def __init__(self, selector: Selector, value: str | None) -> None:
+        self.result: bool = True
+        self.matched: str | None = None
+        if value is None:
+            self.result = selector.include is None
+            return
+        if selector.exclude is not None:
+            self.result = True
+            if any(re.search(pat, value) for pat in selector.exclude):
+                self.matched = value
+                self.result = False
+        if selector.include is not None:
+            self.result = False
+            if any(re.search(pat, value) for pat in selector.include):
+                self.matched = value
+                self.result = True
+
+
+VERSION_RE = r"[vV]?[0-9]+(\.[0-9]+)*"
+
+
+def select_version(
+    version_policy: VersionPolicy,
+    version: str | None,
+    digest: str | None,
+    other_version: str | None = None,
+    other_digest: str | None = None,
+) -> str:
+    if version_policy == VersionPolicy.VERSION and version:
+        return version
+    if version_policy == VersionPolicy.DIGEST and digest and digest != NO_KNOWN_IMAGE:
+        return digest
+    if version_policy == VersionPolicy.VERSION_DIGEST and version and digest and digest != NO_KNOWN_IMAGE:
+        return f"{version} ({digest})"
+    # AUTO or fallback
+    if version_policy == VersionPolicy.AUTO and version and re.match(VERSION_RE, version or ""):
+        # Smells like semver
+        if other_version is None and other_digest is None:
+            return version
+        if re.match(VERSION_RE, other_version or "") and (
+            (version == other_version and digest == other_digest) or (version != other_version and digest != other_digest)
+        ):
+            # Only semver if versions and digest consistently same or different
+            return version
+
+    if version and digest and digest != NO_KNOWN_IMAGE:
+        return f"{version}:{digest}"
+    if version:
+        return version
+    if digest and digest != NO_KNOWN_IMAGE:
+        return digest
+
+    return other_version or other_version or NO_KNOWN_IMAGE

updates2mqtt/mqtt.py

@@ -16,7 +16,7 @@ from paho.mqtt.reasoncodes import ReasonCode
 
 from updates2mqtt.model import Discovery, ReleaseProvider
 
-from .config import HomeAssistantConfig, MqttConfig, NodeConfig
+from .config import HomeAssistantConfig, MqttConfig, NodeConfig, PublishPolicy
 from .hass_formatter import hass_format_config, hass_format_state
 
 log = structlog.get_logger()
@@ -235,7 +235,10 @@ 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)
+                    if discovery.publish_policy in (PublishPolicy.HOMEASSISTANT, PublishPolicy.MQTT):
+                        self.publish_discovery(discovery)
+                    if discovery.publish_policy == PublishPolicy.HOMEASSISTANT:
+                        self.publish_hass_state(discovery)
                 else:
                     logger.debug("No change to republish after execution")
             logger.info("Execution ended")
@@ -283,10 +286,12 @@ class MqttPublisher:
 
     def handle_message(self, msg: mqtt.MQTTMessage | LocalMessage) -> None:
         def update_start(discovery: Discovery) -> None:
-            self.publish_hass_state(discovery, in_progress=True)
+            if discovery.publish_policy in (PublishPolicy.HOMEASSISTANT, PublishPolicy.MQTT):
+                self.publish_hass_state(discovery, in_progress=True)
 
         def update_end(discovery: Discovery) -> None:
-            self.publish_hass_state(discovery, in_progress=False)
+            if discovery.publish_policy in (PublishPolicy.HOMEASSISTANT, PublishPolicy.MQTT):
+                self.publish_hass_state(discovery, in_progress=False)
 
         if self.event_loop is not None:
             asyncio.run_coroutine_threadsafe(self.execute_command(msg, update_start, update_end), self.event_loop)
@@ -298,12 +303,26 @@ class MqttPublisher:
         return f"{prefix}/update/{self.node_cfg.name}_{discovery.source_type}_{discovery.name}/update/config"
 
     def state_topic(self, discovery: Discovery) -> str:
+        return f"{self.cfg.topic_root}/{self.node_cfg.name}/{discovery.source_type}/{discovery.name}/state"
+
+    def general_topic(self, discovery: Discovery) -> str:
         return f"{self.cfg.topic_root}/{self.node_cfg.name}/{discovery.source_type}/{discovery.name}"
 
     def command_topic(self, provider: ReleaseProvider) -> str:
         return f"{self.cfg.topic_root}/{self.node_cfg.name}/{provider.source_type}"
 
+    def publish_discovery(self, discovery: Discovery, in_progress: bool = False) -> None:
+        """Comprehensive, non Home Assistant specific, base publication"""
+        if discovery.publish_policy not in (PublishPolicy.HOMEASSISTANT, PublishPolicy.MQTT):
+            return
+        self.log.debug("Discovery publish: %s", discovery)
+        payload: dict[str, Any] = discovery.as_dict()
+        payload["update"]["in_progress"] = in_progress  # ty:ignore[invalid-assignment]
+        self.publish(self.general_topic(discovery), payload)
+
     def publish_hass_state(self, discovery: Discovery, in_progress: bool = False) -> None:
+        if discovery.publish_policy != PublishPolicy.HOMEASSISTANT:
+            return
         self.log.debug("HASS State update, in progress: %s, discovery: %s", in_progress, discovery)
         self.publish(
             self.state_topic(discovery),
@@ -315,6 +334,8 @@ class MqttPublisher:
         )
 
     def publish_hass_config(self, discovery: Discovery) -> None:
+        if discovery.publish_policy != PublishPolicy.HOMEASSISTANT:
+            return
         object_id = f"{discovery.source_type}_{self.node_cfg.name}_{discovery.name}"
         self.publish(
             self.config_topic(discovery),
@@ -323,10 +344,10 @@ class MqttPublisher:
                 object_id=object_id,
                 area=self.hass_cfg.area,
                 state_topic=self.state_topic(discovery),
+                attrs_topic=self.general_topic(discovery) if self.hass_cfg.extra_attributes else None,
                 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,
             ),
         )