Re-commiting whole course squashed into one commit

The history is non-sensical and messy (including every dumb typo)
so I squashed it all to avoid the rabbit hole of thinking how to split
it in a meaningful way.

.codecrafters/run.sh

@@ -8,4 +8,4 @@
 
 set -e # Exit on failure
 
-exec zig-out/bin/main "$@"
+exec zig-out/bin/main --debug --verbose --max-replicas 4 --max-threads 8 "$@"

.gitignore

@@ -16,3 +16,6 @@ bin/
 **/.DS_Store
 *.swp
 *~
+
+# server logs
+logs/

codecrafters.yml

@@ -2,7 +2,7 @@
 #
 # These can be VERY verbose, so we suggest turning them off
 # unless you really need them.
-debug: false
+debug: true
 
 # Use this to change the Zig version used to run your code
 # on Codecrafters.

src/main.zig

@@ -1,25 +1,305 @@
 const std = @import("std");
 const net = std.net;
 
+const util = @import("util.zig");
+const redis = @import("redis.zig");
+
+const _KB = 1024;
+const _MB = 1024 * _KB;
+
+const HELP_TEXT =
+    \\usage: codecrafters-redis [options]
+    \\
+    \\options:
+    \\  --address ADDR     Bind to IP address ADDR.
+    \\  --port PORT        Bind to port PORT.
+    \\  --command-timeout SECONDS
+    \\                     Drop command connection if a peer does not respond under
+    \\                     SECONDS.   SECONDS must be decimal with up to millisecond
+    \\                     precision. Default: 10 seconds.
+    \\  --max-threads THREAD_COUNT
+    \\                     Don't create more than THREAD_COUNT threads.  Shared for
+    \\                     command threads as well as replication threads.
+    \\                     Default: use as many threads as available on CPU.
+    \\  --max-replicas REPLICA_COUNT
+    \\                     Don't accept more than REPLICA_COUNT replicas.  This must
+    \\                     at least one lower than --max-threads, otherwise
+    \\                     no commands can be processed.  Default: half of --max-threads,
+    \\                     rounded up to integer value.
+    \\                     This option is ignored in replica mode.
+    \\  --replica-timeout SECONDS
+    \\                     Drop replica connection if it does not respond under
+    \\                     SECONDS.   Applies to replicas for master and vice
+    \\                     versa.  SECONDS must be decimal with up to millisecond
+    \\                     precision. Default: 10 seconds.
+    \\  --replicaof CONN   Run as replica of CONN; CONN must be in form
+    \\                     of 'ADDR PORT'; that is, IP address or hostname
+    \\                     followed by space and port number.
+    \\  --dir DIRPATH      Store RDB files in DIRPATH.
+    \\  --dbfilename NAME  RDB file name.
+    \\  --debug            Enable debugging output.
+    \\  --logdir DIRPATH   Store logs in directory DIRPATH.  This will create separate
+    \\                     files for server and each individual task (connection).
+    \\                     (Default: logging to files is disabled).
+    \\  --verbose          Enable verbose output.
+    \\
+    \\
+;
+
+const ArgParsingResult = union(enum) {
+    options: AppOptions,
+    usage_error: []const u8,
+
+    fn unknown_arg(arg: []const u8) ArgParsingResult {
+        var arr: [100]u8 = undefined;
+        const msg = std.fmt.bufPrint(@as([]u8, &arr), "unknown argument: {s}", .{arg}) catch "unknown argument";
+        return ArgParsingResult{ .usage_error = msg };
+    }
+};
+
+const AppOptions = struct {
+    address: []const u8 = "127.0.0.1",
+    port: u16 = 6379,
+    debug: bool = false,
+    verbose: bool = false,
+    logdir: ?[]const u8 = null,
+    thread_buff_size: usize = 3 * _MB,
+    server_buff_size: usize = 10 * _MB,
+    replica_buff_size: usize = 640 * _KB,
+    replica_timeout_ms: u64 = 10_000,
+    command_timeout_ms: u64 = 10_000,
+    max_dump_bytes: usize = 10 * _MB,
+    max_threads: ?usize = null,
+    max_replicas: ?usize = null,
+    dir: ?[]const u8 = null,
+    dbfilename: []const u8 = "dump.rdb",
+    redis_replicaof_host: ?[]const u8 = null,
+    redis_replicaof_port: u16 = 6379,
+
+    const ConnInfo = struct {
+        addr: []const u8,
+        port: u16,
+        fn parse(text: []const u8) !ConnInfo {
+            if (std.mem.count(u8, text, " ") != 1) return error.InvalidConnStr;
+            const space_idx = std.mem.indexOf(u8, text, " ") orelse unreachable;
+            return ConnInfo{
+                .addr = text[0..space_idx],
+                .port = std.fmt.parseInt(u16, text[space_idx + 1 ..], 10) catch return error.InvalidConnStr,
+            };
+        }
+    };
+
+    fn init() AppOptions {
+        const parsing_result = AppOptions.parse_args();
+        switch (parsing_result) {
+            .options => return parsing_result.options,
+            .usage_error => {
+                _ = std.io.getStdErr().write(HELP_TEXT) catch {};
+                _ = std.io.getStdErr().write(parsing_result.usage_error) catch {};
+                _ = std.io.getStdErr().write("\n") catch {};
+                std.process.exit(2);
+            },
+        }
+    }
+
+    fn parse_args() ArgParsingResult {
+        var options = AppOptions{};
+        var this: []const u8 = undefined;
+        var it = std.process.args();
+        var param: ?[]const u8 = null;
+        _ = it.next(); // drop program name
+        while (true) {
+            this = @as(?[]const u8, it.next()) orelse break;
+            if (std.mem.eql(u8, this, "--address")) {
+                param = @as(?[]const u8, it.next());
+                options.address = param orelse return ArgParsingResult{ .usage_error = "no ADDRESS?" };
+            } else if (std.mem.eql(u8, this, "--port")) {
+                param = @as(?[]const u8, it.next());
+                options.port = std.fmt.parseInt(u16, param orelse return ArgParsingResult{ .usage_error = "no PORT?" }, 10) catch {
+                    return ArgParsingResult{ .usage_error = "PORT must be integer" };
+                };
+            } else if (std.mem.eql(u8, this, "--replicaof")) {
+                param = @as(?[]const u8, it.next());
+                const conn_info = ConnInfo.parse(param orelse return ArgParsingResult{ .usage_error = "no CONN?" }) catch {
+                    return ArgParsingResult{ .usage_error = "invalid CONN (must be '<ADDR> <PORT>')" };
+                };
+                options.redis_replicaof_host = conn_info.addr;
+                options.redis_replicaof_port = conn_info.port;
+            } else if (std.mem.eql(u8, this, "--thread-buff-size")) {
+                param = @as(?[]const u8, it.next());
+                options.thread_buff_size = std.fmt.parseInt(usize, param orelse return ArgParsingResult{ .usage_error = "no BYTES?" }, 10) catch {
+                    return ArgParsingResult{ .usage_error = "BYTES must be integer" };
+                };
+            } else if (std.mem.eql(u8, this, "--server-buff-size")) {
+                param = @as(?[]const u8, it.next());
+                options.server_buff_size = std.fmt.parseInt(usize, param orelse return ArgParsingResult{ .usage_error = "no BYTES?" }, 10) catch {
+                    return ArgParsingResult{ .usage_error = "BYTES must be integer" };
+                };
+            } else if (std.mem.eql(u8, this, "--max-dump-bytes")) {
+                param = @as(?[]const u8, it.next());
+                options.max_dump_bytes = std.fmt.parseInt(usize, param orelse return ArgParsingResult{ .usage_error = "no BYTES?" }, 10) catch {
+                    return ArgParsingResult{ .usage_error = "BYTES must be integer" };
+                };
+            } else if (std.mem.eql(u8, this, "--max-threads")) {
+                param = @as(?[]const u8, it.next());
+                options.max_threads = std.fmt.parseInt(usize, param orelse return ArgParsingResult{ .usage_error = "no THREAD_COUNT?" }, 10) catch {
+                    return ArgParsingResult{ .usage_error = "THREAD_COUNT must be integer" };
+                };
+                if (options.max_threads == 0) {
+                    return ArgParsingResult{ .usage_error = "THREAD_COUNT must be greater than 0" };
+                }
+            } else if (std.mem.eql(u8, this, "--max-replicas")) {
+                param = @as(?[]const u8, it.next());
+                options.max_replicas = std.fmt.parseInt(usize, param orelse return ArgParsingResult{ .usage_error = "no REPLICA_COUNT?" }, 10) catch {
+                    return ArgParsingResult{ .usage_error = "REPLICA_COUNT must be integer" };
+                };
+            } else if (std.mem.eql(u8, this, "--replica-timeout")) {
+                param = @as(?[]const u8, it.next());
+                const replica_timeout_s = std.fmt.parseFloat(f32, param orelse return ArgParsingResult{ .usage_error = "no SECONDS?" }) catch {
+                    return ArgParsingResult{ .usage_error = "SECONDS must be decimal" };
+                };
+                options.replica_timeout_ms = @intFromFloat(replica_timeout_s * std.time.ms_per_s);
+            } else if (std.mem.eql(u8, this, "--command-timeout")) {
+                param = @as(?[]const u8, it.next());
+                const command_timeout_s = std.fmt.parseFloat(f32, param orelse return ArgParsingResult{ .usage_error = "no SECONDS?" }) catch {
+                    return ArgParsingResult{ .usage_error = "SECONDS must be decimal" };
+                };
+                options.command_timeout_ms = @intFromFloat(command_timeout_s * std.time.ms_per_s);
+            } else if (std.mem.eql(u8, this, "--dir")) {
+                param = @as(?[]const u8, it.next());
+                options.dir = param orelse return ArgParsingResult{ .usage_error = "no DIRPATH?" };
+            } else if (std.mem.eql(u8, this, "--dbfilename")) {
+                param = @as(?[]const u8, it.next());
+                options.dbfilename = param orelse return ArgParsingResult{ .usage_error = "no NAME?" };
+            } else if (std.mem.eql(u8, this, "--debug")) {
+                options.debug = true;
+            } else if (std.mem.eql(u8, this, "--verbose")) {
+                options.verbose = true;
+            } else if (std.mem.eql(u8, this, "--logdir")) {
+                param = @as(?[]const u8, it.next());
+                options.logdir = param orelse return ArgParsingResult{ .usage_error = "no DIRPATH?" };
+            } else {
+                return ArgParsingResult.unknown_arg(this);
+            }
+        }
+        return ArgParsingResult{ .options = options };
+    }
+};
+
+const Memory = struct {
+    allocator: std.mem.Allocator,
+    server_buff: []u8,
+    rdbload_buff: []u8,
+    threads_buff: []u8,
+    replicas_buff: []u8,
+    server_fba: std.heap.FixedBufferAllocator,
+    rdbload_fba: std.heap.FixedBufferAllocator,
+    threads_fba: std.heap.FixedBufferAllocator,
+    replicas_fba: std.heap.FixedBufferAllocator,
+
+    fn create(options: AppOptions, thread_count: usize, replica_count: usize, allocator: std.mem.Allocator) !Memory {
+        const server_buff = try allocator.alloc(u8, options.server_buff_size);
+        const threads_buff_size = try std.math.mul(usize, options.thread_buff_size, thread_count);
+        const threads_buff = try allocator.alloc(u8, threads_buff_size);
+        const replicas_buff_size = try std.math.mul(usize, options.replica_buff_size, replica_count);
+        const replicas_buff = try allocator.alloc(u8, replicas_buff_size);
+        const rdbload_buff_size = try std.math.mul(usize, options.max_dump_bytes, 2);
+        const rdbload_buff = try allocator.alloc(u8, rdbload_buff_size);
+        return Memory{
+            .allocator = allocator,
+            .server_buff = server_buff,
+            .server_fba = std.heap.FixedBufferAllocator.init(server_buff),
+            .threads_buff = threads_buff,
+            .threads_fba = std.heap.FixedBufferAllocator.init(threads_buff),
+            .replicas_buff = replicas_buff,
+            .replicas_fba = std.heap.FixedBufferAllocator.init(replicas_buff),
+            .rdbload_buff = rdbload_buff,
+            .rdbload_fba = std.heap.FixedBufferAllocator.init(rdbload_buff),
+        };
+    }
+
+    fn destroy(self: *Memory) void {
+        self.server_fba.reset();
+        self.allocator.free(self.server_buff);
+        self.threads_fba.reset();
+        self.replicas_fba.reset();
+        self.allocator.free(self.threads_buff);
+        self.rdbload_fba.reset();
+        self.allocator.free(self.rdbload_buff);
+    }
+};
+
 pub fn main() !void {
-    const stdout = std.io.getStdOut().writer();
-
-    // You can use print statements as follows for debugging, they'll be visible when running tests.
-    try stdout.print("Logs from your program will appear here!", .{});
-
-    // Uncomment this block to pass the first stage
-    //
-    // const address = try net.Address.resolveIp("127.0.0.1", 6379);
-    //
-    // var listener = try address.listen(.{
-    //     .reuse_address = true,
-    // });
-    // defer listener.deinit();
-    //
-    // while (true) {
-    //     const connection = try listener.accept();
-    //
-    //     try stdout.print("accepted new connection", .{});
-    //     connection.stream.close();
-    // }
+    const app_options = AppOptions.init();
+    if (app_options.verbose) {
+        std.log.info("PID: {}", .{std.os.linux.getpid()});
+        std.log.info("getCpuCount: {}", .{try std.Thread.getCpuCount()});
+        std.log.info("app_options.address: {s}", .{app_options.address});
+        std.log.info("app_options.port: {d}", .{app_options.port});
+        std.log.info("app_options.debug: {}", .{app_options.debug});
+        std.log.info("app_options.verbose: {}", .{app_options.verbose});
+        std.log.info("app_options.logdir: {?s}", .{app_options.logdir});
+        std.log.info("app_options.thread_buff_size: {d}", .{app_options.thread_buff_size});
+        std.log.info("app_options.server_buff_size: {d}", .{app_options.server_buff_size});
+        std.log.info("app_options.replica_buff_size: {d}", .{app_options.replica_buff_size});
+        std.log.info("app_options.replica_timeout_ms: {d}", .{app_options.replica_timeout_ms});
+        std.log.info("app_options.command_timeout_s: {d}", .{app_options.command_timeout_ms});
+        std.log.info("app_options.max_dump_bytes: {d}", .{app_options.max_dump_bytes});
+        std.log.info("app_options.max_threads: {?d}", .{app_options.max_threads});
+        std.log.info("app_options.max_replicas: {?d}", .{app_options.max_replicas});
+        std.log.info("app_options.dir: {?s}", .{app_options.dir});
+        std.log.info("app_options.dbfilename: {s}", .{app_options.dbfilename});
+        std.log.info("app_options.redis_replicaof_host: {?s}", .{app_options.redis_replicaof_host});
+        std.log.info("app_options.redis_replicaof_port: {d}", .{app_options.redis_replicaof_port});
+    }
+
+    const thread_count = app_options.max_threads orelse @as(usize, @max(1, try std.Thread.getCpuCount()));
+    const replica_count = counting: {
+        if (app_options.redis_replicaof_host != null) break :counting 1;
+        if (app_options.max_replicas != null) break :counting app_options.max_replicas.?;
+        if (app_options.redis_replicaof_host != null and app_options.max_replicas != null) {
+            std.log.warn("ignoring --max-replicas in replica mode", .{});
+        }
+        break :counting (thread_count + 1) / 2;
+    };
+
+    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    var memory = try Memory.create(app_options, thread_count, replica_count, gpa.allocator());
+    defer memory.destroy();
+
+    const address = try net.Address.resolveIp(app_options.address, app_options.port);
+    var listener = try address.listen(.{
+        .reuse_address = true,
+    });
+    defer listener.deinit();
+
+    var server = try redis.server.Server.create(
+        redis.server.Config{
+            .dir = app_options.dir,
+            .dbfilename = app_options.dbfilename,
+            .max_dump_bytes = app_options.max_dump_bytes,
+            .replication_host = app_options.redis_replicaof_host,
+            .replication_port = app_options.redis_replicaof_port,
+            .replica_timeout_ms = app_options.replica_timeout_ms,
+            .command_timeout_ms = app_options.command_timeout_ms,
+            .thread_count = thread_count,
+            .replica_count = replica_count,
+            .replica_buff_size = app_options.replica_buff_size,
+            .port = app_options.port,
+            .debug = app_options.debug,
+            .verbose = app_options.verbose,
+            .logdir = app_options.logdir,
+        },
+        memory.threads_buff,
+        memory.replicas_buff,
+        memory.server_fba.allocator(),
+    );
+    defer server.destroy();
+
+    try server.maybe_load_dump(memory.rdbload_fba.allocator());
+    try server.serve(&listener);
+}
+
+test {
+    std.testing.refAllDecls(@This());
 }

src/redis.zig

@@ -0,0 +1,4 @@
+pub const resp = @import("redis/resp.zig");
+pub const server = @import("redis/server.zig");
+pub const command = @import("redis/command.zig");
+pub const task = @import("redis/task.zig");

src/redis/command.zig

@@ -0,0 +1,844 @@
+const std = @import("std");
+
+const glob = @import("../glob.zig");
+const util = @import("../util.zig");
+
+const core = @import("core.zig");
+const resp = @import("resp.zig");
+const replication = @import("replication.zig");
+const store = @import("store.zig");
+
+const Elem = core.Elem;
+const Logger = @import("logger.zig").Logger;
+const Server = @import("server.zig").Server;
+const Task = @import("task.zig").Task;
+
+const ELEM_MAX_DEPTH: usize = 128;
+
+const SyntaxError = error{
+    InvalidArgument,
+    InvalidCommand,
+    InvalidKey,
+    InvalidValue,
+    NoCommand,
+    TooFewArguments,
+    TooManyArguments,
+    UnknownArgument,
+    UnknownCommand,
+    UnknownValue,
+};
+
+const RunError = error{
+    InternalError,
+    NotAMaster,
+    NotAReplica,
+};
+
+const ParseCtx = struct {
+    args_stack: *ElemStack,
+    logger: Logger,
+    allocator: std.mem.Allocator,
+};
+
+pub const Result = struct {
+    elem: Elem,
+    ok: bool = true,
+
+    const NBS = Result{ .elem = Elem{ .nbs = null } };
+
+    pub fn from_str(str: []const u8) Result {
+        return Result{ .elem = Elem{ .str = str } };
+    }
+
+    pub fn from_err(err: anyerror) Result {
+        return Result{ .elem = Elem{ .err = @errorName(err) }, .ok = false };
+    }
+
+    pub fn from_int(int: i64) Result {
+        return Result{ .elem = Elem{ .int = int }, .ok = false };
+    }
+
+    pub fn from_arr(arr: []const Elem) Result {
+        return Result{ .elem = Elem{ .arr = arr } };
+    }
+
+    pub fn format(value: Result, comptime fmt: []const u8, options: std.fmt.FormatOptions, writer: anytype) !void {
+        _ = fmt;
+        _ = options;
+        const w: std.io.AnyWriter = writer;
+        try w.print("Result{{.elem={any}}}", .{&value.elem});
+    }
+};
+
+const _TestCommand = struct {
+    subcommand: Subcmd,
+
+    const Subcmd = union(enum) {
+        queuing,
+        slowset: SetCommand,
+        slowset_p: SetCommand,
+    };
+
+    fn parse(ctx: ParseCtx) !Command {
+        const subcmd = b: {
+            if (try ctx.args_stack.pop_literal("SLOWSET")) {
+                const command = try SetCommand.parse(ctx);
+                break :b Subcmd{ .slowset = command.set };
+            } else if (try ctx.args_stack.pop_literal("SLOWSET_P")) {
+                const command = try SetCommand.parse(ctx);
+                break :b Subcmd{ .slowset = command.set };
+            } else if (try ctx.args_stack.pop_literal("QUEUING")) {
+                break :b Subcmd{ .queuing = {} };
+            } else return SyntaxError.UnknownValue;
+        };
+        return Command{ ._test = _TestCommand{ .subcommand = subcmd } };
+    }
+
+    fn _run_queuing(self: @This(), task: *Task, server: *Server) !Result {
+        _ = self;
+        _ = server;
+        const timeout_ns = 5_000_000;
+        const ms = try task.require_master_state();
+        const data = "*3\r\n+SET\r\n+_test\r\n+foo\r\n";
+        var fba = std.io.fixedBufferStream(data);
+        const et = try resp.parse_et(fba.reader().any(), task.allocator);
+        const batch1 = try ms.replicas.bq.queue_batch(.{ .propagate = et }, timeout_ns);
+        ms.replicas.bq._dump("_TEST QUEUING batch1 queued");
+        const batch2 = try ms.replicas.bq.queue_batch(.{ .propagate = et }, timeout_ns);
+        ms.replicas.bq._dump("_TEST QUEUING batch2 queued");
+        const batch3 = try ms.replicas.bq.queue_batch(.{ .propagate = et }, timeout_ns);
+        ms.replicas.bq._dump("_TEST QUEUING batch3 queued");
+        while (true) {
+            const item = batch1.next();
+            std.log.debug("batch1.next()={any}", .{item});
+            if (item == null) break;
+        }
+        ms.replicas.bq._dump("_TEST QUEUING batch1 exhausted");
+        batch1.deinit();
+        ms.replicas.bq._dump("_TEST QUEUING batch1 deinited");
+        while (true) {
+            const item = batch2.next();
+            std.log.debug("batch2.next()={any}", .{item});
+            if (item == null) break;
+        }
+        ms.replicas.bq._dump("_TEST QUEUING batch2 exhausted");
+        batch2.deinit();
+        ms.replicas.bq._dump("_TEST QUEUING batch2 deinited");
+        while (true) {
+            const item = batch3.next();
+            std.log.debug("batch3.next()={any}", .{item});
+            if (item == null) break;
+        }
+        ms.replicas.bq._dump("_TEST QUEUING batch3 exhausted");
+        batch3.deinit();
+        ms.replicas.bq._dump("_TEST QUEUING batch3 deinited");
+        task.logger.info("_TestCommand().run():et={any}", .{et});
+        return Result.from_str("najs");
+    }
+
+    fn _run_slowset(self: @This(), task: *Task, server: *Server) !Result {
+        task.sleep(5_000);
+        return try self.subcommand.slowset.run(task, server);
+    }
+
+    fn run(self: @This(), task: *Task, server: *Server) !Result {
+        return switch (self.subcommand) {
+            .slowset_p => try self._run_slowset(task, server),
+            .slowset => try self._run_slowset(task, server),
+            .queuing => try self._run_queuing(task, server),
+        };
+    }
+};
+
+const ConfigCommand = struct {
+    subcommand: Subcmd,
+
+    const Subcmd = union(enum) {
+        get: struct { key: []const u8 },
+    };
+
+    fn parse(ctx: ParseCtx) !Command {
+        var subcmd: Subcmd = undefined;
+        if (try ctx.args_stack.pop_literal("GET")) {
+            const key = try ctx.args_stack.pop_str();
+            subcmd = Subcmd{ .get = .{ .key = key } };
+        } else return SyntaxError.UnknownValue;
+        return Command{ .config = .{ .subcommand = subcmd } };
+    }
+
+    fn _run_get(self: @This(), server: *Server, allocator: std.mem.Allocator) !Result {
+        var elems_al = std.ArrayList(Elem).init(allocator);
+        const key = self.subcommand.get.key;
+        const key_elem = Elem{ .str = key };
+        const value_elem = blk: {
+            if (std.mem.eql(u8, key, "dir")) break :blk Elem{
+                .str = server.config.dir orelse break :blk core.NBS,
+            };
+            if (std.mem.eql(u8, key, "dbfilename")) break :blk Elem{
+                .str = server.config.dbfilename,
+            };
+            return Result.NBS;
+        };
+        try elems_al.append(key_elem);
+        try elems_al.append(value_elem);
+        return Result.from_arr(elems_al.items);
+    }
+
+    fn run(self: @This(), task: *Task, server: *Server) !Result {
+        switch (self.subcommand) {
+            .get => return try self._run_get(server, task.allocator),
+        }
+    }
+};
+
+const EchoCommand = struct {
+    message: Elem,
+
+    fn parse(ctx: ParseCtx) !Command {
+        const message = try ctx.args_stack.pop_elem();
+        return Command{ .echo = EchoCommand{ .message = message } };
+    }
+
+    fn run(self: @This(), task: *Task, server: *Server) !Result {
+        _ = task;
+        _ = server;
+        return Result{ .elem = self.message };
+    }
+};
+
+const GetCommand = struct {
+    key: []const u8,
+
+    fn parse(ctx: ParseCtx) !Command {
+        const key = try ctx.args_stack.pop_str();
+        return Command{ .get = GetCommand{ .key = key } };
+    }
+
+    fn run(self: @This(), task: *Task, server: *Server) !Result {
+        _ = task;
+        server.store.m.lock();
+        defer server.store.m.unlock();
+        const maybe_elem = try server.store.get_elem(self.key);
+        return Result{ .elem = maybe_elem orelse core.NBS };
+    }
+};
+
+const InfoCommand = struct {
+    sections: std.AutoHashMap(Section, void),
+
+    const Section = enum { replication };
+    const KnownSection = struct {
+        section: Section,
+        label: []const u8,
+    };
+
+    const KNOWN_SECTIONS: []const KnownSection = &.{
+        KnownSection{ .section = .replication, .label = "Replication" },
+    };
+
+    const Buff = struct {
+        al: std.ArrayList(u8),
+        fn init(allocator: std.mem.Allocator) Buff {
+            return Buff{ .al = std.ArrayList(u8).init(allocator) };
+        }
+        fn append_cmt(self: *Buff, text: []const u8) !void {
+            const w = self.al.writer();
+            try std.fmt.format(w, "# {s}\n", .{text});
+        }
+        fn append_replid(self: *Buff, key: []const u8, value: u160) !void {
+            const w = self.al.writer();
+            try std.fmt.format(w, "{s}:{x:040}\n", .{ key, value });
+        }
+        fn append_int(self: *Buff, key: []const u8, value: usize) !void {
+            const w = self.al.writer();
+            try std.fmt.format(w, "{s}:{d}\n", .{ key, value });
+        }
+        fn append_str(self: *Buff, key: []const u8, value: []const u8) !void {
+            const w = self.al.writer();
+            try std.fmt.format(w, "{s}:{s}\n", .{ key, value });
+        }
+        fn append_crep(self: *Buff, r: replication.Replica, s: *Server) !void {
+            const connection = try s.connection_pool.require(r.connection_h);
+            const w = self.al.writer();
+            try std.fmt.format(w, "# connected replica: connection_handle:{any} addr:{any} port:{?d} capabilities:", .{
+                r.connection_h,
+                connection.address,
+                r.port,
+            });
+            var wrote = false;
+            if (r.capabilities.psync2) {
+                if (wrote) try w.writeByte(',');
+                wrote = true;
+                try w.writeAll("psync2");
+            }
+            try w.writeByte('\n');
+        }
+    };
+
+    fn parse(ctx: ParseCtx) !Command {
+        var sections = std.AutoHashMap(Section, void).init(ctx.allocator);
+        while (ctx.args_stack.has_more()) {
+            const section_name = try ctx.args_stack.pop_str();
+            const section: Section = std.meta.stringToEnum(Section, section_name) orelse {
+                ctx.logger.err("unknown section name: '{s}'", .{section_name});
+                return SyntaxError.UnknownValue;
+            };
+            try sections.put(section, {});
+        }
+        return Command{ .info = InfoCommand{ .sections = sections } };
+    }
+
+    fn run(self: @This(), task: *Task, server: *Server) !Result {
+        var buff = Buff.init(task.allocator);
+        for (KNOWN_SECTIONS) |known_section| {
+            if (!self.sections.contains(known_section.section)) continue;
+            try buff.append_cmt(known_section.label);
+            switch (known_section.section) {
+                .replication => {
+                    switch (server.replication_state) {
+                        .master => |v| {
+                            try buff.append_str("role", "master");
+                            try buff.append_replid("master_replid", v.replid);
+                            try buff.append_int("master_repl_offset", @intCast(v.repl_offset));
+                            var itr = v.replicas.ptr_iterator();
+                            while (itr.next()) |ptr| try buff.append_crep(ptr.*, server);
+                        },
+                        .replica => |v| {
+                            try buff.append_str("role", "slave");
+                            try buff.append_str("master_host", v.master_host);
+                            try buff.append_int("master_port", @intCast(v.master_port));
+                        },
+                    }
+                },
+            }
+        }
+        return Result.from_str(buff.al.items);
+    }
+};
+
+const KeysCommand = struct {
+    glob: glob.Glob,
+    _pattern: []const u8,
+
+    fn parse(ctx: ParseCtx) !Command {
+        const pattern = try ctx.args_stack.pop_str();
+        const glob_ = glob.parse_glob(pattern, ctx.allocator) catch |e| {
+            ctx.logger.err("invalid pattern: {} when parsing '{s}'", .{ e, pattern });
+            return SyntaxError.InvalidArgument;
+        };
+        return Command{ .keys = KeysCommand{ .glob = glob_, ._pattern = pattern } };
+    }
+
+    fn run(self: @This(), task: *Task, server: *Server) !Result {
+        var elems_al = std.ArrayList(Elem).init(task.allocator);
+        server.store.m.lock();
+        defer server.store.m.unlock();
+        var key_iter = server.store.elems_db.keyIterator();
+        while (key_iter.next()) |key| {
+            const is_match = self.glob.match(key.*) catch |e| {
+                task.logger.err("internal error: {} when matching key: '{s}' against glob pattern '{s}'", .{
+                    e,
+                    key.*,
+                    self._pattern,
+                });
+                return e;
+            };
+            if (!is_match) continue;
+            try elems_al.append(Elem{ .str = key.* });
+        }
+        return Result.from_arr(elems_al.items);
+    }
+};
+
+const PingCommand = struct {
+    fn parse(task: ParseCtx) !Command {
+        _ = task;
+        return Command{ .ping = PingCommand{} };
+    }
+
+    fn run(self: @This(), task: *Task, server: *Server) !Result {
+        _ = self;
+        _ = task;
+        _ = server;
+        return Result.from_str("PONG");
+    }
+};
+
+const PsyncCommand = struct {
+    replid: ?u160,
+    offset: isize,
+
+    fn parse(ctx: ParseCtx) !Command {
+        return Command{ .psync = PsyncCommand{
+            .replid = blk: {
+                const word = try ctx.args_stack.pop_str();
+                if (word.len == 1 and word[0] == '?') break :blk null;
+                break :blk std.fmt.parseInt(u160, word, 16) catch return SyntaxError.InvalidValue;
+            },
+            .offset = blk: {
+                const word = try ctx.args_stack.pop_str();
+                break :blk std.fmt.parseInt(isize, word, 10) catch return SyntaxError.InvalidValue;
+            },
+        } };
+    }
+
+    fn run(self: @This(), task: *Task, server: *Server) !Result {
+        _ = self;
+        _ = server;
+        const ms = try task.require_master_state();
+        var cmd_al = std.ArrayList(u8).init(task.allocator);
+        try cmd_al.writer().print(
+            "FULLRESYNC {x} {d}",
+            .{ ms.replid, 0 },
+        );
+        return Result{ .elem = Elem{ .str = try cmd_al.toOwnedSlice() } };
+    }
+};
+
+const ReplconfCommand = struct {
+    subcommand: Subcmd,
+
+    const Subcmd = union(enum) {
+        listening_port: u16,
+        capa: []replication.Capability,
+        getack: void,
+    };
+
+    fn parse(ctx: ParseCtx) !Command {
+        var subcmd: Subcmd = undefined;
+        if (try ctx.args_stack.pop_literal("listening-port")) {
+            const port_str = try ctx.args_stack.pop_str();
+            const port = std.fmt.parseInt(u16, port_str, 10) catch return SyntaxError.InvalidValue;
+            subcmd = Subcmd{ .listening_port = port };
+        } else if (try ctx.args_stack.pop_literal("capa")) {
+            var capas_al = std.ArrayList(replication.Capability).init(ctx.allocator);
+            if (try ctx.args_stack.pop_literal("psync2")) {
+                try capas_al.append(.psync2);
+            } else return SyntaxError.InvalidValue;
+            subcmd = Subcmd{ .capa = capas_al.items };
+        } else if (try ctx.args_stack.pop_literal("getack")) {
+            _ = try ctx.args_stack.pop_literal("*"); // no explanation for this argument
+            subcmd = Subcmd{ .getack = {} };
+        } else return SyntaxError.UnknownValue;
+        return Command{ .replconf = .{ .subcommand = subcmd } };
+    }
+
+    fn run(self: @This(), task: *Task, server: *Server) !Result {
+        _ = server;
+        switch (self.subcommand) {
+            .listening_port => |port| {
+                const ms = try task.require_master_state();
+                const replica = try ms.mkreplica(task.connection_h);
+                replica.port = port;
+                return Result.from_str("OK");
+            },
+            .capa => |new_capas| {
+                const ms = try task.require_master_state();
+                const replica = try ms.mkreplica(task.connection_h);
+                replica.set_capas(new_capas);
+                return Result.from_str("OK");
+            },
+            .getack => {
+                const rs = try task.require_replica_state();
+                var eb = ElemBuilder.init(task.allocator);
+                try eb.append_str("REPLCONF");
+                try eb.append_str("ACK");
+                try eb.append_fmt("{d}", .{rs.master_last_offset orelse 0});
+                return Result.from_arr(try eb.al.toOwnedSlice());
+            },
+        }
+    }
+};
+
+const SetCommand = struct {
+    key: []const u8,
+    elem: Elem,
+    xc: ExistenceConstraint,
+    px_update: store.PxUpdate,
+    do_get: bool,
+
+    const ExistenceConstraint = enum { yes, no, any };
+
+    fn parse(ctx: ParseCtx) !Command {
+        const key = try ctx.args_stack.pop_str();
+        const elem = try ctx.args_stack.pop_elem();
+        var do_get: bool = false;
+        var xc: ExistenceConstraint = .any;
+        var px_update: store.PxUpdate = .unset;
+        while (ctx.args_stack.has_more()) {
+            if (try ctx.args_stack.pop_literal("NX")) {
+                xc = .no;
+            } else if (try ctx.args_stack.pop_literal("XX")) {
+                xc = .yes;
+            } else if (try ctx.args_stack.pop_literal("GET")) {
+                do_get = true;
+            } else if (try ctx.args_stack.pop_literal("EX")) {
+                const param_str = try ctx.args_stack.pop_str();
+                const offset_s = std.fmt.parseInt(i64, param_str, 10) catch return SyntaxError.InvalidValue;
+                const offset_ms = std.math.mul(i64, offset_s, 1000) catch return SyntaxError.InvalidValue;
+                const ts_ms = std.math.add(i64, offset_ms, std.time.milliTimestamp()) catch return SyntaxError.InvalidValue;
+                px_update = .{ .new = ts_ms };
+            } else if (try ctx.args_stack.pop_literal("PX")) {
+                const param_str = try ctx.args_stack.pop_str();
+                const offset_ms = std.fmt.parseInt(i64, param_str, 10) catch return SyntaxError.InvalidValue;
+                const ts_ms = std.math.add(i64, offset_ms, std.time.milliTimestamp()) catch return SyntaxError.InvalidValue;
+                px_update = .{ .new = ts_ms };
+            } else if (try ctx.args_stack.pop_literal("EXAT")) {
+                const param_str = try ctx.args_stack.pop_str();
+                const ts_s = std.fmt.parseInt(i64, param_str, 10) catch return SyntaxError.InvalidValue;
+                const ts_ms = std.math.mul(i64, ts_s, 1000) catch return SyntaxError.InvalidValue;
+                px_update = .{ .new = ts_ms };
+            } else if (try ctx.args_stack.pop_literal("PXAT")) {
+                const param_str = try ctx.args_stack.pop_str();
+                const ts_ms = std.fmt.parseInt(i64, param_str, 10) catch return SyntaxError.InvalidValue;
+                px_update = .{ .new = ts_ms };
+            } else if (try ctx.args_stack.pop_literal("KEEPTTL")) {
+                px_update = .keep;
+            } else {
+                return SyntaxError.UnknownArgument;
+            }
+        }
+        return Command{ .set = SetCommand{
+            .key = key,
+            .elem = elem,
+            .do_get = do_get,
+            .xc = xc,
+            .px_update = px_update,
+        } };
+    }
+
+    fn _put_get_elem(self: @This(), server: *Server) !Elem {
+        var ok_elem = Elem{ .str = "OK" };
+        if (self.do_get) {
+            ok_elem = if (try server.store.get_elem(self.key)) |prev| prev else core.NBS;
+        }
+        try server.store.put_elem(self.key, self.elem, self.px_update);
+        return ok_elem;
+    }
+
+    fn run(self: @This(), task: *Task, server: *Server) !Result {
+        server.store.m.lock();
+        defer server.store.m.unlock();
+        switch (self.xc) {
+            .yes => if (!server.store.elems_db.contains(self.key)) return Result.NBS,
+            .no => if (server.store.elems_db.contains(self.key)) return Result.NBS,
+            .any => {},
+        }
+        return Result{ .elem = self._put_get_elem(server) catch |e| {
+            task.logger.warn("error when storing element: {}", .{e});
+            return e;
+        } };
+    }
+};
+
+const WaitCommand = struct {
+    numreplicas: usize,
+    timeout_ms: u32,
+
+    fn parse(ctx: ParseCtx) !Command {
+        const numreplicas = try ctx.args_stack.pop_int(usize);
+        const timeout_ms = try ctx.args_stack.pop_int(u32);
+        return Command{ .wait = WaitCommand{
+            .numreplicas = numreplicas,
+            .timeout_ms = timeout_ms,
+        } };
+    }
+
+    fn run(self: @This(), task: *Task, server: *Server) !Result {
+        _ = server;
+        const ok_count = try task.check_replicas(self.numreplicas, self.timeout_ms);
+        return Result.from_int(@intCast(ok_count));
+    }
+};
+
+pub const Command = union(enum) {
+    _test: _TestCommand,
+    config: ConfigCommand,
+    echo: EchoCommand,
+    get: GetCommand,
+    info: InfoCommand,
+    keys: KeysCommand,
+    ping: PingCommand,
+    psync: PsyncCommand,
+    replconf: ReplconfCommand,
+    set: SetCommand,
+    wait: WaitCommand,
+
+    pub const Flag = enum { propagate, start_replica, ack_master };
+
+    pub fn parse(elem: ?Elem, logger: Logger, allocator: std.mem.Allocator) !Command {
+        const tokens = elem orelse return SyntaxError.NoCommand;
+        if (tokens != .arr) return SyntaxError.InvalidCommand;
+        if (tokens.arr.len == 0) return SyntaxError.InvalidCommand;
+        var args_stack = ElemStack{ .elems = tokens.arr };
+        const ctx = ParseCtx{ .args_stack = &args_stack, .logger = logger, .allocator = allocator };
+        var command: Command = undefined;
+        if (try args_stack.pop_literal("_TEST")) {
+            command = try _TestCommand.parse(ctx);
+        } else if (try args_stack.pop_literal("ECHO")) {
+            command = try EchoCommand.parse(ctx);
+        } else if (try args_stack.pop_literal("GET")) {
+            command = try GetCommand.parse(ctx);
+        } else if (try args_stack.pop_literal("INFO")) {
+            command = try InfoCommand.parse(ctx);
+        } else if (try args_stack.pop_literal("KEYS")) {
+            command = try KeysCommand.parse(ctx);
+        } else if (try args_stack.pop_literal("PING")) {
+            command = try PingCommand.parse(ctx);
+        } else if (try args_stack.pop_literal("PSYNC")) {
+            command = try PsyncCommand.parse(ctx);
+        } else if (try args_stack.pop_literal("REPLCONF")) {
+            command = try ReplconfCommand.parse(ctx);
+        } else if (try args_stack.pop_literal("SET")) {
+            command = try SetCommand.parse(ctx);
+        } else if (try args_stack.pop_literal("WAIT")) {
+            command = try WaitCommand.parse(ctx);
+        } else if (try args_stack.pop_literal("CONFIG")) {
+            command = try ConfigCommand.parse(ctx);
+        } else {
+            return SyntaxError.UnknownCommand;
+        }
+        try args_stack.assert_done();
+        return command;
+    }
+
+    pub fn run(
+        self: @This(),
+        task: *Task,
+        server: *Server,
+    ) Result {
+        return switch (self) {
+            inline else => |c| c.run(task, server) catch |e| Result.from_err(e),
+        };
+    }
+
+    pub fn should(self: Command, flag: Flag) bool {
+        return switch (flag) {
+            .propagate => switch (self) {
+                .set => true,
+                ._test => |impl| switch (impl.subcommand) {
+                    .slowset => true,
+                    else => false,
+                },
+                else => false,
+            },
+            .start_replica => switch (self) {
+                .psync => true,
+                else => false,
+            },
+            .ack_master => switch (self) {
+                .replconf => |c| c.subcommand == .getack,
+                else => false,
+            },
+        };
+    }
+};
+
+const ElemStack = struct {
+    elems: []const Elem,
+    cur: usize = 0,
+
+    fn _step(self: *ElemStack, n: usize) void {
+        //
+        // [|]      (0) +0 => 0 < 0     // ok
+        // [|]      (0) +1 => 0 < 1     // unreachable
+        // [|]      (0) +2 => 0 < 2     // unreachable
+        // [ ]!     (1) +0 => 0 < 1     // unreachable
+        // [ ]!     (1) +1 => 0 < 2     // unreachable
+        // [ ]!     (1) +2 => 0 < 3     // unreachable
+        // [ ]!     (2) +0 => 0 < 2     // unreachable
+        // [ ]!     (2) +1 => 0 < 3     // unreachable
+        // [ ]!     (2) +2 => 0 < 4     // unreachable
+        //
+        // [|_ ]    (0) +0 => 1 < 0     // ok
+        // [|_ ]    (0) +1 => 1 < 1     // ok
+        // [|_ ]    (0) +2 => 1 < 2     // unreachable
+        // [ _|]    (1) +0 => 1 < 1     // ok
+        // [ _|]    (1) +1 => 1 < 2     // unreachable
+        // [ _|]    (1) +2 => 1 < 3     // unreachable
+        // [ _ ]!   (2) +0 => 1 < 2     // unreachable
+        // [ _ ]!   (2) +1 => 1 < 3     // unreachable
+        // [ _ ]!   (2) +2 => 1 < 4     // unreachable
+        //
+        // [|_ _ ]  (0) +0 => 2 < 0     // ok
+        // [|_ _ ]  (0) +1 => 2 < 1     // ok
+        // [|_ _ ]  (0) +2 => 2 < 2     // ok
+        // [ _|_ ]  (1) +0 => 2 < 1     // ok
+        // [ _|_ ]  (1) +1 => 2 < 2     // ok
+        // [ _|_ ]  (1) +2 => 2 < 3     // unreachable
+        // [ _ _|]  (2) +0 => 2 < 2     // ok
+        // [ _ _|]  (2) +1 => 2 < 3     // unreachable
+        // [ _ _|]  (2) +2 => 2 < 4     // unreachable
+        //
+        if (self.elems.len < (self.cur + n)) unreachable;
+        self.cur = self.cur + n;
+    }
+    fn assert_done(self: ElemStack) !void {
+        if (self.has_more()) return SyntaxError.TooManyArguments;
+        return;
+    }
+    fn has_more(self: ElemStack) bool {
+        const rest = self.elems[self.cur..];
+        return rest.len > 0;
+    }
+    fn _maybe_next(self: ElemStack) ?Elem {
+        if (self.cur >= self.elems.len) return null;
+        return self.elems[self.cur];
+    }
+    fn pop_literal(self: *ElemStack, str: []const u8) !bool {
+        const next = self._maybe_next() orelse return SyntaxError.TooFewArguments;
+        if (next != .str) return SyntaxError.InvalidValue;
+        if (!util.eql_i(next.str, str)) return false;
+        self._step(1);
+        return true;
+    }
+    fn pop_elem(self: *ElemStack) !Elem {
+        const next = self._maybe_next() orelse return SyntaxError.TooFewArguments;
+        self._step(1);
+        return next;
+    }
+    fn pop_int(self: *ElemStack, comptime T: type) !T {
+        const elem = try self.pop_elem();
+        const ti: std.builtin.Type = @typeInfo(T);
+        if (ti != .Int) @compileError("not an integer type: " ++ @typeName(T) ++ " is " ++ @tagName(ti));
+        switch (elem) {
+            .int => |n| return @intCast(n),
+            .str => |s| return std.fmt.parseInt(T, s, 10) catch return SyntaxError.InvalidValue,
+            else => return SyntaxError.InvalidValue,
+        }
+    }
+    fn pop_str(self: *ElemStack) ![]const u8 {
+        const next = self._maybe_next() orelse return SyntaxError.TooFewArguments;
+        if (next != .str) return SyntaxError.InvalidValue;
+        self._step(1);
+        return next.str;
+    }
+};
+
+test "ElemStack" {
+    const Case = struct {
+        stack: *ElemStack,
+        const Case = @This();
+        fn init(elems: []const Elem) !Case {
+            var elems_al = std.ArrayList(Elem).init(std.heap.page_allocator);
+            try elems_al.appendSlice(elems);
+            const stack_ptr = try std.heap.page_allocator.create(ElemStack);
+            stack_ptr.elems = elems_al.items;
+            stack_ptr.cur = 0;
+            return .{ .stack = stack_ptr };
+        }
+        fn expect_fullness(self: *Case) !void {
+            try std.testing.expectEqual(true, self.stack.has_more());
+            try std.testing.expectEqual(SyntaxError.TooManyArguments, self.stack.assert_done());
+        }
+        fn expect_emptiness(self: *Case) !void {
+            try std.testing.expectEqual(false, self.stack.has_more());
+            try self.stack.assert_done();
+            try std.testing.expectEqual(SyntaxError.TooFewArguments, self.stack.pop_literal("FOO"));
+            try std.testing.expectEqual(SyntaxError.TooFewArguments, self.stack.pop_str());
+            try std.testing.expectEqual(SyntaxError.TooFewArguments, self.stack.pop_elem());
+        }
+    };
+
+    var c: Case = undefined;
+    const mkcase = Case.init;
+
+    c = try mkcase(&.{});
+    try c.expect_emptiness();
+
+    c = try mkcase(&.{Elem{ .null = null }});
+    try c.expect_fullness();
+    try std.testing.expectEqual(SyntaxError.InvalidValue, c.stack.pop_literal("FOO"));
+    try std.testing.expectEqual(SyntaxError.InvalidValue, c.stack.pop_str());
+    try std.testing.expectEqualDeep(Elem{ .null = null }, try c.stack.pop_elem());
+    try c.expect_emptiness();
+
+    c = try mkcase(&.{Elem{ .int = 3 }});
+    try c.expect_fullness();
+    try std.testing.expectEqual(SyntaxError.InvalidValue, c.stack.pop_literal("FOO"));
+    try std.testing.expectEqual(SyntaxError.InvalidValue, c.stack.pop_str());
+    try std.testing.expectEqualDeep(Elem{ .int = 3 }, try c.stack.pop_elem());
+    try c.expect_emptiness();
+
+    c = try mkcase(&.{Elem{ .str = "" }});
+    try c.expect_fullness();
+    try std.testing.expectEqual(false, c.stack.pop_literal("FOO"));
+    try std.testing.expectEqual("", c.stack.pop_str());
+    try c.expect_emptiness();
+
+    c = try mkcase(&.{Elem{ .str = "" }});
+    try c.expect_fullness();
+    try std.testing.expectEqualDeep(Elem{ .str = "" }, try c.stack.pop_elem());
+    try c.expect_emptiness();
+
+    c = try mkcase(&.{Elem{ .str = "FOO" }});
+    try c.expect_fullness();
+    try std.testing.expectEqual(true, c.stack.pop_literal("FOO"));
+    try c.expect_emptiness();
+
+    c = try mkcase(&.{Elem{ .str = "FOO" }});
+    try c.expect_fullness();
+    try std.testing.expectEqualDeep(Elem{ .str = "FOO" }, try c.stack.pop_elem());
+    try c.expect_emptiness();
+
+    c = try mkcase(&.{ Elem{ .str = "FOO" }, Elem{ .null = null } });
+    try c.expect_fullness();
+    try std.testing.expectEqual(true, c.stack.pop_literal("FOO"));
+    try std.testing.expectEqual(SyntaxError.InvalidValue, c.stack.pop_str());
+    try std.testing.expectEqualDeep(Elem{ .null = null }, try c.stack.pop_elem());
+    try c.expect_emptiness();
+
+    c = try mkcase(&.{ Elem{ .str = "FOO" }, Elem{ .null = null } });
+    try c.expect_fullness();
+    try std.testing.expectEqual(true, c.stack.pop_literal("FOO"));
+    try std.testing.expectEqualDeep(Elem{ .null = null }, try c.stack.pop_elem());
+    try c.expect_emptiness();
+
+    c = try mkcase(&.{ Elem{ .str = "FOO" }, Elem{ .int = 42 } });
+    try c.expect_fullness();
+    try std.testing.expectEqual(true, c.stack.pop_literal("FOO"));
+    try std.testing.expectEqual(SyntaxError.InvalidValue, c.stack.pop_str());
+    try std.testing.expectEqualDeep(Elem{ .int = 42 }, try c.stack.pop_elem());
+    try c.expect_emptiness();
+
+    c = try mkcase(&.{ Elem{ .str = "FOO" }, Elem{ .int = 42 } });
+    try c.expect_fullness();
+    try std.testing.expectEqual(true, c.stack.pop_literal("FOO"));
+    try std.testing.expectEqualDeep(Elem{ .int = 42 }, try c.stack.pop_elem());
+    try c.expect_emptiness();
+
+    c = try mkcase(&.{ Elem{ .str = "FOO" }, Elem{ .str = "bar" } });
+    try c.expect_fullness();
+    try std.testing.expectEqual(true, c.stack.pop_literal("FOO"));
+    try std.testing.expectEqual("bar", c.stack.pop_str());
+    try c.expect_emptiness();
+
+    c = try mkcase(&.{ Elem{ .str = "FOO" }, Elem{ .str = "bar" } });
+    try c.expect_fullness();
+    try std.testing.expectEqual(true, c.stack.pop_literal("FOO"));
+    try std.testing.expectEqualDeep(Elem{ .str = "bar" }, try c.stack.pop_elem());
+    try c.expect_emptiness();
+}
+
+const ElemBuilder = struct {
+    al: std.ArrayList(Elem),
+    allocator: std.mem.Allocator,
+
+    fn init(allocator: std.mem.Allocator) ElemBuilder {
+        return ElemBuilder{ .al = std.ArrayList(Elem).init(allocator), .allocator = allocator };
+    }
+
+    fn append_str(self: *ElemBuilder, str: []const u8) !void {
+        try self.al.append(Elem{ .str = try self.allocator.dupe(u8, str) });
+    }
+
+    fn append_fmt(self: *ElemBuilder, comptime fmt: []const u8, args: anytype) !void {
+        var str = std.ArrayList(u8).init(self.allocator);
+        try str.writer().print(fmt, args);
+        try self.al.append(Elem{ .str = try str.toOwnedSlice() });
+    }
+
+    fn to_arr(self: *ElemBuilder) !Elem {
+        return Elem{ .arr = try self.al.toOwnedSlice() };
+    }
+};

src/redis/core.zig

@@ -0,0 +1,490 @@
+const std = @import("std");
+
+const util = @import("../util.zig");
+
+pub const ElemType = enum { null, nbs, bool, int, double, err, str, bin, arr };
+
+pub const Elem = union(ElemType) {
+    null: ?void,
+    nbs: ?void,
+    bool: bool,
+    int: i64,
+    double: f64,
+    err: []const u8,
+    str: []const u8,
+    bin: []const u8,
+    arr: []const Elem,
+    pub fn format(self: Elem, comptime fmt: []const u8, options: std.fmt.FormatOptions, writer: anytype) !void {
+        _ = fmt;
+        _ = options;
+        try deep_fmt_elem(&self, writer, ELEM_MAX_DEPTH);
+    }
+};
+
+pub const ElemTree = struct {
+    root: ?*Elem,
+    raw_bytes: []const u8,
+    arena: std.heap.ArenaAllocator,
+
+    pub const Error = error{
+        ElemIsABinaryString,
+        ElemIsAScalar,
+        ElemIsAString,
+        ElemIsAnArray,
+        ElemIsAnError,
+        ElemIsAnInteger,
+        ElemNotABinaryString,
+        ElemNotAString,
+        ElemNotAnArray,
+        ElemNotAnError,
+        ElemNotAnInteger,
+        ElemNotExpected,
+        ElemStringNotAnInt,
+        ElemTooLong,
+        ElemTooShort,
+        ElemValueTooHigh,
+        ElemValueTooLow,
+        NoElem,
+    };
+
+    pub fn deinit(self: ElemTree) void {
+        self.arena.deinit();
+    }
+
+    pub fn format(self: ElemTree, comptime fmt: []const u8, options: std.fmt.FormatOptions, writer: anytype) !void {
+        _ = fmt;
+        _ = options;
+        if (self.root) |_| {
+            try writer.print("ElemTree{{.raw_bytes=({d}B),.root={?any}}}", .{ self.raw_bytes.len, self.root });
+        } else {
+            try writer.writeAll("ElemTree{}(STREAM_END)");
+        }
+    }
+
+    const Condition = struct {
+        idx: ?usize = null,
+
+        isa_arr: ?bool = null,
+        isa_bin: ?bool = null,
+        isa_str: ?bool = null,
+        isa_err: ?bool = null,
+        isa_int: ?bool = null,
+
+        len_gt: ?usize = null,
+        len_ge: ?usize = null,
+        len_eq: ?usize = null,
+        len_le: ?usize = null,
+        len_lt: ?usize = null,
+
+        int_gt: ?i64 = null,
+        int_ge: ?i64 = null,
+        int_eq: ?i64 = null,
+        int_le: ?i64 = null,
+        int_lt: ?i64 = null,
+
+        sint_gt: ?i64 = null,
+        sint_ge: ?i64 = null,
+        sint_eq: ?i64 = null,
+        sint_le: ?i64 = null,
+        sint_lt: ?i64 = null,
+
+        str_neq: ?[]const u8 = null,
+        str_eq: ?[]const u8 = null,
+        str_startswith: ?[]const u8 = null,
+        str_neq_i: ?[]const u8 = null,
+        str_eq_i: ?[]const u8 = null,
+        str_startswith_i: ?[]const u8 = null,
+
+        fn _needs_len(self: Condition) bool {
+            if (self.len_gt) |_| return true;
+            if (self.len_ge) |_| return true;
+            if (self.len_eq) |_| return true;
+            if (self.len_le) |_| return true;
+            if (self.len_lt) |_| return true;
+            return false;
+        }
+
+        fn _needs_int(self: Condition) bool {
+            if (self.int_gt) |_| return true;
+            if (self.int_ge) |_| return true;
+            if (self.int_eq) |_| return true;
+            if (self.int_le) |_| return true;
+            if (self.int_lt) |_| return true;
+            return false;
+        }
+
+        fn _needs_sint(self: Condition) bool {
+            if (self.sint_gt) |_| return true;
+            if (self.sint_ge) |_| return true;
+            if (self.sint_eq) |_| return true;
+            if (self.sint_le) |_| return true;
+            if (self.sint_lt) |_| return true;
+            return false;
+        }
+
+        fn _needs_str(self: Condition) bool {
+            if (self.str_neq) |_| return true;
+            if (self.str_eq) |_| return true;
+            if (self.str_startswith) |_| return true;
+            if (self.str_neq_i) |_| return true;
+            if (self.str_eq_i) |_| return true;
+            if (self.str_startswith_i) |_| return true;
+            return false;
+        }
+    };
+
+    pub fn _assert_cond(condition: Condition, elem: Elem, idx: ?usize) !void {
+        if (idx) |i| {
+            if (elem != .arr) return Error.ElemNotAnArray;
+            if (i >= elem.arr.len) return Error.ElemTooShort;
+            return _assert_cond(condition, elem.arr[i], null);
+        }
+
+        if (condition.isa_err) |goal| {
+            if (goal and elem != .err) return Error.ElemNotAnError;
+            if (!goal and elem == .err) return Error.ElemIsAnError;
+        }
+        if (condition.isa_str) |goal| {
+            if (goal and elem != .str) return Error.ElemNotAString;
+            if (!goal and elem == .str) return Error.ElemIsAString;
+        }
+        if (condition.isa_arr) |goal| {
+            if (goal and elem != .arr) return Error.ElemNotAnArray;
+            if (!goal and elem == .arr) return Error.ElemIsAnArray;
+        }
+        if (condition.isa_bin) |goal| {
+            if (goal and elem != .bin) return Error.ElemNotABinaryString;
+            if (!goal and elem == .bin) return Error.ElemIsABinaryString;
+        }
+        if (condition.isa_int) |goal| {
+            if (goal and elem != .arr) return Error.ElemNotAnInteger;
+            if (!goal and elem == .arr) return Error.ElemIsAnInteger;
+        }
+
+        if (condition._needs_len()) {
+            const val = switch (elem) {
+                .str => |e| e.len,
+                .bin => |e| e.len,
+                .err => |e| e.len,
+                .arr => |e| e.len,
+                else => return Error.ElemIsAScalar,
+            };
+            if (condition.len_gt) |goal| {
+                if (val <= goal) return Error.ElemTooShort;
+            }
+            if (condition.len_ge) |goal| {
+                if (val < goal) return Error.ElemTooShort;
+            }
+            if (condition.len_eq) |goal| {
+                if (val > goal) return Error.ElemTooLong;
+                if (val < goal) return Error.ElemTooShort;
+            }
+            if (condition.len_le) |goal| {
+                if (val > goal) return Error.ElemTooLong;
+            }
+            if (condition.len_lt) |goal| {
+                if (val >= goal) return Error.ElemTooLong;
+            }
+        }
+
+        if (condition._needs_int()) {
+            if (elem != .int) return Error.ElemNotAnInteger;
+            const val = elem.int;
+            if (condition.int_gt) |goal| {
+                if (val <= goal) return Error.ElemValueTooLow;
+            }
+            if (condition.int_ge) |goal| {
+                if (val < goal) return Error.ElemValueTooLow;
+            }
+            if (condition.int_eq) |goal| {
+                if (val > goal) return Error.ElemValueTooHigh;
+                if (val < goal) return Error.ElemValueTooLow;
+            }
+            if (condition.int_le) |goal| {
+                if (val > goal) return Error.ElemValueTooHigh;
+            }
+            if (condition.int_lt) |goal| {
+                if (val >= goal) return Error.ElemValueTooHigh;
+            }
+        }
+
+        if (condition._needs_sint()) {
+            if (elem != .str) return Error.ElemNotAString;
+            const val = std.fmt.parseInt(i64, elem.str, 10) catch return Error.ElemStringNotAnInt;
+            if (condition.sint_gt) |goal| {
+                if (val <= goal) return Error.ElemValueTooLow;
+            }
+            if (condition.sint_ge) |goal| {
+                if (val < goal) return Error.ElemValueTooLow;
+            }
+            if (condition.sint_eq) |goal| {
+                if (val > goal) return Error.ElemValueTooHigh;
+                if (val < goal) return Error.ElemValueTooLow;
+            }
+            if (condition.sint_le) |goal| {
+                if (val > goal) return Error.ElemValueTooHigh;
+            }
+            if (condition.sint_lt) |goal| {
+                if (val >= goal) return Error.ElemValueTooHigh;
+            }
+        }
+
+        if (condition._needs_str()) {
+            if (elem != .str) return Error.ElemNotAString;
+            const val = elem.str;
+            if (condition.str_eq) |goal| {
+                if (!std.mem.eql(u8, val, goal)) return Error.ElemNotExpected;
+            }
+            if (condition.str_neq) |goal| {
+                if (std.mem.eql(u8, val, goal)) return Error.ElemNotExpected;
+            }
+            if (condition.str_startswith) |goal| {
+                if (!std.mem.startsWith(u8, val, goal)) return Error.ElemNotExpected;
+            }
+            if (condition.str_eq_i) |goal| {
+                if (!util.eql_i(goal, val)) return Error.ElemNotExpected;
+            }
+            if (condition.str_neq_i) |goal| {
+                if (util.eql_i(goal, val)) return Error.ElemNotExpected;
+            }
+            if (condition.str_startswith_i) |goal| {
+                if (!util.startswith_i(goal, val)) return Error.ElemNotExpected;
+            }
+        }
+    }
+
+    pub fn assert_cond(self: ElemTree, condition: Condition) !void {
+        const elem = self.root orelse return Error.NoElem;
+        try _assert_cond(condition, elem.*, condition.idx);
+    }
+
+    pub fn assert_arr_len(self: ElemTree, len: usize) !void {
+        const elem = self.root orelse return Error.NoElem;
+        if (elem.* != .arr) return Error.ElemNotAnArray;
+        if (elem.arr.len < len) return Error.ElemTooShort;
+        if (elem.arr.len > len) return Error.ElemTooLong;
+    }
+
+    pub fn assert_bin_len_ge(self: ElemTree, len: usize) !void {
+        const elem = self.root orelse return Error.NoElem;
+        if (elem.* != .bin) return Error.ElemNotAString;
+        if (elem.arr.len < len) return Error.ElemTooShort;
+    }
+
+    pub fn assert_eql_at(self: ElemTree, idx: usize, text: []const u8) !void {
+        const elem = self.root orelse return Error.NoElem;
+        if (elem.* != .arr) return Error.ElemNotAnArray;
+        if (idx >= elem.arr.len) return Error.ElemTooShort;
+        const e = elem.arr[idx];
+        if (e != .str) return Error.ElemNotAString;
+        if (!util.eql_i(text, e.str)) return Error.ElemNotExpected;
+    }
+
+    pub fn assert_ok(self: ElemTree) !void {
+        try self.assert_cond(.{ .isa_err = false });
+    }
+
+    pub fn assert_parsed_int_eql_at(self: ElemTree, idx: usize, number: i64) !void {
+        const elem = self.root orelse return Error.NoElem;
+        if (elem.* != .arr) return Error.ElemNotAnArray;
+        if (idx >= elem.arr.len) return Error.ElemTooShort;
+        const e = elem.arr[idx];
+        if (e != .str) return Error.ElemNotAnArray;
+        const value = try std.fmt.parseInt(i64, e.str, 10);
+        if (value < number) return Error.ElemValueTooLow;
+        if (value > number) return Error.ElemValueTooHigh;
+    }
+
+    pub fn assert_startswith(self: ElemTree, text: []const u8) !void {
+        const elem = self.root orelse return Error.NoElem;
+        if (elem.* != .str) return Error.ElemNotAString;
+        if (!util.startswith_i(text, elem.str)) return Error.ElemNotExpected;
+    }
+
+    pub fn parse_int_at(self: ElemTree, idx: usize) !i64 {
+        try self.assert_cond(.{ .isa_str = true, .idx = idx });
+        return try std.fmt.parseInt(i64, self.root.?.*.arr[idx].str, 10);
+    }
+};
+
+pub const NBS = Elem{ .nbs = null };
+
+pub const ELEM_MAX_DEPTH: usize = 128;
+
+pub fn deep_copy_elem(elem: *const Elem, allocator: std.mem.Allocator, frames: usize) !*Elem {
+    if (frames < 1) return error.ValueTooComplex;
+    const new_ptr = try allocator.create(Elem);
+    switch (elem.*) {
+        .null => |value| new_ptr.* = Elem{ .null = value },
+        .nbs => |value| new_ptr.* = Elem{ .nbs = value },
+        .bool => |value| new_ptr.* = Elem{ .bool = value },
+        .int => |value| new_ptr.* = Elem{ .int = value },
+        .double => |value| new_ptr.* = Elem{ .double = value },
+        .str => |values| new_ptr.* = Elem{ .str = try allocator.dupe(u8, values) },
+        .bin => |values| new_ptr.* = Elem{ .bin = try allocator.dupe(u8, values) },
+        .err => |values| new_ptr.* = Elem{ .err = try allocator.dupe(u8, values) },
+        .arr => |values| {
+            const items = try allocator.alloc(Elem, values.len);
+            for (values, 0..) |*value, idx| {
+                const new_item_ptr = try deep_copy_elem(value, allocator, frames - 1);
+                items[idx] = new_item_ptr.*;
+            }
+            new_ptr.* = Elem{ .arr = items };
+        },
+    }
+    return new_ptr;
+}
+
+pub fn deep_fmt_elem(elem: *const Elem, writer: std.io.AnyWriter, frames: usize) !void {
+    if (frames < 1) return error.ValueTooComplex;
+    if (frames == ELEM_MAX_DEPTH) {
+        try writer.writeAll("Elem{");
+    } else {
+        try writer.writeAll(".{");
+    }
+    switch (elem.*) {
+        .null => try writer.print(".null", .{}),
+        .nbs => try writer.print(".nbs", .{}),
+        .bool => |value| try writer.print(".bool={}", .{value}),
+        .int => |value| try writer.print(".int={d}", .{value}),
+        .double => |value| try writer.print(".double={d}", .{value}),
+        .str => |value| try util.qstr(value, writer),
+        .bin => |value| try util.qblob(value, writer),
+        .err => |value| try writer.print(".err=\"{s}\"", .{value}),
+        .arr => |values| {
+            try writer.writeByte('[');
+            for (values, 0..) |*value, i| {
+                if (i > 0) try writer.writeByte(',');
+                try deep_fmt_elem(value, writer, frames - 1);
+            }
+            try writer.print("]", .{});
+        },
+    }
+    try writer.writeByte('}');
+}
+
+pub fn deep_free_elem(elem: *const Elem, allocator: std.mem.Allocator, frames: usize) !void {
+    if (frames < 1) return error.ValueTooComplex;
+    switch (elem.*) {
+        .str => |values| allocator.free(values),
+        .bin => |values| allocator.free(values),
+        .err => |values| allocator.free(values),
+        .arr => |values| for (values) |*value_ptr| try deep_free_elem(value_ptr, allocator, frames - 1),
+        else => {},
+    }
+    allocator.destroy(elem);
+}
+
+const Overstep = enum {
+    data_inside_prohibited_buff,
+    data_outside_required_buff,
+    data_mixed_layout,
+    items_inside_prohibited_buff,
+    items_outside_required_buff,
+    items_mixed_layout,
+    none,
+};
+
+fn find_overstep_sli(
+    comptime T: type,
+    buff_rng: util.Range,
+    comptime should_own: bool,
+    sli: []const T,
+) Overstep {
+    const items_rng = util.range_from_sli(T, sli) orelse return .none;
+    const items_rel = util.range_rel(items_rng, buff_rng) catch unreachable;
+    switch (items_rel) {
+        .inside, .same => if (!should_own) return .items_inside_prohibited_buff,
+        .left, .right => if (should_own) return .items_outside_required_buff,
+        else => return .items_outside_required_buff,
+    }
+    if (T == Elem) {
+        for (sli) |*item| {
+            const overstep = find_overstep_elem(buff_rng, should_own, item);
+            if (overstep != .none) return overstep;
+        }
+    }
+    return .none;
+}
+
+fn find_overstep_elem(
+    buff_rng: util.Range,
+    comptime should_own: bool,
+    elem: *const Elem,
+) Overstep {
+    const data_rng = util.range_from_ptr(Elem, elem);
+    // first, check elem's own memory
+    const own_rel = util.range_rel(data_rng, buff_rng) catch unreachable;
+    switch (own_rel) {
+        .inside, .same => if (!should_own) return .data_inside_prohibited_buff,
+        .left, .right => if (should_own) return .data_outside_required_buff,
+        else => return .data_mixed_layout,
+    }
+    // then, check any memory of elems
+    switch (elem.*) {
+        .nbs, .null, .bool, .int, .double => return .none,
+        .err, .str, .bin => |values| return find_overstep_sli(u8, buff_rng, should_own, values),
+        .arr => |values| return find_overstep_sli(Elem, buff_rng, should_own, values),
+    }
+    return .none;
+}
+
+fn assert_elem_ownership(
+    buff: []u8,
+    comptime should_own: bool,
+    elem: *const Elem,
+) !void {
+    const buff_rng = util.range_from_sli(u8, buff) orelse return error.InvalidBuff;
+    const overstep = find_overstep_elem(buff_rng, should_own, elem);
+    return switch (overstep) {
+        .data_inside_prohibited_buff => error.DataInsideProhibitedBuff,
+        .data_outside_required_buff => error.DataOutsideRequiredBuff,
+        .data_mixed_layout => error.DataMixedLayout,
+        .items_inside_prohibited_buff => error.ItemInsideProhibitedBuff,
+        .items_outside_required_buff => error.ItemOutsideRequiredBuff,
+        .items_mixed_layout => error.ItemMixedLayout,
+        .none => {},
+    };
+}
+
+fn assert_clones_ok(elem: *const Elem) !void {
+    const buff_a = try std.heap.page_allocator.alloc(u8, 1024);
+    const buff_b = try std.heap.page_allocator.alloc(u8, 1024);
+    defer std.heap.page_allocator.free(buff_a);
+    defer std.heap.page_allocator.free(buff_b);
+    var fba_a = std.heap.FixedBufferAllocator.init(buff_a);
+    var fba_b = std.heap.FixedBufferAllocator.init(buff_b);
+    const inter = try deep_copy_elem(elem, fba_a.allocator(), 10);
+    const clone = try deep_copy_elem(inter, fba_b.allocator(), 10);
+    try assert_elem_ownership(buff_b, true, clone);
+    try assert_elem_ownership(buff_a, false, clone);
+    try std.testing.expectEqualDeep(elem, clone);
+}
+
+test "deep copy" {
+    try assert_clones_ok(&Elem{ .null = {} });
+    try assert_clones_ok(&Elem{ .nbs = {} });
+    try assert_clones_ok(&Elem{ .bool = false });
+    try assert_clones_ok(&Elem{ .int = 123 });
+    try assert_clones_ok(&Elem{ .double = 123.45 });
+    try assert_clones_ok(&Elem{ .err = "" });
+    try assert_clones_ok(&Elem{ .err = "F" });
+    try assert_clones_ok(&Elem{ .err = "FOO" });
+    try assert_clones_ok(&Elem{ .str = "" });
+    try assert_clones_ok(&Elem{ .str = "F" });
+    try assert_clones_ok(&Elem{ .str = "FOO" });
+    try assert_clones_ok(&Elem{ .arr = &.{} });
+    try assert_clones_ok(&Elem{ .arr = &.{Elem{ .null = {} }} });
+    try assert_clones_ok(&Elem{ .arr = &.{Elem{ .arr = &.{Elem{ .null = {} }} }} });
+    try assert_clones_ok(&Elem{
+        .arr = &.{
+            Elem{ .int = 123 },
+            Elem{ .arr = &.{} },
+            Elem{ .arr = &.{
+                Elem{ .str = "" },
+                Elem{ .str = "def" },
+            } },
+            Elem{ .str = "abc" },
+        },
+    });
+}

src/redis/logger.zig

@@ -0,0 +1,167 @@
+const std = @import("std");
+
+const Server = @import("server.zig").Server;
+const Role = @import("task.zig").Role;
+
+const Logfile = struct {
+    name: []const u8,
+    fh: std.fs.File,
+    allocator: ?std.mem.Allocator,
+    ctx: Logger.Ctx,
+
+    fn deinit(self: Logfile) void {
+        if (self.allocator) |a| a.free(self.name);
+        self.fh.close();
+    }
+
+    fn _open_fh(dir: []const u8, name: []const u8) !std.fs.File {
+        const dh = try std.fs.cwd().makeOpenPath(dir, .{});
+        return dh.createFile(name, .{}) catch |e| switch (e) {
+            error.PathAlreadyExists => return try dh.openFile(name, .{}),
+            else => return e,
+        };
+    }
+
+    fn try_init(dir: []const u8, ctx: Logger.Ctx, allocator: ?std.mem.Allocator) ?Logfile {
+        const task_fn_fmt = "task-{s}{d:0>2}.log";
+        const name = switch (ctx) {
+            .root => "root.log",
+            .task => |c| std.fmt.allocPrint(allocator.?, task_fn_fmt, .{ c.task_id_pfx, c.task_id }) catch |e| {
+                std.log.warn("[LOGGER] could not format log filename: fmt={s}, task_id={d} e={!}", .{ task_fn_fmt, c.task_id, e });
+                return null;
+            },
+        };
+        const fh = _open_fh(dir, name) catch |e| {
+            std.log.warn("[LOGGER] could not open file: {s}/{s}, e={!}", .{ dir, name, e });
+            return null;
+        };
+        return .{
+            .name = name,
+            .fh = fh,
+            .allocator = allocator,
+            .ctx = ctx,
+        };
+    }
+
+    fn try_write(self: Logfile, comptime sigil: u8, msg: []const u8) void {
+        const w = self.fh.writer();
+        w.print("{c}: [{any}] {s}\n", .{ sigil, self.ctx, msg }) catch {
+            std.log.warn("[LOGGER] failed to write to log file: name='{s}'", .{self.name});
+        };
+    }
+};
+
+pub const Logger = struct {
+    options: Options,
+    ctx: Ctx,
+    logfile: ?Logfile,
+
+    const Options = struct {
+        debug: bool = false,
+        verbose: bool = false,
+        logdir: ?[]const u8,
+    };
+
+    pub const TaskCtx = struct {
+        task_id: usize,
+        task_id_pfx: []const u8,
+        thread_id: ?std.Thread.Id,
+        handle: Server.ConnectionPool.Handle,
+        address: std.net.Address,
+        stream: std.net.Stream,
+        role: Role,
+    };
+
+    pub const Ctx = union(enum) {
+        task: TaskCtx,
+        root: void,
+        pub fn format(self: Ctx, comptime fmt: []const u8, options: std.fmt.FormatOptions, writer: anytype) !void {
+            _ = fmt;
+            _ = options;
+            switch (self) {
+                .root => try writer.writeAll("t=ROOT"),
+                .task => |ctx| {
+                    try writer.print("t={s}{d}", .{ ctx.task_id_pfx, ctx.task_id });
+                    if (ctx.thread_id) |thread_id| {
+                        try writer.print(" T={any}", .{thread_id});
+                    } else {
+                        try writer.writeAll(" T=MAIN");
+                    }
+                    try writer.print(
+                        " c={any} a={any} h={any} r={s}",
+                        .{
+                            ctx.handle,
+                            ctx.address,
+                            ctx.stream.handle,
+                            @tagName(ctx.role),
+                        },
+                    );
+                },
+            }
+        }
+    };
+
+    pub fn init_for_task(options: Options, ctx: TaskCtx, allocator: std.mem.Allocator) Logger {
+        const ctx_ = .{ .task = ctx };
+        return .{
+            .options = options,
+            .ctx = ctx_,
+            .logfile = if (options.logdir) |logdir| Logfile.try_init(logdir, ctx_, allocator) else null,
+        };
+    }
+
+    pub fn init_root(options: Options) Logger {
+        const ctx = .{ .root = {} };
+        return .{
+            .options = options,
+            .ctx = ctx,
+            .logfile = if (options.logdir) |logdir| Logfile.try_init(logdir, ctx, null) else null,
+        };
+    }
+
+    pub fn deinit(self: Logger) void {
+        if (self.logfile) |logfile| logfile.deinit();
+    }
+
+    pub fn set_thread_id(self: *Logger, thread_id: std.Thread.Id) void {
+        switch (self.ctx) {
+            .root => unreachable,
+            .task => self.ctx.task.thread_id = thread_id,
+        }
+    }
+
+    fn try_write(self: Logger, comptime sigil: u8, msg: []const u8) void {
+        if (self.logfile == null) return;
+        self.logfile.?.try_write(sigil, msg);
+    }
+
+    pub fn debug(self: Logger, comptime fmt: []const u8, args: anytype) void {
+        if (!self.options.debug) return;
+        var arr: [1024]u8 = undefined;
+        const msg = std.fmt.bufPrint(@as([]u8, &arr), fmt, args) catch return;
+        self.try_write('D', msg);
+        std.log.debug("[{any}] {s}", .{ self.ctx, msg });
+    }
+
+    pub fn err(self: Logger, comptime fmt: []const u8, args: anytype) void {
+        var arr: [1024]u8 = undefined;
+        const msg = std.fmt.bufPrint(@as([]u8, &arr), fmt, args) catch return;
+        self.try_write('E', msg);
+        std.log.err("[{any}] {s}", .{ self.ctx, msg });
+    }
+
+    pub fn info(self: Logger, comptime fmt: []const u8, args: anytype) void {
+        if (!self.options.verbose) return;
+        var arr: [1024]u8 = undefined;
+        const msg = std.fmt.bufPrint(@as([]u8, &arr), fmt, args) catch return;
+        self.try_write('I', msg);
+        std.log.info("[{any}] {s}", .{ self.ctx, msg });
+    }
+
+    pub fn warn(self: Logger, comptime fmt: []const u8, args: anytype) void {
+        var arr: [1024]u8 = undefined;
+        const msg = std.fmt.bufPrint(@as([]u8, &arr), fmt, args) catch return;
+        self.try_write('W', msg);
+        std.log.warn("[{any}] {s}", .{ self.ctx, msg });
+    }
+};

src/redis/replication.zig

@@ -0,0 +1,279 @@
+const std = @import("std");
+
+const core = @import("core.zig");
+const util = @import("../util.zig");
+
+const ConnectionHandle = @import("server.zig").Server.ConnectionPool.Handle;
+const Server = @import("server.zig").Server;
+const ServerConfig = @import("server.zig").Config;
+const Task = @import("task.zig").Task;
+const HandlerResult = @import("worker.zig").HandlerResult;
+const EMPTY_RDB = @import("rdb.zig").EMPTY_RDB;
+
+pub const Capability = enum {
+    psync2,
+};
+
+const Error = error{ TooManyReplicas, MemoryError, AlreadyExists, QueueFull, QueueEmpty };
+
+const CapabilitySet = struct {
+    psync2: bool = false,
+};
+
+pub const Request = union(enum) {
+    propagate: core.ElemTree,
+    getack: struct { elem: *const core.Elem, timeout_ms: u64 },
+    shutdown: void,
+
+    pub fn format(self: Request, comptime fmt: []const u8, options: std.fmt.FormatOptions, writer: anytype) !void {
+        _ = fmt;
+        _ = options;
+        try writer.writeAll("Request{");
+        switch (self) {
+            .propagate => |et| try writer.print(".propagate={s}", .{util.qb(et.raw_bytes)}),
+            .getack => |v| try writer.print(".getack={{timeout_ms={d}}}", .{v.timeout_ms}),
+            .shutdown => try writer.writeAll(".shutdown"),
+        }
+        try writer.writeByte('}');
+    }
+};
+
+const Response = union(enum) {
+    err: anyerror,
+    ack_offset: u64,
+    sent: void,
+
+    pub fn format(self: Response, comptime fmt: []const u8, options: std.fmt.FormatOptions, writer: anytype) !void {
+        _ = fmt;
+        _ = options;
+        try writer.writeAll("Response{");
+        switch (self) {
+            .err => |e| try writer.print(".err={!}", .{e}),
+            .ack_offset => |o| try writer.print(".ack_offset={d}", .{o}),
+            .sent => try writer.writeAll(".sent"),
+        }
+        try writer.writeByte('}');
+    }
+};
+
+pub const Replica = struct {
+    id: Id,
+    connection_h: ConnectionHandle,
+    capabilities: CapabilitySet,
+    port: ?u16,
+    last_propagation: ?i64 = null,
+
+    pub const Id = ConnectionHandle;
+
+    pub fn set_capas(self: *Replica, capas: []Capability) void {
+        for (capas) |capa| switch (capa) {
+            .psync2 => self.capabilities.psync2 = true,
+        };
+    }
+
+    pub fn set_port(self: *Replica, port: u16) !void {
+        self.port = port;
+    }
+};
+
+pub const MasterState = struct {
+    replid: u160,
+    repl_offset: u64,
+    replicas: ReplicaPool,
+
+    pub fn mkreplica(self: *MasterState, connection_h: ConnectionHandle) !*Replica {
+        if (self.replicas.get_ptr(connection_h)) |ptr| return ptr;
+        const new_id = try self.replicas.create(connection_h);
+        return self.replicas.get_ptr(new_id) orelse return Error.MemoryError;
+    }
+};
+
+pub const ReplicaState = struct {
+    master_host: []const u8,
+    master_port: u16,
+    master_last_replid: ?u160 = null,
+    master_last_offset: ?u64 = null,
+};
+
+pub const State = union(enum) {
+    master: MasterState,
+    replica: ReplicaState,
+
+    pub fn init(config: ServerConfig, allocator: std.mem.Allocator) !State {
+        if (config.replication_host) |h| {
+            return .{ .replica = .{
+                .master_host = h,
+                .master_port = config.replication_port,
+            } };
+        } else {
+            const r = std.crypto.random.int(u160);
+            return .{ .master = .{
+                .replid = r,
+                .repl_offset = 0,
+                .replicas = try ReplicaPool.init(
+                    config.replica_count,
+                    allocator,
+                ),
+            } };
+        }
+    }
+    pub fn deinit(self: State) void {
+        switch (self) {
+            .master => |m| m.replicas.deinit(),
+            .replica => {},
+        }
+    }
+};
+
+pub const ReplicaPool = struct {
+    buff: []?Replica,
+    allocator: std.mem.Allocator,
+    bq: BatchQueue,
+
+    pub const BatchQueue = util.BatchQueue(Request, Response, Replica.Id);
+
+    pub const PtrIterator = struct {
+        cur: usize = 0,
+        pool: ReplicaPool,
+        pub fn next(self: *PtrIterator) ?*Replica {
+            while (self.cur < self.pool.buff.len) {
+                if (self.pool.buff[self.cur]) |*item_ptr| {
+                    self.cur += 1;
+                    return item_ptr;
+                }
+                self.cur += 1;
+            }
+            return null;
+        }
+    };
+
+    fn init(max_replicas: usize, allocator: std.mem.Allocator) !ReplicaPool {
+        const buff = try allocator.alloc(?Replica, max_replicas);
+        for (0..max_replicas) |i| buff[i] = null;
+        return ReplicaPool{
+            .buff = buff,
+            .allocator = allocator,
+            .bq = try BatchQueue.init(max_replicas, allocator),
+        };
+    }
+
+    fn deinit(self: ReplicaPool) void {
+        self.allocator.free(self.buff);
+        self.bq.deinit();
+    }
+
+    fn _locate(self: ReplicaPool, id: Replica.Id) ?usize {
+        for (0..self.buff.len) |idx| {
+            if (self.buff[idx] == null) continue;
+            const item_ptr = &self.buff[idx].?;
+            if (item_ptr.id == id) return idx;
+        }
+        return null;
+    }
+
+    fn _locate_free(self: ReplicaPool) ?usize {
+        for (0..self.buff.len) |idx| {
+            if (self.buff[idx] == null) return idx;
+        }
+        return null;
+    }
+
+    pub fn ptr_iterator(self: ReplicaPool) PtrIterator {
+        return PtrIterator{ .pool = self };
+    }
+
+    pub fn count(self: ReplicaPool) usize {
+        var out: usize = 0;
+        for (self.buff) |item| out += if (item == null) 0 else 1;
+        return out;
+    }
+
+    fn create(self: *ReplicaPool, connection_h: ConnectionHandle) !Replica.Id {
+        const id = @as(Replica.Id, connection_h);
+        if (self._locate(id)) |_| return Error.AlreadyExists;
+        const free_idx = self._locate_free() orelse return Error.TooManyReplicas;
+        try self.bq.add_ctx(id);
+        self.buff[free_idx] = Replica{
+            .id = id,
+            .connection_h = connection_h,
+            .capabilities = .{},
+            .port = null,
+            .last_propagation = null,
+        };
+        return id;
+    }
+
+    pub fn get_ptr(self: ReplicaPool, id: Replica.Id) ?*Replica {
+        if (self._locate(id)) |idx| return &self.buff[idx].?;
+        return null;
+    }
+
+    pub fn remove(self: *ReplicaPool, id: Replica.Id) void {
+        const idx = self._locate(id) orelse return;
+        self.buff[idx] = null;
+        self.bq.delete_ctx(id);
+    }
+};
+
+/// Handshake with master and start handling incoming commands,
+/// mostly propagations.
+pub fn handle_replica2master(task: *Task, server: *Server) !HandlerResult {
+    task.logger.info("* replica2master handler listening", .{});
+    try task.handshake();
+    while (true) {
+        const et = try task.rcv_et();
+        defer et.deinit();
+        if (et.root == null) break; // connection closed by peeer
+        const cmd = try task.parse_cmd_or_reject(et.root.?) orelse break; // we rejected
+        const cmd_result = cmd.run(task, server);
+        if (cmd.should(.ack_master)) {
+            try task.send_elem(cmd_result.elem);
+        }
+        try task.bump_replica_offset(et.raw_bytes.len);
+    }
+    return .{};
+}
+
+/// Finalize handshake by sending RDB and begin handling requests
+/// for this replica.
+///
+/// The replica to serve is identified by connection handler
+/// *task.connection_h*; once the connection is removed from the connection
+/// pool, the handler will no longer resolve, ie. we assume replica has been
+/// removed and we quit.
+pub fn handle_master2replica(task: *Task, server: *Server) !HandlerResult {
+    _ = server;
+    const ms = try task.require_master_state();
+    var reqs_done: usize = 0;
+    try task.send_bin_elem(EMPTY_RDB);
+    task.logger.info("* master2replica handler ready", .{});
+    while (ms.replicas.get_ptr(task.connection_h)) |replica| { // "while we still have replica to care about"
+        task.logger.info("* waiting on replication request pipe", .{});
+        const ctx = try ms.replicas.bq.wait_request(replica.id);
+        task.logger.info("* received replication request: {any}", .{ctx.request});
+        switch (ctx.request) {
+            .shutdown => break,
+            .propagate => |et| {
+                task.send_blob(et.raw_bytes) catch |e| {
+                    task.logger.err("! failed to send element: {any} due to {!}", .{ et, e });
+                    try ctx.respond(.{ .err = e });
+                    break;
+                };
+                try ctx.respond(.{ .sent = {} });
+            },
+            .getack => |req| {
+                const offset = task.getack_one(req.elem) catch |e| {
+                    task.logger.err("! failed to get ACK within: {any} ns due to {!}", .{ req.timeout_ms, e });
+                    try ctx.respond(.{ .err = e });
+                    break;
+                };
+                try ctx.respond(.{ .ack_offset = @intCast(offset) });
+            },
+        }
+        task.logger.info("* processed replication request: {any}", .{ctx.request});
+        reqs_done +|= 1;
+    }
+    task.logger.debug(": reqs_done={d}", .{reqs_done});
+    task.logger.info("* shutting down master2replica propagation handler", .{});
+    return .{};
+}

src/redis/resp.zig

@@ -0,0 +1,851 @@
+const std = @import("std");
+
+const util = @import("../util.zig");
+
+const Elem = @import("core.zig").Elem;
+const ElemTree = @import("core.zig").ElemTree;
+const ElemType = @import("core.zig").ElemType;
+
+pub const Sigil = enum {
+    a_bulk_string, // bulk string (Elem.str) or null bulk string (Elem.nbs)
+    binary_string,
+    // ^^ Elem.bin: encoded like bulk string but without \r\n at the end (sigh...).
+    //
+    // This one is impossible to detect from the sigil so caller must know to expect
+    // binary string and use parse_binary_string() function.   (This happens eg. with
+    // the PSYNC2 command.)
+    simple_error,
+    simple_string,
+    integer,
+    null,
+    array,
+    nothing,
+};
+
+fn str_contains_only_digits(haystack: []const u8) bool {
+    const idx = std.mem.indexOfNone(u8, haystack, "0123456789");
+    return (idx == null);
+}
+
+fn str_contains_any(haystack: []const u8, needles: []const u8) bool {
+    const idx = std.mem.indexOfAny(u8, haystack, needles);
+    return (idx != null);
+}
+
+const MAX_READ_BYTES = 1024 * 1024;
+
+const Parser = struct {
+    reader: std.io.AnyReader,
+    arena: std.heap.ArenaAllocator,
+    raw: std.ArrayList(u8),
+    // ^^ we could be smarter and have all .err, .str and .bin refer to .raw,
+    // saving lots of memory, but it would require rewrite of some of the parser
+    // logic
+
+    pub const Error = error{
+        _NotImplemented,
+        ReaderError,
+        BadSigil,
+        BadSize,
+        EmptyCommand,
+        MissingData,
+        MissingBlob,
+        MissingSigil,
+        MissingArrayElement,
+        MissingArrayValue,
+        MissingSize,
+        MissingCRLF,
+        BadIntegerValue,
+        OutOfMemory,
+        InternalError,
+    };
+
+    fn init(reader: std.io.AnyReader, allocator: std.mem.Allocator) Parser {
+        var p: Parser = undefined;
+        p.arena = std.heap.ArenaAllocator.init(allocator);
+        p.raw = std.ArrayList(u8).init(p.arena.allocator());
+        p.reader = reader;
+        return p;
+    }
+
+    fn _pop_size(self: *Parser) Error!?usize {
+        // Size is positive int except for special-case of `-1`, which
+        // is only valid after bulk string sigil (`$`) and signifies
+        // that the element is "null bulk string" (apparently an older
+        // solution for "null").
+        // For simplicity we just report size as `null`.
+        const word = try self._stream_until_crlf();
+        defer self.arena.allocator().free(word);
+        if (std.mem.eql(u8, word, "-1")) return null;
+        if (!str_contains_only_digits(word)) return Error.BadSize;
+        const num = std.fmt.parseInt(usize, word, 10) catch return Error.BadSize;
+        return num;
+    }
+
+    fn _load_blob(self: *Parser, len: usize) Error![]u8 {
+        const dest = try self.arena.allocator().alloc(u8, len);
+        var rcvd_bytes_n: usize = 0;
+        while (rcvd_bytes_n < dest.len) {
+            const new_bytes_n = self.reader.read(dest[rcvd_bytes_n..]) catch |e| {
+                std.log.err("Parser._load_blob():e={}", .{e});
+                return Error.ReaderError;
+            };
+            if (new_bytes_n == 0) break;
+            rcvd_bytes_n = std.math.add(usize, rcvd_bytes_n, new_bytes_n) catch return Error.InternalError;
+        }
+        if (rcvd_bytes_n < dest.len) return Error.MissingData;
+        self.raw.appendSlice(dest) catch return Error.OutOfMemory;
+        return dest;
+    }
+
+    fn _stream_until_crlf(self: *Parser) Error![]u8 {
+        var dest = std.ArrayList(u8).init(self.arena.allocator());
+        var got_crlf = false;
+        while (true) {
+            // .streamUntilDelimiter() will drop the LF
+            self.reader.streamUntilDelimiter(dest.writer(), '\n', null) catch |e| switch (e) {
+                error.EndOfStream => break,
+                else => {
+                    std.log.err("Parser._stream_until_crlf():e={}", .{e});
+                    return Error.ReaderError;
+                },
+            };
+            if (dest.items.len > 0 and dest.getLast() == '\r') {
+                // CRLF confirmed; drop the CR as well
+                _ = dest.pop();
+                got_crlf = true;
+                break;
+            }
+            // this was just LF: put it back in
+            dest.append('\n') catch return Error.OutOfMemory;
+        }
+        if (!got_crlf) return Error.MissingCRLF;
+        self.raw.appendSlice(dest.items) catch return Error.OutOfMemory;
+        self.raw.appendSlice("\r\n") catch return Error.OutOfMemory;
+        return dest.toOwnedSlice() catch return Error.OutOfMemory;
+    }
+
+    fn __require_crlf(self: *Parser) Error!void {
+        const b1 = self.reader.readByte() catch return Error.MissingCRLF;
+        const b2 = self.reader.readByte() catch return Error.MissingCRLF;
+        self.raw.append(b1) catch return Error.OutOfMemory;
+        self.raw.append(b2) catch return Error.OutOfMemory;
+        if (b1 == '\r' and b2 == '\n') return;
+        return Error.MissingCRLF;
+    }
+
+    fn _popelem_array(self: *Parser) Error!Elem {
+        const len = try self._pop_size() orelse return Error.BadSize;
+        var togo = len;
+        var elem_al = std.ArrayList(Elem).init(self.arena.allocator());
+        while (togo > 0) {
+            const elem = try self._popelem() orelse return Error.MissingArrayElement;
+            try elem_al.append(elem);
+            togo = togo - 1;
+        }
+        return Elem{ .arr = elem_al.toOwnedSlice() catch return Error.OutOfMemory };
+    }
+
+    fn _popelem(self: *Parser) Error!?Elem {
+        switch (try self.__pop_sigil()) {
+            .nothing => return null,
+            .array => return try self._popelem_array(),
+            .integer => return try self._popelem_integer(),
+            .null => return try self._popelem_null(),
+            .simple_error => return try self._popelem_simple_error(),
+            .a_bulk_string => return try self._popelem_a_bulk_string(),
+            .simple_string => return try self._popelem_simple_string(),
+            .binary_string => unreachable,
+        }
+    }
+
+    fn _popelem_a_bulk_string(self: *Parser) Error!Elem {
+        if (try self._pop_size()) |len| {
+            // proper bulk_string with actual data
+            const buff = try self._load_blob(len);
+            try self.__require_crlf();
+            return Elem{ .str = buff };
+        } else {
+            // size was `-1` -> NBS
+            return Elem{ .nbs = null };
+        }
+    }
+
+    fn _popelem_binary_string(self: *Parser) Error!?Elem {
+        const sigil = try self.__pop_sigil();
+        if (sigil == .nothing) return null;
+        if (sigil != .a_bulk_string) return Error.BadSigil;
+        const len = try self._pop_size() orelse return Error.BadSize;
+        const buff = try self._load_blob(len);
+        return Elem{ .bin = buff };
+    }
+
+    fn _popelem_integer(self: *Parser) Error!Elem {
+        const bytes = try self._stream_until_crlf();
+        const int = std.fmt.parseInt(i64, bytes, 10) catch return Error.BadIntegerValue;
+        return Elem{ .int = int };
+    }
+
+    fn _popelem_null(self: *Parser) Error!Elem {
+        try self.__require_crlf();
+        return Elem{ .null = null };
+    }
+
+    fn _popelem_simple_error(self: *Parser) Error!Elem {
+        const bytes = try self._stream_until_crlf();
+        return Elem{ .err = bytes };
+    }
+
+    fn _popelem_simple_string(self: *Parser) Error!Elem {
+        const bytes = try self._stream_until_crlf();
+        return Elem{ .str = bytes };
+    }
+
+    fn __pop_sigil(self: *Parser) Error!Sigil {
+        const sigil = self.reader.readByte() catch return .nothing;
+        try self.raw.append(sigil);
+        switch (sigil) {
+            '*' => return .array,
+            '+' => return .simple_string,
+            '-' => return .simple_error,
+            '$' => return .a_bulk_string,
+            ':' => return .integer,
+            '_' => return .null,
+            else => return Error.BadSigil,
+        }
+    }
+
+    fn _as_tree(self: *Parser, root: ?Elem) Error!ElemTree {
+        return ElemTree{
+            .root = r: {
+                if (root == null) break :r null;
+                const ptr = self.arena.allocator().create(Elem) catch return Error.OutOfMemory;
+                ptr.* = root.?;
+                break :r ptr;
+            },
+            .raw_bytes = self.raw.toOwnedSlice() catch return Error.OutOfMemory,
+            .arena = self.arena,
+        };
+    }
+
+    fn parse(self: *Parser) Error!ElemTree {
+        //      const EP = self.arena.allocator().create(Elem) catch return Error.OutOfMemory;
+        //      std.log.err("EP: {*}", .{EP});
+        return try self._as_tree(try self._popelem());
+    }
+
+    fn parse_binary_string(self: *Parser) Error!ElemTree {
+        return try self._as_tree(try self._popelem_binary_string());
+    }
+};
+
+pub fn parse_et(reader: std.io.AnyReader, allocator: std.mem.Allocator) Parser.Error!ElemTree {
+    var parser = Parser.init(reader, allocator);
+    return try parser.parse();
+}
+
+/// measure how much bytes would *elem* take encoded
+pub fn predict_write(elem: Elem, allocator: std.mem.Allocator) !usize {
+    var al = std.ArrayList(u8).init(allocator);
+    defer al.deinit();
+    try write(elem, al.writer());
+    return al.items.len;
+}
+
+pub const ElemStreamTimer = struct {
+    allocator: std.mem.Allocator,
+    poller: Poller,
+
+    const StreamEnum = enum { file };
+    const Poller = std.io.Poller(StreamEnum);
+
+    pub const Error = error{ StreamClosed, StreamTimeout };
+    const ParseFn = *const fn (std.io.AnyReader, std.mem.Allocator) anyerror!ElemTree;
+
+    pub fn init(stream: std.net.Stream, allocator: std.mem.Allocator) ElemStreamTimer {
+        return .{
+            .poller = std.io.poll(
+                allocator,
+                StreamEnum,
+                .{ .file = std.fs.File{ .handle = stream.handle } },
+            ),
+            .allocator = allocator,
+        };
+    }
+
+    pub fn deinit(self: *ElemStreamTimer) void {
+        self.poller.deinit();
+    }
+
+    fn _get_slice(self: *ElemStreamTimer, timeout_ns: u64) ![]const u8 {
+        if (!(try self.poller.pollTimeout(timeout_ns))) return Error.StreamClosed;
+        const fifo = self.poller.fifo(.file);
+        if (fifo.readableLength() == 0) return Error.StreamTimeout;
+        return fifo.readableSlice(0);
+    }
+
+    fn _get_et(self: *ElemStreamTimer, parse_fn: ParseFn, timeout_ns: u64, allocator: std.mem.Allocator) !ElemTree {
+        var remaining_ns = timeout_ns;
+        while (true) {
+            if (remaining_ns == 0) return Error.StreamTimeout;
+            const start_nst = std.time.nanoTimestamp();
+            const data = try self._get_slice(remaining_ns);
+            var stream = std.io.fixedBufferStream(data);
+            const et = parse_fn(stream.reader().any(), allocator) catch continue;
+            const dur_ns = std.time.nanoTimestamp() - start_nst;
+            remaining_ns -|= @intCast(dur_ns);
+            if (et.root == null) unreachable; // .get_slice should never return slice of 0;
+            return et;
+        }
+    }
+
+    pub fn get_bin_et(self: *ElemStreamTimer, timeout_ns: u64, allocator: std.mem.Allocator) !ElemTree {
+        return self._get_et(
+            parse_binary_string_et,
+            timeout_ns,
+            allocator,
+        );
+    }
+
+    pub fn get_et(self: *ElemStreamTimer, timeout_ns: u64, allocator: std.mem.Allocator) !ElemTree {
+        return self._get_et(
+            parse_et,
+            timeout_ns,
+            allocator,
+        );
+    }
+};
+
+pub fn parse_binary_string_et(reader: std.io.AnyReader, allocator: std.mem.Allocator) Parser.Error!ElemTree {
+    var parser = Parser.init(reader, allocator);
+    return try parser.parse_binary_string();
+}
+
+pub fn require_blob(reader: std.io.AnyReader, allocator: std.mem.Allocator) Parser.Error![]const u8 {
+    var parser = Parser.init(reader, allocator);
+    const et = try parser.parse_binary_string();
+    const elem = et.root orelse error.MissingBlob;
+    return elem.bin;
+}
+
+pub fn write(data: Elem, writer: anytype) !void {
+    switch (data) {
+        .bool, .double, .null => return Parser.Error._NotImplemented,
+        .int => {
+            try std.fmt.format(writer, ":{d}\r\n", .{data.int});
+        },
+        .arr => {
+            try std.fmt.format(writer, "*{d}\r\n", .{data.arr.len});
+            for (data.arr) |item| {
+                try write(item, writer);
+            }
+        },
+        .nbs => {
+            try writer.writeAll("$-1\r\n");
+        },
+        .err => {
+            try std.fmt.format(writer, "-{s}\r\n", .{data.err});
+        },
+        .bin => {
+            try std.fmt.format(writer, "${d}\r\n", .{data.bin.len});
+            try writer.writeAll(data.bin);
+        },
+        .str => {
+            if (str_contains_any(data.str, "\r\n+")) {
+                try std.fmt.format(writer, "${d}\r\n", .{data.str.len});
+                try writer.writeAll(data.str);
+                try writer.writeAll("\r\n");
+            } else {
+                try std.fmt.format(writer, "+{s}\r\n", .{data.str});
+            }
+        },
+    }
+}
+
+const ParseTestCase = struct {
+    buff: []const u8,
+    result: anyerror!ElemTree,
+    gpa: std.heap.GeneralPurposeAllocator(.{}),
+
+    /// Initialize test case with source buffer *buff*
+    fn init(buff: []const u8) ParseTestCase {
+        var fbs = std.io.fixedBufferStream(buff);
+        var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+        return ParseTestCase{
+            .buff = buff,
+            .gpa = gpa,
+            .result = parse_et(fbs.reader().any(), gpa.allocator()),
+        };
+    }
+
+    /// Initialize test case with source buffer *buff* and parse_binary_string()
+    fn init_bin(buff: []const u8) ParseTestCase {
+        var fbs = std.io.fixedBufferStream(buff);
+        var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+        return ParseTestCase{
+            .buff = buff,
+            .gpa = gpa,
+            .result = parse_binary_string_et(fbs.reader().any(), gpa.allocator()),
+        };
+    }
+
+    fn _get_root(self: ParseTestCase) !Elem {
+        const tree = try self.result;
+        try std.testing.expectStringStartsWith(self.buff, tree.raw_bytes);
+        const root_ptr = tree.root orelse return error.TestFailNoRoot;
+        return root_ptr.*;
+    }
+
+    fn _get_arr_item(self: ParseTestCase, idx: usize) !Elem {
+        const elem = try self._get_root();
+        std.testing.expect(elem == ElemType.arr) catch return error.TestFailWrongTag;
+        std.testing.expect(elem.arr.len >= (idx + 1)) catch return error.TestFailWrongSize;
+        return elem.arr[idx];
+    }
+
+    /// Expect Parser.Error *oracle* thrown when parsing source buffer
+    fn expect_error(self: ParseTestCase, oracle: Parser.Error) !void {
+        try std.testing.expectEqual(oracle, self.result);
+    }
+
+    /// Expect null, ie. no elem at all found in the string (i.e. empty string was parsed)
+    fn expect_no_elem(self: ParseTestCase) !void {
+        const tree = try self.result;
+        try std.testing.expectEqualStrings(self.buff, tree.raw_bytes);
+        try std.testing.expectEqual(null, tree.root);
+    }
+
+    /// Expect ElemType.nbs
+    fn expect_nbs(self: ParseTestCase) !void {
+        const elem = try self._get_root();
+        std.testing.expect(elem == ElemType.nbs) catch return error.TestFailWrongTag;
+    }
+
+    /// Expect ElemType.null
+    fn expect_null(self: ParseTestCase) !void {
+        const elem = try self._get_root();
+        std.testing.expect(elem == ElemType.null) catch return error.TestFailWrongTag;
+    }
+
+    /// Expect ElemType.bool with bool value *oracle*
+    fn expect_bool(self: ParseTestCase, oracle: bool) !void {
+        const elem = try self._get_root();
+        std.testing.expect(elem == ElemType.bool) catch return error.TestFailWrongTag;
+        try std.testing.expectEqual(oracle, elem.bool);
+    }
+
+    /// Expect ElemType.double with f64 value *oracle*
+    fn expect_double(self: ParseTestCase, oracle: f64) !void {
+        const elem = try self._get_root();
+        std.testing.expect(elem == ElemType.double) catch return error.TestFailWrongTag;
+        try std.testing.expectEqual(oracle, elem.double);
+    }
+
+    /// Expect ElemType.int with i64 value *oracle*
+    fn expect_int(self: ParseTestCase, oracle: i64) !void {
+        const elem = try self._get_root();
+        std.testing.expect(elem == ElemType.int) catch return error.TestFailWrongTag;
+        try std.testing.expectEqual(oracle, elem.int);
+    }
+
+    /// Expect ElemType.err with string value *oracle*
+    fn expect_err(self: ParseTestCase, oracle: []const u8) !void {
+        const elem = try self._get_root();
+        std.testing.expect(elem == ElemType.err) catch return error.TestFailWrongTag;
+        try std.testing.expectEqualStrings(oracle, elem.err);
+    }
+
+    /// Expect ElemType.str with string value *oracle*
+    fn expect_str(self: ParseTestCase, oracle: []const u8) !void {
+        const elem = try self._get_root();
+        std.testing.expect(elem == ElemType.str) catch return error.TestFailWrongTag;
+        try std.testing.expectEqualStrings(oracle, elem.str);
+    }
+
+    /// Expect ElemType.bin with string value *oracle*
+    fn expect_bin(self: ParseTestCase, oracle: []const u8) !void {
+        const elem = try self._get_root();
+        std.testing.expect(elem == ElemType.bin) catch return error.TestFailWrongTag;
+        try std.testing.expectEqualStrings(oracle, elem.bin);
+    }
+
+    /// Expect ElemType.arr of length of *oracle*
+    fn expect_arr_len(self: ParseTestCase, oracle: usize) !void {
+        const elem = try self._get_root();
+        std.testing.expect(elem == ElemType.arr) catch return error.TestFailWrongTag;
+        try std.testing.expectEqual(oracle, elem.arr.len);
+    }
+
+    /// Expect ElemType.arr with ElemType.str at *idx*, with string value *oracle*
+    fn expect_str_at(self: ParseTestCase, idx: usize, oracle: []const u8) !void {
+        const elem = try self._get_arr_item(idx);
+        std.testing.expect(elem == ElemType.str) catch return error.TestFailWrongTag;
+        try std.testing.expectEqualStrings(oracle, elem.str);
+    }
+
+    /// Expect ElemType.arr with ElemType.bin at *idx*, with string value *oracle*
+    fn expect_bin_at(self: ParseTestCase, idx: usize, oracle: []const u8) !void {
+        const elem = try self._get_arr_item(idx);
+        std.testing.expect(elem == ElemType.bin) catch return error.TestFailWrongTag;
+        try std.testing.expectEqualStrings(oracle, elem.bin);
+    }
+
+    /// Expect ElemType.arr with ElemType.int at *idx*, with i64 value *oracle*
+    fn expect_int_at(self: ParseTestCase, idx: usize, oracle: i64) !void {
+        const elem = try self._get_arr_item(idx);
+        std.testing.expect(elem == ElemType.int) catch return error.TestFailWrongTag;
+        try std.testing.expectEqual(oracle, elem.int);
+    }
+
+    /// Expect ElemType.arr with ElemType.int at *idx*, with i64 value *oracle*
+    fn expect_null_at(self: ParseTestCase, idx: usize) !void {
+        const elem = try self._get_arr_item(idx);
+        std.testing.expect(elem == ElemType.null) catch return error.TestFailWrongTag;
+    }
+};
+
+test "parse()-NEW: nothing" {
+    const mkcase = ParseTestCase.init;
+    try mkcase("").expect_no_elem();
+}
+
+test "parse()-NEW: null" {
+    const mkcase = ParseTestCase.init;
+    try mkcase("_").expect_error(Parser.Error.MissingCRLF);
+    try mkcase("_\n").expect_error(Parser.Error.MissingCRLF);
+    try mkcase("_\r").expect_error(Parser.Error.MissingCRLF);
+    try mkcase("_\n\r").expect_error(Parser.Error.MissingCRLF);
+    try mkcase("_\r\n").expect_null();
+}
+
+test "parse()-NEW: nbs" {
+    const mkcase = ParseTestCase.init;
+    try mkcase("$").expect_error(Parser.Error.MissingCRLF);
+    try mkcase("$-").expect_error(Parser.Error.MissingCRLF);
+    try mkcase("$-1").expect_error(Parser.Error.MissingCRLF);
+    try mkcase("$-1\n").expect_error(Parser.Error.MissingCRLF);
+    try mkcase("$-1\r").expect_error(Parser.Error.MissingCRLF);
+    try mkcase("$-1\r\n").expect_nbs();
+    try mkcase("$-1\r\nX").expect_nbs();
+}
+
+test "parse()-NEW: simple error" {
+    const mkcase = ParseTestCase.init;
+    try mkcase("-").expect_error(Parser.Error.MissingCRLF);
+    try mkcase("-\n").expect_error(Parser.Error.MissingCRLF);
+    try mkcase("-\r").expect_error(Parser.Error.MissingCRLF);
+    try mkcase("-\n\r").expect_error(Parser.Error.MissingCRLF);
+    try mkcase("-\r\n").expect_err("");
+    try mkcase("-A\r\n").expect_err("A");
+    try mkcase("-AB\r\n").expect_err("AB");
+    try mkcase("-+\r\n").expect_err("+");
+}
+
+test "parse()-NEW: simple string" {
+    const mkcase = ParseTestCase.init;
+    try mkcase("+").expect_error(Parser.Error.MissingCRLF);
+    try mkcase("+\n").expect_error(Parser.Error.MissingCRLF);
+    try mkcase("+\r").expect_error(Parser.Error.MissingCRLF);
+    try mkcase("+\n\r").expect_error(Parser.Error.MissingCRLF);
+    try mkcase("+\r\n").expect_str("");
+    try mkcase("+A\r\n").expect_str("A");
+    try mkcase("+AB\r\n").expect_str("AB");
+    try mkcase("++\r\n").expect_str("+");
+}
+
+test "parse()-NEW: integer" {
+    const mkcase = ParseTestCase.init;
+    try mkcase(":").expect_error(Parser.Error.MissingCRLF);
+    try mkcase(":\n").expect_error(Parser.Error.MissingCRLF);
+    try mkcase(":\r").expect_error(Parser.Error.MissingCRLF);
+    try mkcase(":\n\r").expect_error(Parser.Error.MissingCRLF);
+    try mkcase(":\r\n").expect_error(Parser.Error.BadIntegerValue);
+    try mkcase(":A\r\n").expect_error(Parser.Error.BadIntegerValue);
+    try mkcase(":+A\r\n").expect_error(Parser.Error.BadIntegerValue);
+    try mkcase("::1\r\n").expect_error(Parser.Error.BadIntegerValue);
+    try mkcase(":1A\r\n").expect_error(Parser.Error.BadIntegerValue);
+    try mkcase(":A1\r\n").expect_error(Parser.Error.BadIntegerValue);
+    try mkcase(":0x01\r\n").expect_error(Parser.Error.BadIntegerValue);
+    try mkcase(":0\r\n").expect_int(0);
+    try mkcase(":1\r\n").expect_int(1);
+    try mkcase(":123\r\n").expect_int(123);
+    try mkcase(":-1\r\n").expect_int(-1);
+    try mkcase(":+1\r\n").expect_int(1);
+}
+
+test "parse()-NEW: bulk string" {
+    const mkcase = ParseTestCase.init;
+    try mkcase("$").expect_error(Parser.Error.MissingCRLF);
+    try mkcase("$1").expect_error(Parser.Error.MissingCRLF);
+    try mkcase("$X").expect_error(Parser.Error.MissingCRLF);
+    try mkcase("$XY").expect_error(Parser.Error.MissingCRLF);
+    try mkcase("$\r\n").expect_error(Parser.Error.BadSize);
+    try mkcase("$X\r\n").expect_error(Parser.Error.BadSize);
+    try mkcase("$XY\r\n").expect_error(Parser.Error.BadSize);
+    try mkcase("$1X\r\n").expect_error(Parser.Error.BadSize);
+    try mkcase("$1_000\r\n").expect_error(Parser.Error.BadSize);
+    try mkcase("$-2\r\n").expect_error(Parser.Error.BadSize); // -1 would be valid as NBS
+    try mkcase("$0x01\r\n").expect_error(Parser.Error.BadSize);
+    try mkcase("$1\r\n\r\n").expect_error(Parser.Error.MissingCRLF);
+    try mkcase("$1\r\nA").expect_error(Parser.Error.MissingCRLF);
+    try mkcase("$2\r\n\r\n").expect_error(Parser.Error.MissingCRLF);
+    try mkcase("$2\r\nA").expect_error(Parser.Error.MissingData);
+    try mkcase("$2\r\nAB").expect_error(Parser.Error.MissingCRLF);
+    try mkcase("$0\r\nA").expect_error(Parser.Error.MissingCRLF);
+    try mkcase("$0\r\nA\r\n").expect_error(Parser.Error.MissingCRLF);
+    try mkcase("$0\r\n\r\nX").expect_str("");
+    try mkcase("$0\r\n\r\n").expect_str("");
+    try mkcase("$1\r\nA\r\n").expect_str("A");
+    try mkcase("$1\r\n\r\r\n").expect_str("\r");
+    try mkcase("$1\r\n\n\r\n").expect_str("\n");
+    try mkcase("$2\r\nAB\r\n").expect_str("AB");
+    try mkcase("$2\r\n\r\n\r\n").expect_str("\r\n");
+    try mkcase("$9\r\n$3\r\nFOO\r\n\r\n").expect_str("$3\r\nFOO\r\n"); // including own code safely
+}
+
+test "parse()-NEW: binary string" {
+    const mkcase = ParseTestCase.init_bin;
+    try mkcase("$").expect_error(Parser.Error.MissingCRLF);
+    try mkcase("$1").expect_error(Parser.Error.MissingCRLF);
+    try mkcase("$X").expect_error(Parser.Error.MissingCRLF);
+    try mkcase("$XY").expect_error(Parser.Error.MissingCRLF);
+    try mkcase("$\r\n").expect_error(Parser.Error.BadSize);
+    try mkcase("$X\r\n").expect_error(Parser.Error.BadSize);
+    try mkcase("$XY\r\n").expect_error(Parser.Error.BadSize);
+    try mkcase("$1X\r\n").expect_error(Parser.Error.BadSize);
+    try mkcase("$1_000\r\n").expect_error(Parser.Error.BadSize);
+    try mkcase("$-2\r\n").expect_error(Parser.Error.BadSize); // -1 would be valid as NBS
+    try mkcase("$0x01\r\n").expect_error(Parser.Error.BadSize);
+    try mkcase("$0\r\n").expect_bin("");
+    try mkcase("$0\r\nA").expect_bin(""); // 'A' ignored
+    try mkcase("$1\r\nA").expect_bin("A");
+    try mkcase("$1\r\nAB").expect_bin("A"); // 'B' ignored
+    try mkcase("$1\r\n").expect_error(Parser.Error.MissingData);
+    try mkcase("$2\r\nAB").expect_bin("AB");
+    try mkcase("$2\r\nABC").expect_bin("AB"); // 'C' ignored
+    try mkcase("$2\r\nA").expect_error(Parser.Error.MissingData);
+}
+
+test "parse()-NEW: array: header" {
+    const mkcase = ParseTestCase.init;
+    try mkcase("*").expect_error(Parser.Error.MissingCRLF);
+    try mkcase("*1").expect_error(Parser.Error.MissingCRLF);
+    try mkcase("*12").expect_error(Parser.Error.MissingCRLF);
+    try mkcase("*X").expect_error(Parser.Error.MissingCRLF);
+    try mkcase("*XY").expect_error(Parser.Error.MissingCRLF);
+    try mkcase("*\r\n").expect_error(Parser.Error.BadSize);
+    try mkcase("*XY\r\n").expect_error(Parser.Error.BadSize);
+    try mkcase("*1X\r\n").expect_error(Parser.Error.BadSize);
+    try mkcase("*1_000\r\n").expect_error(Parser.Error.BadSize);
+    try mkcase("*-1\r\n").expect_error(Parser.Error.BadSize);
+    try mkcase("*0x01\r\n").expect_error(Parser.Error.BadSize);
+}
+
+test "parse()-NEW: array: empty" {
+    const mkcase = ParseTestCase.init;
+    try mkcase("*0\r").expect_error(Parser.Error.MissingCRLF);
+    try mkcase("*0\n").expect_error(Parser.Error.MissingCRLF);
+    try mkcase("*0\n\r").expect_error(Parser.Error.MissingCRLF);
+    try mkcase("*0\r\nX").expect_arr_len(0);
+    try mkcase("*0\r\nXY").expect_arr_len(0);
+    try mkcase("*0\r\n").expect_arr_len(0);
+}
+
+test "parse()-NEW: array: item header error" {
+    const mkcase = ParseTestCase.init;
+    try mkcase("*1\r\n").expect_error(Parser.Error.MissingArrayElement);
+    try mkcase("*1\r\nX").expect_error(Parser.Error.BadSigil);
+    try mkcase("*1\r\n*").expect_error(Parser.Error.MissingCRLF);
+}
+
+test "parse()-NEW: array: bulk string" {
+    const mkcase = ParseTestCase.init;
+    var case: ParseTestCase = undefined;
+
+    case = mkcase("*1\r\n$0\r\n\r\n");
+    try case.expect_arr_len(1);
+    try case.expect_str_at(0, "");
+    case = mkcase("*1\r\n$1\r\nA\r\n");
+    try case.expect_arr_len(1);
+    try case.expect_str_at(0, "A");
+    case = mkcase("*1\r\n$2\r\nAB\r\n");
+    try case.expect_arr_len(1);
+    try case.expect_str_at(0, "AB");
+    case = mkcase("*1\r\n$2\r\n\r\n\r\n");
+    try case.expect_arr_len(1);
+    try case.expect_str_at(0, "\r\n");
+}
+
+test "parse()-NEW: array: simple string header errors" {
+    const mkcase = ParseTestCase.init;
+    try mkcase("*1\r\n+").expect_error(Parser.Error.MissingCRLF);
+    try mkcase("*1\r\n+\n").expect_error(Parser.Error.MissingCRLF);
+    try mkcase("*1\r\n+\r").expect_error(Parser.Error.MissingCRLF);
+    try mkcase("*1\r\n+\n\r").expect_error(Parser.Error.MissingCRLF);
+}
+
+test "parse()-NEW: array: single, simple string" {
+    const mkcase = ParseTestCase.init;
+    var case: ParseTestCase = undefined;
+    case = mkcase("*1\r\n+\r\n");
+    try case.expect_arr_len(1);
+    try case.expect_str_at(0, "");
+    case = mkcase("*1\r\n+A\r\n");
+    try case.expect_arr_len(1);
+    try case.expect_str_at(0, "A");
+    case = mkcase("*1\r\n+AB\r\n");
+    try case.expect_arr_len(1);
+    try case.expect_str_at(0, "AB");
+}
+
+test "parse()-NEW: array: multiple: simple string, simple string" {
+    const mkcase = ParseTestCase.init;
+    var case: ParseTestCase = undefined;
+    case = mkcase("*2\r\n+\r\n+\r\n");
+    try case.expect_arr_len(2);
+    try case.expect_str_at(0, "");
+    try case.expect_str_at(1, "");
+    case = mkcase("*2\r\n+A\r\n+\r\n");
+    try case.expect_arr_len(2);
+    try case.expect_str_at(0, "A");
+    try case.expect_str_at(1, "");
+    case = mkcase("*2\r\n+\r\n+B\r\n");
+    try case.expect_arr_len(2);
+    try case.expect_str_at(0, "");
+    try case.expect_str_at(1, "B");
+    case = mkcase("*2\r\n+Foo bar\r\n+baz!\r\n");
+    try case.expect_arr_len(2);
+    try case.expect_str_at(0, "Foo bar");
+    try case.expect_str_at(1, "baz!");
+}
+
+test "parse()-NEW: array: multiple: simple string, bulk string" {
+    const mkcase = ParseTestCase.init;
+    var case: ParseTestCase = undefined;
+    case = mkcase("*2\r\n+\r\n$0\r\n\r\n");
+    try case.expect_arr_len(2);
+    try case.expect_str_at(0, "");
+    try case.expect_str_at(1, "");
+    case = mkcase("*2\r\n+A\r\n$0\r\n\r\n");
+    try case.expect_arr_len(2);
+    try case.expect_str_at(0, "A");
+    try case.expect_str_at(1, "");
+    case = mkcase("*2\r\n+\r\n$1\r\nB\r\n");
+    try case.expect_arr_len(2);
+    try case.expect_str_at(0, "");
+    try case.expect_str_at(1, "B");
+    case = mkcase("*2\r\n+Foo bar\r\n$4\r\nbaz!\r\n");
+    try case.expect_arr_len(2);
+    try case.expect_str_at(0, "Foo bar");
+    try case.expect_str_at(1, "baz!");
+}
+
+test "parse()-NEW: array: multiple: bulk string, simple string" {
+    const mkcase = ParseTestCase.init;
+    var case: ParseTestCase = undefined;
+    case = mkcase("*2\r\n$0\r\n\r\n+\r\n");
+    try case.expect_arr_len(2);
+    try case.expect_str_at(0, "");
+    try case.expect_str_at(1, "");
+    case = mkcase("*2\r\n+A\r\n$0\r\n\r\n");
+    try case.expect_arr_len(2);
+    try case.expect_str_at(0, "A");
+    try case.expect_str_at(1, "");
+    case = mkcase("*2\r\n$0\r\n\r\n+B\r\n");
+    try case.expect_arr_len(2);
+    try case.expect_str_at(0, "");
+    try case.expect_str_at(1, "B");
+    case = mkcase("*2\r\n$7\r\nFoo bar\r\n+baz!\r\n");
+    try case.expect_arr_len(2);
+    try case.expect_str_at(0, "Foo bar");
+    try case.expect_str_at(1, "baz!");
+}
+
+test "parse()-NEW: array: multiple: bulk string, bulk string" {
+    const mkcase = ParseTestCase.init;
+    var case: ParseTestCase = undefined;
+    case = mkcase("*2\r\n$0\r\n\r\n$0\r\n\r\n");
+    try case.expect_arr_len(2);
+    try case.expect_str_at(0, "");
+    try case.expect_str_at(1, "");
+    case = mkcase("*2\r\n$1\r\nA\r\n$0\r\n\r\n");
+    try case.expect_arr_len(2);
+    try case.expect_str_at(0, "A");
+    try case.expect_str_at(1, "");
+    case = mkcase("*2\r\n$0\r\n\r\n$1\r\nB\r\n");
+    try case.expect_arr_len(2);
+    try case.expect_str_at(0, "");
+    try case.expect_str_at(1, "B");
+    case = mkcase("*2\r\n$7\r\nFoo bar\r\n$4\r\nbaz!\r\n");
+    try case.expect_arr_len(2);
+    try case.expect_str_at(0, "Foo bar");
+    try case.expect_str_at(1, "baz!");
+}
+
+test "parse()-NEW: array: multiple: simple string, null" {
+    const mkcase = ParseTestCase.init;
+    var case: ParseTestCase = undefined;
+    case = mkcase("*2\r\n+\r\n_\r\n");
+    try case.expect_arr_len(2);
+    try case.expect_str_at(0, "");
+    try case.expect_null_at(1);
+    case = mkcase("*2\r\n+A\r\n_\r\n");
+    try case.expect_arr_len(2);
+    try case.expect_str_at(0, "A");
+    try case.expect_null_at(1);
+    case = mkcase("*2\r\n+Foo bar\r\n_\r\n");
+    try case.expect_arr_len(2);
+    try case.expect_str_at(0, "Foo bar");
+    try case.expect_null_at(1);
+}
+
+test "parse()-NEW: array: multiple: null, simple string" {
+    const mkcase = ParseTestCase.init;
+    var case: ParseTestCase = undefined;
+    case = mkcase("*2\r\n_\r\n+\r\n");
+    try case.expect_arr_len(2);
+    try case.expect_null_at(0);
+    try case.expect_str_at(1, "");
+    case = mkcase("*2\r\n_\r\n+A\r\n");
+    try case.expect_arr_len(2);
+    try case.expect_null_at(0);
+    try case.expect_str_at(1, "A");
+    case = mkcase("*2\r\n_\r\n+baz!\r\n");
+    try case.expect_arr_len(2);
+    try case.expect_null_at(0);
+    try case.expect_str_at(1, "baz!");
+}
+
+test "parse()-NEW: array: multiple: bulk string, null" {
+    const mkcase = ParseTestCase.init;
+    var case: ParseTestCase = undefined;
+    case = mkcase("*2\r\n$0\r\n\r\n_\r\n");
+    try case.expect_arr_len(2);
+    try case.expect_str_at(0, "");
+    try case.expect_null_at(1);
+    case = mkcase("*2\r\n+A\r\n_\r\n");
+    try case.expect_arr_len(2);
+    try case.expect_str_at(0, "A");
+    try case.expect_null_at(1);
+    case = mkcase("*2\r\n+Foo bar\r\n_\r\n");
+    try case.expect_arr_len(2);
+    try case.expect_str_at(0, "Foo bar");
+    try case.expect_null_at(1);
+}
+
+test "parse()-NEW: array: multiple: null, bulk string" {
+    const mkcase = ParseTestCase.init;
+    var case: ParseTestCase = undefined;
+    case = mkcase("*2\r\n_\r\n$0\r\n\r\n");
+    try case.expect_arr_len(2);
+    try case.expect_null_at(0);
+    try case.expect_str_at(1, "");
+    case = mkcase("*2\r\n_\r\n$1\r\nA\r\n");
+    try case.expect_arr_len(2);
+    try case.expect_null_at(0);
+    try case.expect_str_at(1, "A");
+    case = mkcase("*2\r\n_\r\n$4\r\nbaz!\r\n");
+    try case.expect_arr_len(2);
+    try case.expect_null_at(0);
+    try case.expect_str_at(1, "baz!");
+}

src/redis/server.zig

@@ -0,0 +1,251 @@
+const std = @import("std");
+
+const util = @import("../util.zig");
+const resp = @import("resp.zig");
+
+const replication = @import("replication.zig");
+
+const HandlerFn = @import("worker.zig").HandlerFn;
+const HandlerResult = @import("worker.zig").HandlerResult;
+const Logger = @import("logger.zig").Logger;
+const Role = @import("task.zig").Role;
+const Store = @import("store.zig").Store;
+const Task = @import("task.zig").Task;
+const WorkerPool = @import("worker.zig").WorkerPool;
+
+pub const Config = struct {
+    dir: ?[]const u8,
+    dbfilename: []const u8,
+    replication_host: ?[]const u8,
+    replication_port: u16,
+    max_dump_bytes: usize,
+    thread_count: usize,
+    replica_count: usize,
+    replica_buff_size: usize,
+    replica_timeout_ms: u64,
+    command_timeout_ms: u64,
+    port: u16,
+    debug: bool,
+    verbose: bool,
+    logdir: ?[]const u8,
+};
+
+pub const Connection = struct {
+    stream: std.net.Stream,
+    address: std.net.Address,
+};
+
+pub const Server = struct {
+    config: Config,
+    store: Store,
+    logger: Logger,
+    allocator: std.mem.Allocator,
+    replication_state: replication.State,
+    connection_pool: ConnectionPool,
+    last_task_id: usize = 0,
+    main_thread_id: std.Thread.Id,
+    cmd_worker_pool: CmdWorkerPool,
+    replica_worker_pool: ReplicaWorkerPool,
+
+    pub const CmdWorkerPool = WorkerPool("cmd", 0xDD);
+    pub const ReplicaWorkerPool = WorkerPool("rep", 0xDD);
+    pub const ConnectionPool = util.OpaquePool(Connection, 6, 48);
+
+    pub fn create(
+        config: Config,
+        threads_buff: []u8,
+        replicas_buff: []u8,
+        allocator: std.mem.Allocator,
+    ) !Server {
+        const logger = Logger.init_root(.{
+            .verbose = config.verbose,
+            .debug = config.debug,
+            .logdir = config.logdir,
+        });
+
+        const replication_state = try replication.State.init(config, allocator);
+
+        // validate config
+        {
+            const ideal_cpus = switch (replication_state) {
+                .master => 1 + config.thread_count + config.replica_count,
+                .replica => 1 + config.thread_count + 1,
+            };
+            const have_cpus = try std.Thread.getCpuCount();
+            switch (replication_state) {
+                .master => {
+                    if (config.thread_count == 0) {
+                        logger.err("cannot work with zero threads: config.thread_count=0", .{});
+                        return error.InvalidConfig;
+                    }
+                    if (have_cpus < ideal_cpus)
+                        logger.warn(
+                            "not enough CPUs; commands or replication might be blocked: have {d} but need {d} + {d} + 1 (commands, replicas, main thread)",
+                            .{ have_cpus, config.thread_count, config.replica_count },
+                        );
+                },
+                .replica => {
+                    if (have_cpus < ideal_cpus) {
+                        logger.warn(
+                            "not enough CPUs; commands or replication might be blocked: have {d} but need {d} + 1 + 1 (commands, replication, main thread)",
+                            .{ have_cpus, config.thread_count },
+                        );
+                    }
+                },
+            }
+        }
+
+        return Server{
+            .config = config,
+            .store = Store.init(allocator),
+            .logger = logger,
+            .allocator = allocator,
+            .replication_state = replication_state,
+            .connection_pool = try ConnectionPool.init(allocator),
+            .cmd_worker_pool = CmdWorkerPool.init(
+                threads_buff,
+                config.thread_count,
+                allocator,
+            ),
+            .replica_worker_pool = ReplicaWorkerPool.init(
+                replicas_buff,
+                config.replica_count,
+                allocator,
+            ),
+            .main_thread_id = std.Thread.getCurrentId(),
+        };
+    }
+
+    pub fn destroy(self: *Server) void {
+        self.cmd_worker_pool.destroy();
+        self.replica_worker_pool.destroy();
+    }
+
+    pub fn maybe_load_dump(self: *Server, allocator: std.mem.Allocator) !void {
+        if (self.config.dir == null) return;
+        const dir = self.config.dir.?;
+        const dbfilename = self.config.dbfilename;
+        self.store.load_rdb_dump(
+            dir,
+            dbfilename,
+            self.config.max_dump_bytes,
+            self.logger,
+            allocator,
+        ) catch |e| switch (e) {
+            error.FileNotFound => {
+                self.logger.warn("? ignoring non-existent dump file: {s}/{s}", .{ dir, dbfilename });
+                return;
+            },
+            else => {
+                self.logger.err("! error while loading dump file: {any} with {s}/{s}", .{ e, dir, dbfilename });
+                return e;
+            },
+        };
+    }
+
+    fn queue_task(self: *Server, role: Role, handler_fn: HandlerFn, connection_h: ConnectionPool.Handle) !void {
+        const task_args = Task.Args{
+            .role = role,
+            .connection_h = connection_h,
+            .timeout_ms = switch (role) {
+                .m2r, .r2m => self.config.replica_timeout_ms,
+                .cmd => self.config.command_timeout_ms,
+            },
+        };
+        switch (role) {
+            .m2r, .r2m => try self.replica_worker_pool.queue(handler_fn, task_args),
+            .cmd => try self.cmd_worker_pool.queue(handler_fn, task_args),
+        }
+    }
+
+    pub fn create_master_connection(self: *Server) !ConnectionPool.Handle {
+        const list = try std.net.getAddressList(
+            self.allocator,
+            self.replication_state.replica.master_host,
+            self.replication_state.replica.master_port,
+        );
+        defer list.deinit();
+        if (list.addrs.len == 0) return error.UnknownHostName;
+        var stream: std.net.Stream = undefined;
+        for (list.addrs) |addr| {
+            stream = std.net.tcpConnectToAddress(addr) catch |err| switch (err) {
+                error.ConnectionRefused => {
+                    continue;
+                },
+                else => return err,
+            };
+            return try self.connection_pool.put(Connection{
+                .stream = stream,
+                .address = addr,
+            });
+        }
+        return std.posix.ConnectError.ConnectionRefused;
+    }
+
+    pub fn serve(
+        self: *Server,
+        listener: *std.net.Server,
+    ) !void {
+        try self.cmd_worker_pool.start(self);
+        try self.replica_worker_pool.start(self);
+
+        if (self.replication_state == .replica) {
+            const handle = try self.create_master_connection();
+            try self.queue_task(
+                .r2m,
+                replication.handle_replica2master,
+                handle,
+            );
+        }
+
+        var conn: std.net.Server.Connection = undefined;
+        while (true) {
+            conn = try listener.accept();
+            const handle = try self.connection_pool.put(Connection{
+                .address = conn.address,
+                .stream = conn.stream,
+            });
+            try self.queue_task(
+                .cmd,
+                handle_cmd,
+                handle,
+            );
+        }
+    }
+};
+
+/// Handle incoming RESP commands.
+pub fn handle_cmd(task: *Task, server: *Server) !HandlerResult {
+    task.logger.info("* command handler started; awaiting commands from stream", .{});
+    while (true) {
+        const et = try task.rcv_et();
+        if (et.root == null) break; // connection closed by peeer
+        const cmd = try task.parse_cmd_or_reject(et.root.?) orelse break; // we rejected
+        const cmd_result = cmd.run(task, server);
+        try task.send_elem(cmd_result.elem);
+
+        // propagate?
+        if (cmd.should(.propagate) and cmd_result.ok) {
+            try task.maybe_propagate(et);
+        } else {
+            // only deinit if no propagation is happening
+            defer et.deinit();
+        }
+
+        // keep stream as new replica?
+        if (cmd.should(.start_replica)) {
+            if (!cmd_result.ok) {
+                task.logger.warn("? replica propagation setup failed", .{});
+                break;
+            }
+            task.logger.info("* re-using connection for replica propagation", .{});
+            try server.queue_task(
+                .m2r,
+                replication.handle_master2replica,
+                task.connection_h,
+            );
+            return .{ .connection_policy = .keep };
+        }
+    }
+    return .{};
+}

src/redis/store.zig

@@ -0,0 +1,118 @@
+const std = @import("std");
+
+const core = @import("core.zig");
+const rdb = @import("rdb.zig");
+
+const Elem = core.Elem;
+const Logger = @import("logger.zig").Logger;
+
+pub const PxUpdate = union(enum) {
+    unset,
+    keep,
+    new: i64,
+};
+
+pub const Store = struct {
+    pxats_db: std.StringHashMap(i64),
+    elems_db: std.StringHashMap(*Elem),
+    m: std.Thread.Mutex,
+    allocator: std.mem.Allocator,
+
+    const Error = error{
+        NoPreviousTtl,
+    };
+
+    pub fn init(allocator: std.mem.Allocator) Store {
+        return Store{
+            .m = std.Thread.Mutex{},
+            .pxats_db = std.StringHashMap(i64).init(allocator),
+            .elems_db = std.StringHashMap(*Elem).init(allocator),
+            .allocator = allocator,
+        };
+    }
+
+    fn _adopt_key(self: Store, key: []const u8) ![]const u8 {
+        if (self.elems_db.getEntry(key)) |old_entry| {
+            return old_entry.key_ptr.*;
+        } else {
+            return try self.allocator.dupe(u8, key);
+        }
+    }
+
+    fn _disown_key(self: *Store, key: []const u8) void {
+        const old_entry = self.elems_db.getEntry(key);
+        if (old_entry == null) return;
+        self.allocator.free(old_entry.?.key_ptr.*);
+    }
+
+    fn _remove_if_expired(self: *Store, key: []const u8) !void {
+        const pxat = self.pxats_db.get(key) orelse return;
+        const now = std.time.milliTimestamp();
+        if (now < pxat) return;
+        try self.delete_elem(key);
+    }
+
+    pub fn delete_elem(self: *Store, key: []const u8) !void {
+        const elem = self.elems_db.get(key) orelse return;
+        try core.deep_free_elem(elem, self.allocator, core.ELEM_MAX_DEPTH);
+        _ = self.pxats_db.remove(key);
+        _ = self.elems_db.remove(key);
+        self._disown_key(key);
+    }
+
+    pub fn get_elem(self: *Store, key: []const u8) !?Elem {
+        try self._remove_if_expired(key);
+        const elem_ptr = self.elems_db.get(key) orelse return null;
+        return elem_ptr.*;
+    }
+
+    pub fn put_elem(self: *Store, key: []const u8, value: Elem, px_update: PxUpdate) !void {
+        const our_pxat = switch (px_update) {
+            .unset => null,
+            .new => px_update.new,
+            .keep => self.pxats_db.get(key) orelse return Error.NoPreviousTtl,
+        };
+        const our_elem = try core.deep_copy_elem(&value, self.allocator, core.ELEM_MAX_DEPTH);
+        const our_key = try self._adopt_key(key);
+        try self.elems_db.put(our_key, our_elem);
+        try self.pxats_db.put(our_key, our_pxat orelse return);
+    }
+
+    pub fn describe(self: Store, logger: Logger) void {
+        var n: usize = 0;
+        var key_iter = self.elems_db.keyIterator();
+        while (key_iter.next()) |key| {
+            n += 1;
+            logger.debug("Store.describe():key={s}", .{key.*});
+        }
+        logger.debug("Store.describe():n={d}", .{n});
+    }
+
+    pub fn load_rdb_dump(
+        self: *Store,
+        dirpath: []const u8,
+        dbfilename: []const u8,
+        max_bytes: usize,
+        logger: Logger,
+        allocator: std.mem.Allocator,
+    ) !void {
+        const dir = try std.fs.openDirAbsolute(dirpath, .{});
+        const fh = try dir.openFile(dbfilename, .{ .mode = .read_only });
+        const content = try fh.readToEndAlloc(allocator, max_bytes);
+        var parser = rdb.Parser.init(content, allocator);
+        const rdb_file = try parser.parse();
+        for (rdb_file.database) |sub| {
+            var iter = sub.values.iterator();
+            while (iter.next()) |rdb_entry_ptr| {
+                const key = rdb_entry_ptr.key_ptr.*;
+                const elem = rdb_entry_ptr.value_ptr.*;
+                const px_update = if (sub.pxats.get(key)) |pxat|
+                    PxUpdate{ .new = pxat }
+                else
+                    PxUpdate{ .unset = {} };
+                logger.info("* loading elem: {s} | {any} ({any})", .{ key, elem, px_update });
+                try self.put_elem(key, elem, px_update);
+            }
+        }
+    }
+};

src/redis/task.zig

@@ -0,0 +1,345 @@
+const std = @import("std");
+
+const resp = @import("resp.zig");
+const util = @import("../util.zig");
+
+const Command = @import("command.zig").Command;
+const Elem = @import("core.zig").Elem;
+const ElemTree = @import("core.zig").ElemTree;
+const Logger = @import("logger.zig").Logger;
+const ConnectionHandle = @import("server.zig").Server.ConnectionPool.Handle;
+const ReplicationState = @import("replication.zig").State;
+const ReplicaState = @import("replication.zig").ReplicaState;
+const ReplicaRequest = @import("replication.zig").Request;
+const ReplicationBatch = @import("replication.zig").ReplicaPool.BatchQueue.Batch;
+const MasterState = @import("replication.zig").MasterState;
+const WorkerPool = @import("worker.zig").WorkerPool;
+const EMPTY_RDB = @import("rdb.zig").EMPTY_RDB;
+
+pub const Role = enum { cmd, r2m, m2r };
+
+pub const Task = struct {
+    connection_h: ConnectionHandle,
+    timeout_ms: u64,
+    stream: std.net.Stream,
+    logger: Logger,
+    replication_state: *ReplicationState,
+    allocator: std.mem.Allocator,
+
+    pub const Args = struct {
+        role: Role,
+        connection_h: ConnectionHandle,
+        timeout_ms: u64,
+    };
+
+    pub fn deinit(self: *Task) void {
+        self.logger.debug("* done", .{});
+        self.logger.deinit();
+    }
+
+    //
+    // replication state access helpers
+    //
+
+    pub fn get_master_state(self: Task) ?*MasterState {
+        if (self.replication_state.* == .replica) return null;
+        return &self.replication_state.master;
+    }
+
+    pub fn get_replica_state(self: Task) ?*ReplicaState {
+        if (self.replication_state.* == .master) return null;
+        return &self.replication_state.replica;
+    }
+
+    pub fn require_master_state(self: Task) !*MasterState {
+        if (self.replication_state.* == .replica) return error.NotAMaster;
+        return &self.replication_state.master;
+    }
+
+    pub fn require_replica_state(self: Task) !*ReplicaState {
+        if (self.replication_state.* == .master) return error.NotAReplica;
+        return &self.replication_state.replica;
+    }
+
+    //
+    // basic send/receive
+    //
+
+    pub fn require_bin_et(self: Task) !ElemTree {
+        var timer = resp.ElemStreamTimer.init(self.stream, self.allocator);
+        defer timer.deinit();
+        const et = timer.get_bin_et(self.timeout_ms * std.time.ns_per_ms, self.allocator) catch |e| {
+            self.logger.warn("? did not receive full RESP element: {!} (timeout_ms={d})", .{ e, self.timeout_ms });
+            return e;
+        };
+        errdefer et.deinit();
+        if (et.root == null) {
+            self.logger.info("* connection closed by peer", .{});
+            return error.ConnectionClosed;
+        }
+        return et;
+    }
+
+    pub fn require_et(self: Task) !ElemTree {
+        return self.require_et_within(self.timeout_ms);
+    }
+
+    pub fn require_et_within(self: Task, timeout_ms: u64) !ElemTree {
+        var timer = resp.ElemStreamTimer.init(self.stream, self.allocator);
+        defer timer.deinit();
+        const et = timer.get_et(timeout_ms * std.time.ns_per_ms, self.allocator) catch |e| {
+            self.logger.warn("? did not receive full RESP element: {!} within {d} ms", .{ e, timeout_ms });
+            return e;
+        };
+        errdefer et.deinit();
+        if (et.root == null) {
+            self.logger.info("* connection closed by peer", .{});
+            return error.ConnectionClosed;
+        }
+        return et;
+    }
+
+    pub fn rcv_et(self: Task) !ElemTree {
+        const et = resp.parse_et(self.stream.reader().any(), self.allocator) catch |e| {
+            self.logger.err("! error parsing RESP element: {!}", .{e});
+            return e;
+        };
+        if (et.root == null) {
+            std.debug.assert(et.raw_bytes.len == 0);
+            self.logger.info("* connection closed by peer", .{});
+        } else {
+            self.logger.info("< {any}", .{et});
+        }
+        return et;
+    }
+
+    pub fn send_bin_elem(self: Task, bin: []const u8) !void {
+        self.logger.info(">> {s}", .{util.qb(bin)});
+        const w = self.stream.writer().any();
+        w.print("${d}\r\n{s}", .{ bin.len, bin }) catch |e| {
+            self.logger.err("! error sending RESP .bin: {!}", .{e});
+            return e;
+        };
+    }
+
+    pub fn send_blob(self: Task, blob: []const u8) !void {
+        self.logger.info(">>> {s}", .{util.qb(blob)});
+        const w = self.stream.writer().any();
+        w.writeAll(blob) catch |e| {
+            self.logger.err("! error sending raw blob: {!}", .{e});
+            return e;
+        };
+    }
+
+    pub fn send_elem(self: Task, cmd_elem: Elem) !void {
+        self.logger.info("> {any}", .{cmd_elem});
+        resp.write(cmd_elem, self.stream.writer().any()) catch |e| {
+            self.logger.err("! error sending RESP element: {!}", .{e});
+            return e;
+        };
+    }
+
+    //
+    // simple operations
+    //
+
+    pub fn parse_cmd_or_reject(self: Task, cmd_elem: *Elem) !?Command {
+        return Command.parse(cmd_elem.*, self.logger, self.allocator) catch |e| {
+            try self.send_elem(Elem{ .err = @errorName(e) });
+            self.logger.err("! error parsing REDIS command: {!}", .{e});
+            return null;
+        };
+    }
+
+    pub fn sleep(self: Task, ms: usize) void {
+        self.logger.info("* sleeping for {d}ms", .{ms});
+        std.debug.assert(ms < 1_000_000);
+        const ns = std.math.mul(usize, ms, 1_000_000) catch unreachable;
+        std.time.sleep(ns);
+    }
+
+    //
+    // replication operations
+    //
+
+    pub fn handshake(
+        self: *Task,
+    ) !void {
+        const rs = try self.require_replica_state();
+        var response_et: ElemTree = undefined;
+        defer response_et.deinit();
+
+        // PING
+        try self.send_elem(
+            Elem{ .arr = &.{
+                Elem{ .str = "PING" },
+            } },
+        );
+        response_et = try self.rcv_et();
+        try response_et.assert_cond(.{ .str_eq_i = "PONG" });
+
+        // REPLCONF listening-port <OUR_PORT>
+        const port_str = try std.fmt.allocPrint(self.allocator, "{d}", .{rs.master_port});
+        defer self.allocator.free(port_str);
+        try self.send_elem(
+            Elem{ .arr = &.{
+                Elem{ .str = "REPLCONF" },
+                Elem{ .str = "listening-port" },
+                Elem{ .str = port_str },
+            } },
+        );
+        response_et = try self.rcv_et();
+        try response_et.assert_cond(.{ .str_eq_i = "OK" });
+
+        // REPLCONF capa
+        try self.send_elem(
+            Elem{ .arr = &.{
+                Elem{ .str = "REPLCONF" },
+                Elem{ .str = "capa" },
+                Elem{ .str = "psync2" },
+            } },
+        );
+        response_et = try self.rcv_et();
+        try response_et.assert_cond(.{ .str_eq_i = "OK" });
+
+        // PSYNC <REPLID> <OFFSET>
+        //  .. but since it's handshake, REPLID="?" and OFFSET=-1
+        try self.send_elem(
+            Elem{ .arr = &.{
+                Elem{ .str = "PSYNC" },
+                Elem{ .str = "?" },
+                Elem{ .str = "-1" },
+            } },
+        );
+        response_et = try self.rcv_et();
+        try response_et.assert_cond(.{ .str_startswith_i = "FULLRESYNC" });
+
+        // blob with master's RDB
+        response_et = try self.require_bin_et();
+        try response_et.assert_cond(.{ .isa_bin = true, .len_ge = EMPTY_RDB.len });
+    }
+
+    fn _bump_master_offset(self: Task, bytes_n: u64) !void {
+        const ms = try self.require_master_state();
+        const old_offset = ms.repl_offset;
+        ms.repl_offset = try std.math.add(u64, old_offset, bytes_n);
+        self.logger.debug(
+            ": bumped master offset: {d} + {d} => {d}",
+            .{ old_offset, bytes_n, ms.repl_offset },
+        );
+    }
+
+    pub fn _broadcast(self: Task, ms: *MasterState, req: ReplicaRequest, timeout_ms: u64) !*ReplicationBatch {
+        self.logger.info("* broadcasting request: {any} to {d} replicas", .{ req, ms.replicas.count() });
+        const batch_ptr = try ms.replicas.bq.queue_batch(req, try std.math.mul(u64, timeout_ms, std.time.ns_per_ms));
+        ms.replicas.bq._dump("_broadcast()");
+        return batch_ptr;
+    }
+
+    pub fn maybe_propagate(self: Task, et: ElemTree) !void {
+        defer et.deinit();
+        const ms = self.get_master_state() orelse return;
+        try self._bump_master_offset(et.raw_bytes.len);
+        const batch_ptr = try self._broadcast(ms, .{ .propagate = et }, 0);
+        batch_ptr.disown();
+        // while (batch.next()) |msg| {
+        //     self.logger.debug(": thread responded: {any}", .{msg});
+        //     switch (msg.response) {
+        //         .sent => {
+        //             self.logger.debug(
+        //                 ": replica acked, propagation sent: replica_id={d} duration_ms={d}",
+        //                 .{ msg.ctx_id, msg.duration_ms },
+        //             );
+        //         },
+        //         .err => {
+        //             self.logger.err(
+        //                 "! propagation was not sent, dropping replica: replica_id={d} duration_ms={d} err={!}",
+        //                 .{ msg.ctx_id, msg.duration_ms, msg.response.err },
+        //             );
+        //             ms.replicas.remove(msg.ctx_id);
+        //         },
+        //         else => {
+        //             unreachable; // unexpected response to .propagation request
+        //         },
+        //     }
+        //     ms.replicas.bq._dump(".maybe_propagate(), received propagation");
+        // }
+        // for (batch.jobs) |j| self.logger.debug(": j={any}", .{j});
+    }
+
+    pub fn bump_replica_offset(self: Task, bytes_n: u64) !void {
+        const rs = try self.require_replica_state();
+        const old_offset = rs.master_last_offset orelse 0;
+        rs.master_last_offset = try std.math.add(u64, old_offset, bytes_n);
+        self.logger.debug(
+            ": bumped replica offset: {d} + {d} => {d}",
+            .{ old_offset, bytes_n, rs.master_last_offset.? },
+        );
+    }
+
+    pub fn check_replicas(self: Task, numreplicas: usize, timeout_ms: u64) !usize {
+        if (numreplicas == 0) return 0;
+        const ms = try self.require_master_state();
+        const getack_elem = Elem{ .arr = &.{
+            Elem{ .str = "REPLCONF" },
+            Elem{ .str = "GETACK" },
+            Elem{ .str = "*" },
+        } };
+        const getack_len = try resp.predict_write(getack_elem, self.allocator);
+        var acked_count: usize = 0;
+        var acked_togo = numreplicas;
+        var batch = try self._broadcast(
+            ms,
+            .{ .getack = .{ .elem = &getack_elem, .timeout_ms = timeout_ms } },
+            timeout_ms,
+        );
+        defer batch.deinit();
+        while (batch.next()) |msg| {
+            self.logger.debug(": thread responded: {any}", .{msg});
+            switch (msg.response) {
+                .err => {
+                    self.logger.err(
+                        "! ACK failed, dropping replica: replica_id={d} duration_ms={d} err={!}",
+                        .{ msg.ctx_id, msg.duration_ms, msg.response.err },
+                    );
+                    ms.replicas.remove(msg.ctx_id);
+                },
+                .ack_offset => |offset| {
+                    if (offset == ms.repl_offset) {
+                        acked_count += 1;
+                        acked_togo -|= 1;
+                    } else {
+                        self.logger.debug(
+                            ": ACK not accepted: replica_id={d} duration_ms={d} .ack_offset={d} ms.repl_offset={d}",
+                            .{ msg.ctx_id, msg.duration_ms, offset, ms.repl_offset },
+                        );
+                    }
+                },
+                else => {
+                    unreachable; // unexpected response to .propagation request
+                },
+            }
+            if (acked_togo == 0) break; // enough to satisfy *numreplicas*
+        }
+        for (batch.jobs) |j| self.logger.debug(": j={any}", .{j});
+        for (batch.jobs) |j| {
+            if (j == .timeouted) self.logger.debug("* replica late for timeout: replica_id={d}", .{j.timeouted});
+        }
+        try self._bump_master_offset(getack_len);
+        return acked_count;
+    }
+
+    pub fn getack_one(self: Task, elem: *const Elem) !i64 {
+        if (self.replication_state.* == .replica) unreachable; // replica must not call this
+        self.logger.debug(": sending GETACK elem..", .{});
+        try self.send_elem(elem.*);
+        self.logger.debug(": ..sent, receiving response..", .{});
+        const et = try self.require_et();
+        self.logger.debug(": ..received: {any}", .{et});
+        defer et.deinit();
+        try et.assert_cond(.{ .len_eq = 3 });
+        try et.assert_cond(.{ .idx = 0, .str_eq_i = "REPLCONF" });
+        try et.assert_cond(.{ .idx = 1, .str_eq_i = "ACK" });
+        return try et.parse_int_at(2);
+    }
+};

src/redis/worker.zig

@@ -0,0 +1,188 @@
+const std = @import("std");
+const builtin = @import("builtin");
+
+const Connection = @import("server.zig").Connection;
+const Logger = @import("logger.zig").Logger;
+const Server = @import("server.zig").Server;
+const Task = @import("task.zig").Task;
+const Role = @import("task.zig").Role;
+
+pub const HandlerResult = struct {
+    connection_policy: enum { close, keep } = .close,
+};
+
+pub const HandlerFn = *const fn (*Task, *Server) anyerror!HandlerResult;
+
+pub fn WorkerPool(comptime pfx: []const u8, comptime buff_mask: ?u8) type {
+    return struct {
+        threads_buff: []u8,
+        arena: std.heap.ArenaAllocator,
+        m: std.Thread.Mutex,
+        c: std.Thread.Condition,
+        job_queue: JobList,
+        thread_count: usize,
+        state: enum { new, running, stopped, disabled },
+        next_task_id: usize = 0,
+        server: ?*Server = null,
+
+        const TaskIdPfx = pfx;
+        const BuffMask = buff_mask;
+
+        const JobList = std.SinglyLinkedList(Job);
+        const WorkerPoolT = @This();
+
+        pub const Workspace = struct {
+            buff: []u8,
+            fba: std.heap.FixedBufferAllocator,
+        };
+
+        pub const Job = struct {
+            handler_fn: HandlerFn,
+            task_args: Task.Args,
+            task_id: usize,
+        };
+
+        pub fn init(
+            threads_buff: []u8,
+            thread_count: usize,
+            allocator: std.mem.Allocator,
+        ) WorkerPoolT {
+            return WorkerPoolT{
+                .thread_count = thread_count,
+                .threads_buff = threads_buff,
+                .arena = std.heap.ArenaAllocator.init(allocator),
+                .m = std.Thread.Mutex{},
+                .c = std.Thread.Condition{},
+                .job_queue = JobList{},
+                .state = .new,
+            };
+        }
+
+        pub fn start(self: *WorkerPoolT, server: *Server) !void {
+            self.server = server;
+            if (self.thread_count == 0) {
+                self.state = .disabled;
+                return;
+            }
+            const thread_count = self.thread_count;
+            if (@mod(self.threads_buff.len, thread_count) > 0) return error.BuffTooLarge;
+            const buff_len = @divExact(self.threads_buff.len, thread_count);
+            self.state = .running;
+            for (0..thread_count) |idx| {
+                const ws_ptr = try self.arena.allocator().create(Workspace);
+                const bgn = idx * buff_len;
+                const ws_buff = self.threads_buff[bgn..(bgn + buff_len)];
+                ws_ptr.* = Workspace{
+                    .buff = ws_buff,
+                    .fba = std.heap.FixedBufferAllocator.init(ws_buff),
+                };
+                _ = try std.Thread.spawn(.{}, WorkerPoolT._worker_fn, .{ ws_ptr, self });
+            }
+        }
+
+        pub fn destroy(self: *WorkerPoolT) void {
+            self.state = .stopped;
+            self.arena.deinit();
+        }
+
+        fn _worker_fn(
+            ws: *Workspace,
+            pool: *WorkerPoolT,
+        ) void {
+            const thread_id = std.Thread.getCurrentId();
+            const server = pool.server.?; // server pointer must be set by now
+            while (pool.state == .running) {
+                var maybe_job: ?Job = null;
+                {
+                    pool.m.lock();
+                    defer pool.m.unlock();
+                    while (pool.job_queue.first == null) {
+                        pool.c.wait(&pool.m);
+                    }
+                    const jnode = pool.job_queue.popFirst().?;
+                    maybe_job = jnode.*.data;
+                    pool.arena.allocator().destroy(jnode);
+                }
+                var job = maybe_job.?;
+
+                // reset and wipe ws memory
+                ws.fba.reset();
+                if (WorkerPoolT.BuffMask) |m| {
+                    for (ws.buff) |*b| b.* = m;
+                }
+
+                // create new task
+                const connection: Connection = server.connection_pool.get(job.task_args.connection_h) orelse {
+                    unreachable; // spawning task for a nonexistent connection!?
+                };
+                const logger_ctx = Logger.TaskCtx{
+                    .task_id = job.task_id,
+                    .task_id_pfx = WorkerPoolT.TaskIdPfx,
+                    .thread_id = if (thread_id == server.main_thread_id) null else thread_id,
+                    .handle = job.task_args.connection_h,
+                    .address = connection.address,
+                    .stream = connection.stream,
+                    .role = job.task_args.role,
+                };
+                var task = Task{
+                    .connection_h = job.task_args.connection_h,
+                    .timeout_ms = job.task_args.timeout_ms,
+                    .replication_state = &server.replication_state,
+                    .stream = connection.stream,
+                    .logger = Logger.init_for_task(server.logger.options, logger_ctx, ws.fba.allocator()),
+                    .allocator = ws.fba.allocator(),
+                };
+                defer task.deinit();
+
+                // run the handler
+                const result = job.handler_fn(
+                    &task,
+                    server,
+                ) catch |e| {
+                    _ = server.connection_pool.delete(task.connection_h);
+                    task.stream.close();
+                    task.logger.err("handler returned error: {!}", .{e});
+                    server.logger.err(
+                        "connection handler returned error:a connection_h={any} address={any} e={!}",
+                        .{ job.task_args.connection_h, connection.address, e },
+                    );
+                    return;
+                };
+
+                switch (result.connection_policy) {
+                    .close => {
+                        task.logger.info("* task done; closing connection", .{});
+                        task.stream.close();
+                        _ = server.connection_pool.delete(task.connection_h);
+                    },
+                    .keep => {
+                        task.logger.info("* re-using connection for next task", .{});
+                    },
+                }
+            }
+        }
+
+        pub fn queue(
+            self: *WorkerPoolT,
+            handler_fn: HandlerFn,
+            task_args: Task.Args,
+        ) !void {
+            if (self.state == .disabled) return error.WorkerPoolDisabled;
+            if (self.state == .stopped) return error.WorkerPoolStopped;
+            if (self.state == .new) return error.WorkerPoolNotStarted;
+            {
+                self.m.lock();
+                defer self.m.unlock();
+                const jnode_ptr = try self.arena.allocator().create(JobList.Node);
+                jnode_ptr.* = JobList.Node{ .data = Job{
+                    .handler_fn = handler_fn,
+                    .task_args = task_args,
+                    .task_id = self.next_task_id,
+                } };
+                self.next_task_id += 1;
+                self.job_queue.prepend(jnode_ptr);
+            }
+            self.c.signal();
+        }
+    };
+}

watch_logs.sh

@@ -0,0 +1,74 @@
+#!/bin/bash
+
+
+usage() {
+    local self="${0##*/}"
+    local err=$1; shift
+    echo >&2 "usage: $self DIR [DIR...]"
+    echo >&2 ""
+    echo >&2 "$err"
+    exit 3
+}
+
+warn() {
+    echo >&2 "$@"
+}
+
+die() {
+    echo >&2 "$@"
+    exit 3
+}
+
+list_files() {
+    local dir
+    for dir in "${Dirs[@]}"; do
+        echo "$dir/root.log"
+        seq -f "$dir/task-rep%02.0f.log" 0 3
+        seq -f "$dir/task-cmd%02.0f.log" 0 9
+    done
+}
+
+open_files() {
+    local i=0
+    local path=0
+    for path in "$@"; do
+        twinner -t "$path" -O "$Tmp/pid-$i" -P -c "tail -F \"$path\"" &
+        sleep 0.1   # allow WM to have predictable order of windows
+        ((i++))
+    done
+}
+
+onclose() {
+    warn ""
+    warn "got SIGINT; killing: Pids=(${Pids[*]})"
+    kill "${Pids[@]}"
+    rm -r "$Tmp"
+}
+
+main() {
+    test "$#" -eq 0 && usage "no DIRs?"
+    local Dirs=("$@")
+    local filelist=()
+    local Pids=()
+    local Tmp
+
+    Tmp=$(mktemp -d /tmp/watch_logs.XXXXXXXX)
+
+    list_files >"$Tmp/files"
+    mapfile -t filelist <"$Tmp/files"
+
+    open_files "${filelist[@]}"
+    sleep 2
+    cat "$Tmp/pid-"* > "$Tmp/pids"
+    mapfile -t Pids <"$Tmp/pids"
+
+    warn "spawned children: ${Pids[*]}"
+    warn "press ^C to close all open files"
+    wait # "${Pids[@]}"
+
+    rm -r "$Tmp"
+}
+
+trap onclose SIGINT
+
+main "$@"

your_program.sh

@@ -21,4 +21,4 @@ set -e # Exit early if any commands fail
 #
 # - Edit this to change how your program runs locally
 # - Edit .codecrafters/run.sh to change how your program runs remotely
-exec zig-out/bin/main "$@"
+exec zig-out/bin/main --verbose "$@"