[rust] Allow to change default folder for Selenium Manager cache (#11688

)

rust/README.md

@@ -47,6 +47,8 @@ Options:
           Driver TTL (time-to-live) [default: 3600]
       --browser-ttl <BROWSER_TTL>
           Browser TTL (time-to-live) [default: 3600]
+      --cache-path <CACHE_PATH>
+          Local folder used to store downloaded assets (drivers and browsers), local metadata, and configuration file [default: ~/.cache/selenium]
       --clear-cache
           Clear cache folder (~/.cache/selenium)
       --clear-metadata

rust/src/chrome.rs

@@ -26,9 +26,7 @@ use std::path::PathBuf;
 use crate::config::ARCH::{ARM64, X32};
 use crate::config::OS::{LINUX, MACOS, WINDOWS};
 use crate::downloads::{parse_json_from_url, read_version_from_link};
-use crate::files::{
-    compose_driver_path_in_cache, get_cache_folder, path_buf_to_string, BrowserPath,
-};
+use crate::files::{compose_driver_path_in_cache, path_buf_to_string, BrowserPath};
 use crate::logger::Logger;
 use crate::metadata::{
     create_driver_metadata, get_driver_version_from_metadata, get_metadata, write_metadata,
@@ -315,7 +313,7 @@ impl ChromeManager {
     }
 
     fn get_browser_path_in_cache(&self) -> PathBuf {
-        get_cache_folder()
+        self.get_cache_path()
             .join(self.get_browser_name())
             .join(self.get_platform_label())
             .join(self.get_browser_version())
@@ -402,7 +400,7 @@ impl SeleniumManager for ChromeManager {
     fn request_driver_version(&mut self) -> Result<String, Box<dyn Error>> {
         let major_browser_version_binding = self.get_major_browser_version();
         let major_browser_version = major_browser_version_binding.as_str();
-        let mut metadata = get_metadata(self.get_logger());
+        let mut metadata = get_metadata(self.get_logger(), self.get_cache_path());
 
         match get_driver_version_from_metadata(
             &metadata.drivers,
@@ -447,7 +445,7 @@ impl SeleniumManager for ChromeManager {
                         &driver_version,
                         driver_ttl,
                     ));
-                    write_metadata(&metadata, self.get_logger());
+                    write_metadata(&metadata, self.get_logger(), self.get_cache_path());
                 }
                 Ok(driver_version)
             }
@@ -458,7 +456,7 @@ impl SeleniumManager for ChromeManager {
         let browser_name = self.browser_name;
         let browser_version;
         let major_browser_version = self.get_major_browser_version();
-        let mut metadata = get_metadata(self.get_logger());
+        let mut metadata = get_metadata(self.get_logger(), self.get_cache_path());
 
         // First, browser version is checked in the local metadata
         match get_browser_version_from_metadata(
@@ -486,7 +484,7 @@ impl SeleniumManager for ChromeManager {
                         &browser_version,
                         browser_ttl,
                     ));
-                    write_metadata(&metadata, self.get_logger());
+                    write_metadata(&metadata, self.get_logger(), self.get_cache_path());
                 }
             }
         }
@@ -540,7 +538,13 @@ impl SeleniumManager for ChromeManager {
         let driver_version = self.get_driver_version();
         let os = self.get_os();
         let arch_folder = self.get_platform_label();
-        compose_driver_path_in_cache(self.driver_name, os, arch_folder, driver_version)
+        compose_driver_path_in_cache(
+            self.get_cache_path(),
+            self.driver_name,
+            os,
+            arch_folder,
+            driver_version,
+        )
     }
 
     fn get_config(&self) -> &ManagerConfig {
@@ -566,7 +570,7 @@ impl SeleniumManager for ChromeManager {
     fn download_browser(&mut self) -> Result<Option<PathBuf>, Box<dyn Error>> {
         let browser_version;
         let browser_name = self.browser_name;
-        let mut metadata = get_metadata(self.get_logger());
+        let mut metadata = get_metadata(self.get_logger(), self.get_cache_path());
         let major_browser_version = self.get_major_browser_version();
         let major_browser_version_int = major_browser_version.parse::<i32>().unwrap_or_default();
 
@@ -618,7 +622,7 @@ impl SeleniumManager for ChromeManager {
                         &browser_version,
                         browser_ttl,
                     ));
-                    write_metadata(&metadata, self.get_logger());
+                    write_metadata(&metadata, self.get_logger(), self.get_cache_path());
                 }
             }
         }

rust/src/config.rs

@@ -16,22 +16,30 @@
 // under the License.
 
 use crate::config::OS::{LINUX, MACOS, WINDOWS};
-use crate::files::get_cache_folder;
 use crate::shell::run_shell_command_by_os;
-use crate::{format_one_arg, Command, REQUEST_TIMEOUT_SEC, UNAME_COMMAND};
+use crate::{
+    default_cache_folder, format_one_arg, path_buf_to_string, Command, REQUEST_TIMEOUT_SEC,
+    UNAME_COMMAND,
+};
 use crate::{ARCH_AMD64, ARCH_ARM64, ARCH_X86, TTL_BROWSERS_SEC, TTL_DRIVERS_SEC, WMIC_COMMAND_OS};
+use std::cell::RefCell;
 use std::env;
 use std::env::consts::OS;
 use std::error::Error;
 use std::fs::read_to_string;
+use std::path::Path;
 use toml::Table;
 
+thread_local!(static CACHE_PATH: RefCell<String> = RefCell::new(path_buf_to_string(default_cache_folder())));
+
 pub const CONFIG_FILE: &str = "selenium-manager-config.toml";
 pub const ENV_PREFIX: &str = "SE_";
 pub const VERSION_PREFIX: &str = "-version";
 pub const PATH_PREFIX: &str = "-path";
+pub const CACHE_PATH_KEY: &str = "cache-path";
 
 pub struct ManagerConfig {
+    pub cache_path: String,
     pub browser_version: String,
     pub driver_version: String,
     pub browser_path: String,
@@ -47,6 +55,8 @@ pub struct ManagerConfig {
 
 impl ManagerConfig {
     pub fn default(browser_name: &str, driver_name: &str) -> ManagerConfig {
+        let cache_path = StringKey(vec![CACHE_PATH_KEY], &read_cache_path()).get_value();
+
         let self_os = OS;
         let self_arch = if WINDOWS.is(self_os) {
             let wmic_command = Command::new_single(WMIC_COMMAND_OS.to_string());
@@ -77,12 +87,12 @@ impl ManagerConfig {
         let browser_path_label = concat(browser_name, PATH_PREFIX);
 
         ManagerConfig {
-            browser_version: StringKey(vec!["browser-version", browser_version_label.as_str()], "")
+            cache_path,
+            browser_version: StringKey(vec!["browser-version", &browser_version_label], "")
                 .get_value(),
-            driver_version: StringKey(vec!["driver-version", driver_version_label.as_str()], "")
-                .get_value(),
-            browser_path: StringKey(vec!["browser-path", browser_path_label.as_str()], "")
+            driver_version: StringKey(vec!["driver-version", &driver_version_label], "")
                 .get_value(),
+            browser_path: StringKey(vec!["browser-path", &browser_path_label], "").get_value(),
             os: StringKey(vec!["os"], self_os).get_value(),
             arch: StringKey(vec!["arch"], self_arch.as_str()).get_value(),
             proxy: StringKey(vec!["proxy"], "").get_value(),
@@ -168,6 +178,9 @@ impl StringKey<'_> {
                 result = env::var(get_env_name(key)).unwrap_or_default()
             }
             if !result.is_empty() {
+                if key.eq(CACHE_PATH_KEY) {
+                    write_cache_path(result.clone());
+                }
                 return result;
             }
         }
@@ -215,7 +228,8 @@ fn get_env_name(suffix: &str) -> String {
 }
 
 fn get_config() -> Result<Table, Box<dyn Error>> {
-    let config_path = get_cache_folder().join(CONFIG_FILE);
+    let cache_path = read_cache_path();
+    let config_path = Path::new(&cache_path).to_path_buf().join(CONFIG_FILE);
     Ok(read_to_string(config_path)?.parse()?)
 }
 
@@ -224,3 +238,20 @@ fn concat(prefix: &str, suffix: &str) -> String {
     version_label.push_str(suffix);
     version_label
 }
+
+fn write_cache_path(cache_path: String) {
+    CACHE_PATH.with(|value| {
+        *value.borrow_mut() = cache_path;
+    });
+}
+
+fn read_cache_path() -> String {
+    let mut cache_path: String = path_buf_to_string(default_cache_folder());
+    CACHE_PATH.with(|value| {
+        let path: String = (&*value.borrow().to_string()).into();
+        if !path.is_empty() {
+            cache_path = path;
+        }
+    });
+    cache_path
+}

rust/src/edge.rs

@@ -134,7 +134,7 @@ impl SeleniumManager for EdgeManager {
 
     fn request_driver_version(&mut self) -> Result<String, Box<dyn Error>> {
         let mut major_browser_version = self.get_major_browser_version();
-        let mut metadata = get_metadata(self.get_logger());
+        let mut metadata = get_metadata(self.get_logger(), self.get_cache_path());
 
         match get_driver_version_from_metadata(
             &metadata.drivers,
@@ -191,7 +191,7 @@ impl SeleniumManager for EdgeManager {
                         &driver_version,
                         driver_ttl,
                     ));
-                    write_metadata(&metadata, self.get_logger());
+                    write_metadata(&metadata, self.get_logger(), self.get_cache_path());
                 }
 
                 Ok(driver_version)
@@ -251,7 +251,13 @@ impl SeleniumManager for EdgeManager {
         } else {
             "linux64"
         };
-        compose_driver_path_in_cache(self.driver_name, os, arch_folder, driver_version)
+        compose_driver_path_in_cache(
+            self.get_cache_path(),
+            self.driver_name,
+            os,
+            arch_folder,
+            driver_version,
+        )
     }
 
     fn get_config(&self) -> &ManagerConfig {

rust/src/files.rs

@@ -186,27 +186,22 @@ pub fn get_raw_file_name(file_name: &str) -> &str {
     raw_file_name
 }
 
-pub fn compose_cache_folder() -> PathBuf {
+pub fn default_cache_folder() -> PathBuf {
     if let Some(base_dirs) = BaseDirs::new() {
         return Path::new(base_dirs.home_dir())
             .join(String::from(CACHE_FOLDER).replace('/', std::path::MAIN_SEPARATOR_STR));
     }
     PathBuf::new()
 }
 
-pub fn get_cache_folder() -> PathBuf {
-    let cache_path = compose_cache_folder();
-    create_path_if_not_exists(&cache_path);
-    cache_path
-}
-
 pub fn compose_driver_path_in_cache(
+    driver_path: PathBuf,
     driver_name: &str,
     os: &str,
     arch_folder: &str,
     driver_version: &str,
 ) -> PathBuf {
-    get_cache_folder()
+    driver_path
         .join(driver_name)
         .join(arch_folder)
         .join(driver_version)

rust/src/firefox.rs

@@ -132,7 +132,7 @@ impl SeleniumManager for FirefoxManager {
     fn request_driver_version(&mut self) -> Result<String, Box<dyn Error>> {
         let major_browser_version_binding = self.get_major_browser_version();
         let major_browser_version = major_browser_version_binding.as_str();
-        let mut metadata = get_metadata(self.get_logger());
+        let mut metadata = get_metadata(self.get_logger(), self.get_cache_path());
 
         match get_driver_version_from_metadata(
             &metadata.drivers,
@@ -161,7 +161,7 @@ impl SeleniumManager for FirefoxManager {
                         &driver_version,
                         driver_ttl,
                     ));
-                    write_metadata(&metadata, self.get_logger());
+                    write_metadata(&metadata, self.get_logger(), self.get_cache_path());
                 }
 
                 Ok(driver_version)
@@ -241,7 +241,13 @@ impl SeleniumManager for FirefoxManager {
         } else {
             "linux64"
         };
-        compose_driver_path_in_cache(self.driver_name, os, arch_folder, driver_version)
+        compose_driver_path_in_cache(
+            self.get_cache_path(),
+            self.driver_name,
+            os,
+            arch_folder,
+            driver_version,
+        )
     }
 
     fn get_config(&self) -> &ManagerConfig {

rust/src/grid.rs

@@ -21,7 +21,7 @@ use std::collections::HashMap;
 use std::error::Error;
 use std::path::PathBuf;
 
-use crate::files::{get_cache_folder, BrowserPath};
+use crate::files::BrowserPath;
 
 use crate::downloads::parse_json_from_url;
 use crate::{
@@ -97,7 +97,7 @@ impl SeleniumManager for GridManager {
     fn request_driver_version(&mut self) -> Result<String, Box<dyn Error>> {
         let major_browser_version_binding = self.get_major_browser_version();
         let major_browser_version = major_browser_version_binding.as_str();
-        let mut metadata = get_metadata(self.get_logger());
+        let mut metadata = get_metadata(self.get_logger(), self.get_cache_path());
 
         match get_driver_version_from_metadata(
             &metadata.drivers,
@@ -156,7 +156,7 @@ impl SeleniumManager for GridManager {
                             &driver_version,
                             driver_ttl,
                         ));
-                        write_metadata(&metadata, self.get_logger());
+                        write_metadata(&metadata, self.get_logger(), self.get_cache_path());
                     }
 
                     Ok(driver_version)
@@ -191,7 +191,7 @@ impl SeleniumManager for GridManager {
         let browser_name = self.get_browser_name();
         let driver_name = self.get_driver_name();
         let driver_version = self.get_driver_version();
-        get_cache_folder()
+        self.get_cache_path()
             .join(browser_name)
             .join(driver_version)
             .join(format!("{driver_name}-{driver_version}.{GRID_EXTENSION}"))

rust/src/iexplorer.rs

@@ -109,7 +109,7 @@ impl SeleniumManager for IExplorerManager {
     fn request_driver_version(&mut self) -> Result<String, Box<dyn Error>> {
         let major_browser_version_binding = self.get_major_browser_version();
         let major_browser_version = major_browser_version_binding.as_str();
-        let mut metadata = get_metadata(self.get_logger());
+        let mut metadata = get_metadata(self.get_logger(), self.get_cache_path());
 
         match get_driver_version_from_metadata(
             &metadata.drivers,
@@ -164,7 +164,7 @@ impl SeleniumManager for IExplorerManager {
                             &driver_version,
                             driver_ttl,
                         ));
-                        write_metadata(&metadata, self.get_logger());
+                        write_metadata(&metadata, self.get_logger(), self.get_cache_path());
                     }
 
                     Ok(driver_version)
@@ -201,7 +201,13 @@ impl SeleniumManager for IExplorerManager {
             .unwrap_or_default()
             .parse::<i32>()
             .unwrap_or_default();
-        compose_driver_path_in_cache(self.driver_name, "Windows", "win32", driver_version)
+        compose_driver_path_in_cache(
+            self.get_cache_path(),
+            self.driver_name,
+            "Windows",
+            "win32",
+            driver_version,
+        )
     }
 
     fn get_config(&self) -> &ManagerConfig {