Make local backup a backup agent

homeassistant/components/backup/__init__.py

@@ -33,6 +33,7 @@
 async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     """Set up the Backup integration."""
     hass.data[DOMAIN] = backup_manager = BackupManager(hass)
+    await backup_manager.async_setup()
 
     with_hassio = is_hassio(hass)
 
@@ -48,8 +49,10 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
 
     async def async_handle_create_service(call: ServiceCall) -> None:
         """Service handler for creating backups."""
+        agent_id = list(backup_manager.local_backup_agents)[0]
         await backup_manager.async_create_backup(
             addons_included=None,
+            agent_ids=[agent_id],
             database_included=True,
             folders_included=None,
             name=None,

homeassistant/components/backup/agent.py

@@ -56,6 +56,26 @@ async def async_upload_backup(
     async def async_list_backups(self, **kwargs: Any) -> list[UploadedBackup]:
         """List backups."""
 
+    @abc.abstractmethod
+    async def async_get_backup(
+        self,
+        *,
+        slug: str,
+        **kwargs: Any,
+    ) -> UploadedBackup | None:
+        """Return a backup."""
+
+
+class LocalBackupAgent(BackupAgent):
+    """Local backup agent."""
+
+    @abc.abstractmethod
+    def get_backup_path(self, slug: str) -> Path:
+        """Return the local path to a backup.
+
+        The method should return the path to the backup file with the specified slug.
+        """
+
 
 class BackupAgentPlatformProtocol(Protocol):
     """Define the format of backup platforms which implement backup agents."""

homeassistant/components/backup/backup.py

@@ -0,0 +1,150 @@
+"""Local backup support for Core and Container installations."""
+
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass
+import json
+from pathlib import Path
+from tarfile import TarError
+from typing import Any
+
+from homeassistant.core import HomeAssistant
+
+from .agent import BackupAgent, LocalBackupAgent, UploadedBackup
+from .const import LOGGER
+from .models import BackupUploadMetadata
+from .util import read_backup
+
+
+async def async_get_backup_agents(
+    hass: HomeAssistant,
+    **kwargs: Any,
+) -> list[BackupAgent]:
+    """Return the local backup agent."""
+    return [CoreLocalBackupAgent(hass)]
+
+
+@dataclass(slots=True)
+class LocalBackup(UploadedBackup):
+    """Local backup class."""
+
+    path: Path
+
+    def as_dict(self) -> dict:
+        """Return a dict representation of this backup."""
+        return {**asdict(self), "path": self.path.as_posix()}
+
+
+class CoreLocalBackupAgent(LocalBackupAgent):
+    """Local backup agent for Core and Container installations."""
+
+    name = "local"
+
+    def __init__(self, hass: HomeAssistant) -> None:
+        """Initialize the backup agent."""
+        super().__init__()
+        self._hass = hass
+        self._backup_dir = Path(hass.config.path("backups"))
+        self._backups: dict[str, LocalBackup] = {}
+        self._loaded_backups = False
+
+    async def load_backups(self) -> None:
+        """Load data of stored backup files."""
+        backups = await self._hass.async_add_executor_job(self._read_backups)
+        LOGGER.debug("Loaded %s local backups", len(backups))
+        self._backups = backups
+        self._loaded_backups = True
+
+    def _read_backups(self) -> dict[str, LocalBackup]:
+        """Read backups from disk."""
+        backups: dict[str, LocalBackup] = {}
+        for backup_path in self._backup_dir.glob("*.tar"):
+            try:
+                base_backup = read_backup(backup_path)
+                backup = LocalBackup(
+                    id=base_backup.slug,
+                    slug=base_backup.slug,
+                    name=base_backup.name,
+                    date=base_backup.date,
+                    path=backup_path,
+                    size=round(backup_path.stat().st_size / 1_048_576, 2),
+                    protected=base_backup.protected,
+                )
+                backups[backup.slug] = backup
+            except (OSError, TarError, json.JSONDecodeError, KeyError) as err:
+                LOGGER.warning("Unable to read backup %s: %s", backup_path, err)
+        return backups
+
+    async def async_download_backup(
+        self,
+        *,
+        id: str,
+        path: Path,
+        **kwargs: Any,
+    ) -> None:
+        """Download a backup file."""
+        raise NotImplementedError
+
+    async def async_upload_backup(
+        self,
+        *,
+        path: Path,
+        metadata: BackupUploadMetadata,
+        **kwargs: Any,
+    ) -> None:
+        """Upload a backup."""
+        self._backups[metadata.slug] = LocalBackup(
+            id=metadata.slug,  # Do we need another ID?
+            slug=metadata.slug,
+            name=metadata.name,
+            date=metadata.date,
+            path=path,
+            size=round(path.stat().st_size / 1_048_576, 2),
+            protected=metadata.protected,
+        )
+
+    async def async_list_backups(self, **kwargs: Any) -> list[UploadedBackup]:
+        """List backups."""
+        if not self._loaded_backups:
+            await self.load_backups()
+        return list(self._backups.values())
+
+    async def async_get_backup(
+        self,
+        *,
+        slug: str,
+        **kwargs: Any,
+    ) -> UploadedBackup | None:
+        """Return a backup."""
+        if not self._loaded_backups:
+            await self.load_backups()
+
+        if not (backup := self._backups.get(slug)):
+            return None
+
+        if not await self._hass.async_add_executor_job(backup.path.exists):
+            LOGGER.debug(
+                (
+                    "Removing tracked backup (%s) that does not exists on the expected"
+                    " path %s"
+                ),
+                backup.slug,
+                backup.path,
+            )
+            self._backups.pop(slug)
+            return None
+
+        return backup
+
+    def get_backup_path(self, slug: str) -> Path:
+        """Return the local path to a backup."""
+        return self._backup_dir / f"{slug}.tar"
+
+    async def async_remove_backup(self, *, slug: str, **kwargs: Any) -> None:
+        """Remove a backup."""
+        if (backup := await self.async_get_backup(slug=slug)) is None:
+            return
+
+        await self._hass.async_add_executor_job(backup.path.unlink, True)  # type: ignore[attr-defined]
+        LOGGER.debug("Removed backup located at %s", backup.path)  # type: ignore[attr-defined]
+        self._backups.pop(slug)

homeassistant/components/backup/const.py

@@ -11,6 +11,7 @@
     from .manager import BaseBackupManager
     from .models import BaseBackup
 
+BUF_SIZE = 2**20 * 4  # 4MB
 DOMAIN = "backup"
 DATA_MANAGER: HassKey[BaseBackupManager[BaseBackup]] = HassKey(DOMAIN)
 LOGGER = getLogger(__package__)

homeassistant/components/backup/http.py

@@ -17,6 +17,9 @@
 from .const import DATA_MANAGER
 from .manager import BackupManager
 
+# pylint: disable=fixme
+# TODO: Don't forget to remove this when the implementation is complete
+
 
 @callback
 def async_register_http_views(hass: HomeAssistant) -> None:
@@ -39,15 +42,32 @@ async def get(
         """Download a backup file."""
         if not request["hass_user"].is_admin:
             return Response(status=HTTPStatus.UNAUTHORIZED)
+        try:
+            agent_id = request.query.getone("agent_id")
+        except KeyError:
+            return Response(status=HTTPStatus.BAD_REQUEST)
 
         manager = cast(BackupManager, request.app[KEY_HASS].data[DATA_MANAGER])
-        backup = await manager.async_get_backup(slug=slug)
-
-        if backup is None or not backup.path.exists():
+        if agent_id not in manager.backup_agents:
+            return Response(status=HTTPStatus.BAD_REQUEST)
+        agent = manager.backup_agents[agent_id]
+        backup = await agent.async_get_backup(slug=slug)
+
+        # We don't need to check if the path exists, aiohttp.FileResponse will handle
+        # that
+        if backup is None:
             return Response(status=HTTPStatus.NOT_FOUND)
 
+        if agent_id in manager.local_backup_agents:
+            local_agent = manager.local_backup_agents[agent_id]
+            path = local_agent.get_backup_path(slug=slug)
+        else:
+            path = manager.temp_backup_dir / f"{slug}.tar"
+            await agent.async_download_backup(id=backup.id, path=path)
+
+        # TODO: We need a callback to remove the temp file once the download is complete
         return FileResponse(
-            path=backup.path.as_posix(),
+            path=path.as_posix(),
             headers={
                 CONTENT_DISPOSITION: f"attachment; filename={slugify(backup.name)}.tar"
             },
@@ -63,12 +83,16 @@ class UploadBackupView(HomeAssistantView):
     @require_admin
     async def post(self, request: Request) -> Response:
         """Upload a backup file."""
+        try:
+            agent_ids = request.query.getall("agent_id")
+        except KeyError:
+            return Response(status=HTTPStatus.BAD_REQUEST)
         manager = request.app[KEY_HASS].data[DATA_MANAGER]
         reader = await request.multipart()
         contents = cast(BodyPartReader, await reader.next())
 
         try:
-            await manager.async_receive_backup(contents=contents)
+            await manager.async_receive_backup(contents=contents, agent_ids=agent_ids)
         except OSError as err:
             return Response(
                 body=f"Can't write backup file {err}",