Feature request: When caching a Result or Option: soft and hard timeouts, to have the ability to return the expired cache value if the operation fails

[axos88]

In some cases it may be worthwile to fall back to the cached, but expired value if the function is not successful in computing the current value of the thing to be cached.

For example a function retrieves some rarely changing value over the network, and caches it for say 1 day. In case the thing is requested after 24 hours and 1 minute, the cache is expired, so we attempt to retrieve it again. In case the retrieval fails (because network is down, server is down, etc.), one may assume that the old cached value is probably still valid, and I'd like to have it return it. This would basically make the function infallible though I'm not sure we can express that using the type system as the function itself needs to be able to return a failure to communicate to the cache that it needs to return the cached value even though it is expired.

One step further and adding more flexibility would be to add a "soft" and a "hard" timeout for the cached values. After the soft timeout the operation to calculate the value is attempted again, but if it fails the cached value is returned. After the hard timeout the cached value is not returned at all.

[jaemk]

Hi @axos88 , the ability to prime a #[cached] function was just recently added. You should be able to implement the logic you're describing by priming your cached-fn after 24hrs have passed, and you could keep calling the *_prime_cache method until you don't get back an error.

See this test for how the #[cached] macro will generate a *_prime_cache function for you alongside the annotated function:

cached/tests/cached.rs

Line 1064 in e24d7a7

fn test_cached_timed_sized_refresh_prime() {

And here's an example from the readme of refreshing in the background:

cached/src/lib.rs

Lines 283 to 294 in 8295ad2

	#[cached(time = 60, key = "String", convert = r#"{ String::from(a) }"#)]
	fn keyed(a: &str) -> usize {
	a.len()
	}
	pub fn main() {
	std::thread::spawn(|| {
	loop {
	sleep(Duration::from_secs(60));
	keyed_prime_cache("a");
	}
	});
	}

[Raz-Hemo]

I've implemented a small sample to help people who also stumble on this problem. Would love this to be a simple flag inside the #[cached] macro though.

fn stuff_wrapper() -> Result<i64, ()> {
    let old_val = STUFF.lock().unwrap().get_store().get(&()).cloned();
    println!("here's the old value: {:?}", old_val);
    match stuff() {
        Ok(val) => Ok(val),
        Err(_) => {
            println!("Failed, reusing old val");
            match old_val {
                Some(val) => {
                    STUFF.lock().unwrap().cache_set((), val.1);
                    Ok(val.1)
                },
                None => Err(()),
            }
        }
    }
}

#[cached::proc_macro::cached(result=true, time=2)]
fn stuff() -> Result<i64, ()> {
    println!("Refreshing cache");
    if rand::random::<bool>() {
        Ok(1)
    } else {
        Err(())
    }
}

fn main() {
    loop {
        std::thread::sleep(std::time::Duration::from_secs(1));
        println!("Result with fallback: {:?}", stuff_wrapper());
    }
}

[Raz-Hemo]

Actually went and made a quick reference implementation for use at work, i would love to hear feedback and maybe merge this upstream if possible :)
#177