Application Arguments (#81)

* add support for various restic alike arguments
  - repo, repository-file, password, password-file, password-command
  - only show help or version when specified and do not launch the app

* add "insecure tls" opion for non local repositories

Author: emuell

src-tauri/Cargo.lock

@@ -22,6 +22,7 @@ simplelog = { version = "^0.12" }
 anyhow = { version = "^1.0" }
 which = { version = "^4.0" }
 open = { version = "^5.0" }
+shlex = { version = "^1.2" }
 
 #tauri
 tauri = { version = "^1.5", features = [ "cli", "api-all"] }

src-tauri/Cargo.toml

@@ -1,6 +1,5 @@
-use std::{collections::HashSet, env, fs, path, sync::RwLock};
+use std::{collections::HashSet, fs, path, sync::RwLock};
 
-use anyhow::anyhow;
 use tauri::api::dialog::blocking::{ask, FileDialogBuilder, MessageDialogBuilder};
 
 use crate::restic::*;
@@ -116,119 +115,16 @@ impl SharedAppState {
 
 // -------------------------------------------------------------------------------------------------
 
-struct LocationInfo<'a> {
-    prefix: &'a str,
-    credentials: Vec<&'a str>,
-}
-
-fn location_infos() -> Vec<LocationInfo<'static>> {
-    vec![
-        LocationInfo {
-            prefix: "bs",
-            credentials: vec![],
-        },
-        LocationInfo {
-            prefix: "sftp",
-            credentials: vec![],
-        },
-        LocationInfo {
-            prefix: "rest",
-            credentials: vec![],
-        },
-        LocationInfo {
-            prefix: "rclone",
-            credentials: vec![],
-        },
-        LocationInfo {
-            prefix: "s3",
-            credentials: vec!["AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY"],
-        },
-        LocationInfo {
-            prefix: "b2",
-            credentials: vec!["B2_ACCOUNT_ID", "B2_ACCOUNT_KEY"],
-        },
-        LocationInfo {
-            prefix: "azure",
-            credentials: vec!["AZURE_ACCOUNT_NAME", "AZURE_ACCOUNT_KEY"],
-        },
-    ]
-}
-
-// defaultRepo determines the default restic repository location from the environment.
-fn default_repo() -> anyhow::Result<String> {
-    if let Ok(repository_file) = env::var("RESTIC_REPOSITORY_FILE") {
-        let content = fs::read_to_string(repository_file.clone());
-        if let Ok(content) = content {
-            return Ok(content.trim().replace('\n', ""));
-        } else {
-            return Err(anyhow!("{repository_file} does not exist"));
-        }
-    }
-    if let Ok(repository) = env::var("RESTIC_REPOSITORY") {
-        Ok(repository)
-    } else {
-        Err(anyhow!("No repository set"))
-    }
-}
-
-// defaultRepoPassword determines the default restic repository password from the environment.
-fn default_repo_password() -> anyhow::Result<String> {
-    if let Ok(password_file) = env::var("RESTIC_PASSWORD_FILE") {
-        let content = fs::read_to_string(password_file.clone());
-        if let Ok(content) = content {
-            return Ok(content.trim().replace('\n', ""));
-        } else {
-            return Err(anyhow!("{password_file} does not exist"));
-        }
-    }
-    if let Ok(repository) = env::var("RESTIC_PASSWORD") {
-        Ok(repository)
-    } else {
-        Err(anyhow!("No repository password set"))
-    }
+#[tauri::command]
+pub fn open_file_or_url(path: String) -> Result<(), String> {
+    open::that(path).map_err(|err| err.to_string())
 }
 
 // -------------------------------------------------------------------------------------------------
 
 #[tauri::command]
-pub fn default_repo_location() -> Result<Location, String> {
-    // read default location from env
-    let mut location = Location {
-        path: default_repo().unwrap_or_default(),
-        password: default_repo_password().unwrap_or_default(),
-        credentials: vec![],
-        prefix: "".to_string(),
-    };
-    if location.path.is_empty() {
-        // skip reading other location info when no repo is present
-        return Ok(location);
-    }
-    location.prefix = "".to_string();
-    for location_info in location_infos() {
-        if location
-            .path
-            .starts_with(&(location_info.prefix.to_string() + ":"))
-        {
-            location.prefix = location_info.prefix.to_string();
-            location.path =
-                location
-                    .path
-                    .replacen(&(location_info.prefix.to_string() + ":"), "", 1);
-            for credential in location_info.credentials {
-                location.credentials.push(EnvValue {
-                    name: credential.to_string(),
-                    value: env::var(credential).unwrap_or_default(),
-                })
-            }
-            break;
-        }
-    }
-    Ok(location)
-}
-
-#[tauri::command]
-pub fn open_file_or_url(path: String) -> Result<(), String> {
-    open::that(path).map_err(|err| err.to_string())
+pub fn default_repo_location(app_state: tauri::State<SharedAppState>) -> Result<Location, String> {
+    Ok(app_state.get()?.location)
 }
 
 // -------------------------------------------------------------------------------------------------

src-tauri/src/app.rs

@@ -1,7 +1,7 @@
 // Prevents additional console window on Windows in release, DO NOT REMOVE!!
 #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
 
-use std::{env, fs, path, process};
+use std::{collections::HashMap, env, fs, path, process};
 
 use anyhow::anyhow;
 use simplelog::*;
@@ -52,13 +52,14 @@ fn initialize_app(app: &mut tauri::App) -> Result<(), Box<dyn std::error::Error>
 
     // get restic from args or find restic in path
     let mut restic_path = "".to_owned();
-    if let Ok(matches) = app.get_cli_matches() {
-        if let Some(arg) = matches.args.get("restic") {
+    match app.get_cli_matches() {
+        Ok(matches) => if let Some(arg) = matches.args.get("restic") {
             restic_path = arg.value.as_str().unwrap_or("").to_string();
             if !restic_path.is_empty() {
                 log::info!("Got restic as arg {}", restic_path);
             }
-        }
+        },
+        Err(err) => log::error!("{}", err.to_string())
     }
     if restic_path.is_empty() {
         if let Ok(restic) = which("restic") {
@@ -84,6 +85,23 @@ fn initialize_app(app: &mut tauri::App) -> Result<(), Box<dyn std::error::Error>
         }
     }
 
+    // get default restic location from args or env
+    let mut location;
+    if let Ok(matches) = app.get_cli_matches() {
+        location = Location::new_from_args(
+            matches
+                .args
+                .into_iter()
+                .map(|(k, v)| (k, v.value.as_str().unwrap_or("").to_string()))
+                .collect::<HashMap<_, _>>(),
+        );
+        if location.path.is_empty() {
+            location = Location::new_from_env();
+        }
+    } else {
+        location = Location::new_from_env();
+    }
+
     // create temp dir for previews
     let mut temp_dir = path::Path::new(&env::temp_dir())
         .join(app.package_info().name.clone() + "_" + &process::id().to_string());
@@ -97,7 +115,7 @@ fn initialize_app(app: &mut tauri::App) -> Result<(), Box<dyn std::error::Error>
     // create new app state
     app.manage(app::SharedAppState::new(app::AppState::new(
         ResticCommand::new(&restic_path),
-        Location::default(),
+        location,
         temp_dir.to_string_lossy().as_ref(),
     )));
 
@@ -129,7 +147,7 @@ fn show_app(app_window: tauri::Window) -> Result<(), String> {
 
 fn main() {
     // create new app
-    tauri::Builder::default()
+    let app = tauri::Builder::default()
         .setup(initialize_app)
         .on_window_event(|event| {
             if let tauri::WindowEvent::Destroyed = event.event() {
@@ -157,6 +175,28 @@ fn main() {
             app::dump_file_to_temp,
             app::restore_file
         ])
-        .run(tauri::generate_context!())
+        .build(tauri::generate_context!())
         .expect("error while running tauri application");
+
+    // show argument help / version only
+    let mut do_run = true;
+    if let Ok(matches) = app.get_cli_matches() {
+        if let Some(arg) = matches.args.get("help") {
+            print!("{}", arg.value.as_str().unwrap());
+            do_run = false;
+        } else if matches.args.get("version").is_some() {
+            let package = app.config().package.clone();
+            println!(
+                "{} v{}",
+                package.product_name.unwrap_or("Restic Browser".to_string()),
+                package.version.unwrap_or("[Unknown version]".to_string())
+            );
+            do_run = false;
+        }
+    }
+
+    // run the app
+    if do_run {
+        app.run(|_, _| {});
+    }
 }