Bookmark name as hostname for cli args (#111)

bookmark name as hostname for cli args

src/activity_manager.rs

@@ -28,6 +28,7 @@
 // Deps
 use crate::filetransfer::FileTransferParams;
 use crate::host::{HostError, Localhost};
+use crate::system::bookmarks_client::BookmarksClient;
 use crate::system::config_client::ConfigClient;
 use crate::system::environment;
 use crate::system::theme_provider::ThemeProvider;
@@ -36,6 +37,8 @@ use crate::ui::activities::{
     ExitReason,
 };
 use crate::ui::context::Context;
+use crate::utils::fmt;
+use crate::utils::tty;
 
 // Namespaces
 use std::path::{Path, PathBuf};
@@ -64,7 +67,7 @@ impl ActivityManager {
     pub fn new(local_dir: &Path, ticks: Duration) -> Result<ActivityManager, HostError> {
         // Prepare Context
         // Initialize configuration client
-        let (config_client, error): (ConfigClient, Option<String>) =
+        let (config_client, error_config): (ConfigClient, Option<String>) =
             match Self::init_config_client() {
                 Ok(cli) => (cli, None),
                 Err(err) => {
@@ -72,8 +75,13 @@ impl ActivityManager {
                     (ConfigClient::degraded(), Some(err))
                 }
             };
+        let (bookmarks_client, error_bookmark) = match Self::init_bookmarks_client() {
+            Ok(cli) => (cli, None),
+            Err(err) => (None, Some(err)),
+        };
+        let error = error_config.or(error_bookmark);
         let theme_provider: ThemeProvider = Self::init_theme_provider();
-        let ctx: Context = Context::new(config_client, theme_provider, error);
+        let ctx: Context = Context::new(bookmarks_client, config_client, theme_provider, error);
         Ok(ActivityManager {
             context: Some(ctx),
             local_dir: local_dir.to_path_buf(),
@@ -82,9 +90,54 @@ impl ActivityManager {
     }
 
     /// Set file transfer params
-    pub fn set_filetransfer_params(&mut self, params: FileTransferParams) {
+    pub fn set_filetransfer_params(
+        &mut self,
+        mut params: FileTransferParams,
+        password: Option<&str>,
+    ) -> Result<(), String> {
+        // Set password if provided
+        if params.password_missing() {
+            if let Some(password) = password {
+                params.set_default_secret(password.to_string());
+            } else {
+                match tty::read_secret_from_tty("Password: ") {
+                    Err(err) => return Err(format!("Could not read password: {}", err)),
+                    Ok(Some(secret)) => {
+                        debug!(
+                            "Read password from tty: {}",
+                            fmt::shadow_password(secret.as_str())
+                        );
+                        params.set_default_secret(secret);
+                    }
+                    Ok(None) => {}
+                }
+            }
+        }
         // Put params into the context
         self.context.as_mut().unwrap().set_ftparams(params);
+        Ok(())
+    }
+
+    /// Resolve provided bookmark name and set it as file transfer params.
+    /// Returns error if bookmark is not found
+    pub fn resolve_bookmark_name(
+        &mut self,
+        bookmark_name: &str,
+        password: Option<&str>,
+    ) -> Result<(), String> {
+        if let Some(bookmarks_client) = self.context.as_mut().unwrap().bookmarks_client_mut() {
+            match bookmarks_client.get_bookmark(bookmark_name) {
+                None => Err(format!(
+                    r#"Could not resolve bookmark name: "{}" no such bookmark"#,
+                    bookmark_name
+                )),
+                Some(params) => self.set_filetransfer_params(params, password),
+            }
+        } else {
+            Err(String::from(
+                "Could not resolve bookmark name: bookmarks client not initialized",
+            ))
+        }
     }
 
     ///
@@ -256,6 +309,33 @@ impl ActivityManager {
 
     // -- misc
 
+    fn init_bookmarks_client() -> Result<Option<BookmarksClient>, String> {
+        // Get config dir
+        match environment::init_config_dir() {
+            Ok(path) => {
+                // If some configure client, otherwise do nothing; don't bother users telling them that bookmarks are not supported on their system.
+                if let Some(config_dir_path) = path {
+                    let bookmarks_file: PathBuf =
+                        environment::get_bookmarks_paths(config_dir_path.as_path());
+                    // Initialize client
+                    BookmarksClient::new(bookmarks_file.as_path(), config_dir_path.as_path(), 16)
+                        .map(Option::Some)
+                        .map_err(|e| {
+                            format!(
+                                "Could not initialize bookmarks (at \"{}\", \"{}\"): {}",
+                                bookmarks_file.display(),
+                                config_dir_path.display(),
+                                e
+                            )
+                        })
+                } else {
+                    Ok(None)
+                }
+            }
+            Err(err) => Err(err),
+        }
+    }
+
     /// Initialize configuration client
     fn init_config_client() -> Result<ConfigClient, String> {
         // Get config dir