tigerbeetle-node 0.11.8 → 0.11.10

package/src/tigerbeetle/src/{test → testing}/table.zig

@@ -66,6 +66,13 @@ fn parse_data(comptime Data: type, tokens: *std.mem.TokenIterator(u8)) Data {
             }
             return data;
         },
+        .Array => |info| {
+            var values: Data = undefined;
+            for (values[0..]) |*value| {
+                value.* = parse_data(info.child, tokens);
+            }
+            return values;
+        },
         .Union => |info| {
             const variant_string = tokens.next().?;
             inline for (info.fields) |variant_field| {
@@ -209,6 +216,20 @@ test "struct (nested)" {
     );
 }
 
+test "array" {
+    try test_parse(struct {
+        a: u32,
+        b: [2]u32,
+        c: u32,
+    }, &.{
+        .{ .a = 1, .b = .{ 2, 3 }, .c = 4 },
+        .{ .a = 5, .b = .{ 6, 7 }, .c = 8 },
+    },
+        \\ 1 2 3 4
+        \\ 5 6 7 8
+    );
+}
+
 test "union" {
     try test_parse(union(enum) {
         a: struct { b: u8, c: i8 },

package/src/tigerbeetle/src/tigerbeetle.zig

@@ -95,6 +95,7 @@ pub const CreateAccountResult = enum(u32) {
     ok,
     linked_event_failed,
     linked_event_chain_open,
+    timestamp_must_be_zero,
 
     reserved_flag,
     reserved_field,
@@ -121,6 +122,7 @@ pub const CreateTransferResult = enum(u32) {
     ok,
     linked_event_failed,
     linked_event_chain_open,
+    timestamp_must_be_zero,
 
     reserved_flag,
     reserved_field,

package/src/tigerbeetle/src/tracer.zig

@@ -61,7 +61,7 @@ const log = std.log.scoped(.tracer);
 
 const constants = @import("./constants.zig");
 const Time = @import("./time.zig").Time;
-const util = @import("util.zig");
+const stdx = @import("stdx.zig");
 
 /// All strings in Event must be comptime constants to ensure that they live until after `tracer.deinit` is called.
 pub const Event = union(enum) {
@@ -411,7 +411,7 @@ const TracerTracy = struct {
         c.___tracy_fiber_enter(event_group.name());
         const name = std.fmt.bufPrint(&print_buffer, "{}", .{event}) catch name: {
             const dots = "...";
-            util.copy_disjoint(.exact, u8, print_buffer[print_buffer.len - dots.len ..], dots);
+            stdx.copy_disjoint(.exact, u8, print_buffer[print_buffer.len - dots.len ..], dots);
             break :name &print_buffer;
         };
         // TODO The alloc_srcloc here is not free and should be unnecessary,
@@ -454,7 +454,7 @@ const TracerTracy = struct {
             args,
         ) catch message: {
             const dots = "...";
-            util.copy_disjoint(.exact, u8, print_buffer[print_buffer.len - dots.len ..], dots);
+            stdx.copy_disjoint(.exact, u8, print_buffer[print_buffer.len - dots.len ..], dots);
             break :message &print_buffer;
         };
         c.___tracy_fiber_enter((EventGroup{ .main = {} }).name());

package/src/tigerbeetle/src/unit_tests.zig

@@ -19,7 +19,7 @@ test {
 
     _ = @import("io.zig");
     _ = @import("ewah.zig");
-    _ = @import("util.zig");
+    _ = @import("stdx.zig");
 
     _ = @import("clients/c/test.zig");
     _ = @import("clients/c/tb_client_header_test.zig");
@@ -29,9 +29,9 @@ test {
     _ = @import("lsm/manifest_level.zig");
     _ = @import("lsm/segmented_array.zig");
 
-    _ = @import("test/id.zig");
-    _ = @import("test/storage.zig");
-    _ = @import("test/table.zig");
+    _ = @import("testing/id.zig");
+    _ = @import("testing/storage.zig");
+    _ = @import("testing/table.zig");
 
     _ = @import("clients/go/go_bindings_test.zig");
     _ = @import("clients/dotnet/dotnet_bindings_test.zig");

package/src/tigerbeetle/src/vopr.zig

@@ -8,7 +8,7 @@ const log = std.log;
 
 const simulator = @import("simulator.zig");
 const vsr = @import("vsr.zig");
-const util = @import("util.zig");
+const stdx = @import("stdx.zig");
 
 // TODO use DNS instead since hard-coding an IP address isn't ideal.
 const default_send_address = net.Address.initIp4([4]u8{ 65, 21, 207, 251 }, 5555);
@@ -375,7 +375,7 @@ fn create_report(allocator: mem.Allocator, bug: Bug, seed: u64) Report {
 
     var hash: [32]u8 = undefined;
     std.crypto.hash.sha2.Sha256.hash(std.mem.asBytes(&message)[@sizeOf(u128)..45], hash[0..], .{});
-    util.copy_disjoint(.exact, u8, message.checksum[0..], hash[0..message.checksum.len]);
+    stdx.copy_disjoint(.exact, u8, message.checksum[0..], hash[0..message.checksum.len]);
 
     return message;
 }

package/src/tigerbeetle/src/vsr/client.zig

@@ -87,7 +87,6 @@ pub fn Client(comptime StateMachine_: type, comptime MessageBus: type) type {
         on_reply_context: ?*anyopaque = null,
         /// Used for testing. Called for replies to all operations (including `register`).
         on_reply_callback: ?fn (
-            context: ?*anyopaque,
             client: *Self,
             request: *Message,
             reply: *Message,
@@ -194,6 +193,10 @@ pub fn Client(comptime StateMachine_: type, comptime MessageBus: type) type {
             message: *Message,
             message_body_size: usize,
         ) void {
+            assert(operation != .reserved);
+            assert(operation != .root);
+            assert(operation != .register);
+
             self.register();
             assert(self.request_number > 0);
 
@@ -367,7 +370,7 @@ pub fn Client(comptime StateMachine_: type, comptime MessageBus: type) type {
             }
 
             if (self.on_reply_callback) |on_reply_callback| {
-                on_reply_callback(self.on_reply_context, self, inflight.message, reply);
+                on_reply_callback(self, inflight.message, reply);
             }
 
             if (inflight.callback) |callback| {

package/src/tigerbeetle/src/vsr/clock.zig

@@ -453,33 +453,35 @@ pub fn Clock(comptime Time: type) type {
 }
 
 const testing = std.testing;
-const OffsetType = @import("../test/time.zig").OffsetType;
-const DeterministicTime = @import("../test/time.zig").Time;
+const OffsetType = @import("../testing/time.zig").OffsetType;
+const DeterministicTime = @import("../testing/time.zig").Time;
 const DeterministicClock = Clock(DeterministicTime);
 
 const ClockUnitTestContainer = struct {
     const Self = @This();
+    time: DeterministicTime,
     clock: DeterministicClock,
     rtt: u64 = 300 * std.time.ns_per_ms,
     owd: u64 = 150 * std.time.ns_per_ms,
     learn_interval: u64 = 5,
 
     pub fn init(
+        self: *Self,
         allocator: std.mem.Allocator,
         offset_type: OffsetType,
         offset_coefficient_A: i64,
         offset_coefficient_B: i64,
-    ) !Self {
-        const time: DeterministicTime = .{
-            .resolution = std.time.ns_per_s / 2,
-            .offset_type = offset_type,
-            .offset_coefficient_A = offset_coefficient_A,
-            .offset_coefficient_B = offset_coefficient_B,
-        };
-        const self: Self = .{
-            .clock = try DeterministicClock.init(allocator, 3, 0, time),
+    ) !void {
+        // TODO(Zig) Use @returnAddress() when available.
+        self.* = .{
+            .time = .{
+                .resolution = std.time.ns_per_s / 2,
+                .offset_type = offset_type,
+                .offset_coefficient_A = offset_coefficient_A,
+                .offset_coefficient_B = offset_coefficient_B,
+            },
+            .clock = try DeterministicClock.init(allocator, 3, 0, &self.time),
         };
-        return self;
     }
 
     pub fn run_till_tick(self: *Self, tick: u64) void {
@@ -567,9 +569,10 @@ test "ideal clocks get clamped to cluster time" {
     std.testing.log_level = .err;
     var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
     defer arena.deinit();
-    const allocator = &arena.allocator;
+    const allocator = arena.allocator();
 
-    var ideal_constant_drift_clock = try ClockUnitTestContainer.init(
+    var ideal_constant_drift_clock: ClockUnitTestContainer = undefined;
+    try ideal_constant_drift_clock.init(
         allocator,
         OffsetType.linear,
         std.time.ns_per_ms, // loses 1ms per tick
@@ -585,7 +588,8 @@ test "ideal clocks get clamped to cluster time" {
         );
     }
 
-    var ideal_periodic_drift_clock = try ClockUnitTestContainer.init(
+    var ideal_periodic_drift_clock: ClockUnitTestContainer = undefined;
+    try ideal_periodic_drift_clock.init(
         allocator,
         OffsetType.periodic,
         std.time.ns_per_s, // loses up to 1s
@@ -602,7 +606,8 @@ test "ideal clocks get clamped to cluster time" {
         );
     }
 
-    var ideal_jumping_clock = try ClockUnitTestContainer.init(
+    var ideal_jumping_clock: ClockUnitTestContainer = undefined;
+    try ideal_jumping_clock.init(
         allocator,
         OffsetType.step,
         -5 * std.time.ns_per_day, // jumps 5 days ahead.
@@ -619,9 +624,10 @@ test "ideal clocks get clamped to cluster time" {
     }
 }
 
-const PacketSimulatorOptions = @import("../test/packet_simulator.zig").PacketSimulatorOptions;
-const PacketSimulator = @import("../test/packet_simulator.zig").PacketSimulator;
-const Path = @import("../test/packet_simulator.zig").Path;
+const PacketSimulatorOptions = @import("../testing/packet_simulator.zig").PacketSimulatorOptions;
+const PacketSimulatorType = @import("../testing/packet_simulator.zig").PacketSimulatorType;
+const Path = @import("../testing/packet_simulator.zig").Path;
+const Command = @import("../vsr.zig").Command;
 const ClockSimulator = struct {
     const Packet = struct {
         m0: u64,
@@ -629,9 +635,8 @@ const ClockSimulator = struct {
         clock_simulator: *ClockSimulator,
 
         /// PacketSimulator requires this function, but we don't actually have anything to deinit.
-        pub fn deinit(packet: *const Packet, path: Path) void {
+        pub fn deinit(packet: *const Packet) void {
             _ = packet;
-            _ = path;
         }
     };
 
@@ -644,39 +649,62 @@ const ClockSimulator = struct {
     allocator: std.mem.Allocator,
     options: Options,
     ticks: u64 = 0,
-    network: PacketSimulator(Packet),
+    network: PacketSimulatorType(Packet),
+    times: []DeterministicTime,
     clocks: []DeterministicClock,
     prng: std.rand.DefaultPrng,
 
     pub fn init(allocator: std.mem.Allocator, options: Options) !ClockSimulator {
-        var self = ClockSimulator{
-            .allocator = allocator,
-            .options = options,
-            .network = try PacketSimulator(Packet).init(allocator, options.network_options),
-            .clocks = try allocator.alloc(DeterministicClock, options.clock_count),
-            .prng = std.rand.DefaultPrng.init(options.network_options.seed),
-        };
+        var network = try PacketSimulatorType(Packet).init(allocator, options.network_options);
+        errdefer network.deinit(allocator);
 
-        for (self.clocks) |*clock, index| {
-            clock.* = try self.create_clock(@intCast(u8, index));
-        }
+        var times = try allocator.alloc(DeterministicTime, options.clock_count);
+        errdefer allocator.free(times);
 
-        return self;
-    }
+        var clocks = try allocator.alloc(DeterministicClock, options.clock_count);
+        errdefer allocator.free(clocks);
+
+        var prng = std.rand.DefaultPrng.init(options.network_options.seed);
+
+        for (clocks) |*clock, replica| {
+            errdefer for (clocks[0..replica]) |*c| c.deinit(allocator);
+
+            const amplitude = prng.random().intRangeAtMost(i64, -10, 10) * std.time.ns_per_s;
+            const phase = prng.random().intRangeAtMost(i64, 100, 1000) +
+                @floatToInt(i64, prng.random().floatNorm(f64) * 50);
+            times[replica] = .{
+                .resolution = std.time.ns_per_s / 2, // delta_t = 0.5s
+                .offset_type = OffsetType.non_ideal,
+                .offset_coefficient_A = amplitude,
+                .offset_coefficient_B = phase,
+                .offset_coefficient_C = 10,
+            };
 
-    fn create_clock(self: *ClockSimulator, replica: u8) !DeterministicClock {
-        const amplitude = self.prng.random.intRangeAtMost(i64, -10, 10) * std.time.ns_per_s;
-        const phase = self.prng.random.intRangeAtMost(i64, 100, 1000) +
-            @floatToInt(i64, self.prng.random.floatNorm(f64) * 50);
-        const time: DeterministicTime = .{
-            .resolution = std.time.ns_per_s / 2, // delta_t = 0.5s
-            .offset_type = OffsetType.non_ideal,
-            .offset_coefficient_A = amplitude,
-            .offset_coefficient_B = phase,
-            .offset_coefficient_C = 10,
+            clock.* = try DeterministicClock.init(
+                allocator,
+                options.clock_count,
+                @intCast(u8, replica),
+                &times[replica],
+            );
+            errdefer clock.deinit(allocator);
+        }
+        errdefer for (clocks) |*clock| clock.deinit(allocator);
+
+        return ClockSimulator{
+            .allocator = allocator,
+            .options = options,
+            .network = network,
+            .times = times,
+            .clocks = clocks,
+            .prng = prng,
         };
+    }
 
-        return try DeterministicClock.init(self.allocator, self.options.clock_count, replica, time);
+    pub fn deinit(self: *ClockSimulator) void {
+        for (self.clocks) |*clock| clock.deinit(self.allocator);
+        self.allocator.free(self.clocks);
+        self.allocator.free(self.times);
+        self.network.deinit(self.allocator);
     }
 
     pub fn tick(self: *ClockSimulator) void {
@@ -738,24 +766,29 @@ const ClockSimulator = struct {
     }
 };
 
-test "fuzz test" {
+test "clock: fuzz test" {
     std.testing.log_level = .err; // silence all clock logs
-    var arena_allocator = std.heap.ArenaAllocator.init(std.heap.page_allocator);
-    defer arena_allocator.deinit();
-    const allocator = &arena_allocator.allocator;
+
     const ticks_max: u64 = 1_000_000;
     const clock_count: u8 = 3;
-    const SystemTime = @import("../test/time.zig").Time;
-    var system_time = SystemTime{};
+    const SystemTime = @import("../testing/time.zig").Time;
+    var system_time = SystemTime{
+        .resolution = constants.tick_ms * std.time.ns_per_ms,
+        .offset_type = .linear,
+        .offset_coefficient_A = 0,
+        .offset_coefficient_B = 0,
+    };
     var seed = @intCast(u64, system_time.realtime());
     var min_sync_error: u64 = 1_000_000_000;
     var max_sync_error: u64 = 0;
     var max_clock_offset: u64 = 0;
     var min_clock_offset: u64 = 1_000_000_000;
-    var simulator = try ClockSimulator.init(allocator, .{
+    var simulator = try ClockSimulator.init(std.testing.allocator, .{
         .network_options = .{
-            .node_count = clock_count,
+            .replica_count = 3,
+            .client_count = 0,
             .seed = seed,
+
             .one_way_delay_mean = 25,
             .one_way_delay_min = 10,
             .packet_loss_probability = 10,
@@ -763,10 +796,17 @@ test "fuzz test" {
             .path_clog_duration_mean = 200,
             .path_clog_probability = 2,
             .packet_replay_probability = 2,
+
+            .partition_mode = .isolate_single,
+            .partition_probability = 25,
+            .unpartition_probability = 5,
+            .partition_stability = 100,
+            .unpartition_stability = 10,
         },
         .clock_count = clock_count,
         .ping_timeout = 20,
     });
+    defer simulator.deinit();
 
     var clock_ticks_without_synchronization = [_]u32{0} ** clock_count;
     while (simulator.ticks < ticks_max) {