Use aiohasupervisor for all calls from hassio/coordinator

Author: mdegat01

homeassistant/components/hassio/__init__.py

@@ -504,27 +504,33 @@ async def update_info_data(_: datetime | None = None) -> None:
 
         try:
             (
-                hass.data[DATA_INFO],
-                hass.data[DATA_HOST_INFO],
+                root_info,
+                host_info,
                 store_info,
-                hass.data[DATA_CORE_INFO],
-                hass.data[DATA_SUPERVISOR_INFO],
-                hass.data[DATA_OS_INFO],
-                hass.data[DATA_NETWORK_INFO],
+                homeassistant_info,
+                supervisor_info,
+                os_info,
+                network_info,
             ) = await asyncio.gather(
-                create_eager_task(hassio.get_info()),
-                create_eager_task(hassio.get_host_info()),
+                create_eager_task(supervisor_client.info()),
+                create_eager_task(supervisor_client.host.info()),
                 create_eager_task(supervisor_client.store.info()),
-                create_eager_task(hassio.get_core_info()),
-                create_eager_task(hassio.get_supervisor_info()),
-                create_eager_task(hassio.get_os_info()),
-                create_eager_task(hassio.get_network_info()),
+                create_eager_task(supervisor_client.homeassistant.info()),
+                create_eager_task(supervisor_client.supervisor.info()),
+                create_eager_task(supervisor_client.os.info()),
+                create_eager_task(supervisor_client.network.info()),
             )
 
-        except HassioAPIError as err:
+        except SupervisorError as err:
             _LOGGER.warning("Can't read Supervisor data: %s", err)
         else:
+            hass.data[DATA_INFO] = root_info.to_dict()
+            hass.data[DATA_HOST_INFO] = host_info.to_dict()
             hass.data[DATA_STORE] = store_info.to_dict()
+            hass.data[DATA_CORE_INFO] = homeassistant_info.to_dict()
+            hass.data[DATA_SUPERVISOR_INFO] = supervisor_info.to_dict()
+            hass.data[DATA_OS_INFO] = os_info.to_dict()
+            hass.data[DATA_NETWORK_INFO] = network_info.to_dict()
 
         async_call_later(
             hass,

homeassistant/components/hassio/coordinator.py

@@ -6,11 +6,16 @@
 from collections import defaultdict
 from copy import deepcopy
 import logging
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, cast
 
 from aiohasupervisor import SupervisorError, SupervisorNotFoundError
-from aiohasupervisor.models import StoreInfo
-from aiohasupervisor.models.mounts import CIFSMountResponse, NFSMountResponse
+from aiohasupervisor.models import (
+    AddonState,
+    CIFSMountResponse,
+    NFSMountResponse,
+    StoreInfo,
+)
+from aiohasupervisor.models.base import ResponseData
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import ATTR_MANUFACTURER, ATTR_NAME
@@ -22,11 +27,8 @@
 from homeassistant.loader import bind_hass
 
 from .const import (
-    ATTR_AUTO_UPDATE,
     ATTR_REPOSITORY,
     ATTR_SLUG,
-    ATTR_STARTED,
-    ATTR_STATE,
     ATTR_URL,
     ATTR_VERSION,
     CONTAINER_INFO,
@@ -57,7 +59,7 @@
     SUPERVISOR_CONTAINER,
     SupervisorEntityModel,
 )
-from .handler import HassioAPIError, get_supervisor_client
+from .handler import get_supervisor_client
 from .jobs import SupervisorJobs
 
 if TYPE_CHECKING:
@@ -341,7 +343,7 @@ async def _async_update_data(self) -> dict[str, Any]:
 
         try:
             await self.force_data_refresh(is_first_update)
-        except HassioAPIError as err:
+        except SupervisorError as err:
             raise UpdateFailed(f"Error on Supervisor API: {err}") from err
 
         new_data: dict[str, Any] = {}
@@ -360,17 +362,14 @@ async def _async_update_data(self) -> dict[str, Any]:
             repositories = {}
 
         new_data[DATA_KEY_ADDONS] = {
-            addon[ATTR_SLUG]: {
+            slug: {
                 **addon,
-                **((addons_stats or {}).get(addon[ATTR_SLUG]) or {}),
-                ATTR_AUTO_UPDATE: (addons_info.get(addon[ATTR_SLUG]) or {}).get(
-                    ATTR_AUTO_UPDATE, False
-                ),
+                **addons_stats.get(slug, {}),
                 ATTR_REPOSITORY: repositories.get(
-                    addon.get(ATTR_REPOSITORY), addon.get(ATTR_REPOSITORY, "")
+                    repo_slug := addon.get(ATTR_REPOSITORY, ""), repo_slug
                 ),
             }
-            for addon in supervisor_info.get("addons", [])
+            for slug, addon in addons_info.items()
         }
         if self.is_hass_os:
             new_data[DATA_KEY_OS] = get_os_info(self.hass)
@@ -462,32 +461,37 @@ async def force_data_refresh(self, first_update: bool) -> None:
         container_updates = self._container_updates
 
         data = self.hass.data
-        hassio = self.hassio
+        client = self.supervisor_client
+
         updates = {
-            DATA_INFO: hassio.get_info(),
-            DATA_CORE_INFO: hassio.get_core_info(),
-            DATA_SUPERVISOR_INFO: hassio.get_supervisor_info(),
-            DATA_OS_INFO: hassio.get_os_info(),
+            DATA_INFO: client.info(),
+            DATA_CORE_INFO: client.homeassistant.info(),
+            DATA_SUPERVISOR_INFO: client.supervisor.info(),
+            DATA_OS_INFO: client.os.info(),
         }
         if CONTAINER_STATS in container_updates[CORE_CONTAINER]:
-            updates[DATA_CORE_STATS] = hassio.get_core_stats()
+            updates[DATA_CORE_STATS] = client.homeassistant.stats()
         if CONTAINER_STATS in container_updates[SUPERVISOR_CONTAINER]:
-            updates[DATA_SUPERVISOR_STATS] = hassio.get_supervisor_stats()
-
-        results = await asyncio.gather(*updates.values())
-        for key, result in zip(updates, results, strict=False):
-            data[key] = result
-
-        _addon_data = data[DATA_SUPERVISOR_INFO].get("addons", [])
-        all_addons: list[str] = []
-        started_addons: list[str] = []
-        for addon in _addon_data:
-            slug = addon[ATTR_SLUG]
-            all_addons.append(slug)
-            if addon[ATTR_STATE] == ATTR_STARTED:
-                started_addons.append(slug)
+            updates[DATA_SUPERVISOR_STATS] = client.supervisor.stats()
+
+        results = await asyncio.gather(client.addons.list(), *updates.values())
+        # Pull off addons.list results for further processing before caching
+        apps_list = results.pop(0)
+        # Zip the rest and cache in hass.data
+        for key, result in zip(
+            updates, cast(list[ResponseData], results), strict=False
+        ):
+            data[key] = result.to_dict()
+
+        all_apps = {app.slug: app for app in apps_list}
+        started_apps = {
+            app.slug
+            for app in apps_list
+            if app.state in {AddonState.STARTED, AddonState.STARTUP}
+        }
+
         #
-        # Update add-on info if its the first update or
+        # Update app info if its the first update or
         # there is at least one entity that needs the data.
         #
         # When entities are added they call async_enable_container_updates
@@ -497,50 +501,57 @@ async def force_data_refresh(self, first_update: bool) -> None:
         # API calls since otherwise we would fetch stats for all containers
         # and throw them away.
         #
-        for data_key, update_func, enabled_key, wanted_addons, needs_first_update in (
-            (
-                DATA_ADDONS_STATS,
-                self._update_addon_stats,
-                CONTAINER_STATS,
-                started_addons,
-                False,
-            ),
-            (
-                DATA_ADDONS_INFO,
-                self._update_addon_info,
-                CONTAINER_INFO,
-                all_addons,
-                True,
-            ),
-        ):
-            container_data: dict[str, Any] = data.setdefault(data_key, {})
-            container_data.update(
-                dict(
-                    await asyncio.gather(
-                        *[
-                            update_func(slug)
-                            for slug in wanted_addons
-                            if (first_update and needs_first_update)
-                            or enabled_key in container_updates[slug]
-                        ]
-                    )
+        stats_data: dict[str, Any] = data.setdefault(DATA_ADDONS_STATS, {})
+        info_data: dict[str, Any] = data.setdefault(DATA_ADDONS_INFO, {})
+
+        # Clean up caches
+        for slug in stats_data.keys() - started_apps:
+            del stats_data[slug]
+        for slug in info_data.keys() - all_apps:
+            del info_data[slug]
+
+        # Update stats cache from API
+        stats_data.update(
+            dict(
+                await asyncio.gather(
+                    *[
+                        self._update_app_stats(slug)
+                        for slug in started_apps
+                        if CONTAINER_STATS in container_updates[slug]
+                    ]
                 )
             )
+        )
+
+        # Update info cache from API. On failure keep old data if we have any.
+        # If we have none, use the data that came back from addons.list API instead
+        all_app_info = await asyncio.gather(
+            *[
+                self._update_app_info(slug)
+                for slug in all_apps
+                if first_update or CONTAINER_INFO in container_updates[slug]
+            ]
+        )
+        for slug, app_info in all_app_info:
+            if app_info:
+                info_data[slug] = app_info
+            elif slug not in info_data:
+                info_data[slug] = all_apps[slug].to_dict()
 
         # Refresh jobs data
         await self.jobs.refresh_data(first_update)
 
-    async def _update_addon_stats(self, slug: str) -> tuple[str, dict[str, Any] | None]:
-        """Update single addon stats."""
+    async def _update_app_stats(self, slug: str) -> tuple[str, dict[str, Any] | None]:
+        """Update single app stats."""
         try:
             stats = await self.supervisor_client.addons.addon_stats(slug)
         except SupervisorError as err:
             _LOGGER.warning("Could not fetch stats for %s: %s", slug, err)
             return (slug, None)
         return (slug, stats.to_dict())
 
-    async def _update_addon_info(self, slug: str) -> tuple[str, dict[str, Any] | None]:
-        """Return the info for an add-on."""
+    async def _update_app_info(self, slug: str) -> tuple[str, dict[str, Any] | None]:
+        """Return the info for an app."""
         try:
             info = await self.supervisor_client.addons.addon_info(slug)
         except SupervisorError as err:
@@ -595,7 +606,7 @@ async def _async_refresh(
     async def force_addon_info_data_refresh(self, addon_slug: str) -> None:
         """Force refresh of addon info data for a specific addon."""
         try:
-            slug, info = await self._update_addon_info(addon_slug)
+            slug, info = await self._update_app_info(addon_slug)
             if info is not None and DATA_KEY_ADDONS in self.data:
                 if slug in self.data[DATA_KEY_ADDONS]:
                     data = deepcopy(self.data)

homeassistant/components/hassio/handler.py

@@ -87,70 +87,6 @@ def base_url(self) -> URL:
         """Return base url for Supervisor."""
         return self._base_url
 
-    @api_data
-    def get_info(self) -> Coroutine:
-        """Return generic Supervisor information.
-
-        This method returns a coroutine.
-        """
-        return self.send_command("/info", method="get")
-
-    @api_data
-    def get_host_info(self) -> Coroutine:
-        """Return data for Host.
-
-        This method returns a coroutine.
-        """
-        return self.send_command("/host/info", method="get")
-
-    @api_data
-    def get_os_info(self) -> Coroutine:
-        """Return data for the OS.
-
-        This method returns a coroutine.
-        """
-        return self.send_command("/os/info", method="get")
-
-    @api_data
-    def get_core_info(self) -> Coroutine:
-        """Return data for Home Asssistant Core.
-
-        This method returns a coroutine.
-        """
-        return self.send_command("/core/info", method="get")
-
-    @api_data
-    def get_supervisor_info(self) -> Coroutine:
-        """Return data for the Supervisor.
-
-        This method returns a coroutine.
-        """
-        return self.send_command("/supervisor/info", method="get")
-
-    @api_data
-    def get_network_info(self) -> Coroutine:
-        """Return data for the Host Network.
-
-        This method returns a coroutine.
-        """
-        return self.send_command("/network/info", method="get")
-
-    @api_data
-    def get_core_stats(self) -> Coroutine:
-        """Return stats for the core.
-
-        This method returns a coroutine.
-        """
-        return self.send_command("/core/stats", method="get")
-
-    @api_data
-    def get_supervisor_stats(self) -> Coroutine:
-        """Return stats for the supervisor.
-
-        This method returns a coroutine.
-        """
-        return self.send_command("/supervisor/stats", method="get")
-
     @api_data
     def get_ingress_panels(self) -> Coroutine:
         """Return data for Add-on ingress panels.

homeassistant/components/hassio/issues.py

@@ -275,13 +275,9 @@ def add_issue(self, issue: Issue) -> None:
 
             elif issue.key == ISSUE_KEY_SYSTEM_FREE_SPACE:
                 host_info = get_host_info(self._hass)
-                if (
-                    host_info
-                    and "data" in host_info
-                    and "disk_free" in host_info["data"]
-                ):
+                if host_info and "disk_free" in host_info:
                     placeholders[PLACEHOLDER_KEY_FREE_SPACE] = str(
-                        host_info["data"]["disk_free"]
+                        host_info["disk_free"]
                     )
                 else:
                     placeholders[PLACEHOLDER_KEY_FREE_SPACE] = "<2"

homeassistant/components/hassio/system_health.py

@@ -9,6 +9,7 @@
 from homeassistant.core import HomeAssistant, callback
 
 from .coordinator import (
+    get_addons_info,
     get_host_info,
     get_info,
     get_network_info,
@@ -35,6 +36,7 @@ async def system_health_info(hass: HomeAssistant) -> dict[str, Any]:
     host_info = get_host_info(hass) or {}
     supervisor_info = get_supervisor_info(hass)
     network_info = get_network_info(hass) or {}
+    addons_info = get_addons_info(hass) or {}
 
     healthy: bool | dict[str, str]
     if supervisor_info is not None and supervisor_info.get("healthy"):
@@ -84,6 +86,8 @@ async def system_health_info(hass: HomeAssistant) -> dict[str, Any]:
         os_info = get_os_info(hass) or {}
         information["board"] = os_info.get("board")
 
+    # Not using aiohasupervisor for ping call below intentionally. Given system health
+    # context seems preferable this check be done with minimal dependencies
     information["supervisor_api"] = system_health.async_check_can_reach_url(
         hass,
         SUPERVISOR_PING.format(ip_address=ip_address),
@@ -95,8 +99,7 @@ async def system_health_info(hass: HomeAssistant) -> dict[str, Any]:
     )
 
     information["installed_addons"] = ", ".join(
-        f"{addon['name']} ({addon['version']})"
-        for addon in (supervisor_info or {}).get("addons", [])
+        f"{addon['name']} ({addon['version']})" for addon in addons_info.values()
     )
 
     return information