The Stage 1 review (docs/reviews/2026-10-04-stage1-review.md, verdict
yes-with-fixes) found a real bug, and it was the kind Stage 2 would have
cemented. All five findings:
(1) HIGH, and reproduced before fixing: `key` resolved the action and
then used only its `code`. So `keyboard key A` sent a bare code 30
and the window received `a`; on `de`, `at` lost its level-three mask
and typed `q`. `type` was the only path that used the mask, which is
why every `type` test stayed green. `key` now sends
modifiers(baseline | mask) before the down and restores the baseline
on the up -- the one-character `type` sequence -- and `Shift_L`
keeps its key-then-mask order, which is the other path on purpose.
The same hole aliased two names onto one keycode: `down A` then
`down a` recorded both and pressed 30 twice, Hyprland dropped the
second, and the held set lied until the lease ended. A second name
for a code already down is now refused.
(2) HIGH: the shutdown comment claimed hyprland-conf.nix sets
input:virtualkeyboard:release_pressed_on_close. It did not. The line
is there now, with the note that it releases keys and still never
clears a mask -- which is why release_all zeroes the mask on every
path we control rather than relying on it.
(3) MEDIUM: nothing would have noticed the keymap upload stopping. A
`main` that connected and listened without uploading passed every
test in the tree. Now asserted on the real sink: uploaded once,
before `listen` (one shared ordering log across both stand-ins), the
payload NUL-terminated with `size == len(utf8) + 1` read back
through the fd, format 1, one terminator not two, and modifiers(0)
straight after.
(4) LOW: `key` up now forgets the name only after a successful send,
like `button` -- otherwise a raise between the two leaves us
believing a key is up that the compositor still has down, and
release_all will not try again.
(5) LOW: `\r` no longer aliases to Return (CRLF would have become two
newlines silently), and an empty layout is refused -- xkbcommon
compiles "" as the same keymap as `us`, so `--xkb-layout ''` looked
configured and typed `us`.
Several of the review's named false passes are closed too: Control's
mask is compared against mod_get_index("Control") rather than merely
"not Shift's"; the keymap text assertion names pc_us_inet/pc_de_inet
instead of substring-matching "us"; the capital-under-Control case
asserts the whole sequence; the exit-code mirror is compared against
hhstreamd.protocol; and the module's defaults are read out of
nix/module.nix rather than asserted against themselves.
Stage 2 proper:
* broker verbs keyboard.key / keyboard.type, both in the mutation set,
both through _refresh (so they refresh the lease and, like every
pointer verb, do NOT count as activity)
* the driver's `kind` token mapped: a bad keysym or character is
invalid_argument (exit 2), a missing keyboard global stays
driver_refused (exit 10). The 4096-scalar cap and the shape checks
are broker-side, because only a broker-side invalid_argument is 2
* keys[] on pointer.state, keys_lifted[] on pointer.release and on
pointer_lease_timeout, one release_all for both halves
* CLI `session keyboard type|key|down|up`, reusing the pointer lease
and its cache; `type` takes one raw argument and interprets nothing;
the audit records a character count and never the text
* sessions.keyboard.{layout,model,variant,options} on the unit's argv,
layout defaulting to "us" with a type that refuses a comma. NO
[keyboard] TOML table: hhstreamd reads that file and the driver is a
different unit, so it would be a setting with no effect
* CONTRACT-sessions.md bumped to v3; README.dev.md item 3 and
vm-pointer.nix's header corrected (both still said the conf ships
follow_mouse = 0 and that the keyboard work would choose)
And the operator decision that acquire grabs both devices: it now sends
two warps a real pixel apart, because one warp onto an idle cursor moves
the cursor and not keyboard focus. follow_mouse_threshold = 0 is set
explicitly in hyprland-conf.nix since the second warp depends on it,
`dispatch focuswindow` is the fallback when the nudge cannot be sent,
and the reply and audit carry which mechanism ran. The acquire test
asserts the pair and that they floor to different pixels -- a test that
only saw wl_pointer.enter would pass while the first keystroke went to
the wrong window.
nix develop -c python -m pytest tests/pointer tests/sessions/unit -q
605 passed in 27.11s
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01GhNPM6rGcuzxocM1nATnuM
604 lines
29 KiB
Nix
604 lines
29 KiB
Nix
# checks.<system>.vm-pointer -- the lease, the driver, and a click that lands.
|
|
#
|
|
# The lease's arithmetic is already proved by the unit suite with an injected
|
|
# clock. What no fake can prove is the half this check is for: that a warp
|
|
# through `zwlr_virtual_pointer_v1` reaches a real compositor, that the
|
|
# coordinates are the *output's* and not the desktop's, and that the button
|
|
# the broker sent arrives at the application underneath it.
|
|
#
|
|
# ─── "A CLICK LANDS WHERE IT WAS AIMED", AND WHY NOT PIXELS ──────────────────
|
|
# PLAN §14 says this must be verified by reading back the application's own
|
|
# state. A pixel comparison would prove the compositor drew a cursor
|
|
# somewhere; it would not prove any client was told about a button, and a
|
|
# cursor drawn at the right place with no `wl_pointer.button` delivered is
|
|
# precisely the failure a virtual pointer bound to the wrong output produces.
|
|
#
|
|
# So the victim is `hhs-pointer-target` (checks/lib/pointer_target.py), a
|
|
# Wayland client that prints every pointer event it receives with the
|
|
# surface-local coordinates the compositor sent it. The broker captures its
|
|
# stdout into the session log, so `hhstream session logs` is the read-back,
|
|
# and the assertion is on numbers the *client* reported.
|
|
#
|
|
# It also reads `$HHSTREAM_APP_ID` and sets its own `xdg_toplevel` app id from
|
|
# it, which is what gets its window into the container the pointer aims at.
|
|
# `foot` and `wev` cannot: they ignore the environment, so their windows are
|
|
# quarantined and there would be nothing under the cursor. See vm-containers.
|
|
# ─────────────────────────────────────────────────────────────────────────────
|
|
#
|
|
# The expiry subtest uses a caller-supplied `--ttl` of a few seconds and waits
|
|
# for it in real time. No clock is injected anywhere: an injected clock would
|
|
# prove the arithmetic the unit suite already proves, and not the sweeper, the
|
|
# driver call it makes, or the button it has to lift.
|
|
#
|
|
# `sessions.pointer.leaseTtl` is set on the machine anyway, and the acquire
|
|
# subtest *prints* it beside the TTL the broker reports. They disagree, and
|
|
# that is the point: the module renders the option into the generated TOML and
|
|
# `hhstreamd/policy.py` reads neither it nor any flag for it. Printed rather
|
|
# than asserted, because the broker is not this slice's file to change.
|
|
#
|
|
# ─── TWO THINGS THIS CHECK MEASURED, BOTH WORTH READING BEFORE EDITING IT ────
|
|
#
|
|
# 1. A WARP TO WHERE THE CURSOR ALREADY IS REPORTS NOTHING, and correctly so:
|
|
# nothing moved. It is only a trap for a check -- a second `acquire` that
|
|
# restores a bookmark the cursor never left delivers no `wl_pointer.motion`,
|
|
# so "the bookmark was restored" has no client-side evidence. The restore is
|
|
# therefore asserted on the broker's reply, where the bookmark lives, and
|
|
# *delivery* is asserted with a warp to somewhere the cursor is not.
|
|
#
|
|
# 2. `input:follow_mouse = 0` SENDS POINTER EVENTS TO THE FOCUSED WINDOW ONLY,
|
|
# and when the window under the cursor is not the focused one, to nobody at
|
|
# all. `nix/hyprland-conf.nix` USED TO ship it, justified by "No pointer
|
|
# will ever exist; do not let focus depend on one" -- a belief this build
|
|
# made false. **That is fixed: the conf file now sets `1`**, so the
|
|
# `extraConfig` override below is belt and braces rather than the only
|
|
# thing making this check pass. The measurement is kept because it is the
|
|
# reason the conf changed, and because a revert would make it current again.
|
|
#
|
|
# What `1` does NOT fix, measured later by `tests/keyboard_probe.py`: one
|
|
# warp moves the cursor and not KEYBOARD focus, because Hyprland zeroes
|
|
# `m_mousePosDelta` when the previous movement was over 0.5s ago. So
|
|
# `pointer acquire` sends two warps a real pixel apart, and the conf sets
|
|
# `input:follow_mouse_threshold = 0` explicitly because that is what the
|
|
# second one depends on. `checks/vm-keyboard.nix` is where that is asserted;
|
|
# this check asserts pointer delivery and says nothing about keys.
|
|
#
|
|
# MEASURED, against the shipped config, with two sessions and the second
|
|
# one holding focus because its window opened last:
|
|
#
|
|
# aimed at target-le22h7: it reports [] <- the session the warp named
|
|
# focused is target-s76taj: it reports [] <- the session with focus
|
|
# cursor now at {'x': 2048, 'y': 288} <- EXACTLY where it was aimed
|
|
#
|
|
# The compositor moved the cursor to the right pixel, inside the right
|
|
# window, on the right output -- and told no client. The same warp and the
|
|
# same click are delivered perfectly in the subtests above, where the
|
|
# aimed-at session is also the focused one, which is why nothing before
|
|
# this check noticed.
|
|
#
|
|
# That defeats what containers and the lease exist for: an agent can only
|
|
# drive whichever session the compositor last focused. So this machine
|
|
# overrides the one line through the module's `extraConfig`, and the
|
|
# subtest "the cursor reaches a session that does not hold focus" is the
|
|
# assertion that goes red if the shipped default comes back.
|
|
# `nix/hyprland-conf.nix` is not this slice's file; the fix belongs there,
|
|
# and whether it should be `1` (Hyprland's own default, keyboard focus
|
|
# follows the cursor too) or a looser setting that leaves keyboard focus
|
|
# alone is a decision for the keyboard work in PLAN §6.7.
|
|
# ─────────────────────────────────────────────────────────────────────────────
|
|
{
|
|
testers,
|
|
hhstream,
|
|
hhsModule,
|
|
testTools,
|
|
hyprland,
|
|
foot,
|
|
jq,
|
|
grim,
|
|
procps,
|
|
coreutils,
|
|
dejavu_fonts,
|
|
width ? 1280,
|
|
height ? 720,
|
|
sessionUser ? "hermes",
|
|
# Short enough that the expiry subtest is seconds and not minutes, long
|
|
# enough that a `systemd-run` round trip inside the guest (several seconds)
|
|
# fits comfortably inside one lease.
|
|
leaseTtl ? 20,
|
|
leaseMax ? 120,
|
|
}:
|
|
testers.runNixOSTest (
|
|
{ pkgs, ... }:
|
|
let
|
|
tools = pkgs.callPackage ./lib/session-tools.nix { inherit hhstream; };
|
|
guest = import ./lib/session-machine.nix {
|
|
inherit
|
|
hhsModule
|
|
hhstream
|
|
hyprland
|
|
testTools
|
|
foot
|
|
jq
|
|
procps
|
|
grim
|
|
coreutils
|
|
dejavu_fonts
|
|
;
|
|
sessionTools = tools;
|
|
};
|
|
prelude = import ./lib/session-prelude.nix {
|
|
inherit hhstream coreutils sessionUser;
|
|
};
|
|
target = pkgs.writeShellScript "hhs-target-wrapper" ''
|
|
exec ${tools}/bin/hhs-pointer-target --app-id "$HHSTREAM_APP_ID" "$@"
|
|
'';
|
|
in
|
|
{
|
|
name = "hhstream-vm-pointer";
|
|
|
|
globalTimeout = 1800;
|
|
|
|
nodes.machine = guest {
|
|
inherit
|
|
width
|
|
height
|
|
sessionUser
|
|
leaseTtl
|
|
leaseMax
|
|
;
|
|
pointer = true;
|
|
apps.target = {
|
|
exec = "${target}";
|
|
argsAllow = [ ];
|
|
};
|
|
# Point 2 of the block at the top of this file. One line, overriding one
|
|
# line of nix/hyprland-conf.nix, because that file is not this slice's
|
|
# to edit -- not because there is any doubt about it.
|
|
extraConfig = "input:follow_mouse = 1";
|
|
};
|
|
|
|
testScript =
|
|
prelude
|
|
+ ''
|
|
import re
|
|
|
|
LEASE_TTL = ${toString leaseTtl}
|
|
POINTER_SOCKET = "/run/hhstream/pointer.sock"
|
|
#: wl_pointer surface coordinates are logical pixels. The budget covers
|
|
#: two things and nothing else: the protocol's integer extent (the
|
|
#: driver scales a normalised coordinate by 0xFFFF, so under a pixel on
|
|
#: a 1280-wide output) and Hyprland's default 2px border, which sits
|
|
#: between the window box `clients -j` reports and the surface the
|
|
#: client is given coordinates in. A pointer bound without an output
|
|
#: speaks *global* coordinates and would be out by hundreds, so this
|
|
#: tolerance does not blunt the assertion it guards.
|
|
TOLERANCE = 6.0
|
|
|
|
|
|
def pointer_log(session_id):
|
|
"""Every line the victim has printed so far."""
|
|
|
|
return machine.succeed(cli(f"logs {session_id} --lines 400"), timeout=120)
|
|
|
|
|
|
def positions(session_id):
|
|
"""(x, y) from every `enter`/`motion` line the client printed."""
|
|
|
|
found = []
|
|
for line in pointer_log(session_id).splitlines():
|
|
if line.startswith(("pointer enter", "pointer motion")):
|
|
pair = re.findall(r"[xy]=([-\d.]+)", line)
|
|
if len(pair) == 2:
|
|
found.append((float(pair[0]), float(pair[1])))
|
|
return found
|
|
|
|
|
|
def buttons(session_id):
|
|
"""(code, state, x, y) from every `button` line the client printed."""
|
|
|
|
found = []
|
|
for line in pointer_log(session_id).splitlines():
|
|
match = re.match(
|
|
r"pointer button code=(\d+) state=(\w+) x=([-\d.]+) y=([-\d.]+)",
|
|
line,
|
|
)
|
|
if match:
|
|
found.append(
|
|
(
|
|
int(match.group(1)),
|
|
match.group(2),
|
|
float(match.group(3)),
|
|
float(match.group(4)),
|
|
)
|
|
)
|
|
return found
|
|
|
|
|
|
def aimed_at(nx, ny):
|
|
"""Where a warp to (nx, ny) of the output should land *in the surface*.
|
|
|
|
Computed from the compositor's own geometry rather than assumed to
|
|
be a fraction of the window: Hyprland's default layout leaves 20px
|
|
outer gaps, so the window is not the output and the centre of one
|
|
is not the centre of the other. Asking `monitors` and `clients`
|
|
for both boxes is what makes this an assertion about aiming rather
|
|
than about the layout.
|
|
"""
|
|
|
|
monitor = monitor_named(output)
|
|
client = [c for c in compositor("clients") if c.get("initialClass") == output][0]
|
|
at = client["at"]
|
|
return (
|
|
monitor["x"] + nx * monitor["width"] - at[0],
|
|
monitor["y"] + ny * monitor["height"] - at[1],
|
|
)
|
|
|
|
|
|
def close_enough(got, want):
|
|
return abs(got[0] - want[0]) <= TOLERANCE and abs(got[1] - want[1]) <= TOLERANCE
|
|
|
|
|
|
start_all()
|
|
bring_up("the compositor and broker")
|
|
|
|
with subtest("the driver unit comes up and binds its socket"):
|
|
# Same reasoning as the broker's: `Type=simple` means wait_for_unit
|
|
# passes against a crash loop, so the socket and a restart count of
|
|
# zero are the honest test. The driver refuses to start at all if
|
|
# the compositor offers only a version-1 virtual-pointer manager --
|
|
# that refusal is deliberate (coordinates would be global and every
|
|
# warp would aim at the wrong output) and shows here as a restart
|
|
# loop with its own words in the journal.
|
|
try:
|
|
machine.wait_for_unit("hhstream-pointer.service", timeout=180)
|
|
machine.wait_for_file(POINTER_SOCKET, timeout=120)
|
|
machine.succeed("systemctl is-active hhstream-pointer.service")
|
|
restarts = machine.succeed(
|
|
"systemctl show -p NRestarts --value hhstream-pointer.service"
|
|
).strip()
|
|
assert restarts == "0", (
|
|
f"the driver has restarted {restarts} time(s); read its journal"
|
|
)
|
|
print(
|
|
machine.succeed(
|
|
"journalctl --no-pager --boot --unit hhstream-pointer.service"
|
|
)
|
|
)
|
|
except Exception:
|
|
dump("the pointer driver did not come up")
|
|
raise
|
|
|
|
with subtest("the broker reports the driver and a free cursor"):
|
|
try:
|
|
state = cli_json("pointer state --json")
|
|
print(json.dumps(state, indent=2, sort_keys=True))
|
|
assert state["holder"] is None, state
|
|
assert state["buttons"] == [], state
|
|
assert state["driver"] == POINTER_SOCKET, state
|
|
except Exception:
|
|
dump("pointer state is not what a fresh broker should report")
|
|
raise
|
|
|
|
with subtest("a session's window is in its container, under the cursor"):
|
|
try:
|
|
session_id = machine.succeed(cli("start target"), timeout=180).strip()
|
|
output = f"hh-{session_id}"
|
|
print(f"session {session_id} -> {output}")
|
|
machine.wait_until_succeeds(
|
|
f"{HYPRCTL} clients | jq -e --arg m {output}"
|
|
" 'any(.initialClass == $m)' >/dev/null",
|
|
timeout=120,
|
|
)
|
|
client = [
|
|
c for c in compositor("clients") if c.get("initialClass") == output
|
|
][0]
|
|
print(json.dumps(client, indent=2, sort_keys=True))
|
|
print(json.dumps(monitor_named(output), indent=2, sort_keys=True))
|
|
except Exception:
|
|
dump("the victim never got a window in its container", locals().get("session_id"))
|
|
raise
|
|
|
|
with subtest("acquire takes the cursor and the seat grows a pointer"):
|
|
# The seat of a headless session has *no* pointer capability until
|
|
# something creates a virtual one: there is no input device here.
|
|
# So the client cannot have bound `wl_pointer` before this point,
|
|
# and "target: pointer bound" appearing after the first warp is the
|
|
# proof that the driver's `zwlr_virtual_pointer_v1` reached the
|
|
# seat -- not merely that the broker thinks it sent something.
|
|
try:
|
|
reply = cli_json(f"pointer acquire --json {session_id}", timeout=120)
|
|
print(json.dumps(reply, indent=2, sort_keys=True))
|
|
bookmark = reply["bookmark"]
|
|
assert bookmark["output"] == output, bookmark
|
|
assert (bookmark["x"], bookmark["y"]) == (0.5, 0.5), (
|
|
f"with no bookmark the cursor must go to the centre: {bookmark}"
|
|
)
|
|
# A GAP, printed rather than asserted: the module's
|
|
# `sessions.pointer.leaseTtl` is rendered into the generated
|
|
# TOML and the broker reads neither the TOML nor any flag for
|
|
# it, so the lease runs on the broker's own default. The number
|
|
# below is the evidence.
|
|
print(
|
|
f"module leaseTtl={LEASE_TTL}s, broker reports "
|
|
f"expires_in_s={reply['expires_in_s']}"
|
|
)
|
|
wait_for(
|
|
lambda: "target: pointer bound" in pointer_log(session_id),
|
|
timeout=60,
|
|
what="the client to bind wl_pointer",
|
|
)
|
|
print(pointer_log(session_id))
|
|
except Exception:
|
|
dump("acquire did not reach the compositor", session_id)
|
|
raise
|
|
|
|
with subtest("a warp lands where it was aimed, as the application saw it"):
|
|
# Aimed off-centre so a wrong answer cannot coincide with the
|
|
# centre the acquire already warped to.
|
|
try:
|
|
aim = (0.25, 0.75)
|
|
before = len(positions(session_id))
|
|
moved = cli_json(
|
|
f"pointer move --json {session_id} --to {aim[0]},{aim[1]}", timeout=120
|
|
)
|
|
print(json.dumps(moved, indent=2, sort_keys=True))
|
|
assert (moved["bookmark"]["x"], moved["bookmark"]["y"]) == aim, moved
|
|
|
|
seen = wait_for(
|
|
lambda: positions(session_id)[before:],
|
|
timeout=60,
|
|
what="the client to report the warp",
|
|
)
|
|
want = aimed_at(*aim)
|
|
print(f"the client reports {seen}, aimed at {want}")
|
|
assert close_enough(seen[-1], want), (
|
|
f"the cursor arrived at {seen[-1]} and was aimed at {want}. "
|
|
"An offset of hundreds of pixels means the virtual pointer "
|
|
"speaks global coordinates, i.e. it was created without an "
|
|
"output."
|
|
)
|
|
except Exception:
|
|
dump("the warp did not land where it was aimed", session_id)
|
|
raise
|
|
|
|
with subtest("a click is delivered there, pressed and released"):
|
|
try:
|
|
before = len(buttons(session_id))
|
|
clicked = cli_json(f"pointer click --json {session_id}", timeout=120)
|
|
print(json.dumps(clicked, indent=2, sort_keys=True))
|
|
events = wait_for(
|
|
lambda: (
|
|
buttons(session_id)[before:]
|
|
if len(buttons(session_id)) >= before + 2
|
|
else None
|
|
),
|
|
timeout=60,
|
|
what="the client to report a press and a release",
|
|
)
|
|
print(f"the client reports: {events}")
|
|
assert {code for code, _, _, _ in events} == {0x110}, (
|
|
f"the client was sent {events}, not BTN_LEFT (0x110)"
|
|
)
|
|
assert [state for _, state, _, _ in events] == ["pressed", "released"], (
|
|
f"a click delivered {events}; it must be exactly one press "
|
|
"and one release, or something is left held down"
|
|
)
|
|
want = aimed_at(0.25, 0.75)
|
|
for _, state, x, y in events:
|
|
assert close_enough((x, y), want), (
|
|
f"the {state} arrived at ({x}, {y}), aimed at {want}"
|
|
)
|
|
except Exception:
|
|
dump("the click did not reach the application", session_id)
|
|
raise
|
|
|
|
with subtest("a second acquire is refused with BUSY, naming the holder"):
|
|
# The lock is broker-wide because the cursor is one (PLAN §6.2).
|
|
try:
|
|
other = machine.succeed(cli("start target"), timeout=180).strip()
|
|
print(f"second session: {other}")
|
|
code, out = machine.execute(
|
|
cli(f"pointer acquire {other}") + " 2>&1", timeout=120
|
|
)
|
|
print(f"exit {code}: {out}")
|
|
assert code == 8, f"a contended acquire exited {code}, not 8 (BUSY)"
|
|
assert session_id in out, (
|
|
f"the refusal does not name the holder {session_id}: {out!r}"
|
|
)
|
|
except Exception:
|
|
dump("a contended acquire was not refused", locals().get("other"))
|
|
raise
|
|
|
|
with subtest("a session that never acquired cannot move the cursor"):
|
|
# Exit 9 and not 8: an agent that sees 9 must acquire, one that
|
|
# sees 8 must wait, and conflating them is how a retry loop spins.
|
|
try:
|
|
code, out = machine.execute(
|
|
cli(f"pointer move {other} --to 0.5,0.5") + " 2>&1", timeout=120
|
|
)
|
|
print(f"exit {code}: {out}")
|
|
assert code == 9, f"a gesture with no lease exited {code}, not 9"
|
|
except Exception:
|
|
dump("a gesture without a lease was not refused", other)
|
|
raise
|
|
|
|
with subtest("release frees the lock and leaves the bookmark behind"):
|
|
try:
|
|
released = cli_json(f"pointer release --json {session_id}", timeout=120)
|
|
print(json.dumps(released, indent=2, sort_keys=True))
|
|
assert released["buttons_lifted"] == [], released
|
|
assert (released["bookmark"]["x"], released["bookmark"]["y"]) == (
|
|
0.25,
|
|
0.75,
|
|
), released
|
|
state = cli_json("pointer state --json")
|
|
assert state["holder"] is None, state
|
|
except Exception:
|
|
dump("release did not give the cursor back", session_id)
|
|
raise
|
|
|
|
with subtest("the cursor reaches a session that does not hold focus"):
|
|
# Two assertions in one, because they need the same situation: a
|
|
# second session exists and its window took focus when it opened
|
|
# (the BUSY subtest above started it).
|
|
#
|
|
# 1. `acquire` restores the bookmark the previous lease left --
|
|
# the point of a bookmark is that a gesture is resumable, and
|
|
# it is checked on the client's side as well as the broker's.
|
|
# 2. A warp is delivered to the session it was AIMED at, not to
|
|
# whichever window the compositor last focused -- and the
|
|
# focused one is told nothing. The lease and the containers
|
|
# are worth nothing if a click aimed at one session arrives at
|
|
# another, and `input:follow_mouse` is where that would go
|
|
# wrong (see the block at the top of this file).
|
|
try:
|
|
before = len(positions(session_id))
|
|
reply = cli_json(f"pointer acquire --json {session_id}", timeout=120)
|
|
print(json.dumps(reply, indent=2, sort_keys=True))
|
|
assert (reply["bookmark"]["x"], reply["bookmark"]["y"]) == (0.25, 0.75), (
|
|
f"acquire restored to {reply['bookmark']}, not where the "
|
|
"previous lease left the cursor"
|
|
)
|
|
focused = [
|
|
c.get("initialClass")
|
|
for c in compositor("clients")
|
|
if c.get("focusHistoryID") == 0
|
|
]
|
|
print(f"the compositor's focused window belongs to: {focused}")
|
|
assert focused and focused[0] != output, (
|
|
f"this subtest needs the OTHER session focused; {focused} is"
|
|
)
|
|
|
|
# Somewhere the cursor is not, so there is a motion to deliver
|
|
# (see the note at the top of this file).
|
|
elsewhere = (0.6, 0.4)
|
|
before_other = len(positions(other))
|
|
machine.succeed(
|
|
cli(f"pointer move {session_id} --to {elsewhere[0]},{elsewhere[1]}"),
|
|
timeout=120,
|
|
)
|
|
# Waits for EITHER client to report something, so a warp that
|
|
# went to the wrong one is a message naming where it went
|
|
# rather than a timeout naming nothing.
|
|
wait_for(
|
|
lambda: positions(session_id)[before:] or positions(other)[before_other:],
|
|
timeout=60,
|
|
what=f"either {session_id} or {other} to report the warp",
|
|
)
|
|
mine = positions(session_id)[before:]
|
|
theirs = positions(other)[before_other:]
|
|
print(f"aimed at {session_id}: it reports {mine}")
|
|
print(f"focused is {other}: it reports {theirs}")
|
|
print(f"cursor now at {compositor('cursorpos')}")
|
|
assert not theirs, (
|
|
f"the warp was aimed into {output} and {other}'s window got "
|
|
f"it: {theirs}. The compositor is routing pointer events by "
|
|
"keyboard focus, not by what is under the cursor -- read "
|
|
"input:follow_mouse in nix/hyprland-conf.nix."
|
|
)
|
|
want = aimed_at(*elsewhere)
|
|
print(f"the client reports {mine}, aimed at {want}")
|
|
assert close_enough(mine[-1], want), (mine[-1], want)
|
|
machine.succeed(cli(f"pointer release {session_id}"), timeout=120)
|
|
except Exception:
|
|
dump("the warp did not reach the session it was aimed at", session_id)
|
|
raise
|
|
|
|
with subtest("an expired lease is released and its button is lifted"):
|
|
# Real time, a caller-supplied TTL, and nothing touching the lease.
|
|
# The sweeper is what makes the TTL a promise: without it expiry
|
|
# would only be noticed by the next verb, so an agent that pressed
|
|
# a button and died would hold the cursor -- with the button down
|
|
# -- until somebody else happened to try.
|
|
try:
|
|
short = 8
|
|
cli_json(
|
|
f"pointer acquire --json --ttl {short}s {session_id}", timeout=120
|
|
)
|
|
before = len(buttons(session_id))
|
|
machine.succeed(cli(f"pointer down {session_id}"), timeout=120)
|
|
held = cli_json("pointer state --json")
|
|
print(json.dumps(held, indent=2, sort_keys=True))
|
|
assert held["holder"] == session_id, held
|
|
assert held["buttons"] == ["left"], (
|
|
f"the button is not recorded as down: {held}"
|
|
)
|
|
|
|
# One bounded wait for the deadline to arrive, not a retry of
|
|
# the assertion: the lease expires on its own or it does not.
|
|
machine.wait_until_succeeds(
|
|
cli("pointer state --json") + " | jq -e '.holder == null' >/dev/null",
|
|
timeout=short * 6 + 120,
|
|
)
|
|
state = cli_json("pointer state --json")
|
|
print(json.dumps(state, indent=2, sort_keys=True))
|
|
assert state["buttons"] == [], (
|
|
f"the lease expired with a button still down: {state}"
|
|
)
|
|
events = wait_for(
|
|
lambda: (
|
|
buttons(session_id)[before:]
|
|
if len(buttons(session_id)) >= before + 2
|
|
else None
|
|
),
|
|
timeout=60,
|
|
what="the client to be told the button came back up",
|
|
)
|
|
print(f"the client reports: {events}")
|
|
assert [s for _, s, _, _ in events] == ["pressed", "released"], (
|
|
"the application was told the button went down and never "
|
|
f"that it came up: {events}. A compositor left holding a "
|
|
"button is a drag nobody started."
|
|
)
|
|
except Exception:
|
|
dump("the lease did not expire cleanly", session_id)
|
|
raise
|
|
|
|
with subtest("a broker restart leaves the lock free and the bookmark intact"):
|
|
# Leases are stale by definition across a restart (PLAN §6.2); the
|
|
# bookmark is not, because it lives in the session record on disk.
|
|
try:
|
|
cli_json(f"pointer acquire --json {session_id}", timeout=120)
|
|
machine.succeed(cli(f"pointer move {session_id} --to 0.8,0.2"), timeout=120)
|
|
machine.succeed("systemctl restart hhstream-sessions.service", timeout=180)
|
|
machine.wait_for_unit("hhstream-sessions.service", timeout=180)
|
|
machine.wait_until_succeeds(cli("list") + " >/dev/null", timeout=120)
|
|
|
|
state = cli_json("pointer state --json")
|
|
print(json.dumps(state, indent=2, sort_keys=True))
|
|
assert state["holder"] is None, (
|
|
f"the restarted broker believes {state['holder']} still holds "
|
|
"a lease that died with the process that granted it"
|
|
)
|
|
record = cli_json(f"status --json {session_id}")["session"]
|
|
bookmark = (record.get("pointer") or {}).get("bookmark")
|
|
print(json.dumps(bookmark, indent=2, sort_keys=True))
|
|
assert bookmark is not None, record
|
|
assert (bookmark["x"], bookmark["y"]) == (0.8, 0.2), (
|
|
f"the bookmark did not survive the restart: {bookmark}"
|
|
)
|
|
assert bookmark["output"] == output, bookmark
|
|
except Exception:
|
|
dump("the restart lost the lock or the bookmark", session_id)
|
|
raise
|
|
|
|
with subtest("the driver is still reachable after the broker restarted"):
|
|
# The socket the two speak over lives in the broker's runtime
|
|
# directory. Without `RuntimeDirectoryPreserve` on that unit,
|
|
# restarting the broker deletes /run/hhstream and takes
|
|
# pointer.sock with it -- leaving the driver listening on an
|
|
# unlinked inode and every pointer verb answering exit 10 while
|
|
# `systemctl status hhstream-pointer` still says "active".
|
|
try:
|
|
machine.succeed(f"test -S {POINTER_SOCKET}")
|
|
machine.succeed("systemctl is-active hhstream-pointer.service")
|
|
reply = cli_json(f"pointer acquire --json {session_id}", timeout=120)
|
|
print(json.dumps(reply, indent=2, sort_keys=True))
|
|
assert reply["bookmark"]["x"] == 0.8, reply
|
|
machine.succeed(cli(f"pointer release {session_id}"), timeout=120)
|
|
except Exception:
|
|
dump("the driver was unreachable after the broker restarted", session_id)
|
|
raise
|
|
'';
|
|
}
|
|
)
|