bader-db 0.1.5

Key-value cache RESP server with support for key expirations
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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

use std::time::{Duration, Instant};

#[derive(Eq, PartialEq, Clone, Debug)]
pub struct Expiry {
    instant: Option<Instant>,
}

impl Expiry {
    pub fn new<I>(instant: I) -> Self
        where
            I: Into<Instant>,
    {
        Self {
            instant: Some(instant.into()),
        }
    }

    /// Create an empty expiration (i.e. no expiration).
    pub fn none() -> Self {
        Self { instant: None }
    }

    /// Retrieve the instant associated with this expiration.
    pub fn instant(&self) -> &Option<Instant> {
        &self.instant
    }

    /// Retrieve whether a cache entry has passed expiration.
    pub fn is_expired(&self) -> bool {
        self.instant()
            .map(|expiration| expiration < Instant::now())
            .unwrap_or(false)
    }

    /// Retrieve the time remaining before expiration.
    pub fn remaining(&self) -> Option<Duration> {
        self.instant
            .map(|i| i.saturating_duration_since(Instant::now()))
    }
}

// Automatic conversation from `Instant`.
impl From<Instant> for Expiry {
    fn from(instant: Instant) -> Self {
        Self::new(instant)
    }
}

// Automatic conversation from `u64`.
impl From<u64> for Expiry {
    fn from(millis: u64) -> Self {
        Duration::from_millis(millis).into()
    }
}

// Automatic conversation from `u64`.
impl From<(u64, &String)> for Expiry {
    fn from(expiry: (u64, &String)) -> Self {
        let amount = expiry.0;
        let format = expiry.1;
        let expiry_type = format.to_ascii_lowercase().as_str().into();
        match expiry_type {
            ExpiryFormat::PX => {
                Duration::from_millis(amount).into()
            } ,
            ExpiryFormat::EX => {
                Duration::from_secs(amount).into()
            },
            _ => Self{ instant: None},
        }
    }
}

// Automatic conversation from `Duration`.
impl From<Duration> for Expiry {
    fn from(duration: Duration) -> Self {
        Instant::now().checked_add(duration).unwrap().into()
    }
}

#[derive(Debug, PartialEq)]
pub enum ExpiryFormat {
    EX,
    PX,
    Uninitialized,
}

impl From<&str> for ExpiryFormat {
    fn from(s: &str) -> Self {
        match s {
            "ex" => ExpiryFormat::EX,
            "px" => ExpiryFormat::PX,
            _ => ExpiryFormat::Uninitialized,
        }
    }
}


#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_new() {
        let instant = Instant::now();
        let expiry = Expiry::new(instant);
        assert_eq!(expiry.instant(), &Some(instant));
    }

    #[test]
    fn test_none() {
        let expiry = Expiry::none();
        assert_eq!(expiry.instant(), &None);
    }

    #[test]
    fn test_is_expired() {
        let instant = Instant::now() + Duration::from_secs(1);
        let expiry = Expiry::new(instant);
        assert!(!expiry.is_expired());

        let past_instant = Instant::now() - Duration::from_secs(1);
        let expired_expiry = Expiry::new(past_instant);
        assert!(expired_expiry.is_expired());

        let none_expiry = Expiry::none();
        assert!(!none_expiry.is_expired());
    }

    #[test]
    fn test_remaining() {
        let instant = Instant::now() + Duration::from_secs(1);
        let expiry = Expiry::new(instant);
        assert!(expiry.remaining().is_some());

        let past_instant = Instant::now() - Duration::from_secs(3);
        let expired_expiry = Expiry::new(past_instant);
        assert_eq!(expired_expiry.remaining(), Some(Duration::from_nanos(0)));

        let none_expiry = Expiry::none();
        assert!(none_expiry.remaining().is_none());
    }

    #[test]
    fn test_conversions() {
        let instant = Instant::now();
        let expiry_from_instant: Expiry = instant.into();
        assert_eq!(expiry_from_instant.instant(), &Some(instant));

        let millis = 1000;
        let expiry_from_millis: Expiry = millis.into();
        assert!(expiry_from_millis.instant().is_some());

        let duration = Duration::from_secs(1);
        let expiry_from_duration: Expiry = duration.into();
        assert!(expiry_from_duration.instant().is_some());
    }
}