"""Start-up reconciliation: adopt what is ours, remove what is unattended. A container is a render target that costs CPU and a place windows can land, so one with no live session must never be left behind — and a broker that lost its registry recovers by exactly this scan. The danger is the other direction: the scan deletes outputs, so everything here is also a test that it deletes only what :func:`hhstreamd.containers.contains_output` claims. """ from __future__ import annotations import asyncio import os from pathlib import Path import pytest from fakes import FakeCompositor from hhstreamd import procmon from hhstreamd.clock import ManualClock from hhstreamd.manager import ManagerConfig, SessionManager from hhstreamd.policy import Policy from hhstreamd.registry import ContainerState, Session, State, container_record def make_session(session_id: str, *, output: str | None, workspace: int | None, **kwargs) -> Session: return Session( id=session_id, app="foot", argv=["/usr/bin/foot"], pid=4242, pgid=4242, sid=4242, pid_starttime=1, cmdline_sha256="9f2c", home="/home/someone", runtime_dir=f"/run/hhstream/sessions/{session_id}", created_at="2026-10-01T09:14:02Z", created_boottime=1000.0, last_activity_at="2026-10-01T09:14:02Z", last_activity_boottime=1000.0, idle_timeout_s=10800.0, state=State.READY, container=container_record( output=output, workspace=workspace, mode=(1280, 720), created_by="broker", state=ContainerState.OWNED, ), **kwargs, ) @pytest.fixture def compositor(short_tmpdir: Path): fake = FakeCompositor(short_tmpdir) try: yield fake finally: fake.stop() @pytest.fixture def manager(short_tmpdir: Path, compositor: FakeCompositor) -> SessionManager: return SessionManager( ManagerConfig( state_dir=short_tmpdir / "state", runtime_dir=short_tmpdir / "run", policy=Policy(), compositor_runtime_dir=compositor.runtime_dir, signature=compositor.signature, ), clock=ManualClock(boottime=1000.0), ) def test_an_unattended_output_is_removed_at_start_up(manager, compositor): compositor.add_output("hh-ghost-aaaaaa") summary = manager.reconcile_containers() assert summary["removed"] == ["hh-ghost-aaaaaa"] assert "hh-ghost-aaaaaa" not in compositor.outputs() @pytest.mark.parametrize("name", ["HEADLESS-1", "DP-1", "hh-", "hh-Upper", "hhother"]) def test_an_output_the_filter_rejects_is_never_touched(manager, compositor, name): """The one thing between this scan and somebody else's monitor.""" compositor.add_output(name) summary = manager.reconcile_containers() assert summary["removed"] == [] assert name in compositor.outputs() def test_a_container_with_a_live_session_is_adopted_not_removed(manager, compositor): compositor.add_output("hh-foot-aaaaaa") manager.registry.add( make_session("foot-aaaaaa", output="hh-foot-aaaaaa", workspace=1002, signature=compositor.signature) ) summary = manager.reconcile_containers() assert summary["adopted"] == [{"id": "foot-aaaaaa", "output": "hh-foot-aaaaaa"}] assert summary["removed"] == [] assert "hh-foot-aaaaaa" in compositor.outputs() def test_an_adopted_workspace_is_not_handed_to_the_next_session(manager, compositor): """After a restart the records name slots that are still in use.""" compositor.add_output("hh-foot-aaaaaa") manager.registry.add( make_session("foot-aaaaaa", output="hh-foot-aaaaaa", workspace=1000, signature=compositor.signature) ) manager.reconcile_containers() assert manager.host.allocator.in_use() == [1000] assert manager.host.create("foot-bbbbbb", "hh-foot-bbbbbb").workspace == 1001 def test_a_record_naming_an_output_that_is_gone_is_marked_orphan(manager, compositor): """The application may still be running, so nothing is killed for this.""" session = manager.registry.add( make_session("foot-aaaaaa", output="hh-foot-aaaaaa", workspace=1000, signature=compositor.signature) ) summary = manager.reconcile_containers() assert session.container["state"] == ContainerState.ORPHAN assert summary["orphaned"] == [{"id": "foot-aaaaaa", "output": "hh-foot-aaaaaa"}] assert session.live, "losing a container is not losing the session" def test_a_container_from_a_previous_compositor_instance_is_not_claimed(manager, compositor): """This is what the recorded signature is for. The output name would match, and adopting it would hand this broker a container that died with its compositor — and reserve a workspace slot in an instance that never allocated one. """ compositor.add_output("hh-foot-aaaaaa") session = manager.registry.add( make_session("foot-aaaaaa", output="hh-foot-aaaaaa", workspace=1000, signature="an-older-instance") ) summary = manager.reconcile_containers() assert session.container["state"] == ContainerState.ORPHAN assert summary["orphaned"] == [{"id": "foot-aaaaaa", "why": "signature_changed"}] # Unclaimed, so the scan takes it down like any other unattended output. assert summary["removed"] == ["hh-foot-aaaaaa"] assert manager.host.allocator.in_use() == [] def test_the_quarantine_backstop_is_installed_before_anything_else(manager, compositor): manager.reconcile_containers() keywords = [c for c in compositor.commands if c.startswith("keyword")] assert keywords[0].startswith("keyword windowrule match:initial_class .*,") def test_no_compositor_leaves_the_broker_degraded_rather_than_refusing(short_tmpdir: Path): manager = SessionManager( ManagerConfig( state_dir=short_tmpdir / "state", runtime_dir=short_tmpdir / "run", policy=Policy(), compositor_runtime_dir=short_tmpdir / "no-compositor", ), clock=ManualClock(boottime=1000.0), ) summary = manager.reconcile_containers() assert summary["available"] is False assert summary["removed"] == [] assert manager.containers_available is False assert "no-compositor" in summary["error"] def test_container_list_will_not_claim_there_are_no_orphans_without_looking(short_tmpdir): """`[]` would read as "nothing is out there", which we cannot know.""" manager = SessionManager( ManagerConfig( state_dir=short_tmpdir / "state", runtime_dir=short_tmpdir / "run", policy=Policy(), compositor_runtime_dir=short_tmpdir / "no-compositor", ), clock=ManualClock(boottime=1000.0), ) manager.reconcile_containers() listing = manager.container_list() assert listing["orphans"] is None assert listing["compositor"] == "absent" def test_container_list_names_the_orphans_it_can_see(manager, compositor): compositor.add_output("hh-ghost-aaaaaa") manager.containers_available = True manager.registry.add( make_session("foot-aaaaaa", output="hh-foot-aaaaaa", workspace=1000, signature=compositor.signature) ) compositor.add_output("hh-foot-aaaaaa") listing = manager.container_list() assert listing["orphans"] == ["hh-ghost-aaaaaa"] assert [row["id"] for row in listing["containers"]] == ["foot-aaaaaa"] # Listing is not acting: the orphan is still there afterwards. assert "hh-ghost-aaaaaa" in compositor.outputs() def test_gc_takes_down_the_container_of_a_session_it_tombstones(manager, compositor): """`gc` is the last thing that will ever look at that session. It tombstones a record whose process vanished without the watcher noticing; if it did not also take the output down, nothing else would, until the next broker start-up found it unattended. """ compositor.add_output("hh-foot-aaaaaa") session = manager.registry.add( make_session("foot-aaaaaa", output="hh-foot-aaaaaa", workspace=1000, signature=compositor.signature) ) manager.reconcile_containers() # adopts it, and reserves its slot # A pid that is not a process: what `gc` is for. session.pid = session.pgid = session.sid = 4_194_303 result = asyncio.run(manager.gc()) entry = {row["id"]: row for row in result["reconciled"]}["foot-aaaaaa"] assert entry["container_removed"] is True assert entry["container_survivors"] == [] assert "hh-foot-aaaaaa" not in compositor.outputs() assert session.container["state"] == ContainerState.REMOVED assert manager.host.allocator.in_use() == [], "the slot came back" def test_gc_leaves_a_healthy_session_s_container_alone(manager, compositor): compositor.add_output("hh-foot-aaaaaa") session = manager.registry.add( make_session("foot-aaaaaa", output="hh-foot-aaaaaa", workspace=1000, signature=compositor.signature) ) manager.reconcile_containers() # This process: alive, and its own identity. identity = procmon.identity(os.getpid()) session.pid, session.pgid, session.sid = os.getpid(), identity.pgid, identity.sid session.pid_starttime = identity.starttime session.cmdline_sha256 = identity.cmdline_sha256 asyncio.run(manager.gc()) assert "hh-foot-aaaaaa" in compositor.outputs() assert session.container["state"] == ContainerState.OWNED def test_reconciling_everything_rescans_the_outputs_and_every_session(manager, compositor): """`container.reconcile` with no id is the start-up scan, on demand.""" compositor.add_output("hh-foot-aaaaaa") session = manager.registry.add( make_session("foot-aaaaaa", output="hh-foot-aaaaaa", workspace=1000, signature=compositor.signature) ) manager.reconcile_containers() compositor.add_output("hh-ghost-aaaaaa") compositor.add_window("hh-foot-aaaaaa", 1000, "hh-foot-aaaaaa") result = asyncio.run(manager.container_reconcile(None)) assert result["scan"]["removed"] == ["hh-ghost-aaaaaa"] assert result["scan"]["adopted"] == [{"id": "foot-aaaaaa", "output": "hh-foot-aaaaaa"}] # The window that appeared while nobody was looking is now in the record. assert session.window["initial_class"] == "hh-foot-aaaaaa" assert {d["field"] for d in result["diff"]} == {"workspace", "window"} # The slot stays reserved across a second scan rather than being hunted # for again in a band it is itself occupying. assert manager.host.allocator.in_use() == [1000]