tigerbeetle 0.0.40 → 0.17.8

data/ext/tb_client/tigerbeetle/src/repl.zig

@@ -1,1034 +0,0 @@
-const std = @import("std");
-const assert = std.debug.assert;
-
-const vsr = @import("vsr.zig");
-const stdx = vsr.stdx;
-const constants = vsr.constants;
-const IO = vsr.io.IO;
-const Time = vsr.time.Time;
-const StaticAllocator = @import("static_allocator.zig");
-const MessagePool = vsr.message_pool.MessagePool;
-const RingBufferType = stdx.RingBufferType;
-const tb = vsr.tigerbeetle;
-
-const Terminal = @import("repl/terminal.zig").Terminal;
-const Completion = @import("repl/completion.zig").Completion;
-const Parser = @import("repl/parser.zig").Parser;
-
-const repl_history_entries = 256;
-const repl_history_entry_bytes_with_nul = 512;
-const repl_history_entry_bytes_without_nul = 511;
-
-const ReplBufferBoundedArray = stdx.BoundedArrayType(u8, repl_history_entry_bytes_without_nul);
-
-pub fn ReplType(comptime MessageBus: type) type {
-    const Client = vsr.ClientType(tb.Operation, MessageBus);
-
-    // Requires 512 * 256 == 128KiB of stack space.
-    const HistoryBuffer = RingBufferType(
-        [repl_history_entry_bytes_with_nul]u8,
-        .{ .array = repl_history_entries },
-    );
-
-    return struct {
-        event_loop_done: bool,
-        request_done: bool,
-
-        interactive: bool,
-        debug_logs: bool,
-
-        client: Client,
-        terminal: Terminal,
-        completion: Completion,
-        history: HistoryBuffer,
-
-        /// Fixed-capacity buffer for reading input strings.
-        buffer: ReplBufferBoundedArray,
-        /// Saved input string while navigating through history.
-        buffer_outside_history: ReplBufferBoundedArray,
-
-        arguments: std.ArrayListUnmanaged(u8),
-        message_pool: *MessagePool,
-        io: *IO,
-
-        static_allocator: StaticAllocator,
-
-        const Repl = @This();
-
-        fn fail(repl: *const Repl, comptime format: []const u8, arguments: anytype) !void {
-            if (!repl.interactive) {
-                try repl.terminal.print_error(format, arguments);
-                std.process.exit(1);
-            }
-
-            try repl.terminal.print(format, arguments);
-        }
-
-        fn debug(repl: *const Repl, comptime format: []const u8, arguments: anytype) !void {
-            if (repl.debug_logs) {
-                try repl.terminal.print("[Debug] " ++ format, arguments);
-            }
-        }
-
-        fn do_statement(
-            repl: *Repl,
-            statement: Parser.Statement,
-        ) !void {
-            try repl.debug("Running command: {}.\n", .{statement.operation});
-            switch (statement.operation) {
-                .none => {
-                    // No input was parsed.
-                    try repl.debug("No command was parsed, continuing.\n", .{});
-                },
-                .help => {
-                    try repl.display_help();
-                },
-
-                .create_accounts,
-                .create_transfers,
-                .lookup_accounts,
-                .lookup_transfers,
-                .get_account_transfers,
-                .get_account_balances,
-                .query_accounts,
-                .query_transfers,
-                => |operation| {
-                    const state_machine_operation = operation.state_machine_op();
-                    try repl.send(
-                        state_machine_operation,
-                        statement.arguments,
-                    );
-                },
-            }
-        }
-
-        const prompt = "> ";
-
-        fn read_until_newline_or_eof(
-            repl: *Repl,
-        ) !?[]const u8 {
-            repl.buffer.clear();
-            repl.buffer_outside_history.clear();
-
-            try repl.terminal.prompt_mode_set();
-            defer repl.terminal.prompt_mode_unset() catch {};
-
-            var terminal_screen = try repl.terminal.get_screen();
-
-            var buffer_index: usize = 0;
-            var history_index = repl.history.count;
-
-            var current_completion: []const u8 = "";
-
-            while (true) {
-                const user_input = try repl.terminal.read_user_input() orelse return null;
-
-                // Clear the completion menu when a match is selected or another key is pressed.
-                if (user_input != .tab and repl.completion.count() > 0) {
-                    repl.completion.clear();
-                    try repl.terminal.print("\x1b[{};1H\x1b[J\x1b[{};{}H", .{
-                        terminal_screen.cursor_row + 1,
-                        terminal_screen.cursor_row,
-                        terminal_screen.cursor_column,
-                    });
-                }
-
-                switch (user_input) {
-                    .ctrld => {
-                        if (repl.buffer.count() == 0 and buffer_index == 0) {
-                            return null;
-                        }
-                        if (buffer_index < repl.buffer.count()) {
-                            try repl.terminal.print("\x1b[{};{}H{s}\x20\x1b[{};{}H", .{
-                                terminal_screen.cursor_row,
-                                terminal_screen.cursor_column,
-                                repl.buffer.const_slice()[buffer_index + 1 ..],
-                                terminal_screen.cursor_row,
-                                terminal_screen.cursor_column,
-                            });
-                            _ = repl.buffer.ordered_remove(buffer_index);
-                        }
-                    },
-                    .ctrlc => {
-                        // Move to end of line, print "^C" and abort the command.
-                        const position_end_diff = @as(
-                            isize,
-                            @intCast(repl.buffer.count() - buffer_index),
-                        );
-                        terminal_screen.update_cursor_position(position_end_diff);
-                        try repl.terminal.print("\x1b[{};{}H", .{
-                            terminal_screen.cursor_row,
-                            terminal_screen.cursor_column,
-                        });
-                        try repl.terminal.print("^C\n", .{});
-                        repl.buffer.clear();
-                        return &.{};
-                    },
-                    .newline => {
-                        // Move to end of buffer, then return.
-                        const position_end_diff = @as(
-                            isize,
-                            @intCast(repl.buffer.count() - buffer_index),
-                        );
-                        terminal_screen.update_cursor_position(position_end_diff);
-                        try repl.terminal.print("\x1b[{};{}H", .{
-                            terminal_screen.cursor_row,
-                            terminal_screen.cursor_column,
-                        });
-                        try repl.terminal.print("\n", .{});
-                        return repl.buffer.const_slice();
-                    },
-                    .printable => |character| {
-                        if (repl.buffer.count() == repl_history_entry_bytes_without_nul) {
-                            continue;
-                        }
-
-                        const is_append = buffer_index == repl.buffer.count();
-                        if (is_append) {
-                            terminal_screen.update_cursor_position(1);
-                            try repl.terminal.print("{c}", .{character});
-                            // Some terminals may not automatically move/scroll us down to the next
-                            // row after appending a character at the last column. This can cause us
-                            // to incorrectly report the cursor's position, so we force the terminal
-                            // to do so by moving the cursor forward and backward one space.
-                            if (terminal_screen.cursor_column == terminal_screen.columns) {
-                                try repl.terminal.print("\x20\x1b[{};{}H", .{
-                                    terminal_screen.cursor_row,
-                                    terminal_screen.cursor_column,
-                                });
-                            }
-                        } else {
-                            // If we're inserting mid-buffer, we need to redraw everything that
-                            // comes after as well. We'll track as if the cursor moved to the end of
-                            // the buffer after redrawing, and move it back to one position after
-                            // the newly inserted character.
-                            const buffer_redraw_len: isize = @intCast(
-                                repl.buffer.count() - buffer_index,
-                            );
-                            // It's crucial to update in two steps because the terminal may have
-                            // scrolled down as part of the text redraw.
-                            terminal_screen.update_cursor_position(buffer_redraw_len);
-                            terminal_screen.update_cursor_position(1 - buffer_redraw_len);
-                            try repl.terminal.print("{c}{s}\x1b[{};{}H", .{
-                                character,
-                                repl.buffer.const_slice()[buffer_index..],
-                                terminal_screen.cursor_row,
-                                terminal_screen.cursor_column,
-                            });
-                        }
-
-                        repl.buffer.insert_at(buffer_index, character);
-                        buffer_index += 1;
-                    },
-                    .backspace => if (buffer_index > 0) {
-                        terminal_screen.update_cursor_position(-1);
-                        // Move to new position, write the remaining buffer,
-                        // write a space (\x20) to overwrite the last character,
-                        // then move back to the new position.
-                        try repl.terminal.print("\x1b[{};{}H{s}\x20\x1b[{};{}H", .{
-                            terminal_screen.cursor_row,
-                            terminal_screen.cursor_column,
-                            // If we're deleting mid-buffer, we need to redraw everything that
-                            // comes after as well.
-                            if (buffer_index < repl.buffer.count())
-                                repl.buffer.const_slice()[buffer_index..]
-                            else
-                                "",
-                            terminal_screen.cursor_row,
-                            terminal_screen.cursor_column,
-                        });
-                        buffer_index -= 1;
-                        _ = repl.buffer.ordered_remove(buffer_index);
-                    },
-                    .delete => if (buffer_index < repl.buffer.count()) {
-                        try repl.terminal.print("\x1b[{};{}H{s}\x20\x1b[{};{}H", .{
-                            terminal_screen.cursor_row,
-                            terminal_screen.cursor_column,
-                            repl.buffer.const_slice()[buffer_index + 1 ..],
-                            terminal_screen.cursor_row,
-                            terminal_screen.cursor_column,
-                        });
-                        _ = repl.buffer.ordered_remove(buffer_index);
-                    },
-                    .tab => {
-                        try repl.completion.split_and_complete(repl.buffer.slice(), buffer_index);
-
-                        current_completion = try repl.completion.get_next_completion();
-
-                        // Skip the current completion entry if adding it would overflow the buffer.
-                        if ((repl.completion.prefix.count() + repl.completion.suffix.count() +
-                            current_completion.len) >= repl_history_entry_bytes_without_nul)
-                        {
-                            continue;
-                        }
-
-                        // Move cursor to the start of the current row, clear the screen from start
-                        // to end. Then print the leading buffer, currently selected completion and
-                        // trailing buffer(if any).
-                        terminal_screen.update_cursor_position(-@as(isize, @intCast(buffer_index)));
-
-                        const buffer_row = terminal_screen.cursor_row;
-
-                        terminal_screen.update_cursor_position(
-                            @as(
-                                isize,
-                                @intCast(repl.completion.prefix.count() + current_completion.len),
-                            ),
-                        );
-
-                        // \x1b[n;mH - Moves the cursor to row n, column m.
-                        // \x1b[J - Clear the screen from current cursor position to end.
-                        try repl.terminal.print("\x1b[{};1H\x1b[J{s}{s}{s}{s}\x20\x08", .{
-                            buffer_row,
-                            prompt,
-                            repl.completion.prefix.const_slice(),
-                            current_completion,
-                            repl.completion.suffix.const_slice(),
-                        });
-
-                        // When cursor reaches the last row of terminal, scroll content upward
-                        // to create space for displaying completion menu.
-                        // \x1b[nS - Scroll whole page up by n lines; default 1 line.
-                        // \x1b[nA - Moves cursor up n cells; default 1 cell up.
-                        if (terminal_screen.cursor_row == terminal_screen.rows) {
-                            try repl.terminal.print("\x1b[S\x1b[A", .{});
-                        }
-
-                        // Position cursor for completion menu. If the current buffer overflows to
-                        // the next line after printing the prefix, selected completion and suffix,
-                        // the completion menu should effectively be placed `row_delta` lines below
-                        // the current buffer row.
-                        const buffer_width =
-                            repl.completion.prefix.count() +
-                            repl.completion.suffix.count() +
-                            current_completion.len + 1;
-                        const row_delta = @divFloor(buffer_width, terminal_screen.columns) + 1;
-                        try repl.terminal.print("\x1b[{};1H", .{buffer_row + row_delta});
-
-                        // Display completion menu in the next line and highlight the currently
-                        // selected completion.
-                        var menu_width: usize = 0;
-                        var match_itr = repl.completion.matches.iterator();
-
-                        while (match_itr.next()) |match| {
-                            const match_len = std.mem.indexOfScalar(u8, match[0..], '\x00').?;
-                            menu_width += match_len + 2;
-
-                            // \x1b[7m - Highlights the text by inverting the color. Inverts
-                            //           the text and background color.
-                            // \x1b[0m - Reset the style property of text. In this case, resets
-                            //           the effect of \x1b[7m - color inversion.
-                            if (std.mem.eql(u8, match[0..match_len], current_completion)) {
-                                try repl.terminal.print("\x20\x1b[7m{s}\x1b[0m\x20", .{
-                                    match[0..match_len],
-                                });
-                            } else {
-                                try repl.terminal.print("\x20{s}\x20", .{match[0..match_len]});
-                            }
-                        }
-
-                        // If the completion menu overflows past the last row of terminal screen,
-                        // move the cursor up by number of rows that would be overflown.
-                        const menu_rows = @divFloor(menu_width, terminal_screen.columns) + 1;
-                        const required_rows = terminal_screen.cursor_row + menu_rows;
-                        const overflow_rows = @as(
-                            isize,
-                            @intCast(required_rows),
-                        ) - @as(
-                            isize,
-                            @intCast(terminal_screen.rows),
-                        );
-                        if (overflow_rows > 0) {
-                            terminal_screen.update_cursor_position(
-                                -@as(isize, @intCast(terminal_screen.columns)) * overflow_rows,
-                            );
-                        }
-
-                        try repl.terminal.print("\x1b[{};{}H", .{
-                            terminal_screen.cursor_row,
-                            terminal_screen.cursor_column,
-                        });
-
-                        // Re-fill the buffer with prefix, current match and suffix. Set the
-                        // buffer index where the current selected match ends.
-                        repl.buffer.clear();
-                        repl.buffer.push_slice(repl.completion.prefix.slice());
-                        repl.buffer.push_slice(current_completion);
-                        repl.buffer.push_slice(repl.completion.suffix.slice());
-                        buffer_index = repl.buffer.count() - repl.completion.suffix.count();
-                    },
-                    .left, .ctrlb => if (buffer_index > 0) {
-                        terminal_screen.update_cursor_position(-1);
-                        try repl.terminal.print("\x1b[{};{}H", .{
-                            terminal_screen.cursor_row,
-                            terminal_screen.cursor_column,
-                        });
-                        buffer_index -= 1;
-                    },
-                    .right, .ctrlf => if (buffer_index < repl.buffer.count()) {
-                        terminal_screen.update_cursor_position(1);
-                        try repl.terminal.print("\x1b[{};{}H", .{
-                            terminal_screen.cursor_row,
-                            terminal_screen.cursor_column,
-                        });
-                        buffer_index += 1;
-                    },
-                    .up, .ctrlp => if (history_index > 0) {
-                        const history_index_next = history_index - 1;
-                        const buffer_next_full = repl.history.get_ptr(history_index_next).?;
-                        const buffer_next = std.mem.sliceTo(buffer_next_full, '\x00');
-                        assert(buffer_next.len < repl_history_entry_bytes_with_nul);
-
-                        // Move to the beginning of the current buffer.
-                        terminal_screen.update_cursor_position(
-                            -@as(isize, @intCast(buffer_index)),
-                        );
-                        const row_current_buffer_start = terminal_screen.cursor_row;
-
-                        // Move to the end of the new buffer.
-                        terminal_screen.update_cursor_position(
-                            @as(isize, @intCast(buffer_next.len)),
-                        );
-
-                        try repl.terminal.print("\x1b[{};1H\x1b[J{s}{s}\x20\x1b[{};{}H", .{
-                            row_current_buffer_start,
-                            prompt,
-                            buffer_next,
-                            terminal_screen.cursor_row,
-                            terminal_screen.cursor_column,
-                        });
-
-                        if (history_index == repl.history.count) {
-                            repl.buffer_outside_history.clear();
-                            repl.buffer_outside_history.push_slice(repl.buffer.const_slice());
-                        }
-                        history_index = history_index_next;
-
-                        repl.buffer.clear();
-                        repl.buffer.push_slice(buffer_next);
-                        buffer_index = repl.buffer.count();
-                    },
-                    .down, .ctrln => if (history_index < repl.history.count) {
-                        const history_index_next = history_index + 1;
-
-                        const buffer_next = if (history_index_next == repl.history.count)
-                            repl.buffer_outside_history.const_slice()
-                        else brk: {
-                            const buffer_next_full = repl.history.get_ptr(history_index_next).?;
-                            const buffer_next = std.mem.sliceTo(buffer_next_full, '\x00');
-                            assert(buffer_next.len < repl_history_entry_bytes_with_nul);
-                            break :brk buffer_next;
-                        };
-
-                        history_index = history_index_next;
-
-                        // Move to the beginning of the current buffer.
-                        terminal_screen.update_cursor_position(
-                            -@as(isize, @intCast(buffer_index)),
-                        );
-                        const row_current_buffer_start = terminal_screen.cursor_row;
-
-                        // Move to the end of the new buffer.
-                        terminal_screen.update_cursor_position(
-                            @as(isize, @intCast(buffer_next.len)),
-                        );
-
-                        try repl.terminal.print("\x1b[{};1H\x1b[J{s}{s}\x20\x1b[{};{}H", .{
-                            row_current_buffer_start,
-                            prompt,
-                            buffer_next,
-                            terminal_screen.cursor_row,
-                            terminal_screen.cursor_column,
-                        });
-
-                        repl.buffer.clear();
-                        repl.buffer.push_slice(buffer_next);
-                        buffer_index = repl.buffer.count();
-                    },
-                    .altf, .ctrlright => {
-                        const forward = move_forward_by_word(repl.buffer.slice(), buffer_index);
-                        terminal_screen.update_cursor_position(
-                            @as(isize, @intCast(forward - buffer_index)),
-                        );
-                        try repl.terminal.print("\x1b[{};{}H", .{
-                            terminal_screen.cursor_row,
-                            terminal_screen.cursor_column,
-                        });
-                        buffer_index = forward;
-                    },
-                    .altb, .ctrlleft => {
-                        const backward = move_backward_by_word(repl.buffer.slice(), buffer_index);
-                        terminal_screen.update_cursor_position(
-                            -@as(isize, @intCast(buffer_index - backward)),
-                        );
-                        try repl.terminal.print("\x1b[{};{}H", .{
-                            terminal_screen.cursor_row,
-                            terminal_screen.cursor_column,
-                        });
-                        buffer_index = backward;
-                    },
-                    .ctrla, .home => {
-                        // Move to start of line.
-                        const position_start_diff = -@as(isize, @intCast(buffer_index));
-                        terminal_screen.update_cursor_position(position_start_diff);
-                        try repl.terminal.print("\x1b[{};{}H", .{
-                            terminal_screen.cursor_row,
-                            terminal_screen.cursor_column,
-                        });
-                        buffer_index = 0;
-                    },
-                    .ctrle, .end => {
-                        // Move to end of line.
-                        const position_end_diff = @as(
-                            isize,
-                            @intCast(repl.buffer.count() - buffer_index),
-                        );
-                        terminal_screen.update_cursor_position(position_end_diff);
-                        try repl.terminal.print("\x1b[{};{}H", .{
-                            terminal_screen.cursor_row,
-                            terminal_screen.cursor_column,
-                        });
-                        buffer_index = repl.buffer.count();
-                    },
-                    .ctrlk => {
-                        // Clear screen from cursor.
-                        try repl.terminal.print("\x1b[J", .{});
-                        repl.buffer.resize(buffer_index) catch unreachable;
-                    },
-                    .ctrll => {
-                        // Move to 0,0 and clear the screen from cursor, print the prompt, then ask
-                        // the terminal for the new position.
-                        try repl.terminal.print("\x1b[0;0H\x1b[J", .{});
-                        try repl.terminal.print(prompt, .{});
-                        terminal_screen = try repl.terminal.get_screen();
-
-                        // Print whatever is in the buffer and move the cursor back to buffer_index.
-                        terminal_screen.update_cursor_position(
-                            @as(isize, @intCast(buffer_index)),
-                        );
-
-                        try repl.terminal.print("{s}\x1b[{};{}H", .{
-                            repl.buffer.const_slice(),
-                            terminal_screen.cursor_row,
-                            terminal_screen.cursor_column,
-                        });
-                    },
-                    .unhandled => {},
-                }
-            }
-            unreachable;
-        }
-
-        fn move_forward_by_word(buffer: []const u8, buffer_index: usize) usize {
-            var cur_pos = buffer_index;
-            while (cur_pos < buffer.len and std.ascii.isWhitespace(buffer[cur_pos])) {
-                cur_pos += 1;
-            }
-            while (cur_pos < buffer.len and !std.ascii.isWhitespace(buffer[cur_pos])) {
-                cur_pos += 1;
-            }
-            return cur_pos;
-        }
-
-        fn move_backward_by_word(buffer: []const u8, buffer_index: usize) usize {
-            var cur_pos = buffer_index;
-            while (cur_pos > 0 and std.ascii.isWhitespace(buffer[cur_pos - 1])) {
-                cur_pos -= 1;
-            }
-            while (cur_pos > 0 and !std.ascii.isWhitespace(buffer[cur_pos - 1])) {
-                cur_pos -= 1;
-            }
-            return cur_pos;
-        }
-
-        fn do_repl(
-            repl: *Repl,
-            arguments: *std.ArrayListUnmanaged(u8),
-        ) !void {
-            try repl.terminal.print(prompt, .{});
-            const input = repl.read_until_newline_or_eof() catch |err| {
-                repl.event_loop_done = true;
-                return err;
-            } orelse {
-                // EOF.
-                repl.event_loop_done = true;
-                try repl.fail("\nExiting.\n", .{});
-                return;
-            };
-
-            if (input.len > 0) {
-                const add_to_history = brk: {
-                    const last_entry = repl.history.tail_ptr_const() orelse break :brk true;
-                    const last_entry_str = std.mem.sliceTo(last_entry, '\x00');
-                    break :brk !std.mem.eql(u8, last_entry_str, input);
-                };
-
-                if (add_to_history) {
-                    // NB: Avoiding big stack allocations below.
-
-                    assert(input.len < repl_history_entry_bytes_with_nul);
-
-                    if (repl.history.full()) {
-                        repl.history.advance_head();
-                    }
-                    const history_tail: *[repl_history_entry_bytes_with_nul]u8 =
-                        repl.history.next_tail_ptr().?;
-                    @memset(history_tail, '\x00');
-                    stdx.copy_left(.inexact, u8, history_tail, input);
-                    repl.history.advance_tail();
-                }
-            }
-
-            const statement = Parser.parse_statement(
-                input,
-                &repl.terminal,
-                arguments,
-            ) catch |err| {
-                switch (err) {
-                    // These are parsing errors, so the REPL should
-                    // not continue to execute this statement but can
-                    // still accept new statements.
-                    Parser.Error.IdentifierBad,
-                    Parser.Error.OperationBad,
-                    Parser.Error.ValueBad,
-                    Parser.Error.KeyValuePairBad,
-                    Parser.Error.KeyValuePairEqualMissing,
-                    Parser.Error.SyntaxMatchNone,
-                    Parser.Error.SliceOperationUnsupported,
-                    // TODO(zig): This will be more convenient to express
-                    // once https://github.com/ziglang/zig/issues/2473 is
-                    // in.
-                    => return,
-
-                    // An unexpected error for which we do
-                    // want the stacktrace.
-                    error.AccessDenied,
-                    error.BrokenPipe,
-                    error.ConnectionResetByPeer,
-                    error.DeviceBusy,
-                    error.DiskQuota,
-                    error.FileTooBig,
-                    error.InputOutput,
-                    error.InvalidArgument,
-                    error.LockViolation,
-                    error.NoSpaceLeft,
-                    error.NotOpenForWriting,
-                    error.OperationAborted,
-                    error.OutOfMemory,
-                    error.SystemResources,
-                    error.Unexpected,
-                    error.WouldBlock,
-                    error.NoDevice,
-                    error.ProcessNotFound,
-                    => return err,
-                }
-            };
-            try repl.do_statement(statement);
-        }
-
-        fn display_help(repl: *Repl) !void {
-            try repl.terminal.print("TigerBeetle CLI Client {}\n" ++
-                \\  Hit enter after a semicolon to run a command.
-                \\  Ctrl+D to exit.
-                \\
-                \\Examples:
-                \\  create_accounts id=1 code=10 ledger=700 flags=linked|history, id=2 code=10 ledger=700;
-                \\  create_transfers id=1 debit_account_id=1 credit_account_id=2 amount=10 ledger=700 code=10;
-                \\  lookup_accounts id=1;
-                \\  lookup_accounts id=1, id=2;
-                \\  get_account_transfers account_id=1 flags=debits|credits;
-                \\  get_account_balances account_id=1 flags=debits|credits;
-                \\
-                \\
-            , .{constants.semver});
-        }
-
-        pub fn init(
-            parent_allocator: std.mem.Allocator,
-            io: *IO,
-            time: Time,
-            options: struct {
-                addresses: []const std.net.Address,
-                cluster_id: u128,
-                verbose: bool,
-            },
-        ) !Repl {
-            var static_allocator = StaticAllocator.init(parent_allocator);
-            const allocator = static_allocator.allocator();
-
-            var arguments = try std.ArrayListUnmanaged(u8).initCapacity(
-                allocator,
-                constants.message_body_size_max,
-            );
-            errdefer arguments.deinit(allocator);
-
-            var message_pool = try allocator.create(MessagePool);
-            errdefer allocator.destroy(message_pool);
-
-            message_pool.* = try MessagePool.init(allocator, .client);
-            errdefer message_pool.deinit(allocator);
-
-            const client_id = stdx.unique_u128();
-            const client = try Client.init(
-                allocator,
-                time,
-                message_pool,
-                .{
-                    .id = client_id,
-                    .cluster = options.cluster_id,
-                    .replica_count = @intCast(options.addresses.len),
-                    .aof_recovery = false,
-                    .message_bus_options = .{
-                        .configuration = options.addresses,
-                        .io = io,
-                        .trace = null,
-                    },
-                },
-            );
-            errdefer client.deinit(allocator);
-
-            // Disable all dynamic allocation from this point onwards.
-            static_allocator.transition_from_init_to_static();
-
-            return .{
-                .client = client,
-                .debug_logs = options.verbose,
-                .request_done = true,
-                .event_loop_done = false,
-                .interactive = false,
-                .terminal = undefined, // Init on run.
-                .completion = undefined, // Init on run.
-                .history = HistoryBuffer.init(), // No corresponding deinit.
-                .buffer = .{},
-                .buffer_outside_history = .{},
-                .arguments = arguments,
-                .message_pool = message_pool,
-                .io = io,
-                .static_allocator = static_allocator,
-            };
-        }
-
-        pub fn deinit(repl: *Repl, allocator: std.mem.Allocator) void {
-            repl.static_allocator.transition_from_static_to_deinit();
-
-            repl.client.deinit(allocator);
-            repl.message_pool.deinit(allocator);
-            allocator.destroy(repl.message_pool);
-            repl.arguments.deinit(allocator);
-        }
-
-        pub fn run(repl: *Repl, statements: []const u8) !void {
-            repl.interactive = statements.len == 0;
-            try Terminal.init(&repl.terminal, repl.interactive); // No corresponding deinit.
-
-            try Completion.init(&repl.completion);
-
-            repl.client.register(register_callback, @intCast(@intFromPtr(repl)));
-            while (!repl.event_loop_done) {
-                repl.client.tick();
-                try repl.io.run_for_ns(constants.tick_ms * std.time.ns_per_ms);
-            }
-            repl.event_loop_done = false;
-
-            if (repl.interactive) {
-                try repl.display_help();
-            }
-
-            var statements_iterator = if (statements.len > 0)
-                std.mem.splitScalar(u8, statements, ';')
-            else
-                null;
-
-            while (!repl.event_loop_done) {
-                if (repl.request_done) {
-                    repl.arguments.clearRetainingCapacity();
-                    if (repl.interactive) {
-                        try repl.do_repl(&repl.arguments);
-                    } else blk: {
-                        const statement_string = statements_iterator.?.next() orelse break :blk;
-
-                        const statement = Parser.parse_statement(
-                            statement_string,
-                            &repl.terminal,
-                            &repl.arguments,
-                        ) catch |err| {
-                            switch (err) {
-                                // These are parsing errors and since this
-                                // is not an interactive command, we should
-                                // exit immediately. Parsing error info
-                                // has already been emitted to stderr.
-                                Parser.Error.IdentifierBad,
-                                Parser.Error.OperationBad,
-                                Parser.Error.ValueBad,
-                                Parser.Error.KeyValuePairBad,
-                                Parser.Error.KeyValuePairEqualMissing,
-                                Parser.Error.SyntaxMatchNone,
-                                Parser.Error.SliceOperationUnsupported,
-                                // TODO: This will be more convenient to express
-                                // once https://github.com/ziglang/zig/issues/2473 is
-                                // in.
-                                => std.posix.exit(1),
-
-                                // An unexpected error for which we do
-                                // want the stacktrace.
-                                error.AccessDenied,
-                                error.BrokenPipe,
-                                error.ConnectionResetByPeer,
-                                error.DeviceBusy,
-                                error.DiskQuota,
-                                error.FileTooBig,
-                                error.InputOutput,
-                                error.InvalidArgument,
-                                error.LockViolation,
-                                error.NoSpaceLeft,
-                                error.NotOpenForWriting,
-                                error.OperationAborted,
-                                error.OutOfMemory,
-                                error.SystemResources,
-                                error.Unexpected,
-                                error.WouldBlock,
-                                error.NoDevice,
-                                error.ProcessNotFound,
-                                => return err,
-                            }
-                        };
-
-                        try repl.do_statement(statement);
-                    }
-                }
-
-                repl.client.tick();
-                try repl.io.run_for_ns(constants.tick_ms * std.time.ns_per_ms);
-            }
-        }
-
-        fn register_callback(
-            user_data: u128,
-            result: *const vsr.RegisterResult,
-        ) void {
-            _ = result;
-
-            const repl: *Repl = @ptrFromInt(@as(usize, @intCast(user_data)));
-            assert(!repl.event_loop_done);
-
-            repl.event_loop_done = true;
-        }
-
-        fn send(
-            repl: *Repl,
-            operation: tb.Operation,
-            arguments: *std.ArrayListUnmanaged(u8),
-        ) !void {
-            const operation_type = switch (operation) {
-                .create_accounts, .create_transfers => "create",
-                .get_account_transfers, .get_account_balances => "get",
-                .lookup_accounts, .lookup_transfers => "lookup",
-                .query_accounts, .query_transfers => "query",
-                else => unreachable,
-            };
-            const object_type = switch (operation) {
-                .create_accounts, .lookup_accounts, .query_accounts => "accounts",
-                .create_transfers, .lookup_transfers, .query_transfers => "transfers",
-                .get_account_transfers => "account transfers",
-                .get_account_balances => "account balances",
-                else => unreachable,
-            };
-
-            if (arguments.items.len == 0) {
-                try repl.fail(
-                    "No {s} to {s}.\n",
-                    .{ object_type, operation_type },
-                );
-                return;
-            }
-
-            repl.request_done = false;
-            try repl.debug("Sending command: {}.\n", .{operation});
-
-            const payload_size: u32 = @intCast(arguments.items.len);
-            const buffer: []u8 = buffer: {
-                arguments.expandToCapacity();
-                assert(arguments.items.len == constants.message_body_size_max);
-                break :buffer arguments.items;
-            };
-            var body_encoder = vsr.multi_batch.MultiBatchEncoder.init(buffer, .{
-                .element_size = operation.event_size(),
-            });
-            body_encoder.add(payload_size);
-            const bytes_written = body_encoder.finish();
-            assert(bytes_written > 0);
-
-            repl.client.request(
-                client_request_callback,
-                @intCast(@intFromPtr(repl)),
-                operation,
-                buffer[0..bytes_written],
-            );
-        }
-
-        fn display_object(repl: *Repl, object: anytype) !void {
-            assert(@TypeOf(object.*) == tb.Account or
-                @TypeOf(object.*) == tb.Transfer or
-                @TypeOf(object.*) == tb.AccountBalance);
-
-            try repl.terminal.print("{{\n", .{});
-            inline for (@typeInfo(@TypeOf(object.*)).@"struct".fields, 0..) |object_field, i| {
-                if (comptime std.mem.eql(u8, object_field.name, "reserved")) {
-                    continue;
-                    // No need to print out reserved.
-                }
-
-                if (i > 0) {
-                    try repl.terminal.print(",\n", .{});
-                }
-
-                if (comptime std.mem.eql(u8, object_field.name, "flags")) {
-                    try repl.terminal.print("  \"" ++ object_field.name ++ "\": [", .{});
-                    var needs_comma = false;
-
-                    inline for (@typeInfo(object_field.type).@"struct".fields) |flag_field| {
-                        if (comptime !std.mem.eql(u8, flag_field.name, "padding")) {
-                            if (@field(@field(object, "flags"), flag_field.name)) {
-                                if (needs_comma) {
-                                    try repl.terminal.print(",", .{});
-                                    needs_comma = false;
-                                }
-
-                                try repl.terminal.print("\"{s}\"", .{flag_field.name});
-                                needs_comma = true;
-                            }
-                        }
-                    }
-
-                    try repl.terminal.print("]", .{});
-                } else {
-                    try repl.terminal.print(
-                        "  \"{s}\": \"{}\"",
-                        .{ object_field.name, @field(object, object_field.name) },
-                    );
-                }
-            }
-            try repl.terminal.print("\n}}\n", .{});
-        }
-
-        fn client_request_completed(
-            user_data: u128,
-            operation: tb.Operation,
-            timestamp: u64,
-            result: []const u8,
-        ) !void {
-            const repl: *Repl = @ptrFromInt(@as(usize, @intCast(user_data)));
-            assert(repl.request_done == false);
-            try repl.debug("Operation completed: {} timestamp={}.\n", .{ operation, timestamp });
-
-            defer {
-                repl.request_done = true;
-
-                if (!repl.interactive) {
-                    repl.event_loop_done = true;
-                }
-            }
-
-            switch (operation) {
-                .create_accounts => {
-                    const create_account_results = stdx.bytes_as_slice(
-                        .exact,
-                        tb.CreateAccountsResult,
-                        result,
-                    );
-                    if (create_account_results.len > 0) {
-                        for (create_account_results) |*reason| {
-                            try repl.terminal.print(
-                                "Failed to create account ({}): {any}.\n",
-                                .{ reason.index, reason.result },
-                            );
-                        }
-                    }
-                },
-                .lookup_accounts, .query_accounts => {
-                    const account_results = stdx.bytes_as_slice(
-                        .exact,
-                        tb.Account,
-                        result,
-                    );
-                    if (account_results.len == 0) {
-                        try repl.fail("No accounts were found.\n", .{});
-                    } else {
-                        for (account_results) |*account| {
-                            try repl.display_object(account);
-                        }
-                    }
-                },
-                .create_transfers => {
-                    const create_transfer_results = stdx.bytes_as_slice(
-                        .exact,
-                        tb.CreateTransfersResult,
-                        result,
-                    );
-                    if (create_transfer_results.len > 0) {
-                        for (create_transfer_results) |*reason| {
-                            try repl.terminal.print(
-                                "Failed to create transfer ({}): {any}.\n",
-                                .{ reason.index, reason.result },
-                            );
-                        }
-                    }
-                },
-                .lookup_transfers,
-                .get_account_transfers,
-                .query_transfers,
-                => {
-                    const transfer_results = stdx.bytes_as_slice(
-                        .exact,
-                        tb.Transfer,
-                        result,
-                    );
-                    if (transfer_results.len == 0) {
-                        try repl.fail("No transfers were found.\n", .{});
-                    } else {
-                        for (transfer_results) |*transfer| {
-                            try repl.display_object(transfer);
-                        }
-                    }
-                },
-                .get_account_balances => {
-                    const get_account_balances_results = stdx.bytes_as_slice(
-                        .exact,
-                        tb.AccountBalance,
-                        result,
-                    );
-                    if (get_account_balances_results.len == 0) {
-                        try repl.fail("No balances were found.\n", .{});
-                    } else {
-                        for (get_account_balances_results) |*balance| {
-                            try repl.display_object(balance);
-                        }
-                    }
-                },
-                else => unreachable,
-            }
-        }
-
-        fn client_request_callback(
-            user_data: u128,
-            operation_vsr: vsr.Operation,
-            timestamp: u64,
-            result: []u8,
-        ) void {
-            const operation = operation_vsr.cast(tb.Operation);
-            const reply_decoder = vsr.multi_batch.MultiBatchDecoder.init(result, .{
-                .element_size = operation.result_size(),
-            }) catch unreachable;
-            assert(reply_decoder.batch_count() == 1);
-            client_request_completed(
-                user_data,
-                operation,
-                timestamp,
-                reply_decoder.peek(),
-            ) catch |err| {
-                const repl: *Repl = @ptrFromInt(@as(usize, @intCast(user_data)));
-                repl.fail("Error in callback: {any}", .{err}) catch return;
-            };
-        }
-    };
-}