tigerbeetle-node 0.5.0 → 0.6.0

package/src/tigerbeetle/src/storage.zig

@@ -1,12 +1,11 @@
 const std = @import("std");
+const builtin = @import("builtin");
 const os = std.os;
 const Allocator = std.mem.Allocator;
 const assert = std.debug.assert;
 const log = std.log.scoped(.storage);
 
 const IO = @import("io.zig").IO;
-const is_darwin = std.Target.current.isDarwin();
-
 const config = @import("config.zig");
 const vsr = @import("vsr.zig");
 
@@ -90,7 +89,7 @@ pub const Storage = struct {
         buffer: []u8,
         offset: u64,
     ) void {
-        self.assert_alignment(buffer, offset);
+        assert_alignment(buffer, offset);
 
         read.* = .{
             .completion = undefined,
@@ -189,7 +188,7 @@ pub const Storage = struct {
             error.Unseekable,
             error.Unexpected,
             => {
-                log.emerg(
+                log.err(
                     "impossible read: offset={} buffer.len={} error={s}",
                     .{ read.offset, read.buffer.len, @errorName(err) },
                 );
@@ -201,7 +200,7 @@ pub const Storage = struct {
             // We tried to read more than there really is available to read.
             // In other words, we thought we could read beyond the end of the file descriptor.
             // This can happen if the data file inode `size` was truncated or corrupted.
-            log.emerg(
+            log.err(
                 "short read: buffer.len={} offset={} bytes_read={}",
                 .{ read.offset, read.buffer.len, bytes_read },
             );
@@ -227,7 +226,7 @@ pub const Storage = struct {
         buffer: []const u8,
         offset: u64,
     ) void {
-        self.assert_alignment(buffer, offset);
+        assert_alignment(buffer, offset);
 
         write.* = .{
             .completion = undefined,
@@ -262,7 +261,7 @@ pub const Storage = struct {
             // TODO: It seems like it might be possible for some filesystems to return ETIMEDOUT
             // here. Consider handling this without panicking.
             else => {
-                log.emerg(
+                log.err(
                     "impossible write: offset={} buffer.len={} error={s}",
                     .{ write.offset, write.buffer.len, @errorName(err) },
                 );
@@ -295,7 +294,7 @@ pub const Storage = struct {
     /// If this is not the case, then the underlying syscall will return EINVAL.
     /// We check this only at the start of a read or write because the physical sector size may be
     /// less than our logical sector size so that partial IOs then leave us no longer aligned.
-    fn assert_alignment(self: *Storage, buffer: []const u8, offset: u64) void {
+    fn assert_alignment(buffer: []const u8, offset: u64) void {
         assert(@ptrToInt(buffer.ptr) % config.sector_size == 0);
         assert(buffer.len % config.sector_size == 0);
         assert(offset % config.sector_size == 0);
@@ -306,230 +305,4 @@ pub const Storage = struct {
         assert(buffer.len > 0);
         assert(offset + buffer.len <= self.size);
     }
-
-    // Static helper functions to handle data file creation/opening/allocation:
-
-    /// Opens or creates a journal file:
-    /// - For reading and writing.
-    /// - For Direct I/O (if possible in development mode, but required in production mode).
-    /// - Obtains an advisory exclusive lock to the file descriptor.
-    /// - Allocates the file contiguously on disk if this is supported by the file system.
-    /// - Ensures that the file data (and file inode in the parent directory) is durable on disk.
-    ///   The caller is responsible for ensuring that the parent directory inode is durable.
-    /// - Verifies that the file size matches the expected file size before returning.
-    pub fn open(
-        dir_fd: os.fd_t,
-        relative_path: [:0]const u8,
-        size: u64,
-        must_create: bool,
-    ) !os.fd_t {
-        assert(relative_path.len > 0);
-        assert(size >= config.sector_size);
-        assert(size % config.sector_size == 0);
-
-        // TODO Use O_EXCL when opening as a block device to obtain a mandatory exclusive lock.
-        // This is much stronger than an advisory exclusive lock, and is required on some platforms.
-
-        var flags: u32 = os.O_CLOEXEC | os.O_RDWR | os.O_DSYNC;
-        var mode: os.mode_t = 0;
-
-        // TODO Document this and investigate whether this is in fact correct to set here.
-        if (@hasDecl(os, "O_LARGEFILE")) flags |= os.O_LARGEFILE;
-
-        var direct_io_supported = false;
-        if (config.direct_io) {
-            direct_io_supported = try Storage.fs_supports_direct_io(dir_fd);
-            if (direct_io_supported) {
-                if (!is_darwin) flags |= os.O_DIRECT;
-            } else if (config.deployment_environment == .development) {
-                log.warn("file system does not support Direct I/O", .{});
-            } else {
-                // We require Direct I/O for safety to handle fsync failure correctly, and therefore
-                // panic in production if it is not supported.
-                @panic("file system does not support Direct I/O");
-            }
-        }
-
-        if (must_create) {
-            log.info("creating \"{s}\"...", .{relative_path});
-            flags |= os.O_CREAT;
-            flags |= os.O_EXCL;
-            mode = 0o666;
-        } else {
-            log.info("opening \"{s}\"...", .{relative_path});
-        }
-
-        // This is critical as we rely on O_DSYNC for fsync() whenever we write to the file:
-        assert((flags & os.O_DSYNC) > 0);
-
-        // Be careful with openat(2): "If pathname is absolute, then dirfd is ignored." (man page)
-        assert(!std.fs.path.isAbsolute(relative_path));
-        const fd = try os.openatZ(dir_fd, relative_path, flags, mode);
-        // TODO Return a proper error message when the path exists or does not exist (init/start).
-        errdefer os.close(fd);
-
-        // TODO Check that the file is actually a file.
-
-        // On darwin, use F_NOCACHE on direct_io to disable the page cache as O_DIRECT doesn't exit.
-        if (is_darwin and config.direct_io and direct_io_supported) {
-            _ = try os.fcntl(fd, os.F_NOCACHE, 1);
-        }
-
-        // Obtain an advisory exclusive lock that works only if all processes actually use flock().
-        // LOCK_NB means that we want to fail the lock without waiting if another process has it.
-        os.flock(fd, os.LOCK_EX | os.LOCK_NB) catch |err| switch (err) {
-            error.WouldBlock => @panic("another process holds the data file lock"),
-            else => return err,
-        };
-
-        // Ask the file system to allocate contiguous sectors for the file (if possible):
-        // If the file system does not support `fallocate()`, then this could mean more seeks or a
-        // panic if we run out of disk space (ENOSPC).
-        if (must_create) try Storage.allocate(fd, size);
-
-        // The best fsync strategy is always to fsync before reading because this prevents us from
-        // making decisions on data that was never durably written by a previously crashed process.
-        // We therefore always fsync when we open the path, also to wait for any pending O_DSYNC.
-        // Thanks to Alex Miller from FoundationDB for diving into our source and pointing this out.
-        try os.fsync(fd);
-
-        // We fsync the parent directory to ensure that the file inode is durably written.
-        // The caller is responsible for the parent directory inode stored under the grandparent.
-        // We always do this when opening because we don't know if this was done before crashing.
-        try os.fsync(dir_fd);
-
-        const stat = try os.fstat(fd);
-        if (stat.size != size) @panic("data file inode size was truncated or corrupted");
-
-        return fd;
-    }
-
-    /// Allocates a file contiguously using fallocate() if supported.
-    /// Alternatively, writes to the last sector so that at least the file size is correct.
-    pub fn allocate(fd: os.fd_t, size: u64) !void {
-        log.info("allocating {}...", .{std.fmt.fmtIntSizeBin(size)});
-        Storage.fallocate(fd, 0, 0, @intCast(i64, size)) catch |err| switch (err) {
-            error.OperationNotSupported => {
-                log.warn("file system does not support fallocate(), an ENOSPC will panic", .{});
-                log.notice("allocating by writing to the last sector of the file instead...", .{});
-
-                const sector_size = config.sector_size;
-                const sector: [sector_size]u8 align(sector_size) = [_]u8{0} ** sector_size;
-
-                // Handle partial writes where the physical sector is less than a logical sector:
-                const offset = size - sector.len;
-                var written: usize = 0;
-                while (written < sector.len) {
-                    written += try os.pwrite(fd, sector[written..], offset + written);
-                }
-            },
-            else => return err,
-        };
-    }
-
-    fn fallocate(fd: i32, mode: i32, offset: i64, length: i64) !void {
-        // https://stackoverflow.com/a/11497568
-        // https://api.kde.org/frameworks/kcoreaddons/html/posix__fallocate__mac_8h_source.html
-        // http://hg.mozilla.org/mozilla-central/file/3d846420a907/xpcom/glue/FileUtils.cpp#l61
-        if (is_darwin) {
-            const F_ALLOCATECONTIG = 0x2; // allocate contiguous space
-            const F_ALLOCATEALL = 0x4; // allocate all or nothing
-            const F_PEOFPOSMODE = 3; // use relative offset from the seek pos mode
-            const F_VOLPOSMODE = 4; // use the specified volume offset
-            const fstore_t = extern struct {
-                fst_flags: c_uint,
-                fst_posmode: c_int,
-                fst_offset: os.off_t,
-                fst_length: os.off_t,
-                fst_bytesalloc: os.off_t,
-            };
-
-            var store = fstore_t{
-                .fst_flags = F_ALLOCATECONTIG | F_ALLOCATEALL,
-                .fst_posmode = F_PEOFPOSMODE,
-                .fst_offset = 0,
-                .fst_length = offset + length,
-                .fst_bytesalloc = 0,
-            };
-
-            // try to pre-allocate contiguous space and fall back to default non-continugous
-            var res = os.system.fcntl(fd, os.F_PREALLOCATE, @ptrToInt(&store));
-            if (os.errno(res) != 0) {
-                store.fst_flags = F_ALLOCATEALL;
-                res = os.system.fcntl(fd, os.F_PREALLOCATE, @ptrToInt(&store));
-            }
-
-            switch (os.errno(res)) {
-                0 => {},
-                os.EACCES => unreachable, // F_SETLK or F_SETSIZE of F_WRITEBOOTSTRAP
-                os.EBADF => return error.FileDescriptorInvalid,
-                os.EDEADLK => unreachable, // F_SETLKW
-                os.EINTR => unreachable, // F_SETLKW
-                os.EINVAL => return error.ArgumentsInvalid, // for F_PREALLOCATE (offset invalid)
-                os.EMFILE => unreachable, // F_DUPFD or F_DUPED
-                os.ENOLCK => unreachable, // F_SETLK or F_SETLKW
-                os.EOVERFLOW => return error.FileTooBig,
-                os.ESRCH => unreachable, // F_SETOWN
-                os.EOPNOTSUPP => return error.OperationNotSupported, // not reported but need same error union
-                else => |errno| return os.unexpectedErrno(errno),
-            }
-
-            // now actually perform the allocation
-            return os.ftruncate(fd, @intCast(u64, length)) catch |err| switch (err) {
-                error.AccessDenied => error.PermissionDenied,
-                else => |e| e,
-            };
-        }
-
-        while (true) {
-            const rc = os.linux.fallocate(fd, mode, offset, length);
-            switch (os.linux.getErrno(rc)) {
-                0 => return,
-                os.linux.EBADF => return error.FileDescriptorInvalid,
-                os.linux.EFBIG => return error.FileTooBig,
-                os.linux.EINTR => continue,
-                os.linux.EINVAL => return error.ArgumentsInvalid,
-                os.linux.EIO => return error.InputOutput,
-                os.linux.ENODEV => return error.NoDevice,
-                os.linux.ENOSPC => return error.NoSpaceLeft,
-                os.linux.ENOSYS => return error.SystemOutdated,
-                os.linux.EOPNOTSUPP => return error.OperationNotSupported,
-                os.linux.EPERM => return error.PermissionDenied,
-                os.linux.ESPIPE => return error.Unseekable,
-                os.linux.ETXTBSY => return error.FileBusy,
-                else => |errno| return os.unexpectedErrno(errno),
-            }
-        }
-    }
-
-    /// Detects whether the underlying file system for a given directory fd supports Direct I/O.
-    /// Not all Linux file systems support `O_DIRECT`, e.g. a shared macOS volume.
-    fn fs_supports_direct_io(dir_fd: std.os.fd_t) !bool {
-        if (!@hasDecl(std.os, "O_DIRECT") and !is_darwin) return false;
-
-        const path = "fs_supports_direct_io";
-        const dir = std.fs.Dir{ .fd = dir_fd };
-        const fd = try os.openatZ(dir_fd, path, os.O_CLOEXEC | os.O_CREAT | os.O_TRUNC, 0o666);
-        defer os.close(fd);
-        defer dir.deleteFile(path) catch {};
-
-        // F_NOCACHE on darwin is the most similar option to O_DIRECT on linux.
-        if (is_darwin) {
-            _ = os.fcntl(fd, os.F_NOCACHE, 1) catch return false;
-            return true;
-        }
-
-        while (true) {
-            const res = os.system.openat(dir_fd, path, os.O_CLOEXEC | os.O_RDONLY | os.O_DIRECT, 0);
-            switch (os.linux.getErrno(res)) {
-                0 => {
-                    os.close(@intCast(os.fd_t, res));
-                    return true;
-                },
-                os.linux.EINTR => continue,
-                os.linux.EINVAL => return false,
-                else => |err| return os.unexpectedErrno(err),
-            }
-        }
-    }
 };

package/src/tigerbeetle/src/test/cluster.zig

@@ -6,7 +6,8 @@ const config = @import("../config.zig");
 
 const StateChecker = @import("state_checker.zig").StateChecker;
 
-const MessagePool = @import("../message_pool.zig").MessagePool;
+const message_pool = @import("../message_pool.zig");
+const MessagePool = message_pool.MessagePool;
 const Message = MessagePool.Message;
 
 const Network = @import("network.zig").Network;
@@ -34,7 +35,7 @@ pub const ClusterOptions = struct {
 };
 
 pub const Cluster = struct {
-    allocator: *mem.Allocator,
+    allocator: mem.Allocator,
     options: ClusterOptions,
 
     state_machines: []StateMachine,
@@ -49,7 +50,7 @@ pub const Cluster = struct {
     state_checker: StateChecker = undefined,
     on_change_state: fn (replica: *Replica) void = undefined,
 
-    pub fn create(allocator: *mem.Allocator, prng: *std.rand.Random, options: ClusterOptions) !*Cluster {
+    pub fn create(allocator: mem.Allocator, prng: std.rand.Random, options: ClusterOptions) !*Cluster {
         const cluster = try allocator.create(Cluster);
         errdefer allocator.destroy(cluster);
 
@@ -197,12 +198,8 @@ pub const Cluster = struct {
             var it = message_bus.pool.free_list;
             while (it) |message| : (it = message.next) messages_in_pool += 1;
         }
-        {
-            var it = message_bus.pool.header_only_free_list;
-            while (it) |message| : (it = message.next) messages_in_pool += 1;
-        }
 
-        const total_messages = config.message_bus_messages_max + config.message_bus_headers_max;
+        const total_messages = message_pool.messages_max_replica;
         assert(messages_in_network + messages_in_pool == total_messages);
 
         replica.* = try Replica.init(

package/src/tigerbeetle/src/test/message_bus.zig

@@ -6,12 +6,13 @@ const config = @import("../config.zig");
 const MessagePool = @import("../message_pool.zig").MessagePool;
 const Message = MessagePool.Message;
 const Header = @import("../vsr.zig").Header;
+const ProcessType = @import("../vsr.zig").ProcessType;
 
 const Network = @import("network.zig").Network;
 
 const log = std.log.scoped(.message_bus);
 
-pub const Process = union(enum) {
+pub const Process = union(ProcessType) {
     replica: u8,
     client: u128,
 };
@@ -25,17 +26,17 @@ pub const MessageBus = struct {
 
     /// 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,
 
     pub fn init(
-        allocator: *std.mem.Allocator,
+        allocator: std.mem.Allocator,
         cluster: u32,
         process: Process,
         network: *Network,
     ) !MessageBus {
         return MessageBus{
-            .pool = try MessagePool.init(allocator),
+            .pool = try MessagePool.init(allocator, @as(ProcessType, process)),
             .network = network,
             .cluster = cluster,
             .process = process,
@@ -43,7 +44,7 @@ pub const MessageBus = struct {
     }
 
     /// TODO
-    pub fn deinit(bus: *MessageBus) void {}
+    pub fn deinit(_: *MessageBus) void {}
 
     pub fn set_on_message(
         bus: *MessageBus,
@@ -52,16 +53,16 @@ pub const MessageBus = struct {
         comptime on_message: fn (context: Context, message: *Message) void,
     ) void {
         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;
         bus.on_message_context = context;
     }
 
-    pub fn tick(self: *MessageBus) void {}
+    pub fn tick(_: *MessageBus) void {}
 
-    pub fn get_message(bus: *MessageBus) ?*Message {
+    pub fn get_message(bus: *MessageBus) *Message {
         return bus.pool.get_message();
     }
 

package/src/tigerbeetle/src/test/network.zig

@@ -28,7 +28,7 @@ pub const Network = struct {
         message: *Message,
 
         pub fn deinit(packet: *const Packet, path: PacketSimulatorPath) void {
-            const source_bus = &packet.network.busses.items[path.source];
+            const source_bus = &packet.network.buses.items[path.source];
             source_bus.unref(packet.message);
         }
     };
@@ -38,16 +38,16 @@ pub const Network = struct {
         target: Process,
     };
 
-    allocator: *std.mem.Allocator,
+    allocator: std.mem.Allocator,
 
     options: NetworkOptions,
     packet_simulator: PacketSimulator(Packet),
 
-    busses: std.ArrayListUnmanaged(MessageBus),
+    buses: std.ArrayListUnmanaged(MessageBus),
     processes: std.ArrayListUnmanaged(u128),
 
     pub fn init(
-        allocator: *std.mem.Allocator,
+        allocator: std.mem.Allocator,
         replica_count: u8,
         client_count: u8,
         options: NetworkOptions,
@@ -55,8 +55,8 @@ pub const Network = struct {
         const process_count = client_count + replica_count;
         assert(process_count <= std.math.maxInt(u8));
 
-        var busses = try std.ArrayListUnmanaged(MessageBus).initCapacity(allocator, process_count);
-        errdefer busses.deinit(allocator);
+        var buses = try std.ArrayListUnmanaged(MessageBus).initCapacity(allocator, process_count);
+        errdefer buses.deinit(allocator);
 
         var processes = try std.ArrayListUnmanaged(u128).initCapacity(allocator, process_count);
         errdefer processes.deinit(allocator);
@@ -71,18 +71,18 @@ pub const Network = struct {
             .allocator = allocator,
             .options = options,
             .packet_simulator = packet_simulator,
-            .busses = busses,
+            .buses = buses,
             .processes = processes,
         };
     }
 
     pub fn deinit(network: *Network) void {
-        // TODO: deinit the busses themselves when they gain a deinit()
-        network.busses.deinit(network.allocator);
+        // TODO: deinit the buses themselves when they gain a deinit()
+        network.buses.deinit(network.allocator);
         network.processes.deinit(network.allocator);
     }
 
-    /// Returns the address (index into Network.busses)
+    /// Returns the address (index into Network.buses)
     pub fn init_message_bus(network: *Network, cluster: u32, process: Process) !*MessageBus {
         const raw_process = switch (process) {
             .replica => |replica| replica,
@@ -97,9 +97,9 @@ pub const Network = struct {
         const bus = try MessageBus.init(network.allocator, cluster, process, network);
 
         network.processes.appendAssumeCapacity(raw_process);
-        network.busses.appendAssumeCapacity(bus);
+        network.buses.appendAssumeCapacity(bus);
 
-        return &network.busses.items[network.busses.items.len - 1];
+        return &network.buses.items[network.buses.items.len - 1];
     }
 
     pub fn send_message(network: *Network, message: *Message, path: Path) void {
@@ -131,18 +131,15 @@ pub const Network = struct {
     }
 
     pub fn get_message_bus(network: *Network, process: Process) *MessageBus {
-        return &network.busses.items[network.process_to_address(process)];
+        return &network.buses.items[network.process_to_address(process)];
     }
 
     fn deliver_message(packet: Packet, path: PacketSimulatorPath) void {
         const network = packet.network;
-        const source_bus = &network.busses.items[path.source];
-        const target_bus = &network.busses.items[path.target];
 
-        const message = target_bus.get_message() orelse {
-            log.debug("deliver_message: target message bus has no free messages, dropping", .{});
-            return;
-        };
+        const target_bus = &network.buses.items[path.target];
+
+        const message = target_bus.get_message();
         defer target_bus.unref(message);
 
         std.mem.copy(u8, message.buffer, packet.message.buffer);