Struct Config 

pub struct Config {
    pub maxmemory: u64,
    pub eviction_policy: EvictionPolicy,
    pub data_dir: Option<PathBuf>,
    pub aof: bool,
    pub appendfsync: AppendFsync,
    pub snapshot_filename: String,
    pub aof_filename: String,
    pub ttl_reaper: TtlReaperMode,
    pub reaper_interval: Duration,
    pub reaper_samples: usize,
    pub reaper_max_rounds: u32,
}

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

Fields

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).

snapshot_filename: String

Snapshot file name inside data_dir. Default "dump-0.rdb".

aof_filename: String

AOF file name inside data_dir. Default "aof-0.aof".

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.

Implementations

impl Config

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.

Examples found in repository

examples/replay_real_aof.rs (line 35)

fn main() {
    let path = std::env::args()
        .nth(1)
        .expect("usage: replay_real_aof <aof-path>");
    let src = PathBuf::from(&path);
    let bytes = std::fs::metadata(&src)
        .map(|m| m.len())
        .unwrap_or(0);
    println!("reproducer: staging {} bytes from {}", bytes, src.display());

    let dir = std::env::temp_dir().join(format!(
        "kevy-aof-reproducer-{}",
        std::process::id()
    ));
    std::fs::create_dir_all(&dir).expect("create temp dir");
    let staged = dir.join("aof-0.aof");
    std::fs::copy(&src, &staged).expect("copy AOF into staging dir");

    println!("reproducer: opening Store from {}", dir.display());
    let store = Store::open(
        Config::default()
            .with_persist(&dir)
            .with_aof_filename("aof-0.aof"),
    )
    .expect("Store::open");

    println!("reproducer: opened OK; dbsize = {}", store.dbsize());
}

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).

Examples found in repository

examples/embedded-cache.rs (line 12)

fn main() -> std::io::Result<()> {
    let s = Store::open(
        Config::default()
            .with_max_memory(200 * 1024)
            .with_eviction(EvictionPolicy::AllKeysLru),
    )?;

    for i in 0..10_000 {
        let key = format!("user:{i:05}");
        let val = format!("user-payload-{i}");
        s.set(key.as_bytes(), val.as_bytes())?;
    }

    println!("dbsize after insert flood: {}", s.dbsize());
    println!("used_memory: {} bytes (limit 200 KiB)", s.used_memory());
    println!("evictions_total: {}", s.evictions_total());

    // Touch a recent key — it should still be live.
    let recent = format!("user:0{}", 9999);
    println!(
        "user:09999 → {:?}",
        s.get(recent.as_bytes())?.as_deref().map(String::from_utf8_lossy)
    );

    Ok(())
}

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

Eviction policy when over Self::with_max_memory.

Examples found in repository

examples/embedded-cache.rs (line 13)

fn main() -> std::io::Result<()> {
    let s = Store::open(
        Config::default()
            .with_max_memory(200 * 1024)
            .with_eviction(EvictionPolicy::AllKeysLru),
    )?;

    for i in 0..10_000 {
        let key = format!("user:{i:05}");
        let val = format!("user-payload-{i}");
        s.set(key.as_bytes(), val.as_bytes())?;
    }

    println!("dbsize after insert flood: {}", s.dbsize());
    println!("used_memory: {} bytes (limit 200 KiB)", s.used_memory());
    println!("evictions_total: {}", s.evictions_total());

    // Touch a recent key — it should still be live.
    let recent = format!("user:0{}", 9999);
    println!(
        "user:09999 → {:?}",
        s.get(recent.as_bytes())?.as_deref().map(String::from_utf8_lossy)
    );

    Ok(())
}

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

AOF fsync policy. Default AppendFsync::EverySec.

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_reaper_interval(self, iv: Duration) -> Self

Override the background reaper interval. Default 100 ms.

pub fn with_snapshot_filename(self, name: impl Into<String>) -> Self

Override the snapshot file name inside data_dir.

pub fn with_aof_filename(self, name: impl Into<String>) -> Self

Override the AOF file name inside data_dir.

Examples found in repository

examples/replay_real_aof.rs (line 36)

fn main() {
    let path = std::env::args()
        .nth(1)
        .expect("usage: replay_real_aof <aof-path>");
    let src = PathBuf::from(&path);
    let bytes = std::fs::metadata(&src)
        .map(|m| m.len())
        .unwrap_or(0);
    println!("reproducer: staging {} bytes from {}", bytes, src.display());

    let dir = std::env::temp_dir().join(format!(
        "kevy-aof-reproducer-{}",
        std::process::id()
    ));
    std::fs::create_dir_all(&dir).expect("create temp dir");
    let staged = dir.join("aof-0.aof");
    std::fs::copy(&src, &staged).expect("copy AOF into staging dir");

    println!("reproducer: opening Store from {}", dir.display());
    let store = Store::open(
        Config::default()
            .with_persist(&dir)
            .with_aof_filename("aof-0.aof"),
    )
    .expect("Store::open");

    println!("reproducer: opened OK; dbsize = {}", store.dbsize());
}

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.