vcon-server 0.1.0

Stores vCons encrypted at rest and returns them to authorised readers.
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

//! Time, behind an interface so tests can set it.

use time::OffsetDateTime;

/// Where the server gets the time.
pub trait Clock: Send + Sync {
    /// The time now, in UTC.
    fn now(&self) -> OffsetDateTime;
}

/// A time as the catalogs keep it: nanoseconds since the Unix epoch.
pub(crate) fn nanos(at: OffsetDateTime) -> i64 {
    i64::try_from(at.unix_timestamp_nanos()).expect("a time before 2262")
}

/// A time the catalogs kept as `nanos` wrote it, or None if it is out of
/// range.
pub(crate) fn from_nanos(at: i64) -> Option<OffsetDateTime> {
    OffsetDateTime::from_unix_timestamp_nanos(i128::from(at)).ok()
}

/// The system's clock.
pub struct SystemClock;

impl Clock for SystemClock {
    fn now(&self) -> OffsetDateTime {
        OffsetDateTime::now_utc()
    }
}

#[cfg(test)]
pub(crate) use manual::ManualClock;

#[cfg(test)]
mod manual {
    use std::sync::Mutex;

    use time::OffsetDateTime;

    use super::Clock;

    /// A clock that stands still until a test moves it.
    pub(crate) struct ManualClock(Mutex<OffsetDateTime>);

    impl ManualClock {
        pub(crate) fn at(now: OffsetDateTime) -> ManualClock {
            ManualClock(Mutex::new(now))
        }

        pub(crate) fn set(&self, now: OffsetDateTime) {
            *self.0.lock().expect("clock") = now;
        }
    }

    impl Clock for ManualClock {
        fn now(&self) -> OffsetDateTime {
            *self.0.lock().expect("clock")
        }
    }
}

#[cfg(test)]
mod tests {
    use time::macros::datetime;

    use super::*;

    #[test]
    fn the_system_clock_is_close_to_now() {
        let before = OffsetDateTime::now_utc();
        let now = SystemClock.now();
        let after = OffsetDateTime::now_utc();
        assert!(before <= now && now <= after);
    }

    #[test]
    fn a_manual_clock_moves_only_when_set() {
        let clock = ManualClock::at(datetime!(2026-10-23 12:00 UTC));
        assert_eq!(clock.now(), datetime!(2026-10-23 12:00 UTC));
        clock.set(datetime!(2026-10-24 12:00 UTC));
        assert_eq!(clock.now(), datetime!(2026-10-24 12:00 UTC));
    }
}