tigerbeetle-node 0.11.6 → 0.11.7

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

@@ -1,177 +0,0 @@
-const std = @import("std");
-const builtin = @import("builtin");
-
-pub const tb_packet_t = @import("tb_client/packet.zig").Packet;
-pub const tb_packet_list_t = tb_packet_t.List;
-pub const tb_packet_status_t = tb_packet_t.Status;
-
-pub const tb_client_t = *anyopaque;
-pub const tb_status_t = enum(c_int) {
-    success = 0,
-    unexpected,
-    out_of_memory,
-    address_invalid,
-    address_limit_exceeded,
-    packets_count_invalid,
-    system_resources,
-    network_subsystem,
-};
-
-pub const tb_operation_t = StateMachine.Operation;
-pub const tb_completion_t = fn (
-    context: usize,
-    client: tb_client_t,
-    packet: *tb_packet_t,
-    result_ptr: ?[*]const u8,
-    result_len: u32,
-) callconv(.C) void;
-
-const constants = @import("../constants.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 = constants.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);
-}
-
-fn client_to_context(tb_client: tb_client_t) *ContextImplementation {
-    return @ptrCast(*ContextImplementation, @alignCast(@alignOf(ContextImplementation), tb_client));
-}
-
-// Only export the functions if we're compiling libtb_client.
-// If it's only being imported by another zig file, then exporting the functions
-// will force them to be evaluated/codegen/linked and trigger unexpected comptime paths.
-comptime {
-    if (builtin.link_libc) {
-        @export(tb_client_init, .{ .name = "tb_client_init", .linkage = .Strong });
-        @export(tb_client_init_echo, .{ .name = "tb_client_init_echo", .linkage = .Strong });
-    }
-}
-
-pub fn tb_client_init(
-    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,
-) callconv(.C) tb_status_t {
-    return init(
-        DefaultContext,
-        out_client,
-        out_packets,
-        cluster_id,
-        addresses_ptr,
-        addresses_len,
-        packets_count,
-        on_completion_ctx,
-        on_completion_fn,
-    );
-}
-
-pub 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,
-) callconv(.C) tb_status_t {
-    return init(
-        TestingContext,
-        out_client,
-        out_packets,
-        cluster_id,
-        addresses_ptr,
-        addresses_len,
-        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 {
-    // Pick the most suitable allocator for the platform.
-    const 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 {
-            var gpa = std.heap.HeapAllocator.init();
-        }).gpa.allocator()
-    else
-        @compileError("tb_client must be built with libc");
-
-    const addresses = @ptrCast([*]const u8, addresses_ptr)[0..addresses_len];
-    const context = Context.init(
-        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,
-) void {
-    const context = client_to_context(client);
-    (context.submit_fn)(context, packets);
-}
-
-pub export fn tb_client_deinit(
-    client: tb_client_t,
-) void {
-    const context = client_to_context(client);
-    (context.deinit_fn)(context);
-}

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

@@ -1,218 +0,0 @@
-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/tb_client_header_test.zig

@@ -1,135 +0,0 @@
-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),
-        }
-    }
-}