EIM-117 added copying of openocd rules on linux

Author: Hahihula

src-tauri/src/lib/mod.rs

@@ -8,6 +8,7 @@ use reqwest::Client;
 #[cfg(feature = "userustpython")]
 use rustpython_vm::literal::char;
 use sha2::{Digest, Sha256};
+use system_dependencies::copy_openocd_rules;
 use std::fs::metadata;
 use std::io::BufReader;
 use tar::Archive;
@@ -1494,6 +1495,11 @@ pub fn single_version_post_install(
                 export_paths,
                 env_vars,
             );
+            // copy openocd rules (it's noop on macOs)
+            match copy_openocd_rules(tool_install_directory) {
+                Ok(_) => info!("OpenOCD rules copied successfully"),
+                Err(err) => error!("Failed to copy OpenOCD rules: {:?}", err),
+            }
         }
     }
 }

src-tauri/src/lib/system_dependencies.rs

@@ -1,8 +1,9 @@
-use std::env;
+use std::{env, fs};
+use anyhow::{anyhow, Result, Context};
 
 use log::{debug, trace, warn};
 
-use crate::command_executor;
+use crate::{command_executor, utils::find_by_name_and_extension};
 
 /// Determines the package manager installed on the system.
 ///
@@ -608,3 +609,47 @@ fn add_to_path(new_path: &str) -> Result<String, std::io::Error> {
 
     Ok(new_path_string)
 }
+
+/// Copies the 60-openocd.rules file to /etc/udev/rules.d/ on Linux.
+///
+/// This function checks if the rules file already exists. If not, it attempts
+/// to find it within the provided `tools_path` and copy it.
+///
+/// # Arguments
+/// * `tools_path` - The path where tool-related files might be located,
+///                  including the openocd rules file.
+///
+/// # Returns
+/// A `Result` indicating success (`Ok(())`) or an `anyhow::Error` if
+/// an error occurs during file operations or if the file is not found.
+pub fn copy_openocd_rules(tools_path: &str) -> Result<()> {
+  let openocd_rules_path = match std::env::consts::OS {
+    "linux" => "/etc/udev/rules.d/60-openocd.rules",
+    _ => return Ok(()),
+  };
+  let openocd_rules_path = std::path::Path::new(openocd_rules_path);
+  if openocd_rules_path.exists() {
+    debug!("openocd rules file already exists");
+    return Ok(());
+  }
+
+  let tools_path = std::path::Path::new(tools_path);
+
+  let found_files = find_by_name_and_extension(tools_path, "60-openocd", "rules");
+
+  let openocd_rules_source = found_files.first().ok_or_else(|| {
+    anyhow!(
+      "60-openocd.rules file not found in {}",
+      tools_path.display()
+    )
+  })?;
+  fs::copy(openocd_rules_source, openocd_rules_path).with_context(|| {
+    format!(
+      "Failed to copy {} to {}",
+      openocd_rules_source,
+      openocd_rules_path.display()
+    )
+  })?;
+
+  Ok(())
+}

src-tauri/src/lib/utils.rs

@@ -89,6 +89,46 @@ pub fn find_directories_by_name(path: &Path, name: &str) -> Vec<String> {
     filter_directories(filter_subpaths(search))
 }
 
+/// Searches for files within a specified directory that match a given name and extension.
+///
+/// This function constructs a search query using `SearchBuilder` to find files.
+/// The search is strict, case-insensitive, includes hidden files, and looks for
+/// an exact match for the file name and extension.
+///
+/// # Arguments
+///
+/// * `path` - A reference to a `Path` indicating the directory where the search should begin.
+/// * `name` - A string slice representing the exact name of the file to search for (without the extension).
+/// * `extension` - A string slice representing the exact extension of the file to search for (e.g., "txt", "rs").
+///
+/// # Returns
+///
+/// A `Vec<String>` containing the paths of all files found that match the criteria.
+/// The paths are returned as strings. If no files are found, an empty vector is returned.
+///
+/// # Examples
+///
+/// ```no_run
+/// use std::path::Path;
+///
+/// let search_path = Path::new("./my_directory");
+/// let found_files = find_by_name_and_extension(search_path, "document", "pdf");
+/// for file in found_files {
+///     println!("Found: {}", file);
+/// }
+/// ```
+pub fn find_by_name_and_extension(path: &Path, name: &str, extension: &str) -> Vec<String> {
+  SearchBuilder::default()
+    .location(path)
+    .search_input(name)
+    .ext(extension)
+    .strict()
+    .ignore_case()
+    .hidden()
+    .build()
+    .collect()
+}
+
 /// Checks if the given path is a valid ESP-IDF directory.
 ///
 /// # Purpose