| // 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 anyhow::Error; | |
| use clap::Parser; | |
| use exitcode::DATAERR; | |
| use exitcode::OK; | |
| use exitcode::UNAVAILABLE; | |
| use selenium_manager::TTL_SEC; | |
| use selenium_manager::config::{BooleanKey, CACHE_PATH_KEY, StringKey}; | |
| use selenium_manager::grid::GridManager; | |
| use selenium_manager::lock::clear_lock_if_required; | |
| use selenium_manager::logger::{BROWSER_PATH, DRIVER_PATH, Logger}; | |
| use selenium_manager::metadata::clear_metadata; | |
| use selenium_manager::rules::write_rules_file; | |
| use selenium_manager::skills::write_skills_file; | |
| use selenium_manager::{ | |
| CACHE_TTL_DAYS, SeleniumManager, clear_cache, format_error, get_manager_by_browser, | |
| get_manager_by_driver, prune_old_cache_entries, | |
| }; | |
| use selenium_manager::{REQUEST_TIMEOUT_SEC, SM_BETA_LABEL}; | |
| use std::backtrace::{Backtrace, BacktraceStatus}; | |
| use std::path::Path; | |
| use std::process::exit; | |
| use std::sync::mpsc::Receiver; | |
| const LICENSE: &str = include_str!("../LICENSE"); | |
| const NOTICE: &str = include_str!("../NOTICE"); | |
| /// Automated driver management for Selenium | |
| #[derive(Parser, Debug)] | |
| #[clap(version, about, long_about = None, help_template = "\ | |
| {name} {version} | |
| {about-with-newline} | |
| {usage-heading} {usage} | |
| {all-args}")] | |
| struct Cli { | |
| /// Browser name (chrome, firefox, edge, iexplorer, safari, safaritp, webview2, or electron) | |
| #[clap(long, value_parser)] | |
| browser: Option<String>, | |
| /// Driver name (chromedriver, geckodriver, msedgedriver, IEDriverServer, or safaridriver) | |
| #[clap(long, value_parser)] | |
| driver: Option<String>, | |
| /// Selenium Grid. If version is not provided, the latest version is downloaded | |
| #[clap(long, value_parser, num_args = 0..=1, default_missing_value = "", value_name = "GRID_VERSION")] | |
| grid: Option<String>, | |
| /// Driver version (e.g., 106.0.5249.61, 0.31.0, etc.) | |
| #[clap(long, value_parser)] | |
| driver_version: Option<String>, | |
| /// Major browser version (e.g., 105, 106, etc. Also: beta, dev, canary -or nightly-, | |
| /// and esr -in Firefox- are accepted) | |
| #[clap(long, value_parser)] | |
| browser_version: Option<String>, | |
| /// 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") | |
| #[clap(long, value_parser)] | |
| browser_path: Option<String>, | |
| /// Mirror for driver repositories (e.g., https://registry.npmmirror.com/-/binary/chromedriver/) | |
| #[clap(long, value_parser)] | |
| driver_mirror_url: Option<String>, | |
| /// Mirror for browser repositories | |
| #[clap(long, value_parser)] | |
| browser_mirror_url: Option<String>, | |
| /// Output type: LOGGER (using INFO, WARN, etc.), JSON (custom JSON notation), SHELL (Unix-like), | |
| /// or MIXED (INFO, WARN, DEBUG, etc. to stderr and minimal JSON to stdout) | |
| #[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>, | |
| /// Disable TLS certificate validation for network requests (not recommended; use only when | |
| /// the required CA cannot be added to the system trust store) | |
| #[clap(long)] | |
| insecure: bool, | |
| /// Timeout for network requests (in seconds) | |
| #[clap(long, value_parser, default_value_t = REQUEST_TIMEOUT_SEC)] | |
| timeout: u64, | |
| /// TTL (time-to-live) for discovered versions (online) of drivers and browsers | |
| #[clap(long, value_parser, default_value_t = TTL_SEC)] | |
| ttl: u64, | |
| /// Local folder used to store downloaded assets (drivers and browsers), local metadata, | |
| /// and configuration file [default: ~/.cache/selenium] | |
| #[clap(long, value_parser)] | |
| cache_path: Option<String>, | |
| /// Clear cache folder (~/.cache/selenium) | |
| #[clap(long)] | |
| clear_cache: bool, | |
| /// Clear metadata file (~/.cache/selenium/selenium-manager.json) | |
| #[clap(long)] | |
| clear_metadata: bool, | |
| /// Display DEBUG messages | |
| #[clap(long)] | |
| debug: bool, | |
| /// Display TRACE messages | |
| #[clap(long)] | |
| trace: bool, | |
| /// Level for output messages. The possible values are: info, debug, trace, warn, error | |
| #[clap(long)] | |
| log_level: Option<String>, | |
| /// Offline mode (i.e., disabling network requests and downloads) | |
| #[clap(long)] | |
| offline: bool, | |
| /// Force to download browser (even when browser is already in the system) | |
| #[clap(long)] | |
| force_browser_download: bool, | |
| /// Avoid to download browser (even when browser-version is specified) | |
| #[clap(long)] | |
| avoid_browser_download: bool, | |
| /// Selenium language bindings that invokes Selenium Manager (e.g., Java, JavaScript, Python, | |
| /// DotNet, Ruby) | |
| #[clap(long)] | |
| language_binding: Option<String>, | |
| /// Avoid sends usage statistics to plausible.io | |
| #[clap(long)] | |
| avoid_stats: bool, | |
| /// Not using drivers found in the PATH | |
| #[clap(long)] | |
| skip_driver_in_path: bool, | |
| /// Not using browsers found in the PATH | |
| #[clap(long)] | |
| skip_browser_in_path: bool, | |
| /// Print the license and copyright notices | |
| #[clap(long)] | |
| license: bool, | |
| /// Add a skills file with Selenium best practices to the repository | |
| #[clap(long, value_name = "FILE_NAME", num_args = 0..=1, default_missing_value = "")] | |
| init_skills: Option<String>, | |
| /// Add a rules file with Selenium guidance for LLM coding assistants to the repository | |
| #[clap(long, value_name = "FILE_NAME", num_args = 0..=1, default_missing_value = "")] | |
| init_rules: Option<String>, | |
| } | |
| fn main() { | |
| let mut cli = Cli::parse(); | |
| if cli.license { | |
| print!("{}\n{}", LICENSE, NOTICE); | |
| return; | |
| } | |
| let debug = cli.debug || BooleanKey("debug", false).get_value(); | |
| let trace = cli.trace || BooleanKey("trace", false).get_value(); | |
| let log_level = StringKey(vec!["log-level"], &cli.log_level.unwrap_or_default()).get_value(); | |
| let log = Logger::create(&cli.output, debug, trace, &log_level); | |
| if let Some(mut skills_file) = cli.init_skills { | |
| if skills_file.is_empty() { | |
| let default_path = Path::new("skills").join("skills.md"); | |
| if default_path.exists() { | |
| skills_file = "selenium.md".to_string(); | |
| } else { | |
| skills_file = default_path.to_string_lossy().to_string(); | |
| } | |
| } | |
| if let Err(err) = write_skills_file(Path::new(&skills_file), &log) { | |
| log.error(format!("Error creating {}: {}", skills_file, err)); | |
| flush_and_exit(DATAERR, &log, Some(err)); | |
| } | |
| log.info(format!("{} file successfully created", skills_file)); | |
| flush_and_exit(OK, &log, None); | |
| } | |
| if let Some(mut rules_file) = cli.init_rules { | |
| if rules_file.is_empty() { | |
| let default_path = Path::new("rules").join("selenium.md"); | |
| if default_path.exists() { | |
| rules_file = "selenium-rules.md".to_string(); | |
| } else { | |
| rules_file = default_path.to_string_lossy().to_string(); | |
| } | |
| } | |
| if let Err(err) = write_rules_file(Path::new(&rules_file), &log) { | |
| log.error(format!("Error creating {}: {}", rules_file, err)); | |
| flush_and_exit(DATAERR, &log, Some(err)); | |
| } | |
| log.info(format!("{} file successfully created", rules_file)); | |
| flush_and_exit(OK, &log, None); | |
| } | |
| let cache_path = | |
| StringKey(vec![CACHE_PATH_KEY], &cli.cache_path.unwrap_or_default()).get_value(); | |
| let grid = cli.grid; | |
| let mut browser_name: String = cli.browser.unwrap_or_default(); | |
| let mut driver_name: String = cli.driver.unwrap_or_default(); | |
| if browser_name.is_empty() { | |
| browser_name = StringKey(vec!["browser"], "").get_value(); | |
| } | |
| if driver_name.is_empty() { | |
| driver_name = StringKey(vec!["driver"], "").get_value(); | |
| } | |
| let mut selenium_manager: Box<dyn SeleniumManager> = if !browser_name.is_empty() { | |
| get_manager_by_browser(browser_name).unwrap_or_else(|err| { | |
| log.error(&err); | |
| flush_and_exit(DATAERR, &log, Some(err)); | |
| }) | |
| } else if !driver_name.is_empty() { | |
| get_manager_by_driver(driver_name).unwrap_or_else(|err| { | |
| log.error(&err); | |
| flush_and_exit(DATAERR, &log, Some(err)); | |
| }) | |
| } else if let Some(grid_value) = &grid { | |
| GridManager::new(grid_value.to_string()).unwrap_or_else(|err| { | |
| log.error(&err); | |
| flush_and_exit(DATAERR, &log, Some(err)); | |
| }) | |
| } else { | |
| log.error("You need to specify a browser or driver"); | |
| flush_and_exit(DATAERR, &log, None); | |
| }; | |
| if cli.offline { | |
| if cli.force_browser_download { | |
| log.warn("Offline flag set, but also asked to force downloads. Honouring offline flag"); | |
| } | |
| cli.force_browser_download = false; | |
| if !cli.avoid_browser_download { | |
| log.debug("Offline flag set, but also asked not to avoid browser downloads. Honouring offline flag"); | |
| } | |
| cli.avoid_browser_download = true; | |
| } | |
| // Logger set first so other setters can use it | |
| selenium_manager.set_logger(log); | |
| 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_driver_mirror_url(cli.driver_mirror_url.unwrap_or_default()); | |
| selenium_manager.set_browser_mirror_url(cli.browser_mirror_url.unwrap_or_default()); | |
| selenium_manager.set_os(cli.os.unwrap_or_default()); | |
| selenium_manager.set_arch(cli.arch.unwrap_or_default()); | |
| selenium_manager.set_ttl(cli.ttl); | |
| selenium_manager.set_force_browser_download(cli.force_browser_download); | |
| selenium_manager.set_avoid_browser_download(cli.avoid_browser_download); | |
| selenium_manager.set_cache_path(cache_path.clone()); | |
| selenium_manager.set_offline(cli.offline); | |
| selenium_manager.set_language_binding(cli.language_binding.unwrap_or_default()); | |
| let sm_version = clap::crate_version!(); | |
| let selenium_version = sm_version.strip_prefix(SM_BETA_LABEL).unwrap_or(sm_version); | |
| selenium_manager.set_selenium_version(selenium_version.to_string()); | |
| selenium_manager.set_avoid_stats(cli.avoid_stats); | |
| selenium_manager.set_skip_driver_in_path(cli.skip_driver_in_path); | |
| selenium_manager.set_skip_browser_in_path(cli.skip_browser_in_path); | |
| if cli.clear_cache || BooleanKey("clear-cache", false).get_value() { | |
| clear_cache(selenium_manager.get_logger(), &cache_path); | |
| } | |
| if cli.clear_metadata || BooleanKey("clear-metadata", false).get_value() { | |
| clear_metadata(selenium_manager.get_logger(), &cache_path); | |
| } | |
| prune_old_cache_entries(selenium_manager.get_logger(), &cache_path, CACHE_TTL_DAYS); | |
| selenium_manager | |
| .set_timeout(cli.timeout) | |
| .and_then(|_| selenium_manager.set_proxy(cli.proxy.unwrap_or_default())) | |
| .and_then(|_| selenium_manager.set_insecure(cli.insecure)) | |
| .and_then(|_| selenium_manager.stats()) | |
| .and_then(|_| selenium_manager.setup()) | |
| .map(|driver_path| { | |
| let log = selenium_manager.get_logger(); | |
| log_driver_and_browser_path( | |
| log, | |
| &driver_path, | |
| &selenium_manager.get_browser_path_or_latest_from_cache(), | |
| selenium_manager.get_receiver(), | |
| ); | |
| flush_and_exit(OK, log, None); | |
| }) | |
| .unwrap_or_else(|err| { | |
| let log = selenium_manager.get_logger(); | |
| let browser_path = selenium_manager.get_browser_path_or_latest_from_cache(); | |
| if selenium_manager.is_fallback_driver_from_cache() | |
| && let Some(best_driver_from_cache) = | |
| selenium_manager.find_best_driver_from_cache().unwrap() | |
| { | |
| log.debug_or_warn( | |
| format!( | |
| "There was an error managing {} ({}); using driver found in the cache", | |
| selenium_manager.get_driver_name(), | |
| format_error(&err) | |
| ), | |
| selenium_manager.is_offline(), | |
| ); | |
| log_driver_and_browser_path( | |
| log, | |
| &best_driver_from_cache, | |
| &browser_path, | |
| selenium_manager.get_receiver(), | |
| ); | |
| flush_and_exit(OK, log, Some(err)); | |
| } | |
| if selenium_manager.is_offline() { | |
| log.warn(&err); | |
| log_browser_path(&log, &browser_path); | |
| flush_and_exit(OK, log, Some(err)); | |
| } else { | |
| log.error(format_error(&err)); | |
| flush_and_exit(DATAERR, log, Some(err)); | |
| } | |
| }); | |
| } | |
| fn log_driver_and_browser_path( | |
| log: &Logger, | |
| driver_path: &Path, | |
| browser_path: &str, | |
| receiver: &Receiver<String>, | |
| ) { | |
| if let Ok(err) = receiver.try_recv() { | |
| log.warn(err); | |
| } | |
| if driver_path.exists() { | |
| log.info(format!("{}{}", DRIVER_PATH, driver_path.display())); | |
| } else { | |
| log.error(format!("Driver unavailable: {}", driver_path.display())); | |
| flush_and_exit(UNAVAILABLE, log, None); | |
| } | |
| log_browser_path(log, browser_path); | |
| } | |
| fn log_browser_path(log: &Logger, browser_path: &str) { | |
| if !browser_path.is_empty() { | |
| log.info(format!("{}{}", BROWSER_PATH, browser_path)); | |
| } | |
| } | |
| fn flush_and_exit(code: i32, log: &Logger, err: Option<Error>) -> ! { | |
| if let Some(error) = err { | |
| let backtrace = Backtrace::capture(); | |
| let backtrace_status = backtrace.status(); | |
| if backtrace_status == BacktraceStatus::Captured { | |
| log.debug(format!("Backtrace:\n{}", error.backtrace())); | |
| } | |
| } | |
| log.set_code(code); | |
| log.flush(); | |
| clear_lock_if_required(); | |
| exit(code); | |
| } |