Struct Config 

pub struct Config {

    pub resp_listener: Option<SocketAddr>,
    pub maxmemory: u64,
    pub eviction_policy: EvictionPolicy,
    pub data_dir: Option<PathBuf>,
    pub aof: bool,
    pub appendfsync: AppendFsync,
    pub tier_budget: Option<TierBudgetSpec>,
    pub max_spill_value: u64,
    pub ttl_reaper: TtlReaperMode,
    pub reaper_interval: Duration,
    pub reaper_samples: usize,
    pub reaper_max_rounds: u32,
    pub auto_aof_rewrite_pct: u32,
    pub auto_aof_rewrite_min_size: u64,
    pub auto_aof_rewrite_bytes: u64,
    pub auto_aof_rewrite_interval_secs: u64,
    pub replay_resync: bool,
    pub shards: usize,
    pub replica_upstream: Option<String>,
    pub replica_id: String,
    pub replica_reconnect_min: Duration,
    pub replica_reconnect_max: Duration,
    pub embed_writer_listen_addr: Option<String>,
    pub feed_enabled: bool,
    pub feed_buffer_size: u64,
    pub embed_writer_backlog_bytes: usize,
    /* private fields */
}

Embedded-store config. Build by chaining with_* methods on Config::default.

Fields

resp_listener: Option<SocketAddr>

Optional READ-ONLY RESP listener address (ops tooling — redis-cli against a live embedded store). None (default) = no listener thread, no socket, zero tax.

maxmemory: u64

Soft memory ceiling in bytes. 0 (default) = unlimited.

eviction_policy: EvictionPolicy

Eviction policy when over maxmemory. Default NoEviction.

data_dir: Option<PathBuf>

Persistence directory. None = pure in-memory (no AOF, no snapshot).

aof: bool

AOF on/off when data_dir is set. Defaults to true (on) when with_persist was called; ignored if data_dir is None.

appendfsync: AppendFsync

AOF fsync policy. Default EverySec (matches Redis: ≤ 1 s loss).

tier_budget: Option<TierBudgetSpec>

Transparent-tiering RAM budget (capacity arc). None (default) = tiering off — today’s paths byte-identical. Some requires a disk data_dir (the cold value log lives at <data_dir>/tier/); a mem-only store rejects the combo at open. The budget is the WHOLE store’s (split evenly across shards); auto/percent forms resolve against the detected memory bound at open and re-resolve on every reaper tick.

max_spill_value: u64

Largest value the tier may spill (bytes; 0 = unlimited). Default 256 KiB (RFC §7): an embedded cold read holds the shard lock for the pread, so the cap bounds that hold time. Over-cap values simply stay hot.

ttl_reaper: TtlReaperMode

TTL reaper mode. Default Background.

reaper_interval: Duration

Reaper tick interval. Default 100 ms (10 Hz).

reaper_samples: usize

tick_expire samples per round. Default 20 (matches Redis).

reaper_max_rounds: u32

Max sample rounds per tick. Default 16.

auto_aof_rewrite_pct: u32

Auto-BGREWRITEAOF trigger: rewrite when the live AOF has grown by at least this percent over its size at the previous rewrite. 0 disables (call crate::Store::rewrite_aof manually). Default 100 (Redis).

auto_aof_rewrite_min_size: u64

Floor below which auto-rewrite is skipped. Default 64 MiB (Redis).

auto_aof_rewrite_bytes: u64

Absolute-size auto-rewrite trigger in bytes (0 = off). The growth rule alone lets a large log double before compacting — a 2.2 GB AOF waits for 4.4 GB; this caps it outright.

auto_aof_rewrite_interval_secs: u64

Time-based auto-rewrite trigger in seconds (0 = off): compact at least this often while the log grows.

replay_resync: bool

Best-effort replay: on a corrupt v2 record, hop to the next valid record (length + CRC + parse all agree) instead of dropping the good tail behind it. Default false (strict).

shards: usize

Keyspace shard count (hash(key) % shards), each a fully independent lock + keyspace + AOF (shared-nothing) — concurrent access scales across cores. Default 1 (single shard = the original single-lock / single-aof-0.aof layout, zero migration). Set > 1 via Self::with_shards; the first open with > 1 re-shards an existing single AOF into per-shard files.

replica_upstream: Option<String>

Replication upstream. Some("host:port") makes this store a read-replica that streams writes from the named primary; None (default) is a normal primary store. Configured via Self::with_replica_upstream or the convenience constructor crate::Store::open_replica.

replica_id: String

Replica identity string sent to the primary at handshake (REPLICATE FROM <offset> ID <replica_id>). Default "kevy-embedded-replica". Override per-process when multiple embed replicas connect to the same primary (they’d otherwise share the slot and clobber each other’s session state on the primary side).

replica_reconnect_min: Duration

Replica reconnect backoff: lower bound. Default 100 ms. The runner sleeps this long after the first connection failure; each subsequent failure doubles the wait up to Self::replica_reconnect_max.

replica_reconnect_max: Duration

Replica reconnect backoff: upper bound. Default 5 s — matches the server-side replica reconnect default so embed replicas and server replicas behave identically when the same primary disappears.

embed_writer_listen_addr: Option<String>

Embed-as-writer bind address ("host:port" or "0.0.0.0:port") for the replication source listener. When Some, every commit on this store pushes its argv into a process-local ReplicationSource backlog, and replicas (other embeds, server-as-replicas) connect to this port to stream the writes. None (default) keeps the embed in pure-local mode. Mutually exclusive in spirit with replica_upstream (a single store should be either a writer source or a reader sink, not both); the builder does not reject the combo so tests can exercise the guard rails.

feed_enabled: bool

CDC feed (changes_since / changes_tail). Default off.

feed_buffer_size: u64

Feed backlog byte budget. Default 64 MB, capped at 1 GB.

embed_writer_backlog_bytes: usize

Backlog byte budget for the embed-as-writer source. Default 1 MiB (matches the server replication default). Set higher when consumers may disconnect for longer than the backlog can buffer (otherwise a reconnect falls past the backlog and is re-seeded with a full snapshot ship instead of an incremental stream).

Implementations

impl Config

pub fn with_tier_budget(self, bytes: u64) -> Self

Enable transparent tiering with a RAM budget of bytes: values past the demote watermark spill to the cold tier on disk (<data_dir>/tier/) and page back in on access — every command keeps its exact semantics. Requires Self::with_persist; a memory-only store fails at open with a named error.

pub fn with_tier_budget_auto(self) -> Self

Enable transparent tiering with the auto budget: 0.70 × the detected memory bound (cgroup v2 limit / MemAvailable on Linux, hw.memsize on macOS), re-probed on every reaper tick. Open fails with a named error when no bound is detectable.

pub fn with_max_spill_value(self, bytes: u64) -> Self

Cap the largest spillable value (bytes; 0 = unlimited). Bounds the embedded cold-read lock-hold time; default 256 KiB.

pub fn with_tier_budget_percent(self, p: u8) -> Self

Enable transparent tiering with a percent-of-detected-bound budget (p in 1..=100 — validated at open with a named error, like every other config refusal).

impl Config

pub fn with_resp_listener(self, addr: SocketAddr) -> Self

Enable the read-only RESP listener on addr (e.g. "127.0.0.1:6009".parse().unwrap()).

pub fn with_persist(self, dir: impl Into<PathBuf>) -> Self

Enable persistence under dir — snapshot file + AOF land inside. AOF defaults on; turn it off with Self::without_aof for pure snapshot-only durability.

pub fn without_aof(self) -> Self

Disable the AOF (snapshot-only persistence — explicit save_snapshot calls are the only way data survives restart).

pub fn with_max_memory(self, bytes: u64) -> Self

Soft memory ceiling in bytes. 0 keeps the default (unlimited).

pub fn with_eviction(self, policy: EvictionPolicy) -> Self

Eviction policy when over Self::with_max_memory.

pub fn with_appendfsync(self, fsync: AppendFsync) -> Self

AOF fsync policy. Default AppendFsync::EverySec.

pub fn with_auto_rewrite_bytes(self, bytes: u64) -> Self

Absolute-size auto-rewrite trigger: compact whenever the AOF reaches bytes, regardless of growth ratio (0 = off). Complements Self::with_auto_aof_rewrite, whose growth rule is too sluggish for long-lived instances with a large baseline.

pub fn with_auto_rewrite_interval(self, interval: Duration) -> Self

Time-based auto-rewrite trigger: compact at least every interval while the log grows (zero duration = off).

pub fn with_replay_resync(self, resync: bool) -> Self

Best-effort replay: recover the good records BEHIND a corrupt v2 record instead of dropping them (a production incident lost a 231 MB well-formed tail over one bad frame). The skip is deterministic — length + CRC32C + an exactly-one-command parse must all agree before a record is trusted — and the open still reports corrupt so hosts still alert. Strict (default false) remains the conservative choice: nothing after the first bad byte is trusted.

pub fn with_auto_aof_rewrite(self, pct: u32, min_size: u64) -> Self

Auto-BGREWRITEAOF thresholds: rewrite once the AOF has grown pct percent past its size at the last rewrite AND is at least min_size bytes. In Background reaper mode the check runs on the reaper tick; in Manual mode it runs when you call crate::Store::tick. Pass pct = 0 to disable auto-rewrite (you can still call crate::Store::rewrite_aof yourself). Defaults: 100 % / 64 MiB.

pub fn with_auto_aof_rewrite_disabled(self) -> Self

Disable every automatic rewrite trigger — growth, absolute size and interval — in one named call This is the canary-window switch: the first rewrite is the documented one-way step that upgrades a 3.x-era AOF to v2 (crate::Store::downgradeable_to_v3 reads the window), so an embedder keeping a binary-swap escape hatch open turns the automatics off rather than remembering which of three knobs zeroes which rule. Explicit crate::Store::rewrite_aof calls still work — and still close the window.

pub fn with_shards(self, n: usize) -> Self

Shard the keyspace into n shared-nothing partitions (hash(key) % n), each with its own lock + keyspace + AOF, so concurrent access scales across cores. n clamps to ≥ 1; 1 (default) is the original single-shard layout. Going from a single-AOF store to n > 1 re-shards the existing aof-0.aof into aof-0..aof-{n-1} on the next open (the old file is backed up to aof-0.aof.premigration.<ts> first). Pub/sub is process-wide (handled on shard 0), not sharded.

pub fn with_metric_sink( self, sink: impl Fn(KevyMetric) + Send + Sync + 'static, ) -> Self

Register a push-style metric callback. It receives a crate::KevyMetric for each AOF replay (startup) and AOF rewrite (compaction) — wire it to Prometheus / a log line / a counter. The callback runs synchronously on the emitting thread (reaper thread for background rewrites), so keep it fast and non-blocking. Replaces any previously-set sink.

pub fn with_ttl_reaper_manual(self) -> Self

Caller-driven TTL reaping — disables the background thread. Required for WASM (no threads available). Call crate::Store::tick yourself from your event loop.

pub fn with_replica_upstream(self, upstream: impl Into<String>) -> Self

Configure this store as a replication replica of upstream ("host:port" of a kevy server’s replication listener). A background thread streams writes from the primary and applies them locally; this store rejects local writes with a READONLY error. See crate::Store::open_replica for the convenience constructor.

pub fn with_replica_id(self, id: impl Into<String>) -> Self

Override the replica identity sent to the primary at handshake. Useful when multiple embed replicas share one primary — otherwise they’d share the slot and stomp each other’s session state.

pub fn with_replica_reconnect(self, min: Duration, max: Duration) -> Self

Override the replica reconnect backoff bounds.

pub fn with_embed_writer(self, bind_addr: impl Into<String>) -> Self

Run this store as an embed-as-writer: bind a replication source listener on bind_addr so replicas can subscribe to the writes applied here.

pub fn with_feed(self, buffer_size: u64) -> Self

Enable the CDC feed (changes_since / changes_tail). buffer_size = 0 keeps the 64 MB default; values cap at 1 GB.

pub fn with_embed_writer_backlog(self, bytes: usize) -> Self

Override the embed-as-writer backlog byte budget.

pub fn with_reaper_interval(self, iv: Duration) -> Self

Override the background reaper interval. Default 100 ms.

Trait Implementations

impl Clone for Config

fn clone(&self) -> Config

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Config

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Config

fn default() -> Self

Returns the “default value” for a type.