tigerbeetle-node 0.4.2 → 0.5.2

package/src/tigerbeetle/src/test/storage.zig

@@ -55,8 +55,10 @@ pub const Storage = struct {
         /// Tick at which this read is considered "completed" and the callback should be called.
         done_at_tick: u64,
 
-        fn less_than(storage: *Read, other: *Read) math.Order {
-            return math.order(storage.done_at_tick, other.done_at_tick);
+        fn less_than(context: void, a: *Read, b: *Read) math.Order {
+            _ = context;
+
+            return math.order(a.done_at_tick, b.done_at_tick);
         }
     };
 
@@ -67,8 +69,10 @@ pub const Storage = struct {
         /// Tick at which this write is considered "completed" and the callback should be called.
         done_at_tick: u64,
 
-        fn less_than(storage: *Write, other: *Write) math.Order {
-            return math.order(storage.done_at_tick, other.done_at_tick);
+        fn less_than(context: void, a: *Write, b: *Write) math.Order {
+            _ = context;
+
+            return math.order(a.done_at_tick, b.done_at_tick);
         }
     };
 
@@ -92,13 +96,13 @@ pub const Storage = struct {
     // allow faults in certian areas which differ between replicas.
     faulty_areas: FaultyAreas,
 
-    reads: std.PriorityQueue(*Storage.Read),
-    writes: std.PriorityQueue(*Storage.Write),
+    reads: std.PriorityQueue(*Storage.Read, void, Storage.Read.less_than),
+    writes: std.PriorityQueue(*Storage.Write, void, Storage.Write.less_than),
 
     ticks: u64 = 0,
 
     pub fn init(
-        allocator: *mem.Allocator,
+        allocator: mem.Allocator,
         size: u64,
         options: Storage.Options,
         replica_index: u8,
@@ -112,13 +116,13 @@ pub const Storage = struct {
         // TODO: random data
         mem.set(u8, memory, 0);
 
-        var reads = std.PriorityQueue(*Storage.Read).init(allocator, Storage.Read.less_than);
+        var reads = std.PriorityQueue(*Storage.Read, void, Storage.Read.less_than).init(allocator, {});
         errdefer reads.deinit();
-        try reads.ensureCapacity(config.io_depth_read);
+        try reads.ensureTotalCapacity(config.io_depth_read);
 
-        var writes = std.PriorityQueue(*Storage.Write).init(allocator, Storage.Write.less_than);
+        var writes = std.PriorityQueue(*Storage.Write, void, Storage.Write.less_than).init(allocator, {});
         errdefer writes.deinit();
-        try writes.ensureCapacity(config.io_depth_write);
+        try writes.ensureTotalCapacity(config.io_depth_write);
 
         return Storage{
             .memory = memory,
@@ -138,7 +142,7 @@ pub const Storage = struct {
         storage.writes.len = 0;
     }
 
-    pub fn deinit(storage: *Storage, allocator: *mem.Allocator) void {
+    pub fn deinit(storage: *Storage, allocator: mem.Allocator) void {
         allocator.free(storage.memory);
         storage.reads.deinit();
         storage.writes.deinit();
@@ -186,7 +190,7 @@ pub const Storage = struct {
             // Randomly corrupt one of the faulty sectors the read targeted
             // TODO: inject more realistic and varied storage faults as described above.
             const sector_count = @divExact(faulty.len, config.sector_size);
-            const faulty_sector = storage.prng.random.uintLessThan(u64, sector_count);
+            const faulty_sector = storage.prng.random().uintLessThan(u64, sector_count);
             const faulty_sector_offset = faulty_sector * config.sector_size;
             const faulty_sector_bytes = faulty[faulty_sector_offset..][0..config.sector_size];
 
@@ -195,7 +199,7 @@ pub const Storage = struct {
                 storage.replica_index,
             });
 
-            storage.prng.random.bytes(faulty_sector_bytes);
+            storage.prng.random().bytes(faulty_sector_bytes);
         }
 
         mem.copy(u8, read.buffer, storage.memory[read.offset..][0..read.buffer.len]);
@@ -230,7 +234,7 @@ pub const Storage = struct {
             // Randomly corrupt one of the faulty sectors the write targeted
             // TODO: inject more realistic and varied storage faults as described above.
             const sector_count = @divExact(faulty.len, config.sector_size);
-            const faulty_sector = storage.prng.random.uintLessThan(u64, sector_count);
+            const faulty_sector = storage.prng.random().uintLessThan(u64, sector_count);
             const faulty_sector_offset = faulty_sector * config.sector_size;
             const faulty_sector_bytes = faulty[faulty_sector_offset..][0..config.sector_size];
 
@@ -239,7 +243,7 @@ pub const Storage = struct {
                 storage.replica_index,
             });
 
-            storage.prng.random.bytes(faulty_sector_bytes);
+            storage.prng.random().bytes(faulty_sector_bytes);
         }
 
         write.callback(write);
@@ -265,18 +269,18 @@ pub const Storage = struct {
     }
 
     fn latency(storage: *Storage, min: u64, mean: u64) u64 {
-        return min + @floatToInt(u64, @intToFloat(f64, mean - min) * storage.prng.random.floatExp(f64));
+        return min + @floatToInt(u64, @intToFloat(f64, mean - min) * storage.prng.random().floatExp(f64));
     }
 
     /// Return true with probability x/100.
     fn x_in_100(storage: *Storage, x: u8) bool {
         assert(x <= 100);
-        return x > storage.prng.random.uintLessThan(u8, 100);
+        return x > storage.prng.random().uintLessThan(u8, 100);
     }
 
     /// The return value is a slice into the provided out array.
     pub fn generate_faulty_areas(
-        prng: *std.rand.Random,
+        prng: std.rand.Random,
         size: u64,
         replica_count: u8,
         out: *[config.replicas_max]FaultyAreas,
@@ -287,6 +291,7 @@ pub const Storage = struct {
         // We need to ensure there is message_size_max fault-free padding
         // between faulty areas of memory so that a single message
         // cannot straddle the corruptable areas of a majority of replicas.
+        comptime assert(config.replicas_max == 6);
         switch (replica_count) {
             1 => {
                 // If there is only one replica in the cluster, storage faults are not recoverable.
@@ -332,6 +337,21 @@ pub const Storage = struct {
                 out[3] = .{ .first_offset = 2 * message_size_max, .period = 6 * message_size_max };
                 out[4] = .{ .first_offset = 4 * message_size_max, .period = 6 * message_size_max };
             },
+            6 => {
+                //  0123456789
+                // 0X     X
+                // 1X     X
+                // 2  X     X
+                // 3  X     X
+                // 4    X     X
+                // 5    X     X
+                out[0] = .{ .first_offset = 0 * message_size_max, .period = 6 * message_size_max };
+                out[1] = .{ .first_offset = 0 * message_size_max, .period = 6 * message_size_max };
+                out[2] = .{ .first_offset = 2 * message_size_max, .period = 6 * message_size_max };
+                out[3] = .{ .first_offset = 2 * message_size_max, .period = 6 * message_size_max };
+                out[4] = .{ .first_offset = 4 * message_size_max, .period = 6 * message_size_max };
+                out[5] = .{ .first_offset = 4 * message_size_max, .period = 6 * message_size_max };
+            },
             else => unreachable,
         }
 

package/src/tigerbeetle/src/test/time.zig

@@ -65,11 +65,11 @@ pub const Time = struct {
             },
             .non_ideal => {
                 const phase: f64 = @intToFloat(f64, ticks) * 2 * std.math.pi /
-                    (@intToFloat(f64, self.offset_coefficient_B) + self.prng.random.floatNorm(f64) * 10);
+                    (@intToFloat(f64, self.offset_coefficient_B) + self.prng.random().floatNorm(f64) * 10);
                 const unscaled = std.math.sin(phase);
                 const scaled = @intToFloat(f64, self.offset_coefficient_A) * unscaled;
                 return @floatToInt(i64, std.math.floor(scaled)) +
-                    self.prng.random.intRangeAtMost(
+                    self.prng.random().intRangeAtMost(
                     i64,
                     -@intCast(i64, self.offset_coefficient_C),
                     self.offset_coefficient_C,

package/src/tigerbeetle/src/tigerbeetle.zig

@@ -1,4 +1,5 @@
 const std = @import("std");
+const builtin = @import("builtin");
 const assert = std.debug.assert;
 
 pub const config = @import("config.zig");
@@ -32,24 +33,6 @@ pub const Account = packed struct {
         return (self.flags.credits_must_not_exceed_debits and
             self.credits_reserved + self.credits_accepted + amount > self.debits_accepted);
     }
-
-    pub fn jsonStringify(self: Account, options: std.json.StringifyOptions, writer: anytype) !void {
-        try writer.writeAll("{");
-        try std.fmt.format(writer, "\"id\":{},", .{self.id});
-        try std.fmt.format(writer, "\"user_data\":\"{x:0>32}\",", .{self.user_data});
-        try std.fmt.format(writer, "\"reserved\":\"{x:0>48}\",", .{self.reserved});
-        try std.fmt.format(writer, "\"unit\":{},", .{self.unit});
-        try std.fmt.format(writer, "\"code\":{},", .{self.code});
-        try writer.writeAll("\"flags\":");
-        try std.json.stringify(self.flags, .{}, writer);
-        try writer.writeAll(",");
-        try std.fmt.format(writer, "\"debits_reserved\":{},", .{self.debits_reserved});
-        try std.fmt.format(writer, "\"debits_accepted\":{},", .{self.debits_accepted});
-        try std.fmt.format(writer, "\"credits_reserved\":{},", .{self.credits_reserved});
-        try std.fmt.format(writer, "\"credits_accepted\":{},", .{self.credits_accepted});
-        try std.fmt.format(writer, "\"timestamp\":\"{}\"", .{self.timestamp});
-        try writer.writeAll("}");
-    }
 };
 
 pub const AccountFlags = packed struct {
@@ -71,14 +54,6 @@ pub const AccountFlags = packed struct {
     comptime {
         assert(@sizeOf(AccountFlags) == @sizeOf(u32));
     }
-
-    pub fn jsonStringify(
-        self: AccountFlags,
-        options: std.json.StringifyOptions,
-        writer: anytype,
-    ) !void {
-        try writer.writeAll("{}");
-    }
 };
 
 pub const Transfer = packed struct {
@@ -99,27 +74,6 @@ pub const Transfer = packed struct {
     comptime {
         assert(@sizeOf(Transfer) == 128);
     }
-
-    pub fn jsonStringify(
-        self: Transfer,
-        options: std.json.StringifyOptions,
-        writer: anytype,
-    ) !void {
-        try writer.writeAll("{");
-        try std.fmt.format(writer, "\"id\":{},", .{self.id});
-        try std.fmt.format(writer, "\"debit_account_id\":{},", .{self.debit_account_id});
-        try std.fmt.format(writer, "\"credit_account_id\":{},", .{self.credit_account_id});
-        try std.fmt.format(writer, "\"user_data\":\"{x:0>32}\",", .{self.user_data});
-        try std.fmt.format(writer, "\"reserved\":\"{x:0>64}\",", .{self.reserved});
-        try std.fmt.format(writer, "\"code\":{},", .{self.code});
-        try writer.writeAll("\"flags\":");
-        try std.json.stringify(self.flags, .{}, writer);
-        try writer.writeAll(",");
-        try std.fmt.format(writer, "\"amount\":{},", .{self.amount});
-        try std.fmt.format(writer, "\"timeout\":{},", .{self.timeout});
-        try std.fmt.format(writer, "\"timestamp\":{}", .{self.timestamp});
-        try writer.writeAll("}");
-    }
 };
 
 pub const TransferFlags = packed struct {
@@ -131,19 +85,6 @@ pub const TransferFlags = packed struct {
     comptime {
         assert(@sizeOf(TransferFlags) == @sizeOf(u32));
     }
-
-    pub fn jsonStringify(
-        self: TransferFlags,
-        options: std.json.StringifyOptions,
-        writer: anytype,
-    ) !void {
-        try writer.writeAll("{");
-        try std.fmt.format(writer, "\"accept\":{},", .{self.accept});
-        try std.fmt.format(writer, "\"reject\":{},", .{self.reject});
-        try std.fmt.format(writer, "\"auto_commit\":{},", .{self.auto_commit});
-        try std.fmt.format(writer, "\"condition\":{}", .{self.condition});
-        try writer.writeAll("}");
-    }
 };
 
 pub const Commit = packed struct {
@@ -158,22 +99,6 @@ pub const Commit = packed struct {
     comptime {
         assert(@sizeOf(Commit) == 64);
     }
-
-    pub fn jsonStringify(
-        self: Commit,
-        options: std.json.StringifyOptions,
-        writer: anytype,
-    ) !void {
-        try writer.writeAll("{");
-        try std.fmt.format(writer, "\"id\":{},", .{self.id});
-        try std.fmt.format(writer, "\"reserved\":\"{x:0>64}\",", .{self.reserved});
-        try std.fmt.format(writer, "\"code\":{},", .{self.code});
-        try writer.writeAll("\"flags\":");
-        try std.json.stringify(self.flags, .{}, writer);
-        try writer.writeAll(",");
-        try std.fmt.format(writer, "\"timestamp\":{}", .{self.timestamp});
-        try writer.writeAll("}");
-    }
 };
 
 pub const CommitFlags = packed struct {
@@ -185,21 +110,9 @@ pub const CommitFlags = packed struct {
     comptime {
         assert(@sizeOf(CommitFlags) == @sizeOf(u32));
     }
-
-    pub fn jsonStringify(
-        self: CommitFlags,
-        options: std.json.StringifyOptions,
-        writer: anytype,
-    ) !void {
-        try writer.writeAll("{");
-        try std.fmt.format(writer, "\"accept\":{},", .{self.accept});
-        try std.fmt.format(writer, "\"reject\":{},", .{self.reject});
-        try std.fmt.format(writer, "\"preimage\":{}", .{self.preimage});
-        try writer.writeAll("}");
-    }
 };
 
-pub const CreateAccountResult = packed enum(u32) {
+pub const CreateAccountResult = enum(u32) {
     ok,
     linked_event_failed,
     exists,
@@ -214,7 +127,7 @@ pub const CreateAccountResult = packed enum(u32) {
     reserved_flag_padding,
 };
 
-pub const CreateTransferResult = packed enum(u32) {
+pub const CreateTransferResult = enum(u32) {
     ok,
     linked_event_failed,
     exists,
@@ -241,7 +154,7 @@ pub const CreateTransferResult = packed enum(u32) {
     timeout_reserved_for_two_phase_commit,
 };
 
-pub const CommitTransferResult = packed enum(u32) {
+pub const CommitTransferResult = enum(u32) {
     ok,
     linked_event_failed,
     reserved_field,
@@ -249,7 +162,6 @@ pub const CommitTransferResult = packed enum(u32) {
     transfer_not_found,
     transfer_not_two_phase_commit,
     transfer_expired,
-    already_auto_committed,
     already_committed,
     already_committed_but_accepted,
     already_committed_but_rejected,
@@ -271,17 +183,6 @@ pub const CreateAccountsResult = packed struct {
     comptime {
         assert(@sizeOf(CreateAccountsResult) == 8);
     }
-
-    pub fn jsonStringify(
-        self: CreateAccountResults,
-        options: std.json.StringifyOptions,
-        writer: anytype,
-    ) !void {
-        try writer.writeAll("{");
-        try std.fmt.format(writer, "\"index\":{},", .{self.index});
-        try std.fmt.format(writer, "\"result\":\"{}\"", .{@tagName(self.result)});
-        try writer.writeAll("}");
-    }
 };
 
 pub const CreateTransfersResult = packed struct {
@@ -291,17 +192,6 @@ pub const CreateTransfersResult = packed struct {
     comptime {
         assert(@sizeOf(CreateTransfersResult) == 8);
     }
-
-    pub fn jsonStringify(
-        self: CreateTransferResults,
-        options: std.json.StringifyOptions,
-        writer: anytype,
-    ) !void {
-        try writer.writeAll("{");
-        try std.fmt.format(writer, "\"index\":{},", .{self.index});
-        try std.fmt.format(writer, "\"result\":\"{}\"", .{@tagName(self.result)});
-        try writer.writeAll("}");
-    }
 };
 
 pub const CommitTransfersResult = packed struct {
@@ -311,28 +201,15 @@ pub const CommitTransfersResult = packed struct {
     comptime {
         assert(@sizeOf(CommitTransfersResult) == 8);
     }
-
-    pub fn jsonStringify(
-        self: CommitTransferResults,
-        options: std.json.StringifyOptions,
-        writer: anytype,
-    ) !void {
-        try writer.writeAll("{");
-        try std.fmt.format(writer, "\"index\":{},", .{self.index});
-        try std.fmt.format(writer, "\"result\":\"{}\"", .{@tagName(self.result)});
-        try writer.writeAll("}");
-    }
 };
 
 comptime {
-    const target = std.Target.current;
-
-    if (target.os.tag != .linux and !target.isDarwin()) {
+    if (builtin.target.os.tag != .linux and !builtin.target.isDarwin()) {
         @compileError("linux or macos required for io");
     }
 
     // We require little-endian architectures everywhere for efficient network deserialization:
-    if (target.cpu.arch.endian() != std.builtin.Endian.Little) {
+    if (builtin.target.cpu.arch.endian() != .Little) {
         @compileError("big-endian systems not supported");
     }
 }

package/src/tigerbeetle/src/time.zig

@@ -1,6 +1,7 @@
 const std = @import("std");
+const builtin = @import("builtin");
 const assert = std.debug.assert;
-const is_darwin = std.Target.current.isDarwin();
+const is_darwin = builtin.target.isDarwin();
 const config = @import("./config.zig");
 
 pub const Time = struct {
@@ -40,7 +41,7 @@ pub const Time = struct {
             // For more detail and why CLOCK_MONOTONIC_RAW is even worse than CLOCK_MONOTONIC,
             // see https://github.com/ziglang/zig/pull/933#discussion_r656021295.
             var ts: std.os.timespec = undefined;
-            std.os.clock_gettime(std.os.CLOCK_BOOTTIME, &ts) catch @panic("CLOCK_BOOTTIME required");
+            std.os.clock_gettime(std.os.CLOCK.BOOTTIME, &ts) catch @panic("CLOCK_BOOTTIME required");
             break :blk @intCast(u64, ts.tv_sec) * std.time.ns_per_s + @intCast(u64, ts.tv_nsec);
         };
 
@@ -52,14 +53,14 @@ pub const Time = struct {
 
     /// A timestamp to measure real (i.e. wall clock) time, meaningful across systems, and reboots.
     /// This clock is affected by discontinuous jumps in the system time.
-    pub fn realtime(self: *Self) i64 {
+    pub fn realtime(_: *Self) i64 {
         // macos has supported clock_gettime() since 10.12:
         // https://opensource.apple.com/source/Libc/Libc-1158.1.2/gen/clock_gettime.3.auto.html
 
         var ts: std.os.timespec = undefined;
-        std.os.clock_gettime(std.os.CLOCK_REALTIME, &ts) catch unreachable;
+        std.os.clock_gettime(std.os.CLOCK.REALTIME, &ts) catch unreachable;
         return @as(i64, ts.tv_sec) * std.time.ns_per_s + ts.tv_nsec;
     }
 
-    pub fn tick(self: *Self) void {}
+    pub fn tick(_: *Self) void {}
 };

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

@@ -30,7 +30,7 @@ pub fn Client(comptime StateMachine: type, comptime MessageBus: type) type {
             message: *Message,
         };
 
-        allocator: *mem.Allocator,
+        allocator: mem.Allocator,
         message_bus: *MessageBus,
 
         /// A universally unique identifier for the client (must not be zero).
@@ -82,7 +82,7 @@ pub fn Client(comptime StateMachine: type, comptime MessageBus: type) type {
         prng: std.rand.DefaultPrng,
 
         pub fn init(
-            allocator: *mem.Allocator,
+            allocator: mem.Allocator,
             id: u128,
             cluster: u32,
             replica_count: u8,
@@ -115,7 +115,7 @@ pub fn Client(comptime StateMachine: type, comptime MessageBus: type) type {
             return self;
         }
 
-        pub fn deinit(self: *Self) void {}
+        pub fn deinit(_: *Self) void {}
 
         pub fn on_message(self: *Self, message: *Message) void {
             log.debug("{}: on_message: {}", .{ self.id, message.header });
@@ -238,7 +238,7 @@ pub fn Client(comptime StateMachine: type, comptime MessageBus: type) type {
             assert(eviction.header.client == self.id);
             assert(eviction.header.view >= self.view);
 
-            log.emerg("{}: session evicted: too many concurrent client sessions", .{self.id});
+            log.err("{}: session evicted: too many concurrent client sessions", .{self.id});
             @panic("session evicted: too many concurrent client sessions");
         }
 
@@ -279,7 +279,7 @@ pub fn Client(comptime StateMachine: type, comptime MessageBus: type) type {
                 return;
             }
 
-            if (self.request_queue.peek_ptr()) |inflight| {
+            if (self.request_queue.head_ptr()) |inflight| {
                 if (reply.header.request < inflight.message.header.request) {
                     log.debug("{}: on_reply: ignoring (request {} < {})", .{
                         self.id,
@@ -334,7 +334,7 @@ pub fn Client(comptime StateMachine: type, comptime MessageBus: type) type {
 
             // We must process the next request before releasing control back to the callback.
             // Otherwise, requests may run through send_request_for_the_first_time() more than once.
-            if (self.request_queue.peek_ptr()) |next_request| {
+            if (self.request_queue.head_ptr()) |next_request| {
                 self.send_request_for_the_first_time(next_request.message);
             }
 
@@ -361,9 +361,9 @@ pub fn Client(comptime StateMachine: type, comptime MessageBus: type) type {
         }
 
         fn on_request_timeout(self: *Self) void {
-            self.request_timeout.backoff(&self.prng);
+            self.request_timeout.backoff(self.prng.random());
 
-            const message = self.request_queue.peek_ptr().?.message;
+            const message = self.request_queue.head_ptr().?.message;
             assert(message.header.command == .request);
             assert(message.header.request < self.request_number);
             assert(message.header.checksum == self.parent);
@@ -435,7 +435,7 @@ pub fn Client(comptime StateMachine: type, comptime MessageBus: type) type {
 
         fn send_header_to_replica(self: *Self, replica: u8, header: Header) void {
             const message = self.create_message_from_header(header) orelse {
-                log.alert("{}: no header-only message available, dropping message to replica {}", .{
+                log.err("{}: no header-only message available, dropping message to replica {}", .{
                     self.id,
                     replica,
                 });
@@ -448,7 +448,7 @@ pub fn Client(comptime StateMachine: type, comptime MessageBus: type) type {
 
         fn send_header_to_replicas(self: *Self, header: Header) void {
             const message = self.create_message_from_header(header) orelse {
-                log.alert("{}: no header-only message available, dropping message to replicas", .{
+                log.err("{}: no header-only message available, dropping message to replicas", .{
                     self.id,
                 });
                 return;
@@ -478,7 +478,7 @@ pub fn Client(comptime StateMachine: type, comptime MessageBus: type) type {
         }
 
         fn send_request_for_the_first_time(self: *Self, message: *Message) void {
-            assert(self.request_queue.peek_ptr().?.message == message);
+            assert(self.request_queue.head_ptr().?.message == message);
 
             assert(message.header.command == .request);
             assert(message.header.parent == 0);