cachet 0.3.0

A composable, customizable multi-tier caching library with rich feature support.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.

//! Two-tier cache with automatic fallback and promotion.
//! On L1 miss, L2 is checked and the result is promoted to L1.

use std::time::Duration;

use cachet::{Cache, CacheEntry};
use tick::Clock;

#[tokio::main]
async fn main() {
    let clock = Clock::new_tokio();

    // L2: fallback cache (longer TTL)
    let l2 = Cache::builder::<String, String>(clock.clone())
        .memory()
        .ttl(Duration::from_secs(300));

    // L1: primary cache (shorter TTL) with L2 fallback
    let cache = Cache::builder::<String, String>(clock)
        .memory()
        .ttl(Duration::from_secs(60))
        .fallback(l2)
        .build();

    let key = "user:1".to_string();

    // Insert goes to both L1 and L2
    cache
        .insert(key.clone(), CacheEntry::new("Alice".to_string()))
        .await
        .expect("insert failed");

    // Get from L1
    let value = cache.get(&key).await.expect("get failed");
    match value {
        Some(e) => println!("get({key}): {}", e.value()),
        None => println!("get({key}): not found"),
    }

    // Invalidate clears both L1 and L2 concurrently
    cache.invalidate(&key).await.expect("invalidate failed");

    // Confirm both tiers are empty
    let value = cache.get(&key).await.expect("get failed");
    assert!(value.is_none(), "entry should be gone from both tiers");
}