Advance Welcome installers only after worker thread termination

Author: Fook Me

packages/shadowfetch-defaults/tests/test_welcome_worker_lifetime.py

@@ -0,0 +1,32 @@
+"""Exercise real Qt thread completion, including a delayed return from run()."""
+import ast,os,pathlib,signal,subprocess,sys,threading,time,unittest
+try:
+ from PyQt6.QtCore import QCoreApplication,QThread,pyqtSignal,pyqtSlot
+except ImportError:
+ raise unittest.SkipTest("PyQt6 is required for real worker lifetime tests")
+SOURCE=pathlib.Path(__file__).resolve().parents[3]/'packages/shadowfetch-welcome/src/shadowfetch-welcome'
+nodes=[n for n in ast.parse(SOURCE.read_text()).body if isinstance(n,ast.ClassDef) and n.name in ('CommandWorker','StreamingCommandWorker')]
+namespace=dict(globals(),strip_terminal_escapes=lambda s:s)
+exec(compile(ast.Module(body=nodes,type_ignores=[]),str(SOURCE),'exec'),namespace)
+class LifetimeTests(unittest.TestCase):
+ def test_completion_only_after_thread_termination(self):
+  app=QCoreApplication.instance() or QCoreApplication([])
+  for name in ['CommandWorker','StreamingCommandWorker']:
+   for exit_code in [0,7]:
+    with self.subTest(worker=name,exit_code=exit_code):
+     base=namespace[name]
+     class DelayedReturn(base):
+      def run(self):
+       super().run()
+       time.sleep(.08)
+     command=[sys.executable,'-c','raise SystemExit('+str(exit_code)+')']
+     worker=DelayedReturn([command] if name=='CommandWorker' else command)
+     results=[]
+     event=getattr(worker,'completed',worker.finished)
+     event.connect(lambda code,w=worker:results.append((code,w.isRunning())))
+     worker.start();deadline=time.monotonic()+5
+     while (not results or worker.isRunning()) and time.monotonic()<deadline:
+      app.processEvents();time.sleep(.001)
+     worker.wait(1000);app.processEvents()
+     self.assertEqual([(exit_code,False)],results)
+if __name__=='__main__':unittest.main()

packages/shadowfetch-welcome/src/shadowfetch-welcome

@@ -638,15 +638,22 @@ def hwscan_has_nvidia(scan: dict) -> bool:
 class CommandWorker(QThread):
     """Run cancellable argv commands off the UI thread."""
     progress = pyqtSignal(str)
-    finished = pyqtSignal(int)
+    completed = pyqtSignal(int)
 
     def __init__(self, commands):
         super().__init__()
         self.commands = commands
         self.process = None
+        self.returncode = 1
+        self.finished.connect(self._publish_result)
         self.cancel_requested = False
         self.cancel_escalation_started = False
 
+    @pyqtSlot()
+    def _publish_result(self):
+        # QThread.finished runs after run() returns; advancing setup is now safe.
+        self.completed.emit(self.returncode)
+
     def cancel(self):
         self.cancel_requested = True
         process = self.process
@@ -713,21 +720,28 @@ class CommandWorker(QThread):
                 self.progress.emit(f"  ! {e}")
             finally:
                 self.process = None
-        self.finished.emit(rc)
+        self.returncode = rc
 
 
 class StreamingCommandWorker(QThread):
     """Run one long command and stream its combined output to the UI."""
     progress = pyqtSignal(str)
-    finished = pyqtSignal(int)
+    completed = pyqtSignal(int)
 
     def __init__(self, command):
         super().__init__()
         self.command = command
         self.process = None
+        self.returncode = 1
+        self.finished.connect(self._publish_result)
         self.cancel_requested = False
         self.cancel_escalation_started = False
 
+    @pyqtSlot()
+    def _publish_result(self):
+        # QThread.finished runs after run() returns; advancing setup is now safe.
+        self.completed.emit(self.returncode)
+
     def cancel(self):
         self.cancel_requested = True
         process = self.process
@@ -774,7 +788,7 @@ class StreamingCommandWorker(QThread):
                 self._begin_cancel(process)
         except OSError as error:
             self.progress.emit(f"Could not start setup: {error}")
-            self.finished.emit(1)
+            self.returncode = 1
             return
         assert process.stdout is not None
         for line in iter(process.stdout.readline, ""):
@@ -784,7 +798,7 @@ class StreamingCommandWorker(QThread):
         process.stdout.close()
         code = process.wait()
         self.process = None
-        self.finished.emit(130 if self.cancel_requested else code)
+        self.returncode = 130 if self.cancel_requested else code
 
 
 class Card(QFrame):
@@ -1184,7 +1198,7 @@ class InstallPanel(QWidget):
             "system back atomically and asks for a reboot when done.")
         self._restore_worker = CommandWorker(
             [["pkexec", PHOENIX_RESTORE, str(self.point)]])
-        self._restore_worker.finished.connect(self._restored)
+        self._restore_worker.completed.connect(self._restored)
         self._restore_worker.start()
 
     def _restored(self, rc):
@@ -1612,7 +1626,7 @@ class IgnitionFlow(QWidget):
 
     def _state_call(self, args, on_done):
         self._state_worker = CommandWorker([["pkexec", STATE_HELPER] + args])
-        self._state_worker.finished.connect(on_done)
+        self._state_worker.completed.connect(on_done)
         self._state_worker.start()
 
     # -- result --
@@ -2685,7 +2699,7 @@ class InstallPage(QWidget):
 
         self.worker = CommandWorker(commands)
         self.worker.progress.connect(self.log.setText)
-        self.worker.finished.connect(self._on_done)
+        self.worker.completed.connect(self._on_done)
         self.worker.start()
 
     def _on_done(self, rc):
@@ -2758,7 +2772,7 @@ class InstallPage(QWidget):
         command.extend(["setup", "--yes", "--no-open"])
         self.coding_agent_worker = StreamingCommandWorker(command)
         self.coding_agent_worker.progress.connect(self._coding_agent_progress)
-        self.coding_agent_worker.finished.connect(self._coding_agent_done)
+        self.coding_agent_worker.completed.connect(self._coding_agent_done)
         self.coding_agent_worker.start()
 
     def _coding_agent_progress(self, line):