ocypod 0.8.0

Ocypod is a Redis-backed service for orchestrating background jobs.
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

//! Defines custom `Duration` type.

use std::{fmt, time};

use redis::{self, FromRedisValue, RedisResult, RedisWrite, ToRedisArgs};
use serde::de::{Deserialize, Deserializer, Error};
use serde::ser::{Serialize, Serializer};

/// Duration to second resolution, thin wrapper around `time::Duration` allowing for custom
/// (de)serialisation.
///
/// Serialised to/from JSON as a human readable time (e.g. "1m", "1day", "1h 22m 58s").
/// Serialised to/from Redis as u64 seconds.
#[derive(Clone, Debug, PartialEq)]
pub struct Duration(pub time::Duration);

impl Duration {
    /// Create a new Duration from given number of seconds.
    pub fn from_secs(seconds: u64) -> Self {
        Duration(time::Duration::new(seconds, 0))
    }

    /// Get this duration as number of seconds.
    pub fn as_secs(&self) -> u64 {
        self.0.as_secs()
    }

    pub fn is_zero(&self) -> bool {
        self.0.as_secs() == 0 && self.0.subsec_nanos() == 0
    }
}

impl FromRedisValue for Duration {
    fn from_redis_value(v: &redis::Value) -> RedisResult<Self> {
        let seconds: u64 = redis::from_redis_value(v)?;
        Ok(Self::from_secs(seconds))
    }
}

impl ToRedisArgs for Duration {
    fn write_redis_args<W>(&self, out: &mut W)
    where
        W: ?Sized + RedisWrite,
    {
        self.0.as_secs().write_redis_args(out)
    }
}

impl Serialize for Duration {
    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        serializer.serialize_str(&humantime::format_duration(self.0).to_string())
    }
}

impl<'de> Deserialize<'de> for Duration {
    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Duration, D::Error> {
        let s: &str = Deserialize::deserialize(deserializer)?;
        humantime::parse_duration(s)
            .map(Duration)
            .map_err(D::Error::custom)
    }
}

impl fmt::Display for Duration {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", humantime::format_duration(self.0))
    }
}

impl From<Duration> for serde_json::Value {
    fn from(duration: Duration) -> Self {
        serde_json::Value::String(duration.to_string())
    }
}

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

    #[test]
    fn is_zero() {
        let dur = Duration::from_secs(0);
        assert!(dur.is_zero());

        let dur = Duration::from_secs(1);
        assert!(!dur.is_zero());
    }

    #[test]
    fn json_serialisation() {
        let dur = Duration::from_secs(0);
        assert_eq!(serde_json::to_string(&dur).unwrap(), "\"0s\"");

        let dur = Duration::from_secs(135);
        assert_eq!(serde_json::to_string(&dur).unwrap(), "\"2m 15s\"");

        let dur = Duration::from_secs(1246656);
        assert_eq!(
            serde_json::to_string(&dur).unwrap(),
            "\"14days 10h 17m 36s\""
        );
    }

    #[test]
    fn json_deserialisation() {
        let dur: Duration = serde_json::from_str("\"0s\"").unwrap();
        assert_eq!(dur, Duration::from_secs(0));

        let dur: Duration = serde_json::from_str("\"59s\"").unwrap();
        assert_eq!(dur, Duration::from_secs(59));

        let dur: Duration = serde_json::from_str("\"3h27m\"").unwrap();
        assert_eq!(dur, Duration::from_secs(12420));
    }

    #[test]
    fn roundtrip() {
        let dur = Duration::from_secs(1234567890);
        let ser = serde_json::to_string(&dur).unwrap();
        let deser: Duration = serde_json::from_str(&ser).unwrap();
        assert_eq!(dur, deser);
    }
}