Something went wrong. Try again.
prefect server in zig
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265const std = @import("std");const wap = @import("wap");const env = @import("../utilities/env.zig");const runtime = @import("../runtime.zig");
const log = @import("../logging.zig");
const max_file_size = 32 * 1024 * 1024;const placeholder = "/PREFECT_UI_SERVE_BASE_REPLACE_PLACEHOLDER";
pub fn tryServe(req: *wap.Request, res: *wap.Response) !bool { if (req.method != .GET and req.method != .HEAD) return false; if (isApiPath(req.path)) return false; if (try isUiSettingsRequest(req.arena, req.path)) return false;
const root = staticDir() orelse return false; if (root.len == 0) return false; if (!(try pathTargetsServeBase(req.arena, req.path))) return false;
const io = runtime.appIo(); var dir = std.Io.Dir.cwd().openDir(io, root, .{}) catch |err| { log.warn("ui", "PREFECT_UI_STATIC_DIR={s} is not readable: {}", .{ root, err }); return false; }; defer dir.close(io);
const lookup_path = stripServeBase(req.arena, req.path) catch req.path; const requested_path = relPath(lookup_path) catch { return sendStaticNotFound(req, res); };
if (try serveFile(io, req, res, &dir, requested_path, false)) return true; if (isStaticAssetPath(requested_path)) return sendStaticNotFound(req, res); return serveIndex(io, req, res, &dir);}
fn staticDir() ?[]const u8 { const enabled = env.getenv("PREFECT_SERVER_UI_ENABLED") orelse env.getenv("PREFECT_UI_ENABLED") orelse "true"; if (std.ascii.eqlIgnoreCase(enabled, "false") or std.mem.eql(u8, enabled, "0")) return null; return env.getenv("PREFECT_SERVER_UI_STATIC_DIRECTORY") orelse env.getenv("PREFECT_UI_STATIC_DIRECTORY") orelse env.getenv("PREFECT_UI_STATIC_DIR") orelse env.getenv("PREFECT_SERVER_UI_STATIC_DIR");}
fn serveBase() []const u8 { const raw = env.getenv("PREFECT_UI_SERVE_BASE") orelse env.getenv("PREFECT_SERVER_UI_SERVE_BASE") orelse "/"; return raw;}
fn normalizeServeBase(alloc: std.mem.Allocator, raw: []const u8) ![]const u8 { const trimmed = std.mem.trim(u8, raw, " \t\r\n"); if (trimmed.len == 0 or std.mem.eql(u8, trimmed, "/")) return "/";
var end = trimmed.len; while (end > 1 and trimmed[end - 1] == '/') end -= 1; const normalized = trimmed[0..end]; return if (normalized[0] == '/') normalized else try std.fmt.allocPrint(alloc, "/{s}", .{normalized});}
fn replacementServeBase(alloc: std.mem.Allocator) ![]const u8 { const normalized = try normalizeServeBase(alloc, serveBase()); return if (std.mem.eql(u8, normalized, "/")) "" else normalized;}
fn stripServeBase(alloc: std.mem.Allocator, path: []const u8) ![]const u8 { const normalized = try normalizeServeBase(alloc, serveBase()); if (std.mem.eql(u8, normalized, "/")) return path; if (std.mem.eql(u8, path, normalized)) return "/"; if (std.mem.startsWith(u8, path, normalized) and path.len > normalized.len and path[normalized.len] == '/') { return path[normalized.len..]; } return path;}
fn pathTargetsServeBase(alloc: std.mem.Allocator, path: []const u8) !bool { const normalized = try normalizeServeBase(alloc, serveBase()); if (std.mem.eql(u8, normalized, "/")) return true; if (std.mem.eql(u8, path, normalized)) return true; return std.mem.startsWith(u8, path, normalized) and path.len > normalized.len and path[normalized.len] == '/';}
pub fn isUiSettingsRequest(alloc: std.mem.Allocator, path: []const u8) !bool { return isUiSettingsPath(try stripServeBase(alloc, path));}
fn isApiPath(path: []const u8) bool { return std.mem.eql(u8, path, "/api") or std.mem.startsWith(u8, path, "/api/");}
fn isUiSettingsPath(path: []const u8) bool { return std.mem.eql(u8, path, "/ui-settings");}
fn relPath(path: []const u8) ![]const u8 { if (path.len == 0 or std.mem.eql(u8, path, "/")) return "index.html"; if (std.mem.indexOfScalar(u8, path, '\\') != null) return error.InvalidPath; if (std.mem.indexOfScalar(u8, path, 0) != null) return error.InvalidPath;
const stripped = std.mem.trimStart(u8, path, "/"); var parts = std.mem.splitScalar(u8, stripped, '/'); while (parts.next()) |part| { if (std.mem.eql(u8, part, "..")) return error.InvalidPath; } return stripped;}
fn serveIndex(io: std.Io, req: *wap.Request, res: *wap.Response, dir: *std.Io.Dir) !bool { return serveFile(io, req, res, dir, "index.html", true);}
fn sendStaticNotFound(req: *wap.Request, res: *wap.Response) !bool { _ = res.setStatus(.not_found) .setHeader("content-type", "text/plain; charset=utf-8") .setHeader("cache-control", "no-cache"); if (req.method == .HEAD) { try res.sendBody(""); } else { try res.sendBody("not found"); } return true;}
fn isStaticAssetPath(path: []const u8) bool { if (std.mem.startsWith(u8, path, "assets/")) return true; if (std.mem.startsWith(u8, path, "ico/")) return true;
const basename = std.fs.path.basename(path); return std.mem.eql(u8, basename, "favicon.ico") or std.mem.eql(u8, basename, "manifest.json") or std.mem.eql(u8, basename, "robots.txt") or std.mem.eql(u8, basename, "site.webmanifest") or std.mem.eql(u8, basename, "asset-manifest.json");}
fn serveFile(io: std.Io, req: *wap.Request, res: *wap.Response, dir: *std.Io.Dir, path: []const u8, is_index: bool) !bool { var file = dir.openFile(io, path, .{ .mode = .read_only, .allow_directory = false, .resolve_beneath = true }) catch |err| switch (err) { error.FileNotFound, error.IsDir, error.NotDir => return false, else => return err, }; defer file.close(io);
const stat = try file.stat(io); if (stat.kind != .file) return false; if (stat.size > max_file_size) return error.FileTooLarge;
const size: usize = std.math.cast(usize, stat.size) orelse return error.FileTooLarge; const body = try req.arena.alloc(u8, size); const n = try file.readPositionalAll(io, body, 0); const bytes = body[0..n];
const ctype = contentType(path); const response_body = if (shouldRewritePlaceholders(path)) try rewritePlaceholders(req.arena, bytes) else bytes;
_ = res.setStatus(.ok) .setHeader("content-type", ctype) .setHeader("cache-control", if (is_index) "no-cache" else cacheControl(path));
if (req.method == .HEAD) { try res.sendBody(""); } else { try res.sendBody(response_body); } return true;}
fn shouldRewritePlaceholders(path: []const u8) bool { const ext = std.fs.path.extension(path); return std.ascii.eqlIgnoreCase(ext, ".html") or std.ascii.eqlIgnoreCase(ext, ".js") or std.ascii.eqlIgnoreCase(ext, ".mjs") or std.ascii.eqlIgnoreCase(ext, ".css") or std.ascii.eqlIgnoreCase(ext, ".json") or std.ascii.eqlIgnoreCase(ext, ".svg") or std.ascii.eqlIgnoreCase(ext, ".map") or std.ascii.eqlIgnoreCase(ext, ".txt");}
fn rewritePlaceholders(alloc: std.mem.Allocator, body: []const u8) ![]const u8 { if (std.mem.indexOf(u8, body, placeholder) == null) return body; const replacement = try replacementServeBase(alloc); return rewritePlaceholdersWithBase(alloc, body, replacement);}
fn rewritePlaceholdersWithBase(alloc: std.mem.Allocator, body: []const u8, replacement: []const u8) ![]const u8 { return std.mem.replaceOwned(u8, alloc, body, placeholder, replacement);}
fn cacheControl(path: []const u8) []const u8 { if (std.mem.startsWith(u8, path, "assets/")) { return "public, max-age=31536000, immutable"; } return "no-cache";}
fn contentType(path: []const u8) []const u8 { const ext = std.fs.path.extension(path); if (std.ascii.eqlIgnoreCase(ext, ".html")) return "text/html; charset=utf-8"; if (std.ascii.eqlIgnoreCase(ext, ".js")) return "text/javascript; charset=utf-8"; if (std.ascii.eqlIgnoreCase(ext, ".mjs")) return "text/javascript; charset=utf-8"; if (std.ascii.eqlIgnoreCase(ext, ".css")) return "text/css; charset=utf-8"; if (std.ascii.eqlIgnoreCase(ext, ".json")) return "application/json"; if (std.ascii.eqlIgnoreCase(ext, ".svg")) return "image/svg+xml"; if (std.ascii.eqlIgnoreCase(ext, ".png")) return "image/png"; if (std.ascii.eqlIgnoreCase(ext, ".jpg")) return "image/jpeg"; if (std.ascii.eqlIgnoreCase(ext, ".jpeg")) return "image/jpeg"; if (std.ascii.eqlIgnoreCase(ext, ".gif")) return "image/gif"; if (std.ascii.eqlIgnoreCase(ext, ".webp")) return "image/webp"; if (std.ascii.eqlIgnoreCase(ext, ".ico")) return "image/x-icon"; if (std.ascii.eqlIgnoreCase(ext, ".woff")) return "font/woff"; if (std.ascii.eqlIgnoreCase(ext, ".woff2")) return "font/woff2"; if (std.ascii.eqlIgnoreCase(ext, ".map")) return "application/json"; if (std.ascii.eqlIgnoreCase(ext, ".txt")) return "text/plain; charset=utf-8"; return "application/octet-stream";}
test "relPath rejects traversal" { try std.testing.expectError(error.InvalidPath, relPath("/../index.html")); try std.testing.expectError(error.InvalidPath, relPath("/assets/../app.js")); try std.testing.expectError(error.InvalidPath, relPath("/assets\\app.js"));}
test "relPath maps root and strips leading slash" { try std.testing.expectEqualStrings("index.html", try relPath("/")); try std.testing.expectEqualStrings("runs/flow-run/abc", try relPath("/runs/flow-run/abc"));}
test "static asset paths do not use SPA fallback" { try std.testing.expect(isStaticAssetPath("assets/app.js")); try std.testing.expect(isStaticAssetPath("ico/favicon.svg")); try std.testing.expect(isStaticAssetPath("favicon.ico")); try std.testing.expect(!isStaticAssetPath("dashboard")); try std.testing.expect(!isStaticAssetPath("runs/flow-run/abc"));}
test "ui settings bypasses SPA fallback" { try std.testing.expect(try isUiSettingsRequest(std.testing.allocator, "/ui-settings")); try std.testing.expect(!try isUiSettingsRequest(std.testing.allocator, "/api/ui-settings"));}
test "normalizeServeBase follows python shape" { try std.testing.expectEqualStrings("/", try normalizeServeBase(std.testing.allocator, "")); try std.testing.expectEqualStrings("/", try normalizeServeBase(std.testing.allocator, "/"));
const prefect = try normalizeServeBase(std.testing.allocator, "prefect/"); defer std.testing.allocator.free(prefect); try std.testing.expectEqualStrings("/prefect", prefect);
try std.testing.expectEqualStrings("/prefect/v2", try normalizeServeBase(std.testing.allocator, "/prefect/v2/"));}
test "rewritePlaceholders removes root placeholder" { const alloc = std.testing.allocator; const rewritten = try rewritePlaceholdersWithBase(alloc, "<script src=\"/PREFECT_UI_SERVE_BASE_REPLACE_PLACEHOLDER/assets/app.js\"></script>", ""); defer alloc.free(rewritten); try std.testing.expectEqualStrings("<script src=\"/assets/app.js\"></script>", rewritten);}
test "rewritePlaceholders inserts non-root serve base" { const alloc = std.testing.allocator; const rewritten = try rewritePlaceholdersWithBase(alloc, "import('/PREFECT_UI_SERVE_BASE_REPLACE_PLACEHOLDER/assets/chunk.js')", "/prefect"); defer alloc.free(rewritten); try std.testing.expectEqualStrings("import('/prefect/assets/chunk.js')", rewritten);}