| // 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::ARCH::{ARM64, X32}; | |
| use crate::config::ManagerConfig; | |
| use crate::config::OS::{LINUX, MACOS, WINDOWS}; | |
| use crate::downloads::{parse_json_from_url, read_version_from_link}; | |
| use crate::files::{BrowserPath, compose_driver_path_in_cache, first_existing_path}; | |
| use crate::logger::Logger; | |
| use crate::metadata::{ | |
| create_driver_metadata, get_driver_version_from_metadata, get_metadata, | |
| should_cache_driver_version, write_metadata, | |
| }; | |
| use crate::{ | |
| BETA, DASH_DASH_VERSION, DEV, NIGHTLY, OFFLINE_REQUEST_ERR_MSG, REG_VERSION_ARG, STABLE, | |
| SeleniumManager, UNAVAILABLE_DOWNLOAD_WITH_MIN_VERSION_ERR_MSG, format_four_args, | |
| }; | |
| use anyhow::Error; | |
| use anyhow::anyhow; | |
| use reqwest::Client; | |
| use serde::{Deserialize, Serialize}; | |
| use std::collections::HashMap; | |
| use std::option::Option; | |
| use std::path::{Path, PathBuf}; | |
| use std::process::Command; | |
| use std::sync::OnceLock; | |
| use std::sync::mpsc; | |
| use std::sync::mpsc::{Receiver, Sender}; | |
| pub const CHROME_NAME: &str = "chrome"; | |
| pub const CHROMEDRIVER_NAME: &str = "chromedriver"; | |
| // Directories and names chromedriver searches to locate Chrome/Chromium on Linux (chrome_finder.cc). | |
| pub const CHROME_KNOWN_DIRS: &[&str] = &[ | |
| "/usr/local/sbin", | |
| "/usr/local/bin", | |
| "/usr/sbin", | |
| "/usr/bin", | |
| "/sbin", | |
| "/bin", | |
| "/opt/google/chrome", | |
| "/opt/chromium.org/chromium", | |
| ]; | |
| pub const CHROME_KNOWN_NAMES: &[&str] = | |
| &["chrome", "google-chrome", "chromium", "chromium-browser"]; | |
| const DRIVER_URL: &str = "https://chromedriver.storage.googleapis.com/"; | |
| const LATEST_RELEASE: &str = "LATEST_RELEASE"; | |
| const CFT_URL: &str = "https://googlechromelabs.github.io/chrome-for-testing/"; | |
| const GOOD_VERSIONS_ENDPOINT: &str = "known-good-versions-with-downloads.json"; | |
| const LATEST_VERSIONS_ENDPOINT: &str = "last-known-good-versions-with-downloads.json"; | |
| const CFT_MACOS_APP_NAME: &str = | |
| "Google Chrome for Testing.app/Contents/MacOS/Google Chrome for Testing"; | |
| const MIN_CHROME_VERSION_CFT: i32 = 113; | |
| const MIN_CHROMEDRIVER_VERSION_CFT: i32 = 115; | |
| const MIN_CHROME_VERSION_LINUX_ARM64: i32 = 153; | |
| const CHROMIUM_SNAP_LINK: &str = "/snap/bin/chromium"; | |
| const CHROMIUM_SNAP_BINARY: &str = "/snap/chromium/current/usr/lib/chromium-browser/chrome"; | |
| pub struct ChromeManager { | |
| 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>, | |
| pub browser_url: Option<String>, | |
| } | |
| impl ChromeManager { | |
| pub fn new() -> Result<Box<Self>, Error> { | |
| let browser_name = CHROME_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(ChromeManager { | |
| browser_name, | |
| driver_name, | |
| http_client: OnceLock::new(), | |
| config, | |
| log: Logger::new(), | |
| tx, | |
| rx, | |
| download_browser: false, | |
| driver_url: None, | |
| browser_url: None, | |
| })) | |
| } | |
| fn create_latest_release_url(&self) -> String { | |
| format!( | |
| "{}{}", | |
| self.get_driver_mirror_url_or_default(DRIVER_URL), | |
| LATEST_RELEASE | |
| ) | |
| } | |
| fn create_latest_release_with_version_url(&self) -> String { | |
| format!( | |
| "{}{}_{}", | |
| self.get_driver_mirror_url_or_default(DRIVER_URL), | |
| LATEST_RELEASE, | |
| self.get_major_browser_version() | |
| ) | |
| } | |
| fn create_cft_url(&self, base_url: &str, endpoint: &str) -> String { | |
| format!("{}{}", base_url, endpoint) | |
| } | |
| fn create_cft_url_for_browsers(&self, endpoint: &str) -> String { | |
| self.create_cft_url(&self.get_browser_mirror_url_or_default(CFT_URL), endpoint) | |
| } | |
| fn create_cft_url_for_drivers(&self, endpoint: &str) -> String { | |
| self.create_cft_url(&self.get_driver_mirror_url_or_default(CFT_URL), endpoint) | |
| } | |
| fn find_platform_url<'a>(&self, downloads: &'a [PlatformUrl]) -> Option<&'a str> { | |
| downloads | |
| .iter() | |
| .find(|p| p.platform.eq_ignore_ascii_case(self.get_platform_label())) | |
| .map(|p| p.url.as_str()) | |
| } | |
| // CfT publishes Linux arm64 binaries later than the rest of the platforms, so the minimum | |
| // version available for download is higher there than the general CfT minimum. | |
| fn min_version_for_platform(&self, min_cft_version: i32) -> i32 { | |
| if LINUX.is(self.get_os()) && ARM64.is(self.get_arch()) { | |
| MIN_CHROME_VERSION_LINUX_ARM64.max(min_cft_version) | |
| } else { | |
| min_cft_version | |
| } | |
| } | |
| fn request_driver_version_from_latest(&self, driver_url: &str) -> Result<String, Error> { | |
| self.log.debug(format!( | |
| "Reading {} version from {}", | |
| &self.driver_name, driver_url | |
| )); | |
| read_version_from_link(self.get_http_client()?, driver_url, self.get_logger()) | |
| } | |
| fn request_versions_from_online<T>(&self, driver_url: &str) -> Result<T, Error> | |
| where | |
| T: Serialize + for<'a> Deserialize<'a>, | |
| { | |
| self.log | |
| .debug(format!("Discovering versions from {}", driver_url)); | |
| parse_json_from_url::<T>(self.get_http_client()?, driver_url) | |
| } | |
| fn request_latest_driver_version_from_online(&mut self) -> Result<String, Error> { | |
| let driver_name = self.driver_name; | |
| self.get_logger().trace(format!( | |
| "Using Chrome for Testing (CfT) endpoints to find out latest stable {} version", | |
| driver_name | |
| )); | |
| let latest_versions_url = self.create_cft_url_for_drivers(LATEST_VERSIONS_ENDPOINT); | |
| let versions_with_downloads = | |
| self.request_versions_from_online::<LatestVersionsWithDownloads>(&latest_versions_url)?; | |
| let stable_channel = versions_with_downloads.channels.stable; | |
| let chromedriver = stable_channel.downloads.chromedriver; | |
| if chromedriver.is_none() { | |
| self.log.warn(format!( | |
| "Latest stable version of {} not found using CfT endpoints. Trying with {}", | |
| &self.driver_name, LATEST_RELEASE | |
| )); | |
| return self.request_driver_version_from_latest(&self.create_latest_release_url()); | |
| } | |
| let platform_url = self.find_platform_url(chromedriver.as_ref().unwrap()); | |
| self.log.trace(format!( | |
| "CfT URL for downloading {}: {:?}", | |
| self.get_driver_name(), | |
| platform_url | |
| )); | |
| match platform_url { | |
| Some(url) => self.driver_url = Some(url.to_string()), | |
| None => return self.unavailable_discovery(), | |
| } | |
| Ok(stable_channel.version) | |
| } | |
| fn request_good_driver_version_from_online(&mut self) -> Result<String, Error> { | |
| let version_for_filtering = if self.is_driver_version_specific() { | |
| self.get_driver_version().to_string() | |
| } else { | |
| let browser_or_driver_version = if self.get_driver_version().is_empty() { | |
| self.get_browser_version() | |
| } else { | |
| self.get_driver_version() | |
| }; | |
| self.get_major_version(browser_or_driver_version)? | |
| }; | |
| self.log.trace(format!( | |
| "Driver version used to request CfT: {version_for_filtering}" | |
| )); | |
| let good_versions_url = self.create_cft_url_for_drivers(GOOD_VERSIONS_ENDPOINT); | |
| let all_versions = | |
| self.request_versions_from_online::<VersionsWithDownloads>(&good_versions_url)?; | |
| // Not every version is published for every platform, so the availability of a download | |
| // for the current platform is part of the filter (and not a later check) to let the most | |
| // recent usable version win | |
| let filtered_versions: Vec<Version> = all_versions | |
| .versions | |
| .into_iter() | |
| .filter(|r| { | |
| r.version.starts_with(version_for_filtering.as_str()) | |
| && r.downloads | |
| .chromedriver | |
| .as_deref() | |
| .is_some_and(|d| self.find_platform_url(d).is_some()) | |
| }) | |
| .collect(); | |
| if filtered_versions.is_empty() { | |
| return Err(anyhow!(format!( | |
| "{}. Check available versions at {}", | |
| format_four_args( | |
| UNAVAILABLE_DOWNLOAD_WITH_MIN_VERSION_ERR_MSG, | |
| self.get_driver_name(), | |
| version_for_filtering.as_str(), | |
| self.get_arch(), | |
| &self | |
| .min_version_for_platform(MIN_CHROMEDRIVER_VERSION_CFT) | |
| .to_string(), | |
| ), | |
| CFT_URL | |
| ))); | |
| } | |
| let driver_version = filtered_versions.last().unwrap(); | |
| let url = driver_version | |
| .downloads | |
| .chromedriver | |
| .as_deref() | |
| .and_then(|d| self.find_platform_url(d)); | |
| self.log.trace(format!("URL for CfT: {:?}", url)); | |
| match url { | |
| Some(url) => self.driver_url = Some(url.to_string()), | |
| None => return self.unavailable_discovery(), | |
| } | |
| Ok(driver_version.version.to_string()) | |
| } | |
| } | |
| impl SeleniumManager for ChromeManager { | |
| // Chrome's sandboxed services need an AppContainer ACL on the install directory, which the | |
| // installer normally grants; setup.exe ships in the CfT zip to grant it on an unpacked copy. | |
| fn configure_browser_in_cache(&self, browser_path_in_cache: &Path) { | |
| let setup = browser_path_in_cache.join("setup.exe"); | |
| if !WINDOWS.is(self.get_os()) || !setup.exists() { | |
| return; | |
| } | |
| let argument = format!( | |
| "--configure-browser-in-directory={}", | |
| browser_path_in_cache.display() | |
| ); | |
| self.get_logger() | |
| .debug(format!("Running command: {} {}", setup.display(), argument)); | |
| let outcome = match Command::new(&setup).arg(&argument).status() { | |
| Ok(status) if status.success() => return, | |
| Ok(status) => format!("setup.exe exited with {status}"), | |
| Err(err) => err.to_string(), | |
| }; | |
| self.get_logger() | |
| .warn(format!("Unable to configure the Chrome sandbox: {outcome}")); | |
| } | |
| fn get_browser_name(&self) -> &str { | |
| self.browser_name | |
| } | |
| fn get_browser_names_in_path(&self) -> Vec<&str> { | |
| vec![ | |
| self.get_browser_name(), | |
| "google-chrome", | |
| "chromium", | |
| "chromium-browser", | |
| ] | |
| } | |
| fn detect_browser_in_known_locations(&self) -> Option<PathBuf> { | |
| // chromedriver's fixed directory search (chrome_finder.cc) is Linux-only. | |
| if !LINUX.is(self.get_os()) { | |
| return None; | |
| } | |
| first_existing_path(CHROME_KNOWN_DIRS, CHROME_KNOWN_NAMES) | |
| } | |
| 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::from([ | |
| ( | |
| BrowserPath::new(WINDOWS, STABLE), | |
| r"Google\Chrome\Application\chrome.exe", | |
| ), | |
| ( | |
| BrowserPath::new(WINDOWS, BETA), | |
| r"Google\Chrome Beta\Application\chrome.exe", | |
| ), | |
| ( | |
| BrowserPath::new(WINDOWS, DEV), | |
| r"Google\Chrome Dev\Application\chrome.exe", | |
| ), | |
| ( | |
| BrowserPath::new(WINDOWS, NIGHTLY), | |
| r"Google\Chrome SxS\Application\chrome.exe", | |
| ), | |
| ( | |
| BrowserPath::new(MACOS, STABLE), | |
| "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome", | |
| ), | |
| ( | |
| BrowserPath::new(MACOS, BETA), | |
| "/Applications/Google Chrome Beta.app/Contents/MacOS/Google Chrome Beta", | |
| ), | |
| ( | |
| BrowserPath::new(MACOS, DEV), | |
| "/Applications/Google Chrome Dev.app/Contents/MacOS/Google Chrome Dev", | |
| ), | |
| ( | |
| BrowserPath::new(MACOS, NIGHTLY), | |
| "/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary", | |
| ), | |
| (BrowserPath::new(LINUX, STABLE), "/usr/bin/google-chrome"), | |
| (BrowserPath::new(LINUX, BETA), "/usr/bin/google-chrome-beta"), | |
| ( | |
| BrowserPath::new(LINUX, DEV), | |
| "/usr/bin/google-chrome-unstable", | |
| ), | |
| ]) | |
| } | |
| fn discover_browser_version(&mut self) -> Result<Option<String>, Error> { | |
| self.general_discover_browser_version( | |
| r"HKCU\Software\Google\Chrome\BLBeacon", | |
| REG_VERSION_ARG, | |
| DASH_DASH_VERSION, | |
| ) | |
| } | |
| fn get_driver_name(&self) -> &str { | |
| self.driver_name | |
| } | |
| fn request_driver_version(&mut self) -> Result<String, Error> { | |
| 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 major_browser_version_int = | |
| major_browser_version.parse::<i32>().unwrap_or_default(); | |
| let driver_version = if self.is_browser_version_stable() | |
| || major_browser_version.is_empty() | |
| || self.is_browser_version_unstable() | |
| { | |
| // For discovering the latest driver version, the CfT endpoints are also used | |
| self.request_latest_driver_version_from_online()? | |
| } else if !major_browser_version.is_empty() | |
| && major_browser_version_int < MIN_CHROMEDRIVER_VERSION_CFT | |
| { | |
| // For old versions (chromedriver 114-), the traditional method should work: | |
| // https://chromedriver.chromium.org/downloads | |
| self.request_driver_version_from_latest( | |
| &self.create_latest_release_with_version_url(), | |
| )? | |
| } else { | |
| // As of chromedriver 115+, the metadata for version discovery are published | |
| // by the "Chrome for Testing" (CfT) JSON endpoints: | |
| // https://googlechromelabs.github.io/chrome-for-testing/ | |
| self.request_good_driver_version_from_online()? | |
| }; | |
| let driver_ttl = self.get_ttl(); | |
| if should_cache_driver_version(driver_ttl, major_browser_version, &driver_version) { | |
| 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> { | |
| self.general_request_browser_version(self.browser_name) | |
| } | |
| fn get_driver_url(&mut self) -> Result<String, Error> { | |
| let major_driver_version = self | |
| .get_major_driver_version() | |
| .parse::<i32>() | |
| .unwrap_or_default(); | |
| if major_driver_version >= MIN_CHROMEDRIVER_VERSION_CFT && self.driver_url.is_none() { | |
| // This case happens when driver_version is set (e.g. using CLI flag) | |
| self.request_good_driver_version_from_online()?; | |
| } | |
| // As of Chrome 115+, the driver URL is already gathered thanks to the CfT endpoints | |
| if self.driver_url.is_some() { | |
| return Ok(self.driver_url.as_ref().unwrap().to_string()); | |
| } | |
| let driver_version = self.get_driver_version(); | |
| let os = self.get_os(); | |
| let arch = self.get_arch(); | |
| let driver_label = if WINDOWS.is(os) { | |
| "win32" | |
| } else if MACOS.is(os) { | |
| if ARM64.is(arch) { | |
| // As of chromedriver 106, the naming convention for macOS ARM64 releases changed. See: | |
| // https://groups.google.com/g/chromedriver-users/c/JRuQzH3qr2c | |
| if major_driver_version < 106 { | |
| "mac64_m1" | |
| } else { | |
| "mac_arm64" | |
| } | |
| } else { | |
| "mac64" | |
| } | |
| } else if LINUX.is(os) && ARM64.is(arch) { | |
| // This URL scheme only serves chromedriver 114-, which was never published for Linux | |
| // arm64. Newer versions are served by the CfT endpoints and never reach this point. | |
| return Err(anyhow!(format!( | |
| "Linux arm64 requires {} {} or above", | |
| self.driver_name, MIN_CHROME_VERSION_LINUX_ARM64 | |
| ))); | |
| } else { | |
| "linux64" | |
| }; | |
| Ok(format!( | |
| "{}{}/{}_{}.zip", | |
| self.get_driver_mirror_url_or_default(DRIVER_URL), | |
| driver_version, | |
| self.driver_name, | |
| driver_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" } else { "win64" } | |
| } else if MACOS.is(os) { | |
| if ARM64.is(arch) { | |
| "mac-arm64" | |
| } else { | |
| "mac-x64" | |
| } | |
| } else if ARM64.is(arch) { | |
| "linux-arm64" | |
| } else { | |
| "linux64" | |
| } | |
| } | |
| fn request_latest_browser_version_from_online( | |
| &mut self, | |
| _browser_version: &str, | |
| ) -> Result<String, Error> { | |
| let browser_name = self.browser_name; | |
| self.get_logger().trace(format!( | |
| "Using Chrome for Testing (CfT) endpoints to find out latest stable {} version", | |
| browser_name | |
| )); | |
| let latest_versions_url = self.create_cft_url_for_browsers(LATEST_VERSIONS_ENDPOINT); | |
| let versions_with_downloads = | |
| self.request_versions_from_online::<LatestVersionsWithDownloads>(&latest_versions_url)?; | |
| let stable_channel = versions_with_downloads.channels.stable; | |
| let platform_url = self.find_platform_url(&stable_channel.downloads.chrome); | |
| self.log.trace(format!( | |
| "CfT URL for downloading {}: {:?}", | |
| self.get_browser_name(), | |
| platform_url | |
| )); | |
| match platform_url { | |
| Some(url) => self.browser_url = Some(url.to_string()), | |
| None => return self.unavailable_discovery(), | |
| } | |
| Ok(stable_channel.version) | |
| } | |
| fn request_fixed_browser_version_from_online( | |
| &mut self, | |
| _browser_version: &str, | |
| ) -> Result<String, Error> { | |
| let browser_name = self.browser_name; | |
| let browser_version = self.get_browser_version().to_string(); | |
| let major_browser_version = self.get_major_browser_version(); | |
| self.get_logger().trace(format!( | |
| "Using Chrome for Testing (CfT) endpoints to find out {} {}", | |
| browser_name, major_browser_version | |
| )); | |
| if self.is_browser_version_unstable() { | |
| let latest_versions_url = self.create_cft_url_for_browsers(LATEST_VERSIONS_ENDPOINT); | |
| let versions_with_downloads = self | |
| .request_versions_from_online::<LatestVersionsWithDownloads>( | |
| &latest_versions_url, | |
| )?; | |
| let channel = if browser_version.eq_ignore_ascii_case(BETA) { | |
| versions_with_downloads.channels.beta | |
| } else if browser_version.eq_ignore_ascii_case(DEV) { | |
| versions_with_downloads.channels.dev | |
| } else { | |
| versions_with_downloads.channels.canary | |
| }; | |
| let platform_url = self.find_platform_url(&channel.downloads.chrome); | |
| match platform_url { | |
| Some(url) => self.browser_url = Some(url.to_string()), | |
| None => return self.unavailable_discovery(), | |
| } | |
| Ok(channel.version) | |
| } else { | |
| let good_versions_url = self.create_cft_url_for_browsers(GOOD_VERSIONS_ENDPOINT); | |
| let all_versions = | |
| self.request_versions_from_online::<VersionsWithDownloads>(&good_versions_url)?; | |
| let version_matches = |r: &Version| { | |
| if self.is_browser_version_specific() { | |
| r.version.eq(browser_version.as_str()) | |
| } else { | |
| r.version.starts_with(major_browser_version.as_str()) | |
| } | |
| }; | |
| // Not every version is published for every platform, so the availability of a download | |
| // for the current platform is part of the filter (and not a later check) to let the | |
| // most recent usable version win | |
| let filtered_versions: Vec<Version> = all_versions | |
| .versions | |
| .into_iter() | |
| .filter(|r| { | |
| version_matches(r) && self.find_platform_url(&r.downloads.chrome).is_some() | |
| }) | |
| .collect(); | |
| if filtered_versions.is_empty() { | |
| return self.unavailable_download(); | |
| } | |
| let last_browser = filtered_versions.last().unwrap(); | |
| let platform_url = self.find_platform_url(&last_browser.downloads.chrome); | |
| match platform_url { | |
| Some(url) => self.browser_url = Some(url.to_string()), | |
| None => return self.unavailable_discovery(), | |
| } | |
| Ok(last_browser.version.to_string()) | |
| } | |
| } | |
| fn get_min_browser_version_for_download(&self) -> Result<i32, Error> { | |
| Ok(self.min_version_for_platform(MIN_CHROME_VERSION_CFT)) | |
| } | |
| fn get_browser_binary_path(&mut self, _browser_version: &str) -> Result<PathBuf, Error> { | |
| let browser_in_cache = self.get_browser_path_in_cache()?; | |
| if MACOS.is(self.get_os()) { | |
| Ok(browser_in_cache.join(CFT_MACOS_APP_NAME)) | |
| } else { | |
| Ok(browser_in_cache.join(self.get_browser_name_with_extension())) | |
| } | |
| } | |
| fn get_browser_url_for_download(&mut self, browser_version: &str) -> Result<String, Error> { | |
| if let Some(browser_url) = self.browser_url.clone() { | |
| Ok(browser_url) | |
| } else { | |
| if self.is_browser_version_stable() || self.is_browser_version_empty() { | |
| self.request_latest_browser_version_from_online(browser_version)?; | |
| } else { | |
| self.request_fixed_browser_version_from_online(browser_version)?; | |
| } | |
| Ok(self.browser_url.clone().unwrap()) | |
| } | |
| } | |
| fn get_browser_label_for_download( | |
| &self, | |
| _browser_version: &str, | |
| ) -> Result<Option<&str>, Error> { | |
| Ok(None) | |
| } | |
| fn get_browser_versions_url(&self) -> &str { | |
| CFT_URL | |
| } | |
| 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 { | |
| LINUX.is(self.get_os()) | |
| && (browser_path.eq(CHROMIUM_SNAP_LINK) || browser_path.eq(CHROMIUM_SNAP_BINARY)) | |
| } | |
| fn get_snap_path(&self) -> Option<PathBuf> { | |
| Some(Path::new(CHROMIUM_SNAP_BINARY).to_path_buf()) | |
| } | |
| } | |
| #[derive(Serialize, Deserialize)] | |
| pub struct LatestVersionsWithDownloads { | |
| pub timestamp: String, | |
| pub channels: Channels, | |
| } | |
| #[derive(Serialize, Deserialize)] | |
| pub struct Channels { | |
| #[serde(rename = "Stable")] | |
| pub stable: Channel, | |
| #[serde(rename = "Beta")] | |
| pub beta: Channel, | |
| #[serde(rename = "Dev")] | |
| pub dev: Channel, | |
| #[serde(rename = "Canary")] | |
| pub canary: Channel, | |
| } | |
| #[derive(Serialize, Deserialize, Debug)] | |
| pub struct Channel { | |
| pub channel: String, | |
| pub version: String, | |
| pub revision: String, | |
| pub downloads: Downloads, | |
| } | |
| #[derive(Serialize, Deserialize, Debug)] | |
| pub struct VersionsWithDownloads { | |
| pub timestamp: String, | |
| pub versions: Vec<Version>, | |
| } | |
| #[derive(Serialize, Deserialize, Debug)] | |
| pub struct Version { | |
| pub version: String, | |
| pub revision: String, | |
| pub downloads: Downloads, | |
| } | |
| #[derive(Serialize, Deserialize, Debug)] | |
| pub struct Downloads { | |
| pub chrome: Vec<PlatformUrl>, | |
| pub chromedriver: Option<Vec<PlatformUrl>>, | |
| } | |
| #[derive(Serialize, Deserialize, Debug)] | |
| pub struct PlatformUrl { | |
| pub platform: String, | |
| pub url: String, | |
| } |