feat: all local servers managed together

linkup-cli/src/commands/health.rs

@@ -90,20 +90,18 @@ struct OrphanProcess {
 pub struct BackgroundServices {
     pub linkup_server: BackgroundServiceHealth,
     cloudflared: BackgroundServiceHealth,
-    dns_server: BackgroundServiceHealth,
     possible_orphan_processes: Vec<OrphanProcess>,
 }
 
 #[derive(Debug, Serialize)]
 pub enum BackgroundServiceHealth {
-    Unknown,
     NotInstalled,
     Stopped,
     Running(u32),
 }
 
 impl BackgroundServices {
-    pub fn load(state: Option<&State>) -> Self {
+    pub fn load(_state: Option<&State>) -> Self {
         let mut managed_pids: Vec<services::Pid> = Vec::with_capacity(4);
 
         let linkup_server = match services::LocalServer::find_pid() {
@@ -128,30 +126,9 @@ impl BackgroundServices {
             BackgroundServiceHealth::NotInstalled
         };
 
-        let dns_server = match services::LocalDnsServer::find_pid() {
-            Some(pid) => {
-                managed_pids.push(pid);
-
-                BackgroundServiceHealth::Running(pid.as_u32())
-            }
-            None => match state {
-                // If there is no state, we cannot know if local-dns is installed since we depend on
-                // the domains listed on it.
-                Some(state) => {
-                    if local_dns::is_installed(&crate::state::managed_domains(Some(state), &None)) {
-                        BackgroundServiceHealth::Stopped
-                    } else {
-                        BackgroundServiceHealth::NotInstalled
-                    }
-                }
-                None => BackgroundServiceHealth::Unknown,
-            },
-        };
-
         Self {
             linkup_server,
             cloudflared,
-            dns_server,
             possible_orphan_processes: find_potential_orphan_processes(managed_pids),
         }
     }
@@ -357,23 +334,13 @@ impl Display for Health {
             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    ")?;
         match &self.background_services.cloudflared {
             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())?,
         }
 
         writeln!(f, "{}", "Linkup:".bold().italic())?;

linkup-cli/src/commands/server.rs

@@ -1,78 +1,31 @@
+use std::path::PathBuf;
+
 use crate::Result;
 use linkup::MemoryStringStore;
-use tokio::select;
 
 #[derive(clap::Args)]
 pub struct Args {
-    #[command(subcommand)]
-    server_kind: ServerKind,
-}
+    #[arg(long)]
+    session_name: String,
 
-#[derive(clap::Subcommand)]
-pub enum ServerKind {
-    LocalWorker {
-        #[arg(long)]
-        certs_dir: String,
-    },
+    #[arg(long, value_parser, num_args = 1.., value_delimiter = ',')]
+    domains: Vec<String>,
 
-    Dns {
-        #[arg(long)]
-        session_name: String,
-        #[arg(long, value_parser, num_args = 1.., value_delimiter = ',')]
-        domains: Vec<String>,
-    },
+    #[arg(long)]
+    certs_dir: String,
 }
 
 pub async fn server(args: &Args) -> Result<()> {
-    match &args.server_kind {
-        ServerKind::LocalWorker { certs_dir } => {
-            let config_store = MemoryStringStore::default();
-
-            let http_config_store = config_store.clone();
-            let handler_http = tokio::spawn(async move {
-                linkup_local_server::start_server_http(http_config_store)
-                    .await
-                    .unwrap();
-            });
-
-            let handler_https = {
-                use std::path::PathBuf;
-
-                let https_config_store = config_store.clone();
-                let https_certs_dir = PathBuf::from(certs_dir);
-
-                Some(tokio::spawn(async move {
-                    linkup_local_server::start_server_https(https_config_store, &https_certs_dir)
-                        .await;
-                }))
-            };
-
-            match handler_https {
-                Some(handler_https) => {
-                    select! {
-                        _ = handler_http => (),
-                        _ = handler_https => (),
-                    }
-                }
-                None => {
-                    handler_http.await.unwrap();
-                }
-            }
-        }
-        ServerKind::Dns {
-            session_name,
-            domains,
-        } => {
-            let session_name = session_name.clone();
-            let domains = domains.clone();
-
-            let handler_dns = tokio::spawn(async move {
-                linkup_local_server::start_dns_server(session_name, domains).await;
-            });
-
-            handler_dns.await.unwrap();
-        }
-    }
+    let config_store = MemoryStringStore::default();
+    let https_certs_dir = PathBuf::from(&args.certs_dir);
+
+    linkup_local_server::start(
+        config_store,
+        &https_certs_dir,
+        args.session_name.clone(),
+        args.domains.clone(),
+    )
+    .await;
 
     Ok(())
 }

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();
-    let local_dns_server = services::LocalDnsServer::new();
 
     let mut display_thread: Option<JoinHandle<()>> = None;
     let display_channel = sync::mpsc::channel::<bool>();
@@ -59,7 +58,6 @@ pub async fn start(args: &Args, fresh_state: bool, config_arg: &Option<String>)
             &[
                 services::LocalServer::NAME,
                 services::CloudflareTunnel::NAME,
-                services::LocalDnsServer::NAME,
             ],
             status_update_channel.1,
             display_channel.1,
@@ -89,16 +87,6 @@ pub async fn start(args: &Args, fresh_state: bool, config_arg: &Option<String>)
         }
     }
 
-    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 let Some(display_thread) = display_thread {
         display_channel.0.send(true).unwrap();
         display_thread.join().unwrap();

linkup-cli/src/commands/stop.rs

@@ -37,7 +37,6 @@ pub fn stop(_args: &Args, clear_env: bool) -> Result<()> {
 
     services::LocalServer::stop();
     services::CloudflareTunnel::stop();
-    services::LocalDnsServer::stop();
 
     println!("Stopped linkup");
 

linkup-cli/src/services/local_server.rs

@@ -50,7 +50,7 @@ impl LocalServer {
         Url::parse("http://localhost:80").expect("linkup url invalid")
     }
 
-    fn start(&self) -> Result<()> {
+    fn start(&self, session_name: String, domains: Vec<String>) -> Result<()> {
         log::debug!("Starting {}", Self::NAME);
 
         let stdout_file = File::create(&self.stdout_file_path)?;
@@ -66,7 +66,10 @@ impl LocalServer {
         command.env("LINKUP_SERVICE_ID", Self::ID);
         command.args([
             "server",
-            "local-worker",
+            "--session-name",
+            &session_name,
+            "--domains",
+            &domains.join(","),
             "--certs-dir",
             linkup_certs_dir_path().to_str().unwrap(),
         ]);
@@ -116,6 +119,9 @@ impl BackgroundService for LocalServer {
     ) -> Result<()> {
         self.notify_update(&status_sender, super::RunStatus::Starting);
 
+        let session_name = state.linkup.session_name.clone();
+        let domains = state.domain_strings();
+
         if self.reachable().await {
             self.notify_update_with_details(
                 &status_sender,
@@ -126,7 +132,7 @@ impl BackgroundService for LocalServer {
             return Ok(());
         }
 
-        if let Err(e) = self.start() {
+        if let Err(e) = self.start(session_name, domains) {
             self.notify_update_with_details(
                 &status_sender,
                 super::RunStatus::Error,

linkup-cli/src/services/mod.rs

@@ -4,10 +4,8 @@ use sysinfo::{ProcessRefreshKind, RefreshKind, System};
 use thiserror::Error;
 
 mod cloudflare_tunnel;
-mod local_dns_server;
 mod local_server;
 
-pub use local_dns_server::LocalDnsServer;
 pub use local_server::LocalServer;
 pub use sysinfo::{Pid, Signal};
 pub use {