Skip to content

Lightpanda: the headless browser designed for AI and automation

mac/bsd support (kqueue)

Karl Seguin116dab4c85c6
diff --git a/src/server/Server.zig b/src/server/Server.zig
index 38257e4a1..34b781a00 100644
--- a/src/server/Server.zig
+++ b/src/server/Server.zig
@@ -666,7 +666,7 @@ const Worker = struct {
const IOEngine = switch (builtin.os.tag) {
.linux => EPoll,
- // .macos, .ios, .tvos, .watchos, .freebsd, .netbsd, .dragonfly, .openbsd => KQueue,
+ .macos, .ios, .tvos, .watchos, .freebsd, .netbsd, .dragonfly, .openbsd => KQueue,
else => unreachable,
};
@@ -855,6 +855,196 @@ const EPoll = struct {
};
};
+const KQueue = struct {
+ fd: i32,
+ event_list: [128]Kevent,
+
+ const EV = std.c.EV;
+ const NOTE = std.c.NOTE;
+ const EVFILT = std.c.EVFILT;
+ const Kevent = std.c.Kevent;
+
+ // Poll data carries the owner: an http Connection as-is, an WebSocket with
+ // the low bit set (both are word-aligned, so the bit is free).
+ const WS_TAG: usize = 1;
+
+ // The listener carries 0. The two wake channels are EVFILT_USER events,
+ // whose ident only has to be unique amongst user events, so it doubles as
+ // the udata sentinel.
+ const LISTENER: usize = 0;
+ const SHUTDOWN: usize = 1;
+ const SIGNAL: usize = 2;
+
+ fn init() !KQueue {
+ const fd = try sys_net.kqueue();
+ errdefer sys_net.close(fd);
+
+ var self = KQueue{ .fd = fd, .event_list = undefined };
+
+ // Both wake channels are edge-triggered and never drained: every
+ // NOTE_TRIGGER is its own edge, EV_CLEAR resets the event as it is
+ // delivered, and one delivery services everything that arrived.
+ try self.change(&.{
+ userEvent(SHUTDOWN, EV.ADD | EV.CLEAR, 0),
+ userEvent(SIGNAL, EV.ADD | EV.CLEAR, 0),
+ });
+
+ return self;
+ }
+
+ fn deinit(self: *const KQueue) void {
+ sys_net.close(self.fd);
+ }
+
+ fn stop(self: *const KQueue) void {
+ self.change(&.{userEvent(SHUTDOWN, 0, NOTE.TRIGGER)}) catch |err| {
+ log.fatal(.serve, "network close", .{ .err = err, .type = "kqueue" });
+ };
+ }
+
+ fn signal(self: *const KQueue) void {
+ self.change(&.{userEvent(SIGNAL, 0, NOTE.TRIGGER)}) catch |err| {
+ log.err(.serve, "network signal", .{ .err = err, .type = "kqueue" });
+ };
+ }
+
+ fn monitorListener(self: *const KQueue, fd: posix.fd_t) !void {
+ return self.monitor(fd, EVFILT.READ, LISTENER);
+ }
+
+ fn pauseListener(self: *const KQueue, fd: posix.fd_t) !void {
+ return self.change(&.{socketEvent(fd, EVFILT.READ, EV.DELETE, 0)});
+ }
+
+ fn monitorHTTP(self: *const KQueue, conn: *Connection) !void {
+ return self.monitor(conn.socket, EVFILT.READ, @intFromPtr(conn));
+ }
+
+ fn monitorWebSocket(self: *const KQueue, ws: *WebSocket) !void {
+ return self.monitor(ws.socket, EVFILT.READ, @intFromPtr(ws) | WS_TAG);
+ }
+
+ // A socket only ever has one of the two filters registered, so flipping is
+ // a delete plus an add. The callers only ever flip a connection that is
+ // registered for the filter being dropped, so the delete can't fail and
+ // abort the rest of the list.
+ pub fn waitWritable(self: *const KQueue, conn: *Connection) !void {
+ return self.flip(conn, EVFILT.READ, EVFILT.WRITE);
+ }
+
+ pub fn waitReadable(self: *const KQueue, conn: *Connection) !void {
+ return self.flip(conn, EVFILT.WRITE, EVFILT.READ);
+ }
+
+ fn flip(self: *const KQueue, conn: *Connection, from: i16, to: i16) !void {
+ return self.change(&.{
+ socketEvent(conn.socket, from, EV.DELETE, 0),
+ socketEvent(conn.socket, to, EV.ADD | EV.ENABLE, @intFromPtr(conn)),
+ });
+ }
+
+ pub fn remove(self: *const KQueue, socket: posix.socket_t) void {
+ // We don't track which of the two a socket is registered for, and it
+ // might not be registered at all.
+ self.unmonitor(socket, EVFILT.READ);
+ self.unmonitor(socket, EVFILT.WRITE);
+ }
+
+ // No EV_CLEAR, no EV_DISPATCH: socket filters stay level-triggered, the
+ // loop relies on an unread remainder waking us again.
+ fn monitor(self: *const KQueue, socket: posix.socket_t, filter: i16, udata: usize) !void {
+ return self.change(&.{socketEvent(socket, filter, EV.ADD | EV.ENABLE, udata)});
+ }
+
+ fn unmonitor(self: *const KQueue, socket: posix.socket_t, filter: i16) void {
+ self.change(&.{socketEvent(socket, filter, EV.DELETE, 0)}) catch {};
+ }
+
+ // Registrations go through their own kevent call rather than riding along
+ // with the next wait: an empty event list makes kqueue report a bad change
+ // through errno, so the callers above can keep an honest error union.
+ fn change(self: *const KQueue, changes: []const Kevent) !void {
+ var none: [0]Kevent = .{};
+ _ = try sys_net.kevent(self.fd, changes, &none, null);
+ }
+
+ fn userEvent(ident: usize, flags: u16, fflags: u32) Kevent {
+ return .{
+ .ident = ident,
+ .filter = EVFILT.USER,
+ .flags = flags,
+ .fflags = fflags,
+ .data = 0,
+ .udata = ident,
+ };
+ }
+
+ fn socketEvent(socket: posix.socket_t, filter: i16, flags: u16, udata: usize) Kevent {
+ return .{
+ .ident = @intCast(socket),
+ .filter = filter,
+ .flags = flags,
+ .fflags = 0,
+ .data = 0,
+ .udata = udata,
+ };
+ }
+
+ // null blocks until an event arrives
+ fn wait(self: *KQueue, timeout_ms: ?u64) Iterator {
+ const event_list = &self.event_list;
+
+ var ts: std.c.timespec = undefined;
+ const timeout: ?*const std.c.timespec = if (timeout_ms) |ms| blk: {
+ ts = .{ .sec = @intCast(ms / 1000), .nsec = @intCast((ms % 1000) * std.time.ns_per_ms) };
+ break :blk &ts;
+ } else null;
+
+ // With no changes to apply, only programmer errors are possible.
+ const event_count = sys_net.kevent(self.fd, &.{}, event_list, timeout) catch unreachable;
+ return .{
+ .index = 0,
+ .events = event_list[0..event_count],
+ };
+ }
+
+ const Iterator = struct {
+ index: usize,
+ events: []Kevent,
+
+ fn next(self: *Iterator) ?IOEvent {
+ const index = self.index;
+ const events = self.events;
+ if (index == events.len) {
+ return null;
+ }
+ self.index = index + 1;
+
+ const event = &events[index];
+ switch (event.udata) {
+ LISTENER => return .{ .accept = {} },
+ SHUTDOWN => return .{ .shutdown = {} },
+ SIGNAL => return .{ .signal = {} },
+ else => |nptr| {
+ return .{
+ .read_write = .{
+ .target = if (nptr & WS_TAG == 0)
+ .{ .http = @ptrFromInt(nptr) }
+ else
+ .{ .ws = @ptrFromInt(nptr & ~WS_TAG) },
+ .readable = event.filter == EVFILT.READ,
+ .writable = event.filter == EVFILT.WRITE,
+ // EV_EOF on a read filter can still come with buffered
+ // bytes; readers deal with the two together.
+ .hangup = event.flags & (EV.EOF | EV.ERROR) != 0,
+ },
+ };
+ },
+ }
+ }
+ };
+};
+
const testing = @import("../testing.zig");
test "server: buildJSONVersionResponse" {
const res = try http.buildJSONVersionResponse(testing.test_app, testing.test_app.config.port());
diff --git a/src/sys/net.zig b/src/sys/net.zig
index e5881491a..08ad2ef93 100644
--- a/src/sys/net.zig
+++ b/src/sys/net.zig
@@ -284,6 +284,34 @@ pub fn epoll_wait(epfd: i32, events: []c.epoll_event, timeout: i32) usize {
}
}
+pub fn kqueue() !i32 {
+ const rc = c.kqueue();
+ return switch (c.errno(rc)) {
+ .SUCCESS => @intCast(rc),
+ .MFILE => error.ProcessFdQuotaExceeded,
+ .NFILE => error.SystemFdQuotaExceeded,
+ else => error.Unexpected,
+ };
+}
+
+pub fn kevent(kq: i32, changes: []const c.Kevent, events: []c.Kevent, timeout: ?*const c.timespec) !usize {
+ while (true) {
+ const rc = c.kevent(kq, changes.ptr, @intCast(changes.len), events.ptr, @intCast(events.len), timeout);
+ switch (c.errno(rc)) {
+ .SUCCESS => return @intCast(rc),
+ .INTR => continue,
+ .BADF => unreachable, // always a race condition if this happens
+ .FAULT => unreachable,
+ .INVAL => unreachable,
+ .ACCES => return error.AccessDenied,
+ .NOENT => return error.EventNotFound,
+ .NOMEM => return error.SystemResources,
+ .SRCH => return error.ProcessNotFound,
+ else => return error.Unexpected,
+ }
+ }
+}
+
fn errnoError(e: posix.E) anyerror {
return switch (e) {
.AGAIN => error.WouldBlock,