tigerbeetle-node 0.11.3 → 0.11.5

package/src/tigerbeetle/src/c/tb_client_header.zig

@@ -0,0 +1,218 @@
+const std = @import("std");
+const tb = @import("../tigerbeetle.zig");
+const tb_client = @import("tb_client.zig");
+
+const type_mappings = .{
+    .{ tb.AccountFlags, "TB_ACCOUNT_FLAGS" },
+    .{ tb.Account, "tb_account_t" },
+    .{ tb.TransferFlags, "TB_TRANSFER_FLAGS" },
+    .{ tb.Transfer, "tb_transfer_t" },
+    .{ 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" },
+    .{ tb_client.tb_operation_t, "TB_OPERATION" },
+    .{ tb_client.tb_packet_status_t, "TB_PACKET_STATUS" },
+    .{ tb_client.tb_packet_t, "tb_packet_t" },
+    .{ tb_client.tb_packet_list_t, "tb_packet_list_t" },
+    .{ tb_client.tb_client_t, "tb_client_t" },
+    .{ tb_client.tb_status_t, "TB_STATUS" },
+};
+
+fn resolve_c_type(comptime Type: type) []const u8 {
+    switch (@typeInfo(Type)) {
+        .Array => |info| return resolve_c_type(info.child),
+        .Enum => |info| return resolve_c_type(info.tag_type),
+        .Struct => return resolve_c_type(std.meta.Int(.unsigned, @bitSizeOf(Type))),
+        .Int => |info| {
+            std.debug.assert(info.signedness == .unsigned);
+            return switch (info.bits) {
+                8 => "uint8_t",
+                16 => "uint16_t",
+                32 => "uint32_t",
+                64 => "uint64_t",
+                128 => "tb_uint128_t",
+                else => @compileError("invalid int type"),
+            };
+        },
+        .Optional => |info| switch (@typeInfo(info.child)) {
+            .Pointer => return resolve_c_type(info.child),
+            else => @compileError("Unsupported optional type: " ++ @typeName(Type)),
+        },
+        .Pointer => |info| {
+            std.debug.assert(info.size != .Slice);
+            std.debug.assert(!info.is_allowzero);
+
+            inline for (type_mappings) |type_mapping| {
+                const ZigType = type_mapping[0];
+                const c_name = type_mapping[1];
+
+                if (info.child == ZigType) {
+                    const prefix = if (@typeInfo(ZigType) == .Struct) "struct " else "";
+                    return prefix ++ c_name ++ "*";
+                }
+            }
+
+            return resolve_c_type(info.child) ++ "*";
+        },
+        .Void, .Opaque => return "void",
+        else => @compileError("Unhandled type: " ++ @typeName(Type)),
+    }
+}
+
+fn to_uppercase(comptime input: []const u8) []const u8 {
+    comptime var output: [input.len]u8 = undefined;
+    inline for (output) |*char, i| {
+        char.* = input[i];
+        char.* -= 32 * @as(u8, @boolToInt(char.* >= 'a' and char.* <= 'z'));
+    }
+    return &output;
+}
+
+fn emit_enum(
+    buffer: *std.ArrayList(u8),
+    comptime type_info: anytype,
+    comptime c_name: []const u8,
+    comptime value_fmt: []const u8,
+    comptime skip_fields: []const []const u8,
+) !void {
+    var suffix_pos = std.mem.lastIndexOf(u8, c_name, "_").?;
+    if (std.mem.count(u8, c_name, "_") == 1) suffix_pos = c_name.len;
+
+    try buffer.writer().print("typedef enum {s} {{\n", .{c_name});
+
+    inline for (type_info.fields) |field, i| {
+        comptime var skip = false;
+        inline for (skip_fields) |sf| {
+            skip = skip or comptime std.mem.eql(u8, sf, field.name);
+        }
+
+        if (!skip) {
+            try buffer.writer().print("    {s}_{s} = " ++ value_fmt ++ ",\n", .{
+                c_name[0..suffix_pos],
+                to_uppercase(field.name),
+                i,
+            });
+        }
+    }
+
+    try buffer.writer().print("}} {s};\n\n", .{c_name});
+}
+
+fn emit_struct(
+    buffer: *std.ArrayList(u8),
+    comptime type_info: anytype,
+    comptime c_name: []const u8,
+) !void {
+    try buffer.writer().print("typedef struct {s} {{\n", .{c_name});
+
+    inline for (type_info.fields) |field| {
+        try buffer.writer().print("    {s} {s}", .{
+            resolve_c_type(field.field_type),
+            field.name,
+        });
+
+        switch (@typeInfo(field.field_type)) {
+            .Array => |array| try buffer.writer().print("[{d}]", .{array.len}),
+            else => {},
+        }
+
+        try buffer.writer().print(";\n", .{});
+    }
+
+    try buffer.writer().print("}} {s};\n\n", .{c_name});
+}
+
+pub fn main() !void {
+    @setEvalBranchQuota(100_000);
+
+    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
+    defer arena.deinit();
+    const allocator = arena.allocator();
+
+    var buffer = std.ArrayList(u8).init(allocator);
+    try buffer.writer().print(
+        \\ //////////////////////////////////////////////////////////
+        \\ // This file was auto-generated by tb_client_header.zig //
+        \\ //              Do not manually modify.                 //
+        \\ //////////////////////////////////////////////////////////
+        \\
+        \\#ifndef TB_CLIENT_H
+        \\#define TB_CLIENT_H
+        \\ 
+        \\#include <stddef.h>
+        \\#include <stdint.h>
+        \\#include <stdbool.h>
+        \\
+        \\typedef __uint128_t tb_uint128_t;
+        \\
+        \\
+    , .{});
+
+    // Emit C type declarations.
+    inline for (type_mappings) |type_mapping| {
+        const ZigType = type_mapping[0];
+        const c_name = type_mapping[1];
+
+        switch (@typeInfo(ZigType)) {
+            .Struct => |info| switch (info.layout) {
+                .Auto => @compileError("Invalid C struct type: " ++ @typeName(ZigType)),
+                .Packed => try emit_enum(&buffer, info, c_name, "1 << {d}", &.{"padding"}),
+                .Extern => try emit_struct(&buffer, info, c_name),
+            },
+            .Enum => |info| {
+                comptime var skip: []const []const u8 = &.{};
+                if (ZigType == tb_client.tb_operation_t) {
+                    skip = &.{ "reserved", "root", "register" };
+                }
+
+                try emit_enum(&buffer, info, c_name, "{d}", skip);
+            },
+            else => try buffer.writer().print("typedef {s} {s}; \n\n", .{
+                resolve_c_type(ZigType),
+                c_name,
+            }),
+        }
+    }
+
+    // Emit C function declarations.
+    // TODO: use `std.meta.declaractions` and generate with pub + export functions.
+    // Zig 0.9.1 has `decl.data.Fn.arg_names` but it's currently/incorrectly a zero-sized slice.
+    try buffer.writer().print(
+        \\TB_STATUS tb_client_init(
+        \\    tb_client_t* out_client,
+        \\    struct 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)
+        \\);
+        \\
+        \\TB_STATUS tb_client_init_echo(
+        \\    tb_client_t* out_client,
+        \\    struct 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)
+        \\);
+        \\
+        \\void tb_client_submit(
+        \\    tb_client_t client,
+        \\    struct tb_packet_list_t* packets
+        \\);
+        \\
+        \\void tb_client_deinit(
+        \\    tb_client_t client
+        \\);
+        \\
+        \\
+    , .{});
+
+    try buffer.writer().print("#endif // TB_CLIENT_H\n\n", .{});
+    try std.fs.cwd().writeFile("src/c/tb_client.h", buffer.items);
+}

package/src/tigerbeetle/src/c/test.zig

@@ -6,7 +6,7 @@ const testing = std.testing;
 const c = @cImport(@cInclude("tb_client.h"));
 
 const util = @import("../util.zig");
-const config = @import("../config.zig");
+const constants = @import("../constants.zig");
 const Packet = @import("tb_client/packet.zig").Packet;
 
 const Mutex = std.Thread.Mutex;
@@ -91,10 +91,10 @@ const Completion = struct {
 // 3. the data marshaling is correct, and exactly the same data sent was received back.
 test "c_client echo" {
     // Using the create_accounts operation for this test.
-    const RequestContext = RequestContextType(config.message_body_size_max);
-    const create_accounts_operation: u8 = c.TB_OP_CREATE_ACCOUNTS;
+    const RequestContext = RequestContextType(constants.message_body_size_max);
+    const create_accounts_operation: u8 = c.TB_OPERATION_CREATE_ACCOUNTS;
     const event_size = @sizeOf(c.tb_account_t);
-    const event_request_max = @divFloor(config.message_body_size_max, event_size);
+    const event_request_max = @divFloor(constants.message_body_size_max, event_size);
 
     // Initializing an echo client for testing purposes.
     // We ensure that the retry mechanism is being tested
@@ -103,7 +103,7 @@ test "c_client echo" {
     var tb_packet_list: c.tb_packet_list_t = undefined;
     const cluster_id = 0;
     const address = "3000";
-    const packets_count: u32 = config.client_request_queue_max * 2;
+    const packets_count: u32 = constants.client_request_queue_max * 2;
     const tb_context: usize = 42;
     const result = c.tb_client_init_echo(
         &tb_client,
@@ -221,7 +221,7 @@ test "c_client tb_status" {
     // More addresses thant "replicas_max" should return "TB_STATUS_ADDRESS_LIMIT_EXCEEDED":
     try assert_status(
         1,
-        ("3000," ** config.replicas_max) ++ "3001",
+        ("3000," ** constants.replicas_max) ++ "3001",
         c.TB_STATUS_ADDRESS_LIMIT_EXCEEDED,
     );
 
@@ -234,7 +234,7 @@ test "c_client tb_status" {
 
 // Asserts the validation rules associated with the "TB_PACKET_STATUS" enum.
 test "c_client tb_packet_status" {
-    const RequestContext = RequestContextType(config.message_body_size_max);
+    const RequestContext = RequestContextType(constants.message_body_size_max);
 
     var tb_client: c.tb_client_t = undefined;
     var tb_packet_list: c.tb_packet_list_t = undefined;
@@ -299,12 +299,12 @@ test "c_client tb_packet_status" {
 
     var packet_list = @ptrCast(*Packet.List, &tb_packet_list);
 
-    // Messages larger than config.message_body_size_max should return "too_much_data":
+    // Messages larger than constants.message_body_size_max should return "too_much_data":
     try assert_result(
         tb_client,
         packet_list,
-        c.TB_OP_CREATE_TRANSFERS,
-        config.message_body_size_max + @sizeOf(c.tb_transfer_t),
+        c.TB_OPERATION_CREATE_TRANSFERS,
+        constants.message_body_size_max + @sizeOf(c.tb_transfer_t),
         c.TB_PACKET_TOO_MUCH_DATA,
     );
 
@@ -343,28 +343,28 @@ test "c_client tb_packet_status" {
     try assert_result(
         tb_client,
         packet_list,
-        c.TB_OP_CREATE_ACCOUNTS,
+        c.TB_OPERATION_CREATE_ACCOUNTS,
         0,
         c.TB_PACKET_INVALID_DATA_SIZE,
     );
     try assert_result(
         tb_client,
         packet_list,
-        c.TB_OP_CREATE_TRANSFERS,
+        c.TB_OPERATION_CREATE_TRANSFERS,
         @sizeOf(c.tb_transfer_t) - 1,
         c.TB_PACKET_INVALID_DATA_SIZE,
     );
     try assert_result(
         tb_client,
         packet_list,
-        c.TB_OP_LOOKUP_TRANSFERS,
+        c.TB_OPERATION_LOOKUP_TRANSFERS,
         @sizeOf(u128) + 1,
         c.TB_PACKET_INVALID_DATA_SIZE,
     );
     try assert_result(
         tb_client,
         packet_list,
-        c.TB_OP_LOOKUP_ACCOUNTS,
+        c.TB_OPERATION_LOOKUP_ACCOUNTS,
         @sizeOf(u128) * 2.5,
         c.TB_PACKET_INVALID_DATA_SIZE,
     );

package/src/tigerbeetle/src/cli.zig

@@ -7,7 +7,7 @@ const meta = std.meta;
 const net = std.net;
 const os = std.os;
 
-const config = @import("config.zig");
+const constants = @import("constants.zig");
 const tigerbeetle = @import("tigerbeetle.zig");
 const vsr = @import("vsr.zig");
 const IO = @import("io.zig").IO;
@@ -72,8 +72,8 @@ const usage = fmt.comptimePrint(
     \\  tigerbeetle version --verbose
     \\
 , .{
-    .default_address = config.address,
-    .default_port = config.port,
+    .default_address = constants.address,
+    .default_port = constants.port,
 });
 
 pub const Command = union(enum) {
@@ -206,17 +206,17 @@ pub fn parse_args(allocator: std.mem.Allocator) !Command {
                     .cache_accounts = parse_size_to_count(
                         tigerbeetle.Account,
                         cache_accounts,
-                        config.cache_accounts_max,
+                        constants.cache_accounts_max,
                     ),
                     .cache_transfers = parse_size_to_count(
                         tigerbeetle.Transfer,
                         cache_transfers,
-                        config.cache_transfers_max,
+                        constants.cache_transfers_max,
                     ),
                     .cache_transfers_posted = parse_size_to_count(
                         u256, // TODO(#264): Use actual type here, once exposed.
                         cache_transfers_posted,
-                        config.cache_transfers_posted_max,
+                        constants.cache_transfers_posted_max,
                     ),
                     .path = path orelse fatal("required: <path>", .{}),
                 },
@@ -255,11 +255,11 @@ fn parse_cluster(raw_cluster: []const u8) u32 {
 
 /// Parse and allocate the addresses returning a slice into that array.
 fn parse_addresses(allocator: std.mem.Allocator, raw_addresses: []const u8) []net.Address {
-    return vsr.parse_addresses(allocator, raw_addresses, config.replicas_max) catch |err| switch (err) {
+    return vsr.parse_addresses(allocator, raw_addresses, constants.replicas_max) catch |err| switch (err) {
         error.AddressHasTrailingComma => fatal("--addresses: invalid trailing comma", .{}),
         error.AddressLimitExceeded => {
             fatal("--addresses: too many addresses, at most {d} are allowed", .{
-                config.replicas_max,
+                constants.replicas_max,
             });
         },
         error.AddressHasMoreThanOneColon => {
@@ -351,7 +351,7 @@ fn parse_size_to_count(comptime T: type, string_opt: ?[]const u8, comptime defau
         const count = math.cast(u32, count_u64) catch |err| switch (err) {
             error.Overflow => fatal("size value is too large: '{s}'", .{string}),
         };
-        if (count < 2048) fatal("size value is too small: '{s}'", .{string});
+        if (count > 0 and count < 2048) fatal("size value is too small: '{s}'", .{string});
         assert(count * @sizeOf(T) <= byte_size);
 
         result = count;
@@ -359,14 +359,14 @@ fn parse_size_to_count(comptime T: type, string_opt: ?[]const u8, comptime defau
 
     // SetAssociativeCache requires a power-of-two cardinality and a minimal
     // size.
-    assert(result >= 2048);
-    assert(math.isPowerOfTwo(result));
+    assert(result == 0 or result >= 2048);
+    assert(result == 0 or math.isPowerOfTwo(result));
 
     return result;
 }
 
 fn parse_replica(raw_replica: []const u8) u8 {
-    comptime assert(config.replicas_max <= std.math.maxInt(u8));
+    comptime assert(constants.replicas_max <= std.math.maxInt(u8));
     const replica = fmt.parseUnsigned(u8, raw_replica, 10) catch |err| switch (err) {
         error.Overflow => fatal("--replica: value exceeds an 8-bit unsigned integer", .{}),
         error.InvalidCharacter => fatal("--replica: value contains an invalid character", .{}),