samiandClaude Sonnet 5
824fa481bb
The two items aimed at pointing GUI at a real veloxd instead of mockd.
rpc/event_hub — per-subscription fan-out shared by both transports.
subscribe() registers a connection with no interest; set_filter()
(session.subscribe, replaces not adds) turns on event kinds and an
optional per-task id filter; publish() delivers a pre-built
notification to every matching subscriber. session.subscribe on both
UdsServer and WsServer now does the real thing — registers/updates a
subscription, tears it down in close_conn.
sched/scheduler — the on_engine_state hook now actually publishes:
- transition() is the one place a task's row changes state; it reads
the store's own prior row for previousState (authoritative
regardless of engine/scheduler timing), writes the error columns,
and — when a hub is supplied — publishes event.task.state with
{taskId, state, previousState, summary, error}. Wired into every
transition: scheduler-driven (admission -> probing, resume ->
connecting, pause) and engine-reported (on_engine_state).
- progress_snapshot(): one row per task the engine is tracking
(EnginePort::progress(), a new interface method backed by
DownloadHandle::progress()), plus a store side-effect
(Tasks::update_progress) so download.list/get stay current between
state transitions. Returns rows; does NOT publish itself — batching
into one array message is the caller's job, per the schema's
x-maxRateHz: 4 and AGENT-DAEMON.md item 5 ("one message per task per
tick burns a core"). main.cpp's 250 ms timerfd is that caller: one
event.task.progress per tick, only when there's something to say.
dispatcher::on_download_add now publishes event.task.added (schema:
"summary is always present so a client can insert the row without a
follow-up download.get").
store/categories, store/queues — the two D3 handlers GUI's panels
call. category.list projects the six seeded built-ins; queue.list
derives taskIds from tasks.queue_id/queue_position (Queue's own schema
note: a queue's stored row never carries membership, download.update
/ queue.reorder do).
Verified live end to end against tools/testserver: a subscribed client
sees event.task.added on add, then the full event.task.state sequence
(queued -> probing -> connecting -> downloading -> assembling ->
verifying -> complete) with correct previousState at every step, and
real category.list / queue.list results.
Tests: event_hub (filter-by-kind, filter-by-task-id, replace-not-add,
unsubscribe), store_categories_queues, plus new sched_scheduler cases
for event.task.state publishing and progress_snapshot's store
side-effect. 38 daemon/cli tests green; sched_scheduler / event_hub /
ws_server / uds_roundtrip TSan-clean.
deferrals.md: D5 mostly closed (event.task.removed and the
still-unpublished events wait on their owning D3 handlers); D3 down to
the remaining download.* verbs, rules/settings/limiter/schedule,
queue mutation, category mutation, grabber, media.
Co-Authored-By: Claude Sonnet 5 <[email protected]>
Claude-Session: https://claude.ai/code/session_01Upd9WhG9oppieig5nRDLig
69 lines
3.0 KiB
C++
69 lines
3.0 KiB
C++
#include "rpc/event_hub.hpp"
|
|
|
|
#include <nlohmann/json.hpp>
|
|
|
|
#include "check.hpp"
|
|
|
|
using velox::daemon::rpc::EventHub;
|
|
namespace proto = velox::proto;
|
|
|
|
void run() {
|
|
EventHub hub;
|
|
|
|
// --- no subscribers: publish is a no-op, not an error --------------------------
|
|
hub.publish(proto::Event::TaskAdded, nlohmann::json{{"x", 1}});
|
|
|
|
// --- a subscription with no filter set receives nothing -------------------
|
|
std::vector<nlohmann::json> a;
|
|
const auto sub_a = hub.subscribe([&](const nlohmann::json& n) { a.push_back(n); });
|
|
hub.publish(proto::Event::TaskAdded, nlohmann::json{{"n", 1}});
|
|
CHECK_EQ(a.size(), 0u);
|
|
|
|
// --- filtering by event kind ------------------------------------------------
|
|
hub.set_filter(sub_a, {proto::Event::TaskAdded}, std::nullopt);
|
|
hub.publish(proto::Event::TaskAdded, nlohmann::json{{"n", 2}});
|
|
hub.publish(proto::Event::TaskRemoved, nlohmann::json{{"n", 3}}); // not subscribed
|
|
CHECK_EQ(a.size(), 1u);
|
|
CHECK_EQ(a[0]["n"].get<int>(), 2);
|
|
|
|
// --- two subscribers, independent filters -----------------------------------
|
|
std::vector<nlohmann::json> b;
|
|
const auto sub_b = hub.subscribe([&](const nlohmann::json& n) { b.push_back(n); });
|
|
hub.set_filter(sub_b, {proto::Event::TaskRemoved}, std::nullopt);
|
|
hub.publish(proto::Event::TaskAdded, nlohmann::json{{"n", 4}});
|
|
hub.publish(proto::Event::TaskRemoved, nlohmann::json{{"n", 5}});
|
|
CHECK_EQ(a.size(), 2u); // got the TaskAdded
|
|
CHECK_EQ(b.size(), 1u); // got the TaskRemoved
|
|
CHECK_EQ(b[0]["n"].get<int>(), 5);
|
|
|
|
// --- per-task filter: only the named ids reach the subscriber ---------------
|
|
std::vector<nlohmann::json> c;
|
|
const auto sub_c = hub.subscribe([&](const nlohmann::json& n) { c.push_back(n); });
|
|
hub.set_filter(sub_c, {proto::Event::TaskState},
|
|
std::vector<std::string>{"t1", "t2"});
|
|
hub.publish(proto::Event::TaskState, nlohmann::json{{"n", 6}}, "t1");
|
|
hub.publish(proto::Event::TaskState, nlohmann::json{{"n", 7}}, "t9"); // filtered out
|
|
hub.publish(proto::Event::TaskState, nlohmann::json{{"n", 8}}, "t2");
|
|
CHECK_EQ(c.size(), 2u);
|
|
CHECK_EQ(c[0]["n"].get<int>(), 6);
|
|
CHECK_EQ(c[1]["n"].get<int>(), 8);
|
|
|
|
// --- a non-task-scoped publish (no task_id) reaches a task-filtered sub too --
|
|
// (matches "session.subscribe narrows task events" — a global event isn't one)
|
|
hub.publish(proto::Event::TaskState, nlohmann::json{{"n", 9}});
|
|
CHECK_EQ(c.size(), 3u);
|
|
|
|
// --- set_filter replaces, it does not add -----------------------------------
|
|
hub.set_filter(sub_a, {proto::Event::TaskRemoved}, std::nullopt);
|
|
hub.publish(proto::Event::TaskAdded, nlohmann::json{{"n", 10}});
|
|
CHECK_EQ(a.size(), 2u); // still 2 -- TaskAdded no longer reaches sub_a
|
|
|
|
// --- unsubscribe stops delivery ------------------------------------------
|
|
hub.unsubscribe(sub_b);
|
|
hub.publish(proto::Event::TaskRemoved, nlohmann::json{{"n", 11}});
|
|
CHECK_EQ(b.size(), 1u); // unchanged
|
|
CHECK_EQ(a.size(), 3u); // sub_a still gets TaskRemoved
|
|
}
|
|
|
|
TEST_MAIN()
|