sinan 0.1.0

A Boilerplate for Rapid Axum Web Service Deployment.
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
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112

use std::future::Future;

use bb8::{Pool, PooledConnection};
use bb8_redis::RedisConnectionManager;
use eyre::{OptionExt, Result};
use redis::{AsyncCommands, FromRedisValue, ToRedisArgs};
use serde::Serialize;
use serde_json::Value;

use crate::services::{Redis, service};

async fn store() -> Result<PooledConnection<'static,RedisConnectionManager>> {
    let client = service().get::<Redis>().unwrap();

    client.connection().await
}

pub async fn has<K>(key: K) -> eyre::Result<bool>
where
    K: ToRedisArgs + Send + Sync,
{
    let mut con = store().await?;

    let exist: bool = con.exists(key).await?;

    Ok(exist)
}

pub async fn get<K, T>(key: K) -> eyre::Result<T>
where
    K: ToRedisArgs + Send + Sync,
    T: FromRedisValue,
{
    let mut con = store().await?;

    let result: T = con.get(key).await?;

    tracing::debug!("cache hit"); // todo 记录 key

    Ok(result)
}

pub async fn set<K, V>(key: K, value: V, seconds: u64) -> eyre::Result<()>
where
    K: ToRedisArgs + Send + Sync,
    V: ToRedisArgs + Send + Sync,
{
    let mut con = store().await?;

    con.set_ex(key, value, seconds).await?;

    Ok(())
}

pub async fn get_json<K>(key: K) -> eyre::Result<Value>
where
    K: ToRedisArgs + Send + Sync,
{
    let value: String = get(key).await?;

    let result = serde_json::from_str(&value)?;

    Ok(result)
}

pub async fn set_json<K, V>(key: K, value: &V, seconds: u64) -> eyre::Result<()>
where
    K: ToRedisArgs + Send + Sync,
    V: Serialize,
{
    set(key, serde_json::to_string(value)?, seconds).await?;

    Ok(())
}

pub async fn remember<K, F, Fut>(key: K, seconds: u64, func: F) -> eyre::Result<Value>
where
    K: ToRedisArgs + Send + Sync,
    F: FnOnce() -> Fut,
    Fut: Future<Output = Result<Value>>,
{
    if has(&key).await? {
        return get_json(&key).await;
    }

    let value = func().await?;

    set_json(&key, &value, seconds).await?;

    Ok(value)
}

pub async fn remember_multi<K, F, Fut>(key: K, seconds: u64, func: F) -> eyre::Result<Vec<Value>>
where
    K: ToRedisArgs + Send + Sync,
    F: FnOnce() -> Fut,
    Fut: Future<Output = Result<Vec<Value>>>,
{
    if has(&key).await? {
        let result = get_json(&key).await?;

        let values = result.as_array().ok_or_eyre("not an array")?;

        return Ok(values.to_owned());
    }

    let values = func().await?;

    set_json(&key, &values, seconds).await?;

    Ok(values)
}