[rust] Automated management of Selenium Grid binaries (selenium-server.jar)

rust/README.md

@@ -25,6 +25,8 @@ Options:
           Browser name (chrome, firefox, edge, iexplorer, safari, or safaritp)
       --driver <DRIVER>
           Driver name (chromedriver, geckodriver, msedgedriver, IEDriverServer, or safaridriver)
+      --grid [<GRID_VERSION>]
+          Selenium Grid. If version is not provided, the latest version is downloaded
       --driver-version <DRIVER_VERSION>
           Driver version (e.g., 106.0.5249.61, 0.31.0, etc.)
       --browser-version <BROWSER_VERSION>

rust/src/downloads.rs

@@ -15,7 +15,7 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use reqwest::Client;
+use reqwest::{Client, StatusCode};
 use serde::{Deserialize, Serialize};
 use std::error::Error;
 use std::fs::File;
@@ -40,7 +40,12 @@ pub async fn download_driver_to_tmp_folder(
         tmp_dir.path()
     ));
 
-    let response = http_client.get(url).send().await?;
+    let response = http_client.get(&url).send().await?;
+    let status_code = response.status();
+    if status_code != StatusCode::OK {
+        return Err(format!("Unsuccessful response ({}) for URL {}", status_code, url).into());
+    }
+
     let target_path;
     let mut tmp_file = {
         let target_name = response

rust/src/files.rs

@@ -54,6 +54,12 @@ impl BrowserPath {
     }
 }
 
+pub fn create_parent_path_if_not_exists(path: &Path) {
+    if let Some(p) = path.parent() {
+        create_path_if_not_exists(p);
+    }
+}
+
 pub fn create_path_if_not_exists(path: &Path) {
     if !path.exists() {
         fs::create_dir_all(path).unwrap();
@@ -123,9 +129,7 @@ pub fn unzip(file: File, target: &Path, log: &Logger) -> Result<(), Box<dyn Erro
                 target.display(),
                 file.size()
             ));
-            if let Some(p) = target.parent() {
-                create_path_if_not_exists(p);
-            }
+            create_parent_path_if_not_exists(target);
             if !target.exists() {
                 let mut outfile = File::create(&target)?;
 

rust/src/grid.rs

@@ -0,0 +1,208 @@
+// Licensed to the Software Freedom Conservancy (SFC) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The SFC licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+use crate::config::ManagerConfig;
+use reqwest::Client;
+use std::collections::HashMap;
+use std::error::Error;
+use std::path::PathBuf;
+
+use crate::files::{get_cache_folder, BrowserPath};
+
+use crate::downloads::parse_json_from_url;
+use crate::{create_http_client, parse_version, Logger, SeleniumManager, SNAPSHOT};
+
+use crate::metadata::{
+    create_driver_metadata, get_driver_version_from_metadata, get_metadata, write_metadata,
+};
+use crate::mirror::{Assets, SeleniumRelease, MIRROR_URL};
+
+pub const GRID_NAME: &str = "grid";
+const GRID_RELEASE: &str = "selenium-server";
+const GRID_EXTENSION: &str = "jar";
+const DRIVER_URL: &str = "https://github.com/SeleniumHQ/selenium/releases/";
+
+// Although Selenium Grid is not a browser, we can use the same manager struct, where:
+// - browser_name refers to the product name, i.e., grid
+// - driver_name refers to the downloadable artifact, i.e., selenium-server (.jar)
+pub struct GridManager {
+    pub browser_name: &'static str,
+    pub driver_name: &'static str,
+    pub config: ManagerConfig,
+    pub http_client: Client,
+    pub log: Logger,
+    pub driver_url: Option<String>,
+}
+
+impl GridManager {
+    pub fn new(driver_version: String) -> Result<Box<Self>, Box<dyn Error>> {
+        let browser_name = GRID_NAME;
+        let driver_name = GRID_RELEASE;
+        let mut config = ManagerConfig::default(browser_name, driver_name);
+        config.driver_version = driver_version;
+        let default_timeout = config.timeout.to_owned();
+        let default_proxy = &config.proxy;
+        Ok(Box::new(GridManager {
+            browser_name,
+            driver_name,
+            http_client: create_http_client(default_timeout, default_proxy)?,
+            config,
+            log: Logger::default(),
+            driver_url: None,
+        }))
+    }
+}
+
+impl SeleniumManager for GridManager {
+    fn get_browser_name(&self) -> &str {
+        self.browser_name
+    }
+
+    fn get_http_client(&self) -> &Client {
+        &self.http_client
+    }
+
+    fn set_http_client(&mut self, http_client: Client) {
+        self.http_client = http_client;
+    }
+
+    fn get_browser_path_map(&self) -> HashMap<BrowserPath, &str> {
+        HashMap::new()
+    }
+
+    fn discover_browser_version(&self) -> Option<String> {
+        None
+    }
+
+    fn get_driver_name(&self) -> &str {
+        self.driver_name
+    }
+
+    fn request_driver_version(&mut self) -> Result<String, Box<dyn Error>> {
+        let browser_version_binding = self.get_major_browser_version();
+        let browser_version = browser_version_binding.as_str();
+        let mut metadata = get_metadata(self.get_logger());
+
+        match get_driver_version_from_metadata(&metadata.drivers, self.driver_name, browser_version)
+        {
+            Some(driver_version) => {
+                self.log.trace(format!(
+                    "Driver TTL is valid. Getting {} version from metadata",
+                    &self.driver_name
+                ));
+                Ok(driver_version)
+            }
+            _ => {
+                let selenium_releases = parse_json_from_url::<Vec<SeleniumRelease>>(
+                    self.get_http_client(),
+                    MIRROR_URL.to_string(),
+                )?;
+
+                let filtered_releases: Vec<SeleniumRelease> = selenium_releases
+                    .into_iter()
+                    .filter(|r| {
+                        r.assets.iter().any(|url| {
+                            url.browser_download_url.contains(GRID_RELEASE)
+                                && !url.browser_download_url.contains(SNAPSHOT)
+                        })
+                    })
+                    .collect();
+
+                if !filtered_releases.is_empty() {
+                    let assets = &filtered_releases.get(0).unwrap().assets;
+                    let driver_releases: Vec<&Assets> = assets
+                        .iter()
+                        .filter(|url| {
+                            url.browser_download_url.contains(GRID_RELEASE)
+                                && url.browser_download_url.contains(GRID_EXTENSION)
+                        })
+                        .collect();
+                    let driver_url = &driver_releases.last().unwrap().browser_download_url;
+                    self.driver_url = Some(driver_url.to_string());
+
+                    let index_release =
+                        driver_url.rfind(GRID_RELEASE).unwrap() + GRID_RELEASE.len() + 1;
+                    let driver_version = parse_version(
+                        driver_url.as_str()[index_release..].to_string(),
+                        self.get_logger(),
+                    )?;
+
+                    let driver_ttl = self.get_driver_ttl();
+                    if driver_ttl > 0 {
+                        metadata.drivers.push(create_driver_metadata(
+                            browser_version,
+                            self.driver_name,
+                            &driver_version,
+                            driver_ttl,
+                        ));
+                        write_metadata(&metadata, self.get_logger());
+                    }
+
+                    Ok(driver_version)
+                } else {
+                    Err(format!("{} release not available", self.get_driver_name()).into())
+                }
+            }
+        }
+    }
+
+    fn get_driver_url(&mut self) -> Result<String, Box<dyn Error>> {
+        if self.driver_url.is_some() {
+            return Ok(self.driver_url.as_ref().unwrap().to_string());
+        }
+
+        let release_version = self.get_selenium_release_version()?;
+        Ok(format!(
+            "{}download/{}/{}-{}.{}",
+            DRIVER_URL,
+            release_version,
+            GRID_RELEASE,
+            self.get_driver_version(),
+            GRID_EXTENSION
+        ))
+    }
+
+    fn get_driver_path_in_cache(&self) -> PathBuf {
+        let browser_name = self.get_browser_name();
+        let driver_name = self.get_driver_name();
+        let driver_version = self.get_driver_version();
+        get_cache_folder()
+            .join(browser_name)
+            .join(driver_version)
+            .join(format!("{driver_name}-{driver_version}.{GRID_EXTENSION}"))
+    }
+
+    fn get_config(&self) -> &ManagerConfig {
+        &self.config
+    }
+
+    fn get_config_mut(&mut self) -> &mut ManagerConfig {
+        &mut self.config
+    }
+
+    fn set_config(&mut self, config: ManagerConfig) {
+        self.config = config;
+    }
+
+    fn get_logger(&self) -> &Logger {
+        &self.log
+    }
+
+    fn set_logger(&mut self, log: Logger) {
+        self.log = log;
+    }
+}

rust/src/iexplorer.rs

@@ -164,22 +164,13 @@ impl SeleniumManager for IExplorerManager {
             return Ok(self.driver_url.as_ref().unwrap().to_string());
         }
 
-        let driver_version = self.get_driver_version();
-        let mut release_version = driver_version.to_string();
-        if !driver_version.ends_with('0') {
-            // E.g.: version 4.8.1 is shipped within release 4.8.0
-            let error_message = format!(
-                "Wrong {} version: '{}'",
-                self.get_driver_name(),
-                driver_version
-            );
-            let index = release_version.rfind('.').ok_or(error_message)? + 1;
-            release_version = release_version[..index].to_string();
-            release_version.push('0');
-        }
+        let release_version = self.get_selenium_release_version()?;
         Ok(format!(
-            "{}download/selenium-{}/{}{}.zip",
-            DRIVER_URL, release_version, IEDRIVER_RELEASE, driver_version
+            "{}download/{}/{}{}.zip",
+            DRIVER_URL,
+            release_version,
+            IEDRIVER_RELEASE,
+            self.get_driver_version()
         ))
     }