Re-commiting whole course squashed into one commit

The history is non-sensical and messy (including every dumb typo)
so I squashed it all to avoid the rabbit hole of thinking how to split
it in a meaningful way.

src/main.zig

@@ -1,19 +1,769 @@
 const std = @import("std");
+const LOG = std.log;
 const net = std.net;
 
+const _KB = 1024;
+const _MB = 1024 * _KB;
+const THREAD_BUF_SIZE = 3 * _MB;
+const MAX_READ_BYTES = 512 * _KB;
+
+const HELP_TEXT =
+    \\usage: codecrafters-http-server [options]
+    \\
+    \\options:
+    \\  --address ADDR     Bind to IP address ADDR.
+    \\  --port PORT        Bind to port PORT.
+    \\  --max-threads NUM  Don't create more than NUM threads.
+    \\  --debug            Enable debugging output.
+    \\  --verbose          Enable verbose output.
+    \\  --directory PATH   Serve files from PATH directory.
+    \\
+    \\
+;
+
+const AppError = error{
+    UnsupportedMethod,
+};
+
+const ParsingError = error{
+    InvalidHeader,
+    InvalidRequestLine,
+    InvalidRequest,
+    OutOfMemory,
+};
+
+const FormattingError = error{
+    BufferOverflow,
+};
+
+const RequestMethod = enum {
+    GET,
+    POST,
+};
+
+const ContentType = enum {
+    plain,
+    binary,
+};
+
+const ContentEncoding = enum {
+    _none,
+    gzip,
+};
+
+const Request = struct {
+    method: RequestMethod,
+    target: []const u8,
+    proto_version: []const u8,
+    body: []const u8,
+    accept_encoding: []ContentEncoding,
+    user_agent: []const u8,
+};
+
+const ResponseStatus = enum(u16) {
+    OK = 200,
+    CREATED = 201,
+    BAD = 400,
+    NOT_FOUND = 404,
+    ERROR = 500,
+};
+
+const Response = struct {
+    status: ResponseStatus,
+    content: []const u8,
+    content_type: ContentType,
+    content_encoding: ContentEncoding = ._none,
+    content_length: usize,
+
+    fn _compressed_content(self: @This(), allocator: std.mem.Allocator) ![]const u8 {
+        var compressed_al = std.ArrayList(u8).init(allocator);
+        var content_fbs = std.io.fixedBufferStream(self.content);
+        try std.compress.gzip.compress(content_fbs.reader(), compressed_al.writer(), .{});
+        return @as([]const u8, compressed_al.items);
+    }
+
+    fn format(self: @This(), allocator: std.mem.Allocator) ![]u8 {
+        var out_al = std.ArrayList(u8).init(allocator);
+        try out_al.appendSlice(switch (self.status) {
+            .OK => "HTTP/1.1 200 OK\r\n",
+            .CREATED => "HTTP/1.1 201 Created\r\n",
+            .BAD => "HTTP/1.1 400 Bad Request\r\n",
+            .NOT_FOUND => "HTTP/1.1 404 Not Found\r\n",
+            .ERROR => "HTTP/1.1 500 Internal Server Error\r\n",
+        });
+        try out_al.appendSlice(switch (self.content_type) {
+            .plain => "Content-Type: text/plain\r\n",
+            .binary => "Content-Type: application/octet-stream\r\n",
+        });
+        const content = switch (self.content_encoding) {
+            .gzip => try self._compressed_content(allocator),
+            ._none => self.content,
+        };
+        if (self.content_encoding == .gzip) try out_al.appendSlice("Content-Encoding: gzip\r\n");
+        try std.fmt.format(out_al.writer(), "Content-Length: {d}\r\n", .{content.len});
+        try out_al.appendSlice("\r\n");
+        try out_al.appendSlice(content);
+        return out_al.items;
+    }
+};
+
+const Header = struct {
+    name: []const u8,
+    value: []const u8,
+};
+
+fn parse_request(buff: []const u8, logger: ThreadLogger, allocator: std.mem.Allocator) ParsingError!Request {
+    var end: usize = 0;
+    var pos: usize = 0;
+
+    // generic checks
+    if (!std.mem.containsAtLeast(u8, buff, 2, "\r\n")) return ParsingError.InvalidRequest;
+
+    // method
+    end = std.mem.indexOfPos(u8, buff, pos, " ") orelse return ParsingError.InvalidRequestLine;
+    const method: RequestMethod = blk: {
+        if (std.mem.eql(u8, buff[pos..end], "GET")) break :blk .GET;
+        if (std.mem.eql(u8, buff[pos..end], "POST")) break :blk .POST;
+        return ParsingError.InvalidRequestLine;
+    };
+    pos = end + 1;
+
+    // target
+    end = std.mem.indexOfPos(u8, buff, pos, " ") orelse return ParsingError.InvalidRequestLine;
+    const target = buff[pos..end];
+    if (target.len < 1) return ParsingError.InvalidRequestLine;
+    pos = end + 1;
+
+    // proto_version
+    end = std.mem.indexOfPos(u8, buff, pos, "\r\n") orelse return ParsingError.InvalidRequest;
+    const proto_version = buff[pos..end];
+    pos = end + 2;
+
+    // headers
+    var accept_encoding_al = std.ArrayList(ContentEncoding).init(allocator);
+    var user_agent_al = std.ArrayList(u8).init(allocator);
+    var headerline_iter = std.mem.split(u8, buff[pos..], "\r\n");
+    var headerline_delim_pos: usize = 0;
+    var header_name: []const u8 = undefined;
+    var header_value: []const u8 = undefined;
+    while (headerline_iter.next()) |headerline| {
+        pos = pos + headerline.len + 2;
+        if (headerline.len == 0) break;
+        headerline_delim_pos = std.mem.indexOf(u8, headerline, ": ") orelse return ParsingError.InvalidHeader;
+        header_name = headerline[0..headerline_delim_pos];
+        header_value = headerline[headerline_delim_pos + 2 ..];
+
+        if (eql_i(header_name, "Accept-Encoding")) {
+            var ae_iter = std.mem.split(u8, header_value, ", ");
+            while (ae_iter.next()) |ae_word| {
+                if (eql_i(ae_word, "gzip")) {
+                    accept_encoding_al.append(.gzip) catch return ParsingError.OutOfMemory;
+                } else {
+                    logger.warn("ignoring unknown Accept-Encoding: {s}", .{ae_word});
+                }
+            }
+        } else if (eql_i(header_name, "User-Agent")) {
+            user_agent_al.appendSlice(header_value) catch return ParsingError.OutOfMemory;
+        } else {
+            logger.warn("ignoring unknown header: {s}", .{header_name});
+        }
+    }
+
+    return Request{
+        .method = method,
+        .target = target,
+        .proto_version = proto_version,
+        .user_agent = user_agent_al.items,
+        .accept_encoding = accept_encoding_al.items,
+        .body = buff[pos..],
+    };
+}
+
+const Task = struct {
+    request: Request,
+    app_options: AppOptions,
+    allocator: std.mem.Allocator,
+    logger: ThreadLogger,
+
+    fn _create_response(self: @This(), status: ResponseStatus, content: []const u8, content_type: ContentType) !Response {
+        const content_encoding: ContentEncoding = blk: {
+            if (self.request.accept_encoding.len == 0) break :blk ._none;
+            if (content.len == 0) break :blk ._none;
+            break :blk self.request.accept_encoding[0];
+        };
+        return Response{
+            .status = status,
+            .content = content,
+            .content_type = content_type,
+            .content_encoding = content_encoding,
+            .content_length = content.len,
+        };
+    }
+
+    fn _process(self: @This(), endpoint: Endpoint) !Response {
+        switch (endpoint) {
+            ._not_found => {
+                return self._create_response(.NOT_FOUND, "", .plain);
+            },
+
+            ._method_unsupported => {
+                return self._create_response(.BAD, "method not supported", .plain);
+            },
+
+            .get_echo_void => {
+                return self._create_response(.OK, "", .plain);
+            },
+
+            .get_echo_str => {
+                std.debug.assert(std.mem.startsWith(u8, self.request.target, "/echo/"));
+                const str: []const u8 = self.request.target[6..];
+                return self._create_response(.OK, str, .plain);
+            },
+
+            .get_echo_ua => {
+                std.debug.assert(std.mem.eql(u8, self.request.target, "/user-agent"));
+                return self._create_response(.OK, self.request.user_agent, .plain);
+            },
+
+            .get_files_path => {
+                std.debug.assert(std.mem.startsWith(u8, self.request.target, "/files/"));
+                const filename = self.request.target[7..];
+                if (contains(filename, "/")) return self._create_response(.BAD, "filename .plain not contain slash", .plain);
+                if (self.app_options.directory == null) return self._create_response(.BAD, "storage .plain", .plain);
+                const root = try std.fs.openDirAbsolute(self.app_options.directory orelse unreachable, .{});
+                const fh = root.openFile(filename, .{ .mode = .read_only }) catch |e| switch (e) {
+                    error.FileNotFound => return self._create_response(.NOT_FOUND, "", .plain),
+                    error.AccessDenied => return self._create_response(.NOT_FOUND, "", .plain),
+                    else => return e,
+                };
+                const content = try fh.readToEndAlloc(self.allocator, MAX_READ_BYTES);
+                return self._create_response(.OK, content, .binary);
+            },
+
+            .post_files_path => {
+                std.debug.assert(std.mem.startsWith(u8, self.request.target, "/files/"));
+                const filename = self.request.target[7..];
+                if (contains(filename, "/")) return self._create_response(.BAD, "filename .plain not contain slash", .plain);
+                if (self.app_options.directory == null) return self._create_response(.BAD, "storage disabled", .plain);
+                const root = try std.fs.openDirAbsolute(self.app_options.directory orelse unreachable, .{});
+                const fh = try root.createFile(filename, .{});
+                try fh.writeAll(self.request.body);
+                return self._create_response(.CREATED, "", .plain);
+            },
+
+            ._error => {
+                return self._create_response(.ERROR, "", .plain);
+            },
+        }
+    }
+
+    fn respond(self: @This()) Response {
+        const endpoint = Endpoint.select(self.request);
+        self.logger.debug("Task.respond():selected endpoint: {}", .{endpoint});
+        return self._process(endpoint) catch |e| {
+            self.logger.err("Endpoint.respond():e={}", .{e});
+            return Response{
+                .status = .ERROR,
+                .content = "error when creating response",
+                .content_type = .plain,
+                .content_encoding = ._none,
+                .content_length = 0,
+            };
+        };
+    }
+};
+
+fn contains(haystack: []const u8, needle: []const u8) bool {
+    const idx = std.mem.indexOf(u8, haystack, needle);
+    return idx != null;
+}
+
+const Endpoint = union(enum) {
+    get_echo_void,
+    get_echo_str,
+    get_echo_ua,
+    get_files_path,
+    post_files_path,
+    _not_found,
+    _method_unsupported,
+    _error,
+
+    fn _match(request: Request, method: RequestMethod, op: enum { eq, sw }, needle: []const u8) bool {
+        if (request.method != method) return false;
+        return switch (op) {
+            .eq => std.mem.eql(u8, request.target, needle),
+            .sw => std.mem.startsWith(u8, request.target, needle),
+        };
+    }
+
+    fn select(request: Request) Endpoint {
+        if (Endpoint._match(request, .GET, .eq, "/")) return .get_echo_void;
+        if (Endpoint._match(request, .GET, .sw, "/echo/")) return .get_echo_str;
+        if (Endpoint._match(request, .GET, .eq, "/user-agent")) return .get_echo_ua;
+        if (Endpoint._match(request, .GET, .sw, "/files/")) return .get_files_path;
+        if (Endpoint._match(request, .POST, .sw, "/files/")) return .post_files_path;
+        return ._not_found;
+    }
+};
+
+// True if ASCII strings *a* and *b* are equal with case-insensitive comparison.
+fn eql_i(a: []const u8, b: []const u8) bool {
+    if (a.len != b.len) return false;
+    for (a, b) |ac, bc| {
+        std.debug.assert(std.ascii.isASCII(ac));
+        std.debug.assert(std.ascii.isASCII(bc));
+        if (ac == bc) continue;
+        if (std.ascii.eqlIgnoreCase(a, b)) continue;
+        return false;
+    }
+    return true;
+}
+
+fn append(buff: []u8, pos: usize, val: []const u8) FormattingError!usize {
+    if (pos >= buff.len) return FormattingError.BufferOverflow;
+    const dest = buff[pos..];
+    if (dest.len < val.len) return FormattingError.BufferOverflow;
+    std.mem.copyForwards(u8, dest, val);
+    return pos + val.len;
+}
+
+fn append_fmt(buff: []u8, pos: usize, comptime fmt: []const u8, args: anytype) FormattingError!usize {
+    if (pos >= buff.len) return FormattingError.BufferOverflow;
+    if (buff.len < fmt.len) return FormattingError.BufferOverflow;
+    const dest = buff[pos..];
+    const written = std.fmt.bufPrint(dest, fmt, args) catch |err| switch (err) {
+        error.NoSpaceLeft => return FormattingError.BufferOverflow,
+        else => unreachable,
+    };
+    return pos + written.len;
+}
+
+fn upto(buff: []const u8, len: usize) []const u8 {
+    if (buff.len <= len) return buff;
+    return buff[0..len];
+}
+
+const ThreadLogger = struct {
+    conn: std.net.Server.Connection,
+    thread_id: std.Thread.Id,
+
+    fn init(conn: std.net.Server.Connection) ThreadLogger {
+        return ThreadLogger{
+            .conn = conn,
+            .thread_id = std.Thread.getCurrentId(),
+        };
+    }
+
+    fn debug(self: @This(), comptime fmt: []const u8, args: anytype) void {
+        var arr: [1000]u8 = undefined;
+        const msg = std.fmt.bufPrint(@as([]u8, &arr), fmt, args) catch return;
+        LOG.debug("{} thread[{}]: {s}", .{ self.conn.address, self.thread_id, msg });
+    }
+
+    fn err(self: @This(), comptime fmt: []const u8, args: anytype) void {
+        var arr: [1000]u8 = undefined;
+        const msg = std.fmt.bufPrint(@as([]u8, &arr), fmt, args) catch return;
+        LOG.err("{} thread[{}]: {s}", .{ self.conn.address, self.thread_id, msg });
+    }
+
+    fn info(self: @This(), comptime fmt: []const u8, args: anytype) void {
+        var arr: [1000]u8 = undefined;
+        const msg = std.fmt.bufPrint(@as([]u8, &arr), fmt, args) catch return;
+        LOG.info("{} thread[{}]: {s}", .{ self.conn.address, self.thread_id, msg });
+    }
+
+    fn warn(self: @This(), comptime fmt: []const u8, args: anytype) void {
+        var arr: [1000]u8 = undefined;
+        const msg = std.fmt.bufPrint(@as([]u8, &arr), fmt, args) catch return;
+        LOG.warn("{} thread[{}]: {s}", .{ self.conn.address, self.thread_id, msg });
+    }
+};
+
+fn safe_handle_connection(conn: std.net.Server.Connection, app_options: AppOptions) void {
+    const logger = ThreadLogger.init(conn);
+    logger.info("safe_handle_connection():processing connection", .{});
+    handle_connection(conn, logger, app_options) catch |err| {
+        logger.err("safe_handle_connection():aborting thread: processing request failed: {}", .{err});
+        return;
+    };
+    logger.info("safe_handle_connection():done", .{});
+}
+
+/// Helper struct to aid with learning about and debugging ThreadMem
+const ThreadMemDebug = struct {
+    buff: []u8,
+    inner_fba_ptr: *std.heap.FixedBufferAllocator,
+    allocator_ptr: *std.mem.Allocator,
+    arena_ptr: *std.heap.ArenaAllocator,
+    outer_sky: []u8,
+    inner_sky: []u8,
+
+    /// Write to *buff* a unique four-character symbol of *ptr*.
+    ///
+    /// Value of the symbol bears no useul relation to value or type of the pointer
+    /// but different pointers will likely produce different symbol.  The symbol is
+    /// only useful for visually distinguishing two distinct pointers.
+    fn _write_ptr_sym(buff: *[4]u8, ptr: anytype) void {
+        buff.*[0] = '_';
+        buff.*[1] = '_';
+        var desc_buff: [1000]u8 = undefined;
+        const desc = std.fmt.bufPrint(&desc_buff, "{*}", .{ptr}) catch return;
+        var hash: [16]u8 = undefined;
+        std.crypto.hash.Md5.hash(desc, &hash, .{});
+        _ = std.fmt.bufPrint(buff, "{x}{x}", .{ hash[0], hash[1] }) catch return;
+    }
+
+    /// Describe pointer *item_ptr* in relation to our main buffer.
+    ///
+    /// *item_ptr* must be pointer to an object previously allocated using
+    /// ThreadMem.allocator.
+    ///
+    /// Send to debug log a description of main buffer and *item_ptr* prefixed by
+    /// simplified information about where the *item_ptr* points within our buffer.
+    fn describe_ptr(self: @This(), logger: ThreadLogger, label: []const u8, item_ptr: anytype) void {
+        const buff_addr = @intFromPtr(&self.buff);
+        var buff_sym: [4]u8 = undefined;
+        _write_ptr_sym(&buff_sym, &self.buff);
+        var item_sym: [4]u8 = undefined;
+        _write_ptr_sym(&item_sym, item_ptr);
+        const item_addr = @intFromPtr(item_ptr);
+        std.debug.assert(item_addr > buff_addr);
+        const item_off = item_addr - buff_addr;
+        logger.debug("{s: <50}: {s} + {d: >6}       {*}: [...{*}]", .{ label, buff_sym, item_off, &self.buff, item_ptr });
+    }
+
+    fn debug_dump(self: @This(), logger: ThreadLogger) void {
+        self.describe_ptr(logger, "ThreadMemDebug.debug_dump():inner_fba_ptr", self.inner_fba_ptr);
+        self.describe_ptr(logger, "ThreadMemDebug.debug_dump():arena_ptr", self.arena_ptr);
+        self.describe_ptr(logger, "ThreadMemDebug.debug_dump():allocator_ptr", self.allocator_ptr);
+        self.describe_ptr(logger, "ThreadMemDebug.debug_dump():&outer_sky", &self.outer_sky);
+        self.describe_ptr(logger, "ThreadMemDebug.debug_dump():&inner_sky", &self.inner_sky);
+        logger.debug("ThreadMemDebug.debug_dump():inner_fba_ptr.end_index={d}", .{self.inner_fba_ptr.end_index});
+        logger.debug("ThreadMemDebug.debug_dump():outer_sky.len={d}", .{self.outer_sky.len});
+        logger.debug("ThreadMemDebug.debug_dump():inner_sky.len={d}", .{self.inner_sky.len});
+    }
+};
+
+/// Memory management helper which is created using fixed array
+/// and contains embedded ArenaAllocator which can be used to further
+/// allocate memory from the rest of the array.
+///
+/// You only need to call .deinit() on ThreadMem in order to release
+/// the whole structure.
+const ThreadMem = struct {
+    allocator: std.mem.Allocator,
+    arena: std.heap.ArenaAllocator,
+    debug: ThreadMemDebug,
+
+    /// WARNING: buff must be at least 1024 bytes long.
+    fn init(buff: []u8) !ThreadMem {
+        std.debug.assert(buff.len > 1024);
+        // first, create FBA from buff and allocate memory for all supporting objects
+        var outer_fba = std.heap.FixedBufferAllocator.init(buff);
+        var arena_ptr = try outer_fba.allocator().create(std.heap.ArenaAllocator);
+        const allocator_ptr = try outer_fba.allocator().create(std.mem.Allocator);
+        var inner_fba_ptr = try outer_fba.allocator().create(std.heap.FixedBufferAllocator);
+        const outer_sky = buff[outer_fba.end_index..];
+        // now, ^^ outer_sky is the actual free remaining memory
+        inner_fba_ptr.* = std.heap.FixedBufferAllocator.init(outer_sky);
+        arena_ptr.* = std.heap.ArenaAllocator.init(inner_fba_ptr.allocator());
+        allocator_ptr.* = arena_ptr.allocator();
+        const inner_sky = buff[inner_fba_ptr.end_index..];
+        return ThreadMem{
+            .allocator = allocator_ptr.*,
+            .arena = arena_ptr.*,
+            .debug = ThreadMemDebug{
+                .buff = buff,
+                .inner_fba_ptr = inner_fba_ptr,
+                .arena_ptr = arena_ptr,
+                .allocator_ptr = allocator_ptr,
+                .outer_sky = outer_sky,
+                .inner_sky = inner_sky,
+            },
+        };
+    }
+
+    fn deinit(self: @This()) void {
+        self.arena.deinit();
+    }
+};
+
+fn handle_connection(conn: std.net.Server.Connection, logger: ThreadLogger, app_options: AppOptions) !void {
+    var thread_buf: [THREAD_BUF_SIZE]u8 = undefined;
+    const mem = try ThreadMem.init(&thread_buf);
+    defer mem.deinit();
+    mem.debug.debug_dump(logger);
+    defer conn.stream.close();
+    const request_buff = try mem.allocator.alloc(u8, app_options.request_buff_size);
+    const response_buff = try mem.allocator.alloc(u8, app_options.response_buff_size);
+    mem.debug.describe_ptr(logger, "handle_connection():&request_buff", &request_buff);
+    mem.debug.describe_ptr(logger, "handle_connection():&response_buff", &response_buff);
+    var bytes_read: usize = undefined;
+    bytes_read = try conn.stream.read(request_buff);
+    logger.info("handle_connection():read: {d} bytes", .{bytes_read});
+    const request = try parse_request(request_buff[0..bytes_read], logger, mem.allocator);
+    logger.info("handle_connection():parsed request: proto_version={s}, method={}, target={s}, user_agent={s}, accept_encoding={any}, body.len={d}", .{
+        request.proto_version,
+        request.method,
+        request.target,
+        request.user_agent,
+        request.accept_encoding,
+        request.body.len,
+    });
+    const task = Task{
+        .request = request,
+        .allocator = mem.allocator,
+        .app_options = app_options,
+        .logger = logger,
+    };
+    const response = task.respond();
+    logger.debug("handle_connection():formed response: status={}, content[0..32]=|{s}|", .{ response.status, upto(response.content, 32) });
+    //    mem.debug.describe_ptr(logger, "handle_connection():response.headers", &response.headers);
+    const response_bytes = try response.format(mem.allocator);
+    logger.info("handle_connection():sending response: {d} bytes", .{response_bytes.len});
+    try conn.stream.writeAll(response_bytes);
+    logger.info("handle_connection():wrote response to stream: {*}", .{&conn.stream});
+}
+
+const ArgParsingResult = union(enum) {
+    options: AppOptions,
+    usage_error: []const u8,
+
+    fn unknown_arg(arg: []const u8) ArgParsingResult {
+        var arr: [100]u8 = undefined;
+        const msg = std.fmt.bufPrint(@as([]u8, &arr), "unknown argument: {s}", .{arg}) catch "unknown argument";
+        return ArgParsingResult{ .usage_error = msg };
+    }
+};
+
+const AppOptions = struct {
+    directory: ?[]const u8,
+    address: []const u8,
+    port: u16,
+    debug: bool,
+    verbose: bool,
+    response_buff_size: usize,
+    request_buff_size: usize,
+    max_threads: usize,
+
+    fn init() AppOptions {
+        const parsing_result = AppOptions.parse_args();
+        switch (parsing_result) {
+            .options => return parsing_result.options,
+            .usage_error => {
+                _ = std.io.getStdErr().write(HELP_TEXT) catch {};
+                _ = std.io.getStdErr().write(parsing_result.usage_error) catch {};
+                _ = std.io.getStdErr().write("\n") catch {};
+                std.process.exit(2);
+            },
+        }
+    }
+
+    fn parse_args() ArgParsingResult {
+        var options = AppOptions{
+            .debug = false,
+            .directory = null,
+            .address = "127.0.0.1",
+            .port = 4221,
+            .verbose = false,
+            .request_buff_size = 1024 * 1024,
+            .response_buff_size = 1024 * 1024,
+            .max_threads = std.Thread.getCpuCount() catch 1,
+        };
+        var this: []const u8 = undefined;
+        var it = std.process.args();
+        var param: ?[]const u8 = null;
+        _ = it.next(); // drop program name
+        while (true) {
+            this = @as(?[]const u8, it.next()) orelse break;
+            if (std.mem.eql(u8, this, "--directory")) {
+                param = @as(?[]const u8, it.next());
+                options.directory = param orelse return ArgParsingResult{ .usage_error = "no DIRECTORY?" };
+            } else if (std.mem.eql(u8, this, "--address")) {
+                param = @as(?[]const u8, it.next());
+                options.address = param orelse return ArgParsingResult{ .usage_error = "no ADDRESS?" };
+            } else if (std.mem.eql(u8, this, "--port")) {
+                param = @as(?[]const u8, it.next());
+                options.port = std.fmt.parseInt(u16, param orelse return ArgParsingResult{ .usage_error = "no PORT?" }, 10) catch {
+                    return ArgParsingResult{ .usage_error = "PORT must be integer" };
+                };
+            } else if (std.mem.eql(u8, this, "--max-threads")) {
+                param = @as(?[]const u8, it.next());
+                options.max_threads = std.fmt.parseInt(usize, param orelse return ArgParsingResult{ .usage_error = "no NUM?" }, 10) catch {
+                    return ArgParsingResult{ .usage_error = "NUM must be integer" };
+                };
+            } else if (std.mem.eql(u8, this, "--debug")) {
+                options.debug = true;
+            } else if (std.mem.eql(u8, this, "--verbose")) {
+                options.verbose = true;
+            } else {
+                return ArgParsingResult.unknown_arg(this);
+            }
+        }
+        return ArgParsingResult{ .options = options };
+    }
+};
+
 pub fn main() !void {
-    const stdout = std.io.getStdOut().writer();
-
-    // You can use print statements as follows for debugging, they'll be visible when running tests.
-    try stdout.print("Logs from your program will appear here!\n", .{});
-
-    // Uncomment this block to pass the first stage
-    // const address = try net.Address.resolveIp("127.0.0.1", 4221);
-    // var listener = try address.listen(.{
-    //     .reuse_address = true,
-    // });
-    // defer listener.deinit();
-    //
-    // _ = try listener.accept();
-    // try stdout.print("client connected!", .{});
+    const app_options = AppOptions.init();
+    LOG.info("app_options.address: {str}", .{app_options.address});
+    LOG.info("app_options.port: {d}", .{app_options.port});
+    LOG.info("app_options.directory: {any}", .{app_options.directory});
+    LOG.info("app_options.debug: {}", .{app_options.debug});
+    LOG.info("app_options.verbose: {}", .{app_options.verbose});
+    LOG.info("app_options.request_buff_size: {d}", .{app_options.request_buff_size});
+    LOG.info("app_options.response_buff_size: {d}", .{app_options.response_buff_size});
+    LOG.info("app_options.max_threads: {d}", .{app_options.max_threads});
+
+    // Server
+    const address = try net.Address.resolveIp(app_options.address, @as(u16, app_options.port));
+    var listener = try address.listen(.{
+        .reuse_address = true,
+    });
+    defer listener.deinit();
+    LOG.info("listening: {}", .{listener.listen_address});
+
+    // Worker thread pool
+    var pool: std.Thread.Pool = undefined;
+    try pool.init(std.Thread.Pool.Options{
+        .allocator = std.heap.page_allocator,
+        .n_jobs = @intCast(app_options.max_threads),
+    });
+
+    // Connections
+    var conn: net.Server.Connection = undefined;
+    while (true) {
+        conn = try listener.accept();
+        LOG.info("{any}: accepted connection", .{conn.address});
+        try pool.spawn(safe_handle_connection, .{ conn, app_options });
+    }
+}
+
+test parse_request {
+    var poor_buf: [10]u8 = undefined;
+    var tiny_buf: [100]u8 = undefined;
+    var rich_buf: [10_000]u8 = undefined;
+    var rich_fba = std.heap.FixedBufferAllocator.init(&rich_buf);
+    var poor_fba = std.heap.FixedBufferAllocator.init(&poor_buf);
+    var tiny_fba = std.heap.FixedBufferAllocator.init(&tiny_buf);
+    const poor_allocator = poor_fba.allocator();
+    const tiny_allocator = tiny_fba.allocator();
+    const rich_allocator = rich_fba.allocator();
+
+    // bad request
+    try std.testing.expectEqual(ParsingError.InvalidRequest, parse_request("", rich_allocator));
+    try std.testing.expectEqual(ParsingError.InvalidRequest, parse_request(" ", rich_allocator));
+    try std.testing.expectEqual(ParsingError.InvalidRequest, parse_request("\r\n", rich_allocator));
+    try std.testing.expectEqual(ParsingError.InvalidRequest, parse_request("\n", rich_allocator));
+    try std.testing.expectEqual(ParsingError.InvalidRequest, parse_request("GET / HTTP/1.1\n\n", rich_allocator));
+    try std.testing.expectEqual(ParsingError.InvalidRequest, parse_request(" ", rich_allocator));
+    try std.testing.expectEqual(ParsingError.InvalidRequest, parse_request("\r\n", rich_allocator));
+    try std.testing.expectEqual(ParsingError.InvalidRequest, parse_request("\n", rich_allocator));
+
+    // bad request line
+    try std.testing.expectEqual(ParsingError.InvalidRequestLine, parse_request("GET  / HTTP/1.1\r\n\r\n", rich_allocator));
+    try std.testing.expectEqual(ParsingError.InvalidRequestLine, parse_request("GET  HTTP/1.1\r\n\r\n", rich_allocator));
+    try std.testing.expectEqual(ParsingError.InvalidRequestLine, parse_request("GET HTTP/1.1\r\n\r\n", rich_allocator));
+    try std.testing.expectEqual(ParsingError.InvalidRequestLine, parse_request("GET\r\n\r\n", rich_allocator));
+    try std.testing.expectEqual(ParsingError.InvalidRequestLine, parse_request("\r\n\r\n", rich_allocator));
+
+    const poor_request = ("GET / HTTP/1.1\r\n" ++ "\r\n");
+    const tiny_request = ("GET / HTTP/1.1\r\n" ++ "Foo: bar\r\n" ++ "\r\n");
+    const rich_request = ("GET /hey HTTP/1.1\r\n" ++ "Jane: 3\r\n" ++ "Joe: 42\r\n" ++ "\r\n" ++ "abc");
+
+    // out of memory
+    try std.testing.expectEqual(ParsingError.OutOfMemory, parse_request(tiny_request, poor_allocator));
+    try std.testing.expectEqual(ParsingError.OutOfMemory, parse_request(rich_request, tiny_allocator));
+
+    // small memory, comply
+    const poor_result = try parse_request(poor_request, poor_allocator);
+    try std.testing.expectEqual(RequestMethod.GET, poor_result.method);
+    try std.testing.expectEqualSlices(u8, "HTTP/1.1", poor_result.proto_version);
+    try std.testing.expectEqualSlices(u8, "/", poor_result.target);
+    try std.testing.expectEqual(0, poor_result.headers.len);
+    try std.testing.expectEqualSlices(u8, "", poor_result.body);
+
+    // correct request, tiny one
+    const tiny_result = try parse_request(tiny_request, rich_allocator);
+    try std.testing.expectEqual(RequestMethod.GET, tiny_result.method);
+    try std.testing.expectEqualSlices(u8, "/", tiny_result.target);
+    try std.testing.expectEqualSlices(u8, "HTTP/1.1", tiny_result.proto_version);
+    try std.testing.expectEqual(1, tiny_result.headers.len);
+    try std.testing.expectEqualDeep(Header{ .name = "Foo", .value = "bar" }, tiny_result.headers[0]);
+    try std.testing.expectEqualSlices(u8, "", tiny_result.body);
+
+    // correct request
+    const rich_result = try parse_request(rich_request, rich_allocator);
+    try std.testing.expectEqual(RequestMethod.GET, rich_result.method);
+    try std.testing.expectEqualSlices(u8, "/hey", rich_result.target);
+    try std.testing.expectEqualSlices(u8, "HTTP/1.1", rich_result.proto_version);
+    try std.testing.expectEqual(2, rich_result.headers.len);
+    try std.testing.expectEqualDeep(Header{ .name = "Jane", .value = "3" }, rich_result.headers[0]);
+    try std.testing.expectEqualDeep(Header{ .name = "Joe", .value = "42" }, rich_result.headers[1]);
+    try std.testing.expectEqualSlices(u8, "abc", rich_result.body);
+    try std.testing.expectEqual(3, rich_result.body.len);
+}
+
+test append {
+    const buff = try std.testing.allocator.alloc(u8, 8);
+    defer std.testing.allocator.free(buff);
+
+    // empty buff
+    try std.testing.expectEqual(FormattingError.BufferOverflow, append(buff[0..0], 0, "foo"));
+
+    // small buff: value is longer
+    try std.testing.expectEqual(FormattingError.BufferOverflow, append(buff[0..7], 0, "foo-bar-baz"));
+
+    // small buff: pos is outside
+    try std.testing.expectEqual(FormattingError.BufferOverflow, append(buff, 8, "foo"));
+
+    // small buff: pos is too far
+    try std.testing.expectEqual(FormattingError.BufferOverflow, append(buff, 7, "foo"));
+
+    // bad value: empty but outside
+    try std.testing.expectEqual(FormattingError.BufferOverflow, append(buff, 8, ""));
+
+    // ok: empty left
+    try std.testing.expectEqual(0, append(buff, 0, ""));
+
+    // ok: empty right
+    try std.testing.expectEqual(7, append(buff, 7, ""));
+
+    // ok: aligned left
+    try std.testing.expectEqual(3, append(buff, 0, "foo"));
+
+    // ok: aligned right
+    try std.testing.expectEqual(7, append(buff, 4, "foo"));
+}
+
+test append_fmt {
+    const buff = try std.testing.allocator.alloc(u8, 8);
+    defer std.testing.allocator.free(buff);
+
+    // empty buff
+    try std.testing.expectEqual(FormattingError.BufferOverflow, append_fmt(buff[0..0], 0, "foo", .{}));
+
+    // small buff: value is longer
+    try std.testing.expectEqual(FormattingError.BufferOverflow, append_fmt(buff[0..7], 0, "foo-{s}", .{"bar-baz"}));
+
+    // small buff: pos is outside
+    try std.testing.expectEqual(FormattingError.BufferOverflow, append_fmt(buff, 8, "foo", .{}));
+
+    // small buff: pos is too far (empty fmt)
+    try std.testing.expectEqual(FormattingError.BufferOverflow, append_fmt(buff, 7, "foo", .{}));
+
+    // small buff: pos is too far (expanded fmt)
+    try std.testing.expectEqual(FormattingError.BufferOverflow, append_fmt(buff, 2, "foo-{s}", .{"bar"}));
+
+    // ok: empty left
+    try std.testing.expectEqual(0, append_fmt(buff, 0, "", .{}));
+
+    // ok: empty right
+    try std.testing.expectEqual(7, append_fmt(buff, 7, "", .{}));
+
+    // ok: aligned left
+    try std.testing.expectEqual(5, append_fmt(buff, 0, "foo-{d}", .{1}));
+
+    // ok: aligned right
+    try std.testing.expectEqual(7, append_fmt(buff, 2, "foo-{d}", .{1}));
 }

your_program.sh

@@ -14,7 +14,7 @@ set -e # Exit early if any commands fail
 # - Edit .codecrafters/compile.sh to change how your program compiles remotely
 (
   cd "$(dirname "$0")" # Ensure compile steps are run within the repository directory
-  zig build
+  zig build -freference-trace
 )
 
 # Copied from .codecrafters/run.sh