[rust] Search better driver possible in the cache (#12753)

bonigarcia · web-flow · commit eafd7cfff0e4 · 2023-09-15T20:57:22.000-05:00
* [rust] Search better driver possible in the cache

* [rust] Update Cargo.Bazel.lock
diff --git a/rust/Cargo.Bazel.lock b/rust/Cargo.Bazel.lock
@@ -1,5 +1,5 @@
 {
-  "checksum": "0c722a74f5cadc8bb75a62763e298e0698afcb48a51d9f7bf6754e285caa644b",
+  "checksum": "1f16f4cfa433faeb0bd8242b382da4d71e41405dc8a07363d8c1f410ee0d651e",
   "crates": {
     "addr2line 0.19.0": {
       "name": "addr2line",
@@ -7636,6 +7636,47 @@
       },
       "license": "Apache-2.0 OR BSL-1.0"
     },
+    "same-file 1.0.6": {
+      "name": "same-file",
+      "version": "1.0.6",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/same-file/1.0.6/download",
+          "sha256": "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "same_file",
+            "crate_root": "src/lib.rs",
+            "srcs": [
+              "**/*.rs"
+            ]
+          }
+        }
+      ],
+      "library_target_name": "same_file",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [],
+          "selects": {
+            "cfg(windows)": [
+              {
+                "id": "winapi-util 0.1.5",
+                "target": "winapi_util"
+              }
+            ]
+          }
+        },
+        "edition": "2018",
+        "version": "1.0.6"
+      },
+      "license": "Unlicense/MIT"
+    },
     "sct 0.7.0": {
       "name": "sct",
       "version": "0.7.0",
@@ -7773,6 +7814,10 @@
               "id": "toml 0.7.6",
               "target": "toml"
             },
+            {
+              "id": "walkdir 2.4.0",
+              "target": "walkdir"
+            },
             {
               "id": "zip 0.6.6",
               "target": "zip"
@@ -10300,6 +10345,52 @@
       },
       "license": "MIT/Apache-2.0"
     },
+    "walkdir 2.4.0": {
+      "name": "walkdir",
+      "version": "2.4.0",
+      "repository": {
+        "Http": {
+          "url": "https://crates.io/api/v1/crates/walkdir/2.4.0/download",
+          "sha256": "d71d857dc86794ca4c280d616f7da00d2dbfd8cd788846559a6813e6aa4b54ee"
+        }
+      },
+      "targets": [
+        {
+          "Library": {
+            "crate_name": "walkdir",
+            "crate_root": "src/lib.rs",
+            "srcs": [
+              "**/*.rs"
+            ]
+          }
+        }
+      ],
+      "library_target_name": "walkdir",
+      "common_attrs": {
+        "compile_data_glob": [
+          "**"
+        ],
+        "deps": {
+          "common": [
+            {
+              "id": "same-file 1.0.6",
+              "target": "same_file"
+            }
+          ],
+          "selects": {
+            "cfg(windows)": [
+              {
+                "id": "winapi-util 0.1.5",
+                "target": "winapi_util"
+              }
+            ]
+          }
+        },
+        "edition": "2018",
+        "version": "2.4.0"
+      },
+      "license": "Unlicense/MIT"
+    },
     "want 0.3.0": {
       "name": "want",
       "version": "0.3.0",
diff --git a/rust/Cargo.lock b/rust/Cargo.lock
diff --git a/rust/Cargo.toml b/rust/Cargo.toml
@@ -31,6 +31,7 @@ is_executable = "1.0.1"
 toml = "0.7.6"
 bzip2 = "0.4.4"
 sevenz-rust = "0.5.2"
+walkdir = "2.4.0"
 
 [dev-dependencies]
 assert_cmd = "2.0.12"
diff --git a/rust/src/lib.rs b/rust/src/lib.rs
@@ -34,6 +34,7 @@ use std::collections::HashMap;
 use std::error::Error;
 use std::path::{Path, PathBuf};
 use std::time::Duration;
+use walkdir::{DirEntry, WalkDir};
 
 use crate::downloads::download_to_tmp_folder;
 use crate::files::{parse_version, uncompress, BrowserPath};
@@ -593,6 +594,74 @@ pub trait SeleniumManager {
         Ok(driver_path)
     }
 
+    fn is_driver(&self, entry: &DirEntry) -> bool {
+        let is_file = entry.path().is_file();
+
+        let is_driver = entry
+            .file_name()
+            .to_str()
+            .map(|s| s.contains(&self.get_driver_name_with_extension()))
+            .unwrap_or(false);
+
+        let match_os = entry
+            .path()
+            .to_str()
+            .map(|s| s.contains(self.get_platform_label()))
+            .unwrap_or(false);
+
+        is_file && is_driver && match_os
+    }
+
+    fn is_driver_and_matches_browser_version(&self, entry: &DirEntry) -> bool {
+        let match_driver_version = entry
+            .path()
+            .parent()
+            .unwrap_or(entry.path())
+            .file_name()
+            .map(|s| {
+                s.to_str()
+                    .unwrap_or_default()
+                    .starts_with(&self.get_major_browser_version())
+            })
+            .unwrap_or(false);
+
+        self.is_driver(entry) && match_driver_version
+    }
+
+    fn find_best_driver_from_cache(&self) -> Result<Option<PathBuf>, Box<dyn Error>> {
+        let cache_path = self.get_cache_path()?;
+        let drivers_in_cache_matching_version: Vec<PathBuf> = WalkDir::new(&cache_path)
+            .into_iter()
+            .filter_map(|entry| entry.ok())
+            .filter(|entry| self.is_driver_and_matches_browser_version(entry))
+            .map(|entry| entry.path().to_owned())
+            .collect();
+
+        // First we look for drivers in cache that matches browser version (should work for Chrome and Edge)
+        if !drivers_in_cache_matching_version.is_empty() {
+            Ok(Some(
+                drivers_in_cache_matching_version
+                    .iter()
+                    .last()
+                    .unwrap()
+                    .to_owned(),
+            ))
+        } else {
+            // If not available, we look for the latest available driver in the cache
+            let drivers_in_cache: Vec<PathBuf> = WalkDir::new(&cache_path)
+                .into_iter()
+                .filter_map(|entry| entry.ok())
+                .filter(|entry| self.is_driver(entry))
+                .map(|entry| entry.path().to_owned())
+                .collect();
+            if !drivers_in_cache.is_empty() {
+                Ok(Some(drivers_in_cache.iter().last().unwrap().to_owned()))
+            } else {
+                Ok(None)
+            }
+        }
+    }
+
     fn get_major_version(&self, full_version: &str) -> Result<String, Box<dyn Error>> {
         get_index_version(full_version, 0)
     }
diff --git a/rust/src/main.rs b/rust/src/main.rs
@@ -15,6 +15,7 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use std::path::PathBuf;
 use std::process::exit;
 
 use clap::Parser;
@@ -194,21 +195,26 @@ fn main() {
         .and_then(|_| selenium_manager.setup())
         .map(|driver_path| {
             let log = selenium_manager.get_logger();
-            if driver_path.exists() {
-                log.info(format!("{}{}", DRIVER_PATH, driver_path.display()));
-            } else {
-                log.error(format!("Driver unavailable: {}", DRIVER_PATH));
-                flush_and_exit(UNAVAILABLE, log);
-            }
-            let browser_path = selenium_manager.get_browser_path();
-            if !browser_path.is_empty() {
-                log.info(format!("{}{}", BROWSER_PATH, browser_path));
-            }
+            log_driver_and_browser_path(log, &driver_path, selenium_manager.get_browser_path());
             flush_and_exit(OK, log);
         })
         .unwrap_or_else(|err| {
             let log = selenium_manager.get_logger();
-            if selenium_manager.is_offline() {
+            if let Some(best_driver_from_cache) =
+                selenium_manager.find_best_driver_from_cache().unwrap()
+            {
+                log.warn(format!(
+                    "There was an error managing {} ({}); using driver found in the cache",
+                    selenium_manager.get_browser_name(),
+                    err
+                ));
+                log_driver_and_browser_path(
+                    log,
+                    &best_driver_from_cache,
+                    selenium_manager.get_browser_path(),
+                );
+                flush_and_exit(OK, log);
+            } else if selenium_manager.is_offline() {
                 log.warn(err.to_string());
                 flush_and_exit(OK, log);
             } else {
@@ -218,6 +224,18 @@ fn main() {
         });
 }
 
+fn log_driver_and_browser_path(log: &Logger, driver_path: &PathBuf, browser_path: &str) {
+    if driver_path.exists() {
+        log.info(format!("{}{}", DRIVER_PATH, driver_path.display()));
+    } else {
+        log.error(format!("Driver unavailable: {}", DRIVER_PATH));
+        flush_and_exit(UNAVAILABLE, log);
+    }
+    if !browser_path.is_empty() {
+        log.info(format!("{}{}", BROWSER_PATH, browser_path));
+    }
+}
+
 fn flush_and_exit(code: i32, log: &Logger) -> ! {
     log.set_code(code);
     log.flush();
diff --git a/rust/tests/browser_tests.rs b/rust/tests/browser_tests.rs
@@ -19,6 +19,10 @@ use assert_cmd::Command;
 use rstest::rstest;
 use std::env::consts::OS;
 
+use crate::common::assert_output;
+
+mod common;
+
 #[rstest]
 #[case("chrome", "chromedriver", "114", "114.0.5735.90")]
 #[case("chrome", "chromedriver", "115", "115.0.5790")]
@@ -68,7 +72,7 @@ fn wrong_parameters_test(
     #[case] error_code: i32,
 ) {
     let mut cmd = Command::new(env!("CARGO_BIN_EXE_selenium-manager"));
-    let assert_result = cmd
+    let result = cmd
         .args([
             "--debug",
             "--browser",
@@ -81,17 +85,7 @@ fn wrong_parameters_test(
         .assert()
         .try_success();
 
-    if assert_result.is_ok() {
-        let stdout = &cmd.unwrap().stdout;
-        let output = std::str::from_utf8(stdout).unwrap();
-        assert!(output.contains("in PATH"));
-    } else {
-        assert!(assert_result
-            .err()
-            .unwrap()
-            .to_string()
-            .contains(&error_code.to_string()));
-    }
+    assert_output(&mut cmd, result, "in PATH", error_code);
 }
 
 #[rstest]
diff --git a/rust/tests/common.rs b/rust/tests/common.rs
@@ -15,6 +15,7 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use assert_cmd::assert::AssertResult;
 use assert_cmd::Command;
 use std::borrow::BorrowMut;
 use std::env::consts::OS;
@@ -72,3 +73,23 @@ pub fn display_output(cmd: &mut Command) {
     let output = std::str::from_utf8(stdout).unwrap();
     println!("{}", output);
 }
+
+#[allow(dead_code)]
+pub fn assert_output(
+    cmd: &mut Command,
+    assert_result: AssertResult,
+    expected_output: &str,
+    error_code: i32,
+) {
+    if assert_result.is_ok() {
+        let stdout = &cmd.unwrap().stdout;
+        let output = std::str::from_utf8(stdout).unwrap();
+        assert!(output.contains(expected_output));
+    } else {
+        assert!(assert_result
+            .err()
+            .unwrap()
+            .to_string()
+            .contains(&error_code.to_string()));
+    }
+}
diff --git a/rust/tests/grid_tests.rs b/rust/tests/grid_tests.rs
diff --git a/rust/tests/proxy_tests.rs b/rust/tests/proxy_tests.rs
