tigerbeetle-node 0.5.0 → 0.6.0

package/src/tigerbeetle/src/main.zig

@@ -20,12 +20,24 @@ const vsr = @import("vsr.zig");
 const Replica = vsr.Replica(StateMachine, MessageBus, Storage, Time);
 
 pub fn main() !void {
-    var arena_allocator = std.heap.ArenaAllocator.init(std.heap.page_allocator);
-    const arena = &arena_allocator.allocator;
+    var io = try IO.init(128, 0);
+    defer io.deinit();
+
+    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
+    defer arena.deinit();
+
+    const allocator = arena.allocator();
 
-    switch (cli.parse_args(arena)) {
-        .init => |args| try init(arena, args.cluster, args.replica, args.dir_fd),
-        .start => |args| try start(arena, args.cluster, args.replica, args.addresses, args.dir_fd),
+    switch (try cli.parse_args(allocator)) {
+        .init => |args| try init(&io, args.cluster, args.replica, args.dir_fd),
+        .start => |args| try start(
+            &io,
+            allocator,
+            args.cluster,
+            args.replica,
+            args.addresses,
+            args.dir_fd,
+        ),
     }
 }
 
@@ -34,14 +46,14 @@ const filename_fmt = "cluster_{d:0>10}_replica_{d:0>3}.tigerbeetle";
 const filename_len = fmt.count(filename_fmt, .{ 0, 0 });
 
 /// Create a .tigerbeetle data file for the given args and exit
-fn init(arena: *mem.Allocator, cluster: u32, replica: u8, dir_fd: os.fd_t) !void {
+fn init(io: *IO, cluster: u32, replica: u8, dir_fd: os.fd_t) !void {
     // Add 1 for the terminating null byte
     var buffer: [filename_len + 1]u8 = undefined;
     const filename = fmt.bufPrintZ(&buffer, filename_fmt, .{ cluster, replica }) catch unreachable;
     assert(filename.len == filename_len);
 
     // TODO Expose data file size on the CLI.
-    _ = try Storage.open(
+    _ = try io.open_file(
         dir_fd,
         filename,
         config.journal_size_max, // TODO Double-check that we have space for redundant headers.
@@ -53,7 +65,8 @@ fn init(arena: *mem.Allocator, cluster: u32, replica: u8, dir_fd: os.fd_t) !void
 
 /// Run as a replica server defined by the given args
 fn start(
-    arena: *mem.Allocator,
+    io: *IO,
+    allocator: mem.Allocator,
     cluster: u32,
     replica_index: u8,
     addresses: []std.net.Address,
@@ -67,30 +80,30 @@ fn start(
     assert(filename.len == filename_len);
 
     // TODO Expose data file size on the CLI.
-    const storage_fd = try Storage.open(
+    const storage_fd = try io.open_file(
         dir_fd,
         filename,
         config.journal_size_max, // TODO Double-check that we have space for redundant headers.
         false,
     );
-    var io = try IO.init(128, 0);
+
     var state_machine = try StateMachine.init(
-        arena,
+        allocator,
         config.accounts_max,
         config.transfers_max,
         config.commits_max,
     );
-    var storage = try Storage.init(config.journal_size_max, storage_fd, &io);
+    var storage = try Storage.init(config.journal_size_max, storage_fd, io);
     var message_bus = try MessageBus.init(
-        arena,
+        allocator,
         cluster,
         addresses,
         replica_index,
-        &io,
+        io,
     );
     var time: Time = .{};
     var replica = try Replica.init(
-        arena,
+        allocator,
         cluster,
         @intCast(u8, addresses.len),
         replica_index,

package/src/tigerbeetle/src/message_bus.zig

@@ -1,10 +1,10 @@
 const std = @import("std");
+const builtin = @import("builtin");
 const assert = std.debug.assert;
 const mem = std.mem;
 const os = std.os;
 
-const is_darwin = std.Target.current.isDarwin();
-const sock_flags = os.SOCK_CLOEXEC | (if (is_darwin) os.SOCK_NONBLOCK else 0);
+const is_linux = builtin.target.os.tag == .linux;
 
 const config = @import("config.zig");
 const log = std.log.scoped(.message_bus);
@@ -17,14 +17,21 @@ const IO = @import("io.zig").IO;
 const MessagePool = @import("message_pool.zig").MessagePool;
 const Message = MessagePool.Message;
 
-const SendQueue = RingBuffer(*Message, config.connection_send_queue_max);
-
 pub const MessageBusReplica = MessageBusImpl(.replica);
 pub const MessageBusClient = MessageBusImpl(.client);
 
-const ProcessType = enum { replica, client };
+fn MessageBusImpl(comptime process_type: vsr.ProcessType) type {
+    const SendQueue = RingBuffer(*Message, switch (process_type) {
+        .replica => config.connection_send_queue_max_replica,
+        // A client has at most 1 in-flight request, plus pings.
+        .client => config.connection_send_queue_max_client,
+    });
+
+    const tcp_sndbuf = switch (process_type) {
+        .replica => config.tcp_sndbuf_replica,
+        .client => config.tcp_sndbuf_client,
+    };
 
-fn MessageBusImpl(comptime process_type: ProcessType) type {
     return struct {
         const Self = @This();
 
@@ -54,8 +61,8 @@ fn MessageBusImpl(comptime process_type: ProcessType) type {
 
         /// The callback to be called when a message is received. Use set_on_message() to set
         /// with type safety for the context pointer.
-        on_message_callback: ?fn (context: ?*c_void, message: *Message) void = null,
-        on_message_context: ?*c_void = null,
+        on_message_callback: ?fn (context: ?*anyopaque, message: *Message) void = null,
+        on_message_context: ?*anyopaque = null,
 
         /// This slice is allocated with a fixed size in the init function and never reallocated.
         connections: []Connection,
@@ -75,7 +82,7 @@ fn MessageBusImpl(comptime process_type: ProcessType) type {
 
         /// Initialize the MessageBus for the given cluster, configuration and replica/client process.
         pub fn init(
-            allocator: *mem.Allocator,
+            allocator: mem.Allocator,
             cluster: u32,
             configuration: []std.net.Address,
             process: switch (process_type) {
@@ -105,14 +112,14 @@ fn MessageBusImpl(comptime process_type: ProcessType) type {
             };
 
             var bus: Self = .{
-                .pool = try MessagePool.init(allocator),
+                .pool = try MessagePool.init(allocator, process_type),
                 .io = io,
                 .cluster = cluster,
                 .configuration = configuration,
                 .process = switch (process_type) {
                     .replica => .{
                         .replica = process,
-                        .accept_fd = try init_tcp(configuration[process]),
+                        .accept_fd = try init_tcp(io, configuration[process]),
                     },
                     .client => {},
                 },
@@ -124,7 +131,7 @@ fn MessageBusImpl(comptime process_type: ProcessType) type {
 
             // Pre-allocate enough memory to hold all possible connections in the client map.
             if (process_type == .replica) {
-                try bus.process.clients.ensureCapacity(allocator, config.connections_max);
+                try bus.process.clients.ensureTotalCapacity(allocator, config.connections_max);
             }
 
             return bus;
@@ -140,7 +147,7 @@ fn MessageBusImpl(comptime process_type: ProcessType) type {
             assert(bus.on_message_context == null);
 
             bus.on_message_callback = struct {
-                fn wrapper(_context: ?*c_void, message: *Message) void {
+                fn wrapper(_context: ?*anyopaque, message: *Message) void {
                     on_message(@intToPtr(Context, @ptrToInt(_context)), message);
                 }
             }.wrapper;
@@ -148,15 +155,15 @@ fn MessageBusImpl(comptime process_type: ProcessType) type {
         }
 
         /// TODO This is required by the Client.
-        pub fn deinit(bus: *Self) void {}
+        pub fn deinit(_: *Self) void {}
 
-        fn init_tcp(address: std.net.Address) !os.socket_t {
-            const fd = try os.socket(
+        fn init_tcp(io: *IO, address: std.net.Address) !os.socket_t {
+            const fd = try io.open_socket(
                 address.any.family,
-                os.SOCK_STREAM | sock_flags,
-                os.IPPROTO_TCP,
+                os.SOCK.STREAM,
+                os.IPPROTO.TCP,
             );
-            errdefer os.close(fd);
+            errdefer os.closeSocket(fd);
 
             const set = struct {
                 fn set(_fd: os.socket_t, level: u32, option: u32, value: c_int) !void {
@@ -164,71 +171,55 @@ fn MessageBusImpl(comptime process_type: ProcessType) type {
                 }
             }.set;
 
-            // darwin doesn't support os.MSG_NOSIGNAL, but instead a socket option to avoid SIGPIPE.
-            if (is_darwin) {
-                try set(fd, os.SOL_SOCKET, os.SO_NOSIGPIPE, 1);
-            }
-
-            // Set tcp recv buffer size
             if (config.tcp_rcvbuf > 0) rcvbuf: {
-                if (!is_darwin) {
+                if (is_linux) {
                     // Requires CAP_NET_ADMIN privilege (settle for SO_RCVBUF in case of an EPERM):
-                    if (set(fd, os.SOL_SOCKET, os.SO_RCVBUFFORCE, config.tcp_rcvbuf)) |_| {
+                    if (set(fd, os.SOL.SOCKET, os.SO.RCVBUFFORCE, config.tcp_rcvbuf)) |_| {
                         break :rcvbuf;
                     } else |err| switch (err) {
                         error.PermissionDenied => {},
                         else => |e| return e,
                     }
                 }
-                try set(fd, os.SOL_SOCKET, os.SO_RCVBUF, config.tcp_rcvbuf);
+                try set(fd, os.SOL.SOCKET, os.SO.RCVBUF, config.tcp_rcvbuf);
             }
 
-            // Set tcp send buffer size
-            if (config.tcp_sndbuf > 0) sndbuf: {
-                if (!is_darwin) {
+            if (tcp_sndbuf > 0) sndbuf: {
+                if (is_linux) {
                     // Requires CAP_NET_ADMIN privilege (settle for SO_SNDBUF in case of an EPERM):
-                    if (set(fd, os.SOL_SOCKET, os.SO_SNDBUFFORCE, config.tcp_sndbuf)) |_| {
+                    if (set(fd, os.SOL.SOCKET, os.SO.SNDBUFFORCE, tcp_sndbuf)) |_| {
                         break :sndbuf;
                     } else |err| switch (err) {
                         error.PermissionDenied => {},
                         else => |e| return e,
                     }
                 }
-                try set(fd, os.SOL_SOCKET, os.SO_SNDBUF, config.tcp_sndbuf);
+                try set(fd, os.SOL.SOCKET, os.SO.SNDBUF, tcp_sndbuf);
             }
 
-            // Set tcp keep alive
             if (config.tcp_keepalive) {
-                try set(fd, os.SOL_SOCKET, os.SO_KEEPALIVE, 1);
-                if (!is_darwin) {
-                    try set(fd, os.IPPROTO_TCP, os.TCP_KEEPIDLE, config.tcp_keepidle);
-                    try set(fd, os.IPPROTO_TCP, os.TCP_KEEPINTVL, config.tcp_keepintvl);
-                    try set(fd, os.IPPROTO_TCP, os.TCP_KEEPCNT, config.tcp_keepcnt);
+                try set(fd, os.SOL.SOCKET, os.SO.KEEPALIVE, 1);
+                if (is_linux) {
+                    try set(fd, os.IPPROTO.TCP, os.TCP.KEEPIDLE, config.tcp_keepidle);
+                    try set(fd, os.IPPROTO.TCP, os.TCP.KEEPINTVL, config.tcp_keepintvl);
+                    try set(fd, os.IPPROTO.TCP, os.TCP.KEEPCNT, config.tcp_keepcnt);
                 }
             }
 
-            // Set tcp user timeout
             if (config.tcp_user_timeout > 0) {
-                if (!is_darwin) {
-                    try set(fd, os.IPPROTO_TCP, os.TCP_USER_TIMEOUT, config.tcp_user_timeout);
+                if (is_linux) {
+                    try set(fd, os.IPPROTO.TCP, os.TCP.USER_TIMEOUT, config.tcp_user_timeout);
                 }
             }
 
             // Set tcp no-delay
             if (config.tcp_nodelay) {
-                const TCP_NODELAY: ?u32 = if (@hasDecl(os, "TCP_NODELAY"))
-                    @as(u32, os.TCP_NODELAY)
-                else if (is_darwin)
-                    @as(u32, 1)
-                else
-                    null;
-
-                if (TCP_NODELAY) |tcp_nodelay| {
-                    try set(fd, os.IPPROTO_TCP, tcp_nodelay, 1);
+                if (is_linux) {
+                    try set(fd, os.IPPROTO.TCP, os.TCP.NODELAY, 1);
                 }
             }
 
-            try set(fd, os.SOL_SOCKET, os.SO_REUSEADDR, 1);
+            try set(fd, os.SOL.SOCKET, os.SO.REUSEADDR, 1);
             try os.bind(fd, &address.any, address.getOsSockLen());
             try os.listen(fd, config.tcp_backlog);
 
@@ -289,7 +280,7 @@ fn MessageBusImpl(comptime process_type: ProcessType) type {
                 if (connection.state == .terminating) return;
             }
 
-            log.notice("all connections in use but not all replicas are connected, " ++
+            log.info("all connections in use but not all replicas are connected, " ++
                 "attempting to disconnect a client", .{});
             for (bus.connections) |*connection| {
                 if (connection.peer == .client) {
@@ -298,7 +289,7 @@ fn MessageBusImpl(comptime process_type: ProcessType) type {
                 }
             }
 
-            log.notice("failed to disconnect a client as no peer was a known client, " ++
+            log.info("failed to disconnect a client as no peer was a known client, " ++
                 "attempting to disconnect an unknown peer.", .{});
             for (bus.connections) |*connection| {
                 if (connection.peer == .unknown) {
@@ -332,7 +323,6 @@ fn MessageBusImpl(comptime process_type: ProcessType) type {
                 on_accept,
                 &bus.process.accept_completion,
                 bus.process.accept_fd,
-                sock_flags,
             );
         }
 
@@ -341,6 +331,8 @@ fn MessageBusImpl(comptime process_type: ProcessType) type {
             completion: *IO.Completion,
             result: IO.AcceptError!os.socket_t,
         ) void {
+            _ = completion;
+
             comptime assert(process_type == .replica);
             assert(bus.process.accept_connection != null);
             defer bus.process.accept_connection = null;
@@ -353,7 +345,7 @@ fn MessageBusImpl(comptime process_type: ProcessType) type {
             bus.process.accept_connection.?.on_accept(bus, fd);
         }
 
-        pub fn get_message(bus: *Self) ?*Message {
+        pub fn get_message(bus: *Self) *Message {
             return bus.pool.get_message();
         }
 
@@ -414,11 +406,11 @@ fn MessageBusImpl(comptime process_type: ProcessType) type {
                 terminating,
             } = .free,
             /// This is guaranteed to be valid only while state is connected.
-            /// It will be reset to -1 during the shutdown process and is always -1 if the
-            /// connection is unused (i.e. peer == .none). We use -1 instead of undefined here
+            /// It will be reset to IO.INVALID_SOCKET during the shutdown process and is always IO.INVALID_SOCKET if the
+            /// connection is unused (i.e. peer == .none). We use IO.INVALID_SOCKET instead of undefined here
             /// for safety to ensure an error if the invalid value is ever used, instead of
             /// potentially performing an action on an active fd.
-            fd: os.socket_t = -1,
+            fd: os.socket_t = IO.INVALID_SOCKET,
 
             /// This completion is used for all recv operations.
             /// It is also used for the initial connect when establishing a replica connection.
@@ -454,12 +446,12 @@ fn MessageBusImpl(comptime process_type: ProcessType) type {
 
                 assert(connection.peer == .none);
                 assert(connection.state == .free);
-                assert(connection.fd == -1);
+                assert(connection.fd == IO.INVALID_SOCKET);
 
                 // The first replica's network address family determines the
                 // family for all other replicas:
                 const family = bus.configuration[0].any.family;
-                connection.fd = os.socket(family, os.SOCK_STREAM | sock_flags, 0) catch return;
+                connection.fd = bus.io.open_socket(family, os.SOCK.STREAM, os.IPPROTO.TCP) catch return;
                 connection.peer = .{ .replica = replica };
                 connection.state = .connecting;
                 bus.connections_used += 1;
@@ -469,7 +461,7 @@ fn MessageBusImpl(comptime process_type: ProcessType) type {
 
                 var attempts = &bus.replicas_connect_attempts[replica];
                 const ms = vsr.exponential_backoff_with_jitter(
-                    &bus.prng,
+                    bus.prng.random(),
                     config.connection_delay_min_ms,
                     config.connection_delay_max_ms,
                     attempts.*,
@@ -560,7 +552,7 @@ fn MessageBusImpl(comptime process_type: ProcessType) type {
             pub fn on_accept(connection: *Connection, bus: *Self, fd: os.socket_t) void {
                 assert(connection.peer == .none);
                 assert(connection.state == .accepting);
-                assert(connection.fd == -1);
+                assert(connection.fd == IO.INVALID_SOCKET);
 
                 connection.peer = .unknown;
                 connection.state = .connected;
@@ -577,7 +569,7 @@ fn MessageBusImpl(comptime process_type: ProcessType) type {
 
                 assert(connection.peer == .unknown or connection.peer == .replica);
                 assert(connection.state == .connected);
-                assert(connection.fd != -1);
+                assert(connection.fd != IO.INVALID_SOCKET);
 
                 assert(connection.recv_submitted == false);
                 assert(connection.recv_message == null);
@@ -597,15 +589,14 @@ fn MessageBusImpl(comptime process_type: ProcessType) type {
                     .terminating => return,
                     .free, .accepting => unreachable,
                 }
-                connection.send_queue.push(message.ref()) catch |err| switch (err) {
-                    error.NoSpaceLeft => {
-                        bus.unref(message);
-                        log.notice("message queue for peer {} full, dropping message", .{
-                            connection.peer,
-                        });
-                        return;
-                    },
-                };
+                if (connection.send_queue.full()) {
+                    log.info("message queue for peer {} full, dropping {s} message", .{
+                        connection.peer,
+                        @tagName(message.header.command),
+                    });
+                    return;
+                }
+                connection.send_queue.push_assume_capacity(message.ref());
                 // If the connection has not yet been established we can't send yet.
                 // Instead on_connect() will call send().
                 if (connection.state == .connecting) {
@@ -625,7 +616,7 @@ fn MessageBusImpl(comptime process_type: ProcessType) type {
             pub fn terminate(connection: *Connection, bus: *Self, how: enum { shutdown, close }) void {
                 assert(connection.peer != .none);
                 assert(connection.state != .free);
-                assert(connection.fd != -1);
+                assert(connection.fd != IO.INVALID_SOCKET);
                 switch (how) {
                     .shutdown => {
                         // The shutdown syscall will cause currently in progress send/recv
@@ -633,12 +624,8 @@ fn MessageBusImpl(comptime process_type: ProcessType) type {
                         //
                         // TODO: Investigate differences between shutdown() on Linux vs Darwin.
                         // Especially how this interacts with our assumptions around pending I/O.
-                        const rc = os.system.shutdown(connection.fd, os.SHUT_RDWR);
-                        switch (os.errno(rc)) {
-                            0 => {},
-                            os.EBADF => unreachable,
-                            os.EINVAL => unreachable,
-                            os.ENOTCONN => {
+                        os.shutdown(connection.fd, .both) catch |err| switch (err) {
+                            error.SocketNotConnected => {
                                 // This should only happen if we for some reason decide to terminate
                                 // a connection while a connect operation is in progress.
                                 // This is fine though, we simply continue with the logic below and
@@ -653,9 +640,9 @@ fn MessageBusImpl(comptime process_type: ProcessType) type {
                                 //assert(connection.recv_submitted);
                                 //assert(!connection.send_submitted);
                             },
-                            os.ENOTSOCK => unreachable,
-                            else => |err| os.unexpectedErrno(err) catch {},
-                        }
+                            // Ignore all the remaining errors for now
+                            error.ConnectionAborted, error.ConnectionResetByPeer, error.BlockingOperationInProgress, error.NetworkSubsystemFailed, error.SystemResources, error.Unexpected => {},
+                        };
                     },
                     .close => {},
                 }
@@ -667,7 +654,7 @@ fn MessageBusImpl(comptime process_type: ProcessType) type {
             fn parse_messages(connection: *Connection, bus: *Self) void {
                 assert(connection.peer != .none);
                 assert(connection.state == .connected);
-                assert(connection.fd != -1);
+                assert(connection.fd != IO.INVALID_SOCKET);
 
                 while (connection.parse_message(bus)) |message| {
                     defer bus.unref(message);
@@ -749,14 +736,7 @@ fn MessageBusImpl(comptime process_type: ProcessType) type {
                 // `references` and `header` metadata.
                 if (connection.recv_progress == header.size) return connection.recv_message.?.ref();
 
-                const message = bus.get_message() orelse {
-                    // TODO Decrease the probability of this happening by:
-                    // 1. using a header-only message if possible.
-                    // 2. determining a true upper limit for static allocation.
-                    log.err("no free buffer available to deliver message from {}", .{connection.peer});
-                    connection.terminate(bus, .shutdown);
-                    return null;
-                };
+                const message = bus.get_message();
                 mem.copy(u8, message.buffer, data[0..header.size]);
                 return message;
             }
@@ -794,7 +774,7 @@ fn MessageBusImpl(comptime process_type: ProcessType) type {
 
                 assert(connection.peer != .none);
                 assert(connection.state == .connected);
-                assert(connection.fd != -1);
+                assert(connection.fd != IO.INVALID_SOCKET);
 
                 if (connection.peer != .unknown) return;
 
@@ -841,14 +821,7 @@ fn MessageBusImpl(comptime process_type: ProcessType) type {
                     return;
                 }
 
-                const new_message = bus.get_message() orelse {
-                    // TODO Decrease the probability of this happening by:
-                    // 1. using a header-only message if possible.
-                    // 2. determining a true upper limit for static allocation.
-                    log.err("no free buffer available to recv message from {}", .{connection.peer});
-                    connection.terminate(bus, .shutdown);
-                    return;
-                };
+                const new_message = bus.get_message();
                 defer bus.unref(new_message);
 
                 if (connection.recv_message) |recv_message| {
@@ -872,7 +845,7 @@ fn MessageBusImpl(comptime process_type: ProcessType) type {
             fn recv(connection: *Connection, bus: *Self) void {
                 assert(connection.peer != .none);
                 assert(connection.state == .connected);
-                assert(connection.fd != -1);
+                assert(connection.fd != IO.INVALID_SOCKET);
 
                 assert(!connection.recv_submitted);
                 connection.recv_submitted = true;
@@ -886,7 +859,6 @@ fn MessageBusImpl(comptime process_type: ProcessType) type {
                     &connection.recv_completion,
                     connection.fd,
                     connection.recv_message.?.buffer[connection.recv_progress..config.message_size_max],
-                    if (is_darwin) 0 else os.MSG_NOSIGNAL,
                 );
             }
 
@@ -918,7 +890,7 @@ fn MessageBusImpl(comptime process_type: ProcessType) type {
             fn send(connection: *Connection, bus: *Self) void {
                 assert(connection.peer == .client or connection.peer == .replica);
                 assert(connection.state == .connected);
-                assert(connection.fd != -1);
+                assert(connection.fd != IO.INVALID_SOCKET);
                 const message = connection.send_queue.head() orelse return;
                 assert(!connection.send_submitted);
                 connection.send_submitted = true;
@@ -929,7 +901,6 @@ fn MessageBusImpl(comptime process_type: ProcessType) type {
                     &connection.send_completion,
                     connection.fd,
                     message.buffer[connection.send_progress..message.header.size],
-                    if (is_darwin) 0 else os.MSG_NOSIGNAL,
                 );
             }
 
@@ -976,8 +947,8 @@ fn MessageBusImpl(comptime process_type: ProcessType) type {
                     bus.unref(message);
                     connection.recv_message = null;
                 }
-                assert(connection.fd != -1);
-                defer connection.fd = -1;
+                assert(connection.fd != IO.INVALID_SOCKET);
+                defer connection.fd = IO.INVALID_SOCKET;
                 // It's OK to use the send completion here as we know that no send
                 // operation is currently in progress.
                 bus.io.close(*Self, bus, on_close, &connection.send_completion, connection.fd);