Move write of core state to executor (home-assistant#5720)

Author: mdegat01

supervisor/backups/manager.py

@@ -496,7 +496,7 @@ async def _do_backup(
         addon_start_tasks: list[Awaitable[None]] | None = None
 
         try:
-            self.sys_core.state = CoreState.FREEZE
+            await self.sys_core.set_state(CoreState.FREEZE)
 
             async with backup.create():
                 # HomeAssistant Folder is for v1
@@ -549,7 +549,7 @@ async def _do_backup(
 
             return backup
         finally:
-            self.sys_core.state = CoreState.RUNNING
+            await self.sys_core.set_state(CoreState.RUNNING)
 
     @Job(
         name="backup_manager_full_backup",
@@ -808,7 +808,7 @@ async def do_restore_full(
             )
 
         _LOGGER.info("Full-Restore %s start", backup.slug)
-        self.sys_core.state = CoreState.FREEZE
+        await self.sys_core.set_state(CoreState.FREEZE)
 
         try:
             # Stop Home-Assistant / Add-ons
@@ -823,7 +823,7 @@ async def do_restore_full(
                 location=location,
             )
         finally:
-            self.sys_core.state = CoreState.RUNNING
+            await self.sys_core.set_state(CoreState.RUNNING)
 
         if success:
             _LOGGER.info("Full-Restore %s done", backup.slug)
@@ -878,7 +878,7 @@ async def do_restore_partial(
             )
 
         _LOGGER.info("Partial-Restore %s start", backup.slug)
-        self.sys_core.state = CoreState.FREEZE
+        await self.sys_core.set_state(CoreState.FREEZE)
 
         try:
             success = await self._do_restore(
@@ -890,7 +890,7 @@ async def do_restore_partial(
                 location=location,
             )
         finally:
-            self.sys_core.state = CoreState.RUNNING
+            await self.sys_core.set_state(CoreState.RUNNING)
 
         if success:
             _LOGGER.info("Partial-Restore %s done", backup.slug)
@@ -904,7 +904,7 @@ async def do_restore_partial(
     )
     async def freeze_all(self, timeout: float = DEFAULT_FREEZE_TIMEOUT) -> None:
         """Freeze system to prepare for an external backup such as an image snapshot."""
-        self.sys_core.state = CoreState.FREEZE
+        await self.sys_core.set_state(CoreState.FREEZE)
 
         # Determine running addons
         installed = self.sys_addons.installed.copy()
@@ -957,7 +957,7 @@ async def _thaw_all(
                 if task
             ]
         finally:
-            self.sys_core.state = CoreState.RUNNING
+            await self.sys_core.set_state(CoreState.RUNNING)
             self._thaw_event.clear()
             self._thaw_task = None
 

supervisor/core.py

@@ -5,6 +5,7 @@
 from contextlib import suppress
 from datetime import timedelta
 import logging
+from typing import Self
 
 from .const import (
     ATTR_STARTUP,
@@ -39,7 +40,6 @@ def __init__(self, coresys: CoreSys):
         """Initialize Supervisor object."""
         self.coresys: CoreSys = coresys
         self._state: CoreState = CoreState.INITIALIZE
-        self._write_run_state(self._state)
         self.exit_code: int = 0
 
     @property
@@ -57,32 +57,38 @@ def healthy(self) -> bool:
         """Return true if the installation is healthy."""
         return len(self.sys_resolution.unhealthy) == 0
 
-    def _write_run_state(self, new_state: CoreState):
+    async def _write_run_state(self):
         """Write run state for s6 service supervisor."""
         try:
-            RUN_SUPERVISOR_STATE.write_text(str(new_state), encoding="utf-8")
+            await self.sys_run_in_executor(
+                RUN_SUPERVISOR_STATE.write_text, str(self._state), encoding="utf-8"
+            )
         except OSError as err:
             _LOGGER.warning(
-                "Can't update the Supervisor state to %s: %s", new_state, err
+                "Can't update the Supervisor state to %s: %s", self._state, err
             )
 
-    @state.setter
-    def state(self, new_state: CoreState) -> None:
+    async def post_init(self) -> Self:
+        """Post init actions that must be done in event loop."""
+        await self._write_run_state()
+        return self
+
+    async def set_state(self, new_state: CoreState) -> None:
         """Set core into new state."""
         if self._state == new_state:
             return
 
-        self._write_run_state(new_state)
         self._state = new_state
+        await self._write_run_state()
 
         # Don't attempt to notify anyone on CLOSE as we're about to stop the event loop
-        if new_state != CoreState.CLOSE:
-            self.sys_bus.fire_event(BusEvent.SUPERVISOR_STATE_CHANGE, new_state)
+        if self._state != CoreState.CLOSE:
+            self.sys_bus.fire_event(BusEvent.SUPERVISOR_STATE_CHANGE, self._state)
 
             # These will be received by HA after startup has completed which won't make sense
-            if new_state not in STARTING_STATES:
+            if self._state not in STARTING_STATES:
                 self.sys_homeassistant.websocket.supervisor_update_event(
-                    "info", {"state": new_state}
+                    "info", {"state": self._state}
                 )
 
     async def connect(self):
@@ -116,7 +122,7 @@ async def connect(self):
 
     async def setup(self):
         """Start setting up supervisor orchestration."""
-        self.state = CoreState.SETUP
+        await self.set_state(CoreState.SETUP)
 
         # Check internet on startup
         await self.sys_supervisor.check_connectivity()
@@ -196,7 +202,7 @@ async def setup(self):
 
     async def start(self):
         """Start Supervisor orchestration."""
-        self.state = CoreState.STARTUP
+        await self.set_state(CoreState.STARTUP)
 
         # Check if system is healthy
         if not self.supported:
@@ -282,7 +288,7 @@ async def start(self):
             self.sys_create_task(self.sys_updater.reload())
             self.sys_create_task(self.sys_resolution.healthcheck())
 
-            self.state = CoreState.RUNNING
+            await self.set_state(CoreState.RUNNING)
             self.sys_homeassistant.websocket.supervisor_update_event(
                 "supervisor", {ATTR_STARTUP: "complete"}
             )
@@ -297,7 +303,7 @@ async def stop(self):
             return
 
         # don't process scheduler anymore
-        self.state = CoreState.STOPPING
+        await self.set_state(CoreState.STOPPING)
 
         # Stage 1
         try:
@@ -332,15 +338,15 @@ async def stop(self):
         except TimeoutError:
             _LOGGER.warning("Stage 2: Force Shutdown!")
 
-        self.state = CoreState.CLOSE
+        await self.set_state(CoreState.CLOSE)
         _LOGGER.info("Supervisor is down - %d", self.exit_code)
         self.sys_loop.stop()
 
     async def shutdown(self, *, remove_homeassistant_container: bool = False):
         """Shutdown all running containers in correct order."""
         # don't process scheduler anymore
         if self.state == CoreState.RUNNING:
-            self.state = CoreState.SHUTDOWN
+            await self.set_state(CoreState.SHUTDOWN)
 
         # Shutdown Application Add-ons, using Home Assistant API
         await self.sys_addons.shutdown(AddonStartup.APPLICATION)

tests/api/middleware/test_security.py

@@ -58,7 +58,7 @@ async def api_token_validation(aiohttp_client, coresys: CoreSys) -> TestClient:
 @pytest.mark.asyncio
 async def test_api_security_system_initialize(api_system: TestClient, coresys: CoreSys):
     """Test security."""
-    coresys.core.state = CoreState.INITIALIZE
+    await coresys.core.set_state(CoreState.INITIALIZE)
 
     resp = await api_system.get("/supervisor/ping")
     result = await resp.json()
@@ -69,7 +69,7 @@ async def test_api_security_system_initialize(api_system: TestClient, coresys: C
 @pytest.mark.asyncio
 async def test_api_security_system_setup(api_system: TestClient, coresys: CoreSys):
     """Test security."""
-    coresys.core.state = CoreState.SETUP
+    await coresys.core.set_state(CoreState.SETUP)
 
     resp = await api_system.get("/supervisor/ping")
     result = await resp.json()
@@ -80,7 +80,7 @@ async def test_api_security_system_setup(api_system: TestClient, coresys: CoreSy
 @pytest.mark.asyncio
 async def test_api_security_system_running(api_system: TestClient, coresys: CoreSys):
     """Test security."""
-    coresys.core.state = CoreState.RUNNING
+    await coresys.core.set_state(CoreState.RUNNING)
 
     resp = await api_system.get("/supervisor/ping")
     assert resp.status == 200
@@ -89,7 +89,7 @@ async def test_api_security_system_running(api_system: TestClient, coresys: Core
 @pytest.mark.asyncio
 async def test_api_security_system_startup(api_system: TestClient, coresys: CoreSys):
     """Test security."""
-    coresys.core.state = CoreState.STARTUP
+    await coresys.core.set_state(CoreState.STARTUP)
 
     resp = await api_system.get("/supervisor/ping")
     assert resp.status == 200

tests/api/test_backups.py

@@ -137,7 +137,7 @@ async def test_backup_to_location(
     await coresys.mounts.create_mount(mount)
     coresys.mounts.default_backup_mount = mount
 
-    coresys.core.state = CoreState.RUNNING
+    await coresys.core.set_state(CoreState.RUNNING)
     coresys.hardware.disk.get_disk_free_space = lambda x: 5000
     resp = await api_client.post(
         "/backups/new/full",
@@ -178,7 +178,7 @@ async def test_backup_to_default(api_client: TestClient, coresys: CoreSys):
     await coresys.mounts.create_mount(mount)
     coresys.mounts.default_backup_mount = mount
 
-    coresys.core.state = CoreState.RUNNING
+    await coresys.core.set_state(CoreState.RUNNING)
     coresys.hardware.disk.get_disk_free_space = lambda x: 5000
     resp = await api_client.post(
         "/backups/new/full",
@@ -196,7 +196,7 @@ async def test_api_freeze_thaw(
     api_client: TestClient, coresys: CoreSys, ha_ws_client: AsyncMock
 ):
     """Test manual freeze and thaw for external backup via API."""
-    coresys.core.state = CoreState.RUNNING
+    await coresys.core.set_state(CoreState.RUNNING)
     coresys.hardware.disk.get_disk_free_space = lambda x: 5000
     ha_ws_client.ha_version = AwesomeVersion("2022.1.0")
 
@@ -230,7 +230,7 @@ async def test_api_backup_exclude_database(
     exclude_db_setting: bool,
 ):
     """Test backups exclude the database when specified."""
-    coresys.core.state = CoreState.RUNNING
+    await coresys.core.set_state(CoreState.RUNNING)
     coresys.hardware.disk.get_disk_free_space = lambda x: 5000
     coresys.homeassistant.version = AwesomeVersion("2023.09.0")
     coresys.homeassistant.backups_exclude_database = exclude_db_setting
@@ -278,7 +278,7 @@ async def test_api_backup_restore_background(
     tmp_supervisor_data: Path,
 ):
     """Test background option on backup/restore APIs."""
-    coresys.core.state = CoreState.RUNNING
+    await coresys.core.set_state(CoreState.RUNNING)
     coresys.hardware.disk.get_disk_free_space = lambda x: 5000
     coresys.homeassistant.version = AwesomeVersion("2023.09.0")
     (tmp_supervisor_data / "addons/local").mkdir(parents=True)
@@ -364,7 +364,7 @@ async def test_api_backup_errors(
     tmp_supervisor_data: Path,
 ):
     """Test error reporting in backup job."""
-    coresys.core.state = CoreState.RUNNING
+    await coresys.core.set_state(CoreState.RUNNING)
     coresys.hardware.disk.get_disk_free_space = lambda x: 5000
     coresys.homeassistant.version = AwesomeVersion("2023.09.0")
     (tmp_supervisor_data / "addons/local").mkdir(parents=True)
@@ -435,15 +435,15 @@ async def test_api_backup_errors(
 
 async def test_backup_immediate_errors(api_client: TestClient, coresys: CoreSys):
     """Test backup errors that return immediately even in background mode."""
-    coresys.core.state = CoreState.FREEZE
+    await coresys.core.set_state(CoreState.FREEZE)
     resp = await api_client.post(
         "/backups/new/full",
         json={"name": "Test", "background": True},
     )
     assert resp.status == 400
     assert "freeze" in (await resp.json())["message"]
 
-    coresys.core.state = CoreState.RUNNING
+    await coresys.core.set_state(CoreState.RUNNING)
     coresys.hardware.disk.get_disk_free_space = lambda x: 0.5
     resp = await api_client.post(
         "/backups/new/partial",
@@ -460,7 +460,7 @@ async def test_restore_immediate_errors(
     mock_partial_backup: Backup,
 ):
     """Test restore errors that return immediately even in background mode."""
-    coresys.core.state = CoreState.RUNNING
+    await coresys.core.set_state(CoreState.RUNNING)
     coresys.hardware.disk.get_disk_free_space = lambda x: 5000
 
     resp = await api_client.post(
@@ -634,7 +634,7 @@ async def test_backup_to_multiple_locations(
     inputs: dict[str, Any],
 ):
     """Test making a backup to multiple locations."""
-    coresys.core.state = CoreState.RUNNING
+    await coresys.core.set_state(CoreState.RUNNING)
     coresys.hardware.disk.get_disk_free_space = lambda x: 5000
 
     resp = await api_client.post(
@@ -669,7 +669,7 @@ async def test_backup_with_extras(
     inputs: dict[str, Any],
 ):
     """Test backup including extra metdata."""
-    coresys.core.state = CoreState.RUNNING
+    await coresys.core.set_state(CoreState.RUNNING)
     coresys.hardware.disk.get_disk_free_space = lambda x: 5000
 
     resp = await api_client.post(
@@ -909,7 +909,7 @@ async def test_partial_backup_all_addons(
     install_addon_ssh: Addon,
 ):
     """Test backup including extra metdata."""
-    coresys.core.state = CoreState.RUNNING
+    await coresys.core.set_state(CoreState.RUNNING)
     coresys.hardware.disk.get_disk_free_space = lambda x: 5000
 
     with patch.object(Backup, "store_addons") as store_addons:
@@ -928,7 +928,7 @@ async def test_restore_backup_from_location(
     local_location: str | None,
 ):
     """Test restoring a backup from a specific location."""
-    coresys.core.state = CoreState.RUNNING
+    await coresys.core.set_state(CoreState.RUNNING)
     coresys.hardware.disk.get_disk_free_space = lambda x: 5000
 
     # Make a backup and a file to test with
@@ -1000,7 +1000,7 @@ async def test_restore_backup_unencrypted_after_encrypted(
     # We punt the ball on this one for this PR since this is a rare edge case.
     backup.restore_dockerconfig = MagicMock()
 
-    coresys.core.state = CoreState.RUNNING
+    await coresys.core.set_state(CoreState.RUNNING)
     coresys.hardware.disk.get_disk_free_space = lambda x: 5000
 
     # Restore encrypted backup
@@ -1050,7 +1050,7 @@ async def test_restore_homeassistant_adds_env(
 ):
     """Test restoring home assistant from backup adds env to container."""
     event = asyncio.Event()
-    coresys.core.state = CoreState.RUNNING
+    await coresys.core.set_state(CoreState.RUNNING)
     coresys.hardware.disk.get_disk_free_space = lambda x: 5000
     coresys.homeassistant.version = AwesomeVersion("2025.1.0")
     backup = await coresys.backups.do_backup_full()
@@ -1134,7 +1134,7 @@ async def test_protected_backup(
     api_client: TestClient, coresys: CoreSys, backup_type: str, options: dict[str, Any]
 ):
     """Test creating a protected backup."""
-    coresys.core.state = CoreState.RUNNING
+    await coresys.core.set_state(CoreState.RUNNING)
     coresys.hardware.disk.get_disk_free_space = lambda x: 5000
 
     resp = await api_client.post(
@@ -1246,7 +1246,7 @@ async def test_missing_file_removes_location_from_cache(
     backup_file: str,
 ):
     """Test finding a missing file removes the location from cache."""
-    coresys.core.state = CoreState.RUNNING
+    await coresys.core.set_state(CoreState.RUNNING)
     coresys.hardware.disk.get_disk_free_space = lambda x: 5000
 
     backup_file = get_fixture_path(backup_file)
@@ -1305,7 +1305,7 @@ async def test_missing_file_removes_backup_from_cache(
     backup_file: str,
 ):
     """Test finding a missing file removes the backup from cache if its the only one."""
-    coresys.core.state = CoreState.RUNNING
+    await coresys.core.set_state(CoreState.RUNNING)
     coresys.hardware.disk.get_disk_free_space = lambda x: 5000
 
     backup_file = get_fixture_path(backup_file)
@@ -1331,7 +1331,7 @@ async def test_immediate_list_after_missing_file_restore(
     api_client: TestClient, coresys: CoreSys
 ):
     """Test race with reload for missing file on restore does not error."""
-    coresys.core.state = CoreState.RUNNING
+    await coresys.core.set_state(CoreState.RUNNING)
     coresys.hardware.disk.get_disk_free_space = lambda x: 5000
 
     backup_file = get_fixture_path("backup_example.tar")