tigerbeetle-node 0.11.0 → 0.11.1

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

@@ -1,181 +1,44 @@
 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);
-
-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 log = std.log.scoped(.tb_client_thread);
 
 const Packet = @import("packet.zig").Packet;
 const Signal = @import("signal.zig").Signal;
 
 pub fn ThreadType(
-    comptime StateMachine: type,
-    comptime MessageBus: type,
+    comptime Context: type,
 ) type {
     return struct {
-        pub const Client = vsr.Client(StateMachine, MessageBus);
-        pub const Operation = StateMachine.Operation;
-
-        fn operation_size_of(op: u8) ?usize {
-            const allowed_operations = [_]Operation{
-                .create_accounts,
-                .create_transfers,
-                .lookup_accounts,
-                .lookup_transfers,
-            };
-
-            inline for (allowed_operations) |operation| {
-                if (op == @enumToInt(operation)) {
-                    return @sizeOf(StateMachine.Event(operation));
-                }
-            }
-
-            return null;
-        }
-
-        /////////////////////////////////////////////////////////////////////////
-
         const Self = @This();
 
-        allocator: std.mem.Allocator,
-        client_id: u128,
-        packets: []Packet,
-
-        addresses: []std.net.Address,
-        io: IO,
-        message_pool: MessagePool,
-        message_bus: MessageBus,
-        client: Client,
+        context: *Context,
 
         retry: Packet.List,
         submitted: Packet.Stack,
-        available_messages: usize,
-        on_completion_fn: CompletionFn,
 
         signal: Signal,
         thread: std.Thread,
 
-        pub const CompletionFn = fn (
-            client_thread: *Self,
-            packet: *Packet,
-            result: ?[]const u8,
-        ) void;
-
-        pub const Error = error{
-            Unexpected,
-            OutOfMemory,
-            InvalidAddress,
-            SystemResources,
-            NetworkSubsystemFailed,
-        };
-
         pub fn init(
             self: *Self,
-            allocator: std.mem.Allocator,
-            cluster_id: u32,
-            addresses: []const u8,
-            num_packets: u32,
-            on_completion_fn: CompletionFn,
-        ) Error!void {
-            self.allocator = allocator;
-            self.client_id = std.crypto.random.int(u128);
-            log.debug("init: initializing client_id={}.", .{self.client_id});
-
-            log.debug("init: allocating tb_packets.", .{});
-            self.packets = self.allocator.alloc(Packet, num_packets) catch |err| {
-                log.err("failed to allocate tb_packets: {}", .{err});
-                return Error.OutOfMemory;
-            };
-            errdefer self.allocator.free(self.packets);
-
-            log.debug("init: parsing vsr addresses.", .{});
-            const address_limit = std.mem.count(u8, addresses, ",") + 1;
-            self.addresses = vsr.parse_addresses(self.allocator, addresses, address_limit) catch |err| {
-                log.err("failed to parse addresses: {}.", .{err});
-                return Error.InvalidAddress;
-            };
-            errdefer self.allocator.free(self.addresses);
-
-            log.debug("init: initializing IO.", .{});
-            self.io = IO.init(32, 0) catch |err| {
-                log.err("failed to initialize IO: {}.", .{err});
-                return switch (err) {
-                    error.ProcessFdQuotaExceeded => error.SystemResources,
-                    error.Unexpected => error.Unexpected,
-                    else => unreachable,
-                };
-            };
-            errdefer self.io.deinit();
-
-            log.debug("init: initializing MessagePool", .{});
-            self.message_pool = MessagePool.init(allocator, .client) catch |err| {
-                log.err("failed to initialize MessagePool: {}", .{err});
-                return err;
-            };
-            errdefer self.message_pool.deinit(self.allocator);
-
-            log.debug("init: initializing MessageBus.", .{});
-            self.message_bus = MessageBus.init(
-                self.allocator,
-                cluster_id,
-                .{ .client = self.client_id },
-                &self.message_pool,
-                Client.on_message,
-                .{
-                    .configuration = self.addresses,
-                    .io = &self.io,
-                },
-            ) catch |err| {
-                log.err("failed to initialize message bus: {}.", .{err});
-                return err;
-            };
-            errdefer self.message_bus.deinit(self.allocator);
-
-            log.debug("init: Initializing client(cluster_id={d}, client_id={d}, addresses={o})", .{
-                cluster_id,
-                self.client_id,
-                self.addresses,
-            });
-            self.client = Client.init(
-                allocator,
-                self.client_id,
-                cluster_id,
-                @intCast(u8, self.addresses.len),
-                &self.message_pool,
-                .{
-                    .configuration = self.addresses,
-                    .io = &self.io,
-                },
-            ) catch |err| {
-                log.err("failed to initalize client: {}", .{err});
-                return err;
-            };
-            errdefer self.client.deinit(self.allocator);
-
+            context: *Context,
+        ) !void {
+            self.context = context;
             self.retry = .{};
             self.submitted = .{};
-            self.available_messages = message_pool.messages_max_client;
-            self.on_completion_fn = on_completion_fn;
 
-            log.debug("init: initializing Signal.", .{});
-            self.signal.init(&self.io, Self.on_signal) catch |err| {
-                log.err("failed to initialize Signal: {}.", .{err});
-                return err;
-            };
+            log.debug("{}: init: initializing signal", .{context.client_id});
+            try self.signal.init(&context.io, Self.on_signal);
             errdefer self.signal.deinit();
 
-            log.debug("init: spawning Context thread.", .{});
-            self.thread = std.Thread.spawn(.{}, Self.run, .{self}) catch |err| {
-                log.err("failed to spawn context thread: {}.", .{err});
+            log.debug("{}: init: spawning thread", .{context.client_id});
+            self.thread = std.Thread.spawn(.{}, Context.run, .{context}) catch |err| {
+                log.err("{}: failed to spawn thread: {s}", .{
+                    context.client_id,
+                    @errorName(err),
+                });
                 return switch (err) {
                     error.Unexpected => error.Unexpected,
                     error.OutOfMemory => error.OutOfMemory,
@@ -189,13 +52,6 @@ pub fn ThreadType(
             self.thread.join();
             self.signal.deinit();
 
-            self.client.deinit(self.allocator);
-            self.message_bus.deinit(self.allocator);
-            self.message_pool.deinit(self.allocator);
-            self.io.deinit();
-
-            self.allocator.free(self.addresses);
-            self.allocator.free(self.packets);
             self.* = undefined;
         }
 
@@ -205,19 +61,9 @@ pub fn ThreadType(
             self.signal.notify();
         }
 
-        fn run(self: *Self) void {
-            while (!self.signal.is_shutdown()) {
-                self.client.tick();
-                self.io.run_for_ns(config.tick_ms * std.time.ns_per_ms) catch |err| {
-                    log.err("IO.run() failed with {}", .{err});
-                    return;
-                };
-            }
-        }
-
         fn on_signal(signal: *Signal) void {
             const self = @fieldParentPtr(Self, "signal", signal);
-            self.client.tick();
+            self.context.tick();
 
             // Consume all of retry here to avoid infinite loop
             // if the code below pushes to self.retry while we're dequeueing.
@@ -234,95 +80,10 @@ pub fn ThreadType(
             }
 
             // Process packets from either pending or submitted as long as we have messages.
-            while (self.available_messages > 0) {
+            while (self.context.messages_available > 0) {
                 const packet = pending.pop() orelse self.submitted.pop() orelse break;
-                const message = self.client.get_message();
-                defer self.client.unref(message);
-
-                self.available_messages -= 1;
-                self.request(packet, message);
+                self.context.request(packet);
             }
         }
-
-        fn request(self: *Self, packet: *Packet, message: *Message) void {
-            // Get the size of each request structure in the packet.data
-            const request_size: usize = operation_size_of(packet.operation) orelse {
-                return self.on_complete(packet, error.InvalidOperation);
-            };
-
-            // Make sure the packet.data size is correct.
-            const readable = packet.data[0..packet.data_size];
-            if (readable.len == 0 or readable.len % request_size != 0) {
-                return self.on_complete(packet, error.InvalidDataSize);
-            }
-
-            // Make sure the packet.data wouldn't overflow a message.
-            const writable = message.buffer[@sizeOf(Header)..];
-            if (readable.len > writable.len) {
-                return self.on_complete(packet, error.TooMuchData);
-            }
-
-            // Write the packet data to the message
-            std.mem.copy(u8, writable, readable);
-            const wrote = readable.len;
-
-            // .. and submit the message for processing
-            self.client.request(
-                @bitCast(u128, UserData{
-                    .self = self,
-                    .packet = packet,
-                }),
-                Self.on_result,
-                @intToEnum(Operation, packet.operation),
-                message,
-                wrote,
-            );
-        }
-
-        const UserData = packed struct {
-            self: *Self,
-            packet: *Packet,
-        };
-
-        fn on_result(raw_user_data: u128, op: 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);
-        }
-
-        const PacketError = Client.Error || error{
-            TooMuchData,
-            InvalidOperation,
-            InvalidDataSize,
-        };
-
-        fn on_complete(
-            self: *Self,
-            packet: *Packet,
-            result: PacketError![]const u8,
-        ) void {
-            assert(self.available_messages < message_pool.messages_max_client);
-            self.available_messages += 1;
-
-            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.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, packet, null);
-            };
-
-            // The packet completed normally
-            packet.status = .ok;
-            self.on_completion_fn(self, packet, bytes);
-        }
     };
 }

package/src/tigerbeetle/src/c/tb_client.h

@@ -120,6 +120,7 @@ typedef enum TB_CREATE_TRANSFER_RESULT {
     TB_CREATE_TRANSFER_OVERFLOWS_CREDITS_POSTED,
     TB_CREATE_TRANSFER_OVERFLOWS_DEBITS,
     TB_CREATE_TRANSFER_OVERFLOWS_CREDITS,
+    TB_CREATE_TRANSFER_OVERFLOWS_TIMEOUT,
 
     TB_CREATE_TRANSFER_EXCEEDS_CREDITS,
     TB_CREATE_TRANSFER_EXCEEDS_DEBITS,
@@ -193,9 +194,11 @@ typedef enum TB_STATUS {
     TB_STATUS_SUCCESS = 0,
     TB_STATUS_UNEXPECTED = 1,
     TB_STATUS_OUT_OF_MEMORY = 2,
-    TB_STATUS_INVALID_ADDRESS = 3,
-    TB_STATUS_SYSTEM_RESOURCES = 4,
-    TB_STATUS_NETWORK_SUBSYSTEM = 5,
+    TB_STATUS_ADDRESS_INVALID = 3,
+    TB_STATUS_ADDRESS_LIMIT_EXCEEDED = 4,
+    TB_STATUS_PACKETS_COUNT_INVALID = 5,
+    TB_STATUS_SYSTEM_RESOURCES = 6,
+    TB_STATUS_NETWORK_SUBSYSTEM = 7,
 } TB_STATUS;
 
 TB_STATUS tb_client_init(
@@ -204,7 +207,18 @@ TB_STATUS tb_client_init(
     uint32_t cluster_id,
     const char* address_ptr,
     uint32_t address_len,
-    uint32_t num_packets,
+    uint32_t packets_count,
+    uintptr_t on_completion_ctx,
+    void (*on_completion_fn)(uintptr_t, tb_client_t, tb_packet_t*, const uint8_t*, uint32_t)
+);
+
+TB_STATUS tb_client_init_echo(
+    tb_client_t* out_client,
+    tb_packet_list_t* out_packets,
+    uint32_t cluster_id,
+    const char* address_ptr,
+    uint32_t address_len,
+    uint32_t packets_count,
     uintptr_t on_completion_ctx,
     void (*on_completion_fn)(uintptr_t, tb_client_t, tb_packet_t*, const uint8_t*, uint32_t)
 );

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

@@ -10,7 +10,9 @@ pub const tb_status_t = enum(c_int) {
     success = 0,
     unexpected,
     out_of_memory,
-    invalid_address,
+    address_invalid,
+    address_limit_exceeded,
+    packets_count_invalid,
     system_resources,
     network_subsystem,
 };
@@ -23,9 +25,26 @@ pub const tb_completion_t = fn (
     result_len: u32,
 ) callconv(.C) void;
 
+const config = @import("../config.zig");
+const Storage = @import("../storage.zig").Storage;
+const MessageBus = @import("../message_bus.zig").MessageBusClient;
+const StateMachine = @import("../state_machine.zig").StateMachineType(Storage, .{
+    .message_body_size_max = config.message_body_size_max,
+});
+
 const ContextType = @import("tb_client/context.zig").ContextType;
 const ContextImplementation = @import("tb_client/context.zig").ContextImplementation;
 
+const DefaultContext = blk: {
+    const Client = @import("../vsr/client.zig").Client(StateMachine, MessageBus);
+    break :blk ContextType(Client);
+};
+
+const TestingContext = blk: {
+    const EchoClient = @import("tb_client/echo_client.zig").EchoClient(StateMachine, MessageBus);
+    break :blk ContextType(EchoClient);
+};
+
 pub fn context_to_client(implementation: *ContextImplementation) tb_client_t {
     return @ptrCast(tb_client_t, implementation);
 }
@@ -34,24 +53,10 @@ fn client_to_context(tb_client: tb_client_t) *ContextImplementation {
     return @ptrCast(*ContextImplementation, @alignCast(@alignOf(ContextImplementation), tb_client));
 }
 
-const DefaultContext = blk: {
-    const config = @import("../config.zig");
-    const Storage = @import("../storage.zig").Storage;
-    const MessageBus = @import("../message_bus.zig").MessageBusClient;
-    const StateMachine = @import("../state_machine.zig").StateMachineType(Storage, .{
-        .message_body_size_max = config.message_body_size_max,
-    });
-    break :blk ContextType(StateMachine, MessageBus);
-};
-
-// const TestingContext = blk: {
-//     const MessageBus = @import("test_message_bus.zig").MessageBusClient;
-//     const StateMachine = @import("../state_machine.zig").StateMachine;
-//     break :blk ContextType(StateMachine, MessageBus);
-// };
-
 // Pick the most suitable allocator
-const global_allocator = if (builtin.link_libc)
+const global_allocator = if (builtin.is_test)
+    std.testing.allocator
+else if (builtin.link_libc)
     std.heap.c_allocator
 else if (builtin.target.os.tag == .windows)
     (struct {
@@ -66,28 +71,85 @@ pub export fn tb_client_init(
     cluster_id: u32,
     addresses_ptr: [*:0]const u8,
     addresses_len: u32,
-    num_packets: u32,
+    packets_count: u32,
     on_completion_ctx: usize,
     on_completion_fn: tb_completion_t,
 ) tb_status_t {
-    var init_fn = DefaultContext.init;
-    // if (addresses_len == 0) {
-    //     init_fn = TestingContext.init;
-    // }
+    return init(
+        DefaultContext,
+        out_client,
+        out_packets,
+        cluster_id,
+        addresses_ptr,
+        addresses_len,
+        packets_count,
+        on_completion_ctx,
+        on_completion_fn,
+    );
+}
 
-    return (init_fn)(
-        global_allocator,
+pub export fn tb_client_init_echo(
+    out_client: *tb_client_t,
+    out_packets: *tb_packet_list_t,
+    cluster_id: u32,
+    addresses_ptr: [*:0]const u8,
+    addresses_len: u32,
+    packets_count: u32,
+    on_completion_ctx: usize,
+    on_completion_fn: tb_completion_t,
+) tb_status_t {
+    return init(
+        TestingContext,
         out_client,
         out_packets,
         cluster_id,
         addresses_ptr,
         addresses_len,
-        num_packets,
+        packets_count,
         on_completion_ctx,
         on_completion_fn,
     );
 }
 
+fn init(
+    comptime Context: type,
+    out_client: *tb_client_t,
+    out_packets: *tb_packet_list_t,
+    cluster_id: u32,
+    addresses_ptr: [*:0]const u8,
+    addresses_len: u32,
+    packets_count: u32,
+    on_completion_ctx: usize,
+    on_completion_fn: tb_completion_t,
+) tb_status_t {
+    const addresses = @ptrCast([*]const u8, addresses_ptr)[0..addresses_len];
+    const context = Context.init(
+        global_allocator,
+        cluster_id,
+        addresses,
+        packets_count,
+        on_completion_ctx,
+        on_completion_fn,
+    ) catch |err| switch (err) {
+        error.Unexpected => return .unexpected,
+        error.OutOfMemory => return .out_of_memory,
+        error.AddressInvalid => return .address_invalid,
+        error.AddressLimitExceeded => return .address_limit_exceeded,
+        error.PacketsCountInvalid => return .packets_count_invalid,
+        error.SystemResources => return .system_resources,
+        error.NetworkSubsystemFailed => return .network_subsystem,
+    };
+
+    out_client.* = context_to_client(&context.implementation);
+    var list = tb_packet_list_t{};
+    for (context.packets) |*packet| {
+        list.push(tb_packet_list_t.from(packet));
+    }
+
+    out_packets.* = list;
+    return .success;
+}
+
 pub export fn tb_client_submit(
     client: tb_client_t,
     packets: *tb_packet_list_t,

package/src/tigerbeetle/src/c/tb_client_header_test.zig

@@ -0,0 +1,135 @@
+const std = @import("std");
+const assert = std.debug.assert;
+
+const tb = @import("../tigerbeetle.zig");
+const tb_client = @import("./tb_client.zig");
+const c = @cImport(@cInclude("tb_client.h"));
+
+fn to_lowercase(comptime input: []const u8) []const u8 {
+    comptime var lowercase: [input.len]u8 = undefined;
+    inline for (input) |char, i| {
+        const is_uppercase = (char >= 'A') and (char <= 'Z');
+        lowercase[i] = char + (@as(u8, @boolToInt(is_uppercase)) * 32);
+    }
+    return &lowercase;
+}
+
+fn to_uppercase(comptime input: []const u8) []const u8 {
+    comptime var uppercase: [input.len]u8 = undefined;
+    inline for (input) |char, i| {
+        const is_lowercase = (char >= 'a') and (char <= 'z');
+        uppercase[i] = char - (@as(u8, @boolToInt(is_lowercase)) * 32);
+    }
+    return &uppercase;
+}
+
+fn to_snakecase(comptime input: []const u8) []const u8 {
+    comptime var output: []const u8 = &.{};
+    inline for (input) |char, i| {
+        const is_uppercase = (char >= 'A') and (char <= 'Z');
+        if (is_uppercase and i > 0) output = "_" ++ output;
+        output = output ++ &[_]u8{char};
+    }
+    return output;
+}
+
+test "valid tb_client.h" {
+    @setEvalBranchQuota(10_000);
+
+    inline for (.{
+        .{ tb.Account, "tb_account_t" },
+        .{ tb.Transfer, "tb_transfer_t" },
+        .{ tb.AccountFlags, "TB_ACCOUNT_FLAGS" },
+        .{ tb.TransferFlags, "TB_TRANSFER_FLAGS" },
+        .{ tb.CreateAccountResult, "TB_CREATE_ACCOUNT_RESULT" },
+        .{ tb.CreateTransferResult, "TB_CREATE_TRANSFER_RESULT" },
+        .{ tb.CreateAccountsResult, "tb_create_accounts_result_t" },
+        .{ tb.CreateTransfersResult, "tb_create_transfers_result_t" },
+
+        .{ u128, "tb_uint128_t" },
+        .{ tb_client.tb_status_t, "TB_STATUS" },
+        .{ tb_client.tb_client_t, "tb_client_t" },
+        .{ tb_client.tb_packet_t, "tb_packet_t" },
+        .{ tb_client.tb_packet_list_t, "tb_packet_list_t" },
+        .{ tb_client.tb_packet_status_t, "TB_PACKET_STATUS" },
+    }) |c_export| {
+        const ty: type = c_export[0];
+        const c_type_name = @as([]const u8, c_export[1]);
+        const c_type: type = @field(c, c_type_name);
+
+        switch (@typeInfo(ty)) {
+            .Int => comptime assert(ty == c_type),
+            .Pointer => comptime assert(@sizeOf(ty) == @sizeOf(c_type)),
+            .Enum => {
+                const prefix_offset = comptime std.mem.lastIndexOf(u8, c_type_name, "_").?;
+                comptime var c_enum_prefix: []const u8 = c_type_name[0 .. prefix_offset + 1];
+                comptime assert(c_type == c_uint);
+
+                // TB_STATUS is a special case in naming
+                if (comptime std.mem.eql(u8, c_type_name, "TB_STATUS")) {
+                    c_enum_prefix = c_type_name ++ "_";
+                }
+
+                // Compare the enum int values in C to the enum int values in Zig.
+                inline for (std.meta.fields(ty)) |field| {
+                    const c_enum_field = comptime to_uppercase(to_snakecase(field.name));
+                    const c_value = @field(c, c_enum_prefix ++ c_enum_field);
+
+                    const zig_value = @enumToInt(@field(ty, field.name));
+                    comptime assert(zig_value == c_value);
+                }
+            },
+            .Struct => |type_info| switch (type_info.layout) {
+                .Auto => @compileError("struct must be extern or packed to be used in C"),
+                .Packed => {
+                    const prefix_offset = comptime std.mem.lastIndexOf(u8, c_type_name, "_").?;
+                    const c_enum_prefix = c_type_name[0 .. prefix_offset + 1];
+                    comptime assert(c_type == c_uint);
+
+                    inline for (std.meta.fields(ty)) |field| {
+                        if (comptime !std.mem.eql(u8, field.name, "padding")) {
+                            // Get the bit value in the C enum.
+                            const c_enum_field = comptime to_uppercase(to_snakecase(field.name));
+                            const c_value = @field(c, c_enum_prefix ++ c_enum_field);
+
+                            // Compare the bit value to the packed struct's field.
+                            comptime var instance = std.mem.zeroes(ty);
+                            @field(instance, field.name) = true;
+                            comptime assert(@bitCast(u16, instance) == c_value);
+                        }
+                    }
+                },
+                .Extern => {
+                    // Ensure structs are effectively the same.
+                    comptime assert(@sizeOf(ty) == @sizeOf(c_type));
+                    comptime assert(@alignOf(ty) == @alignOf(c_type));
+
+                    inline for (std.meta.fields(ty)) |field| {
+                        // In C, packed structs and enums are replaced with integers.
+                        comptime var field_type = field.field_type;
+                        switch (@typeInfo(field_type)) {
+                            .Struct => |info| {
+                                comptime assert(info.layout == .Packed);
+                                comptime assert(@sizeOf(field_type) <= @sizeOf(u128));
+                                field_type = std.meta.Int(.unsigned, @bitSizeOf(field_type));
+                            },
+                            .Enum => |info| field_type = info.tag_type,
+                            else => {},
+                        }
+
+                        // In C, pointers are opaque so we compare only the field sizes,
+                        comptime var c_field_type = @TypeOf(@field(@as(c_type, undefined), field.name));
+                        switch (@typeInfo(c_field_type)) {
+                            .Pointer => |info| {
+                                comptime assert(info.size == .C);
+                                comptime assert(@sizeOf(c_field_type) == @sizeOf(field_type));
+                            },
+                            else => comptime assert(c_field_type == field_type),
+                        }
+                    }
+                },
+            },
+            else => |i| @compileLog("TODO", i),
+        }
+    }
+}