masterstat 0.8.0

Get server addresses from QuakeWorld master servers.
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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

use futures::future;
use std::time::Duration;

use crate::query;

#[derive(Debug, Default)]
pub struct QuerySuccess {
    master_address: String,
    server_addresses: Vec<String>,
}
impl QuerySuccess {
    pub fn master_address(&self) -> &str {
        &self.master_address
    }

    pub fn server_addresses(&self) -> &[String] {
        &self.server_addresses
    }
}

#[derive(Debug)]
pub struct QueryFailure {
    master_address: String,
    error: anyhow::Error,
}
impl QueryFailure {
    pub fn master_address(&self) -> &str {
        &self.master_address
    }

    pub fn error(&self) -> &anyhow::Error {
        &self.error
    }
}

#[derive(Debug, Default)]
pub struct MultiQueryResult {
    /// Collection of successful queries.
    successes: Vec<QuerySuccess>,

    /// Collection of failed queries.
    failures: Vec<QueryFailure>,
}

impl MultiQueryResult {
    /// Iterator over successful query results.
    pub fn successful_queries(&self) -> impl Iterator<Item = &QuerySuccess> {
        self.successes.iter()
    }

    /// Iterator over failed query results.
    pub fn failed_queries(&self) -> impl Iterator<Item = &QueryFailure> {
        self.failures.iter()
    }

    /// Unique server addresses from successful queries.
    pub fn server_addresses(&self) -> Vec<String> {
        let mut addresses: Vec<String> = self
            .successes
            .iter()
            .flat_map(|res| res.server_addresses().iter())
            .cloned()
            .collect();
        addresses.sort();
        addresses.dedup();
        addresses
    }
}

/// Get server addresses from multiple master servers (concurrently)
///
/// # Arguments
/// * `master_addresses` - A slice of master server addresses to query.
/// * `timeout` - The timeout duration for each query.
///
/// # Returns
/// A `MultiQueryResult` containing successful and failed queries.
///
/// # Example
/// ```rust
/// #[tokio::main]
/// async fn main() {
///     let master_addresses = vec![
///         "master.quakeservers.net:27000".to_string(),
///         "master.quakeworld.nu:27000".to_string(),
///     ];
///     let timeout = std::time::Duration::from_secs(2);
///     let result = masterstat::query_multiple(&master_addresses, timeout).await;
/// }
/// ```
pub async fn query_multiple(master_addresses: &[String], timeout: Duration) -> MultiQueryResult {
    let tasks = master_addresses
        .iter()
        .map(|address| async move { (address.clone(), query(address, timeout).await) });

    let mut results = MultiQueryResult::default();

    for (master_address, res) in future::join_all(tasks).await {
        match res {
            Ok(server_addresses) => results.successes.push(QuerySuccess {
                master_address,
                server_addresses,
            }),
            Err(error) => results.failures.push(QueryFailure {
                master_address,
                error,
            }),
        }
    }

    results
}

#[cfg(test)]
mod tests {
    use super::*;
    use anyhow::Result;
    use pretty_assertions::assert_eq;

    #[tokio::test]
    #[cfg_attr(feature = "ci", ignore)]
    async fn test_query_multiple() -> Result<()> {
        let master_addresses = vec![
            "master.quakeservers.net:27000".to_string(),
            "master.quakeworld.nu:27000".to_string(),
            "INVALID:27000".to_string(),
        ];
        let results = query_multiple(&master_addresses, Duration::from_secs(2)).await;

        assert!(results.server_addresses().len() >= 300);
        assert!(2 == results.successful_queries().count());
        assert!(1 == results.failed_queries().count());

        let query1 = results.successful_queries().next().unwrap();
        assert!(query1.server_addresses().len() >= 300);
        assert_eq!(
            query1.master_address(),
            "master.quakeservers.net:27000".to_string()
        );

        let query2 = results.successful_queries().last().unwrap();
        assert!(query2.server_addresses().len() >= 300);
        assert_eq!(
            query2.master_address(),
            "master.quakeworld.nu:27000".to_string()
        );

        let query3 = results.failed_queries().next().unwrap();
        assert_eq!(query3.master_address(), "INVALID:27000".to_string());
        assert!(query3.error().to_string().contains("failed to lookup"));

        Ok(())
    }
}