| // 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::chrome::CHROMEDRIVER_NAME; | |
| use crate::config::ARCH::{ARM64, X32}; | |
| use crate::config::ManagerConfig; | |
| use crate::config::OS::MACOS; | |
| use crate::downloads::read_redirect_from_link; | |
| use crate::files::{BrowserPath, compose_driver_path_in_cache}; | |
| use crate::metadata::{ | |
| create_driver_metadata, get_driver_version_from_metadata, get_metadata, write_metadata, | |
| }; | |
| use crate::{ | |
| BETA, CANARY, DEV, ESR, LATEST_RELEASE, Logger, NIGHTLY, OFFLINE_REQUEST_ERR_MSG, STABLE, | |
| SeleniumManager, WINDOWS, | |
| }; | |
| use anyhow::Error; | |
| use reqwest::Client; | |
| use std::collections::HashMap; | |
| use std::path::PathBuf; | |
| use std::sync::OnceLock; | |
| use std::sync::mpsc; | |
| use std::sync::mpsc::{Receiver, Sender}; | |
| pub const ELECTRON_NAME: &str = "electron"; | |
| const DRIVER_URL: &str = "https://github.com/electron/electron/releases/"; | |
| /// Returns the user's `--browser-version` as the resolved Electron driver | |
| /// version when - and only when - it is a *specific* version that we can use | |
| /// verbatim as a release tag (e.g. `36.2.1`, `v36.2.1`, `36.0.0-beta.1`). | |
| /// | |
| /// Returns `None` for empty input, channel names (`stable`, `beta`, `dev`, | |
| /// `nightly`, `canary`, `esr`), and major-only inputs like `36` - those must | |
| /// keep using the `/releases/latest` redirect path because Electron has no | |
| /// `v36` tag and emitting one would build a 404 download URL. | |
| /// | |
| /// A leading `v` or `V` is stripped (so `v36.2.1` doesn't double up against | |
| /// the `v` prefix added by `get_driver_url()`); we deliberately do *not* call | |
| /// `parse_version()` here because that strips prerelease suffixes such as | |
| /// `-beta.1`, which Electron release tags legitimately carry. | |
| fn normalize_pinned_version(browser_version: &str) -> Option<String> { | |
| let trimmed = browser_version.trim(); | |
| if trimmed.is_empty() { | |
| return None; | |
| } | |
| if trimmed.eq_ignore_ascii_case(STABLE) | |
| || trimmed.eq_ignore_ascii_case(BETA) | |
| || trimmed.eq_ignore_ascii_case(DEV) | |
| || trimmed.eq_ignore_ascii_case(NIGHTLY) | |
| || trimmed.eq_ignore_ascii_case(CANARY) | |
| || trimmed.eq_ignore_ascii_case(ESR) | |
| { | |
| return None; | |
| } | |
| let stripped = trimmed | |
| .strip_prefix('v') | |
| .or_else(|| trimmed.strip_prefix('V')) | |
| .unwrap_or(trimmed); | |
| // Require a specific version (contains a dot); major-only inputs like | |
| // `36` are not valid Electron release tags and must use the latest | |
| // fallback. | |
| if !stripped.contains('.') { | |
| return None; | |
| } | |
| Some(stripped.to_string()) | |
| } | |
| pub struct ElectronManager { | |
| pub browser_name: &'static str, | |
| pub driver_name: &'static str, | |
| pub config: ManagerConfig, | |
| pub http_client: OnceLock<Client>, | |
| pub log: Logger, | |
| pub tx: Sender<String>, | |
| pub rx: Receiver<String>, | |
| pub download_browser: bool, | |
| pub driver_url: Option<String>, | |
| } | |
| impl ElectronManager { | |
| pub fn new() -> Result<Box<Self>, Error> { | |
| let browser_name = ELECTRON_NAME; | |
| let driver_name = CHROMEDRIVER_NAME; | |
| let config = ManagerConfig::default(browser_name, driver_name); | |
| let (tx, rx): (Sender<String>, Receiver<String>) = mpsc::channel(); | |
| Ok(Box::new(ElectronManager { | |
| browser_name, | |
| driver_name, | |
| http_client: OnceLock::new(), | |
| config, | |
| log: Logger::new(), | |
| tx, | |
| rx, | |
| download_browser: false, | |
| driver_url: None, | |
| })) | |
| } | |
| } | |
| impl SeleniumManager for ElectronManager { | |
| fn get_browser_name(&self) -> &str { | |
| self.browser_name | |
| } | |
| fn get_browser_names_in_path(&self) -> Vec<&str> { | |
| vec![self.get_browser_name()] | |
| } | |
| fn get_http_client_cell(&self) -> &OnceLock<Client> { | |
| &self.http_client | |
| } | |
| fn get_http_client_cell_mut(&mut self) -> &mut OnceLock<Client> { | |
| &mut self.http_client | |
| } | |
| fn get_browser_path_map(&self) -> HashMap<BrowserPath, &str> { | |
| HashMap::new() | |
| } | |
| fn discover_browser_version(&mut self) -> Result<Option<String>, Error> { | |
| Ok(None) | |
| } | |
| fn get_driver_name(&self) -> &str { | |
| self.driver_name | |
| } | |
| fn request_driver_version(&mut self) -> Result<String, Error> { | |
| // Electron releases are tagged by Electron version, and the | |
| // chromedriver asset shipped in each release matches that tag. | |
| // When the user pins a *specific* browser version (e.g. | |
| // `--browser-version 36.2.1`), that version is the driver version | |
| // we want; resolving via `/releases/latest` would discard the | |
| // user's request and return the latest tag instead. | |
| // | |
| // This short-circuit must run *before* the metadata cache lookup: | |
| // the cache is keyed only on `major_browser_version`, so a cached | |
| // entry for major `36` would otherwise override an explicit | |
| // `36.2.1` pin and silently return a different patch version. | |
| // | |
| // Major-only inputs like `36` keep using the latest-redirect | |
| // fallback path, because Electron has no `v36` tag - using it | |
| // verbatim would build a 404 download URL. | |
| let browser_version = self.get_browser_version().to_string(); | |
| let normalized_pin = normalize_pinned_version(&browser_version); | |
| if let Some(pinned) = normalized_pin { | |
| return Ok(pinned); | |
| } | |
| let major_browser_version_binding = self.get_major_browser_version(); | |
| let major_browser_version = major_browser_version_binding.as_str(); | |
| let cache_path = self.get_cache_path()?; | |
| let mut metadata = get_metadata(self.get_logger(), &cache_path); | |
| match get_driver_version_from_metadata( | |
| &metadata.drivers, | |
| self.driver_name, | |
| major_browser_version, | |
| ) { | |
| Some(driver_version) => { | |
| self.log.trace(format!( | |
| "Driver TTL is valid. Getting {} version from metadata", | |
| &self.driver_name | |
| )); | |
| Ok(driver_version) | |
| } | |
| _ => { | |
| self.assert_online_or_err(OFFLINE_REQUEST_ERR_MSG)?; | |
| let latest_url = format!( | |
| "{}{}", | |
| self.get_driver_mirror_url_or_default(DRIVER_URL), | |
| LATEST_RELEASE | |
| ); | |
| let driver_version = read_redirect_from_link( | |
| self.get_http_client()?, | |
| latest_url, | |
| self.get_logger(), | |
| )?; | |
| let driver_ttl = self.get_ttl(); | |
| if driver_ttl > 0 && !major_browser_version.is_empty() && !driver_version.is_empty() | |
| { | |
| metadata.drivers.push(create_driver_metadata( | |
| major_browser_version, | |
| self.driver_name, | |
| &driver_version, | |
| driver_ttl, | |
| )); | |
| write_metadata(&metadata, self.get_logger(), cache_path); | |
| } | |
| Ok(driver_version) | |
| } | |
| } | |
| } | |
| fn request_browser_version(&mut self) -> Result<Option<String>, Error> { | |
| Ok(None) | |
| } | |
| fn get_driver_url(&mut self) -> Result<String, Error> { | |
| if self.driver_url.is_some() { | |
| return Ok(self.driver_url.as_ref().unwrap().to_string()); | |
| } | |
| Ok(format!( | |
| "{}download/v{}/{}-v{}-{}.zip", | |
| self.get_driver_mirror_url_or_default(DRIVER_URL), | |
| self.get_driver_version(), | |
| CHROMEDRIVER_NAME, | |
| self.get_driver_version(), | |
| self.get_platform_label() | |
| )) | |
| } | |
| fn get_driver_path_in_cache(&self) -> Result<PathBuf, Error> { | |
| Ok(compose_driver_path_in_cache( | |
| self.get_cache_path()?.unwrap_or_default(), | |
| self.driver_name, | |
| self.get_os(), | |
| self.get_platform_label(), | |
| self.get_driver_version(), | |
| )) | |
| } | |
| 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; | |
| } | |
| fn get_sender(&self) -> &Sender<String> { | |
| &self.tx | |
| } | |
| fn get_receiver(&self) -> &Receiver<String> { | |
| &self.rx | |
| } | |
| fn get_platform_label(&self) -> &str { | |
| let os = self.get_os(); | |
| let arch = self.get_arch(); | |
| if WINDOWS.is(os) { | |
| if X32.is(arch) { | |
| "win32-ia32" | |
| } else if ARM64.is(arch) { | |
| "win32-arm64" | |
| } else { | |
| "win32-x64" | |
| } | |
| } else if MACOS.is(os) { | |
| if ARM64.is(arch) { | |
| "mas-arm64" | |
| } else { | |
| "mas-x64" | |
| } | |
| } else if ARM64.is(arch) { | |
| "linux-arm64" | |
| } else { | |
| "linux-x64" | |
| } | |
| } | |
| fn request_latest_browser_version_from_online( | |
| &mut self, | |
| _browser_version: &str, | |
| ) -> Result<String, Error> { | |
| self.unavailable_download() | |
| } | |
| fn request_fixed_browser_version_from_online( | |
| &mut self, | |
| _browser_version: &str, | |
| ) -> Result<String, Error> { | |
| self.unavailable_download() | |
| } | |
| fn get_min_browser_version_for_download(&self) -> Result<i32, Error> { | |
| self.unavailable_download() | |
| } | |
| fn get_browser_binary_path(&mut self, _browser_version: &str) -> Result<PathBuf, Error> { | |
| self.unavailable_download() | |
| } | |
| fn get_browser_url_for_download(&mut self, _browser_version: &str) -> Result<String, Error> { | |
| self.unavailable_download() | |
| } | |
| fn get_browser_label_for_download( | |
| &self, | |
| _browser_version: &str, | |
| ) -> Result<Option<&str>, Error> { | |
| self.unavailable_download() | |
| } | |
| fn is_download_browser(&self) -> bool { | |
| self.download_browser | |
| } | |
| fn set_download_browser(&mut self, download_browser: bool) { | |
| self.download_browser = download_browser; | |
| } | |
| fn is_snap(&self, _browser_path: &str) -> bool { | |
| false | |
| } | |
| fn get_snap_path(&self) -> Option<PathBuf> { | |
| None | |
| } | |
| } | |
| #[cfg(test)] | |
| mod tests { | |
| use super::ElectronManager; | |
| use super::normalize_pinned_version; | |
| use crate::SeleniumManager; | |
| #[test] | |
| fn test_driver_url() { | |
| let mut electron_manager = ElectronManager::new().unwrap(); | |
| let data = vec![ | |
| vec![ | |
| "windows", | |
| "x86", | |
| "https://github.com/electron/electron/releases/download/v36.2.1/chromedriver-v36.2.1-win32-ia32.zip", | |
| ], | |
| vec![ | |
| "windows", | |
| "x86_64", | |
| "https://github.com/electron/electron/releases/download/v36.2.1/chromedriver-v36.2.1-win32-x64.zip", | |
| ], | |
| vec![ | |
| "windows", | |
| "aarch64", | |
| "https://github.com/electron/electron/releases/download/v36.2.1/chromedriver-v36.2.1-win32-arm64.zip", | |
| ], | |
| vec![ | |
| "macos", | |
| "aarch64", | |
| "https://github.com/electron/electron/releases/download/v36.2.1/chromedriver-v36.2.1-mas-arm64.zip", | |
| ], | |
| vec![ | |
| "linux", | |
| "aarch64", | |
| "https://github.com/electron/electron/releases/download/v36.2.1/chromedriver-v36.2.1-linux-arm64.zip", | |
| ], | |
| ]; | |
| electron_manager.set_driver_version("36.2.1".to_string()); | |
| data.iter().for_each(|d| { | |
| electron_manager.set_os(d.first().unwrap().to_string()); | |
| electron_manager.set_arch(d.get(1).unwrap().to_string()); | |
| let driver_url = electron_manager.get_driver_url().unwrap(); | |
| assert_eq!(d.get(2).unwrap().to_string(), driver_url); | |
| }); | |
| } | |
| #[test] | |
| fn specific_version_is_returned_verbatim() { | |
| assert_eq!( | |
| normalize_pinned_version("36.2.1"), | |
| Some("36.2.1".to_string()) | |
| ); | |
| } | |
| #[test] | |
| fn leading_v_is_stripped() { | |
| assert_eq!( | |
| normalize_pinned_version("v36.2.1"), | |
| Some("36.2.1".to_string()) | |
| ); | |
| assert_eq!( | |
| normalize_pinned_version("V36.2.1"), | |
| Some("36.2.1".to_string()) | |
| ); | |
| } | |
| #[test] | |
| fn prerelease_suffix_is_preserved() { | |
| assert_eq!( | |
| normalize_pinned_version("36.0.0-beta.1"), | |
| Some("36.0.0-beta.1".to_string()) | |
| ); | |
| assert_eq!( | |
| normalize_pinned_version("v36.0.0-beta.1"), | |
| Some("36.0.0-beta.1".to_string()) | |
| ); | |
| } | |
| #[test] | |
| fn major_only_falls_back() { | |
| // `36` has no Electron tag; must fall back to /releases/latest. | |
| assert_eq!(normalize_pinned_version("36"), None); | |
| assert_eq!(normalize_pinned_version("v36"), None); | |
| } | |
| #[test] | |
| fn channel_names_fall_back() { | |
| for channel in ["stable", "beta", "dev", "nightly", "canary", "esr"] { | |
| assert_eq!(normalize_pinned_version(channel), None, "{}", channel); | |
| assert_eq!( | |
| normalize_pinned_version(&channel.to_uppercase()), | |
| None, | |
| "{}", | |
| channel | |
| ); | |
| } | |
| } | |
| #[test] | |
| fn empty_or_whitespace_falls_back() { | |
| assert_eq!(normalize_pinned_version(""), None); | |
| assert_eq!(normalize_pinned_version(" "), None); | |
| } | |
| } |