Something went wrong. Try again.
prefect server in zig
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487//! 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 fallbackconst 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;}