tiny.profiling.report.serve

1pub const serve = @import("serve.zig");

1const std = @import("std");2const alloc = @import("alloc");3const http = @import("http");4const pretty_usage = @import("pretty_usage");5const sys = @import("sys");67const site = @import("root.zig").site;89const max_page_bytes = 512 * 1024 * 1024;1011pub const Options = struct {12    site: site.Options = .{},13    address: []const u8 = "127.0.0.1",14    port: u16 = 8787,15};1617pub const Generated = struct {18    runs: usize,19    pages: usize,20};2122pub const State = struct {23    allocator: std.mem.Allocator,24    options: Options,25    output_dir: []const u8 = "",26    newest_seen: i128 = 0,27    mutex: std.atomic.Mutex = .unlocked,2829    pub fn init(allocator: std.mem.Allocator, options: Options) State {30        return .{ .allocator = allocator, .options = options };31    }3233    pub fn regenerate(self: *State) !Generated {34        var scratch_state = std.heap.ArenaAllocator.init(self.allocator);35        defer scratch_state.deinit();36        const result = try site.generate(scratch_state.allocator(), self.options.site);37        const output_dir = try self.allocator.dupe(u8, result.output_dir);38        if (self.output_dir.len != 0) self.allocator.free(self.output_dir);39        self.output_dir = output_dir;40        self.newest_seen = newestArtifact(self.allocator, self.options.site.profiling_dir) orelse 0;41        return .{ .runs = result.runs, .pages = result.pages };42    }4344    fn refresh(self: *State) void {45        const newest = newestArtifact(self.allocator, self.options.site.profiling_dir) orelse return;46        if (newest <= self.newest_seen) return;47        const result = self.regenerate() catch |err| {48            pretty_usage.Terminal.stderr(self.allocator, .{}).writeTextFmt(49                "profile web: regeneration failed, serving the previous site: {s}\n",50                .{@errorName(err)},51            ) catch {};52            return;53        };54        pretty_usage.Terminal.stderr(self.allocator, .{}).writeTextFmt(55            "profile web: regenerated {d} page(s) for {d} run(s)\n",56            .{ result.pages, result.runs },57        ) catch {};58    }5960    fn lock(self: *State) void {61        while (!self.mutex.tryLock()) sys.thread.yield();62    }6364    fn unlock(self: *State) void {65        self.mutex.unlock();66    }67};6869fn newestArtifact(allocator: std.mem.Allocator, profiling_dir: []const u8) ?i128 {70    var scratch_state = std.heap.ArenaAllocator.init(allocator);71    defer scratch_state.deinit();72    const scratch = scratch_state.allocator();73    const dir_stat = sys.fs.statFile(profiling_dir) catch return null;74    var newest: i128 = dir_stat.mtime.nanoseconds;75    const listing = sys.fs.listDirAlloc(scratch, profiling_dir) catch return newest;76    for (listing) |item| {77        if (item.kind != .directory) continue;78        const manifest = std.fs.path.join(scratch, &.{ item.path, "manifest.json" }) catch continue;79        const stat = sys.fs.statFile(manifest) catch continue;80        newest = @max(newest, @as(i128, stat.mtime.nanoseconds));81    }82    return newest;83}8485pub fn run(options: Options) !void {86    const allocator = alloc.workerAllocator();87    var state = State.init(allocator, options);88    const first = try state.regenerate();8990    var router = http.Router(*State).init(allocator, &state);91    defer router.deinit();92    router.notFound(serveFile);9394    const server = try http.Server.init(allocator, .{95        .address = options.address,96        .port = options.port,97    });98    defer server.deinit();99    const port = try sys.net.socketPort(server.listener.?);100101    server.setHandler(&router, handleConnection);102103    try pretty_usage.Terminal.stdout(allocator, .{}).writeTextFmt(104        "profile web: {d} run(s), {d} page(s) in {s}\nserving http://{s}:{d}/ (Ctrl-C to stop)\n",105        .{ first.runs, first.pages, state.output_dir, options.address, port },106    );107    try server.listen();108}109110fn handleConnection(router: *http.Router(*State), conn: *http.Connection) void {111    while (router.handleRequest(conn) catch false) {}112}113114fn releaseFileBody(state: *State, body: []const u8) void {115    state.allocator.free(body);116}117118fn serveFile(state: *State, req: *http.Request, res: *http.Response) !void {119    state.lock();120    defer state.unlock();121122    const target = req.pathOnly();123    if (std.mem.eql(u8, target, "/") or std.mem.eql(u8, target, "/index.html")) state.refresh();124125    const relative = resolveRelative(state.allocator, target) catch {126        res.status = 400;127        res.status_text = "Bad Request";128        res.body = "Bad Request";129        return;130    };131    defer state.allocator.free(relative);132    const full = try std.fs.path.join(state.allocator, &.{ state.output_dir, relative });133    defer state.allocator.free(full);134135    const body = sys.fs.readFileAlloc(state.allocator, full, max_page_bytes) catch {136        res.status = 404;137        res.status_text = "Not Found";138        res.body = "Not Found";139        try res.setHeader("Content-Type", "text/plain");140        return;141    };142    res.setBodyWithRelease(body, state, releaseFileBody);143    try res.setHeader("Content-Type", contentType(relative));144    try res.setHeader("Cache-Control", "no-store");145}146147fn resolveRelative(allocator: std.mem.Allocator, target: []const u8) ![]const u8 {148    var trimmed = std.mem.trimStart(u8, target, "/");149    if (trimmed.len == 0) trimmed = "index.html";150    var parts = std.mem.splitScalar(u8, trimmed, '/');151    while (parts.next()) |part| {152        if (std.mem.eql(u8, part, "..") or std.mem.eql(u8, part, ".")) return error.PathEscapes;153    }154    if (trimmed[trimmed.len - 1] == '/') {155        return try std.fmt.allocPrint(allocator, "{s}index.html", .{trimmed});156    }157    return try allocator.dupe(u8, trimmed);158}159160fn contentType(path: []const u8) []const u8 {161    const extension = std.fs.path.extension(path);162    if (std.mem.eql(u8, extension, ".html")) return "text/html; charset=utf-8";163    if (std.mem.eql(u8, extension, ".css")) return "text/css";164    if (std.mem.eql(u8, extension, ".js")) return "text/javascript";165    if (std.mem.eql(u8, extension, ".svg")) return "image/svg+xml";166    if (std.mem.eql(u8, extension, ".json")) return "application/json";167    if (std.mem.eql(u8, extension, ".txt")) return "text/plain; charset=utf-8";168    if (std.mem.eql(u8, extension, ".png")) return "image/png";169    return "application/octet-stream";170}171172test "serve resolves paths and rejects escapes" {173    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);174    defer arena_state.deinit();175    const allocator = arena_state.allocator();176    try std.testing.expectEqualStrings("index.html", try resolveRelative(allocator, "/"));177    try std.testing.expectEqualStrings("index.html", try resolveRelative(allocator, ""));178    try std.testing.expectEqualStrings("runs/a/index.html", try resolveRelative(allocator, "/runs/a/"));179    try std.testing.expectEqualStrings("runs/a/workloads/w.html", try resolveRelative(allocator, "/runs/a/workloads/w.html"));180    try std.testing.expectError(error.PathEscapes, resolveRelative(allocator, "/../etc/passwd"));181    try std.testing.expectError(error.PathEscapes, resolveRelative(allocator, "/runs/../../x"));182}183184test "serve names content types by extension" {185    try std.testing.expectEqualStrings("text/html; charset=utf-8", contentType("index.html"));186    try std.testing.expectEqualStrings("text/css", contentType("profile.css"));187    try std.testing.expectEqualStrings("application/json", contentType("analysis.json"));188    try std.testing.expectEqualStrings("application/octet-stream", contentType("perf.data"));189}190191fn test_listen(server: *http.Server) void {192    server.listen() catch {};193}194195test "serve regenerates and serves the site over http" {196    const model = @import("root.zig").model;197    var arena_state = std.heap.ArenaAllocator.init(std.testing.allocator);198    defer arena_state.deinit();199    const allocator = arena_state.allocator();200    const profiling_dir = ".zig-cache/profile-web-serve-test";201    const output_dir = ".zig-cache/profile-web-serve-test-out";202    defer sys.fs.deleteTree(profiling_dir) catch {};203    defer sys.fs.deleteTree(output_dir) catch {};204    try model.writeTestFixture(allocator, profiling_dir);205206    var state = State.init(allocator, .{207        .site = .{ .profiling_dir = profiling_dir, .output_dir = output_dir },208    });209    const generated = try state.regenerate();210    try std.testing.expectEqual(@as(usize, 9), generated.pages);211212    var router = http.Router(*State).init(allocator, &state);213    defer router.deinit();214    router.notFound(serveFile);215    const server = try http.Server.init(std.testing.allocator, .{ .port = 0, .num_workers = 1 });216    defer {217        server.stop();218        server.deinit();219    }220    const port = try sys.net.socketPort(server.listener.?);221    server.setHandler(&router, handleConnection);222    const listen_thread = try sys.thread.spawn(test_listen, .{server});223    defer {224        server.stop();225        listen_thread.join();226    }227    sys.time.sleepMilliseconds(10);228229    var client = http.Client.init(std.testing.allocator);230    defer client.deinit();231    var client_operation_storage = try http.ClientOperationStorage.init(std.testing.allocator, .{232        .operation_count = 1,233        .host_bytes_per_operation = http.default_client_operation_host_bytes,234        .target_bytes_per_operation = http.default_client_operation_target_bytes,235        .plain_read_bytes_per_operation = http.default_client_operation_plain_read_bytes,236        .plain_write_bytes_per_operation = http.default_client_operation_plain_write_bytes,237    });238    defer client_operation_storage.deinit(std.testing.allocator);239    client_operation_storage.activate();240    const operation_scratch = try client_operation_storage.operation(0);241    var client_response_storage = try http.ClientResponseStorage.init(std.testing.allocator, .{242        .response_count = 1,243        .header_count_per_response = 16,244        .head_bytes_per_response = 4096,245        .body_bytes_per_response = 1024 * 1024,246    });247    defer client_response_storage.deinit(std.testing.allocator);248    client_response_storage.activate();249    const response_scratch = try client_response_storage.response(0);250    var url_buffer: [128]u8 = undefined;251252    const index_response = try client.get(253        operation_scratch,254        response_scratch,255        try std.fmt.bufPrint(&url_buffer, "http://127.0.0.1:{d}/", .{port}),256        &.{},257    );258    try std.testing.expectEqual(@as(u16, 200), index_response.status);259    try std.testing.expect(std.mem.indexOf(u8, index_response.body, "tiny profiling") != null);260261    const flame_response = try client.get(262        operation_scratch,263        response_scratch,264        try std.fmt.bufPrint(265            &url_buffer,266            "http://127.0.0.1:{d}/runs/run-200-bbb/workloads/gpalloc.allocator.flame.html",267            .{port},268        ),269        &.{},270    );271    try std.testing.expectEqual(@as(u16, 200), flame_response.status);272    try std.testing.expect(std.mem.indexOf(u8, flame_response.body, "flame-cpu") != null);273274    const missing_response = try client.get(275        operation_scratch,276        response_scratch,277        try std.fmt.bufPrint(&url_buffer, "http://127.0.0.1:{d}/nope.html", .{port}),278        &.{},279    );280    try std.testing.expectEqual(@as(u16, 404), missing_response.status);281282    const escape_response = try client.get(283        operation_scratch,284        response_scratch,285        try std.fmt.bufPrint(&url_buffer, "http://127.0.0.1:{d}/../build.zig", .{port}),286        &.{},287    );288    try std.testing.expect(escape_response.status == 400 or escape_response.status == 404);289}