serveSourcesTar

fn serveSourcesTar(request: *std.http.Server.Request, context: *Context) !void

File

Code

fn serveSourcesTar(request: *std.http.Server.Request, context: *Context) !void {
    const gpa = context.gpa;
    const io = context.io;

    var send_buffer: [0x4000]u8 = undefined;
    var response = try request.respondStreaming(&send_buffer, .{
        .respond_options = .{
            .extra_headers = &.{
                .{ .name = "content-type", .value = "application/x-tar" },
                cache_control_header,
            },
        },
    });

    var std_dir = try context.lib_dir.openDir(io, "std", .{ .iterate = true });
    defer std_dir.close(io);

    var walker = try std_dir.walk(gpa);
    defer walker.deinit();

    var archiver: std.tar.Writer = .{ .underlying_writer = &response.writer };
    archiver.prefix = "std";

    var path_buf: std.ArrayList(u8) = .empty;
    defer path_buf.deinit(gpa);

    while (try walker.next(io)) |entry| {
        switch (entry.kind) {
            .file => {
                if (!std.mem.endsWith(u8, entry.basename, ".zig"))
                    continue;
                if (std.mem.endsWith(u8, entry.basename, "test.zig"))
                    continue;
            },
            else => continue,
        }
        var file = try entry.dir.openFile(io, entry.basename, .{});
        defer file.close(io);
        const stat = try file.stat(io);
        var file_reader: Io.File.Reader = .{
            .io = io,
            .file = file,
            .interface = Io.File.Reader.initInterface(&.{}),
            .size = stat.size,
        };

        const posix_path = if (comptime std.fs.path.sep == std.fs.path.sep_posix)
            entry.path
        else blk: {
            path_buf.clearRetainingCapacity();
            try path_buf.appendSlice(gpa, entry.path);
            std.mem.replaceScalar(u8, path_buf.items, std.fs.path.sep, std.fs.path.sep_posix);
            break :blk path_buf.items;
        };

        try archiver.writeFileTimestamp(posix_path, &file_reader, stat.mtime);
    }

    {
        // Since this command is JIT compiled, the builtin module available in
        // this source file corresponds to the user's host system.
        const builtin_zig = @embedFile("builtin");
        archiver.prefix = "builtin";
        try archiver.writeFileBytes("builtin.zig", builtin_zig, .{});
    }

    // intentionally omitting the pointless trailer
    //try archiver.finish();
    try response.end();
}