cache-loader-async
The goal of this crate is to provide a thread-safe and easy way to access any data structure which might is stored in a database at most once and keep it in cache for further requests.
This library is based on tokio-rs and futures.
Usage
Using this library is as easy as that:
#[tokio::main]
async fn main() {
let static_db: HashMap<String, u32> =
vec![("foo".into(), 32), ("bar".into(), 64)]
.into_iter()
.collect();
let (cache, _) = LoadingCache::new(move |key: String| {
let db_clone = static_db.clone();
async move {
db_clone.get(&key).cloned().ok_or("error-message")
}
});
let result = cache.get("foo".to_owned()).await.unwrap().0;
assert_eq!(result, 32);
}
The LoadingCache will first try to look up the result in an internal HashMap and if it's not found and there's no load ongoing, it will fire the load request and queue any other get requests until the load request finishes.
Features & Cache Backings
The cache-loader-async library currently supports two additional inbuilt backings: LRU & TTL LRU evicts keys based on the cache maximum size, while TTL evicts keys automatically after their TTL expires.
LRU Backing
You can use a simple pre-built LRU cache from the lru-rs crate by enabling the lru-cache feature.
To create a LoadingCache with lru cache backing use the with_backing method on the LoadingCache.
async fn main() {
let size: usize = 10;
let (cache, _) = LoadingCache::with_backing(LruCacheBacking::new(size), move |key: String| {
async move {
Ok(key.to_lowercase())
}
});
}
TTL Backing
You can use a simple pre-build TTL cache by enabling the ttl-cache feature. This will not require any additional dependencies.
To create a LoadingCache with ttl cache backing use the with_backing method on the LoadingCache.
async fn main() {
let duration: Duration = Duration::from_secs(30);
let (cache, _) = LoadingCache::with_backing(TtlCacheBacking::new(duration), move |key: String| {
async move {
Ok(key.to_lowercase())
}
});
}
Own Backing
To implement an own cache backing, simply implement the public CacheBacking trait from the backing mod.
pub trait CacheBacking
where K: Eq + Hash + Sized + Clone + Send,
V: Sized + Clone + Send {
fn get(&mut self, key: &K) -> Option<&V>;
fn set(&mut self, key: K, value: V) -> Option;
fn remove(&mut self, key: &K) -> Option;
fn contains_key(&self, key: &K) -> bool;
}
3 Mar 23, 2024
23 Jul 9, 2024
61 Jan 8, 2023
37 Dec 21, 2022
8 Nov 10, 2022
5 May 15, 2022
40 Jan 16, 2023
8 Feb 1, 2023
8 Jul 5, 2022
8 Sep 13, 2022
4 Sep 24, 2022
108 Jan 1, 2023
113 Dec 28, 2022
7 Jan 10, 2023
54 Sep 29, 2023
4 Feb 27, 2024
135 Jul 25, 2024
6 Nov 4, 2021
6 Mar 31, 2023
![[question] TtlCacheBacking - SystemTime or Instant?](https://avatars.githubusercontent.com/u/7777017?v=4)
1 Apr 20, 2022
137 Dec 19, 2022
74 Jan 2, 2023
8 Sep 16, 2024
6 Oct 23, 2022
29 Dec 27, 2022
34 Apr 17, 2023
10 Dec 10, 2021
15 Dec 21, 2022
5 Nov 7, 2022