core: make action calls UI-agnostic

Author: vnepogodin

src/actions.rs

@@ -1,4 +1,4 @@
-use crate::pages::{Action, DialogMessage, MessageType};
+use crate::ui::{Action, DialogMessage, MessageType, RunCmdCallback};
 use crate::{fl, kwin_dbus, utils, PacmanWrapper};
 
 use std::path::Path;
@@ -139,29 +139,29 @@ pub fn remove_dblock(dialog_tx: Sender<DialogMessage>) {
     }
 }
 
-pub fn update_system() {
+pub fn update_system(callback: RunCmdCallback) {
     let (cmd, escalate) = match utils::get_pacman_wrapper() {
         PacmanWrapper::Aura => ("aura -Syu && aura -Akaxu", false),
         _ => ("pacman -Syu", true),
     };
-    let _ = utils::run_cmd_terminal(String::from(cmd), escalate);
+    let _ = utils::run_cmd_terminal(callback, String::from(cmd), escalate);
 }
 
-pub fn clear_pkgcache() {
+pub fn clear_pkgcache(callback: RunCmdCallback) {
     let (cmd, escalate) = match utils::get_pacman_wrapper() {
         PacmanWrapper::Pak => ("pak -Sc", false),
         PacmanWrapper::Yay => ("yay -Sc", false),
         PacmanWrapper::Paru => ("paru -Sc", false),
         _ => ("pacman -Sc", true),
     };
-    let _ = utils::run_cmd_terminal(String::from(cmd), escalate);
+    let _ = utils::run_cmd_terminal(callback, String::from(cmd), escalate);
 }
 
-pub fn reinstall_packages() {
-    let _ = utils::run_cmd_terminal(String::from("pacman -S $(pacman -Qnq)"), true);
+pub fn reinstall_packages(callback: RunCmdCallback) {
+    let _ = utils::run_cmd_terminal(callback, String::from("pacman -S $(pacman -Qnq)"), true);
 }
 
-pub fn remove_orphans(dialog_tx: Sender<DialogMessage>) {
+pub fn remove_orphans(callback: RunCmdCallback, dialog_tx: Sender<DialogMessage>) {
     // check if you have orphans packages.
     let mut orphan_pkgs = Exec::cmd("/sbin/pacman")
         .arg("-Qtdq")
@@ -183,21 +183,22 @@ pub fn remove_orphans(dialog_tx: Sender<DialogMessage>) {
             .expect("Couldn't send data to channel");
         return;
     }
-    let _ = utils::run_cmd_terminal(format!("pacman -Rns {orphan_pkgs}"), true);
+    let _ = utils::run_cmd_terminal(callback, format!("pacman -Rns {orphan_pkgs}"), true);
 }
 
-pub fn reset_keyring() {
+pub fn reset_keyring(callback: RunCmdCallback) {
     let key_reset = r#"
 rm -rf /etc/pacman.d/gnupg/ && \
 pacman-key --init && pacman-key --populate && \
 pacman-key --recv-keys F3B607488DB35A47 --keyserver keyserver.ubuntu.com && \
 pacman-key --lsign-key F3B607488DB35A47
 "#;
 
-    let _ = utils::run_cmd_terminal(key_reset.into(), true);
+    let _ = utils::run_cmd_terminal(callback, key_reset.into(), true);
 }
 
 pub fn install_needed_packages(
+    callback: RunCmdCallback,
     package_names: &[&str],
     dialog_msg: String,
     dialog_action: Action,
@@ -223,34 +224,37 @@ pub fn install_needed_packages(
 
     // install overwise
     let packages = packages_to_install.join(" ");
-    let _ = utils::run_cmd_terminal(format!("pacman -S {packages}"), true);
+    let _ = utils::run_cmd_terminal(callback, format!("pacman -S {packages}"), true);
 }
 
-pub fn rankmirrors() {
-    let _ = utils::run_cmd_terminal(String::from("cachyos-rate-mirrors"), true);
+pub fn rankmirrors(callback: RunCmdCallback) {
+    let _ = utils::run_cmd_terminal(callback, String::from("cachyos-rate-mirrors"), true);
 }
 
-pub fn install_gaming(dialog_tx: Sender<DialogMessage>) {
+pub fn install_gaming(callback: RunCmdCallback, dialog_tx: Sender<DialogMessage>) {
     const ALPM_PACKAGE_NAMES: [&str; 2] = ["cachyos-gaming-meta", "cachyos-gaming-applications"];
     install_needed_packages(
+        callback,
         &ALPM_PACKAGE_NAMES,
         fl!("gaming-package-installed"),
         Action::InstallGaming,
         dialog_tx,
     );
 }
 
-pub fn install_snapper(dialog_tx: Sender<DialogMessage>) {
+pub fn install_snapper(callback: RunCmdCallback, dialog_tx: Sender<DialogMessage>) {
     install_needed_packages(
+        callback,
         &["cachyos-snapper-support"],
         fl!("snapper-package-installed"),
         Action::InstallSnapper,
         dialog_tx,
     );
 }
 
-pub fn install_spoofdpi(dialog_tx: Sender<DialogMessage>) {
+pub fn install_spoofdpi(callback: RunCmdCallback, dialog_tx: Sender<DialogMessage>) {
     install_needed_packages(
+        callback,
         &["spoofdpi"],
         fl!("spoof-dpi-package-installed"),
         Action::InstallSpoofDpi,

src/dns.rs

@@ -0,0 +1,82 @@
+use phf::phf_ordered_map;
+
+pub static G_DNS_SERVERS: phf::OrderedMap<&'static str, (&'static str, &'static str)> = phf_ordered_map! {
+    "AdGuard" => ("94.140.14.14,94.140.15.15", "2a10:50c0::ad1:ff,2a10:50c0::ad2:ff"),
+    "AdGuard Family Protection" => ("94.140.14.15,94.140.15.16", "2a10:50c0::bad1:ff,2a10:50c0::bad2:ff"),
+    "Cloudflare" => ("1.1.1.1,1.0.0.1", "2606:4700:4700::1111,2606:4700:4700::1001"),
+    "Cloudflare Malware blocking" => ("1.1.1.2,1.0.0.2", "2606:4700:4700::1112,2606:4700:4700::1002"),
+    "Cloudflare Malware and adult content blocking" => ("1.1.1.3,1.0.0.3", "2606:4700:4700::1113,2606:4700:4700::1003"),
+    "Cisco Umbrella(OpenDNS)" => ("208.67.222.222,208.67.220.220", "2620:119:35::35,2620:119:53::53"),
+    "DNS.Watch" => ("84.200.69.80,84.200.70.40", "2001:1608:10:25::1c04:b12f,2001:1608:10:25::9249:d69b"),
+    "GCore" => ("95.85.95.85,2.56.220.2", "2a03:90c0:999d::1,2a03:90c0:9992::1"),
+    "Google" => ("8.8.8.8,8.8.4.4", "2001:4860:4860::8888,2001:4860:4860::8844"),
+    "Quad9" => ("9.9.9.9,149.112.112.112", "2620:fe::fe,2620:fe::9"),
+    "Yandex" => ("77.88.8.8,77.88.8.1", "2a02:6b8::feed:0ff,2a02:6b8:0:1::feed:0ff"),
+    "Yandex Malware blocking" => ("77.88.8.88,77.88.8.2", "2a02:6b8::feed:bad,2a02:6b8:0:1::feed:bad"),
+    "Yandex Malware and adult content blocking" => ("77.88.8.7,77.88.8.3", "2a02:6b8::feed:a11,2a02:6b8:0:1::feed:a11"),
+    "阿里云公共DNS (AliDNS)" => ("223.5.5.5,223.6.6.6", "2400:3200::1,2400:3200:baba::1"),
+    "腾讯云 DNSPod (Tencent)" => ("119.29.29.29,119.28.28.28", "2402:4e00::,2402:4e00:1::")
+};
+
+#[derive(Debug)]
+pub enum DnsAction {
+    /// Set a DNS provider for a network connection
+    Set {
+        /// Network connection name (use 'list-connections' to see available)
+        connection: String,
+
+        /// DNS provider to use (use 'list-servers' to see available)
+        server: DnsServer,
+    },
+    /// Reset DNS settings for a network connection to automatic (DHCP)
+    Reset {
+        /// Network connection name to reset
+        connection: String,
+    },
+    /// List available network connections managed by NetworkManager
+    ListConnections,
+    /// List available third-party DNS providers
+    ListServers,
+}
+
+#[derive(Debug, Clone, Copy)]
+pub enum DnsServer {
+    AdGuard,
+    AdGuardFamily,
+    Cloudflare,
+    CloudflareMalware,
+    CloudflareMalwareAdult,
+    OpenDns,
+    DnsWatch,
+    GCore,
+    Google,
+    Quad9,
+    Yandex,
+    YandexMalware,
+    YandexMalwareAdult,
+    AliDns,
+    Tencent,
+}
+
+// TODO(vnepogodin): use these mapping instead of phf::map
+impl DnsServer {
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            DnsServer::AdGuard => "AdGuard",
+            DnsServer::AdGuardFamily => "AdGuard Family Protection",
+            DnsServer::Cloudflare => "Cloudflare",
+            DnsServer::CloudflareMalware => "Cloudflare Malware blocking",
+            DnsServer::CloudflareMalwareAdult => "Cloudflare Malware and adult content blocking",
+            DnsServer::OpenDns => "Cisco Umbrella(OpenDNS)",
+            DnsServer::DnsWatch => "DNS.Watch",
+            DnsServer::GCore => "GCore",
+            DnsServer::Google => "Google",
+            DnsServer::Quad9 => "Quad9",
+            DnsServer::Yandex => "Yandex",
+            DnsServer::YandexMalware => "Yandex Malware blocking",
+            DnsServer::YandexMalwareAdult => "Yandex Malware and adult content blocking",
+            DnsServer::AliDns => "阿里云公共DNS (AliDNS)",
+            DnsServer::Tencent => "腾讯云 DNSPod (Tencent)",
+        }
+    }
+}

src/gui.rs

@@ -0,0 +1,54 @@
+use crate::ui::{MessageType, UI};
+use gtk::prelude::*;
+
+pub struct GUI {
+    window: gtk::Window,
+}
+
+impl GUI {
+    pub fn new(window: gtk::Window) -> Self {
+        GUI { window }
+    }
+}
+
+impl UI for GUI {
+    fn show_message(&self, message_type: MessageType, message: &str, title: String) {
+        let dialog_msg_type = match message_type {
+            MessageType::Info => gtk::MessageType::Info,
+            MessageType::Warning => gtk::MessageType::Warning,
+            MessageType::Error => gtk::MessageType::Error,
+        };
+
+        let dialog = gtk::MessageDialog::builder()
+            .transient_for(&self.window)
+            .message_type(dialog_msg_type)
+            .text(message)
+            .title(title)
+            .modal(true)
+            .buttons(gtk::ButtonsType::Ok)
+            .build();
+        dialog.connect_response(|dialog, _| dialog.close());
+
+        dialog.show();
+        // block until user responds
+        dialog.run();
+        // we are required to close/hide manually according to the docs
+        dialog.close();
+    }
+}
+
+pub fn run_command(command: &str, escalate: bool) -> bool {
+    let cmd_formated = format!("{command}; read -p 'Press enter to exit'");
+    let mut args: Vec<&str> = vec![];
+    if escalate {
+        args.extend_from_slice(&["-s", "pkexec /usr/share/cachyos-hello/scripts/rootshell.sh"]);
+    }
+    args.push(cmd_formated.as_str());
+
+    let exit_status = subprocess::Exec::cmd("/usr/share/cachyos-hello/scripts/terminal-helper")
+        .args(args.as_slice())
+        .stdout(subprocess::Redirection::Pipe)
+        .join()
+        .unwrap();
+    exit_status.success()
+}

src/installer.rs

@@ -1,4 +1,5 @@
-use crate::pages::MessageType;
+use crate::gui::GUI;
+use crate::ui::{MessageType, UI};
 use crate::{check_regular_file, fl, utils, G_HELLO_WINDOW};
 
 use std::fs;
@@ -19,31 +20,21 @@ struct Versions {
     handheld_iso_version: String,
 }
 
-fn outdated_version_check(window: &gtk::Window, message: String) -> bool {
+fn outdated_version_check(ui: &GUI, message: String) -> bool {
     let edition_tag: String =
         fs::read_to_string("/etc/edition-tag").unwrap_or("desktop".into()).trim().into();
     let version_tag: String =
         fs::read_to_string("/etc/version-tag").unwrap_or("testing".into()).trim().into();
 
     if version_tag.contains("testing") {
-        utils::show_simple_dialog(
-            window,
-            MessageType::Warning,
-            &fl!("testing-iso-warning"),
-            message.clone(),
-        );
+        ui.show_message(MessageType::Warning, &fl!("testing-iso-warning"), message.clone());
         return true;
     }
 
     let response = reqwest::blocking::get("https://cachyos.org/versions.json");
 
     if response.is_err() {
-        utils::show_simple_dialog(
-            window,
-            MessageType::Warning,
-            &fl!("offline-error"),
-            message.clone(),
-        );
+        ui.show_message(MessageType::Warning, &fl!("offline-error"), message.clone());
         return false;
     }
 
@@ -58,17 +49,12 @@ fn outdated_version_check(window: &gtk::Window, message: String) -> bool {
     .to_owned();
 
     if version_tag != latest_version {
-        utils::show_simple_dialog(
-            window,
-            MessageType::Warning,
-            &fl!("outdated-version-warning"),
-            message.clone(),
-        );
+        ui.show_message(MessageType::Warning, &fl!("outdated-version-warning"), message.clone());
     }
     true
 }
 
-fn edition_compat_check(window: &gtk::Window, message: String) -> bool {
+fn edition_compat_check(ui: &GUI, message: String) -> bool {
     let edition_tag = fs::read_to_string("/etc/edition-tag").unwrap_or("desktop".to_string());
 
     if edition_tag == "handheld" {
@@ -84,19 +70,14 @@ fn edition_compat_check(window: &gtk::Window, message: String) -> bool {
 
         if available_profiles.iter().any(|profile| handheld_profile_names.contains(&&profile.name))
         {
-            utils::show_simple_dialog(
-                window,
-                MessageType::Warning,
-                &fl!("unsupported-hw-warning"),
-                message.clone(),
-            );
+            ui.show_message(MessageType::Warning, &fl!("unsupported-hw-warning"), message.clone());
             return true;
         }
     }
     true
 }
 
-fn connectivity_check(window: &gtk::Window, message: String) -> bool {
+fn connectivity_check(ui: &GUI, message: String) -> bool {
     // First try HTTP check to cachyos.org
     let http_status = match reqwest::blocking::get("https://cachyos.org") {
         Ok(resp) => resp.status().is_success() || resp.status().is_server_error(),
@@ -127,7 +108,7 @@ fn connectivity_check(window: &gtk::Window, message: String) -> bool {
     }
 
     // All connectivity checks failed
-    utils::show_simple_dialog(window, MessageType::Error, &fl!("offline-error"), message);
+    ui.show_message(MessageType::Error, &fl!("offline-error"), message);
     false
 }
 
@@ -140,8 +121,9 @@ pub fn launch_installer(message: String) {
         let install_btn: gtk::Button = builder.object("install").unwrap();
         install_btn.set_sensitive(false);
 
+        let ui_comp = crate::gui::GUI::new(window_ref.clone());
         let checks = [connectivity_check, edition_compat_check, outdated_version_check];
-        if !checks.iter().all(|x| x(window_ref, message.clone())) {
+        if !checks.iter().all(|x| x(&ui_comp, message.clone())) {
             // if any check failed, return
             info!("Some ISO check failed!");
             install_btn.set_sensitive(true);

src/main.rs

@@ -3,14 +3,17 @@
 
 mod actions;
 mod config;
+mod dns;
 mod embed_data;
 mod gresource;
+mod gui;
 mod installer;
 mod kwin_dbus;
 mod localization;
 mod logger;
 mod pages;
 mod systemd_units;
+mod ui;
 mod utils;
 mod window;