tigerbeetle-node 0.11.0 → 0.11.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tigerbeetle-node",
-  "version": "0.11.0",
+  "version": "0.11.1",
   "description": "TigerBeetle Node.js client",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -22,7 +22,8 @@
     "src/index.ts",
     "src/node.zig",
     "src/test.ts",
-    "src/tigerbeetle/src",
+    "src/tigerbeetle/src/*.zig",
+    "src/tigerbeetle/src/{c,io,lsm,test,vsr}",
     "src/tigerbeetle/scripts",
     "src/translate.zig",
     "tsconfig.json"
@@ -39,7 +40,7 @@
     "build": "npm run build_tsc && npm run build_lib",
     "build_tsc": "./node_modules/typescript/bin/tsc",
     "build_lib": "mkdir -p dist && zig/zig build-lib -mcpu=baseline -OReleaseSafe -dynamic -lc -isystem build/node-$(node --version)/include/node src/node.zig -fallow-shlib-undefined -femit-bin=dist/client.node",
-    "prepack": "git submodule deinit --all && git submodule update --init && npm run build_tsc",
+    "prepack": "npm run build_tsc",
     "clean": "rm -rf build dist node_modules src/zig-cache zig"
   },
   "author": "TigerBeetle, Inc",

package/src/tigerbeetle/scripts/fuzz_loop.sh

@@ -2,7 +2,7 @@
 set -eu
 
 # Repeatedly runs some zig build command with different seeds and stores the output in the current directory.
-# Eg `fuzz_repeatedly.sh lsm_forest_fuzz` will run `zig build lsm_forest_fuzz -- seed $SEED > fuzz_lsm_forest_fuzz_${SEED}`
+# Eg `fuzz_repeatedly.sh fuzz_lsm_forest` will run `zig build fuzz_lsm_forest -- seed $SEED > fuzz_lsm_forest_fuzz_${SEED}`
 # Use ./fuzz_unique_errors.sh to analyze the results.
 
 FUZZ_COMMAND=$1

package/src/tigerbeetle/scripts/pre-commit.sh

@@ -4,6 +4,6 @@
 # ln -s ../../scripts/pre-commit.sh .git/hooks/pre-commit
 
 set -euo pipefail
-cd "$(dirname "$0")/../.."
+cd "$(git rev-parse --show-toplevel)"
 
-zig fmt --check .
+zig fmt --check .

package/src/tigerbeetle/scripts/validate_docs.sh

@@ -0,0 +1,17 @@
+#!/usr/bin/env bash
+
+set -e
+
+# This script builds the docs website for the currently checked out
+# branch.
+
+git clone https://github.com/tigerbeetledb/docs docs_website
+# Try to grab branch from Github Actions CI.
+# See also: https://docs.github.com/en/actions/learn-github-actions/environment-variables.
+BRANCH="$GITHUB_HEAD_REF"
+if [[ -z "$BRANCH" ]]; then
+    # Otherwise fall back to git rev-parse
+    BRANCH=$(git rev-parse --abbrev-ref HEAD)
+fi
+( cd docs_website && npm install && ./scripts/build.sh "$BRANCH" )
+rm -rf docs_website

package/src/tigerbeetle/src/benchmark.zig

@@ -9,6 +9,7 @@ pub const log_level: std.log.Level = .err;
 const cli = @import("cli.zig");
 const IO = @import("io.zig").IO;
 
+const util = @import("util.zig");
 const Storage = @import("storage.zig").Storage;
 const MessagePool = @import("message_pool.zig").MessagePool;
 const MessageBus = @import("message_bus.zig").MessageBusClient;
@@ -40,7 +41,7 @@ var accounts = [_]tb.Account{
         .user_data = 0,
         .reserved = [_]u8{0} ** 48,
         .ledger = 2,
-        .code = 0,
+        .code = 1,
         .flags = .{},
         .debits_pending = 0,
         .debits_posted = 0,
@@ -52,7 +53,7 @@ var accounts = [_]tb.Account{
         .user_data = 0,
         .reserved = [_]u8{0} ** 48,
         .ledger = 2,
-        .code = 0,
+        .code = 1,
         .flags = .{},
         .debits_pending = 0,
         .debits_posted = 0,
@@ -104,17 +105,18 @@ pub fn main() !void {
 
     for (transfers) |*transfer, index| {
         transfer.* = .{
-            .id = index,
+            .id = index + 1,
             .debit_account_id = accounts[0].id,
             .credit_account_id = accounts[1].id,
-            .pending_id = 0,
             .user_data = 0,
             .reserved = 0,
-            .code = 0,
+            .pending_id = 0,
+            .timeout = 0,
             .ledger = 2,
+            .code = 1,
             .flags = .{},
             .amount = 1,
-            .timeout = 0,
+            .timestamp = 0,
         };
     }
 
@@ -209,7 +211,8 @@ const TimedQueue = struct {
             const message = self.client.get_message();
             defer self.client.unref(message);
 
-            std.mem.copy(
+            util.copy_disjoint(
+                .inexact,
                 u8,
                 message.buffer[@sizeOf(vsr.Header)..],
                 std.mem.sliceAsBytes(starting_batch.data),
@@ -240,8 +243,6 @@ const TimedQueue = struct {
             @panic("Client returned error during benchmarking.");
         };
 
-        log.debug("response={s}", .{std.mem.bytesAsSlice(tb.CreateAccountsResult, value)});
-
         const self: *TimedQueue = @intToPtr(*TimedQueue, @intCast(usize, user_data));
         const completed_batch: ?Batch = self.batches.pop();
         assert(completed_batch != null);
@@ -253,8 +254,20 @@ const TimedQueue = struct {
         });
         const latency = now - self.batch_start.?;
         switch (operation) {
-            .create_accounts => {},
+            .create_accounts => {
+                const create_accounts_results = std.mem.bytesAsSlice(tb.CreateAccountsResult, value);
+                if (create_accounts_results.len > 0) {
+                    log.err("CreateAccountsResults={any}", .{create_accounts_results});
+                    @panic("Unexpected result creating accounts.");
+                }
+            },
             .create_transfers => {
+                const create_transfers_results = std.mem.bytesAsSlice(tb.CreateTransfersResult, value);
+                if (create_transfers_results.len > 0) {
+                    log.err("CreateTransfersResults={any}", .{create_transfers_results});
+                    @panic("Unexpected result creating transfers.");
+                }
+
                 if (latency > self.transfers_latency_max) {
                     self.transfers_latency_max = latency;
                 }
@@ -266,7 +279,8 @@ const TimedQueue = struct {
             const message = self.client.get_message();
             defer self.client.unref(message);
 
-            std.mem.copy(
+            util.copy_disjoint(
+                .inexact,
                 u8,
                 message.buffer[@sizeOf(vsr.Header)..],
                 std.mem.sliceAsBytes(next_batch.data),

package/src/tigerbeetle/src/c/tb_client/context.zig

@@ -1,4 +1,22 @@
 const std = @import("std");
+const os = std.os;
+const assert = std.debug.assert;
+
+const config = @import("../../config.zig");
+const log = std.log.scoped(.tb_client_context);
+
+const util = @import("../../util.zig");
+const vsr = @import("../../vsr.zig");
+const Header = vsr.Header;
+
+const IO = @import("../../io.zig").IO;
+const message_pool = @import("../../message_pool.zig");
+
+const MessagePool = message_pool.MessagePool;
+const Message = MessagePool.Message;
+
+const Packet = @import("packet.zig").Packet;
+const Signal = @import("signal.zig").Signal;
 const ThreadType = @import("thread.zig").ThreadType;
 
 const api = @import("../tb_client.zig");
@@ -13,15 +31,64 @@ pub const ContextImplementation = struct {
     deinit_fn: fn (*ContextImplementation) void,
 };
 
+pub const Error = std.mem.Allocator.Error || error{
+    Unexpected,
+    AddressInvalid,
+    AddressLimitExceeded,
+    PacketsCountInvalid,
+    SystemResources,
+    NetworkSubsystemFailed,
+};
+
 pub fn ContextType(
-    comptime StateMachine: type,
-    comptime MessageBus: type,
+    comptime Client: type,
 ) type {
     return struct {
         const Context = @This();
-        const Thread = ThreadType(StateMachine, MessageBus);
+        const Thread = ThreadType(Context);
+
+        const UserData = extern struct {
+            self: *Context,
+            packet: *Packet,
+        };
+
+        comptime {
+            assert(@sizeOf(UserData) == @sizeOf(u128));
+        }
+
+        fn operation_event_size(op: u8) ?usize {
+            const allowed_operations = [_]Client.StateMachine.Operation{
+                .create_accounts,
+                .create_transfers,
+                .lookup_accounts,
+                .lookup_transfers,
+            };
+
+            inline for (allowed_operations) |operation| {
+                if (op == @enumToInt(operation)) {
+                    return @sizeOf(Client.StateMachine.Event(operation));
+                }
+            }
+
+            return null;
+        }
+
+        const PacketError = Client.Error || error{
+            TooMuchData,
+            InvalidOperation,
+            InvalidDataSize,
+        };
 
         allocator: std.mem.Allocator,
+        client_id: u128,
+        packets: []Packet,
+
+        addresses: []const std.net.Address,
+        io: IO,
+        message_pool: MessagePool,
+        messages_available: usize,
+        client: Client,
+
         on_completion_ctx: usize,
         on_completion_fn: tb_completion_t,
         implementation: ContextImplementation,
@@ -29,51 +96,199 @@ pub fn ContextType(
 
         pub fn init(
             allocator: std.mem.Allocator,
-            out_tb_client: *tb_client_t,
-            out_packets: *tb_packet_list_t,
             cluster_id: u32,
-            addresses_ptr: [*:0]const u8,
-            addresses_len: u32,
-            num_packets: u32,
+            addresses: []const u8,
+            packets_count: u32,
             on_completion_ctx: usize,
             on_completion_fn: tb_completion_t,
-        ) tb_status_t {
-            const context = allocator.create(Context) catch return .out_of_memory;
+        ) Error!*Context {
+            var context = try allocator.create(Context);
+            errdefer allocator.destroy(context);
+
             context.allocator = allocator;
+            context.client_id = std.crypto.random.int(u128);
+            log.debug("{}: init: initializing", .{context.client_id});
+
+            const packets_count_max = 4096;
+            if (packets_count > packets_count_max) {
+                return error.PacketsCountInvalid;
+            }
+
+            log.debug("{}: init: allocating tb_packets", .{context.client_id});
+            context.packets = try context.allocator.alloc(Packet, packets_count);
+            errdefer context.allocator.free(context.packets);
+
+            log.debug("{}: init: parsing vsr addresses: {s}", .{ context.client_id, addresses });
+            context.addresses = vsr.parse_addresses(
+                context.allocator,
+                addresses,
+                config.replicas_max,
+            ) catch |err| return switch (err) {
+                error.AddressLimitExceeded => error.AddressLimitExceeded,
+                else => error.AddressInvalid,
+            };
+            errdefer context.allocator.free(context.addresses);
+
+            log.debug("{}: init: initializing IO", .{context.client_id});
+            context.io = IO.init(32, 0) catch |err| {
+                log.err("{}: failed to initialize IO: {s}", .{
+                    context.client_id,
+                    @errorName(err),
+                });
+                return switch (err) {
+                    error.ProcessFdQuotaExceeded => error.SystemResources,
+                    error.Unexpected => error.Unexpected,
+                    else => unreachable,
+                };
+            };
+            errdefer context.io.deinit();
+
+            log.debug("{}: init: initializing MessagePool", .{context.client_id});
+            context.message_pool = try MessagePool.init(allocator, .client);
+            errdefer context.message_pool.deinit(context.allocator);
+
+            log.debug("{}: init: initializing client (cluster_id={}, addresses={any})", .{
+                context.client_id,
+                cluster_id,
+                context.addresses,
+            });
+            context.client = try Client.init(
+                allocator,
+                context.client_id,
+                cluster_id,
+                @intCast(u8, context.addresses.len),
+                &context.message_pool,
+                .{
+                    .configuration = context.addresses,
+                    .io = &context.io,
+                },
+            );
+            errdefer context.client.deinit(context.allocator);
+
+            context.messages_available = config.client_request_queue_max;
             context.on_completion_ctx = on_completion_ctx;
             context.on_completion_fn = on_completion_fn;
-
-            out_tb_client.* = api.context_to_client(&context.implementation);
             context.implementation = .{
                 .submit_fn = Context.on_submit,
                 .deinit_fn = Context.on_deinit,
             };
 
-            const addresses = @ptrCast([*]const u8, addresses_ptr)[0..addresses_len];
-            context.thread.init(
-                allocator,
-                cluster_id,
-                addresses,
-                num_packets,
-                Context.on_completion,
-            ) catch |err| {
-                allocator.destroy(context);
-                return switch (err) {
-                    error.Unexpected => .unexpected,
-                    error.OutOfMemory => .out_of_memory,
-                    error.InvalidAddress => .invalid_address,
-                    error.SystemResources => .system_resources,
-                    error.NetworkSubsystemFailed => .network_subsystem,
+            log.debug("{}: init: initializing thread", .{context.client_id});
+            try context.thread.init(context);
+            errdefer context.thread.deinit(context.allocator);
+
+            return context;
+        }
+
+        pub fn deinit(self: *Context) void {
+            self.thread.deinit();
+
+            self.client.deinit(self.allocator);
+            self.message_pool.deinit(self.allocator);
+            self.io.deinit();
+
+            self.allocator.free(self.addresses);
+            self.allocator.free(self.packets);
+            self.allocator.destroy(self);
+        }
+
+        pub fn tick(self: *Context) void {
+            self.client.tick();
+        }
+
+        pub fn run(self: *Context) void {
+            while (!self.thread.signal.is_shutdown()) {
+                self.tick();
+                self.io.run_for_ns(config.tick_ms * std.time.ns_per_ms) catch |err| {
+                    log.err("{}: IO.run() failed: {s}", .{
+                        self.client_id,
+                        @errorName(err),
+                    });
+                    @panic("IO.run() failed");
                 };
+            }
+        }
+
+        pub fn request(self: *Context, packet: *Packet) void {
+            const message = self.message_pool.get_message();
+            defer self.message_pool.unref(message);
+            self.messages_available -= 1;
+
+            // Get the size of each request structure in the packet.data:
+            const event_size: usize = operation_event_size(packet.operation) orelse {
+                return self.on_complete(packet, error.InvalidOperation);
             };
 
-            var list = tb_packet_list_t{};
-            for (context.thread.packets) |*packet| {
-                list.push(tb_packet_list_t.from(packet));
+            // Make sure the packet.data size is correct:
+            const readable = @ptrCast([*]const u8, packet.data)[0..packet.data_size];
+            if (readable.len == 0 or readable.len % event_size != 0) {
+                return self.on_complete(packet, error.InvalidDataSize);
             }
 
-            out_packets.* = list;
-            return .success;
+            // Make sure the packet.data wouldn't overflow a message:
+            const writable = message.buffer[@sizeOf(Header)..][0..config.message_body_size_max];
+            if (readable.len > writable.len) {
+                return self.on_complete(packet, error.TooMuchData);
+            }
+
+            // Write the packet data to the message:
+            util.copy_disjoint(.inexact, u8, writable, readable);
+            const wrote = readable.len;
+
+            // Submit the message for processing:
+            self.client.request(
+                @bitCast(u128, UserData{
+                    .self = self,
+                    .packet = packet,
+                }),
+                Context.on_result,
+                @intToEnum(Client.StateMachine.Operation, packet.operation),
+                message,
+                wrote,
+            );
+        }
+
+        fn on_result(
+            raw_user_data: u128,
+            op: Client.StateMachine.Operation,
+            results: Client.Error![]const u8,
+        ) void {
+            const user_data = @bitCast(UserData, raw_user_data);
+            const self = user_data.self;
+            const packet = user_data.packet;
+
+            assert(packet.operation == @enumToInt(op));
+            self.on_complete(packet, results);
+        }
+
+        fn on_complete(
+            self: *Context,
+            packet: *Packet,
+            result: PacketError![]const u8,
+        ) void {
+            self.messages_available += 1;
+            assert(self.messages_available <= config.client_request_queue_max);
+
+            // Signal to resume sending requests that was waiting for available messages.
+            if (self.messages_available == 1) self.thread.signal.notify();
+
+            const tb_client = api.context_to_client(&self.implementation);
+            const bytes = result catch |err| {
+                packet.status = switch (err) {
+                    // If there's too many requests, (re)try submitting the packet later.
+                    error.TooManyOutstandingRequests => {
+                        return self.thread.retry.push(Packet.List.from(packet));
+                    },
+                    error.TooMuchData => .too_much_data,
+                    error.InvalidOperation => .invalid_operation,
+                    error.InvalidDataSize => .invalid_data_size,
+                };
+                return (self.on_completion_fn)(self.on_completion_ctx, tb_client, packet, null, 0);
+            };
+
+            // The packet completed normally.
+            packet.status = .ok;
+            (self.on_completion_fn)(self.on_completion_ctx, tb_client, packet, bytes.ptr, @intCast(u32, bytes.len));
         }
 
         fn on_submit(implementation: *ContextImplementation, packets: *tb_packet_list_t) void {
@@ -83,21 +298,7 @@ pub fn ContextType(
 
         fn on_deinit(implementation: *ContextImplementation) void {
             const context = @fieldParentPtr(Context, "implementation", implementation);
-            context.thread.deinit();
-            context.allocator.destroy(context);
-        }
-
-        fn on_completion(thread: *Thread, packet: *tb_packet_t, result: ?[]const u8) void {
-            const context = @fieldParentPtr(Context, "thread", thread);
-            const tb_client = api.context_to_client(&context.implementation);
-
-            context.on_completion_fn(
-                context.on_completion_ctx,
-                tb_client,
-                packet,
-                if (result) |r| r.ptr else null,
-                if (result) |r| @intCast(u32, r.len) else 0,
-            );
+            context.deinit();
         }
     };
 }

package/src/tigerbeetle/src/c/tb_client/echo_client.zig

@@ -0,0 +1,108 @@
+const std = @import("std");
+const assert = std.debug.assert;
+const mem = std.mem;
+
+const config = @import("../../config.zig");
+const vsr = @import("../../vsr.zig");
+const Header = vsr.Header;
+
+const RingBuffer = @import("../../ring_buffer.zig").RingBuffer;
+const MessagePool = @import("../../message_pool.zig").MessagePool;
+const Message = @import("../../message_pool.zig").MessagePool.Message;
+
+pub fn EchoClient(comptime StateMachine_: type, comptime MessageBus: type) type {
+    return struct {
+        const Self = @This();
+
+        // Exposing the same types the real client does:
+        pub usingnamespace blk: {
+            const Client = @import("../../vsr/client.zig").Client(StateMachine_, MessageBus);
+            break :blk struct {
+                pub const StateMachine = Client.StateMachine;
+                pub const Error = Client.Error;
+                pub const Request = Client.Request;
+            };
+        };
+
+        request_queue: RingBuffer(Self.Request, config.client_request_queue_max, .array) = .{},
+        message_pool: *MessagePool,
+
+        pub fn init(
+            allocator: mem.Allocator,
+            id: u128,
+            cluster: u32,
+            replica_count: u8,
+            message_pool: *MessagePool,
+            message_bus_options: MessageBus.Options,
+        ) !Self {
+            _ = allocator;
+            _ = id;
+            _ = cluster;
+            _ = replica_count;
+            _ = message_bus_options;
+
+            return Self{
+                .message_pool = message_pool,
+            };
+        }
+
+        pub fn deinit(self: *Self, allocator: std.mem.Allocator) void {
+            _ = allocator;
+            // Drains all pending requests before deiniting.
+            self.reply();
+        }
+
+        pub fn tick(self: *Self) void {
+            self.reply();
+        }
+
+        pub fn request(
+            self: *Self,
+            user_data: u128,
+            callback: Self.Request.Callback,
+            operation: Self.StateMachine.Operation,
+            message: *Message,
+            message_body_size: usize,
+        ) void {
+            message.header.* = .{
+                .client = 0,
+                .request = 0,
+                .cluster = 0,
+                .command = .request,
+                .operation = vsr.Operation.from(Self.StateMachine, operation),
+                .size = @intCast(u32, @sizeOf(Header) + message_body_size),
+            };
+
+            if (self.request_queue.full()) {
+                callback(user_data, operation, error.TooManyOutstandingRequests);
+                return;
+            }
+
+            self.request_queue.push_assume_capacity(.{
+                .user_data = user_data,
+                .callback = callback,
+                .message = message.ref(),
+            });
+        }
+
+        pub fn get_message(self: *Self) *Message {
+            return self.message_pool.get_message();
+        }
+
+        pub fn unref(self: *Self, message: *Message) void {
+            self.message_pool.unref(message);
+        }
+
+        fn reply(self: *Self) void {
+            while (self.request_queue.pop()) |inflight| {
+                defer self.unref(inflight.message);
+
+                inflight.callback(
+                    inflight.user_data,
+                    inflight.message.header.operation.cast(Self.StateMachine),
+                    inflight.message.body(),
+                );
+            }
+        }
+    };
+}

package/src/tigerbeetle/src/c/tb_client/packet.zig

@@ -4,11 +4,11 @@ const Atomic = std.atomic.Atomic;
 
 pub const Packet = extern struct {
     next: ?*Packet,
-    user_data: usize,
+    user_data: ?*anyopaque,
     operation: u8,
     status: Status,
     data_size: u32,
-    data: [*]const u8,
+    data: ?*anyopaque,
 
     pub const Status = enum(u8) {
         ok,

package/src/tigerbeetle/src/c/tb_client/signal.zig

@@ -8,12 +8,10 @@ const Atomic = std.atomic.Atomic;
 
 const log = std.log.scoped(.tb_client_signal);
 
-/// A Signal is a way to trigger a registered callback on a tigerbeetle IO instace 
+/// A Signal is a way to trigger a registered callback on a tigerbeetle IO instance 
 /// when notification occurs from another thread.
 /// It does this by using OS sockets (which are thread safe) 
 /// to resolve IO.Completions on the tigerbeetle thread.
-///
-/// TODO: implement a simpler version of this eventually..
 pub const Signal = struct {
     io: *IO,
     server_socket: os.socket_t,
@@ -50,7 +48,7 @@ pub const Signal = struct {
 
         // Windows requires that the socket is bound before listening
         if (builtin.target.os.tag == .windows) {
-            var addr = std.net.Address.initIp4(.{ 127, 0, 0, 1 }, 0); // zero port lets the OS choose
+            const addr = std.net.Address.initIp4(.{ 127, 0, 0, 1 }, 0); // zero port lets the OS choose
             os.bind(self.server_socket, &addr.any, addr.getOsSockLen()) catch |err| {
                 log.err("failed to bind the server socket to a local random port: {}", .{err});
                 return switch (err) {