netspd 0.1.1

A beautiful, modern, minimalistic network speed testing terminal application
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

//! Orders the phases of a speed test run.

use reqwest::Client;
use tokio::sync::mpsc;
use tokio_util::sync::CancellationToken;

use crate::errors::EngineResult;

use super::engine::EngineConfig;
use super::event::{emit, EngineEvent};
use super::models::{LatencyStats, Server, TestPhase, TestReport};
use super::network::{download, icmp, ping, upload};

/// Runs ping, download and upload in sequence against one server and
/// assembles the final report.
///
/// Each phase announces itself with [`EngineEvent::PhaseStarted`] and
/// publishes its results before the next phase begins. Cancellation is
/// honored at every await point.
pub(crate) async fn run_sequence(
    client: &Client,
    server: &Server,
    config: &EngineConfig,
    events: &mpsc::Sender<EngineEvent>,
    cancel: &CancellationToken,
) -> EngineResult<TestReport> {
    emit(
        events,
        EngineEvent::PhaseStarted {
            phase: TestPhase::Ping,
        },
    )
    .await?;
    // HTTP latency and ICMP loss probe run side by side; ICMP is
    // best-effort and refines the loss figure when sockets allow it.
    let (latency, icmp_loss) = tokio::join!(
        ping::measure_latency(client, &server.endpoints.ping, &config.ping, events, cancel),
        measure_icmp_loss(server, cancel),
    );
    let mut latency: LatencyStats = latency?;
    if let Some(loss) = icmp_loss {
        latency.packet_loss_pct = loss;
    }
    emit(events, EngineEvent::PingFinished { stats: latency }).await?;

    emit(
        events,
        EngineEvent::PhaseStarted {
            phase: TestPhase::Download,
        },
    )
    .await?;
    lead_in(config, cancel).await?;
    let download_stats = download::run_download(
        client,
        &server.endpoints.download,
        &config.transfer,
        events,
        cancel,
    )
    .await?;
    emit(
        events,
        EngineEvent::TransferFinished {
            phase: TestPhase::Download,
            stats: download_stats,
        },
    )
    .await?;

    emit(
        events,
        EngineEvent::PhaseStarted {
            phase: TestPhase::Upload,
        },
    )
    .await?;
    lead_in(config, cancel).await?;
    let upload_stats = upload::run_upload(
        client,
        &server.endpoints.upload,
        &config.transfer,
        events,
        cancel,
    )
    .await?;
    emit(
        events,
        EngineEvent::TransferFinished {
            phase: TestPhase::Upload,
            stats: upload_stats,
        },
    )
    .await?;

    Ok(TestReport {
        server_name: server.name.clone(),
        latency,
        download: download_stats,
        upload: upload_stats,
    })
}

/// Runs the ICMP loss probe against the server's host, when derivable.
async fn measure_icmp_loss(server: &Server, cancel: &CancellationToken) -> Option<f64> {
    let host = icmp::host_of_url(&server.endpoints.ping)?;
    icmp::measure_loss(&host, cancel).await
}

/// Waits out the configured lead-in between a phase announcement and its
/// first byte, so front ends can play phase transitions against a still
/// needle. Cancellation is honored during the wait.
async fn lead_in(config: &EngineConfig, cancel: &CancellationToken) -> EngineResult<()> {
    if config.transfer.lead_in.is_zero() {
        return Ok(());
    }
    tokio::select! {
        () = cancel.cancelled() => Err(crate::errors::EngineError::Cancelled),
        () = tokio::time::sleep(config.transfer.lead_in) => Ok(()),
    }
}