rkik 2.2.0

Rusty Klock Inspection Kit - NTP Query and Compare Tool
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

use crate::domain::ntp::ProbeResult;
#[cfg(all(feature = "ptp", target_os = "linux"))]
use crate::domain::ptp::PtpProbeResult;
#[cfg(feature = "json")]
use serde::Serialize;

#[derive(Debug, Clone)]
#[cfg_attr(feature = "json", derive(Serialize))]
pub struct Stats {
    pub count: usize,
    pub offset_avg: f64,
    pub offset_min: f64,
    pub offset_max: f64,
    pub rtt_avg: f64,
}

pub fn compute_stats(results: &[ProbeResult]) -> Stats {
    if results.is_empty() {
        return Stats {
            count: 0,
            offset_avg: 0.0,
            offset_min: 0.0,
            offset_max: 0.0,
            rtt_avg: 0.0,
        };
    }

    let count = results.len();
    let offset_avg = results.iter().map(|r| r.offset_ms).sum::<f64>() / count as f64;
    let offset_min = results
        .iter()
        .map(|r| r.offset_ms)
        .fold(f64::INFINITY, f64::min);
    let offset_max = results
        .iter()
        .map(|r| r.offset_ms)
        .fold(f64::NEG_INFINITY, f64::max);
    let rtt_avg = results.iter().map(|r| r.rtt_ms).sum::<f64>() / count as f64;
    Stats {
        count,
        offset_avg,
        offset_min,
        offset_max,
        rtt_avg,
    }
}

#[cfg(all(feature = "ptp", target_os = "linux"))]
#[derive(Debug, Clone)]
#[cfg_attr(feature = "json", derive(Serialize))]
pub struct PtpStats {
    pub count: usize,
    pub offset_avg_ns: f64,
    pub offset_min_ns: f64,
    pub offset_max_ns: f64,
    pub mean_path_delay_avg_ns: f64,
}

#[cfg(all(feature = "ptp", target_os = "linux"))]
pub fn compute_ptp_stats(results: &[PtpProbeResult]) -> PtpStats {
    if results.is_empty() {
        return PtpStats {
            count: 0,
            offset_avg_ns: 0.0,
            offset_min_ns: 0.0,
            offset_max_ns: 0.0,
            mean_path_delay_avg_ns: 0.0,
        };
    }

    let count = results.len();
    let offset_avg_ns = results.iter().map(|r| r.offset_ns as f64).sum::<f64>() / count as f64;
    let offset_min_ns = results
        .iter()
        .map(|r| r.offset_ns as f64)
        .fold(f64::INFINITY, f64::min);
    let offset_max_ns = results
        .iter()
        .map(|r| r.offset_ns as f64)
        .fold(f64::NEG_INFINITY, f64::max);
    let mean_path_delay_avg_ns = results
        .iter()
        .map(|r| r.mean_path_delay_ns as f64)
        .sum::<f64>()
        / count as f64;

    PtpStats {
        count,
        offset_avg_ns,
        offset_min_ns,
        offset_max_ns,
        mean_path_delay_avg_ns,
    }
}

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

    #[test]
    fn compute_stats_empty_results() {
        let results: Vec<ProbeResult> = Vec::new();

        let stats = compute_stats(&results);

        assert_eq!(stats.count, 0);
        assert_eq!(stats.offset_avg, 0.0);
        assert_eq!(stats.offset_min, 0.0);
        assert_eq!(stats.offset_max, 0.0);
        assert_eq!(stats.rtt_avg, 0.0);
    }
}