From 2bb013f9baa927fc7b392766b0182b91380b9aa8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Thu, 15 Aug 2024 22:47:16 +0100 Subject: [PATCH] refactor: `version` module exports a single const struct (#25014) This commit rewrites the internal `version` module that exported various information about the current executable. Instead of exporting several consts, we are now exporting a single const structure that contains all the necessary information. This is the first step towards cleaning up how we use this information and should allow us to use SUI to be able to patch this information in already produced binary making it easier to cut new releases. --------- Co-authored-by: Divy Srivastava --- cli/args/flags.rs | 11 ++-- cli/args/mod.rs | 5 +- cli/build.rs | 12 +--- cli/cache/caches.rs | 8 ++- cli/cache/common.rs | 2 +- cli/cache/emit.rs | 2 +- cli/http_util.rs | 16 ++--- cli/lsp/language_server.rs | 2 +- cli/main.rs | 2 +- cli/shared.rs | 1 + cli/standalone/binary.rs | 29 ++++++---- cli/tools/bench/mod.rs | 1 - cli/tools/bench/reporters.rs | 10 +++- cli/tools/jupyter/server.rs | 4 +- cli/tools/repl/mod.rs | 2 +- cli/tools/upgrade.rs | 74 ++++++++++++++---------- cli/version.rs | 109 ++++++++++++++++++++++++----------- cli/worker.rs | 6 +- runtime/js/99_main.js | 53 ++++++++--------- runtime/ops/bootstrap.rs | 2 - runtime/worker_bootstrap.rs | 5 ++ 21 files changed, 214 insertions(+), 142 deletions(-) diff --git a/cli/args/flags.rs b/cli/args/flags.rs index 79a6fcbd4f8617..38953a388bae4e 100644 --- a/cli/args/flags.rs +++ b/cli/args/flags.rs @@ -1334,7 +1334,7 @@ static UNSTABLE_HEADING: &str = "Unstable"; pub fn clap_root() -> Command { let long_version = format!( "{} ({}, {})\nv8 {}\ntypescript {}", - crate::version::deno(), + crate::version::DENO_VERSION_INFO.deno, // TODO(bartlomieju): alter what's printed here. // I think it's best if we print as follows: // (+) (, , ) @@ -1346,14 +1346,17 @@ pub fn clap_root() -> Command { // v2.1.13-lts (LTS (long term support), release, aarch64-apple-darwin) // For canary it would be: // v1.46.0+25bb59d (canary, release, aarch64-apple-darwin) - if matches!(crate::version::RELEASE_CHANNEL, ReleaseChannel::Canary) { + if matches!( + crate::version::DENO_VERSION_INFO.release_channel, + ReleaseChannel::Canary + ) { "canary" } else { env!("PROFILE") }, env!("TARGET"), deno_core::v8_version(), - crate::version::TYPESCRIPT + crate::version::DENO_VERSION_INFO.typescript ); let mut cmd = run_args(Command::new("deno"), true) @@ -1368,7 +1371,7 @@ pub fn clap_root() -> Command { ) .color(ColorChoice::Auto) .term_width(800) - .version(crate::version::deno()) + .version(crate::version::DENO_VERSION_INFO.deno) .long_version(long_version) // cause --unstable flags to display at the bottom of the help text .next_display_order(1000) diff --git a/cli/args/mod.rs b/cli/args/mod.rs index 4a644cb09a3d1e..696d0e5606264d 100644 --- a/cli/args/mod.rs +++ b/cli/args/mod.rs @@ -1293,7 +1293,10 @@ impl CliOptions { return Ok(None); }; - Ok(Some(InspectorServer::new(host, version::get_user_agent())?)) + Ok(Some(InspectorServer::new( + host, + version::DENO_VERSION_INFO.user_agent, + )?)) } pub fn maybe_lockfile(&self) -> Option<&Arc> { diff --git a/cli/build.rs b/cli/build.rs index 4fe6fd1eabaeee..05636f7f9fba68 100644 --- a/cli/build.rs +++ b/cli/build.rs @@ -5,6 +5,7 @@ use std::path::PathBuf; use deno_core::snapshot::*; use deno_runtime::*; +mod shared; mod ts { use super::*; @@ -329,18 +330,7 @@ mod ts { fn create_cli_snapshot(snapshot_path: PathBuf) { use deno_runtime::ops::bootstrap::SnapshotOptions; - // NOTE(bartlomieju): keep in sync with `cli/version.rs`. - // Ideally we could deduplicate that code. - fn deno_version() -> String { - if env::var("DENO_CANARY").is_ok() { - format!("{}+{}", env!("CARGO_PKG_VERSION"), &git_commit_hash()[..7]) - } else { - env!("CARGO_PKG_VERSION").to_string() - } - } - let snapshot_options = SnapshotOptions { - deno_version: deno_version(), ts_version: ts::version(), v8_version: deno_core::v8_version(), target: std::env::var("TARGET").unwrap(), diff --git a/cli/cache/caches.rs b/cli/cache/caches.rs index 1be14b53bbc226..54371cee48bf1f 100644 --- a/cli/cache/caches.rs +++ b/cli/cache/caches.rs @@ -48,9 +48,13 @@ impl Caches { cell .get_or_init(|| { if let Some(path) = path { - CacheDB::from_path(config, path, crate::version::deno()) + CacheDB::from_path( + config, + path, + crate::version::DENO_VERSION_INFO.deno, + ) } else { - CacheDB::in_memory(config, crate::version::deno()) + CacheDB::in_memory(config, crate::version::DENO_VERSION_INFO.deno) } }) .clone() diff --git a/cli/cache/common.rs b/cli/cache/common.rs index a88ef8c9770378..0a68e95159a5a6 100644 --- a/cli/cache/common.rs +++ b/cli/cache/common.rs @@ -12,7 +12,7 @@ impl FastInsecureHasher { pub fn new_deno_versioned() -> Self { let mut hasher = Self::new_without_deno_version(); - hasher.write_str(crate::version::deno()); + hasher.write_str(crate::version::DENO_VERSION_INFO.deno); hasher } diff --git a/cli/cache/emit.rs b/cli/cache/emit.rs index fcec9e84b204e7..757df0b7566878 100644 --- a/cli/cache/emit.rs +++ b/cli/cache/emit.rs @@ -30,7 +30,7 @@ impl EmitCache { pub fn new(disk_cache: DiskCache) -> Self { Self { disk_cache, - cli_version: crate::version::deno(), + cli_version: crate::version::DENO_VERSION_INFO.deno, emit_failed_flag: Default::default(), } } diff --git a/cli/http_util.rs b/cli/http_util.rs index 9ec90dd61c18a3..cf244c525a81b1 100644 --- a/cli/http_util.rs +++ b/cli/http_util.rs @@ -2,7 +2,7 @@ use crate::auth_tokens::AuthToken; use crate::util::progress_bar::UpdateGuard; -use crate::version::get_user_agent; +use crate::version; use cache_control::Cachability; use cache_control::CacheControl; @@ -248,7 +248,7 @@ impl HttpClientProvider { Entry::Occupied(entry) => Ok(HttpClient::new(entry.get().clone())), Entry::Vacant(entry) => { let client = create_http_client( - get_user_agent(), + version::DENO_VERSION_INFO.user_agent, CreateHttpClientOptions { root_cert_store: match &self.root_cert_store_provider { Some(provider) => Some(provider.get_or_try_init()?.clone()), @@ -948,7 +948,7 @@ mod test { let client = HttpClient::new( create_http_client( - version::get_user_agent(), + version::DENO_VERSION_INFO.user_agent, CreateHttpClientOptions { ca_certs: vec![std::fs::read( test_util::testdata_path().join("tls/RootCA.pem"), @@ -1000,7 +1000,7 @@ mod test { let client = HttpClient::new( create_http_client( - version::get_user_agent(), + version::DENO_VERSION_INFO.user_agent, CreateHttpClientOptions::default(), ) .unwrap(), @@ -1059,7 +1059,7 @@ mod test { let client = HttpClient::new( create_http_client( - version::get_user_agent(), + version::DENO_VERSION_INFO.user_agent, CreateHttpClientOptions { root_cert_store: Some(root_cert_store), ..Default::default() @@ -1108,7 +1108,7 @@ mod test { .unwrap(); let client = HttpClient::new( create_http_client( - version::get_user_agent(), + version::DENO_VERSION_INFO.user_agent, CreateHttpClientOptions { ca_certs: vec![std::fs::read( test_util::testdata_path() @@ -1149,7 +1149,7 @@ mod test { let url = Url::parse("https://localhost:5545/etag_script.ts").unwrap(); let client = HttpClient::new( create_http_client( - version::get_user_agent(), + version::DENO_VERSION_INFO.user_agent, CreateHttpClientOptions { ca_certs: vec![std::fs::read( test_util::testdata_path() @@ -1205,7 +1205,7 @@ mod test { .unwrap(); let client = HttpClient::new( create_http_client( - version::get_user_agent(), + version::DENO_VERSION_INFO.user_agent, CreateHttpClientOptions { ca_certs: vec![std::fs::read( test_util::testdata_path() diff --git a/cli/lsp/language_server.rs b/cli/lsp/language_server.rs index 6fa079bd833715..ff3a7f0c686b56 100644 --- a/cli/lsp/language_server.rs +++ b/cli/lsp/language_server.rs @@ -691,7 +691,7 @@ impl Inner { let version = format!( "{} ({}, {})", - crate::version::deno(), + crate::version::DENO_VERSION_INFO.deno, env!("PROFILE"), env!("TARGET") ); diff --git a/cli/main.rs b/cli/main.rs index 48e78becb21e88..9b141c53676865 100644 --- a/cli/main.rs +++ b/cli/main.rs @@ -314,7 +314,7 @@ fn setup_panic_hook() { eprintln!("var set and include the backtrace in your report."); eprintln!(); eprintln!("Platform: {} {}", env::consts::OS, env::consts::ARCH); - eprintln!("Version: {}", version::deno()); + eprintln!("Version: {}", version::DENO_VERSION_INFO.deno); eprintln!("Args: {:?}", env::args().collect::>()); eprintln!(); orig_hook(panic_info); diff --git a/cli/shared.rs b/cli/shared.rs index 36e7e1d01e37f0..d9375814e2cdd9 100644 --- a/cli/shared.rs +++ b/cli/shared.rs @@ -1,5 +1,6 @@ // Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. +/// This module is shared between build script and the binaries. Use it sparsely. use deno_core::anyhow::bail; use deno_core::error::AnyError; diff --git a/cli/standalone/binary.rs b/cli/standalone/binary.rs index bbb3a66c1cb093..168310efd31d13 100644 --- a/cli/standalone/binary.rs +++ b/cli/standalone/binary.rs @@ -417,18 +417,23 @@ impl<'a> DenoCompileBinaryWriter<'a> { let target = compile_flags.resolve_target(); let binary_name = format!("denort-{target}.zip"); - let binary_path_suffix = match crate::version::RELEASE_CHANNEL { - ReleaseChannel::Canary => { - format!("canary/{}/{}", crate::version::GIT_COMMIT_HASH, binary_name) - } - ReleaseChannel::Stable => { - format!("release/v{}/{}", env!("CARGO_PKG_VERSION"), binary_name) - } - _ => bail!( - "`deno compile` current doesn't support {} release channel", - crate::version::RELEASE_CHANNEL.name() - ), - }; + let binary_path_suffix = + match crate::version::DENO_VERSION_INFO.release_channel { + ReleaseChannel::Canary => { + format!( + "canary/{}/{}", + crate::version::DENO_VERSION_INFO.git_hash, + binary_name + ) + } + ReleaseChannel::Stable => { + format!("release/v{}/{}", env!("CARGO_PKG_VERSION"), binary_name) + } + _ => bail!( + "`deno compile` current doesn't support {} release channel", + crate::version::DENO_VERSION_INFO.release_channel.name() + ), + }; let download_directory = self.deno_dir.dl_folder_path(); let binary_path = download_directory.join(&binary_path_suffix); diff --git a/cli/tools/bench/mod.rs b/cli/tools/bench/mod.rs index 9cf222c45d32dc..44ae8321d281e3 100644 --- a/cli/tools/bench/mod.rs +++ b/cli/tools/bench/mod.rs @@ -13,7 +13,6 @@ use crate::util::file_watcher; use crate::util::fs::collect_specifiers; use crate::util::path::is_script_ext; use crate::util::path::matches_pattern_or_exact_path; -use crate::version::get_user_agent; use crate::worker::CliMainWorkerFactory; use deno_config::glob::WalkEntry; diff --git a/cli/tools/bench/reporters.rs b/cli/tools/bench/reporters.rs index 690373dc8d4915..9a1da04ec045d1 100644 --- a/cli/tools/bench/reporters.rs +++ b/cli/tools/bench/reporters.rs @@ -2,6 +2,8 @@ use serde::Serialize; +use crate::version; + use super::*; pub trait BenchReporter { @@ -25,7 +27,11 @@ struct JsonReporterOutput { impl Default for JsonReporterOutput { fn default() -> Self { Self { - runtime: format!("{} {}", get_user_agent(), env!("TARGET")), + runtime: format!( + "{} {}", + version::DENO_VERSION_INFO.user_agent, + env!("TARGET") + ), cpu: mitata::cpu::name(), benches: vec![], } @@ -150,7 +156,7 @@ impl BenchReporter for ConsoleReporter { "{}\n", colors::gray(format!( "runtime: deno {} ({})", - crate::version::deno(), + crate::version::DENO_VERSION_INFO.deno, env!("TARGET") )) ); diff --git a/cli/tools/jupyter/server.rs b/cli/tools/jupyter/server.rs index 42e341f21e96fc..bcfc522128a46c 100644 --- a/cli/tools/jupyter/server.rs +++ b/cli/tools/jupyter/server.rs @@ -670,10 +670,10 @@ fn kernel_info() -> messaging::KernelInfoReply { status: ReplyStatus::Ok, protocol_version: "5.3".to_string(), implementation: "Deno kernel".to_string(), - implementation_version: crate::version::deno().to_string(), + implementation_version: crate::version::DENO_VERSION_INFO.deno.to_string(), language_info: messaging::LanguageInfo { name: "typescript".to_string(), - version: crate::version::TYPESCRIPT.to_string(), + version: crate::version::DENO_VERSION_INFO.typescript.to_string(), mimetype: "text/x.typescript".to_string(), file_extension: ".ts".to_string(), pygments_lexer: "typescript".to_string(), diff --git a/cli/tools/repl/mod.rs b/cli/tools/repl/mod.rs index 9798a696740300..d754b4dd232e5d 100644 --- a/cli/tools/repl/mod.rs +++ b/cli/tools/repl/mod.rs @@ -242,7 +242,7 @@ pub async fn run( // Doing this manually, instead of using `log::info!` because these messages // are supposed to go to stdout, not stderr. if !cli_options.is_quiet() { - println!("Deno {}", crate::version::deno()); + println!("Deno {}", crate::version::DENO_VERSION_INFO.deno); println!("exit using ctrl+d, ctrl+c, or close()"); if repl_flags.is_default_command { println!( diff --git a/cli/tools/upgrade.rs b/cli/tools/upgrade.rs index 01239964c8a0f4..bd194554d67b64 100644 --- a/cli/tools/upgrade.rs +++ b/cli/tools/upgrade.rs @@ -140,7 +140,7 @@ impl VersionProvider for RealVersionProvider { } fn current_version(&self) -> Cow { - Cow::Borrowed(version::release_version_or_canary_commit_hash()) + Cow::Borrowed(version::DENO_VERSION_INFO.version_or_git_hash()) } // TODO(bartlomieju): update to handle `Lts` channel @@ -148,7 +148,10 @@ impl VersionProvider for RealVersionProvider { &self, ) -> Result { // TODO(bartlomieju): remove hitting a remote server - if matches!(version::RELEASE_CHANNEL, ReleaseChannel::Canary) { + if matches!( + version::DENO_VERSION_INFO.release_channel, + ReleaseChannel::Canary + ) { // If this fails for whatever reason, just return an empty vector. // It's better to miss that than throw error here. let rc_versions = get_rc_versions( @@ -160,7 +163,7 @@ impl VersionProvider for RealVersionProvider { let is_current_exe_an_rc = rc_versions .iter() - .any(|(hash, _)| hash == version::GIT_COMMIT_HASH); + .any(|(hash, _)| hash == version::DENO_VERSION_INFO.git_hash); if is_current_exe_an_rc { Ok(ReleaseChannel::Rc) @@ -338,7 +341,7 @@ pub fn check_for_upgrades( log::info!( "{} {} → {} {}", colors::green("A new release of Deno is available:"), - colors::cyan(version::deno()), + colors::cyan(version::DENO_VERSION_INFO.deno), colors::cyan(&upgrade_version), colors::italic_gray("Run `deno upgrade` to install it.") ); @@ -546,7 +549,7 @@ pub async fn upgrade( log::info!("Upgraded successfully (dry run)"); if !requested_version.is_canary() { print_release_notes( - version::deno(), + version::DENO_VERSION_INFO.deno, &selected_version_to_upgrade.version_or_hash, ); } @@ -569,7 +572,10 @@ pub async fn upgrade( colors::green(selected_version_to_upgrade.display()) ); if !requested_version.is_canary() { - print_release_notes(version::deno(), &selected_version_to_upgrade.display); + print_release_notes( + version::DENO_VERSION_INFO.deno, + &selected_version_to_upgrade.display, + ); } drop(temp_dir); // delete the temp dir @@ -638,15 +644,20 @@ fn select_specific_version_for_upgrade( ) -> Result, AnyError> { match release_channel { ReleaseChannel::Stable => { - let current_is_passed = - if !matches!(version::RELEASE_CHANNEL, ReleaseChannel::Canary) { - version::deno() == version - } else { - false - }; + let current_is_passed = if !matches!( + version::DENO_VERSION_INFO.release_channel, + ReleaseChannel::Canary + ) { + version::DENO_VERSION_INFO.deno == version + } else { + false + }; if !force && current_is_passed { - log::info!("Version {} is already installed", version::deno()); + log::info!( + "Version {} is already installed", + version::DENO_VERSION_INFO.deno + ); return Ok(None); } @@ -657,9 +668,12 @@ fn select_specific_version_for_upgrade( })) } ReleaseChannel::Canary => { - let current_is_passed = version::GIT_COMMIT_HASH == version; + let current_is_passed = version::DENO_VERSION_INFO.git_hash == version; if !force && current_is_passed { - log::info!("Version {} is already installed", version::deno()); + log::info!( + "Version {} is already installed", + version::DENO_VERSION_INFO.deno + ); return Ok(None); } @@ -693,17 +707,19 @@ async fn find_latest_version_to_upgrade( let (maybe_newer_latest_version, current_version) = match release_channel { ReleaseChannel::Stable => { - let current_version = version::deno(); - let current_is_most_recent = - if !matches!(version::RELEASE_CHANNEL, ReleaseChannel::Canary) { - let current = Version::parse_standard(current_version).unwrap(); - let latest = - Version::parse_standard(&latest_version_found.version_or_hash) - .unwrap(); - current >= latest - } else { - false - }; + let current_version = version::DENO_VERSION_INFO.deno; + let current_is_most_recent = if !matches!( + version::DENO_VERSION_INFO.release_channel, + ReleaseChannel::Canary + ) { + let current = Version::parse_standard(current_version).unwrap(); + let latest = + Version::parse_standard(&latest_version_found.version_or_hash) + .unwrap(); + current >= latest + } else { + false + }; if !force && current_is_most_recent { (None, current_version) @@ -712,7 +728,7 @@ async fn find_latest_version_to_upgrade( } } ReleaseChannel::Canary => { - let current_version = version::GIT_COMMIT_HASH; + let current_version = version::DENO_VERSION_INFO.git_hash; let current_is_most_recent = current_version == latest_version_found.version_or_hash; @@ -723,7 +739,7 @@ async fn find_latest_version_to_upgrade( } } ReleaseChannel::Rc => { - let current_version = version::GIT_COMMIT_HASH; + let current_version = version::DENO_VERSION_INFO.git_hash; let current_is_most_recent = current_version == latest_version_found.version_or_hash; @@ -1054,7 +1070,7 @@ impl CheckVersionFile { self.last_checked.to_rfc3339(), self.latest_version, self.current_version, - self.current_release_channel.serialize(), + self.current_release_channel.serialize() ) } diff --git a/cli/version.rs b/cli/version.rs index e4801e108ddd17..4a71d7090b60b1 100644 --- a/cli/version.rs +++ b/cli/version.rs @@ -1,47 +1,86 @@ // Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. +use once_cell::sync::Lazy; + use crate::shared::ReleaseChannel; -pub const GIT_COMMIT_HASH: &str = env!("GIT_COMMIT_HASH"); -pub const TYPESCRIPT: &str = env!("TS_VERSION"); +const GIT_COMMIT_HASH: &str = env!("GIT_COMMIT_HASH"); +const TYPESCRIPT: &str = env!("TS_VERSION"); +const CARGO_PKG_VERSION: &str = env!("CARGO_PKG_VERSION"); // TODO(bartlomieju): ideally we could remove this const. const IS_CANARY: bool = option_env!("DENO_CANARY").is_some(); -pub const RELEASE_CHANNEL: ReleaseChannel = if IS_CANARY { - ReleaseChannel::Canary -} else { - ReleaseChannel::Stable -}; - -pub fn deno() -> &'static str { - if IS_CANARY { - concat!( - env!("CARGO_PKG_VERSION"), - "+", - env!("GIT_COMMIT_HASH_SHORT") - ) - } else { - env!("CARGO_PKG_VERSION") - } -} -// Keep this in sync with `deno()` above -pub fn get_user_agent() -> &'static str { - if IS_CANARY { - concat!( - "Deno/", - env!("CARGO_PKG_VERSION"), - "+", - env!("GIT_COMMIT_HASH_SHORT") - ) - } else { - concat!("Deno/", env!("CARGO_PKG_VERSION")) +pub static DENO_VERSION_INFO: Lazy = Lazy::new(|| { + let release_channel = libsui::find_section("denover") + .and_then(|buf| std::str::from_utf8(buf).ok()) + .and_then(|str_| ReleaseChannel::deserialize(str_).ok()) + .unwrap_or({ + if IS_CANARY { + ReleaseChannel::Canary + } else { + ReleaseChannel::Stable + } + }); + + DenoVersionInfo { + // TODO(bartlomieju): fix further for RC and LTS releases + deno: if IS_CANARY { + concat!( + env!("CARGO_PKG_VERSION"), + "+", + env!("GIT_COMMIT_HASH_SHORT") + ) + } else { + env!("CARGO_PKG_VERSION") + }, + + release_channel, + + git_hash: GIT_COMMIT_HASH, + + // Keep in sync with `deno` field. + // TODO(bartlomieju): fix further for RC and LTS releases + user_agent: if IS_CANARY { + concat!( + "Deno/", + env!("CARGO_PKG_VERSION"), + "+", + env!("GIT_COMMIT_HASH_SHORT") + ) + } else { + concat!("Deno/", env!("CARGO_PKG_VERSION")) + }, + + typescript: TYPESCRIPT, } +}); + +pub struct DenoVersionInfo { + /// Human-readable version of the current Deno binary. + /// + /// For stable release, a semver, eg. `v1.46.2`. + /// For canary release, a semver + 7-char git hash, eg. `v1.46.3+asdfqwq`. + pub deno: &'static str, + + pub release_channel: ReleaseChannel, + + /// A full git hash. + pub git_hash: &'static str, + + /// A user-agent header that will be used in HTTP client. + pub user_agent: &'static str, + + pub typescript: &'static str, } -pub fn release_version_or_canary_commit_hash() -> &'static str { - if IS_CANARY { - GIT_COMMIT_HASH - } else { - env!("CARGO_PKG_VERSION") +impl DenoVersionInfo { + /// For stable release, a semver like, eg. `v1.46.2`. + /// For canary release a full git hash, eg. `9bdab6fb6b93eb43b1930f40987fa4997287f9c8`. + pub fn version_or_git_hash(&self) -> &'static str { + if IS_CANARY { + self.git_hash + } else { + CARGO_PKG_VERSION + } } } diff --git a/cli/worker.rs b/cli/worker.rs index 7f04e8846d1bd2..09aa1aec490a4e 100644 --- a/cli/worker.rs +++ b/cli/worker.rs @@ -581,6 +581,7 @@ impl CliMainWorkerFactory { let options = WorkerOptions { bootstrap: BootstrapOptions { + deno_version: crate::version::DENO_VERSION_INFO.deno.to_string(), args: shared.options.argv.clone(), cpu_count: std::thread::available_parallelism() .map(|p| p.get()) @@ -596,7 +597,7 @@ impl CliMainWorkerFactory { color_level: colors::get_color_level(), unstable: shared.options.unstable, unstable_features, - user_agent: version::get_user_agent().to_string(), + user_agent: version::DENO_VERSION_INFO.user_agent.to_string(), inspect: shared.options.is_inspecting, has_node_modules_dir: shared.options.has_node_modules_dir, argv0: shared.options.argv0.clone(), @@ -778,6 +779,7 @@ fn create_web_worker_callback( let options = WebWorkerOptions { bootstrap: BootstrapOptions { + deno_version: crate::version::DENO_VERSION_INFO.deno.to_string(), args: shared.options.argv.clone(), cpu_count: std::thread::available_parallelism() .map(|p| p.get()) @@ -793,7 +795,7 @@ fn create_web_worker_callback( is_stderr_tty: deno_terminal::is_stderr_tty(), unstable: shared.options.unstable, unstable_features, - user_agent: version::get_user_agent().to_string(), + user_agent: version::DENO_VERSION_INFO.user_agent.to_string(), inspect: shared.options.is_inspecting, has_node_modules_dir: shared.options.has_node_modules_dir, argv0: shared.options.argv0.clone(), diff --git a/runtime/js/99_main.js b/runtime/js/99_main.js index 5e25a3818c662f..013f4996feb399 100644 --- a/runtime/js/99_main.js +++ b/runtime/js/99_main.js @@ -672,7 +672,6 @@ ObjectDefineProperties(finalDenoNs, { }); const { - denoVersion, tsVersion, v8Version, target, @@ -697,21 +696,22 @@ function bootstrapMainRuntime(runtimeOptions, warmup = false) { } const { - 0: location_, - 1: unstableFlag, - 2: unstableFeatures, - 3: inspectFlag, - 5: hasNodeModulesDir, - 6: argv0, - 7: nodeDebug, - 8: shouldDisableDeprecatedApiWarning, - 9: shouldUseVerboseDeprecatedApiWarning, - 10: future, - 11: mode, - 12: servePort, - 13: serveHost, - 14: serveIsMain, - 15: serveWorkerCount, + 0: denoVersion, + 1: location_, + 2: unstableFlag, + 3: unstableFeatures, + 4: inspectFlag, + 6: hasNodeModulesDir, + 7: argv0, + 8: nodeDebug, + 9: shouldDisableDeprecatedApiWarning, + 10: shouldUseVerboseDeprecatedApiWarning, + 11: future, + 12: mode, + 13: servePort, + 14: serveHost, + 15: serveIsMain, + 16: serveWorkerCount, } = runtimeOptions; if (mode === executionModes.serve) { @@ -970,16 +970,17 @@ function bootstrapWorkerRuntime( } const { - 0: location_, - 1: unstableFlag, - 2: unstableFeatures, - 4: enableTestingFeaturesFlag, - 5: hasNodeModulesDir, - 6: argv0, - 7: nodeDebug, - 8: shouldDisableDeprecatedApiWarning, - 9: shouldUseVerboseDeprecatedApiWarning, - 10: future, + 0: denoVersion, + 1: location_, + 2: unstableFlag, + 3: unstableFeatures, + 5: enableTestingFeaturesFlag, + 6: hasNodeModulesDir, + 7: argv0, + 8: nodeDebug, + 9: shouldDisableDeprecatedApiWarning, + 10: shouldUseVerboseDeprecatedApiWarning, + 11: future, } = runtimeOptions; // TODO(iuioiua): remove in Deno v2. This allows us to dynamically delete diff --git a/runtime/ops/bootstrap.rs b/runtime/ops/bootstrap.rs index 997bebd767f5f2..88475f415444db 100644 --- a/runtime/ops/bootstrap.rs +++ b/runtime/ops/bootstrap.rs @@ -36,7 +36,6 @@ deno_core::extension!( #[derive(Serialize)] #[serde(rename_all = "camelCase")] pub struct SnapshotOptions { - pub deno_version: String, pub ts_version: String, pub v8_version: &'static str, pub target: String, @@ -54,7 +53,6 @@ impl Default for SnapshotOptions { }; Self { - deno_version: "dev".to_owned(), ts_version: "n/a".to_owned(), v8_version: deno_core::v8_version(), target, diff --git a/runtime/worker_bootstrap.rs b/runtime/worker_bootstrap.rs index afd3242e89a08f..b04a337a66ce3c 100644 --- a/runtime/worker_bootstrap.rs +++ b/runtime/worker_bootstrap.rs @@ -92,6 +92,7 @@ impl From for WorkerLogLevel { /// Common bootstrap options for MainWorker & WebWorker #[derive(Clone)] pub struct BootstrapOptions { + pub deno_version: String, /// Sets `Deno.args` in JS runtime. pub args: Vec, pub cpu_count: usize, @@ -134,6 +135,7 @@ impl Default for BootstrapOptions { let user_agent = format!("Deno/{runtime_version}"); Self { + deno_version: runtime_version.to_string(), user_agent, cpu_count, no_color: !colors::use_color(), @@ -174,6 +176,8 @@ impl Default for BootstrapOptions { /// Keep this in sync with `99_main.js`. #[derive(Serialize)] struct BootstrapV8<'a>( + // deno version + &'a str, // location Option<&'a str>, // unstable @@ -219,6 +223,7 @@ impl BootstrapOptions { let (serve_is_main, serve_worker_count) = self.mode.serve_info(); let bootstrap = BootstrapV8( + &self.deno_version, self.location.as_ref().map(|l| l.as_str()), self.unstable, self.unstable_features.as_ref(),