fix(updater): fail health check fast, signal busy during boot provisioning, keep overlay through UI restart

Author: gmmcosta15

BlocksScreen/lib/panels/widgets/MainWindow/updatePage.py

@@ -72,6 +72,7 @@ def __init__(self) -> None:
         self._update_avail: bool = False
         self._post_update_status_pending: bool = False
         self._overlay_shown: bool = False
+        self._restart_pending: bool = False
         self._elapsed_time_seconds: int = 0
         self._elapsed_timer: QtCore.QTimer = QtCore.QTimer(self)
         self._elapsed_timer.setSingleShot(False)
@@ -335,7 +336,7 @@ def handle_status_ready(self, json_str: str) -> None:
         self._update_avail = _update_avail
         if not self._busy:
             self.show_loading(False)
-            if self._post_update_status_pending:
+            if self._post_update_status_pending and not self._restart_pending:
                 _log.debug("status_ready: emitting call_load_panel(False)")
                 self.call_load_panel.emit(False, "", False)
                 self._post_update_status_pending = False
@@ -350,6 +351,7 @@ def handle_busy_changed(self, busy: bool) -> None:
         self._busy = busy
         self.show_loading(busy)
         if busy:
+            self._restart_pending = False
             self._elapsed_time_seconds = 0
             self._elapsed_timer.start()
             self._busy_timeout_timer.start()
@@ -364,11 +366,21 @@ def handle_busy_changed(self, busy: bool) -> None:
             self._progress_label.hide()
             self._cancel_btn.hide()
             self.update_all_btn.setEnabled(True)
-            if self._overlay_shown:
+            if self._restart_pending:
+                # Keep the overlay up: SIGTERM is imminent, MainWindow would flash.
+                QtCore.QTimer.singleShot(15000, self._dismiss_after_restart_grace)
+            elif self._overlay_shown:
                 self._overlay_shown = False
                 self.call_load_panel.emit(False, "", False)
             self._request_status_debounced()
 
+    def _dismiss_after_restart_grace(self) -> None:
+        """Drop the overlay if the expected UI restart never came."""
+        if self._restart_pending and not self._busy:
+            self._restart_pending = False
+            self._overlay_shown = False
+            self.call_load_panel.emit(False, "", False)
+
     @QtCore.pyqtSlot(name="on-update-all-clicked")
     def on_update_all_clicked(self) -> None:
         """Guard against updates during a print or with hot heaters; otherwise show confirm dialog."""
@@ -425,6 +437,8 @@ def handle_step_complete(self, name: str, step: int, total: int) -> None:
         if self._busy_timeout_timer.isActive():
             self._busy_timeout_timer.start()
         self._overlay_shown = True
+        # BlocksScreen's last step restarts this very process.
+        self._restart_pending = name == "BlocksScreen" and step == total
         overlay_msg = f"{name}: {label}"
         self._progress_label.setText(f"Step {step}/{total}")
         self.call_load_panel.emit(True, overlay_msg, False)

updater/dbus_service.py

@@ -195,7 +195,7 @@ async def _periodic_status_check(self) -> None:
         while True:
             try:
                 await self._emit_status()
-                if await self._svc.provision_missing():
+                if await self._svc.provision_missing(self._set_busy):
                     await self._emit_status()  # reflect freshly-installed components
             except Exception as exc:  # noqa: BLE001
                 _log.error("periodic_check failed: %s", exc)

updater/executor.py

@@ -1034,13 +1034,22 @@ def _http_probe(url: str) -> bool:
         conn.close()
 
 
-async def wait_for_http_ready(url: str, timeout: float = 120.0) -> bool:
-    """Poll a component's loopback health URL until it returns 2xx or timeout."""
+async def wait_for_http_ready(
+    url: str, timeout: float = 120.0, *, service: str | None = None
+) -> bool:
+    """Poll a health URL until 2xx or timeout; fail fast if `service` leaves active."""
     deadline = asyncio.get_running_loop().time() + timeout
     while True:
         if await asyncio.to_thread(_http_probe, url):
             logger.info("health check ok: %s", url)
             return True
+        # A crash-looping unit is 'activating', never 'active': don't wait out the timeout.
+        if (
+            service
+            and not (await _run([SYSTEMCTL, "is-active", service], timeout=10.0))[0]
+        ):
+            logger.warning("service %r left active during health check", service)
+            return False
         if asyncio.get_running_loop().time() >= deadline:
             logger.warning("health check timed out after %.0fs: %s", timeout, url)
             return False

updater/service.py

@@ -476,8 +476,10 @@ async def _filter_dead_branch_batch(self, batch: list[ComponentConfig]) -> bool:
                 )
         return ok
 
-    async def provision_missing(self) -> bool:
-        """Clone absent install_if_missing components at boot (no manual update)."""
+    async def provision_missing(
+        self, on_busy: Callable[[bool], None] | None = None
+    ) -> bool:
+        """Clone absent install_if_missing components at boot; on_busy brackets the work."""
         missing = [
             c
             for c in self._components
@@ -492,10 +494,16 @@ async def provision_missing(self) -> bool:
             if not acquired:
                 self._log.info("provision_missing: update in progress, deferring")
                 return False
-            for c in missing:
-                if c.path is None or not c.path.exists():  # recheck under lock
-                    await self._provision_component(c)
-                    provisioned = True
+            if on_busy:
+                on_busy(True)  # UI shows step_complete only while busy
+            try:
+                for c in missing:
+                    if c.path is None or not c.path.exists():  # recheck under lock
+                        await self._provision_component(c)
+                        provisioned = True
+            finally:
+                if on_busy:
+                    on_busy(False)
         return provisioned
 
     async def _preflight_fetch(
@@ -1982,7 +1990,7 @@ async def _restart_one(self, service: str, health_url: str | None = None) -> boo
         if not await wait_for_service_active(service, timeout=90.0):
             self._log.error("%s did not become active after restart", service)
             return False
-        if health_url and not await wait_for_http_ready(health_url):
+        if health_url and not await wait_for_http_ready(health_url, service=service):
             self._log.error("%s active but health check failed", service)
             return False
         self._log.info("%s active after restart", service)