tigerbeetle-node 0.4.3 → 0.5.0

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

@@ -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/storage.zig

@@ -287,6 +287,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 +333,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/tigerbeetle.zig

@@ -249,7 +249,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,

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

@@ -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);
             }
 
@@ -363,7 +363,7 @@ pub fn Client(comptime StateMachine: type, comptime MessageBus: type) type {
         fn on_request_timeout(self: *Self) void {
             self.request_timeout.backoff(&self.prng);
 
-            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);
@@ -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);

package/src/tigerbeetle/src/vsr/replica.zig

@@ -1467,7 +1467,7 @@ pub fn Replica(
             assert(self.status == .normal);
             assert(self.leader());
 
-            const prepare = self.pipeline.peek_ptr().?;
+            const prepare = self.pipeline.head_ptr().?;
             assert(prepare.message.header.command == .prepare);
 
             if (prepare.ok_quorum_received) {
@@ -1925,7 +1925,7 @@ pub fn Replica(
             assert(self.leader());
             assert(self.pipeline.count > 0);
 
-            while (self.pipeline.peek_ptr()) |prepare| {
+            while (self.pipeline.head_ptr()) |prepare| {
                 assert(self.pipeline.count > 0);
                 assert(self.commit_min == self.commit_max);
                 assert(self.commit_max + self.pipeline.count == self.op);