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
|
const std = @import("std");
const Response = @import("Response.zig");
const RouteSet = @import("RouteSet.zig");
pub const Options = struct {
address: std.Io.net.IpAddress,
headers: []const std.http.Header = &.{},
};
pub fn serve(
gpa: std.mem.Allocator,
comptime routes: RouteSet,
options: Options,
) !void {
var threaded: std.Io.Threaded = .init(gpa, .{});
var group: std.Io.Group = .init;
const io = threaded.io();
var server = try options.address.listen(io, .{ .reuse_address = true });
const send_options: Response.SendOptions = .{
.headers = options.headers,
};
while (true) {
const stream = try server.accept(io);
group.async(io, handle, .{ io, gpa, stream, &routes, send_options });
}
}
pub fn handle(
io: std.Io,
gpa: std.mem.Allocator,
stream: std.Io.net.Stream,
routes: *const RouteSet,
send_options: Response.SendOptions,
) void {
var read_buffer: [1024 * 8]u8 = undefined;
var write_buffer: [1024 * 8]u8 = undefined;
defer stream.close(io);
var arena: std.heap.ArenaAllocator = .init(gpa);
defer arena.deinit();
var reader = stream.reader(io, &read_buffer);
var writer = stream.writer(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 (routes.getInterface(request.head.target)) |interface| {
const response = interface.handle(gpa, arena.allocator(), io, &request);
response.send(io, arena.allocator(), &request, send_options) catch return;
} else {
request.respond("", .{ .status = .not_found }) catch return;
}
}
|
