Something went wrong. Try again.
prefect server in zig
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513// REST API handlers for /events endpoints// separate from events.zig which handles websocket connections
const std = @import("std");const mem = std.mem;const wap = @import("wap");const log = @import("../logging.zig");const db_events = @import("../db/events.zig");const json_nav = @import("../utilities/json.zig"); // dot-path navigation for freeform filter blobsconst encoding = @import("../utilities/encoding.zig");const broker = @import("../broker.zig");const text_search = @import("../utilities/text_search.zig");
const EVENTS_TOPIC = "events";
const PAGE_SIZE: usize = 50;
fn sendError(res: *wap.Response, status: std.http.Status, detail: []const u8) !void { _ = res.setStatus(status); try res.writeJson(.{ .detail = detail });}
// POST /events/filter - query events with filters// GET /events/filter/next?page-token=... - get next page// GET /events/count - count total eventspub fn handle(req: *wap.Request, res: *wap.Response) !void { const target = req.path; const method = @tagName(req.method);
// GET /events/filter/next?page-token=... if (mem.eql(u8, method, "GET") and mem.indexOf(u8, target, "/filter/next") != null) { try filterNext(req, res); return; }
// POST /events/filter if (mem.eql(u8, method, "POST") and mem.endsWith(u8, target, "/filter")) { try filter(req, res); return; }
// POST /events/count-by/{time|event} if (mem.eql(u8, method, "POST") and mem.indexOf(u8, target, "/count-by/") != null) { try countBy(req, res, target); return; }
// GET /events/count if (mem.eql(u8, method, "GET") and mem.endsWith(u8, target, "/count")) { try count(res); return; }
// POST /events — HTTP ingest fallback. Body is a JSON array of Event // objects. Mirrors python's `create_events`: publish each event to the // broker (event_persister consumes), return 204. if (mem.eql(u8, method, "POST") and (mem.eql(u8, target, "/events") or mem.eql(u8, target, "/api/events"))) { try createEvents(req, res); return; }
try sendError(res, .not_found, "not found");}
fn createEvents(req: *wap.Request, res: *wap.Response) !void { const alloc = req.arena;
const parsed = std.json.parseFromSlice(std.json.Value, alloc, req.body, .{}) catch |err| { if (err == error.OutOfMemory) return err; try sendError(res, .bad_request, "invalid json"); return; }; if (parsed.value != .array) { try sendError(res, .bad_request, "request body must be a JSON array of events"); return; }
const b = broker.getBroker() orelse { try sendError(res, .service_unavailable, "broker not available"); return; };
for (parsed.value.array.items) |item| { if (item != .object) continue; publishEvent(alloc, b, item) catch |err| { log.warn("events-api", "publish failed: {}", .{err}); // Per python's `create_events`, ingest is fire-and-forget — on // partial failure we still 204 (clients are expected to retry on // missing events via the resilient event id). }; }
try res.sendEmpty(.no_content);}
fn publishEvent(alloc: std.mem.Allocator, b: broker.Broker, event: std.json.Value) !void { const obj = event.object;
const id = strField(obj, "id") orelse return error.MissingId; const occurred = strField(obj, "occurred") orelse return error.MissingOccurred; const event_name = strField(obj, "event") orelse return error.MissingEvent;
var resource_id: []const u8 = ""; if (obj.get("resource")) |r| if (r == .object) { resource_id = strField(r.object, "prefect.resource.id") orelse ""; };
const resource_json = stringifyOrDefault(alloc, obj.get("resource"), "{}"); const payload_json = stringifyOrDefault(alloc, obj.get("payload"), "{}"); const related_json = stringifyOrDefault(alloc, obj.get("related"), "[]"); const follows = strField(obj, "follows"); const follows_json = if (follows) |f| try jsonString(alloc, f) else "null";
// 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 event_json = try std.fmt.allocPrint( alloc, \\{{"id":{s},"occurred":{s},"event":{s},"resource_id":{s},"resource":{s},"payload":{s},"related":{s},"follows":{s}}} , .{ try jsonString(alloc, id), try jsonString(alloc, occurred), try jsonString(alloc, event_name), try jsonString(alloc, resource_id), resource_json, payload_json, related_json, follows_json }, ); try b.publish(EVENTS_TOPIC, id, event_json);}
/// `s` as a quoted, escaped JSON stringpub fn jsonString(alloc: std.mem.Allocator, s: []const u8) ![]const u8 { return std.json.Stringify.valueAlloc(alloc, s, .{});}
fn strField(obj: std.json.ObjectMap, key: []const u8) ?[]const u8 { const v = obj.get(key) orelse return null; return switch (v) { .string => |s| s, else => null, };}
fn stringifyOrDefault(alloc: std.mem.Allocator, val: ?std.json.Value, default: []const u8) []const u8 { if (val) |v| { const formatted = std.fmt.allocPrint(alloc, "{f}", .{std.json.fmt(v, .{})}) catch return default; return formatted; } return default;}
fn filter(req: *wap.Request, res: *wap.Response) !void { const alloc = req.arena;
// parse request body const parsed = std.json.parseFromSlice(std.json.Value, alloc, req.body, .{}) catch |err| { if (err == error.OutOfMemory) return err; try sendError(res, .bad_request, "invalid json"); return; };
// parse limit (default PAGE_SIZE, max PAGE_SIZE for pagination) const limit: usize = blk: { if (json_nav.getInt(parsed.value, "limit")) |l| { if (l > 0 and l <= PAGE_SIZE) break :blk @intCast(l); } break :blk PAGE_SIZE; };
// parse filter object const filter_opts = parseFilterOptions(alloc, parsed.value) catch |err| switch (err) { error.InvalidTextFilter => return sendError(res, .unprocessable_entity, "invalid text filter"), else => return err, };
// get total count first const total = try db_events.countWithFilter(alloc, filter_opts);
// query first page (offset 0) const events = db_events.queryWithFilter(alloc, filter_opts, limit, 0) catch |err| { log.err("events-api", "query error: {}", .{err}); try sendError(res, .internal_server_error, "database error"); return; };
// generate next_page URL if there are more results const next_page = try generateNextPageUrl(alloc, req, filter_opts, total, limit, 0);
// send response try sendEventPage(res, alloc, events, total, next_page);}
fn filterNext(req: *wap.Request, res: *wap.Response) !void { const alloc = req.arena;
// extract page-token from query string const query = req.query orelse ""; const token_start = mem.indexOf(u8, query, "page-token=") orelse { try sendError(res, .forbidden, "missing page token"); return; };
const token_value_start = token_start + "page-token=".len; var token_end = query.len; if (mem.indexOf(u8, query[token_value_start..], "&")) |amp| { token_end = token_value_start + amp; } const url_encoded_token = query[token_value_start..token_end];
// URL decode (handle %2B -> +, %2F -> /, %3D -> =) const decoded_token = encoding.urlDecode(alloc, url_encoded_token) catch |err| { if (err == error.OutOfMemory) return err; try sendError(res, .forbidden, "invalid page token"); return; };
// first base64 decode (URL layer) const inner_token = encoding.base64Decode(alloc, decoded_token) catch |err| { if (err == error.OutOfMemory) return err; try sendError(res, .forbidden, "invalid page token"); return; };
// second base64 decode (token layer) const token_json = encoding.base64Decode(alloc, inner_token) catch |err| { if (err == error.OutOfMemory) return err; try sendError(res, .forbidden, "invalid page token"); return; };
// parse token JSON const token_parsed = std.json.parseFromSlice(std.json.Value, alloc, token_json, .{}) catch |err| { if (err == error.OutOfMemory) return err; try sendError(res, .forbidden, "invalid page token"); return; };
if (token_parsed.value != .object) { try sendError(res, .forbidden, "invalid page token"); return; }
// extract token fields using path helpers const total: usize = if (json_nav.getInt(token_parsed.value, "count")) |c| if (c >= 0) @intCast(c) else 0 else 0;
const page_size: usize = if (json_nav.getInt(token_parsed.value, "page_size")) |ps| if (ps > 0) @intCast(ps) else PAGE_SIZE else PAGE_SIZE;
const offset: usize = if (json_nav.getInt(token_parsed.value, "offset")) |o| if (o >= 0) @intCast(o) else 0 else 0;
// parse filter from token var filter_opts = db_events.FilterOptions{}; filter_opts.occurred_since = json_nav.getString(token_parsed.value, "filter.occurred_since"); filter_opts.occurred_until = json_nav.getString(token_parsed.value, "filter.occurred_until"); filter_opts.order_asc = json_nav.getBool(token_parsed.value, "filter.order_asc") orelse false;
if (json_nav.getPath(token_parsed.value, "filter.event_prefixes")) |v| { filter_opts.event_prefixes = try db_events.parseJsonStringArray(alloc, v); } if (json_nav.getPath(token_parsed.value, "filter.event_names")) |v| { filter_opts.event_names = try db_events.parseJsonStringArray(alloc, v); } if (json_nav.getPath(token_parsed.value, "filter.resource_ids")) |v| { filter_opts.resource_ids = try db_events.parseJsonStringArray(alloc, v); } if (json_nav.getPath(token_parsed.value, "filter.resource_id_prefixes")) |v| { filter_opts.resource_id_prefixes = try db_events.parseJsonStringArray(alloc, v); } filter_opts.text = json_nav.getString(token_parsed.value, "filter.text");
// query this page const events = db_events.queryWithFilter(alloc, filter_opts, page_size, offset) catch |err| { log.err("events-api", "query next page error: {}", .{err}); try sendError(res, .internal_server_error, "database error"); return; };
// generate next_page URL if there are more results const next_page = try generateNextPageUrl(alloc, req, filter_opts, total, page_size, offset);
// send response try sendEventPage(res, alloc, events, total, next_page);}
pub fn parseFilterOptions(alloc: std.mem.Allocator, value: std.json.Value) !db_events.FilterOptions { var opts = db_events.FilterOptions{};
// occurred filter opts.occurred_since = json_nav.getString(value, "filter.occurred.since"); opts.occurred_until = json_nav.getString(value, "filter.occurred.until");
// event filter if (json_nav.getPath(value, "filter.event.prefix")) |v| { opts.event_prefixes = try db_events.parseJsonStringArray(alloc, v); } if (json_nav.getPath(value, "filter.event.name")) |v| { opts.event_names = try db_events.parseJsonStringArray(alloc, v); }
// resource filter if (json_nav.getPath(value, "filter.resource.id")) |v| { opts.resource_ids = try db_events.parseJsonStringArray(alloc, v); } if (json_nav.getPath(value, "filter.resource.id_prefix")) |v| { opts.resource_id_prefixes = try db_events.parseJsonStringArray(alloc, v); } if (json_nav.getPath(value, "filter.any_resource.id")) |v| { opts.any_resource_ids = try db_events.parseJsonStringArray(alloc, v); } if (json_nav.getPath(value, "filter.any_resource.id_prefix")) |v| { opts.any_resource_id_prefixes = try db_events.parseJsonStringArray(alloc, v); }
if (json_nav.getPath(value, "filter.text")) |text| { opts.text = try text_search.queryFromJson(text); }
// order if (json_nav.getString(value, "filter.order")) |order| { opts.order_asc = mem.eql(u8, order, "ASC"); }
return opts;}
fn generateNextPageUrl(alloc: std.mem.Allocator, req: *wap.Request, filter_opts: db_events.FilterOptions, total: usize, page_size: usize, current_offset: usize) !?[]const u8 { const next_offset = current_offset + page_size; if (next_offset >= total) return null;
// build token JSON: {"filter": {...}, "count": N, "page_size": N, "offset": N} const filter_json = try filter_opts.toJson(alloc); defer alloc.free(filter_json);
const token_json = try std.fmt.allocPrint(alloc, "{{\"filter\":{s},\"count\":{d},\"page_size\":{d},\"offset\":{d}}}", .{ filter_json, total, page_size, next_offset, }); defer alloc.free(token_json);
// base64 encode the token const inner_token = try encoding.base64Encode(alloc, token_json); defer alloc.free(inner_token);
// base64 encode again for URL const url_token = try encoding.base64Encode(alloc, inner_token); defer alloc.free(url_token);
// build URL const host = req.header("host") orelse "localhost:4200"; return try std.fmt.allocPrint(alloc, "http://{s}/api/events/filter/next?page-token={s}", .{ host, url_token });}
fn sendEventPage(res: *wap.Response, alloc: std.mem.Allocator, events: []const []const u8, total: usize, next_page: ?[]const u8) !void { var output: std.Io.Writer.Allocating = .init(alloc); defer output.deinit(); var jw: std.json.Stringify = .{ .writer = &output.writer };
try jw.beginObject();
// "events": [...] try jw.objectField("events"); try jw.beginArray(); for (events) |event_json| { try jw.print("{s}", .{event_json}); } try jw.endArray();
// "total": N try jw.objectField("total"); try jw.write(total);
// "next_page": "..." or null try jw.objectField("next_page"); if (next_page) |url| { try jw.write(url); } else { try jw.write(null); }
try jw.endObject();
_ = res.setHeader("content-type", "application/json"); try res.sendBody(output.written());}
fn count(res: *wap.Response) !void { const total = try db_events.count(); try res.writeJson(.{ .count = total });}
fn countBy(req: *wap.Request, res: *wap.Response, target: []const u8) !void { if (mem.endsWith(u8, target, "/count-by/event")) { try countByEvent(req, res); return; } if (mem.endsWith(u8, target, "/count-by/time")) { try countByTime(req, res); return; } try sendError(res, .not_found, "not found");}
fn countByEvent(req: *wap.Request, res: *wap.Response) !void { const alloc = req.arena;
const filter_opts = parseRequestFilter(alloc, req) catch |err| switch (err) { error.OutOfMemory => return err, error.InvalidTextFilter => return sendError(res, .unprocessable_entity, "invalid text filter"), else => return sendError(res, .bad_request, "invalid json"), };
const counts = db_events.countByEvent(alloc, filter_opts, 200) catch |err| { log.err("events-api", "count-by event error: {}", .{err}); try sendError(res, .internal_server_error, "database error"); return; };
var output: std.Io.Writer.Allocating = .init(alloc); var jw: std.json.Stringify = .{ .writer = &output.writer }; try jw.beginArray(); for (counts) |item| { try jw.beginObject(); try jw.objectField("value"); try jw.write(item.value); try jw.objectField("count"); try jw.write(item.count); try jw.endObject(); } try jw.endArray();
_ = res.setHeader("content-type", "application/json"); try res.sendBody(try output.toOwnedSlice());}
fn countByTime(req: *wap.Request, res: *wap.Response) !void { const alloc = req.arena;
const filter_opts = parseRequestFilter(alloc, req) catch |err| switch (err) { error.OutOfMemory => return err, error.InvalidTextFilter => return sendError(res, .unprocessable_entity, "invalid text filter"), else => return sendError(res, .bad_request, "invalid json"), }; const total = try db_events.countWithFilter(alloc, filter_opts); const start_time = filter_opts.occurred_since orelse "1970-01-01T00:00:00.000Z";
try res.writeJson(&[_]struct { start_time: []const u8, count: usize, }{.{ .start_time = start_time, .count = total, }});}
fn parseRequestFilter(alloc: std.mem.Allocator, req: *wap.Request) !db_events.FilterOptions { if (req.body.len == 0) return db_events.FilterOptions{}; const parsed = try std.json.parseFromSlice(std.json.Value, alloc, req.body, .{}); return try parseFilterOptions(alloc, parsed.value);}
test "event page serialization propagates allocation failure without sending partial JSON" { const Check = struct { fn send(res: *wap.Response, alloc: std.mem.Allocator) !void { const message: [4096]u8 = @splat('x'); var buffer: [8192]u8 = undefined; const event = try std.fmt.bufPrint(&buffer, "{{\"message\":\"{s}\"}}", .{message}); try sendEventPage(res, alloc, &.{ event, event }, 2, null); } }; try @import("response_test.zig").checkJsonResponse(Check.send);}
test "event filters propagate allocation failure without dropping constraints" { try @import("json_test.zig").checkFilterStrings(db_events.parseJsonStringArray);}
test "next event page cannot disappear on allocation failure" { const Check = struct { fn run(alloc: std.mem.Allocator) !void { var req: wap.Request = .{ .method = .POST, .target = "/api/events/filter", .path = "/api/events/filter", .query = null, .body = "", .headers = .{ .keys = &.{}, .values = &.{} }, .arena = alloc, }; const url = (generateNextPageUrl(alloc, &req, .{ .event_names = &.{"preserved.event"} }, 120, 10, 0) catch |err| return switch (err) { error.WriteFailed => error.OutOfMemory, else => err, }) orelse return error.MissingNextPage; defer alloc.free(url); const prefix = "http://localhost:4200/api/events/filter/next?page-token="; try std.testing.expect(mem.startsWith(u8, url, prefix)); var read_arena = std.heap.ArenaAllocator.init(std.testing.allocator); defer read_arena.deinit(); const inner = try encoding.base64Decode(read_arena.allocator(), url[prefix.len..]); const raw = try encoding.base64Decode(read_arena.allocator(), inner); const parsed = try std.json.parseFromSlice(std.json.Value, std.testing.allocator, raw, .{}); defer parsed.deinit(); try std.testing.expectEqual(@as(i64, 10), parsed.value.object.get("offset").?.integer); try std.testing.expectEqual(@as(i64, 120), parsed.value.object.get("count").?.integer); try std.testing.expectEqualStrings("preserved.event", parsed.value.object.get("filter").?.object.get("event_names").?.array.items[0].string); } }; try std.testing.checkAllAllocationFailures(std.testing.allocator, Check.run, .{});}