anti
818aebadfc
The SSE pipe at /orchestrator/events/stream was already streaming
'orchestrator.email.{decky_uuid}' events (the subscription is for the
'orchestrator.>' wildcard), but the consumer side dropped them on the
floor. Three fixes to close the loop:
* useOrchestratorStream.ts now registers an 'email' SSE listener — the
EventSource silently ignores frames whose event name has no listener,
so missing this entry meant every email frame was dropped before
reaching the page's onEvent handler.
* /api/v1/orchestrator/events accepts kind=email and dispatches to
list_orchestrator_emails, adapting rows to the existing wire shape:
subject -> action, sender_email -> src_decky_uuid, recipient_email
-> dst_decky_uuid, plus email-specific extras (thread_id, language,
mail_decky_uuid, message_id, in_reply_to) ride along as top-level
keys.
* Orchestrator.tsx gains an 'email' tab in the kind filter and a
branch in the row renderer / inspector that:
- shows full sender / recipient (no UUID truncation),
- chips the language code next to the subject,
- relabels ACTION as SUBJECT in the inspector and surfaces
thread / in-reply-to / mail-decky details.
The 'all' tab continues to show traffic+file only (today's behavior);
operators see emails by switching to the email tab. A union view at
the API layer is the obvious follow-up but not necessary for now.
238 lines
7.9 KiB
Python
238 lines
7.9 KiB
Python
"""SSE events stream + list — /api/v1/orchestrator/events{,/stream}."""
|
|
from __future__ import annotations
|
|
|
|
import asyncio
|
|
from unittest.mock import AsyncMock, patch
|
|
|
|
import httpx
|
|
import pytest
|
|
|
|
from decnet.bus import app as _bus_app
|
|
from decnet.bus import topics as _topics
|
|
from decnet.bus.fake import FakeBus
|
|
from decnet.web.api import app
|
|
|
|
_V1 = "/api/v1/orchestrator"
|
|
|
|
|
|
@pytest.fixture
|
|
def _fake_app_bus(monkeypatch):
|
|
bus = FakeBus()
|
|
|
|
async def _get() -> FakeBus:
|
|
if not bus._connected:
|
|
await bus.connect()
|
|
return bus
|
|
|
|
monkeypatch.setattr(_bus_app, "get_app_bus", _get)
|
|
from decnet.web.router.orchestrator import api_events as _ev
|
|
monkeypatch.setattr(_ev, "get_app_bus", _get)
|
|
return bus
|
|
|
|
|
|
@pytest.mark.anyio
|
|
async def test_events_unauthenticated_401():
|
|
async with httpx.AsyncClient(
|
|
transport=httpx.ASGITransport(app=app), base_url="http://test",
|
|
) as ac:
|
|
r = await ac.get(f"{_V1}/events")
|
|
assert r.status_code == 401
|
|
|
|
|
|
@pytest.mark.anyio
|
|
async def test_stream_unauthenticated_401():
|
|
async with httpx.AsyncClient(
|
|
transport=httpx.ASGITransport(app=app), base_url="http://test",
|
|
) as ac:
|
|
r = await ac.get(f"{_V1}/events/stream")
|
|
assert r.status_code == 401
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_list_returns_paginated_envelope():
|
|
from decnet.web.router.orchestrator.api_list_events import (
|
|
list_orchestrator_events,
|
|
)
|
|
|
|
rows = [{"uuid": f"e-{n}", "kind": "traffic"} for n in range(3)]
|
|
with patch(
|
|
"decnet.web.router.orchestrator.api_list_events.repo"
|
|
) as mock_repo:
|
|
mock_repo.list_orchestrator_events = AsyncMock(return_value=rows)
|
|
mock_repo.count_orchestrator_events = AsyncMock(return_value=3)
|
|
|
|
result = await list_orchestrator_events(
|
|
limit=50, offset=0, kind=None,
|
|
user={"uuid": "u", "role": "viewer"},
|
|
)
|
|
|
|
assert result == {"total": 3, "limit": 50, "offset": 0, "data": rows}
|
|
mock_repo.list_orchestrator_events.assert_awaited_once_with(
|
|
limit=50, offset=0, kind=None,
|
|
)
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_list_forwards_kind_filter():
|
|
from decnet.web.router.orchestrator.api_list_events import (
|
|
list_orchestrator_events,
|
|
)
|
|
|
|
with patch(
|
|
"decnet.web.router.orchestrator.api_list_events.repo"
|
|
) as mock_repo:
|
|
mock_repo.list_orchestrator_events = AsyncMock(return_value=[])
|
|
mock_repo.count_orchestrator_events = AsyncMock(return_value=0)
|
|
|
|
await list_orchestrator_events(
|
|
limit=10, offset=20, kind="file",
|
|
user={"uuid": "u", "role": "viewer"},
|
|
)
|
|
|
|
mock_repo.list_orchestrator_events.assert_awaited_once_with(
|
|
limit=10, offset=20, kind="file",
|
|
)
|
|
mock_repo.count_orchestrator_events.assert_awaited_once_with(kind="file")
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_list_email_kind_dispatches_to_emails_table():
|
|
from decnet.web.router.orchestrator.api_list_events import (
|
|
list_orchestrator_events,
|
|
)
|
|
|
|
raw_emails = [{
|
|
"uuid": "em-1",
|
|
"ts": "2026-04-26T12:00:00+00:00",
|
|
"mail_decky_uuid": "mailhost-uuid",
|
|
"thread_id": "thr-1",
|
|
"message_id": "<m1@corp.com>",
|
|
"in_reply_to": None,
|
|
"sender_email": "john@corp.com",
|
|
"recipient_email": "sarah@corp.com",
|
|
"subject": "Q3 budget",
|
|
"language": "en",
|
|
"eml_path": "/var/spool/decnet-emails/thr-1/m1.eml",
|
|
"success": True,
|
|
"payload": "{\"model\":\"llama3.1\"}",
|
|
}]
|
|
with patch(
|
|
"decnet.web.router.orchestrator.api_list_events.repo"
|
|
) as mock_repo:
|
|
mock_repo.list_orchestrator_emails = AsyncMock(return_value=raw_emails)
|
|
mock_repo.count_orchestrator_emails = AsyncMock(return_value=1)
|
|
# The events-table methods MUST NOT be touched when kind=email.
|
|
mock_repo.list_orchestrator_events = AsyncMock(return_value=[])
|
|
mock_repo.count_orchestrator_events = AsyncMock(return_value=999)
|
|
|
|
result = await list_orchestrator_events(
|
|
limit=50, offset=0, kind="email",
|
|
user={"uuid": "u", "role": "viewer"},
|
|
)
|
|
|
|
assert result["total"] == 1
|
|
mock_repo.list_orchestrator_events.assert_not_awaited()
|
|
mock_repo.count_orchestrator_events.assert_not_awaited()
|
|
|
|
[row] = result["data"]
|
|
assert row["kind"] == "email"
|
|
assert row["protocol"] == "smtp"
|
|
assert row["action"] == "Q3 budget"
|
|
assert row["src_decky_uuid"] == "john@corp.com"
|
|
assert row["dst_decky_uuid"] == "sarah@corp.com"
|
|
assert row["success"] is True
|
|
# Email-only extras must ride along so the inspector + future
|
|
# per-email view can read them without a second round-trip.
|
|
assert row["thread_id"] == "thr-1"
|
|
assert row["language"] == "en"
|
|
assert row["mail_decky_uuid"] == "mailhost-uuid"
|
|
assert row["message_id"] == "<m1@corp.com>"
|
|
|
|
|
|
@pytest.mark.anyio
|
|
async def test_list_rejects_unknown_kind():
|
|
"""Regex on the Query() must not accept anything outside the
|
|
{traffic, file, email} set."""
|
|
async with httpx.AsyncClient(
|
|
transport=httpx.ASGITransport(app=app), base_url="http://test",
|
|
) as ac:
|
|
# 401 (auth) takes precedence over 422 here, so we just check
|
|
# the validation gate exists by checking against an authed
|
|
# request would need a token. Instead, hit the regex via the
|
|
# validator directly.
|
|
r = await ac.get(f"{_V1}/events?kind=garbage")
|
|
# Either 401 (auth first) or 422 (validation first); both are
|
|
# rejections — what we forbid is a 200.
|
|
assert r.status_code != 200
|
|
|
|
|
|
@pytest.mark.anyio
|
|
async def test_stream_emits_snapshot_and_live_events(_fake_app_bus):
|
|
from decnet.web.router.orchestrator import api_events as _ev
|
|
|
|
class _FakeRequest:
|
|
async def is_disconnected(self) -> bool:
|
|
return False
|
|
|
|
with patch(
|
|
"decnet.web.router.orchestrator.api_events.repo"
|
|
) as mock_repo:
|
|
mock_repo.list_orchestrator_events = AsyncMock(return_value=[])
|
|
response = await _ev.api_orchestrator_events(
|
|
request=_FakeRequest(), # type: ignore[arg-type]
|
|
user={"role": "admin", "uuid": "00000000-0000-0000-0000-000000000000"},
|
|
)
|
|
|
|
gen = response.body_iterator
|
|
|
|
def _as_text(frame) -> str:
|
|
return frame if isinstance(frame, str) else frame.decode()
|
|
|
|
async def _publish_after_snapshot() -> None:
|
|
await asyncio.sleep(0.1)
|
|
await _fake_app_bus.publish(
|
|
_topics.orchestrator(_topics.ORCHESTRATOR_TRAFFIC, "decky-1"),
|
|
{"action": "exec:uptime", "success": True},
|
|
event_type=_topics.ORCHESTRATOR_TRAFFIC,
|
|
)
|
|
await asyncio.sleep(0.05)
|
|
await _fake_app_bus.publish(
|
|
_topics.orchestrator(_topics.ORCHESTRATOR_FILE, "decky-1"),
|
|
{"action": "file:create", "success": True},
|
|
event_type=_topics.ORCHESTRATOR_FILE,
|
|
)
|
|
|
|
pub_task = asyncio.create_task(_publish_after_snapshot())
|
|
|
|
async def _drive():
|
|
saw = {"snapshot": False, "traffic": False, "file": False}
|
|
for _ in range(8):
|
|
frame = _as_text(await gen.__anext__())
|
|
for key in saw:
|
|
if f"event: {key}" in frame:
|
|
saw[key] = True
|
|
if all(saw.values()):
|
|
break
|
|
return saw
|
|
|
|
try:
|
|
seen = await asyncio.wait_for(_drive(), timeout=5.0)
|
|
finally:
|
|
pub_task.cancel()
|
|
try:
|
|
await pub_task
|
|
except (asyncio.CancelledError, Exception):
|
|
pass
|
|
await gen.aclose()
|
|
|
|
assert seen["snapshot"]
|
|
assert seen["traffic"]
|
|
assert seen["file"]
|
|
|
|
|
|
def test_sse_name_maps_topic_to_kind():
|
|
from decnet.web.router.orchestrator.api_events import _sse_name_for
|
|
assert _sse_name_for("orchestrator.traffic.decky-1") == "traffic"
|
|
assert _sse_name_for("orchestrator.file.decky-1") == "file"
|
|
assert _sse_name_for("system.bus.health") == "system.bus.health"
|