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
433 lines
17 KiB
Python
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()
|