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
|
const std = @import("std");
const RouteSet = @import("RouteSet.zig");
const Self = @This();
server: std.Io.net.Server,
threaded: std.Io.Threaded,
routes: RouteSet,
pub fn init(
gpa: std.mem.Allocator,
address: std.Io.net.IpAddress,
comptime routes: RouteSet,
) !Self {
var threaded: std.Io.Threaded = .init(gpa, .{});
return .{
.threaded = threaded,
.server = try address.listen(threaded.io(), .{ .reuse_address = true }),
.routes = routes,
};
}
pub fn serve(self: *Self, gpa: std.mem.Allocator) !void {
var group: std.Io.Group = .init;
const io = self.threaded.io();
while (true) {
const stream = try self.server.accept(self.threaded.io());
group.async(io, handle, .{self, gpa, stream});
}
}
pub fn handle(
self: *Self,
gpa: std.mem.Allocator,
stream: std.Io.net.Stream,
) void {
var read_buffer: [1024 * 8]u8 = undefined;
var write_buffer: [1024 * 8]u8 = undefined;
defer stream.close(self.threaded.io());
var arena: std.heap.ArenaAllocator = .init(gpa);
defer arena.deinit();
var reader = stream.reader(self.threaded.io(), &read_buffer);
var writer = stream.writer(self.threaded.io(), &write_buffer);
var server: std.http.Server = .init(&reader.interface, &writer.interface);
var request = server.receiveHead() catch |e| {
std.debug.print("error: {}\n", .{e});
return;
};
std.debug.print("{s} {s}\n", .{ @tagName(request.head.method), request.head.target });
if (self.routes.getInterface(request.head.target)) |interface| {
const message = interface.handle(gpa, arena.allocator(), self.threaded.io(), &request);
message.send(self.threaded.io(), &request) catch return;
} else {
request.respond("", .{ .status = .not_found }) catch return;
}
}
|
