feat: add setup

Signed-off-by: Oskar Manhart <[email protected]>

Author: oskardotglobal

Cargo.lock

@@ -48,9 +48,10 @@ fn main() -> Result<()> {
         .with_env_filter(EnvFilter::from_default_env())
         .init();
 
-    let config = Config::load()?;
+    let config_lock = Config::try_get_lock()?;
+    let config = config_lock.read();
 
-    let client = Freerdp::new(config);
+    let client = Freerdp::new();
     let backend = config.get_backend();
 
     client.check_depends()?;
@@ -61,7 +62,20 @@ fn main() -> Result<()> {
     match cli.clone().get_matches().subcommand() {
         Some(("setup", _)) => {
             info!("Running setup");
-            todo!()
+
+            match inquire::MultiSelect::new("Select apps to link", config.get_available_apps()?)
+                .prompt_skippable()
+                .map_err(|e| winapps::Error::Command {
+                    message: "Failed to display selection dialog".into(),
+                    source: e.into(),
+                })? {
+                Some(apps) => apps
+                    .into_iter()
+                    .try_for_each(|app| app.link(&mut config_lock.write(), "".into()))?,
+                None => info!("No apps selected, skipping setup..."),
+            };
+
+            Ok(())
         }
 
         Some(("connect", _)) => {

winapps-cli/src/main.rs

@@ -17,3 +17,4 @@ thiserror = "2.0.9"
 enum_dispatch = "0.3.13"
 base64 = "0.22.1"
 regex = { version = "1.11.2", features = [] }
+parking_lot = "0.12.5"

winapps/Cargo.toml

@@ -1,10 +1,11 @@
 use crate::{command::command, ensure, Backend, Config, Error, Result};
+use parking_lot::RwLock;
 use std::net::{IpAddr, Ipv4Addr};
 use tracing::debug;
 
 #[derive(Debug, Clone)]
 pub struct Container {
-    config: &'static Config,
+    config: &'static RwLock<Config>,
 }
 
 impl Container {
@@ -13,29 +14,32 @@ impl Container {
     const DEFAULT_COMMAND: &'static str = "docker";
     const PODMAN_COMMAND: &'static str = "podman";
 
-    pub(crate) fn new(config: &'static Config) -> Self {
-        Self { config }
+    pub(crate) fn new() -> Self {
+        Self {
+            config: Config::get_lock(),
+        }
     }
 }
 
 impl Backend for Container {
     fn check_depends(&self) -> Result<()> {
-        assert!(self.config.container.enable);
+        let config = self.config.read();
+        assert!(config.container.enable);
 
         ensure!(
-            !self.config.container.container_name.is_empty(),
+            !config.container.container_name.is_empty(),
             Error::Config("Container name shouldn't be empty")
         );
 
-        let command = if self.config.container.enable_podman {
+        let command = if config.container.enable_podman {
             Self::PODMAN_COMMAND
         } else {
             Self::DEFAULT_COMMAND
         };
 
         let state = command!(
             r#"{command} ps --all --filter name={} --format {{{{.State}}}}"#,
-            self.config.container.container_name
+            config.container.container_name
         )?
         .with_err("Could not get container status")
         .wait_with_output()?;

winapps/src/backend/container.rs

@@ -1,38 +1,45 @@
+use parking_lot::RwLock;
 use std::{net::IpAddr, str::FromStr};
 
 use crate::{ensure, Backend, Config, Error, Result};
 
 #[derive(Debug, Clone)]
 pub struct Manual {
-    config: &'static Config,
+    config: &'static RwLock<Config>,
 }
 
 impl Manual {
-    pub(crate) fn new(config: &'static Config) -> Self {
-        Self { config }
+    pub(crate) fn new() -> Self {
+        Self {
+            config: Config::get_lock(),
+        }
     }
 }
 
 impl Backend for Manual {
     fn check_depends(&self) -> Result<()> {
-        assert!(self.config.manual.enable);
+        let config = self.config.read();
+
+        assert!(config.manual.enable);
         ensure!(
-            !self.config.manual.host.is_empty(),
+            !config.manual.host.is_empty(),
             Error::Config("Host shouldn't be empty")
         );
 
         ensure!(
-            IpAddr::from_str(&self.config.manual.host).is_ok(),
+            IpAddr::from_str(&config.manual.host).is_ok(),
             Error::Config("manual.host is not a valid IP address")
         );
 
         Ok(())
     }
 
     fn get_host(&self) -> IpAddr {
+        let config = self.config.read();
+
         // SAFETY: When the config is read, we check that this is a valid IP
         // We assume that the program will never write this field,
         // so it should always be valid at this point
-        IpAddr::from_str(&self.config.manual.host).unwrap()
+        IpAddr::from_str(&config.manual.host).unwrap()
     }
 }

winapps/src/backend/manual.rs

@@ -5,7 +5,7 @@ use enum_dispatch::enum_dispatch;
 use crate::{
     backend::{container::Container, manual::Manual},
     command::Command,
-    config::App,
+    config::{App, AppKind::Detected},
     Config, Result,
 };
 
@@ -27,27 +27,26 @@ pub enum Backends {
 }
 
 impl Config {
-    pub fn get_backend(&'static self) -> &'static Backends {
+    pub fn get_backend(&self) -> &Backends {
         self.backend.get_or_init(|| {
             match (
                 self.libvirt.enable,
                 self.container.enable,
                 self.manual.enable,
             ) {
                 (true, _, _) => todo!(),
-                (_, true, _) => Container::new(self).into(),
-                (_, _, true) => Manual::new(self).into(),
+                (_, true, _) => Container::new().into(),
+                (_, _, true) => Manual::new().into(),
                 _ => unreachable!(),
             }
         })
     }
 
-    pub fn get_host(&'static self) -> IpAddr {
+    pub fn get_host(&self) -> IpAddr {
         self.get_backend().get_host()
     }
 
-    #[allow(dead_code)]
-    fn get_installed_apps(&'static self) -> Result<Vec<App>> {
+    pub fn get_available_apps(&self) -> Result<Vec<App>> {
         let apps = Command::new("C:\\ExtractPrograms.ps1")
             .into_remote(self)
             .wait_with_output()?
@@ -60,8 +59,7 @@ impl Config {
                         id: id.to_string(),
                         name: name.to_string(),
                         win_exec: path.to_string(),
-                        icon: Some(icon.to_string()),
-                        icon_path: None,
+                        kind: Detected(icon.to_string()),
                     }),
                     _ => None,
                 }

winapps/src/backend/mod.rs

@@ -51,16 +51,16 @@ impl FromStr for Command {
 }
 
 impl Command {
-    pub fn new(exec: &'static str) -> Self {
+    pub fn new<T: Into<String>>(exec: T) -> Self {
         Self {
-            exec: exec.to_string(),
+            exec: exec.into(),
             args: Vec::new(),
             error_message: String::from("Error running child command"),
             loud: false,
         }
     }
 
-    pub fn into_remote(mut self, config: &'static Config) -> Self {
+    pub fn into_remote(mut self, config: &Config) -> Self {
         let prev = format!("{} {}", self.exec, self.args.join(" "));
 
         self.exec = "sshpass".to_string();

winapps/src/command.rs

@@ -1,52 +1,64 @@
 use crate::{
-    config::App,
+    config::{App, AppKind},
     dirs::{desktop_dir, icons_dir},
     Config, Result,
 };
 use base64::{prelude::BASE64_STANDARD, Engine};
-use std::fs::write;
+use std::{fmt::Display, fs::write};
 
 impl PartialEq for App {
     fn eq(&self, other: &Self) -> bool {
         self.id == other.id
     }
 }
 
+impl Display for App {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_fmt(format_args!("{} ({})", self.name, self.win_exec))
+    }
+}
+
 impl App {
-    /// Panics: If `self.icon_path` is `None`
-    /// Make sure to write the icon to a file by now
-    /// and populate `icon_path`
-    /// This should be normally done by now
-    fn as_desktop_file(&self, exec: String) -> String {
-        format!(
-            "[Desktop Entry]
+    fn try_as_existing(&mut self) -> Result<&mut Self> {
+        match self.kind.clone() {
+            AppKind::Detected(base64) => {
+                let path = icons_dir()?.join(format!("{}.png", self.id));
+                write(path.clone(), BASE64_STANDARD.decode(base64)?)?;
+
+                self.kind = AppKind::Existing(path);
+
+                Ok(self)
+            }
+            AppKind::Existing(_) => Ok(self),
+        }
+    }
+
+    fn try_as_desktop_file(&mut self, exec: String) -> Result<String> {
+        match &self.kind {
+            AppKind::Detected(_) => self.try_as_existing()?.try_as_desktop_file(exec),
+            AppKind::Existing(path) => Ok(format!(
+                "[Desktop Entry]
 Name={}
 Exec={exec}
 Terminal=false
 Type=Application
 Icon={}
 StartupWMClass={}
 Comment={}",
-            self.name,
-            self.icon_path.clone().unwrap(),
-            self.id,
-            self.name
-        )
+                self.name,
+                path.to_string_lossy(),
+                self.id,
+                self.name
+            )),
+        }
     }
 
-    /// Panics: If `self.icon` is `None` and `write_icon` is `true` OR if `self.icon_path` is `None` and `write_icon` is `false` (or if both are `None`)
-    /// At this point in the program, that shouldn't normally be the case
-    pub fn link(self, config: &mut Config, exec: String, write_icon: bool) -> Result<()> {
-        if write_icon {
-            write(
-                icons_dir()?.join(format!("{}.png", self.id)),
-                BASE64_STANDARD.decode(self.icon.clone().unwrap())?,
-            )?;
-        }
+    pub fn link(mut self, config: &mut Config, exec: String) -> Result<()> {
+        self.try_as_existing()?;
 
         write(
             desktop_dir()?.join(format!("{}.desktop", self.id)),
-            self.as_desktop_file(exec),
+            self.try_as_desktop_file(exec)?,
         )?;
 
         if !config.linked_apps.contains(&self) {