diff --git a/build.zig b/build.zig index 1a2193a..c7efd86 100644 --- a/build.zig +++ b/build.zig @@ -34,6 +34,7 @@ pub fn build(b: *std.build.Builder) !void { .{ .name = "hello", .src = "examples/hello/hello.zig" }, .{ .name = "https", .src = "examples/https/https.zig" }, .{ .name = "hello2", .src = "examples/hello2/hello2.zig" }, + .{ .name = "hello3", .src = "examples/hello3/hello3.zig" }, .{ .name = "routes", .src = "examples/routes/routes.zig" }, .{ .name = "serve", .src = "examples/serve/serve.zig" }, .{ .name = "hello_json", .src = "examples/hello_json/hello_json.zig" }, diff --git a/examples/hello3/hello3.zig b/examples/hello3/hello3.zig new file mode 100644 index 0000000..5c7675d --- /dev/null +++ b/examples/hello3/hello3.zig @@ -0,0 +1,108 @@ +const std = @import("std"); +const zap = @import("zap"); +const Allocator = std.mem.Allocator; + +fn on_request_verbose(r: zap.Request) void { + if (r.path) |the_path| { + std.debug.print("PATH: {s}\n", .{the_path}); + } + + if (r.query) |the_query| { + std.debug.print("QUERY: {s}\n", .{the_query}); + } + r.sendBody("

Hello from ZAP!!!

") catch return; +} + +pub const SomePackage = struct { + const Self = @This(); + + allocator: Allocator, + a: i8, + b: i8, + + pub fn init(allocator: Allocator, a: i8, b: i8) Self { + return .{ + .allocator = allocator, + .a = a, + .b = b, + }; + } + + pub fn getA(self: *Self, req: zap.Request) void { + std.log.warn("get_a_requested", .{}); + + const string = std.fmt.allocPrint( + self.allocator, + "A value is {d}\n", + .{self.a}, + ) catch return; + defer self.allocator.free(string); + + req.sendBody(string) catch return; + } + + pub fn getB(self: *Self, req: zap.Request) void { + std.log.warn("get_b_requested", .{}); + + const string = std.fmt.allocPrint( + self.allocator, + "B value is {d}\n", + .{self.b}, + ) catch return; + defer self.allocator.free(string); + + req.sendBody(string) catch return; + } + + pub fn incrementA(self: *Self, req: zap.Request) void { + std.log.warn("increment_a_requested", .{}); + + self.a += 1; + + req.sendBody("incremented A") catch return; + } +}; + +fn not_found(req: zap.Request) void { + std.debug.print("not found handler", .{}); + + req.sendBody("Not found") catch return; +} + +pub fn main() !void { + var gpa = std.heap.GeneralPurposeAllocator(.{ + .thread_safe = true, + }){}; + var allocator = gpa.allocator(); + + var simpleRouter = zap.Router.init(allocator, .{ + .not_found = not_found, + }); + defer simpleRouter.deinit(); + + var somePackage = SomePackage.init(allocator, 1, 2); + + try simpleRouter.handle_func("/", on_request_verbose); + + try simpleRouter.handle_func("/geta", zap.RequestHandler(&somePackage, SomePackage.getA)); + + try simpleRouter.handle_func("/getb", zap.RequestHandler(&somePackage, SomePackage.getB)); + + try simpleRouter.handle_func("/inca", zap.RequestHandler(&somePackage, SomePackage.incrementA)); + + var listener = zap.HttpListener.init(.{ + .port = 3000, + .on_request = zap.RequestHandler(&simpleRouter, &zap.Router.serve), + .log = true, + .max_clients = 100000, + }); + try listener.listen(); + + std.debug.print("Listening on 0.0.0.0:3000\n", .{}); + + // start worker threads + zap.start(.{ + .threads = 2, + .workers = 2, + }); +} diff --git a/src/router.zig b/src/router.zig new file mode 100644 index 0000000..387e4da --- /dev/null +++ b/src/router.zig @@ -0,0 +1,77 @@ +const std = @import("std"); +const zap = @import("zap.zig"); + +const Allocator = std.mem.Allocator; +const RouterError = error{ + AlreadyExists, + EmptyPath, +}; + +// inline closure for RequestFn with self argument +pub inline fn RequestHandler(self: anytype, func: *const fn (@TypeOf(self), zap.Request) void) *const fn (zap.Request) void { + return (opaque { + var hidden_self: @TypeOf(self) = undefined; + var hidden_func: *const fn (@TypeOf(self), zap.Request) void = undefined; + pub fn init(h_self: @TypeOf(self), h_func: *const fn (@TypeOf(self), zap.Request) void) *const @TypeOf(run) { + hidden_self = h_self; + hidden_func = h_func; + return &run; + } + + fn run(req: zap.Request) void { + hidden_func(hidden_self, req); + } + }).init(self, func); +} + +pub const RouterOptions = struct { + not_found: ?zap.HttpRequestFn = null, +}; + +pub const Router = struct { + const Self = @This(); + + routes: std.StringHashMap(zap.HttpRequestFn), + not_found: ?zap.HttpRequestFn, + + pub fn init(allocator: Allocator, options: RouterOptions) Self { + return .{ + .routes = std.StringHashMap(zap.HttpRequestFn).init(allocator), + + .not_found = options.not_found, + }; + } + + pub fn deinit(self: *Self) void { + self.routes.deinit(); + } + + pub fn handle_func(self: *Self, path: []const u8, h: zap.HttpRequestFn) !void { + if (path.len == 0) { + return RouterError.EmptyPath; + } + + const route = self.routes.get(path); + + if (route != null) { + return RouterError.AlreadyExists; + } + + try self.routes.put(path, h); + } + + pub fn serve(self: *Self, r: zap.Request) void { + var route = self.routes.get(r.path.?); + + if (route) |handler| { + handler(r); + } else if (self.not_found) |handler| { + // not found handler + handler(r); + } else { + // default 404 output + r.setStatus(.not_found); + r.sendBody("404 Not Found") catch return; + } + } +}; diff --git a/src/zap.zig b/src/zap.zig index 35f7bf2..5d9a91f 100644 --- a/src/zap.zig +++ b/src/zap.zig @@ -52,6 +52,8 @@ pub const Tls = @import("tls.zig"); /// ``` pub const Endpoint = @import("endpoint.zig"); +pub usingnamespace @import("router.zig"); + pub usingnamespace @import("util.zig"); pub usingnamespace @import("http.zig");