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
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
|
const std = @import("std");
const memora = @import("memora");
pub const std_options = std.Options {
.logFn = memora.log.handler,
};
const log = std.log.scoped(.main);
var net_server: std.net.Server = undefined;
var storage: memora.Storage = undefined;
fn signal_handler(signo: i32) callconv(.c) void {
if (signo == std.os.linux.SIG.INT) {
log.info("shutdown", .{});
net_server.deinit();
std.process.exit(0);
}
}
fn register_sigaction() void {
var sa = std.os.linux.Sigaction{
.handler = .{ .handler = signal_handler },
.mask = std.mem.zeroes(std.os.linux.sigset_t),
.flags = 0,
};
_ = std.os.linux.sigaction(std.os.linux.SIG.INT, &sa, null);
}
pub fn main() !void {
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
defer std.debug.assert(gpa.deinit() == .ok);
const allocator = gpa.allocator();
storage = try .init(allocator);
const address = try std.net.Address.parseIpAndPort("0.0.0.0:8080");
net_server = try address.listen(.{ .reuse_address = true });
defer net_server.deinit();
register_sigaction();
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} {s}", .{std.enums.tagName(std.http.Method, request.head.method) orelse "<unknown>", request.head.target});
const handler_info = memora.routes.get(request.head.target);
try handler_info.handle(
&request,
&storage,
allocator
);
}
}
|
