tigerbeetle-node 0.4.2 → 0.5.2

package/src/tigerbeetle/src/storage.zig

@@ -1,11 +1,12 @@
 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 is_darwin = builtin.target.isDarwin();
 
 const config = @import("config.zig");
 const vsr = @import("vsr.zig");
@@ -90,7 +91,7 @@ pub const Storage = struct {
         buffer: []u8,
         offset: u64,
     ) void {
-        self.assert_alignment(buffer, offset);
+        assert_alignment(buffer, offset);
 
         read.* = .{
             .completion = undefined,
@@ -189,7 +190,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 +202,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 +228,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 +263,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 +296,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);
@@ -330,17 +331,17 @@ pub const Storage = struct {
         // 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 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;
+        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;
+                if (!is_darwin) flags |= os.O.DIRECT;
             } else if (config.deployment_environment == .development) {
                 log.warn("file system does not support Direct I/O", .{});
             } else {
@@ -352,15 +353,15 @@ pub const Storage = struct {
 
         if (must_create) {
             log.info("creating \"{s}\"...", .{relative_path});
-            flags |= os.O_CREAT;
-            flags |= os.O_EXCL;
+            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);
+        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));
@@ -372,12 +373,12 @@ pub const Storage = struct {
 
         // 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);
+            _ = 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) {
+        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,
         };
@@ -411,7 +412,7 @@ pub const Storage = struct {
         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...", .{});
+                log.info("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;
@@ -436,6 +437,8 @@ pub const Storage = struct {
             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
+            _ = F_VOLPOSMODE;
+
             const fstore_t = extern struct {
                 fst_flags: c_uint,
                 fst_posmode: c_int,
@@ -453,24 +456,24 @@ pub const Storage = struct {
             };
 
             // 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) {
+            var res = os.system.fcntl(fd, os.F.PREALLOCATE, @ptrToInt(&store));
+            if (os.errno(res) != .SUCCESS) {
                 store.fst_flags = F_ALLOCATEALL;
-                res = os.system.fcntl(fd, os.F_PREALLOCATE, @ptrToInt(&store));
+                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
+                .SUCCESS => {},
+                .ACCES => unreachable, // F_SETLK or F_SETSIZE of F_WRITEBOOTSTRAP
+                .BADF => return error.FileDescriptorInvalid,
+                .DEADLK => unreachable, // F_SETLKW
+                .INTR => unreachable, // F_SETLKW
+                .INVAL => return error.ArgumentsInvalid, // for F_PREALLOCATE (offset invalid)
+                .MFILE => unreachable, // F_DUPFD or F_DUPED
+                .NOLCK => unreachable, // F_SETLK or F_SETLKW
+                .OVERFLOW => return error.FileTooBig,
+                .SRCH => unreachable, // F_SETOWN
+                .OPNOTSUPP => return error.OperationNotSupported, // not reported but need same error union
                 else => |errno| return os.unexpectedErrno(errno),
             }
 
@@ -484,19 +487,19 @@ pub const Storage = struct {
         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,
+                .SUCCESS => return,
+                .BADF => return error.FileDescriptorInvalid,
+                .FBIG => return error.FileTooBig,
+                .INTR => continue,
+                .INVAL => return error.ArgumentsInvalid,
+                .IO => return error.InputOutput,
+                .NODEV => return error.NoDevice,
+                .NOSPC => return error.NoSpaceLeft,
+                .NOSYS => return error.SystemOutdated,
+                .OPNOTSUPP => return error.OperationNotSupported,
+                .PERM => return error.PermissionDenied,
+                .SPIPE => return error.Unseekable,
+                .TXTBSY => return error.FileBusy,
                 else => |errno| return os.unexpectedErrno(errno),
             }
         }
@@ -509,18 +512,18 @@ pub const Storage = struct {
 
         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);
+        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;
+            _ = 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);
+            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));

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

@@ -34,7 +34,7 @@ pub const ClusterOptions = struct {
 };
 
 pub const Cluster = struct {
-    allocator: *mem.Allocator,
+    allocator: mem.Allocator,
     options: ClusterOptions,
 
     state_machines: []StateMachine,
@@ -49,7 +49,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);
 

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

@@ -25,11 +25,11 @@ 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,
@@ -43,7 +43,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,14 +52,14 @@ 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 {
         return bus.pool.get_message();

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

@@ -38,7 +38,7 @@ pub const Network = struct {
         target: Process,
     };
 
-    allocator: *std.mem.Allocator,
+    allocator: std.mem.Allocator,
 
     options: NetworkOptions,
     packet_simulator: PacketSimulator(Packet),
@@ -47,7 +47,7 @@ pub const Network = struct {
     processes: std.ArrayListUnmanaged(u128),
 
     pub fn init(
-        allocator: *std.mem.Allocator,
+        allocator: std.mem.Allocator,
         replica_count: u8,
         client_count: u8,
         options: NetworkOptions,
@@ -136,7 +136,7 @@ pub const Network = struct {
 
     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 {

package/src/tigerbeetle/src/test/packet_simulator.zig

@@ -88,7 +88,7 @@ pub fn PacketSimulator(comptime Packet: type) type {
 
         /// A send and receive path between each node in the network. We use the `path` function to
         /// index it.
-        paths: []std.PriorityQueue(Data),
+        paths: []std.PriorityQueue(Data, void, Self.order_packets),
 
         /// We can arbitrary clog a path until a tick.
         path_clogged_till: []u64,
@@ -103,11 +103,11 @@ pub fn PacketSimulator(comptime Packet: type) type {
         replicas: []u8,
         stability: u32,
 
-        pub fn init(allocator: *std.mem.Allocator, options: PacketSimulatorOptions) !Self {
+        pub fn init(allocator: std.mem.Allocator, options: PacketSimulatorOptions) !Self {
             assert(options.one_way_delay_mean >= options.one_way_delay_min);
             var self = Self{
                 .paths = try allocator.alloc(
-                    std.PriorityQueue(Data),
+                    std.PriorityQueue(Data, void, Self.order_packets),
                     @as(usize, options.node_count) * options.node_count,
                 ),
                 .path_clogged_till = try allocator.alloc(
@@ -128,8 +128,8 @@ pub fn PacketSimulator(comptime Packet: type) type {
             }
 
             for (self.paths) |*queue| {
-                queue.* = std.PriorityQueue(Data).init(allocator, Self.order_packets);
-                try queue.ensureCapacity(options.path_maximum_capacity);
+                queue.* = std.PriorityQueue(Data, void, Self.order_packets).init(allocator, {});
+                try queue.ensureTotalCapacity(options.path_maximum_capacity);
             }
 
             for (self.path_clogged_till) |*clogged_till| {
@@ -139,7 +139,7 @@ pub fn PacketSimulator(comptime Packet: type) type {
             return self;
         }
 
-        pub fn deinit(self: *Self, allocator: *std.mem.Allocator) void {
+        pub fn deinit(self: *Self, allocator: std.mem.Allocator) void {
             for (self.paths) |*queue| {
                 while (queue.popOrNull()) |*data| data.packet.deinit();
                 queue.deinit();
@@ -147,12 +147,14 @@ pub fn PacketSimulator(comptime Packet: type) type {
             allocator.free(self.paths);
         }
 
-        fn order_packets(a: Data, b: Data) math.Order {
+        fn order_packets(context: void, a: Data, b: Data) math.Order {
+            _ = context;
+
             return math.order(a.expiry, b.expiry);
         }
 
         fn should_drop(self: *Self) bool {
-            return self.prng.random.uintAtMost(u8, 100) < self.options.packet_loss_probability;
+            return self.prng.random().uintAtMost(u8, 100) < self.options.packet_loss_probability;
         }
 
         fn path_index(self: *Self, path: Path) usize {
@@ -161,9 +163,8 @@ pub fn PacketSimulator(comptime Packet: type) type {
             return @as(usize, path.source) * self.options.node_count + path.target;
         }
 
-        pub fn path_queue(self: *Self, path: Path) *std.PriorityQueue(Data) {
-            var index = self.path_index(path);
-            return &self.paths[@as(usize, path.source) * self.options.node_count + path.target];
+        pub fn path_queue(self: *Self, path: Path) *std.PriorityQueue(Data, void, Self.order_packets) {
+            return &self.paths[self.path_index(path)];
         }
 
         fn is_clogged(self: *Self, path: Path) bool {
@@ -171,7 +172,9 @@ pub fn PacketSimulator(comptime Packet: type) type {
         }
 
         fn should_clog(self: *Self, path: Path) bool {
-            return self.prng.random.uintAtMost(u8, 100) < self.options.path_clog_probability;
+            _ = path;
+
+            return self.prng.random().uintAtMost(u8, 100) < self.options.path_clog_probability;
         }
 
         fn clog_for(self: *Self, path: Path, ticks: u64) void {
@@ -185,15 +188,15 @@ pub fn PacketSimulator(comptime Packet: type) type {
         }
 
         fn should_replay(self: *Self) bool {
-            return self.prng.random.uintAtMost(u8, 100) < self.options.packet_replay_probability;
+            return self.prng.random().uintAtMost(u8, 100) < self.options.packet_replay_probability;
         }
 
         fn should_partition(self: *Self) bool {
-            return self.prng.random.uintAtMost(u8, 100) < self.options.partition_probability;
+            return self.prng.random().uintAtMost(u8, 100) < self.options.partition_probability;
         }
 
         fn should_unpartition(self: *Self) bool {
-            return self.prng.random.uintAtMost(u8, 100) < self.options.unpartition_probability;
+            return self.prng.random().uintAtMost(u8, 100) < self.options.unpartition_probability;
         }
 
         /// Return a value produced using an exponential distribution with
@@ -201,7 +204,7 @@ pub fn PacketSimulator(comptime Packet: type) type {
         fn one_way_delay(self: *Self) u64 {
             const min = self.options.one_way_delay_min;
             const mean = self.options.one_way_delay_mean;
-            return min + @floatToInt(u64, @intToFloat(f64, mean - min) * self.prng.random.floatExp(f64));
+            return min + @floatToInt(u64, @intToFloat(f64, mean - min) * self.prng.random().floatExp(f64));
         }
 
         /// Partitions the network. Guaranteed to isolate at least one replica.
@@ -217,8 +220,8 @@ pub fn PacketSimulator(comptime Packet: type) type {
                 .uniform_size => {
                     // Exclude cases sz == 0 and sz == replica_count
                     const sz =
-                        1 + self.prng.random.uintAtMost(u8, self.options.replica_count - 2);
-                    self.prng.random.shuffle(u8, self.replicas);
+                        1 + self.prng.random().uintAtMost(u8, self.options.replica_count - 2);
+                    self.prng.random().shuffle(u8, self.replicas);
                     for (self.replicas) |r, i| {
                         self.partition[r] = i < sz;
                     }
@@ -226,18 +229,18 @@ pub fn PacketSimulator(comptime Packet: type) type {
                 .uniform_partition => {
                     var only_same = true;
                     self.partition[0] =
-                        self.prng.random.uintLessThan(u8, 2) == 1;
+                        self.prng.random().uintLessThan(u8, 2) == 1;
 
                     var i: usize = 1;
                     while (i < self.options.replica_count) : (i += 1) {
                         self.partition[i] =
-                            self.prng.random.uintLessThan(u8, 2) == 1;
+                            self.prng.random().uintLessThan(u8, 2) == 1;
                         only_same =
                             only_same and (self.partition[i - 1] == self.partition[i]);
                     }
 
                     if (only_same) {
-                        const n = self.prng.random.uintLessThan(u8, self.options.replica_count);
+                        const n = self.prng.random().uintLessThan(u8, self.options.replica_count);
                         self.partition[n] = true;
                     }
                 },
@@ -245,7 +248,7 @@ pub fn PacketSimulator(comptime Packet: type) type {
                     for (self.replicas) |_, i| {
                         self.partition[i] = false;
                     }
-                    const n = self.prng.random.uintLessThan(u8, self.options.replica_count);
+                    const n = self.prng.random().uintLessThan(u8, self.options.replica_count);
                     self.partition[n] = true;
                 },
                 // Put your own partitioning logic here.
@@ -279,12 +282,12 @@ pub fn PacketSimulator(comptime Packet: type) type {
                 if (self.is_partitioned) {
                     if (self.should_unpartition()) {
                         self.unpartition_network();
-                        log.alert("unpartitioned network: partition={d}", .{self.partition});
+                        log.err("unpartitioned network: partition={d}", .{self.partition});
                     }
                 } else {
                     if (self.options.replica_count > 1 and self.should_partition()) {
                         self.partition_network();
-                        log.alert("partitioned network: partition={d}", .{self.partition});
+                        log.err("partitioned network: partition={d}", .{self.partition});
                     }
                 }
             }
@@ -305,14 +308,14 @@ pub fn PacketSimulator(comptime Packet: type) type {
                             self.replicas_are_in_different_partitions(from, to))
                         {
                             self.stats[@enumToInt(PacketStatistics.dropped_due_to_partition)] += 1;
-                            log.alert("dropped packet (different partitions): from={} to={}", .{ from, to });
+                            log.err("dropped packet (different partitions): from={} to={}", .{ from, to });
                             data.packet.deinit(path);
                             continue;
                         }
 
                         if (self.should_drop()) {
                             self.stats[@enumToInt(PacketStatistics.dropped)] += 1;
-                            log.alert("dropped packet from={} to={}.", .{ from, to });
+                            log.err("dropped packet from={} to={}.", .{ from, to });
                             data.packet.deinit(path);
                             continue;
                         }
@@ -336,7 +339,7 @@ pub fn PacketSimulator(comptime Packet: type) type {
                     if (self.should_clog(reverse_path)) {
                         log.debug("reverse path clogged", .{});
                         const mean = @intToFloat(f64, self.options.path_clog_duration_mean);
-                        const ticks = @floatToInt(u64, mean * self.prng.random.floatExp(f64));
+                        const ticks = @floatToInt(u64, mean * self.prng.random().floatExp(f64));
                         self.clog_for(reverse_path, ticks);
                     }
                 }
@@ -352,10 +355,10 @@ pub fn PacketSimulator(comptime Packet: type) type {
             const queue = self.path_queue(path);
             var queue_length = queue.count();
             if (queue_length + 1 > queue.capacity()) {
-                const index = self.prng.random.uintLessThanBiased(u64, queue_length);
+                const index = self.prng.random().uintLessThanBiased(u64, queue_length);
                 const data = queue.removeIndex(index);
                 data.packet.deinit(path);
-                log.alert("submit_packet: {} reached capacity, dropped packet={}", .{
+                log.err("submit_packet: {} reached capacity, dropped packet={}", .{
                     path,
                     index,
                 });

package/src/tigerbeetle/src/test/state_checker.zig

@@ -34,7 +34,7 @@ pub const StateChecker = struct {
     /// The number of times the cannonical state has been advanced.
     transitions: u64 = 0,
 
-    pub fn init(allocator: *mem.Allocator, cluster: *Cluster) !StateChecker {
+    pub fn init(allocator: mem.Allocator, cluster: *Cluster) !StateChecker {
         const state = cluster.state_machines[0].state;
 
         var state_machine_states: [config.replicas_max]u128 = undefined;
@@ -86,7 +86,7 @@ pub const StateChecker = struct {
         // The replica has transitioned to state `b` that is not yet in the history.
         // Check if this is a valid new state based on all currently inflight client requests.
         for (state_checker.client_requests) |*queue| {
-            if (queue.peek_ptr()) |input| {
+            if (queue.head_ptr()) |input| {
                 if (b == StateMachine.hash(state_checker.state, std.mem.asBytes(input))) {
                     const transitions_executed = state_checker.history.get(a).?;
                     if (transitions_executed < state_checker.transitions) {

package/src/tigerbeetle/src/test/state_machine.zig

@@ -24,6 +24,10 @@ pub const StateMachine = struct {
         operation: Operation,
         input: []u8,
     ) void {
+        _ = state_machine;
+        _ = realtime;
+        _ = operation;
+        _ = input;
         // TODO: use realtime in some way to test the system
     }