Two things stood between "containers enabled" and an application actually sitting on its own output, and neither was where I said it was. ipc: discovery refused whenever two instance directories existed, which every compositor restart leaves behind (a log file where a live compositor used to be). After two rebuilds the broker could not reach any compositor at all, so no container could be created and the pointer had nothing to aim at. It now asks each candidate for its version and uses the one that answers, preferring the newest only when two answer, and still refusing when none do. container_host.claim: windows are assigned by the pid the compositor already reports, not by the class stamp the per-session rule matches -- foot, GTK, Qt and the chromium wrapper all ignore that stamp, so the desk was created and left empty while the window sat in special:quarantine. The claim moves the window to its desk's workspace, makes that workspace the one the desk is showing, and reads back: the record says where the window is, never where it was sent. Called from both places a window can appear -- the read-back at start and container.reconcile -- and skipped in the steady state, because a move is a real change on screen and should not be dispatched for its own sake.
490 lines
20 KiB
Python
490 lines
20 KiB
Python
"""A compositor and a pointer driver that are real sockets and nothing else.
|
|
|
|
Both fakes bind an actual ``AF_UNIX`` listener and speak the real wire format.
|
|
Nothing here patches :mod:`socket`, :mod:`subprocess` or any method on the code
|
|
under test: a mock would pass while the things that actually break — a half-
|
|
closed request, a reply that is prose where JSON was promised, a driver that
|
|
went away mid-gesture — went untested. This is the same choice ``tests/ipc``
|
|
made, for the same reason.
|
|
|
|
What they prove and what they do not:
|
|
|
|
* :class:`FakeCompositor` proves the **wiring** — that the broker sends the
|
|
plan's commands in the plan's order, parses what comes back and writes the
|
|
compositor's answer rather than its own intention into the record. It does
|
|
not prove that Hyprland agrees: it answers ``ok`` because it was asked
|
|
politely, and the real compositor's behaviour for ``output create headless``
|
|
is marked unverified in the plan. Every test here is a test of this broker.
|
|
* :class:`FakeDriver` runs the **real dispatcher** from
|
|
:mod:`hhstream_pointer.ops`, behind the **real handler wrapper** from
|
|
:mod:`hhstream_pointer.__main__` and the **real server** from
|
|
:mod:`hhstream_pointer.server`, with only the Wayland sink replaced by a
|
|
recorder. So the protocol, the framing, the driver's own button bookkeeping
|
|
and — importantly — which backend failures become ``ok: false`` and which
|
|
kill the connection are the shipped ones; only the compositor is absent.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
import socket
|
|
import threading
|
|
from pathlib import Path
|
|
from typing import Any
|
|
|
|
import pytest
|
|
|
|
from hhstream_pointer.__main__ import _handler
|
|
from hhstream_pointer.ops import Dispatcher
|
|
from hhstream_pointer.server import PointerServer
|
|
|
|
#: Linux's sun_path is 108 bytes including the NUL.
|
|
SUN_PATH_MAX = 107
|
|
|
|
#: The pid the fake gives a window it conjures for a window rule. Fixed, and
|
|
#: not the session's: the compositor is the authority on what is on screen, and
|
|
#: a fake that echoed the broker's own pid back could not catch a broker that
|
|
#: wrote its intention into the record instead of the read-back.
|
|
WINDOW_PID = 424242
|
|
|
|
|
|
def check_path(path: Path) -> None:
|
|
if len(str(path).encode()) > SUN_PATH_MAX:
|
|
pytest.skip(f"socket path too long for AF_UNIX ({len(str(path))} bytes): {path}")
|
|
|
|
|
|
class FakeCompositor:
|
|
"""A Hyprland request socket with state: outputs, workspaces and windows.
|
|
|
|
Laid out the way Hyprland lays one out — ``<runtime>/hypr/<signature>/
|
|
.socket.sock`` — so the broker's own discovery finds it, and answering
|
|
``j/monitors``, ``j/workspaces``, ``j/clients`` with JSON of the shape
|
|
``-j`` produces.
|
|
|
|
It is stateful because the interesting assertions are about state: an
|
|
``output create`` has to show up in the next ``monitors``, an ``output
|
|
remove`` has to make it and its windows disappear, and an orphan scan is
|
|
only meaningful against a compositor that still has the orphan.
|
|
"""
|
|
|
|
def __init__(self, runtime_dir: Path, signature: str = "fake_1700000000") -> None:
|
|
self.runtime_dir = Path(runtime_dir)
|
|
self.signature = signature
|
|
self.directory = self.runtime_dir / "hypr" / signature
|
|
self.directory.mkdir(parents=True, exist_ok=True)
|
|
self.socket_path = self.directory / ".socket.sock"
|
|
check_path(self.socket_path)
|
|
|
|
#: Commands received, in order, exactly as they arrived on the wire.
|
|
self.commands: list[str] = []
|
|
#: ``initial_class`` -> ``(workspace, monitor)`` from the window rules.
|
|
self.rules: dict[str, tuple[int, str]] = {}
|
|
#: Commands to answer with prose instead of ``ok`` (a refusal).
|
|
self.refuse: set[str] = set()
|
|
#: When true, installing an anchored window rule also conjures the
|
|
#: window it describes — which is what a compositor with a cooperating
|
|
#: application does, and what the read-back path needs to have happen.
|
|
self.auto_window = True
|
|
|
|
self._lock = threading.Lock()
|
|
self._monitors: list[dict[str, Any]] = [
|
|
{
|
|
"id": 0,
|
|
"name": "HEADLESS-1",
|
|
"x": 0,
|
|
"y": 0,
|
|
"width": 1920,
|
|
"height": 1080,
|
|
"scale": 1.0,
|
|
"activeWorkspace": {"id": 1, "name": "1"},
|
|
}
|
|
]
|
|
self._workspaces: list[dict[str, Any]] = [
|
|
{"id": 1, "name": "1", "monitor": "HEADLESS-1", "windows": 0}
|
|
]
|
|
self._clients: list[dict[str, Any]] = []
|
|
self._next_address = 0x1000
|
|
|
|
self._stop = threading.Event()
|
|
self._sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
|
|
self._sock.bind(str(self.socket_path))
|
|
self._sock.listen(8)
|
|
self._sock.settimeout(0.05)
|
|
self._thread = threading.Thread(target=self._serve, daemon=True)
|
|
self._thread.start()
|
|
|
|
# -- inspection, for the tests ---------------------------------------
|
|
|
|
def outputs(self) -> list[str]:
|
|
with self._lock:
|
|
return [m["name"] for m in self._monitors]
|
|
|
|
def workspaces_on(self, output: str) -> list[int]:
|
|
with self._lock:
|
|
return [w["id"] for w in self._workspaces if w["monitor"] == output]
|
|
|
|
def windows(self) -> list[str]:
|
|
with self._lock:
|
|
return [c["initialClass"] for c in self._clients]
|
|
|
|
def add_output(self, name: str) -> None:
|
|
"""Create an output behind the broker's back — an orphan from a crash."""
|
|
|
|
with self._lock:
|
|
self._create_output(name)
|
|
|
|
def add_window(
|
|
self, initial_class: str, workspace: int, monitor: str, *, pid: int = WINDOW_PID
|
|
) -> str:
|
|
with self._lock:
|
|
return self._create_window(initial_class, workspace, monitor, pid)
|
|
|
|
def focus(self, output: str, workspace: int) -> None:
|
|
"""Make ``workspace`` the active one on ``output`` (the foreground join)."""
|
|
|
|
with self._lock:
|
|
for monitor in self._monitors:
|
|
if monitor["name"] == output:
|
|
monitor["activeWorkspace"] = {"id": workspace, "name": str(workspace)}
|
|
|
|
def stop(self) -> None:
|
|
self._stop.set()
|
|
self._sock.close()
|
|
self._thread.join(timeout=5.0)
|
|
|
|
# -- the socket -------------------------------------------------------
|
|
|
|
def _serve(self) -> None:
|
|
while not self._stop.is_set():
|
|
try:
|
|
conn, _ = self._sock.accept()
|
|
except (TimeoutError, socket.timeout):
|
|
continue
|
|
except OSError:
|
|
return
|
|
try:
|
|
self._handle(conn)
|
|
finally:
|
|
conn.close()
|
|
|
|
def _handle(self, conn: socket.socket) -> None:
|
|
# The client half-closes after writing, so the request ends at EOF.
|
|
conn.settimeout(5.0)
|
|
received = b""
|
|
while True:
|
|
try:
|
|
chunk = conn.recv(4096)
|
|
except OSError:
|
|
return
|
|
if not chunk:
|
|
break
|
|
received += chunk
|
|
text = received.decode("utf-8", errors="replace")
|
|
flags, separator, command = text.partition("/")
|
|
if not separator:
|
|
flags, command = "", text
|
|
command = command.strip()
|
|
with self._lock:
|
|
self.commands.append(command)
|
|
reply = self._reply(command)
|
|
try:
|
|
conn.sendall(reply.encode())
|
|
except OSError:
|
|
pass
|
|
|
|
# -- the command set --------------------------------------------------
|
|
|
|
def _reply(self, command: str) -> str:
|
|
if command in self.refuse:
|
|
return "Invalid command"
|
|
if command == "version":
|
|
return "Hyprland 0.56.2 built from branch at commit 0000000\nTag: v0.56.2\n"
|
|
if command == "monitors":
|
|
return json.dumps(self._monitors)
|
|
if command == "workspaces":
|
|
return json.dumps(self._workspaces)
|
|
if command == "clients":
|
|
return json.dumps(self._clients)
|
|
if command == "cursorpos":
|
|
return json.dumps({"x": 0, "y": 0})
|
|
words = command.split()
|
|
if words[:3] == ["output", "create", "headless"] and len(words) == 4:
|
|
self._create_output(words[3])
|
|
return "ok"
|
|
if words[:2] == ["output", "remove"] and len(words) == 3:
|
|
return "ok" if self._remove_output(words[2]) else f"no such output {words[2]}"
|
|
if words[:2] == ["dispatch", "movetoworkspacesilent"] and len(words) == 3:
|
|
return self._move_to_workspace(words[2])
|
|
if words[:2] == ["dispatch", "workspace"] and len(words) == 3:
|
|
return self._show_workspace(words[2])
|
|
if words[:1] == ["keyword"]:
|
|
return self._keyword(command[len("keyword") :].strip())
|
|
return f"unknown request {command!r}"
|
|
|
|
# -- dispatches -------------------------------------------------------
|
|
|
|
def _move_to_workspace(self, spec: str) -> str:
|
|
"""``<workspace>,address:<addr>`` -- what the broker claims with.
|
|
|
|
Moving a window is the one thing that puts a real application on its
|
|
desk, because no allowlisted app carries the class the rule matches.
|
|
"""
|
|
|
|
workspace_text, _, address = spec.partition(",address:")
|
|
if not workspace_text.isdigit() or not address:
|
|
return f"malformed move {spec!r}"
|
|
client = next((c for c in self._clients if c["address"] == address), None)
|
|
if client is None:
|
|
return f"no such window {address}"
|
|
workspace = int(workspace_text)
|
|
monitor = next(
|
|
(m["name"] for m in self._monitors if m["id"] == client["monitor"]), None
|
|
)
|
|
if not any(w["id"] == workspace for w in self._workspaces):
|
|
self._workspaces.append(
|
|
{"id": workspace, "name": str(workspace), "monitor": monitor, "windows": 0}
|
|
)
|
|
for entry in self._workspaces:
|
|
if entry["id"] == client["workspace"]["id"]:
|
|
entry["windows"] = max(0, entry["windows"] - 1)
|
|
if entry["id"] == workspace:
|
|
entry["windows"] += 1
|
|
client["workspace"] = {"id": workspace, "name": str(workspace)}
|
|
return "ok"
|
|
|
|
def _show_workspace(self, workspace_text: str) -> str:
|
|
"""``workspace <n>`` -- makes that workspace the visible one.
|
|
|
|
Only meaningful on the output that holds it, which is how Hyprland
|
|
behaves: the workspace's own monitor switches to it.
|
|
"""
|
|
|
|
if not workspace_text.lstrip("-").isdigit():
|
|
return f"malformed workspace {workspace_text!r}"
|
|
workspace = int(workspace_text)
|
|
holder = next((w["monitor"] for w in self._workspaces if w["id"] == workspace), None)
|
|
if holder is None:
|
|
return f"no such workspace {workspace}"
|
|
for monitor in self._monitors:
|
|
if monitor["name"] == holder:
|
|
monitor["activeWorkspace"] = {"id": workspace, "name": str(workspace)}
|
|
return "ok"
|
|
|
|
def _keyword(self, rest: str) -> str:
|
|
name, _, body = rest.partition(" ")
|
|
if name == "workspace":
|
|
return self._keyword_workspace(body)
|
|
if name == "windowrule":
|
|
return self._keyword_windowrule(body)
|
|
if name == "monitor":
|
|
return self._keyword_monitor(body)
|
|
return f"unknown keyword {name!r}"
|
|
|
|
def _keyword_workspace(self, body: str) -> str:
|
|
# `<n>, monitor:<name>, default:true, persistent:true`
|
|
parts = [p.strip() for p in body.split(",")]
|
|
slot = int(parts[0])
|
|
monitor = next((p.split(":", 1)[1] for p in parts if p.startswith("monitor:")), None)
|
|
if monitor is None:
|
|
return "workspace rule has no monitor"
|
|
if not any(w["id"] == slot for w in self._workspaces):
|
|
self._workspaces.append(
|
|
{"id": slot, "name": str(slot), "monitor": monitor, "windows": 0}
|
|
)
|
|
return "ok"
|
|
|
|
def _keyword_windowrule(self, body: str) -> str:
|
|
# `match:initial_class ^hh-x$, workspace 1000, monitor hh-x`
|
|
parts = [p.strip() for p in body.split(",")]
|
|
match = parts[0]
|
|
if not match.startswith("match:initial_class "):
|
|
return "unsupported rule"
|
|
pattern = match[len("match:initial_class ") :]
|
|
workspace = next((p[len("workspace ") :] for p in parts if p.startswith("workspace ")), None)
|
|
monitor = next((p[len("monitor ") :] for p in parts if p.startswith("monitor ")), None)
|
|
if pattern == ".*" or monitor is None or workspace is None:
|
|
# The quarantine backstop: recorded so a test can assert it was
|
|
# installed, and first, but it conjures nothing.
|
|
self.rules[pattern] = (0, workspace or "")
|
|
return "ok"
|
|
initial_class = pattern.strip("^$")
|
|
self.rules[initial_class] = (int(workspace), monitor)
|
|
if self.auto_window:
|
|
self._create_window(initial_class, int(workspace), monitor, WINDOW_PID)
|
|
return "ok"
|
|
|
|
def _keyword_monitor(self, body: str) -> str:
|
|
# `<name>,<w>x<h>,auto,1`
|
|
parts = body.split(",")
|
|
name = parts[0]
|
|
width, _, height = parts[1].partition("x")
|
|
for monitor in self._monitors:
|
|
if monitor["name"] == name:
|
|
monitor["width"] = int(width)
|
|
monitor["height"] = int(height)
|
|
return "ok"
|
|
return f"no such monitor {name}"
|
|
|
|
# -- state ------------------------------------------------------------
|
|
|
|
def _create_output(self, name: str) -> None:
|
|
if any(m["name"] == name for m in self._monitors):
|
|
return
|
|
self._monitors.append(
|
|
{
|
|
"id": len(self._monitors),
|
|
"name": name,
|
|
"x": 1920 * len(self._monitors),
|
|
"y": 0,
|
|
"width": 1280,
|
|
"height": 720,
|
|
"scale": 1.0,
|
|
"activeWorkspace": None,
|
|
}
|
|
)
|
|
|
|
def _remove_output(self, name: str) -> bool:
|
|
before = len(self._monitors)
|
|
self._monitors = [m for m in self._monitors if m["name"] != name]
|
|
if len(self._monitors) == before:
|
|
return False
|
|
gone = {w["id"] for w in self._workspaces if w["monitor"] == name}
|
|
self._workspaces = [w for w in self._workspaces if w["monitor"] != name]
|
|
# Hyprland destroys a window with its surface; the fake destroys the
|
|
# ones that were on the output's workspaces, which is the behaviour the
|
|
# teardown cross-check is written against.
|
|
self._clients = [c for c in self._clients if c["workspace"]["id"] not in gone]
|
|
return True
|
|
|
|
def _create_window(self, initial_class: str, workspace: int, monitor: str, pid: int) -> str:
|
|
self._next_address += 0x10
|
|
address = hex(self._next_address)
|
|
self._clients.append(
|
|
{
|
|
"address": address,
|
|
"mapped": True,
|
|
"hidden": False,
|
|
"at": [0, 0],
|
|
"size": [1280, 720],
|
|
"workspace": {"id": workspace, "name": str(workspace)},
|
|
"monitor": next(
|
|
(m["id"] for m in self._monitors if m["name"] == monitor), 0
|
|
),
|
|
"class": initial_class,
|
|
"initialClass": initial_class,
|
|
"title": "a window, with a comma in its title",
|
|
"pid": pid,
|
|
}
|
|
)
|
|
for entry in self._workspaces:
|
|
if entry["id"] == workspace:
|
|
entry["windows"] += 1
|
|
# A window that maps makes its workspace the active one on its output,
|
|
# which is what the `foreground` join reads.
|
|
for entry in self._monitors:
|
|
if entry["name"] == monitor:
|
|
entry["activeWorkspace"] = {"id": workspace, "name": str(workspace)}
|
|
return address
|
|
|
|
|
|
class RecordingSink:
|
|
"""A :class:`hhstream_pointer.ops.PointerSink` that writes nothing anywhere."""
|
|
|
|
def __init__(self) -> None:
|
|
self.calls: list[tuple] = []
|
|
#: An exception to raise from the next call. The shipped driver
|
|
#: answers an ``OutputUnknown`` on the wire and lets anything else
|
|
#: take the connection down, so which one is raised here decides which
|
|
#: of the broker's two failure paths is being tested.
|
|
self.fail: Exception | None = None
|
|
|
|
def motion_absolute(self, output: str, x: float, y: float) -> None:
|
|
self._check()
|
|
self.calls.append(("warp", output, round(x, 6), round(y, 6)))
|
|
|
|
def button(self, output: str, code: int, state: int) -> None:
|
|
self._check()
|
|
self.calls.append(("button", output, code, state))
|
|
|
|
def axis(self, output: str, axis: int, value: float) -> None:
|
|
self._check()
|
|
self.calls.append(("axis", output, axis, value))
|
|
|
|
def frame(self, output: str) -> None:
|
|
self._check()
|
|
self.calls.append(("frame", output))
|
|
|
|
def _check(self) -> None:
|
|
if self.fail is not None:
|
|
raise self.fail
|
|
|
|
def of(self, kind: str) -> list[tuple]:
|
|
return [c for c in self.calls if c[0] == kind]
|
|
|
|
|
|
class FakeDriver:
|
|
"""The shipped driver with its Wayland sink replaced by a recorder.
|
|
|
|
The dispatcher, the handler wrapper and the per-connection protocol loop
|
|
are the shipped ones. The **accept loop** is not: ``serve_forever`` blocks
|
|
in ``accept()`` for ever by design, and closing a listening socket does not
|
|
reliably wake a thread already inside it, so a fake that used it would cost
|
|
every test the stop timeout. Four lines with a poll interval replace it;
|
|
everything a test is actually asserting about still runs the real code.
|
|
"""
|
|
|
|
def __init__(self, socket_path: Path) -> None:
|
|
check_path(Path(socket_path))
|
|
self.socket_path = Path(socket_path)
|
|
self.sink = RecordingSink()
|
|
self.dispatcher = Dispatcher(self.sink)
|
|
self.server = PointerServer(self.socket_path, _handler(self.dispatcher))
|
|
self.server.listen()
|
|
self.connections: list[socket.socket] = []
|
|
self._stop = threading.Event()
|
|
self._listener = self.server._sock
|
|
self._listener.settimeout(0.05)
|
|
self._thread = threading.Thread(target=self._serve, daemon=True)
|
|
self._thread.start()
|
|
|
|
def _serve(self) -> None:
|
|
while not self._stop.is_set():
|
|
try:
|
|
conn, _ = self._listener.accept()
|
|
except (TimeoutError, socket.timeout):
|
|
continue
|
|
except OSError:
|
|
return
|
|
conn.settimeout(None)
|
|
self.connections.append(conn)
|
|
try:
|
|
self.server._serve_connection(conn)
|
|
except Exception:
|
|
# The shipped `main` lets a backend failure out of the serve
|
|
# loop and exits with code 10 — a driver talking to a dead
|
|
# display has nothing useful left to say. The fake ends its
|
|
# thread for the same reason, so the broker sees the same
|
|
# thing: a connection that closed without answering.
|
|
return
|
|
finally:
|
|
conn.close()
|
|
|
|
def stop(self) -> None:
|
|
"""Stop the way a killed process stops: listener *and* connections.
|
|
|
|
The shipped driver never has to do this — the kernel closes its fds
|
|
when it exits — but a fake that left the broker's held connection open
|
|
would not look like a driver that restarted, which is one of the
|
|
things the client has to get right.
|
|
"""
|
|
|
|
self._stop.set()
|
|
for conn in self.connections:
|
|
try:
|
|
conn.shutdown(socket.SHUT_RDWR)
|
|
except OSError:
|
|
pass
|
|
conn.close()
|
|
self._thread.join(timeout=5.0)
|
|
self.server.close()
|