Files
HermenixandClaude Opus 5 129430bffd wire the broker to the compositor, containers and pointer
The four slices existed and nothing called them. Now the broker builds a
spatial container per session, reads back what the compositor actually did,
and aims the cursor into one container under a broker-wide lease.

Record schema 3 (registry.py): `container` {output, workspace, mode,
created_by, state}, `pointer` {bookmark, last_released_at, released_by} and
the compositor's `signature`. A v2 record is migrated on load, not refused —
its application is still running. Every field that could not be verified is
null; `container: null` means "no container", never "probably something".

Containers (new container_host.py, manager.py, launcher.py): `start`
allocates a slot from `WorkspaceAllocator`, runs `container_plan()`'s argv,
launches the app with the container stamp in its environment, then reads the
workspace, output and window back out of `clients -j`. Teardown removes the
output, releases the slot and reports survivors rather than claiming success
— and runs for an unprompted exit and for `gc` too, so no container is ever
left unattended. Broker start-up reconciles: adopt `hh-*` outputs a live
session claims, remove the rest, `contains_output()` being the only filter.
No IPC means `container: degraded` and lifecycle verbs unchanged.

The plans' argv are dispatched over the compositor's request socket rather
than by executing `hyprctl`, which is what hyprctl does with the same words;
the reply is checked, so a refused command is not recorded as a container.

Pointer (new driver.py, manager.py): a client for the driver's private
socket, and `pointer.acquire|move|button|click|release|state` on top of
`PointerLease`. The broker owns the lease, the driver executes. The bookmark
is marked on every move and before release and stored in the record, so it
survives a restart. On expiry `pressed()` is read before `expire()` and
`release_all` goes to the driver, because the lease cannot lift a button
itself; a sweep runs unprompted so the TTL is a promise.

containers.py to v2: `quarantine_plan()` -> `quarantine_argv()`, with the
before-any-per-session-rule ordering stated where the caller could get it
wrong. protocol.py: 9 NO_LEASE, 10 COMPOSITOR, the verb table, and the
`request_id` cache moved out of the server so the CLI agrees with it.

Tests: real AF_UNIX everywhere — a stateful fake compositor and the shipped
pointer driver behind a recording sink. No mocked sockets, no compositor, no
VM. 551 -> 693.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017mUq7QvQ9EZb2Wi35xj4cs
2026-10-02 19:47:33 +00:00

433 lines
17 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[:1] == ["keyword"]:
return self._keyword(command[len("keyword") :].strip())
return f"unknown request {command!r}"
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 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()