tigerbeetle-node 0.11.7 → 0.11.9

package/src/tigerbeetle/src/demo.zig

@@ -1,132 +0,0 @@
-const std = @import("std");
-const assert = std.debug.assert;
-
-const constants = @import("constants.zig");
-
-const tb = @import("tigerbeetle.zig");
-const Account = tb.Account;
-const Transfer = tb.Transfer;
-
-const CreateAccountsResult = tb.CreateAccountsResult;
-const CreateTransfersResult = tb.CreateTransfersResult;
-
-const util = @import("util.zig");
-const IO = @import("io.zig").IO;
-const Storage = @import("storage.zig").Storage;
-const MessagePool = @import("message_pool.zig").MessagePool;
-const MessageBus = @import("message_bus.zig").MessageBusClient;
-const StateMachine = @import("state_machine.zig").StateMachineType(Storage, .{
-    .message_body_size_max = constants.message_body_size_max,
-});
-
-const vsr = @import("vsr.zig");
-const Header = vsr.Header;
-const Client = vsr.Client(StateMachine, MessageBus);
-
-pub const log_level: std.log.Level = .alert;
-
-pub fn request(
-    operation: StateMachine.Operation,
-    batch: anytype,
-    on_reply: fn (
-        user_data: u128,
-        operation: StateMachine.Operation,
-        results: Client.Error![]const u8,
-    ) void,
-) !void {
-    const allocator = std.heap.page_allocator;
-    const client_id = std.crypto.random.int(u128);
-    const cluster_id: u32 = 0;
-    var addresses = [_]std.net.Address{try std.net.Address.parseIp4("127.0.0.1", constants.port)};
-
-    var io = try IO.init(32, 0);
-    defer io.deinit();
-
-    var message_pool = try MessagePool.init(allocator, .client);
-    defer message_pool.deinit(allocator);
-
-    var client = try Client.init(
-        allocator,
-        client_id,
-        cluster_id,
-        @intCast(u8, addresses.len),
-        &message_pool,
-        .{
-            .configuration = &addresses,
-            .io = &io,
-        },
-    );
-    defer client.deinit(allocator);
-
-    const message = client.get_message();
-    defer client.unref(message);
-
-    const body = std.mem.asBytes(&batch);
-    util.copy_disjoint(.inexact, u8, message.buffer[@sizeOf(Header)..], body);
-
-    client.request(
-        0,
-        on_reply,
-        operation,
-        message,
-        body.len,
-    );
-
-    while (client.request_queue.count > 0) {
-        client.tick();
-        try io.run_for_ns(constants.tick_ms * std.time.ns_per_ms);
-    }
-}
-
-pub fn on_create_accounts(
-    user_data: u128,
-    operation: StateMachine.Operation,
-    results: Client.Error![]const u8,
-) void {
-    _ = user_data;
-    _ = operation;
-
-    print_results(CreateAccountsResult, results);
-}
-
-pub fn on_lookup_accounts(
-    user_data: u128,
-    operation: StateMachine.Operation,
-    results: Client.Error![]const u8,
-) void {
-    _ = user_data;
-    _ = operation;
-
-    print_results(Account, results);
-}
-
-pub fn on_lookup_transfers(
-    user_data: u128,
-    operation: StateMachine.Operation,
-    results: Client.Error![]const u8,
-) void {
-    _ = user_data;
-    _ = operation;
-
-    print_results(Transfer, results);
-}
-
-pub fn on_create_transfers(
-    user_data: u128,
-    operation: StateMachine.Operation,
-    results: Client.Error![]const u8,
-) void {
-    _ = user_data;
-    _ = operation;
-
-    print_results(CreateTransfersResult, results);
-}
-
-fn print_results(comptime Results: type, results: Client.Error![]const u8) void {
-    const body = results catch unreachable;
-    const slice = std.mem.bytesAsSlice(Results, body);
-    for (slice) |result| {
-        std.debug.print("{}\n", .{result});
-    }
-    if (slice.len == 0) std.debug.print("OK\n", .{});
-}

package/src/tigerbeetle/src/demo_01_create_accounts.zig

@@ -1,35 +0,0 @@
-const tb = @import("tigerbeetle.zig");
-const demo = @import("demo.zig");
-
-const Account = tb.Account;
-
-pub fn main() !void {
-    const accounts = [_]Account{
-        Account{
-            .id = 1,
-            .user_data = 0,
-            .reserved = [_]u8{0} ** 48,
-            .ledger = 710, // Let's use the ISO-4217 Code Number for ZAR
-            .code = 1000, // A chart of accounts code to describe this as a clearing account.
-            .flags = .{ .debits_must_not_exceed_credits = true },
-            .debits_pending = 0,
-            .debits_posted = 0,
-            .credits_pending = 0,
-            .credits_posted = 0,
-        },
-        Account{
-            .id = 2,
-            .user_data = 0,
-            .reserved = [_]u8{0} ** 48,
-            .ledger = 710, // Let's use the ISO-4217 Code Number for ZAR
-            .code = 2000, // A chart of accounts code to describe this as a payable account.
-            .flags = .{},
-            .debits_pending = 0,
-            .debits_posted = 0,
-            .credits_pending = 0,
-            .credits_posted = 0,
-        },
-    };
-
-    try demo.request(.create_accounts, accounts, demo.on_create_accounts);
-}

package/src/tigerbeetle/src/demo_02_lookup_accounts.zig

@@ -1,7 +0,0 @@
-const demo = @import("demo.zig");
-
-pub fn main() !void {
-    const ids = [_]u128{ 1, 2 };
-
-    try demo.request(.lookup_accounts, ids, demo.on_lookup_accounts);
-}

package/src/tigerbeetle/src/demo_03_create_transfers.zig

@@ -1,37 +0,0 @@
-const tb = @import("tigerbeetle.zig");
-const demo = @import("demo.zig");
-
-const Transfer = tb.Transfer;
-
-pub fn main() !void {
-    const transfers = [_]Transfer{
-        Transfer{
-            .id = 1,
-            .debit_account_id = 2,
-            .credit_account_id = 1,
-            .user_data = 0,
-            .reserved = 0,
-            .pending_id = 0,
-            .timeout = 0,
-            .ledger = 710, // Let's use the ISO-4217 Code Number for ZAR
-            .code = 1,
-            .flags = .{},
-            .amount = 10000, // Let's start with some liquidity in account 1.
-        },
-        Transfer{
-            .id = 2,
-            .debit_account_id = 1,
-            .credit_account_id = 2,
-            .user_data = 0,
-            .reserved = 0,
-            .pending_id = 0,
-            .timeout = 0,
-            .ledger = 710, // Let's use the ISO-4217 Code Number for ZAR
-            .code = 1,
-            .flags = .{},
-            .amount = 1000,
-        },
-    };
-
-    try demo.request(.create_transfers, transfers, demo.on_create_transfers);
-}

package/src/tigerbeetle/src/demo_04_create_pending_transfers.zig

@@ -1,61 +0,0 @@
-const std = @import("std");
-
-const tb = @import("tigerbeetle.zig");
-const demo = @import("demo.zig");
-
-const Transfer = tb.Transfer;
-
-pub fn main() !void {
-    const transfers = [_]Transfer{
-        Transfer{
-            .id = 1001,
-            .debit_account_id = 1,
-            .credit_account_id = 2,
-            .user_data = 0,
-            .reserved = 0,
-            .pending_id = 0,
-            .timeout = std.time.ns_per_hour,
-            .ledger = 710,
-            .code = 1,
-            .flags = .{
-                .pending = true, // Set this transfer to be two-phase.
-            },
-            .amount = 8000,
-        },
-        Transfer{
-            .id = 1002,
-            .debit_account_id = 1,
-            .credit_account_id = 2,
-            .user_data = 0,
-            .reserved = 0,
-            .pending_id = 0,
-            .timeout = std.time.ns_per_hour,
-            .ledger = 710,
-            .code = 1,
-            .flags = .{
-                .pending = true, // Set this transfer to be two-phase.
-                .linked = true, // Link this transfer with the next transfer 1003.
-            },
-            .amount = 500,
-        },
-        Transfer{
-            .id = 1003,
-            .debit_account_id = 1,
-            .credit_account_id = 2,
-            .user_data = 0,
-            .reserved = 0,
-            .pending_id = 0,
-            .timeout = std.time.ns_per_hour,
-            .ledger = 710,
-            .code = 1,
-            .flags = .{
-                .pending = true, // Set this transfer to be two-phase.
-                // The last transfer in a linked chain has .linked set to false to close the chain.
-                // This transfer will succeed or fail together with transfer 1002 above.
-            },
-            .amount = 500,
-        },
-    };
-
-    try demo.request(.create_transfers, transfers, demo.on_create_transfers);
-}

package/src/tigerbeetle/src/demo_05_post_pending_transfers.zig

@@ -1,37 +0,0 @@
-const tb = @import("tigerbeetle.zig");
-const demo = @import("demo.zig");
-
-const Transfer = tb.Transfer;
-
-pub fn main() !void {
-    const commits = [_]Transfer{
-        Transfer{
-            .id = 2001,
-            .debit_account_id = 1,
-            .credit_account_id = 2,
-            .user_data = 0,
-            .reserved = 0,
-            .pending_id = 1001,
-            .timeout = 0,
-            .ledger = 0, // Honor original Transfer ledger.
-            .code = 0, // Honor original Transfer code.
-            .flags = .{ .post_pending_transfer = true }, // Post the pending two-phase transfer.
-            .amount = 0, // Inherit the amount from the pending transfer.
-        },
-        Transfer{
-            .id = 2002,
-            .debit_account_id = 1,
-            .credit_account_id = 2,
-            .user_data = 0,
-            .reserved = 0,
-            .pending_id = 1002,
-            .timeout = 0,
-            .ledger = 0,
-            .code = 0,
-            .flags = .{ .post_pending_transfer = true }, // Post the pending two-phase transfer.
-            .amount = 0, // Inherit the amount from the pending transfer.
-        },
-    };
-
-    try demo.request(.create_transfers, commits, demo.on_create_transfers);
-}

package/src/tigerbeetle/src/demo_06_void_pending_transfers.zig

@@ -1,24 +0,0 @@
-const tb = @import("tigerbeetle.zig");
-const demo = @import("demo.zig");
-
-const Transfer = tb.Transfer;
-
-pub fn main() !void {
-    const commits = [_]Transfer{
-        Transfer{
-            .id = 2003,
-            .debit_account_id = 1,
-            .credit_account_id = 2,
-            .user_data = 0,
-            .reserved = 0,
-            .pending_id = 1003,
-            .timeout = 0,
-            .ledger = 0,
-            .code = 0,
-            .flags = .{ .void_pending_transfer = true },
-            .amount = 0,
-        },
-    };
-
-    try demo.request(.create_transfers, commits, demo.on_create_transfers);
-}

package/src/tigerbeetle/src/demo_07_lookup_transfers.zig

@@ -1,7 +0,0 @@
-const demo = @import("demo.zig");
-
-pub fn main() !void {
-    const ids = [_]u128{ 1, 1001, 1002, 1003, 2001, 2002, 2003 };
-
-    try demo.request(.lookup_transfers, ids, demo.on_lookup_transfers);
-}

package/src/tigerbeetle/src/test/cluster.zig

@@ -1,352 +0,0 @@
-const std = @import("std");
-const assert = std.debug.assert;
-const mem = std.mem;
-
-const constants = @import("../constants.zig");
-
-const message_pool = @import("../message_pool.zig");
-const MessagePool = message_pool.MessagePool;
-const Message = MessagePool.Message;
-
-const Network = @import("network.zig").Network;
-const NetworkOptions = @import("network.zig").NetworkOptions;
-
-pub const StateMachine = constants.StateMachineType(Storage, .{
-    .message_body_size_max = constants.message_body_size_max,
-});
-const MessageBus = @import("message_bus.zig").MessageBus;
-const Storage = @import("storage.zig").Storage;
-const Time = @import("time.zig").Time;
-
-const vsr = @import("../vsr.zig");
-pub const Replica = vsr.ReplicaType(StateMachine, MessageBus, Storage, Time);
-pub const ReplicaFormat = vsr.ReplicaFormatType(Storage);
-pub const Client = vsr.Client(StateMachine, MessageBus);
-const SuperBlock = vsr.SuperBlockType(Storage);
-const superblock_zone_size = @import("../vsr/superblock.zig").superblock_zone_size;
-
-pub const ClusterOptions = struct {
-    cluster: u32,
-    replica_count: u8,
-    client_count: u8,
-    storage_size_limit: u64,
-
-    seed: u64,
-    on_change_state: fn (replica: *const Replica) void,
-    on_compact: fn (replica: *const Replica) void,
-    on_checkpoint: fn (replica: *const Replica) void,
-
-    network_options: NetworkOptions,
-    storage_options: Storage.Options,
-    health_options: HealthOptions,
-    state_machine_options: StateMachine.Options,
-};
-
-pub const HealthOptions = struct {
-    /// Probability per tick that a crash will occur.
-    crash_probability: f64,
-    /// Minimum duration of a crash.
-    crash_stability: u32,
-    /// Probability per tick that a crashed replica will recovery.
-    restart_probability: f64,
-    /// Minimum time a replica is up until it is crashed again.
-    restart_stability: u32,
-};
-
-pub const ReplicaHealth = union(enum) {
-    /// When >0, the replica cannot crash.
-    /// When =0, the replica may crash.
-    up: u32,
-    /// When >0, this is the ticks remaining until recovery is possible.
-    /// When =0, the replica may recover.
-    down: u32,
-};
-
-pub const Cluster = struct {
-    allocator: mem.Allocator,
-    options: ClusterOptions,
-
-    storages: []Storage,
-    pools: []MessagePool,
-    replicas: []Replica,
-    health: []ReplicaHealth,
-
-    network: Network,
-
-    pub fn create(allocator: mem.Allocator, prng: std.rand.Random, options: ClusterOptions) !*Cluster {
-        assert(options.replica_count > 0);
-        assert(options.client_count > 0);
-        assert(options.storage_size_limit % constants.sector_size == 0);
-        assert(options.storage_size_limit <= constants.storage_size_max);
-        assert(options.health_options.crash_probability < 1.0);
-        assert(options.health_options.crash_probability >= 0.0);
-        assert(options.health_options.restart_probability < 1.0);
-        assert(options.health_options.restart_probability >= 0.0);
-
-        const cluster = try allocator.create(Cluster);
-        errdefer allocator.destroy(cluster);
-
-        const storages = try allocator.alloc(Storage, options.replica_count);
-        errdefer allocator.free(storages);
-
-        var pools = try allocator.alloc(MessagePool, options.replica_count);
-        errdefer allocator.free(pools);
-
-        for (pools) |*pool, i| {
-            errdefer for (pools[0..i]) |*p| p.deinit(allocator);
-            pool.* = try MessagePool.init(allocator, .replica);
-        }
-        errdefer for (pools) |*pool| pool.deinit(allocator);
-
-        const replicas = try allocator.alloc(Replica, options.replica_count);
-        errdefer allocator.free(replicas);
-
-        const health = try allocator.alloc(ReplicaHealth, options.replica_count);
-        errdefer allocator.free(health);
-        mem.set(ReplicaHealth, health, .{ .up = 0 });
-
-        var network = try Network.init(
-            allocator,
-            options.replica_count,
-            options.client_count,
-            options.network_options,
-        );
-        errdefer network.deinit();
-
-        cluster.* = .{
-            .allocator = allocator,
-            .options = options,
-            .storages = storages,
-            .pools = pools,
-            .replicas = replicas,
-            .health = health,
-            .network = network,
-        };
-
-        var buffer: [constants.replicas_max]Storage.FaultyAreas = undefined;
-        const faulty_wal_areas = Storage.generate_faulty_wal_areas(
-            prng,
-            constants.journal_size_max,
-            options.replica_count,
-            &buffer,
-        );
-        assert(faulty_wal_areas.len == options.replica_count);
-
-        for (cluster.storages) |*storage, replica_index| {
-            var storage_options = options.storage_options;
-            storage_options.replica_index = @intCast(u8, replica_index);
-            storage_options.faulty_wal_areas = faulty_wal_areas[replica_index];
-            storage.* = try Storage.init(allocator, options.storage_size_limit, storage_options);
-            // Disable most faults at startup, so that the replicas don't get stuck in recovery mode.
-            storage.faulty = replica_index >= vsr.quorums(options.replica_count).view_change;
-        }
-        errdefer for (cluster.storages) |*storage| storage.deinit(allocator);
-
-        // Format each replica's storage (equivalent to "tigerbeetle format ...").
-        for (cluster.storages) |*storage, replica_index| {
-            var superblock = try SuperBlock.init(allocator, .{
-                .storage = storage,
-                .message_pool = &cluster.pools[replica_index],
-                .storage_size_limit = options.storage_size_limit,
-            });
-            defer superblock.deinit(allocator);
-
-            try vsr.format(
-                Storage,
-                allocator,
-                options.cluster,
-                @intCast(u8, replica_index),
-                storage,
-                &superblock,
-            );
-        }
-
-        for (cluster.replicas) |_, replica_index| {
-            try cluster.open_replica(@intCast(u8, replica_index), .{
-                .resolution = constants.tick_ms * std.time.ns_per_ms,
-                .offset_type = .linear,
-                .offset_coefficient_A = 0,
-                .offset_coefficient_B = 0,
-            });
-        }
-        errdefer for (cluster.replicas) |*replica| replica.deinit(allocator);
-
-        return cluster;
-    }
-
-    pub fn destroy(cluster: *Cluster) void {
-        cluster.network.deinit();
-
-        for (cluster.replicas) |*replica| replica.deinit(cluster.allocator);
-        cluster.allocator.free(cluster.replicas);
-        cluster.allocator.free(cluster.health);
-        for (cluster.pools) |*pool| pool.deinit(cluster.allocator);
-        cluster.allocator.free(cluster.pools);
-
-        for (cluster.storages) |*storage| storage.deinit(cluster.allocator);
-        cluster.allocator.free(cluster.storages);
-
-        cluster.allocator.destroy(cluster);
-    }
-
-    /// Reset a replica to its initial state, simulating a random crash/panic.
-    /// Leave the persistent storage untouched, and leave any currently
-    /// inflight messages to/from the replica in the network.
-    ///
-    /// Returns whether the replica was crashed.
-    pub fn crash_replica(cluster: *Cluster, replica_index: u8) !bool {
-        const replica = &cluster.replicas[replica_index];
-        if (replica.op == 0) {
-            // Only crash when `replica.op > 0` — an empty WAL would skip recovery after a crash.
-            return false;
-        }
-
-        // TODO Remove this workaround when VSR recovery protocol is disabled.
-        for (replica.journal.prepare_inhabited) |inhabited, i| {
-            if (i == 0) {
-                // Ignore the root header.
-            } else {
-                if (inhabited) break;
-            }
-        } else {
-            // Only crash when at least one header has been written to the WAL.
-            // An empty WAL would skip recovery after a crash.
-            return false;
-        }
-
-        // Ensure that the cluster can eventually recover without this replica.
-        // Verify that each op is recoverable by the current healthy cluster (minus the replica we
-        // are trying to crash).
-        // TODO Remove this workaround when VSR recovery protocol is disabled.
-        if (cluster.options.replica_count != 1) {
-            var parent: u128 = undefined;
-            const cluster_op_max = op_max: {
-                var v: ?u32 = null;
-                var op_max: ?u64 = null;
-                for (cluster.replicas) |other_replica, i| {
-                    if (cluster.health[i] == .down) continue;
-                    if (other_replica.status == .recovering) continue;
-
-                    if (v == null or other_replica.view_normal > v.? or
-                        (other_replica.view_normal == v.? and other_replica.op > op_max.?))
-                    {
-                        v = other_replica.view_normal;
-                        op_max = other_replica.op;
-                        parent = other_replica.journal.header_with_op(op_max.?).?.checksum;
-                    }
-                }
-                break :op_max op_max.?;
-            };
-
-            // This whole workaround doesn't handle log wrapping correctly.
-            // If the log has wrapped, don't crash the replica.
-            if (cluster_op_max >= constants.journal_slot_count) {
-                return false;
-            }
-
-            var op: u64 = cluster_op_max + 1;
-            while (op > 0) {
-                op -= 1;
-
-                var cluster_op_known: bool = false;
-                for (cluster.replicas) |other_replica, i| {
-                    // Ignore replicas that are ineligible to assist recovery.
-                    if (replica_index == i) continue;
-                    if (cluster.health[i] == .down) continue;
-                    if (other_replica.status == .recovering) continue;
-
-                    if (other_replica.journal.header_with_op_and_checksum(op, parent)) |header| {
-                        parent = header.parent;
-                        if (!other_replica.journal.dirty.bit(.{ .index = op })) {
-                            // The op is recoverable if this replica crashes.
-                            break;
-                        }
-                        cluster_op_known = true;
-                    }
-                } else {
-                    if (op == cluster_op_max and !cluster_op_known) {
-                        // The replica can crash; it will be able to truncate the last op.
-                    } else {
-                        // The op isn't recoverable if this replica is crashed.
-                        return false;
-                    }
-                }
-            }
-
-            // We can't crash this replica because without it we won't be able to repair a broken
-            // hash chain.
-            if (parent != 0) return false;
-        }
-
-        cluster.health[replica_index] = .{ .down = cluster.options.health_options.crash_stability };
-
-        // Reset the storage before the replica so that pending writes can (partially) finish.
-        cluster.storages[replica_index].reset();
-        const replica_time = replica.time;
-        replica.deinit(cluster.allocator);
-
-        // Ensure that none of the replica's messages leaked when it was deinitialized.
-        var messages_in_pool: usize = 0;
-        const message_bus = cluster.network.get_message_bus(.{ .replica = replica_index });
-        {
-            var it = message_bus.pool.free_list;
-            while (it) |message| : (it = message.next) messages_in_pool += 1;
-        }
-        assert(messages_in_pool == message_pool.messages_max_replica);
-
-        // Logically it would make more sense to run this during restart, not immediately following
-        // the crash. But having it here allows the replica's MessageBus to initialize and begin
-        // queueing packets.
-        //
-        // Pass the old replica's Time through to the new replica. It will continue to be tick
-        // while the replica is crashed, to ensure the clocks don't desyncronize too far to recover.
-        try cluster.open_replica(replica_index, replica_time);
-
-        return true;
-    }
-
-    /// Returns the number of replicas capable of helping a crashed node recover (i.e. with
-    /// replica.status=normal).
-    pub fn replica_normal_count(cluster: *Cluster) u8 {
-        var count: u8 = 0;
-        for (cluster.replicas) |*replica| {
-            if (replica.status == .normal) count += 1;
-        }
-        return count;
-    }
-
-    pub fn replica_up_count(cluster: *const Cluster) u8 {
-        var count: u8 = 0;
-        for (cluster.health) |health| {
-            if (health == .up) {
-                count += 1;
-            }
-        }
-        return count;
-    }
-
-    fn open_replica(cluster: *Cluster, replica_index: u8, time: Time) !void {
-        var replica = &cluster.replicas[replica_index];
-        try replica.open(
-            cluster.allocator,
-            .{
-                .replica_count = @intCast(u8, cluster.replicas.len),
-                .storage = &cluster.storages[replica_index],
-                // TODO Test restarting with a higher storage limit.
-                .storage_size_limit = cluster.options.storage_size_limit,
-                .message_pool = &cluster.pools[replica_index],
-                .time = time,
-                .state_machine_options = cluster.options.state_machine_options,
-                .message_bus_options = .{ .network = &cluster.network },
-            },
-        );
-        assert(replica.cluster == cluster.options.cluster);
-        assert(replica.replica == replica_index);
-        assert(replica.replica_count == cluster.replicas.len);
-
-        replica.on_change_state = cluster.options.on_change_state;
-        replica.on_compact = cluster.options.on_compact;
-        replica.on_checkpoint = cluster.options.on_checkpoint;
-        cluster.network.link(replica.message_bus.process, &replica.message_bus);
-    }
-};