tigerbeetle-node 0.4.2 → 0.5.2

package/src/tigerbeetle/src/{io_darwin.zig → io/darwin.zig}

@@ -1,19 +1,24 @@
 const std = @import("std");
 const os = std.os;
+const mem = std.mem;
 const assert = std.debug.assert;
 
-const FIFO = @import("fifo.zig").FIFO;
-const Time = @import("time.zig").Time;
-const buffer_limit = @import("io.zig").buffer_limit;
+const FIFO = @import("../fifo.zig").FIFO;
+const Time = @import("../time.zig").Time;
+const buffer_limit = @import("../io.zig").buffer_limit;
 
 pub const IO = struct {
     kq: os.fd_t,
     time: Time = .{},
+    io_inflight: usize = 0,
     timeouts: FIFO(Completion) = .{},
     completed: FIFO(Completion) = .{},
     io_pending: FIFO(Completion) = .{},
 
     pub fn init(entries: u12, flags: u32) !IO {
+        _ = entries;
+        _ = flags;
+
         const kq = try os.kqueue();
         assert(kq > -1);
         return IO{ .kq = kq };
@@ -27,9 +32,7 @@ pub const IO = struct {
 
     /// Pass all queued submissions to the kernel and peek for completions.
     pub fn tick(self: *IO) !void {
-        // TODO This is a hack to block 1ms every 10ms tick on macOS while we fix `flush(false)`:
-        // What we're seeing for the tigerbeetle-node client is that recv() syscalls never complete.
-        return self.run_for_ns(std.time.ns_per_ms);
+        return self.flush(false);
     }
 
     /// Pass all queued submissions to the kernel and run for `nanoseconds`.
@@ -42,8 +45,11 @@ pub const IO = struct {
             fn callback(
                 timed_out_ptr: *bool,
                 _completion: *Completion,
-                _result: TimeoutError!void,
+                result: TimeoutError!void,
             ) void {
+                _ = _completion;
+                _ = result catch unreachable;
+
                 timed_out_ptr.* = true;
             }
         }.callback;
@@ -84,10 +90,13 @@ pub const IO = struct {
             // - tick() is non-blocking (wait_for_completions = false)
             // - run_for_ns() always submits a timeout
             if (change_events == 0 and self.completed.peek() == null) {
-                if (!wait_for_completions) return;
-                const timeout_ns = next_timeout orelse @panic("kevent() blocking forever");
-                ts.tv_nsec = @intCast(@TypeOf(ts.tv_nsec), timeout_ns % std.time.ns_per_s);
-                ts.tv_sec = @intCast(@TypeOf(ts.tv_sec), timeout_ns / std.time.ns_per_s);
+                if (wait_for_completions) {
+                    const timeout_ns = next_timeout orelse @panic("kevent() blocking forever");
+                    ts.tv_nsec = @intCast(@TypeOf(ts.tv_nsec), timeout_ns % std.time.ns_per_s);
+                    ts.tv_sec = @intCast(@TypeOf(ts.tv_sec), timeout_ns / std.time.ns_per_s);
+                } else if (self.io_inflight == 0) {
+                    return;
+                }
             }
 
             const new_events = try os.kevent(
@@ -103,8 +112,12 @@ pub const IO = struct {
                 self.io_pending.in = null;
             }
 
+            self.io_inflight += change_events;
+            self.io_inflight -= new_events;
+
             for (events[0..new_events]) |event| {
                 const completion = @intToPtr(*Completion, event.udata);
+                completion.next = null;
                 self.completed.push(completion);
             }
         }
@@ -116,25 +129,25 @@ pub const IO = struct {
         }
     }
 
-    fn flush_io(self: *IO, events: []os.Kevent, io_pending_top: *?*Completion) usize {
+    fn flush_io(_: *IO, events: []os.Kevent, io_pending_top: *?*Completion) usize {
         for (events) |*event, flushed| {
             const completion = io_pending_top.* orelse return flushed;
             io_pending_top.* = completion.next;
 
             const event_info = switch (completion.operation) {
-                .accept => |op| [2]c_int{ op.socket, os.EVFILT_READ },
-                .connect => |op| [2]c_int{ op.socket, os.EVFILT_WRITE },
-                .read => |op| [2]c_int{ op.fd, os.EVFILT_READ },
-                .write => |op| [2]c_int{ op.fd, os.EVFILT_WRITE },
-                .recv => |op| [2]c_int{ op.socket, os.EVFILT_READ },
-                .send => |op| [2]c_int{ op.socket, os.EVFILT_WRITE },
+                .accept => |op| [2]c_int{ op.socket, os.system.EVFILT_READ },
+                .connect => |op| [2]c_int{ op.socket, os.system.EVFILT_WRITE },
+                .read => |op| [2]c_int{ op.fd, os.system.EVFILT_READ },
+                .write => |op| [2]c_int{ op.fd, os.system.EVFILT_WRITE },
+                .recv => |op| [2]c_int{ op.socket, os.system.EVFILT_READ },
+                .send => |op| [2]c_int{ op.socket, os.system.EVFILT_WRITE },
                 else => @panic("invalid completion operation queued for io"),
             };
 
             event.* = .{
                 .ident = @intCast(u32, event_info[0]),
                 .filter = @intCast(i16, event_info[1]),
-                .flags = os.EV_ADD | os.EV_ENABLE | os.EV_ONESHOT,
+                .flags = os.system.EV_ADD | os.system.EV_ENABLE | os.system.EV_ONESHOT,
                 .fflags = 0,
                 .data = 0,
                 .udata = @ptrToInt(completion),
@@ -174,7 +187,7 @@ pub const IO = struct {
     /// This struct holds the data needed for a single IO operation
     pub const Completion = struct {
         next: ?*Completion,
-        context: ?*c_void,
+        context: ?*anyopaque,
         callback: fn (*IO, *Completion) void,
         operation: Operation,
     };
@@ -182,7 +195,6 @@ pub const IO = struct {
     const Operation = union(enum) {
         accept: struct {
             socket: os.socket_t,
-            flags: u32,
         },
         close: struct {
             fd: os.fd_t,
@@ -194,13 +206,6 @@ pub const IO = struct {
         },
         fsync: struct {
             fd: os.fd_t,
-            flags: u32,
-        },
-        openat: struct {
-            fd: os.fd_t,
-            path: [*:0]const u8,
-            flags: u32,
-            mode: os.mode_t,
         },
         read: struct {
             fd: os.fd_t,
@@ -212,13 +217,11 @@ pub const IO = struct {
             socket: os.socket_t,
             buf: [*]u8,
             len: u32,
-            flags: u32,
         },
         send: struct {
             socket: os.socket_t,
             buf: [*]const u8,
             len: u32,
-            flags: u32,
         },
         timeout: struct {
             expires: u64,
@@ -284,7 +287,7 @@ pub const IO = struct {
         }
     }
 
-    pub const AcceptError = os.AcceptError;
+    pub const AcceptError = os.AcceptError || os.SetSockOptError;
 
     pub fn accept(
         self: *IO,
@@ -297,7 +300,6 @@ pub const IO = struct {
         ) void,
         completion: *Completion,
         socket: os.socket_t,
-        flags: u32,
     ) void {
         self.submit(
             context,
@@ -306,11 +308,33 @@ pub const IO = struct {
             .accept,
             .{
                 .socket = socket,
-                .flags = flags,
             },
             struct {
                 fn doOperation(op: anytype) AcceptError!os.socket_t {
-                    return os.accept(op.socket, null, null, op.flags);
+                    const fd = try os.accept(
+                        op.socket,
+                        null,
+                        null,
+                        os.SOCK.NONBLOCK | os.SOCK.CLOEXEC,
+                    );
+                    errdefer os.close(fd);
+
+                    // Darwin doesn't support os.MSG_NOSIGNAL to avoid getting SIGPIPE on socket send().
+                    // Instead, it uses the SO_NOSIGPIPE socket option which does the same for all send()s.
+                    os.setsockopt(
+                        fd,
+                        os.SOL.SOCKET,
+                        os.SO.NOSIGPIPE,
+                        &mem.toBytes(@as(c_int, 1)),
+                    ) catch |err| return switch (err) {
+                        error.TimeoutTooBig => unreachable,
+                        error.PermissionDenied => error.NetworkSubsystemFailed,
+                        error.AlreadyConnected => error.NetworkSubsystemFailed,
+                        error.InvalidProtocolOption => error.ProtocolFailure,
+                        else => |e| e,
+                    };
+
+                    return fd;
                 }
             },
         );
@@ -346,10 +370,10 @@ pub const IO = struct {
             struct {
                 fn doOperation(op: anytype) CloseError!void {
                     return switch (os.errno(os.system.close(op.fd))) {
-                        0 => {},
-                        os.EBADF => error.FileDescriptorInvalid,
-                        os.EINTR => {}, // A success, see https://github.com/ziglang/zig/issues/2425
-                        os.EIO => error.InputOutput,
+                        .SUCCESS => {},
+                        .BADF => error.FileDescriptorInvalid,
+                        .INTR => {}, // A success, see https://github.com/ziglang/zig/issues/2425
+                        .IO => error.InputOutput,
                         else => |errno| os.unexpectedErrno(errno),
                     };
                 }
@@ -398,14 +422,7 @@ pub const IO = struct {
         );
     }
 
-    pub const FsyncError = error{
-        FileDescriptorInvalid,
-        DiskQuota,
-        ArgumentsInvalid,
-        InputOutput,
-        NoSpaceLeft,
-        ReadOnlyFileSystem,
-    } || os.UnexpectedError;
+    pub const FsyncError = os.SyncError;
 
     pub fn fsync(
         self: *IO,
@@ -418,7 +435,6 @@ pub const IO = struct {
         ) void,
         completion: *Completion,
         fd: os.fd_t,
-        flags: u32,
     ) void {
         self.submit(
             context,
@@ -427,66 +443,10 @@ pub const IO = struct {
             .fsync,
             .{
                 .fd = fd,
-                .flags = flags,
             },
             struct {
                 fn doOperation(op: anytype) FsyncError!void {
-                    _ = os.fcntl(op.fd, os.F_FULLFSYNC, 1) catch return os.fsync(op.fd);
-                }
-            },
-        );
-    }
-
-    pub const OpenatError = error{
-        AccessDenied,
-        FileDescriptorInvalid,
-        DeviceBusy,
-        PathAlreadyExists,
-        FileTooBig,
-        ArgumentsInvalid,
-        IsDir,
-        SymLinkLoop,
-        ProcessFdQuotaExceeded,
-        NameTooLong,
-        SystemFdQuotaExceeded,
-        NoDevice,
-        FileNotFound,
-        SystemResources,
-        NoSpaceLeft,
-        NotDir,
-        FileLocksNotSupported,
-        WouldBlock,
-    } || os.UnexpectedError;
-
-    pub fn openat(
-        self: *IO,
-        comptime Context: type,
-        context: Context,
-        comptime callback: fn (
-            context: Context,
-            completion: *Completion,
-            result: OpenatError!os.fd_t,
-        ) void,
-        completion: *Completion,
-        fd: os.fd_t,
-        path: [*:0]const u8,
-        flags: u32,
-        mode: os.mode_t,
-    ) void {
-        self.submit(
-            context,
-            callback,
-            completion,
-            .openat,
-            .{
-                .fd = fd,
-                .path = path,
-                .mode = mode,
-                .flags = flags,
-            },
-            struct {
-                fn doOperation(op: anytype) OpenatError!os.fd_t {
-                    return os.openatZ(op.fd, op.path, op.flags, op.mode);
+                    _ = os.fcntl(op.fd, os.F.FULLFSYNC, 1) catch return os.fsync(op.fd);
                 }
             },
         );
@@ -538,20 +498,20 @@ pub const IO = struct {
                             @bitCast(isize, op.offset),
                         );
                         return switch (os.errno(rc)) {
-                            0 => @intCast(usize, rc),
-                            os.EINTR => continue,
-                            os.EAGAIN => error.WouldBlock,
-                            os.EBADF => error.NotOpenForReading,
-                            os.ECONNRESET => error.ConnectionResetByPeer,
-                            os.EFAULT => unreachable,
-                            os.EINVAL => error.Alignment,
-                            os.EIO => error.InputOutput,
-                            os.EISDIR => error.IsDir,
-                            os.ENOBUFS => error.SystemResources,
-                            os.ENOMEM => error.SystemResources,
-                            os.ENXIO => error.Unseekable,
-                            os.EOVERFLOW => error.Unseekable,
-                            os.ESPIPE => error.Unseekable,
+                            .SUCCESS => @intCast(usize, rc),
+                            .INTR => continue,
+                            .AGAIN => error.WouldBlock,
+                            .BADF => error.NotOpenForReading,
+                            .CONNRESET => error.ConnectionResetByPeer,
+                            .FAULT => unreachable,
+                            .INVAL => error.Alignment,
+                            .IO => error.InputOutput,
+                            .ISDIR => error.IsDir,
+                            .NOBUFS => error.SystemResources,
+                            .NOMEM => error.SystemResources,
+                            .NXIO => error.Unseekable,
+                            .OVERFLOW => error.Unseekable,
+                            .SPIPE => error.Unseekable,
                             else => |err| os.unexpectedErrno(err),
                         };
                     }
@@ -574,7 +534,6 @@ pub const IO = struct {
         completion: *Completion,
         socket: os.socket_t,
         buffer: []u8,
-        flags: u32,
     ) void {
         self.submit(
             context,
@@ -585,11 +544,10 @@ pub const IO = struct {
                 .socket = socket,
                 .buf = buffer.ptr,
                 .len = @intCast(u32, buffer_limit(buffer.len)),
-                .flags = flags,
             },
             struct {
                 fn doOperation(op: anytype) RecvError!usize {
-                    return os.recv(op.socket, op.buf[0..op.len], op.flags);
+                    return os.recv(op.socket, op.buf[0..op.len], 0);
                 }
             },
         );
@@ -609,7 +567,6 @@ pub const IO = struct {
         completion: *Completion,
         socket: os.socket_t,
         buffer: []const u8,
-        flags: u32,
     ) void {
         self.submit(
             context,
@@ -620,11 +577,10 @@ pub const IO = struct {
                 .socket = socket,
                 .buf = buffer.ptr,
                 .len = @intCast(u32, buffer_limit(buffer.len)),
-                .flags = flags,
             },
             struct {
                 fn doOperation(op: anytype) SendError!usize {
-                    return os.send(op.socket, op.buf[0..op.len], op.flags);
+                    return os.send(op.socket, op.buf[0..op.len], 0);
                 }
             },
         );
@@ -694,4 +650,13 @@ pub const IO = struct {
             },
         );
     }
+
+    pub fn openSocket(family: u32, sock_type: u32, protocol: u32) !os.socket_t {
+        const fd = try os.socket(family, sock_type | os.SOCK.NONBLOCK, protocol);
+        errdefer os.close(fd);
+
+        // darwin doesn't support os.MSG_NOSIGNAL, but instead a socket option to avoid SIGPIPE.
+        try os.setsockopt(fd, os.SOL.SOCKET, os.SO.NOSIGPIPE, &mem.toBytes(@as(c_int, 1)));
+        return fd;
+    }
 };