tigerbeetle-node 0.11.3 → 0.11.5

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("config.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("../../config.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("../../config.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("../config.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("../config.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/fuzz.zig

@@ -64,14 +64,18 @@ pub fn random_enum(
 
 pub const FuzzArgs = struct {
     seed: u64,
+    events_max: ?usize,
 };
 
 /// Parse common command-line arguments to fuzzers:
 ///
 ///    [--seed u64]
 ///        Sets the seed used for the random number generator.
+///    [--events-max usize]
+///        Override the fuzzer's default maximum number of generated events.
 pub fn parse_fuzz_args(allocator: mem.Allocator) !FuzzArgs {
     var seed: ?u64 = null;
+    var events_max: ?usize = null;
 
     var args = std.process.args();
 
@@ -96,6 +100,20 @@ pub fn parse_fuzz_args(allocator: mem.Allocator) !FuzzArgs {
                 "Could not parse \"{}\" as an integer seed: {}",
                 .{ std.zig.fmtEscapes(seed_string), err },
             );
+        } else if (std.mem.eql(u8, arg, "--events-max")) {
+            const events_string_or_err = args.next(allocator) orelse
+                std.debug.panic("Expected an argument to --events-max", .{});
+            const events_string = try events_string_or_err;
+            defer allocator.free(events_string);
+
+            if (events_max != null) {
+                std.debug.panic("Received more than one \"--events-max\"", .{});
+            }
+            events_max = std.fmt.parseInt(usize, events_string, 10) catch |err|
+                std.debug.panic(
+                "Could not parse \"{}\" as an integer events-max: {}",
+                .{ std.zig.fmtEscapes(events_string), err },
+            );
         } else {
             // When run with `--test-cmd`,
             // `zig run` also passes the location of the zig binary as an extra arg.
@@ -117,5 +135,6 @@ pub fn parse_fuzz_args(allocator: mem.Allocator) !FuzzArgs {
 
     return FuzzArgs{
         .seed = seed.?,
+        .events_max = events_max,
     };
 }

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

@@ -1,8 +1,6 @@
 const std = @import("std");
 const assert = std.debug.assert;
 
-const config = @import("../config.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("../config.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("../config.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`.
     ///