94 lines
2.9 KiB
Zig
94 lines
2.9 KiB
Zig
const std = @import("std");
|
|
const builtin = @import("builtin");
|
|
const http = @import("http");
|
|
const db = @import("./db.zig");
|
|
|
|
// this thing is overcomplicated and weird. stop this
|
|
const Router = http.Router(*RequestServer);
|
|
const Route = Router.Route;
|
|
const RouteArgs = http.RouteArgs;
|
|
const router = Router{
|
|
.routes = &[_]Route{
|
|
Route.new(.GET, "/healthcheck", healthcheck),
|
|
Route.new(.GET, "/:id", getNote),
|
|
},
|
|
};
|
|
|
|
const json_options = if (builtin.mode == .Debug)
|
|
.{
|
|
.whitespace = .{
|
|
.indent = .{ .Space = 2 },
|
|
.separator = true,
|
|
},
|
|
} else .{
|
|
.whitespace = .{
|
|
.indent = .None,
|
|
.separator = false,
|
|
},
|
|
};
|
|
|
|
// Responds to a request with a json value
|
|
fn respondJson(ctx: *http.server.Context, status: http.Status, value: anytype, alloc: std.mem.Allocator) !void {
|
|
var headers = http.Headers.init(alloc);
|
|
defer headers.deinit();
|
|
|
|
// Don't need to free this k/v pair because they aren't dynamically allocated
|
|
try headers.put("Content-Type", "application/json");
|
|
|
|
var stream = try ctx.openResponse(&headers, status);
|
|
defer stream.close();
|
|
|
|
const writer = stream.writer();
|
|
try std.json.stringify(value, json_options, writer);
|
|
|
|
try stream.finish();
|
|
}
|
|
|
|
fn getNote(srv: *RequestServer, ctx: *http.server.Context, args: RouteArgs) !void {
|
|
const id = args.get("id") orelse return error.NotFound;
|
|
const note = (try srv.db.getNote(id, srv.alloc)) orelse return error.NotFound;
|
|
defer db.free(srv.alloc, note);
|
|
|
|
try respondJson(ctx, .ok, note, srv.alloc);
|
|
}
|
|
|
|
fn healthcheck(srv: *RequestServer, ctx: *http.server.Context, _: RouteArgs) !void {
|
|
try respondJson(ctx, .ok, .{ .status = "ok" }, srv.alloc);
|
|
}
|
|
|
|
const RequestServer = struct {
|
|
alloc: std.mem.Allocator,
|
|
db: db.Database,
|
|
|
|
fn init(alloc: std.mem.Allocator) !RequestServer {
|
|
return RequestServer{
|
|
.alloc = alloc,
|
|
.db = try db.Database.init(alloc),
|
|
};
|
|
}
|
|
|
|
fn listenAndRun(self: *RequestServer, addr: std.net.Address) noreturn {
|
|
var srv = http.Server.listen(addr) catch unreachable;
|
|
defer srv.shutdown();
|
|
|
|
while (true) {
|
|
var buf: [1 << 20]u8 = undefined;
|
|
var fba = std.heap.FixedBufferAllocator.init(&buf);
|
|
const alloc = fba.allocator();
|
|
|
|
var ctx = srv.accept(alloc) catch unreachable;
|
|
defer ctx.close();
|
|
|
|
router.dispatch(self, &ctx, ctx.request.method, ctx.request.path) catch |err| switch (err) {
|
|
error.NotFound, error.RouteNotApplicable => respondJson(&ctx, .not_found, .{ .@"error" = "Not Found" }, alloc) catch unreachable,
|
|
else => unreachable,
|
|
};
|
|
}
|
|
}
|
|
};
|
|
|
|
pub fn main() anyerror!void {
|
|
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
|
|
var srv = try RequestServer.init(gpa.allocator());
|
|
srv.listenAndRun(std.net.Address.parseIp("0.0.0.0", 8080) catch unreachable);
|
|
}
|