time_server_utils 0.1.0

Utilities for the time server project
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

use std::time::{SystemTime, UNIX_EPOCH};
use rocket::serde::{Serialize, Deserialize};

extern crate serde;
extern crate serde_json;

pub fn get_unix_times() -> (u64, u64) {
    let start = SystemTime::now();
    let since_the_epoch = start
        .duration_since(UNIX_EPOCH)
        .expect("Time went backwards");

    let unix = since_the_epoch.as_secs();
    let unix_ms = unix * 1000 + since_the_epoch.subsec_nanos() as u64 / 1_000_000;
    (unix_ms, unix);
    return (unix_ms, unix);
}

pub fn round_to_nearest(number: i128, denominator: i128) -> i128 {
    (number + (denominator / 2)) / denominator * denominator
}

#[derive(Serialize, Deserialize)]
#[serde()]
pub struct Result {
    pub diff_ms: Option<i128>,
    pub diff_s: Option<i128>,
    pub unix_ms: u64,
    pub unix: u64
}

#[derive(Serialize, Deserialize)]
#[serde()]
pub struct Response {
    pub status: Status,
    pub result: Result
}

#[derive(Serialize, Deserialize)]
pub enum Status {
    #[serde(rename = "success")]
    Success,
    #[serde(rename = "error")]
    _Error
}

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

    #[test]
    fn unix() {
        let (unix_ms, unix) = get_unix_times();
        println!("unix_ms: {}", unix_ms);
        println!("unix: {}", unix);
        assert!(unix_ms > 0);
        assert!(unix > 0);
        assert!(unix_ms > unix);
    }

    #[test]
    fn round() {
        assert_eq!(round_to_nearest(1499, 1000), 1000);
        assert_eq!(round_to_nearest(1500, 1000), 2000);
        assert_eq!(round_to_nearest(1501, 1000), 2000);
        assert_eq!(round_to_nearest(1499, 100), 1500);
        assert_eq!(round_to_nearest(1500, 100), 1500);
        assert_eq!(round_to_nearest(1501, 100), 1500);
    }
}