groupcache 0.3.0

groupcache is a distributed caching and cache-filling library, intended as a replacement for a pool of memcached nodes in many cases. It shards by key to select which peer is responsible for that key.
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
50
51
52
53
54
55
56
57

use async_trait::async_trait;
use groupcache::{Groupcache, GroupcachePeer, ServiceDiscovery, ValueLoader};
use moka::future::CacheBuilder;
use std::collections::HashSet;
use std::error::Error;
use std::net::SocketAddr;
use std::time::Duration;
use tonic::transport::Endpoint;

mod common;

struct DummyLoader {}

#[async_trait]
impl ValueLoader for DummyLoader {
    type Value = u32;
    async fn load(
        &self,
        _key: &str,
    ) -> Result<Self::Value, Box<dyn Error + Send + Sync + 'static>> {
        Ok(42)
    }
}

struct ServiceDiscoveryStub {
    me: GroupcachePeer,
}

#[async_trait]
impl ServiceDiscovery for ServiceDiscoveryStub {
    async fn pull_instances(
        &self,
    ) -> Result<HashSet<GroupcachePeer>, Box<dyn Error + Send + Sync + 'static>> {
        Ok(HashSet::from([self.me]))
    }
}

#[tokio::test]
async fn builder_api_test() {
    let main_cache = CacheBuilder::default().max_capacity(100).build();
    let hot_cache = CacheBuilder::default()
        .max_capacity(10)
        .time_to_live(Duration::from_secs(10))
        .build();
    let loader = DummyLoader {};
    let me: SocketAddr = "127.0.0.1:8080".parse().unwrap();

    let _groupcache = Groupcache::builder(me.into(), loader)
        .main_cache(main_cache)
        .hot_cache(hot_cache)
        .grpc_endpoint_builder(Box::new(|endpoint: Endpoint| {
            endpoint.timeout(Duration::from_secs(2))
        }))
        .https()
        .service_discovery(ServiceDiscoveryStub { me: me.into() })
        .build();
}