Consolidate Supervisor auto-update into updater reload task (#6705)

* Consolidate Supervisor auto-update into updater reload task

The separate _update_supervisor task (24h interval) was redundant since
_reload_updater (previously ~7.5h interval) already triggered the same
update when a new version was found. This meant Supervisor updates were
effectively checked every 7.5h, undermining the intent of #6633 and
#6638 to reduce update frequency and registry pressure.

Merge the two code paths into one: _reload_updater now directly calls
_auto_update_supervisor (with the same job conditions) when a new
version is detected. The reload interval is increased from ~7.5h to 24h
to match the originally intended update cadence.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* Add regression test for scheduled supervisor auto-update

Verify that the scheduled reload_updater task triggers exactly one
supervisor update when a new version is available. Uses event loop
time patching to simulate the 24h interval firing.

This guards against the previous bug where a separate _update_supervisor
task ran on its own schedule, causing duplicate update attempts.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: agners

supervisor/misc/tasks.py

@@ -31,7 +31,6 @@
 HASS_WATCHDOG_MAX_API_ATTEMPTS = 2
 HASS_WATCHDOG_MAX_REANIMATE_ATTEMPTS = 5
 
-RUN_UPDATE_SUPERVISOR = 86400  # 24h
 RUN_UPDATE_ADDONS = 57600
 RUN_UPDATE_CLI = 43200  # 12h, staggered +2min per plugin
 RUN_UPDATE_DNS = 43320
@@ -42,7 +41,7 @@
 RUN_RELOAD_ADDONS = 10800
 RUN_RELOAD_BACKUPS = 72000
 RUN_RELOAD_HOST = 7600
-RUN_RELOAD_UPDATER = 27100
+RUN_RELOAD_UPDATER = 86400  # 24h
 RUN_RELOAD_INGRESS = 930
 RUN_RELOAD_MOUNTS = 900
 
@@ -73,7 +72,6 @@ async def load(self):
         """Add Tasks to scheduler."""
         # Update
         self.sys_scheduler.register_task(self._update_addons, RUN_UPDATE_ADDONS)
-        self.sys_scheduler.register_task(self._update_supervisor, RUN_UPDATE_SUPERVISOR)
         self.sys_scheduler.register_task(self._update_cli, RUN_UPDATE_CLI)
         self.sys_scheduler.register_task(self._update_dns, RUN_UPDATE_DNS)
         self.sys_scheduler.register_task(self._update_audio, RUN_UPDATE_AUDIO)
@@ -164,34 +162,6 @@ async def _update_addons(self):
                     err,
                 )
 
-    @Job(
-        name="tasks_update_supervisor",
-        conditions=[
-            JobCondition.AUTO_UPDATE,
-            JobCondition.FREE_SPACE,
-            JobCondition.HEALTHY,
-            JobCondition.INTERNET_HOST,
-            JobCondition.OS_SUPPORTED,
-            JobCondition.RUNNING,
-            JobCondition.ARCHITECTURE_SUPPORTED,
-        ],
-        concurrency=JobConcurrency.REJECT,
-    )
-    async def _update_supervisor(self):
-        """Check and run update of Supervisor Supervisor."""
-        if not self.sys_supervisor.need_update:
-            return
-
-        _LOGGER.info(
-            "Found new Supervisor version %s, updating",
-            self.sys_supervisor.latest_version,
-        )
-
-        # Errors are logged by the exceptions, we can't really do something
-        # if an update fails here.
-        with suppress(SupervisorUpdateError):
-            await self.sys_supervisor.update()
-
     async def _watchdog_homeassistant_api(self):
         """Create scheduler task for monitoring running state of API.
 
@@ -390,9 +360,34 @@ async def _reload_updater(self) -> None:
         """Check for new versions of Home Assistant, Supervisor, OS, etc."""
         await self.sys_updater.reload()
 
-        # If there's a new version of supervisor, start update immediately
+        # If there's a new version of supervisor, update immediately
         if self.sys_supervisor.need_update:
-            await self._update_supervisor()
+            await self._auto_update_supervisor()
+
+    @Job(
+        name="tasks_update_supervisor",
+        conditions=[
+            JobCondition.AUTO_UPDATE,
+            JobCondition.FREE_SPACE,
+            JobCondition.HEALTHY,
+            JobCondition.INTERNET_HOST,
+            JobCondition.OS_SUPPORTED,
+            JobCondition.RUNNING,
+            JobCondition.ARCHITECTURE_SUPPORTED,
+        ],
+        concurrency=JobConcurrency.REJECT,
+    )
+    async def _auto_update_supervisor(self):
+        """Auto update Supervisor if enabled."""
+        if not self.sys_supervisor.need_update:
+            return
+
+        _LOGGER.info(
+            "Found new Supervisor version %s, updating",
+            self.sys_supervisor.latest_version,
+        )
+        with suppress(SupervisorUpdateError):
+            await self.sys_supervisor.update()
 
     @Job(name="tasks_core_backup_cleanup", conditions=[JobCondition.HEALTHY])
     async def _core_backup_cleanup(self) -> None:

tests/misc/test_tasks.py

@@ -1,5 +1,6 @@
 """Test scheduled tasks."""
 
+import asyncio
 from collections.abc import AsyncGenerator
 from shutil import copy
 from unittest.mock import AsyncMock, Mock, PropertyMock, patch
@@ -244,6 +245,60 @@ async def test_update_dns_skipped_when_auto_update_disabled(
         update.assert_not_called()
 
 
+@pytest.mark.usefixtures("no_job_throttle", "supervisor_internet")
+async def test_scheduled_reload_updater_triggers_one_supervisor_update(
+    tasks: Tasks, coresys: CoreSys, mock_update_data: MockResponse
+):
+    """Test scheduled reload updater triggers exactly one supervisor update.
+
+    Regression test: previously _update_supervisor ran on a separate schedule
+    in addition to being called from _reload_updater, causing duplicate updates.
+    Now only _reload_updater triggers the supervisor auto-update.
+    """
+    coresys.hardware.disk.get_disk_free_space = lambda x: 5000
+    await coresys.core.set_state(CoreState.RUNNING)
+
+    # Make version data show a newer supervisor version
+    version_data = await mock_update_data.text()
+    mock_update_data.update_text(version_data.replace("2024.10.0", "2024.10.1"))
+
+    with (
+        patch.object(
+            Supervisor,
+            "version",
+            new=PropertyMock(return_value=AwesomeVersion("2024.10.0")),
+        ),
+        patch.object(Supervisor, "update") as update,
+    ):
+        await tasks.load()
+        update.assert_not_called()
+
+        # Advance the event loop clock by 24h+ so scheduled tasks fire.
+        # Patching loop.time makes all call_later callbacks appear due;
+        # a tiny real sleep lets _run_once re-evaluate and execute them.
+        loop = asyncio.get_event_loop()
+        original_time = loop.time
+        loop.time = lambda: original_time() + 86401
+
+        try:
+            # Busy-wait until call_later callbacks fire and create jobs
+            while not any(t.job and not t.job.done() for t in coresys.scheduler._tasks):
+                await asyncio.sleep(0)
+
+            # Wait for all scheduler-created tasks to finish
+            pending = [
+                t.job for t in coresys.scheduler._tasks if t.job and not t.job.done()
+            ]
+            await asyncio.gather(*pending)
+
+            # Verify update was triggered exactly once
+            update.assert_called_once()
+        finally:
+            loop.time = original_time
+
+    await coresys.scheduler.shutdown()
+
+
 @pytest.mark.usefixtures("tmp_supervisor_data")
 async def test_update_addons_auto_update_success(
     tasks: Tasks,