multi-tier-cache 0.6.5

Customizable multi-tier cache with L1 (Moka in-memory) + L2 (Redis distributed) defaults, expandable to L3/L4+, cross-instance invalidation via Pub/Sub, stampede protection, and flexible TTL scaling
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
113
114
115
116
117
118
119
120
121
122
123

use crate::error::CacheResult;
use bytes::Bytes;
use serde::Serialize;
use serde::de::DeserializeOwned;
use std::fmt::Debug;

/// High-performance cache data serialization enum
#[derive(Debug, Clone)]
pub enum CacheSerializer {
    /// Default JSON serializer
    Json(JsonSerializer),
    /// Binary serializer using bincode
    #[cfg(feature = "bincode")]
    Bincode(BincodeSerializer),
    /// Binary serializer using `MessagePack`
    #[cfg(feature = "msgpack")]
    MsgPack(MsgPackSerializer),
}

impl Default for CacheSerializer {
    fn default() -> Self {
        Self::Json(JsonSerializer)
    }
}

impl CacheSerializer {
    /// Serialize a value to Bytes
    ///
    /// # Errors
    ///
    /// Returns a `SerializationError` if the value cannot be serialized.
    pub fn serialize<T: Serialize>(&self, value: &T) -> CacheResult<Bytes> {
        match self {
            Self::Json(_) => JsonSerializer::serialize_internal(value),
            #[cfg(feature = "bincode")]
            Self::Bincode(_) => BincodeSerializer::serialize_internal(value),
            #[cfg(feature = "msgpack")]
            Self::MsgPack(_) => MsgPackSerializer::serialize_internal(value),
        }
    }

    /// Deserialize Bytes to a value
    ///
    /// # Errors
    ///
    /// Returns a `SerializationError` if the bytes cannot be deserialized.
    pub fn deserialize<T: DeserializeOwned>(&self, bytes: &[u8]) -> CacheResult<T> {
        match self {
            Self::Json(_) => JsonSerializer::deserialize_internal(bytes),
            #[cfg(feature = "bincode")]
            Self::Bincode(_) => BincodeSerializer::deserialize_internal(bytes),
            #[cfg(feature = "msgpack")]
            Self::MsgPack(_) => MsgPackSerializer::deserialize_internal(bytes),
        }
    }

    /// Serializer identifier
    #[must_use]
    pub fn name(&self) -> &'static str {
        match self {
            Self::Json(_) => "Json",
            #[cfg(feature = "bincode")]
            Self::Bincode(_) => "Bincode",
            #[cfg(feature = "msgpack")]
            Self::MsgPack(_) => "MsgPack",
        }
    }
}

/// Default JSON serializer using `serde_json`
#[derive(Debug, Default, Clone)]
pub struct JsonSerializer;

impl JsonSerializer {
    fn serialize_internal<T: Serialize>(value: &T) -> CacheResult<Bytes> {
        serde_json::to_vec(value)
            .map(Bytes::from)
            .map_err(|e| crate::error::CacheError::SerializationError(e.to_string()))
    }

    fn deserialize_internal<T: DeserializeOwned>(bytes: &[u8]) -> CacheResult<T> {
        serde_json::from_slice(bytes)
            .map_err(|e| crate::error::CacheError::SerializationError(e.to_string()))
    }
}

/// Binary serializer using bincode
#[cfg(feature = "bincode")]
#[derive(Debug, Default, Clone)]
pub struct BincodeSerializer;

#[cfg(feature = "bincode")]
impl BincodeSerializer {
    fn serialize_internal<T: Serialize>(value: &T) -> CacheResult<Bytes> {
        bincode::serialize(value)
            .map(Bytes::from)
            .map_err(|e| crate::error::CacheError::SerializationError(e.to_string()))
    }

    fn deserialize_internal<T: DeserializeOwned>(bytes: &[u8]) -> CacheResult<T> {
        bincode::deserialize(bytes)
            .map_err(|e| crate::error::CacheError::SerializationError(e.to_string()))
    }
}

/// Binary serializer using `MessagePack`
#[cfg(feature = "msgpack")]
#[derive(Debug, Default, Clone)]
pub struct MsgPackSerializer;

#[cfg(feature = "msgpack")]
impl MsgPackSerializer {
    fn serialize_internal<T: Serialize>(value: &T) -> CacheResult<Bytes> {
        rmp_serde::to_vec(value)
            .map(Bytes::from)
            .map_err(|e| crate::error::CacheError::SerializationError(e.to_string()))
    }

    fn deserialize_internal<T: DeserializeOwned>(bytes: &[u8]) -> CacheResult<T> {
        rmp_serde::from_slice(bytes)
            .map_err(|e| crate::error::CacheError::SerializationError(e.to_string()))
    }
}