//! WebSocket handlers for `/events/in` (event ingestion) and `/events/out` //! (subscription/broadcast). Bridged into wap's WebSocket layer via two //! `wap.ws.Route` entries returned by `wapRoutes()`. const std = @import("std"); const wap = @import("wap"); const log = @import("../logging.zig"); const messaging = @import("../utilities/messaging.zig"); // legacy fallback const broker = @import("../broker.zig"); const event_broadcaster = @import("../services/event_broadcaster.zig"); const auth_util = @import("auth.zig"); const sync = @import("../utilities/sync.zig"); /// Topic for Prefect events (matches Python: "events"). pub const EVENTS_TOPIC = "events"; pub const PERSISTED_EVENTS_TOPIC = "events-persisted"; const Allocator = std.mem.Allocator; // ============================================================================ // /events/in — event ingestion // ============================================================================ const InState = struct { const Queue = broker.Queue; conn: *wap.ws.Conn, allocator: Allocator, queue: Queue(IngestEvent), worker: std.Thread, pending_mutex: sync.Mutex = .{}, pending_drained: sync.Condition = .{}, pending: usize = 0, failed: bool = false, messages: usize = 0, task_events: usize = 0, const IngestEvent = struct { id: []const u8, event_name: []const u8, event_json: []const u8, allocator: Allocator, fn init(allocator: Allocator, id: []const u8, event_name: []const u8, event_json: []const u8) !IngestEvent { const id_copy = try allocator.dupe(u8, id); errdefer allocator.free(id_copy); const event_name_copy = try allocator.dupe(u8, event_name); errdefer allocator.free(event_name_copy); const event_json_copy = try allocator.dupe(u8, event_json); return .{ .id = id_copy, .event_name = event_name_copy, .event_json = event_json_copy, .allocator = allocator, }; } fn deinit(self: IngestEvent) void { self.allocator.free(self.id); self.allocator.free(self.event_name); self.allocator.free(self.event_json); } }; fn markQueued(self: *InState) void { self.pending_mutex.lock(); defer self.pending_mutex.unlock(); self.pending += 1; } fn markDone(self: *InState, accepted: bool) void { self.pending_mutex.lock(); defer self.pending_mutex.unlock(); self.pending -= 1; self.failed = self.failed or !accepted; if (self.pending == 0 or self.failed) { self.pending_drained.broadcast(); } } /// Wait up to `timeout_ns` for the ingest queue to drain. Returns true if /// it drained. Bounded because this runs on the connection's read loop /// (via the ping handler): an unbounded wait here once wedged the whole /// connection when a broker publish stalled — the server stopped reading, /// the client blocked in send(), and its flow-run process zombied. fn waitDrainedTimeout(self: *InState, timeout_ns: u64) bool { const slice_ns: u64 = 10 * std.time.ns_per_ms; self.pending_mutex.lock(); defer self.pending_mutex.unlock(); var waited: u64 = 0; while (self.pending != 0 and !self.failed and waited < timeout_ns) { self.pending_drained.timedWait(&self.pending_mutex, slice_ns) catch {}; waited += slice_ns; } return self.pending == 0 and !self.failed; } }; fn inFactory(allocator: Allocator, _: std.Io, _: *const wap.ws.Handshake, conn: *wap.ws.Conn) anyerror!*anyopaque { const state = try allocator.create(InState); state.* = .{ .conn = conn, .allocator = allocator, .queue = InState.Queue(InState.IngestEvent).init(allocator), .worker = undefined, }; state.worker = try std.Thread.spawn(.{}, inWorkerLoop, .{state}); log.debug("websocket", "events-in connection opened", .{}); return @ptrCast(state); } fn inWorkerLoop(state: *InState) void { const timeout_ns: u64 = 100 * std.time.ns_per_ms; while (true) { const event = state.queue.popTimeout(timeout_ns) orelse { if (state.queue.len() == 0) { state.queue.mutex.lock(); const closed = state.queue.closed; state.queue.mutex.unlock(); if (closed) break; } continue; }; defer event.deinit(); var accepted = false; defer state.markDone(accepted); if (broker.getBroker()) |b| { b.publish(EVENTS_TOPIC, event.id, event.event_json) catch |err| { log.warn("events", "dropped (broker error): {s} - {}", .{ event.event_name, err }); continue; }; log.debug("events", "published: {s}", .{event.event_name}); accepted = true; } else { if (messaging.publishEvent(event.id, "", event.event_name, "", "{}", event.event_json, "[]", null)) { log.debug("events", "queued (legacy): {s}", .{event.event_name}); accepted = true; } else { log.warn("events", "dropped (backpressure): {s}", .{event.event_name}); } } } } fn inOnMessage(state_ptr: *anyopaque, data: []const u8, is_text: bool) anyerror!void { const state: *InState = @ptrCast(@alignCast(state_ptr)); log.debug("events", "received message: {d} bytes, text={}", .{ data.len, is_text }); var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator); defer arena.deinit(); const alloc = arena.allocator(); const parsed = std.json.parseFromSlice(std.json.Value, alloc, data, .{}) catch { log.err("events", "failed to parse event json", .{}); return; }; if (parsed.value != .object) { log.err("events", "event payload is not a JSON object", .{}); return; } const obj = parsed.value.object; // Auth handshake: prefect client sends {"type":"auth","token":...} on connect // and waits for {"type":"auth_success"} before continuing. unauthenticated mode // returns success unconditionally — token validation can wire in here later. if (obj.get("type")) |type_val| { if (type_val == .string and std.mem.eql(u8, type_val.string, "auth")) { if (!auth_util.validateSocketAuthFrame(alloc, data, false)) { state.conn.close(.{ .code = 1008, .reason = "authentication_failed" }) catch {}; return; } state.conn.writeText("{\"type\":\"auth_success\"}") catch |err| { log.err("events", "auth reply send failed: {}", .{err}); }; log.debug("events", "auth handshake completed", .{}); return; } } const getString = struct { fn f(val: ?std.json.Value) ?[]const u8 { if (val) |v| { return switch (v) { .string => |s| s, else => null, }; } return null; } }.f; const stringifyJson = struct { fn f(a: Allocator, val: ?std.json.Value, default: []const u8) []const u8 { if (val) |v| { const formatted = std.fmt.allocPrint(a, "{f}", .{std.json.fmt(v, .{})}) catch return default; return formatted; } return default; } }.f; const id = getString(obj.get("id")); const occurred = getString(obj.get("occurred")); const event_name = getString(obj.get("event")); if (id == null or occurred == null or event_name == null) { log.err("events", "event missing required fields", .{}); return; } state.messages += 1; if (std.mem.startsWith(u8, event_name.?, "prefect.task-run.")) { state.task_events += 1; } if (state.messages % 50 == 0) { log.info("events", "events-in received {d} messages ({d} task events)", .{ state.messages, state.task_events }); } var resource_id: []const u8 = ""; if (obj.get("resource")) |res| { if (res == .object) { resource_id = getString(res.object.get("prefect.resource.id")) orelse ""; } } const resource_json = stringifyJson(alloc, obj.get("resource"), "{}"); const payload_json = stringifyJson(alloc, obj.get("payload"), "{}"); const related_json = stringifyJson(alloc, obj.get("related"), "[]"); const follows = getString(obj.get("follows")); // every string is written as a JSON string: an event name or resource id // with a quote or backslash in it must not break the message apart const quote = struct { fn of(a: Allocator, s: []const u8) []const u8 { return std.json.Stringify.valueAlloc(a, s, .{}) catch "\"\""; } }.of; const event_json = std.fmt.allocPrint(alloc, \\{{"id":{s},"occurred":{s},"event":{s},"resource_id":{s},"resource":{s},"payload":{s},"related":{s},"follows":{s}}} , .{ quote(alloc, id.?), quote(alloc, occurred.?), quote(alloc, event_name.?), quote(alloc, resource_id), resource_json, payload_json, related_json, if (follows) |f| quote(alloc, f) else "null", }) catch { log.err("events", "failed to format event json", .{}); return; }; const ingest_event = InState.IngestEvent.init(state.allocator, id.?, event_name.?, event_json) catch |err| { log.err("events", "failed to allocate event for ingest queue: {}", .{err}); return err; }; errdefer ingest_event.deinit(); state.markQueued(); state.queue.push(ingest_event) catch |err| { state.markDone(false); log.warn("events", "dropped (ingest queue closed): {s} - {}", .{ event_name.?, err }); return err; }; } fn inOnPing(state_ptr: *anyopaque, conn: *wap.ws.Conn, data: []const u8) anyerror!void { const state: *InState = @ptrCast(@alignCast(state_ptr)); // pong doubles as the client's durability checkpoint, so it must not be // sent while events are still queued. if the drain stalls (wedged broker), // close instead of ponging: no false ack, the read loop unblocks, and the // client reconnects and resends from its last checkpoint. if (!state.waitDrainedTimeout(30 * std.time.ns_per_s)) { log.err("events", "ingest failed or stalled; closing events-in connection without checkpoint", .{}); conn.close(.{ .code = 1013, .reason = "event ingest unavailable" }) catch {}; return; } try conn.writePong(@constCast(data)); } fn inOnClose(state_ptr: *anyopaque) void { const state: *InState = @ptrCast(@alignCast(state_ptr)); state.queue.close(); state.worker.join(); state.queue.deinit(); log.info("websocket", "events-in connection closed after {d} messages ({d} task events)", .{ state.messages, state.task_events }); // The factory used the route's allocator (= wap.Server.allocator); we leak the // InState until that allocator is freed. Switch to a per-conn arena if we // store more state. } // ============================================================================ // /events/out — event subscription / broadcast // ============================================================================ const SubState = enum { waiting_auth, waiting_filter, subscribed }; const OutState = struct { conn: *wap.ws.Conn, allocator: Allocator, state: SubState = .waiting_auth, registered: bool = false, }; fn outFactory(allocator: Allocator, _: std.Io, _: *const wap.ws.Handshake, conn: *wap.ws.Conn) anyerror!*anyopaque { const state = try allocator.create(OutState); state.* = .{ .conn = conn, .allocator = allocator }; log.debug("events-out", "subscriber connected", .{}); return @ptrCast(state); } fn outOnMessage(state_ptr: *anyopaque, data: []const u8, _: bool) anyerror!void { const s: *OutState = @ptrCast(@alignCast(state_ptr)); var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator); defer arena.deinit(); const alloc = arena.allocator(); const parsed = std.json.parseFromSlice(std.json.Value, alloc, data, .{}) catch { log.err("events-out", "invalid json from subscriber", .{}); s.conn.close(.{}) catch {}; return; }; const obj = parsed.value.object; const msg_type = if (obj.get("type")) |v| switch (v) { .string => |str| str, else => null, } else null; if (msg_type == null) { log.err("events-out", "message missing type field", .{}); s.conn.close(.{}) catch {}; return; } switch (s.state) { .waiting_auth => { if (!std.mem.eql(u8, msg_type.?, "auth")) { log.err("events-out", "expected auth message, got {s}", .{msg_type.?}); s.conn.close(.{}) catch {}; return; } if (!auth_util.validateSocketAuthFrame(alloc, data, true)) { s.conn.close(.{ .code = 1008, .reason = "authentication_failed" }) catch {}; return; } s.conn.writeText("{\"type\":\"auth_success\"}") catch { log.err("events-out", "failed to send auth_success", .{}); return; }; s.state = .waiting_filter; log.debug("events-out", "auth successful, waiting for filter", .{}); }, .waiting_filter => { if (!std.mem.eql(u8, msg_type.?, "filter")) { log.err("events-out", "expected filter message, got {s}", .{msg_type.?}); s.conn.close(.{}) catch {}; return; } const wants_backfill = if (obj.get("backfill")) |v| switch (v) { .bool => |b| b, else => true, } else true; const filter = event_broadcaster.EventFilter.parseFromJson(std.heap.page_allocator, data) catch { log.err("events-out", "failed to parse filter", .{}); s.conn.close(.{}) catch {}; return; }; event_broadcaster.addSubscriber(s.conn, filter, wants_backfill) catch |err| { switch (err) { error.BroadcasterNotRunning => log.err("events-out", "broadcaster not running in this process (tier=webserver_only would still start it; loop-only services tier did not)", .{}), error.AtCapacity => log.err("events-out", "broadcaster at capacity (256 subscribers); rejecting new connection", .{}), } var f = filter; f.deinit(); s.conn.close(.{}) catch {}; return; }; s.registered = true; if (wants_backfill) { const db_events = @import("../db/events.zig"); var opts = @import("events_api.zig").parseFilterOptions(alloc, parsed.value) catch { event_broadcaster.removeSubscriber(s.conn); s.registered = false; s.conn.close(.{ .code = 1013, .reason = "event backfill unavailable" }) catch {}; return; }; opts.order_asc = true; var offset: usize = 0; while (true) { var page_arena = std.heap.ArenaAllocator.init(std.heap.page_allocator); defer page_arena.deinit(); const page_alloc = page_arena.allocator(); const events = db_events.queryWithFilter(page_alloc, opts, 100, offset) catch |err| { log.warn("events-out", "backfill query failed: {}", .{err}); event_broadcaster.removeSubscriber(s.conn); s.registered = false; s.conn.close(.{ .code = 1013, .reason = "event backfill unavailable" }) catch {}; return; }; for (events) |event_json| { const wrapped = std.fmt.allocPrint(page_alloc, "{{\"type\":\"event\",\"event\":{s}}}", .{event_json}) catch { event_broadcaster.removeSubscriber(s.conn); s.registered = false; s.conn.close(.{ .code = 1013 }) catch {}; return; }; s.conn.writeText(wrapped) catch { event_broadcaster.removeSubscriber(s.conn); s.registered = false; s.conn.close(.{}) catch {}; return; }; } offset += events.len; if (events.len < 100) break; } log.debug("events-out", "sent {d} backfill events", .{offset}); } event_broadcaster.finishBackfill(s.conn) catch { event_broadcaster.removeSubscriber(s.conn); s.registered = false; s.conn.close(.{ .code = 1013, .reason = "event backfill interrupted" }) catch {}; return; }; s.state = .subscribed; log.info("events-out", "subscriber registered, total: {d}", .{event_broadcaster.getSubscriberCount()}); }, .subscribed => { log.debug("events-out", "ignoring message from subscribed client", .{}); }, } } fn outOnClose(state_ptr: *anyopaque) void { const s: *OutState = @ptrCast(@alignCast(state_ptr)); if (s.registered) { event_broadcaster.removeSubscriber(s.conn); } log.debug("events-out", "subscriber disconnected", .{}); } // ============================================================================ // Route exports for wap.Server // ============================================================================ const routes_table = [_]wap.ws.Route{ .{ .path = "/events/in", .factory = inFactory, .on_message = inOnMessage, .on_close = inOnClose, .on_ping = inOnPing, }, .{ .path = "/api/events/in", .factory = inFactory, .on_message = inOnMessage, .on_close = inOnClose, .on_ping = inOnPing, }, .{ .path = "/events/out", .factory = outFactory, .on_message = outOnMessage, .on_close = outOnClose, }, .{ .path = "/api/events/out", .factory = outFactory, .on_message = outOnMessage, .on_close = outOnClose, }, }; pub fn wapRoutes() []const wap.ws.Route { return &routes_table; }