tigerbeetle 0.0.40 → 0.17.8

data/ext/tb_client/tigerbeetle/src/io/common.zig

@@ -1,155 +0,0 @@
-//! Code shared across several IO implementations, because, e.g., it is expressible via POSIX layer.
-const builtin = @import("builtin");
-const std = @import("std");
-const posix = std.posix;
-
-const assert = std.debug.assert;
-
-const is_linux = builtin.target.os.tag == .linux;
-
-pub const TCPOptions = struct {
-    rcvbuf: c_int,
-    sndbuf: c_int,
-    keepalive: ?struct {
-        keepidle: c_int,
-        keepintvl: c_int,
-        keepcnt: c_int,
-    },
-    user_timeout_ms: c_int,
-    nodelay: bool,
-};
-
-pub const ListenOptions = struct {
-    backlog: u31,
-};
-
-pub fn listen(
-    fd: posix.socket_t,
-    address: std.net.Address,
-    options: ListenOptions,
-) !std.net.Address {
-    try setsockopt(fd, posix.SOL.SOCKET, posix.SO.REUSEADDR, 1);
-    try posix.bind(fd, &address.any, address.getOsSockLen());
-
-    // Resolve port 0 to an actual port picked by the OS.
-    var address_resolved: std.net.Address = .{ .any = undefined };
-    var addrlen: posix.socklen_t = @sizeOf(std.net.Address);
-    try posix.getsockname(fd, &address_resolved.any, &addrlen);
-    assert(address_resolved.getOsSockLen() == addrlen);
-    assert(address_resolved.any.family == address.any.family);
-
-    try posix.listen(fd, options.backlog);
-
-    return address_resolved;
-}
-
-/// Sets the socket options.
-/// Although some options are generic at the socket level,
-/// these settings are intended only for TCP sockets.
-pub fn tcp_options(
-    fd: posix.socket_t,
-    options: TCPOptions,
-) !void {
-    if (options.rcvbuf > 0) rcvbuf: {
-        if (is_linux) {
-            // Requires CAP_NET_ADMIN privilege (settle for SO_RCVBUF in case of an EPERM):
-            if (setsockopt(fd, posix.SOL.SOCKET, posix.SO.RCVBUFFORCE, options.rcvbuf)) |_| {
-                break :rcvbuf;
-            } else |err| switch (err) {
-                error.PermissionDenied => {},
-                else => |e| return e,
-            }
-        }
-        try setsockopt(fd, posix.SOL.SOCKET, posix.SO.RCVBUF, options.rcvbuf);
-    }
-
-    if (options.sndbuf > 0) sndbuf: {
-        if (is_linux) {
-            // Requires CAP_NET_ADMIN privilege (settle for SO_SNDBUF in case of an EPERM):
-            if (setsockopt(fd, posix.SOL.SOCKET, posix.SO.SNDBUFFORCE, options.sndbuf)) |_| {
-                break :sndbuf;
-            } else |err| switch (err) {
-                error.PermissionDenied => {},
-                else => |e| return e,
-            }
-        }
-        try setsockopt(fd, posix.SOL.SOCKET, posix.SO.SNDBUF, options.sndbuf);
-    }
-
-    if (options.keepalive) |keepalive| {
-        try setsockopt(fd, posix.SOL.SOCKET, posix.SO.KEEPALIVE, 1);
-        if (is_linux) {
-            try setsockopt(fd, posix.IPPROTO.TCP, posix.TCP.KEEPIDLE, keepalive.keepidle);
-            try setsockopt(fd, posix.IPPROTO.TCP, posix.TCP.KEEPINTVL, keepalive.keepintvl);
-            try setsockopt(fd, posix.IPPROTO.TCP, posix.TCP.KEEPCNT, keepalive.keepcnt);
-        }
-    }
-
-    if (options.user_timeout_ms > 0) {
-        if (is_linux) {
-            const timeout_ms = options.user_timeout_ms;
-            try setsockopt(fd, posix.IPPROTO.TCP, posix.TCP.USER_TIMEOUT, timeout_ms);
-        }
-    }
-
-    // Set tcp no-delay
-    if (options.nodelay) {
-        if (is_linux) {
-            try setsockopt(fd, posix.IPPROTO.TCP, posix.TCP.NODELAY, 1);
-        }
-    }
-}
-
-pub fn setsockopt(fd: posix.socket_t, level: i32, option: u32, value: c_int) !void {
-    try posix.setsockopt(fd, level, option, &std.mem.toBytes(value));
-}
-
-pub fn aof_blocking_write_all(fd: posix.fd_t, buffer: []const u8) posix.WriteError!void {
-    const file = std.fs.File{ .handle = fd };
-    return file.writeAll(buffer);
-}
-
-pub fn aof_blocking_pread_all(fd: posix.fd_t, buffer: []u8, offset: u64) posix.PReadError!usize {
-    const file = std.fs.File{ .handle = fd };
-    return file.preadAll(buffer, offset);
-}
-
-pub fn aof_blocking_close(fd: posix.fd_t) void {
-    const file = std.fs.File{ .handle = fd };
-    file.close();
-}
-
-pub fn aof_blocking_stat(path: []const u8) std.fs.Dir.StatFileError!std.fs.File.Stat {
-    return std.fs.cwd().statFile(path);
-}
-
-pub fn aof_blocking_fstat(fd: posix.fd_t) std.fs.Dir.StatError!std.fs.File.Stat {
-    const file = std.fs.File{ .handle = fd };
-    return file.stat();
-}
-
-pub fn aof_blocking_open(dir_fd: posix.fd_t, path: []const u8) !posix.fd_t {
-    assert(!std.fs.path.isAbsolute(path));
-
-    const dir = std.fs.Dir{ .fd = dir_fd };
-
-    const file = try dir.createFile(path, .{
-        .read = true,
-        .truncate = false,
-        .exclusive = false,
-        .lock = .exclusive,
-    });
-    errdefer file.close();
-
-    try file.sync();
-
-    // We cannot fsync the directory handle on Windows.
-    // We have no way to open a directory with write access.
-    if (builtin.os.tag != .windows) {
-        try std.posix.fsync(dir_fd);
-    }
-
-    try file.seekFromEnd(0);
-
-    return file.handle;
-}