tigerbeetle-node 0.11.4 → 0.11.6

package/src/tigerbeetle/src/unit_tests.zig

@@ -11,6 +11,8 @@ test {
     //_ = @import("vsr/clock.zig");
 
     _ = @import("state_machine.zig");
+    _ = @import("state_machine/auditor.zig");
+    _ = @import("state_machine/workload.zig");
 
     _ = @import("fifo.zig");
     _ = @import("ring_buffer.zig");
@@ -30,8 +32,6 @@ test {
     _ = @import("lsm/segmented_array.zig");
 
     _ = @import("test/id.zig");
-    _ = @import("test/accounting/auditor.zig");
-    _ = @import("test/accounting/workload.zig");
     _ = @import("test/storage.zig");
     _ = @import("test/table.zig");
 }

package/src/tigerbeetle/src/vsr/client.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 Header = vsr.Header;
 
@@ -64,19 +64,19 @@ pub fn Client(comptime StateMachine_: type, comptime MessageBus: type) type {
         request_number: u32 = 0,
 
         /// The highest view number seen by the client in messages exchanged with the cluster.
-        /// Used to locate the current leader, and provide more information to a partitioned leader.
+        /// Used to locate the current primary, and provide more information to a partitioned primary.
         view: u32 = 0,
 
         /// A client is allowed at most one inflight request at a time at the protocol layer.
         /// We therefore queue any further concurrent requests made by the application layer.
-        request_queue: RingBuffer(Request, config.client_request_queue_max, .array) = .{},
+        request_queue: RingBuffer(Request, constants.client_request_queue_max, .array) = .{},
 
         /// The number of ticks without a reply before the client resends the inflight request.
         /// Dynamically adjusted as a function of recent request round-trip time.
         request_timeout: vsr.Timeout,
 
         /// The number of ticks before the client broadcasts a ping to the cluster.
-        /// Used for end-to-end keepalive, and to discover a new leader between requests.
+        /// Used for end-to-end keepalive, and to discover a new primary between requests.
         ping_timeout: vsr.Timeout,
 
         /// Used to calculate exponential backoff with random jitter.
@@ -122,12 +122,12 @@ pub fn Client(comptime StateMachine_: type, comptime MessageBus: type) type {
                 .request_timeout = .{
                     .name = "request_timeout",
                     .id = id,
-                    .after = config.rtt_ticks * config.rtt_multiple,
+                    .after = constants.rtt_ticks * constants.rtt_multiple,
                 },
                 .ping_timeout = .{
                     .name = "ping_timeout",
                     .id = id,
-                    .after = 30000 / config.tick_ms,
+                    .after = 30000 / constants.tick_ms,
                 },
                 .prng = std.rand.DefaultPrng.init(@truncate(u64, id)),
             };
@@ -407,7 +407,7 @@ pub fn Client(comptime StateMachine_: type, comptime MessageBus: type) type {
                 message.header.checksum,
             });
 
-            // We assume the leader is down and round-robin through the cluster:
+            // We assume the primary is down and round-robin through the cluster:
             self.send_message_to_replica(
                 @intCast(u8, (self.view + self.request_timeout.attempts) % self.replica_count),
                 message,
@@ -503,7 +503,7 @@ pub fn Client(comptime StateMachine_: type, comptime MessageBus: type) type {
             assert(message.header.context == 0);
             assert(message.header.request < self.request_number);
             assert(message.header.view == 0);
-            assert(message.header.size <= config.message_size_max);
+            assert(message.header.size <= constants.message_size_max);
 
             // We set the message checksums only when sending the request for the first time,
             // which is when we have the checksum of the latest reply available to set as `parent`,
@@ -529,8 +529,8 @@ pub fn Client(comptime StateMachine_: type, comptime MessageBus: type) type {
             assert(!self.request_timeout.ticking);
             self.request_timeout.start();
 
-            // If our view number is out of date, then the old leader will forward our request.
-            // If the leader is offline, then our request timeout will fire and we will round-robin.
+            // If our view number is out of date, then the old primary will forward our request.
+            // If the primary is offline, then our request timeout will fire and we will round-robin.
             self.send_message_to_replica(@intCast(u8, self.view % self.replica_count), message);
         }
     };

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

@@ -3,12 +3,12 @@ const assert = std.debug.assert;
 const log = std.log.scoped(.clock);
 const fmt = std.fmt;
 
-const config = @import("../constants.zig");
+const constants = @import("../constants.zig");
 
-const clock_offset_tolerance_max: u64 = config.clock_offset_tolerance_max_ms * std.time.ns_per_ms;
-const epoch_max: u64 = config.clock_epoch_max_ms * std.time.ns_per_ms;
-const window_min: u64 = config.clock_synchronization_window_min_ms * std.time.ns_per_ms;
-const window_max: u64 = config.clock_synchronization_window_max_ms * std.time.ns_per_ms;
+const clock_offset_tolerance_max: u64 = constants.clock_offset_tolerance_max_ms * std.time.ns_per_ms;
+const epoch_max: u64 = constants.clock_epoch_max_ms * std.time.ns_per_ms;
+const window_min: u64 = constants.clock_synchronization_window_min_ms * std.time.ns_per_ms;
+const window_max: u64 = constants.clock_synchronization_window_max_ms * std.time.ns_per_ms;
 
 const Marzullo = @import("marzullo.zig").Marzullo;
 
@@ -83,7 +83,8 @@ pub fn Clock(comptime Time: type) type {
         time: *Time,
 
         /// An epoch from which the clock can read synchronized clock timestamps within safe bounds.
-        /// At least `config.clock_synchronization_window_min_ms` is needed for this to be ready to use.
+        /// At least `constants.clock_synchronization_window_min_ms` is needed for this to be ready
+        /// to use.
         epoch: Epoch,
 
         /// The next epoch (collecting samples and being synchronized) to replace the current epoch.
@@ -156,8 +157,8 @@ pub fn Clock(comptime Time: type) type {
 
             // Our m0 and m2 readings should always be monotonically increasing if not equal.
             // Crucially, it is possible for a very fast network to have m0 == m2, especially where
-            // `config.tick_ms` is at a more course granularity. We must therefore tolerate RTT=0 or
-            // otherwise we would have a liveness bug simply because we would be throwing away
+            // `constants.tick_ms` is at a more course granularity. We must therefore tolerate RTT=0
+            // or otherwise we would have a liveness bug simply because we would be throwing away
             // perfectly good clock samples.
             // This condition should never be true. Reject this as a bad sample:
             if (m0 > m2) {
@@ -246,8 +247,8 @@ pub fn Clock(comptime Time: type) type {
             return self.time.realtime();
         }
 
-        /// Called by `StateMachine.prepare_timestamp()` when the leader wants to timestamp a batch.
-        /// If the leader's clock is not synchronized with the cluster, it must wait until it is.
+        /// Called by `StateMachine.prepare_timestamp()` when the primary wants to timestamp a batch.
+        /// If the primary's clock is not synchronized with the cluster, it must wait until it is.
         /// Returns the system time clamped to be within our synchronized lower and upper bounds.
         /// This is complementary to NTP and allows clusters with very accurate time to make use of it,
         /// while providing guard rails for when NTP is partitioned or unable to correct quickly enough.