Add --exclude-countries option and fix manjaro mirror parsing

Author: westandskif

CHANGELOG.md

@@ -1,3 +1,10 @@
+# 0.24.0 (2026-01-16)
+
+- added base option `--exclude-countries` to skip mirrors from certain
+  countries (comma separated 2-letter ISO country codes)
+- fixed manjaro mirror delay calculation (hours were incorrectly treated as minutes)
+- fixed manjaro URL handling in mirror parsing
+
 # 0.23.0 (2025-12-16)
 
 - update artix mirrorlist, handling comments, preserving country labels [#83 by Sachin-Bhat](https://github.com/westandskif/rate-mirrors/pull/83/files)

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "rate_mirrors"
-version = "0.23.0"
+version = "0.24.0"
 authors = ["Nikita Almakov <nikita.almakov@gmail.com>"]
 edition = "2024"
 description = "Everyday-use client-side map-aware mirror ranking tool (Arch Linux; Manjaro; custom ones)"

Cargo.toml

@@ -17,6 +17,7 @@ use crate::target_configs::stdin::StdinTarget;
 use ambassador::{delegatable_trait, Delegate};
 use clap::{Parser, Subcommand};
 use itertools::Itertools;
+use std::collections::HashSet;
 use std::fmt;
 use std::str::FromStr;
 use std::sync::{mpsc, Arc};
@@ -156,8 +157,7 @@ pub struct Config {
     #[arg(env = "RATE_MIRRORS_PROTOCOL", long = "protocol", name = "protocol")]
     pub protocols: Vec<Protocol>,
 
-    /// Per-mirror speed test timeout in milliseconds. It is doubled in cases where slow connection
-    /// times are detected
+    /// Per-mirror speed test timeout in milliseconds
     #[arg(env = "RATE_MIRRORS_PER_MIRROR_TIMEOUT", long, default_value = "8000")]
     pub per_mirror_timeout: u64,
 
@@ -227,6 +227,15 @@ pub struct Config {
     )]
     pub entry_country: String,
 
+    /// Exclude countries from mirror selection (comma-separated 2-letter ISO country codes).
+    #[arg(
+        env = "RATE_MIRRORS_EXCLUDE_COUNTRIES",
+        long = "exclude-countries",
+        name = "country-codes",
+        verbatim_doc_comment
+    )]
+    pub exclude_countries: Option<String>,
+
     /// Neighbor country to test per country
     #[arg(
         env = "RATE_MIRRORS_COUNTRY_NEIGHBORS_PER_COUNTRY",
@@ -270,13 +279,37 @@ pub struct Config {
     /// Disable printing comments to output file
     #[arg(env = "RATE_MIRRORS_DISABLE_COMMENTS_IN_FILE", long)]
     pub disable_comments_in_file: bool,
+
+    /// Pre-parsed set of excluded country codes (lowercase)
+    #[arg(skip)]
+    pub excluded_countries_set: HashSet<String>,
 }
 
 impl Config {
+    pub fn new() -> Self {
+        let mut config = Self::parse();
+        config.excluded_countries_set = config
+            .exclude_countries
+            .as_ref()
+            .map(|s| {
+                s.split(',')
+                    .map(|c| c.trim().to_ascii_lowercase())
+                    .filter(|c| !c.is_empty())
+                    .collect()
+            })
+            .unwrap_or_default();
+        config
+    }
+
     pub fn is_protocol_allowed(&self, protocol: &Protocol) -> bool {
         self.protocols.is_empty() || self.protocols.contains(protocol)
     }
 
+    pub fn is_country_excluded(&self, code: &str) -> bool {
+        self.excluded_countries_set
+            .contains(&code.to_ascii_lowercase())
+    }
+
     pub fn is_protocol_allowed_for_url(&self, url: &Url) -> bool {
         self.protocols.is_empty()
             || url

README.md

@@ -11,7 +11,6 @@ mod targets;
 use crate::config::{AppError, Config, FetchMirrors};
 use crate::speed_test::{test_speed_by_countries, SpeedTestResult, SpeedTestResults};
 use chrono::prelude::*;
-use clap::Parser;
 use config::LogFormatter;
 use itertools::Itertools;
 use mirror::Mirror;
@@ -92,7 +91,7 @@ impl<'a, T: LogFormatter> OutputSink<'a, T> {
 }
 
 fn main() -> Result<(), AppError> {
-    let config = Arc::new(Config::parse());
+    let config = Arc::new(Config::new());
     if !config.allow_root && Uid::effective().is_root() {
         return Err(AppError::Root);
     }

src/config.rs

@@ -13,7 +13,7 @@ use std::convert::From;
 use std::fmt;
 use std::fmt::Debug;
 use std::sync::mpsc::Sender;
-use std::sync::{mpsc, Arc};
+use std::sync::{Arc, mpsc};
 use std::time::{Duration, Instant};
 
 use tokio::runtime::Runtime;
@@ -290,9 +290,10 @@ pub fn test_speed_by_countries(
     let mut unlabeled_mirrors: Vec<Mirror> = Vec::new();
     for mirror in mirrors.into_iter() {
         match mirror.country {
-            Some(country) => {
+            Some(country) if !config.is_country_excluded(country.code) => {
                 map.entry(country).or_insert_with(Vec::new).push(mirror);
             }
+            Some(_) => {}
             None => {
                 unlabeled_mirrors.push(mirror);
             }
@@ -360,7 +361,11 @@ pub fn test_speed_by_countries(
                 };
 
                 let mut links: Vec<_> = if !explored {
-                    country.links.iter().collect()
+                    country
+                        .links
+                        .iter()
+                        .filter(|link| !config.is_country_excluded(link.code))
+                        .collect()
                 } else {
                     Vec::new()
                 };
@@ -441,7 +446,8 @@ pub fn test_speed_by_countries(
                 tx_progress
                     .send(format!(
                         "    TOP NEIGHBOR - CONNECTION TIME: {} - {}",
-                        top_country.code, result.fmt_connection_time(),
+                        top_country.code,
+                        result.fmt_connection_time(),
                     ))
                     .unwrap();
                 countries_to_check.push(top_country);
@@ -451,7 +457,8 @@ pub fn test_speed_by_countries(
                 tx_progress
                     .send(format!(
                         "    TOP CONNECTION TIME: {} - {}",
-                        top_country.code, result.fmt_connection_time(),
+                        top_country.code,
+                        result.fmt_connection_time(),
                     ))
                     .unwrap();
                 latest_top_connection_times.push(result.connection_time);

src/main.rs

@@ -121,7 +121,7 @@ impl FetchMirrors for EndeavourOSTarget {
             })?
         } else {
             fs::read_to_string(self.mirror_list_file.as_str())
-                .expect("failed to read from mirror-list-file")
+                .map_err(|e| AppError::RequestError(format!("failed to read mirror-list-file: {}", e)))?
         };
 
         let mut current_country = None;

src/speed_test.rs

@@ -37,7 +37,7 @@ where
     if let Ok(value) = String::deserialize(deserializer) {
         if let Some((h, m)) = value.split_once(":") {
             if let (Ok(h), Ok(m)) = (h.parse::<i64>(), m.parse::<i64>()) {
-                return Ok(Some(h * 60 + m));
+                return Ok(Some(h * 3600 + m * 60));
             }
         }
     };
@@ -108,7 +108,7 @@ impl FetchMirrors for ManjaroTarget {
                     .and_then(|u| u.join(&self.path_to_test))
                     .map(|url_to_test| Mirror {
                         country: Country::from_str(&m.country),
-                        url: m.url,
+                        url,
                         url_to_test,
                     })
                     .ok()

src/targets/endeavouros.rs

@@ -33,17 +33,23 @@ impl FetchMirrors for StdinTarget {
             .lock()
             .lines()
             .filter_map(
-                |line| match MirrorInfo::parse(&line.unwrap(), &self.separator) {
-                    Ok(info) => Some(Mirror {
-                        country: info.country,
-                        url_to_test: info
-                            .url
-                            .join(&self.path_to_test)
-                            .expect("failed to join path-to-test"),
-                        url: info.url,
-                    }),
+                |line| match line {
+                    Ok(line) => match MirrorInfo::parse(&line, &self.separator) {
+                        Ok(info) => Some(Mirror {
+                            country: info.country,
+                            url_to_test: info
+                                .url
+                                .join(&self.path_to_test)
+                                .expect("failed to join path-to-test"),
+                            url: info.url,
+                        }),
+                        Err(err) => {
+                            eprintln!("{}", err);
+                            None
+                        }
+                    },
                     Err(err) => {
-                        eprintln!("{}", err);
+                        eprintln!("failed to read line: {}", err);
                         None
                     }
                 },