refactor: simplify State and Config entities

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},
+    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()),
@@ -103,7 +103,7 @@ pub enum BackgroundServiceHealth {
 }
 
 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) {
@@ -138,10 +138,7 @@ impl BackgroundServices {
                 // 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,
-                    )) {
+                    if local_dns::is_installed(&crate::state::managed_domains(Some(state), &None)) {
                         BackgroundServiceHealth::Stopped
                     } else {
                         BackgroundServiceHealth::NotInstalled
@@ -283,11 +280,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 +306,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 {

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},
+    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()
@@ -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},
+    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,7 +35,7 @@ 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() {
         println!(
@@ -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?;

linkup-cli/src/commands/start.rs

@@ -15,10 +15,10 @@ use crossterm::{cursor, ExecutableCommand};
 use crate::{
     commands::status::{format_state_domains, SessionStatus},
     env_files::write_to_env_file,
-    local_config::{config_path, config_to_state, get_config},
     services::{self, BackgroundService},
+    state::{config_path, config_to_state, get_config},
 };
-use crate::{local_config::LocalState, Result};
+use crate::{state::State, Result};
 
 const LOADING_CHARS: [char; 10] = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
 
@@ -39,7 +39,7 @@ pub async fn start(args: &Args, fresh_state: bool, config_arg: &Option<String>)
 
         state
     } else {
-        LocalState::load()?
+        State::load()?
     };
 
     let status_update_channel = sync::mpsc::channel::<services::RunUpdate>();
@@ -217,18 +217,18 @@ fn spawn_display_thread(
     })
 }
 
-fn set_linkup_env(state: LocalState) -> Result<()> {
+fn set_linkup_env(state: State) -> Result<()> {
     // Set env vars to linkup
     for service in &state.services {
-        if let Some(d) = &service.directory {
+        if let Some(d) = &service.config.directory {
             set_service_env(d.clone(), state.linkup.config_path.clone())?
         }
     }
     Ok(())
 }
 
-fn load_and_save_state(config_arg: &Option<String>, no_tunnel: bool) -> Result<LocalState> {
-    let previous_state = LocalState::load();
+fn load_and_save_state(config_arg: &Option<String>, no_tunnel: bool) -> Result<State> {
+    let previous_state = State::load();
     let config_path = config_path(config_arg)?;
     let input_config = get_config(&config_path)?;