Add sensor platform to backup integration (#138663)

* add sensor platform to backup integration

* adjust namings, remove system integration flag

* add first simple test

* apply review comments

* fix test

* add sensor tests

* adjustements to use backup helper

* remove obsolet async_get_manager from init

* unsubscribe from events on entry unload

* add configuration_url

* fix doc string

* fix sensor tests

* mark async_unsubscribe as callback

* set integration_type service

* extend sensor test

* set integration_type on correct integration :)

* fix after online conflict resolution

* add sensor update tests

* simplify the sensor update tests

* avoid io during tests

* Add comment

---------

Co-authored-by: Martin Hjelmare <[email protected]>

Author: mib1185

homeassistant/components/backup/__init__.py

@@ -1,7 +1,9 @@
 """The Backup integration."""
 
+from homeassistant.config_entries import SOURCE_SYSTEM
+from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant, ServiceCall
-from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers import config_validation as cv, discovery_flow
 from homeassistant.helpers.backup import DATA_BACKUP
 from homeassistant.helpers.hassio import is_hassio
 from homeassistant.helpers.typing import ConfigType
@@ -18,10 +20,12 @@
 )
 from .config import BackupConfig, CreateBackupParametersDict
 from .const import DATA_MANAGER, DOMAIN
+from .coordinator import BackupConfigEntry, BackupDataUpdateCoordinator
 from .http import async_register_http_views
 from .manager import (
     BackupManager,
     BackupManagerError,
+    BackupPlatformEvent,
     BackupPlatformProtocol,
     BackupReaderWriter,
     BackupReaderWriterError,
@@ -52,6 +56,7 @@
     "BackupConfig",
     "BackupManagerError",
     "BackupNotFound",
+    "BackupPlatformEvent",
     "BackupPlatformProtocol",
     "BackupReaderWriter",
     "BackupReaderWriterError",
@@ -74,6 +79,8 @@
     "suggested_filename_from_name_date",
 ]
 
+PLATFORMS = [Platform.SENSOR]
+
 CONFIG_SCHEMA = cv.empty_config_schema(DOMAIN)
 
 
@@ -128,4 +135,28 @@ async def async_handle_create_automatic_service(call: ServiceCall) -> None:
 
     async_register_http_views(hass)
 
+    discovery_flow.async_create_flow(
+        hass, DOMAIN, context={"source": SOURCE_SYSTEM}, data={}
+    )
+
+    return True
+
+
+async def async_setup_entry(hass: HomeAssistant, entry: BackupConfigEntry) -> bool:
+    """Set up a config entry."""
+    backup_manager: BackupManager = hass.data[DATA_MANAGER]
+    coordinator = BackupDataUpdateCoordinator(hass, entry, backup_manager)
+    await coordinator.async_config_entry_first_refresh()
+
+    entry.async_on_unload(coordinator.async_unsubscribe)
+
+    entry.runtime_data = coordinator
+
+    await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
+
     return True
+
+
+async def async_unload_entry(hass: HomeAssistant, entry: BackupConfigEntry) -> bool:
+    """Unload a config entry."""
+    return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)

homeassistant/components/backup/config_flow.py

@@ -0,0 +1,21 @@
+"""Config flow for Home Assistant Backup integration."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
+
+from .const import DOMAIN
+
+
+class BackupConfigFlow(ConfigFlow, domain=DOMAIN):
+    """Handle a config flow for Home Assistant Backup."""
+
+    VERSION = 1
+
+    async def async_step_system(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle the initial step."""
+        return self.async_create_entry(title="Backup", data={})

homeassistant/components/backup/coordinator.py

@@ -0,0 +1,81 @@
+"""Coordinator for Home Assistant Backup integration."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+from datetime import datetime
+
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers.backup import (
+    async_subscribe_events,
+    async_subscribe_platform_events,
+)
+from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
+
+from .const import DOMAIN, LOGGER
+from .manager import (
+    BackupManager,
+    BackupManagerState,
+    BackupPlatformEvent,
+    ManagerStateEvent,
+)
+
+type BackupConfigEntry = ConfigEntry[BackupDataUpdateCoordinator]
+
+
+@dataclass
+class BackupCoordinatorData:
+    """Class to hold backup data."""
+
+    backup_manager_state: BackupManagerState
+    last_successful_automatic_backup: datetime | None
+    next_scheduled_automatic_backup: datetime | None
+
+
+class BackupDataUpdateCoordinator(DataUpdateCoordinator[BackupCoordinatorData]):
+    """Class to retrieve backup status."""
+
+    config_entry: ConfigEntry
+
+    def __init__(
+        self,
+        hass: HomeAssistant,
+        config_entry: ConfigEntry,
+        backup_manager: BackupManager,
+    ) -> None:
+        """Initialize coordinator."""
+        super().__init__(
+            hass,
+            LOGGER,
+            config_entry=config_entry,
+            name=DOMAIN,
+            update_interval=None,
+        )
+        self.unsubscribe: list[Callable[[], None]] = [
+            async_subscribe_events(hass, self._on_event),
+            async_subscribe_platform_events(hass, self._on_event),
+        ]
+
+        self.backup_manager = backup_manager
+
+    @callback
+    def _on_event(self, event: ManagerStateEvent | BackupPlatformEvent) -> None:
+        """Handle new event."""
+        LOGGER.debug("Received backup event: %s", event)
+        self.config_entry.async_create_task(self.hass, self.async_refresh())
+
+    async def _async_update_data(self) -> BackupCoordinatorData:
+        """Update backup manager data."""
+        return BackupCoordinatorData(
+            self.backup_manager.state,
+            self.backup_manager.config.data.last_completed_automatic_backup,
+            self.backup_manager.config.data.schedule.next_automatic_backup,
+        )
+
+    @callback
+    def async_unsubscribe(self) -> None:
+        """Unsubscribe from events."""
+        for unsub in self.unsubscribe:
+            unsub()

homeassistant/components/backup/entity.py

@@ -0,0 +1,36 @@
+"""Base for backup entities."""
+
+from __future__ import annotations
+
+from homeassistant.const import __version__ as HA_VERSION
+from homeassistant.helpers.device_registry import DeviceEntryType, DeviceInfo
+from homeassistant.helpers.entity import EntityDescription
+from homeassistant.helpers.update_coordinator import CoordinatorEntity
+
+from .const import DOMAIN
+from .coordinator import BackupDataUpdateCoordinator
+
+
+class BackupManagerEntity(CoordinatorEntity[BackupDataUpdateCoordinator]):
+    """Base entity for backup manager."""
+
+    _attr_has_entity_name = True
+
+    def __init__(
+        self,
+        coordinator: BackupDataUpdateCoordinator,
+        entity_description: EntityDescription,
+    ) -> None:
+        """Initialize base entity."""
+        super().__init__(coordinator)
+        self.entity_description = entity_description
+        self._attr_unique_id = entity_description.key
+        self._attr_device_info = DeviceInfo(
+            identifiers={(DOMAIN, "backup_manager")},
+            manufacturer="Home Assistant",
+            model="Home Assistant Backup",
+            sw_version=HA_VERSION,
+            name="Backup",
+            entry_type=DeviceEntryType.SERVICE,
+            configuration_url="homeassistant://config/backup",
+        )

homeassistant/components/backup/manager.py

@@ -229,6 +229,13 @@ class RestoreBackupEvent(ManagerStateEvent):
     state: RestoreBackupState
 
 
+@dataclass(frozen=True, kw_only=True, slots=True)
+class BackupPlatformEvent:
+    """Backup platform class."""
+
+    domain: str
+
+
 @dataclass(frozen=True, kw_only=True, slots=True)
 class BlockedEvent(ManagerStateEvent):
     """Backup manager blocked, Home Assistant is starting."""
@@ -355,6 +362,9 @@ def __init__(self, hass: HomeAssistant, reader_writer: BackupReaderWriter) -> No
         self._backup_event_subscriptions = hass.data[
             DATA_BACKUP
         ].backup_event_subscriptions
+        self._backup_platform_event_subscriptions = hass.data[
+            DATA_BACKUP
+        ].backup_platform_event_subscriptions
 
     async def async_setup(self) -> None:
         """Set up the backup manager."""
@@ -465,6 +475,9 @@ async def _add_platform(
         LOGGER.debug("%s platforms loaded in total", len(self.platforms))
         LOGGER.debug("%s agents loaded in total", len(self.backup_agents))
         LOGGER.debug("%s local agents loaded in total", len(self.local_backup_agents))
+        event = BackupPlatformEvent(domain=integration_domain)
+        for subscription in self._backup_platform_event_subscriptions:
+            subscription(event)
 
     async def async_pre_backup_actions(self) -> None:
         """Perform pre backup actions."""

homeassistant/components/backup/manifest.json

@@ -5,8 +5,9 @@
   "codeowners": ["@home-assistant/core"],
   "dependencies": ["http", "websocket_api"],
   "documentation": "https://www.home-assistant.io/integrations/backup",
-  "integration_type": "system",
+  "integration_type": "service",
   "iot_class": "calculated",
   "quality_scale": "internal",
-  "requirements": ["cronsim==2.6", "securetar==2025.2.1"]
+  "requirements": ["cronsim==2.6", "securetar==2025.2.1"],
+  "single_config_entry": true
 }

homeassistant/components/backup/sensor.py

@@ -0,0 +1,75 @@
+"""Sensor platform for Home Assistant Backup integration."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+from datetime import datetime
+
+from homeassistant.components.sensor import (
+    SensorDeviceClass,
+    SensorEntity,
+    SensorEntityDescription,
+)
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from .coordinator import BackupConfigEntry, BackupCoordinatorData
+from .entity import BackupManagerEntity
+from .manager import BackupManagerState
+
+
+@dataclass(kw_only=True, frozen=True)
+class BackupSensorEntityDescription(SensorEntityDescription):
+    """Description for Home Assistant Backup sensor entities."""
+
+    value_fn: Callable[[BackupCoordinatorData], str | datetime | None]
+
+
+BACKUP_MANAGER_DESCRIPTIONS = (
+    BackupSensorEntityDescription(
+        key="backup_manager_state",
+        translation_key="backup_manager_state",
+        device_class=SensorDeviceClass.ENUM,
+        options=[state.value for state in BackupManagerState],
+        value_fn=lambda data: data.backup_manager_state,
+    ),
+    BackupSensorEntityDescription(
+        key="next_scheduled_automatic_backup",
+        translation_key="next_scheduled_automatic_backup",
+        device_class=SensorDeviceClass.TIMESTAMP,
+        value_fn=lambda data: data.next_scheduled_automatic_backup,
+    ),
+    BackupSensorEntityDescription(
+        key="last_successful_automatic_backup",
+        translation_key="last_successful_automatic_backup",
+        device_class=SensorDeviceClass.TIMESTAMP,
+        value_fn=lambda data: data.last_successful_automatic_backup,
+    ),
+)
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    config_entry: BackupConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Sensor set up for backup config entry."""
+
+    coordinator = config_entry.runtime_data
+
+    async_add_entities(
+        BackupManagerSensor(coordinator, description)
+        for description in BACKUP_MANAGER_DESCRIPTIONS
+    )
+
+
+class BackupManagerSensor(BackupManagerEntity, SensorEntity):
+    """Sensor to track backup manager state."""
+
+    entity_description: BackupSensorEntityDescription
+
+    @property
+    def native_value(self) -> str | datetime | None:
+        """Return native value of entity."""
+        return self.entity_description.value_fn(self.coordinator.data)

homeassistant/components/backup/strings.json

@@ -22,5 +22,24 @@
       "name": "Create automatic backup",
       "description": "Creates a new backup with automatic backup settings."
     }
+  },
+  "entity": {
+    "sensor": {
+      "backup_manager_state": {
+        "name": "Backup Manager State",
+        "state": {
+          "idle": "Idle",
+          "create_backup": "Creating a backup",
+          "receive_backup": "Receiving a backup",
+          "restore_backup": "Restoring a backup"
+        }
+      },
+      "next_scheduled_automatic_backup": {
+        "name": "Next scheduled automatic backup"
+      },
+      "last_successful_automatic_backup": {
+        "name": "Last successful automatic backup"
+      }
+    }
   }
 }

homeassistant/generated/integrations.json

@@ -611,6 +611,13 @@
       "config_flow": true,
       "iot_class": "local_push"
     },
+    "backup": {
+      "name": "Backup",
+      "integration_type": "service",
+      "config_flow": false,
+      "iot_class": "calculated",
+      "single_config_entry": true
+    },
     "baf": {
       "name": "Big Ass Fans",
       "integration_type": "hub",