Fix CTRL+C not working on Windows

Seems sending CTRL_C event on Windows to a new process group does not
work in general. It registers on cmd.exe and powershell.exe on its own,
however is ignored on powershell when ran within Windows Terminal or
Wezterm. Sending CTRL_BREAK seems to work, but on the later brings down
the shell itself.

However, Windows works differently with signals than Linux. On Linux
only the root process gets the signal. On Windows when a signal is sent
to a process all processes within that process group will get an
instance of that signal. This means that on Windows we don't need to
forward signals. All child automatically gets it. The only thing we do is
escalate the unanswered interrupt to process kill (there's no SIGTERM on
Windows).

Signed-off-by: Bernát Gábor <[email protected]>

Author: gaborbernat

docs/changelog/2159.bugfix.rst

@@ -0,0 +1 @@
+Fix ``CTRL+C`` is not stopping the process on Windows - by :user:`gaborbernat`.

src/tox/execute/local_sub_process/__init__.py

@@ -23,20 +23,16 @@
         from asyncio.windows_utils import Popen
     from signal import CTRL_C_EVENT as SIG_INTERRUPT
     from signal import SIGTERM
-    from subprocess import CREATE_NEW_PROCESS_GROUP
 
     from .read_via_thread_windows import ReadViaThreadWindows as ReadViaThread
 
-    CREATION_FLAGS = CREATE_NEW_PROCESS_GROUP  # a custom flag needed for Windows signal send ability (CTRL+C)
 else:  # pragma: win32 no cover
     from signal import SIGINT as SIG_INTERRUPT
     from signal import SIGKILL, SIGTERM
     from subprocess import Popen
 
     from .read_via_thread_unix import ReadViaThreadUnix as ReadViaThread
 
-    CREATION_FLAGS = 0
-
 
 IS_WIN = sys.platform == "win32"
 
@@ -67,9 +63,10 @@ def interrupt(self) -> None:
             msg = "requested interrupt of %d from %d, activate in %.2f"
             logging.warning(msg, to_pid, host_pid, self.options.suicide_timeout)
             if self.wait(self.options.suicide_timeout) is None:  # still alive -> INT
-                msg = "send signal %s to %d from %d with timeout %.2f"
-                logging.warning(msg, f"SIGINT({SIG_INTERRUPT})", to_pid, host_pid, self.options.interrupt_timeout)
-                self._process.send_signal(SIG_INTERRUPT)
+                if sys.platform != "win32":  # on Windows everyone in the same process group, so they got the message
+                    msg = "send signal %s to %d from %d with timeout %.2f"
+                    logging.warning(msg, f"SIGINT({SIG_INTERRUPT})", to_pid, host_pid, self.options.interrupt_timeout)
+                    self._process.send_signal(SIG_INTERRUPT)
                 if self.wait(self.options.interrupt_timeout) is None:  # still alive -> TERM # pragma: no branch
                     terminate_output = self.options.terminate_timeout
                     logging.warning(msg, f"SIGTERM({SIGTERM})", to_pid, host_pid, terminate_output)
@@ -198,7 +195,6 @@ def __enter__(self) -> ExecuteStatus:
                 stdin={StdinSource.USER: None, StdinSource.OFF: DEVNULL, StdinSource.API: PIPE}[self.request.stdin],
                 cwd=str(self.request.cwd),
                 env=self.request.env,
-                creationflags=CREATION_FLAGS,
             )
         except OSError as exception:
             return LocalSubprocessExecuteFailedStatus(self.options, self._out, self._err, exception.errno)

src/tox/session/cmd/run/common.py

@@ -191,13 +191,13 @@ def execute(state: State, max_workers: Optional[int], has_spinner: bool, live: b
     previous, has_previous = None, False
     try:
         spinner = ToxSpinner(has_spinner, state, len(to_run_list))
+        thread = Thread(
+            target=_queue_and_wait,
+            name="tox-interrupt",
+            args=(state, to_run_list, results, future_to_env, interrupt, done, max_workers, spinner, live),
+        )
+        thread.start()
         try:
-            thread = Thread(
-                target=_queue_and_wait,
-                name="tox-interrupt",
-                args=(state, to_run_list, results, future_to_env, interrupt, done, max_workers, spinner, live),
-            )
-            thread.start()
             thread.join()
         except KeyboardInterrupt:
             previous, has_previous = signal(SIGINT, Handlers.SIG_IGN), True