tigerbeetle-node 0.11.12 → 0.12.0

package/src/tigerbeetle/src/static_allocator.zig

@@ -1,65 +0,0 @@
-//! An allocator wrapper which can be disabled at runtime.
-//! We use this for allocating at startup and then
-//! disable it to prevent accidental dynamic allocation at runtime.
-
-const std = @import("std");
-const assert = std.debug.assert;
-const mem = std.mem;
-const log = std.log.scoped(.static_allocator);
-
-const Self = @This();
-parent_allocator: mem.Allocator,
-state: State,
-
-const State = enum {
-    /// Allow `alloc` and `resize`.
-    /// (To make errdefer cleanup easier to write we also allow calling `free`,
-    ///  in which case we switch state to `.deinit` and no longer allow `alloc` or `resize`.)
-    init,
-    /// Don't allow any calls.
-    static,
-    /// Allow `free` but not `alloc` and `resize`.
-    deinit,
-};
-
-pub fn init(parent_allocator: mem.Allocator) Self {
-    return .{
-        .parent_allocator = parent_allocator,
-        .state = .init,
-    };
-}
-
-pub fn deinit(self: *Self) void {
-    self.* = undefined;
-}
-
-pub fn transition_from_init_to_static(self: *Self) void {
-    assert(self.state == .init);
-    self.state = .static;
-}
-
-pub fn transition_from_static_to_deinit(self: *Self) void {
-    assert(self.state == .static);
-    self.state = .deinit;
-}
-
-pub fn allocator(self: *Self) mem.Allocator {
-    return mem.Allocator.init(self, alloc, resize, free);
-}
-
-fn alloc(self: *Self, len: usize, ptr_align: u29, len_align: u29, ret_addr: usize) error{OutOfMemory}![]u8 {
-    assert(self.state == .init);
-    return self.parent_allocator.rawAlloc(len, ptr_align, len_align, ret_addr);
-}
-
-fn resize(self: *Self, buf: []u8, buf_align: u29, new_len: usize, len_align: u29, ret_addr: usize) ?usize {
-    assert(self.state == .init);
-    return self.parent_allocator.rawResize(buf, buf_align, new_len, len_align, ret_addr);
-}
-
-fn free(self: *Self, buf: []u8, buf_align: u29, ret_addr: usize) void {
-    assert(self.state == .init or self.state == .deinit);
-    // Once you start freeing, you don't stop.
-    self.state = .deinit;
-    return self.parent_allocator.rawFree(buf, buf_align, ret_addr);
-}

package/src/tigerbeetle/src/stdx.zig

@@ -1,162 +0,0 @@
-//! Extensions to the standard library -- things which could have been in std, but aren't.
-
-const std = @import("std");
-const assert = std.debug.assert;
-
-pub inline fn div_ceil(numerator: anytype, denominator: anytype) @TypeOf(numerator, denominator) {
-    comptime {
-        switch (@typeInfo(@TypeOf(numerator))) {
-            .Int => |int| assert(int.signedness == .unsigned),
-            .ComptimeInt => assert(numerator >= 0),
-            else => @compileError("div_ceil: invalid numerator type"),
-        }
-
-        switch (@typeInfo(@TypeOf(denominator))) {
-            .Int => |int| assert(int.signedness == .unsigned),
-            .ComptimeInt => assert(denominator > 0),
-            else => @compileError("div_ceil: invalid denominator type"),
-        }
-    }
-
-    assert(denominator > 0);
-
-    if (numerator == 0) return 0;
-    return @divFloor(numerator - 1, denominator) + 1;
-}
-
-test "div_ceil" {
-    // Comptime ints.
-    try std.testing.expectEqual(div_ceil(0, 8), 0);
-    try std.testing.expectEqual(div_ceil(1, 8), 1);
-    try std.testing.expectEqual(div_ceil(7, 8), 1);
-    try std.testing.expectEqual(div_ceil(8, 8), 1);
-    try std.testing.expectEqual(div_ceil(9, 8), 2);
-
-    // Unsized ints
-    const max = std.math.maxInt(u64);
-    try std.testing.expectEqual(div_ceil(@as(u64, 0), 8), 0);
-    try std.testing.expectEqual(div_ceil(@as(u64, 1), 8), 1);
-    try std.testing.expectEqual(div_ceil(@as(u64, max), 2), max / 2 + 1);
-    try std.testing.expectEqual(div_ceil(@as(u64, max) - 1, 2), max / 2);
-    try std.testing.expectEqual(div_ceil(@as(u64, max) - 2, 2), max / 2);
-}
-
-pub const CopyPrecision = enum { exact, inexact };
-
-pub inline fn copy_left(
-    comptime precision: CopyPrecision,
-    comptime T: type,
-    target: []T,
-    source: []const T,
-) void {
-    switch (precision) {
-        .exact => assert(target.len == source.len),
-        .inexact => assert(target.len >= source.len),
-    }
-
-    if (!disjoint_slices(T, T, target, source)) {
-        assert(@ptrToInt(target.ptr) < @ptrToInt(source.ptr));
-    }
-    std.mem.copy(T, target, source);
-}
-
-test "copy_left" {
-    const a = try std.testing.allocator.alloc(usize, 8);
-    defer std.testing.allocator.free(a);
-
-    for (a) |*v, i| v.* = i;
-    copy_left(.exact, usize, a[0..6], a[2..]);
-    try std.testing.expect(std.mem.eql(usize, a, &.{ 2, 3, 4, 5, 6, 7, 6, 7 }));
-}
-
-pub inline fn copy_right(
-    comptime precision: CopyPrecision,
-    comptime T: type,
-    target: []T,
-    source: []const T,
-) void {
-    switch (precision) {
-        .exact => assert(target.len == source.len),
-        .inexact => assert(target.len >= source.len),
-    }
-
-    if (!disjoint_slices(T, T, target, source)) {
-        assert(@ptrToInt(target.ptr) > @ptrToInt(source.ptr));
-    }
-    std.mem.copyBackwards(T, target, source);
-}
-
-test "copy_right" {
-    const a = try std.testing.allocator.alloc(usize, 8);
-    defer std.testing.allocator.free(a);
-
-    for (a) |*v, i| v.* = i;
-    copy_right(.exact, usize, a[2..], a[0..6]);
-    try std.testing.expect(std.mem.eql(usize, a, &.{ 0, 1, 0, 1, 2, 3, 4, 5 }));
-}
-
-pub inline fn copy_disjoint(
-    comptime precision: CopyPrecision,
-    comptime T: type,
-    target: []T,
-    source: []const T,
-) void {
-    switch (precision) {
-        .exact => assert(target.len == source.len),
-        .inexact => assert(target.len >= source.len),
-    }
-
-    assert(disjoint_slices(T, T, target, source));
-    std.mem.copy(T, target, source);
-}
-
-pub inline fn disjoint_slices(comptime A: type, comptime B: type, a: []const A, b: []const B) bool {
-    return @ptrToInt(a.ptr) + a.len * @sizeOf(A) <= @ptrToInt(b.ptr) or
-        @ptrToInt(b.ptr) + b.len * @sizeOf(B) <= @ptrToInt(a.ptr);
-}
-
-test "disjoint_slices" {
-    const a = try std.testing.allocator.alignedAlloc(u8, @sizeOf(u32), 8 * @sizeOf(u32));
-    defer std.testing.allocator.free(a);
-
-    const b = try std.testing.allocator.alloc(u32, 8);
-    defer std.testing.allocator.free(b);
-
-    try std.testing.expectEqual(true, disjoint_slices(u8, u32, a, b));
-    try std.testing.expectEqual(true, disjoint_slices(u32, u8, b, a));
-
-    try std.testing.expectEqual(true, disjoint_slices(u8, u8, a, a[0..0]));
-    try std.testing.expectEqual(true, disjoint_slices(u32, u32, b, b[0..0]));
-
-    try std.testing.expectEqual(false, disjoint_slices(u8, u8, a, a[0..1]));
-    try std.testing.expectEqual(false, disjoint_slices(u8, u8, a, a[a.len - 1 .. a.len]));
-
-    try std.testing.expectEqual(false, disjoint_slices(u32, u32, b, b[0..1]));
-    try std.testing.expectEqual(false, disjoint_slices(u32, u32, b, b[b.len - 1 .. b.len]));
-
-    try std.testing.expectEqual(false, disjoint_slices(u8, u32, a, std.mem.bytesAsSlice(u32, a)));
-    try std.testing.expectEqual(false, disjoint_slices(u32, u8, b, std.mem.sliceAsBytes(b)));
-}
-
-/// Utility function for ad-hoc profiling.
-///
-/// A thin wrapper around `std.time.Timer` which handles the boilerplate of
-/// printing to stderr and formatting times in some (unspecified) readable way.
-pub fn timeit() TimeIt {
-    return TimeIt{ .inner = std.time.Timer.start() catch unreachable };
-}
-
-const TimeIt = struct {
-    inner: std.time.Timer,
-
-    /// Prints elapesed time to stderr and resets the internal timer.
-    pub fn lap(self: *TimeIt, comptime label: []const u8) void {
-        const label_alignment = comptime " " ** (1 + (12 -| label.len));
-
-        const nanos = self.inner.lap();
-        std.debug.print(
-            label ++ ":" ++ label_alignment ++ "{}\n",
-            .{std.fmt.fmtDuration(nanos)},
-        );
-    }
-};

package/src/tigerbeetle/src/storage.zig

@@ -1,393 +0,0 @@
-const std = @import("std");
-const builtin = @import("builtin");
-const os = std.os;
-const assert = std.debug.assert;
-const log = std.log.scoped(.storage);
-
-const IO = @import("io.zig").IO;
-const FIFO = @import("fifo.zig").FIFO;
-const constants = @import("constants.zig");
-const vsr = @import("vsr.zig");
-
-pub const Storage = struct {
-    /// See usage in Journal.write_sectors() for details.
-    pub const synchronicity: enum {
-        always_synchronous,
-        always_asynchronous,
-    } = .always_asynchronous;
-
-    pub const Read = struct {
-        completion: IO.Completion,
-        callback: fn (read: *Storage.Read) void,
-
-        /// The buffer to read into, re-sliced and re-assigned as we go, e.g. after partial reads.
-        buffer: []u8,
-
-        /// The position into the file descriptor from where we should read, also adjusted as we go.
-        offset: u64,
-
-        /// The maximum amount of bytes to read per syscall. We use this to subdivide troublesome
-        /// reads into smaller reads to work around latent sector errors (LSEs).
-        target_max: u64,
-
-        /// Returns a target slice into `buffer` to read into, capped by `target_max`.
-        /// If the previous read was a partial read of physical sectors (e.g. 512 bytes) less than
-        /// our logical sector size (e.g. 4 KiB), so that the remainder of the buffer is no longer
-        /// aligned to a logical sector, then we further cap the slice to get back onto a logical
-        /// sector boundary.
-        fn target(read: *Read) []u8 {
-            // A worked example of a partial read that leaves the rest of the buffer unaligned:
-            // This could happen for non-Advanced Format disks with a physical sector of 512 bytes.
-            // We want to read 8 KiB:
-            //     buffer.ptr = 0
-            //     buffer.len = 8192
-            // ... and then experience a partial read of only 512 bytes:
-            //     buffer.ptr = 512
-            //     buffer.len = 7680
-            // We can now see that `buffer.len` is no longer a sector multiple of 4 KiB and further
-            // that we have 3584 bytes left of the partial sector read. If we subtract this amount
-            // from our logical sector size of 4 KiB we get 512 bytes, which is the alignment error
-            // that we need to subtract from `target_max` to get back onto the boundary.
-            var max = read.target_max;
-
-            const partial_sector_read_remainder = read.buffer.len % constants.sector_size;
-            if (partial_sector_read_remainder != 0) {
-                // TODO log.debug() because this is interesting, and to ensure fuzz test coverage.
-                const partial_sector_read = constants.sector_size - partial_sector_read_remainder;
-                max -= partial_sector_read;
-            }
-
-            return read.buffer[0..std.math.min(read.buffer.len, max)];
-        }
-    };
-
-    pub const Write = struct {
-        completion: IO.Completion,
-        callback: fn (write: *Storage.Write) void,
-        buffer: []const u8,
-        offset: u64,
-    };
-
-    pub const NextTick = struct {
-        next: ?*NextTick = null,
-        callback: fn (next_tick: *NextTick) void,
-    };
-
-    io: *IO,
-    fd: os.fd_t,
-
-    next_tick_queue: FIFO(NextTick) = .{},
-    next_tick_completion_scheduled: bool = false,
-    next_tick_completion: IO.Completion = undefined,
-
-    pub fn init(io: *IO, fd: os.fd_t) !Storage {
-        return Storage{
-            .io = io,
-            .fd = fd,
-        };
-    }
-
-    pub fn deinit(storage: *Storage) void {
-        assert(storage.next_tick_queue.empty());
-        assert(storage.fd != IO.INVALID_FILE);
-        storage.fd = IO.INVALID_FILE;
-    }
-
-    pub fn tick(storage: *Storage) void {
-        storage.io.tick() catch |err| {
-            log.warn("tick: {}", .{err});
-            std.debug.panic("io.tick(): {}", .{err});
-        };
-    }
-
-    pub fn on_next_tick(
-        storage: *Storage,
-        callback: fn (next_tick: *Storage.NextTick) void,
-        next_tick: *Storage.NextTick,
-    ) void {
-        next_tick.* = .{ .callback = callback };
-        storage.next_tick_queue.push(next_tick);
-
-        if (!storage.next_tick_completion_scheduled) {
-            storage.next_tick_completion_scheduled = true;
-            storage.io.timeout(
-                *Storage,
-                storage,
-                timeout_callback,
-                &storage.next_tick_completion,
-                0, // 0ns timeout means to resolve as soon as possible - like a yield
-            );
-        }
-    }
-
-    fn timeout_callback(
-        storage: *Storage,
-        completion: *IO.Completion,
-        result: IO.TimeoutError!void,
-    ) void {
-        assert(completion == &storage.next_tick_completion);
-        _ = result catch |e| switch (e) {
-            error.Canceled => unreachable,
-            error.Unexpected => unreachable,
-        };
-
-        // Reset the scheduled flag after processing all tick entries
-        assert(storage.next_tick_completion_scheduled);
-        defer {
-            assert(storage.next_tick_completion_scheduled);
-            storage.next_tick_completion_scheduled = false;
-        }
-
-        while (storage.next_tick_queue.pop()) |next_tick| {
-            next_tick.callback(next_tick);
-        }
-    }
-
-    pub fn read_sectors(
-        self: *Storage,
-        callback: fn (read: *Storage.Read) void,
-        read: *Storage.Read,
-        buffer: []u8,
-        zone: vsr.Zone,
-        offset_in_zone: u64,
-    ) void {
-        if (zone.size()) |zone_size| {
-            assert(offset_in_zone + buffer.len <= zone_size);
-        }
-
-        const offset_in_storage = zone.offset(offset_in_zone);
-        assert_alignment(buffer, offset_in_storage);
-
-        read.* = .{
-            .completion = undefined,
-            .callback = callback,
-            .buffer = buffer,
-            .offset = offset_in_storage,
-            .target_max = buffer.len,
-        };
-
-        self.start_read(read, null);
-        assert(read.target().len > 0);
-    }
-
-    fn start_read(self: *Storage, read: *Storage.Read, bytes_read: ?usize) void {
-        const bytes = bytes_read orelse 0;
-        assert(bytes <= read.target().len);
-
-        read.offset += bytes;
-        read.buffer = read.buffer[bytes..];
-
-        const target = read.target();
-        if (target.len == 0) {
-            // Resolving the read inline means start_read() must not have been called from
-            // read_sectors(). If it was, this is a synchronous callback resolution and should
-            // be reported.
-            assert(bytes_read != null);
-
-            read.callback(read);
-            return;
-        }
-
-        self.assert_bounds(target, read.offset);
-        self.io.read(
-            *Storage,
-            self,
-            on_read,
-            &read.completion,
-            self.fd,
-            target,
-            read.offset,
-        );
-    }
-
-    fn on_read(self: *Storage, completion: *IO.Completion, result: IO.ReadError!usize) void {
-        const read = @fieldParentPtr(Storage.Read, "completion", completion);
-
-        const bytes_read = result catch |err| switch (err) {
-            error.InputOutput => {
-                // The disk was unable to read some sectors (an internal CRC or hardware failure):
-                // We may also have already experienced a partial unaligned read, reading less
-                // physical sectors than the logical sector size, so we cannot expect `target.len`
-                // to be an exact logical sector multiple.
-                const target = read.target();
-                if (target.len > constants.sector_size) {
-                    // We tried to read more than a logical sector and failed.
-                    log.err("latent sector error: offset={}, subdividing read...", .{read.offset});
-
-                    // Divide the buffer in half and try to read each half separately:
-                    // This creates a recursive binary search for the sector(s) causing the error.
-                    // This is considerably slower than doing a single bulk read and by now we might
-                    // also have experienced the disk's read retry timeout (in seconds).
-                    // TODO Our docs must instruct on why and how to reduce disk firmware timeouts.
-
-                    // These lines both implement ceiling division e.g. `((3 - 1) / 2) + 1 == 2` and
-                    // require that the numerator is always greater than zero:
-                    assert(target.len > 0);
-                    const target_sectors = @divFloor(target.len - 1, constants.sector_size) + 1;
-                    assert(target_sectors > 0);
-                    read.target_max = (@divFloor(target_sectors - 1, 2) + 1) * constants.sector_size;
-                    assert(read.target_max >= constants.sector_size);
-
-                    // Pass 0 for `bytes_read`, we want to retry the read with smaller `target_max`:
-                    self.start_read(read, 0);
-                    return;
-                } else {
-                    // We tried to read at (or less than) logical sector granularity and failed.
-                    log.err("latent sector error: offset={}, zeroing sector...", .{read.offset});
-
-                    // Zero this logical sector which can't be read:
-                    // We will treat these EIO errors the same as a checksum failure.
-                    // TODO This could be an interesting avenue to explore further, whether
-                    // temporary or permanent EIO errors should be conflated with checksum failures.
-                    assert(target.len > 0);
-                    std.mem.set(u8, target, 0);
-
-                    // We could set `read.target_max` to `vsr.sector_ceil(read.buffer.len)` here
-                    // in order to restart our pseudo-binary search on the rest of the sectors to be
-                    // read, optimistically assuming that this is the last failing sector.
-                    // However, data corruption that causes EIO errors often has spacial locality.
-                    // Therefore, restarting our pseudo-binary search here might give us abysmal
-                    // performance in the (not uncommon) case of many successive failing sectors.
-                    self.start_read(read, target.len);
-                    return;
-                }
-            },
-
-            error.WouldBlock,
-            error.NotOpenForReading,
-            error.ConnectionResetByPeer,
-            error.Alignment,
-            error.IsDir,
-            error.SystemResources,
-            error.Unseekable,
-            error.ConnectionTimedOut,
-            error.Unexpected,
-            => {
-                log.err(
-                    "impossible read: offset={} buffer.len={} error={s}",
-                    .{ read.offset, read.buffer.len, @errorName(err) },
-                );
-                @panic("impossible read");
-            },
-        };
-
-        if (bytes_read == 0) {
-            // We tried to read more than there really is available to read.
-            // In other words, we thought we could read beyond the end of the file descriptor.
-            // This can happen if the data file inode `size` was truncated or corrupted.
-            log.err(
-                "short read: buffer.len={} offset={} bytes_read={}",
-                .{ read.offset, read.buffer.len, bytes_read },
-            );
-            @panic("data file inode size was truncated or corrupted");
-        }
-
-        // If our target was limited to a single sector, perhaps because of a latent sector error,
-        // then increase `target_max` according to AIMD now that we have read successfully and
-        // hopefully cleared the faulty zone.
-        // We assume that `target_max` may exceed `read.buffer.len` at any time.
-        if (read.target_max == constants.sector_size) {
-            // TODO Add log.debug because this is interesting.
-            read.target_max += constants.sector_size;
-        }
-
-        self.start_read(read, bytes_read);
-    }
-
-    pub fn write_sectors(
-        self: *Storage,
-        callback: fn (write: *Storage.Write) void,
-        write: *Storage.Write,
-        buffer: []const u8,
-        zone: vsr.Zone,
-        offset_in_zone: u64,
-    ) void {
-        if (zone.size()) |zone_size| {
-            assert(offset_in_zone + buffer.len <= zone_size);
-        }
-
-        const offset_in_storage = zone.offset(offset_in_zone);
-        assert_alignment(buffer, offset_in_storage);
-
-        write.* = .{
-            .completion = undefined,
-            .callback = callback,
-            .buffer = buffer,
-            .offset = offset_in_storage,
-        };
-
-        self.start_write(write);
-        // Assert that the callback is called asynchronously.
-        assert(write.buffer.len > 0);
-    }
-
-    fn start_write(self: *Storage, write: *Storage.Write) void {
-        self.assert_bounds(write.buffer, write.offset);
-        self.io.write(
-            *Storage,
-            self,
-            on_write,
-            &write.completion,
-            self.fd,
-            write.buffer,
-            write.offset,
-        );
-    }
-
-    fn on_write(self: *Storage, completion: *IO.Completion, result: IO.WriteError!usize) void {
-        const write = @fieldParentPtr(Storage.Write, "completion", completion);
-
-        const bytes_written = result catch |err| switch (err) {
-            // We assume that the disk will attempt to reallocate a spare sector for any LSE.
-            // TODO What if we receive a temporary EIO error because of a faulty cable?
-            error.InputOutput => @panic("latent sector error: no spare sectors to reallocate"),
-            // TODO: It seems like it might be possible for some filesystems to return ETIMEDOUT
-            // here. Consider handling this without panicking.
-            else => {
-                log.err(
-                    "impossible write: offset={} buffer.len={} error={s}",
-                    .{ write.offset, write.buffer.len, @errorName(err) },
-                );
-                @panic("impossible write");
-            },
-        };
-
-        if (bytes_written == 0) {
-            // This should never happen if the kernel and filesystem are well behaved.
-            // However, block devices are known to exhibit this behavior in the wild.
-            // TODO: Consider retrying with a timeout if this panic proves problematic, and be
-            // careful to avoid logging in a busy loop. Perhaps a better approach might be to
-            // return wrote = null here and let the protocol retry at a higher layer where there is
-            // more context available to decide on how important this is or whether to cancel.
-            @panic("write operation returned 0 bytes written");
-        }
-
-        write.offset += bytes_written;
-        write.buffer = write.buffer[bytes_written..];
-
-        if (write.buffer.len == 0) {
-            write.callback(write);
-            return;
-        }
-
-        self.start_write(write);
-    }
-
-    /// Ensures that the read or write is aligned correctly for Direct I/O.
-    /// If this is not the case, then the underlying syscall will return EINVAL.
-    /// We check this only at the start of a read or write because the physical sector size may be
-    /// less than our logical sector size so that partial IOs then leave us no longer aligned.
-    fn assert_alignment(buffer: []const u8, offset: u64) void {
-        assert(@ptrToInt(buffer.ptr) % constants.sector_size == 0);
-        assert(buffer.len % constants.sector_size == 0);
-        assert(offset % constants.sector_size == 0);
-    }
-
-    /// Ensures that the read or write is within bounds and intends to read or write some bytes.
-    fn assert_bounds(self: *Storage, buffer: []const u8, offset: u64) void {
-        _ = self;
-        _ = offset;
-
-        assert(buffer.len > 0);
-    }
-};

package/src/tigerbeetle/src/testing/cluster/message_bus.zig

@@ -1,82 +0,0 @@
-const std = @import("std");
-const assert = std.debug.assert;
-
-const MessagePool = @import("../../message_pool.zig").MessagePool;
-const Message = MessagePool.Message;
-const Header = @import("../../vsr.zig").Header;
-const ProcessType = @import("../../vsr.zig").ProcessType;
-
-const Network = @import("network.zig").Network;
-
-const log = std.log.scoped(.message_bus);
-
-pub const Process = union(ProcessType) {
-    replica: u8,
-    client: u128,
-};
-
-pub const MessageBus = struct {
-    network: *Network,
-    pool: *MessagePool,
-
-    cluster: u32,
-    process: Process,
-
-    /// The callback to be called when a message is received.
-    on_message_callback: fn (message_bus: *MessageBus, message: *Message) void,
-
-    pub const Options = struct {
-        network: *Network,
-    };
-
-    pub fn init(
-        _: std.mem.Allocator,
-        cluster: u32,
-        process: Process,
-        message_pool: *MessagePool,
-        on_message_callback: fn (message_bus: *MessageBus, message: *Message) void,
-        options: Options,
-    ) !MessageBus {
-        return MessageBus{
-            .network = options.network,
-            .pool = message_pool,
-            .cluster = cluster,
-            .process = process,
-            .on_message_callback = on_message_callback,
-        };
-    }
-
-    /// TODO
-    pub fn deinit(_: *MessageBus, _: std.mem.Allocator) void {}
-
-    pub fn tick(_: *MessageBus) void {}
-
-    pub fn get_message(bus: *MessageBus) *Message {
-        return bus.pool.get_message();
-    }
-
-    pub fn unref(bus: *MessageBus, message: *Message) void {
-        bus.pool.unref(message);
-    }
-
-    pub fn send_message_to_replica(bus: *MessageBus, replica: u8, message: *Message) void {
-        // Messages sent by a process to itself should never be passed to the message bus
-        if (bus.process == .replica) assert(replica != bus.process.replica);
-
-        bus.network.send_message(message, .{
-            .source = bus.process,
-            .target = .{ .replica = replica },
-        });
-    }
-
-    /// Try to send the message to the client with the given id.
-    /// If the client is not currently connected, the message is silently dropped.
-    pub fn send_message_to_client(bus: *MessageBus, client_id: u128, message: *Message) void {
-        assert(bus.process == .replica);
-
-        bus.network.send_message(message, .{
-            .source = bus.process,
-            .target = .{ .client = client_id },
-        });
-    }
-};