Merge remote-tracking branch 'upstream/main'

Author: Rippanda12

.github/workflows/builder.yml

@@ -106,7 +106,7 @@ jobs:
 
       - name: Build wheels
         if: needs.init.outputs.requirements == 'true'
-        uses: home-assistant/wheels@2024.11.0
+        uses: home-assistant/wheels@2025.02.0
         with:
           abi: cp313
           tag: musllinux_1_2

.github/workflows/sentry.yaml

@@ -12,7 +12,7 @@ jobs:
       - name: Check out code from GitHub
         uses: actions/[email protected]
       - name: Sentry Release
-        uses: getsentry/action-release@v1.10.4
+        uses: getsentry/action-release@v3.1.0
         env:
           SENTRY_AUTH_TOKEN: ${{ secrets.SENTRY_AUTH_TOKEN }}
           SENTRY_ORG: ${{ secrets.SENTRY_ORG }}

requirements.txt

@@ -3,18 +3,19 @@ aiohttp==3.11.13
 atomicwrites-homeassistant==1.4.1
 attrs==25.1.0
 awesomeversion==24.6.0
+blockbuster==1.5.23
 brotli==1.1.0
 ciso8601==2.3.2
 colorlog==6.9.0
 cpe==1.3.1
-cryptography==44.0.1
-debugpy==1.8.12
+cryptography==44.0.2
+debugpy==1.8.13
 deepmerge==2.0
 dirhash==0.5.0
 docker==7.1.0
 faust-cchardet==2.1.19
 gitpython==3.1.44
-jinja2==3.1.5
+jinja2==3.1.6
 orjson==3.10.12
 pulsectl==24.12.0
 pyudev==0.24.3
@@ -24,6 +25,6 @@ securetar==2025.2.1
 sentry-sdk==2.22.0
 setuptools==75.8.2
 voluptuous==0.15.2
-dbus-fast==2.34.0
+dbus-fast==2.37.0
 typing_extensions==4.12.2
 zlib-fast==0.2.1

requirements_tests.txt

@@ -6,8 +6,8 @@ pytest-aiohttp==1.1.0
 pytest-asyncio==0.25.2
 pytest-cov==6.0.0
 pytest-timeout==2.3.1
-pytest==8.3.4
-ruff==0.9.8
+pytest==8.3.5
+ruff==0.9.9
 time-machine==2.16.0
 typing_extensions==4.12.2
 urllib3==2.3.0

supervisor/addons/addon.py

@@ -140,9 +140,7 @@ def __init__(self, coresys: CoreSys, slug: str):
         super().__init__(coresys, slug)
         self.instance: DockerAddon = DockerAddon(coresys, self)
         self._state: AddonState = AddonState.UNKNOWN
-        self._manual_stop: bool = (
-            self.sys_hardware.helper.last_boot != self.sys_config.last_boot
-        )
+        self._manual_stop: bool = False
         self._listeners: list[EventListener] = []
         self._startup_event = asyncio.Event()
         self._startup_task: asyncio.Task | None = None
@@ -216,6 +214,10 @@ def in_progress(self) -> bool:
 
     async def load(self) -> None:
         """Async initialize of object."""
+        self._manual_stop = (
+            await self.sys_hardware.helper.last_boot() != self.sys_config.last_boot
+        )
+
         if self.is_detached:
             await super().refresh_path_cache()
 
@@ -720,7 +722,7 @@ async def write_options(self) -> None:
 
         try:
             options = self.schema.validate(self.options)
-            write_json_file(self.path_options, options)
+            await self.sys_run_in_executor(write_json_file, self.path_options, options)
         except vol.Invalid as ex:
             _LOGGER.error(
                 "Add-on %s has invalid options: %s",
@@ -751,9 +753,12 @@ async def unload(self) -> None:
         for listener in self._listeners:
             self.sys_bus.remove_listener(listener)
 
-        if self.path_data.is_dir():
-            _LOGGER.info("Removing add-on data folder %s", self.path_data)
-            await remove_data(self.path_data)
+        def remove_data_dir():
+            if self.path_data.is_dir():
+                _LOGGER.info("Removing add-on data folder %s", self.path_data)
+                remove_data(self.path_data)
+
+        await self.sys_run_in_executor(remove_data_dir)
 
     async def _check_ingress_port(self):
         """Assign a ingress port if dynamic port selection is used."""
@@ -775,11 +780,14 @@ async def install(self) -> None:
         await self.sys_addons.data.install(self.addon_store)
         await self.load()
 
-        if not self.path_data.is_dir():
-            _LOGGER.info(
-                "Creating Home Assistant add-on data folder %s", self.path_data
-            )
-            self.path_data.mkdir()
+        def setup_data():
+            if not self.path_data.is_dir():
+                _LOGGER.info(
+                    "Creating Home Assistant add-on data folder %s", self.path_data
+                )
+                self.path_data.mkdir()
+
+        await self.sys_run_in_executor(setup_data)
 
         # Setup/Fix AppArmor profile
         await self.install_apparmor()
@@ -818,14 +826,17 @@ async def uninstall(
 
         await self.unload()
 
-        # Remove config if present and requested
-        if self.addon_config_used and remove_config:
-            await remove_data(self.path_config)
+        def cleanup_config_and_audio():
+            # Remove config if present and requested
+            if self.addon_config_used and remove_config:
+                remove_data(self.path_config)
+
+            # Cleanup audio settings
+            if self.path_pulse.exists():
+                with suppress(OSError):
+                    self.path_pulse.unlink()
 
-        # Cleanup audio settings
-        if self.path_pulse.exists():
-            with suppress(OSError):
-                self.path_pulse.unlink()
+        await self.sys_run_in_executor(cleanup_config_and_audio)
 
         # Cleanup AppArmor profile
         with suppress(HostAppArmorError):
@@ -938,19 +949,20 @@ async def rebuild(self) -> asyncio.Task | None:
             )
         return out
 
-    def write_pulse(self) -> None:
+    async def write_pulse(self) -> None:
         """Write asound config to file and return True on success."""
         pulse_config = self.sys_plugins.audio.pulse_client(
             input_profile=self.audio_input, output_profile=self.audio_output
         )
 
-        # Cleanup wrong maps
-        if self.path_pulse.is_dir():
-            shutil.rmtree(self.path_pulse, ignore_errors=True)
+        def write_pulse_config():
+            # Cleanup wrong maps
+            if self.path_pulse.is_dir():
+                shutil.rmtree(self.path_pulse, ignore_errors=True)
+            self.path_pulse.write_text(pulse_config, encoding="utf-8")
 
-        # Write pulse config
         try:
-            self.path_pulse.write_text(pulse_config, encoding="utf-8")
+            await self.sys_run_in_executor(write_pulse_config)
         except OSError as err:
             if err.errno == errno.EBADMSG:
                 self.sys_resolution.unhealthy = UnhealthyReason.OSERROR_BAD_MESSAGE
@@ -965,7 +977,7 @@ def write_pulse(self) -> None:
     async def install_apparmor(self) -> None:
         """Install or Update AppArmor profile for Add-on."""
         exists_local = self.sys_host.apparmor.exists(self.slug)
-        exists_addon = self.path_apparmor.exists()
+        exists_addon = await self.sys_run_in_executor(self.path_apparmor.exists)
 
         # Nothing to do
         if not exists_local and not exists_addon:
@@ -1070,7 +1082,7 @@ async def start(self) -> asyncio.Task:
 
         # Sound
         if self.with_audio:
-            self.write_pulse()
+            await self.write_pulse()
 
         def _check_addon_config_dir():
             if self.path_config.is_dir():
@@ -1441,6 +1453,12 @@ def _extract_tarfile() -> tuple[TemporaryDirectory, dict[str, Any]]:
                 # Restore data and config
                 def _restore_data():
                     """Restore data and config."""
+                    _LOGGER.info("Restoring data and config for addon %s", self.slug)
+                    if self.path_data.is_dir():
+                        remove_data(self.path_data)
+                    if self.path_config.is_dir():
+                        remove_data(self.path_config)
+
                     temp_data = Path(tmp.name, "data")
                     if temp_data.is_dir():
                         shutil.copytree(temp_data, self.path_data, symlinks=True)
@@ -1453,12 +1471,6 @@ def _restore_data():
                     elif self.addon_config_used:
                         self.path_config.mkdir()
 
-                _LOGGER.info("Restoring data and config for addon %s", self.slug)
-                if self.path_data.is_dir():
-                    await remove_data(self.path_data)
-                if self.path_config.is_dir():
-                    await remove_data(self.path_config)
-
                 try:
                     await self.sys_run_in_executor(_restore_data)
                 except shutil.Error as err:
@@ -1468,7 +1480,7 @@ def _restore_data():
 
                 # Restore AppArmor
                 profile_file = Path(tmp.name, "apparmor.txt")
-                if profile_file.exists():
+                if await self.sys_run_in_executor(profile_file.exists):
                     try:
                         await self.sys_host.apparmor.load_profile(
                             self.slug, profile_file
@@ -1489,7 +1501,7 @@ def _restore_data():
                 if data[ATTR_STATE] == AddonState.STARTED:
                     wait_for_start = await self.start()
         finally:
-            tmp.cleanup()
+            await self.sys_run_in_executor(tmp.cleanup)
         _LOGGER.info("Finished restore for add-on %s", self.slug)
         return wait_for_start
 

supervisor/addons/build.py

@@ -81,13 +81,6 @@ def base_image(self) -> str:
             )
         return self._data[ATTR_BUILD_FROM][self.arch]
 
-    @property
-    def dockerfile(self) -> Path:
-        """Return Dockerfile path."""
-        if self.addon.path_location.joinpath(f"Dockerfile.{self.arch}").exists():
-            return self.addon.path_location.joinpath(f"Dockerfile.{self.arch}")
-        return self.addon.path_location.joinpath("Dockerfile")
-
     @property
     def squash(self) -> bool:
         """Return True or False if squash is active."""
@@ -103,25 +96,40 @@ def additional_labels(self) -> dict[str, str]:
         """Return additional Docker labels."""
         return self._data[ATTR_LABELS]
 
-    @property
-    def is_valid(self) -> bool:
+    def get_dockerfile(self) -> Path:
+        """Return Dockerfile path.
+
+        Must be run in executor.
+        """
+        if self.addon.path_location.joinpath(f"Dockerfile.{self.arch}").exists():
+            return self.addon.path_location.joinpath(f"Dockerfile.{self.arch}")
+        return self.addon.path_location.joinpath("Dockerfile")
+
+    async def is_valid(self) -> bool:
         """Return true if the build env is valid."""
-        try:
+
+        def build_is_valid() -> bool:
             return all(
                 [
                     self.addon.path_location.is_dir(),
-                    self.dockerfile.is_file(),
+                    self.get_dockerfile().is_file(),
                 ]
             )
+
+        try:
+            return await self.sys_run_in_executor(build_is_valid)
         except HassioArchNotFound:
             return False
 
     def get_docker_args(self, version: AwesomeVersion, image: str | None = None):
-        """Create a dict with Docker build arguments."""
+        """Create a dict with Docker build arguments.
+
+        Must be run in executor.
+        """
         args = {
             "path": str(self.addon.path_location),
             "tag": f"{image or self.addon.image}:{version!s}",
-            "dockerfile": str(self.dockerfile),
+            "dockerfile": str(self.get_dockerfile()),
             "pull": True,
             "forcerm": not self.sys_dev,
             "squash": self.squash,

supervisor/addons/utils.py

@@ -2,9 +2,9 @@
 
 from __future__ import annotations
 
-import asyncio
 import logging
 from pathlib import Path
+import subprocess
 from typing import TYPE_CHECKING
 
 from ..const import ROLE_ADMIN, ROLE_MANAGER, SECURITY_DISABLE, SECURITY_PROFILE
@@ -86,18 +86,20 @@ def rating_security(addon: AddonModel) -> int:
     return max(min(8, rating), 1)
 
 
-async def remove_data(folder: Path) -> None:
-    """Remove folder and reset privileged."""
+def remove_data(folder: Path) -> None:
+    """Remove folder and reset privileged.
+
+    Must be run in executor.
+    """
     try:
-        proc = await asyncio.create_subprocess_exec(
-            "rm", "-rf", str(folder), stdout=asyncio.subprocess.DEVNULL
+        subprocess.run(
+            ["rm", "-rf", str(folder)], stdout=subprocess.DEVNULL, text=True, check=True
         )
-
-        _, error_msg = await proc.communicate()
     except OSError as err:
         error_msg = str(err)
+    except subprocess.CalledProcessError as procerr:
+        error_msg = procerr.stderr.strip()
     else:
-        if proc.returncode == 0:
-            return
+        return
 
     _LOGGER.error("Can't remove Add-on Data: %s", error_msg)