It it possible to serialize cache data?

[sondrelg]

Hi!

This might be a weird use-case, but is it possible to extract cache data, or create a cache from a hashmap and vice versa?

When my application starts, I would like to pull of some data from Redis, to cache in memory. On shutdown I want to dump the data back to Redis so it isn't lost.

This is simple enough with a HashMap as you can implement a struct like

#[derive(Debug, Serialize, Deserialize)]
struct Cache(HashMap<String, Vec<ResultItem>>);

And use, e.g., bincode to serialize it.

Is there a way for me to perform and equivalent operation to the one described here, but with the moka cache? 🙇

[tatsuya6502]

Hi. moka cache currently do not provide a convenient way to serialize the cache data. So you need to do it by yourself:

1. Iterate over the cache and collect the entries into a std::collections::HashMap.
2. Serialize the HashMap into binary using serde and bincode.

There is a limitation though. I will explain it later.

Example

use std::collections::HashMap;

use moka::sync::Cache;
use serde::{Deserialize, Serialize};

#[derive(Clone, Debug, Serialize, Deserialize)]
struct ResultItem {
    value: String,
}

fn main() {
    // Create a cache.
    let cache = Cache::builder().max_capacity(1024).build();

    // Insert a value for "key1".
    cache.insert(
        "key1".to_string(),
        ResultItem {
            value: "value1".to_string(),
        },
    );

    // Get the value for "key1".
    dbg!(cache.get("key1"));

    // Copy all entries to a HashMap.
    let all_entries: HashMap<_, _> = cache
        .iter()
        .map(|(k, v)| {
            // k: Arc<String>, v: ResultItem
            // Convert k to String by cloning it.
            (k.as_ref().clone(), v)
        })
        .collect();

    // Serialize the HashMap using serde + bincode.
    let serialized = bincode::serialize(&all_entries).unwrap();

    // Create another cache.
    let cache = Cache::builder().max_capacity(1024).build();

    // Deserialize the HashMap and insert all entries into the cache.
    let all_entries: HashMap<String, ResultItem> = bincode::deserialize(&serialized).unwrap();
    for (k, v) in all_entries {
        cache.insert(k, v);
    }

    // Get the value for "key1".
    dbg!(cache.get("key1"));
}

Limitation

• While iterating, you should not insert new entries to the cache. Otherwise, the iterator may miss these entries.
  • Details: https://docs.rs/moka/*/moka/sync/struct.Cache.html#method.iter

[sondrelg]

That's super useful, thanks @tatsuya6502!

I am planning to run the code during a pod's preStop lifecycle hook, so the limitation should be totally fine for my use-case 👍

If I'm interpreting this correctly it seems like this solution would double the memory footprint of the cached data, temporarily. Do you know if it's possible to "pop" keys and values from the cache rather than cloning them, or if there is some other way to maintain the same memory usage? No problem if not, I will adapt 😄

[tatsuya6502]

If I'm interpreting this correctly it seems like this solution would double the memory footprint of the cached data, temporarily.

That is correct.

Do you know if it's possible to "pop" keys and values from the cache rather than cloning them, or if there is some other way to maintain the same memory usage?

There is no way to pop keys and values from the cache. But it allows to remove (invalidate) keys and values while iterating. So you can replace the following lines:

    // Copy all entries to a HashMap.
    let all_entries: HashMap<_, _> = cache
        .iter()
        .map(|(k, v)| {
            (k.as_ref().clone(), v)
        })
        .collect();

with this:

    // Copy all entries to a HashMap.
    let mut all_entries = HashMap::new();
    for (k, v) in &cache {
        all_entries.insert(k.as_ref().clone(), v);
        // Remove the entry from the cache.
        cache.invalidate(k.as_ref());
    }

to remove keys and values while iterating.

[sondrelg]

Amazing! Thanks a lot 🙇

This is my final implementation in case anyone else finds it useful (thought it's exactly the same hehe):

let mut cache_copy: HashMap<String, Vec<Self::ResultItem>> = HashMap::new();
let guard = cache.lock().await;  // our cache is an Arc<Mutex<Cache<_>>>
for (k, v) in guard.iter() {
    cache_copy.insert(k.as_ref().to_owned(), v);
    guard.invalidate(k.as_ref())
}