next tracking PR for version TBD

linkup-cli/src/commands/health.rs

@@ -10,8 +10,8 @@ use std::{
 
 use crate::{
     linkup_dir_path,
-    local_config::LocalState,
-    services::{self, find_service_pid, BackgroundService},
+    services::{self, BackgroundService},
+    state::State,
     Result,
 };
 
@@ -62,7 +62,7 @@ struct Session {
 }
 
 impl Session {
-    fn load(state: Option<&LocalState>) -> Self {
+    fn load(state: Option<&State>) -> Self {
         match state {
             Some(state) => Self {
                 name: Some(state.linkup.session_name.clone()),
@@ -90,23 +90,21 @@ 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<&LocalState>) -> Self {
+    pub fn load(_state: Option<&State>) -> Self {
         let mut managed_pids: Vec<services::Pid> = Vec::with_capacity(4);
 
-        let linkup_server = match find_service_pid(services::LocalServer::ID) {
+        let linkup_server = match services::LocalServer::find_pid() {
             Some(pid) => {
                 managed_pids.push(pid);
 
@@ -116,7 +114,7 @@ impl BackgroundServices {
         };
 
         let cloudflared = if services::is_cloudflared_installed() {
-            match find_service_pid(services::CloudflareTunnel::ID) {
+            match services::CloudflareTunnel::find_pid() {
                 Some(pid) => {
                     managed_pids.push(pid);
 
@@ -128,33 +126,9 @@ impl BackgroundServices {
             BackgroundServiceHealth::NotInstalled
         };
 
-        let dns_server = match find_service_pid(services::LocalDnsServer::ID) {
-            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::local_config::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),
         }
     }
@@ -283,11 +257,11 @@ struct LocalDNS {
 }
 
 impl LocalDNS {
-    fn load(state: Option<&LocalState>) -> Result<Self> {
+    fn load(state: Option<&State>) -> Result<Self> {
         // If there is no state, we cannot know if local-dns is installed since we depend on
         // the domains listed on it.
         let is_installed = state.as_ref().map(|state| {
-            local_dns::is_installed(&crate::local_config::managed_domains(Some(state), &None))
+            local_dns::is_installed(&crate::state::managed_domains(Some(state), &None))
         });
 
         Ok(Self {
@@ -309,7 +283,7 @@ struct Health {
 
 impl Health {
     pub fn load() -> Result<Self> {
-        let state = LocalState::load().ok();
+        let state = State::load().ok();
         let session = Session::load(state.as_ref());
 
         Ok(Self {
@@ -360,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/local.rs

@@ -2,8 +2,8 @@ use anyhow::anyhow;
 use colored::Colorize;
 
 use crate::{
-    local_config::{upload_state, LocalState, ServiceTarget},
-    services::{self, find_service_pid, BackgroundService},
+    services::{self, BackgroundService},
+    state::{upload_state, ServiceTarget, State},
     Result,
 };
 
@@ -25,7 +25,7 @@ pub async fn local(args: &Args) -> Result<()> {
         return Err(anyhow!("No service names provided"));
     }
 
-    if !LocalState::exists() {
+    if !State::exists() {
         println!(
             "{}",
             "Seems like you don't have any state yet to point to local.".yellow()
@@ -35,7 +35,7 @@ pub async fn local(args: &Args) -> Result<()> {
         return Ok(());
     }
 
-    if find_service_pid(services::LocalServer::ID).is_none() {
+    if services::LocalServer::find_pid().is_none() {
         println!(
             "{}",
             "Seems like your local Linkup server is not running. Please run 'linkup start' first."
@@ -45,7 +45,7 @@ pub async fn local(args: &Args) -> Result<()> {
         return Ok(());
     }
 
-    let mut state = LocalState::load()?;
+    let mut state = State::load()?;
 
     if args.all {
         for service in state.services.iter_mut() {
@@ -56,7 +56,7 @@ pub async fn local(args: &Args) -> Result<()> {
             let service = state
                 .services
                 .iter_mut()
-                .find(|s| s.name.as_str() == service_name)
+                .find(|s| s.config.name.as_str() == service_name)
                 .ok_or_else(|| anyhow!("Service with name '{}' does not exist", service_name))?;
 
             service.current = ServiceTarget::Local;

linkup-cli/src/commands/local_dns.rs

@@ -5,7 +5,7 @@ use std::{
 
 use crate::{
     commands, is_sudo, linkup_certs_dir_path,
-    local_config::{self, managed_domains, top_level_domains, LocalState},
+    state::{self, managed_domains, top_level_domains, State},
     sudo_su, Result,
 };
 use anyhow::{anyhow, Context};
@@ -50,7 +50,7 @@ pub async fn install(config_arg: &Option<String>) -> Result<()> {
 
     ensure_resolver_dir()?;
 
-    let domains = managed_domains(LocalState::load().ok().as_ref(), config_arg);
+    let domains = managed_domains(State::load().ok().as_ref(), config_arg);
 
     install_resolvers(&top_level_domains(&domains))?;
 
@@ -76,9 +76,10 @@ pub async fn uninstall(config_arg: &Option<String>) -> Result<()> {
 
     commands::stop(&commands::StopArgs {}, false)?;
 
-    let managed_top_level_domains = local_config::top_level_domains(
-        &local_config::managed_domains(LocalState::load().ok().as_ref(), config_arg),
-    );
+    let managed_top_level_domains = state::top_level_domains(&state::managed_domains(
+        State::load().ok().as_ref(),
+        config_arg,
+    ));
 
     uninstall_resolvers(&managed_top_level_domains)?;
     uninstall_self_signed_certificates(&linkup_certs_dir_path())

linkup-cli/src/commands/preview.rs

@@ -1,10 +1,11 @@
 use crate::commands::status::{format_state_domains, SessionStatus};
-use crate::local_config::{config_path, get_config};
+use crate::state::{config_path, get_config};
 use crate::worker_client::WorkerClient;
 use crate::Result;
 use anyhow::Context;
 use clap::builder::ValueParser;
 use linkup::CreatePreviewRequest;
+use url::Url;
 
 #[derive(clap::Args)]
 pub struct Args {
@@ -14,7 +15,7 @@ pub struct Args {
         required = true,
         num_args = 1..,
     )]
-    services: Vec<(String, String)>,
+    services: Vec<(String, Url)>,
 
     #[arg(long, help = "Print the request body instead of sending it.")]
     print_request: bool,
@@ -24,7 +25,7 @@ pub async fn preview(args: &Args, config: &Option<String>) -> Result<()> {
     let config_path = config_path(config)?;
     let input_config = get_config(&config_path)?;
     let create_preview_request: CreatePreviewRequest =
-        input_config.create_preview_request(&args.services);
+        linkup::create_preview_req_from_config(&input_config, &args.services);
     let url = input_config.linkup.worker_url.clone();
 
     if args.print_request {

linkup-cli/src/commands/remote.rs

@@ -1,6 +1,6 @@
 use crate::{
-    local_config::{upload_state, LocalState, ServiceTarget},
-    services::{self, find_service_pid, BackgroundService},
+    services::{self, BackgroundService},
+    state::{upload_state, ServiceTarget, State},
     Result,
 };
 
@@ -25,7 +25,7 @@ pub async fn remote(args: &Args) -> Result<()> {
         return Err(anyhow!("No service names provided"));
     }
 
-    if !LocalState::exists() {
+    if !State::exists() {
         println!(
             "{}",
             "Seems like you don't have any state yet to point to remote.".yellow()
@@ -35,9 +35,9 @@ pub async fn remote(args: &Args) -> Result<()> {
         return Ok(());
     }
 
-    let mut state = LocalState::load()?;
+    let mut state = State::load()?;
 
-    if find_service_pid(services::LocalServer::ID).is_none() {
+    if services::LocalServer::find_pid().is_none() {
         println!(
             "{}",
             "Seems like your local Linkup server is not running. Please run 'linkup start' first."
@@ -56,7 +56,7 @@ pub async fn remote(args: &Args) -> Result<()> {
             let service = state
                 .services
                 .iter_mut()
-                .find(|s| s.name.as_str() == service_name)
+                .find(|s| s.config.name.as_str() == service_name)
                 .ok_or_else(|| anyhow!("Service with name '{}' does not exist", service_name))?;
 
             service.current = ServiceTarget::Remote;

linkup-cli/src/commands/reset.rs

@@ -1,10 +1,10 @@
-use crate::{commands, local_config::LocalState, Result};
+use crate::{commands, state::State, Result};
 
 #[derive(clap::Args)]
 pub struct Args {}
 
 pub async fn reset(_args: &Args) -> Result<()> {
-    let _ = LocalState::load()?;
+    let _ = State::load()?;
 
     commands::stop(&commands::StopArgs {}, false)?;
     commands::start(&commands::StartArgs { no_tunnel: false }, false, &None).await?;