added Arch4edu support

Author: westandskif

CHANGELOG.md

@@ -1,3 +1,7 @@
+# 0.27.0 (2026-02-08)
+
+- added Arch4edu support (`arch4edu`)
+
 # 0.26.0 (2026-02-08)
 
 - added `--disable-untested-fallback` to exit with error when all speed tests fail

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "rate_mirrors"
-version = "0.26.0"
+version = "0.27.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

@@ -54,6 +54,7 @@ rate-mirrors --help
 | Command | Distribution | Notes |
 |---------|-------------|-------|
 | `rate-mirrors arch` | Arch Linux | Skips outdated/syncing mirrors |
+| `rate-mirrors arch4edu` | Arch4edu | |
 | `rate-mirrors archarm` | Arch Linux ARM | |
 | `rate-mirrors arcolinux` | ArcoLinux | |
 | `rate-mirrors artix` | Artix Linux | |

README.md

@@ -1,4 +1,5 @@
 use crate::mirror::Mirror;
+use crate::target_configs::arch4edu::Arch4eduTarget;
 use crate::target_configs::archarm::ArcharmTarget;
 use crate::target_configs::archlinux::ArchTarget;
 use crate::target_configs::archlinuxcn::ArchCNTarget;
@@ -14,7 +15,7 @@ use crate::target_configs::openbsd::OpenBSDTarget;
 use crate::target_configs::rebornos::RebornOSTarget;
 use crate::target_configs::stdin::StdinTarget;
 // use crate::target_configs::ubuntu::UbuntuTarget;
-use ambassador::{Delegate, delegatable_trait};
+use ambassador::{delegatable_trait, Delegate};
 use clap::{Parser, Subcommand};
 use serde::de::DeserializeOwned;
 use std::collections::HashSet;
@@ -89,10 +90,7 @@ pub trait LogFormatter {
 
 #[delegatable_trait]
 pub trait FetchMirrors {
-    fn fetch_mirrors(
-        &self,
-        tx_progress: mpsc::Sender<String>,
-    ) -> Result<Vec<Mirror>, AppError>;
+    fn fetch_mirrors(&self, tx_progress: mpsc::Sender<String>) -> Result<Vec<Mirror>, AppError>;
 }
 
 #[derive(Debug, Subcommand, Clone, Delegate)]
@@ -105,6 +103,10 @@ pub enum Target {
     /// test archlinux mirrors
     Arch(ArchTarget),
 
+    /// test arch4edu mirrors
+    #[command(name = "arch4edu")]
+    Arch4edu(Arch4eduTarget),
+
     /// test archlinuxcn mirrors
     #[command(name = "archlinuxcn")]
     ArchCN(ArchCNTarget),
@@ -335,7 +337,6 @@ impl Config {
                 .unwrap_or(false)
         }
     }
-
 }
 
 fn convert_reqwest_error(e: reqwest::Error, url: &str) -> AppError {

src/config.rs

@@ -119,9 +119,7 @@ fn main() -> Result<(), AppError> {
     let (tx_mirrors, rx_mirrors) = mpsc::channel::<Mirror>();
 
     let thread_handle = thread::spawn(move || -> Result<(), AppError> {
-        let mut mirrors = config
-            .target
-            .fetch_mirrors(tx_progress.clone())?;
+        let mut mirrors = config.target.fetch_mirrors(tx_progress.clone())?;
 
         // Centralized protocol filtering
         let before_protocol = mirrors.len();

src/main.rs

@@ -13,7 +13,7 @@ use std::convert::From;
 use std::fmt;
 use std::fmt::Debug;
 use std::sync::mpsc::Sender;
-use std::sync::{Arc, mpsc};
+use std::sync::{mpsc, Arc};
 use std::time::{Duration, Instant};
 
 use tokio::runtime::Runtime;

src/speed_test.rs

@@ -0,0 +1,31 @@
+use clap::Args;
+
+#[derive(Debug, Clone, Args)]
+pub struct Arch4eduTarget {
+    /// Fetch list of mirrors timeout in milliseconds
+    #[arg(
+        env = "RATE_MIRRORS_FETCH_MIRRORS_TIMEOUT",
+        long,
+        default_value = "15000"
+    )]
+    pub fetch_mirrors_timeout: u64,
+
+    /// Path to be joined to a mirror url and used for speed testing
+    ///   the file should be big enough to allow for testing high
+    ///   speed connections
+    #[arg(
+        env = "RATE_MIRRORS_PATH_TO_TEST",
+        long,
+        default_value = "x86_64/arch4edu.files",
+        verbatim_doc_comment
+    )]
+    pub path_to_test: String,
+
+    /// Architecture
+    #[arg(env = "RATE_MIRRORS_ARCH", long, default_value = "auto")]
+    pub arch: String,
+
+    /// comment prefix to use when outputting
+    #[arg(env = "RATE_MIRRORS_COMMENT_PREFIX", long, default_value = "# ")]
+    pub comment_prefix: String,
+}

src/target_configs/arch4edu.rs

@@ -1,3 +1,4 @@
+pub mod arch4edu;
 pub mod archarm;
 pub mod archlinux;
 pub mod archlinuxcn;

src/target_configs/mod.rs

@@ -0,0 +1,137 @@
+use crate::config::{fetch_text, AppError, FetchMirrors, LogFormatter};
+use crate::mirror::Mirror;
+use crate::target_configs::arch4edu::Arch4eduTarget;
+use std::fmt::Display;
+use std::sync::mpsc;
+use url::Url;
+
+const ARCH4EDU_MIRRORLIST_URL: &str =
+    "https://raw.githubusercontent.com/arch4edu/mirrorlist/refs/heads/master/mirrorlist.arch4edu";
+
+fn parse_mirror_url(line: &str) -> Option<Url> {
+    let mut cleaned = line.trim_start();
+    while cleaned.starts_with('#') {
+        cleaned = cleaned.trim_start_matches('#').trim_start();
+    }
+
+    let raw_url = cleaned
+        .strip_prefix("Global Server = ")
+        .or_else(|| cleaned.strip_prefix("Server = "))?
+        .trim()
+        .replace("$arch", "");
+
+    if raw_url.is_empty() {
+        return None;
+    }
+
+    Url::parse(&raw_url).ok()
+}
+
+impl LogFormatter for Arch4eduTarget {
+    fn format_comment(&self, message: impl Display) -> String {
+        format!("{}{}", self.comment_prefix, message)
+    }
+
+    fn format_mirror(&self, mirror: &Mirror) -> String {
+        let arch = if self.arch == "auto" {
+            "$arch"
+        } else {
+            &self.arch
+        };
+
+        format!("Server = {}{}", mirror.url, arch)
+    }
+}
+
+impl FetchMirrors for Arch4eduTarget {
+    fn fetch_mirrors(&self, _tx_progress: mpsc::Sender<String>) -> Result<Vec<Mirror>, AppError> {
+        let output = fetch_text(ARCH4EDU_MIRRORLIST_URL, self.fetch_mirrors_timeout)?;
+
+        let mirrors = output
+            .lines()
+            .filter_map(parse_mirror_url)
+            .map(|url| {
+                let url_to_test = url
+                    .join(&self.path_to_test)
+                    .expect("failed to join path_to_test");
+                Mirror {
+                    country: None,
+                    url,
+                    url_to_test,
+                }
+            })
+            .collect();
+
+        Ok(mirrors)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::parse_mirror_url;
+    use crate::config::LogFormatter;
+    use crate::mirror::Mirror;
+    use crate::target_configs::arch4edu::Arch4eduTarget;
+    use url::Url;
+
+    #[test]
+    fn parse_server_line() {
+        let url = parse_mirror_url("#Server = https://mirror.example/arch4edu/$arch").unwrap();
+        assert_eq!(url.as_str(), "https://mirror.example/arch4edu/");
+    }
+
+    #[test]
+    fn parse_global_server_line() {
+        let url =
+            parse_mirror_url("## Global Server = https://mirror.example/arch4edu/$arch").unwrap();
+        assert_eq!(url.as_str(), "https://mirror.example/arch4edu/");
+    }
+
+    #[test]
+    fn ignore_non_server_lines() {
+        assert!(parse_mirror_url("# random comment").is_none());
+        assert!(parse_mirror_url("Include = /etc/pacman.d/mirrorlist").is_none());
+    }
+
+    #[test]
+    fn format_mirror_uses_arch_placeholder_for_auto() {
+        let target = Arch4eduTarget {
+            fetch_mirrors_timeout: 15_000,
+            path_to_test: "arch4edu/x86_64/arch4edu.files".to_string(),
+            arch: "auto".to_string(),
+            comment_prefix: "# ".to_string(),
+        };
+        let mirror = Mirror {
+            country: None,
+            url: Url::parse("https://mirror.example/arch4edu/").unwrap(),
+            url_to_test: Url::parse("https://mirror.example/arch4edu/x86_64/arch4edu.files")
+                .unwrap(),
+        };
+
+        assert_eq!(
+            target.format_mirror(&mirror),
+            "Server = https://mirror.example/arch4edu/$arch"
+        );
+    }
+
+    #[test]
+    fn format_mirror_uses_custom_arch() {
+        let target = Arch4eduTarget {
+            fetch_mirrors_timeout: 15_000,
+            path_to_test: "arch4edu/x86_64/arch4edu.files".to_string(),
+            arch: "x86_64".to_string(),
+            comment_prefix: "# ".to_string(),
+        };
+        let mirror = Mirror {
+            country: None,
+            url: Url::parse("https://mirror.example/arch4edu/").unwrap(),
+            url_to_test: Url::parse("https://mirror.example/arch4edu/x86_64/arch4edu.files")
+                .unwrap(),
+        };
+
+        assert_eq!(
+            target.format_mirror(&mirror),
+            "Server = https://mirror.example/arch4edu/x86_64"
+        );
+    }
+}