Add update integration

.core_files.yaml

@@ -94,6 +94,7 @@ components: &components
   - homeassistant/components/tag/*
   - homeassistant/components/template/*
   - homeassistant/components/timer/*
+  - homeassistant/components/update/*
   - homeassistant/components/usb/*
   - homeassistant/components/webhook/*
   - homeassistant/components/websocket_api/*

CODEOWNERS

@@ -1005,6 +1005,8 @@ tests/components/upb/* @gwww
 homeassistant/components/upc_connect/* @pvizeli @fabaff
 homeassistant/components/upcloud/* @scop
 tests/components/upcloud/* @scop
+homeassistant/components/update/* @home-assistant/core
+tests/components/update/* @home-assistant/core
 homeassistant/components/updater/* @home-assistant/core
 tests/components/updater/* @home-assistant/core
 homeassistant/components/upnp/* @StevenLooman @ehendrix23

homeassistant/components/default_config/manifest.json

@@ -31,11 +31,12 @@
     "tag",
     "timer",
     "usb",
+    "update",
     "updater",
     "webhook",
     "zeroconf",
     "zone"
   ],
   "codeowners": [],
   "quality_scale": "internal"
-}
+}

homeassistant/components/update/__init__.py

@@ -0,0 +1,243 @@
+"""Support for Update."""
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Awaitable, Callable
+import dataclasses
+import logging
+
+import async_timeout
+import voluptuous as vol
+
+from homeassistant.components import websocket_api
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers import integration_platform, storage
+from homeassistant.helpers.typing import ConfigType
+
+_LOGGER = logging.getLogger(__name__)
+
+DOMAIN = "update"
+
+INFO_CALLBACK_TIMEOUT = 5
+STORAGE_VERSION = 1
+
+
+async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
+    """Set up the Update integration."""
+    store = storage.Store(
+        hass=hass,
+        version=STORAGE_VERSION,
+        key=DOMAIN,
+    )
+    hass.data[DOMAIN] = UpdateData(
+        store=store,
+        skip=set(await store.async_load() or []),
+    )
+
+    websocket_api.async_register_command(hass, handle_info)
+    websocket_api.async_register_command(hass, handle_update)
+    websocket_api.async_register_command(hass, handle_skip)
+
+    await integration_platform.async_process_integration_platforms(
+        hass, DOMAIN, _register_update_platform
+    )
+
+    return True
+
+
+async def _register_update_platform(hass, integration_domain, platform) -> None:
+    """Register a update platform."""
+    if hasattr(platform, "async_register"):
+        platform.async_register(UpdateRegistration(hass, integration_domain))
+
+
+async def get_integration_info(
+    hass: HomeAssistant,
+    registration: UpdateRegistration,
+) -> list[UpdateDescription] | None:
+    """Get integration update details."""
+    assert registration.updates_callback
+
+    try:
+        async with async_timeout.timeout(INFO_CALLBACK_TIMEOUT):
+            return await registration.updates_callback(hass)
+    except asyncio.TimeoutError:
+        _LOGGER.warning("Timeout while getting updates from %s", registration.domain)
+    except Exception:  # pylint: disable=broad-except
+        _LOGGER.exception("Error fetching info")
+    return None
+
+
+def _get_update_details(
+    update_data: UpdateData,
+    domain: str,
+    identifier: str,
+) -> UpdateDescription | None:
+    """Get an update."""
+    return next(
+        (
+            update
+            for update in update_data.updates.get(domain, [])
+            if update.identifier == identifier
+        ),
+        None,
+    )
+
+
+def _filtered_updates(update_data: UpdateData) -> list[dict]:
+    """Return a list of updates that are not skipped."""
+    return [
+        {
+            "domain": domain,
+            "identifier": description.identifier,
+            "name": description.name,
+            "current_version": description.current_version,
+            "available_version": description.available_version,
+            "changelog_url": description.changelog_url,
+            "icon_url": description.icon_url,
+        }
+        for domain, domain_data in update_data.updates.items()
+        if domain_data is not None
+        for description in domain_data
+        if f"{domain}_{description.identifier}_{description.available_version}"
+        not in update_data.skip
+    ]
+
+
+@websocket_api.websocket_command({vol.Required("type"): "update/info"})
+@websocket_api.async_response
+async def handle_info(
+    hass: HomeAssistant,
+    connection: websocket_api.ActiveConnection,
+    msg: dict,
+):
+    """Get pending updates from all platforms."""
+    update_data: UpdateData = hass.data[DOMAIN]
+
+    for domain, domain_data in zip(
+        update_data.registrations,
+        await asyncio.gather(
+            *(
+                get_integration_info(hass, registration)
+                for registration in update_data.registrations.values()
+            )
+        ),
+    ):
+        update_data.updates[domain] = domain_data
+
+    connection.send_result(msg["id"], _filtered_updates(update_data))
+
+
+@websocket_api.websocket_command(
+    {
+        vol.Required("type"): "update/skip",
+        vol.Required("domain"): str,
+        vol.Required("identifier"): str,
+    }
+)
+@websocket_api.async_response
+async def handle_skip(
+    hass: HomeAssistant,
+    connection: websocket_api.ActiveConnection,
+    msg: dict,
+):
+    """Skip an update."""
+    update_data: UpdateData = hass.data[DOMAIN]
+    update_details = _get_update_details(update_data, msg["domain"], msg["identifier"])
+    if update_details is not None:
+        update_data.skip.add(
+            f"{msg['domain']}_{update_details.identifier}_{update_details.available_version}"
+        )
+        update_data.updates[msg["domain"]].remove(update_details)
+        await update_data.store.async_save(list(update_data.skip))
+
+    connection.send_result(
+        msg["id"],
+        _filtered_updates(update_data),
+    )
+
+
+@websocket_api.websocket_command(
+    {
+        vol.Required("type"): "update/update",
+        vol.Required("domain"): str,
+        vol.Required("identifier"): str,
+    }
+)
+@websocket_api.async_response
+async def handle_update(
+    hass: HomeAssistant,
+    connection: websocket_api.ActiveConnection,
+    msg: dict,
+):
+    """Handle an update."""
+    update_data: UpdateData = hass.data[DOMAIN]
+    update_details = _get_update_details(update_data, msg["domain"], msg["identifier"])
+
+    if update_details is None:
+        connection.send_error(
+            msg["id"],
+            "not_found",
+            f"No updates found for {msg['domain']} and {msg['identifier']}",
+        )
+        return
+
+    if not await update_details.update_callback(hass, update_details):
+        connection.send_error(msg["id"], "update_failed", "Update failed")
+        return
+
+    update_data.updates[msg["domain"]].remove(update_details)
+
+    connection.send_result(
+        msg["id"],
+        _filtered_updates(update_data),
+    )
+
+
+@dataclasses.dataclass()
+class UpdateData:
+    """Data for the update integration."""
+
+    store: storage.Store
+    skip: set[str]
+    registrations: dict[str, UpdateRegistration] = dataclasses.field(
+        default_factory=dict
+    )
+    updates: dict[str, list[UpdateDescription]] = dataclasses.field(
+        default_factory=dict
+    )
+
+
+@dataclasses.dataclass()
+class UpdateDescription:
+    """Describe an update update."""
+
+    identifier: str
+    name: str
+    current_version: str
+    available_version: str
+    update_callback: Callable[[HomeAssistant, UpdateDescription], Awaitable[bool]]
+    changelog_content: str | None = None
+    changelog_url: str | None = None
+    icon_url: str | None = None
+
+
+@dataclasses.dataclass()
+class UpdateRegistration:
+    """Helper class to track platform registration."""
+
+    hass: HomeAssistant
+    domain: str
+    updates_callback: Callable[
+        [HomeAssistant], Awaitable[list[UpdateDescription]]
+    ] | None = None
+
+    @callback
+    def async_register(
+        self,
+        updates_callback: Callable[[HomeAssistant], Awaitable[list[UpdateDescription]]],
+    ):
+        """Register the updates info callback."""
+        update_data: UpdateData = self.hass.data[DOMAIN]
+        self.updates_callback = updates_callback
+        update_data.registrations[self.domain] = self

homeassistant/components/update/manifest.json

@@ -0,0 +1,10 @@
+{
+  "domain": "update",
+  "name": "Update",
+  "documentation": "https://www.home-assistant.io/integrations/update",
+  "codeowners": [
+    "@home-assistant/core"
+  ],
+  "quality_scale": "internal",
+  "iot_class": "calculated"
+}

homeassistant/components/update/strings.json

@@ -0,0 +1,3 @@
+{
+    "title": "Update"
+}

homeassistant/components/update/translations/en.json

@@ -0,0 +1,3 @@
+{
+    "title": "Update"
+}

script/scaffold/docs.py

@@ -30,6 +30,11 @@
         "title": "Integration",
         "docs": "https://developers.home-assistant.io/docs/en/creating_integration_file_structure.html",
     },
+    "update": {
+        "title": "Update",
+        "docs": "https://developers.home-assistant.io/docs/en/update.html",
+        "extra": "This will allow you to present updates the user can perform.",
+    },
     "reproduce_state": {
         "title": "Reproduce State",
         "docs": "https://developers.home-assistant.io/docs/en/reproduce_state_index.html",

script/scaffold/templates/update/integration/update.py

@@ -0,0 +1,27 @@
+"""Update support for the NEW_NAME integration."""
+
+from homeassistant.components.update import UpdateDescription, UpdateRegistration
+from homeassistant.core import HomeAssistant, callback
+
+
+@callback
+def async_register(registration: UpdateRegistration) -> None:
+    """Register the update handler."""
+    registration.async_register(get_pending_updates)
+
+
+async def get_pending_updates(hass: HomeAssistant) -> list[UpdateDescription]:
+    """Get pending updates."""
+    # TODO: Add your logic to gather updates here.
+    # And return a list of UpdateDescription objects.
+    return []
+
+
+async def handle_update(
+    hass: HomeAssistant,
+    update_details: UpdateDescription,
+) -> bool:
+    """Handle an update."""
+    # TODO: Add your logic to perform updates here.
+    # And return a bool to indicate if the update where successful or not.
+    return True

script/scaffold/templates/update/tests/test_update.py

@@ -0,0 +1,10 @@
+"""Test the NEW_NAME update platform."""
+from homeassistant.components.NEW_DOMAIN.const import DOMAIN
+from homeassistant.core import HomeAssistant
+
+from tests.common import get_integration_updates
+
+
+async def test_pending_updates(hass: HomeAssistant) -> None:
+    """Test getting NEW_NAME updates."""
+    assert await get_integration_updates(hass, DOMAIN) == []

tests/common.py

@@ -35,6 +35,11 @@
     _async_get_device_automation_capabilities as async_get_device_automation_capabilities,
 )
 from homeassistant.components.mqtt.models import ReceiveMessage
+from homeassistant.components.update import (
+    DOMAIN as UPDATE_DOMAIN,
+    UpdateData,
+    UpdateDescription,
+)
 from homeassistant.config import async_process_component_config
 from homeassistant.const import (
     DEVICE_DEFAULT_NAME,
@@ -1129,6 +1134,16 @@ async def get_system_health_info(hass, domain):
     return await hass.data["system_health"][domain].info_callback(hass)
 
 
+async def get_integration_updates(
+    hass: HomeAssistant,
+    domain: str,
+) -> list[UpdateDescription]:
+    """Get updates for an integration."""
+    await async_setup_component(hass, UPDATE_DOMAIN, {})
+    update_data: UpdateData = hass.data[UPDATE_DOMAIN]
+    return await update_data.registrations[domain].updates_callback(hass)
+
+
 def mock_integration(hass, module, built_in=True):
     """Mock an integration."""
     integration = loader.Integration(

tests/components/update/__init__.py

@@ -0,0 +1 @@
+"""Tests for the Update integration."""