Bound the remote default-branch lookup on every platform

GitPython's kill_after_timeout is rejected on Windows and relies on
ps --ppid, which macOS lacks. It also leaves git-remote-https holding the
output pipe after the parent dies, so a stalled remote blocked startup past
the timeout.

Run git ls-remote in its own process group and kill the whole group on
timeout, with taskkill /T on Windows.

Author: mtorp

socketsecurity/core/git_interface.py

@@ -1,13 +1,18 @@
 import json
 import os
 import re
+import signal
+import subprocess
 import time
 import urllib.parse
 
 from git import Repo
 
 from socketsecurity.core import log
 
+REMOTE_HEAD_TIMEOUT_SECONDS = 30
+IS_WINDOWS = os.name == "nt"
+
 
 class Git:
     repo: Repo
@@ -688,23 +693,66 @@ def _default_branch_from_github_event() -> str | None:
         return default_branch or None
 
     def _default_branch_from_remote(self) -> str | None:
+        # A new process group lets a timeout also kill the remote helpers, which
+        # otherwise hold stdout open and keep communicate() blocked.
+        if IS_WINDOWS:
+            group_kwargs = {"creationflags": subprocess.CREATE_NEW_PROCESS_GROUP}
+        else:
+            group_kwargs = {"start_new_session": True}
         try:
-            output = self.repo.git.ls_remote(
-                "--symref",
-                "origin",
-                "HEAD",
-                env={"GIT_TERMINAL_PROMPT": "0"},
-                kill_after_timeout=30,
+            process = subprocess.Popen(
+                ["git", "ls-remote", "--symref", "origin", "HEAD"],
+                cwd=self.repo.working_dir,
+                env={**os.environ, "GIT_TERMINAL_PROMPT": "0"},
+                stdin=subprocess.DEVNULL,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.DEVNULL,
+                text=True,
+                **group_kwargs,
             )
         except Exception as error:
             log.debug(f"Could not query origin for its default branch: {error}")
             return None
+        try:
+            output, _ = process.communicate(timeout=REMOTE_HEAD_TIMEOUT_SECONDS)
+        except subprocess.TimeoutExpired:
+            self._kill_process_tree(process)
+            log.debug(
+                f"Querying origin for its default branch timed out after "
+                f"{REMOTE_HEAD_TIMEOUT_SECONDS}s"
+            )
+            return None
+        if process.returncode != 0:
+            log.debug(f"Querying origin for its default branch exited with {process.returncode}")
+            return None
         for line in output.splitlines():
             match = re.match(r"ref: refs/heads/(\S+)\tHEAD$", line)
             if match:
                 log.debug(f"Default branch detected from origin: {match.group(1)}")
                 return match.group(1)
         return None
+
+    @staticmethod
+    def _kill_process_tree(process: subprocess.Popen) -> None:
+        try:
+            if IS_WINDOWS:
+                subprocess.run(
+                    ["taskkill", "/F", "/T", "/PID", str(process.pid)],
+                    stdout=subprocess.DEVNULL,
+                    stderr=subprocess.DEVNULL,
+                    timeout=10,
+                )
+            else:
+                os.killpg(process.pid, signal.SIGKILL)
+        except Exception as error:
+            log.debug(f"Failed to stop git ls-remote process tree: {error}")
+            process.kill()
+        if process.stdout:
+            process.stdout.close()
+        try:
+            process.wait(timeout=5)
+        except subprocess.TimeoutExpired:
+            log.debug("git ls-remote did not exit after being killed")
 
     def is_commit_on_default_branch(self) -> bool:
         """

tests/unit/test_git_interface.py

@@ -1,10 +1,15 @@
 import logging
+import socket
 import subprocess
+import threading
+import time
 from types import SimpleNamespace
 from unittest.mock import MagicMock
 
 import pytest
+from git import Repo
 
+from socketsecurity.core import git_interface
 from socketsecurity.core.git_interface import Git
 
 CI_ENVIRONMENT_VARIABLES = (
@@ -450,3 +455,70 @@ def test_feature_branch_in_single_branch_checkout_is_not_default(
     repository = Git(str(single_branch_checkout))
 
     assert repository.is_default_branch is False
+
+
+@pytest.fixture
+def stalled_http_remote():
+    """An HTTP server that accepts connections and never responds."""
+    server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    server.bind(("127.0.0.1", 0))
+    server.listen()
+    connections = []
+    stop = threading.Event()
+
+    def accept():
+        server.settimeout(0.2)
+        while not stop.is_set():
+            try:
+                connections.append(server.accept()[0])
+            except OSError:
+                continue
+
+    thread = threading.Thread(target=accept, daemon=True)
+    thread.start()
+    yield f"http://127.0.0.1:{server.getsockname()[1]}/repo.git"
+    stop.set()
+    thread.join()
+    for connection in connections:
+        connection.close()
+    server.close()
+
+
+def test_stalled_remote_lookup_stops_at_timeout(
+        single_branch_checkout, stalled_http_remote, monkeypatch
+):
+    _git(single_branch_checkout, "remote", "set-url", "origin", stalled_http_remote)
+    monkeypatch.setattr(git_interface, "REMOTE_HEAD_TIMEOUT_SECONDS", 1)
+    repository = Git.__new__(Git)
+    repository.repo = Repo(str(single_branch_checkout))
+
+    started = time.monotonic()
+    result = repository._default_branch_from_remote()
+
+    assert result is None
+    assert time.monotonic() - started < 10
+
+
+def test_windows_remote_lookup_uses_new_process_group(monkeypatch, mocker):
+    monkeypatch.setattr(git_interface, "IS_WINDOWS", True)
+    monkeypatch.setattr(subprocess, "CREATE_NEW_PROCESS_GROUP", 0x200, raising=False)
+    process = MagicMock(returncode=0)
+    process.communicate.return_value = ("ref: refs/heads/release/stable\tHEAD\n", "")
+    popen = mocker.patch.object(git_interface.subprocess, "Popen", return_value=process)
+    repository = Git.__new__(Git)
+    repository.repo = MagicMock(working_dir="/repo")
+
+    assert repository._default_branch_from_remote() == "release/stable"
+    assert popen.call_args.kwargs["creationflags"] == 0x200
+    assert "start_new_session" not in popen.call_args.kwargs
+
+
+def test_windows_timeout_kills_the_whole_process_tree(monkeypatch, mocker):
+    monkeypatch.setattr(git_interface, "IS_WINDOWS", True)
+    run = mocker.patch.object(git_interface.subprocess, "run")
+    process = MagicMock(pid=4321)
+
+    Git._kill_process_tree(process)
+
+    assert run.call_args.args[0] == ["taskkill", "/F", "/T", "/PID", "4321"]
+    process.wait.assert_called_once()