tiny.http.Router

1pub fn Router(comptime Context: type) type {2    return struct {3        allocator: std.mem.Allocator,4        routes: RouteMap,5        not_found_handler: ?Handler,6        context: Context,78        const Self = @This();910        pub const Handler = *const fn (Context, *Request, *Response) anyerror!void;11        pub const WsHandler = *const fn (Context, *WebSocket) anyerror!void;1213        const RouteEntry: type = RouterRouteEntryType(Handler, WsHandler);14        const RouteMap: type = std.HashMap(RouterRouteKey, RouteEntry, RouterRouteKeyContext, 80);1516        const WebSocketSession = struct {17            allocator: std.mem.Allocator,18            websocket: WebSocket,19            context: Context,20            handler: WsHandler,2122            fn drive(self: *WebSocketSession) !void {23                self.handler(self.context, &self.websocket) catch |err| switch (err) {24                    error.WouldBlock => return,25                    else => {26                        self.websocket.close(WebSocketCloseCode.internal_error, "Handler error") catch |close_err| {27                            log.warn("failed to send websocket close after handler error: {s}", .{@errorName(close_err)});28                        };29                        self.websocket.connection.markClosing();30                        return err;31                    },32                };33                if (self.websocket.state == .closed) self.websocket.connection.markClosing();34            }3536            fn destroy(self: *WebSocketSession) void {37                self.websocket.deinit(self.allocator);38                self.allocator.destroy(self);39            }40        };4142        pub fn init(allocator: std.mem.Allocator, context: Context) Self {43            return .{44                .allocator = allocator,45                .routes = RouteMap.init(allocator),46                .not_found_handler = null,47                .context = context,48            };49        }5051        pub fn deinit(self: *Self) void {52            self.routes.deinit();53        }5455        pub fn route(self: *Self, method: Request.Method, path: []const u8, handler: Handler) !void {56            try self.routes.put(.{ .method = method, .path = path }, .{57                .handler = handler,58                .is_websocket = false,59                .ws_handler = null,60                .websocket_limits = null,61            });62        }6364        pub fn get(self: *Self, path: []const u8, handler: Handler) !void {65            try self.route(.GET, path, handler);66        }6768        pub fn head(self: *Self, path: []const u8, handler: Handler) !void {69            try self.route(.HEAD, path, handler);70        }7172        pub fn post(self: *Self, path: []const u8, handler: Handler) !void {73            try self.route(.POST, path, handler);74        }7576        pub fn put(self: *Self, path: []const u8, handler: Handler) !void {77            try self.route(.PUT, path, handler);78        }7980        pub fn delete(self: *Self, path: []const u8, handler: Handler) !void {81            try self.route(.DELETE, path, handler);82        }8384        pub fn websocket(85            self: *Self,86            path: []const u8,87            limits: WebSocket.Limits,88            upgrade_handler: Handler,89            ws_handler: WsHandler,90        ) !void {91            try self.routes.put(.{ .method = .GET, .path = path }, .{92                .handler = upgrade_handler,93                .is_websocket = true,94                .ws_handler = ws_handler,95                .websocket_limits = limits,96            });97        }9899        pub fn notFound(self: *Self, handler: Handler) void {100            self.not_found_handler = handler;101        }102103        pub fn handleRequest(self: *Self, conn: *Connection) !bool {104            switch (conn.currentState()) {105                .http => {},106                .websocket => {107                    conn.driveProtocol() catch |err| {108                        conn.markClosing();109                        return err;110                    };111                    if (conn.currentState() == .websocket) conn.waitForInput();112                    return false;113                },114                .closing, .closed => return false,115            }116117            const parse_result = while (true) {118                if (conn.hasBufferedInput()) {119                    if (Request.parse(120                        conn.requestScratch(),121                        conn.bufferedInput(),122                    )) |result| {123                        break result;124                    } else |err| {125                        if (err != ParseError.IncompleteRequest) {126                            try sendBadRequest(conn);127                            conn.markClosing();128                            return false;129                        }130                    }131                }132                _ = conn.bufferInput() catch |err| switch (err) {133                    error.ConnectionClosed => return false,134                    error.WouldBlock => {135                        conn.waitForRead();136                        return false;137                    },138                    error.InputCapacityExceeded => {139                        try sendBadRequest(conn);140                        conn.markClosing();141                        return false;142                    },143                    else => return err,144                };145            };146            defer conn.consumeBufferedInput(parse_result.consumed);147148            var req = parse_result.request;149150            var res = Response.init(conn.responseScratch());151            defer res.deinit();152153            const key = RouterRouteKey{ .method = req.method, .path = req.pathOnly() };154            if (self.routes.get(key)) |entry| {155                if (entry.is_websocket and req.isWebSocketUpgrade()) {156                    return self.handleWebSocketUpgrade(conn, &req, entry);157                } else {158                    entry.handler(self.context, &req, &res) catch |err| {159                        try sendInternalError(conn, req.method);160                        conn.markClosing();161                        return err;162                    };163                }164            } else if (self.not_found_handler) |handler| {165                handler(self.context, &req, &res) catch |err| {166                    try sendInternalError(conn, req.method);167                    conn.markClosing();168                    return err;169                };170            } else {171                res.status = 404;172                res.status_text = "Not Found";173                res.body = "Not Found";174            }175176            try writeResponse(conn, try res.serializeForMethod(req.method));177178            const connection_header = req.headers.get("Connection") orelse "";179            const keep_alive = connectionWantsKeepAlive(req.version, connection_header);180            if (keep_alive) {181                conn.waitForInput();182            } else {183                conn.markClosing();184            }185            return keep_alive;186        }187188        fn handleWebSocketUpgrade(self: *Self, conn: *Connection, req: *Request, entry: RouteEntry) !bool {189            const handshake = WebSocket.validateClientHandshake(req) catch {190                try sendBadRequest(conn);191                conn.markClosing();192                return false;193            };194195            var res = Response.init(conn.responseScratch());196            defer res.deinit();197198            entry.handler(self.context, req, &res) catch |err| {199                try sendInternalError(conn, req.method);200                conn.markClosing();201                return err;202            };203204            if (res.status != 200 and res.status != 0) {205                try writeResponse(conn, try res.serializeForMethod(req.method));206                conn.markClosing();207                return false;208            }209210            const session = try self.allocator.create(WebSocketSession);211            errdefer self.allocator.destroy(session);212            session.* = .{213                .allocator = self.allocator,214                .websocket = try WebSocket.init(215                    self.allocator,216                    entry.websocket_limits.?,217                    conn,218                ),219                .context = self.context,220                .handler = entry.ws_handler.?,221            };222            errdefer session.websocket.deinit(self.allocator);223224            const accept_key = handshake.accept();225226            var ws_res = try Response.switchingProtocols(conn.responseScratch(), &accept_key);227            defer ws_res.deinit();228            try writeResponse(conn, try ws_res.serialize());229230            session.websocket.activate();231            conn.installProtocol(session, WebSocketSession.drive, WebSocketSession.destroy);232233            return false;234        }235236        fn sendBadRequest(conn: *Connection) !void {237            var res = Response.init(conn.responseScratch());238            defer res.deinit();239            res.status = 400;240            res.status_text = "Bad Request";241            res.body = "Bad Request";242243            try writeResponse(conn, try res.serialize());244        }245246        fn sendInternalError(conn: *Connection, method: Request.Method) !void {247            var res = Response.init(conn.responseScratch());248            defer res.deinit();249            res.status = 500;250            res.status_text = "Internal Server Error";251            res.body = "Internal Server Error";252253            try writeResponse(conn, try res.serializeForMethod(method));254        }255    };256}

1pub const Router = router.Router;