tigerbeetle-node 0.10.0 → 0.11.1

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) {

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

@@ -1,180 +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.", .{});
-            self.addresses = vsr.parse_addresses(self.allocator, addresses) 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,
@@ -188,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;
         }
 
@@ -204,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.
@@ -233,97 +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();
-                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, message, 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, message, 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, message, 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;
-
-            // Complete the packet without a message as it's already unref()'s by the Client.
-            assert(packet.operation == @enumToInt(op));
-            self.on_complete(packet, null, results);
-        }
-
-        const PacketError = Client.Error || error{
-            TooMuchData,
-            InvalidOperation,
-            InvalidDataSize,
-        };
-
-        fn on_complete(
-            self: *Self,
-            packet: *Packet,
-            message: ?*Message,
-            result: PacketError![]const u8,
-        ) void {
-            // Mark the message as completed
-            if (message) |m| self.client.unref(m);
-            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);
-        }
     };
 }