Add support for cloud backups in Core

Author: mdegat01

supervisor/addons/model.py

@@ -47,7 +47,7 @@
     ATTR_JOURNALD,
     ATTR_KERNEL_MODULES,
     ATTR_LEGACY,
-    ATTR_LOCATON,
+    ATTR_LOCATION,
     ATTR_MACHINE,
     ATTR_MAP,
     ATTR_NAME,
@@ -581,7 +581,7 @@ def map_volumes(self) -> dict[MappingType, FolderMapping]:
     @property
     def path_location(self) -> Path:
         """Return path to this add-on."""
-        return Path(self.data[ATTR_LOCATON])
+        return Path(self.data[ATTR_LOCATION])
 
     @property
     def path_icon(self) -> Path:

supervisor/addons/validate.py

@@ -55,7 +55,7 @@
     ATTR_KERNEL_MODULES,
     ATTR_LABELS,
     ATTR_LEGACY,
-    ATTR_LOCATON,
+    ATTR_LOCATION,
     ATTR_MACHINE,
     ATTR_MAP,
     ATTR_NAME,
@@ -483,7 +483,7 @@ def _migrate(config: dict[str, Any]):
     _migrate_addon_config(),
     _SCHEMA_ADDON_CONFIG.extend(
         {
-            vol.Required(ATTR_LOCATON): str,
+            vol.Required(ATTR_LOCATION): str,
             vol.Required(ATTR_REPOSITORY): str,
             vol.Required(ATTR_TRANSLATIONS, default=dict): {
                 str: SCHEMA_ADDON_TRANSLATIONS

supervisor/api/backups.py

@@ -14,18 +14,22 @@
 import voluptuous as vol
 
 from ..backups.backup import Backup
+from ..backups.const import LOCATION_CLOUD_BACKUP
 from ..backups.validate import ALL_FOLDERS, FOLDER_HOMEASSISTANT, days_until_stale
 from ..const import (
     ATTR_ADDONS,
+    ATTR_BACKUP,
     ATTR_BACKUPS,
     ATTR_COMPRESSED,
     ATTR_CONTENT,
     ATTR_DATE,
     ATTR_DAYS_UNTIL_STALE,
+    ATTR_FILENAME,
     ATTR_FOLDERS,
     ATTR_HOMEASSISTANT,
     ATTR_HOMEASSISTANT_EXCLUDE_DATABASE,
-    ATTR_LOCATON,
+    ATTR_JOB_ID,
+    ATTR_LOCATION,
     ATTR_NAME,
     ATTR_PASSWORD,
     ATTR_PROTECTED,
@@ -36,20 +40,22 @@
     ATTR_TIMEOUT,
     ATTR_TYPE,
     ATTR_VERSION,
+    REQUEST_FROM,
     BusEvent,
     CoreState,
 )
 from ..coresys import CoreSysAttributes
-from ..exceptions import APIError
+from ..exceptions import APIError, APIForbidden
 from ..jobs import JobSchedulerOptions
 from ..mounts.const import MountUsage
 from ..resolution.const import UnhealthyReason
-from .const import ATTR_BACKGROUND, ATTR_JOB_ID, CONTENT_TYPE_TAR
+from .const import ATTR_BACKGROUND, ATTR_LOCATIONS, CONTENT_TYPE_TAR
 from .utils import api_process, api_validate
 
 _LOGGER: logging.Logger = logging.getLogger(__name__)
 
 RE_SLUGIFY_NAME = re.compile(r"[^A-Za-z0-9]+")
+RE_FILENAME = re.compile(r"^[^\\\/]+")
 
 # Backwards compatible
 # Remove: 2022.08
@@ -76,7 +82,7 @@
         vol.Optional(ATTR_NAME): str,
         vol.Optional(ATTR_PASSWORD): vol.Maybe(str),
         vol.Optional(ATTR_COMPRESSED): vol.Maybe(vol.Boolean()),
-        vol.Optional(ATTR_LOCATON): vol.Maybe(str),
+        vol.Optional(ATTR_LOCATION): vol.Maybe(str),
         vol.Optional(ATTR_HOMEASSISTANT_EXCLUDE_DATABASE): vol.Boolean(),
         vol.Optional(ATTR_BACKGROUND, default=False): vol.Boolean(),
     }
@@ -101,6 +107,16 @@
         vol.Optional(ATTR_TIMEOUT): vol.All(int, vol.Range(min=1)),
     }
 )
+SCHEMA_RELOAD = vol.Schema(
+    {
+        vol.Optional(ATTR_BACKUP, default={}): vol.Schema(
+            {
+                vol.Required(ATTR_LOCATION): vol.Maybe(str),
+                vol.Required(ATTR_FILENAME): vol.Match(RE_FILENAME),
+            }
+        )
+    }
+)
 
 
 class APIBackups(CoreSysAttributes):
@@ -122,7 +138,8 @@ def _list_backups(self):
                 ATTR_DATE: backup.date,
                 ATTR_TYPE: backup.sys_type,
                 ATTR_SIZE: backup.size,
-                ATTR_LOCATON: backup.location,
+                ATTR_LOCATION: backup.location,
+                ATTR_LOCATIONS: backup.locations,
                 ATTR_PROTECTED: backup.protected,
                 ATTR_COMPRESSED: backup.compressed,
                 ATTR_CONTENT: {
@@ -132,6 +149,7 @@ def _list_backups(self):
                 },
             }
             for backup in self.sys_backups.list_backups
+            if backup.location != LOCATION_CLOUD_BACKUP
         ]
 
     @api_process
@@ -164,10 +182,12 @@ async def options(self, request):
         self.sys_backups.save_data()
 
     @api_process
-    async def reload(self, _):
+    async def reload(self, request: web.Request):
         """Reload backup list."""
-        await asyncio.shield(self.sys_backups.reload())
-        return True
+        body = await api_validate(SCHEMA_RELOAD, request)
+        backup = self._location_to_mount(body[ATTR_BACKUP])
+
+        return await asyncio.shield(self.sys_backups.reload(**backup))
 
     @api_process
     async def backup_info(self, request):
@@ -195,7 +215,8 @@ async def backup_info(self, request):
             ATTR_PROTECTED: backup.protected,
             ATTR_SUPERVISOR_VERSION: backup.supervisor_version,
             ATTR_HOMEASSISTANT: backup.homeassistant_version,
-            ATTR_LOCATON: backup.location,
+            ATTR_LOCATION: backup.location,
+            ATTR_LOCATIONS: backup.locations,
             ATTR_ADDONS: data_addons,
             ATTR_REPOSITORIES: backup.repositories,
             ATTR_FOLDERS: backup.folders,
@@ -204,17 +225,29 @@ async def backup_info(self, request):
 
     def _location_to_mount(self, body: dict[str, Any]) -> dict[str, Any]:
         """Change location field to mount if necessary."""
-        if not body.get(ATTR_LOCATON):
+        if not body.get(ATTR_LOCATION) or body[ATTR_LOCATION] == LOCATION_CLOUD_BACKUP:
             return body
 
-        body[ATTR_LOCATON] = self.sys_mounts.get(body[ATTR_LOCATON])
-        if body[ATTR_LOCATON].usage != MountUsage.BACKUP:
+        body[ATTR_LOCATION] = self.sys_mounts.get(body[ATTR_LOCATION])
+        if body[ATTR_LOCATION].usage != MountUsage.BACKUP:
             raise APIError(
-                f"Mount {body[ATTR_LOCATON].name} is not used for backups, cannot backup to there"
+                f"Mount {body[ATTR_LOCATION].name} is not used for backups, cannot backup to there"
             )
 
         return body
 
+    def _validate_cloud_backup_location(
+        self, request: web.Request, location: str | None
+    ) -> None:
+        """Cloud backup location is only available to Home Assistant."""
+        if (
+            location == LOCATION_CLOUD_BACKUP
+            and request.get(REQUEST_FROM) != self.sys_homeassistant
+        ):
+            raise APIForbidden(
+                f"Location {LOCATION_CLOUD_BACKUP} is only available for Home Assistant"
+            )
+
     async def _background_backup_task(
         self, backup_method: Callable, *args, **kwargs
     ) -> tuple[asyncio.Task, str]:
@@ -246,9 +279,10 @@ async def release_on_freeze(new_state: CoreState):
             self.sys_bus.remove_listener(listener)
 
     @api_process
-    async def backup_full(self, request):
+    async def backup_full(self, request: web.Request):
         """Create full backup."""
         body = await api_validate(SCHEMA_BACKUP_FULL, request)
+        self._validate_cloud_backup_location(request, body.get(ATTR_LOCATION))
         background = body.pop(ATTR_BACKGROUND)
         backup_task, job_id = await self._background_backup_task(
             self.sys_backups.do_backup_full, **self._location_to_mount(body)
@@ -266,9 +300,10 @@ async def backup_full(self, request):
         )
 
     @api_process
-    async def backup_partial(self, request):
+    async def backup_partial(self, request: web.Request):
         """Create a partial backup."""
         body = await api_validate(SCHEMA_BACKUP_PARTIAL, request)
+        self._validate_cloud_backup_location(request, body.get(ATTR_LOCATION))
         background = body.pop(ATTR_BACKGROUND)
         backup_task, job_id = await self._background_backup_task(
             self.sys_backups.do_backup_partial, **self._location_to_mount(body)
@@ -286,9 +321,10 @@ async def backup_partial(self, request):
         )
 
     @api_process
-    async def restore_full(self, request):
+    async def restore_full(self, request: web.Request):
         """Full restore of a backup."""
         backup = self._extract_slug(request)
+        self._validate_cloud_backup_location(request, backup.location)
         body = await api_validate(SCHEMA_RESTORE_FULL, request)
         background = body.pop(ATTR_BACKGROUND)
         restore_task, job_id = await self._background_backup_task(
@@ -303,9 +339,10 @@ async def restore_full(self, request):
         )
 
     @api_process
-    async def restore_partial(self, request):
+    async def restore_partial(self, request: web.Request):
         """Partial restore a backup."""
         backup = self._extract_slug(request)
+        self._validate_cloud_backup_location(request, backup.location)
         body = await api_validate(SCHEMA_RESTORE_PARTIAL, request)
         background = body.pop(ATTR_BACKGROUND)
         restore_task, job_id = await self._background_backup_task(
@@ -320,23 +357,24 @@ async def restore_partial(self, request):
         )
 
     @api_process
-    async def freeze(self, request):
+    async def freeze(self, request: web.Request):
         """Initiate manual freeze for external backup."""
         body = await api_validate(SCHEMA_FREEZE, request)
         await asyncio.shield(self.sys_backups.freeze_all(**body))
 
     @api_process
-    async def thaw(self, request):
+    async def thaw(self, request: web.Request):
         """Begin thaw after manual freeze."""
         await self.sys_backups.thaw_all()
 
     @api_process
-    async def remove(self, request):
+    async def remove(self, request: web.Request):
         """Remove a backup."""
         backup = self._extract_slug(request)
+        self._validate_cloud_backup_location(request, backup.location)
         return self.sys_backups.remove(backup)
 
-    async def download(self, request):
+    async def download(self, request: web.Request):
         """Download a backup file."""
         backup = self._extract_slug(request)
 
@@ -349,7 +387,7 @@ async def download(self, request):
         return response
 
     @api_process
-    async def upload(self, request):
+    async def upload(self, request: web.Request):
         """Upload a backup file."""
         with TemporaryDirectory(dir=str(self.sys_config.path_tmp)) as temp_dir:
             tar_file = Path(temp_dir, "backup.tar")

supervisor/api/const.py

@@ -42,11 +42,11 @@
 ATTR_IDENTIFIERS = "identifiers"
 ATTR_IS_ACTIVE = "is_active"
 ATTR_IS_OWNER = "is_owner"
-ATTR_JOB_ID = "job_id"
 ATTR_JOBS = "jobs"
 ATTR_LLMNR = "llmnr"
 ATTR_LLMNR_HOSTNAME = "llmnr_hostname"
 ATTR_LOCAL_ONLY = "local_only"
+ATTR_LOCATIONS = "locations"
 ATTR_MDNS = "mdns"
 ATTR_MODEL = "model"
 ATTR_MOUNTS = "mounts"

supervisor/backups/backup.py

@@ -10,11 +10,11 @@
 import io
 import json
 import logging
-from pathlib import Path
+from pathlib import Path, PurePath
 import tarfile
 from tempfile import TemporaryDirectory
 import time
-from typing import Any
+from typing import Any, Literal
 
 from awesomeversion import AwesomeVersion, AwesomeVersionCompareException
 from cryptography.hazmat.backends import default_backend
@@ -48,14 +48,15 @@
     CRYPTO_AES128,
 )
 from ..coresys import CoreSys
+from ..docker.const import PATH_BACKUP, PATH_CLOUD_BACKUP
 from ..exceptions import AddonsError, BackupError, BackupInvalidError
 from ..jobs.const import JOB_GROUP_BACKUP
 from ..jobs.decorator import Job
 from ..jobs.job_group import JobGroup
 from ..utils import remove_folder
 from ..utils.dt import parse_datetime, utcnow
 from ..utils.json import json_bytes
-from .const import BUF_SIZE, BackupType
+from .const import BUF_SIZE, LOCATION_CLOUD_BACKUP, BackupType
 from .utils import key_to_iv, password_to_key
 from .validate import SCHEMA_BACKUP
 
@@ -70,6 +71,7 @@ def __init__(
         coresys: CoreSys,
         tar_file: Path,
         slug: str,
+        location: str | None,
         data: dict[str, Any] | None = None,
     ):
         """Initialize a backup."""
@@ -83,6 +85,8 @@ def __init__(
         self._outer_secure_tarfile_tarfile: tarfile.TarFile | None = None
         self._key: bytes | None = None
         self._aes: Cipher | None = None
+        # Order is maintained in dict keys so this is effectively an ordered set
+        self._locations: dict[str | None, Literal[None]] = {location: None}
 
     @property
     def version(self) -> int:
@@ -178,12 +182,41 @@ def docker(self, value: dict[str, Any]) -> None:
         """Set the Docker config data."""
         self._data[ATTR_DOCKER] = value
 
-    @cached_property
+    @property
     def location(self) -> str | None:
         """Return the location of the backup."""
-        for backup_mount in self.sys_mounts.backup_mounts:
-            if self.tarfile.is_relative_to(backup_mount.local_where):
-                return backup_mount.name
+        return self.locations[0]
+
+    @property
+    def all_locations(self) -> set[str | None]:
+        """Return all locations this backup was found in."""
+        return self._locations.keys()
+
+    @property
+    def locations(self) -> list[str | None]:
+        """Return locations this backup was found in except cloud backup (unless that's the only one)."""
+        if len(self._locations) == 1:
+            return list(self._locations)
+        return [
+            location
+            for location in self._locations
+            if location != LOCATION_CLOUD_BACKUP
+        ]
+
+    @cached_property
+    def container_path(self) -> PurePath | None:
+        """Return where this is made available in managed containers (core, addons, etc.).
+
+        This returns none if the tarfile is not in a place mapped into other containers.
+        """
+        path_map: dict[Path, PurePath] = {
+            self.sys_config.path_backup: PATH_BACKUP,
+            self.sys_config.path_core_backup: PATH_CLOUD_BACKUP,
+        }
+        for source, target in path_map.items():
+            if self.tarfile.is_relative_to(source):
+                return target / self.tarfile.relative_to(source)
+
         return None
 
     @property
@@ -215,6 +248,10 @@ def data(self) -> dict[str, Any]:
         """Returns a copy of the data."""
         return deepcopy(self._data)
 
+    def add_location(self, location: str | None) -> None:
+        """Add a location the backup exists."""
+        self._locations[location] = None
+
     def new(
         self,
         name: str,