tigerbeetle-node 0.9.0 → 0.11.0

package/src/tigerbeetle/src/main.zig

@@ -3,41 +3,48 @@ const assert = std.debug.assert;
 const fmt = std.fmt;
 const mem = std.mem;
 const os = std.os;
-const log = std.log;
+const log = std.log.scoped(.main);
 
 const config = @import("config.zig");
 pub const log_level: std.log.Level = @intToEnum(std.log.Level, config.log_level);
 
 const cli = @import("cli.zig");
+const fatal = cli.fatal;
 
 const IO = @import("io.zig").IO;
 const Time = @import("time.zig").Time;
 const Storage = @import("storage.zig").Storage;
+
 const MessageBus = @import("message_bus.zig").MessageBusReplica;
-const StateMachine = @import("state_machine.zig").StateMachine;
+const MessagePool = @import("message_pool.zig").MessagePool;
+const StateMachine = @import("state_machine.zig").StateMachineType(Storage, .{
+    .message_body_size_max = config.message_body_size_max,
+});
 
 const vsr = @import("vsr.zig");
-const Replica = vsr.Replica(StateMachine, MessageBus, Storage, Time);
+const Replica = vsr.ReplicaType(StateMachine, MessageBus, Storage, Time);
 
-pub fn main() !void {
-    var io = try IO.init(128, 0);
-    defer io.deinit();
+const SuperBlock = vsr.SuperBlockType(Storage);
+const superblock_zone_size = @import("vsr/superblock.zig").superblock_zone_size;
+const data_file_size_min = @import("vsr/superblock.zig").data_file_size_min;
+
+comptime {
+    assert(config.deployment_environment == .production or
+        config.deployment_environment == .development);
+}
 
+pub fn main() !void {
     var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
     defer arena.deinit();
 
     const allocator = arena.allocator();
 
-    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,
-        ),
+    var parse_args = try cli.parse_args(allocator);
+    defer parse_args.deinit(allocator);
+
+    switch (parse_args) {
+        .format => |*args| try Command.format(allocator, args.cluster, args.replica, args.path),
+        .start => |*args| try Command.start(&arena, args.addresses, args.memory, args.path),
     }
 }
 
@@ -45,100 +52,125 @@ pub fn main() !void {
 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(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.
-    const fd = try io.open_file(
-        dir_fd,
-        filename,
-        config.journal_size_max,
-        true,
-    );
-    std.os.close(fd);
-
-    const file = try (std.fs.Dir{ .fd = dir_fd }).openFile(filename, .{ .write = true });
-    defer file.close();
-
-    {
-        const write_size_max = 4 * 1024 * 1024;
-        var write: [write_size_max]u8 = undefined;
-        var offset: u64 = 0;
-        while (true) {
-            const write_size = vsr.format_journal(cluster, offset, &write);
-            if (write_size == 0) break;
-            try file.writeAll(write[0..write_size]);
-            offset += write_size;
-        }
+const Command = struct {
+    dir_fd: os.fd_t,
+    fd: os.fd_t,
+    io: IO,
+    storage: Storage,
+    message_pool: MessagePool,
+
+    fn init(
+        command: *Command,
+        allocator: mem.Allocator,
+        path: [:0]const u8,
+        must_create: bool,
+    ) !void {
+        // TODO Resolve the parent directory properly in the presence of .. and symlinks.
+        // TODO Handle physical volumes where there is no directory to fsync.
+        const dirname = std.fs.path.dirname(path) orelse ".";
+        command.dir_fd = try IO.open_dir(dirname);
+        errdefer os.close(command.dir_fd);
+
+        const basename = std.fs.path.basename(path);
+        command.fd = try IO.open_file(command.dir_fd, basename, data_file_size_min, must_create);
+        errdefer os.close(command.fd);
+
+        command.io = try IO.init(128, 0);
+        errdefer command.io.deinit();
+
+        command.storage = try Storage.init(&command.io, command.fd);
+        errdefer command.storage.deinit();
+
+        command.message_pool = try MessagePool.init(allocator, .replica);
+        errdefer command.message_pool.deinit(allocator);
     }
 
-    log.info("initialized data file", .{});
-}
+    fn deinit(command: *Command, allocator: mem.Allocator) void {
+        command.message_pool.deinit(allocator);
+        command.storage.deinit();
+        command.io.deinit();
+        os.close(command.fd);
+        os.close(command.dir_fd);
+    }
 
-/// Run as a replica server defined by the given args
-fn start(
-    io: *IO,
-    allocator: mem.Allocator,
-    cluster: u32,
-    replica_index: u8,
-    addresses: []std.net.Address,
-    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_index }) catch {
-        unreachable;
-    };
-    assert(filename.len == filename_len);
-
-    // TODO Expose data file size on the CLI.
-    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 state_machine = try StateMachine.init(
-        allocator,
-        config.accounts_max,
-        config.transfers_max,
-        config.transfers_pending_max,
-    );
-    var storage = try Storage.init(config.journal_size_max, storage_fd, io);
-    var message_bus = try MessageBus.init(
-        allocator,
-        cluster,
-        addresses,
-        replica_index,
-        io,
-    );
-    var time: Time = .{};
-    var replica = try Replica.init(
-        allocator,
-        cluster,
-        @intCast(u8, addresses.len),
-        replica_index,
-        &time,
-        &storage,
-        &message_bus,
-        &state_machine,
-    );
-    message_bus.set_on_message(*Replica, &replica, Replica.on_message);
-
-    log.info("cluster={x} replica={}: listening on {}", .{
-        cluster,
-        replica_index,
-        addresses[replica_index],
-    });
-
-    while (true) {
-        replica.tick();
-        message_bus.tick();
-        try io.run_for_ns(config.tick_ms * std.time.ns_per_ms);
+    pub fn format(allocator: mem.Allocator, cluster: u32, replica: u8, path: [:0]const u8) !void {
+        var command: Command = undefined;
+        try command.init(allocator, path, true);
+        defer command.deinit(allocator);
+
+        var superblock = try SuperBlock.init(
+            allocator,
+            &command.storage,
+            &command.message_pool,
+        );
+        defer superblock.deinit(allocator);
+
+        try vsr.format(Storage, allocator, cluster, replica, &command.storage, &superblock);
     }
-}
+
+    pub fn start(
+        arena: *std.heap.ArenaAllocator,
+        addresses: []std.net.Address,
+        memory: u64,
+        path: [:0]const u8,
+    ) !void {
+        _ = memory; // TODO
+
+        const allocator = arena.allocator();
+
+        var command: Command = undefined;
+        try command.init(allocator, path, false);
+        defer command.deinit(allocator);
+
+        var replica: Replica = undefined;
+        try replica.open(allocator, .{
+            .replica_count = @intCast(u8, addresses.len),
+            .storage = &command.storage,
+            .message_pool = &command.message_pool,
+            .time = .{},
+            .state_machine_options = .{
+                // TODO Tune lsm_forest_node_count better.
+                .lsm_forest_node_count = 4096,
+                .cache_entries_accounts = config.cache_accounts_max,
+                .cache_entries_transfers = config.cache_transfers_max,
+                .cache_entries_posted = config.cache_transfers_pending_max,
+            },
+            .message_bus_options = .{
+                .configuration = addresses,
+                .io = &command.io,
+            },
+        }) catch |err| switch (err) {
+            error.NoAddress => fatal("all --addresses must be provided", .{}),
+            else => err,
+        };
+
+        // Calculate how many bytes are allocated inside `arena`.
+        // TODO This does not account for the fact that any allocations will be rounded up to the nearest page by `std.heap.page_allocator`.
+        var allocation_count: usize = 0;
+        var allocation_size: usize = 0;
+        {
+            var node_maybe = arena.state.buffer_list.first;
+            while (node_maybe) |node| {
+                allocation_count += 1;
+                allocation_size += node.data.len;
+                node_maybe = node.next;
+            }
+        }
+        log.info("{}: Allocated {} bytes in {} regions during replica init", .{
+            replica.replica,
+            allocation_size,
+            allocation_count,
+        });
+
+        log.info("{}: cluster={}: listening on {}", .{
+            replica.replica,
+            replica.cluster,
+            addresses[replica.replica],
+        });
+
+        while (true) {
+            replica.tick();
+            try command.io.run_for_ns(config.tick_ms * std.time.ns_per_ms);
+        }
+    }
+};

package/src/tigerbeetle/src/message_bus.zig

@@ -17,25 +17,30 @@ const IO = @import("io.zig").IO;
 const MessagePool = @import("message_pool.zig").MessagePool;
 const Message = MessagePool.Message;
 
-pub const MessageBusReplica = MessageBusImpl(.replica);
-pub const MessageBusClient = MessageBusImpl(.client);
+pub const MessageBusReplica = MessageBusType(.replica);
+pub const MessageBusClient = MessageBusType(.client);
 
-fn MessageBusImpl(comptime process_type: vsr.ProcessType) type {
+fn MessageBusType(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,
-    });
+    }, .array);
 
     const tcp_sndbuf = switch (process_type) {
         .replica => config.tcp_sndbuf_replica,
         .client => config.tcp_sndbuf_client,
     };
 
+    const Process = union(vsr.ProcessType) {
+        replica: u8,
+        client: u128,
+    };
+
     return struct {
         const Self = @This();
 
-        pool: MessagePool,
+        pool: *MessagePool,
         io: *IO,
 
         cluster: u32,
@@ -59,10 +64,8 @@ fn MessageBusImpl(comptime process_type: vsr.ProcessType) type {
             .client => void,
         },
 
-        /// 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: ?*anyopaque, message: *Message) void = null,
-        on_message_context: ?*anyopaque = null,
+        /// The callback to be called when a message is received.
+        on_message_callback: fn (message_bus: *Self, message: *Message) void,
 
         /// This slice is allocated with a fixed size in the init function and never reallocated.
         connections: []Connection,
@@ -80,49 +83,54 @@ fn MessageBusImpl(comptime process_type: vsr.ProcessType) type {
         /// Seeded with the process' replica index or client ID.
         prng: std.rand.DefaultPrng,
 
+        pub const Options = struct {
+            configuration: []std.net.Address,
+            io: *IO,
+        };
+
         /// Initialize the MessageBus for the given cluster, configuration and replica/client process.
         pub fn init(
             allocator: mem.Allocator,
             cluster: u32,
-            configuration: []std.net.Address,
-            process: switch (process_type) {
-                .replica => u8,
-                .client => u128,
-            },
-            io: *IO,
+            process: Process,
+            message_pool: *MessagePool,
+            on_message_callback: fn (message_bus: *Self, message: *Message) void,
+            options: Options,
         ) !Self {
             // There must be enough connections for all replicas and at least one client.
-            assert(config.connections_max > configuration.len);
+            assert(config.connections_max > options.configuration.len);
+            assert(@as(vsr.ProcessType, process) == process_type);
 
             const connections = try allocator.alloc(Connection, config.connections_max);
             errdefer allocator.free(connections);
             mem.set(Connection, connections, .{});
 
-            const replicas = try allocator.alloc(?*Connection, configuration.len);
+            const replicas = try allocator.alloc(?*Connection, options.configuration.len);
             errdefer allocator.free(replicas);
             mem.set(?*Connection, replicas, null);
 
-            const replicas_connect_attempts = try allocator.alloc(u64, configuration.len);
+            const replicas_connect_attempts = try allocator.alloc(u64, options.configuration.len);
             errdefer allocator.free(replicas_connect_attempts);
             mem.set(u64, replicas_connect_attempts, 0);
 
             const prng_seed = switch (process_type) {
-                .replica => process,
-                .client => @truncate(u64, process),
+                .replica => process.replica,
+                .client => @truncate(u64, process.client),
             };
 
             var bus: Self = .{
-                .pool = try MessagePool.init(allocator, process_type),
-                .io = io,
+                .pool = message_pool,
+                .io = options.io,
                 .cluster = cluster,
-                .configuration = configuration,
+                .configuration = options.configuration,
                 .process = switch (process_type) {
                     .replica => .{
-                        .replica = process,
-                        .accept_fd = try init_tcp(io, configuration[process]),
+                        .replica = process.replica,
+                        .accept_fd = try init_tcp(options.io, options.configuration[process.replica]),
                     },
                     .client => {},
                 },
+                .on_message_callback = on_message_callback,
                 .connections = connections,
                 .replicas = replicas,
                 .replicas_connect_attempts = replicas_connect_attempts,
@@ -137,25 +145,8 @@ fn MessageBusImpl(comptime process_type: vsr.ProcessType) type {
             return bus;
         }
 
-        pub fn set_on_message(
-            bus: *Self,
-            comptime Context: type,
-            context: Context,
-            comptime on_message: fn (context: Context, message: *Message) void,
-        ) void {
-            assert(bus.on_message_callback == null);
-            assert(bus.on_message_context == null);
-
-            bus.on_message_callback = struct {
-                fn wrapper(_context: ?*anyopaque, message: *Message) void {
-                    on_message(@intToPtr(Context, @ptrToInt(_context)), message);
-                }
-            }.wrapper;
-            bus.on_message_context = context;
-        }
-
         /// TODO This is required by the Client.
-        pub fn deinit(_: *Self) void {}
+        pub fn deinit(_: *Self, _: std.mem.Allocator) void {}
 
         fn init_tcp(io: *IO, address: std.net.Address) !os.socket_t {
             const fd = try io.open_socket(
@@ -206,9 +197,9 @@ fn MessageBusImpl(comptime process_type: vsr.ProcessType) type {
                 }
             }
 
-            if (config.tcp_user_timeout > 0) {
+            if (config.tcp_user_timeout_ms > 0) {
                 if (is_linux) {
-                    try set(fd, os.IPPROTO.TCP, os.TCP.USER_TIMEOUT, config.tcp_user_timeout);
+                    try set(fd, os.IPPROTO.TCP, os.TCP.USER_TIMEOUT, config.tcp_user_timeout_ms);
                 }
             }
 
@@ -641,7 +632,13 @@ fn MessageBusImpl(comptime process_type: vsr.ProcessType) type {
                                 //assert(!connection.send_submitted);
                             },
                             // Ignore all the remaining errors for now
-                            error.ConnectionAborted, error.ConnectionResetByPeer, error.BlockingOperationInProgress, error.NetworkSubsystemFailed, error.SystemResources, error.Unexpected => {},
+                            error.ConnectionAborted,
+                            error.ConnectionResetByPeer,
+                            error.BlockingOperationInProgress,
+                            error.NetworkSubsystemFailed,
+                            error.SystemResources,
+                            error.Unexpected,
+                            => {},
                         };
                     },
                     .close => {},
@@ -670,7 +667,11 @@ fn MessageBusImpl(comptime process_type: vsr.ProcessType) type {
                     return null;
                 }
 
-                const header = mem.bytesAsValue(Header, data[0..@sizeOf(Header)]);
+                const header = mem.bytesAsValue(
+                    Header,
+                    @alignCast(@alignOf(Header), data[0..@sizeOf(Header)]),
+                );
+
                 if (!connection.recv_checked_header) {
                     if (!header.valid_checksum()) {
                         log.err("invalid header checksum received from {}", .{connection.peer});
@@ -763,7 +764,7 @@ fn MessageBusImpl(comptime process_type: vsr.ProcessType) type {
                     }
                 }
 
-                bus.on_message_callback.?(bus.on_message_context, message);
+                bus.on_message_callback(bus, message);
             }
 
             fn maybe_set_peer(connection: *Connection, bus: *Self, header: *const Header) void {

package/src/tigerbeetle/src/message_pool.zig

@@ -23,9 +23,10 @@ pub const messages_max_replica = messages_max: {
     var sum: usize = 0;
 
     sum += config.io_depth_read + config.io_depth_write; // Journal I/O
-    sum += config.clients_max; // Replica.client_table
+    sum += config.clients_max; // SuperBlock.client_table
     sum += 1; // Replica.loopback_queue
     sum += config.pipeline_max; // Replica.pipeline
+    sum += 1; // Replica.commit_prepare
     // Replica.do_view_change_from_all_replicas quorum:
     // Replica.recovery_response_quorum is only used for recovery and does not increase the limit.
     // All other quorums are bitsets.
@@ -67,9 +68,7 @@ pub const MessagePool = struct {
     pub const Message = struct {
         // TODO: replace this with a header() function to save memory
         header: *Header,
-        /// This buffer is aligned to config.sector_size and casting to that alignment in order
-        /// to perform Direct I/O is safe.
-        buffer: []u8,
+        buffer: []align(config.sector_size) u8,
         references: u32 = 0,
         next: ?*Message,
 
@@ -79,21 +78,23 @@ pub const MessagePool = struct {
             return message;
         }
 
-        pub fn body(message: *Message) []u8 {
+        pub fn body(message: *const Message) []align(@sizeOf(Header)) u8 {
             return message.buffer[@sizeOf(Header)..message.header.size];
         }
     };
 
-    /// List of currently unused messages of message_size_max_padded
+    /// List of currently unused messages.
     free_list: ?*Message,
 
     pub fn init(allocator: mem.Allocator, process_type: vsr.ProcessType) error{OutOfMemory}!MessagePool {
-        const messages_max: usize = switch (process_type) {
+        return MessagePool.init_capacity(allocator, switch (process_type) {
             .replica => messages_max_replica,
             .client => messages_max_client,
-        };
+        });
+    }
 
-        var ret: MessagePool = .{
+    pub fn init_capacity(allocator: mem.Allocator, messages_max: usize) error{OutOfMemory}!MessagePool {
+        var pool: MessagePool = .{
             .free_list = null,
         };
         {
@@ -109,13 +110,22 @@ pub const MessagePool = struct {
                 message.* = .{
                     .header = mem.bytesAsValue(Header, buffer[0..@sizeOf(Header)]),
                     .buffer = buffer,
-                    .next = ret.free_list,
+                    .next = pool.free_list,
                 };
-                ret.free_list = message;
+                pool.free_list = message;
             }
         }
 
-        return ret;
+        return pool;
+    }
+
+    /// Frees all messages that were unused or returned to the pool via unref().
+    pub fn deinit(pool: *MessagePool, allocator: mem.Allocator) void {
+        while (pool.free_list) |message| {
+            pool.free_list = message.next;
+            allocator.free(message.buffer);
+            allocator.destroy(message);
+        }
     }
 
     /// Get an unused message with a buffer of config.message_size_max.