tigerbeetle-node 0.11.4 → 0.11.5

package/src/tigerbeetle/src/message_bus.zig

@@ -6,7 +6,7 @@ const os = std.os;
 
 const is_linux = builtin.target.os.tag == .linux;
 
-const config = @import("constants.zig");
+const constants = @import("constants.zig");
 const log = std.log.scoped(.message_bus);
 
 const vsr = @import("vsr.zig");
@@ -23,14 +23,14 @@ pub const MessageBusClient = MessageBusType(.client);
 
 fn MessageBusType(comptime process_type: vsr.ProcessType) type {
     const SendQueue = RingBuffer(*Message, switch (process_type) {
-        .replica => config.connection_send_queue_max_replica,
+        .replica => constants.connection_send_queue_max_replica,
         // A client has at most 1 in-flight request, plus pings.
-        .client => config.connection_send_queue_max_client,
+        .client => constants.connection_send_queue_max_client,
     }, .array);
 
     const tcp_sndbuf = switch (process_type) {
-        .replica => config.tcp_sndbuf_replica,
-        .client => config.tcp_sndbuf_client,
+        .replica => constants.tcp_sndbuf_replica,
+        .client => constants.tcp_sndbuf_client,
     };
 
     const Process = union(vsr.ProcessType) {
@@ -99,10 +99,10 @@ fn MessageBusType(comptime process_type: vsr.ProcessType) type {
             options: Options,
         ) !Self {
             // There must be enough connections for all replicas and at least one client.
-            assert(config.connections_max > options.configuration.len);
+            assert(constants.connections_max > options.configuration.len);
             assert(@as(vsr.ProcessType, process) == process_type);
 
-            const connections = try allocator.alloc(Connection, config.connections_max);
+            const connections = try allocator.alloc(Connection, constants.connections_max);
             errdefer allocator.free(connections);
             mem.set(Connection, connections, .{});
 
@@ -140,7 +140,7 @@ fn MessageBusType(comptime process_type: vsr.ProcessType) type {
 
             // Pre-allocate enough memory to hold all possible connections in the client map.
             if (process_type == .replica) {
-                try bus.process.clients.ensureTotalCapacity(allocator, config.connections_max);
+                try bus.process.clients.ensureTotalCapacity(allocator, constants.connections_max);
             }
 
             return bus;
@@ -174,17 +174,17 @@ fn MessageBusType(comptime process_type: vsr.ProcessType) type {
                 }
             }.set;
 
-            if (config.tcp_rcvbuf > 0) rcvbuf: {
+            if (constants.tcp_rcvbuf > 0) rcvbuf: {
                 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, constants.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, constants.tcp_rcvbuf);
             }
 
             if (tcp_sndbuf > 0) sndbuf: {
@@ -200,23 +200,23 @@ fn MessageBusType(comptime process_type: vsr.ProcessType) type {
                 try set(fd, os.SOL.SOCKET, os.SO.SNDBUF, tcp_sndbuf);
             }
 
-            if (config.tcp_keepalive) {
+            if (constants.tcp_keepalive) {
                 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);
+                    try set(fd, os.IPPROTO.TCP, os.TCP.KEEPIDLE, constants.tcp_keepidle);
+                    try set(fd, os.IPPROTO.TCP, os.TCP.KEEPINTVL, constants.tcp_keepintvl);
+                    try set(fd, os.IPPROTO.TCP, os.TCP.KEEPCNT, constants.tcp_keepcnt);
                 }
             }
 
-            if (config.tcp_user_timeout_ms > 0) {
+            if (constants.tcp_user_timeout_ms > 0) {
                 if (is_linux) {
-                    try set(fd, os.IPPROTO.TCP, os.TCP.USER_TIMEOUT, config.tcp_user_timeout_ms);
+                    try set(fd, os.IPPROTO.TCP, os.TCP.USER_TIMEOUT, constants.tcp_user_timeout_ms);
                 }
             }
 
             // Set tcp no-delay
-            if (config.tcp_nodelay) {
+            if (constants.tcp_nodelay) {
                 if (is_linux) {
                     try set(fd, os.IPPROTO.TCP, os.TCP.NODELAY, 1);
                 }
@@ -224,7 +224,7 @@ fn MessageBusType(comptime process_type: vsr.ProcessType) type {
 
             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);
+            try os.listen(fd, constants.tcp_backlog);
 
             return fd;
         }
@@ -465,8 +465,8 @@ fn MessageBusType(comptime process_type: vsr.ProcessType) type {
                 var attempts = &bus.replicas_connect_attempts[replica];
                 const ms = vsr.exponential_backoff_with_jitter(
                     bus.prng.random(),
-                    config.connection_delay_min_ms,
-                    config.connection_delay_max_ms,
+                    constants.connection_delay_min_ms,
+                    constants.connection_delay_max_ms,
                     attempts.*,
                 );
                 attempts.* += 1;
@@ -691,7 +691,7 @@ fn MessageBusType(comptime process_type: vsr.ProcessType) type {
                         return null;
                     }
 
-                    if (header.size < @sizeOf(Header) or header.size > config.message_size_max) {
+                    if (header.size < @sizeOf(Header) or header.size > constants.message_size_max) {
                         log.err("header with invalid size {d} received from peer {}", .{
                             header.size,
                             connection.peer,
@@ -771,7 +771,7 @@ fn MessageBusType(comptime process_type: vsr.ProcessType) type {
                     const sector_ceil = vsr.sector_ceil(message.header.size);
                     if (message.header.size != sector_ceil) {
                         assert(message.header.size < sector_ceil);
-                        assert(message.buffer.len == config.message_size_max + config.sector_size);
+                        assert(message.buffer.len == constants.message_size_max + constants.sector_size);
                         mem.set(u8, message.buffer[message.header.size..sector_ceil], 0);
                     }
                 }
@@ -862,7 +862,7 @@ fn MessageBusType(comptime process_type: vsr.ProcessType) type {
                 assert(!connection.recv_submitted);
                 connection.recv_submitted = true;
 
-                assert(connection.recv_progress < config.message_size_max);
+                assert(connection.recv_progress < constants.message_size_max);
 
                 bus.io.recv(
                     *Self,
@@ -870,7 +870,7 @@ fn MessageBusType(comptime process_type: vsr.ProcessType) type {
                     on_recv,
                     &connection.recv_completion,
                     connection.fd,
-                    connection.recv_message.?.buffer[connection.recv_progress..config.message_size_max],
+                    connection.recv_message.?.buffer[connection.recv_progress..constants.message_size_max],
                 );
             }
 

package/src/tigerbeetle/src/message_pool.zig

@@ -3,36 +3,36 @@ const builtin = @import("builtin");
 const assert = std.debug.assert;
 const mem = std.mem;
 
-const config = @import("constants.zig");
+const constants = @import("constants.zig");
 
 const vsr = @import("vsr.zig");
 const Header = vsr.Header;
 
 comptime {
     // message_size_max must be a multiple of sector_size for Direct I/O
-    assert(config.message_size_max % config.sector_size == 0);
+    assert(constants.message_size_max % constants.sector_size == 0);
 }
 
 /// Add an extra sector_size bytes to allow a partially received subsequent
 /// message to be shifted to make space for 0 padding to vsr.sector_ceil.
-const message_size_max_padded = config.message_size_max + config.sector_size;
+const message_size_max_padded = constants.message_size_max + constants.sector_size;
 
 /// The number of full-sized messages allocated at initialization by the replica message pool.
 /// There must be enough messages to ensure that the replica can always progress, to avoid deadlock.
 pub const messages_max_replica = messages_max: {
     var sum: usize = 0;
 
-    sum += config.journal_iops_read_max + config.journal_iops_write_max; // Journal I/O
-    sum += config.clients_max; // SuperBlock.client_table
+    sum += constants.journal_iops_read_max + constants.journal_iops_write_max; // Journal I/O
+    sum += constants.clients_max; // SuperBlock.client_table
     sum += 1; // Replica.loopback_queue
-    sum += config.pipeline_max; // Replica.pipeline
+    sum += constants.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.
-    sum += config.replicas_max;
-    sum += config.connections_max; // Connection.recv_message
-    sum += config.connections_max * config.connection_send_queue_max_replica; // Connection.send_queue
+    sum += constants.replicas_max;
+    sum += constants.connections_max; // Connection.recv_message
+    sum += constants.connections_max * constants.connection_send_queue_max_replica; // Connection.send_queue
     sum += 1; // Handle bursts (e.g. Connection.parse_message)
     // Handle Replica.commit_op's reply:
     // (This is separate from the burst +1 because they may occur concurrently).
@@ -45,9 +45,9 @@ pub const messages_max_replica = messages_max: {
 pub const messages_max_client = messages_max: {
     var sum: usize = 0;
 
-    sum += config.replicas_max; // Connection.recv_message
-    sum += config.replicas_max * config.connection_send_queue_max_client; // Connection.send_queue
-    sum += config.client_request_queue_max; // Client.request_queue
+    sum += constants.replicas_max; // Connection.recv_message
+    sum += constants.replicas_max * constants.connection_send_queue_max_client; // Connection.send_queue
+    sum += constants.client_request_queue_max; // Client.request_queue
     // Handle bursts (e.g. Connection.parse_message, or sending a ping when the send queue is full).
     sum += 1;
 
@@ -56,8 +56,8 @@ pub const messages_max_client = messages_max: {
 
 comptime {
     // These conditions are necessary (but not sufficient) to prevent deadlocks.
-    assert(messages_max_replica > config.replicas_max);
-    assert(messages_max_client > config.client_request_queue_max);
+    assert(messages_max_replica > constants.replicas_max);
+    assert(messages_max_client > constants.client_request_queue_max);
 }
 
 /// A pool of reference-counted Messages, memory for which is allocated only once during
@@ -66,7 +66,7 @@ pub const MessagePool = struct {
     pub const Message = struct {
         // TODO: replace this with a header() function to save memory
         header: *Header,
-        buffer: []align(config.sector_size) u8,
+        buffer: []align(constants.sector_size) u8,
         references: u32 = 0,
         next: ?*Message,
 
@@ -103,7 +103,7 @@ pub const MessagePool = struct {
             while (i < messages_max) : (i += 1) {
                 const buffer = try allocator.allocAdvanced(
                     u8,
-                    config.sector_size,
+                    constants.sector_size,
                     message_size_max_padded,
                     .exact,
                 );
@@ -134,7 +134,7 @@ pub const MessagePool = struct {
         assert(free_count == pool.messages_max);
     }
 
-    /// Get an unused message with a buffer of config.message_size_max.
+    /// Get an unused message with a buffer of constants.message_size_max.
     /// The returned message has exactly one reference.
     pub fn get_message(pool: *MessagePool) *Message {
         const message = pool.free_list.?;

package/src/tigerbeetle/src/simulator.zig

@@ -4,7 +4,7 @@ const assert = std.debug.assert;
 const mem = std.mem;
 
 const tb = @import("tigerbeetle.zig");
-const config = @import("constants.zig");
+const constants = @import("constants.zig");
 const vsr = @import("vsr.zig");
 const Header = vsr.Header;
 
@@ -31,6 +31,8 @@ const log_state_transitions_only = builtin.mode != .Debug;
 
 const log_simulator = std.log.scoped(.simulator);
 
+pub const tigerbeetle_config = @import("config.zig").configs.test_min;
+
 /// You can fine tune your log levels even further (debug/info/warn/err):
 pub const log_level: std.log.Level = if (log_state_transitions_only) .info else .debug;
 
@@ -77,8 +79,8 @@ pub fn main() !void {
     var prng = std.rand.DefaultPrng.init(seed);
     const random = prng.random();
 
-    const replica_count = 1 + random.uintLessThan(u8, config.replicas_max);
-    const client_count = 1 + random.uintLessThan(u8, config.clients_max);
+    const replica_count = 1 + random.uintLessThan(u8, constants.replicas_max);
+    const client_count = 1 + random.uintLessThan(u8, constants.clients_max);
     const node_count = replica_count + client_count;
 
     const ticks_max = 50_000_000;
@@ -88,7 +90,7 @@ pub fn main() !void {
 
     // TODO: When block recovery and state transfer are implemented, remove this flag to allow
     // crashes to coexist with WAL wraps.
-    const requests_committed_max: usize = config.journal_slot_count * 3;
+    const requests_committed_max: usize = constants.journal_slot_count * 3;
 
     const cluster_options: ClusterOptions = .{
         .cluster = cluster_id,

package/src/tigerbeetle/src/storage.zig

@@ -5,7 +5,7 @@ const assert = std.debug.assert;
 const log = std.log.scoped(.storage);
 
 const IO = @import("io.zig").IO;
-const config = @import("constants.zig");
+const constants = @import("constants.zig");
 const fatal = @import("cli.zig").fatal;
 const vsr = @import("vsr.zig");
 
@@ -50,10 +50,10 @@ pub const Storage = struct {
             // that we need to subtract from `target_max` to get back onto the boundary.
             var max = read.target_max;
 
-            const partial_sector_read_remainder = read.buffer.len % config.sector_size;
+            const partial_sector_read_remainder = read.buffer.len % constants.sector_size;
             if (partial_sector_read_remainder != 0) {
                 // TODO log.debug() because this is interesting, and to ensure fuzz test coverage.
-                const partial_sector_read = config.sector_size - partial_sector_read_remainder;
+                const partial_sector_read = constants.sector_size - partial_sector_read_remainder;
                 max -= partial_sector_read;
             }
 
@@ -151,7 +151,7 @@ pub const Storage = struct {
                 // physical sectors than the logical sector size, so we cannot expect `target.len`
                 // to be an exact logical sector multiple.
                 const target = read.target();
-                if (target.len > config.sector_size) {
+                if (target.len > constants.sector_size) {
                     // We tried to read more than a logical sector and failed.
                     log.err("latent sector error: offset={}, subdividing read...", .{read.offset});
 
@@ -164,10 +164,10 @@ pub const Storage = struct {
                     // These lines both implement ceiling division e.g. `((3 - 1) / 2) + 1 == 2` and
                     // require that the numerator is always greater than zero:
                     assert(target.len > 0);
-                    const target_sectors = @divFloor(target.len - 1, config.sector_size) + 1;
+                    const target_sectors = @divFloor(target.len - 1, constants.sector_size) + 1;
                     assert(target_sectors > 0);
-                    read.target_max = (@divFloor(target_sectors - 1, 2) + 1) * config.sector_size;
-                    assert(read.target_max >= config.sector_size);
+                    read.target_max = (@divFloor(target_sectors - 1, 2) + 1) * constants.sector_size;
+                    assert(read.target_max >= constants.sector_size);
 
                     // Pass 0 for `bytes_read`, we want to retry the read with smaller `target_max`:
                     self.start_read(read, 0);
@@ -227,9 +227,9 @@ pub const Storage = struct {
         // then increase `target_max` according to AIMD now that we have read successfully and
         // hopefully cleared the faulty zone.
         // We assume that `target_max` may exceed `read.buffer.len` at any time.
-        if (read.target_max == config.sector_size) {
+        if (read.target_max == constants.sector_size) {
             // TODO Add log.debug because this is interesting.
-            read.target_max += config.sector_size;
+            read.target_max += constants.sector_size;
         }
 
         self.start_read(read, bytes_read);
@@ -319,9 +319,9 @@ pub const Storage = struct {
     /// 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(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);
+        assert(@ptrToInt(buffer.ptr) % constants.sector_size == 0);
+        assert(buffer.len % constants.sector_size == 0);
+        assert(offset % constants.sector_size == 0);
     }
 
     /// Ensures that the read or write is within bounds and intends to read or write some bytes.

package/src/tigerbeetle/src/test/accounting/auditor.zig

@@ -6,7 +6,7 @@ const std = @import("std");
 const assert = std.debug.assert;
 const log = std.log.scoped(.test_auditor);
 
-const config = @import("../../constants.zig");
+const constants = @import("../../constants.zig");
 const tb = @import("../../tigerbeetle.zig");
 const vsr = @import("../../vsr.zig");
 const RingBuffer = @import("../../ring_buffer.zig").RingBuffer;
@@ -16,7 +16,7 @@ const IdPermutation = @import("../id.zig").IdPermutation;
 const PriorityQueue = @import("../priority_queue.zig").PriorityQueue;
 const Storage = @import("../storage.zig").Storage;
 const StateMachine = @import("../../state_machine.zig").StateMachineType(Storage, .{
-    .message_body_size_max = config.message_body_size_max,
+    .message_body_size_max = constants.message_body_size_max,
 });
 
 pub const CreateAccountResultSet = std.enums.EnumSet(tb.CreateAccountResult);

package/src/tigerbeetle/src/test/accounting/workload.zig

@@ -21,7 +21,7 @@ const std = @import("std");
 const assert = std.debug.assert;
 const log = std.log.scoped(.test_workload);
 
-const config = @import("../../constants.zig");
+const constants = @import("../../constants.zig");
 const tb = @import("../../tigerbeetle.zig");
 const vsr = @import("../../vsr.zig");
 const accounting_auditor = @import("./auditor.zig");
@@ -266,7 +266,7 @@ pub fn WorkloadType(comptime AccountingStateMachine: type) type {
             var transfers_delivered_recently = TransferBatchQueue.init(allocator, {});
             errdefer transfers_delivered_recently.deinit();
             try transfers_delivered_recently.ensureTotalCapacity(
-                options.auditor_options.client_count * config.client_request_queue_max,
+                options.auditor_options.client_count * constants.client_request_queue_max,
             );
 
             for (auditor.accounts) |*account, i| {
@@ -308,7 +308,7 @@ pub fn WorkloadType(comptime AccountingStateMachine: type) type {
             size: usize,
         } {
             assert(client_index < self.auditor.options.client_count);
-            assert(body.len == config.message_size_max - @sizeOf(vsr.Header));
+            assert(body.len == constants.message_size_max - @sizeOf(vsr.Header));
 
             const action = action: {
                 if (!self.accounts_sent and self.random.boolean()) {
@@ -353,8 +353,8 @@ pub fn WorkloadType(comptime AccountingStateMachine: type) type {
             reply_body: []align(@alignOf(vsr.Header)) const u8,
         ) void {
             assert(timestamp != 0);
-            assert(request_body.len <= config.message_size_max - @sizeOf(vsr.Header));
-            assert(reply_body.len <= config.message_size_max - @sizeOf(vsr.Header));
+            assert(request_body.len <= constants.message_size_max - @sizeOf(vsr.Header));
+            assert(reply_body.len <= constants.message_size_max - @sizeOf(vsr.Header));
 
             switch (operation.cast(AccountingStateMachine)) {
                 .create_accounts => self.auditor.on_create_accounts(

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

@@ -2,7 +2,7 @@ const std = @import("std");
 const assert = std.debug.assert;
 const mem = std.mem;
 
-const config = @import("../constants.zig");
+const constants = @import("../constants.zig");
 
 const message_pool = @import("../message_pool.zig");
 const MessagePool = message_pool.MessagePool;
@@ -12,7 +12,7 @@ const Network = @import("network.zig").Network;
 const NetworkOptions = @import("network.zig").NetworkOptions;
 
 pub const StateMachine = @import("../state_machine.zig").StateMachineType(Storage, .{
-    .message_body_size_max = config.message_body_size_max,
+    .message_body_size_max = constants.message_body_size_max,
 });
 const MessageBus = @import("message_bus.zig").MessageBus;
 const Storage = @import("storage.zig").Storage;
@@ -77,7 +77,7 @@ pub const Cluster = struct {
         assert(options.replica_count > 0);
         assert(options.client_count > 0);
         assert(options.grid_size_max > 0);
-        assert(options.grid_size_max % config.sector_size == 0);
+        assert(options.grid_size_max % constants.sector_size == 0);
         assert(options.health_options.crash_probability < 1.0);
         assert(options.health_options.crash_probability >= 0.0);
         assert(options.health_options.restart_probability < 1.0);
@@ -123,10 +123,10 @@ pub const Cluster = struct {
             .network = network,
         };
 
-        var buffer: [config.replicas_max]Storage.FaultyAreas = undefined;
+        var buffer: [constants.replicas_max]Storage.FaultyAreas = undefined;
         const faulty_wal_areas = Storage.generate_faulty_wal_areas(
             prng,
-            config.journal_size_max,
+            constants.journal_size_max,
             options.replica_count,
             &buffer,
         );
@@ -138,7 +138,7 @@ pub const Cluster = struct {
             storage_options.faulty_wal_areas = faulty_wal_areas[replica_index];
             storage.* = try Storage.init(
                 allocator,
-                superblock_zone_size + config.journal_size_max + options.grid_size_max,
+                superblock_zone_size + constants.journal_size_max + options.grid_size_max,
                 storage_options,
             );
         }
@@ -161,7 +161,7 @@ pub const Cluster = struct {
 
         for (cluster.replicas) |_, replica_index| {
             try cluster.open_replica(@intCast(u8, replica_index), .{
-                .resolution = config.tick_ms * std.time.ns_per_ms,
+                .resolution = constants.tick_ms * std.time.ns_per_ms,
                 .offset_type = .linear,
                 .offset_coefficient_A = 0,
                 .offset_coefficient_B = 0,
@@ -238,7 +238,7 @@ pub const Cluster = struct {
 
             // This whole workaround doesn't handle log wrapping correctly.
             // If the log has wrapped, don't crash the replica.
-            if (cluster_op_max >= config.journal_slot_count) {
+            if (cluster_op_max >= constants.journal_slot_count) {
                 return false;
             }
 

package/src/tigerbeetle/src/test/conductor.zig

@@ -9,7 +9,7 @@ const log = std.log.scoped(.test_conductor);
 
 const vsr = @import("../vsr.zig");
 const util = @import("../util.zig");
-const config = @import("../constants.zig");
+const constants = @import("../constants.zig");
 const IdPermutation = @import("id.zig").IdPermutation;
 const MessagePool = @import("../message_pool.zig").MessagePool;
 const Message = MessagePool.Message;
@@ -47,7 +47,8 @@ pub fn ConductorType(
         ///
         /// `Conduction.stalled_queue` hold replies (and corresponding requests) that are
         /// waiting to be processed.
-        pub const stalled_queue_capacity = config.clients_max * config.client_request_queue_max * 2;
+        pub const stalled_queue_capacity =
+            constants.clients_max * constants.client_request_queue_max * 2;
 
         random: std.rand.Random,
         workload: *Workload,
@@ -225,7 +226,7 @@ pub fn ConductorType(
             var client = &self.clients[client_index];
 
             // Check for space in the client's own request queue.
-            if (client.request_queue.count + 1 > config.client_request_queue_max) return;
+            if (client.request_queue.count + 1 > constants.client_request_queue_max) return;
 
             var request_message = client.get_message();
             defer client.unref(request_message);
@@ -234,10 +235,10 @@ pub fn ConductorType(
                 client_index,
                 @alignCast(
                     @alignOf(vsr.Header),
-                    request_message.buffer[@sizeOf(vsr.Header)..config.message_size_max],
+                    request_message.buffer[@sizeOf(vsr.Header)..constants.message_size_max],
                 ),
             );
-            assert(request_metadata.size <= config.message_size_max - @sizeOf(vsr.Header));
+            assert(request_metadata.size <= constants.message_size_max - @sizeOf(vsr.Header));
 
             client.request(
                 0,

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

@@ -1,8 +1,6 @@
 const std = @import("std");
 const assert = std.debug.assert;
 
-const config = @import("../constants.zig");
-
 const MessagePool = @import("../message_pool.zig").MessagePool;
 const Message = MessagePool.Message;
 const Header = @import("../vsr.zig").Header;

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

@@ -3,7 +3,7 @@ const math = std.math;
 const mem = std.mem;
 const assert = std.debug.assert;
 
-const config = @import("../constants.zig");
+const constants = @import("../constants.zig");
 const vsr = @import("../vsr.zig");
 const util = @import("../util.zig");
 
@@ -115,7 +115,7 @@ pub const Network = struct {
         const raw_process = switch (process) {
             .replica => |replica| replica,
             .client => |client| blk: {
-                assert(client >= config.replicas_max);
+                assert(client >= constants.replicas_max);
                 break :blk client;
             },
         };
@@ -194,7 +194,7 @@ pub const Network = struct {
             const sector_ceil = vsr.sector_ceil(target_message.header.size);
             if (target_message.header.size != sector_ceil) {
                 assert(target_message.header.size < sector_ceil);
-                assert(target_message.buffer.len == config.message_size_max + config.sector_size);
+                assert(target_message.buffer.len == constants.message_size_max + constants.sector_size);
                 mem.set(u8, target_message.buffer[target_message.header.size..sector_ceil], 0);
             }
         }
@@ -204,9 +204,9 @@ pub const Network = struct {
 
     fn raw_process_to_process(raw: u128) Process {
         switch (raw) {
-            0...(config.replicas_max - 1) => return .{ .replica = @intCast(u8, raw) },
+            0...(constants.replicas_max - 1) => return .{ .replica = @intCast(u8, raw) },
             else => {
-                assert(raw >= config.replicas_max);
+                assert(raw >= constants.replicas_max);
                 return .{ .client = raw };
             },
         }

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

@@ -2,7 +2,7 @@ const std = @import("std");
 const assert = std.debug.assert;
 const mem = std.mem;
 
-const config = @import("../constants.zig");
+const constants = @import("../constants.zig");
 const vsr = @import("../vsr.zig");
 
 const Cluster = @import("cluster.zig").Cluster;
@@ -23,7 +23,7 @@ const log = std.log.scoped(.state_checker);
 
 pub const StateChecker = struct {
     /// Indexed by replica index.
-    replica_states: [config.replicas_max]u128 = [_]u128{0} ** config.replicas_max,
+    replica_states: [constants.replicas_max]u128 = [_]u128{0} ** constants.replicas_max,
 
     /// Keyed by committed `message.header.checksum`.
     ///