Files
hyprland-headless-stream-pl…/tests/sessions/unit/test_container_host.py
T
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

289 lines
10 KiB
Python

"""Running container plans against a compositor-shaped socket.
The compositor here is a real ``AF_UNIX`` listener laid out the way Hyprland
lays one out, answering the commands Hyprland answers. That proves the wiring
— the right commands, in the right order, and a record built from the reply
rather than from the request. It does **not** prove Hyprland agrees: see the
slice report for what is unverified.
"""
from __future__ import annotations
from pathlib import Path
import pytest
from fakes import WINDOW_PID, FakeCompositor
from hhstreamd import containers
from hhstreamd.container_host import ContainerHost
from hhstreamd.ipc import CompositorUnavailable
@pytest.fixture
def compositor(short_tmpdir: Path):
fake = FakeCompositor(short_tmpdir)
try:
yield fake
finally:
fake.stop()
def make_host(fake: FakeCompositor, *, slots: int = 4) -> ContainerHost:
return ContainerHost(
fake.runtime_dir,
allocator=containers.WorkspaceAllocator(1000, slots),
signature=fake.signature,
)
def test_a_live_compositor_is_available_and_names_its_instance(compositor):
host = make_host(compositor)
assert host.available() is True
# The signature goes in the record so a restarted broker re-attaches to
# this instance rather than whichever one is there later.
assert host.signature == compositor.signature
def test_no_compositor_is_unavailable_and_says_why(short_tmpdir: Path):
host = ContainerHost(
short_tmpdir / "nothing-here",
allocator=containers.WorkspaceAllocator(1000, 2),
)
assert host.available() is False
assert host.last_error and "nothing-here" in host.last_error
def test_no_runtime_directory_at_all_is_unavailable_rather_than_an_error(short_tmpdir):
"""A broker with no `--compositor-runtime-dir` still has to start."""
host = ContainerHost(None, allocator=containers.WorkspaceAllocator(1000, 2))
assert host.available() is False
assert "no compositor runtime directory" in (host.last_error or "")
def test_create_runs_the_plan_in_order_and_the_output_appears(compositor):
host = make_host(compositor)
host.available()
plan = host.create("foot-aaaaaa", "hh-foot-aaaaaa")
assert plan.output == "hh-foot-aaaaaa"
assert plan.workspace == 1000
# The plan's own order, which is load-bearing: the output has to exist
# before a rule can name it, and the mode is set on an output that is
# already there.
queries = ("version", "clients", "monitors", "workspaces")
assert [c for c in compositor.commands if not c.startswith(queries)] == [
"output create headless hh-foot-aaaaaa",
"keyword workspace 1000, monitor:hh-foot-aaaaaa, default:true, persistent:true",
"keyword windowrule match:initial_class ^hh-foot-aaaaaa$, workspace 1000, "
"monitor hh-foot-aaaaaa",
"keyword monitor hh-foot-aaaaaa,1280x720,auto,1",
]
assert "hh-foot-aaaaaa" in compositor.outputs()
assert compositor.workspaces_on("hh-foot-aaaaaa") == [1000]
def test_the_quarantine_backstop_goes_in_before_any_container_rule(compositor):
"""Rules are applied in declaration order, so the catch-all must be first.
Installed after a session's anchored rule, the catch-all would override it
and sweep that session's own window into the special workspace — the exact
leak containers exist to prevent.
"""
host = make_host(compositor)
host.available()
assert host.install_quarantine() is True
host.create("foot-aaaaaa", "hh-foot-aaaaaa")
rules = [c for c in compositor.commands if c.startswith("keyword windowrule")]
assert rules[0] == "keyword windowrule match:initial_class .*, workspace special:quarantine"
assert rules[1].startswith("keyword windowrule match:initial_class ^hh-foot-aaaaaa$")
def test_a_blank_quarantine_workspace_installs_nothing(compositor):
host = ContainerHost(
compositor.runtime_dir,
allocator=containers.WorkspaceAllocator(1000, 2),
quarantine_workspace=" ",
)
host.available()
assert host.install_quarantine() is False
assert not [c for c in compositor.commands if c.startswith("keyword")]
def test_a_refused_command_is_reported_and_the_slot_is_given_back(compositor):
"""A half-built container must not also leak a workspace number."""
host = make_host(compositor)
host.available()
compositor.refuse.add("keyword monitor hh-foot-aaaaaa,1280x720,auto,1")
with pytest.raises(CompositorUnavailable) as exc:
host.create("foot-aaaaaa", "hh-foot-aaaaaa")
assert "refused" in str(exc.value)
assert host.allocator.in_use() == []
def test_read_back_reports_the_compositor_s_answer_not_ours(compositor):
host = make_host(compositor)
host.available()
host.create("foot-aaaaaa", "hh-foot-aaaaaa")
facts = host.read_back("hh-foot-aaaaaa")
assert facts is not None
assert facts.workspace == 1000
# The output is joined through the *workspace's* monitor name, because a
# client reports its monitor as a numeric index and `ipc.Monitor` carries
# no id to join that against (see the slice report).
assert facts.output == "hh-foot-aaaaaa"
assert facts.window["initial_class"] == "hh-foot-aaaaaa"
assert facts.window["stable_id"] == f"hh-foot-aaaaaa:{WINDOW_PID}"
# Titles contain commas; the client must not have lost the end of one.
assert facts.window["title"] == "a window, with a comma in its title"
def test_foreground_is_the_monitor_active_workspace_join(compositor):
"""Not the client's `visible` flag: "is anyone actually looking at this"."""
host = make_host(compositor)
host.available()
host.create("foot-aaaaaa", "hh-foot-aaaaaa")
assert host.read_back("hh-foot-aaaaaa").foreground is True
compositor.focus("hh-foot-aaaaaa", 9999)
assert host.read_back("hh-foot-aaaaaa").foreground is False
def test_no_window_yet_is_none_and_not_an_invented_one(compositor):
host = make_host(compositor)
host.available()
compositor.auto_window = False
host.create("foot-aaaaaa", "hh-foot-aaaaaa")
assert host.read_back("hh-foot-aaaaaa") is None
def test_a_window_that_kept_its_own_class_is_still_found_by_pid(compositor):
"""An application that ignored the stamp is observed, not pretended away."""
host = make_host(compositor)
host.available()
compositor.auto_window = False
host.create("foot-aaaaaa", "hh-foot-aaaaaa")
compositor.add_window("firefox", 1, "HEADLESS-1", pid=777)
facts = host.read_back("hh-foot-aaaaaa", pid=777)
assert facts is not None
assert facts.window["initial_class"] == "firefox"
# On the shared output, not the container's: the rule did not bind, and
# the caller is the one that has to say so.
assert facts.output == "HEADLESS-1"
def test_remove_takes_the_output_and_its_windows_with_it(compositor):
host = make_host(compositor)
host.available()
plan = host.create("foot-aaaaaa", "hh-foot-aaaaaa")
host.remove(plan.output)
assert "hh-foot-aaaaaa" not in compositor.outputs()
assert compositor.windows() == []
assert host.survivors("hh-foot-aaaaaa", plan.output) == []
def test_a_window_that_outlives_the_output_is_reported_as_a_survivor(compositor):
"""Teardown reports what is left rather than declaring success."""
host = make_host(compositor)
host.available()
host.create("foot-aaaaaa", "hh-foot-aaaaaa")
# A second window of ours that landed somewhere else entirely.
compositor.add_window("hh-foot-aaaaaa", 1, "HEADLESS-1", pid=999)
host.remove("hh-foot-aaaaaa")
survivors = host.survivors("hh-foot-aaaaaa", "hh-foot-aaaaaa")
assert [s["pid"] for s in survivors] == [999]
@pytest.mark.parametrize("name", ["HEADLESS-1", "hh-", "HH-x", "eDP-1", "hh-Foo"])
def test_remove_refuses_any_name_the_filter_rejects(compositor, name):
"""`contains_output` is the only thing between the scan and someone
else's monitor, so the removal path asks it too."""
host = make_host(compositor)
host.available()
with pytest.raises(ValueError) as exc:
host.remove(name)
assert "not one this broker creates" in str(exc.value)
def test_our_outputs_lists_only_names_this_broker_could_have_made(compositor):
host = make_host(compositor)
host.available()
host.create("foot-aaaaaa", "hh-foot-aaaaaa")
compositor.add_output("DP-1")
compositor.add_output("hh-orphan-zzzzzz")
assert host.our_outputs() == ["hh-foot-aaaaaa", "hh-orphan-zzzzzz"]
def test_reserve_re_takes_an_adopted_slot_so_it_is_not_handed_out_twice(compositor):
"""After a restart the records name workspaces that are still in use."""
host = make_host(compositor)
assert host.reserve([1002]) == [1002]
assert host.allocator.in_use() == [1002]
# The slots walked past on the way there were given back, so the next
# session still gets the lowest free one.
assert host.allocator.allocate() == 1000
def test_reserving_a_slot_this_allocator_already_holds_is_not_a_second_hunt(compositor):
"""Reconcile runs more than once; the second pass must be a no-op."""
host = make_host(compositor, slots=2)
assert host.reserve([1001]) == [1001]
assert host.reserve([1001]) == [1001]
assert host.allocator.in_use() == [1001]
assert host.allocator.allocate() == 1000
def test_reserve_is_a_no_op_for_a_session_that_never_had_a_slot(compositor):
host = make_host(compositor)
assert host.reserve([None, None]) == []
assert host.allocator.in_use() == []
def test_release_tolerates_a_slot_this_allocator_never_held(compositor):
"""Teardown runs for sessions started before the broker restarted too."""
host = make_host(compositor)
host.release(1003) # must not raise: the application is already dead
host.release(None)
assert host.allocator.in_use() == []
def test_a_plan_entry_that_is_not_hyprctl_is_a_bug_and_says_so(compositor):
host = make_host(compositor)
host.available()
with pytest.raises(ValueError) as exc:
host.dispatch(["sh", "-c", "rm -rf /"])
assert "not a hyprctl plan entry" in str(exc.value)