daemon: event.* fan-out (D5) + category.list/queue.list (D3) — GUI-ready

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
2026-09-11 07:19:11 +04:00
parent 72344134cc
commit 824fa481bb
29 changed files with 775 additions and 58 deletions
@@ -0,0 +1,36 @@
+#include "store/categories.hpp"
+
+#include <nlohmann/json.hpp>
+
+namespace velox::daemon::store {
+
+namespace proto = velox::proto;
+
+DbResult<std::vector<proto::Category>> Categories::list() {
+    auto st = db_.prepare(
+        "SELECT category_id, name, save_dir, extensions, builtin FROM categories "
+        "ORDER BY builtin DESC, name");
+    if (!st) return std::unexpected(st.error());
+
+    std::vector<proto::Category> out;
+    for (;;) {
+        auto row = st->step();
+        if (!row) return std::unexpected(row.error());
+        if (!*row) break;
+
+        proto::Category c;
+        c.categoryId = st->column_text(0);
+        c.name = st->column_text(1);
+        c.saveDir = st->column_text(2);
+        auto j = nlohmann::json::parse(st->column_text(3), nullptr, false);
+        if (j.is_array()) {
+            for (const auto& e : j)
+                if (e.is_string()) c.extensions.push_back(e.get<std::string>());
+        }
+        c.builtin = st->column_int(4) != 0;
+        out.push_back(std::move(c));
+    }
+    return out;
+}
+
+}  // namespace velox::daemon::store
@@ -0,0 +1,24 @@
+#pragma once
+
+// Read access to the `categories` table, projected onto proto::Category. Owned here
+// rather than duplicated per handler since category.list and download.add (rule
+// matching, later) both need it.
+
+#include <vector>
+
+#include "store/sqlite.hpp"
+#include "velox_proto.hpp"
+
+namespace velox::daemon::store {
+
+class Categories {
+public:
+    explicit Categories(Db& db) : db_(db) {}
+
+    DbResult<std::vector<velox::proto::Category>> list();
+
+private:
+    Db& db_;
+};
+
+}  // namespace velox::daemon::store
@@ -0,0 +1,48 @@
+#include "store/queues.hpp"
+
+#include <nlohmann/json.hpp>
+
+namespace velox::daemon::store {
+
+namespace proto = velox::proto;
+
+DbResult<std::vector<proto::Queue>> Queues::list() {
+    auto st = db_.prepare(
+        "SELECT queue_id, name, state, max_concurrent, schedule FROM queues ORDER BY name");
+    if (!st) return std::unexpected(st.error());
+
+    std::vector<proto::Queue> out;
+    for (;;) {
+        auto row = st->step();
+        if (!row) return std::unexpected(row.error());
+        if (!*row) break;
+
+        proto::Queue q;
+        q.queueId = st->column_text(0);
+        q.name = st->column_text(1);
+        if (auto s = proto::parse_QueueState(st->column_text(2))) q.state = *s;
+        q.maxConcurrent = st->column_int(3);
+        if (!st->column_is_null(4)) {
+            auto j = nlohmann::json::parse(st->column_text(4), nullptr, false);
+            if (auto sched = proto::parse<proto::Schedule>(j, "schedule")) q.schedule = *sched;
+        }
+
+        auto ts = db_.prepare(
+            "SELECT task_id FROM tasks WHERE queue_id = ?1 ORDER BY queue_position");
+        if (!ts) return std::unexpected(ts.error());
+        if (auto b = ts->bind(1, std::string_view(q.queueId)); !b) return std::unexpected(b.error());
+        std::vector<std::string> ids;
+        for (;;) {
+            auto r = ts->step();
+            if (!r) return std::unexpected(r.error());
+            if (!*r) break;
+            ids.push_back(ts->column_text(0));
+        }
+        q.taskIds = std::move(ids);
+
+        out.push_back(std::move(q));
+    }
+    return out;
+}
+
+}  // namespace velox::daemon::store
@@ -0,0 +1,25 @@
+#pragma once
+
+// Read access to the `queues` table, projected onto proto::Queue. taskIds is derived from
+// `tasks` (queue_id = this queue, ordered by queue_position), not stored on the queue row
+// — membership changes through download.update / queue.reorder, per Queue's own schema
+// note that a queue.upsert payload's taskIds is ignored.
+
+#include <vector>
+
+#include "store/sqlite.hpp"
+#include "velox_proto.hpp"
+
+namespace velox::daemon::store {
+
+class Queues {
+public:
+    explicit Queues(Db& db) : db_(db) {}
+
+    DbResult<std::vector<velox::proto::Queue>> list();
+
+private:
+    Db& db_;
+};
+
+}  // namespace velox::daemon::store
@@ -264,6 +264,20 @@ DbResult<bool> Tasks::remove(std::string_view task_id) {
    return sqlite3_changes(db_.raw()) > 0;
 }

+DbResult<bool> Tasks::update_progress(std::string_view task_id, std::int64_t downloaded_bytes,
+                                      std::int64_t eff_segments, std::int64_t eff_buffer_bytes) {
+    auto st = db_.prepare(
+        "UPDATE tasks SET downloaded_bytes = ?2, eff_segments = ?3, eff_buffer_bytes = ?4 "
+        "WHERE task_id = ?1");
+    if (!st) return std::unexpected(st.error());
+    if (auto r = st->bind(1, task_id); !r) return std::unexpected(r.error());
+    if (auto r = st->bind(2, downloaded_bytes); !r) return std::unexpected(r.error());
+    if (auto r = st->bind(3, eff_segments); !r) return std::unexpected(r.error());
+    if (auto r = st->bind(4, eff_buffer_bytes); !r) return std::unexpected(r.error());
+    if (auto r = st->step(); !r) return std::unexpected(r.error());
+    return sqlite3_changes(db_.raw()) > 0;
+}
+
 DbResult<std::int64_t> Tasks::count() {
    auto st = db_.prepare("SELECT count(*) FROM tasks");
    if (!st) return std::unexpected(st.error());
@@ -78,6 +78,11 @@ public:
    DbResult<bool> remove(std::string_view task_id);
    DbResult<std::int64_t> count();

+    // Byte-counter update from an engine progress tick — cheaper than a full row rewrite,
+    // and keeps download.list / download.get current between state transitions.
+    DbResult<bool> update_progress(std::string_view task_id, std::int64_t downloaded_bytes,
+                                   std::int64_t eff_segments, std::int64_t eff_buffer_bytes);
+
 private:
    Db& db_;
 };