mentimeter · RayProud · Apr 28, 2025 · Apr 23, 2025 · Apr 23, 2025 · Apr 24, 2025
diff --git a/linkup-cli/src/commands/health.rs b/linkup-cli/src/commands/health.rs
@@ -15,7 +15,6 @@ use crate::{
     Result,
 };
 
-#[cfg(target_os = "macos")]
 use super::local_dns;
 
 #[derive(clap::Args)]
@@ -91,13 +90,11 @@ struct OrphanProcess {
 struct BackgroudServices {
     linkup_server: BackgroundServiceHealth,
     cloudflared: BackgroundServiceHealth,
-    #[cfg(target_os = "macos")]
     dns_server: BackgroundServiceHealth,
     possible_orphan_processes: Vec<OrphanProcess>,
 }
 
 #[derive(Debug, Serialize)]
-#[cfg_attr(not(target_os = "macos"), allow(dead_code))]
 enum BackgroundServiceHealth {
     Unknown,
     NotInstalled,
@@ -106,7 +103,6 @@ enum BackgroundServiceHealth {
 }
 
 impl BackgroudServices {
-    #[cfg_attr(not(target_os = "macos"), allow(unused_variables))]
     fn load(state: &Option<LocalState>) -> Self {
         let mut managed_pids: Vec<services::Pid> = Vec::with_capacity(4);
 
@@ -132,7 +128,6 @@ impl BackgroudServices {
             BackgroundServiceHealth::NotInstalled
         };
 
-        #[cfg(target_os = "macos")]
         let dns_server = match find_service_pid(services::LocalDnsServer::ID) {
             Some(pid) => {
                 managed_pids.push(pid);
@@ -159,7 +154,6 @@ impl BackgroudServices {
         Self {
             linkup_server,
             cloudflared,
-            #[cfg(target_os = "macos")]
             dns_server,
             possible_orphan_processes: find_potential_orphan_processes(managed_pids),
         }
@@ -267,14 +261,12 @@ impl Linkup {
     }
 }
 
-#[cfg(target_os = "macos")]
 #[derive(Debug, Serialize)]
 struct LocalDNS {
     is_installed: Option<bool>,
     resolvers: Vec<String>,
 }
 
-#[cfg(target_os = "macos")]
 impl LocalDNS {
     fn load(state: &Option<LocalState>) -> Result<Self> {
         // If there is no state, we cannot know if local-dns is installed since we depend on
@@ -297,7 +289,6 @@ struct Health {
     session: Session,
     background_services: BackgroudServices,
     linkup: Linkup,
-    #[cfg(target_os = "macos")]
     local_dns: LocalDNS,
 }
 
@@ -312,7 +303,6 @@ impl Health {
             session,
             background_services: BackgroudServices::load(&state),
             linkup: Linkup::load()?,
-            #[cfg(target_os = "macos")]
             local_dns: LocalDNS::load(&state)?,
         })
     }
@@ -358,19 +348,12 @@ impl Display for Health {
             BackgroundServiceHealth::Unknown => writeln!(f, "{}", "UNKNOWN".yellow())?,
         }
 
-        #[cfg(target_os = "macos")]
-        {
-            write!(f, "  - DNS Server     ")?;
-            match &self.background_services.dns_server {
-                BackgroundServiceHealth::NotInstalled => {
-                    writeln!(f, "{}", "NOT INSTALLED".yellow())?
-                }
-                BackgroundServiceHealth::Stopped => writeln!(f, "{}", "NOT RUNNING".yellow())?,
-                BackgroundServiceHealth::Running(pid) => {
-                    writeln!(f, "{} ({})", "RUNNING".blue(), pid)?
-                }
-                BackgroundServiceHealth::Unknown => writeln!(f, "{}", "UNKNOWN".yellow())?,
-            }
+        write!(f, "  - DNS Server     ")?;
+        match &self.background_services.dns_server {
+            BackgroundServiceHealth::NotInstalled => writeln!(f, "{}", "NOT INSTALLED".yellow())?,
+            BackgroundServiceHealth::Stopped => writeln!(f, "{}", "NOT RUNNING".yellow())?,
+            BackgroundServiceHealth::Running(pid) => writeln!(f, "{} ({})", "RUNNING".blue(), pid)?,
+            BackgroundServiceHealth::Unknown => writeln!(f, "{}", "UNKNOWN".yellow())?,
         }
 
         write!(f, "  - Cloudflared    ")?;
@@ -408,30 +391,27 @@ impl Display for Health {
             }
         }
 
-        #[cfg(target_os = "macos")]
-        {
-            write!(f, "{}", "Local DNS: ".bold().italic())?;
-            match self.local_dns.is_installed {
-                Some(installed) => {
-                    write!(f, "\n  Installed: ",)?;
-                    if installed {
-                        writeln!(f, "{}", "YES".green())?;
-                    } else {
-                        writeln!(f, "{}", "NO".yellow())?
-                    }
+        write!(f, "{}", "Local DNS: ".bold().italic())?;
+        match self.local_dns.is_installed {
+            Some(installed) => {
+                write!(f, "\n  Installed: ",)?;
+                if installed {
+                    writeln!(f, "{}", "YES".green())?;
+                } else {
+                    writeln!(f, "{}", "NO".yellow())?
+                }
 
-                    write!(f, "  Resolvers:")?;
-                    if self.local_dns.resolvers.is_empty() {
-                        writeln!(f, " {}", "EMPTY".yellow())?;
-                    } else {
-                        writeln!(f)?;
-                        for file in &self.local_dns.resolvers {
-                            writeln!(f, "      - {}", file)?;
-                        }
+                write!(f, "  Resolvers:")?;
+                if self.local_dns.resolvers.is_empty() {
+                    writeln!(f, " {}", "EMPTY".yellow())?;
+                } else {
+                    writeln!(f)?;
+                    for file in &self.local_dns.resolvers {
+                        writeln!(f, "      - {}", file)?;
                     }
                 }
-                None => writeln!(f, "{}", "UNKNOWN".yellow())?,
             }
+            None => writeln!(f, "{}", "UNKNOWN".yellow())?,
         }
 
         write!(f, "{}", "Possible orphan processes:".bold().italic())?;

diff --git a/linkup-cli/src/commands/local_dns.rs b/linkup-cli/src/commands/local_dns.rs
@@ -173,6 +173,7 @@ pub fn list_resolvers() -> std::result::Result<Vec<String>, std::io::Error> {
     Ok(resolvers)
 }
 
+#[cfg(target_os = "macos")]
 fn flush_dns_cache() -> Result<()> {
     let status_flush = Command::new("dscacheutil")
         .args(["-flushcache"])
@@ -186,6 +187,21 @@ fn flush_dns_cache() -> Result<()> {
     Ok(())
 }
 
+#[cfg(target_os = "linux")]
+fn flush_dns_cache() -> Result<()> {
+    let status_flush = Command::new("sudo")
+        .args(["resolvectl", "flush-caches"])
+        .status()
+        .context("Failed to flush DNS cache")?;
+
+    if !status_flush.success() {
+        log::warn!("Flushing DNS cache was unsuccessful");
+    }
+
+    Ok(())
+}
+
+#[cfg(target_os = "macos")]
 fn kill_dns_responder() -> Result<()> {
     let status_kill_responder = Command::new("sudo")
         .args(["killall", "-HUP", "mDNSResponder"])
@@ -198,3 +214,17 @@ fn kill_dns_responder() -> Result<()> {
 
     Ok(())
 }
+
+#[cfg(target_os = "linux")]
+fn kill_dns_responder() -> Result<()> {
+    let status_kill_responder = Command::new("sudo")
+        .args(["killall", "-USR2", "systemd-resolved"])
+        .status()
+        .context("Failed to kill DNS responder")?;
+
+    if !status_kill_responder.success() {
+        log::warn!("Killing DNS responder was unsuccessful");
+    }
+
+    Ok(())
+}
diff --git a/linkup-cli/src/commands/mod.rs b/linkup-cli/src/commands/mod.rs
@@ -2,7 +2,6 @@ pub mod completion;
 pub mod deploy;
 pub mod health;
 pub mod local;
-#[cfg(target_os = "macos")]
 pub mod local_dns;
 pub mod preview;
 pub mod remote;
@@ -19,7 +18,6 @@ pub use {deploy::deploy, deploy::DeployArgs};
 pub use {deploy::destroy, deploy::DestroyArgs};
 pub use {health::health, health::Args as HealthArgs};
 pub use {local::local, local::Args as LocalArgs};
-#[cfg(target_os = "macos")]
 pub use {local_dns::local_dns, local_dns::Args as LocalDnsArgs};
 pub use {preview::preview, preview::Args as PreviewArgs};
 pub use {remote::remote, remote::Args as RemoteArgs};

diff --git a/linkup-cli/src/commands/server.rs b/linkup-cli/src/commands/server.rs
@@ -36,7 +36,6 @@ pub async fn server(args: &Args) -> Result<()> {
                     .unwrap();
             });
 
-            #[cfg(target_os = "macos")]
             let handler_https = {
                 use std::path::PathBuf;
 

diff --git a/linkup-cli/src/commands/start.rs b/linkup-cli/src/commands/start.rs
@@ -46,7 +46,6 @@ pub async fn start(args: &Args, fresh_state: bool, config_arg: &Option<String>)
 
     let local_server = services::LocalServer::new();
     let cloudflare_tunnel = services::CloudflareTunnel::new();
-    #[cfg(target_os = "macos")]
     let local_dns_server = services::LocalDnsServer::new();
 
     let mut display_thread: Option<JoinHandle<()>> = None;
@@ -60,7 +59,6 @@ pub async fn start(args: &Args, fresh_state: bool, config_arg: &Option<String>)
             &[
                 services::LocalServer::NAME,
                 services::CloudflareTunnel::NAME,
-                #[cfg(target_os = "macos")]
                 services::LocalDnsServer::NAME,
             ],
             status_update_channel.1,
@@ -91,16 +89,13 @@ pub async fn start(args: &Args, fresh_state: bool, config_arg: &Option<String>)
         }
     }
 
-    #[cfg(target_os = "macos")]
-    {
-        if exit_error.is_none() {
-            match local_dns_server
-                .run_with_progress(&mut state, status_update_channel.0.clone())
-                .await
-            {
-                Ok(_) => (),
-                Err(err) => exit_error = Some(err),
-            }
+    if exit_error.is_none() {
+        match local_dns_server
+            .run_with_progress(&mut state, status_update_channel.0.clone())
+            .await
+        {
+            Ok(_) => (),
+            Err(err) => exit_error = Some(err),
         }
     }
 

diff --git a/linkup-cli/src/commands/stop.rs b/linkup-cli/src/commands/stop.rs
@@ -34,7 +34,6 @@ pub fn stop(_args: &Args, clear_env: bool) -> Result<()> {
 
     stop_service(services::LocalServer::ID);
     stop_service(services::CloudflareTunnel::ID);
-    #[cfg(target_os = "macos")]
     stop_service(services::LocalDnsServer::ID);
 
     println!("Stopped linkup");

diff --git a/linkup-cli/src/commands/uninstall.rs b/linkup-cli/src/commands/uninstall.rs
@@ -1,6 +1,9 @@
 use std::{fs, process};
 
-use crate::{commands, linkup_dir_path, linkup_exe_path, prompt, InstallationMethod, Result};
+use crate::{
+    commands, commands::local_dns, linkup_dir_path, linkup_exe_path, local_config::managed_domains,
+    local_config::LocalState, prompt, InstallationMethod, Result,
+};
 
 #[derive(clap::Args)]
 pub struct Args {}
@@ -19,19 +22,11 @@ pub async fn uninstall(_args: &Args, config_arg: &Option<String>) -> Result<()>
 
     commands::stop(&commands::StopArgs {}, true)?;
 
-    #[cfg(target_os = "macos")]
-    {
-        use crate::{
-            commands::local_dns,
-            local_config::{self, LocalState},
-        };
-
-        if local_dns::is_installed(&local_config::managed_domains(
-            LocalState::load().ok().as_ref(),
-            config_arg,
-        )) {
-            local_dns::uninstall(config_arg).await?;
-        }
+    if local_dns::is_installed(&managed_domains(
+        LocalState::load().ok().as_ref(),
+        config_arg,
+    )) {
+        local_dns::uninstall(config_arg).await?;
     }
 
     let exe_path = linkup_exe_path()?;

diff --git a/linkup-cli/src/local_config.rs b/linkup-cli/src/local_config.rs
@@ -365,7 +365,6 @@ impl From<&LocalState> for ServerConfig {
     }
 }
 
-#[cfg(target_os = "macos")]
 pub fn managed_domains(state: Option<&LocalState>, cfg_path: &Option<String>) -> Vec<String> {
     let config_domains = match config_path(cfg_path).ok() {
         Some(cfg_path) => match get_config(&cfg_path) {
@@ -396,7 +395,6 @@ pub fn managed_domains(state: Option<&LocalState>, cfg_path: &Option<String>) ->
     domain_set.into_iter().collect()
 }
 
-#[cfg(target_os = "macos")]
 pub fn top_level_domains(domains: &[String]) -> Vec<String> {
     domains
         .iter()

diff --git a/linkup-cli/src/main.rs b/linkup-cli/src/main.rs
@@ -96,7 +96,6 @@ fn current_version() -> Version {
         .expect("current version on CARGO_PKG_VERSION should be a valid version")
 }
 
-#[cfg(target_os = "macos")]
 fn is_sudo() -> bool {
     let sudo_check = std::process::Command::new("sudo")
         .arg("-n")
@@ -112,7 +111,6 @@ fn is_sudo() -> bool {
     false
 }
 
-#[cfg(target_os = "macos")]
 fn sudo_su() -> Result<()> {
     let status = std::process::Command::new("sudo")
         .arg("su")
@@ -226,7 +224,6 @@ enum Commands {
     #[clap(about = "View linkup component and service status")]
     Status(commands::StatusArgs),
 
-    #[cfg(target_os = "macos")]
     #[clap(about = "Speed up your local environment by routing traffic locally when possible")]
     LocalDNS(commands::LocalDnsArgs),
 
@@ -272,7 +269,6 @@ async fn main() -> anyhow::Result<()> {
         Commands::Local(args) => commands::local(args).await,
         Commands::Remote(args) => commands::remote(args).await,
         Commands::Status(args) => commands::status(args),
-        #[cfg(target_os = "macos")]
         Commands::LocalDNS(args) => commands::local_dns(args, &cli.config).await,
         Commands::Completion(args) => commands::completion(args),
         Commands::Preview(args) => commands::preview(args, &cli.config).await,

diff --git a/linkup-cli/src/services/mod.rs b/linkup-cli/src/services/mod.rs
@@ -4,11 +4,9 @@ use sysinfo::{ProcessRefreshKind, RefreshKind, System};
 use thiserror::Error;
 
 mod cloudflare_tunnel;
-#[cfg(target_os = "macos")]
 mod local_dns_server;
 mod local_server;
 
-#[cfg(target_os = "macos")]
 pub use local_dns_server::LocalDnsServer;
 pub use local_server::LocalServer;
 pub use sysinfo::{Pid, Signal};