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

#![cfg(all(feature = "ptp", target_os = "linux"))]

use std::time::Duration;

use futures::future::join_all;

use crate::adapters::{ptp_client, resolver};
use crate::domain::ptp::PtpProbeResult;
use crate::error::RkikError;

use super::query::parse_target;

/// Options controlling a PTP probe.
#[derive(Debug, Clone)]
pub struct PtpQueryOptions {
    pub domain: u8,
    pub event_port: u16,
    pub general_port: u16,
    pub hw_timestamping: bool,
    pub verbose: bool,
}

impl PtpQueryOptions {
    pub fn new(
        domain: u8,
        event_port: u16,
        general_port: u16,
        hw_timestamping: bool,
        verbose: bool,
    ) -> Self {
        Self {
            domain,
            event_port,
            general_port,
            hw_timestamping,
            verbose,
        }
    }
}

/// Query a single target and produce a [`PtpProbeResult`].
pub async fn query_target(
    target: &str,
    mut ipv6: bool,
    timeout: Duration,
    opts: &PtpQueryOptions,
) -> Result<PtpProbeResult, RkikError> {
    let parsed = parse_target(target)?;
    if parsed.is_ipv6_literal {
        ipv6 = true;
    }

    let ip = resolver::resolve_ip(parsed.host, ipv6)?;
    let event_port = parsed.port.unwrap_or(opts.event_port);

    ptp_client::query_ptp(
        target,
        ip,
        opts.domain,
        event_port,
        opts.general_port,
        opts.hw_timestamping,
        timeout,
        opts.verbose,
    )
    .await
}

/// Query several targets concurrently and return the successful results.
pub async fn query_many(
    targets: &[String],
    ipv6: bool,
    timeout: Duration,
    opts: &PtpQueryOptions,
) -> Result<Vec<PtpProbeResult>, RkikError> {
    let futures = targets
        .iter()
        .map(|t| query_target(t, ipv6, timeout, opts))
        .collect::<Vec<_>>();

    let results = join_all(futures).await;
    let mut out = Vec::new();
    for res in results {
        out.push(res?);
    }
    Ok(out)
}