[rust] Change default type (arch, os) for binaries downloaded by Sele…

…nium Manager (#11685) (#12485) * [rust] Change default type (arch, os) for binaries downloaded by Selenium Manager (#11685) * [rust] Fix discover version function after merging
SeleniumHQ · Aug 7, 2023 · d06a6ee · d06a6ee
1 parent 0579687
commit d06a6ee
Show file tree

Hide file tree

Showing 11 changed files with 58 additions and 31 deletions.
diff --git a/rust/README.md b/rust/README.md
@@ -35,6 +35,10 @@ Options:
           Browser path (absolute) for browser version detection (e.g., /usr/bin/google-chrome, "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome", "C:\Program Files\Google\Chrome\Application\chrome.exe")
       --output <OUTPUT>
           Output type: LOGGER (using INFO, WARN, etc.), JSON (custom JSON notation), or SHELL (Unix-like) [default: LOGGER]
+      --os <OS>
+          Operating system (i.e., windows, linux, or macos)
+      --arch <ARCH>
+          System architecture (i.e., x32, x64, or arm64)
       --proxy <PROXY>
           HTTP proxy for network connection (e.g., https://myproxy.net:8080)
       --timeout <TIMEOUT>

diff --git a/rust/src/chrome.rs b/rust/src/chrome.rs
@@ -387,7 +387,7 @@ impl SeleniumManager for ChromeManager {
         ])
     }
 
-    fn discover_browser_version(&mut self) -> Option<String> {
+    fn discover_browser_version(&mut self) -> Result<Option<String>, Box<dyn Error>> {
         self.discover_general_browser_version(
             r#"HKCU\Software\Google\Chrome\BLBeacon"#,
             REG_VERSION_ARG,

diff --git a/rust/src/config.rs b/rust/src/config.rs
@@ -106,26 +106,29 @@ pub enum OS {
 }
 
 impl OS {
-    pub fn to_str(&self) -> &str {
+    pub fn to_str_vector(&self) -> Vec<&str> {
         match self {
-            WINDOWS => "windows",
-            MACOS => "macos",
-            LINUX => "linux",
+            WINDOWS => vec!["windows", "win"],
+            MACOS => vec!["macos", "mac"],
+            LINUX => vec!["linux", "gnu/linux"],
         }
     }
 
     pub fn is(&self, os: &str) -> bool {
-        self.to_str().eq_ignore_ascii_case(os)
+        self.to_str_vector()
+            .contains(&os.to_ascii_lowercase().as_str())
     }
 }
 
-pub fn str_to_os(os: &str) -> OS {
+pub fn str_to_os(os: &str) -> Result<OS, Box<dyn Error>> {
     if WINDOWS.is(os) {
-        WINDOWS
+        Ok(WINDOWS)
     } else if MACOS.is(os) {
-        MACOS
+        Ok(MACOS)
+    } else if LINUX.is(os) {
+        Ok(LINUX)
     } else {
-        LINUX
+        Err(format!("Invalid operating system: {os}").into())
     }
 }
 
@@ -140,9 +143,9 @@ pub enum ARCH {
 impl ARCH {
     pub fn to_str_vector(&self) -> Vec<&str> {
         match self {
-            ARCH::X32 => vec![ARCH_X86, "i386"],
+            ARCH::X32 => vec![ARCH_X86, "i386", "x32"],
             ARCH::X64 => vec![ARCH_AMD64, "x86_64", "x64", "i686", "ia64"],
-            ARCH::ARM64 => vec![ARCH_ARM64, "aarch64", "arm"],
+            ARCH::ARM64 => vec![ARCH_ARM64, "aarch64", "arm", "arm64"],
         }
     }
 

diff --git a/rust/src/edge.rs b/rust/src/edge.rs
@@ -120,7 +120,7 @@ impl SeleniumManager for EdgeManager {
         ])
     }
 
-    fn discover_browser_version(&mut self) -> Option<String> {
+    fn discover_browser_version(&mut self) -> Result<Option<String>, Box<dyn Error>> {
         self.discover_general_browser_version(
             r#"HKCU\Software\Microsoft\Edge\BLBeacon"#,
             REG_VERSION_ARG,

diff --git a/rust/src/firefox.rs b/rust/src/firefox.rs
@@ -117,7 +117,7 @@ impl SeleniumManager for FirefoxManager {
         ])
     }
 
-    fn discover_browser_version(&mut self) -> Option<String> {
+    fn discover_browser_version(&mut self) -> Result<Option<String>, Box<dyn Error>> {
         self.discover_general_browser_version(
             r#"HKCU\Software\Mozilla\Mozilla Firefox"#,
             REG_CURRENT_VERSION_ARG,

diff --git a/rust/src/grid.rs b/rust/src/grid.rs
@@ -86,8 +86,8 @@ impl SeleniumManager for GridManager {
         HashMap::new()
     }
 
-    fn discover_browser_version(&mut self) -> Option<String> {
-        None
+    fn discover_browser_version(&mut self) -> Result<Option<String>, Box<dyn Error>> {
+        Ok(None)
     }
 
     fn get_driver_name(&self) -> &str {

diff --git a/rust/src/iexplorer.rs b/rust/src/iexplorer.rs
@@ -62,7 +62,7 @@ impl IExplorerManager {
         let mut config = ManagerConfig::default(browser_name, driver_name);
         let default_timeout = config.timeout.to_owned();
         let default_proxy = &config.proxy;
-        config.os = WINDOWS.to_str().to_string();
+        config.os = WINDOWS.to_str_vector().first().unwrap().to_string();
         Ok(Box::new(IExplorerManager {
             browser_name,
             driver_name,
@@ -94,7 +94,7 @@ impl SeleniumManager for IExplorerManager {
         )])
     }
 
-    fn discover_browser_version(&mut self) -> Option<String> {
+    fn discover_browser_version(&mut self) -> Result<Option<String>, Box<dyn Error>> {
         self.discover_general_browser_version(
             r#"HKEY_LOCAL_MACHINE\Software\Microsoft\Internet Explorer"#,
             REG_VERSION_ARG,

diff --git a/rust/src/lib.rs b/rust/src/lib.rs
@@ -108,7 +108,7 @@ pub trait SeleniumManager {
 
     fn get_browser_path_map(&self) -> HashMap<BrowserPath, &str>;
 
-    fn discover_browser_version(&mut self) -> Option<String>;
+    fn discover_browser_version(&mut self) -> Result<Option<String>, Box<dyn Error>>;
 
     fn get_driver_name(&self) -> &str;
 
@@ -169,7 +169,10 @@ pub trait SeleniumManager {
 
         let browser_path = self
             .get_browser_path_map()
-            .get(&BrowserPath::new(str_to_os(self.get_os()), browser_version))
+            .get(&BrowserPath::new(
+                str_to_os(self.get_os()).unwrap(),
+                browser_version,
+            ))
             .cloned()
             .unwrap_or_default();
 
@@ -261,7 +264,7 @@ pub trait SeleniumManager {
 
         // First, we try to discover the browser version
         if !download_browser {
-            match self.discover_browser_version() {
+            match self.discover_browser_version()? {
                 Some(discovered_version) => {
                     if !self.is_safari() {
                         self.get_logger().debug(format!(
@@ -596,7 +599,7 @@ pub trait SeleniumManager {
         reg_key: &'static str,
         reg_version_arg: &'static str,
         cmd_version_arg: &str,
-    ) -> Option<String> {
+    ) -> Result<Option<String>, Box<dyn Error>> {
         let mut browser_path = self.get_browser_path().to_string();
         let mut escaped_browser_path = self.get_escaped_path(browser_path.to_string());
         if browser_path.is_empty() {
@@ -643,28 +646,31 @@ pub trait SeleniumManager {
             )));
         }
 
-        self.detect_browser_version(commands)
+        Ok(self.detect_browser_version(commands))
     }
 
-    fn discover_safari_version(&mut self, safari_path: String) -> Option<String> {
+    fn discover_safari_version(
+        &mut self,
+        safari_path: String,
+    ) -> Result<Option<String>, Box<dyn Error>> {
         let mut browser_path = self.get_browser_path().to_string();
         let mut commands = Vec::new();
         if browser_path.is_empty() {
             match self.detect_browser_path() {
                 Some(path) => {
                     browser_path = self.get_escaped_path(path_buf_to_string(path));
                 }
-                _ => return None,
+                _ => return Ok(None),
             }
         }
         if MACOS.is(self.get_os()) {
             let plist_command = Command::new_single(format_one_arg(PLIST_COMMAND, &browser_path));
             commands.push(plist_command);
         } else {
-            return None;
+            return Ok(None);
         }
         self.set_browser_path(safari_path);
-        self.detect_browser_version(commands)
+        Ok(self.detect_browser_version(commands))
     }
 
     // ----------------------------------------------------------
@@ -676,15 +682,19 @@ pub trait SeleniumManager {
     }
 
     fn set_os(&mut self, os: String) {
-        self.get_config_mut().os = os;
+        if !os.is_empty() {
+            self.get_config_mut().os = os;
+        }
     }
 
     fn get_arch(&self) -> &str {
         self.get_config().arch.as_str()
     }
 
     fn set_arch(&mut self, arch: String) {
-        self.get_config_mut().arch = arch;
+        if !arch.is_empty() {
+            self.get_config_mut().arch = arch;
+        }
     }
 
     fn get_browser_version(&self) -> &str {

diff --git a/rust/src/main.rs b/rust/src/main.rs
@@ -72,6 +72,14 @@ struct Cli {
     #[clap(long, value_parser, default_value = "LOGGER")]
     output: String,
 
+    /// Operating system (i.e., windows, linux, or macos)
+    #[clap(long, value_parser)]
+    os: Option<String>,
+
+    /// System architecture (i.e., x32, x64, or arm64)
+    #[clap(long, value_parser)]
+    arch: Option<String>,
+
     /// HTTP proxy for network connection (e.g., https://myproxy.net:8080)
     #[clap(long, value_parser)]
     proxy: Option<String>,
@@ -155,6 +163,8 @@ fn main() {
     selenium_manager.set_browser_version(cli.browser_version.unwrap_or_default());
     selenium_manager.set_driver_version(cli.driver_version.unwrap_or_default());
     selenium_manager.set_browser_path(cli.browser_path.unwrap_or_default());
+    selenium_manager.set_os(cli.os.unwrap_or_default());
+    selenium_manager.set_arch(cli.arch.unwrap_or_default());
     selenium_manager.set_driver_ttl(cli.driver_ttl);
     selenium_manager.set_browser_ttl(cli.browser_ttl);
     selenium_manager.set_offline(cli.offline);

diff --git a/rust/src/safari.rs b/rust/src/safari.rs
@@ -74,7 +74,7 @@ impl SeleniumManager for SafariManager {
         HashMap::from([(BrowserPath::new(MACOS, STABLE), SAFARI_PATH)])
     }
 
-    fn discover_browser_version(&mut self) -> Option<String> {
+    fn discover_browser_version(&mut self) -> Result<Option<String>, Box<dyn Error>> {
         self.discover_safari_version(SAFARI_FULL_PATH.to_string())
     }
 

diff --git a/rust/src/safaritp.rs b/rust/src/safaritp.rs
@@ -80,7 +80,7 @@ impl SeleniumManager for SafariTPManager {
         HashMap::from([(BrowserPath::new(MACOS, STABLE), SAFARITP_PATH)])
     }
 
-    fn discover_browser_version(&mut self) -> Option<String> {
+    fn discover_browser_version(&mut self) -> Result<Option<String>, Box<dyn Error>> {
         self.discover_safari_version(SAFARITP_FULL_PATH.to_string())
     }