mirror of
https://github.com/daijro/camoufox.git
synced 2026-11-19 00:07:28 +00:00
headless="virtual" started Xvfb in its own session and stopped it only on the browser's close path. A launcher ended by a signal (timeout, a supervisor, a cancelled CI job) never reaches that path, so its Xvfb ran forever, together with the session bus and desktop helpers Firefox autolaunched on that display. Both packages now exec Xvfb through `setpriv --pdeathsig TERM`, so the kernel signals it when its launcher dies, even by SIGKILL. SIGTERM lets Xvfb remove its own lock and socket, and the autolaunched bus exits when it loses its X connection. setpriv comes from util-linux. The leak suite missed this because every crash test keeps the launcher alive to tear down, and leak_check follows only our descendants, which an orphan no longer is. test_launcher_sigkill_leaves_nothing_on_its_display kills the launcher and looks machine-wide. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
177 lines
5.3 KiB
Python
177 lines
5.3 KiB
Python
"""
|
|
Tests for camoufox.virtdisplay.
|
|
|
|
Mirrors typescript/tests/virtdisplay.test.ts.
|
|
|
|
Run with:
|
|
cd python && python -m pytest tests/test_virtdisplay.py -v
|
|
|
|
VIRTDISPLAY_TEST_N controls the concurrent-launch count. Default is kept
|
|
low so the test passes on any developer box; set to e.g. 1000 to exercise
|
|
real scaling. At high N you will need `ulimit -n` headroom -- each Xvfb
|
|
takes one X11 socket plus our -displayfd pipe.
|
|
"""
|
|
|
|
import os
|
|
import re
|
|
import signal
|
|
import subprocess # nosec
|
|
import sys
|
|
import time
|
|
from typing import List, Set
|
|
|
|
import pytest
|
|
|
|
from camoufox.virtdisplay import VirtualDisplay
|
|
|
|
DISPLAY_RE = re.compile(r"^:\d+$")
|
|
N = int(os.environ.get("VIRTDISPLAY_TEST_N", "50"))
|
|
|
|
pytestmark = pytest.mark.skipif(
|
|
sys.platform != "linux", reason="VirtualDisplay is Linux-only"
|
|
)
|
|
|
|
|
|
# Track every VirtualDisplay we spawn so the fixture can guarantee
|
|
# cleanup even if an assertion fails mid-test.
|
|
@pytest.fixture
|
|
def tracked() -> List[VirtualDisplay]:
|
|
items: List[VirtualDisplay] = []
|
|
yield items
|
|
for vd in items:
|
|
try:
|
|
vd.kill()
|
|
except Exception:
|
|
pass
|
|
|
|
|
|
def _track(items: List[VirtualDisplay], vd: VirtualDisplay) -> VirtualDisplay:
|
|
items.append(vd)
|
|
return vd
|
|
|
|
|
|
def _wait_for_exit(vd: VirtualDisplay, timeout_s: float = 5.0) -> None:
|
|
deadline = time.monotonic() + timeout_s
|
|
while time.monotonic() < deadline:
|
|
if vd.proc is None or vd.proc.poll() is not None:
|
|
return
|
|
time.sleep(0.025)
|
|
|
|
|
|
def test_single_launch_returns_valid_display_and_kill_terminates_xvfb(tracked):
|
|
vd = _track(tracked, VirtualDisplay())
|
|
display = vd.get()
|
|
assert DISPLAY_RE.match(display), display
|
|
assert vd.proc is not None
|
|
assert vd.proc.poll() is None # alive
|
|
|
|
vd.kill()
|
|
_wait_for_exit(vd)
|
|
# kill() reaps the child and clears the handle, so `proc is None` is the
|
|
# post-condition; a surviving handle must at least report an exit code.
|
|
assert vd.proc is None or vd.proc.poll() is not None # exited
|
|
|
|
|
|
def test_get_is_idempotent_within_one_virtual_display(tracked):
|
|
vd = _track(tracked, VirtualDisplay())
|
|
a = vd.get()
|
|
b = vd.get()
|
|
assert a == b
|
|
|
|
|
|
def test_concurrent_reservations_all_get_unique_displays(tracked):
|
|
# Every VirtualDisplay spawns its own Xvfb. Each Xvfb scans up from :0
|
|
# and atomically claims the first free X11 socket (kernel-mediated
|
|
# bind, no userspace race). -displayfd reports the chosen number back
|
|
# to us. A duplicate here would mean we mis-parsed or mis-routed the
|
|
# displayfd output, or two Xvfbs somehow bound the same socket.
|
|
vds = [_track(tracked, VirtualDisplay()) for _ in range(N)]
|
|
|
|
displays = [vd.get() for vd in vds]
|
|
|
|
for d in displays:
|
|
assert DISPLAY_RE.match(d), d
|
|
|
|
unique: Set[str] = set(displays)
|
|
assert len(unique) == len(displays), (
|
|
f"duplicate displays: {len(displays) - len(unique)} of {len(displays)}"
|
|
)
|
|
|
|
# Every Xvfb is alive.
|
|
for vd in vds:
|
|
assert vd.proc is not None and vd.proc.poll() is None
|
|
|
|
# Tear them all down and confirm every Xvfb actually exited -- no
|
|
# leaked processes.
|
|
for vd in vds:
|
|
vd.kill()
|
|
for vd in vds:
|
|
_wait_for_exit(vd)
|
|
for vd in vds:
|
|
assert vd.proc is None or vd.proc.poll() is not None
|
|
|
|
|
|
def test_released_display_numbers_can_be_reused_on_the_next_launch(tracked):
|
|
a = _track(tracked, VirtualDisplay())
|
|
a_display = a.get()
|
|
|
|
a.kill()
|
|
_wait_for_exit(a)
|
|
|
|
# Spawning a new Xvfb after release must succeed. The new display
|
|
# number may or may not equal a_display -- Xvfb's allocation order is
|
|
# its concern -- but we must get *some* display.
|
|
b = _track(tracked, VirtualDisplay())
|
|
b_display = b.get()
|
|
assert DISPLAY_RE.match(b_display), b_display
|
|
|
|
b.kill()
|
|
_wait_for_exit(b)
|
|
|
|
# Sanity: a_display was a valid form too.
|
|
assert DISPLAY_RE.match(a_display), a_display
|
|
|
|
|
|
def _alive(pid: int) -> bool:
|
|
"""True while `pid` runs; a zombie waiting for its new parent counts as dead."""
|
|
try:
|
|
with open(f"/proc/{pid}/stat") as f:
|
|
return f.read().rsplit(")", 1)[1].split()[0] != "Z"
|
|
except FileNotFoundError:
|
|
return False
|
|
|
|
|
|
def test_xvfb_dies_with_the_process_that_started_it():
|
|
"""A SIGKILLed launcher never runs kill(), so the kernel must stop Xvfb (#868).
|
|
|
|
Supervisors, `timeout` and CI cancellation end the Python process with a
|
|
signal that skips every `finally`. Xvfb then has to go on its own, and
|
|
remove its lock and socket on the way out.
|
|
"""
|
|
child = subprocess.Popen( # nosec
|
|
[
|
|
sys.executable,
|
|
"-c",
|
|
"import sys, time\n"
|
|
"from camoufox.virtdisplay import VirtualDisplay\n"
|
|
"vd = VirtualDisplay()\n"
|
|
"print(vd.get()[1:], vd.proc.pid, flush=True)\n"
|
|
"time.sleep(60)\n",
|
|
],
|
|
stdout=subprocess.PIPE,
|
|
text=True,
|
|
)
|
|
display, pid = child.stdout.readline().split()
|
|
xvfb = int(pid)
|
|
assert _alive(xvfb)
|
|
|
|
child.send_signal(signal.SIGKILL)
|
|
child.wait()
|
|
|
|
deadline = time.monotonic() + 5
|
|
while _alive(xvfb) and time.monotonic() < deadline:
|
|
time.sleep(0.025)
|
|
assert not _alive(xvfb), f"Xvfb {xvfb} outlived the process that started it"
|
|
assert not os.path.exists(f"/tmp/.X{display}-lock")
|
|
assert not os.path.exists(f"/tmp/.X11-unix/X{display}")
|