tigerbeetle 0.0.40 → 0.17.8

data/ext/tb_client/tigerbeetle/src/clients/dotnet/dotnet_bindings.zig

@@ -1,542 +0,0 @@
-const std = @import("std");
-const vsr = @import("vsr");
-
-const assert = std.debug.assert;
-const stdx = vsr.stdx;
-const tb = vsr.tigerbeetle;
-const exports = vsr.tb_client.exports;
-
-const TypeMapping = struct {
-    name: []const u8,
-    visibility: enum { public, internal },
-    private_fields: []const []const u8 = &.{},
-    readonly_fields: []const []const u8 = &.{},
-    docs_link: ?[]const u8 = null,
-    constants: []const u8 = "",
-
-    pub fn is_private(comptime self: @This(), name: []const u8) bool {
-        inline for (self.private_fields) |field| {
-            if (std.mem.eql(u8, field, name)) {
-                return true;
-            }
-        } else return false;
-    }
-
-    pub fn is_read_only(comptime self: @This(), name: []const u8) bool {
-        inline for (self.readonly_fields) |field| {
-            if (std.mem.eql(u8, field, name)) {
-                return true;
-            }
-        } else return false;
-    }
-};
-
-const type_mappings = .{
-    .{ tb.AccountFlags, TypeMapping{
-        .name = "AccountFlags",
-        .visibility = .public,
-        .private_fields = &.{"padding"},
-        .docs_link = "reference/account#flags",
-    } },
-    .{ tb.TransferFlags, TypeMapping{
-        .name = "TransferFlags",
-        .visibility = .public,
-        .private_fields = &.{"padding"},
-        .docs_link = "reference/transfer#flags",
-    } },
-    .{ tb.AccountFilterFlags, TypeMapping{
-        .name = "AccountFilterFlags",
-        .visibility = .public,
-        .private_fields = &.{"padding"},
-        .docs_link = "reference/account-filter#flags",
-    } },
-    .{ tb.QueryFilterFlags, TypeMapping{
-        .name = "QueryFilterFlags",
-        .visibility = .public,
-        .private_fields = &.{"padding"},
-        .docs_link = "reference/query-filter#flags",
-    } },
-    .{ tb.Account, TypeMapping{
-        .name = "Account",
-        .visibility = .public,
-        .private_fields = &.{"reserved"},
-        .readonly_fields = &.{
-            "debits_pending",
-            "credits_pending",
-            "debits_posted",
-            "credits_posted",
-        },
-        .docs_link = "reference/account#",
-    } },
-    .{
-        tb.Transfer, TypeMapping{
-            .name = "Transfer",
-            .visibility = .public,
-            .private_fields = &.{"reserved"},
-            .readonly_fields = &.{},
-            .docs_link = "reference/transfer#",
-            .constants =
-            \\    public static UInt128 AmountMax => UInt128.MaxValue;
-            \\
-            ,
-        },
-    },
-    .{ tb.CreateAccountResult, TypeMapping{
-        .name = "CreateAccountResult",
-        .visibility = .public,
-        .docs_link = "reference/requests/create_accounts#",
-    } },
-    .{ tb.CreateTransferResult, TypeMapping{
-        .name = "CreateTransferResult",
-        .visibility = .public,
-        .docs_link = "reference/requests/create_transfers#",
-    } },
-    .{ tb.CreateAccountsResult, TypeMapping{
-        .name = "CreateAccountsResult",
-        .visibility = .public,
-    } },
-    .{ tb.CreateTransfersResult, TypeMapping{
-        .name = "CreateTransfersResult",
-        .visibility = .public,
-    } },
-    .{ tb.AccountFilter, TypeMapping{
-        .name = "AccountFilter",
-        .visibility = .public,
-        .private_fields = &.{"reserved"},
-        .docs_link = "reference/account-filter#",
-    } },
-    .{ tb.AccountBalance, TypeMapping{
-        .name = "AccountBalance",
-        .visibility = .public,
-        .private_fields = &.{"reserved"},
-        .docs_link = "reference/account-balances#",
-    } },
-    .{ tb.QueryFilter, TypeMapping{
-        .name = "QueryFilter",
-        .visibility = .public,
-        .private_fields = &.{"reserved"},
-        .docs_link = "reference/query-filter#",
-    } },
-    .{ exports.tb_init_status, TypeMapping{
-        .name = "InitializationStatus",
-        .visibility = .public,
-    } },
-    .{ exports.tb_client_status, TypeMapping{
-        .name = "ClientStatus",
-        .visibility = .internal,
-    } },
-    .{ exports.tb_packet_status, TypeMapping{
-        .name = "PacketStatus",
-        .visibility = .public,
-    } },
-    .{ exports.tb_operation, TypeMapping{
-        .name = "TBOperation",
-        .visibility = .internal,
-        .private_fields = &.{ "reserved", "root", "register" },
-    } },
-    .{ exports.tb_client_t, TypeMapping{
-        .name = "TBClient",
-        .visibility = .internal,
-        .private_fields = &.{"opaque"},
-    } },
-    .{ exports.tb_packet_t, TypeMapping{
-        .name = "TBPacket",
-        .visibility = .internal,
-        .private_fields = &.{"opaque"},
-    } },
-};
-
-fn dotnet_type(comptime Type: type) []const u8 {
-    switch (@typeInfo(Type)) {
-        .@"enum", .@"struct" => return comptime get_mapped_type_name(Type) orelse
-            @compileError("Type " ++ @typeName(Type) ++ " not mapped."),
-        .bool => return "byte",
-        .int => |info| {
-            assert(info.signedness == .unsigned);
-            return switch (info.bits) {
-                8 => "byte",
-                16 => "ushort",
-                32 => "uint",
-                64 => "ulong",
-                128 => "UInt128",
-                else => @compileError("invalid int type"),
-            };
-        },
-        .optional => |info| switch (@typeInfo(info.child)) {
-            .pointer => return dotnet_type(info.child),
-            else => @compileError("Unsupported optional type: " ++ @typeName(Type)),
-        },
-        .pointer => |info| {
-            assert(info.size != .slice);
-            assert(!info.is_allowzero);
-
-            return if (comptime get_mapped_type_name(info.child)) |name|
-                name ++ "*"
-            else
-                dotnet_type(info.child);
-        },
-        .void, .@"opaque" => return "IntPtr",
-        else => @compileError("Unhandled type: " ++ @typeName(Type)),
-    }
-}
-
-fn get_mapped_type_name(comptime Type: type) ?[]const u8 {
-    inline for (type_mappings) |type_mapping| {
-        if (Type == type_mapping[0]) {
-            return type_mapping[1].name;
-        }
-    } else return null;
-}
-
-fn to_case(comptime input: []const u8, comptime case: enum { camel, pascal }) []const u8 {
-    return comptime blk: {
-        var len: usize = 0;
-        var output: [input.len]u8 = undefined;
-        var iterator = std.mem.tokenizeScalar(u8, input, '_');
-        while (iterator.next()) |word| {
-            _ = std.ascii.lowerString(output[len..], word);
-            output[len] = std.ascii.toUpper(output[len]);
-            len += word.len;
-        }
-
-        output[0] = switch (case) {
-            .camel => std.ascii.toLower(output[0]),
-            .pascal => std.ascii.toUpper(output[0]),
-        };
-
-        break :blk stdx.comptime_slice(&output, len);
-    };
-}
-
-fn emit_enum(
-    buffer: *std.ArrayList(u8),
-    comptime Type: type,
-    comptime type_info: anytype,
-    comptime mapping: TypeMapping,
-    comptime int_type: []const u8,
-) !void {
-    const is_packed_struct = @TypeOf(type_info) == std.builtin.Type.Struct;
-    if (is_packed_struct) {
-        assert(type_info.layout == .@"packed");
-        // Packed structs represented as Enum needs a Flags attribute:
-        try buffer.writer().print("[Flags]\n", .{});
-    }
-
-    try buffer.writer().print(
-        \\{s} enum {s} : {s}
-        \\{{
-        \\
-    , .{
-        @tagName(mapping.visibility),
-        mapping.name,
-        int_type,
-    });
-
-    if (is_packed_struct) {
-        // Packed structs represented as Enum needs a ZERO value:
-        try buffer.writer().print(
-            \\    None = 0,
-            \\
-            \\
-        , .{});
-    }
-
-    inline for (type_info.fields, 0..) |field, i| {
-        if (comptime mapping.is_private(field.name)) continue;
-        if (comptime std.mem.startsWith(u8, field.name, "deprecated_")) continue;
-
-        try emit_docs(buffer, mapping, field.name);
-        if (is_packed_struct) {
-            try buffer.writer().print("    {s} = 1 << {},\n\n", .{
-                to_case(field.name, .pascal),
-                i,
-            });
-        } else {
-            try buffer.writer().print("    {s} = {},\n\n", .{
-                to_case(field.name, .pascal),
-                @intFromEnum(@field(Type, field.name)),
-            });
-        }
-    }
-
-    try buffer.writer().print(
-        \\}}
-        \\
-        \\
-    , .{});
-}
-
-fn emit_struct(
-    buffer: *std.ArrayList(u8),
-    comptime type_info: anytype,
-    comptime mapping: TypeMapping,
-    comptime size: usize,
-) !void {
-    try buffer.writer().print(
-        \\[StructLayout(LayoutKind.Sequential, Size = SIZE)]
-        \\{s} {s}struct {s}
-        \\{{
-        \\    public const int SIZE = {};
-        \\
-        \\{s}
-        \\
-    , .{
-        @tagName(mapping.visibility),
-        if (mapping.visibility == .internal) "unsafe " else "",
-        mapping.name,
-        size,
-        mapping.constants,
-    });
-
-    // Fixed len array are exposed as internal structs with stackalloc fields
-    // It's more efficient than exposing heap-allocated arrays using
-    // [MarshalAs(UnmanagedType.ByValArray)] attribute.
-    inline for (type_info.fields) |field| {
-        switch (@typeInfo(field.type)) {
-            .array => |array| {
-                try buffer.writer().print(
-                    \\    [StructLayout(LayoutKind.Sequential, Size = {[name]s}Data.SIZE)]
-                    \\    private unsafe struct {[name]s}Data
-                    \\    {{
-                    \\        public const int SIZE = {[size]};
-                    \\        private const int LENGTH = {[len]};
-                    \\
-                    \\        private fixed {[child_type]s} raw[LENGTH];
-                    \\
-                    \\        public {[child_type]s}[] GetData()
-                    \\        {{
-                    \\            fixed (void* ptr = raw)
-                    \\            {{
-                    \\                return new ReadOnlySpan<{[child_type]s}>(ptr, LENGTH).ToArray();
-                    \\            }}
-                    \\        }}
-                    \\
-                    \\        public void SetData({[child_type]s}[] value)
-                    \\        {{
-                    \\            if (value == null) throw new ArgumentNullException(nameof(value));
-                    \\            if (value.Length != LENGTH)
-                    \\            {{
-                    \\                throw new ArgumentException(
-                    \\                    "Expected a {[child_type]s}[" + LENGTH + "] array",
-                    \\                    nameof(value));
-                    \\            }}
-                    \\
-                    \\            fixed (void* ptr = raw)
-                    \\            {{
-                    \\                value.CopyTo(new Span<{[child_type]s}>(ptr, LENGTH));
-                    \\            }}
-                    \\        }}
-                    \\    }}
-                    \\
-                    \\
-                , .{
-                    .name = to_case(field.name, .pascal),
-                    .size = array.len * @sizeOf(array.child),
-                    .len = array.len,
-                    .child_type = dotnet_type(array.child),
-                });
-            },
-            else => {},
-        }
-    }
-
-    // Fields
-    inline for (type_info.fields) |field| {
-        const is_private = comptime mapping.is_private(field.name);
-
-        switch (@typeInfo(field.type)) {
-            .array => try buffer.writer().print(
-                \\    {s} {s}Data {s};
-                \\
-                \\
-            ,
-                .{
-                    if (mapping.visibility == .internal and !is_private) "public" else "private",
-                    to_case(field.name, .pascal),
-                    to_case(field.name, .camel),
-                },
-            ),
-            else => try buffer.writer().print(
-                \\    {s} {s} {s};
-                \\
-                \\
-            ,
-                .{
-                    if (mapping.visibility == .internal and !is_private) "public" else "private",
-                    dotnet_type(field.type),
-                    to_case(field.name, .camel),
-                },
-            ),
-        }
-    }
-
-    if (mapping.visibility == .public) {
-
-        // Properties
-        inline for (type_info.fields) |field| {
-            try emit_docs(buffer, mapping, field.name);
-
-            const is_private = comptime mapping.is_private(field.name);
-            const is_read_only = comptime mapping.is_read_only(field.name);
-
-            switch (@typeInfo(field.type)) {
-                .array => try buffer.writer().print(
-                    \\    {s} byte[] {s} {{ get => {s}.GetData(); {s}set => {s}.SetData(value); }}
-                    \\
-                    \\
-                , .{
-                    if (is_private) "internal" else "public",
-                    to_case(field.name, .pascal),
-                    to_case(field.name, .camel),
-                    if (is_read_only and !is_private) "internal " else "",
-                    to_case(field.name, .camel),
-                }),
-                else => try buffer.writer().print(
-                    \\    {s} {s} {s} {{ get => {s}; {s}set => {s} = value; }}
-                    \\
-                    \\
-                , .{
-                    if (is_private) "internal" else "public",
-                    dotnet_type(field.type),
-                    to_case(field.name, .pascal),
-                    to_case(field.name, .camel),
-                    if (is_read_only and !is_private) "internal " else "",
-                    to_case(field.name, .camel),
-                }),
-            }
-        }
-    }
-
-    try buffer.writer().print(
-        \\}}
-        \\
-        \\
-    , .{});
-}
-
-fn emit_docs(buffer: anytype, comptime mapping: TypeMapping, comptime field: ?[]const u8) !void {
-    if (mapping.docs_link) |docs_link| {
-        try buffer.writer().print(
-            \\    /// <summary>
-            \\    /// https://docs.tigerbeetle.com/{s}{s}
-            \\    /// </summary>
-            \\
-        , .{
-            docs_link,
-            field orelse "",
-        });
-    }
-}
-
-pub fn generate_bindings(buffer: *std.ArrayList(u8)) !void {
-    @setEvalBranchQuota(100_000);
-
-    try buffer.writer().print(
-        \\//////////////////////////////////////////////////////////
-        \\// This file was auto-generated by dotnet_bindings.zig  //
-        \\//              Do not manually modify.                 //
-        \\//////////////////////////////////////////////////////////
-        \\
-        \\using System;
-        \\using System.Runtime.InteropServices;
-        \\
-        \\namespace TigerBeetle;
-        \\
-        \\
-    , .{});
-
-    // Emit C# declarations.
-    inline for (type_mappings) |type_mapping| {
-        const ZigType = type_mapping[0];
-        const mapping = type_mapping[1];
-
-        switch (@typeInfo(ZigType)) {
-            .@"struct" => |info| switch (info.layout) {
-                .auto => @compileError(
-                    "Only packed or extern structs are supported: " ++ @typeName(ZigType),
-                ),
-                .@"packed" => try emit_enum(
-                    buffer,
-                    ZigType,
-                    info,
-                    mapping,
-                    comptime dotnet_type(
-                        std.meta.Int(.unsigned, @bitSizeOf(ZigType)),
-                    ),
-                ),
-                .@"extern" => try emit_struct(
-                    buffer,
-                    info,
-                    mapping,
-                    @sizeOf(ZigType),
-                ),
-            },
-            .@"enum" => |info| try emit_enum(
-                buffer,
-                ZigType,
-                info,
-                mapping,
-                comptime dotnet_type(std.meta.Int(.unsigned, @bitSizeOf(ZigType))),
-            ),
-            else => @compileError("Type cannot be represented: " ++ @typeName(ZigType)),
-        }
-    }
-
-    // Emit 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(
-        \\internal static class Native
-        \\{{
-        \\    private const string LIB_NAME = "tb_client";
-        \\
-        \\    [DllImport(LIB_NAME, CallingConvention = CallingConvention.Cdecl)]
-        \\    public static unsafe extern InitializationStatus tb_client_init(
-        \\        TBClient* client_out,
-        \\        UInt128Extensions.UnsafeU128* cluster_id,
-        \\        byte* address_ptr,
-        \\        uint address_len,
-        \\        IntPtr completion_ctx,
-        \\        delegate* unmanaged[Cdecl]<IntPtr,
-        \\                                   TBPacket*, ulong,
-        \\                                   byte*, uint, void> completion_callback
-        \\    );
-        \\
-        \\    [DllImport(LIB_NAME, CallingConvention = CallingConvention.Cdecl)]
-        \\    public static unsafe extern InitializationStatus tb_client_init_echo(
-        \\        TBClient* out_client,
-        \\        UInt128Extensions.UnsafeU128* cluster_id,
-        \\        byte* address_ptr,
-        \\        uint address_len,
-        \\        IntPtr completion_ctx,
-        \\        delegate* unmanaged[Cdecl]<IntPtr,
-        \\                                   TBPacket*, ulong,
-        \\                                   byte*, uint, void> completion_callback
-        \\    );
-        \\
-        \\    [DllImport(LIB_NAME, CallingConvention = CallingConvention.Cdecl)]
-        \\    public static unsafe extern ClientStatus tb_client_submit(
-        \\        TBClient* client,
-        \\        TBPacket* packet
-        \\    );
-        \\
-        \\    [DllImport(LIB_NAME, CallingConvention = CallingConvention.Cdecl)]
-        \\    public static unsafe extern ClientStatus tb_client_deinit(
-        \\        TBClient* client
-        \\    );
-        \\}}
-        \\
-        \\
-    , .{});
-}
-
-pub fn main() !void {
-    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 generate_bindings(&buffer);
-
-    try std.io.getStdOut().writeAll(buffer.items);
-}

data/ext/tb_client/tigerbeetle/src/clients/go/ci.zig

@@ -1,109 +0,0 @@
-const builtin = @import("builtin");
-const std = @import("std");
-const log = std.log;
-const assert = std.debug.assert;
-
-const Shell = @import("../../shell.zig");
-const TmpTigerBeetle = @import("../../testing/tmp_tigerbeetle.zig");
-
-pub fn tests(shell: *Shell, gpa: std.mem.Allocator) !void {
-    assert(shell.file_exists("go.mod"));
-
-    const bad_formatting = try shell.exec_stdout("gofmt -l .", .{});
-    if (!std.mem.eql(u8, bad_formatting, "")) {
-        log.err("these go files need formatting:\n'{s}'", .{bad_formatting});
-        return error.GoFmt;
-    }
-
-    try shell.exec("go vet", .{});
-
-    // `go build`  won't compile the native library automatically, we need to do that ourselves.
-    try shell.exec_zig("build clients:go -Drelease", .{});
-    try shell.exec_zig("build -Drelease", .{});
-
-    // Although we have compiled the TigerBeetle client library, we still need `cgo` to link it with
-    // our resulting Go binary. Strictly speaking, `CC` is controlled by the users of TigerBeetle,
-    // so ideally we should test common flavors of gcc. For simplicity, we:
-    //   - use `zig cc` on Windows, as that doesn't have `gcc` out of the box
-    //   - use `zig cc` on Linux. It might or might not have `gcc`, but `zig cc` makes our CI more
-    //     reproducible
-    //   - (implicitly) use `gcc` on Mac, as `zig cc` doesn't work there:
-    //     <https://github.com/ziglang/zig/issues/15438>
-    switch (builtin.os.tag) {
-        .linux, .windows => {
-            const zig_cc = try shell.fmt("{s} cc", .{shell.zig_exe.?});
-            try shell.env.put("CC", zig_cc);
-        },
-        .macos => {},
-        else => unreachable,
-    }
-
-    try shell.exec("go test", .{});
-    {
-        log.info("testing `types` package helpers", .{});
-
-        try shell.pushd("./pkg/types");
-        defer shell.popd();
-
-        try shell.exec("go test", .{});
-    }
-
-    inline for (.{ "basic", "two-phase", "two-phase-many", "walkthrough" }) |sample| {
-        log.info("testing sample '{s}'", .{sample});
-
-        try shell.pushd("./samples/" ++ sample);
-        defer shell.popd();
-
-        var tmp_beetle = try TmpTigerBeetle.init(gpa, .{
-            .development = true,
-        });
-        defer tmp_beetle.deinit(gpa);
-        errdefer tmp_beetle.log_stderr();
-
-        try shell.env.put("TB_ADDRESS", tmp_beetle.port_str);
-        try shell.exec("go build main.go", .{});
-        try shell.exec("./main" ++ builtin.target.exeFileExt(), .{});
-    }
-}
-
-pub fn validate_release(shell: *Shell, gpa: std.mem.Allocator, options: struct {
-    version: []const u8,
-    tigerbeetle: []const u8,
-}) !void {
-    var tmp_beetle = try TmpTigerBeetle.init(gpa, .{
-        .development = true,
-        .prebuilt = options.tigerbeetle,
-    });
-    defer tmp_beetle.deinit(gpa);
-    errdefer tmp_beetle.log_stderr();
-
-    try shell.env.put("TB_ADDRESS", tmp_beetle.port_str);
-
-    try shell.exec("go mod init tbtest", .{});
-    try shell.exec("go get github.com/tigerbeetle/tigerbeetle-go@v{version}", .{
-        .version = options.version,
-    });
-
-    try Shell.copy_path(
-        shell.project_root,
-        "src/clients/go/samples/basic/main.go",
-        shell.cwd,
-        "main.go",
-    );
-    const zig_cc = try shell.fmt("{s} cc", .{shell.zig_exe.?});
-
-    try shell.env.put("CC", zig_cc);
-    try shell.exec("go run main.go", .{});
-}
-
-pub fn release_published_latest(shell: *Shell) ![]const u8 {
-    // Example output:
-    //  github.com/tigerbeetle/tigerbeetle-go v0.9.149 v0.13.56 v0.13.57
-    const output = try shell.exec_stdout(
-        "go list -m -versions github.com/tigerbeetle/tigerbeetle-go",
-        .{},
-    );
-    const last_version = std.mem.lastIndexOf(u8, output, " v").?;
-
-    return output[last_version + 2 ..];
-}