src/main.zig


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

const std = @import("std");
const memora = @import("memora");

pub const std_options = std.Options {
    .logFn = memora.log.handler,
};

const log = std.log.scoped(.main);

pub fn main() !void {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer std.debug.assert(gpa.deinit() == .ok);

    const allocator = gpa.allocator();

    const address = try std.net.Address.parseIpAndPort("127.0.0.1:8080");
    var net_server = try address.listen(.{});
    defer net_server.deinit();

    log.info("listening on {f}", .{address});

    while (true) {
        const connection = net_server.accept() catch |err| {
            log.err("error: {}", .{err});
            continue;
        };
        defer connection.stream.close();

        var read_buf: [1024 * 8]u8 = undefined;
        var write_buf: [1024 * 8]u8 = undefined;
        var reader = connection.stream.reader(&read_buf);
        var writer = connection.stream.writer(&write_buf);
        var http_server = std.http.Server.init(reader.interface(), &writer.interface);

        var request = http_server.receiveHead() catch continue;
        log.info("{} {s}", .{request.head.method, request.head.target});

        const handler = memora.routes.get(request.head.target);

        handler(&request, allocator) catch |err| {
            log.err("handler({s}): {}", .{request.head.target, err});
        };
    }
}