mirror of
https://github.com/denoland/deno.git
synced 2024-12-23 15:49:44 -05:00
5f8be055db
split up otel config into user configurable and runtime configurable parts. user configurable part is now set via env vars parsed according to the otel spec. otel is now enabled via `OTEL_DENO=true`, and `--unstable-otel` only acts as a guard. Fixes: https://github.com/denoland/deno/issues/27273
483 lines
17 KiB
Rust
483 lines
17 KiB
Rust
// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
|
|
|
|
mod args;
|
|
mod auth_tokens;
|
|
mod cache;
|
|
mod cdp;
|
|
mod emit;
|
|
mod errors;
|
|
mod factory;
|
|
mod file_fetcher;
|
|
mod graph_container;
|
|
mod graph_util;
|
|
mod http_util;
|
|
mod js;
|
|
mod jsr;
|
|
mod lsp;
|
|
mod module_loader;
|
|
mod node;
|
|
mod npm;
|
|
mod ops;
|
|
mod resolver;
|
|
mod shared;
|
|
mod standalone;
|
|
mod task_runner;
|
|
mod tools;
|
|
mod tsc;
|
|
mod util;
|
|
mod version;
|
|
mod worker;
|
|
|
|
use crate::args::flags_from_vec;
|
|
use crate::args::DenoSubcommand;
|
|
use crate::args::Flags;
|
|
use crate::util::display;
|
|
use crate::util::v8::get_v8_flags_from_env;
|
|
use crate::util::v8::init_v8_flags;
|
|
|
|
use args::TaskFlags;
|
|
use deno_resolver::npm::ByonmResolvePkgFolderFromDenoReqError;
|
|
use deno_resolver::npm::ResolvePkgFolderFromDenoReqError;
|
|
use deno_runtime::WorkerExecutionMode;
|
|
pub use deno_runtime::UNSTABLE_GRANULAR_FLAGS;
|
|
|
|
use deno_core::anyhow::Context;
|
|
use deno_core::error::AnyError;
|
|
use deno_core::error::JsError;
|
|
use deno_core::futures::FutureExt;
|
|
use deno_core::unsync::JoinHandle;
|
|
use deno_npm::resolution::SnapshotFromLockfileError;
|
|
use deno_runtime::fmt_errors::format_js_error;
|
|
use deno_runtime::tokio_util::create_and_run_current_thread_with_maybe_metrics;
|
|
use deno_terminal::colors;
|
|
use factory::CliFactory;
|
|
use standalone::MODULE_NOT_FOUND;
|
|
use standalone::UNSUPPORTED_SCHEME;
|
|
use std::env;
|
|
use std::future::Future;
|
|
use std::io::IsTerminal;
|
|
use std::ops::Deref;
|
|
use std::path::PathBuf;
|
|
use std::sync::Arc;
|
|
|
|
#[cfg(feature = "dhat-heap")]
|
|
#[global_allocator]
|
|
static ALLOC: dhat::Alloc = dhat::Alloc;
|
|
|
|
/// Ensures that all subcommands return an i32 exit code and an [`AnyError`] error type.
|
|
trait SubcommandOutput {
|
|
fn output(self) -> Result<i32, AnyError>;
|
|
}
|
|
|
|
impl SubcommandOutput for Result<i32, AnyError> {
|
|
fn output(self) -> Result<i32, AnyError> {
|
|
self
|
|
}
|
|
}
|
|
|
|
impl SubcommandOutput for Result<(), AnyError> {
|
|
fn output(self) -> Result<i32, AnyError> {
|
|
self.map(|_| 0)
|
|
}
|
|
}
|
|
|
|
impl SubcommandOutput for Result<(), std::io::Error> {
|
|
fn output(self) -> Result<i32, AnyError> {
|
|
self.map(|_| 0).map_err(|e| e.into())
|
|
}
|
|
}
|
|
|
|
/// Ensure that the subcommand runs in a task, rather than being directly executed. Since some of these
|
|
/// futures are very large, this prevents the stack from getting blown out from passing them by value up
|
|
/// the callchain (especially in debug mode when Rust doesn't have a chance to elide copies!).
|
|
#[inline(always)]
|
|
fn spawn_subcommand<F: Future<Output = T> + 'static, T: SubcommandOutput>(
|
|
f: F,
|
|
) -> JoinHandle<Result<i32, AnyError>> {
|
|
// the boxed_local() is important in order to get windows to not blow the stack in debug
|
|
deno_core::unsync::spawn(
|
|
async move { f.map(|r| r.output()).await }.boxed_local(),
|
|
)
|
|
}
|
|
|
|
async fn run_subcommand(flags: Arc<Flags>) -> Result<i32, AnyError> {
|
|
let handle = match flags.subcommand.clone() {
|
|
DenoSubcommand::Add(add_flags) => spawn_subcommand(async {
|
|
tools::registry::add(flags, add_flags, tools::registry::AddCommandName::Add).await
|
|
}),
|
|
DenoSubcommand::Remove(remove_flags) => spawn_subcommand(async {
|
|
tools::registry::remove(flags, remove_flags).await
|
|
}),
|
|
DenoSubcommand::Bench(bench_flags) => spawn_subcommand(async {
|
|
if bench_flags.watch.is_some() {
|
|
tools::bench::run_benchmarks_with_watch(flags, bench_flags).await
|
|
} else {
|
|
tools::bench::run_benchmarks(flags, bench_flags).await
|
|
}
|
|
}),
|
|
DenoSubcommand::Bundle => exit_with_message("⚠️ `deno bundle` was removed in Deno 2.\n\nSee the Deno 1.x to 2.x Migration Guide for migration instructions: https://docs.deno.com/runtime/manual/advanced/migrate_deprecations", 1),
|
|
DenoSubcommand::Doc(doc_flags) => {
|
|
spawn_subcommand(async { tools::doc::doc(flags, doc_flags).await })
|
|
}
|
|
DenoSubcommand::Eval(eval_flags) => spawn_subcommand(async {
|
|
tools::run::eval_command(flags, eval_flags).await
|
|
}),
|
|
DenoSubcommand::Cache(cache_flags) => spawn_subcommand(async move {
|
|
tools::installer::install_from_entrypoints(flags, &cache_flags.files).await
|
|
}),
|
|
DenoSubcommand::Check(check_flags) => spawn_subcommand(async move {
|
|
tools::check::check(flags, check_flags).await
|
|
}),
|
|
DenoSubcommand::Clean => spawn_subcommand(async move {
|
|
tools::clean::clean()
|
|
}),
|
|
DenoSubcommand::Compile(compile_flags) => spawn_subcommand(async {
|
|
tools::compile::compile(flags, compile_flags).await
|
|
}),
|
|
DenoSubcommand::Coverage(coverage_flags) => spawn_subcommand(async {
|
|
tools::coverage::cover_files(flags, coverage_flags)
|
|
}),
|
|
DenoSubcommand::Fmt(fmt_flags) => {
|
|
spawn_subcommand(
|
|
async move { tools::fmt::format(flags, fmt_flags).await },
|
|
)
|
|
}
|
|
DenoSubcommand::Init(init_flags) => {
|
|
spawn_subcommand(async {
|
|
tools::init::init_project(init_flags).await
|
|
})
|
|
}
|
|
DenoSubcommand::Info(info_flags) => {
|
|
spawn_subcommand(async { tools::info::info(flags, info_flags).await })
|
|
}
|
|
DenoSubcommand::Install(install_flags) => spawn_subcommand(async {
|
|
tools::installer::install_command(flags, install_flags).await
|
|
}),
|
|
DenoSubcommand::JSONReference(json_reference) => spawn_subcommand(async move {
|
|
display::write_to_stdout_ignore_sigpipe(&deno_core::serde_json::to_vec_pretty(&json_reference.json).unwrap())
|
|
}),
|
|
DenoSubcommand::Jupyter(jupyter_flags) => spawn_subcommand(async {
|
|
tools::jupyter::kernel(flags, jupyter_flags).await
|
|
}),
|
|
DenoSubcommand::Uninstall(uninstall_flags) => spawn_subcommand(async {
|
|
tools::installer::uninstall(flags, uninstall_flags).await
|
|
}),
|
|
DenoSubcommand::Lsp => spawn_subcommand(async {
|
|
if std::io::stderr().is_terminal() {
|
|
log::warn!(
|
|
"{} command is intended to be run by text editors and IDEs and shouldn't be run manually.
|
|
|
|
Visit https://docs.deno.com/runtime/getting_started/setup_your_environment/ for instruction
|
|
how to setup your favorite text editor.
|
|
|
|
Press Ctrl+C to exit.
|
|
", colors::cyan("deno lsp"));
|
|
}
|
|
lsp::start().await
|
|
}),
|
|
DenoSubcommand::Lint(lint_flags) => spawn_subcommand(async {
|
|
if lint_flags.rules {
|
|
tools::lint::print_rules_list(
|
|
lint_flags.json,
|
|
lint_flags.maybe_rules_tags,
|
|
);
|
|
Ok(())
|
|
} else {
|
|
tools::lint::lint(flags, lint_flags).await
|
|
}
|
|
}),
|
|
DenoSubcommand::Outdated(update_flags) => {
|
|
spawn_subcommand(async move {
|
|
tools::registry::outdated(flags, update_flags).await
|
|
})
|
|
}
|
|
DenoSubcommand::Repl(repl_flags) => {
|
|
spawn_subcommand(async move { tools::repl::run(flags, repl_flags).await })
|
|
}
|
|
DenoSubcommand::Run(run_flags) => spawn_subcommand(async move {
|
|
if run_flags.is_stdin() {
|
|
tools::run::run_from_stdin(flags.clone()).await
|
|
} else {
|
|
let result = tools::run::run_script(WorkerExecutionMode::Run, flags.clone(), run_flags.watch).await;
|
|
match result {
|
|
Ok(v) => Ok(v),
|
|
Err(script_err) => {
|
|
if let Some(ResolvePkgFolderFromDenoReqError::Byonm(ByonmResolvePkgFolderFromDenoReqError::UnmatchedReq(_))) = script_err.downcast_ref::<ResolvePkgFolderFromDenoReqError>() {
|
|
if flags.node_modules_dir.is_none() {
|
|
let mut flags = flags.deref().clone();
|
|
let watch = match &flags.subcommand {
|
|
DenoSubcommand::Run(run_flags) => run_flags.watch.clone(),
|
|
_ => unreachable!(),
|
|
};
|
|
flags.node_modules_dir = Some(deno_config::deno_json::NodeModulesDirMode::None);
|
|
// use the current lockfile, but don't write it out
|
|
if flags.frozen_lockfile.is_none() {
|
|
flags.internal.lockfile_skip_write = true;
|
|
}
|
|
return tools::run::run_script(WorkerExecutionMode::Run, Arc::new(flags), watch).await;
|
|
}
|
|
}
|
|
let script_err_msg = script_err.to_string();
|
|
if script_err_msg.starts_with(MODULE_NOT_FOUND) || script_err_msg.starts_with(UNSUPPORTED_SCHEME) {
|
|
if run_flags.bare {
|
|
let mut cmd = args::clap_root();
|
|
cmd.build();
|
|
let command_names = cmd.get_subcommands().map(|command| command.get_name()).collect::<Vec<_>>();
|
|
let suggestions = args::did_you_mean(&run_flags.script, command_names);
|
|
if !suggestions.is_empty() {
|
|
let mut error = clap::error::Error::<clap::error::DefaultFormatter>::new(clap::error::ErrorKind::InvalidSubcommand).with_cmd(&cmd);
|
|
error.insert(
|
|
clap::error::ContextKind::SuggestedSubcommand,
|
|
clap::error::ContextValue::Strings(suggestions),
|
|
);
|
|
|
|
Err(error.into())
|
|
} else {
|
|
Err(script_err)
|
|
}
|
|
} else {
|
|
let mut new_flags = flags.deref().clone();
|
|
let task_flags = TaskFlags {
|
|
cwd: None,
|
|
task: Some(run_flags.script.clone()),
|
|
is_run: true,
|
|
recursive: false,
|
|
filter: None,
|
|
eval: false,
|
|
};
|
|
new_flags.subcommand = DenoSubcommand::Task(task_flags.clone());
|
|
let result = tools::task::execute_script(Arc::new(new_flags), task_flags.clone()).await;
|
|
match result {
|
|
Ok(v) => Ok(v),
|
|
Err(_) => {
|
|
// Return script error for backwards compatibility.
|
|
Err(script_err)
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
Err(script_err)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}),
|
|
DenoSubcommand::Serve(serve_flags) => spawn_subcommand(async move {
|
|
tools::serve::serve(flags, serve_flags).await
|
|
}),
|
|
DenoSubcommand::Task(task_flags) => spawn_subcommand(async {
|
|
tools::task::execute_script(flags, task_flags).await
|
|
}),
|
|
DenoSubcommand::Test(test_flags) => {
|
|
spawn_subcommand(async {
|
|
if let Some(ref coverage_dir) = test_flags.coverage_dir {
|
|
if test_flags.clean {
|
|
let _ = std::fs::remove_dir_all(coverage_dir);
|
|
}
|
|
std::fs::create_dir_all(coverage_dir)
|
|
.with_context(|| format!("Failed creating: {coverage_dir}"))?;
|
|
// this is set in order to ensure spawned processes use the same
|
|
// coverage directory
|
|
env::set_var(
|
|
"DENO_UNSTABLE_COVERAGE_DIR",
|
|
PathBuf::from(coverage_dir).canonicalize()?,
|
|
);
|
|
}
|
|
|
|
if test_flags.watch.is_some() {
|
|
tools::test::run_tests_with_watch(flags, test_flags).await
|
|
} else {
|
|
tools::test::run_tests(flags, test_flags).await
|
|
}
|
|
})
|
|
}
|
|
DenoSubcommand::Completions(completions_flags) => {
|
|
spawn_subcommand(async move {
|
|
display::write_to_stdout_ignore_sigpipe(&completions_flags.buf)
|
|
})
|
|
}
|
|
DenoSubcommand::Types => spawn_subcommand(async move {
|
|
let types = tsc::get_types_declaration_file_text();
|
|
display::write_to_stdout_ignore_sigpipe(types.as_bytes())
|
|
}),
|
|
#[cfg(feature = "upgrade")]
|
|
DenoSubcommand::Upgrade(upgrade_flags) => spawn_subcommand(async {
|
|
tools::upgrade::upgrade(flags, upgrade_flags).await
|
|
}),
|
|
#[cfg(not(feature = "upgrade"))]
|
|
DenoSubcommand::Upgrade(_) => exit_with_message(
|
|
"This deno was built without the \"upgrade\" feature. Please upgrade using the installation method originally used to install Deno.",
|
|
1,
|
|
),
|
|
DenoSubcommand::Vendor => exit_with_message("⚠️ `deno vendor` was removed in Deno 2.\n\nSee the Deno 1.x to 2.x Migration Guide for migration instructions: https://docs.deno.com/runtime/manual/advanced/migrate_deprecations", 1),
|
|
DenoSubcommand::Publish(publish_flags) => spawn_subcommand(async {
|
|
tools::registry::publish(flags, publish_flags).await
|
|
}),
|
|
DenoSubcommand::Help(help_flags) => spawn_subcommand(async move {
|
|
use std::io::Write;
|
|
|
|
let mut stream = anstream::AutoStream::new(std::io::stdout(), if colors::use_color() {
|
|
anstream::ColorChoice::Auto
|
|
} else {
|
|
anstream::ColorChoice::Never
|
|
});
|
|
|
|
match stream.write_all(help_flags.help.ansi().to_string().as_bytes()) {
|
|
Ok(()) => Ok(()),
|
|
Err(e) => match e.kind() {
|
|
std::io::ErrorKind::BrokenPipe => Ok(()),
|
|
_ => Err(e),
|
|
},
|
|
}
|
|
}),
|
|
};
|
|
|
|
handle.await?
|
|
}
|
|
|
|
#[allow(clippy::print_stderr)]
|
|
fn setup_panic_hook() {
|
|
// This function does two things inside of the panic hook:
|
|
// - Tokio does not exit the process when a task panics, so we define a custom
|
|
// panic hook to implement this behaviour.
|
|
// - We print a message to stderr to indicate that this is a bug in Deno, and
|
|
// should be reported to us.
|
|
let orig_hook = std::panic::take_hook();
|
|
std::panic::set_hook(Box::new(move |panic_info| {
|
|
eprintln!("\n============================================================");
|
|
eprintln!("Deno has panicked. This is a bug in Deno. Please report this");
|
|
eprintln!("at https://github.com/denoland/deno/issues/new.");
|
|
eprintln!("If you can reliably reproduce this panic, include the");
|
|
eprintln!("reproduction steps and re-run with the RUST_BACKTRACE=1 env");
|
|
eprintln!("var set and include the backtrace in your report.");
|
|
eprintln!();
|
|
eprintln!("Platform: {} {}", env::consts::OS, env::consts::ARCH);
|
|
eprintln!("Version: {}", version::DENO_VERSION_INFO.deno);
|
|
eprintln!("Args: {:?}", env::args().collect::<Vec<_>>());
|
|
eprintln!();
|
|
orig_hook(panic_info);
|
|
deno_runtime::exit(1);
|
|
}));
|
|
}
|
|
|
|
fn exit_with_message(message: &str, code: i32) -> ! {
|
|
log::error!(
|
|
"{}: {}",
|
|
colors::red_bold("error"),
|
|
message.trim_start_matches("error: ")
|
|
);
|
|
deno_runtime::exit(code);
|
|
}
|
|
|
|
fn exit_for_error(error: AnyError) -> ! {
|
|
let mut error_string = format!("{error:?}");
|
|
let mut error_code = 1;
|
|
|
|
if let Some(e) = error.downcast_ref::<JsError>() {
|
|
error_string = format_js_error(e);
|
|
} else if let Some(SnapshotFromLockfileError::IntegrityCheckFailed(e)) =
|
|
error.downcast_ref::<SnapshotFromLockfileError>()
|
|
{
|
|
error_string = e.to_string();
|
|
error_code = 10;
|
|
}
|
|
|
|
exit_with_message(&error_string, error_code);
|
|
}
|
|
|
|
pub(crate) fn unstable_exit_cb(feature: &str, api_name: &str) {
|
|
log::error!(
|
|
"Unstable API '{api_name}'. The `--unstable-{}` flag must be provided.",
|
|
feature
|
|
);
|
|
deno_runtime::exit(70);
|
|
}
|
|
|
|
pub fn main() {
|
|
#[cfg(feature = "dhat-heap")]
|
|
let profiler = dhat::Profiler::new_heap();
|
|
|
|
setup_panic_hook();
|
|
|
|
util::unix::raise_fd_limit();
|
|
util::windows::ensure_stdio_open();
|
|
#[cfg(windows)]
|
|
colors::enable_ansi(); // For Windows 10
|
|
deno_runtime::deno_permissions::set_prompt_callbacks(
|
|
Box::new(util::draw_thread::DrawThread::hide),
|
|
Box::new(util::draw_thread::DrawThread::show),
|
|
);
|
|
|
|
let args: Vec<_> = env::args_os().collect();
|
|
let future = async move {
|
|
// NOTE(lucacasonato): due to new PKU feature introduced in V8 11.6 we need to
|
|
// initialize the V8 platform on a parent thread of all threads that will spawn
|
|
// V8 isolates.
|
|
let flags = resolve_flags_and_init(args)?;
|
|
run_subcommand(Arc::new(flags)).await
|
|
};
|
|
|
|
let result = create_and_run_current_thread_with_maybe_metrics(future);
|
|
|
|
#[cfg(feature = "dhat-heap")]
|
|
drop(profiler);
|
|
|
|
match result {
|
|
Ok(exit_code) => deno_runtime::exit(exit_code),
|
|
Err(err) => exit_for_error(err),
|
|
}
|
|
}
|
|
|
|
fn resolve_flags_and_init(
|
|
args: Vec<std::ffi::OsString>,
|
|
) -> Result<Flags, AnyError> {
|
|
let flags = match flags_from_vec(args) {
|
|
Ok(flags) => flags,
|
|
Err(err @ clap::Error { .. })
|
|
if err.kind() == clap::error::ErrorKind::DisplayVersion =>
|
|
{
|
|
// Ignore results to avoid BrokenPipe errors.
|
|
util::logger::init(None, None);
|
|
let _ = err.print();
|
|
deno_runtime::exit(0);
|
|
}
|
|
Err(err) => {
|
|
util::logger::init(None, None);
|
|
exit_for_error(AnyError::from(err))
|
|
}
|
|
};
|
|
|
|
deno_telemetry::init(crate::args::otel_runtime_config())?;
|
|
util::logger::init(flags.log_level, Some(flags.otel_config()));
|
|
|
|
// TODO(bartlomieju): remove in Deno v2.5 and hard error then.
|
|
if flags.unstable_config.legacy_flag_enabled {
|
|
log::warn!(
|
|
"⚠️ {}",
|
|
colors::yellow(
|
|
"The `--unstable` flag has been removed in Deno 2.0. Use granular `--unstable-*` flags instead.\nLearn more at: https://docs.deno.com/runtime/manual/tools/unstable_flags"
|
|
)
|
|
);
|
|
}
|
|
|
|
let default_v8_flags = match flags.subcommand {
|
|
// Using same default as VSCode:
|
|
// https://github.com/microsoft/vscode/blob/48d4ba271686e8072fc6674137415bc80d936bc7/extensions/typescript-language-features/src/configuration/configuration.ts#L213-L214
|
|
DenoSubcommand::Lsp => vec!["--max-old-space-size=3072".to_string()],
|
|
_ => {
|
|
// TODO(bartlomieju): I think this can be removed as it's handled by `deno_core`
|
|
// and its settings.
|
|
// deno_ast removes TypeScript `assert` keywords, so this flag only affects JavaScript
|
|
// TODO(petamoriken): Need to check TypeScript `assert` keywords in deno_ast
|
|
vec!["--no-harmony-import-assertions".to_string()]
|
|
}
|
|
};
|
|
|
|
init_v8_flags(&default_v8_flags, &flags.v8_flags, get_v8_flags_from_env());
|
|
// TODO(bartlomieju): remove last argument once Deploy no longer needs it
|
|
deno_core::JsRuntime::init_platform(
|
|
None, /* import assertions enabled */ false,
|
|
);
|
|
|
|
Ok(flags)
|
|
}
|