From 261196430472f51583820aa2a244d06a3bb91677 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Thu, 9 Dec 2021 01:19:38 +0100 Subject: [PATCH 001/115] Add 'jupyter' subcommand and tools module --- cli/flags.rs | 77 ++++++++++++++++++++++++++++++++++++++++++++ cli/main.rs | 15 +++++++++ cli/tools/jupyter.rs | 16 +++++++++ cli/tools/mod.rs | 1 + 4 files changed, 109 insertions(+) create mode 100644 cli/tools/jupyter.rs diff --git a/cli/flags.rs b/cli/flags.rs index 31180a47ee81f8..43b70139e511f9 100644 --- a/cli/flags.rs +++ b/cli/flags.rs @@ -110,6 +110,12 @@ pub struct InstallFlags { pub force: bool, } +#[derive(Clone, Debug, PartialEq, Deserialize, Serialize)] +pub struct JupyterFlags { + pub install: bool, + pub conn_file: Option, +} + #[derive(Clone, Debug, PartialEq, Deserialize, Serialize)] pub struct UninstallFlags { pub name: String, @@ -172,6 +178,7 @@ pub enum DenoSubcommand { Fmt(FmtFlags), Info(InfoFlags), Install(InstallFlags), + Jupyter(JupyterFlags), Uninstall(UninstallFlags), Lsp, Lint(LintFlags), @@ -472,6 +479,8 @@ pub fn flags_from_vec(args: Vec) -> clap::Result { compile_parse(&mut flags, m); } else if let Some(m) = matches.subcommand_matches("lsp") { lsp_parse(&mut flags, m); + } else if let Some(m) = matches.subcommand_matches("jupyter") { + jupyter_parse(&mut flags, m); } else { repl_parse(&mut flags, &matches); } @@ -529,6 +538,7 @@ If the flag is set, restrict these messages to errors.", .subcommand(fmt_subcommand()) .subcommand(info_subcommand()) .subcommand(install_subcommand()) + .subcommand(jupyter_subcommand()) .subcommand(uninstall_subcommand()) .subcommand(lsp_subcommand()) .subcommand(lint_subcommand()) @@ -1026,6 +1036,22 @@ The installation root is determined, in order of precedence: These must be added to the path manually if required.") } +fn jupyter_subcommand<'a, 'b>() -> App<'a, 'b> { + SubCommand::with_name("jupyter") + .arg( + Arg::with_name("install") + .long("install") + ) + .arg( + Arg::with_name("conn") + .long("conn") + .help("Path to JSON file describing connection parameters, provided by Jupyter") + .takes_value(true) + .required(false) + .conflicts_with("install")) + .about("Jupyter kernel") +} + fn uninstall_subcommand<'a, 'b>() -> App<'a, 'b> { SubCommand::with_name("uninstall") .setting(AppSettings::TrailingVarArg) @@ -1975,6 +2001,20 @@ fn install_parse(flags: &mut Flags, matches: &clap::ArgMatches) { }); } +fn jupyter_parse(flags: &mut Flags, matches: &clap::ArgMatches) { + let conn_file = if matches.is_present("conn") { + let conn_file = matches.value_of("conn").unwrap(); + Some(PathBuf::from(conn_file)) + } else { + None + }; + + let install = matches.is_present("install"); + + flags.subcommand = + DenoSubcommand::Jupyter(JupyterFlags { install, conn_file }); +} + fn uninstall_parse(flags: &mut Flags, matches: &clap::ArgMatches) { let root = if matches.is_present("root") { let install_root = matches.value_of("root").unwrap(); @@ -4519,4 +4559,41 @@ mod tests { } ); } + + #[test] + fn jupyter() { + let r = flags_from_vec(svec!["deno", "jupyter", "--install"]); + assert_eq!( + r.unwrap(), + Flags { + subcommand: DenoSubcommand::Jupyter(JupyterFlags { + install: true, + conn_file: None, + }), + ..Flags::default() + } + ); + + let r = + flags_from_vec(svec!["deno", "jupyter", "--conn", "path/to/conn/file"]); + assert_eq!( + r.unwrap(), + Flags { + subcommand: DenoSubcommand::Jupyter(JupyterFlags { + install: false, + conn_file: Some(PathBuf::from("path/to/conn/file")), + }), + ..Flags::default() + } + ); + + let r = flags_from_vec(svec![ + "deno", + "jupyter", + "--install", + "--conn", + "path/to/conn/file" + ]); + r.unwrap_err(); + } } diff --git a/cli/main.rs b/cli/main.rs index 8878fb57a1373c..4e6add52d29245 100644 --- a/cli/main.rs +++ b/cli/main.rs @@ -51,6 +51,7 @@ use crate::flags::Flags; use crate::flags::FmtFlags; use crate::flags::InfoFlags; use crate::flags::InstallFlags; +use crate::flags::JupyterFlags; use crate::flags::LintFlags; use crate::flags::ReplFlags; use crate::flags::RunFlags; @@ -547,6 +548,17 @@ async fn install_command( ) } +async fn jupyter_command( + flags: Flags, + jupyter_flags: JupyterFlags, +) -> Result<(), AnyError> { + if jupyter_flags.install { + return tools::jupyter::install(); + } + + tools::jupyter::kernel(flags, jupyter_flags) +} + async fn uninstall_command( uninstall_flags: UninstallFlags, ) -> Result<(), AnyError> { @@ -1370,6 +1382,9 @@ fn get_subcommand( DenoSubcommand::Install(install_flags) => { install_command(flags, install_flags).boxed_local() } + DenoSubcommand::Jupyter(jupyter_flags) => { + jupyter_command(flags, jupyter_flags).boxed_local() + } DenoSubcommand::Uninstall(uninstall_flags) => { uninstall_command(uninstall_flags).boxed_local() } diff --git a/cli/tools/jupyter.rs b/cli/tools/jupyter.rs new file mode 100644 index 00000000000000..e07b7812a705ce --- /dev/null +++ b/cli/tools/jupyter.rs @@ -0,0 +1,16 @@ +// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license. + +use crate::flags::Flags; +use crate::flags::JupyterFlags; +use deno_core::error::AnyError; + +pub fn install() -> Result<(), AnyError> { + unimplemented!(); +} + +pub fn kernel( + _flags: Flags, + _jupyter_flags: JupyterFlags, +) -> Result<(), AnyError> { + unimplemented!(); +} diff --git a/cli/tools/mod.rs b/cli/tools/mod.rs index 74d6431ed9bba8..8396b69afa6b0f 100644 --- a/cli/tools/mod.rs +++ b/cli/tools/mod.rs @@ -4,6 +4,7 @@ pub mod coverage; pub mod doc; pub mod fmt; pub mod installer; +pub mod jupyter; pub mod lint; pub mod repl; pub mod standalone; From 0f6e0d5b2aabdd1c9038b88e03ccc119d8d474fa Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Thu, 9 Dec 2021 01:47:49 +0100 Subject: [PATCH 002/115] add install command --- Cargo.lock | 208 +++++++++++++++++++++++++++++++++++++++++-- cli/Cargo.toml | 1 + cli/tools/jupyter.rs | 47 +++++++++- 3 files changed, 249 insertions(+), 7 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 6c0702d8c4742b..d248f27cf02456 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -36,6 +36,15 @@ dependencies = [ "opaque-debug", ] +[[package]] +name = "ahash" +version = "0.3.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e8fd72866655d1904d6b0997d0b07ba561047d070fbe29de039031c641b61217" +dependencies = [ + "const-random", +] + [[package]] name = "ahash" version = "0.4.7" @@ -185,6 +194,19 @@ dependencies = [ "syn 1.0.65", ] +[[package]] +name = "asynchronous-codec" +version = "0.6.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f0de5164e5edbf51c45fb8c2d9664ae1c095cce1b265ecf7569093c0d66ef690" +dependencies = [ + "bytes", + "futures-sink", + "futures-util", + "memchr", + "pin-project-lite", +] + [[package]] name = "atty" version = "0.2.14" @@ -432,6 +454,28 @@ version = "0.6.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "fdab415d6744056100f40250a66bc430c1a46f7a02e20bc11c94c79a0f0464df" +[[package]] +name = "const-random" +version = "0.1.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f590d95d011aa80b063ffe3253422ed5aa462af4e9867d43ce8337562bac77c4" +dependencies = [ + "const-random-macro", + "proc-macro-hack", +] + +[[package]] +name = "const-random-macro" +version = "0.1.13" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "615f6e27d000a2bffbc7f2f6a8669179378fa27ee4d0a509e985dfc0a7defb40" +dependencies = [ + "getrandom 0.2.3", + "lazy_static", + "proc-macro-hack", + "tiny-keccak", +] + [[package]] name = "convert_case" version = "0.4.0" @@ -499,6 +543,30 @@ dependencies = [ "cfg-if 1.0.0", ] +[[package]] +name = "crossbeam" +version = "0.7.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "69323bff1fb41c635347b8ead484a5ca6c3f11914d784170b158d8449ab07f8e" +dependencies = [ + "cfg-if 0.1.10", + "crossbeam-channel 0.4.4", + "crossbeam-deque", + "crossbeam-epoch", + "crossbeam-queue", + "crossbeam-utils 0.7.2", +] + +[[package]] +name = "crossbeam-channel" +version = "0.4.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b153fe7cbef478c567df0f972e02e6d736db11affe43dfc9c56a9374d1adfb87" +dependencies = [ + "crossbeam-utils 0.7.2", + "maybe-uninit", +] + [[package]] name = "crossbeam-channel" version = "0.5.1" @@ -506,7 +574,55 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "06ed27e177f16d65f0f0c22a213e17c696ace5dd64b14258b52f9417ccb52db4" dependencies = [ "cfg-if 1.0.0", - "crossbeam-utils", + "crossbeam-utils 0.8.5", +] + +[[package]] +name = "crossbeam-deque" +version = "0.7.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c20ff29ded3204c5106278a81a38f4b482636ed4fa1e6cfbeef193291beb29ed" +dependencies = [ + "crossbeam-epoch", + "crossbeam-utils 0.7.2", + "maybe-uninit", +] + +[[package]] +name = "crossbeam-epoch" +version = "0.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "058ed274caafc1f60c4997b5fc07bf7dc7cca454af7c6e81edffe5f33f70dace" +dependencies = [ + "autocfg 1.0.1", + "cfg-if 0.1.10", + "crossbeam-utils 0.7.2", + "lazy_static", + "maybe-uninit", + "memoffset 0.5.6", + "scopeguard", +] + +[[package]] +name = "crossbeam-queue" +version = "0.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "774ba60a54c213d409d5353bda12d49cd68d14e45036a285234c8d6f91f92570" +dependencies = [ + "cfg-if 0.1.10", + "crossbeam-utils 0.7.2", + "maybe-uninit", +] + +[[package]] +name = "crossbeam-utils" +version = "0.7.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c3c7c73a2d1e9fc0886a08b93e98eb643461230d5f1925e4036204d5f2e261a8" +dependencies = [ + "autocfg 1.0.1", + "cfg-if 0.1.10", + "lazy_static", ] [[package]] @@ -519,6 +635,12 @@ dependencies = [ "lazy_static", ] +[[package]] +name = "crunchy" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7a81dae078cea95a014a339291cec439d2f232ebe854a9d672b796c6afafa9b7" + [[package]] name = "crypto-bigint" version = "0.2.10" @@ -597,6 +719,17 @@ dependencies = [ "syn 1.0.65", ] +[[package]] +name = "dashmap" +version = "3.11.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0f260e2fc850179ef410018660006951c1b55b79e8087e87111a2c388994b9b5" +dependencies = [ + "ahash 0.3.8", + "cfg-if 0.1.10", + "num_cpus", +] + [[package]] name = "dashmap" version = "4.0.2" @@ -690,6 +823,7 @@ dependencies = [ "walkdir", "winapi 0.3.9", "winres", + "zeromq", ] [[package]] @@ -1225,6 +1359,17 @@ dependencies = [ "syn 1.0.65", ] +[[package]] +name = "enum-primitive-derive" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c375b9c5eadb68d0a6efee2999fef292f45854c3444c86f09d8ab086ba942b0e" +dependencies = [ + "num-traits", + "quote 1.0.10", + "syn 1.0.65", +] + [[package]] name = "enum_kind" version = "0.2.1" @@ -2125,7 +2270,7 @@ dependencies = [ "async-trait", "auto_impl", "bytes", - "dashmap", + "dashmap 4.0.2", "futures", "httparse", "log", @@ -2173,12 +2318,27 @@ version = "0.1.9" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a3e378b66a060d48947b590737b30a1be76706c8dd7b8ba0f2fe3989c68a853f" +[[package]] +name = "maybe-uninit" +version = "2.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "60302e4db3a61da70c0cb7991976248362f30319e88850c487b9b95bbf059e00" + [[package]] name = "memchr" version = "2.4.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "308cc39be01b73d0d18f82a0e7b2a3df85245f84af96fdddc5d202d27e47b86a" +[[package]] +name = "memoffset" +version = "0.5.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "043175f069eda7b85febe4a74abbaeff828d9f8b448515d3151a14a3542811aa" +dependencies = [ + "autocfg 1.0.1", +] + [[package]] name = "memoffset" version = "0.6.4" @@ -2283,7 +2443,7 @@ dependencies = [ "cc", "cfg-if 1.0.0", "libc", - "memoffset", + "memoffset 0.6.4", ] [[package]] @@ -2293,7 +2453,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "20a629259bb2c87a884bb76f6086c8637919de6d074754341c12e5dd3aed6326" dependencies = [ "bitflags", - "crossbeam-channel", + "crossbeam-channel 0.5.1", "filetime", "fsevent-sys", "inotify", @@ -3779,7 +3939,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f8774d32f481b47dec0b0e30765a71d02a1c63919b4ca52f925afbf0dd5b81e6" dependencies = [ "ahash 0.7.4", - "dashmap", + "dashmap 4.0.2", "indexmap", "once_cell", "retain_mut", @@ -3823,7 +3983,7 @@ checksum = "0c7a21856bade56164a0da969aacd3ec90c27bed56e82480c92721fca18d1fe8" dependencies = [ "ahash 0.7.4", "base64 0.13.0", - "dashmap", + "dashmap 4.0.2", "indexmap", "once_cell", "regex", @@ -4101,6 +4261,15 @@ dependencies = [ "winapi 0.3.9", ] +[[package]] +name = "tiny-keccak" +version = "2.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2c9d3793400a45f954c52e73d068316d76b6f4e36977e3fcebb13a2721e80237" +dependencies = [ + "crunchy", +] + [[package]] name = "tinyvec" version = "1.5.0" @@ -4193,6 +4362,7 @@ checksum = "08d3725d3efa29485e87311c5b699de63cde14b00ed4d256b8318aa30ca452cd" dependencies = [ "bytes", "futures-core", + "futures-io", "futures-sink", "log", "pin-project-lite", @@ -4892,3 +5062,29 @@ dependencies = [ "syn 1.0.65", "synstructure", ] + +[[package]] +name = "zeromq" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c376a1982922614fda01ef046cc076503681d8f9b1b3135e85b367e5d8719246" +dependencies = [ + "async-trait", + "asynchronous-codec", + "bytes", + "crossbeam", + "dashmap 3.11.10", + "enum-primitive-derive", + "futures", + "futures-util", + "lazy_static", + "log", + "num-traits", + "parking_lot", + "rand 0.7.3", + "regex", + "thiserror", + "tokio", + "tokio-util", + "uuid", +] diff --git a/cli/Cargo.toml b/cli/Cargo.toml index 4c3997332b6ab0..0c40d964399f6f 100644 --- a/cli/Cargo.toml +++ b/cli/Cargo.toml @@ -83,6 +83,7 @@ text-size = "=1.1.0" tokio = { version = "=1.14", features = ["full"] } uuid = { version = "=0.8.2", features = ["v4", "serde"] } walkdir = "=2.3.2" +zeromq = "0.3.1" [target.'cfg(windows)'.dependencies] fwdansi = "=1.1.0" diff --git a/cli/tools/jupyter.rs b/cli/tools/jupyter.rs index e07b7812a705ce..eeeac6a58f7c88 100644 --- a/cli/tools/jupyter.rs +++ b/cli/tools/jupyter.rs @@ -3,9 +3,54 @@ use crate::flags::Flags; use crate::flags::JupyterFlags; use deno_core::error::AnyError; +use deno_core::serde_json; +use deno_core::serde_json::json; +use tempfile::TempDir; pub fn install() -> Result<(), AnyError> { - unimplemented!(); + let temp_dir = TempDir::new().unwrap(); + let kernel_json_path = temp_dir.path().join("kernel.json"); + + // TODO(bartlomieju): add remaining fields as per + // https://jupyter-client.readthedocs.io/en/stable/kernels.html#kernel-specs + let json_data = json!({ + "argv": ["deno", "jupyter", "--conn", "{connection_file}"], + "display_name": "Deno", + "language": "typescript", + }); + + let f = std::fs::File::create(kernel_json_path)?; + serde_json::to_writer_pretty(f, &json_data)?; + + let child_result = std::process::Command::new("jupyter") + .args([ + "kernelspec", + "install", + "--name", + "deno", + &temp_dir.path().to_string_lossy(), + ]) + .spawn(); + + // TODO(bartlomieju): copy icons the the kernelspec directory + + if let Ok(mut child) = child_result { + let wait_result = child.wait(); + match wait_result { + Ok(status) => { + if !status.success() { + eprintln!("Failed to install kernelspec, try again."); + } + } + Err(err) => { + eprintln!("Failed to install kernelspec: {}", err); + } + } + } + + let _ = std::fs::remove_dir(temp_dir); + println!("Deno kernelspec installed successfully."); + Ok(()) } pub fn kernel( From 172723481437876fc419a7b0c0e8098b4da2727a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Thu, 9 Dec 2021 02:06:18 +0100 Subject: [PATCH 003/115] start working on a kernel --- cli/main.rs | 2 +- cli/tools/jupyter.rs | 90 ++++++++++++++++++++++++++++++++++++++++++-- 2 files changed, 87 insertions(+), 5 deletions(-) diff --git a/cli/main.rs b/cli/main.rs index 4e6add52d29245..4c2ddc0297c838 100644 --- a/cli/main.rs +++ b/cli/main.rs @@ -556,7 +556,7 @@ async fn jupyter_command( return tools::jupyter::install(); } - tools::jupyter::kernel(flags, jupyter_flags) + tools::jupyter::kernel(flags, jupyter_flags).await } async fn uninstall_command( diff --git a/cli/tools/jupyter.rs b/cli/tools/jupyter.rs index eeeac6a58f7c88..803a25cc0876e1 100644 --- a/cli/tools/jupyter.rs +++ b/cli/tools/jupyter.rs @@ -2,9 +2,12 @@ use crate::flags::Flags; use crate::flags::JupyterFlags; +use deno_core::anyhow::Context; use deno_core::error::AnyError; +use deno_core::serde::Deserialize; use deno_core::serde_json; use deno_core::serde_json::json; +use std::env::current_exe; use tempfile::TempDir; pub fn install() -> Result<(), AnyError> { @@ -13,8 +16,9 @@ pub fn install() -> Result<(), AnyError> { // TODO(bartlomieju): add remaining fields as per // https://jupyter-client.readthedocs.io/en/stable/kernels.html#kernel-specs + // FIXME(bartlomieju): replace `current_exe` let json_data = json!({ - "argv": ["deno", "jupyter", "--conn", "{connection_file}"], + "argv": [current_exe().unwrap().to_string_lossy(), "jupyter", "--conn", "{connection_file}"], "display_name": "Deno", "language": "typescript", }); @@ -53,9 +57,87 @@ pub fn install() -> Result<(), AnyError> { Ok(()) } -pub fn kernel( +pub async fn kernel( _flags: Flags, - _jupyter_flags: JupyterFlags, + jupyter_flags: JupyterFlags, ) -> Result<(), AnyError> { - unimplemented!(); + let conn_file_path = jupyter_flags.conn_file.unwrap(); + + let conn_file = std::fs::read_to_string(conn_file_path) + .context("Failed to read connection file")?; + let conn_spec: ConnectionSpec = serde_json::from_str(&conn_file) + .context("Failed to parse connection file")?; + eprintln!("[DENO] parsed conn file: {:#?}", conn_spec); + + let kernel = Kernel { + metadata: KernelMetadata::default(), + conn_spec, + state: KernelState::Idle, + }; + + eprintln!("[DENO] kernel created: {:#?}", kernel); + + Ok(()) +} + +#[derive(Debug)] +enum KernelState { + Busy, + Idle, +} + +#[derive(Debug)] +struct Kernel { + metadata: KernelMetadata, + conn_spec: ConnectionSpec, + state: KernelState, +} + +#[derive(Debug)] +struct KernelMetadata { + banner: String, + file_ext: String, + help_text: String, + help_url: String, + implementation_name: String, + kernel_version: String, + language_version: String, + language: String, + mime: String, + protocol_version: String, + session_id: String, +} + +impl Default for KernelMetadata { + fn default() -> Self { + Self { + banner: "Welcome to Deno kernel".to_string(), + file_ext: ".ts".to_string(), + help_text: "".to_string(), + help_url: "https://github.com/denoland/deno".to_string(), + implementation_name: "Deno kernel".to_string(), + // FIXME: + kernel_version: "0.0.1".to_string(), + // FIXME: + language_version: "1.16.4".to_string(), + language: "typescript".to_string(), + // FIXME: + mime: "text/x.typescript".to_string(), + protocol_version: "5.3".to_string(), + session_id: uuid::Uuid::new_v4().to_string(), + } + } +} + +#[derive(Debug, Deserialize)] +struct ConnectionSpec { + ip: String, + transport: String, + control_port: u32, + shell_port: u32, + stdin_port: u32, + hb_port: u32, + iopub_port: u32, + signature_scheme: String, + key: String, } From 1987776573991c039d51331e6daaf21cf27b179a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Sat, 11 Dec 2021 04:18:37 +0100 Subject: [PATCH 004/115] add a few structs --- cli/Cargo.toml | 2 +- cli/tools/jupyter.rs | 183 ++++++++++++++++++++++++++++++++++++++++++- 2 files changed, 180 insertions(+), 5 deletions(-) diff --git a/cli/Cargo.toml b/cli/Cargo.toml index b0d9ea492da270..10db793fa64535 100644 --- a/cli/Cargo.toml +++ b/cli/Cargo.toml @@ -85,7 +85,7 @@ text-size = "=1.1.0" tokio = { version = "=1.14", features = ["full"] } uuid = { version = "=0.8.2", features = ["v4", "serde"] } walkdir = "=2.3.2" -zeromq = "0.3.1" +zeromq = { version = "0.3.1", default-features = false, features = ["tcp-transport", "tokio-runtime"] } [target.'cfg(windows)'.dependencies] fwdansi = "=1.1.0" diff --git a/cli/tools/jupyter.rs b/cli/tools/jupyter.rs index 803a25cc0876e1..57ee5082f89cd5 100644 --- a/cli/tools/jupyter.rs +++ b/cli/tools/jupyter.rs @@ -7,8 +7,11 @@ use deno_core::error::AnyError; use deno_core::serde::Deserialize; use deno_core::serde_json; use deno_core::serde_json::json; +use deno_core::serde_json::Value; use std::env::current_exe; use tempfile::TempDir; +use zeromq::Socket; +use zeromq::SocketSend; pub fn install() -> Result<(), AnyError> { let temp_dir = TempDir::new().unwrap(); @@ -69,28 +72,114 @@ pub async fn kernel( .context("Failed to parse connection file")?; eprintln!("[DENO] parsed conn file: {:#?}", conn_spec); + let metadata = KernelMetadata::default(); + let iopub = PubComm::new( + conn_spec.ip.clone(), + conn_spec.iopub_port.to_string(), + metadata.session_id.clone(), + conn_spec.key.clone(), + ); + let kernel = Kernel { - metadata: KernelMetadata::default(), + metadata, conn_spec, state: KernelState::Idle, + iopub, }; - eprintln!("[DENO] kernel created: {:#?}", kernel); + eprintln!("[DENO] kernel created: {:#?}", kernel.metadata.session_id); Ok(()) } -#[derive(Debug)] +#[derive(Clone, Copy, Debug, PartialEq)] enum KernelState { Busy, Idle, + Starting, +} + +impl std::fmt::Display for KernelState { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + Self::Busy => write!(f, "busy"), + Self::Idle => write!(f, "idle"), + Self::Starting => write!(f, "starting"), + } + } } -#[derive(Debug)] struct Kernel { metadata: KernelMetadata, conn_spec: ConnectionSpec, state: KernelState, + iopub: PubComm, +} + +impl Kernel { + async fn set_state(&mut self, state: KernelState, ctx: CommContext) { + if self.state == state { + return; + } + + self.state = state; + + let now = std::time::SystemTime::now(); + let now: chrono::DateTime = now.into(); + let now = now.to_rfc3339(); + + let msg = Message { + is_reply: true, + r#type: "status".to_string(), + header: MessageHeader { + msg_id: uuid::Uuid::new_v4().to_string(), + session: ctx.session_id.clone(), + // FIXME: + username: "".to_string(), + date: now.to_string(), + msg_type: "status".to_string(), + // TODO: this should be taken from a global, + version: "5.3".to_string(), + }, + parent_header: Some(ctx.message.header), + session_id: ctx.session_id, + content: json!({ + "execution_state": state.to_string(), + }), + }; + // ignore any error when announcing changes + let _ = self.iopub.send(msg).await; + } + + // TODO(bartlomieju): feels like this info should be a separate struct + // instead of KernelMetadata + fn get_kernel_info(&self) -> Value { + json!({ + "status": "ok", + "protocol_version": self.metadata.protocol_version, + "implementation_version": self.metadata.kernel_version, + "implementation": self.metadata.implementation_name, + "language_info": { + "name": self.metadata.language, + "version": self.metadata.language_version, + "mime": self.metadata.mime, + "file_extension": self.metadata.file_ext, + }, + "help_links": [{ + "text": self.metadata.help_text, + "url": self.metadata.help_url + }], + "banner": self.metadata.banner, + "debugger": false + }) + } + + fn get_comm_info() -> Value { + json!({ + "status": "ok", + "comms": {} + }) + } } #[derive(Debug)] @@ -141,3 +230,89 @@ struct ConnectionSpec { signature_scheme: String, key: String, } + +struct CommContext { + message: Message, + hmac: String, + session_id: String, +} + +struct MessageHeader { + msg_id: String, + session: String, + username: String, + date: String, + msg_type: String, + version: String, +} + +struct Message { + is_reply: bool, + r#type: String, + header: MessageHeader, + parent_header: Option, + content: Value, + session_id: String, +} + +impl Message { + fn new() -> Self { + todo!() + } + + fn calc_hmac(&self, hmac: String) -> String { + todo!() + } + + fn serialize(&self, hmac: String) -> Vec { + todo!() + } + + fn hmac_verify(&self, expected_signature: Vec, hmac: String) { + todo!() + } + + fn from_data(data: Vec, hmac: String) -> Result { + todo!() + } +} + +struct PubComm { + hostname: String, + port: String, + session_id: String, + hmac_key: String, + socket: zeromq::PubSocket, +} + +impl PubComm { + pub fn new( + hostname: String, + port: String, + session_id: String, + hmac_key: String, + ) -> Self { + Self { + hostname, + port, + session_id, + hmac_key, + socket: zeromq::PubSocket::new(), + } + } + + pub async fn connect(&mut self) -> Result<(), AnyError> { + self + .socket + .connect(&format!("tcp://{}:{}", self.hostname, self.port)) + .await?; + + Ok(()) + } + + pub async fn send(&mut self, msg: Message) -> Result<(), AnyError> { + let msg_str = msg.serialize(self.hmac_key.clone()); + self.socket.send(msg_str.into()).await?; + Ok(()) + } +} From f397ae3ae4ea7ad6b4e2c002f8f220c56963ec26 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Sun, 12 Dec 2021 17:04:29 +0100 Subject: [PATCH 005/115] integrate apowers changes --- cli/main.rs | 9 ++-- cli/tools/jupyter.rs | 116 ++++++++++++++++++++++++++++++++++++++----- 2 files changed, 110 insertions(+), 15 deletions(-) diff --git a/cli/main.rs b/cli/main.rs index e21a0d344bb283..1f1a47a8a9f267 100644 --- a/cli/main.rs +++ b/cli/main.rs @@ -552,12 +552,15 @@ async fn install_command( async fn jupyter_command( flags: Flags, jupyter_flags: JupyterFlags, -) -> Result<(), AnyError> { +) -> Result { if jupyter_flags.install { - return tools::jupyter::install(); + tools::jupyter::install()?; + return Ok(0); } - tools::jupyter::kernel(flags, jupyter_flags).await + tools::jupyter::kernel(flags, jupyter_flags).await?; + + Ok(0) } async fn uninstall_command( diff --git a/cli/tools/jupyter.rs b/cli/tools/jupyter.rs index 57ee5082f89cd5..5a762c3081270a 100644 --- a/cli/tools/jupyter.rs +++ b/cli/tools/jupyter.rs @@ -10,8 +10,9 @@ use deno_core::serde_json::json; use deno_core::serde_json::Value; use std::env::current_exe; use tempfile::TempDir; -use zeromq::Socket; -use zeromq::SocketSend; +use tokio::join; +use zeromq::prelude::*; +use zeromq::ZmqMessage; pub fn install() -> Result<(), AnyError> { let temp_dir = TempDir::new().unwrap(); @@ -22,7 +23,7 @@ pub fn install() -> Result<(), AnyError> { // FIXME(bartlomieju): replace `current_exe` let json_data = json!({ "argv": [current_exe().unwrap().to_string_lossy(), "jupyter", "--conn", "{connection_file}"], - "display_name": "Deno", + "display_name": "Deno (Rust)", "language": "typescript", }); @@ -34,7 +35,7 @@ pub fn install() -> Result<(), AnyError> { "kernelspec", "install", "--name", - "deno", + "rusty_deno", &temp_dir.path().to_string_lossy(), ]) .spawn(); @@ -73,22 +74,44 @@ pub async fn kernel( eprintln!("[DENO] parsed conn file: {:#?}", conn_spec); let metadata = KernelMetadata::default(); - let iopub = PubComm::new( - conn_spec.ip.clone(), - conn_spec.iopub_port.to_string(), - metadata.session_id.clone(), - conn_spec.key.clone(), + // let iopub = PubComm::new( + // conn_spec.ip.clone(), + // conn_spec.iopub_port.to_string(), + // metadata.session_id.clone(), + // conn_spec.key.clone(), + // ); + + let shell_conn_str = + create_conn_str(&conn_spec.transport, &conn_spec.ip, conn_spec.shell_port); + let control_conn_str = create_conn_str( + &conn_spec.transport, + &conn_spec.ip, + conn_spec.control_port, ); + let iopub_conn_str = + create_conn_str(&conn_spec.transport, &conn_spec.ip, conn_spec.iopub_port); + let stdin_conn_str = + create_conn_str(&conn_spec.transport, &conn_spec.ip, conn_spec.stdin_port); + let hb_conn_str = + create_conn_str(&conn_spec.transport, &conn_spec.ip, conn_spec.hb_port); let kernel = Kernel { metadata, conn_spec, state: KernelState::Idle, - iopub, + // iopub, }; eprintln!("[DENO] kernel created: {:#?}", kernel.metadata.session_id); + let (_first, _second, _third, _fourth, _fifth) = join!( + create_zmq_dealer("shell", &shell_conn_str), + create_zmq_dealer("control", &control_conn_str), + create_zmq_publisher("iopub", &iopub_conn_str), + create_zmq_dealer("stdin", &stdin_conn_str), + create_zmq_reply("hb", &hb_conn_str), + ); + Ok(()) } @@ -113,7 +136,7 @@ struct Kernel { metadata: KernelMetadata, conn_spec: ConnectionSpec, state: KernelState, - iopub: PubComm, + // iopub: PubComm, } impl Kernel { @@ -148,7 +171,7 @@ impl Kernel { }), }; // ignore any error when announcing changes - let _ = self.iopub.send(msg).await; + // let _ = self.iopub.send(msg).await; } // TODO(bartlomieju): feels like this info should be a separate struct @@ -237,6 +260,7 @@ struct CommContext { session_id: String, } +#[derive(Debug, Deserialize)] struct MessageHeader { msg_id: String, session: String, @@ -316,3 +340,71 @@ impl PubComm { Ok(()) } } + +async fn create_zmq_dealer(name: &str, conn_str: &str) -> Result<(), AnyError> { + println!("dealer '{}' connection string: {}", name, conn_str); + + let mut sock = zeromq::DealerSocket::new(); + sock.monitor(); + sock.bind(conn_str).await?; + + // TODO(apowers313) pop this out into it's own function: we need to send on sock, as well as receive + loop { + let data = sock.recv().await?; + dbg!(&data); + println!("{} got packet!", name); + println!("size is: {}", data.len()); + parse_zmq_packet(&data)?; + } +} + +async fn create_zmq_publisher( + name: &str, + conn_str: &str, +) -> Result { + println!("iopub {} connection string: {}", name, conn_str); + + let mut sock = zeromq::PubSocket::new(); + sock.bind(conn_str).await?; + + // no loop, only used for broadcasting status to Jupyter frontends + + Ok(sock) +} + +async fn create_zmq_reply(name: &str, conn_str: &str) -> Result<(), AnyError> { + println!("reply '{}' connection string: {}", name, conn_str); + + let mut sock = zeromq::RepSocket::new(); // TODO(apowers313) exact same as dealer, refactor + sock.monitor(); + sock.bind(conn_str).await?; + + loop { + let msg = sock.recv().await?; + dbg!(&msg); + println!("{} got packet!", name); + } +} + +fn create_conn_str(transport: &str, ip: &str, port: u32) -> String { + format!("{}://{}:{}", transport, ip, port) +} + +fn parse_zmq_packet(data: &ZmqMessage) -> Result<(), AnyError> { + let _delim = data.get(0); + let _hmac = data.get(1); + let header = data.get(2).unwrap(); + let _parent_header = data.get(3); + let _metadata = data.get(4); + let _content = data.get(5); + + println!("header:"); + dbg!(header); + let header_str = std::str::from_utf8(&header).unwrap(); + let header_value: MessageHeader = serde_json::from_str(header_str).unwrap(); + println!("header_value"); + dbg!(&header_value); + // validate_header(&header_value)?; + + Ok(()) +} From 8c5f6547c18137f11ec81250d11277a9c77b347b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Sun, 12 Dec 2021 17:26:03 +0100 Subject: [PATCH 006/115] refactor IOPub --- cli/tools/jupyter.rs | 55 +++++++++++--------------------------------- 1 file changed, 14 insertions(+), 41 deletions(-) diff --git a/cli/tools/jupyter.rs b/cli/tools/jupyter.rs index 5a762c3081270a..9a7c318a269412 100644 --- a/cli/tools/jupyter.rs +++ b/cli/tools/jupyter.rs @@ -74,12 +74,11 @@ pub async fn kernel( eprintln!("[DENO] parsed conn file: {:#?}", conn_spec); let metadata = KernelMetadata::default(); - // let iopub = PubComm::new( - // conn_spec.ip.clone(), - // conn_spec.iopub_port.to_string(), - // metadata.session_id.clone(), - // conn_spec.key.clone(), - // ); + let iopub = PubComm::new( + create_conn_str(&conn_spec.transport, &conn_spec.ip, conn_spec.iopub_port), + metadata.session_id.clone(), + conn_spec.key.clone(), + ); let shell_conn_str = create_conn_str(&conn_spec.transport, &conn_spec.ip, conn_spec.shell_port); @@ -88,8 +87,6 @@ pub async fn kernel( &conn_spec.ip, conn_spec.control_port, ); - let iopub_conn_str = - create_conn_str(&conn_spec.transport, &conn_spec.ip, conn_spec.iopub_port); let stdin_conn_str = create_conn_str(&conn_spec.transport, &conn_spec.ip, conn_spec.stdin_port); let hb_conn_str = @@ -99,15 +96,14 @@ pub async fn kernel( metadata, conn_spec, state: KernelState::Idle, - // iopub, + iopub, }; eprintln!("[DENO] kernel created: {:#?}", kernel.metadata.session_id); - let (_first, _second, _third, _fourth, _fifth) = join!( + let (_first, _second, _fourth, _fifth) = join!( create_zmq_dealer("shell", &shell_conn_str), create_zmq_dealer("control", &control_conn_str), - create_zmq_publisher("iopub", &iopub_conn_str), create_zmq_dealer("stdin", &stdin_conn_str), create_zmq_reply("hb", &hb_conn_str), ); @@ -136,7 +132,7 @@ struct Kernel { metadata: KernelMetadata, conn_spec: ConnectionSpec, state: KernelState, - // iopub: PubComm, + iopub: PubComm, } impl Kernel { @@ -171,7 +167,7 @@ impl Kernel { }), }; // ignore any error when announcing changes - // let _ = self.iopub.send(msg).await; + let _ = self.iopub.send(msg).await; } // TODO(bartlomieju): feels like this info should be a separate struct @@ -302,23 +298,17 @@ impl Message { } struct PubComm { - hostname: String, - port: String, + conn_str: String, session_id: String, hmac_key: String, socket: zeromq::PubSocket, } impl PubComm { - pub fn new( - hostname: String, - port: String, - session_id: String, - hmac_key: String, - ) -> Self { + pub fn new(conn_str: String, session_id: String, hmac_key: String) -> Self { + println!("iopub connection: {}", conn_str); Self { - hostname, - port, + conn_str, session_id, hmac_key, socket: zeromq::PubSocket::new(), @@ -326,10 +316,7 @@ impl PubComm { } pub async fn connect(&mut self) -> Result<(), AnyError> { - self - .socket - .connect(&format!("tcp://{}:{}", self.hostname, self.port)) - .await?; + self.socket.bind(&self.conn_str).await?; Ok(()) } @@ -358,20 +345,6 @@ async fn create_zmq_dealer(name: &str, conn_str: &str) -> Result<(), AnyError> { } } -async fn create_zmq_publisher( - name: &str, - conn_str: &str, -) -> Result { - println!("iopub {} connection string: {}", name, conn_str); - - let mut sock = zeromq::PubSocket::new(); - sock.bind(conn_str).await?; - - // no loop, only used for broadcasting status to Jupyter frontends - - Ok(sock) -} - async fn create_zmq_reply(name: &str, conn_str: &str) -> Result<(), AnyError> { println!("reply '{}' connection string: {}", name, conn_str); From 5ecf41b92f87ebe3565410ce86487a944b751650 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Sun, 12 Dec 2021 17:58:23 +0100 Subject: [PATCH 007/115] store comms on Kernel and poll message receives accordingly --- cli/tools/jupyter.rs | 132 ++++++++++++++++++++++++++++++++----------- 1 file changed, 100 insertions(+), 32 deletions(-) diff --git a/cli/tools/jupyter.rs b/cli/tools/jupyter.rs index 9a7c318a269412..f68e9cb0f89d21 100644 --- a/cli/tools/jupyter.rs +++ b/cli/tools/jupyter.rs @@ -74,39 +74,51 @@ pub async fn kernel( eprintln!("[DENO] parsed conn file: {:#?}", conn_spec); let metadata = KernelMetadata::default(); - let iopub = PubComm::new( + let iopub_comm = PubComm::new( create_conn_str(&conn_spec.transport, &conn_spec.ip, conn_spec.iopub_port), metadata.session_id.clone(), conn_spec.key.clone(), ); - - let shell_conn_str = - create_conn_str(&conn_spec.transport, &conn_spec.ip, conn_spec.shell_port); - let control_conn_str = create_conn_str( - &conn_spec.transport, - &conn_spec.ip, - conn_spec.control_port, + let shell_comm = DealerComm::new( + "shell", + create_conn_str(&conn_spec.transport, &conn_spec.ip, conn_spec.shell_port), + metadata.session_id.clone(), + conn_spec.key.clone(), + ); + let control_comm = DealerComm::new( + "control", + create_conn_str( + &conn_spec.transport, + &conn_spec.ip, + conn_spec.control_port, + ), + metadata.session_id.clone(), + conn_spec.key.clone(), ); - let stdin_conn_str = - create_conn_str(&conn_spec.transport, &conn_spec.ip, conn_spec.stdin_port); + let stdin_comm = DealerComm::new( + "stdin", + create_conn_str(&conn_spec.transport, &conn_spec.ip, conn_spec.stdin_port), + metadata.session_id.clone(), + conn_spec.key.clone(), + ); + let hb_conn_str = create_conn_str(&conn_spec.transport, &conn_spec.ip, conn_spec.hb_port); - let kernel = Kernel { + let mut kernel = Kernel { metadata, conn_spec, state: KernelState::Idle, - iopub, + iopub_comm, + shell_comm, + control_comm, + stdin_comm, }; eprintln!("[DENO] kernel created: {:#?}", kernel.metadata.session_id); - let (_first, _second, _fourth, _fifth) = join!( - create_zmq_dealer("shell", &shell_conn_str), - create_zmq_dealer("control", &control_conn_str), - create_zmq_dealer("stdin", &stdin_conn_str), - create_zmq_reply("hb", &hb_conn_str), - ); + let (_first, _second) = + join!(kernel.run(), create_zmq_reply("hb", &hb_conn_str),); Ok(()) } @@ -132,10 +144,40 @@ struct Kernel { metadata: KernelMetadata, conn_spec: ConnectionSpec, state: KernelState, - iopub: PubComm, + iopub_comm: PubComm, + shell_comm: DealerComm, + control_comm: DealerComm, + stdin_comm: DealerComm, } impl Kernel { + async fn run(&mut self) -> Result<(), AnyError> { + let (iopub_res, shell_res, control_res, stdin_res) = join!( + self.iopub_comm.connect(), + self.shell_comm.connect(), + self.control_comm.connect(), + self.stdin_comm.connect(), + ); + iopub_res?; + shell_res?; + control_res?; + stdin_res?; + + loop { + tokio::select! { + shell_msg = self.shell_comm.recv() => { + eprintln!("shell got packet: {:#?}", shell_msg); + }, + control_msg = self.control_comm.recv() => { + eprintln!("control got packet: {:#?}", control_msg); + }, + stdin_msg = self.stdin_comm.recv() => { + eprintln!("stdin got packet: {:#?}", stdin_msg); + }, + } + } + } + async fn set_state(&mut self, state: KernelState, ctx: CommContext) { if self.state == state { return; @@ -167,7 +209,7 @@ impl Kernel { }), }; // ignore any error when announcing changes - let _ = self.iopub.send(msg).await; + let _ = self.iopub_comm.send(msg).await; } // TODO(bartlomieju): feels like this info should be a separate struct @@ -328,20 +370,46 @@ impl PubComm { } } -async fn create_zmq_dealer(name: &str, conn_str: &str) -> Result<(), AnyError> { - println!("dealer '{}' connection string: {}", name, conn_str); +struct DealerComm { + name: String, + conn_str: String, + session_id: String, + hmac_key: String, + socket: zeromq::DealerSocket, +} - let mut sock = zeromq::DealerSocket::new(); - sock.monitor(); - sock.bind(conn_str).await?; +impl DealerComm { + pub fn new( + name: &str, + conn_str: String, + session_id: String, + hmac_key: String, + ) -> Self { + println!("dealer '{}' connection: {}", name, conn_str); + Self { + name: name.to_string(), + conn_str, + session_id, + hmac_key, + socket: zeromq::DealerSocket::new(), + } + } - // TODO(apowers313) pop this out into it's own function: we need to send on sock, as well as receive - loop { - let data = sock.recv().await?; - dbg!(&data); - println!("{} got packet!", name); - println!("size is: {}", data.len()); - parse_zmq_packet(&data)?; + pub async fn connect(&mut self) -> Result<(), AnyError> { + self.socket.bind(&self.conn_str).await?; + + Ok(()) + } + + pub async fn recv(&mut self) -> Result { + let msg = self.socket.recv().await?; + Ok(msg) + } + + pub async fn send(&mut self, msg: Message) -> Result<(), AnyError> { + let msg_str = msg.serialize(self.hmac_key.clone()); + self.socket.send(msg_str.into()).await?; + Ok(()) } } From 691f2a42c10c46cfa4f8f4806045bbda0920d360 Mon Sep 17 00:00:00 2001 From: Adam Powers Date: Sun, 12 Dec 2021 23:32:42 -0800 Subject: [PATCH 008/115] add jupyter message structs --- cli/tools/jupyter.rs | 301 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 301 insertions(+) diff --git a/cli/tools/jupyter.rs b/cli/tools/jupyter.rs index f68e9cb0f89d21..ca2da822e4104f 100644 --- a/cli/tools/jupyter.rs +++ b/cli/tools/jupyter.rs @@ -449,3 +449,304 @@ fn parse_zmq_packet(data: &ZmqMessage) -> Result<(), AnyError> { Ok(()) } + +// /* ***************** +// * SHELL MESSAGES +// * *****************/ + +// Shell Request Message Types +// "execute_request" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#execute +// "inspect_request" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#introspection +// "complete_request" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#completion +// "history_request" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#history +// "is_complete_request" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#code-completeness +// "comm_info_request" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#comm-info +// "kernel_info_request" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-info + +// Shell Reply Message Types +// "execute_reply" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#execution-results +// "inspect_reply" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#introspection +// "complete_reply" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#completion +// "history_reply" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#history +// "is_complete_reply" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#code-completeness +// "comm_info_reply" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#comm-info +// "kernel_info_reply" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-info + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#execute +struct ExecuteRequestContent { + code: String, + silent: bool, + store_history: bool, + user_expressions: Value, + allow_stdin: bool, + stop_on_error: bool, +} + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#execution-results +struct ExecuteReplyContent { + status: String, + execution_count: u32, + payload: Option>, + user_expressions: Option, +} + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#introspection +struct InspectRequestContent { + code: String, + cursor_pos: u32, + detail_level: u8, // 0 = Low, 1 = High +} + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#introspection +struct InspectReplyContent { + status: String, + found: bool, + data: Option, + metadata: Option, +} + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#completion +struct CompleteRequestContent { + code: String, + cursor_pos: u32, +} + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#completion +struct CompleteReplyContent { + status: String, + matches: Option, + cursor_start: u32, + cursor_end: u32, + metadata: Option +} + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#history +struct HistoryRequestContent { + output: bool, + raw: bool, + hist_access_type: String, // "range" | "tail" | "search" + session: u32, + start: u32, + stop: u32, + n: u32, +} + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#history +struct HistoryReplyContent { + status: String, + history: Option +} + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#code-completeness +struct CodeCompleteRequestContent { + code: String +} + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#code-completeness +struct CodeCompleteReplyContent { + status: String, // "complete" | "incomplete" | "invalid" | "unknown" + indent: String, +} + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#comm-info +struct CommInfoRequestContent { + target_name: String +} + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#comm-info +struct CommInfoReplyContent { + status: String, + comms: Option, +} + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-info +// struct KernelInfoRequest {} // empty + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-info +struct KernelInfoReply { + status: String, + protocol_version: String, + implementation: String, + implementation_version: String, + language_info: KernelLanguageInfo, + banner: String, + debugger: bool, + help_links: Vec +} + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-info +struct KernelLanguageInfo { + name: String, + version: String, + mimetype: String, + file_extension: String, + pygments_lexer: String, + codemirror_mode: Option, + nbconvert_exporter: String +} + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-info +struct KernelHelpLink { + text: String, + url: String, +} + +/* ***************** + * CONTROL MESSAGES + * *****************/ + +// Control Request Message Types +// "shutdown_request" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-shutdown +// "interrupt_request" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-interrupt +// "debug_request" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#debug-request + +// Control Reply Message Types +// "shutdown_reply" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-shutdown +// "interrupt_reply" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-interrupt +// "debug_reply" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#debug-request + + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-shutdown +struct ShutdownRequestContent { + restart: bool +} + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-shutdown +struct ShutdownReplyContent { + status: String, + restart: bool +} + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-interrupt +// struct InterruptRequestContent {} // empty + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-interrupt +struct InterruptReplyContent { + status: String +} + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#debug-request +// struct DebugRequestContent {} // See Debug Adapter Protocol (DAP) 1.39 or later + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#debug-request +// struct DebugReplyContent {} // See Debug Adapter Protocol (DAP) 1.39 or later + + +/* ***************** + * IOPUB MESSAGES + * *****************/ + +// Io Pub Message Types +// "stream" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#streams-stdout-stderr-etc +// "display_data" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#display-data +// "update_display_data" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#update-display-data +// "execute_input" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#code-inputs +// "execute_result" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#id6 +// "error" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#execution-errors +// "status" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-status +// "clear_output" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#clear-output +// "debug_event" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#debug-event +// "comm_open" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#opening-a-comm +// "comm_msg" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#comm-messages +// "comm_close" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#tearing-down-comms + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#request-reply +struct ErrorStatusContent { + status: String, // "error" + ename: String, + evalue: String, + traceback: Vec, + execution_count: Option +} + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#request-reply +struct StatusContent { + status: String, // "ok" | "abort" +} + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#streams-stdout-stderr-etc +struct StreamContent { + name: String, // "stdout" | "stderr" + text: String +} + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#display-data +struct DisplayDataContent { + data: Value, + metadata: Option, + transient: Option +} + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#update-display-data +// struct UpdateDisplayDataContent {} // same as DisplayDataContent + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#code-inputs +struct ExecuteInputContent { + code: String, + execution_count: u32 +} + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#id6 +struct ExecuteResultContent { + execution_count: u32, + data: Option, + metadata: Option +} + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#execution-errors +struct ErrorContent { + payload: Option>, + user_expressions: Option, +} + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-status +struct KernelStatusContent { + execution_state: String, // "busy" | "idle" | "starting" +} + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#clear-output +struct ClearOutputContent { + wait: bool +} + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#debug-event +// struct DebugEventContent {} // see Event message from the Debug Adapter Protocol (DAP) + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#opening-a-comm +struct CommOpenMessage { + comm_id: uuid::Uuid, + target_name: String, + data: Option, +} + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#comm-messages +struct CommMsgMessage { + comm_id: uuid::Uuid, + data: Option, +} + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#comm-messages +struct CommCloseMessage { + comm_id: uuid::Uuid, + data: Option, +} + +/* ***************** + * STDIN MESSAGES + * *****************/ +// Stdin Request Message Types +// "input_request" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#messages-on-the-stdin-router-dealer-channel + +// Stdin Reply Message Types +// "input_reply" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#messages-on-the-stdin-router-dealer-channel + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#messages-on-the-stdin-router-dealer-channel +struct InputRequestContent { + prompt: String, + password: bool +} + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#messages-on-the-stdin-router-dealer-channel +struct InputReplyContent { + value: String +} \ No newline at end of file From 5fec7ffcf001a413ca881e4313d3f933c35a5ef0 Mon Sep 17 00:00:00 2001 From: Adam Powers Date: Wed, 15 Dec 2021 00:17:05 -0800 Subject: [PATCH 009/115] ignore Jupyter files --- .gitignore | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/.gitignore b/.gitignore index 31a00493985965..62b243b3a983cd 100644 --- a/.gitignore +++ b/.gitignore @@ -33,3 +33,7 @@ cli/tests/.test_coverage/ # WPT generated cert files /tools/wpt/certs/index.txt* /tools/wpt/certs/serial* + +# Jupyter files +.ipynb_checkpoints/ +Untitled*.ipynb \ No newline at end of file From 8849be01775192e40d18bc2a1971828a280323dd Mon Sep 17 00:00:00 2001 From: Adam Powers Date: Wed, 15 Dec 2021 00:17:58 -0800 Subject: [PATCH 010/115] add hmac sign and verify --- Cargo.lock | 1 + cli/Cargo.toml | 1 + cli/tools/jupyter.rs | 96 ++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 98 insertions(+) diff --git a/Cargo.lock b/Cargo.lock index b97eab2624d4b1..44cf414b5c6843 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -770,6 +770,7 @@ dependencies = [ "cache_control", "chrono", "clap", + "data-encoding", "data-url", "deno_ast", "deno_broadcast_channel", diff --git a/cli/Cargo.toml b/cli/Cargo.toml index 10db793fa64535..a6aac166f1cf94 100644 --- a/cli/Cargo.toml +++ b/cli/Cargo.toml @@ -51,6 +51,7 @@ base64 = "=0.13.0" cache_control = "=0.2.0" chrono = "=0.4.19" clap = "=2.33.3" +data-encoding = "2.3.2" data-url = "=0.1.1" dissimilar = "=1.0.2" dprint-plugin-json = "=0.13.2" diff --git a/cli/tools/jupyter.rs b/cli/tools/jupyter.rs index ca2da822e4104f..62232700c0125a 100644 --- a/cli/tools/jupyter.rs +++ b/cli/tools/jupyter.rs @@ -2,12 +2,14 @@ use crate::flags::Flags; use crate::flags::JupyterFlags; +use data_encoding::HEXLOWER; use deno_core::anyhow::Context; use deno_core::error::AnyError; use deno_core::serde::Deserialize; use deno_core::serde_json; use deno_core::serde_json::json; use deno_core::serde_json::Value; +use ring::hmac; use std::env::current_exe; use tempfile::TempDir; use tokio::join; @@ -450,6 +452,100 @@ fn parse_zmq_packet(data: &ZmqMessage) -> Result<(), AnyError> { Ok(()) } +#[allow(dead_code)] +fn hmac_sign(zmq: &ZmqMessage, key: hmac::Key) -> String { + let mut hmac_ctx = hmac::Context::with_key(&key); + hmac_ctx.update(zmq.get(2).unwrap()); // header + hmac_ctx.update(zmq.get(3).unwrap()); // parent header + hmac_ctx.update(zmq.get(4).unwrap()); // metadata + hmac_ctx.update(zmq.get(5).unwrap()); // content + let tag = hmac_ctx.sign(); + dbg!(tag); + let sig = HEXLOWER.encode(tag.as_ref()); + + return sig; +} + +#[allow(dead_code)] +fn hmac_verify( + zmq: &ZmqMessage, + key: hmac::Key, + sig_str: String, +) -> Result<(), ring::error::Unspecified> { + dbg!(&zmq); + let mut msg = Vec::::new(); + msg.extend(zmq.get(2).unwrap()); // header + msg.extend(zmq.get(3).unwrap()); // parent header + msg.extend(zmq.get(4).unwrap()); // metadata + msg.extend(zmq.get(5).unwrap()); // content + let sig = HEXLOWER.decode(sig_str.as_bytes()).unwrap(); + hmac::verify(&key, &msg.as_ref(), &sig.as_ref())?; + + Ok(()) +} + +#[test] +fn hmac_verify_test() { + let key_value = "1f5cec86-8eaa942eef7f5a35b51ddcf5"; + let key = hmac::Key::new(hmac::HMAC_SHA256, key_value.as_ref()); + + let delim = "".as_bytes().to_vec(); + let hash = "43a5c45062e0b6bcc59c727f90165ad1d2eb02e1c5317aa25c2c2049d96d3b6a" + .as_bytes() + .to_vec(); + let header = "{\"msg_id\":\"c0fd20872c1b4d1c87e7fc814b75c93e_0\",\"msg_type\":\"kernel_info_request\",\"username\":\"ampower\",\"session\":\"c0fd20872c1b4d1c87e7fc814b75c93e\",\"date\":\"2021-12-10T06:20:40.259695Z\",\"version\":\"5.3\"}".as_bytes().to_vec(); + let parent_header = "{}".as_bytes().to_vec(); + let metadata = "{}".as_bytes().to_vec(); + let content = "{}".as_bytes().to_vec(); + + let mut test_msg = ZmqMessage::from(delim); + test_msg.push_back(hash.into()); + test_msg.push_back(header.into()); + test_msg.push_back(parent_header.into()); + test_msg.push_back(metadata.into()); + test_msg.push_back(content.into()); + + dbg!(test_msg.clone()); + match hmac_verify( + &test_msg, + key, + String::from("43a5c45062e0b6bcc59c727f90165ad1d2eb02e1c5317aa25c2c2049d96d3b6a"), + ) { + Ok(_) => assert!(true), + Err(_) => assert!(false, "signature validation failed"), + } +} + +#[test] +fn hmac_sign_test() { + let key_value = "1f5cec86-8eaa942eef7f5a35b51ddcf5"; + let key = hmac::Key::new(hmac::HMAC_SHA256, key_value.as_ref()); + + let delim = ""; + let hash = "43a5c45062e0b6bcc59c727f90165ad1d2eb02e1c5317aa25c2c2049d96d3b6a" + .as_bytes() + .to_vec(); + let header = "{\"msg_id\":\"c0fd20872c1b4d1c87e7fc814b75c93e_0\",\"msg_type\":\"kernel_info_request\",\"username\":\"ampower\",\"session\":\"c0fd20872c1b4d1c87e7fc814b75c93e\",\"date\":\"2021-12-10T06:20:40.259695Z\",\"version\":\"5.3\"}".as_bytes().to_vec(); + let parent_header = "{}".as_bytes().to_vec(); + let metadata = "{}".as_bytes().to_vec(); + let content = "{}".as_bytes().to_vec(); + + let mut test_msg = ZmqMessage::from(delim); + test_msg.push_back(hash.into()); + test_msg.push_back(header.into()); + test_msg.push_back(parent_header.into()); + test_msg.push_back(metadata.into()); + test_msg.push_back(content.into()); + + dbg!(test_msg.clone()); + let sig = hmac_sign(&test_msg, key); + println!("Signature: {}", sig); + assert_eq!( + sig, + "43a5c45062e0b6bcc59c727f90165ad1d2eb02e1c5317aa25c2c2049d96d3b6a" + ); +} + // /* ***************** // * SHELL MESSAGES // * *****************/ From f1015f27acf6a7717c362769daebfdfb2346cbb0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Fri, 17 Dec 2021 18:56:13 +0100 Subject: [PATCH 011/115] fix panic and fmt --- cli/tools/jupyter.rs | 342 ++++++++++++++++++++++--------------------- 1 file changed, 173 insertions(+), 169 deletions(-) diff --git a/cli/tools/jupyter.rs b/cli/tools/jupyter.rs index 62232700c0125a..04172a8d93b5e6 100644 --- a/cli/tools/jupyter.rs +++ b/cli/tools/jupyter.rs @@ -5,6 +5,7 @@ use crate::flags::JupyterFlags; use data_encoding::HEXLOWER; use deno_core::anyhow::Context; use deno_core::error::AnyError; +use deno_core::error::generic_error; use deno_core::serde::Deserialize; use deno_core::serde_json; use deno_core::serde_json::json; @@ -67,6 +68,10 @@ pub async fn kernel( _flags: Flags, jupyter_flags: JupyterFlags, ) -> Result<(), AnyError> { + if jupyter_flags.conn_file.is_none() { + return Err(generic_error("Missing --conn flag")); + } + let conn_file_path = jupyter_flags.conn_file.unwrap(); let conn_file = std::fs::read_to_string(conn_file_path) @@ -454,102 +459,103 @@ fn parse_zmq_packet(data: &ZmqMessage) -> Result<(), AnyError> { #[allow(dead_code)] fn hmac_sign(zmq: &ZmqMessage, key: hmac::Key) -> String { - let mut hmac_ctx = hmac::Context::with_key(&key); - hmac_ctx.update(zmq.get(2).unwrap()); // header - hmac_ctx.update(zmq.get(3).unwrap()); // parent header - hmac_ctx.update(zmq.get(4).unwrap()); // metadata - hmac_ctx.update(zmq.get(5).unwrap()); // content - let tag = hmac_ctx.sign(); - dbg!(tag); - let sig = HEXLOWER.encode(tag.as_ref()); + let mut hmac_ctx = hmac::Context::with_key(&key); + hmac_ctx.update(zmq.get(2).unwrap()); // header + hmac_ctx.update(zmq.get(3).unwrap()); // parent header + hmac_ctx.update(zmq.get(4).unwrap()); // metadata + hmac_ctx.update(zmq.get(5).unwrap()); // content + let tag = hmac_ctx.sign(); + dbg!(tag); + let sig = HEXLOWER.encode(tag.as_ref()); - return sig; + return sig; } #[allow(dead_code)] fn hmac_verify( - zmq: &ZmqMessage, - key: hmac::Key, - sig_str: String, + zmq: &ZmqMessage, + key: hmac::Key, + sig_str: String, ) -> Result<(), ring::error::Unspecified> { - dbg!(&zmq); - let mut msg = Vec::::new(); - msg.extend(zmq.get(2).unwrap()); // header - msg.extend(zmq.get(3).unwrap()); // parent header - msg.extend(zmq.get(4).unwrap()); // metadata - msg.extend(zmq.get(5).unwrap()); // content - let sig = HEXLOWER.decode(sig_str.as_bytes()).unwrap(); - hmac::verify(&key, &msg.as_ref(), &sig.as_ref())?; + dbg!(&zmq); + let mut msg = Vec::::new(); + msg.extend(zmq.get(2).unwrap()); // header + msg.extend(zmq.get(3).unwrap()); // parent header + msg.extend(zmq.get(4).unwrap()); // metadata + msg.extend(zmq.get(5).unwrap()); // content + let sig = HEXLOWER.decode(sig_str.as_bytes()).unwrap(); + hmac::verify(&key, &msg.as_ref(), &sig.as_ref())?; - Ok(()) + Ok(()) } #[test] fn hmac_verify_test() { - let key_value = "1f5cec86-8eaa942eef7f5a35b51ddcf5"; - let key = hmac::Key::new(hmac::HMAC_SHA256, key_value.as_ref()); - - let delim = "".as_bytes().to_vec(); - let hash = "43a5c45062e0b6bcc59c727f90165ad1d2eb02e1c5317aa25c2c2049d96d3b6a" - .as_bytes() - .to_vec(); - let header = "{\"msg_id\":\"c0fd20872c1b4d1c87e7fc814b75c93e_0\",\"msg_type\":\"kernel_info_request\",\"username\":\"ampower\",\"session\":\"c0fd20872c1b4d1c87e7fc814b75c93e\",\"date\":\"2021-12-10T06:20:40.259695Z\",\"version\":\"5.3\"}".as_bytes().to_vec(); - let parent_header = "{}".as_bytes().to_vec(); - let metadata = "{}".as_bytes().to_vec(); - let content = "{}".as_bytes().to_vec(); - - let mut test_msg = ZmqMessage::from(delim); - test_msg.push_back(hash.into()); - test_msg.push_back(header.into()); - test_msg.push_back(parent_header.into()); - test_msg.push_back(metadata.into()); - test_msg.push_back(content.into()); - - dbg!(test_msg.clone()); - match hmac_verify( - &test_msg, - key, - String::from("43a5c45062e0b6bcc59c727f90165ad1d2eb02e1c5317aa25c2c2049d96d3b6a"), - ) { - Ok(_) => assert!(true), - Err(_) => assert!(false, "signature validation failed"), - } + let key_value = "1f5cec86-8eaa942eef7f5a35b51ddcf5"; + let key = hmac::Key::new(hmac::HMAC_SHA256, key_value.as_ref()); + + let delim = "".as_bytes().to_vec(); + let hash = "43a5c45062e0b6bcc59c727f90165ad1d2eb02e1c5317aa25c2c2049d96d3b6a" + .as_bytes() + .to_vec(); + let header = "{\"msg_id\":\"c0fd20872c1b4d1c87e7fc814b75c93e_0\",\"msg_type\":\"kernel_info_request\",\"username\":\"ampower\",\"session\":\"c0fd20872c1b4d1c87e7fc814b75c93e\",\"date\":\"2021-12-10T06:20:40.259695Z\",\"version\":\"5.3\"}".as_bytes().to_vec(); + let parent_header = "{}".as_bytes().to_vec(); + let metadata = "{}".as_bytes().to_vec(); + let content = "{}".as_bytes().to_vec(); + + let mut test_msg = ZmqMessage::from(delim); + test_msg.push_back(hash.into()); + test_msg.push_back(header.into()); + test_msg.push_back(parent_header.into()); + test_msg.push_back(metadata.into()); + test_msg.push_back(content.into()); + + dbg!(test_msg.clone()); + match hmac_verify( + &test_msg, + key, + String::from( + "43a5c45062e0b6bcc59c727f90165ad1d2eb02e1c5317aa25c2c2049d96d3b6a", + ), + ) { + Ok(_) => assert!(true), + Err(_) => assert!(false, "signature validation failed"), + } } #[test] fn hmac_sign_test() { - let key_value = "1f5cec86-8eaa942eef7f5a35b51ddcf5"; - let key = hmac::Key::new(hmac::HMAC_SHA256, key_value.as_ref()); - - let delim = ""; - let hash = "43a5c45062e0b6bcc59c727f90165ad1d2eb02e1c5317aa25c2c2049d96d3b6a" - .as_bytes() - .to_vec(); - let header = "{\"msg_id\":\"c0fd20872c1b4d1c87e7fc814b75c93e_0\",\"msg_type\":\"kernel_info_request\",\"username\":\"ampower\",\"session\":\"c0fd20872c1b4d1c87e7fc814b75c93e\",\"date\":\"2021-12-10T06:20:40.259695Z\",\"version\":\"5.3\"}".as_bytes().to_vec(); - let parent_header = "{}".as_bytes().to_vec(); - let metadata = "{}".as_bytes().to_vec(); - let content = "{}".as_bytes().to_vec(); - - let mut test_msg = ZmqMessage::from(delim); - test_msg.push_back(hash.into()); - test_msg.push_back(header.into()); - test_msg.push_back(parent_header.into()); - test_msg.push_back(metadata.into()); - test_msg.push_back(content.into()); - - dbg!(test_msg.clone()); - let sig = hmac_sign(&test_msg, key); - println!("Signature: {}", sig); - assert_eq!( - sig, - "43a5c45062e0b6bcc59c727f90165ad1d2eb02e1c5317aa25c2c2049d96d3b6a" - ); + let key_value = "1f5cec86-8eaa942eef7f5a35b51ddcf5"; + let key = hmac::Key::new(hmac::HMAC_SHA256, key_value.as_ref()); + + let delim = ""; + let hash = "43a5c45062e0b6bcc59c727f90165ad1d2eb02e1c5317aa25c2c2049d96d3b6a" + .as_bytes() + .to_vec(); + let header = "{\"msg_id\":\"c0fd20872c1b4d1c87e7fc814b75c93e_0\",\"msg_type\":\"kernel_info_request\",\"username\":\"ampower\",\"session\":\"c0fd20872c1b4d1c87e7fc814b75c93e\",\"date\":\"2021-12-10T06:20:40.259695Z\",\"version\":\"5.3\"}".as_bytes().to_vec(); + let parent_header = "{}".as_bytes().to_vec(); + let metadata = "{}".as_bytes().to_vec(); + let content = "{}".as_bytes().to_vec(); + + let mut test_msg = ZmqMessage::from(delim); + test_msg.push_back(hash.into()); + test_msg.push_back(header.into()); + test_msg.push_back(parent_header.into()); + test_msg.push_back(metadata.into()); + test_msg.push_back(content.into()); + + dbg!(test_msg.clone()); + let sig = hmac_sign(&test_msg, key); + println!("Signature: {}", sig); + assert_eq!( + sig, + "43a5c45062e0b6bcc59c727f90165ad1d2eb02e1c5317aa25c2c2049d96d3b6a" + ); } // /* ***************** // * SHELL MESSAGES // * *****************/ - // Shell Request Message Types // "execute_request" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#execute // "inspect_request" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#introspection @@ -570,89 +576,89 @@ fn hmac_sign_test() { // https://jupyter-client.readthedocs.io/en/latest/messaging.html#execute struct ExecuteRequestContent { - code: String, - silent: bool, - store_history: bool, - user_expressions: Value, - allow_stdin: bool, - stop_on_error: bool, + code: String, + silent: bool, + store_history: bool, + user_expressions: Value, + allow_stdin: bool, + stop_on_error: bool, } // https://jupyter-client.readthedocs.io/en/latest/messaging.html#execution-results struct ExecuteReplyContent { - status: String, - execution_count: u32, - payload: Option>, - user_expressions: Option, + status: String, + execution_count: u32, + payload: Option>, + user_expressions: Option, } // https://jupyter-client.readthedocs.io/en/latest/messaging.html#introspection struct InspectRequestContent { - code: String, - cursor_pos: u32, - detail_level: u8, // 0 = Low, 1 = High + code: String, + cursor_pos: u32, + detail_level: u8, // 0 = Low, 1 = High } // https://jupyter-client.readthedocs.io/en/latest/messaging.html#introspection struct InspectReplyContent { - status: String, - found: bool, - data: Option, - metadata: Option, + status: String, + found: bool, + data: Option, + metadata: Option, } // https://jupyter-client.readthedocs.io/en/latest/messaging.html#completion struct CompleteRequestContent { - code: String, - cursor_pos: u32, + code: String, + cursor_pos: u32, } // https://jupyter-client.readthedocs.io/en/latest/messaging.html#completion struct CompleteReplyContent { - status: String, - matches: Option, - cursor_start: u32, - cursor_end: u32, - metadata: Option + status: String, + matches: Option, + cursor_start: u32, + cursor_end: u32, + metadata: Option, } // https://jupyter-client.readthedocs.io/en/latest/messaging.html#history struct HistoryRequestContent { - output: bool, - raw: bool, - hist_access_type: String, // "range" | "tail" | "search" - session: u32, - start: u32, - stop: u32, - n: u32, + output: bool, + raw: bool, + hist_access_type: String, // "range" | "tail" | "search" + session: u32, + start: u32, + stop: u32, + n: u32, } // https://jupyter-client.readthedocs.io/en/latest/messaging.html#history struct HistoryReplyContent { - status: String, - history: Option + status: String, + history: Option, } // https://jupyter-client.readthedocs.io/en/latest/messaging.html#code-completeness struct CodeCompleteRequestContent { - code: String + code: String, } // https://jupyter-client.readthedocs.io/en/latest/messaging.html#code-completeness struct CodeCompleteReplyContent { - status: String, // "complete" | "incomplete" | "invalid" | "unknown" - indent: String, + status: String, // "complete" | "incomplete" | "invalid" | "unknown" + indent: String, } // https://jupyter-client.readthedocs.io/en/latest/messaging.html#comm-info struct CommInfoRequestContent { - target_name: String + target_name: String, } // https://jupyter-client.readthedocs.io/en/latest/messaging.html#comm-info struct CommInfoReplyContent { - status: String, - comms: Option, + status: String, + comms: Option, } // https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-info @@ -660,31 +666,31 @@ struct CommInfoReplyContent { // https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-info struct KernelInfoReply { - status: String, - protocol_version: String, - implementation: String, - implementation_version: String, - language_info: KernelLanguageInfo, - banner: String, - debugger: bool, - help_links: Vec + status: String, + protocol_version: String, + implementation: String, + implementation_version: String, + language_info: KernelLanguageInfo, + banner: String, + debugger: bool, + help_links: Vec, } // https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-info struct KernelLanguageInfo { - name: String, - version: String, - mimetype: String, - file_extension: String, - pygments_lexer: String, - codemirror_mode: Option, - nbconvert_exporter: String + name: String, + version: String, + mimetype: String, + file_extension: String, + pygments_lexer: String, + codemirror_mode: Option, + nbconvert_exporter: String, } // https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-info struct KernelHelpLink { - text: String, - url: String, + text: String, + url: String, } /* ***************** @@ -701,16 +707,15 @@ struct KernelHelpLink { // "interrupt_reply" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-interrupt // "debug_reply" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#debug-request - // https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-shutdown struct ShutdownRequestContent { - restart: bool + restart: bool, } // https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-shutdown struct ShutdownReplyContent { - status: String, - restart: bool + status: String, + restart: bool, } // https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-interrupt @@ -718,7 +723,7 @@ struct ShutdownReplyContent { // https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-interrupt struct InterruptReplyContent { - status: String + status: String, } // https://jupyter-client.readthedocs.io/en/latest/messaging.html#debug-request @@ -727,7 +732,6 @@ struct InterruptReplyContent { // https://jupyter-client.readthedocs.io/en/latest/messaging.html#debug-request // struct DebugReplyContent {} // See Debug Adapter Protocol (DAP) 1.39 or later - /* ***************** * IOPUB MESSAGES * *****************/ @@ -748,29 +752,29 @@ struct InterruptReplyContent { // https://jupyter-client.readthedocs.io/en/latest/messaging.html#request-reply struct ErrorStatusContent { - status: String, // "error" - ename: String, - evalue: String, - traceback: Vec, - execution_count: Option + status: String, // "error" + ename: String, + evalue: String, + traceback: Vec, + execution_count: Option, } // https://jupyter-client.readthedocs.io/en/latest/messaging.html#request-reply struct StatusContent { - status: String, // "ok" | "abort" + status: String, // "ok" | "abort" } // https://jupyter-client.readthedocs.io/en/latest/messaging.html#streams-stdout-stderr-etc struct StreamContent { - name: String, // "stdout" | "stderr" - text: String + name: String, // "stdout" | "stderr" + text: String, } // https://jupyter-client.readthedocs.io/en/latest/messaging.html#display-data struct DisplayDataContent { - data: Value, - metadata: Option, - transient: Option + data: Value, + metadata: Option, + transient: Option, } // https://jupyter-client.readthedocs.io/en/latest/messaging.html#update-display-data @@ -778,31 +782,31 @@ struct DisplayDataContent { // https://jupyter-client.readthedocs.io/en/latest/messaging.html#code-inputs struct ExecuteInputContent { - code: String, - execution_count: u32 + code: String, + execution_count: u32, } // https://jupyter-client.readthedocs.io/en/latest/messaging.html#id6 struct ExecuteResultContent { - execution_count: u32, - data: Option, - metadata: Option + execution_count: u32, + data: Option, + metadata: Option, } // https://jupyter-client.readthedocs.io/en/latest/messaging.html#execution-errors struct ErrorContent { - payload: Option>, - user_expressions: Option, + payload: Option>, + user_expressions: Option, } // https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-status struct KernelStatusContent { - execution_state: String, // "busy" | "idle" | "starting" + execution_state: String, // "busy" | "idle" | "starting" } // https://jupyter-client.readthedocs.io/en/latest/messaging.html#clear-output struct ClearOutputContent { - wait: bool + wait: bool, } // https://jupyter-client.readthedocs.io/en/latest/messaging.html#debug-event @@ -810,21 +814,21 @@ struct ClearOutputContent { // https://jupyter-client.readthedocs.io/en/latest/messaging.html#opening-a-comm struct CommOpenMessage { - comm_id: uuid::Uuid, - target_name: String, - data: Option, + comm_id: uuid::Uuid, + target_name: String, + data: Option, } // https://jupyter-client.readthedocs.io/en/latest/messaging.html#comm-messages struct CommMsgMessage { - comm_id: uuid::Uuid, - data: Option, + comm_id: uuid::Uuid, + data: Option, } // https://jupyter-client.readthedocs.io/en/latest/messaging.html#comm-messages struct CommCloseMessage { - comm_id: uuid::Uuid, - data: Option, + comm_id: uuid::Uuid, + data: Option, } /* ***************** @@ -838,11 +842,11 @@ struct CommCloseMessage { // https://jupyter-client.readthedocs.io/en/latest/messaging.html#messages-on-the-stdin-router-dealer-channel struct InputRequestContent { - prompt: String, - password: bool + prompt: String, + password: bool, } // https://jupyter-client.readthedocs.io/en/latest/messaging.html#messages-on-the-stdin-router-dealer-channel struct InputReplyContent { - value: String -} \ No newline at end of file + value: String, +} From f32d9384ebae025fbbdc7448a796d28d28d28daf Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Fri, 17 Dec 2021 19:16:19 +0100 Subject: [PATCH 012/115] disable linting for now --- cli/tools/jupyter.rs | 20 +++++++++++--------- 1 file changed, 11 insertions(+), 9 deletions(-) diff --git a/cli/tools/jupyter.rs b/cli/tools/jupyter.rs index 04172a8d93b5e6..6c2aa1769fc636 100644 --- a/cli/tools/jupyter.rs +++ b/cli/tools/jupyter.rs @@ -1,11 +1,14 @@ // Copyright 2018-2021 the Deno authors. All rights reserved. MIT license. +// TODO(bartlomieju): remove me +#![allow(unused)] + use crate::flags::Flags; use crate::flags::JupyterFlags; use data_encoding::HEXLOWER; use deno_core::anyhow::Context; -use deno_core::error::AnyError; use deno_core::error::generic_error; +use deno_core::error::AnyError; use deno_core::serde::Deserialize; use deno_core::serde_json; use deno_core::serde_json::json; @@ -448,7 +451,7 @@ fn parse_zmq_packet(data: &ZmqMessage) -> Result<(), AnyError> { println!("header:"); dbg!(header); - let header_str = std::str::from_utf8(&header).unwrap(); + let header_str = std::str::from_utf8(header).unwrap(); let header_value: MessageHeader = serde_json::from_str(header_str).unwrap(); println!("header_value"); dbg!(&header_value); @@ -468,7 +471,7 @@ fn hmac_sign(zmq: &ZmqMessage, key: hmac::Key) -> String { dbg!(tag); let sig = HEXLOWER.encode(tag.as_ref()); - return sig; + sig } #[allow(dead_code)] @@ -484,7 +487,7 @@ fn hmac_verify( msg.extend(zmq.get(4).unwrap()); // metadata msg.extend(zmq.get(5).unwrap()); // content let sig = HEXLOWER.decode(sig_str.as_bytes()).unwrap(); - hmac::verify(&key, &msg.as_ref(), &sig.as_ref())?; + hmac::verify(&key, msg.as_ref(), sig.as_ref())?; Ok(()) } @@ -511,16 +514,15 @@ fn hmac_verify_test() { test_msg.push_back(content.into()); dbg!(test_msg.clone()); - match hmac_verify( + let result = hmac_verify( &test_msg, key, String::from( "43a5c45062e0b6bcc59c727f90165ad1d2eb02e1c5317aa25c2c2049d96d3b6a", ), - ) { - Ok(_) => assert!(true), - Err(_) => assert!(false, "signature validation failed"), - } + ); + + assert!(result.is_ok(), "signature validation failed"); } #[test] From 22e52eea6ea20bb8feae6b8bc5bbccd116da49aa Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Sat, 18 Dec 2021 02:42:17 +0100 Subject: [PATCH 013/115] Message::serialize --- cli/tools/jupyter.rs | 111 ++++++++++++++++++++++++------------------- 1 file changed, 61 insertions(+), 50 deletions(-) diff --git a/cli/tools/jupyter.rs b/cli/tools/jupyter.rs index 6c2aa1769fc636..2b33d9a17296d6 100644 --- a/cli/tools/jupyter.rs +++ b/cli/tools/jupyter.rs @@ -10,6 +10,7 @@ use deno_core::anyhow::Context; use deno_core::error::generic_error; use deno_core::error::AnyError; use deno_core::serde::Deserialize; +use deno_core::serde::Serialize; use deno_core::serde_json; use deno_core::serde_json::json; use deno_core::serde_json::Value; @@ -20,6 +21,8 @@ use tokio::join; use zeromq::prelude::*; use zeromq::ZmqMessage; +const DELIMETER: &str = ""; + pub fn install() -> Result<(), AnyError> { let temp_dir = TempDir::new().unwrap(); let kernel_json_path = temp_dir.path().join("kernel.json"); @@ -83,17 +86,18 @@ pub async fn kernel( .context("Failed to parse connection file")?; eprintln!("[DENO] parsed conn file: {:#?}", conn_spec); + let hmac_key = hmac::Key::new(hmac::HMAC_SHA256, conn_spec.key.as_ref()); let metadata = KernelMetadata::default(); let iopub_comm = PubComm::new( create_conn_str(&conn_spec.transport, &conn_spec.ip, conn_spec.iopub_port), metadata.session_id.clone(), - conn_spec.key.clone(), + hmac_key.clone(), ); let shell_comm = DealerComm::new( "shell", create_conn_str(&conn_spec.transport, &conn_spec.ip, conn_spec.shell_port), metadata.session_id.clone(), - conn_spec.key.clone(), + hmac_key.clone(), ); let control_comm = DealerComm::new( "control", @@ -103,13 +107,13 @@ pub async fn kernel( conn_spec.control_port, ), metadata.session_id.clone(), - conn_spec.key.clone(), + hmac_key.clone(), ); let stdin_comm = DealerComm::new( "stdin", create_conn_str(&conn_spec.transport, &conn_spec.ip, conn_spec.stdin_port), metadata.session_id.clone(), - conn_spec.key.clone(), + hmac_key.clone(), ); let hb_conn_str = @@ -214,6 +218,7 @@ impl Kernel { }, parent_header: Some(ctx.message.header), session_id: ctx.session_id, + metadata: json!({}), content: json!({ "execution_state": state.to_string(), }), @@ -308,7 +313,7 @@ struct CommContext { session_id: String, } -#[derive(Debug, Deserialize)] +#[derive(Debug, Deserialize, Serialize)] struct MessageHeader { msg_id: String, session: String, @@ -323,6 +328,7 @@ struct Message { r#type: String, header: MessageHeader, parent_header: Option, + metadata: Value, content: Value, session_id: String, } @@ -332,19 +338,33 @@ impl Message { todo!() } - fn calc_hmac(&self, hmac: String) -> String { - todo!() - } - - fn serialize(&self, hmac: String) -> Vec { - todo!() + fn serialize(&self, hmac_key: &hmac::Key) -> ZmqMessage { + let header = serde_json::to_string(&self.header).unwrap(); + let parent_header = if let Some(p_header) = self.parent_header.as_ref() { + serde_json::to_string(p_header).unwrap() + } else { + serde_json::to_string(&json!({})).unwrap() + }; + let metadata = serde_json::to_string(&self.metadata).unwrap(); + let content = serde_json::to_string(&self.content).unwrap(); + + let hmac = + hmac_sign(hmac_key, &header, &parent_header, &metadata, &content); + + let mut zmq_msg = ZmqMessage::from(DELIMETER); + zmq_msg.push_back(hmac.into()); + zmq_msg.push_back(header.into()); + zmq_msg.push_back(parent_header.into()); + zmq_msg.push_back(metadata.into()); + zmq_msg.push_back(content.into()); + zmq_msg } fn hmac_verify(&self, expected_signature: Vec, hmac: String) { todo!() } - fn from_data(data: Vec, hmac: String) -> Result { + fn from_zmq_message(msg: ZmqMessage, hmac_key: &hmac::Key) -> Result { todo!() } } @@ -352,12 +372,16 @@ impl Message { struct PubComm { conn_str: String, session_id: String, - hmac_key: String, + hmac_key: hmac::Key, socket: zeromq::PubSocket, } impl PubComm { - pub fn new(conn_str: String, session_id: String, hmac_key: String) -> Self { + pub fn new( + conn_str: String, + session_id: String, + hmac_key: hmac::Key, + ) -> Self { println!("iopub connection: {}", conn_str); Self { conn_str, @@ -374,8 +398,8 @@ impl PubComm { } pub async fn send(&mut self, msg: Message) -> Result<(), AnyError> { - let msg_str = msg.serialize(self.hmac_key.clone()); - self.socket.send(msg_str.into()).await?; + let zmq_msg = msg.serialize(&self.hmac_key); + self.socket.send(zmq_msg).await?; Ok(()) } } @@ -384,7 +408,7 @@ struct DealerComm { name: String, conn_str: String, session_id: String, - hmac_key: String, + hmac_key: hmac::Key, socket: zeromq::DealerSocket, } @@ -393,7 +417,7 @@ impl DealerComm { name: &str, conn_str: String, session_id: String, - hmac_key: String, + hmac_key: hmac::Key, ) -> Self { println!("dealer '{}' connection: {}", name, conn_str); Self { @@ -417,8 +441,8 @@ impl DealerComm { } pub async fn send(&mut self, msg: Message) -> Result<(), AnyError> { - let msg_str = msg.serialize(self.hmac_key.clone()); - self.socket.send(msg_str.into()).await?; + let zmq_msg = msg.serialize(&self.hmac_key); + self.socket.send(zmq_msg).await?; Ok(()) } } @@ -460,21 +484,23 @@ fn parse_zmq_packet(data: &ZmqMessage) -> Result<(), AnyError> { Ok(()) } -#[allow(dead_code)] -fn hmac_sign(zmq: &ZmqMessage, key: hmac::Key) -> String { - let mut hmac_ctx = hmac::Context::with_key(&key); - hmac_ctx.update(zmq.get(2).unwrap()); // header - hmac_ctx.update(zmq.get(3).unwrap()); // parent header - hmac_ctx.update(zmq.get(4).unwrap()); // metadata - hmac_ctx.update(zmq.get(5).unwrap()); // content +fn hmac_sign( + key: &hmac::Key, + header: &str, + parent_header: &str, + metadata: &str, + content: &str, +) -> String { + let mut hmac_ctx = hmac::Context::with_key(key); + hmac_ctx.update(header.as_bytes()); + hmac_ctx.update(parent_header.as_bytes()); + hmac_ctx.update(metadata.as_bytes()); + hmac_ctx.update(content.as_bytes()); let tag = hmac_ctx.sign(); - dbg!(tag); let sig = HEXLOWER.encode(tag.as_ref()); - sig } -#[allow(dead_code)] fn hmac_verify( zmq: &ZmqMessage, key: hmac::Key, @@ -529,26 +555,11 @@ fn hmac_verify_test() { fn hmac_sign_test() { let key_value = "1f5cec86-8eaa942eef7f5a35b51ddcf5"; let key = hmac::Key::new(hmac::HMAC_SHA256, key_value.as_ref()); - - let delim = ""; - let hash = "43a5c45062e0b6bcc59c727f90165ad1d2eb02e1c5317aa25c2c2049d96d3b6a" - .as_bytes() - .to_vec(); - let header = "{\"msg_id\":\"c0fd20872c1b4d1c87e7fc814b75c93e_0\",\"msg_type\":\"kernel_info_request\",\"username\":\"ampower\",\"session\":\"c0fd20872c1b4d1c87e7fc814b75c93e\",\"date\":\"2021-12-10T06:20:40.259695Z\",\"version\":\"5.3\"}".as_bytes().to_vec(); - let parent_header = "{}".as_bytes().to_vec(); - let metadata = "{}".as_bytes().to_vec(); - let content = "{}".as_bytes().to_vec(); - - let mut test_msg = ZmqMessage::from(delim); - test_msg.push_back(hash.into()); - test_msg.push_back(header.into()); - test_msg.push_back(parent_header.into()); - test_msg.push_back(metadata.into()); - test_msg.push_back(content.into()); - - dbg!(test_msg.clone()); - let sig = hmac_sign(&test_msg, key); - println!("Signature: {}", sig); + let header = "{\"msg_id\":\"c0fd20872c1b4d1c87e7fc814b75c93e_0\",\"msg_type\":\"kernel_info_request\",\"username\":\"ampower\",\"session\":\"c0fd20872c1b4d1c87e7fc814b75c93e\",\"date\":\"2021-12-10T06:20:40.259695Z\",\"version\":\"5.3\"}"; + let parent_header = "{}"; + let metadata = "{}"; + let content = "{}"; + let sig = hmac_sign(&key, header, parent_header, metadata, content); assert_eq!( sig, "43a5c45062e0b6bcc59c727f90165ad1d2eb02e1c5317aa25c2c2049d96d3b6a" From 370991ae6096dec88a6225b1afaccc7cf46adc34 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Sat, 18 Dec 2021 02:57:10 +0100 Subject: [PATCH 014/115] Message::from_zmq_message --- cli/tools/jupyter.rs | 92 +++++++++++++++++++++++++++++--------------- 1 file changed, 60 insertions(+), 32 deletions(-) diff --git a/cli/tools/jupyter.rs b/cli/tools/jupyter.rs index 2b33d9a17296d6..9c5338a054a5e0 100644 --- a/cli/tools/jupyter.rs +++ b/cli/tools/jupyter.rs @@ -360,12 +360,45 @@ impl Message { zmq_msg } - fn hmac_verify(&self, expected_signature: Vec, hmac: String) { - todo!() - } + fn from_zmq_message( + zmq_msg: ZmqMessage, + hmac_key: &hmac::Key, + ) -> Result { + // TODO(bartomieju): can these unwraps be better handled? + let expected_signature_bytes = zmq_msg.get(0).unwrap(); + let header_bytes = zmq_msg.get(1).unwrap(); + let parent_header_bytes = zmq_msg.get(2).unwrap(); + let metadata_bytes = zmq_msg.get(3).unwrap(); + let content_bytes = zmq_msg.get(4).unwrap(); + + hmac_verify( + hmac_key, + expected_signature_bytes, + header_bytes, + parent_header_bytes, + metadata_bytes, + content_bytes, + )?; + + // TODO(bartomieju): can these unwraps be better handled? + let header: MessageHeader = serde_json::from_slice(header_bytes).unwrap(); + let parent_header: MessageHeader = + serde_json::from_slice(parent_header_bytes).unwrap(); + let metadata: Value = serde_json::from_slice(metadata_bytes).unwrap(); + let content: Value = serde_json::from_slice(content_bytes).unwrap(); - fn from_zmq_message(msg: ZmqMessage, hmac_key: &hmac::Key) -> Result { - todo!() + let msg = Message { + is_reply: false, + r#type: header.msg_type.clone(), + header, + parent_header: Some(parent_header), + metadata, + content, + // FIXME: + session_id: "".to_string(), + }; + + Ok(msg) } } @@ -502,18 +535,20 @@ fn hmac_sign( } fn hmac_verify( - zmq: &ZmqMessage, - key: hmac::Key, - sig_str: String, + key: &hmac::Key, + expected_signature: &[u8], + header: &[u8], + parent_header: &[u8], + metadata: &[u8], + content: &[u8], ) -> Result<(), ring::error::Unspecified> { - dbg!(&zmq); let mut msg = Vec::::new(); - msg.extend(zmq.get(2).unwrap()); // header - msg.extend(zmq.get(3).unwrap()); // parent header - msg.extend(zmq.get(4).unwrap()); // metadata - msg.extend(zmq.get(5).unwrap()); // content - let sig = HEXLOWER.decode(sig_str.as_bytes()).unwrap(); - hmac::verify(&key, msg.as_ref(), sig.as_ref())?; + msg.extend(header); + msg.extend(parent_header); + msg.extend(metadata); + msg.extend(content); + let sig = HEXLOWER.decode(expected_signature).unwrap(); + hmac::verify(key, msg.as_ref(), sig.as_ref())?; Ok(()) } @@ -523,29 +558,22 @@ fn hmac_verify_test() { let key_value = "1f5cec86-8eaa942eef7f5a35b51ddcf5"; let key = hmac::Key::new(hmac::HMAC_SHA256, key_value.as_ref()); - let delim = "".as_bytes().to_vec(); - let hash = "43a5c45062e0b6bcc59c727f90165ad1d2eb02e1c5317aa25c2c2049d96d3b6a" - .as_bytes() - .to_vec(); + let expected_signature = + "43a5c45062e0b6bcc59c727f90165ad1d2eb02e1c5317aa25c2c2049d96d3b6a" + .as_bytes() + .to_vec(); let header = "{\"msg_id\":\"c0fd20872c1b4d1c87e7fc814b75c93e_0\",\"msg_type\":\"kernel_info_request\",\"username\":\"ampower\",\"session\":\"c0fd20872c1b4d1c87e7fc814b75c93e\",\"date\":\"2021-12-10T06:20:40.259695Z\",\"version\":\"5.3\"}".as_bytes().to_vec(); let parent_header = "{}".as_bytes().to_vec(); let metadata = "{}".as_bytes().to_vec(); let content = "{}".as_bytes().to_vec(); - let mut test_msg = ZmqMessage::from(delim); - test_msg.push_back(hash.into()); - test_msg.push_back(header.into()); - test_msg.push_back(parent_header.into()); - test_msg.push_back(metadata.into()); - test_msg.push_back(content.into()); - - dbg!(test_msg.clone()); let result = hmac_verify( - &test_msg, - key, - String::from( - "43a5c45062e0b6bcc59c727f90165ad1d2eb02e1c5317aa25c2c2049d96d3b6a", - ), + &key, + &expected_signature, + &header, + &parent_header, + &metadata, + &content, ); assert!(result.is_ok(), "signature validation failed"); From 299e1af96ec644c42f7a83bab36f249d0b491d0c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Sat, 18 Dec 2021 04:04:22 +0100 Subject: [PATCH 015/115] fix deserialization --- cli/tools/jupyter.rs | 26 ++++++++++++++------------ 1 file changed, 14 insertions(+), 12 deletions(-) diff --git a/cli/tools/jupyter.rs b/cli/tools/jupyter.rs index 9c5338a054a5e0..7fe9dd164fb236 100644 --- a/cli/tools/jupyter.rs +++ b/cli/tools/jupyter.rs @@ -180,13 +180,13 @@ impl Kernel { loop { tokio::select! { shell_msg = self.shell_comm.recv() => { - eprintln!("shell got packet: {:#?}", shell_msg); + eprintln!("shell got packet: {:#?}", Message::from_zmq_message(shell_msg?, &self.shell_comm.hmac_key)?); }, control_msg = self.control_comm.recv() => { - eprintln!("control got packet: {:#?}", control_msg); + eprintln!("control got packet: {:#?}", Message::from_zmq_message(control_msg?, &self.control_comm.hmac_key)?); }, stdin_msg = self.stdin_comm.recv() => { - eprintln!("stdin got packet: {:#?}", stdin_msg); + eprintln!("stdin got packet: {:#?}", Message::from_zmq_message(stdin_msg?, &self.stdin_comm.hmac_key)?); }, } } @@ -313,7 +313,7 @@ struct CommContext { session_id: String, } -#[derive(Debug, Deserialize, Serialize)] +#[derive(Debug, Default, Deserialize, Serialize)] struct MessageHeader { msg_id: String, session: String, @@ -323,6 +323,7 @@ struct MessageHeader { version: String, } +#[derive(Debug)] struct Message { is_reply: bool, r#type: String, @@ -365,11 +366,11 @@ impl Message { hmac_key: &hmac::Key, ) -> Result { // TODO(bartomieju): can these unwraps be better handled? - let expected_signature_bytes = zmq_msg.get(0).unwrap(); - let header_bytes = zmq_msg.get(1).unwrap(); - let parent_header_bytes = zmq_msg.get(2).unwrap(); - let metadata_bytes = zmq_msg.get(3).unwrap(); - let content_bytes = zmq_msg.get(4).unwrap(); + let expected_signature_bytes = zmq_msg.get(1).unwrap(); + let header_bytes = zmq_msg.get(2).unwrap(); + let parent_header_bytes = zmq_msg.get(3).unwrap(); + let metadata_bytes = zmq_msg.get(4).unwrap(); + let content_bytes = zmq_msg.get(5).unwrap(); hmac_verify( hmac_key, @@ -380,10 +381,11 @@ impl Message { content_bytes, )?; + // eprintln!("parent_Header {:?}", String::from_utf8(parent_header_bytes.to_vec()).unwrap()); // TODO(bartomieju): can these unwraps be better handled? let header: MessageHeader = serde_json::from_slice(header_bytes).unwrap(); - let parent_header: MessageHeader = - serde_json::from_slice(parent_header_bytes).unwrap(); + // let parent_header: MessageHeader = + // serde_json::from_slice(parent_header_bytes).unwrap(); let metadata: Value = serde_json::from_slice(metadata_bytes).unwrap(); let content: Value = serde_json::from_slice(content_bytes).unwrap(); @@ -391,7 +393,7 @@ impl Message { is_reply: false, r#type: header.msg_type.clone(), header, - parent_header: Some(parent_header), + parent_header: None, metadata, content, // FIXME: From b9a2141fd3cfb0f52e523286648ae9bce1b19200 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Sat, 18 Dec 2021 17:54:39 +0100 Subject: [PATCH 016/115] Ben's review --- cli/tools/jupyter.rs | 28 ++++------------------------ 1 file changed, 4 insertions(+), 24 deletions(-) diff --git a/cli/tools/jupyter.rs b/cli/tools/jupyter.rs index 7fe9dd164fb236..5cc9f7260df599 100644 --- a/cli/tools/jupyter.rs +++ b/cli/tools/jupyter.rs @@ -21,7 +21,7 @@ use tokio::join; use zeromq::prelude::*; use zeromq::ZmqMessage; -const DELIMETER: &str = ""; +const DELIMITER: &str = ""; pub fn install() -> Result<(), AnyError> { let temp_dir = TempDir::new().unwrap(); @@ -352,7 +352,7 @@ impl Message { let hmac = hmac_sign(hmac_key, &header, &parent_header, &metadata, &content); - let mut zmq_msg = ZmqMessage::from(DELIMETER); + let mut zmq_msg = ZmqMessage::from(DELIMITER); zmq_msg.push_back(hmac.into()); zmq_msg.push_back(header.into()); zmq_msg.push_back(parent_header.into()); @@ -500,25 +500,6 @@ fn create_conn_str(transport: &str, ip: &str, port: u32) -> String { format!("{}://{}:{}", transport, ip, port) } -fn parse_zmq_packet(data: &ZmqMessage) -> Result<(), AnyError> { - let _delim = data.get(0); - let _hmac = data.get(1); - let header = data.get(2).unwrap(); - let _parent_header = data.get(3); - let _metadata = data.get(4); - let _content = data.get(5); - - println!("header:"); - dbg!(header); - let header_str = std::str::from_utf8(header).unwrap(); - let header_value: MessageHeader = serde_json::from_str(header_str).unwrap(); - println!("header_value"); - dbg!(&header_value); - // validate_header(&header_value)?; - - Ok(()) -} - fn hmac_sign( key: &hmac::Key, header: &str, @@ -543,15 +524,14 @@ fn hmac_verify( parent_header: &[u8], metadata: &[u8], content: &[u8], -) -> Result<(), ring::error::Unspecified> { +) -> Result<(), AnyError> { let mut msg = Vec::::new(); msg.extend(header); msg.extend(parent_header); msg.extend(metadata); msg.extend(content); - let sig = HEXLOWER.decode(expected_signature).unwrap(); + let sig = HEXLOWER.decode(expected_signature)?; hmac::verify(key, msg.as_ref(), sig.as_ref())?; - Ok(()) } From 884ff4be5dd4f9eb4ca0a3f132c1c86b2492833f Mon Sep 17 00:00:00 2001 From: Adam Powers Date: Tue, 21 Dec 2021 08:27:50 -0800 Subject: [PATCH 017/115] implement handlers --- cli/tools/jupyter.rs | 279 ++++++++++++++++++++++++++++++++++--------- 1 file changed, 221 insertions(+), 58 deletions(-) diff --git a/cli/tools/jupyter.rs b/cli/tools/jupyter.rs index 9c5338a054a5e0..18f7417c74e325 100644 --- a/cli/tools/jupyter.rs +++ b/cli/tools/jupyter.rs @@ -15,6 +15,7 @@ use deno_core::serde_json; use deno_core::serde_json::json; use deno_core::serde_json::Value; use ring::hmac; +use std::collections::HashMap; use std::env::current_exe; use tempfile::TempDir; use tokio::join; @@ -23,6 +24,12 @@ use zeromq::ZmqMessage; const DELIMETER: &str = ""; +macro_rules! handle { + ($kernel:ident, $method:ident) => { + Box::new(|x| $kernel.$method(x)) + }; +} + pub fn install() -> Result<(), AnyError> { let temp_dir = TempDir::new().unwrap(); let kernel_json_path = temp_dir.path().join("kernel.json"); @@ -80,59 +87,12 @@ pub async fn kernel( let conn_file_path = jupyter_flags.conn_file.unwrap(); - let conn_file = std::fs::read_to_string(conn_file_path) - .context("Failed to read connection file")?; - let conn_spec: ConnectionSpec = serde_json::from_str(&conn_file) - .context("Failed to parse connection file")?; - eprintln!("[DENO] parsed conn file: {:#?}", conn_spec); - - let hmac_key = hmac::Key::new(hmac::HMAC_SHA256, conn_spec.key.as_ref()); - let metadata = KernelMetadata::default(); - let iopub_comm = PubComm::new( - create_conn_str(&conn_spec.transport, &conn_spec.ip, conn_spec.iopub_port), - metadata.session_id.clone(), - hmac_key.clone(), - ); - let shell_comm = DealerComm::new( - "shell", - create_conn_str(&conn_spec.transport, &conn_spec.ip, conn_spec.shell_port), - metadata.session_id.clone(), - hmac_key.clone(), - ); - let control_comm = DealerComm::new( - "control", - create_conn_str( - &conn_spec.transport, - &conn_spec.ip, - conn_spec.control_port, - ), - metadata.session_id.clone(), - hmac_key.clone(), - ); - let stdin_comm = DealerComm::new( - "stdin", - create_conn_str(&conn_spec.transport, &conn_spec.ip, conn_spec.stdin_port), - metadata.session_id.clone(), - hmac_key.clone(), - ); - - let hb_conn_str = - create_conn_str(&conn_spec.transport, &conn_spec.ip, conn_spec.hb_port); - - let mut kernel = Kernel { - metadata, - conn_spec, - state: KernelState::Idle, - iopub_comm, - shell_comm, - control_comm, - stdin_comm, - }; - + let mut kernel = Kernel::new(conn_file_path.to_str().unwrap()); eprintln!("[DENO] kernel created: {:#?}", kernel.metadata.session_id); - let (_first, _second) = - join!(kernel.run(), create_zmq_reply("hb", &hb_conn_str),); + println!("running kernel..."); + kernel.run().await; + println!("done running kernel."); Ok(()) } @@ -153,18 +113,108 @@ impl std::fmt::Display for KernelState { } } } - -struct Kernel { +struct Kernel<'env> { metadata: KernelMetadata, conn_spec: ConnectionSpec, state: KernelState, iopub_comm: PubComm, shell_comm: DealerComm, + shell_handlers: CommHandler<'env>, control_comm: DealerComm, stdin_comm: DealerComm, } -impl Kernel { +impl Kernel<'_> { + fn new(conn_file_path: &str) -> Self { + let conn_file = match std::fs::read_to_string(conn_file_path) + .context("Failed to read connection file") + { + Ok(cf) => cf, + Err(_) => { + println!("Couldn't read connection file: {}", conn_file_path); + std::process::exit(1); + } + }; + let conn_spec: ConnectionSpec = match serde_json::from_str(&conn_file) + .context("Failed to parse connection file") + { + Ok(cs) => cs, + Err(_) => { + println!("Connection file isn't proper JSON: {}", conn_file_path); + std::process::exit(1); + } + }; + eprintln!("[DENO] parsed conn file: {:#?}", conn_spec); + + let hmac_key = hmac::Key::new(hmac::HMAC_SHA256, conn_spec.key.as_ref()); + let metadata = KernelMetadata::default(); + let iopub_comm = PubComm::new( + create_conn_str( + &conn_spec.transport, + &conn_spec.ip, + conn_spec.iopub_port, + ), + metadata.session_id.clone(), + hmac_key.clone(), + ); + let shell_comm = DealerComm::new( + "shell", + create_conn_str( + &conn_spec.transport, + &conn_spec.ip, + conn_spec.shell_port, + ), + metadata.session_id.clone(), + hmac_key.clone(), + ); + let control_comm = DealerComm::new( + "control", + create_conn_str( + &conn_spec.transport, + &conn_spec.ip, + conn_spec.control_port, + ), + metadata.session_id.clone(), + hmac_key.clone(), + ); + let stdin_comm = DealerComm::new( + "stdin", + create_conn_str( + &conn_spec.transport, + &conn_spec.ip, + conn_spec.stdin_port, + ), + metadata.session_id.clone(), + hmac_key.clone(), + ); + + // let shell_handlers = CommHandler::new(&[ + // ("kernel_info_request".to_owned(), Kernel::kernel_info_reply) + // ]); + let shell_handlers = CommHandler::new(&[]); + + let hb_conn_str = + create_conn_str(&conn_spec.transport, &conn_spec.ip, conn_spec.hb_port); + + let s: Kernel = Self { + metadata, + conn_spec, + state: KernelState::Idle, + iopub_comm, + shell_comm, + shell_handlers, + control_comm, + stdin_comm, + }; + + shell_handlers.add_handler( + &"kernel_info_request".to_owned(), + handle!(s, kernel_info_reply), + ); + + s + } + async fn run(&mut self) -> Result<(), AnyError> { let (iopub_res, shell_res, control_res, stdin_res) = join!( self.iopub_comm.connect(), @@ -177,10 +227,14 @@ impl Kernel { control_res?; stdin_res?; + // TODO(apowers313): run heartbeat + // create_zmq_reply("hb", &hb_conn_str) + loop { tokio::select! { shell_msg = self.shell_comm.recv() => { eprintln!("shell got packet: {:#?}", shell_msg); + self.shell_handlers.call(shell_msg); }, control_msg = self.control_comm.recv() => { eprintln!("control got packet: {:#?}", control_msg); @@ -227,6 +281,15 @@ impl Kernel { let _ = self.iopub_comm.send(msg).await; } + pub fn kernel_info_reply( + &self, + req_msg: RequestMessage, + ) -> Result<(), AnyError> { + dbg!(req_msg); + + Ok(()) + } + // TODO(bartlomieju): feels like this info should be a separate struct // instead of KernelMetadata fn get_kernel_info(&self) -> Value { @@ -323,6 +386,92 @@ struct MessageHeader { version: String, } +type CommHandlerFn<'env> = + Box Result<(), AnyError>>; + +struct CommHandler<'env> { + collection: HashMap>, +} + +impl CommHandler<'_> { + fn new(handlers: &[(String, CommHandlerFn)]) -> Self { + let mut s = Self { + collection: HashMap::new(), + }; + + for handler in handlers.iter() { + s.add_handler(&handler.0, handler.1); + } + + s + } + + fn add_handler(&mut self, name: &String, handler: CommHandlerFn) { + self.collection.insert(name.to_owned(), handler); + } + + fn call(&self, msg_res: Result) { + let msg = match msg_res { + Ok(m) => m, + Err(e) => { + eprintln!("error while receiving message: {}", e); + return; + } + }; + let msg_type = msg.header.msg_id; + let handler = match self.collection.get(&msg_type) { + Some(x) => x, + None => { + println!("no message handler found for message type: '{}'", msg_type); + return; + } + }; + + match handler(msg) { + Ok(()) => return, + Err(e) => println!("error while handling {}: {}", msg_type, e), + }; + } +} + +#[derive(Debug)] +struct RequestMessage { + header: MessageHeader, + parent_header: Option<()>, + metadata: String, + content: String, +} + +impl RequestMessage { + fn new(header: MessageHeader, metadata: String, content: String) -> Self { + Self { + header, + parent_header: None, + metadata, + content, + } + } +} + +impl TryFrom for RequestMessage { + type Error = AnyError; + + fn try_from(zmq_msg: ZmqMessage) -> Result { + let header_bytes = zmq_msg.get(2).unwrap(); + let _metadata_bytes = zmq_msg.get(4).unwrap(); + let _content_bytes = zmq_msg.get(5).unwrap(); + dbg!(&header_bytes); + + let header: MessageHeader = serde_json::from_slice(header_bytes).unwrap(); + + Ok(RequestMessage::new( + header, + "TODO".to_owned(), + "TODO".to_owned(), + )) + } +} + struct Message { is_reply: bool, r#type: String, @@ -468,9 +617,22 @@ impl DealerComm { Ok(()) } - pub async fn recv(&mut self) -> Result { - let msg = self.socket.recv().await?; - Ok(msg) + pub async fn recv(&mut self) -> Result { + let zmq_msg = self.socket.recv().await?; + dbg!(&zmq_msg); + + hmac_verify( + &self.hmac_key, + zmq_msg.get(1).unwrap(), + zmq_msg.get(2).unwrap(), + zmq_msg.get(3).unwrap(), + zmq_msg.get(4).unwrap(), + zmq_msg.get(5).unwrap(), + )?; + + let jup_msg = RequestMessage::try_from(zmq_msg)?; + + Ok(jup_msg) } pub async fn send(&mut self, msg: Message) -> Result<(), AnyError> { @@ -480,6 +642,7 @@ impl DealerComm { } } +// TODO(apowers313) this is the heartbeat loop now async fn create_zmq_reply(name: &str, conn_str: &str) -> Result<(), AnyError> { println!("reply '{}' connection string: {}", name, conn_str); @@ -541,7 +704,7 @@ fn hmac_verify( parent_header: &[u8], metadata: &[u8], content: &[u8], -) -> Result<(), ring::error::Unspecified> { +) -> Result<(), AnyError> { let mut msg = Vec::::new(); msg.extend(header); msg.extend(parent_header); From d8fb59d5a5f5ea526f8c5fb381f246f45e2e16ed Mon Sep 17 00:00:00 2001 From: Adam Powers Date: Tue, 21 Dec 2021 23:44:41 -0800 Subject: [PATCH 018/115] working reply messages --- cli/tools/jupyter.rs | 262 ++++++++++++++++++++++++++++++------------- 1 file changed, 185 insertions(+), 77 deletions(-) diff --git a/cli/tools/jupyter.rs b/cli/tools/jupyter.rs index 18f7417c74e325..00046575a19c9a 100644 --- a/cli/tools/jupyter.rs +++ b/cli/tools/jupyter.rs @@ -6,6 +6,7 @@ use crate::flags::Flags; use crate::flags::JupyterFlags; use data_encoding::HEXLOWER; +use deno_core::anyhow::anyhow; use deno_core::anyhow::Context; use deno_core::error::generic_error; use deno_core::error::AnyError; @@ -24,12 +25,6 @@ use zeromq::ZmqMessage; const DELIMETER: &str = ""; -macro_rules! handle { - ($kernel:ident, $method:ident) => { - Box::new(|x| $kernel.$method(x)) - }; -} - pub fn install() -> Result<(), AnyError> { let temp_dir = TempDir::new().unwrap(); let kernel_json_path = temp_dir.path().join("kernel.json"); @@ -88,7 +83,7 @@ pub async fn kernel( let conn_file_path = jupyter_flags.conn_file.unwrap(); let mut kernel = Kernel::new(conn_file_path.to_str().unwrap()); - eprintln!("[DENO] kernel created: {:#?}", kernel.metadata.session_id); + println!("[DENO] kernel created: {:#?}", kernel.metadata.session_id); println!("running kernel..."); kernel.run().await; @@ -113,18 +108,25 @@ impl std::fmt::Display for KernelState { } } } -struct Kernel<'env> { + +struct Kernel { metadata: KernelMetadata, conn_spec: ConnectionSpec, state: KernelState, iopub_comm: PubComm, shell_comm: DealerComm, - shell_handlers: CommHandler<'env>, control_comm: DealerComm, stdin_comm: DealerComm, } -impl Kernel<'_> { +enum HandlerType { + Shell, + Control, + Stdin, + IOPub, +} + +impl Kernel { fn new(conn_file_path: &str) -> Self { let conn_file = match std::fs::read_to_string(conn_file_path) .context("Failed to read connection file") @@ -144,7 +146,7 @@ impl Kernel<'_> { std::process::exit(1); } }; - eprintln!("[DENO] parsed conn file: {:#?}", conn_spec); + println!("[DENO] parsed conn file: {:#?}", conn_spec); let hmac_key = hmac::Key::new(hmac::HMAC_SHA256, conn_spec.key.as_ref()); let metadata = KernelMetadata::default(); @@ -188,11 +190,6 @@ impl Kernel<'_> { hmac_key.clone(), ); - // let shell_handlers = CommHandler::new(&[ - // ("kernel_info_request".to_owned(), Kernel::kernel_info_reply) - // ]); - let shell_handlers = CommHandler::new(&[]); - let hb_conn_str = create_conn_str(&conn_spec.transport, &conn_spec.ip, conn_spec.hb_port); @@ -202,16 +199,10 @@ impl Kernel<'_> { state: KernelState::Idle, iopub_comm, shell_comm, - shell_handlers, control_comm, stdin_comm, }; - shell_handlers.add_handler( - &"kernel_info_request".to_owned(), - handle!(s, kernel_info_reply), - ); - s } @@ -233,19 +224,77 @@ impl Kernel<'_> { loop { tokio::select! { shell_msg = self.shell_comm.recv() => { - eprintln!("shell got packet: {:#?}", shell_msg); - self.shell_handlers.call(shell_msg); + println!("shell got packet: {:#?}", shell_msg); + self.handler(HandlerType::Shell, shell_msg).await; }, control_msg = self.control_comm.recv() => { - eprintln!("control got packet: {:#?}", control_msg); + println!("control got packet: {:#?}", control_msg); + self.handler(HandlerType::Control, control_msg); }, stdin_msg = self.stdin_comm.recv() => { - eprintln!("stdin got packet: {:#?}", stdin_msg); + println!("stdin got packet: {:#?}", stdin_msg); + self.handler(HandlerType::Stdin, stdin_msg); }, } } } + async fn handler( + &mut self, + handler_type: HandlerType, + recv_result: Result, + ) { + let req_msg = match recv_result { + Ok(m) => m, + Err(e) => { + println!("error receiving msg: {}", e); + return; + } + }; + let res = match handler_type { + HandlerType::Shell => self.shell_handler(&req_msg).await, + HandlerType::Control => self.control_handler(&req_msg), + HandlerType::Stdin => self.stdin_handler(&req_msg), + HandlerType::IOPub => self.iopub_handler(&req_msg), + }; + + match res { + Ok(_) => return, + Err(e) => { + println!("error handling packet '{}': {}", req_msg.header.msg_type, e); + dbg!(req_msg); + } + }; + } + + async fn shell_handler( + &mut self, + req_msg: &RequestMessage, + ) -> Result<(), AnyError> { + match req_msg.header.msg_type.as_ref() { + "kernel_info_request" => self.kernel_info_reply(req_msg).await?, + _ => { + return Err(anyhow!("no handler for msg_id: {}", req_msg.header.msg_id)) + } + }; + + Ok(()) + } + + fn control_handler(&self, req_msg: &RequestMessage) -> Result<(), AnyError> { + todo!() + } + + fn stdin_handler(&self, req_msg: &RequestMessage) -> Result<(), AnyError> { + todo!() + } + + fn iopub_handler(&self, req_msg: &RequestMessage) -> Result<(), AnyError> { + // TODO(apowers313) I *think* this is used for custom messages... + // https://jupyter-client.readthedocs.io/en/latest/messaging.html#custom-messages + todo!() + } + async fn set_state(&mut self, state: KernelState, ctx: CommContext) { if self.state == state { return; @@ -281,12 +330,36 @@ impl Kernel<'_> { let _ = self.iopub_comm.send(msg).await; } - pub fn kernel_info_reply( - &self, - req_msg: RequestMessage, + async fn kernel_info_reply( + &mut self, + req_msg: &RequestMessage, ) -> Result<(), AnyError> { dbg!(req_msg); + let content = KernelInfoReplyContent { + status: String::from("ok"), + protocol_version: self.metadata.protocol_version.clone(), + implementation_version: self.metadata.kernel_version.clone(), + implementation: self.metadata.implementation_name.clone(), + language_info: KernelLanguageInfo { + name: self.metadata.language.clone(), + version: self.metadata.language_version.clone(), + mimetype: self.metadata.mime.clone(), + file_extension: self.metadata.file_ext.clone(), + codemirror_mode: None, + nbconvert_exporter: None, + pygments_lexer: None, + }, + help_links: vec![], // TODO(apowers313) dig up help links + banner: self.metadata.banner.clone(), + debugger: false, + }; + + let reply = + ReplyMessage::try_from((&req_msg.header, "TODO".to_string(), content))?; + + self.shell_comm.send(reply).await?; + Ok(()) } @@ -295,6 +368,7 @@ impl Kernel<'_> { fn get_kernel_info(&self) -> Value { json!({ "status": "ok", + // TODO: all of these should be taken from globals, "protocol_version": self.metadata.protocol_version, "implementation_version": self.metadata.kernel_version, "implementation": self.metadata.implementation_name, @@ -376,7 +450,7 @@ struct CommContext { session_id: String, } -#[derive(Debug, Deserialize, Serialize)] +#[derive(Debug, Deserialize, Serialize, Clone)] struct MessageHeader { msg_id: String, session: String, @@ -386,51 +460,22 @@ struct MessageHeader { version: String, } -type CommHandlerFn<'env> = - Box Result<(), AnyError>>; - -struct CommHandler<'env> { - collection: HashMap>, -} - -impl CommHandler<'_> { - fn new(handlers: &[(String, CommHandlerFn)]) -> Self { - let mut s = Self { - collection: HashMap::new(), - }; +impl MessageHeader { + fn new(session_id: String) -> Self { + let now = std::time::SystemTime::now(); + let now: chrono::DateTime = now.into(); + let now = now.to_rfc3339(); - for handler in handlers.iter() { - s.add_handler(&handler.0, handler.1); + Self { + msg_id: uuid::Uuid::new_v4().to_string(), + session: session_id.clone(), + // FIXME: + username: "".to_string(), + date: now.to_string(), + msg_type: "status".to_string(), + // TODO: this should be taken from a global, + version: "5.3".to_string(), } - - s - } - - fn add_handler(&mut self, name: &String, handler: CommHandlerFn) { - self.collection.insert(name.to_owned(), handler); - } - - fn call(&self, msg_res: Result) { - let msg = match msg_res { - Ok(m) => m, - Err(e) => { - eprintln!("error while receiving message: {}", e); - return; - } - }; - let msg_type = msg.header.msg_id; - let handler = match self.collection.get(&msg_type) { - Some(x) => x, - None => { - println!("no message handler found for message type: '{}'", msg_type); - return; - } - }; - - match handler(msg) { - Ok(()) => return, - Err(e) => println!("error while handling {}: {}", msg_type, e), - }; } } @@ -472,6 +517,67 @@ impl TryFrom for RequestMessage { } } +struct ReplyMessage { + header: MessageHeader, + parent_header: MessageHeader, + metadata: Option, + content: Option, +} + +impl ReplyMessage { + fn new(parent_header: &MessageHeader, session_id: String) -> Self { + Self { + header: MessageHeader::new(session_id), + parent_header: parent_header.clone(), + metadata: Some("{}".to_string()), + content: Some("{}".to_string()), + } + } + + fn serialize(&self, hmac_key: &hmac::Key) -> ZmqMessage { + let header = serde_json::to_string(&self.header).unwrap(); + // let parent_header = if let Some(p_header) = self.parent_header.as_ref() { + // serde_json::to_string(p_header).unwrap() + // } else { + // serde_json::to_string(&json!({})).unwrap() + // }; + let parent_header = serde_json::to_string(&self.parent_header).unwrap(); + let metadata = serde_json::to_string(&self.metadata).unwrap(); + let content = serde_json::to_string(&self.content).unwrap(); + + let hmac = + hmac_sign(hmac_key, &header, &parent_header, &metadata, &content); + + let mut zmq_msg = ZmqMessage::from(DELIMETER); + zmq_msg.push_back(hmac.into()); + zmq_msg.push_back(header.into()); + zmq_msg.push_back(parent_header.into()); + zmq_msg.push_back(metadata.into()); + zmq_msg.push_back(content.into()); + println!("+++ SENDING ZMQ MSG: {:#?}", zmq_msg); + zmq_msg + } +} + +impl TryFrom<(&MessageHeader, String, KernelInfoReplyContent)> + for ReplyMessage +{ + type Error = AnyError; + + fn try_from( + args: (&MessageHeader, String, KernelInfoReplyContent), + ) -> Result { + let hdr = args.0; + let session_id = args.1; + let content = args.2; + let mut m = ReplyMessage::new(hdr, session_id); + m.header.msg_type = String::from("kernel_info_reply"); + // m.content = content; + + Ok(m) + } +} + struct Message { is_reply: bool, r#type: String, @@ -581,6 +687,7 @@ impl PubComm { pub async fn send(&mut self, msg: Message) -> Result<(), AnyError> { let zmq_msg = msg.serialize(&self.hmac_key); + println!("==> SENDING: {:#?}", zmq_msg); self.socket.send(zmq_msg).await?; Ok(()) } @@ -635,7 +742,7 @@ impl DealerComm { Ok(jup_msg) } - pub async fn send(&mut self, msg: Message) -> Result<(), AnyError> { + pub async fn send(&mut self, msg: ReplyMessage) -> Result<(), AnyError> { let zmq_msg = msg.serialize(&self.hmac_key); self.socket.send(zmq_msg).await?; Ok(()) @@ -869,7 +976,8 @@ struct CommInfoReplyContent { // struct KernelInfoRequest {} // empty // https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-info -struct KernelInfoReply { +#[derive(Debug, Serialize, Deserialize)] +struct KernelInfoReplyContent { status: String, protocol_version: String, implementation: String, @@ -886,9 +994,9 @@ struct KernelLanguageInfo { version: String, mimetype: String, file_extension: String, - pygments_lexer: String, + pygments_lexer: Option, codemirror_mode: Option, - nbconvert_exporter: String, + nbconvert_exporter: Option, } // https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-info From b7a6fbd9641cbecb8be359d2cb3b827fc2f5d670 Mon Sep 17 00:00:00 2001 From: Adam Powers Date: Tue, 21 Dec 2021 23:48:53 -0800 Subject: [PATCH 019/115] remove iopub return path --- cli/tools/jupyter.rs | 8 -------- 1 file changed, 8 deletions(-) diff --git a/cli/tools/jupyter.rs b/cli/tools/jupyter.rs index 00046575a19c9a..3991f1f3067417 100644 --- a/cli/tools/jupyter.rs +++ b/cli/tools/jupyter.rs @@ -123,7 +123,6 @@ enum HandlerType { Shell, Control, Stdin, - IOPub, } impl Kernel { @@ -255,7 +254,6 @@ impl Kernel { HandlerType::Shell => self.shell_handler(&req_msg).await, HandlerType::Control => self.control_handler(&req_msg), HandlerType::Stdin => self.stdin_handler(&req_msg), - HandlerType::IOPub => self.iopub_handler(&req_msg), }; match res { @@ -289,12 +287,6 @@ impl Kernel { todo!() } - fn iopub_handler(&self, req_msg: &RequestMessage) -> Result<(), AnyError> { - // TODO(apowers313) I *think* this is used for custom messages... - // https://jupyter-client.readthedocs.io/en/latest/messaging.html#custom-messages - todo!() - } - async fn set_state(&mut self, state: KernelState, ctx: CommContext) { if self.state == state { return; From 54ba6bca7ea9f69e82d8c0f7c75ff05d306191f0 Mon Sep 17 00:00:00 2001 From: Adam Powers Date: Wed, 22 Dec 2021 16:02:17 -0800 Subject: [PATCH 020/115] refactor message content and metadata --- cli/tools/jupyter.rs | 90 ++++++++++++++++++++++++++++++++------------ 1 file changed, 65 insertions(+), 25 deletions(-) diff --git a/cli/tools/jupyter.rs b/cli/tools/jupyter.rs index 3991f1f3067417..c554a17c0a28e8 100644 --- a/cli/tools/jupyter.rs +++ b/cli/tools/jupyter.rs @@ -250,10 +250,18 @@ impl Kernel { return; } }; - let res = match handler_type { - HandlerType::Shell => self.shell_handler(&req_msg).await, - HandlerType::Control => self.control_handler(&req_msg), - HandlerType::Stdin => self.stdin_handler(&req_msg), + let major_version = &req_msg.header.version.to_string()[0..1]; + let res = match (handler_type, major_version) { + (HandlerType::Shell, "5") => self.shell_handler(&req_msg).await, + (HandlerType::Control, "5") => self.control_handler(&req_msg), + (HandlerType::Stdin, "5") => self.stdin_handler(&req_msg), + _ => { + println!( + "No handler for message: '{}' v{}", + req_msg.header.msg_type, major_version + ); + return; + } }; match res { @@ -475,12 +483,16 @@ impl MessageHeader { struct RequestMessage { header: MessageHeader, parent_header: Option<()>, - metadata: String, - content: String, + metadata: RequestMetadata, + content: RequestContent, } impl RequestMessage { - fn new(header: MessageHeader, metadata: String, content: String) -> Self { + fn new( + header: MessageHeader, + metadata: RequestMetadata, + content: RequestContent, + ) -> Self { Self { header, parent_header: None, @@ -495,25 +507,26 @@ impl TryFrom for RequestMessage { fn try_from(zmq_msg: ZmqMessage) -> Result { let header_bytes = zmq_msg.get(2).unwrap(); - let _metadata_bytes = zmq_msg.get(4).unwrap(); - let _content_bytes = zmq_msg.get(5).unwrap(); + let metadata_bytes = zmq_msg.get(4).unwrap(); + let content_bytes = zmq_msg.get(5).unwrap(); dbg!(&header_bytes); let header: MessageHeader = serde_json::from_slice(header_bytes).unwrap(); - Ok(RequestMessage::new( - header, - "TODO".to_owned(), - "TODO".to_owned(), - )) + let mc = match header.msg_type.as_ref() { + "kernel_info_request" => (RequestMetadata::Empty, RequestContent::Empty), + _ => (RequestMetadata::Empty, RequestContent::Empty), + }; + + Ok(RequestMessage::new(header, mc.0, mc.1)) } } struct ReplyMessage { header: MessageHeader, parent_header: MessageHeader, - metadata: Option, - content: Option, + metadata: ReplyMetadata, + content: ReplyContent, } impl ReplyMessage { @@ -521,21 +534,23 @@ impl ReplyMessage { Self { header: MessageHeader::new(session_id), parent_header: parent_header.clone(), - metadata: Some("{}".to_string()), - content: Some("{}".to_string()), + metadata: ReplyMetadata::Empty, + content: ReplyContent::Empty, } } fn serialize(&self, hmac_key: &hmac::Key) -> ZmqMessage { + // TODO(apowers313) convert unwrap() to recoverable error let header = serde_json::to_string(&self.header).unwrap(); - // let parent_header = if let Some(p_header) = self.parent_header.as_ref() { - // serde_json::to_string(p_header).unwrap() - // } else { - // serde_json::to_string(&json!({})).unwrap() - // }; let parent_header = serde_json::to_string(&self.parent_header).unwrap(); let metadata = serde_json::to_string(&self.metadata).unwrap(); - let content = serde_json::to_string(&self.content).unwrap(); + let metadata = match &self.metadata { + ReplyMetadata::Empty => serde_json::to_string(&json!({})).unwrap(), + }; + let content = match &self.content { + ReplyContent::Empty => serde_json::to_string(&json!({})).unwrap(), + ReplyContent::KernelInfo(c) => serde_json::to_string(&c).unwrap(), + }; let hmac = hmac_sign(hmac_key, &header, &parent_header, &metadata, &content); @@ -551,6 +566,7 @@ impl ReplyMessage { } } +// TODO(apowers313) replace TryFrom with ReplyMessage::new impl TryFrom<(&MessageHeader, String, KernelInfoReplyContent)> for ReplyMessage { @@ -564,7 +580,7 @@ impl TryFrom<(&MessageHeader, String, KernelInfoReplyContent)> let content = args.2; let mut m = ReplyMessage::new(hdr, session_id); m.header.msg_type = String::from("kernel_info_reply"); - // m.content = content; + m.content = ReplyContent::KernelInfo(content); Ok(m) } @@ -877,6 +893,28 @@ fn hmac_sign_test() { // "comm_info_reply" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#comm-info // "kernel_info_reply" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-info +#[derive(Debug, Serialize, Deserialize)] +enum RequestContent { + Empty, +} + +#[derive(Debug, Serialize, Deserialize)] +enum ReplyContent { + Empty, + KernelInfo(KernelInfoReplyContent), +} + +#[derive(Debug, Serialize, Deserialize)] +enum RequestMetadata { + Empty, + Unknown(Value), +} + +#[derive(Debug, Serialize, Deserialize)] +enum ReplyMetadata { + Empty, +} + // https://jupyter-client.readthedocs.io/en/latest/messaging.html#execute struct ExecuteRequestContent { code: String, @@ -981,6 +1019,7 @@ struct KernelInfoReplyContent { } // https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-info +#[derive(Debug, Serialize, Deserialize)] struct KernelLanguageInfo { name: String, version: String, @@ -992,6 +1031,7 @@ struct KernelLanguageInfo { } // https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-info +#[derive(Debug, Serialize, Deserialize)] struct KernelHelpLink { text: String, url: String, From 3e298c826ec0d613ee7bd1c2992ffd856be88312 Mon Sep 17 00:00:00 2001 From: Adam Powers Date: Thu, 23 Dec 2021 16:49:34 -0800 Subject: [PATCH 021/115] implement set_state --- cli/tools/jupyter.rs | 263 ++++++++++++++++--------------------------- 1 file changed, 94 insertions(+), 169 deletions(-) diff --git a/cli/tools/jupyter.rs b/cli/tools/jupyter.rs index c554a17c0a28e8..d71988bdea1098 100644 --- a/cli/tools/jupyter.rs +++ b/cli/tools/jupyter.rs @@ -250,92 +250,100 @@ impl Kernel { return; } }; - let major_version = &req_msg.header.version.to_string()[0..1]; + + let comm_ctx = CommContext { + session_id: self.metadata.session_id.clone(), + message: req_msg, + }; + + println!("XXX handler calling set_state: busy"); + self.set_state(&comm_ctx, KernelState::Busy).await; + + let major_version = &comm_ctx.message.header.version.to_string()[0..1]; let res = match (handler_type, major_version) { - (HandlerType::Shell, "5") => self.shell_handler(&req_msg).await, - (HandlerType::Control, "5") => self.control_handler(&req_msg), - (HandlerType::Stdin, "5") => self.stdin_handler(&req_msg), - _ => { - println!( - "No handler for message: '{}' v{}", - req_msg.header.msg_type, major_version - ); - return; - } + // TODO(apowers313) implement new and old Jupyter protocols here + (HandlerType::Shell, "5") => self.shell_handler(&comm_ctx).await, + (HandlerType::Control, "5") => self.control_handler(&comm_ctx), + (HandlerType::Stdin, "5") => self.stdin_handler(&comm_ctx), + _ => Err(anyhow!( + "No handler for message: '{}' v{}", + comm_ctx.message.header.msg_type, + major_version + )), }; + println!("XXX handler calling set_state: idle"); + self.set_state(&comm_ctx, KernelState::Idle).await; + match res { Ok(_) => return, Err(e) => { - println!("error handling packet '{}': {}", req_msg.header.msg_type, e); - dbg!(req_msg); + println!( + "Error handling packet '{}': {}", + comm_ctx.message.header.msg_type, e + ); } }; } async fn shell_handler( &mut self, - req_msg: &RequestMessage, + comm_ctx: &CommContext, ) -> Result<(), AnyError> { - match req_msg.header.msg_type.as_ref() { - "kernel_info_request" => self.kernel_info_reply(req_msg).await?, + match comm_ctx.message.header.msg_type.as_ref() { + "kernel_info_request" => self.kernel_info_reply(comm_ctx).await?, _ => { - return Err(anyhow!("no handler for msg_id: {}", req_msg.header.msg_id)) + return Err(anyhow!( + "no handler for msg_id: '{}'", + comm_ctx.message.header.msg_id + )) } }; Ok(()) } - fn control_handler(&self, req_msg: &RequestMessage) -> Result<(), AnyError> { + fn control_handler(&self, comm_ctx: &CommContext) -> Result<(), AnyError> { todo!() } - fn stdin_handler(&self, req_msg: &RequestMessage) -> Result<(), AnyError> { + fn stdin_handler(&self, comm_ctx: &CommContext) -> Result<(), AnyError> { todo!() } - async fn set_state(&mut self, state: KernelState, ctx: CommContext) { + async fn set_state(&mut self, comm_ctx: &CommContext, state: KernelState) { + println!("XXX CALLING SET_STATE"); if self.state == state { return; } + println!("setting state to: {}", state); self.state = state; let now = std::time::SystemTime::now(); let now: chrono::DateTime = now.into(); let now = now.to_rfc3339(); - let msg = Message { - is_reply: true, - r#type: "status".to_string(), - header: MessageHeader { - msg_id: uuid::Uuid::new_v4().to_string(), - session: ctx.session_id.clone(), - // FIXME: - username: "".to_string(), - date: now.to_string(), - msg_type: "status".to_string(), - // TODO: this should be taken from a global, - version: "5.3".to_string(), - }, - parent_header: Some(ctx.message.header), - session_id: ctx.session_id, - metadata: json!({}), - content: json!({ - "execution_state": state.to_string(), - }), + let s = match state { + KernelState::Busy => "busy".to_string(), + KernelState::Idle => "idle".to_string(), + KernelState::Starting => "starting".to_string(), }; - // ignore any error when announcing changes - let _ = self.iopub_comm.send(msg).await; + + let msg = SideEffectMessage::new( + &comm_ctx, + "status".to_string(), + ReplyMetadata::Empty, + ReplyContent::Status(KernelStatusContent { execution_state: s }), + ); + + self.iopub_comm.send(msg).await; } async fn kernel_info_reply( &mut self, - req_msg: &RequestMessage, + comm_ctx: &CommContext, ) -> Result<(), AnyError> { - dbg!(req_msg); - let content = KernelInfoReplyContent { status: String::from("ok"), protocol_version: self.metadata.protocol_version.clone(), @@ -355,8 +363,12 @@ impl Kernel { debugger: false, }; - let reply = - ReplyMessage::try_from((&req_msg.header, "TODO".to_string(), content))?; + let reply = ReplyMessage::new( + comm_ctx, + "kernel_info_reply".to_string(), + ReplyMetadata::Empty, + ReplyContent::KernelInfo(content), + ); self.shell_comm.send(reply).await?; @@ -444,9 +456,9 @@ struct ConnectionSpec { key: String, } +#[derive(Debug)] struct CommContext { - message: Message, - hmac: String, + message: RequestMessage, session_id: String, } @@ -461,7 +473,7 @@ struct MessageHeader { } impl MessageHeader { - fn new(session_id: String) -> Self { + fn new(msg_type: String, session_id: String) -> Self { let now = std::time::SystemTime::now(); let now: chrono::DateTime = now.into(); let now = now.to_rfc3339(); @@ -472,7 +484,7 @@ impl MessageHeader { // FIXME: username: "".to_string(), date: now.to_string(), - msg_type: "status".to_string(), + msg_type, // TODO: this should be taken from a global, version: "5.3".to_string(), } @@ -509,7 +521,6 @@ impl TryFrom for RequestMessage { let header_bytes = zmq_msg.get(2).unwrap(); let metadata_bytes = zmq_msg.get(4).unwrap(); let content_bytes = zmq_msg.get(5).unwrap(); - dbg!(&header_bytes); let header: MessageHeader = serde_json::from_slice(header_bytes).unwrap(); @@ -518,7 +529,10 @@ impl TryFrom for RequestMessage { _ => (RequestMetadata::Empty, RequestContent::Empty), }; - Ok(RequestMessage::new(header, mc.0, mc.1)) + let rm = RequestMessage::new(header, mc.0, mc.1); + println!("<== RECEIVING: {:#?}", rm); + + Ok(rm) } } @@ -530,12 +544,17 @@ struct ReplyMessage { } impl ReplyMessage { - fn new(parent_header: &MessageHeader, session_id: String) -> Self { + fn new( + comm_ctx: &CommContext, + msg_type: String, + metadata: ReplyMetadata, + content: ReplyContent, + ) -> Self { Self { - header: MessageHeader::new(session_id), - parent_header: parent_header.clone(), - metadata: ReplyMetadata::Empty, - content: ReplyContent::Empty, + header: MessageHeader::new(msg_type, comm_ctx.session_id.clone()), + parent_header: comm_ctx.message.header.clone(), + metadata, + content, } } @@ -550,6 +569,7 @@ impl ReplyMessage { let content = match &self.content { ReplyContent::Empty => serde_json::to_string(&json!({})).unwrap(), ReplyContent::KernelInfo(c) => serde_json::to_string(&c).unwrap(), + ReplyContent::Status(c) => serde_json::to_string(&c).unwrap(), }; let hmac = @@ -561,109 +581,13 @@ impl ReplyMessage { zmq_msg.push_back(parent_header.into()); zmq_msg.push_back(metadata.into()); zmq_msg.push_back(content.into()); - println!("+++ SENDING ZMQ MSG: {:#?}", zmq_msg); + println!("==> SENDING ZMQ MSG: {:#?}", zmq_msg); zmq_msg } } -// TODO(apowers313) replace TryFrom with ReplyMessage::new -impl TryFrom<(&MessageHeader, String, KernelInfoReplyContent)> - for ReplyMessage -{ - type Error = AnyError; - - fn try_from( - args: (&MessageHeader, String, KernelInfoReplyContent), - ) -> Result { - let hdr = args.0; - let session_id = args.1; - let content = args.2; - let mut m = ReplyMessage::new(hdr, session_id); - m.header.msg_type = String::from("kernel_info_reply"); - m.content = ReplyContent::KernelInfo(content); - - Ok(m) - } -} - -struct Message { - is_reply: bool, - r#type: String, - header: MessageHeader, - parent_header: Option, - metadata: Value, - content: Value, - session_id: String, -} - -impl Message { - fn new() -> Self { - todo!() - } - - fn serialize(&self, hmac_key: &hmac::Key) -> ZmqMessage { - let header = serde_json::to_string(&self.header).unwrap(); - let parent_header = if let Some(p_header) = self.parent_header.as_ref() { - serde_json::to_string(p_header).unwrap() - } else { - serde_json::to_string(&json!({})).unwrap() - }; - let metadata = serde_json::to_string(&self.metadata).unwrap(); - let content = serde_json::to_string(&self.content).unwrap(); - - let hmac = - hmac_sign(hmac_key, &header, &parent_header, &metadata, &content); - - let mut zmq_msg = ZmqMessage::from(DELIMETER); - zmq_msg.push_back(hmac.into()); - zmq_msg.push_back(header.into()); - zmq_msg.push_back(parent_header.into()); - zmq_msg.push_back(metadata.into()); - zmq_msg.push_back(content.into()); - zmq_msg - } - - fn from_zmq_message( - zmq_msg: ZmqMessage, - hmac_key: &hmac::Key, - ) -> Result { - // TODO(bartomieju): can these unwraps be better handled? - let expected_signature_bytes = zmq_msg.get(0).unwrap(); - let header_bytes = zmq_msg.get(1).unwrap(); - let parent_header_bytes = zmq_msg.get(2).unwrap(); - let metadata_bytes = zmq_msg.get(3).unwrap(); - let content_bytes = zmq_msg.get(4).unwrap(); - - hmac_verify( - hmac_key, - expected_signature_bytes, - header_bytes, - parent_header_bytes, - metadata_bytes, - content_bytes, - )?; - - // TODO(bartomieju): can these unwraps be better handled? - let header: MessageHeader = serde_json::from_slice(header_bytes).unwrap(); - let parent_header: MessageHeader = - serde_json::from_slice(parent_header_bytes).unwrap(); - let metadata: Value = serde_json::from_slice(metadata_bytes).unwrap(); - let content: Value = serde_json::from_slice(content_bytes).unwrap(); - - let msg = Message { - is_reply: false, - r#type: header.msg_type.clone(), - header, - parent_header: Some(parent_header), - metadata, - content, - // FIXME: - session_id: "".to_string(), - }; - - Ok(msg) - } -} +// side effects messages sent on IOPub look lik ReplyMessages (for now?) +type SideEffectMessage = ReplyMessage; struct PubComm { conn_str: String, @@ -672,6 +596,7 @@ struct PubComm { socket: zeromq::PubSocket, } +// TODO(apowers313) connect and send look like traits shared with DealerComm impl PubComm { pub fn new( conn_str: String, @@ -693,9 +618,9 @@ impl PubComm { Ok(()) } - pub async fn send(&mut self, msg: Message) -> Result<(), AnyError> { + pub async fn send(&mut self, msg: SideEffectMessage) -> Result<(), AnyError> { let zmq_msg = msg.serialize(&self.hmac_key); - println!("==> SENDING: {:#?}", zmq_msg); + println!(">>> ZMQ SENDING: {:#?}", zmq_msg); self.socket.send(zmq_msg).await?; Ok(()) } @@ -734,7 +659,7 @@ impl DealerComm { pub async fn recv(&mut self) -> Result { let zmq_msg = self.socket.recv().await?; - dbg!(&zmq_msg); + println!("<<< ZMQ RECEIVING: {:#?}", zmq_msg); hmac_verify( &self.hmac_key, @@ -752,6 +677,7 @@ impl DealerComm { pub async fn send(&mut self, msg: ReplyMessage) -> Result<(), AnyError> { let zmq_msg = msg.serialize(&self.hmac_key); + println!(">>> ZMQ SENDING: {:#?}", zmq_msg); self.socket.send(zmq_msg).await?; Ok(()) } @@ -767,8 +693,7 @@ async fn create_zmq_reply(name: &str, conn_str: &str) -> Result<(), AnyError> { loop { let msg = sock.recv().await?; - dbg!(&msg); - println!("{} got packet!", name); + println!("*** '{}' got packet!", name); } } @@ -784,13 +709,8 @@ fn parse_zmq_packet(data: &ZmqMessage) -> Result<(), AnyError> { let _metadata = data.get(4); let _content = data.get(5); - println!("header:"); - dbg!(header); let header_str = std::str::from_utf8(header).unwrap(); let header_value: MessageHeader = serde_json::from_str(header_str).unwrap(); - println!("header_value"); - dbg!(&header_value); - // validate_header(&header_value)?; Ok(()) } @@ -901,7 +821,10 @@ enum RequestContent { #[derive(Debug, Serialize, Deserialize)] enum ReplyContent { Empty, + // Reply Messages KernelInfo(KernelInfoReplyContent), + // Side Effects + Status(KernelStatusContent), } #[derive(Debug, Serialize, Deserialize)] @@ -1104,9 +1027,10 @@ struct ErrorStatusContent { } // https://jupyter-client.readthedocs.io/en/latest/messaging.html#request-reply -struct StatusContent { - status: String, // "ok" | "abort" -} +// #[derive(Debug, Serialize, Deserialize)] +// struct StatusContent { +// status: String, // "ok" | "abort" +// } // https://jupyter-client.readthedocs.io/en/latest/messaging.html#streams-stdout-stderr-etc struct StreamContent { @@ -1144,6 +1068,7 @@ struct ErrorContent { } // https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-status +#[derive(Debug, Serialize, Deserialize)] struct KernelStatusContent { execution_state: String, // "busy" | "idle" | "starting" } From e43360d50b2ab38e60d9b2ed41c7b754443de31d Mon Sep 17 00:00:00 2001 From: Adam Powers Date: Sat, 25 Dec 2021 15:38:10 -0800 Subject: [PATCH 022/115] partially working execute --- cli/tools/jupyter.rs | 256 +++++++++++++++++++++++++++++++++---------- 1 file changed, 198 insertions(+), 58 deletions(-) diff --git a/cli/tools/jupyter.rs b/cli/tools/jupyter.rs index d71988bdea1098..98b82240d4bd96 100644 --- a/cli/tools/jupyter.rs +++ b/cli/tools/jupyter.rs @@ -18,8 +18,10 @@ use deno_core::serde_json::Value; use ring::hmac; use std::collections::HashMap; use std::env::current_exe; +use std::time::Duration; use tempfile::TempDir; use tokio::join; +use tokio::time::sleep; use zeromq::prelude::*; use zeromq::ZmqMessage; @@ -83,7 +85,7 @@ pub async fn kernel( let conn_file_path = jupyter_flags.conn_file.unwrap(); let mut kernel = Kernel::new(conn_file_path.to_str().unwrap()); - println!("[DENO] kernel created: {:#?}", kernel.metadata.session_id); + println!("[DENO] kernel created: {:#?}", kernel.session_id); println!("running kernel..."); kernel.run().await; @@ -117,6 +119,8 @@ struct Kernel { shell_comm: DealerComm, control_comm: DealerComm, stdin_comm: DealerComm, + session_id: String, + execution_count: u32, } enum HandlerType { @@ -147,6 +151,8 @@ impl Kernel { }; println!("[DENO] parsed conn file: {:#?}", conn_spec); + let execution_count = 0; + let session_id = uuid::Uuid::new_v4().to_string(); let hmac_key = hmac::Key::new(hmac::HMAC_SHA256, conn_spec.key.as_ref()); let metadata = KernelMetadata::default(); let iopub_comm = PubComm::new( @@ -155,7 +161,7 @@ impl Kernel { &conn_spec.ip, conn_spec.iopub_port, ), - metadata.session_id.clone(), + session_id.clone(), hmac_key.clone(), ); let shell_comm = DealerComm::new( @@ -165,7 +171,7 @@ impl Kernel { &conn_spec.ip, conn_spec.shell_port, ), - metadata.session_id.clone(), + session_id.clone(), hmac_key.clone(), ); let control_comm = DealerComm::new( @@ -175,7 +181,7 @@ impl Kernel { &conn_spec.ip, conn_spec.control_port, ), - metadata.session_id.clone(), + session_id.clone(), hmac_key.clone(), ); let stdin_comm = DealerComm::new( @@ -185,7 +191,7 @@ impl Kernel { &conn_spec.ip, conn_spec.stdin_port, ), - metadata.session_id.clone(), + session_id.clone(), hmac_key.clone(), ); @@ -200,6 +206,8 @@ impl Kernel { shell_comm, control_comm, stdin_comm, + session_id, + execution_count, }; s @@ -223,15 +231,15 @@ impl Kernel { loop { tokio::select! { shell_msg = self.shell_comm.recv() => { - println!("shell got packet: {:#?}", shell_msg); + // println!("shell got packet: {:#?}", shell_msg); self.handler(HandlerType::Shell, shell_msg).await; }, control_msg = self.control_comm.recv() => { - println!("control got packet: {:#?}", control_msg); + // println!("control got packet: {:#?}", control_msg); self.handler(HandlerType::Control, control_msg); }, stdin_msg = self.stdin_comm.recv() => { - println!("stdin got packet: {:#?}", stdin_msg); + // println!("stdin got packet: {:#?}", stdin_msg); self.handler(HandlerType::Stdin, stdin_msg); }, } @@ -252,12 +260,17 @@ impl Kernel { }; let comm_ctx = CommContext { - session_id: self.metadata.session_id.clone(), + session_id: self.session_id.clone(), message: req_msg, }; - println!("XXX handler calling set_state: busy"); - self.set_state(&comm_ctx, KernelState::Busy).await; + match self.set_state(&comm_ctx, KernelState::Busy).await { + Ok(_) => {} + Err(e) => { + println!("error setting busy state: {}", e); + return; + } + }; let major_version = &comm_ctx.message.header.version.to_string()[0..1]; let res = match (handler_type, major_version) { @@ -272,11 +285,8 @@ impl Kernel { )), }; - println!("XXX handler calling set_state: idle"); - self.set_state(&comm_ctx, KernelState::Idle).await; - match res { - Ok(_) => return, + Ok(_) => {} Err(e) => { println!( "Error handling packet '{}': {}", @@ -284,6 +294,14 @@ impl Kernel { ); } }; + + match self.set_state(&comm_ctx, KernelState::Idle).await { + Ok(_) => {} + Err(e) => { + println!("error setting idle state: {}", e); + return; + } + }; } async fn shell_handler( @@ -292,6 +310,7 @@ impl Kernel { ) -> Result<(), AnyError> { match comm_ctx.message.header.msg_type.as_ref() { "kernel_info_request" => self.kernel_info_reply(comm_ctx).await?, + "execute_request" => self.execute_request(comm_ctx).await?, _ => { return Err(anyhow!( "no handler for msg_id: '{}'", @@ -311,13 +330,15 @@ impl Kernel { todo!() } - async fn set_state(&mut self, comm_ctx: &CommContext, state: KernelState) { - println!("XXX CALLING SET_STATE"); + async fn set_state( + &mut self, + comm_ctx: &CommContext, + state: KernelState, + ) -> Result<(), AnyError> { if self.state == state { - return; + return Ok(()); } - println!("setting state to: {}", state); self.state = state; let now = std::time::SystemTime::now(); @@ -337,7 +358,7 @@ impl Kernel { ReplyContent::Status(KernelStatusContent { execution_state: s }), ); - self.iopub_comm.send(msg).await; + self.iopub_comm.send(msg).await } async fn kernel_info_reply( @@ -354,9 +375,10 @@ impl Kernel { version: self.metadata.language_version.clone(), mimetype: self.metadata.mime.clone(), file_extension: self.metadata.file_ext.clone(), - codemirror_mode: None, - nbconvert_exporter: None, - pygments_lexer: None, + // TODO: "None" gets translated to "null" + // codemirror_mode: None, + // nbconvert_exporter: None, + // pygments_lexer: None, }, help_links: vec![], // TODO(apowers313) dig up help links banner: self.metadata.banner.clone(), @@ -375,38 +397,127 @@ impl Kernel { Ok(()) } - // TODO(bartlomieju): feels like this info should be a separate struct - // instead of KernelMetadata - fn get_kernel_info(&self) -> Value { - json!({ - "status": "ok", - // TODO: all of these should be taken from globals, - "protocol_version": self.metadata.protocol_version, - "implementation_version": self.metadata.kernel_version, - "implementation": self.metadata.implementation_name, - "language_info": { - "name": self.metadata.language, - "version": self.metadata.language_version, - "mime": self.metadata.mime, - "file_extension": self.metadata.file_ext, + async fn execute_request( + &mut self, + comm_ctx: &CommContext, + ) -> Result<(), AnyError> { + self.execution_count = self.execution_count + 1; + + let exec_request_content = match &comm_ctx.message.content { + RequestContent::Execute(c) => c, + _ => return Err(anyhow!("malformed execution content")), + }; + + let input_msg = SideEffectMessage::new( + comm_ctx, + "execute_input".to_string(), + ReplyMetadata::Empty, + ReplyContent::ExecuteInput(ExecuteInputContent { + code: exec_request_content.code.clone(), + execution_count: self.execution_count, + }), + ); + self.iopub_comm.send(input_msg).await?; + + // TODO(apowers313) it executes code... just not the code you requested :) + // hook in the real REPL request to execute code here + let result = self.fake_task(&comm_ctx, "foo".to_string()).await?; + + self.exec_done(&comm_ctx, result).await?; + + Ok(()) + } + + async fn exec_done( + &mut self, + comm_ctx: &CommContext, + result: ExecResult, + ) -> Result<(), AnyError> { + match result { + ExecResult::OkString(v) => { + println!("sending exec result"); + let msg = ReplyMessage::new( + comm_ctx, + "execute_reply".to_string(), + ReplyMetadata::Empty, + ReplyContent::ExecuteReply(ExecuteReplyContent { + status: "ok".to_string(), + execution_count: self.execution_count, + // TODO: "None" gets translated to "null" by serde_json + // payload: None, + // user_expressions: None, + }), + ); + self.shell_comm.send(msg).await?; + } + ExecResult::Error(e) => { + println!("Not implemented: sending exec ERROR"); + } + }; + + // TODO(apowers313) send(ExecuteResult) + + Ok(()) + } + + async fn send_stdio( + &mut self, + comm_ctx: &CommContext, + t: StdioType, + text: &String, + ) -> Result<(), AnyError> { + let content = StreamContent { + name: match t { + StdioType::Stdout => "stdout".to_string(), + StdioType::Stderr => "stderr".to_string(), }, - "help_links": [{ - "text": self.metadata.help_text, - "url": self.metadata.help_url - }], - "banner": self.metadata.banner, - "debugger": false - }) + text: text.clone(), + }; + + let msg = SideEffectMessage::new( + &comm_ctx, + "stream".to_string(), + ReplyMetadata::Empty, + ReplyContent::Stream(content), + ); + + self.iopub_comm.send(msg).await?; + + Ok(()) } - fn get_comm_info() -> Value { - json!({ - "status": "ok", - "comms": {} - }) + async fn fake_task( + &mut self, + comm_ctx: &CommContext, + arg: String, + ) -> Result { + for i in 0..6 { + sleep(Duration::from_millis(500)).await; + println!("ping! {}", &arg); + self + .send_stdio(comm_ctx, StdioType::Stdout, &format!("ping! {}\n", i)) + .await?; + } + + // TODO(apowers313) result should be any valid JavaScript value + Ok(ExecResult::OkString("fake result".to_string())) } } +enum ExecResult { + OkString(String), + // TODO(apowers313) + // OkValue(Value), + // OkDisplayData(DisplayDataContent), + Error(ExecError), +} + +struct ExecError { + err_name: String, + err_value: String, + stack_trace: Vec, +} + #[derive(Debug)] struct KernelMetadata { banner: String, @@ -419,7 +530,6 @@ struct KernelMetadata { language: String, mime: String, protocol_version: String, - session_id: String, } impl Default for KernelMetadata { @@ -438,7 +548,6 @@ impl Default for KernelMetadata { // FIXME: mime: "text/x.typescript".to_string(), protocol_version: "5.3".to_string(), - session_id: uuid::Uuid::new_v4().to_string(), } } } @@ -467,7 +576,9 @@ struct MessageHeader { msg_id: String, session: String, username: String, - date: String, + // TODO(apowers313) -- date as an Option is to address a Jupyter bug + // see also: https://github.com/jupyter/notebook/issues/6257 + date: Option, msg_type: String, version: String, } @@ -483,7 +594,7 @@ impl MessageHeader { session: session_id.clone(), // FIXME: username: "".to_string(), - date: now.to_string(), + date: Some(now.to_string()), msg_type, // TODO: this should be taken from a global, version: "5.3".to_string(), @@ -518,14 +629,20 @@ impl TryFrom for RequestMessage { type Error = AnyError; fn try_from(zmq_msg: ZmqMessage) -> Result { + // TODO(apowers313) make all unwraps recoverable errors let header_bytes = zmq_msg.get(2).unwrap(); let metadata_bytes = zmq_msg.get(4).unwrap(); let content_bytes = zmq_msg.get(5).unwrap(); let header: MessageHeader = serde_json::from_slice(header_bytes).unwrap(); + // TODO(apowers313) refactor to an unwrap function to handles unwrapping based on different protocol versions let mc = match header.msg_type.as_ref() { "kernel_info_request" => (RequestMetadata::Empty, RequestContent::Empty), + "execute_request" => ( + RequestMetadata::Empty, + RequestContent::Execute(serde_json::from_slice(content_bytes).unwrap()), + ), _ => (RequestMetadata::Empty, RequestContent::Empty), }; @@ -568,8 +685,14 @@ impl ReplyMessage { }; let content = match &self.content { ReplyContent::Empty => serde_json::to_string(&json!({})).unwrap(), + // reply messages ReplyContent::KernelInfo(c) => serde_json::to_string(&c).unwrap(), + ReplyContent::ExecuteReply(c) => serde_json::to_string(&c).unwrap(), + // side effects ReplyContent::Status(c) => serde_json::to_string(&c).unwrap(), + ReplyContent::Stream(c) => serde_json::to_string(&c).unwrap(), + ReplyContent::ExecuteInput(c) => serde_json::to_string(&c).unwrap(), + ReplyContent::ExecuteResult(c) => serde_json::to_string(&c).unwrap(), }; let hmac = @@ -816,6 +939,7 @@ fn hmac_sign_test() { #[derive(Debug, Serialize, Deserialize)] enum RequestContent { Empty, + Execute(ExecuteRequestContent), } #[derive(Debug, Serialize, Deserialize)] @@ -823,8 +947,12 @@ enum ReplyContent { Empty, // Reply Messages KernelInfo(KernelInfoReplyContent), + ExecuteReply(ExecuteReplyContent), // Side Effects Status(KernelStatusContent), + Stream(StreamContent), + ExecuteInput(ExecuteInputContent), + ExecuteResult(ExecuteResultContent), } #[derive(Debug, Serialize, Deserialize)] @@ -839,6 +967,7 @@ enum ReplyMetadata { } // https://jupyter-client.readthedocs.io/en/latest/messaging.html#execute +#[derive(Debug, Serialize, Deserialize)] struct ExecuteRequestContent { code: String, silent: bool, @@ -849,11 +978,13 @@ struct ExecuteRequestContent { } // https://jupyter-client.readthedocs.io/en/latest/messaging.html#execution-results +#[derive(Debug, Serialize, Deserialize)] struct ExecuteReplyContent { status: String, execution_count: u32, - payload: Option>, - user_expressions: Option, + // TODO: "None" gets translated to "null" + // payload: Option>, + // user_expressions: Option, } // https://jupyter-client.readthedocs.io/en/latest/messaging.html#introspection @@ -948,9 +1079,10 @@ struct KernelLanguageInfo { version: String, mimetype: String, file_extension: String, - pygments_lexer: Option, - codemirror_mode: Option, - nbconvert_exporter: Option, + // TODO: "None" gets translated to "null" + // pygments_lexer: Option, + // codemirror_mode: Option, + // nbconvert_exporter: Option, } // https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-info @@ -1033,11 +1165,17 @@ struct ErrorStatusContent { // } // https://jupyter-client.readthedocs.io/en/latest/messaging.html#streams-stdout-stderr-etc +#[derive(Debug, Serialize, Deserialize)] struct StreamContent { name: String, // "stdout" | "stderr" text: String, } +enum StdioType { + Stdout, + Stderr, +} + // https://jupyter-client.readthedocs.io/en/latest/messaging.html#display-data struct DisplayDataContent { data: Value, @@ -1049,12 +1187,14 @@ struct DisplayDataContent { // struct UpdateDisplayDataContent {} // same as DisplayDataContent // https://jupyter-client.readthedocs.io/en/latest/messaging.html#code-inputs +#[derive(Debug, Serialize, Deserialize)] struct ExecuteInputContent { code: String, execution_count: u32, } // https://jupyter-client.readthedocs.io/en/latest/messaging.html#id6 +#[derive(Debug, Serialize, Deserialize)] struct ExecuteResultContent { execution_count: u32, data: Option, From ed93486b1f891540bb40d5cd3394c4444b562e94 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Sun, 26 Dec 2021 01:00:49 +0100 Subject: [PATCH 023/115] lint & fmt --- cli/tools/jupyter.rs | 35 ++++++++++------------------------- 1 file changed, 10 insertions(+), 25 deletions(-) diff --git a/cli/tools/jupyter.rs b/cli/tools/jupyter.rs index 8b62889b2a62ef..002f47826499b1 100644 --- a/cli/tools/jupyter.rs +++ b/cli/tools/jupyter.rs @@ -192,7 +192,7 @@ impl Kernel { conn_spec.stdin_port, ), session_id.clone(), - hmac_key.clone(), + hmac_key, ); let hb_conn_str = @@ -299,7 +299,6 @@ impl Kernel { Ok(_) => {} Err(e) => { println!("error setting idle state: {}", e); - return; } }; } @@ -352,7 +351,7 @@ impl Kernel { }; let msg = SideEffectMessage::new( - &comm_ctx, + comm_ctx, "status".to_string(), ReplyMetadata::Empty, ReplyContent::Status(KernelStatusContent { execution_state: s }), @@ -401,7 +400,7 @@ impl Kernel { &mut self, comm_ctx: &CommContext, ) -> Result<(), AnyError> { - self.execution_count = self.execution_count + 1; + self.execution_count += 1; let exec_request_content = match &comm_ctx.message.content { RequestContent::Execute(c) => c, @@ -421,9 +420,9 @@ impl Kernel { // TODO(apowers313) it executes code... just not the code you requested :) // hook in the real REPL request to execute code here - let result = self.fake_task(&comm_ctx, "foo".to_string()).await?; + let result = self.fake_task(comm_ctx, "foo".to_string()).await?; - self.exec_done(&comm_ctx, result).await?; + self.exec_done(comm_ctx, result).await?; Ok(()) } @@ -464,18 +463,18 @@ impl Kernel { &mut self, comm_ctx: &CommContext, t: StdioType, - text: &String, + text: &str, ) -> Result<(), AnyError> { let content = StreamContent { name: match t { StdioType::Stdout => "stdout".to_string(), StdioType::Stderr => "stderr".to_string(), }, - text: text.clone(), + text: text.to_string(), }; let msg = SideEffectMessage::new( - &comm_ctx, + comm_ctx, "stream".to_string(), ReplyMetadata::Empty, ReplyContent::Stream(content), @@ -591,10 +590,10 @@ impl MessageHeader { Self { msg_id: uuid::Uuid::new_v4().to_string(), - session: session_id.clone(), + session: session_id, // FIXME: username: "".to_string(), - date: Some(now.to_string()), + date: Some(now), msg_type, // TODO: this should be taken from a global, version: "5.3".to_string(), @@ -824,20 +823,6 @@ fn create_conn_str(transport: &str, ip: &str, port: u32) -> String { format!("{}://{}:{}", transport, ip, port) } -fn parse_zmq_packet(data: &ZmqMessage) -> Result<(), AnyError> { - let _delim = data.get(0); - let _hmac = data.get(1); - let header = data.get(2).unwrap(); - let _parent_header = data.get(3); - let _metadata = data.get(4); - let _content = data.get(5); - - let header_str = std::str::from_utf8(header).unwrap(); - let header_value: MessageHeader = serde_json::from_str(header_str).unwrap(); - - Ok(()) -} - fn hmac_sign( key: &hmac::Key, header: &str, From f67bff76bd9ae7a232fb38d3a2494c6103832bac Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Sun, 26 Dec 2021 01:09:39 +0100 Subject: [PATCH 024/115] split into modules --- cli/tools/jupyter/install.rs | 70 ++++ cli/tools/jupyter/message_types.rs | 345 ++++++++++++++++++++ cli/tools/{jupyter.rs => jupyter/mod.rs} | 389 +---------------------- 3 files changed, 419 insertions(+), 385 deletions(-) create mode 100644 cli/tools/jupyter/install.rs create mode 100644 cli/tools/jupyter/message_types.rs rename cli/tools/{jupyter.rs => jupyter/mod.rs} (63%) diff --git a/cli/tools/jupyter/install.rs b/cli/tools/jupyter/install.rs new file mode 100644 index 00000000000000..536d2385566d38 --- /dev/null +++ b/cli/tools/jupyter/install.rs @@ -0,0 +1,70 @@ +// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license. + +use crate::flags::Flags; +use crate::flags::JupyterFlags; +use data_encoding::HEXLOWER; +use deno_core::anyhow::anyhow; +use deno_core::anyhow::Context; +use deno_core::error::generic_error; +use deno_core::error::AnyError; +use deno_core::serde::Deserialize; +use deno_core::serde::Serialize; +use deno_core::serde_json; +use deno_core::serde_json::json; +use deno_core::serde_json::Value; +use ring::hmac; +use std::collections::HashMap; +use std::env::current_exe; +use std::time::Duration; +use tempfile::TempDir; +use tokio::join; +use tokio::time::sleep; +use zeromq::prelude::*; +use zeromq::ZmqMessage; + +pub fn install() -> Result<(), AnyError> { + let temp_dir = TempDir::new().unwrap(); + let kernel_json_path = temp_dir.path().join("kernel.json"); + + // TODO(bartlomieju): add remaining fields as per + // https://jupyter-client.readthedocs.io/en/stable/kernels.html#kernel-specs + // FIXME(bartlomieju): replace `current_exe` + let json_data = json!({ + "argv": [current_exe().unwrap().to_string_lossy(), "jupyter", "--conn", "{connection_file}"], + "display_name": "Deno (Rust)", + "language": "typescript", + }); + + let f = std::fs::File::create(kernel_json_path)?; + serde_json::to_writer_pretty(f, &json_data)?; + + let child_result = std::process::Command::new("jupyter") + .args([ + "kernelspec", + "install", + "--name", + "rusty_deno", + &temp_dir.path().to_string_lossy(), + ]) + .spawn(); + + // TODO(bartlomieju): copy icons the the kernelspec directory + + if let Ok(mut child) = child_result { + let wait_result = child.wait(); + match wait_result { + Ok(status) => { + if !status.success() { + eprintln!("Failed to install kernelspec, try again."); + } + } + Err(err) => { + eprintln!("Failed to install kernelspec: {}", err); + } + } + } + + let _ = std::fs::remove_dir(temp_dir); + println!("Deno kernelspec installed successfully."); + Ok(()) +} diff --git a/cli/tools/jupyter/message_types.rs b/cli/tools/jupyter/message_types.rs new file mode 100644 index 00000000000000..050ebc97d4e8c0 --- /dev/null +++ b/cli/tools/jupyter/message_types.rs @@ -0,0 +1,345 @@ +// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license. + +use deno_core::serde::Deserialize; +use deno_core::serde::Serialize; +use deno_core::serde_json::Value; + +// /* ***************** +// * SHELL MESSAGES +// * *****************/ +// Shell Request Message Types +// "execute_request" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#execute +// "inspect_request" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#introspection +// "complete_request" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#completion +// "history_request" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#history +// "is_complete_request" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#code-completeness +// "comm_info_request" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#comm-info +// "kernel_info_request" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-info + +// Shell Reply Message Types +// "execute_reply" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#execution-results +// "inspect_reply" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#introspection +// "complete_reply" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#completion +// "history_reply" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#history +// "is_complete_reply" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#code-completeness +// "comm_info_reply" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#comm-info +// "kernel_info_reply" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-info + +#[derive(Debug, Serialize, Deserialize)] +pub enum RequestContent { + Empty, + Execute(ExecuteRequestContent), +} + +#[derive(Debug, Serialize, Deserialize)] +pub enum ReplyContent { + Empty, + // Reply Messages + KernelInfo(KernelInfoReplyContent), + ExecuteReply(ExecuteReplyContent), + // Side Effects + Status(KernelStatusContent), + Stream(StreamContent), + ExecuteInput(ExecuteInputContent), + ExecuteResult(ExecuteResultContent), +} + +#[derive(Debug, Serialize, Deserialize)] +pub enum RequestMetadata { + Empty, + Unknown(Value), +} + +#[derive(Debug, Serialize, Deserialize)] +pub enum ReplyMetadata { + Empty, +} + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#execute +#[derive(Debug, Serialize, Deserialize)] +pub struct ExecuteRequestContent { + pub code: String, + pub silent: bool, + pub store_history: bool, + pub user_expressions: Value, + pub allow_stdin: bool, + pub stop_on_error: bool, +} + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#execution-results +#[derive(Debug, Serialize, Deserialize)] +pub struct ExecuteReplyContent { + pub status: String, + pub execution_count: u32, + // TODO: "None" gets translated to "null" + // payload: Option>, + // user_expressions: Option, +} + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#introspection +pub struct InspectRequestContent { + pub code: String, + pub cursor_pos: u32, + pub detail_level: u8, // 0 = Low, 1 = High +} + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#introspection +pub struct InspectReplyContent { + pub status: String, + pub found: bool, + pub data: Option, + pub metadata: Option, +} + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#completion +pub struct CompleteRequestContent { + pub code: String, + pub cursor_pos: u32, +} + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#completion +pub struct CompleteReplyContent { + pub status: String, + pub matches: Option, + pub cursor_start: u32, + pub cursor_end: u32, + pub metadata: Option, +} + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#history +pub struct HistoryRequestContent { + pub output: bool, + pub raw: bool, + pub hist_access_type: String, // "range" | "tail" | "search" + pub session: u32, + pub start: u32, + pub stop: u32, + pub n: u32, +} + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#history +pub struct HistoryReplyContent { + pub status: String, + pub history: Option, +} + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#code-completeness +pub struct CodeCompleteRequestContent { + pub code: String, +} + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#code-completeness +pub struct CodeCompleteReplyContent { + pub status: String, // "complete" | "incomplete" | "invalid" | "unknown" + pub indent: String, +} + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#comm-info +pub struct CommInfoRequestContent { + pub target_name: String, +} + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#comm-info +pub struct CommInfoReplyContent { + pub status: String, + pub comms: Option, +} + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-info +// pub struct KernelInfoRequest {} // empty + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-info +#[derive(Debug, Serialize, Deserialize)] +pub struct KernelInfoReplyContent { + pub status: String, + pub protocol_version: String, + pub implementation: String, + pub implementation_version: String, + pub language_info: KernelLanguageInfo, + pub banner: String, + pub debugger: bool, + pub help_links: Vec, +} + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-info +#[derive(Debug, Serialize, Deserialize)] +pub struct KernelLanguageInfo { + pub name: String, + pub version: String, + pub mimetype: String, + pub file_extension: String, + // TODO: "None" gets translated to "null" + // pygments_lexer: Option, + // codemirror_mode: Option, + // nbconvert_exporter: Option, +} + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-info +#[derive(Debug, Serialize, Deserialize)] +pub struct KernelHelpLink { + pub text: String, + pub url: String, +} + +/* ***************** + * CONTROL MESSAGES + * *****************/ + +// Control Request Message Types +// "shutdown_request" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-shutdown +// "interrupt_request" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-interrupt +// "debug_request" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#debug-request + +// Control Reply Message Types +// "shutdown_reply" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-shutdown +// "interrupt_reply" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-interrupt +// "debug_reply" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#debug-request + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-shutdown +pub struct ShutdownRequestContent { + pub restart: bool, +} + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-shutdown +pub struct ShutdownReplyContent { + pub status: String, + pub restart: bool, +} + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-interrupt +// pub struct InterruptRequestContent {} // empty + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-interrupt +pub struct InterruptReplyContent { + pub status: String, +} + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#debug-request +// pub struct DebugRequestContent {} // See Debug Adapter Protocol (DAP) 1.39 or later + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#debug-request +// pub struct DebugReplyContent {} // See Debug Adapter Protocol (DAP) 1.39 or later + +/* ***************** + * IOPUB MESSAGES + * *****************/ + +// Io Pub Message Types +// "stream" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#streams-stdout-stderr-etc +// "display_data" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#display-data +// "update_display_data" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#update-display-data +// "execute_input" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#code-inputs +// "execute_result" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#id6 +// "error" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#execution-errors +// "status" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-status +// "clear_output" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#clear-output +// "debug_event" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#debug-event +// "comm_open" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#opening-a-comm +// "comm_msg" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#comm-messages +// "comm_close" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#tearing-down-comms + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#request-reply +pub struct ErrorStatusContent { + pub status: String, // "error" + pub ename: String, + pub evalue: String, + pub traceback: Vec, + pub execution_count: Option, +} + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#request-reply +// #[derive(Debug, Serialize, Deserialize)] +// pub struct StatusContent { +// status: String, // "ok" | "abort" +// } + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#streams-stdout-stderr-etc +#[derive(Debug, Serialize, Deserialize)] +pub struct StreamContent { + pub name: String, // "stdout" | "stderr" + pub text: String, +} + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#display-data +pub struct DisplayDataContent { + pub data: Value, + pub metadata: Option, + pub transient: Option, +} + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#update-display-data +// pub struct UpdateDisplayDataContent {} // same as DisplayDataContent + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#code-inputs +#[derive(Debug, Serialize, Deserialize)] +pub struct ExecuteInputContent { + pub code: String, + pub execution_count: u32, +} + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#id6 +#[derive(Debug, Serialize, Deserialize)] +pub struct ExecuteResultContent { + pub execution_count: u32, + pub data: Option, + pub metadata: Option, +} + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#execution-errors +pub struct ErrorContent { + pub payload: Option>, + pub user_expressions: Option, +} + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-status +#[derive(Debug, Serialize, Deserialize)] +pub struct KernelStatusContent { + pub execution_state: String, // "busy" | "idle" | "starting" +} + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#clear-output +pub struct ClearOutputContent { + pub wait: bool, +} + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#debug-event +// pub struct DebugEventContent {} // see Event message from the Debug Adapter Protocol (DAP) + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#opening-a-comm +pub struct CommOpenMessage { + pub comm_id: uuid::Uuid, + pub target_name: String, + pub data: Option, +} + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#comm-messages +pub struct CommMsgMessage { + pub comm_id: uuid::Uuid, + pub data: Option, +} + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#comm-messages +pub struct CommCloseMessage { + pub comm_id: uuid::Uuid, + pub data: Option, +} + +/* ***************** + * STDIN MESSAGES + * *****************/ +// Stdin Request Message Types +// "input_request" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#messages-on-the-stdin-router-dealer-channel + +// Stdin Reply Message Types +// "input_reply" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#messages-on-the-stdin-router-dealer-channel + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#messages-on-the-stdin-router-dealer-channel +pub struct InputRequestContent { + pub prompt: String, + pub password: bool, +} + +// https://jupyter-client.readthedocs.io/en/latest/messaging.html#messages-on-the-stdin-router-dealer-channel +pub struct InputReplyContent { + pub value: String, +} diff --git a/cli/tools/jupyter.rs b/cli/tools/jupyter/mod.rs similarity index 63% rename from cli/tools/jupyter.rs rename to cli/tools/jupyter/mod.rs index 002f47826499b1..555534a712848a 100644 --- a/cli/tools/jupyter.rs +++ b/cli/tools/jupyter/mod.rs @@ -27,52 +27,11 @@ use zeromq::ZmqMessage; const DELIMITER: &str = ""; -pub fn install() -> Result<(), AnyError> { - let temp_dir = TempDir::new().unwrap(); - let kernel_json_path = temp_dir.path().join("kernel.json"); - - // TODO(bartlomieju): add remaining fields as per - // https://jupyter-client.readthedocs.io/en/stable/kernels.html#kernel-specs - // FIXME(bartlomieju): replace `current_exe` - let json_data = json!({ - "argv": [current_exe().unwrap().to_string_lossy(), "jupyter", "--conn", "{connection_file}"], - "display_name": "Deno (Rust)", - "language": "typescript", - }); - - let f = std::fs::File::create(kernel_json_path)?; - serde_json::to_writer_pretty(f, &json_data)?; - - let child_result = std::process::Command::new("jupyter") - .args([ - "kernelspec", - "install", - "--name", - "rusty_deno", - &temp_dir.path().to_string_lossy(), - ]) - .spawn(); - - // TODO(bartlomieju): copy icons the the kernelspec directory - - if let Ok(mut child) = child_result { - let wait_result = child.wait(); - match wait_result { - Ok(status) => { - if !status.success() { - eprintln!("Failed to install kernelspec, try again."); - } - } - Err(err) => { - eprintln!("Failed to install kernelspec: {}", err); - } - } - } +mod install; +mod message_types; - let _ = std::fs::remove_dir(temp_dir); - println!("Deno kernelspec installed successfully."); - Ok(()) -} +pub use install::install; +use message_types::*; pub async fn kernel( _flags: Flags, @@ -899,347 +858,7 @@ fn hmac_sign_test() { ); } -// /* ***************** -// * SHELL MESSAGES -// * *****************/ -// Shell Request Message Types -// "execute_request" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#execute -// "inspect_request" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#introspection -// "complete_request" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#completion -// "history_request" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#history -// "is_complete_request" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#code-completeness -// "comm_info_request" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#comm-info -// "kernel_info_request" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-info - -// Shell Reply Message Types -// "execute_reply" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#execution-results -// "inspect_reply" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#introspection -// "complete_reply" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#completion -// "history_reply" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#history -// "is_complete_reply" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#code-completeness -// "comm_info_reply" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#comm-info -// "kernel_info_reply" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-info - -#[derive(Debug, Serialize, Deserialize)] -enum RequestContent { - Empty, - Execute(ExecuteRequestContent), -} - -#[derive(Debug, Serialize, Deserialize)] -enum ReplyContent { - Empty, - // Reply Messages - KernelInfo(KernelInfoReplyContent), - ExecuteReply(ExecuteReplyContent), - // Side Effects - Status(KernelStatusContent), - Stream(StreamContent), - ExecuteInput(ExecuteInputContent), - ExecuteResult(ExecuteResultContent), -} - -#[derive(Debug, Serialize, Deserialize)] -enum RequestMetadata { - Empty, - Unknown(Value), -} - -#[derive(Debug, Serialize, Deserialize)] -enum ReplyMetadata { - Empty, -} - -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#execute -#[derive(Debug, Serialize, Deserialize)] -struct ExecuteRequestContent { - code: String, - silent: bool, - store_history: bool, - user_expressions: Value, - allow_stdin: bool, - stop_on_error: bool, -} - -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#execution-results -#[derive(Debug, Serialize, Deserialize)] -struct ExecuteReplyContent { - status: String, - execution_count: u32, - // TODO: "None" gets translated to "null" - // payload: Option>, - // user_expressions: Option, -} - -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#introspection -struct InspectRequestContent { - code: String, - cursor_pos: u32, - detail_level: u8, // 0 = Low, 1 = High -} - -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#introspection -struct InspectReplyContent { - status: String, - found: bool, - data: Option, - metadata: Option, -} - -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#completion -struct CompleteRequestContent { - code: String, - cursor_pos: u32, -} - -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#completion -struct CompleteReplyContent { - status: String, - matches: Option, - cursor_start: u32, - cursor_end: u32, - metadata: Option, -} - -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#history -struct HistoryRequestContent { - output: bool, - raw: bool, - hist_access_type: String, // "range" | "tail" | "search" - session: u32, - start: u32, - stop: u32, - n: u32, -} - -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#history -struct HistoryReplyContent { - status: String, - history: Option, -} - -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#code-completeness -struct CodeCompleteRequestContent { - code: String, -} - -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#code-completeness -struct CodeCompleteReplyContent { - status: String, // "complete" | "incomplete" | "invalid" | "unknown" - indent: String, -} - -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#comm-info -struct CommInfoRequestContent { - target_name: String, -} - -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#comm-info -struct CommInfoReplyContent { - status: String, - comms: Option, -} - -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-info -// struct KernelInfoRequest {} // empty - -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-info -#[derive(Debug, Serialize, Deserialize)] -struct KernelInfoReplyContent { - status: String, - protocol_version: String, - implementation: String, - implementation_version: String, - language_info: KernelLanguageInfo, - banner: String, - debugger: bool, - help_links: Vec, -} - -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-info -#[derive(Debug, Serialize, Deserialize)] -struct KernelLanguageInfo { - name: String, - version: String, - mimetype: String, - file_extension: String, - // TODO: "None" gets translated to "null" - // pygments_lexer: Option, - // codemirror_mode: Option, - // nbconvert_exporter: Option, -} - -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-info -#[derive(Debug, Serialize, Deserialize)] -struct KernelHelpLink { - text: String, - url: String, -} - -/* ***************** - * CONTROL MESSAGES - * *****************/ - -// Control Request Message Types -// "shutdown_request" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-shutdown -// "interrupt_request" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-interrupt -// "debug_request" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#debug-request - -// Control Reply Message Types -// "shutdown_reply" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-shutdown -// "interrupt_reply" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-interrupt -// "debug_reply" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#debug-request - -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-shutdown -struct ShutdownRequestContent { - restart: bool, -} - -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-shutdown -struct ShutdownReplyContent { - status: String, - restart: bool, -} - -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-interrupt -// struct InterruptRequestContent {} // empty - -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-interrupt -struct InterruptReplyContent { - status: String, -} - -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#debug-request -// struct DebugRequestContent {} // See Debug Adapter Protocol (DAP) 1.39 or later - -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#debug-request -// struct DebugReplyContent {} // See Debug Adapter Protocol (DAP) 1.39 or later - -/* ***************** - * IOPUB MESSAGES - * *****************/ - -// Io Pub Message Types -// "stream" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#streams-stdout-stderr-etc -// "display_data" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#display-data -// "update_display_data" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#update-display-data -// "execute_input" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#code-inputs -// "execute_result" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#id6 -// "error" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#execution-errors -// "status" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-status -// "clear_output" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#clear-output -// "debug_event" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#debug-event -// "comm_open" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#opening-a-comm -// "comm_msg" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#comm-messages -// "comm_close" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#tearing-down-comms - -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#request-reply -struct ErrorStatusContent { - status: String, // "error" - ename: String, - evalue: String, - traceback: Vec, - execution_count: Option, -} - -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#request-reply -// #[derive(Debug, Serialize, Deserialize)] -// struct StatusContent { -// status: String, // "ok" | "abort" -// } - -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#streams-stdout-stderr-etc -#[derive(Debug, Serialize, Deserialize)] -struct StreamContent { - name: String, // "stdout" | "stderr" - text: String, -} - enum StdioType { Stdout, Stderr, } - -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#display-data -struct DisplayDataContent { - data: Value, - metadata: Option, - transient: Option, -} - -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#update-display-data -// struct UpdateDisplayDataContent {} // same as DisplayDataContent - -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#code-inputs -#[derive(Debug, Serialize, Deserialize)] -struct ExecuteInputContent { - code: String, - execution_count: u32, -} - -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#id6 -#[derive(Debug, Serialize, Deserialize)] -struct ExecuteResultContent { - execution_count: u32, - data: Option, - metadata: Option, -} - -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#execution-errors -struct ErrorContent { - payload: Option>, - user_expressions: Option, -} - -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-status -#[derive(Debug, Serialize, Deserialize)] -struct KernelStatusContent { - execution_state: String, // "busy" | "idle" | "starting" -} - -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#clear-output -struct ClearOutputContent { - wait: bool, -} - -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#debug-event -// struct DebugEventContent {} // see Event message from the Debug Adapter Protocol (DAP) - -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#opening-a-comm -struct CommOpenMessage { - comm_id: uuid::Uuid, - target_name: String, - data: Option, -} - -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#comm-messages -struct CommMsgMessage { - comm_id: uuid::Uuid, - data: Option, -} - -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#comm-messages -struct CommCloseMessage { - comm_id: uuid::Uuid, - data: Option, -} - -/* ***************** - * STDIN MESSAGES - * *****************/ -// Stdin Request Message Types -// "input_request" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#messages-on-the-stdin-router-dealer-channel - -// Stdin Reply Message Types -// "input_reply" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#messages-on-the-stdin-router-dealer-channel - -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#messages-on-the-stdin-router-dealer-channel -struct InputRequestContent { - prompt: String, - password: bool, -} - -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#messages-on-the-stdin-router-dealer-channel -struct InputReplyContent { - value: String, -} From 6ec3e40f70f0e2aea48920bbf7cfc8a32f28b18c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Sun, 26 Dec 2021 01:39:11 +0100 Subject: [PATCH 025/115] code execution, use forked zmq.rs --- Cargo.lock | 3 +-- cli/Cargo.toml | 2 +- cli/main.rs | 6 ++++- cli/tools/jupyter/mod.rs | 49 ++++++++++++++++++++++++++++++++-------- cli/tools/repl/mod.rs | 4 ++-- 5 files changed, 49 insertions(+), 15 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index c7564c1aa7ad6e..763fa41adf5b6d 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -5149,8 +5149,7 @@ dependencies = [ [[package]] name = "zeromq" version = "0.3.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c376a1982922614fda01ef046cc076503681d8f9b1b3135e85b367e5d8719246" +source = "git+https://github.com/bartlomieju/zmq.rs?branch=master#d92c2b5ce2b3d787abcbc56d6ae94e1a9a04e216" dependencies = [ "async-trait", "asynchronous-codec", diff --git a/cli/Cargo.toml b/cli/Cargo.toml index 42c465d69f6527..fca2617468429e 100644 --- a/cli/Cargo.toml +++ b/cli/Cargo.toml @@ -85,7 +85,7 @@ text-size = "=1.1.0" tokio = { version = "=1.14", features = ["full"] } uuid = { version = "=0.8.2", features = ["v4", "serde"] } walkdir = "=2.3.2" -zeromq = { version = "0.3.1", default-features = false, features = ["tcp-transport", "tokio-runtime"] } +zeromq = { version = "0.3.1", default-features = false, features = ["tcp-transport", "tokio-runtime"], git = "https://github.com/bartlomieju/zmq.rs", branch = "master" } [target.'cfg(windows)'.dependencies] fwdansi = "=1.1.0" diff --git a/cli/main.rs b/cli/main.rs index 07edc6c93fa56e..1522eccca654b3 100644 --- a/cli/main.rs +++ b/cli/main.rs @@ -562,7 +562,11 @@ async fn jupyter_command( return Ok(0); } - tools::jupyter::kernel(flags, jupyter_flags).await?; + let main_module = resolve_url_or_path("./$deno$repl.ts").unwrap(); + let permissions = Permissions::from_options(&flags.clone().into()); + let ps = ProcState::build(flags.clone()).await?; + let worker = create_main_worker(&ps, main_module.clone(), permissions, None); + tools::jupyter::kernel(flags, jupyter_flags, worker).await?; Ok(0) } diff --git a/cli/tools/jupyter/mod.rs b/cli/tools/jupyter/mod.rs index 555534a712848a..f392277efc1553 100644 --- a/cli/tools/jupyter/mod.rs +++ b/cli/tools/jupyter/mod.rs @@ -5,6 +5,8 @@ use crate::flags::Flags; use crate::flags::JupyterFlags; +use crate::tools::repl::EvaluationOutput; +use crate::tools::repl::ReplSession; use data_encoding::HEXLOWER; use deno_core::anyhow::anyhow; use deno_core::anyhow::Context; @@ -15,6 +17,7 @@ use deno_core::serde::Serialize; use deno_core::serde_json; use deno_core::serde_json::json; use deno_core::serde_json::Value; +use deno_runtime::worker::MainWorker; use ring::hmac; use std::collections::HashMap; use std::env::current_exe; @@ -36,6 +39,7 @@ use message_types::*; pub async fn kernel( _flags: Flags, jupyter_flags: JupyterFlags, + worker: MainWorker, ) -> Result<(), AnyError> { if jupyter_flags.conn_file.is_none() { return Err(generic_error("Missing --conn flag")); @@ -43,7 +47,8 @@ pub async fn kernel( let conn_file_path = jupyter_flags.conn_file.unwrap(); - let mut kernel = Kernel::new(conn_file_path.to_str().unwrap()); + let repl_session = ReplSession::initialize(worker).await?; + let mut kernel = Kernel::new(conn_file_path.to_str().unwrap(), repl_session); println!("[DENO] kernel created: {:#?}", kernel.session_id); println!("running kernel..."); @@ -80,6 +85,7 @@ struct Kernel { stdin_comm: DealerComm, session_id: String, execution_count: u32, + repl_session: ReplSession, } enum HandlerType { @@ -89,7 +95,7 @@ enum HandlerType { } impl Kernel { - fn new(conn_file_path: &str) -> Self { + fn new(conn_file_path: &str, repl_session: ReplSession) -> Self { let conn_file = match std::fs::read_to_string(conn_file_path) .context("Failed to read connection file") { @@ -157,7 +163,7 @@ impl Kernel { let hb_conn_str = create_conn_str(&conn_spec.transport, &conn_spec.ip, conn_spec.hb_port); - let s: Kernel = Self { + let kernel = Self { metadata, conn_spec, state: KernelState::Idle, @@ -167,9 +173,10 @@ impl Kernel { stdin_comm, session_id, execution_count, + repl_session, }; - s + kernel } async fn run(&mut self) -> Result<(), AnyError> { @@ -377,10 +384,18 @@ impl Kernel { ); self.iopub_comm.send(input_msg).await?; - // TODO(apowers313) it executes code... just not the code you requested :) - // hook in the real REPL request to execute code here - let result = self.fake_task(comm_ctx, "foo".to_string()).await?; - + let output = self + .repl_session + .evaluate_line_and_get_output(&exec_request_content.code) + .await?; + let result = match output { + EvaluationOutput::Value(value_str) => ExecResult::OkString(value_str), + EvaluationOutput::Error(value_str) => ExecResult::Error(ExecError { + err_name: "".to_string(), + err_value: value_str, + stack_trace: vec![], + }), + }; self.exec_done(comm_ctx, result).await?; Ok(()) @@ -391,7 +406,7 @@ impl Kernel { comm_ctx: &CommContext, result: ExecResult, ) -> Result<(), AnyError> { - match result { + match &result { ExecResult::OkString(v) => { println!("sending exec result"); let msg = ReplyMessage::new( @@ -414,6 +429,22 @@ impl Kernel { }; // TODO(apowers313) send(ExecuteResult) + let msg = SideEffectMessage::new( + comm_ctx, + "execute_result".to_string(), + ReplyMetadata::Empty, + ReplyContent::ExecuteResult(ExecuteResultContent { + execution_count: self.execution_count, + data: Some(json!({ + "text/plain": match result { + ExecResult::OkString(v) => v, + ExecResult::Error(v) => v.err_value, + } + })), + metadata: None, + }), + ); + self.iopub_comm.send(msg).await?; Ok(()) } diff --git a/cli/tools/repl/mod.rs b/cli/tools/repl/mod.rs index 4c8eec87a4f976..f49f7cc3b5ba11 100644 --- a/cli/tools/repl/mod.rs +++ b/cli/tools/repl/mod.rs @@ -15,8 +15,8 @@ use channel::RustylineSyncMessageHandler; use channel::RustylineSyncResponse; use editor::EditorHelper; use editor::ReplEditor; -use session::EvaluationOutput; -use session::ReplSession; +pub use session::EvaluationOutput; +pub use session::ReplSession; async fn read_line_and_poll( repl_session: &mut ReplSession, From 099e69c9500823b5e70e949c8defdbc05a8646bf Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Sun, 26 Dec 2021 01:41:17 +0100 Subject: [PATCH 026/115] lint --- cli/tools/jupyter/mod.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cli/tools/jupyter/mod.rs b/cli/tools/jupyter/mod.rs index f392277efc1553..bbaa0e50440f55 100644 --- a/cli/tools/jupyter/mod.rs +++ b/cli/tools/jupyter/mod.rs @@ -163,7 +163,7 @@ impl Kernel { let hb_conn_str = create_conn_str(&conn_spec.transport, &conn_spec.ip, conn_spec.hb_port); - let kernel = Self { + let kernel: Kernel = Self { metadata, conn_spec, state: KernelState::Idle, From 93da7b0bcd11d156c481cfcbfe6f0f68ec5f6080 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Sun, 26 Dec 2021 01:51:45 +0100 Subject: [PATCH 027/115] comm module --- cli/tools/jupyter/comm.rs | 145 +++++++++++++ cli/tools/jupyter/message_types.rs | 246 +++++++++++++++++++++ cli/tools/jupyter/mod.rs | 337 +---------------------------- 3 files changed, 395 insertions(+), 333 deletions(-) create mode 100644 cli/tools/jupyter/comm.rs diff --git a/cli/tools/jupyter/comm.rs b/cli/tools/jupyter/comm.rs new file mode 100644 index 00000000000000..1f2257b223e13a --- /dev/null +++ b/cli/tools/jupyter/comm.rs @@ -0,0 +1,145 @@ +// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license. + +// TODO(bartlomieju): remove me +#![allow(unused)] + +use crate::flags::Flags; +use crate::flags::JupyterFlags; +use crate::tools::repl::EvaluationOutput; +use crate::tools::repl::ReplSession; +use data_encoding::HEXLOWER; +use deno_core::anyhow::anyhow; +use deno_core::anyhow::Context; +use deno_core::error::generic_error; +use deno_core::error::AnyError; +use deno_core::serde::Deserialize; +use deno_core::serde::Serialize; +use deno_core::serde_json; +use deno_core::serde_json::json; +use deno_core::serde_json::Value; +use deno_runtime::worker::MainWorker; +use ring::hmac; +use std::collections::HashMap; +use std::env::current_exe; +use std::time::Duration; +use tempfile::TempDir; +use tokio::join; +use tokio::time::sleep; +use zeromq::prelude::*; +use zeromq::ZmqMessage; + +use super::hmac_verify; +use super::ReplyMessage; +use super::RequestMessage; +use super::SideEffectMessage; + +pub struct PubComm { + conn_str: String, + session_id: String, + hmac_key: hmac::Key, + socket: zeromq::PubSocket, +} + +// TODO(apowers313) connect and send look like traits shared with DealerComm +impl PubComm { + pub fn new( + conn_str: String, + session_id: String, + hmac_key: hmac::Key, + ) -> Self { + println!("iopub connection: {}", conn_str); + Self { + conn_str, + session_id, + hmac_key, + socket: zeromq::PubSocket::new(), + } + } + + pub async fn connect(&mut self) -> Result<(), AnyError> { + self.socket.bind(&self.conn_str).await?; + + Ok(()) + } + + pub async fn send(&mut self, msg: SideEffectMessage) -> Result<(), AnyError> { + let zmq_msg = msg.serialize(&self.hmac_key); + println!(">>> ZMQ SENDING: {:#?}", zmq_msg); + self.socket.send(zmq_msg).await?; + Ok(()) + } +} + +pub struct DealerComm { + name: String, + conn_str: String, + session_id: String, + hmac_key: hmac::Key, + socket: zeromq::DealerSocket, +} + +impl DealerComm { + pub fn new( + name: &str, + conn_str: String, + session_id: String, + hmac_key: hmac::Key, + ) -> Self { + println!("dealer '{}' connection: {}", name, conn_str); + Self { + name: name.to_string(), + conn_str, + session_id, + hmac_key, + socket: zeromq::DealerSocket::new(), + } + } + + pub async fn connect(&mut self) -> Result<(), AnyError> { + self.socket.bind(&self.conn_str).await?; + + Ok(()) + } + + pub async fn recv(&mut self) -> Result { + let zmq_msg = self.socket.recv().await?; + println!("<<< ZMQ RECEIVING: {:#?}", zmq_msg); + + hmac_verify( + &self.hmac_key, + zmq_msg.get(1).unwrap(), + zmq_msg.get(2).unwrap(), + zmq_msg.get(3).unwrap(), + zmq_msg.get(4).unwrap(), + zmq_msg.get(5).unwrap(), + )?; + + let jup_msg = RequestMessage::try_from(zmq_msg)?; + + Ok(jup_msg) + } + + pub async fn send(&mut self, msg: ReplyMessage) -> Result<(), AnyError> { + let zmq_msg = msg.serialize(&self.hmac_key); + println!(">>> ZMQ SENDING: {:#?}", zmq_msg); + self.socket.send(zmq_msg).await?; + Ok(()) + } +} + +// TODO(apowers313) this is the heartbeat loop now +pub async fn create_zmq_reply( + name: &str, + conn_str: &str, +) -> Result<(), AnyError> { + println!("reply '{}' connection string: {}", name, conn_str); + + let mut sock = zeromq::RepSocket::new(); // TODO(apowers313) exact same as dealer, refactor + sock.monitor(); + sock.bind(conn_str).await?; + + loop { + let msg = sock.recv().await?; + println!("*** '{}' got packet!", name); + } +} diff --git a/cli/tools/jupyter/message_types.rs b/cli/tools/jupyter/message_types.rs index 050ebc97d4e8c0..6f255ec4505ff4 100644 --- a/cli/tools/jupyter/message_types.rs +++ b/cli/tools/jupyter/message_types.rs @@ -1,8 +1,178 @@ // Copyright 2018-2021 the Deno authors. All rights reserved. MIT license. +use crate::flags::Flags; +use crate::flags::JupyterFlags; +use crate::tools::repl::EvaluationOutput; +use crate::tools::repl::ReplSession; +use data_encoding::HEXLOWER; +use deno_core::anyhow::anyhow; +use deno_core::anyhow::Context; +use deno_core::error::generic_error; +use deno_core::error::AnyError; use deno_core::serde::Deserialize; use deno_core::serde::Serialize; +use deno_core::serde_json; +use deno_core::serde_json::json; use deno_core::serde_json::Value; +use deno_runtime::worker::MainWorker; +use ring::hmac; +use std::collections::HashMap; +use std::env::current_exe; +use std::time::Duration; +use tempfile::TempDir; +use tokio::join; +use tokio::time::sleep; +use zeromq::prelude::*; +use zeromq::ZmqMessage; + +const DELIMITER: &str = ""; + +#[derive(Debug)] +pub struct RequestMessage { + pub header: MessageHeader, + pub parent_header: Option<()>, + pub metadata: RequestMetadata, + pub content: RequestContent, +} + +impl RequestMessage { + pub fn new( + header: MessageHeader, + metadata: RequestMetadata, + content: RequestContent, + ) -> Self { + Self { + header, + parent_header: None, + metadata, + content, + } + } +} + +impl TryFrom for RequestMessage { + type Error = AnyError; + + fn try_from(zmq_msg: ZmqMessage) -> Result { + // TODO(apowers313) make all unwraps recoverable errors + let header_bytes = zmq_msg.get(2).unwrap(); + let metadata_bytes = zmq_msg.get(4).unwrap(); + let content_bytes = zmq_msg.get(5).unwrap(); + + let header: MessageHeader = serde_json::from_slice(header_bytes).unwrap(); + + // TODO(apowers313) refactor to an unwrap function to handles unwrapping based on different protocol versions + let mc = match header.msg_type.as_ref() { + "kernel_info_request" => (RequestMetadata::Empty, RequestContent::Empty), + "execute_request" => ( + RequestMetadata::Empty, + RequestContent::Execute(serde_json::from_slice(content_bytes).unwrap()), + ), + _ => (RequestMetadata::Empty, RequestContent::Empty), + }; + + let rm = RequestMessage::new(header, mc.0, mc.1); + println!("<== RECEIVING: {:#?}", rm); + + Ok(rm) + } +} + +pub struct ReplyMessage { + pub header: MessageHeader, + pub parent_header: MessageHeader, + pub metadata: ReplyMetadata, + pub content: ReplyContent, +} + +impl ReplyMessage { + pub fn new( + comm_ctx: &CommContext, + msg_type: String, + metadata: ReplyMetadata, + content: ReplyContent, + ) -> Self { + Self { + header: MessageHeader::new(msg_type, comm_ctx.session_id.clone()), + parent_header: comm_ctx.message.header.clone(), + metadata, + content, + } + } + + pub fn serialize(&self, hmac_key: &hmac::Key) -> ZmqMessage { + // TODO(apowers313) convert unwrap() to recoverable error + let header = serde_json::to_string(&self.header).unwrap(); + let parent_header = serde_json::to_string(&self.parent_header).unwrap(); + let metadata = serde_json::to_string(&self.metadata).unwrap(); + let metadata = match &self.metadata { + ReplyMetadata::Empty => serde_json::to_string(&json!({})).unwrap(), + }; + let content = match &self.content { + ReplyContent::Empty => serde_json::to_string(&json!({})).unwrap(), + // reply messages + ReplyContent::KernelInfo(c) => serde_json::to_string(&c).unwrap(), + ReplyContent::ExecuteReply(c) => serde_json::to_string(&c).unwrap(), + // side effects + ReplyContent::Status(c) => serde_json::to_string(&c).unwrap(), + ReplyContent::Stream(c) => serde_json::to_string(&c).unwrap(), + ReplyContent::ExecuteInput(c) => serde_json::to_string(&c).unwrap(), + ReplyContent::ExecuteResult(c) => serde_json::to_string(&c).unwrap(), + }; + + let hmac = + hmac_sign(hmac_key, &header, &parent_header, &metadata, &content); + + let mut zmq_msg = ZmqMessage::from(DELIMITER); + zmq_msg.push_back(hmac.into()); + zmq_msg.push_back(header.into()); + zmq_msg.push_back(parent_header.into()); + zmq_msg.push_back(metadata.into()); + zmq_msg.push_back(content.into()); + println!("==> SENDING ZMQ MSG: {:#?}", zmq_msg); + zmq_msg + } +} + +// side effects messages sent on IOPub look lik ReplyMessages (for now?) +pub type SideEffectMessage = ReplyMessage; + +#[derive(Debug)] +pub struct CommContext { + pub message: RequestMessage, + pub session_id: String, +} + +#[derive(Debug, Deserialize, Serialize, Clone)] +pub struct MessageHeader { + pub msg_id: String, + pub session: String, + pub username: String, + // TODO(apowers313) -- date as an Option is to address a Jupyter bug + // see also: https://github.com/jupyter/notebook/issues/6257 + pub date: Option, + pub msg_type: String, + pub version: String, +} + +impl MessageHeader { + pub fn new(msg_type: String, session_id: String) -> Self { + let now = std::time::SystemTime::now(); + let now: chrono::DateTime = now.into(); + let now = now.to_rfc3339(); + + Self { + msg_id: uuid::Uuid::new_v4().to_string(), + session: session_id, + // FIXME: + username: "".to_string(), + date: Some(now), + msg_type, + // TODO: this should be taken from a global, + version: "5.3".to_string(), + } + } +} // /* ***************** // * SHELL MESSAGES @@ -343,3 +513,79 @@ pub struct InputRequestContent { pub struct InputReplyContent { pub value: String, } + +fn hmac_sign( + key: &hmac::Key, + header: &str, + parent_header: &str, + metadata: &str, + content: &str, +) -> String { + let mut hmac_ctx = hmac::Context::with_key(key); + hmac_ctx.update(header.as_bytes()); + hmac_ctx.update(parent_header.as_bytes()); + hmac_ctx.update(metadata.as_bytes()); + hmac_ctx.update(content.as_bytes()); + let tag = hmac_ctx.sign(); + let sig = HEXLOWER.encode(tag.as_ref()); + sig +} + +pub fn hmac_verify( + key: &hmac::Key, + expected_signature: &[u8], + header: &[u8], + parent_header: &[u8], + metadata: &[u8], + content: &[u8], +) -> Result<(), AnyError> { + let mut msg = Vec::::new(); + msg.extend(header); + msg.extend(parent_header); + msg.extend(metadata); + msg.extend(content); + let sig = HEXLOWER.decode(expected_signature)?; + hmac::verify(key, msg.as_ref(), sig.as_ref())?; + Ok(()) +} + +#[test] +fn hmac_verify_test() { + let key_value = "1f5cec86-8eaa942eef7f5a35b51ddcf5"; + let key = hmac::Key::new(hmac::HMAC_SHA256, key_value.as_ref()); + + let expected_signature = + "43a5c45062e0b6bcc59c727f90165ad1d2eb02e1c5317aa25c2c2049d96d3b6a" + .as_bytes() + .to_vec(); + let header = "{\"msg_id\":\"c0fd20872c1b4d1c87e7fc814b75c93e_0\",\"msg_type\":\"kernel_info_request\",\"username\":\"ampower\",\"session\":\"c0fd20872c1b4d1c87e7fc814b75c93e\",\"date\":\"2021-12-10T06:20:40.259695Z\",\"version\":\"5.3\"}".as_bytes().to_vec(); + let parent_header = "{}".as_bytes().to_vec(); + let metadata = "{}".as_bytes().to_vec(); + let content = "{}".as_bytes().to_vec(); + + let result = hmac_verify( + &key, + &expected_signature, + &header, + &parent_header, + &metadata, + &content, + ); + + assert!(result.is_ok(), "signature validation failed"); +} + +#[test] +fn hmac_sign_test() { + let key_value = "1f5cec86-8eaa942eef7f5a35b51ddcf5"; + let key = hmac::Key::new(hmac::HMAC_SHA256, key_value.as_ref()); + let header = "{\"msg_id\":\"c0fd20872c1b4d1c87e7fc814b75c93e_0\",\"msg_type\":\"kernel_info_request\",\"username\":\"ampower\",\"session\":\"c0fd20872c1b4d1c87e7fc814b75c93e\",\"date\":\"2021-12-10T06:20:40.259695Z\",\"version\":\"5.3\"}"; + let parent_header = "{}"; + let metadata = "{}"; + let content = "{}"; + let sig = hmac_sign(&key, header, parent_header, metadata, content); + assert_eq!( + sig, + "43a5c45062e0b6bcc59c727f90165ad1d2eb02e1c5317aa25c2c2049d96d3b6a" + ); +} diff --git a/cli/tools/jupyter/mod.rs b/cli/tools/jupyter/mod.rs index bbaa0e50440f55..128fa46c3366b7 100644 --- a/cli/tools/jupyter/mod.rs +++ b/cli/tools/jupyter/mod.rs @@ -28,11 +28,13 @@ use tokio::time::sleep; use zeromq::prelude::*; use zeromq::ZmqMessage; -const DELIMITER: &str = ""; - +mod comm; mod install; mod message_types; +use comm::create_zmq_reply; +use comm::DealerComm; +use comm::PubComm; pub use install::install; use message_types::*; @@ -554,341 +556,10 @@ struct ConnectionSpec { key: String, } -#[derive(Debug)] -struct CommContext { - message: RequestMessage, - session_id: String, -} - -#[derive(Debug, Deserialize, Serialize, Clone)] -struct MessageHeader { - msg_id: String, - session: String, - username: String, - // TODO(apowers313) -- date as an Option is to address a Jupyter bug - // see also: https://github.com/jupyter/notebook/issues/6257 - date: Option, - msg_type: String, - version: String, -} - -impl MessageHeader { - fn new(msg_type: String, session_id: String) -> Self { - let now = std::time::SystemTime::now(); - let now: chrono::DateTime = now.into(); - let now = now.to_rfc3339(); - - Self { - msg_id: uuid::Uuid::new_v4().to_string(), - session: session_id, - // FIXME: - username: "".to_string(), - date: Some(now), - msg_type, - // TODO: this should be taken from a global, - version: "5.3".to_string(), - } - } -} - -#[derive(Debug)] -struct RequestMessage { - header: MessageHeader, - parent_header: Option<()>, - metadata: RequestMetadata, - content: RequestContent, -} - -impl RequestMessage { - fn new( - header: MessageHeader, - metadata: RequestMetadata, - content: RequestContent, - ) -> Self { - Self { - header, - parent_header: None, - metadata, - content, - } - } -} - -impl TryFrom for RequestMessage { - type Error = AnyError; - - fn try_from(zmq_msg: ZmqMessage) -> Result { - // TODO(apowers313) make all unwraps recoverable errors - let header_bytes = zmq_msg.get(2).unwrap(); - let metadata_bytes = zmq_msg.get(4).unwrap(); - let content_bytes = zmq_msg.get(5).unwrap(); - - let header: MessageHeader = serde_json::from_slice(header_bytes).unwrap(); - - // TODO(apowers313) refactor to an unwrap function to handles unwrapping based on different protocol versions - let mc = match header.msg_type.as_ref() { - "kernel_info_request" => (RequestMetadata::Empty, RequestContent::Empty), - "execute_request" => ( - RequestMetadata::Empty, - RequestContent::Execute(serde_json::from_slice(content_bytes).unwrap()), - ), - _ => (RequestMetadata::Empty, RequestContent::Empty), - }; - - let rm = RequestMessage::new(header, mc.0, mc.1); - println!("<== RECEIVING: {:#?}", rm); - - Ok(rm) - } -} - -struct ReplyMessage { - header: MessageHeader, - parent_header: MessageHeader, - metadata: ReplyMetadata, - content: ReplyContent, -} - -impl ReplyMessage { - fn new( - comm_ctx: &CommContext, - msg_type: String, - metadata: ReplyMetadata, - content: ReplyContent, - ) -> Self { - Self { - header: MessageHeader::new(msg_type, comm_ctx.session_id.clone()), - parent_header: comm_ctx.message.header.clone(), - metadata, - content, - } - } - - fn serialize(&self, hmac_key: &hmac::Key) -> ZmqMessage { - // TODO(apowers313) convert unwrap() to recoverable error - let header = serde_json::to_string(&self.header).unwrap(); - let parent_header = serde_json::to_string(&self.parent_header).unwrap(); - let metadata = serde_json::to_string(&self.metadata).unwrap(); - let metadata = match &self.metadata { - ReplyMetadata::Empty => serde_json::to_string(&json!({})).unwrap(), - }; - let content = match &self.content { - ReplyContent::Empty => serde_json::to_string(&json!({})).unwrap(), - // reply messages - ReplyContent::KernelInfo(c) => serde_json::to_string(&c).unwrap(), - ReplyContent::ExecuteReply(c) => serde_json::to_string(&c).unwrap(), - // side effects - ReplyContent::Status(c) => serde_json::to_string(&c).unwrap(), - ReplyContent::Stream(c) => serde_json::to_string(&c).unwrap(), - ReplyContent::ExecuteInput(c) => serde_json::to_string(&c).unwrap(), - ReplyContent::ExecuteResult(c) => serde_json::to_string(&c).unwrap(), - }; - - let hmac = - hmac_sign(hmac_key, &header, &parent_header, &metadata, &content); - - let mut zmq_msg = ZmqMessage::from(DELIMITER); - zmq_msg.push_back(hmac.into()); - zmq_msg.push_back(header.into()); - zmq_msg.push_back(parent_header.into()); - zmq_msg.push_back(metadata.into()); - zmq_msg.push_back(content.into()); - println!("==> SENDING ZMQ MSG: {:#?}", zmq_msg); - zmq_msg - } -} - -// side effects messages sent on IOPub look lik ReplyMessages (for now?) -type SideEffectMessage = ReplyMessage; - -struct PubComm { - conn_str: String, - session_id: String, - hmac_key: hmac::Key, - socket: zeromq::PubSocket, -} - -// TODO(apowers313) connect and send look like traits shared with DealerComm -impl PubComm { - pub fn new( - conn_str: String, - session_id: String, - hmac_key: hmac::Key, - ) -> Self { - println!("iopub connection: {}", conn_str); - Self { - conn_str, - session_id, - hmac_key, - socket: zeromq::PubSocket::new(), - } - } - - pub async fn connect(&mut self) -> Result<(), AnyError> { - self.socket.bind(&self.conn_str).await?; - - Ok(()) - } - - pub async fn send(&mut self, msg: SideEffectMessage) -> Result<(), AnyError> { - let zmq_msg = msg.serialize(&self.hmac_key); - println!(">>> ZMQ SENDING: {:#?}", zmq_msg); - self.socket.send(zmq_msg).await?; - Ok(()) - } -} - -struct DealerComm { - name: String, - conn_str: String, - session_id: String, - hmac_key: hmac::Key, - socket: zeromq::DealerSocket, -} - -impl DealerComm { - pub fn new( - name: &str, - conn_str: String, - session_id: String, - hmac_key: hmac::Key, - ) -> Self { - println!("dealer '{}' connection: {}", name, conn_str); - Self { - name: name.to_string(), - conn_str, - session_id, - hmac_key, - socket: zeromq::DealerSocket::new(), - } - } - - pub async fn connect(&mut self) -> Result<(), AnyError> { - self.socket.bind(&self.conn_str).await?; - - Ok(()) - } - - pub async fn recv(&mut self) -> Result { - let zmq_msg = self.socket.recv().await?; - println!("<<< ZMQ RECEIVING: {:#?}", zmq_msg); - - hmac_verify( - &self.hmac_key, - zmq_msg.get(1).unwrap(), - zmq_msg.get(2).unwrap(), - zmq_msg.get(3).unwrap(), - zmq_msg.get(4).unwrap(), - zmq_msg.get(5).unwrap(), - )?; - - let jup_msg = RequestMessage::try_from(zmq_msg)?; - - Ok(jup_msg) - } - - pub async fn send(&mut self, msg: ReplyMessage) -> Result<(), AnyError> { - let zmq_msg = msg.serialize(&self.hmac_key); - println!(">>> ZMQ SENDING: {:#?}", zmq_msg); - self.socket.send(zmq_msg).await?; - Ok(()) - } -} - -// TODO(apowers313) this is the heartbeat loop now -async fn create_zmq_reply(name: &str, conn_str: &str) -> Result<(), AnyError> { - println!("reply '{}' connection string: {}", name, conn_str); - - let mut sock = zeromq::RepSocket::new(); // TODO(apowers313) exact same as dealer, refactor - sock.monitor(); - sock.bind(conn_str).await?; - - loop { - let msg = sock.recv().await?; - println!("*** '{}' got packet!", name); - } -} - fn create_conn_str(transport: &str, ip: &str, port: u32) -> String { format!("{}://{}:{}", transport, ip, port) } -fn hmac_sign( - key: &hmac::Key, - header: &str, - parent_header: &str, - metadata: &str, - content: &str, -) -> String { - let mut hmac_ctx = hmac::Context::with_key(key); - hmac_ctx.update(header.as_bytes()); - hmac_ctx.update(parent_header.as_bytes()); - hmac_ctx.update(metadata.as_bytes()); - hmac_ctx.update(content.as_bytes()); - let tag = hmac_ctx.sign(); - let sig = HEXLOWER.encode(tag.as_ref()); - sig -} - -fn hmac_verify( - key: &hmac::Key, - expected_signature: &[u8], - header: &[u8], - parent_header: &[u8], - metadata: &[u8], - content: &[u8], -) -> Result<(), AnyError> { - let mut msg = Vec::::new(); - msg.extend(header); - msg.extend(parent_header); - msg.extend(metadata); - msg.extend(content); - let sig = HEXLOWER.decode(expected_signature)?; - hmac::verify(key, msg.as_ref(), sig.as_ref())?; - Ok(()) -} - -#[test] -fn hmac_verify_test() { - let key_value = "1f5cec86-8eaa942eef7f5a35b51ddcf5"; - let key = hmac::Key::new(hmac::HMAC_SHA256, key_value.as_ref()); - - let expected_signature = - "43a5c45062e0b6bcc59c727f90165ad1d2eb02e1c5317aa25c2c2049d96d3b6a" - .as_bytes() - .to_vec(); - let header = "{\"msg_id\":\"c0fd20872c1b4d1c87e7fc814b75c93e_0\",\"msg_type\":\"kernel_info_request\",\"username\":\"ampower\",\"session\":\"c0fd20872c1b4d1c87e7fc814b75c93e\",\"date\":\"2021-12-10T06:20:40.259695Z\",\"version\":\"5.3\"}".as_bytes().to_vec(); - let parent_header = "{}".as_bytes().to_vec(); - let metadata = "{}".as_bytes().to_vec(); - let content = "{}".as_bytes().to_vec(); - - let result = hmac_verify( - &key, - &expected_signature, - &header, - &parent_header, - &metadata, - &content, - ); - - assert!(result.is_ok(), "signature validation failed"); -} - -#[test] -fn hmac_sign_test() { - let key_value = "1f5cec86-8eaa942eef7f5a35b51ddcf5"; - let key = hmac::Key::new(hmac::HMAC_SHA256, key_value.as_ref()); - let header = "{\"msg_id\":\"c0fd20872c1b4d1c87e7fc814b75c93e_0\",\"msg_type\":\"kernel_info_request\",\"username\":\"ampower\",\"session\":\"c0fd20872c1b4d1c87e7fc814b75c93e\",\"date\":\"2021-12-10T06:20:40.259695Z\",\"version\":\"5.3\"}"; - let parent_header = "{}"; - let metadata = "{}"; - let content = "{}"; - let sig = hmac_sign(&key, header, parent_header, metadata, content); - assert_eq!( - sig, - "43a5c45062e0b6bcc59c727f90165ad1d2eb02e1c5317aa25c2c2049d96d3b6a" - ); -} - enum StdioType { Stdout, Stderr, From 941592ef0f794a09de64e5c8fcaeb1072d0d0221 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Sun, 26 Dec 2021 02:11:19 +0100 Subject: [PATCH 028/115] loosen types --- cli/tools/jupyter/message_types.rs | 6 +++--- cli/tools/jupyter/mod.rs | 30 ++++++------------------------ 2 files changed, 9 insertions(+), 27 deletions(-) diff --git a/cli/tools/jupyter/message_types.rs b/cli/tools/jupyter/message_types.rs index 6f255ec4505ff4..4a332dbfe6c558 100644 --- a/cli/tools/jupyter/message_types.rs +++ b/cli/tools/jupyter/message_types.rs @@ -88,7 +88,7 @@ pub struct ReplyMessage { impl ReplyMessage { pub fn new( comm_ctx: &CommContext, - msg_type: String, + msg_type: &str, metadata: ReplyMetadata, content: ReplyContent, ) -> Self { @@ -156,7 +156,7 @@ pub struct MessageHeader { } impl MessageHeader { - pub fn new(msg_type: String, session_id: String) -> Self { + pub fn new(msg_type: &str, session_id: String) -> Self { let now = std::time::SystemTime::now(); let now: chrono::DateTime = now.into(); let now = now.to_rfc3339(); @@ -167,7 +167,7 @@ impl MessageHeader { // FIXME: username: "".to_string(), date: Some(now), - msg_type, + msg_type: msg_type.to_string(), // TODO: this should be taken from a global, version: "5.3".to_string(), } diff --git a/cli/tools/jupyter/mod.rs b/cli/tools/jupyter/mod.rs index 128fa46c3366b7..58d87bcd0c893c 100644 --- a/cli/tools/jupyter/mod.rs +++ b/cli/tools/jupyter/mod.rs @@ -320,7 +320,7 @@ impl Kernel { let msg = SideEffectMessage::new( comm_ctx, - "status".to_string(), + "status", ReplyMetadata::Empty, ReplyContent::Status(KernelStatusContent { execution_state: s }), ); @@ -354,7 +354,7 @@ impl Kernel { let reply = ReplyMessage::new( comm_ctx, - "kernel_info_reply".to_string(), + "kernel_info_reply", ReplyMetadata::Empty, ReplyContent::KernelInfo(content), ); @@ -377,7 +377,7 @@ impl Kernel { let input_msg = SideEffectMessage::new( comm_ctx, - "execute_input".to_string(), + "execute_input", ReplyMetadata::Empty, ReplyContent::ExecuteInput(ExecuteInputContent { code: exec_request_content.code.clone(), @@ -413,7 +413,7 @@ impl Kernel { println!("sending exec result"); let msg = ReplyMessage::new( comm_ctx, - "execute_reply".to_string(), + "execute_reply", ReplyMetadata::Empty, ReplyContent::ExecuteReply(ExecuteReplyContent { status: "ok".to_string(), @@ -430,10 +430,9 @@ impl Kernel { } }; - // TODO(apowers313) send(ExecuteResult) let msg = SideEffectMessage::new( comm_ctx, - "execute_result".to_string(), + "execute_result", ReplyMetadata::Empty, ReplyContent::ExecuteResult(ExecuteResultContent { execution_count: self.execution_count, @@ -467,7 +466,7 @@ impl Kernel { let msg = SideEffectMessage::new( comm_ctx, - "stream".to_string(), + "stream", ReplyMetadata::Empty, ReplyContent::Stream(content), ); @@ -476,23 +475,6 @@ impl Kernel { Ok(()) } - - async fn fake_task( - &mut self, - comm_ctx: &CommContext, - arg: String, - ) -> Result { - for i in 0..6 { - sleep(Duration::from_millis(500)).await; - println!("ping! {}", &arg); - self - .send_stdio(comm_ctx, StdioType::Stdout, &format!("ping! {}\n", i)) - .await?; - } - - // TODO(apowers313) result should be any valid JavaScript value - Ok(ExecResult::OkString("fake result".to_string())) - } } enum ExecResult { From b0f116744eb84bc7d59e064cc1c23c2e68bb7645 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Sun, 26 Dec 2021 02:14:46 +0100 Subject: [PATCH 029/115] fix versions --- cli/tools/jupyter/mod.rs | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/cli/tools/jupyter/mod.rs b/cli/tools/jupyter/mod.rs index 58d87bcd0c893c..c529660e894520 100644 --- a/cli/tools/jupyter/mod.rs +++ b/cli/tools/jupyter/mod.rs @@ -513,12 +513,9 @@ impl Default for KernelMetadata { help_text: "".to_string(), help_url: "https://github.com/denoland/deno".to_string(), implementation_name: "Deno kernel".to_string(), - // FIXME: - kernel_version: "0.0.1".to_string(), - // FIXME: - language_version: "1.16.4".to_string(), + kernel_version: crate::version::deno(), + language_version: crate::version::TYPESCRIPT.to_string(), language: "typescript".to_string(), - // FIXME: mime: "text/x.typescript".to_string(), protocol_version: "5.3".to_string(), } From 7d865e400ed3ad22b68d428b0d8028746b013313 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Sun, 26 Dec 2021 02:18:36 +0100 Subject: [PATCH 030/115] clean up imports --- cli/tools/jupyter/comm.rs | 24 ------------------------ cli/tools/jupyter/install.rs | 16 ---------------- cli/tools/jupyter/message_types.rs | 14 -------------- 3 files changed, 54 deletions(-) diff --git a/cli/tools/jupyter/comm.rs b/cli/tools/jupyter/comm.rs index 1f2257b223e13a..43484b22bd9cae 100644 --- a/cli/tools/jupyter/comm.rs +++ b/cli/tools/jupyter/comm.rs @@ -1,32 +1,8 @@ // Copyright 2018-2021 the Deno authors. All rights reserved. MIT license. -// TODO(bartlomieju): remove me -#![allow(unused)] - -use crate::flags::Flags; -use crate::flags::JupyterFlags; -use crate::tools::repl::EvaluationOutput; -use crate::tools::repl::ReplSession; -use data_encoding::HEXLOWER; -use deno_core::anyhow::anyhow; -use deno_core::anyhow::Context; -use deno_core::error::generic_error; use deno_core::error::AnyError; -use deno_core::serde::Deserialize; -use deno_core::serde::Serialize; -use deno_core::serde_json; -use deno_core::serde_json::json; -use deno_core::serde_json::Value; -use deno_runtime::worker::MainWorker; use ring::hmac; -use std::collections::HashMap; -use std::env::current_exe; -use std::time::Duration; -use tempfile::TempDir; -use tokio::join; -use tokio::time::sleep; use zeromq::prelude::*; -use zeromq::ZmqMessage; use super::hmac_verify; use super::ReplyMessage; diff --git a/cli/tools/jupyter/install.rs b/cli/tools/jupyter/install.rs index 536d2385566d38..fa19c4e028162f 100644 --- a/cli/tools/jupyter/install.rs +++ b/cli/tools/jupyter/install.rs @@ -1,26 +1,10 @@ // Copyright 2018-2021 the Deno authors. All rights reserved. MIT license. -use crate::flags::Flags; -use crate::flags::JupyterFlags; -use data_encoding::HEXLOWER; -use deno_core::anyhow::anyhow; -use deno_core::anyhow::Context; -use deno_core::error::generic_error; use deno_core::error::AnyError; -use deno_core::serde::Deserialize; -use deno_core::serde::Serialize; use deno_core::serde_json; use deno_core::serde_json::json; -use deno_core::serde_json::Value; -use ring::hmac; -use std::collections::HashMap; use std::env::current_exe; -use std::time::Duration; use tempfile::TempDir; -use tokio::join; -use tokio::time::sleep; -use zeromq::prelude::*; -use zeromq::ZmqMessage; pub fn install() -> Result<(), AnyError> { let temp_dir = TempDir::new().unwrap(); diff --git a/cli/tools/jupyter/message_types.rs b/cli/tools/jupyter/message_types.rs index 4a332dbfe6c558..0168148a90abb1 100644 --- a/cli/tools/jupyter/message_types.rs +++ b/cli/tools/jupyter/message_types.rs @@ -1,27 +1,13 @@ // Copyright 2018-2021 the Deno authors. All rights reserved. MIT license. -use crate::flags::Flags; -use crate::flags::JupyterFlags; -use crate::tools::repl::EvaluationOutput; -use crate::tools::repl::ReplSession; use data_encoding::HEXLOWER; -use deno_core::anyhow::anyhow; -use deno_core::anyhow::Context; -use deno_core::error::generic_error; use deno_core::error::AnyError; use deno_core::serde::Deserialize; use deno_core::serde::Serialize; use deno_core::serde_json; use deno_core::serde_json::json; use deno_core::serde_json::Value; -use deno_runtime::worker::MainWorker; use ring::hmac; -use std::collections::HashMap; -use std::env::current_exe; -use std::time::Duration; -use tempfile::TempDir; -use tokio::join; -use tokio::time::sleep; use zeromq::prelude::*; use zeromq::ZmqMessage; From f4a3ef0134917456026af82798b4fb0a49c80ab8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Sun, 26 Dec 2021 02:24:57 +0100 Subject: [PATCH 031/115] shorten code --- cli/tools/jupyter/mod.rs | 74 +++++++++++++--------------------------- 1 file changed, 24 insertions(+), 50 deletions(-) diff --git a/cli/tools/jupyter/mod.rs b/cli/tools/jupyter/mod.rs index c529660e894520..96b347cf81d594 100644 --- a/cli/tools/jupyter/mod.rs +++ b/cli/tools/jupyter/mod.rs @@ -50,7 +50,7 @@ pub async fn kernel( let conn_file_path = jupyter_flags.conn_file.unwrap(); let repl_session = ReplSession::initialize(worker).await?; - let mut kernel = Kernel::new(conn_file_path.to_str().unwrap(), repl_session); + let mut kernel = Kernel::new(conn_file_path.to_str().unwrap(), repl_session)?; println!("[DENO] kernel created: {:#?}", kernel.session_id); println!("running kernel..."); @@ -97,77 +97,54 @@ enum HandlerType { } impl Kernel { - fn new(conn_file_path: &str, repl_session: ReplSession) -> Self { - let conn_file = match std::fs::read_to_string(conn_file_path) - .context("Failed to read connection file") - { - Ok(cf) => cf, - Err(_) => { - println!("Couldn't read connection file: {}", conn_file_path); - std::process::exit(1); - } - }; - let conn_spec: ConnectionSpec = match serde_json::from_str(&conn_file) - .context("Failed to parse connection file") - { - Ok(cs) => cs, - Err(_) => { - println!("Connection file isn't proper JSON: {}", conn_file_path); - std::process::exit(1); - } - }; - println!("[DENO] parsed conn file: {:#?}", conn_spec); + fn new( + conn_file_path: &str, + repl_session: ReplSession, + ) -> Result { + let conn_file = + std::fs::read_to_string(conn_file_path).with_context(|| { + format!("Couldn't read connection file: {}", conn_file_path) + })?; + let spec: ConnectionSpec = + serde_json::from_str(&conn_file).with_context(|| { + format!("Connection file isn't proper JSON: {}", conn_file_path) + })?; + + println!("[DENO] parsed conn file: {:#?}", spec); let execution_count = 0; let session_id = uuid::Uuid::new_v4().to_string(); - let hmac_key = hmac::Key::new(hmac::HMAC_SHA256, conn_spec.key.as_ref()); + let hmac_key = hmac::Key::new(hmac::HMAC_SHA256, spec.key.as_ref()); let metadata = KernelMetadata::default(); let iopub_comm = PubComm::new( - create_conn_str( - &conn_spec.transport, - &conn_spec.ip, - conn_spec.iopub_port, - ), + create_conn_str(&spec.transport, &spec.ip, spec.iopub_port), session_id.clone(), hmac_key.clone(), ); let shell_comm = DealerComm::new( "shell", - create_conn_str( - &conn_spec.transport, - &conn_spec.ip, - conn_spec.shell_port, - ), + create_conn_str(&spec.transport, &spec.ip, spec.shell_port), session_id.clone(), hmac_key.clone(), ); let control_comm = DealerComm::new( "control", - create_conn_str( - &conn_spec.transport, - &conn_spec.ip, - conn_spec.control_port, - ), + create_conn_str(&spec.transport, &spec.ip, spec.control_port), session_id.clone(), hmac_key.clone(), ); let stdin_comm = DealerComm::new( "stdin", - create_conn_str( - &conn_spec.transport, - &conn_spec.ip, - conn_spec.stdin_port, - ), + create_conn_str(&spec.transport, &spec.ip, spec.stdin_port), session_id.clone(), hmac_key, ); - let hb_conn_str = - create_conn_str(&conn_spec.transport, &conn_spec.ip, conn_spec.hb_port); + let hb_conn_str = create_conn_str(&spec.transport, &spec.ip, spec.hb_port); - let kernel: Kernel = Self { + let kernel = Self { metadata, - conn_spec, + conn_spec: spec, state: KernelState::Idle, iopub_comm, shell_comm, @@ -178,7 +155,7 @@ impl Kernel { repl_session, }; - kernel + Ok(kernel) } async fn run(&mut self) -> Result<(), AnyError> { @@ -199,15 +176,12 @@ impl Kernel { loop { tokio::select! { shell_msg = self.shell_comm.recv() => { - // println!("shell got packet: {:#?}", shell_msg); self.handler(HandlerType::Shell, shell_msg).await; }, control_msg = self.control_comm.recv() => { - // println!("control got packet: {:#?}", control_msg); self.handler(HandlerType::Control, control_msg); }, stdin_msg = self.stdin_comm.recv() => { - // println!("stdin got packet: {:#?}", stdin_msg); self.handler(HandlerType::Stdin, stdin_msg); }, } From 9ce1f94ae81b4c1cf0483ff11a0b544c0c8e08bc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Sun, 26 Dec 2021 02:47:47 +0100 Subject: [PATCH 032/115] cleanup message_types.rs --- cli/tools/jupyter/message_types.rs | 159 ++++++++++++++--------------- cli/tools/jupyter/mod.rs | 10 +- 2 files changed, 81 insertions(+), 88 deletions(-) diff --git a/cli/tools/jupyter/message_types.rs b/cli/tools/jupyter/message_types.rs index 0168148a90abb1..80cdd795f75aee 100644 --- a/cli/tools/jupyter/message_types.rs +++ b/cli/tools/jupyter/message_types.rs @@ -164,22 +164,22 @@ impl MessageHeader { // * SHELL MESSAGES // * *****************/ // Shell Request Message Types -// "execute_request" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#execute -// "inspect_request" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#introspection -// "complete_request" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#completion -// "history_request" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#history -// "is_complete_request" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#code-completeness -// "comm_info_request" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#comm-info -// "kernel_info_request" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-info +// "execute_request" /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#execute +// "inspect_request" /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#introspection +// "complete_request" /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#completion +// "history_request" /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#history +// "is_complete_request" /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#code-completeness +// "comm_info_request" /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#comm-info +// "kernel_info_request" /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-info // Shell Reply Message Types -// "execute_reply" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#execution-results -// "inspect_reply" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#introspection -// "complete_reply" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#completion -// "history_reply" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#history -// "is_complete_reply" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#code-completeness -// "comm_info_reply" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#comm-info -// "kernel_info_reply" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-info +// "execute_reply" /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#execution-results +// "inspect_reply" /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#introspection +// "complete_reply" /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#completion +// "history_reply" /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#history +// "is_complete_reply" /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#code-completeness +// "comm_info_reply" /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#comm-info +// "kernel_info_reply" /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-info #[derive(Debug, Serialize, Deserialize)] pub enum RequestContent { @@ -211,7 +211,7 @@ pub enum ReplyMetadata { Empty, } -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#execute +//// https://jupyter-client.readthedocs.io/en/latest/messaging.html#execute #[derive(Debug, Serialize, Deserialize)] pub struct ExecuteRequestContent { pub code: String, @@ -222,24 +222,24 @@ pub struct ExecuteRequestContent { pub stop_on_error: bool, } -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#execution-results +//// https://jupyter-client.readthedocs.io/en/latest/messaging.html#execution-results #[derive(Debug, Serialize, Deserialize)] pub struct ExecuteReplyContent { pub status: String, pub execution_count: u32, - // TODO: "None" gets translated to "null" - // payload: Option>, - // user_expressions: Option, + // These two fields are unused + pub payload: Vec, + pub user_expressions: Value, } -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#introspection +//// https://jupyter-client.readthedocs.io/en/latest/messaging.html#introspection pub struct InspectRequestContent { pub code: String, pub cursor_pos: u32, pub detail_level: u8, // 0 = Low, 1 = High } -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#introspection +/// https://jupyter-client.readthedocs.io/en/latest/messaging.html#introspection pub struct InspectReplyContent { pub status: String, pub found: bool, @@ -247,13 +247,13 @@ pub struct InspectReplyContent { pub metadata: Option, } -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#completion +/// https://jupyter-client.readthedocs.io/en/latest/messaging.html#completion pub struct CompleteRequestContent { pub code: String, pub cursor_pos: u32, } -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#completion +/// https://jupyter-client.readthedocs.io/en/latest/messaging.html#completion pub struct CompleteReplyContent { pub status: String, pub matches: Option, @@ -262,7 +262,7 @@ pub struct CompleteReplyContent { pub metadata: Option, } -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#history +/// https://jupyter-client.readthedocs.io/en/latest/messaging.html#history pub struct HistoryRequestContent { pub output: bool, pub raw: bool, @@ -273,38 +273,38 @@ pub struct HistoryRequestContent { pub n: u32, } -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#history +/// https://jupyter-client.readthedocs.io/en/latest/messaging.html#history pub struct HistoryReplyContent { pub status: String, pub history: Option, } -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#code-completeness +/// https://jupyter-client.readthedocs.io/en/latest/messaging.html#code-completeness pub struct CodeCompleteRequestContent { pub code: String, } -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#code-completeness +/// https://jupyter-client.readthedocs.io/en/latest/messaging.html#code-completeness pub struct CodeCompleteReplyContent { pub status: String, // "complete" | "incomplete" | "invalid" | "unknown" pub indent: String, } -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#comm-info +/// https://jupyter-client.readthedocs.io/en/latest/messaging.html#comm-info pub struct CommInfoRequestContent { pub target_name: String, } -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#comm-info +/// https://jupyter-client.readthedocs.io/en/latest/messaging.html#comm-info pub struct CommInfoReplyContent { pub status: String, pub comms: Option, } -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-info +/// https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-info // pub struct KernelInfoRequest {} // empty -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-info +/// https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-info #[derive(Debug, Serialize, Deserialize)] pub struct KernelInfoReplyContent { pub status: String, @@ -317,20 +317,18 @@ pub struct KernelInfoReplyContent { pub help_links: Vec, } -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-info +//// https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-info +/// +/// `pygments_lexer`, `codemirror_more` and `nvconvert_exporter` are omitted. #[derive(Debug, Serialize, Deserialize)] pub struct KernelLanguageInfo { pub name: String, pub version: String, pub mimetype: String, pub file_extension: String, - // TODO: "None" gets translated to "null" - // pygments_lexer: Option, - // codemirror_mode: Option, - // nbconvert_exporter: Option, } -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-info +/// https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-info #[derive(Debug, Serialize, Deserialize)] pub struct KernelHelpLink { pub text: String, @@ -342,59 +340,58 @@ pub struct KernelHelpLink { * *****************/ // Control Request Message Types -// "shutdown_request" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-shutdown -// "interrupt_request" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-interrupt -// "debug_request" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#debug-request +// "shutdown_request" /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-shutdown +// "interrupt_request" /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-interrupt +// "debug_request" /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#debug-request // Control Reply Message Types -// "shutdown_reply" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-shutdown -// "interrupt_reply" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-interrupt -// "debug_reply" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#debug-request +// "shutdown_reply" /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-shutdown +// "interrupt_reply" /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-interrupt +// "debug_reply" /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#debug-request -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-shutdown +/// https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-shutdown pub struct ShutdownRequestContent { pub restart: bool, } -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-shutdown +/// https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-shutdown pub struct ShutdownReplyContent { pub status: String, pub restart: bool, } -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-interrupt +/// https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-interrupt // pub struct InterruptRequestContent {} // empty -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-interrupt +/// https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-interrupt pub struct InterruptReplyContent { pub status: String, } -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#debug-request +/// https://jupyter-client.readthedocs.io/en/latest/messaging.html#debug-request // pub struct DebugRequestContent {} // See Debug Adapter Protocol (DAP) 1.39 or later -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#debug-request +/// https://jupyter-client.readthedocs.io/en/latest/messaging.html#debug-request // pub struct DebugReplyContent {} // See Debug Adapter Protocol (DAP) 1.39 or later /* ***************** * IOPUB MESSAGES * *****************/ - // Io Pub Message Types -// "stream" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#streams-stdout-stderr-etc -// "display_data" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#display-data -// "update_display_data" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#update-display-data -// "execute_input" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#code-inputs -// "execute_result" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#id6 -// "error" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#execution-errors -// "status" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-status -// "clear_output" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#clear-output -// "debug_event" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#debug-event -// "comm_open" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#opening-a-comm -// "comm_msg" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#comm-messages -// "comm_close" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#tearing-down-comms - -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#request-reply +// "stream" /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#streams-stdout-stderr-etc +// "display_data" /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#display-data +// "update_display_data" /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#update-display-data +// "execute_input" /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#code-inputs +// "execute_result" /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#id6 +// "error" /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#execution-errors +// "status" /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-status +// "clear_output" /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#clear-output +// "debug_event" /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#debug-event +// "comm_open" /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#opening-a-comm +// "comm_msg" /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#comm-messages +// "comm_close" /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#tearing-down-comms + +/// https://jupyter-client.readthedocs.io/en/latest/messaging.html#request-reply pub struct ErrorStatusContent { pub status: String, // "error" pub ename: String, @@ -403,37 +400,37 @@ pub struct ErrorStatusContent { pub execution_count: Option, } -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#request-reply +/// https://jupyter-client.readthedocs.io/en/latest/messaging.html#request-reply // #[derive(Debug, Serialize, Deserialize)] // pub struct StatusContent { // status: String, // "ok" | "abort" // } -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#streams-stdout-stderr-etc +/// https://jupyter-client.readthedocs.io/en/latest/messaging.html#streams-stdout-stderr-etc #[derive(Debug, Serialize, Deserialize)] pub struct StreamContent { pub name: String, // "stdout" | "stderr" pub text: String, } -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#display-data +/// https://jupyter-client.readthedocs.io/en/latest/messaging.html#display-data pub struct DisplayDataContent { pub data: Value, pub metadata: Option, pub transient: Option, } -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#update-display-data +/// https://jupyter-client.readthedocs.io/en/latest/messaging.html#update-display-data // pub struct UpdateDisplayDataContent {} // same as DisplayDataContent -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#code-inputs +/// https://jupyter-client.readthedocs.io/en/latest/messaging.html#code-inputs #[derive(Debug, Serialize, Deserialize)] pub struct ExecuteInputContent { pub code: String, pub execution_count: u32, } -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#id6 +/// https://jupyter-client.readthedocs.io/en/latest/messaging.html#id6 #[derive(Debug, Serialize, Deserialize)] pub struct ExecuteResultContent { pub execution_count: u32, @@ -441,40 +438,40 @@ pub struct ExecuteResultContent { pub metadata: Option, } -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#execution-errors +/// https://jupyter-client.readthedocs.io/en/latest/messaging.html#execution-errors pub struct ErrorContent { pub payload: Option>, pub user_expressions: Option, } -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-status +/// https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-status #[derive(Debug, Serialize, Deserialize)] pub struct KernelStatusContent { pub execution_state: String, // "busy" | "idle" | "starting" } -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#clear-output +/// https://jupyter-client.readthedocs.io/en/latest/messaging.html#clear-output pub struct ClearOutputContent { pub wait: bool, } -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#debug-event +/// https://jupyter-client.readthedocs.io/en/latest/messaging.html#debug-event // pub struct DebugEventContent {} // see Event message from the Debug Adapter Protocol (DAP) -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#opening-a-comm +/// https://jupyter-client.readthedocs.io/en/latest/messaging.html#opening-a-comm pub struct CommOpenMessage { pub comm_id: uuid::Uuid, pub target_name: String, pub data: Option, } -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#comm-messages +/// https://jupyter-client.readthedocs.io/en/latest/messaging.html#comm-messages pub struct CommMsgMessage { pub comm_id: uuid::Uuid, pub data: Option, } -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#comm-messages +/// https://jupyter-client.readthedocs.io/en/latest/messaging.html#comm-messages pub struct CommCloseMessage { pub comm_id: uuid::Uuid, pub data: Option, @@ -484,18 +481,18 @@ pub struct CommCloseMessage { * STDIN MESSAGES * *****************/ // Stdin Request Message Types -// "input_request" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#messages-on-the-stdin-router-dealer-channel +// "input_request" /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#messages-on-the-stdin-router-dealer-channel // Stdin Reply Message Types -// "input_reply" // https://jupyter-client.readthedocs.io/en/latest/messaging.html#messages-on-the-stdin-router-dealer-channel +// "input_reply" /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#messages-on-the-stdin-router-dealer-channel -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#messages-on-the-stdin-router-dealer-channel +/// https://jupyter-client.readthedocs.io/en/latest/messaging.html#messages-on-the-stdin-router-dealer-channel pub struct InputRequestContent { pub prompt: String, pub password: bool, } -// https://jupyter-client.readthedocs.io/en/latest/messaging.html#messages-on-the-stdin-router-dealer-channel +/// https://jupyter-client.readthedocs.io/en/latest/messaging.html#messages-on-the-stdin-router-dealer-channel pub struct InputReplyContent { pub value: String, } diff --git a/cli/tools/jupyter/mod.rs b/cli/tools/jupyter/mod.rs index 96b347cf81d594..feb7067bb9e25c 100644 --- a/cli/tools/jupyter/mod.rs +++ b/cli/tools/jupyter/mod.rs @@ -316,10 +316,6 @@ impl Kernel { version: self.metadata.language_version.clone(), mimetype: self.metadata.mime.clone(), file_extension: self.metadata.file_ext.clone(), - // TODO: "None" gets translated to "null" - // codemirror_mode: None, - // nbconvert_exporter: None, - // pygments_lexer: None, }, help_links: vec![], // TODO(apowers313) dig up help links banner: self.metadata.banner.clone(), @@ -392,9 +388,9 @@ impl Kernel { ReplyContent::ExecuteReply(ExecuteReplyContent { status: "ok".to_string(), execution_count: self.execution_count, - // TODO: "None" gets translated to "null" by serde_json - // payload: None, - // user_expressions: None, + // NOTE(bartlomieju): these two fields are always empty + payload: vec![], + user_expressions: json!({}), }), ); self.shell_comm.send(msg).await?; From 07af2fe9ca0e78d2151162eaccea6a0928b9f997 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Sun, 26 Dec 2021 03:07:46 +0100 Subject: [PATCH 033/115] move session creation into Kernel --- cli/main.rs | 6 +----- cli/tools/jupyter/mod.rs | 23 +++++++++++++++-------- 2 files changed, 16 insertions(+), 13 deletions(-) diff --git a/cli/main.rs b/cli/main.rs index 1522eccca654b3..07edc6c93fa56e 100644 --- a/cli/main.rs +++ b/cli/main.rs @@ -562,11 +562,7 @@ async fn jupyter_command( return Ok(0); } - let main_module = resolve_url_or_path("./$deno$repl.ts").unwrap(); - let permissions = Permissions::from_options(&flags.clone().into()); - let ps = ProcState::build(flags.clone()).await?; - let worker = create_main_worker(&ps, main_module.clone(), permissions, None); - tools::jupyter::kernel(flags, jupyter_flags, worker).await?; + tools::jupyter::kernel(flags, jupyter_flags).await?; Ok(0) } diff --git a/cli/tools/jupyter/mod.rs b/cli/tools/jupyter/mod.rs index feb7067bb9e25c..2478b1611a3c72 100644 --- a/cli/tools/jupyter/mod.rs +++ b/cli/tools/jupyter/mod.rs @@ -3,8 +3,10 @@ // TODO(bartlomieju): remove me #![allow(unused)] +use crate::create_main_worker; use crate::flags::Flags; use crate::flags::JupyterFlags; +use crate::proc_state::ProcState; use crate::tools::repl::EvaluationOutput; use crate::tools::repl::ReplSession; use data_encoding::HEXLOWER; @@ -12,11 +14,13 @@ use deno_core::anyhow::anyhow; use deno_core::anyhow::Context; use deno_core::error::generic_error; use deno_core::error::AnyError; +use deno_core::resolve_url_or_path; use deno_core::serde::Deserialize; use deno_core::serde::Serialize; use deno_core::serde_json; use deno_core::serde_json::json; use deno_core::serde_json::Value; +use deno_runtime::permissions::Permissions; use deno_runtime::worker::MainWorker; use ring::hmac; use std::collections::HashMap; @@ -39,9 +43,8 @@ pub use install::install; use message_types::*; pub async fn kernel( - _flags: Flags, + flags: Flags, jupyter_flags: JupyterFlags, - worker: MainWorker, ) -> Result<(), AnyError> { if jupyter_flags.conn_file.is_none() { return Err(generic_error("Missing --conn flag")); @@ -49,8 +52,7 @@ pub async fn kernel( let conn_file_path = jupyter_flags.conn_file.unwrap(); - let repl_session = ReplSession::initialize(worker).await?; - let mut kernel = Kernel::new(conn_file_path.to_str().unwrap(), repl_session)?; + let mut kernel = Kernel::new(flags, conn_file_path.to_str().unwrap()).await?; println!("[DENO] kernel created: {:#?}", kernel.session_id); println!("running kernel..."); @@ -97,10 +99,7 @@ enum HandlerType { } impl Kernel { - fn new( - conn_file_path: &str, - repl_session: ReplSession, - ) -> Result { + async fn new(flags: Flags, conn_file_path: &str) -> Result { let conn_file = std::fs::read_to_string(conn_file_path).with_context(|| { format!("Couldn't read connection file: {}", conn_file_path) @@ -142,6 +141,14 @@ impl Kernel { let hb_conn_str = create_conn_str(&spec.transport, &spec.ip, spec.hb_port); + let main_module = resolve_url_or_path("./$deno$jupyter.ts").unwrap(); + // TODO(bartlomieju): should we run with all permissions? + let permissions = Permissions::allow_all(); + let ps = ProcState::build(flags.clone()).await?; + let worker = + create_main_worker(&ps, main_module.clone(), permissions, None); + let repl_session = ReplSession::initialize(worker).await?; + let kernel = Self { metadata, conn_spec: spec, From 93ecd0398d69212fe0a756329fd6085727c50e2c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Sun, 26 Dec 2021 03:10:28 +0100 Subject: [PATCH 034/115] add overwrite_op --- core/ops.rs | 11 ++++++++++- core/runtime.rs | 16 ++++++++++++---- 2 files changed, 22 insertions(+), 5 deletions(-) diff --git a/core/ops.rs b/core/ops.rs index 6b2c06397f5386..3f85a6276571e8 100644 --- a/core/ops.rs +++ b/core/ops.rs @@ -201,7 +201,16 @@ impl OpTable { F: Fn(Rc>, OpPayload) -> Op + 'static, { let (op_id, prev) = self.0.insert_full(name.to_owned(), Rc::new(op_fn)); - assert!(prev.is_none()); + assert!(prev.is_none(), "Op '{}' was already registered", name); + op_id + } + + pub fn overwrite_op(&mut self, name: &str, op_fn: F) -> OpId + where + F: Fn(Rc>, OpPayload) -> Op + 'static, + { + let (op_id, prev) = self.0.insert_full(name.to_owned(), Rc::new(op_fn)); + assert!(prev.is_some(), "Op '{}' wasn't already registered", name); op_id } diff --git a/core/runtime.rs b/core/runtime.rs index 643a4198de1912..24ed20c7bf77b2 100644 --- a/core/runtime.rs +++ b/core/runtime.rs @@ -637,6 +637,18 @@ impl JsRuntime { .register_op(name, op_fn) } + pub fn overwrite_op(&mut self, name: &str, op_fn: F) -> OpId + where + F: Fn(Rc>, OpPayload) -> Op + 'static, + { + Self::state(self.v8_isolate()) + .borrow_mut() + .op_state + .borrow_mut() + .op_table + .overwrite_op(name, op_fn) + } + /// Registers a callback on the isolate when the memory limits are approached. /// Use this to prevent V8 from crashing the process when reaching the limit. /// @@ -1904,8 +1916,6 @@ pub mod tests { #[test] fn terminate_execution() { let (mut isolate, _dispatch_count) = setup(Mode::Async); - // TODO(piscisaureus): in rusty_v8, the `thread_safe_handle()` method - // should not require a mutable reference to `struct rusty_v8::Isolate`. let v8_isolate_handle = isolate.v8_isolate().thread_safe_handle(); let terminator_thread = std::thread::spawn(move || { @@ -1943,8 +1953,6 @@ pub mod tests { let v8_isolate_handle = { // isolate is dropped at the end of this block let (mut runtime, _dispatch_count) = setup(Mode::Async); - // TODO(piscisaureus): in rusty_v8, the `thread_safe_handle()` method - // should not require a mutable reference to `struct rusty_v8::Isolate`. runtime.v8_isolate().thread_safe_handle() }; From 244c94883a6a5cfebb0d8bfe7ef1f86db8ba5ab7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Sun, 26 Dec 2021 03:46:20 +0100 Subject: [PATCH 035/115] capture stdio --- cli/tools/jupyter/message_types.rs | 10 ++--- cli/tools/jupyter/mod.rs | 71 +++++++++++++++++++++++++++++- 2 files changed, 74 insertions(+), 7 deletions(-) diff --git a/cli/tools/jupyter/message_types.rs b/cli/tools/jupyter/message_types.rs index 80cdd795f75aee..a3796b25e4637b 100644 --- a/cli/tools/jupyter/message_types.rs +++ b/cli/tools/jupyter/message_types.rs @@ -13,7 +13,7 @@ use zeromq::ZmqMessage; const DELIMITER: &str = ""; -#[derive(Debug)] +#[derive(Clone, Debug)] pub struct RequestMessage { pub header: MessageHeader, pub parent_header: Option<()>, @@ -123,7 +123,7 @@ impl ReplyMessage { // side effects messages sent on IOPub look lik ReplyMessages (for now?) pub type SideEffectMessage = ReplyMessage; -#[derive(Debug)] +#[derive(Clone, Debug)] pub struct CommContext { pub message: RequestMessage, pub session_id: String, @@ -181,7 +181,7 @@ impl MessageHeader { // "comm_info_reply" /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#comm-info // "kernel_info_reply" /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-info -#[derive(Debug, Serialize, Deserialize)] +#[derive(Clone, Debug, Serialize, Deserialize)] pub enum RequestContent { Empty, Execute(ExecuteRequestContent), @@ -200,7 +200,7 @@ pub enum ReplyContent { ExecuteResult(ExecuteResultContent), } -#[derive(Debug, Serialize, Deserialize)] +#[derive(Clone, Debug, Serialize, Deserialize)] pub enum RequestMetadata { Empty, Unknown(Value), @@ -212,7 +212,7 @@ pub enum ReplyMetadata { } //// https://jupyter-client.readthedocs.io/en/latest/messaging.html#execute -#[derive(Debug, Serialize, Deserialize)] +#[derive(Clone, Debug, Serialize, Deserialize)] pub struct ExecuteRequestContent { pub code: String, pub silent: bool, diff --git a/cli/tools/jupyter/mod.rs b/cli/tools/jupyter/mod.rs index 2478b1611a3c72..6d3b78a6e791de 100644 --- a/cli/tools/jupyter/mod.rs +++ b/cli/tools/jupyter/mod.rs @@ -14,12 +14,20 @@ use deno_core::anyhow::anyhow; use deno_core::anyhow::Context; use deno_core::error::generic_error; use deno_core::error::AnyError; +use deno_core::futures::channel::mpsc; +use deno_core::futures::channel::mpsc::UnboundedReceiver; +use deno_core::futures::channel::mpsc::UnboundedSender; +use deno_core::futures::SinkExt; +use deno_core::futures::StreamExt; +use deno_core::op_sync; use deno_core::resolve_url_or_path; use deno_core::serde::Deserialize; use deno_core::serde::Serialize; use deno_core::serde_json; use deno_core::serde_json::json; use deno_core::serde_json::Value; +use deno_core::JsRuntime; +use deno_core::OpState; use deno_runtime::permissions::Permissions; use deno_runtime::worker::MainWorker; use ring::hmac; @@ -90,6 +98,8 @@ struct Kernel { session_id: String, execution_count: u32, repl_session: ReplSession, + stdio_rx: StdioProxyReceiver, + last_comm_ctx: Option, } enum HandlerType { @@ -98,6 +108,30 @@ enum HandlerType { Stdin, } +type StdioProxySender = UnboundedSender<(StdioType, String)>; +type StdioProxyReceiver = UnboundedReceiver<(StdioType, String)>; + +fn init(rt: &mut JsRuntime) { + rt.overwrite_op("op_print", op_sync(op_print)); +} + +pub fn op_print( + state: &mut OpState, + msg: String, + is_err: bool, +) -> Result<(), AnyError> { + let mut sender = state.borrow_mut::(); + + if is_err { + let r = sender.unbounded_send((StdioType::Stderr, msg)); + eprintln!("stdio result {:#?}", r); + } else { + let r = sender.unbounded_send((StdioType::Stdout, msg)); + eprintln!("stdio result {:#?}", r); + } + Ok(()) +} + impl Kernel { async fn new(flags: Flags, conn_file_path: &str) -> Result { let conn_file = @@ -145,8 +179,14 @@ impl Kernel { // TODO(bartlomieju): should we run with all permissions? let permissions = Permissions::allow_all(); let ps = ProcState::build(flags.clone()).await?; - let worker = - create_main_worker(&ps, main_module.clone(), permissions, None); + let mut worker = + create_main_worker(&ps, main_module.clone(), permissions, Some(&init)); + let (stdio_tx, stdio_rx) = mpsc::unbounded(); + worker + .js_runtime + .op_state() + .borrow_mut() + .put::(stdio_tx); let repl_session = ReplSession::initialize(worker).await?; let kernel = Self { @@ -160,6 +200,8 @@ impl Kernel { session_id, execution_count, repl_session, + stdio_rx, + last_comm_ctx: None, }; Ok(kernel) @@ -191,6 +233,29 @@ impl Kernel { stdin_msg = self.stdin_comm.recv() => { self.handler(HandlerType::Stdin, stdin_msg); }, + maybe_stdio_proxy_msg = self.stdio_rx.next() => { + println!("Received stdio message {:#?}", maybe_stdio_proxy_msg); + if let Some(stdio_proxy_msg) = maybe_stdio_proxy_msg { + if let Some(comm_ctx) = self.last_comm_ctx.as_ref() { + let (t, content) = stdio_proxy_msg; + let msg = SideEffectMessage::new( + comm_ctx, + "stream", + ReplyMetadata::Empty, + ReplyContent::Stream(StreamContent { + name: match t { + StdioType::Stdout => "stdout".to_string(), + StdioType::Stderr => "stderr".to_string(), + }, + text: content, + }), + ); + self.iopub_comm.send(msg).await?; + } else { + println!("Received stdio message, but there is no last CommContext: {:#?}", stdio_proxy_msg.1); + } + } + } } } } @@ -212,6 +277,7 @@ impl Kernel { session_id: self.session_id.clone(), message: req_msg, }; + self.last_comm_ctx = Some(comm_ctx.clone()); match self.set_state(&comm_ctx, KernelState::Busy).await { Ok(_) => {} @@ -516,6 +582,7 @@ fn create_conn_str(transport: &str, ip: &str, port: u32) -> String { format!("{}://{}:{}", transport, ip, port) } +#[derive(Debug)] enum StdioType { Stdout, Stderr, From 6d398bee0139fa7276382c902100d0dad91f14f4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Sun, 26 Dec 2021 13:17:41 +0100 Subject: [PATCH 036/115] change logging, update msg type --- cli/tools/jupyter/comm.rs | 7 +++---- cli/tools/jupyter/message_types.rs | 7 +++---- cli/tools/jupyter/mod.rs | 10 +++++----- 3 files changed, 11 insertions(+), 13 deletions(-) diff --git a/cli/tools/jupyter/comm.rs b/cli/tools/jupyter/comm.rs index 43484b22bd9cae..432ceea285f867 100644 --- a/cli/tools/jupyter/comm.rs +++ b/cli/tools/jupyter/comm.rs @@ -39,8 +39,8 @@ impl PubComm { } pub async fn send(&mut self, msg: SideEffectMessage) -> Result<(), AnyError> { + println!("==> IoPub SENDING: {:#?}", msg); let zmq_msg = msg.serialize(&self.hmac_key); - println!(">>> ZMQ SENDING: {:#?}", zmq_msg); self.socket.send(zmq_msg).await?; Ok(()) } @@ -79,7 +79,6 @@ impl DealerComm { pub async fn recv(&mut self) -> Result { let zmq_msg = self.socket.recv().await?; - println!("<<< ZMQ RECEIVING: {:#?}", zmq_msg); hmac_verify( &self.hmac_key, @@ -91,13 +90,13 @@ impl DealerComm { )?; let jup_msg = RequestMessage::try_from(zmq_msg)?; - + println!("<== {} RECEIVING: {:#?}", self.name, jup_msg); Ok(jup_msg) } pub async fn send(&mut self, msg: ReplyMessage) -> Result<(), AnyError> { + println!("==> {} SENDING: {:#?}", self.name, msg); let zmq_msg = msg.serialize(&self.hmac_key); - println!(">>> ZMQ SENDING: {:#?}", zmq_msg); self.socket.send(zmq_msg).await?; Ok(()) } diff --git a/cli/tools/jupyter/message_types.rs b/cli/tools/jupyter/message_types.rs index a3796b25e4637b..50b2a6991f1d79 100644 --- a/cli/tools/jupyter/message_types.rs +++ b/cli/tools/jupyter/message_types.rs @@ -58,12 +58,12 @@ impl TryFrom for RequestMessage { }; let rm = RequestMessage::new(header, mc.0, mc.1); - println!("<== RECEIVING: {:#?}", rm); Ok(rm) } } +#[derive(Debug)] pub struct ReplyMessage { pub header: MessageHeader, pub parent_header: MessageHeader, @@ -115,7 +115,6 @@ impl ReplyMessage { zmq_msg.push_back(parent_header.into()); zmq_msg.push_back(metadata.into()); zmq_msg.push_back(content.into()); - println!("==> SENDING ZMQ MSG: {:#?}", zmq_msg); zmq_msg } } @@ -434,8 +433,8 @@ pub struct ExecuteInputContent { #[derive(Debug, Serialize, Deserialize)] pub struct ExecuteResultContent { pub execution_count: u32, - pub data: Option, - pub metadata: Option, + pub data: Value, + pub metadata: Value, } /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#execution-errors diff --git a/cli/tools/jupyter/mod.rs b/cli/tools/jupyter/mod.rs index 6d3b78a6e791de..9d5102aa678687 100644 --- a/cli/tools/jupyter/mod.rs +++ b/cli/tools/jupyter/mod.rs @@ -228,10 +228,10 @@ impl Kernel { self.handler(HandlerType::Shell, shell_msg).await; }, control_msg = self.control_comm.recv() => { - self.handler(HandlerType::Control, control_msg); + self.handler(HandlerType::Control, control_msg).await; }, stdin_msg = self.stdin_comm.recv() => { - self.handler(HandlerType::Stdin, stdin_msg); + self.handler(HandlerType::Stdin, stdin_msg).await; }, maybe_stdio_proxy_msg = self.stdio_rx.next() => { println!("Received stdio message {:#?}", maybe_stdio_proxy_msg); @@ -479,13 +479,13 @@ impl Kernel { ReplyMetadata::Empty, ReplyContent::ExecuteResult(ExecuteResultContent { execution_count: self.execution_count, - data: Some(json!({ + data: json!({ "text/plain": match result { ExecResult::OkString(v) => v, ExecResult::Error(v) => v.err_value, } - })), - metadata: None, + }), + metadata: json!({}), }), ); self.iopub_comm.send(msg).await?; From 0c639c5cfadad67906103fed8c4690d6646db6fc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Sun, 26 Dec 2021 14:27:12 +0100 Subject: [PATCH 037/115] handle errors gracefully --- cli/tools/jupyter/mod.rs | 64 +++++++++++++++------------------------- 1 file changed, 23 insertions(+), 41 deletions(-) diff --git a/cli/tools/jupyter/mod.rs b/cli/tools/jupyter/mod.rs index 9d5102aa678687..a0d3cd3e1bd9b0 100644 --- a/cli/tools/jupyter/mod.rs +++ b/cli/tools/jupyter/mod.rs @@ -77,16 +77,6 @@ enum KernelState { Starting, } -impl std::fmt::Display for KernelState { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - match self { - Self::Busy => write!(f, "busy"), - Self::Idle => write!(f, "idle"), - Self::Starting => write!(f, "starting"), - } - } -} - struct Kernel { metadata: KernelMetadata, conn_spec: ConnectionSpec, @@ -279,13 +269,7 @@ impl Kernel { }; self.last_comm_ctx = Some(comm_ctx.clone()); - match self.set_state(&comm_ctx, KernelState::Busy).await { - Ok(_) => {} - Err(e) => { - println!("error setting busy state: {}", e); - return; - } - }; + self.set_state(&comm_ctx, KernelState::Busy).await; let major_version = &comm_ctx.message.header.version.to_string()[0..1]; let res = match (handler_type, major_version) { @@ -310,29 +294,27 @@ impl Kernel { } }; - match self.set_state(&comm_ctx, KernelState::Idle).await { - Ok(_) => {} - Err(e) => { - println!("error setting idle state: {}", e); - } - }; + self.set_state(&comm_ctx, KernelState::Idle).await; } async fn shell_handler( &mut self, comm_ctx: &CommContext, ) -> Result<(), AnyError> { - match comm_ctx.message.header.msg_type.as_ref() { - "kernel_info_request" => self.kernel_info_reply(comm_ctx).await?, - "execute_request" => self.execute_request(comm_ctx).await?, + let msg_type = comm_ctx.message.header.msg_type.as_ref(); + let result = match msg_type { + "kernel_info_request" => self.kernel_info_reply(comm_ctx).await, + "execute_request" => self.execute_request(comm_ctx).await, _ => { - return Err(anyhow!( - "no handler for msg_id: '{}'", - comm_ctx.message.header.msg_id - )) + println!("[shell] no handler for {}", msg_type); + Ok(()) } }; + if let Err(e) = result { + println!("[shell] error handling {}: {}", msg_type, e); + } + Ok(()) } @@ -344,13 +326,9 @@ impl Kernel { todo!() } - async fn set_state( - &mut self, - comm_ctx: &CommContext, - state: KernelState, - ) -> Result<(), AnyError> { + async fn set_state(&mut self, comm_ctx: &CommContext, state: KernelState) { if self.state == state { - return Ok(()); + return; } self.state = state; @@ -360,19 +338,23 @@ impl Kernel { let now = now.to_rfc3339(); let s = match state { - KernelState::Busy => "busy".to_string(), - KernelState::Idle => "idle".to_string(), - KernelState::Starting => "starting".to_string(), + KernelState::Busy => "busy", + KernelState::Idle => "idle", + KernelState::Starting => "starting", }; let msg = SideEffectMessage::new( comm_ctx, "status", ReplyMetadata::Empty, - ReplyContent::Status(KernelStatusContent { execution_state: s }), + ReplyContent::Status(KernelStatusContent { + execution_state: s.to_string(), + }), ); - self.iopub_comm.send(msg).await + if let Err(e) = self.iopub_comm.send(msg).await { + println!("[IoPub] Error setting state: {}", s); + } } async fn kernel_info_reply( From 60ecbd0f1f60e2fd37f523f5c1880e365f852af6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Sun, 26 Dec 2021 14:32:01 +0100 Subject: [PATCH 038/115] stdio handler --- cli/tools/jupyter/mod.rs | 80 +++++++++++++++++----------------------- 1 file changed, 33 insertions(+), 47 deletions(-) diff --git a/cli/tools/jupyter/mod.rs b/cli/tools/jupyter/mod.rs index a0d3cd3e1bd9b0..c8510a8de13ff6 100644 --- a/cli/tools/jupyter/mod.rs +++ b/cli/tools/jupyter/mod.rs @@ -212,6 +212,7 @@ impl Kernel { // TODO(apowers313): run heartbeat // create_zmq_reply("hb", &hb_conn_str) + // TODO(bartlomieju): errors are not handled here loop { tokio::select! { shell_msg = self.shell_comm.recv() => { @@ -224,27 +225,9 @@ impl Kernel { self.handler(HandlerType::Stdin, stdin_msg).await; }, maybe_stdio_proxy_msg = self.stdio_rx.next() => { - println!("Received stdio message {:#?}", maybe_stdio_proxy_msg); - if let Some(stdio_proxy_msg) = maybe_stdio_proxy_msg { - if let Some(comm_ctx) = self.last_comm_ctx.as_ref() { - let (t, content) = stdio_proxy_msg; - let msg = SideEffectMessage::new( - comm_ctx, - "stream", - ReplyMetadata::Empty, - ReplyContent::Stream(StreamContent { - name: match t { - StdioType::Stdout => "stdout".to_string(), - StdioType::Stderr => "stderr".to_string(), - }, - text: content, - }), - ); - self.iopub_comm.send(msg).await?; - } else { - println!("Received stdio message, but there is no last CommContext: {:#?}", stdio_proxy_msg.1); - } - } + if let Some(stdio_proxy_msg) = maybe_stdio_proxy_msg { + self.stdio_handler(stdio_proxy_msg).await; + } } } } @@ -297,6 +280,35 @@ impl Kernel { self.set_state(&comm_ctx, KernelState::Idle).await; } + async fn stdio_handler( + &mut self, + stdio_proxy_msg: (StdioType, String), + ) -> Result<(), AnyError> { + if let Some(comm_ctx) = self.last_comm_ctx.as_ref() { + let (t, content) = stdio_proxy_msg; + let msg = SideEffectMessage::new( + comm_ctx, + "stream", + ReplyMetadata::Empty, + ReplyContent::Stream(StreamContent { + name: match t { + StdioType::Stdout => "stdout".to_string(), + StdioType::Stderr => "stderr".to_string(), + }, + text: content, + }), + ); + self.iopub_comm.send(msg).await?; + } else { + println!( + "Received stdio message, but there is no last CommContext: {:#?}", + stdio_proxy_msg.1 + ); + } + + Ok(()) + } + async fn shell_handler( &mut self, comm_ctx: &CommContext, @@ -474,32 +486,6 @@ impl Kernel { Ok(()) } - - async fn send_stdio( - &mut self, - comm_ctx: &CommContext, - t: StdioType, - text: &str, - ) -> Result<(), AnyError> { - let content = StreamContent { - name: match t { - StdioType::Stdout => "stdout".to_string(), - StdioType::Stderr => "stderr".to_string(), - }, - text: text.to_string(), - }; - - let msg = SideEffectMessage::new( - comm_ctx, - "stream", - ReplyMetadata::Empty, - ReplyContent::Stream(content), - ); - - self.iopub_comm.send(msg).await?; - - Ok(()) - } } enum ExecResult { From da56ac93139e96029c1b3c94ce6a77c31c6492c2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Sun, 26 Dec 2021 14:52:36 +0100 Subject: [PATCH 039/115] add heartbeat --- cli/tools/jupyter/comm.rs | 40 +++++++++++++++++++++++++-------------- cli/tools/jupyter/mod.rs | 36 +++++++++++++++++++---------------- 2 files changed, 46 insertions(+), 30 deletions(-) diff --git a/cli/tools/jupyter/comm.rs b/cli/tools/jupyter/comm.rs index 432ceea285f867..5a09077fcf8bdf 100644 --- a/cli/tools/jupyter/comm.rs +++ b/cli/tools/jupyter/comm.rs @@ -102,19 +102,31 @@ impl DealerComm { } } -// TODO(apowers313) this is the heartbeat loop now -pub async fn create_zmq_reply( - name: &str, - conn_str: &str, -) -> Result<(), AnyError> { - println!("reply '{}' connection string: {}", name, conn_str); - - let mut sock = zeromq::RepSocket::new(); // TODO(apowers313) exact same as dealer, refactor - sock.monitor(); - sock.bind(conn_str).await?; - - loop { - let msg = sock.recv().await?; - println!("*** '{}' got packet!", name); +pub struct HbComm { + conn_str: String, + socket: zeromq::RepSocket, +} + +impl HbComm { + pub fn new(conn_str: String) -> Self { + println!("hb connection: {}", conn_str); + Self { + conn_str, + socket: zeromq::RepSocket::new(), + } + } + + pub async fn connect(&mut self) -> Result<(), AnyError> { + self.socket.bind(&self.conn_str).await?; + + Ok(()) + } + + pub async fn heartbeat(&mut self) -> Result<(), AnyError> { + let msg = self.socket.recv().await?; + println!("<== heartbeat received"); + self.socket.send(msg).await?; + println!("==> heartbeat sent"); + Ok(()) } } diff --git a/cli/tools/jupyter/mod.rs b/cli/tools/jupyter/mod.rs index c8510a8de13ff6..822dde72e92d85 100644 --- a/cli/tools/jupyter/mod.rs +++ b/cli/tools/jupyter/mod.rs @@ -44,8 +44,8 @@ mod comm; mod install; mod message_types; -use comm::create_zmq_reply; use comm::DealerComm; +use comm::HbComm; use comm::PubComm; pub use install::install; use message_types::*; @@ -85,6 +85,7 @@ struct Kernel { shell_comm: DealerComm, control_comm: DealerComm, stdin_comm: DealerComm, + hb_comm: HbComm, session_id: String, execution_count: u32, repl_session: ReplSession, @@ -114,10 +115,8 @@ pub fn op_print( if is_err { let r = sender.unbounded_send((StdioType::Stderr, msg)); - eprintln!("stdio result {:#?}", r); } else { let r = sender.unbounded_send((StdioType::Stdout, msg)); - eprintln!("stdio result {:#?}", r); } Ok(()) } @@ -162,8 +161,8 @@ impl Kernel { session_id.clone(), hmac_key, ); - - let hb_conn_str = create_conn_str(&spec.transport, &spec.ip, spec.hb_port); + let hb_comm = + HbComm::new(create_conn_str(&spec.transport, &spec.ip, spec.hb_port)); let main_module = resolve_url_or_path("./$deno$jupyter.ts").unwrap(); // TODO(bartlomieju): should we run with all permissions? @@ -187,6 +186,7 @@ impl Kernel { shell_comm, control_comm, stdin_comm, + hb_comm, session_id, execution_count, repl_session, @@ -198,37 +198,41 @@ impl Kernel { } async fn run(&mut self) -> Result<(), AnyError> { - let (iopub_res, shell_res, control_res, stdin_res) = join!( + let (iopub_res, shell_res, control_res, stdin_res, hb_res) = join!( self.iopub_comm.connect(), self.shell_comm.connect(), self.control_comm.connect(), self.stdin_comm.connect(), + self.hb_comm.connect(), ); iopub_res?; shell_res?; control_res?; stdin_res?; - - // TODO(apowers313): run heartbeat - // create_zmq_reply("hb", &hb_conn_str) + hb_res?; // TODO(bartlomieju): errors are not handled here loop { tokio::select! { - shell_msg = self.shell_comm.recv() => { - self.handler(HandlerType::Shell, shell_msg).await; + shell_msg_result = self.shell_comm.recv() => { + self.handler(HandlerType::Shell, shell_msg_result).await; }, - control_msg = self.control_comm.recv() => { - self.handler(HandlerType::Control, control_msg).await; + control_msg_result = self.control_comm.recv() => { + self.handler(HandlerType::Control, control_msg_result).await; }, - stdin_msg = self.stdin_comm.recv() => { - self.handler(HandlerType::Stdin, stdin_msg).await; + stdin_msg_result = self.stdin_comm.recv() => { + self.handler(HandlerType::Stdin, stdin_msg_result).await; }, maybe_stdio_proxy_msg = self.stdio_rx.next() => { if let Some(stdio_proxy_msg) = maybe_stdio_proxy_msg { self.stdio_handler(stdio_proxy_msg).await; } - } + }, + heartbeat_result = self.hb_comm.heartbeat() => { + if let Err(e) = heartbeat_result { + println!("[heartbeat] error: {}", e); + } + }, } } } From 6213db21f41b12bcb40f91329e090c5e6cf74b95 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Sun, 26 Dec 2021 15:04:37 +0100 Subject: [PATCH 040/115] logging, zmq 0.3.2 --- Cargo.lock | 5 +++-- cli/Cargo.toml | 2 +- cli/tools/jupyter/mod.rs | 30 +++++++++++++++++------------- 3 files changed, 21 insertions(+), 16 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 763fa41adf5b6d..e52d18d880cee2 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -5148,8 +5148,9 @@ dependencies = [ [[package]] name = "zeromq" -version = "0.3.1" -source = "git+https://github.com/bartlomieju/zmq.rs?branch=master#d92c2b5ce2b3d787abcbc56d6ae94e1a9a04e216" +version = "0.3.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "66b9ebf6a24cc77c2c7053f8f0df07e6261abc5166c060d874efc828080c7316" dependencies = [ "async-trait", "asynchronous-codec", diff --git a/cli/Cargo.toml b/cli/Cargo.toml index fca2617468429e..073b92c03c4bfb 100644 --- a/cli/Cargo.toml +++ b/cli/Cargo.toml @@ -85,7 +85,7 @@ text-size = "=1.1.0" tokio = { version = "=1.14", features = ["full"] } uuid = { version = "=0.8.2", features = ["v4", "serde"] } walkdir = "=2.3.2" -zeromq = { version = "0.3.1", default-features = false, features = ["tcp-transport", "tokio-runtime"], git = "https://github.com/bartlomieju/zmq.rs", branch = "master" } +zeromq = { version = "0.3.2", default-features = false, features = ["tcp-transport", "tokio-runtime"] } [target.'cfg(windows)'.dependencies] fwdansi = "=1.1.0" diff --git a/cli/tools/jupyter/mod.rs b/cli/tools/jupyter/mod.rs index 822dde72e92d85..b321e445bbcd00 100644 --- a/cli/tools/jupyter/mod.rs +++ b/cli/tools/jupyter/mod.rs @@ -198,20 +198,22 @@ impl Kernel { } async fn run(&mut self) -> Result<(), AnyError> { - let (iopub_res, shell_res, control_res, stdin_res, hb_res) = join!( - self.iopub_comm.connect(), - self.shell_comm.connect(), - self.control_comm.connect(), - self.stdin_comm.connect(), - self.hb_comm.connect(), - ); - iopub_res?; - shell_res?; - control_res?; - stdin_res?; - hb_res?; + println!("Connecting to iopub"); + self.iopub_comm.connect().await?; + println!("Connected to iopub"); + println!("Connecting to shell"); + self.shell_comm.connect().await?; + println!("Connected to shell"); + println!("Connecting to control"); + self.control_comm.connect().await?; + println!("Connected to control"); + println!("Connecting to stdin"); + self.stdin_comm.connect().await?; + println!("Connecting to iopub"); + println!("Connected to heartbeat"); + self.hb_comm.connect().await?; + println!("Connected to heartbeat"); - // TODO(bartlomieju): errors are not handled here loop { tokio::select! { shell_msg_result = self.shell_comm.recv() => { @@ -329,6 +331,8 @@ impl Kernel { if let Err(e) = result { println!("[shell] error handling {}: {}", msg_type, e); + } else { + println!("[shell] ok {}", msg_type); } Ok(()) From c62b198de2d395d79980113b0c3a1cf605c86605 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Sun, 26 Dec 2021 15:08:32 +0100 Subject: [PATCH 041/115] fix logging --- cli/tools/jupyter/mod.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/cli/tools/jupyter/mod.rs b/cli/tools/jupyter/mod.rs index b321e445bbcd00..36ee45f75e1b6b 100644 --- a/cli/tools/jupyter/mod.rs +++ b/cli/tools/jupyter/mod.rs @@ -209,8 +209,8 @@ impl Kernel { println!("Connected to control"); println!("Connecting to stdin"); self.stdin_comm.connect().await?; - println!("Connecting to iopub"); - println!("Connected to heartbeat"); + println!("Connected to stdin"); + println!("Connecting to heartbeat"); self.hb_comm.connect().await?; println!("Connected to heartbeat"); From 45003eff5f82417ac2e623787d8883543173528f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Sun, 26 Dec 2021 18:16:33 +0100 Subject: [PATCH 042/115] poll worker in a loop --- cli/tools/jupyter/mod.rs | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/cli/tools/jupyter/mod.rs b/cli/tools/jupyter/mod.rs index 36ee45f75e1b6b..7224521611b666 100644 --- a/cli/tools/jupyter/mod.rs +++ b/cli/tools/jupyter/mod.rs @@ -214,16 +214,20 @@ impl Kernel { self.hb_comm.connect().await?; println!("Connected to heartbeat"); + let mut poll_worker = true; loop { tokio::select! { shell_msg_result = self.shell_comm.recv() => { self.handler(HandlerType::Shell, shell_msg_result).await; + poll_worker = true; }, control_msg_result = self.control_comm.recv() => { self.handler(HandlerType::Control, control_msg_result).await; + poll_worker = true; }, stdin_msg_result = self.stdin_comm.recv() => { self.handler(HandlerType::Stdin, stdin_msg_result).await; + poll_worker = true; }, maybe_stdio_proxy_msg = self.stdio_rx.next() => { if let Some(stdio_proxy_msg) = maybe_stdio_proxy_msg { @@ -235,6 +239,9 @@ impl Kernel { println!("[heartbeat] error: {}", e); } }, + _ = self.repl_session.run_event_loop(), if poll_worker => { + poll_worker = false; + } } } } From 494c3a2e005f94a4dcf95698f120611de1781d4c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Sun, 26 Dec 2021 22:56:20 +0100 Subject: [PATCH 043/115] more debug logging --- cli/tools/jupyter/comm.rs | 1 + cli/tools/jupyter/mod.rs | 4 ++++ 2 files changed, 5 insertions(+) diff --git a/cli/tools/jupyter/comm.rs b/cli/tools/jupyter/comm.rs index 5a09077fcf8bdf..63cd8fd8c69f0e 100644 --- a/cli/tools/jupyter/comm.rs +++ b/cli/tools/jupyter/comm.rs @@ -98,6 +98,7 @@ impl DealerComm { println!("==> {} SENDING: {:#?}", self.name, msg); let zmq_msg = msg.serialize(&self.hmac_key); self.socket.send(zmq_msg).await?; + println!("==> {} SENT", self.name); Ok(()) } } diff --git a/cli/tools/jupyter/mod.rs b/cli/tools/jupyter/mod.rs index 7224521611b666..bdeb933f66d0a9 100644 --- a/cli/tools/jupyter/mod.rs +++ b/cli/tools/jupyter/mod.rs @@ -93,6 +93,7 @@ struct Kernel { last_comm_ctx: Option, } +#[derive(Copy, Clone, Debug)] enum HandlerType { Shell, Control, @@ -265,6 +266,7 @@ impl Kernel { }; self.last_comm_ctx = Some(comm_ctx.clone()); + println!("[DENO] set_state busy {:#?}", handler_type); self.set_state(&comm_ctx, KernelState::Busy).await; let major_version = &comm_ctx.message.header.version.to_string()[0..1]; @@ -290,6 +292,7 @@ impl Kernel { } }; + println!("[DENO] set_state idle {:#?}", handler_type); self.set_state(&comm_ctx, KernelState::Idle).await; } @@ -355,6 +358,7 @@ impl Kernel { async fn set_state(&mut self, comm_ctx: &CommContext, state: KernelState) { if self.state == state { + println!("[DENO] set_state sets the same state: {:#?}", state); return; } From 20ff23ecc7895c6b485ad6cf03f5f05452d55a3f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Mon, 27 Dec 2021 16:13:57 +0100 Subject: [PATCH 044/115] upgrade zmq.rs to 0.3.3 --- Cargo.lock | 4 ++-- cli/Cargo.toml | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index e52d18d880cee2..5de454483b215a 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -5148,9 +5148,9 @@ dependencies = [ [[package]] name = "zeromq" -version = "0.3.2" +version = "0.3.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "66b9ebf6a24cc77c2c7053f8f0df07e6261abc5166c060d874efc828080c7316" +checksum = "667ece59294ccaf617fcf2e5decc9114a06427c1f68990028b9f12d322686bdc" dependencies = [ "async-trait", "asynchronous-codec", diff --git a/cli/Cargo.toml b/cli/Cargo.toml index 073b92c03c4bfb..90607bd7d62cfb 100644 --- a/cli/Cargo.toml +++ b/cli/Cargo.toml @@ -85,7 +85,7 @@ text-size = "=1.1.0" tokio = { version = "=1.14", features = ["full"] } uuid = { version = "=0.8.2", features = ["v4", "serde"] } walkdir = "=2.3.2" -zeromq = { version = "0.3.2", default-features = false, features = ["tcp-transport", "tokio-runtime"] } +zeromq = { version = "0.3.3", default-features = false, features = ["tcp-transport", "tokio-runtime"] } [target.'cfg(windows)'.dependencies] fwdansi = "=1.1.0" From ecfc9ded7d9fbe64d550b9cf871d9979ab2aaed6 Mon Sep 17 00:00:00 2001 From: Adam Powers Date: Mon, 27 Dec 2021 09:11:05 -0800 Subject: [PATCH 045/115] refactor exec results, implement display data --- cli/tools/jupyter/message_types.rs | 44 ++++-- cli/tools/jupyter/mod.rs | 218 +++++++++++++++++++++++++---- 2 files changed, 219 insertions(+), 43 deletions(-) diff --git a/cli/tools/jupyter/message_types.rs b/cli/tools/jupyter/message_types.rs index a3796b25e4637b..9ced4cc1a137d0 100644 --- a/cli/tools/jupyter/message_types.rs +++ b/cli/tools/jupyter/message_types.rs @@ -46,9 +46,10 @@ impl TryFrom for RequestMessage { let content_bytes = zmq_msg.get(5).unwrap(); let header: MessageHeader = serde_json::from_slice(header_bytes).unwrap(); + let msg_type = header.msg_type.clone(); // TODO(apowers313) refactor to an unwrap function to handles unwrapping based on different protocol versions - let mc = match header.msg_type.as_ref() { + let mc = match msg_type.as_ref() { "kernel_info_request" => (RequestMetadata::Empty, RequestContent::Empty), "execute_request" => ( RequestMetadata::Empty, @@ -58,7 +59,7 @@ impl TryFrom for RequestMessage { }; let rm = RequestMessage::new(header, mc.0, mc.1); - println!("<== RECEIVING: {:#?}", rm); + println!("<== RECEIVING MSG [{}]: {:#?}", msg_type, rm); Ok(rm) } @@ -99,11 +100,14 @@ impl ReplyMessage { // reply messages ReplyContent::KernelInfo(c) => serde_json::to_string(&c).unwrap(), ReplyContent::ExecuteReply(c) => serde_json::to_string(&c).unwrap(), + ReplyContent::ExecuteError(c) => serde_json::to_string(&c).unwrap(), // side effects ReplyContent::Status(c) => serde_json::to_string(&c).unwrap(), ReplyContent::Stream(c) => serde_json::to_string(&c).unwrap(), ReplyContent::ExecuteInput(c) => serde_json::to_string(&c).unwrap(), ReplyContent::ExecuteResult(c) => serde_json::to_string(&c).unwrap(), + ReplyContent::Error(c) => serde_json::to_string(&c).unwrap(), + ReplyContent::DisplayData(c) => serde_json::to_string(&c).unwrap(), }; let hmac = @@ -115,7 +119,10 @@ impl ReplyMessage { zmq_msg.push_back(parent_header.into()); zmq_msg.push_back(metadata.into()); zmq_msg.push_back(content.into()); - println!("==> SENDING ZMQ MSG: {:#?}", zmq_msg); + println!( + "==> SENDING MSG [{}]: {:#?}", + &self.header.msg_type, zmq_msg + ); zmq_msg } } @@ -193,11 +200,14 @@ pub enum ReplyContent { // Reply Messages KernelInfo(KernelInfoReplyContent), ExecuteReply(ExecuteReplyContent), + ExecuteError(ExecuteErrorContent), // Side Effects Status(KernelStatusContent), Stream(StreamContent), ExecuteInput(ExecuteInputContent), ExecuteResult(ExecuteResultContent), + Error(ErrorContent), + DisplayData(DisplayDataContent), } #[derive(Clone, Debug, Serialize, Deserialize)] @@ -229,6 +239,7 @@ pub struct ExecuteReplyContent { pub execution_count: u32, // These two fields are unused pub payload: Vec, + // #[serde(skip_serializing_if = "Option::is_none")] pub user_expressions: Value, } @@ -392,12 +403,11 @@ pub struct InterruptReplyContent { // "comm_close" /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#tearing-down-comms /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#request-reply -pub struct ErrorStatusContent { - pub status: String, // "error" +#[derive(Debug, Serialize, Deserialize)] +pub struct ErrorContent { pub ename: String, pub evalue: String, pub traceback: Vec, - pub execution_count: Option, } /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#request-reply @@ -414,10 +424,11 @@ pub struct StreamContent { } /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#display-data +#[derive(Debug, Serialize, Deserialize)] pub struct DisplayDataContent { pub data: Value, - pub metadata: Option, - pub transient: Option, + pub metadata: Value, + pub transient: Value, } /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#update-display-data @@ -434,14 +445,21 @@ pub struct ExecuteInputContent { #[derive(Debug, Serialize, Deserialize)] pub struct ExecuteResultContent { pub execution_count: u32, - pub data: Option, - pub metadata: Option, + pub data: Value, + pub metadata: Value, } /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#execution-errors -pub struct ErrorContent { - pub payload: Option>, - pub user_expressions: Option, +/// https://jupyter-client.readthedocs.io/en/latest/messaging.html#messages-on-the-shell-router-dealer-channel +#[derive(Debug, Serialize, Deserialize)] +pub struct ExecuteErrorContent { + pub status: String, + pub payload: Vec, + pub user_expressions: Value, + // XXX: the spec says one thing and the ipykernal does another... the following three fields are included by the ipykernel + pub ename: String, + pub evalue: String, + pub traceback: Vec, } /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-status diff --git a/cli/tools/jupyter/mod.rs b/cli/tools/jupyter/mod.rs index 6d3b78a6e791de..256ba35f8c9e7d 100644 --- a/cli/tools/jupyter/mod.rs +++ b/cli/tools/jupyter/mod.rs @@ -433,6 +433,39 @@ impl Kernel { .repl_session .evaluate_line_and_get_output(&exec_request_content.code) .await?; + + let test_svg = r###" + + + + + +"###.to_string(); + let mut dd = DisplayData::new(); + dd.add("image/svg+xml", test_svg); + let dd_msg = SideEffectMessage::new( + comm_ctx, + "display_data", + ReplyMetadata::Empty, + ReplyContent::DisplayData(DisplayDataContent { + data: dd.to_value()?, + metadata: json!({}), + transient: json!({}), + }), + ); + self.iopub_comm.send(dd_msg).await?; + + // let output = self + // .repl_session + // .evaluate_line_with_object_wrapping(&exec_request_content.code) + // .await?; + // let dd = create_display_data(output.result); + // dbg!(dd); let result = match output { EvaluationOutput::Value(value_str) => ExecResult::OkString(value_str), EvaluationOutput::Error(value_str) => ExecResult::Error(ExecError { @@ -441,51 +474,115 @@ impl Kernel { stack_trace: vec![], }), }; - self.exec_done(comm_ctx, result).await?; + + match &result { + ExecResult::OkString(v) => { + self.send_execute_reply_ok(comm_ctx).await?; + self.send_execute_result(comm_ctx, &result).await?; + } + ExecResult::Error(e) => { + self.send_execute_reply_error(comm_ctx, &result).await?; + self.send_error(comm_ctx, &result).await?; + } + }; Ok(()) } - async fn exec_done( + async fn send_execute_reply_ok( &mut self, comm_ctx: &CommContext, - result: ExecResult, ) -> Result<(), AnyError> { - match &result { - ExecResult::OkString(v) => { - println!("sending exec result"); - let msg = ReplyMessage::new( - comm_ctx, - "execute_reply", - ReplyMetadata::Empty, - ReplyContent::ExecuteReply(ExecuteReplyContent { - status: "ok".to_string(), - execution_count: self.execution_count, - // NOTE(bartlomieju): these two fields are always empty - payload: vec![], - user_expressions: json!({}), - }), - ); - self.shell_comm.send(msg).await?; - } - ExecResult::Error(e) => { - println!("Not implemented: sending exec ERROR"); - } + println!("sending exec result"); + let msg = ReplyMessage::new( + comm_ctx, + "execute_reply", + ReplyMetadata::Empty, + ReplyContent::ExecuteReply(ExecuteReplyContent { + status: "ok".to_string(), + execution_count: self.execution_count, + // NOTE(bartlomieju): these two fields are always empty + payload: vec![], + user_expressions: json!({}), + }), + ); + self.shell_comm.send(msg).await?; + + Ok(()) + } + + async fn send_execute_reply_error( + &mut self, + comm_ctx: &CommContext, + result: &ExecResult, + ) -> Result<(), AnyError> { + let e = match result { + ExecResult::Error(e) => e, + _ => return Err(anyhow!("unreachable")), + }; + let msg = ReplyMessage::new( + comm_ctx, + "execute_reply", + ReplyMetadata::Empty, + ReplyContent::ExecuteError(ExecuteErrorContent { + status: "error".to_string(), + payload: vec![], + user_expressions: json!({}), + // TODO(apowers313) implement error messages + ename: e.err_name.clone(), + evalue: e.err_value.clone(), + traceback: e.stack_trace.clone(), + }), + ); + self.shell_comm.send(msg).await?; + + Ok(()) + } + + async fn send_error( + &mut self, + comm_ctx: &CommContext, + result: &ExecResult, + ) -> Result<(), AnyError> { + let e = match result { + ExecResult::Error(e) => e, + _ => return Err(anyhow!("unreachable")), }; + let msg = SideEffectMessage::new( + comm_ctx, + "error", + ReplyMetadata::Empty, + ReplyContent::Error(ErrorContent { + ename: e.err_name.clone(), + evalue: e.err_value.clone(), + traceback: e.stack_trace.clone(), + }), + ); + self.iopub_comm.send(msg); + Ok(()) + } + + async fn send_execute_result( + &mut self, + comm_ctx: &CommContext, + result: &ExecResult, + ) -> Result<(), AnyError> { + let text_result = match result { + ExecResult::OkString(v) => v, + _ => return Err(anyhow!("unreachable")), + }; + let mut dd = DisplayData::new(); + dd.add("text/plain", text_result.to_string()); + let data = dd.to_value()?; let msg = SideEffectMessage::new( comm_ctx, "execute_result", ReplyMetadata::Empty, ReplyContent::ExecuteResult(ExecuteResultContent { execution_count: self.execution_count, - data: Some(json!({ - "text/plain": match result { - ExecResult::OkString(v) => v, - ExecResult::Error(v) => v.err_value, - } - })), - metadata: None, + data, + metadata: json!({}), }), ); self.iopub_comm.send(msg).await?; @@ -518,8 +615,69 @@ impl Kernel { Ok(()) } + + async fn send_display_data( + &mut self, + comm_ctx: &CommContext, + display_data: DisplayData, + ) -> Result<(), AnyError> { + let data = display_data.to_value()?; + + let msg = SideEffectMessage::new( + comm_ctx, + "display_data", + ReplyMetadata::Empty, + ReplyContent::DisplayData(DisplayDataContent { + data, + metadata: json!({}), + transient: json!({}), + }), + ); + self.iopub_comm.send(msg); + + Ok(()) + } +} + +struct DisplayData { + data_list: Vec<(String, String)>, +} + +impl DisplayData { + fn new() -> DisplayData { + Self { data_list: vec![] } + } + + fn add(&mut self, mime_type: &str, data: String) { + self.data_list.push((mime_type.to_string(), data)); + } + + fn to_value(&self) -> Result { + if self.data_list.len() < 1 { + return Err(anyhow!("expected at least one data type")); + } + + let mut data = json!({}); + for d in self.data_list.iter() { + data[&d.0] = json!(&d.1); + } + + Ok(data) + } } +// fn value_to_error(v: Value) -> Option(ErrorValue) { +// if !v["exceptionDetails"].is_object() { +// None +// } else { +// ErrorValue { +// // v["exceptionDetails"] +// } +// } +// } + +struct ErrorValue {} + enum ExecResult { OkString(String), // TODO(apowers313) From 2aefff1267eeec3da730248bca67e179fdf574a0 Mon Sep 17 00:00:00 2001 From: Adam Powers Date: Mon, 27 Dec 2021 14:45:12 -0800 Subject: [PATCH 046/115] improve exec result decoding --- cli/tools/jupyter/mod.rs | 218 ++++++++++++++++------- cli/tools/repl/session.rs | 8 +- integration_test.ipynb | 354 ++++++++++++++++++++++++++++++++++++++ 3 files changed, 513 insertions(+), 67 deletions(-) create mode 100644 integration_test.ipynb diff --git a/cli/tools/jupyter/mod.rs b/cli/tools/jupyter/mod.rs index 15085b4c95934a..243ae1c29c0e54 100644 --- a/cli/tools/jupyter/mod.rs +++ b/cli/tools/jupyter/mod.rs @@ -32,6 +32,7 @@ use deno_runtime::permissions::Permissions; use deno_runtime::worker::MainWorker; use ring::hmac; use std::collections::HashMap; +use std::convert::From; use std::env::current_exe; use std::time::Duration; use tempfile::TempDir; @@ -442,58 +443,66 @@ impl Kernel { ); self.iopub_comm.send(input_msg).await?; - let output = self - .repl_session - .evaluate_line_and_get_output(&exec_request_content.code) - .await?; - - let test_svg = r###" - - - - - -"###.to_string(); - let mut dd = DisplayData::new(); - dd.add("image/svg+xml", test_svg); - let dd_msg = SideEffectMessage::new( - comm_ctx, - "display_data", - ReplyMetadata::Empty, - ReplyContent::DisplayData(DisplayDataContent { - data: dd.to_value()?, - metadata: json!({}), - transient: json!({}), - }), - ); - self.iopub_comm.send(dd_msg).await?; - // let output = self // .repl_session - // .evaluate_line_with_object_wrapping(&exec_request_content.code) + // .evaluate_line_and_get_output(&exec_request_content.code) // .await?; - // let dd = create_display_data(output.result); - // dbg!(dd); - let result = match output { - EvaluationOutput::Value(value_str) => ExecResult::OkString(value_str), - EvaluationOutput::Error(value_str) => ExecResult::Error(ExecError { - err_name: "".to_string(), - err_value: value_str, + + // let test_svg = r###" + // + // + // + // + // + // "###.to_string(); + // let mut dd = DisplayData::new(); + // dd.add("image/svg+xml", test_svg); + // let dd_msg = SideEffectMessage::new( + // comm_ctx, + // "display_data", + // ReplyMetadata::Empty, + // ReplyContent::DisplayData(DisplayDataContent { + // data: dd.to_value()?, + // metadata: json!({}), + // transient: json!({}), + // }), + // ); + // self.iopub_comm.send(dd_msg).await?; + + println!("---- executing code..."); + let output = self + .repl_session + .evaluate_line_with_object_wrapping(&exec_request_content.code) + .await?; + println!("---- done executing code."); + + let result = if output.value["exceptionDetails"].is_object() { + ExecResult::Error(ExecError { + // TODO(apowers313) this could probably use smarter unwrapping -- for example, someone may throw non-object + err_name: output.value["exceptionDetails"]["exception"]["className"] + .to_string(), + err_value: output.value["exceptionDetails"]["exception"]["description"] + .to_string(), + // output.value["exceptionDetails"]["stackTrace"]["callFrames"] stack_trace: vec![], - }), + }) + } else { + ExecResult::Ok(output.value["result"].clone()) }; - match &result { - ExecResult::OkString(v) => { + match result { + ExecResult::Ok(_) => { + println!("XXX result ok"); self.send_execute_reply_ok(comm_ctx).await?; self.send_execute_result(comm_ctx, &result).await?; } - ExecResult::Error(e) => { + ExecResult::Error(_) => { + println!("XXX result error"); self.send_execute_reply_error(comm_ctx, &result).await?; self.send_error(comm_ctx, &result).await?; } @@ -519,6 +528,7 @@ impl Kernel { user_expressions: json!({}), }), ); + println!("+++ Sending execute reply ok"); self.shell_comm.send(msg).await?; Ok(()) @@ -531,7 +541,7 @@ impl Kernel { ) -> Result<(), AnyError> { let e = match result { ExecResult::Error(e) => e, - _ => return Err(anyhow!("unreachable")), + _ => return Err(anyhow!("send_execute_reply_error: unreachable")), }; let msg = ReplyMessage::new( comm_ctx, @@ -547,6 +557,7 @@ impl Kernel { traceback: e.stack_trace.clone(), }), ); + println!("+++ Sending execute reply error"); self.shell_comm.send(msg).await?; Ok(()) @@ -559,7 +570,7 @@ impl Kernel { ) -> Result<(), AnyError> { let e = match result { ExecResult::Error(e) => e, - _ => return Err(anyhow!("unreachable")), + _ => return Err(anyhow!("send_error: unreachable")), }; let msg = SideEffectMessage::new( comm_ctx, @@ -571,6 +582,7 @@ impl Kernel { traceback: e.stack_trace.clone(), }), ); + println!("+++ Sending IOPub error"); self.iopub_comm.send(msg); Ok(()) @@ -581,23 +593,27 @@ impl Kernel { comm_ctx: &CommContext, result: &ExecResult, ) -> Result<(), AnyError> { - let text_result = match result { - ExecResult::OkString(v) => v, - _ => return Err(anyhow!("unreachable")), + let v = match result { + ExecResult::Ok(v) => v, + _ => return Err(anyhow!("send_execute_result: unreachable")), }; - let mut dd = DisplayData::new(); - dd.add("text/plain", text_result.to_string()); - let data = dd.to_value()?; + let mut display_data = DisplayData::from(v.clone()); + if display_data.is_empty() { + return Ok(()); + } + let msg = SideEffectMessage::new( comm_ctx, "execute_result", ReplyMetadata::Empty, ReplyContent::ExecuteResult(ExecuteResultContent { execution_count: self.execution_count, - data, + data: display_data.to_object(), + // data: json!(""), metadata: json!({}), }), ); + println!("+++ Sending execute result"); self.iopub_comm.send(msg).await?; Ok(()) @@ -634,7 +650,7 @@ impl Kernel { comm_ctx: &CommContext, display_data: DisplayData, ) -> Result<(), AnyError> { - let data = display_data.to_value()?; + let data = display_data.to_object(); let msg = SideEffectMessage::new( comm_ctx, @@ -653,7 +669,7 @@ impl Kernel { } struct DisplayData { - data_list: Vec<(String, String)>, + data_list: Vec<(String, Value)>, } impl DisplayData { @@ -661,21 +677,100 @@ impl DisplayData { Self { data_list: vec![] } } - fn add(&mut self, mime_type: &str, data: String) { + fn add(&mut self, mime_type: &str, data: Value) { self.data_list.push((mime_type.to_string(), data)); } - fn to_value(&self) -> Result { - if self.data_list.len() < 1 { - return Err(anyhow!("expected at least one data type")); + fn is_empty(&self) -> bool { + if self.data_list.len() == 0 { + return true; } + return false; + } + + fn to_object(&self) -> Value { let mut data = json!({}); for d in self.data_list.iter() { data[&d.0] = json!(&d.1); } - Ok(data) + data + } +} + +impl From for DisplayData { + fn from(data: Value) -> Self { + dbg!(&data); + let mut d = &data; + let mut ret = DisplayData::new(); + // if we passed in a result, unwrap it + d = if d["result"].is_object() { + &d["result"] + } else { + d + }; + + if !d["type"].is_string() { + // not an execution result + return ret; + } + + let t = match &d["type"] { + serde_json::Value::String(x) => x.to_string(), + _ => return ret, + }; + + match t.as_ref() { + // TODO(apowers313) inspect object / call toPng, toHtml, toSvg, toText, toMime + "object" => { + // TODO: this description isn't very useful + ret.add("text/plain", d["description"].clone()); + ret.add("application/json", d["description"].clone()); + } + "string" => { + ret.add("text/plain", d["value"].clone()); + ret.add("application/json", d["value"].clone()); + } + "null" => { + ret.add( + "text/plain", + serde_json::Value::String(d["value"].to_string()), + ); + ret.add("application/json", d["value"].clone()); + } + "bigint" => { + // TODO: hmmm... is this really what we want? + ret.add("text/plain", d["unserializableValue"].clone()); + ret.add("application/json", d["unserializableValue"].clone()); + } + "symbol" => { + ret.add("text/plain", d["description"].clone()); + ret.add("application/json", d["description"].clone()); + } + "boolean" => { + ret.add( + "text/plain", + serde_json::Value::String(d["value"].to_string()), + ); + ret.add("application/json", d["value"].clone()); + } + "number" => { + ret.add( + "text/plain", + serde_json::Value::String(d["value"].to_string()), + ); + ret.add("application/json", d["value"].clone()); + } + // TODO(apowers313) currently ignoring "undefined" return value, I think most kernels make this a configuration option + "undefined" => return ret, + _ => { + println!("unknown type in DisplayData::from: {}", t); + return ret; + } + }; + + ret } } @@ -692,10 +787,7 @@ impl DisplayData { struct ErrorValue {} enum ExecResult { - OkString(String), - // TODO(apowers313) - // OkValue(Value), - // OkDisplayData(DisplayDataContent), + Ok(Value), Error(ExecError), } diff --git a/cli/tools/repl/session.rs b/cli/tools/repl/session.rs index bc9f215fff27a0..8de669d799b273 100644 --- a/cli/tools/repl/session.rs +++ b/cli/tools/repl/session.rs @@ -57,9 +57,9 @@ impl std::fmt::Display for EvaluationOutput { } } -struct TsEvaluateResponse { - ts_code: String, - value: Value, +pub struct TsEvaluateResponse { + pub ts_code: String, + pub value: Value, } pub struct ReplSession { @@ -200,7 +200,7 @@ impl ReplSession { } } - async fn evaluate_line_with_object_wrapping( + pub async fn evaluate_line_with_object_wrapping( &mut self, line: &str, ) -> Result { diff --git a/integration_test.ipynb b/integration_test.ipynb new file mode 100644 index 00000000000000..264ac1eb15f135 --- /dev/null +++ b/integration_test.ipynb @@ -0,0 +1,354 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "182aef1d", + "metadata": {}, + "source": [ + "# Integration Tests for Deno Jupyter\n", + "This notebook contains a number of tests to ensure that Jupyter is working as expected. You should be able to select \"Kernel->Restart and Run All\" in Jupyter's notebook UI to run the tests. The first section of tests named \"Passing Tests\" should pass. The second set of tests \"Failing Tests\" should fail. When in doubt, refer to the currently committed notebook file to make sure tests pass." + ] + }, + { + "cell_type": "markdown", + "id": "d7705d88", + "metadata": {}, + "source": [ + "## Passing Tests" + ] + }, + { + "cell_type": "markdown", + "id": "669f972e", + "metadata": {}, + "source": [ + "### Simple Tests" + ] + }, + { + "cell_type": "markdown", + "id": "e7e8a512", + "metadata": {}, + "source": [ + "#### This test should print \"hi\".\n", + "If this doesn't work, everything else will probably fail :)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a5d38758", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "hi\n" + ] + } + ], + "source": [ + "console.log(\"hi\")" + ] + }, + { + "cell_type": "markdown", + "id": "eaa0ebc0", + "metadata": {}, + "source": [ + "### Return Values" + ] + }, + { + "cell_type": "markdown", + "id": "52876276", + "metadata": {}, + "source": [ + "#### undefined should not return a value" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bbf2c09b", + "metadata": {}, + "outputs": [], + "source": [ + "undefined" + ] + }, + { + "cell_type": "markdown", + "id": "e175c803", + "metadata": {}, + "source": [ + "#### null should return \"null\"" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "d9801d80", + "metadata": {}, + "outputs": [ + { + "data": { + "application/json": null + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "null" + ] + }, + { + "cell_type": "markdown", + "id": "a2a716dc", + "metadata": {}, + "source": [ + "#### boolean should return the boolean" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cfaac330", + "metadata": {}, + "outputs": [ + { + "data": { + "application/json": true, + "text/plain": [ + "true" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "true" + ] + }, + { + "cell_type": "markdown", + "id": "8d9f1aba", + "metadata": {}, + "source": [ + "#### number should return the number" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "ec3be2da", + "metadata": {}, + "outputs": [ + { + "data": { + "application/json": 42, + "text/plain": [ + "42" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "42" + ] + }, + { + "cell_type": "markdown", + "id": "60965915", + "metadata": {}, + "source": [ + "#### string should return the string" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "997cf2d7", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "this is a test of the emergency broadcast system" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\"this is a test of the emergency broadcast system\"" + ] + }, + { + "cell_type": "markdown", + "id": "fe38dc27", + "metadata": {}, + "source": [ + "#### bigint should return the bigint in literal format" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "44b63807", + "metadata": {}, + "outputs": [ + { + "data": { + "application/json": "31337n", + "text/plain": [ + "31337n" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "31337n" + ] + }, + { + "cell_type": "markdown", + "id": "843ccb6c", + "metadata": {}, + "source": [ + "#### symbol should return a string describing the symbol" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "e10c0d31", + "metadata": {}, + "outputs": [ + { + "data": { + "application/json": "Symbol(foo)", + "text/plain": [ + "Symbol(foo)" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Symbol(\"foo\")" + ] + }, + { + "cell_type": "markdown", + "id": "171b817f", + "metadata": {}, + "source": [ + "#### object should describe the object inspection" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "81c99233", + "metadata": {}, + "outputs": [ + { + "data": { + "application/json": "Object", + "text/plain": [ + "Object" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "{foo: \"bar\"}" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "c065ff3d", + "metadata": {}, + "outputs": [ + { + "data": { + "application/json": "Object", + "text/plain": [ + "Object" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Deno" + ] + }, + { + "cell_type": "markdown", + "id": "3a89dada", + "metadata": {}, + "source": [ + "#### object with Symbol(\"toPng\") should return an image" + ] + }, + { + "cell_type": "markdown", + "id": "3b6d484c", + "metadata": {}, + "source": [ + "## Failing Tests" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Deno (Rust)", + "language": "typescript", + "name": "rusty_deno" + }, + "language_info": { + "file_extension": ".ts", + "mimetype": "text/x.typescript", + "name": "typescript", + "version": "4.5.2" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From cd8940cffa38a82e072677a6444e9690de5d6c1c Mon Sep 17 00:00:00 2001 From: Adam Powers Date: Mon, 27 Dec 2021 15:23:43 -0800 Subject: [PATCH 047/115] fix null exec result, delint --- cli/tools/jupyter/mod.rs | 36 +++++++++++++++++------------------- integration_test.ipynb | 30 +++++++++++++++++------------- 2 files changed, 34 insertions(+), 32 deletions(-) diff --git a/cli/tools/jupyter/mod.rs b/cli/tools/jupyter/mod.rs index 243ae1c29c0e54..8dc4d9ad1431be 100644 --- a/cli/tools/jupyter/mod.rs +++ b/cli/tools/jupyter/mod.rs @@ -474,12 +474,10 @@ impl Kernel { // ); // self.iopub_comm.send(dd_msg).await?; - println!("---- executing code..."); let output = self .repl_session .evaluate_line_with_object_wrapping(&exec_request_content.code) .await?; - println!("---- done executing code."); let result = if output.value["exceptionDetails"].is_object() { ExecResult::Error(ExecError { @@ -497,12 +495,10 @@ impl Kernel { match result { ExecResult::Ok(_) => { - println!("XXX result ok"); self.send_execute_reply_ok(comm_ctx).await?; self.send_execute_result(comm_ctx, &result).await?; } ExecResult::Error(_) => { - println!("XXX result error"); self.send_execute_reply_error(comm_ctx, &result).await?; self.send_error(comm_ctx, &result).await?; } @@ -650,6 +646,9 @@ impl Kernel { comm_ctx: &CommContext, display_data: DisplayData, ) -> Result<(), AnyError> { + if (display_data.is_empty()) { + return Err(anyhow!("send_display_data called with empty DisplayData")); + } let data = display_data.to_object(); let msg = SideEffectMessage::new( @@ -716,11 +715,18 @@ impl From for DisplayData { return ret; } - let t = match &d["type"] { - serde_json::Value::String(x) => x.to_string(), + let mut t = match &d["type"] { + Value::String(x) => x.to_string(), _ => return ret, }; + if t == "object".to_string() + && d["subtype"] == Value::String("null".to_string()) + { + // JavaScript null, the gift that keeps on giving + t = "null".to_string(); + } + match t.as_ref() { // TODO(apowers313) inspect object / call toPng, toHtml, toSvg, toText, toMime "object" => { @@ -733,11 +739,9 @@ impl From for DisplayData { ret.add("application/json", d["value"].clone()); } "null" => { - ret.add( - "text/plain", - serde_json::Value::String(d["value"].to_string()), - ); - ret.add("application/json", d["value"].clone()); + println!("XXX NEW NULL"); + ret.add("text/plain", Value::String("null".to_string())); + ret.add("application/json", Value::Null); } "bigint" => { // TODO: hmmm... is this really what we want? @@ -749,17 +753,11 @@ impl From for DisplayData { ret.add("application/json", d["description"].clone()); } "boolean" => { - ret.add( - "text/plain", - serde_json::Value::String(d["value"].to_string()), - ); + ret.add("text/plain", Value::String(d["value"].to_string())); ret.add("application/json", d["value"].clone()); } "number" => { - ret.add( - "text/plain", - serde_json::Value::String(d["value"].to_string()), - ); + ret.add("text/plain", Value::String(d["value"].to_string())); ret.add("application/json", d["value"].clone()); } // TODO(apowers313) currently ignoring "undefined" return value, I think most kernels make this a configuration option diff --git a/integration_test.ipynb b/integration_test.ipynb index 264ac1eb15f135..a2f950ab0d1f7c 100644 --- a/integration_test.ipynb +++ b/integration_test.ipynb @@ -36,7 +36,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "a5d38758", "metadata": {}, "outputs": [ @@ -70,7 +70,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "id": "bbf2c09b", "metadata": {}, "outputs": [], @@ -88,15 +88,18 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 5, "id": "d9801d80", "metadata": {}, "outputs": [ { "data": { - "application/json": null + "application/json": null, + "text/plain": [ + "null" + ] }, - "execution_count": 8, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -115,7 +118,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "id": "cfaac330", "metadata": {}, "outputs": [ @@ -126,7 +129,7 @@ "true" ] }, - "execution_count": 4, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -145,7 +148,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "id": "ec3be2da", "metadata": {}, "outputs": [ @@ -156,7 +159,7 @@ "42" ] }, - "execution_count": 6, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -175,17 +178,18 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 8, "id": "997cf2d7", "metadata": {}, "outputs": [ { "data": { + "application/json": "this is a test of the emergency broadcast system", "text/plain": [ "this is a test of the emergency broadcast system" ] }, - "execution_count": 4, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } @@ -286,7 +290,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 12, "id": "c065ff3d", "metadata": {}, "outputs": [ @@ -297,7 +301,7 @@ "Object" ] }, - "execution_count": 13, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } From 37cd4125e01dab84688efaad8d49a4f973d6ea07 Mon Sep 17 00:00:00 2001 From: Adam Powers Date: Mon, 27 Dec 2021 15:40:57 -0800 Subject: [PATCH 048/115] fix missing date in msg header --- cli/tools/jupyter/message_types.rs | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/cli/tools/jupyter/message_types.rs b/cli/tools/jupyter/message_types.rs index 3f4c404124e787..fb2e7eb09d2193 100644 --- a/cli/tools/jupyter/message_types.rs +++ b/cli/tools/jupyter/message_types.rs @@ -145,7 +145,8 @@ pub struct MessageHeader { pub username: String, // TODO(apowers313) -- date as an Option is to address a Jupyter bug // see also: https://github.com/jupyter/notebook/issues/6257 - pub date: Option, + #[serde(default = "missing_date")] + pub date: String, pub msg_type: String, pub version: String, } @@ -161,7 +162,7 @@ impl MessageHeader { session: session_id, // FIXME: username: "".to_string(), - date: Some(now), + date: now, msg_type: msg_type.to_string(), // TODO: this should be taken from a global, version: "5.3".to_string(), @@ -169,6 +170,10 @@ impl MessageHeader { } } +fn missing_date() -> String { + "1970-01-01T00:00:00+00:00".to_string() +} + // /* ***************** // * SHELL MESSAGES // * *****************/ From d64ed550edd46b045e6029b6bcb77ea85a663263 Mon Sep 17 00:00:00 2001 From: Adam Powers Date: Mon, 27 Dec 2021 23:43:24 -0800 Subject: [PATCH 049/115] fix error reporting, delint --- cli/tools/jupyter/mod.rs | 25 ++++++++-------- integration_test.ipynb | 65 +++++++++++++++++++++++++++++----------- 2 files changed, 60 insertions(+), 30 deletions(-) diff --git a/cli/tools/jupyter/mod.rs b/cli/tools/jupyter/mod.rs index 8dc4d9ad1431be..4ad390d7cacaa2 100644 --- a/cli/tools/jupyter/mod.rs +++ b/cli/tools/jupyter/mod.rs @@ -365,10 +365,6 @@ impl Kernel { self.state = state; - let now = std::time::SystemTime::now(); - let now: chrono::DateTime = now.into(); - let now = now.to_rfc3339(); - let s = match state { KernelState::Busy => "busy", KernelState::Idle => "idle", @@ -480,14 +476,22 @@ impl Kernel { .await?; let result = if output.value["exceptionDetails"].is_object() { + let stack_trace: Vec = output.value["exceptionDetails"] + ["exception"]["description"] + .as_str() + .unwrap() + .split("\n") + .map(|s| s.to_string()) + .collect(); + dbg!(&stack_trace); + println!("err_value: {}", stack_trace.first().unwrap().to_string()); ExecResult::Error(ExecError { // TODO(apowers313) this could probably use smarter unwrapping -- for example, someone may throw non-object err_name: output.value["exceptionDetails"]["exception"]["className"] .to_string(), - err_value: output.value["exceptionDetails"]["exception"]["description"] - .to_string(), + err_value: stack_trace.first().unwrap().to_string(), // output.value["exceptionDetails"]["stackTrace"]["callFrames"] - stack_trace: vec![], + stack_trace, }) } else { ExecResult::Ok(output.value["result"].clone()) @@ -524,7 +528,6 @@ impl Kernel { user_expressions: json!({}), }), ); - println!("+++ Sending execute reply ok"); self.shell_comm.send(msg).await?; Ok(()) @@ -553,7 +556,6 @@ impl Kernel { traceback: e.stack_trace.clone(), }), ); - println!("+++ Sending execute reply error"); self.shell_comm.send(msg).await?; Ok(()) @@ -578,8 +580,7 @@ impl Kernel { traceback: e.stack_trace.clone(), }), ); - println!("+++ Sending IOPub error"); - self.iopub_comm.send(msg); + self.iopub_comm.send(msg).await?; Ok(()) } @@ -609,7 +610,6 @@ impl Kernel { metadata: json!({}), }), ); - println!("+++ Sending execute result"); self.iopub_comm.send(msg).await?; Ok(()) @@ -739,7 +739,6 @@ impl From for DisplayData { ret.add("application/json", d["value"].clone()); } "null" => { - println!("XXX NEW NULL"); ret.add("text/plain", Value::String("null".to_string())); ret.add("application/json", Value::Null); } diff --git a/integration_test.ipynb b/integration_test.ipynb index a2f950ab0d1f7c..544c3bb3807ab1 100644 --- a/integration_test.ipynb +++ b/integration_test.ipynb @@ -70,7 +70,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "id": "bbf2c09b", "metadata": {}, "outputs": [], @@ -88,7 +88,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "id": "d9801d80", "metadata": {}, "outputs": [ @@ -99,7 +99,7 @@ "null" ] }, - "execution_count": 5, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -118,7 +118,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "id": "cfaac330", "metadata": {}, "outputs": [ @@ -129,7 +129,7 @@ "true" ] }, - "execution_count": 6, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -148,7 +148,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "id": "ec3be2da", "metadata": {}, "outputs": [ @@ -159,7 +159,7 @@ "42" ] }, - "execution_count": 7, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } @@ -178,7 +178,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "id": "997cf2d7", "metadata": {}, "outputs": [ @@ -189,7 +189,7 @@ "this is a test of the emergency broadcast system" ] }, - "execution_count": 8, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -208,7 +208,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "id": "44b63807", "metadata": {}, "outputs": [ @@ -219,7 +219,7 @@ "31337n" ] }, - "execution_count": 9, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } @@ -238,7 +238,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "id": "e10c0d31", "metadata": {}, "outputs": [ @@ -249,7 +249,7 @@ "Symbol(foo)" ] }, - "execution_count": 10, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -268,7 +268,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 12, "id": "81c99233", "metadata": {}, "outputs": [ @@ -279,7 +279,7 @@ "Object" ] }, - "execution_count": 11, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } @@ -290,7 +290,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 13, "id": "c065ff3d", "metadata": {}, "outputs": [ @@ -301,7 +301,7 @@ "Object" ] }, - "execution_count": 12, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -325,6 +325,37 @@ "source": [ "## Failing Tests" ] + }, + { + "cell_type": "markdown", + "id": "ed389024", + "metadata": {}, + "source": [ + "### prints an error message and stack trace" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b5c7b819", + "metadata": {}, + "outputs": [ + { + "ename": "\"Error\"", + "evalue": "Error: this is a test", + "output_type": "error", + "traceback": [ + "Error: this is a test", + " at foo (:3:11)", + " at :4:3" + ] + } + ], + "source": [ + "(function foo() {\n", + " throw new Error(\"this is a test\")\n", + "})()" + ] } ], "metadata": { From ccc80c85ee5c28d615422d365562f071427182cf Mon Sep 17 00:00:00 2001 From: Adam Powers Date: Tue, 28 Dec 2021 11:09:03 -0800 Subject: [PATCH 050/115] improve object printing --- cli/tools/jupyter/mod.rs | 151 +++++++++++++++---------- integration_test.ipynb | 236 +++++++++++++++++++++++++++++++++++---- 2 files changed, 304 insertions(+), 83 deletions(-) diff --git a/cli/tools/jupyter/mod.rs b/cli/tools/jupyter/mod.rs index 4ad390d7cacaa2..cecf0432e89117 100644 --- a/cli/tools/jupyter/mod.rs +++ b/cli/tools/jupyter/mod.rs @@ -32,7 +32,6 @@ use deno_runtime::permissions::Permissions; use deno_runtime::worker::MainWorker; use ring::hmac; use std::collections::HashMap; -use std::convert::From; use std::env::current_exe; use std::time::Duration; use tempfile::TempDir; @@ -439,11 +438,6 @@ impl Kernel { ); self.iopub_comm.send(input_msg).await?; - // let output = self - // .repl_session - // .evaluate_line_and_get_output(&exec_request_content.code) - // .await?; - // let test_svg = r###" // @@ -483,8 +477,6 @@ impl Kernel { .split("\n") .map(|s| s.to_string()) .collect(); - dbg!(&stack_trace); - println!("err_value: {}", stack_trace.first().unwrap().to_string()); ExecResult::Error(ExecError { // TODO(apowers313) this could probably use smarter unwrapping -- for example, someone may throw non-object err_name: output.value["exceptionDetails"]["exception"]["className"] @@ -594,7 +586,8 @@ impl Kernel { ExecResult::Ok(v) => v, _ => return Err(anyhow!("send_execute_result: unreachable")), }; - let mut display_data = DisplayData::from(v.clone()); + let mut display_data = + self.display_data_from_result_value(v.clone()).await?; if display_data.is_empty() { return Ok(()); } @@ -665,42 +658,11 @@ impl Kernel { Ok(()) } -} - -struct DisplayData { - data_list: Vec<(String, Value)>, -} - -impl DisplayData { - fn new() -> DisplayData { - Self { data_list: vec![] } - } - - fn add(&mut self, mime_type: &str, data: Value) { - self.data_list.push((mime_type.to_string(), data)); - } - - fn is_empty(&self) -> bool { - if self.data_list.len() == 0 { - return true; - } - return false; - } - - fn to_object(&self) -> Value { - let mut data = json!({}); - for d in self.data_list.iter() { - data[&d.0] = json!(&d.1); - } - - data - } -} - -impl From for DisplayData { - fn from(data: Value) -> Self { - dbg!(&data); + async fn display_data_from_result_value( + &mut self, + data: Value, + ) -> Result { let mut d = &data; let mut ret = DisplayData::new(); // if we passed in a result, unwrap it @@ -712,12 +674,12 @@ impl From for DisplayData { if !d["type"].is_string() { // not an execution result - return ret; + return Ok(ret); } let mut t = match &d["type"] { Value::String(x) => x.to_string(), - _ => return ret, + _ => return Ok(ret), }; if t == "object".to_string() @@ -731,8 +693,9 @@ impl From for DisplayData { // TODO(apowers313) inspect object / call toPng, toHtml, toSvg, toText, toMime "object" => { // TODO: this description isn't very useful - ret.add("text/plain", d["description"].clone()); - ret.add("application/json", d["description"].clone()); + let v = self.decode_object(&data, true).await?; + ret.add("text/plain", v.clone()); + ret.add("application/json", v.clone()); } "string" => { ret.add("text/plain", d["value"].clone()); @@ -743,7 +706,6 @@ impl From for DisplayData { ret.add("application/json", Value::Null); } "bigint" => { - // TODO: hmmm... is this really what we want? ret.add("text/plain", d["unserializableValue"].clone()); ret.add("application/json", d["unserializableValue"].clone()); } @@ -760,27 +722,92 @@ impl From for DisplayData { ret.add("application/json", d["value"].clone()); } // TODO(apowers313) currently ignoring "undefined" return value, I think most kernels make this a configuration option - "undefined" => return ret, + "undefined" => return Ok(ret), _ => { - println!("unknown type in DisplayData::from: {}", t); - return ret; + println!("unknown type in display_data_from_result_value: {}", t); + return Ok(ret); } }; - ret + Ok(ret) + } + + async fn decode_object( + &mut self, + obj: &Value, + color: bool, + ) -> Result { + // let v = self.repl_session.get_eval_value(&obj).await?; + // TODO(apowers313) copy and paste from `get_eval_value`, consider refactoring API + let fn_decl = match color { + true => { + r#"function (object) { + try { + return Deno[Deno.internal].inspectArgs(["%o", object], { colors: !Deno.noColor }); + } catch (err) { + return Deno[Deno.internal].inspectArgs(["%o", err]); + } + }"# + } + false => { + r#"function (object) { + try { + return Deno[Deno.internal].inspectArgs(["%o", object], { colors: Deno.noColor }); + } catch (err) { + return Deno[Deno.internal].inspectArgs(["%o", err]); + } + }"# + } + }; + + let v = self + .repl_session + .post_message_with_event_loop( + "Runtime.callFunctionOn", + Some(json!({ + "executionContextId": self.repl_session.context_id, + "functionDeclaration": fn_decl, + "arguments": [ + obj, + ], + })), + ) + .await?; + + Ok(v["result"]["value"].clone()) } } -// fn value_to_error(v: Value) -> Option(ErrorValue) { -// if !v["exceptionDetails"].is_object() { -// None -// } else { -// ErrorValue { -// // v["exceptionDetails"] -// } -// } -// } +struct DisplayData { + data_list: Vec<(String, Value)>, +} + +impl DisplayData { + fn new() -> DisplayData { + Self { data_list: vec![] } + } + + fn add(&mut self, mime_type: &str, data: Value) { + self.data_list.push((mime_type.to_string(), data)); + } + + fn is_empty(&self) -> bool { + if self.data_list.len() == 0 { + return true; + } + + return false; + } + fn to_object(&self) -> Value { + let mut data = json!({}); + for d in self.data_list.iter() { + data[&d.0] = json!(&d.1); + } + + data + } +} struct ErrorValue {} enum ExecResult { diff --git a/integration_test.ipynb b/integration_test.ipynb index 544c3bb3807ab1..8e4ec78afa4615 100644 --- a/integration_test.ipynb +++ b/integration_test.ipynb @@ -70,7 +70,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "id": "bbf2c09b", "metadata": {}, "outputs": [], @@ -88,7 +88,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "id": "d9801d80", "metadata": {}, "outputs": [ @@ -99,7 +99,7 @@ "null" ] }, - "execution_count": 6, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -118,7 +118,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "id": "cfaac330", "metadata": {}, "outputs": [ @@ -129,7 +129,7 @@ "true" ] }, - "execution_count": 7, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -148,7 +148,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "id": "ec3be2da", "metadata": {}, "outputs": [ @@ -159,7 +159,7 @@ "42" ] }, - "execution_count": 8, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -178,7 +178,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 8, "id": "997cf2d7", "metadata": {}, "outputs": [ @@ -189,7 +189,7 @@ "this is a test of the emergency broadcast system" ] }, - "execution_count": 9, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } @@ -208,7 +208,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 9, "id": "44b63807", "metadata": {}, "outputs": [ @@ -219,7 +219,7 @@ "31337n" ] }, - "execution_count": 10, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -238,7 +238,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 10, "id": "e10c0d31", "metadata": {}, "outputs": [ @@ -249,7 +249,7 @@ "Symbol(foo)" ] }, - "execution_count": 11, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } @@ -268,18 +268,18 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 11, "id": "81c99233", "metadata": {}, "outputs": [ { "data": { - "application/json": "Object", + "application/json": "{ foo: \u001b[32m\"bar\"\u001b[39m }", "text/plain": [ - "Object" + "{ foo: \u001b[32m\"bar\"\u001b[39m }" ] }, - "execution_count": 12, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -290,18 +290,212 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 12, "id": "c065ff3d", "metadata": {}, "outputs": [ { "data": { - "application/json": "Object", + "application/json": "{\n core: {\n opcallSync: \u001b[36m[Function: opcallSync]\u001b[39m,\n opcallAsync: \u001b[36m[Function: opcallAsync]\u001b[39m,\n refOp: \u001b[36m[Function: refOp]\u001b[39m,\n unrefOp: \u001b[36m[Function: unrefOp]\u001b[39m,\n setMacrotaskCallback: \u001b[36m[Function: setMacrotaskCallback]\u001b[39m,\n setNextTickCallback: \u001b[36m[Function: setNextTickCallback]\u001b[39m,\n setPromiseRejectCallback: \u001b[36m[Function: setPromiseRejectCallback]\u001b[39m,\n setUncaughtExceptionCallback: \u001b[36m[Function: setUncaughtExceptionCallback]\u001b[39m,\n runMicrotasks: \u001b[36m[Function: runMicrotasks]\u001b[39m,\n hasTickScheduled: \u001b[36m[Function: hasTickScheduled]\u001b[39m,\n setHasTickScheduled: \u001b[36m[Function: setHasTickScheduled]\u001b[39m,\n evalContext: \u001b[36m[Function: evalContext]\u001b[39m,\n encode: \u001b[36m[Function: encode]\u001b[39m,\n decode: \u001b[36m[Function: decode]\u001b[39m,\n serialize: \u001b[36m[Function: serialize]\u001b[39m,\n deserialize: \u001b[36m[Function: deserialize]\u001b[39m,\n getPromiseDetails: \u001b[36m[Function: getPromiseDetails]\u001b[39m,\n getProxyDetails: \u001b[36m[Function: getProxyDetails]\u001b[39m,\n isProxy: \u001b[36m[Function: isProxy]\u001b[39m,\n memoryUsage: \u001b[36m[Function: memoryUsage]\u001b[39m,\n callConsole: \u001b[36m[Function: callConsole]\u001b[39m,\n createHostObject: \u001b[36m[Function: createHostObject]\u001b[39m,\n setWasmStreamingCallback: \u001b[36m[Function: setWasmStreamingCallback]\u001b[39m,\n opAsync: \u001b[36m[Function: opAsync]\u001b[39m,\n opSync: \u001b[36m[Function: opSync]\u001b[39m,\n ops: \u001b[36m[Function: ops]\u001b[39m,\n close: \u001b[36m[Function: close]\u001b[39m,\n tryClose: \u001b[36m[Function: tryClose]\u001b[39m,\n read: \u001b[36m[Function: read]\u001b[39m,\n write: \u001b[36m[Function: write]\u001b[39m,\n shutdown: \u001b[36m[Function: shutdown]\u001b[39m,\n print: \u001b[36m[Function: print]\u001b[39m,\n resources: \u001b[36m[Function: resources]\u001b[39m,\n metrics: \u001b[36m[Function: metrics]\u001b[39m,\n registerErrorBuilder: \u001b[36m[Function: registerErrorBuilder]\u001b[39m,\n registerErrorClass: \u001b[36m[Function: registerErrorClass]\u001b[39m,\n opresolve: \u001b[36m[Function: opresolve]\u001b[39m,\n syncOpsCache: \u001b[36m[Function: syncOpsCache]\u001b[39m,\n BadResource: \u001b[36m[Function: BadResource]\u001b[39m,\n Interrupted: \u001b[36m[Function: Interrupted]\u001b[39m,\n createPrepareStackTrace: \u001b[36m[Function: createPrepareStackTrace]\u001b[39m\n },\n internal: \u001b[32mSymbol(Deno.internal)\u001b[39m,\n resources: \u001b[36m[Function: resources]\u001b[39m,\n close: \u001b[36m[Function: close]\u001b[39m,\n memoryUsage: \u001b[36m[Function: memoryUsage]\u001b[39m,\n metrics: \u001b[36m[Function: metrics]\u001b[39m,\n test: \u001b[36m[Function: test]\u001b[39m,\n Process: \u001b[36m[Function: Process]\u001b[39m,\n run: \u001b[36m[Function: run]\u001b[39m,\n isatty: \u001b[36m[Function: isatty]\u001b[39m,\n writeFileSync: \u001b[36m[Function: writeFileSync]\u001b[39m,\n writeFile: \u001b[36m[AsyncFunction: writeFile]\u001b[39m,\n writeTextFileSync: \u001b[36m[Function: writeTextFileSync]\u001b[39m,\n writeTextFile: \u001b[36m[Function: writeTextFile]\u001b[39m,\n readTextFile: \u001b[36m[AsyncFunction: readTextFile]\u001b[39m,\n readTextFileSync: \u001b[36m[Function: readTextFileSync]\u001b[39m,\n readFile: \u001b[36m[AsyncFunction: readFile]\u001b[39m,\n readFileSync: \u001b[36m[Function: readFileSync]\u001b[39m,\n watchFs: \u001b[36m[Function: watchFs]\u001b[39m,\n chmodSync: \u001b[36m[Function: chmodSync]\u001b[39m,\n chmod: \u001b[36m[AsyncFunction: chmod]\u001b[39m,\n chown: \u001b[36m[AsyncFunction: chown]\u001b[39m,\n chownSync: \u001b[36m[Function: chownSync]\u001b[39m,\n copyFileSync: \u001b[36m[Function: copyFileSync]\u001b[39m,\n cwd: \u001b[36m[Function: cwd]\u001b[39m,\n makeTempDirSync: \u001b[36m[Function: makeTempDirSync]\u001b[39m,\n makeTempDir: \u001b[36m[Function: makeTempDir]\u001b[39m,\n makeTempFileSync: \u001b[36m[Function: makeTempFileSync]\u001b[39m,\n makeTempFile: \u001b[36m[Function: makeTempFile]\u001b[39m,\n mkdirSync: \u001b[36m[Function: mkdirSync]\u001b[39m,\n mkdir: \u001b[36m[AsyncFunction: mkdir]\u001b[39m,\n chdir: \u001b[36m[Function: chdir]\u001b[39m,\n copyFile: \u001b[36m[AsyncFunction: copyFile]\u001b[39m,\n readDirSync: \u001b[36m[Function: readDirSync]\u001b[39m,\n readDir: \u001b[36m[Function: readDir]\u001b[39m,\n readLinkSync: \u001b[36m[Function: readLinkSync]\u001b[39m,\n readLink: \u001b[36m[Function: readLink]\u001b[39m,\n realPathSync: \u001b[36m[Function: realPathSync]\u001b[39m,\n realPath: \u001b[36m[Function: realPath]\u001b[39m,\n removeSync: \u001b[36m[Function: removeSync]\u001b[39m,\n remove: \u001b[36m[AsyncFunction: remove]\u001b[39m,\n renameSync: \u001b[36m[Function: renameSync]\u001b[39m,\n rename: \u001b[36m[AsyncFunction: rename]\u001b[39m,\n version: { deno: \u001b[32m\"1.17.0\"\u001b[39m, v8: \u001b[32m\"9.7.106.15\"\u001b[39m, typescript: \u001b[32m\"4.5.2\"\u001b[39m },\n build: {\n target: \u001b[32m\"x86_64-apple-darwin\"\u001b[39m,\n arch: \u001b[32m\"x86_64\"\u001b[39m,\n os: \u001b[32m\"darwin\"\u001b[39m,\n vendor: \u001b[32m\"apple\"\u001b[39m,\n env: \u001b[90mundefined\u001b[39m\n },\n statSync: \u001b[36m[Function: statSync]\u001b[39m,\n lstatSync: \u001b[36m[Function: lstatSync]\u001b[39m,\n stat: \u001b[36m[AsyncFunction: stat]\u001b[39m,\n lstat: \u001b[36m[AsyncFunction: lstat]\u001b[39m,\n truncateSync: \u001b[36m[Function: truncateSync]\u001b[39m,\n truncate: \u001b[36m[AsyncFunction: truncate]\u001b[39m,\n ftruncateSync: \u001b[36m[Function: ftruncateSync]\u001b[39m,\n ftruncate: \u001b[36m[AsyncFunction: ftruncate]\u001b[39m,\n errors: {\n NotFound: \u001b[36m[Function: NotFound]\u001b[39m,\n PermissionDenied: \u001b[36m[Function: PermissionDenied]\u001b[39m,\n ConnectionRefused: \u001b[36m[Function: ConnectionRefused]\u001b[39m,\n ConnectionReset: \u001b[36m[Function: ConnectionReset]\u001b[39m,\n ConnectionAborted: \u001b[36m[Function: ConnectionAborted]\u001b[39m,\n NotConnected: \u001b[36m[Function: NotConnected]\u001b[39m,\n AddrInUse: \u001b[36m[Function: AddrInUse]\u001b[39m,\n AddrNotAvailable: \u001b[36m[Function: AddrNotAvailable]\u001b[39m,\n BrokenPipe: \u001b[36m[Function: BrokenPipe]\u001b[39m,\n AlreadyExists: \u001b[36m[Function: AlreadyExists]\u001b[39m,\n InvalidData: \u001b[36m[Function: InvalidData]\u001b[39m,\n TimedOut: \u001b[36m[Function: TimedOut]\u001b[39m,\n Interrupted: \u001b[36m[Function: Interrupted]\u001b[39m,\n WriteZero: \u001b[36m[Function: WriteZero]\u001b[39m,\n UnexpectedEof: \u001b[36m[Function: UnexpectedEof]\u001b[39m,\n BadResource: \u001b[36m[Function: BadResource]\u001b[39m,\n Http: \u001b[36m[Function: Http]\u001b[39m,\n Busy: \u001b[36m[Function: Busy]\u001b[39m,\n NotSupported: \u001b[36m[Function: NotSupported]\u001b[39m\n },\n customInspect: \u001b[32mSymbol(Deno.customInspect)\u001b[39m,\n inspect: \u001b[36m[Function: inspect]\u001b[39m,\n env: {\n get: \u001b[36m[Function: getEnv]\u001b[39m,\n toObject: \u001b[36m[Function: toObject]\u001b[39m,\n set: \u001b[36m[Function: setEnv]\u001b[39m,\n delete: \u001b[36m[Function: deleteEnv]\u001b[39m\n },\n exit: \u001b[36m[Function: exit]\u001b[39m,\n execPath: \u001b[36m[Function: execPath]\u001b[39m,\n Buffer: \u001b[36m[Function: Buffer]\u001b[39m,\n readAll: \u001b[36m[AsyncFunction: readAll]\u001b[39m,\n readAllSync: \u001b[36m[Function: readAllSync]\u001b[39m,\n writeAll: \u001b[36m[AsyncFunction: writeAll]\u001b[39m,\n writeAllSync: \u001b[36m[Function: writeAllSync]\u001b[39m,\n copy: \u001b[36m[AsyncFunction: copy]\u001b[39m,\n iter: \u001b[36m[AsyncGeneratorFunction: iter]\u001b[39m,\n iterSync: \u001b[36m[GeneratorFunction: iterSync]\u001b[39m,\n SeekMode: { \"0\": \u001b[32m\"Start\"\u001b[39m, \"1\": \u001b[32m\"Current\"\u001b[39m, \"2\": \u001b[32m\"End\"\u001b[39m, Start: \u001b[33m0\u001b[39m, Current: \u001b[33m1\u001b[39m, End: \u001b[33m2\u001b[39m },\n read: \u001b[36m[AsyncFunction: read]\u001b[39m,\n readSync: \u001b[36m[Function: readSync]\u001b[39m,\n write: \u001b[36m[Function: write]\u001b[39m,\n writeSync: \u001b[36m[Function: writeSync]\u001b[39m,\n File: \u001b[36m[Function: File]\u001b[39m,\n open: \u001b[36m[AsyncFunction: open]\u001b[39m,\n openSync: \u001b[36m[Function: openSync]\u001b[39m,\n create: \u001b[36m[Function: create]\u001b[39m,\n createSync: \u001b[36m[Function: createSync]\u001b[39m,\n stdin: Stdin {},\n stdout: Stdout {},\n stderr: Stderr {},\n seek: \u001b[36m[Function: seek]\u001b[39m,\n seekSync: \u001b[36m[Function: seekSync]\u001b[39m,\n connect: \u001b[36m[AsyncFunction: connect]\u001b[39m,\n listen: \u001b[36m[Function: listen]\u001b[39m,\n connectTls: \u001b[36m[AsyncFunction: connectTls]\u001b[39m,\n listenTls: \u001b[36m[Function: listenTls]\u001b[39m,\n startTls: \u001b[36m[AsyncFunction: startTls]\u001b[39m,\n shutdown: \u001b[36m[Function: shutdown]\u001b[39m,\n fstatSync: \u001b[36m[Function: fstatSync]\u001b[39m,\n fstat: \u001b[36m[AsyncFunction: fstat]\u001b[39m,\n fsyncSync: \u001b[36m[Function: fsyncSync]\u001b[39m,\n fsync: \u001b[36m[AsyncFunction: fsync]\u001b[39m,\n fdatasyncSync: \u001b[36m[Function: fdatasyncSync]\u001b[39m,\n fdatasync: \u001b[36m[AsyncFunction: fdatasync]\u001b[39m,\n symlink: \u001b[36m[AsyncFunction: symlink]\u001b[39m,\n symlinkSync: \u001b[36m[Function: symlinkSync]\u001b[39m,\n link: \u001b[36m[AsyncFunction: link]\u001b[39m,\n linkSync: \u001b[36m[Function: linkSync]\u001b[39m,\n permissions: Permissions {},\n Permissions: \u001b[36m[Function: Permissions]\u001b[39m,\n PermissionStatus: \u001b[36m[Function: PermissionStatus]\u001b[39m,\n serveHttp: \u001b[36m[Function: serveHttp]\u001b[39m,\n resolveDns: \u001b[36m[Function: resolveDns]\u001b[39m,\n upgradeWebSocket: \u001b[36m[Function: upgradeWebSocket]\u001b[39m,\n kill: \u001b[36m[Function: opKill]\u001b[39m,\n pid: \u001b[33m79003\u001b[39m,\n ppid: \u001b[33m78992\u001b[39m,\n noColor: \u001b[33mfalse\u001b[39m,\n args: [],\n mainModule: [Getter],\n [Symbol(Deno.internal)]: {\n Console: \u001b[36m[Function: Console]\u001b[39m,\n cssToAnsi: \u001b[36m[Function: cssToAnsi]\u001b[39m,\n inspectArgs: \u001b[36m[Function: inspectArgs]\u001b[39m,\n parseCss: \u001b[36m[Function: parseCss]\u001b[39m,\n parseCssColor: \u001b[36m[Function: parseCssColor]\u001b[39m,\n pathFromURL: \u001b[36m[Function: pathFromURL]\u001b[39m,\n runTests: \u001b[36m[AsyncFunction: runTests]\u001b[39m,\n enableTestSteps: \u001b[36m[Function: enableTestSteps]\u001b[39m\n }\n}", "text/plain": [ - "Object" + "{\n", + " core: {\n", + " opcallSync: \u001b[36m[Function: opcallSync]\u001b[39m,\n", + " opcallAsync: \u001b[36m[Function: opcallAsync]\u001b[39m,\n", + " refOp: \u001b[36m[Function: refOp]\u001b[39m,\n", + " unrefOp: \u001b[36m[Function: unrefOp]\u001b[39m,\n", + " setMacrotaskCallback: \u001b[36m[Function: setMacrotaskCallback]\u001b[39m,\n", + " setNextTickCallback: \u001b[36m[Function: setNextTickCallback]\u001b[39m,\n", + " setPromiseRejectCallback: \u001b[36m[Function: setPromiseRejectCallback]\u001b[39m,\n", + " setUncaughtExceptionCallback: \u001b[36m[Function: setUncaughtExceptionCallback]\u001b[39m,\n", + " runMicrotasks: \u001b[36m[Function: runMicrotasks]\u001b[39m,\n", + " hasTickScheduled: \u001b[36m[Function: hasTickScheduled]\u001b[39m,\n", + " setHasTickScheduled: \u001b[36m[Function: setHasTickScheduled]\u001b[39m,\n", + " evalContext: \u001b[36m[Function: evalContext]\u001b[39m,\n", + " encode: \u001b[36m[Function: encode]\u001b[39m,\n", + " decode: \u001b[36m[Function: decode]\u001b[39m,\n", + " serialize: \u001b[36m[Function: serialize]\u001b[39m,\n", + " deserialize: \u001b[36m[Function: deserialize]\u001b[39m,\n", + " getPromiseDetails: \u001b[36m[Function: getPromiseDetails]\u001b[39m,\n", + " getProxyDetails: \u001b[36m[Function: getProxyDetails]\u001b[39m,\n", + " isProxy: \u001b[36m[Function: isProxy]\u001b[39m,\n", + " memoryUsage: \u001b[36m[Function: memoryUsage]\u001b[39m,\n", + " callConsole: \u001b[36m[Function: callConsole]\u001b[39m,\n", + " createHostObject: \u001b[36m[Function: createHostObject]\u001b[39m,\n", + " setWasmStreamingCallback: \u001b[36m[Function: setWasmStreamingCallback]\u001b[39m,\n", + " opAsync: \u001b[36m[Function: opAsync]\u001b[39m,\n", + " opSync: \u001b[36m[Function: opSync]\u001b[39m,\n", + " ops: \u001b[36m[Function: ops]\u001b[39m,\n", + " close: \u001b[36m[Function: close]\u001b[39m,\n", + " tryClose: \u001b[36m[Function: tryClose]\u001b[39m,\n", + " read: \u001b[36m[Function: read]\u001b[39m,\n", + " write: \u001b[36m[Function: write]\u001b[39m,\n", + " shutdown: \u001b[36m[Function: shutdown]\u001b[39m,\n", + " print: \u001b[36m[Function: print]\u001b[39m,\n", + " resources: \u001b[36m[Function: resources]\u001b[39m,\n", + " metrics: \u001b[36m[Function: metrics]\u001b[39m,\n", + " registerErrorBuilder: \u001b[36m[Function: registerErrorBuilder]\u001b[39m,\n", + " registerErrorClass: \u001b[36m[Function: registerErrorClass]\u001b[39m,\n", + " opresolve: \u001b[36m[Function: opresolve]\u001b[39m,\n", + " syncOpsCache: \u001b[36m[Function: syncOpsCache]\u001b[39m,\n", + " BadResource: \u001b[36m[Function: BadResource]\u001b[39m,\n", + " Interrupted: \u001b[36m[Function: Interrupted]\u001b[39m,\n", + " createPrepareStackTrace: \u001b[36m[Function: createPrepareStackTrace]\u001b[39m\n", + " },\n", + " internal: \u001b[32mSymbol(Deno.internal)\u001b[39m,\n", + " resources: \u001b[36m[Function: resources]\u001b[39m,\n", + " close: \u001b[36m[Function: close]\u001b[39m,\n", + " memoryUsage: \u001b[36m[Function: memoryUsage]\u001b[39m,\n", + " metrics: \u001b[36m[Function: metrics]\u001b[39m,\n", + " test: \u001b[36m[Function: test]\u001b[39m,\n", + " Process: \u001b[36m[Function: Process]\u001b[39m,\n", + " run: \u001b[36m[Function: run]\u001b[39m,\n", + " isatty: \u001b[36m[Function: isatty]\u001b[39m,\n", + " writeFileSync: \u001b[36m[Function: writeFileSync]\u001b[39m,\n", + " writeFile: \u001b[36m[AsyncFunction: writeFile]\u001b[39m,\n", + " writeTextFileSync: \u001b[36m[Function: writeTextFileSync]\u001b[39m,\n", + " writeTextFile: \u001b[36m[Function: writeTextFile]\u001b[39m,\n", + " readTextFile: \u001b[36m[AsyncFunction: readTextFile]\u001b[39m,\n", + " readTextFileSync: \u001b[36m[Function: readTextFileSync]\u001b[39m,\n", + " readFile: \u001b[36m[AsyncFunction: readFile]\u001b[39m,\n", + " readFileSync: \u001b[36m[Function: readFileSync]\u001b[39m,\n", + " watchFs: \u001b[36m[Function: watchFs]\u001b[39m,\n", + " chmodSync: \u001b[36m[Function: chmodSync]\u001b[39m,\n", + " chmod: \u001b[36m[AsyncFunction: chmod]\u001b[39m,\n", + " chown: \u001b[36m[AsyncFunction: chown]\u001b[39m,\n", + " chownSync: \u001b[36m[Function: chownSync]\u001b[39m,\n", + " copyFileSync: \u001b[36m[Function: copyFileSync]\u001b[39m,\n", + " cwd: \u001b[36m[Function: cwd]\u001b[39m,\n", + " makeTempDirSync: \u001b[36m[Function: makeTempDirSync]\u001b[39m,\n", + " makeTempDir: \u001b[36m[Function: makeTempDir]\u001b[39m,\n", + " makeTempFileSync: \u001b[36m[Function: makeTempFileSync]\u001b[39m,\n", + " makeTempFile: \u001b[36m[Function: makeTempFile]\u001b[39m,\n", + " mkdirSync: \u001b[36m[Function: mkdirSync]\u001b[39m,\n", + " mkdir: \u001b[36m[AsyncFunction: mkdir]\u001b[39m,\n", + " chdir: \u001b[36m[Function: chdir]\u001b[39m,\n", + " copyFile: \u001b[36m[AsyncFunction: copyFile]\u001b[39m,\n", + " readDirSync: \u001b[36m[Function: readDirSync]\u001b[39m,\n", + " readDir: \u001b[36m[Function: readDir]\u001b[39m,\n", + " readLinkSync: \u001b[36m[Function: readLinkSync]\u001b[39m,\n", + " readLink: \u001b[36m[Function: readLink]\u001b[39m,\n", + " realPathSync: \u001b[36m[Function: realPathSync]\u001b[39m,\n", + " realPath: \u001b[36m[Function: realPath]\u001b[39m,\n", + " removeSync: \u001b[36m[Function: removeSync]\u001b[39m,\n", + " remove: \u001b[36m[AsyncFunction: remove]\u001b[39m,\n", + " renameSync: \u001b[36m[Function: renameSync]\u001b[39m,\n", + " rename: \u001b[36m[AsyncFunction: rename]\u001b[39m,\n", + " version: { deno: \u001b[32m\"1.17.0\"\u001b[39m, v8: \u001b[32m\"9.7.106.15\"\u001b[39m, typescript: \u001b[32m\"4.5.2\"\u001b[39m },\n", + " build: {\n", + " target: \u001b[32m\"x86_64-apple-darwin\"\u001b[39m,\n", + " arch: \u001b[32m\"x86_64\"\u001b[39m,\n", + " os: \u001b[32m\"darwin\"\u001b[39m,\n", + " vendor: \u001b[32m\"apple\"\u001b[39m,\n", + " env: \u001b[90mundefined\u001b[39m\n", + " },\n", + " statSync: \u001b[36m[Function: statSync]\u001b[39m,\n", + " lstatSync: \u001b[36m[Function: lstatSync]\u001b[39m,\n", + " stat: \u001b[36m[AsyncFunction: stat]\u001b[39m,\n", + " lstat: \u001b[36m[AsyncFunction: lstat]\u001b[39m,\n", + " truncateSync: \u001b[36m[Function: truncateSync]\u001b[39m,\n", + " truncate: \u001b[36m[AsyncFunction: truncate]\u001b[39m,\n", + " ftruncateSync: \u001b[36m[Function: ftruncateSync]\u001b[39m,\n", + " ftruncate: \u001b[36m[AsyncFunction: ftruncate]\u001b[39m,\n", + " errors: {\n", + " NotFound: \u001b[36m[Function: NotFound]\u001b[39m,\n", + " PermissionDenied: \u001b[36m[Function: PermissionDenied]\u001b[39m,\n", + " ConnectionRefused: \u001b[36m[Function: ConnectionRefused]\u001b[39m,\n", + " ConnectionReset: \u001b[36m[Function: ConnectionReset]\u001b[39m,\n", + " ConnectionAborted: \u001b[36m[Function: ConnectionAborted]\u001b[39m,\n", + " NotConnected: \u001b[36m[Function: NotConnected]\u001b[39m,\n", + " AddrInUse: \u001b[36m[Function: AddrInUse]\u001b[39m,\n", + " AddrNotAvailable: \u001b[36m[Function: AddrNotAvailable]\u001b[39m,\n", + " BrokenPipe: \u001b[36m[Function: BrokenPipe]\u001b[39m,\n", + " AlreadyExists: \u001b[36m[Function: AlreadyExists]\u001b[39m,\n", + " InvalidData: \u001b[36m[Function: InvalidData]\u001b[39m,\n", + " TimedOut: \u001b[36m[Function: TimedOut]\u001b[39m,\n", + " Interrupted: \u001b[36m[Function: Interrupted]\u001b[39m,\n", + " WriteZero: \u001b[36m[Function: WriteZero]\u001b[39m,\n", + " UnexpectedEof: \u001b[36m[Function: UnexpectedEof]\u001b[39m,\n", + " BadResource: \u001b[36m[Function: BadResource]\u001b[39m,\n", + " Http: \u001b[36m[Function: Http]\u001b[39m,\n", + " Busy: \u001b[36m[Function: Busy]\u001b[39m,\n", + " NotSupported: \u001b[36m[Function: NotSupported]\u001b[39m\n", + " },\n", + " customInspect: \u001b[32mSymbol(Deno.customInspect)\u001b[39m,\n", + " inspect: \u001b[36m[Function: inspect]\u001b[39m,\n", + " env: {\n", + " get: \u001b[36m[Function: getEnv]\u001b[39m,\n", + " toObject: \u001b[36m[Function: toObject]\u001b[39m,\n", + " set: \u001b[36m[Function: setEnv]\u001b[39m,\n", + " delete: \u001b[36m[Function: deleteEnv]\u001b[39m\n", + " },\n", + " exit: \u001b[36m[Function: exit]\u001b[39m,\n", + " execPath: \u001b[36m[Function: execPath]\u001b[39m,\n", + " Buffer: \u001b[36m[Function: Buffer]\u001b[39m,\n", + " readAll: \u001b[36m[AsyncFunction: readAll]\u001b[39m,\n", + " readAllSync: \u001b[36m[Function: readAllSync]\u001b[39m,\n", + " writeAll: \u001b[36m[AsyncFunction: writeAll]\u001b[39m,\n", + " writeAllSync: \u001b[36m[Function: writeAllSync]\u001b[39m,\n", + " copy: \u001b[36m[AsyncFunction: copy]\u001b[39m,\n", + " iter: \u001b[36m[AsyncGeneratorFunction: iter]\u001b[39m,\n", + " iterSync: \u001b[36m[GeneratorFunction: iterSync]\u001b[39m,\n", + " SeekMode: { \"0\": \u001b[32m\"Start\"\u001b[39m, \"1\": \u001b[32m\"Current\"\u001b[39m, \"2\": \u001b[32m\"End\"\u001b[39m, Start: \u001b[33m0\u001b[39m, Current: \u001b[33m1\u001b[39m, End: \u001b[33m2\u001b[39m },\n", + " read: \u001b[36m[AsyncFunction: read]\u001b[39m,\n", + " readSync: \u001b[36m[Function: readSync]\u001b[39m,\n", + " write: \u001b[36m[Function: write]\u001b[39m,\n", + " writeSync: \u001b[36m[Function: writeSync]\u001b[39m,\n", + " File: \u001b[36m[Function: File]\u001b[39m,\n", + " open: \u001b[36m[AsyncFunction: open]\u001b[39m,\n", + " openSync: \u001b[36m[Function: openSync]\u001b[39m,\n", + " create: \u001b[36m[Function: create]\u001b[39m,\n", + " createSync: \u001b[36m[Function: createSync]\u001b[39m,\n", + " stdin: Stdin {},\n", + " stdout: Stdout {},\n", + " stderr: Stderr {},\n", + " seek: \u001b[36m[Function: seek]\u001b[39m,\n", + " seekSync: \u001b[36m[Function: seekSync]\u001b[39m,\n", + " connect: \u001b[36m[AsyncFunction: connect]\u001b[39m,\n", + " listen: \u001b[36m[Function: listen]\u001b[39m,\n", + " connectTls: \u001b[36m[AsyncFunction: connectTls]\u001b[39m,\n", + " listenTls: \u001b[36m[Function: listenTls]\u001b[39m,\n", + " startTls: \u001b[36m[AsyncFunction: startTls]\u001b[39m,\n", + " shutdown: \u001b[36m[Function: shutdown]\u001b[39m,\n", + " fstatSync: \u001b[36m[Function: fstatSync]\u001b[39m,\n", + " fstat: \u001b[36m[AsyncFunction: fstat]\u001b[39m,\n", + " fsyncSync: \u001b[36m[Function: fsyncSync]\u001b[39m,\n", + " fsync: \u001b[36m[AsyncFunction: fsync]\u001b[39m,\n", + " fdatasyncSync: \u001b[36m[Function: fdatasyncSync]\u001b[39m,\n", + " fdatasync: \u001b[36m[AsyncFunction: fdatasync]\u001b[39m,\n", + " symlink: \u001b[36m[AsyncFunction: symlink]\u001b[39m,\n", + " symlinkSync: \u001b[36m[Function: symlinkSync]\u001b[39m,\n", + " link: \u001b[36m[AsyncFunction: link]\u001b[39m,\n", + " linkSync: \u001b[36m[Function: linkSync]\u001b[39m,\n", + " permissions: Permissions {},\n", + " Permissions: \u001b[36m[Function: Permissions]\u001b[39m,\n", + " PermissionStatus: \u001b[36m[Function: PermissionStatus]\u001b[39m,\n", + " serveHttp: \u001b[36m[Function: serveHttp]\u001b[39m,\n", + " resolveDns: \u001b[36m[Function: resolveDns]\u001b[39m,\n", + " upgradeWebSocket: \u001b[36m[Function: upgradeWebSocket]\u001b[39m,\n", + " kill: \u001b[36m[Function: opKill]\u001b[39m,\n", + " pid: \u001b[33m79003\u001b[39m,\n", + " ppid: \u001b[33m78992\u001b[39m,\n", + " noColor: \u001b[33mfalse\u001b[39m,\n", + " args: [],\n", + " mainModule: [Getter],\n", + " [Symbol(Deno.internal)]: {\n", + " Console: \u001b[36m[Function: Console]\u001b[39m,\n", + " cssToAnsi: \u001b[36m[Function: cssToAnsi]\u001b[39m,\n", + " inspectArgs: \u001b[36m[Function: inspectArgs]\u001b[39m,\n", + " parseCss: \u001b[36m[Function: parseCss]\u001b[39m,\n", + " parseCssColor: \u001b[36m[Function: parseCssColor]\u001b[39m,\n", + " pathFromURL: \u001b[36m[Function: pathFromURL]\u001b[39m,\n", + " runTests: \u001b[36m[AsyncFunction: runTests]\u001b[39m,\n", + " enableTestSteps: \u001b[36m[Function: enableTestSteps]\u001b[39m\n", + " }\n", + "}" ] }, - "execution_count": 13, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" } From 4b1b5be5672ff1ad3028a5436adbb6264ab07e0e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Wed, 29 Dec 2021 15:30:32 +0100 Subject: [PATCH 051/115] replace overwrite op --- cli/tools/jupyter/mod.rs | 29 +++++++++++++++++++---------- core/ops.rs | 11 +---------- core/runtime.rs | 16 ++++------------ 3 files changed, 24 insertions(+), 32 deletions(-) diff --git a/cli/tools/jupyter/mod.rs b/cli/tools/jupyter/mod.rs index bdeb933f66d0a9..ddc10af7d29876 100644 --- a/cli/tools/jupyter/mod.rs +++ b/cli/tools/jupyter/mod.rs @@ -26,6 +26,7 @@ use deno_core::serde::Serialize; use deno_core::serde_json; use deno_core::serde_json::json; use deno_core::serde_json::Value; +use deno_core::Extension; use deno_core::JsRuntime; use deno_core::OpState; use deno_runtime::permissions::Permissions; @@ -103,8 +104,17 @@ enum HandlerType { type StdioProxySender = UnboundedSender<(StdioType, String)>; type StdioProxyReceiver = UnboundedReceiver<(StdioType, String)>; -fn init(rt: &mut JsRuntime) { - rt.overwrite_op("op_print", op_sync(op_print)); +fn print_extension(sender: StdioProxySender) -> Extension { + Extension::builder() + .middleware(|name, opfn| match name { + "op_print" => op_sync(op_print), + _ => opfn, + }) + .state(move |state| { + state.put(sender.clone()); + Ok(()) + }) + .build() } pub fn op_print( @@ -165,18 +175,17 @@ impl Kernel { let hb_comm = HbComm::new(create_conn_str(&spec.transport, &spec.ip, spec.hb_port)); + let (stdio_tx, stdio_rx) = mpsc::unbounded(); let main_module = resolve_url_or_path("./$deno$jupyter.ts").unwrap(); // TODO(bartlomieju): should we run with all permissions? let permissions = Permissions::allow_all(); let ps = ProcState::build(flags.clone()).await?; - let mut worker = - create_main_worker(&ps, main_module.clone(), permissions, Some(&init)); - let (stdio_tx, stdio_rx) = mpsc::unbounded(); - worker - .js_runtime - .op_state() - .borrow_mut() - .put::(stdio_tx); + let mut worker = create_main_worker( + &ps, + main_module.clone(), + permissions, + vec![print_extension(stdio_tx)], + ); let repl_session = ReplSession::initialize(worker).await?; let kernel = Self { diff --git a/core/ops.rs b/core/ops.rs index 3f85a6276571e8..6b2c06397f5386 100644 --- a/core/ops.rs +++ b/core/ops.rs @@ -201,16 +201,7 @@ impl OpTable { F: Fn(Rc>, OpPayload) -> Op + 'static, { let (op_id, prev) = self.0.insert_full(name.to_owned(), Rc::new(op_fn)); - assert!(prev.is_none(), "Op '{}' was already registered", name); - op_id - } - - pub fn overwrite_op(&mut self, name: &str, op_fn: F) -> OpId - where - F: Fn(Rc>, OpPayload) -> Op + 'static, - { - let (op_id, prev) = self.0.insert_full(name.to_owned(), Rc::new(op_fn)); - assert!(prev.is_some(), "Op '{}' wasn't already registered", name); + assert!(prev.is_none()); op_id } diff --git a/core/runtime.rs b/core/runtime.rs index 24ed20c7bf77b2..643a4198de1912 100644 --- a/core/runtime.rs +++ b/core/runtime.rs @@ -637,18 +637,6 @@ impl JsRuntime { .register_op(name, op_fn) } - pub fn overwrite_op(&mut self, name: &str, op_fn: F) -> OpId - where - F: Fn(Rc>, OpPayload) -> Op + 'static, - { - Self::state(self.v8_isolate()) - .borrow_mut() - .op_state - .borrow_mut() - .op_table - .overwrite_op(name, op_fn) - } - /// Registers a callback on the isolate when the memory limits are approached. /// Use this to prevent V8 from crashing the process when reaching the limit. /// @@ -1916,6 +1904,8 @@ pub mod tests { #[test] fn terminate_execution() { let (mut isolate, _dispatch_count) = setup(Mode::Async); + // TODO(piscisaureus): in rusty_v8, the `thread_safe_handle()` method + // should not require a mutable reference to `struct rusty_v8::Isolate`. let v8_isolate_handle = isolate.v8_isolate().thread_safe_handle(); let terminator_thread = std::thread::spawn(move || { @@ -1953,6 +1943,8 @@ pub mod tests { let v8_isolate_handle = { // isolate is dropped at the end of this block let (mut runtime, _dispatch_count) = setup(Mode::Async); + // TODO(piscisaureus): in rusty_v8, the `thread_safe_handle()` method + // should not require a mutable reference to `struct rusty_v8::Isolate`. runtime.v8_isolate().thread_safe_handle() }; From c494a2f53a6cebd49a8fe6d5adb6b2cd2698dd96 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Wed, 29 Dec 2021 15:31:04 +0100 Subject: [PATCH 052/115] remove 'rust' from kernelspec --- cli/tools/jupyter/install.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/cli/tools/jupyter/install.rs b/cli/tools/jupyter/install.rs index fa19c4e028162f..05597b44b4af73 100644 --- a/cli/tools/jupyter/install.rs +++ b/cli/tools/jupyter/install.rs @@ -15,7 +15,7 @@ pub fn install() -> Result<(), AnyError> { // FIXME(bartlomieju): replace `current_exe` let json_data = json!({ "argv": [current_exe().unwrap().to_string_lossy(), "jupyter", "--conn", "{connection_file}"], - "display_name": "Deno (Rust)", + "display_name": "Deno", "language": "typescript", }); @@ -27,7 +27,7 @@ pub fn install() -> Result<(), AnyError> { "kernelspec", "install", "--name", - "rusty_deno", + "deno", &temp_dir.path().to_string_lossy(), ]) .spawn(); From f43d3ca80aa08d79e3118306af232c557e73418d Mon Sep 17 00:00:00 2001 From: Adam Powers Date: Thu, 30 Dec 2021 01:52:53 -0800 Subject: [PATCH 053/115] run kernel in unstable mode for jupyter API --- cli/tools/jupyter/install.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cli/tools/jupyter/install.rs b/cli/tools/jupyter/install.rs index fa19c4e028162f..1f5ea77c27e68a 100644 --- a/cli/tools/jupyter/install.rs +++ b/cli/tools/jupyter/install.rs @@ -14,7 +14,7 @@ pub fn install() -> Result<(), AnyError> { // https://jupyter-client.readthedocs.io/en/stable/kernels.html#kernel-specs // FIXME(bartlomieju): replace `current_exe` let json_data = json!({ - "argv": [current_exe().unwrap().to_string_lossy(), "jupyter", "--conn", "{connection_file}"], + "argv": [current_exe().unwrap().to_string_lossy(), "--unstable", "jupyter", "--conn", "{connection_file}"], "display_name": "Deno (Rust)", "language": "typescript", }); From 06c5e922b7353b1b680bb0a69bcc94c6a809603c Mon Sep 17 00:00:00 2001 From: Adam Powers Date: Thu, 30 Dec 2021 02:05:30 -0800 Subject: [PATCH 054/115] add jupyter display --- cli/tools/jupyter/mod.rs | 149 ++++++++++++++++++++++++++++----------- integration_test.ipynb | 120 +++++++++++++++++++++++++++++-- runtime/js/40_jupyter.js | 14 ++++ runtime/js/90_deno_ns.js | 1 + 4 files changed, 237 insertions(+), 47 deletions(-) create mode 100644 runtime/js/40_jupyter.js diff --git a/cli/tools/jupyter/mod.rs b/cli/tools/jupyter/mod.rs index cecf0432e89117..eb4a5ed2a3292a 100644 --- a/cli/tools/jupyter/mod.rs +++ b/cli/tools/jupyter/mod.rs @@ -28,6 +28,7 @@ use deno_core::serde_json::json; use deno_core::serde_json::Value; use deno_core::JsRuntime; use deno_core::OpState; +use deno_core::ZeroCopyBuf; use deno_runtime::permissions::Permissions; use deno_runtime::worker::MainWorker; use ring::hmac; @@ -89,7 +90,7 @@ struct Kernel { session_id: String, execution_count: u32, repl_session: ReplSession, - stdio_rx: StdioProxyReceiver, + stdio_rx: WorkerCommReceiver, last_comm_ctx: Option, } @@ -100,11 +101,45 @@ enum HandlerType { Stdin, } -type StdioProxySender = UnboundedSender<(StdioType, String)>; -type StdioProxyReceiver = UnboundedReceiver<(StdioType, String)>; +type WorkerCommSender = UnboundedSender; +type WorkerCommReceiver = UnboundedReceiver; + +enum WorkerCommMsg { + Stderr(String), + Stdout(String), + Display(String, ZeroCopyBuf), +} fn init(rt: &mut JsRuntime) { rt.overwrite_op("op_print", op_sync(op_print)); + rt.register_op("op_jupyter_display", op_sync(op_jupyter_display)); + rt.sync_ops_cache(); +} + +#[derive(Deserialize, Debug)] +#[serde(rename_all = "camelCase")] +struct DisplayArgs { + mime_type: String, + data: String, +} + +pub fn op_jupyter_display( + state: &mut OpState, + mime_type: String, + data: Option, +) -> Result<(), AnyError> { + println!("&&& op_jupyter_display"); + println!("mime_type: {}", mime_type); + let d = match data { + Some(x) => x, + None => return Err(anyhow!("op_jupyter_display missing 'data' argument")), + }; + println!("buflen: {}", d.len()); + + let mut sender = state.borrow_mut::(); + sender.unbounded_send(WorkerCommMsg::Display(mime_type, d)); + + Ok(()) } pub fn op_print( @@ -112,12 +147,12 @@ pub fn op_print( msg: String, is_err: bool, ) -> Result<(), AnyError> { - let mut sender = state.borrow_mut::(); + let mut sender = state.borrow_mut::(); if is_err { - let r = sender.unbounded_send((StdioType::Stderr, msg)); + let r = sender.unbounded_send(WorkerCommMsg::Stderr(msg)); } else { - let r = sender.unbounded_send((StdioType::Stdout, msg)); + let r = sender.unbounded_send(WorkerCommMsg::Stdout(msg)); } Ok(()) } @@ -176,7 +211,7 @@ impl Kernel { .js_runtime .op_state() .borrow_mut() - .put::(stdio_tx); + .put::(stdio_tx); let repl_session = ReplSession::initialize(worker).await?; let kernel = Self { @@ -232,7 +267,7 @@ impl Kernel { }, maybe_stdio_proxy_msg = self.stdio_rx.next() => { if let Some(stdio_proxy_msg) = maybe_stdio_proxy_msg { - self.stdio_handler(stdio_proxy_msg).await; + self.worker_comm_handler(stdio_proxy_msg).await; } }, heartbeat_result = self.hb_comm.heartbeat() => { @@ -296,31 +331,38 @@ impl Kernel { self.set_state(&comm_ctx, KernelState::Idle).await; } - async fn stdio_handler( + async fn worker_comm_handler( &mut self, - stdio_proxy_msg: (StdioType, String), + worker_msg: WorkerCommMsg, ) -> Result<(), AnyError> { - if let Some(comm_ctx) = self.last_comm_ctx.as_ref() { - let (t, content) = stdio_proxy_msg; - let msg = SideEffectMessage::new( - comm_ctx, - "stream", - ReplyMetadata::Empty, - ReplyContent::Stream(StreamContent { - name: match t { - StdioType::Stdout => "stdout".to_string(), - StdioType::Stderr => "stderr".to_string(), - }, - text: content, - }), - ); - self.iopub_comm.send(msg).await?; - } else { - println!( - "Received stdio message, but there is no last CommContext: {:#?}", - stdio_proxy_msg.1 - ); - } + println!("&&& worker_comm_handler"); + let comm_ctx = match self.last_comm_ctx.clone() { + Some(cc) => cc, + None => { + return Err(anyhow!( + "Received stdio message, but there is no last CommContext" + )); + } + }; + + match worker_msg { + WorkerCommMsg::Stdout(s) => { + self + .send_stdio(&comm_ctx, StdioType::Stdout, s.as_ref()) + .await?; + } + WorkerCommMsg::Stderr(s) => { + self + .send_stdio(&comm_ctx, StdioType::Stderr, s.as_ref()) + .await?; + } + WorkerCommMsg::Display(mime, buf) => { + println!("&&& WorkerCommMsg::Display"); + let mut dd = DisplayData::new(); + dd.add(mime.as_ref(), json!(buf)); + self.send_display_data(&comm_ctx, dd).await?; + } + }; Ok(()) } @@ -639,6 +681,7 @@ impl Kernel { comm_ctx: &CommContext, display_data: DisplayData, ) -> Result<(), AnyError> { + println!("&&& send_display_data"); if (display_data.is_empty()) { return Err(anyhow!("send_display_data called with empty DisplayData")); } @@ -654,7 +697,8 @@ impl Kernel { transient: json!({}), }), ); - self.iopub_comm.send(msg); + dbg!(&msg); + self.iopub_comm.send(msg).await?; Ok(()) } @@ -693,9 +737,10 @@ impl Kernel { // TODO(apowers313) inspect object / call toPng, toHtml, toSvg, toText, toMime "object" => { // TODO: this description isn't very useful - let v = self.decode_object(&data, true).await?; - ret.add("text/plain", v.clone()); - ret.add("application/json", v.clone()); + let type_list = self.decode_object(data, true).await?; + for t in type_list.iter() { + ret.add(t.0, t.1.clone()); + } } "string" => { ret.add("text/plain", d["value"].clone()); @@ -734,12 +779,12 @@ impl Kernel { async fn decode_object( &mut self, - obj: &Value, + obj: Value, color: bool, - ) -> Result { + ) -> Result, AnyError> { // let v = self.repl_session.get_eval_value(&obj).await?; // TODO(apowers313) copy and paste from `get_eval_value`, consider refactoring API - let fn_decl = match color { + let obj_inspect_fn = match color { true => { r#"function (object) { try { @@ -760,21 +805,39 @@ impl Kernel { } }; + let v = self.repl_exec(obj_inspect_fn, Some(json!([obj]))).await?; + + match v["result"]["value"]["description"].to_string().as_ref() { + "Symbol(Symbol.toPng)" => println!("found Symbol(Symbol.toPng)"), + "Symbol(Symbol.toSvg)" => println!("found Symbol(Symbol.toSvg)"), + "Symbol(Symbol.toHtml)" => println!("found Symbol(Symbol.toHtml)"), + "Symbol(Symbol.toJson)" => println!("found Symbol(Symbol.toJson)"), + "Symbol(Symbol.toJpg)" => println!("found Symbol(Symbol.toJpg)"), + "Symbol(Symbol.toMime)" => println!("found Symbol(Symbol.toMime)"), + _ => return Ok(vec![("text/plain", v["result"]["value"].clone())]), + }; + + Ok(vec![]) + } + + async fn repl_exec( + &mut self, + code: &str, + args: Option, + ) -> Result { let v = self .repl_session .post_message_with_event_loop( "Runtime.callFunctionOn", Some(json!({ "executionContextId": self.repl_session.context_id, - "functionDeclaration": fn_decl, - "arguments": [ - obj, - ], + "functionDeclaration": code, + "arguments": args, })), ) .await?; - Ok(v["result"]["value"].clone()) + Ok(v) } } diff --git a/integration_test.ipynb b/integration_test.ipynb index 8e4ec78afa4615..1f74e19572f8c9 100644 --- a/integration_test.ipynb +++ b/integration_test.ipynb @@ -36,7 +36,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "id": "a5d38758", "metadata": {}, "outputs": [ @@ -52,6 +52,75 @@ "console.log(\"hi\")" ] }, + { + "cell_type": "markdown", + "id": "bc5ce8e3", + "metadata": {}, + "source": [ + "#### Top-level await" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "f7fa885a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "x is \u001b[33m42\u001b[39m\n" + ] + } + ], + "source": [ + "let x = await Promise.resolve(42);\n", + "console.log(\"x is\", x);" + ] + }, + { + "cell_type": "markdown", + "id": "c21455ae", + "metadata": {}, + "source": [ + "#### TypeScript transpiling\n", + "Credit to [typescriptlang.org](https://www.typescriptlang.org/docs/handbook/interfaces.html) for this code" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "08a17340", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{ color: \u001b[32m\"red\"\u001b[39m, area: \u001b[33m10000\u001b[39m }" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "interface SquareConfig {\n", + " color?: string;\n", + " width?: number;\n", + "}\n", + " \n", + "function createSquare(config: SquareConfig): { color: string; area: number } {\n", + " return {\n", + " color: config.color || \"red\",\n", + " area: config.width ? config.width * config.width : 20,\n", + " };\n", + "}\n", + " \n", + "createSquare({ colour: \"red\", width: 100 });" + ] + }, { "cell_type": "markdown", "id": "eaa0ebc0", @@ -88,7 +157,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 13, "id": "d9801d80", "metadata": {}, "outputs": [ @@ -99,7 +168,7 @@ "null" ] }, - "execution_count": 5, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -509,7 +578,50 @@ "id": "3a89dada", "metadata": {}, "source": [ - "#### object with Symbol(\"toPng\") should return an image" + "#### object with Symbol(\"toPng\") should return an image (TODO)" + ] + }, + { + "cell_type": "markdown", + "id": "46da2b23", + "metadata": {}, + "source": [ + "### User API" + ] + }, + { + "cell_type": "markdown", + "id": "64d6cb2c", + "metadata": {}, + "source": [ + "#### Deno.jupyter.display()" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "027948f2", + "metadata": {}, + "outputs": [ + { + "data": { + "application/json": null, + "text/plain": [ + "null" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": {}, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "Deno.jupyter.display(\"text/plain\", Uint8Array.from([1, 2, 3]))" ] }, { diff --git a/runtime/js/40_jupyter.js b/runtime/js/40_jupyter.js new file mode 100644 index 00000000000000..66b0fae9a420cc --- /dev/null +++ b/runtime/js/40_jupyter.js @@ -0,0 +1,14 @@ +// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license. +"use strict"; + +((window) => { + const core = window.__bootstrap.core; + const jupyter = {}; + + function display(mimeType, buf) { + return core.opSync("op_jupyter_display", mimeType, buf); + } + + jupyter.display = display; + window.__bootstrap.jupyter = jupyter; +})(this); \ No newline at end of file diff --git a/runtime/js/90_deno_ns.js b/runtime/js/90_deno_ns.js index 029423ee16572e..a185759e037b23 100644 --- a/runtime/js/90_deno_ns.js +++ b/runtime/js/90_deno_ns.js @@ -143,5 +143,6 @@ funlockSync: __bootstrap.fs.funlockSync, refTimer: __bootstrap.timers.refTimer, unrefTimer: __bootstrap.timers.unrefTimer, + jupyter: __bootstrap.jupyter, }; })(this); From 3e91630f46b95426633a402427e91c0654c98eb6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Thu, 30 Dec 2021 17:22:10 +0100 Subject: [PATCH 055/115] lint & fmt --- cli/tools/jupyter/mod.rs | 12 +++--------- 1 file changed, 3 insertions(+), 9 deletions(-) diff --git a/cli/tools/jupyter/mod.rs b/cli/tools/jupyter/mod.rs index 88040adb5ee823..85bfa51ef47668 100644 --- a/cli/tools/jupyter/mod.rs +++ b/cli/tools/jupyter/mod.rs @@ -525,7 +525,7 @@ impl Kernel { ["exception"]["description"] .as_str() .unwrap() - .split("\n") + .split('\n') .map(|s| s.to_string()) .collect(); ExecResult::Error(ExecError { @@ -735,9 +735,7 @@ impl Kernel { _ => return Ok(ret), }; - if t == "object".to_string() - && d["subtype"] == Value::String("null".to_string()) - { + if t == *"object" && d["subtype"] == Value::String("null".to_string()) { // JavaScript null, the gift that keeps on giving t = "null".to_string(); } @@ -864,11 +862,7 @@ impl DisplayData { } fn is_empty(&self) -> bool { - if self.data_list.len() == 0 { - return true; - } - - return false; + self.data_list.is_empty() } fn to_object(&self) -> Value { From ec65594094c3ec5812db6654861d04af1cbc837d Mon Sep 17 00:00:00 2001 From: Adam Powers Date: Thu, 30 Dec 2021 10:55:28 -0800 Subject: [PATCH 056/115] add binary display data --- cli/tools/jupyter/mod.rs | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) diff --git a/cli/tools/jupyter/mod.rs b/cli/tools/jupyter/mod.rs index eb4a5ed2a3292a..f8579a04e4cc57 100644 --- a/cli/tools/jupyter/mod.rs +++ b/cli/tools/jupyter/mod.rs @@ -9,6 +9,7 @@ use crate::flags::JupyterFlags; use crate::proc_state::ProcState; use crate::tools::repl::EvaluationOutput; use crate::tools::repl::ReplSession; +use base64; use data_encoding::HEXLOWER; use deno_core::anyhow::anyhow; use deno_core::anyhow::Context; @@ -134,7 +135,6 @@ pub fn op_jupyter_display( Some(x) => x, None => return Err(anyhow!("op_jupyter_display missing 'data' argument")), }; - println!("buflen: {}", d.len()); let mut sender = state.borrow_mut::(); sender.unbounded_send(WorkerCommMsg::Display(mime_type, d)); @@ -335,7 +335,6 @@ impl Kernel { &mut self, worker_msg: WorkerCommMsg, ) -> Result<(), AnyError> { - println!("&&& worker_comm_handler"); let comm_ctx = match self.last_comm_ctx.clone() { Some(cc) => cc, None => { @@ -357,9 +356,8 @@ impl Kernel { .await?; } WorkerCommMsg::Display(mime, buf) => { - println!("&&& WorkerCommMsg::Display"); let mut dd = DisplayData::new(); - dd.add(mime.as_ref(), json!(buf)); + dd.add_buf(mime.as_ref(), buf); self.send_display_data(&comm_ctx, dd).await?; } }; @@ -681,7 +679,6 @@ impl Kernel { comm_ctx: &CommContext, display_data: DisplayData, ) -> Result<(), AnyError> { - println!("&&& send_display_data"); if (display_data.is_empty()) { return Err(anyhow!("send_display_data called with empty DisplayData")); } @@ -854,6 +851,11 @@ impl DisplayData { self.data_list.push((mime_type.to_string(), data)); } + fn add_buf(&mut self, mime_type: &str, buf: ZeroCopyBuf) { + let buf_str = base64::encode(buf); + self.add(mime_type, json!(buf_str)); + } + fn is_empty(&self) -> bool { if self.data_list.len() == 0 { return true; From 7f82d0feb3434bf7da137d3c63cc2bbd2b68b1d5 Mon Sep 17 00:00:00 2001 From: Adam Powers Date: Fri, 31 Dec 2021 10:07:08 -0800 Subject: [PATCH 057/115] add display option for string-encoded data --- cli/tools/jupyter/mod.rs | 72 +++++++++++++++++++--------------------- 1 file changed, 34 insertions(+), 38 deletions(-) diff --git a/cli/tools/jupyter/mod.rs b/cli/tools/jupyter/mod.rs index f8579a04e4cc57..f47144f783e90e 100644 --- a/cli/tools/jupyter/mod.rs +++ b/cli/tools/jupyter/mod.rs @@ -108,7 +108,7 @@ type WorkerCommReceiver = UnboundedReceiver; enum WorkerCommMsg { Stderr(String), Stdout(String), - Display(String, ZeroCopyBuf), + Display(String, ZeroCopyBuf, Option, Option), } fn init(rt: &mut JsRuntime) { @@ -119,25 +119,30 @@ fn init(rt: &mut JsRuntime) { #[derive(Deserialize, Debug)] #[serde(rename_all = "camelCase")] -struct DisplayArgs { +pub struct DisplayArgs { mime_type: String, - data: String, + data_format: Option, + metadata: Option, } pub fn op_jupyter_display( state: &mut OpState, - mime_type: String, + args: DisplayArgs, data: Option, ) -> Result<(), AnyError> { - println!("&&& op_jupyter_display"); - println!("mime_type: {}", mime_type); + dbg!(&args); let d = match data { Some(x) => x, None => return Err(anyhow!("op_jupyter_display missing 'data' argument")), }; let mut sender = state.borrow_mut::(); - sender.unbounded_send(WorkerCommMsg::Display(mime_type, d)); + sender.unbounded_send(WorkerCommMsg::Display( + args.mime_type, + d, + args.data_format, + args.metadata, + )); Ok(()) } @@ -355,9 +360,9 @@ impl Kernel { .send_stdio(&comm_ctx, StdioType::Stderr, s.as_ref()) .await?; } - WorkerCommMsg::Display(mime, buf) => { + WorkerCommMsg::Display(mime, buf, format, metadata) => { let mut dd = DisplayData::new(); - dd.add_buf(mime.as_ref(), buf); + dd.add_buf(mime.as_ref(), buf, format, metadata)?; self.send_display_data(&comm_ctx, dd).await?; } }; @@ -478,32 +483,6 @@ impl Kernel { ); self.iopub_comm.send(input_msg).await?; - // let test_svg = r###" - // - // - // - // - // - // "###.to_string(); - // let mut dd = DisplayData::new(); - // dd.add("image/svg+xml", test_svg); - // let dd_msg = SideEffectMessage::new( - // comm_ctx, - // "display_data", - // ReplyMetadata::Empty, - // ReplyContent::DisplayData(DisplayDataContent { - // data: dd.to_value()?, - // metadata: json!({}), - // transient: json!({}), - // }), - // ); - // self.iopub_comm.send(dd_msg).await?; - let output = self .repl_session .evaluate_line_with_object_wrapping(&exec_request_content.code) @@ -851,9 +830,26 @@ impl DisplayData { self.data_list.push((mime_type.to_string(), data)); } - fn add_buf(&mut self, mime_type: &str, buf: ZeroCopyBuf) { - let buf_str = base64::encode(buf); - self.add(mime_type, json!(buf_str)); + fn add_buf( + &mut self, + mime_type: &str, + buf: ZeroCopyBuf, + format: Option, + metadata: Option, + ) -> Result<(), AnyError> { + let fmt_str = match format { + Some(f) => f, + None => "default".to_string(), + }; + + let buf_vec = match fmt_str.as_ref() { + "string" => String::from_utf8(buf.to_vec())?, + "base64" | "default" => base64::encode(buf), + _ => return Err(anyhow!("unknown display mime format: {}", fmt_str)), + }; + self.add(mime_type, json!(buf_vec)); + + Ok(()) } fn is_empty(&self) -> bool { From 8543a88b96ba63c9c2354b1303b9cffaf62da1d4 Mon Sep 17 00:00:00 2001 From: Adam Powers Date: Fri, 31 Dec 2021 10:14:41 -0800 Subject: [PATCH 058/115] add display png --- runtime/js/40_jupyter.js | 59 ++++++++++++++++++++++++++++++++++++++-- 1 file changed, 57 insertions(+), 2 deletions(-) diff --git a/runtime/js/40_jupyter.js b/runtime/js/40_jupyter.js index 66b0fae9a420cc..b7baaacc2e4a1f 100644 --- a/runtime/js/40_jupyter.js +++ b/runtime/js/40_jupyter.js @@ -5,10 +5,65 @@ const core = window.__bootstrap.core; const jupyter = {}; - function display(mimeType, buf) { - return core.opSync("op_jupyter_display", mimeType, buf); + function display(mimeType, buf, opt = {}) { + // for known mime types, do the nice thing and select the known dataFormat + let dataFormat = "base64"; + switch (mimeType) { + case "text/plain": + case "text/html": + dataFormat = "string"; + } + + const args = { + mimeType, + dataFormat: opt.dataFormat ?? dataFormat, + metadata: opt.metadata + }; + + core.opSync("op_jupyter_display", args, buf); + } + + function displayPng(buf, opt = {}) { + display("image/png", buf, opt); + } + + async function displayPngFile(path, opt = {}) { + const buf = await Deno.readFile(path); + displayPng(buf, opt); + } + + // application/json + // text/markdown + // image/bmp + // image/gif + // image/jpeg + // image/svg+xml + // text/html + // text/latex + // application/pdf + // application/vnd.vega.v5+json + // application/vnd.vegalite.v3+json + // application/vdom.v1+json + + function displayFile(path, opt = {}) { + let fileType; + if (opt.hint) { + fileType = opt.hint; + } else { + const pathParts = path.split("."); + fileType = pathParts[pathParts.length - 1]; + } + fileType = fileType.toLowerCase(); + + switch (fileType) { + case "png": return displayPngFile(path, opt); + default: throw new TypeError(`unknown file type: ${fileType}`) + } } jupyter.display = display; + jupyter.displayPng = displayPng; + jupyter.displayPngFile = displayPngFile; + jupyter.displayFile = displayFile; window.__bootstrap.jupyter = jupyter; })(this); \ No newline at end of file From 3c70865c926474c8067934d7da32e55d86dacdfc Mon Sep 17 00:00:00 2001 From: Adam Powers Date: Sat, 1 Jan 2022 14:01:56 -0800 Subject: [PATCH 059/115] add jupyter display html --- runtime/js/40_jupyter.js | 22 +++++++++++++++++++++- 1 file changed, 21 insertions(+), 1 deletion(-) diff --git a/runtime/js/40_jupyter.js b/runtime/js/40_jupyter.js index b7baaacc2e4a1f..2642950f1070f9 100644 --- a/runtime/js/40_jupyter.js +++ b/runtime/js/40_jupyter.js @@ -29,9 +29,26 @@ async function displayPngFile(path, opt = {}) { const buf = await Deno.readFile(path); - displayPng(buf, opt); + displayPng(buf, { + width: opt.width, + height: opt.height, + }); } + function displayHtml(str) { + display("text/html", new TextEncoder().encode(str), { + dataFormat: "string" + }); + } + + async function displayHtmlFile(path) { + const buf = await Deno.readFile(path); + display("text/html", buf, { + dataFormat: "string" + }); + } + + // from: https://jupyterlab.readthedocs.io/en/stable/user/file_formats.html // application/json // text/markdown // image/bmp @@ -57,6 +74,7 @@ switch (fileType) { case "png": return displayPngFile(path, opt); + case "html": return displayHtmlFile(path); default: throw new TypeError(`unknown file type: ${fileType}`) } } @@ -64,6 +82,8 @@ jupyter.display = display; jupyter.displayPng = displayPng; jupyter.displayPngFile = displayPngFile; + jupyter.displayHtml = displayHtml; + jupyter.displayHtmlFile = displayHtmlFile; jupyter.displayFile = displayFile; window.__bootstrap.jupyter = jupyter; })(this); \ No newline at end of file From 4e008b12fa14eab0523fac2e550b016b275818b4 Mon Sep 17 00:00:00 2001 From: Adam Powers Date: Sat, 1 Jan 2022 14:02:59 -0800 Subject: [PATCH 060/115] jupyter test data --- cli/tests/testdata/jupyter/test.html | 2 ++ cli/tests/testdata/jupyter/test.jpeg | Bin 0 -> 32212 bytes cli/tests/testdata/jupyter/test.pdf | Bin 0 -> 13264 bytes cli/tests/testdata/jupyter/test.png | Bin 0 -> 222611 bytes cli/tests/testdata/jupyter/test.svg | 11 +++++++++++ 5 files changed, 13 insertions(+) create mode 100644 cli/tests/testdata/jupyter/test.html create mode 100644 cli/tests/testdata/jupyter/test.jpeg create mode 100644 cli/tests/testdata/jupyter/test.pdf create mode 100644 cli/tests/testdata/jupyter/test.png create mode 100644 cli/tests/testdata/jupyter/test.svg diff --git a/cli/tests/testdata/jupyter/test.html b/cli/tests/testdata/jupyter/test.html new file mode 100644 index 00000000000000..bbfcdcc1e54269 --- /dev/null +++ b/cli/tests/testdata/jupyter/test.html @@ -0,0 +1,2 @@ +

Dummy Heading

+Dummy text. \ No newline at end of file diff --git a/cli/tests/testdata/jupyter/test.jpeg b/cli/tests/testdata/jupyter/test.jpeg new file mode 100644 index 0000000000000000000000000000000000000000..1e519b6a08062a34bf19197309a8765bf1707c03 GIT binary patch literal 32212 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 literal 0 HcmV?d00001 diff --git a/cli/tests/testdata/jupyter/test.png b/cli/tests/testdata/jupyter/test.png new file mode 100644 index 0000000000000000000000000000000000000000..3b8a8f148140f3b2d334b9c893812fe103359839 GIT binary patch literal 222611 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 PHsHdBM~1Z?I(6ZHZ2Z`L literal 0 HcmV?d00001 diff --git a/cli/tests/testdata/jupyter/test.svg b/cli/tests/testdata/jupyter/test.svg new file mode 100644 index 00000000000000..5cbb1d25c355c2 --- /dev/null +++ b/cli/tests/testdata/jupyter/test.svg @@ -0,0 +1,11 @@ + + + + + + From 5883413b28712c08c57896c20095e709c6d93521 Mon Sep 17 00:00:00 2001 From: Adam Powers Date: Sat, 1 Jan 2022 14:03:43 -0800 Subject: [PATCH 061/115] add html tests --- integration_test.ipynb | 361 ++++++++++++++++++++++++++++++++++++----- 1 file changed, 322 insertions(+), 39 deletions(-) diff --git a/integration_test.ipynb b/integration_test.ipynb index 1f74e19572f8c9..f67390336028ae 100644 --- a/integration_test.ipynb +++ b/integration_test.ipynb @@ -20,7 +20,9 @@ { "cell_type": "markdown", "id": "669f972e", - "metadata": {}, + "metadata": { + "heading_collapsed": true + }, "source": [ "### Simple Tests" ] @@ -28,7 +30,9 @@ { "cell_type": "markdown", "id": "e7e8a512", - "metadata": {}, + "metadata": { + "hidden": true + }, "source": [ "#### This test should print \"hi\".\n", "If this doesn't work, everything else will probably fail :)" @@ -36,9 +40,11 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "id": "a5d38758", - "metadata": {}, + "metadata": { + "hidden": true + }, "outputs": [ { "name": "stdout", @@ -55,7 +61,9 @@ { "cell_type": "markdown", "id": "bc5ce8e3", - "metadata": {}, + "metadata": { + "hidden": true + }, "source": [ "#### Top-level await" ] @@ -64,7 +72,9 @@ "cell_type": "code", "execution_count": 3, "id": "f7fa885a", - "metadata": {}, + "metadata": { + "hidden": true + }, "outputs": [ { "name": "stdout", @@ -82,7 +92,9 @@ { "cell_type": "markdown", "id": "c21455ae", - "metadata": {}, + "metadata": { + "hidden": true + }, "source": [ "#### TypeScript transpiling\n", "Credit to [typescriptlang.org](https://www.typescriptlang.org/docs/handbook/interfaces.html) for this code" @@ -92,7 +104,9 @@ "cell_type": "code", "execution_count": 5, "id": "08a17340", - "metadata": {}, + "metadata": { + "hidden": true + }, "outputs": [ { "data": { @@ -124,7 +138,9 @@ { "cell_type": "markdown", "id": "eaa0ebc0", - "metadata": {}, + "metadata": { + "heading_collapsed": true + }, "source": [ "### Return Values" ] @@ -132,7 +148,9 @@ { "cell_type": "markdown", "id": "52876276", - "metadata": {}, + "metadata": { + "hidden": true + }, "source": [ "#### undefined should not return a value" ] @@ -141,7 +159,9 @@ "cell_type": "code", "execution_count": 3, "id": "bbf2c09b", - "metadata": {}, + "metadata": { + "hidden": true + }, "outputs": [], "source": [ "undefined" @@ -150,7 +170,9 @@ { "cell_type": "markdown", "id": "e175c803", - "metadata": {}, + "metadata": { + "hidden": true + }, "source": [ "#### null should return \"null\"" ] @@ -159,7 +181,9 @@ "cell_type": "code", "execution_count": 13, "id": "d9801d80", - "metadata": {}, + "metadata": { + "hidden": true + }, "outputs": [ { "data": { @@ -180,7 +204,9 @@ { "cell_type": "markdown", "id": "a2a716dc", - "metadata": {}, + "metadata": { + "hidden": true + }, "source": [ "#### boolean should return the boolean" ] @@ -189,7 +215,9 @@ "cell_type": "code", "execution_count": 6, "id": "cfaac330", - "metadata": {}, + "metadata": { + "hidden": true + }, "outputs": [ { "data": { @@ -210,7 +238,9 @@ { "cell_type": "markdown", "id": "8d9f1aba", - "metadata": {}, + "metadata": { + "hidden": true + }, "source": [ "#### number should return the number" ] @@ -219,7 +249,9 @@ "cell_type": "code", "execution_count": 7, "id": "ec3be2da", - "metadata": {}, + "metadata": { + "hidden": true + }, "outputs": [ { "data": { @@ -240,7 +272,9 @@ { "cell_type": "markdown", "id": "60965915", - "metadata": {}, + "metadata": { + "hidden": true + }, "source": [ "#### string should return the string" ] @@ -249,7 +283,9 @@ "cell_type": "code", "execution_count": 8, "id": "997cf2d7", - "metadata": {}, + "metadata": { + "hidden": true + }, "outputs": [ { "data": { @@ -270,7 +306,9 @@ { "cell_type": "markdown", "id": "fe38dc27", - "metadata": {}, + "metadata": { + "hidden": true + }, "source": [ "#### bigint should return the bigint in literal format" ] @@ -279,7 +317,9 @@ "cell_type": "code", "execution_count": 9, "id": "44b63807", - "metadata": {}, + "metadata": { + "hidden": true + }, "outputs": [ { "data": { @@ -300,7 +340,9 @@ { "cell_type": "markdown", "id": "843ccb6c", - "metadata": {}, + "metadata": { + "hidden": true + }, "source": [ "#### symbol should return a string describing the symbol" ] @@ -309,7 +351,9 @@ "cell_type": "code", "execution_count": 10, "id": "e10c0d31", - "metadata": {}, + "metadata": { + "hidden": true + }, "outputs": [ { "data": { @@ -330,7 +374,9 @@ { "cell_type": "markdown", "id": "171b817f", - "metadata": {}, + "metadata": { + "hidden": true + }, "source": [ "#### object should describe the object inspection" ] @@ -339,7 +385,9 @@ "cell_type": "code", "execution_count": 11, "id": "81c99233", - "metadata": {}, + "metadata": { + "hidden": true + }, "outputs": [ { "data": { @@ -361,7 +409,9 @@ "cell_type": "code", "execution_count": 12, "id": "c065ff3d", - "metadata": {}, + "metadata": { + "hidden": true + }, "outputs": [ { "data": { @@ -573,10 +623,69 @@ "Deno" ] }, + { + "cell_type": "markdown", + "id": "6caeb583", + "metadata": { + "hidden": true + }, + "source": [ + "#### resolve returned promise" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "43c1581b", + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "Promise { \u001b[32m\"it worked!\"\u001b[39m }" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Promise.resolve(\"it worked!\")" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "9a34b725", + "metadata": { + "hidden": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "Promise { \u001b[31m\u001b[39m Error: it failed!\n", + " at :2:16 }" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Promise.reject(new Error(\"it failed!\"));" + ] + }, { "cell_type": "markdown", "id": "3a89dada", - "metadata": {}, + "metadata": { + "hidden": true + }, "source": [ "#### object with Symbol(\"toPng\") should return an image (TODO)" ] @@ -599,37 +708,182 @@ }, { "cell_type": "code", - "execution_count": 1, - "id": "027948f2", + "execution_count": 9, + "id": "959bf8a6", "metadata": {}, "outputs": [ { "data": { - "application/json": null, "text/plain": [ - "null" + "testing 1 2 3" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "let displayBuf1 = new TextEncoder().encode(\"testing 1 2 3\");\n", + "Deno.jupyter.display(\"text/plain\", displayBuf1, {dataFormat: \"string\"});" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "68203ac8", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "let displayBuf2 = Deno.readFileSync(\"./cli/tests/testdata/jupyter/test.png\");\n", + "Deno.jupyter.display(\"image/png\", displayBuf2);" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "e1fb4d47", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "

This is a heading

And this is some text." + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "let displayBuf3 = new TextEncoder().encode(\"

This is a heading

And this is some text.\");\n", + "Deno.jupyter.display(\"text/html\", displayBuf3, {dataFormat: \"string\"});" + ] + }, + { + "cell_type": "markdown", + "id": "887ef658", + "metadata": {}, + "source": [ + "#### PNG" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "53e74633", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Promise {\n", + " \u001b[31m\u001b[39m TypeError: Deno.fileRead is not a function\n", + " at Object.displayPngFile (deno:runtime/js/40_jupyter.js:23:28)\n", + " at :2:14\n", + "}" ] }, - "execution_count": 1, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" - }, + } + ], + "source": [ + "await Deno.jupyter.displayPngFile(\"./cli/tests/testdata/jupyter/test.png\");" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "215e9465", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "let pngBuf = await Deno.readFile(\"./cli/tests/testdata/jupyter/test.png\");\n", + "Deno.jupyter.displayPng(pngBuf);" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "2384fe0e", + "metadata": {}, + "outputs": [ { - "data": {}, + "data": { + "image/png": "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" + }, "metadata": {}, "output_type": "display_data" } ], "source": [ - "Deno.jupyter.display(\"text/plain\", Uint8Array.from([1, 2, 3]))" + "Deno.jupyter.displayPng(pngBuf, {width: 80, height: 60});" ] }, { "cell_type": "markdown", - "id": "3b6d484c", + "id": "85747c36", + "metadata": {}, + "source": [ + "#### HTML" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1b599abd", "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "

Dummy Heading

\n", + "Dummy text." + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "## Failing Tests" + "await Deno.jupyter.displayHtmlFile(\"./cli/tests/testdata/jupyter/test.html\");" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "f8e1dbb8", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "

This is a test

" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "Deno.jupyter.displayHtml(\"

This is a test

\");" ] }, { @@ -644,7 +898,9 @@ "cell_type": "code", "execution_count": null, "id": "b5c7b819", - "metadata": {}, + "metadata": { + "scrolled": true + }, "outputs": [ { "ename": "\"Error\"", @@ -662,6 +918,33 @@ " throw new Error(\"this is a test\")\n", "})()" ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "72d01fdd", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Promise {\n", + " \u001b[31m\u001b[39m TypeError: Error parsing args: serde_v8 error: ExpectedString\n", + " at Object.opAsync (deno:core/01_core.js:141:28)\n", + " at open (deno:runtime/js/40_files.js:51:28)\n", + " at Object.readFile (deno:runtime/js/40_read_file.js:25:24)\n", + " at :2:6\n", + "}" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Deno.readFile(1)" + ] } ], "metadata": { @@ -687,7 +970,7 @@ "toc_cell": false, "toc_position": {}, "toc_section_display": true, - "toc_window_display": false + "toc_window_display": true } }, "nbformat": 4, From e2b01b899a27e2fad317a4bf357fc9b0a1a3974b Mon Sep 17 00:00:00 2001 From: Adam Powers Date: Sat, 1 Jan 2022 15:07:55 -0800 Subject: [PATCH 062/115] add jupyter display metadata --- cli/tools/jupyter/mod.rs | 69 ++++++++++++++++++++++++++++++---------- integration_test.ipynb | 20 ++++++++---- runtime/js/40_jupyter.js | 12 ++++--- 3 files changed, 73 insertions(+), 28 deletions(-) diff --git a/cli/tools/jupyter/mod.rs b/cli/tools/jupyter/mod.rs index f47144f783e90e..b6363efbfefa02 100644 --- a/cli/tools/jupyter/mod.rs +++ b/cli/tools/jupyter/mod.rs @@ -108,7 +108,7 @@ type WorkerCommReceiver = UnboundedReceiver; enum WorkerCommMsg { Stderr(String), Stdout(String), - Display(String, ZeroCopyBuf, Option, Option), + Display(String, ZeroCopyBuf, Option, Option), } fn init(rt: &mut JsRuntime) { @@ -122,7 +122,7 @@ fn init(rt: &mut JsRuntime) { pub struct DisplayArgs { mime_type: String, data_format: Option, - metadata: Option, + metadata: Option, } pub fn op_jupyter_display( @@ -361,9 +361,10 @@ impl Kernel { .await?; } WorkerCommMsg::Display(mime, buf, format, metadata) => { - let mut dd = DisplayData::new(); - dd.add_buf(mime.as_ref(), buf, format, metadata)?; - self.send_display_data(&comm_ctx, dd).await?; + let mut dd = MimeSet::new(); + dd.add_buf(mime.as_ref(), buf, format)?; + let md = self.create_display_metadata(mime, metadata)?; + self.send_display_data(&comm_ctx, dd, md).await?; } }; @@ -656,20 +657,20 @@ impl Kernel { async fn send_display_data( &mut self, comm_ctx: &CommContext, - display_data: DisplayData, + display_data: MimeSet, + metadata: MimeSet, ) -> Result<(), AnyError> { if (display_data.is_empty()) { - return Err(anyhow!("send_display_data called with empty DisplayData")); + return Err(anyhow!("send_display_data called with empty display data")); } - let data = display_data.to_object(); let msg = SideEffectMessage::new( comm_ctx, "display_data", ReplyMetadata::Empty, ReplyContent::DisplayData(DisplayDataContent { - data, - metadata: json!({}), + data: display_data.to_object(), + metadata: metadata.to_object(), transient: json!({}), }), ); @@ -682,9 +683,9 @@ impl Kernel { async fn display_data_from_result_value( &mut self, data: Value, - ) -> Result { + ) -> Result { let mut d = &data; - let mut ret = DisplayData::new(); + let mut ret = MimeSet::new(); // if we passed in a result, unwrap it d = if d["result"].is_object() { &d["result"] @@ -753,6 +754,43 @@ impl Kernel { Ok(ret) } + fn create_display_metadata( + &self, + format: String, + metadata: Option, + ) -> Result { + let mut ms = MimeSet::new(); + let format_str = format.as_ref(); + + let md = match metadata { + Some(m) => m, + None => { + ms.add(format_str, json!({})); + return Ok(ms); + } + }; + + match format_str { + "image/png" | "image/bmp" | "image/gif" | "image/jpeg" + | "image/svg+xml" => ms.add( + format_str, + json!({ + "width": md["width"], + "height": md["height"], + }), + ), + "application/json" => ms.add( + format_str, + json!({ + "expanded": md["width"], + }), + ), + _ => ms.add(format_str, md), + } + + Ok(ms) + } + async fn decode_object( &mut self, obj: Value, @@ -817,12 +855,12 @@ impl Kernel { } } -struct DisplayData { +struct MimeSet { data_list: Vec<(String, Value)>, } -impl DisplayData { - fn new() -> DisplayData { +impl MimeSet { + fn new() -> MimeSet { Self { data_list: vec![] } } @@ -835,7 +873,6 @@ impl DisplayData { mime_type: &str, buf: ZeroCopyBuf, format: Option, - metadata: Option, ) -> Result<(), AnyError> { let fmt_str = match format { Some(f) => f, diff --git a/integration_test.ipynb b/integration_test.ipynb index f67390336028ae..89189139f2fe03 100644 --- a/integration_test.ipynb +++ b/integration_test.ipynb @@ -802,7 +802,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "id": "215e9465", "metadata": {}, "outputs": [ @@ -815,26 +815,32 @@ } ], "source": [ - "let pngBuf = await Deno.readFile(\"./cli/tests/testdata/jupyter/test.png\");\n", - "Deno.jupyter.displayPng(pngBuf);" + "let pngBuf1 = await Deno.readFile(\"./cli/tests/testdata/jupyter/test.png\");\n", + "Deno.jupyter.displayPng(pngBuf1);" ] }, { "cell_type": "code", - "execution_count": 14, - "id": "2384fe0e", + "execution_count": 1, + "id": "de6764fb", "metadata": {}, "outputs": [ { "data": { "image/png": "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" }, - "metadata": {}, + "metadata": { + "image/png": { + "height": 60, + "width": 80 + } + }, "output_type": "display_data" } ], "source": [ - "Deno.jupyter.displayPng(pngBuf, {width: 80, height: 60});" + "let pngBuf1 = await Deno.readFile(\"./cli/tests/testdata/jupyter/test.png\");\n", + "Deno.jupyter.displayPng(pngBuf1, {width: 80, height: 60});" ] }, { diff --git a/runtime/js/40_jupyter.js b/runtime/js/40_jupyter.js index 2642950f1070f9..b86b328f4bc68d 100644 --- a/runtime/js/40_jupyter.js +++ b/runtime/js/40_jupyter.js @@ -24,15 +24,17 @@ } function displayPng(buf, opt = {}) { - display("image/png", buf, opt); + display("image/png", buf, { + metadata: { + width: opt.width, + height: opt.height, + } + }); } async function displayPngFile(path, opt = {}) { const buf = await Deno.readFile(path); - displayPng(buf, { - width: opt.width, - height: opt.height, - }); + displayPng(buf, opt); } function displayHtml(str) { From a3cf36b0b73d82545116e3ece0b16106190aa1ac Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Mon, 3 Jan 2022 16:13:32 +0100 Subject: [PATCH 063/115] fmt and lint --- runtime/js/40_jupyter.js | 20 +++++++++++++------- 1 file changed, 13 insertions(+), 7 deletions(-) diff --git a/runtime/js/40_jupyter.js b/runtime/js/40_jupyter.js index 0102ae357105f4..59d40ff91130fa 100644 --- a/runtime/js/40_jupyter.js +++ b/runtime/js/40_jupyter.js @@ -3,6 +3,9 @@ ((window) => { const core = window.__bootstrap.core; + const { + TypeError, + } = window.__bootstrap.primordials; const jupyter = {}; function display(mimeType, buf, opt = {}) { @@ -17,7 +20,7 @@ const args = { mimeType, dataFormat: opt.dataFormat ?? dataFormat, - metadata: opt.metadata + metadata: opt.metadata, }; core.opSync("op_jupyter_display", args, buf); @@ -28,7 +31,7 @@ metadata: { width: opt.width, height: opt.height, - } + }, }); } @@ -39,14 +42,14 @@ function displayHtml(str) { display("text/html", new TextEncoder().encode(str), { - dataFormat: "string" + dataFormat: "string", }); } async function displayHtmlFile(path) { const buf = await Deno.readFile(path); display("text/html", buf, { - dataFormat: "string" + dataFormat: "string", }); } @@ -75,9 +78,12 @@ fileType = fileType.toLowerCase(); switch (fileType) { - case "png": return displayPngFile(path, opt); - case "html": return displayHtmlFile(path); - default: throw new TypeError(`unknown file type: ${fileType}`) + case "png": + return displayPngFile(path, opt); + case "html": + return displayHtmlFile(path); + default: + throw new TypeError(`unknown file type: ${fileType}`); } } From 1a0aedc5a9706ac4f2ffd5497066f40c014f98ea Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Mon, 3 Jan 2022 20:39:06 +0100 Subject: [PATCH 064/115] add identity to zmq sockets --- cli/tools/jupyter/comm.rs | 32 +++++++++++++++++++----------- cli/tools/jupyter/message_types.rs | 10 ++++++---- cli/tools/jupyter/mod.rs | 21 +++++++++----------- 3 files changed, 35 insertions(+), 28 deletions(-) diff --git a/cli/tools/jupyter/comm.rs b/cli/tools/jupyter/comm.rs index 63cd8fd8c69f0e..8188b99d07d25b 100644 --- a/cli/tools/jupyter/comm.rs +++ b/cli/tools/jupyter/comm.rs @@ -3,6 +3,8 @@ use deno_core::error::AnyError; use ring::hmac; use zeromq::prelude::*; +use zeromq::util::PeerIdentity; +use zeromq::SocketOptions; use super::hmac_verify; use super::ReplyMessage; @@ -11,24 +13,25 @@ use super::SideEffectMessage; pub struct PubComm { conn_str: String, - session_id: String, + identity: String, hmac_key: hmac::Key, socket: zeromq::PubSocket, } // TODO(apowers313) connect and send look like traits shared with DealerComm impl PubComm { - pub fn new( - conn_str: String, - session_id: String, - hmac_key: hmac::Key, - ) -> Self { + pub fn new(conn_str: String, identity: String, hmac_key: hmac::Key) -> Self { println!("iopub connection: {}", conn_str); + let peer_identity = + PeerIdentity::try_from(identity.as_bytes().to_vec()).unwrap(); + let mut options = SocketOptions::default(); + options.peer_identity(peer_identity); + Self { conn_str, - session_id, + identity, hmac_key, - socket: zeromq::PubSocket::new(), + socket: zeromq::PubSocket::with_options(options), } } @@ -49,7 +52,7 @@ impl PubComm { pub struct DealerComm { name: String, conn_str: String, - session_id: String, + identity: String, hmac_key: hmac::Key, socket: zeromq::DealerSocket, } @@ -58,16 +61,21 @@ impl DealerComm { pub fn new( name: &str, conn_str: String, - session_id: String, + identity: String, hmac_key: hmac::Key, ) -> Self { println!("dealer '{}' connection: {}", name, conn_str); + let peer_identity = + PeerIdentity::try_from(identity.as_bytes().to_vec()).unwrap(); + let mut options = SocketOptions::default(); + options.peer_identity(peer_identity); + Self { name: name.to_string(), conn_str, - session_id, + identity, hmac_key, - socket: zeromq::DealerSocket::new(), + socket: zeromq::DealerSocket::with_options(options), } } diff --git a/cli/tools/jupyter/message_types.rs b/cli/tools/jupyter/message_types.rs index fb2e7eb09d2193..e661d1c855ce17 100644 --- a/cli/tools/jupyter/message_types.rs +++ b/cli/tools/jupyter/message_types.rs @@ -81,7 +81,10 @@ impl ReplyMessage { content: ReplyContent, ) -> Self { Self { - header: MessageHeader::new(msg_type, comm_ctx.session_id.clone()), + header: MessageHeader::new( + msg_type, + comm_ctx.message.header.session.clone(), + ), parent_header: comm_ctx.message.header.clone(), metadata, content, @@ -135,7 +138,6 @@ pub type SideEffectMessage = ReplyMessage; #[derive(Clone, Debug)] pub struct CommContext { pub message: RequestMessage, - pub session_id: String, } #[derive(Debug, Deserialize, Serialize, Clone)] @@ -152,14 +154,14 @@ pub struct MessageHeader { } impl MessageHeader { - pub fn new(msg_type: &str, session_id: String) -> Self { + pub fn new(msg_type: &str, session: String) -> Self { let now = std::time::SystemTime::now(); let now: chrono::DateTime = now.into(); let now = now.to_rfc3339(); Self { msg_id: uuid::Uuid::new_v4().to_string(), - session: session_id, + session, // FIXME: username: "".to_string(), date: now, diff --git a/cli/tools/jupyter/mod.rs b/cli/tools/jupyter/mod.rs index 1a1131ca019a24..e26b6e3d7180cc 100644 --- a/cli/tools/jupyter/mod.rs +++ b/cli/tools/jupyter/mod.rs @@ -64,7 +64,7 @@ pub async fn kernel( let conn_file_path = jupyter_flags.conn_file.unwrap(); let mut kernel = Kernel::new(flags, conn_file_path.to_str().unwrap()).await?; - println!("[DENO] kernel created: {:#?}", kernel.session_id); + println!("[DENO] kernel created: {:#?}", kernel.identity); println!("running kernel..."); kernel.run().await; @@ -89,7 +89,7 @@ struct Kernel { control_comm: DealerComm, stdin_comm: DealerComm, hb_comm: HbComm, - session_id: String, + identity: String, execution_count: u32, repl_session: ReplSession, stdio_rx: WorkerCommReceiver, @@ -185,30 +185,30 @@ impl Kernel { println!("[DENO] parsed conn file: {:#?}", spec); let execution_count = 0; - let session_id = uuid::Uuid::new_v4().to_string(); + let identity = uuid::Uuid::new_v4().to_string(); let hmac_key = hmac::Key::new(hmac::HMAC_SHA256, spec.key.as_ref()); let metadata = KernelMetadata::default(); let iopub_comm = PubComm::new( create_conn_str(&spec.transport, &spec.ip, spec.iopub_port), - session_id.clone(), + identity.clone(), hmac_key.clone(), ); let shell_comm = DealerComm::new( "shell", create_conn_str(&spec.transport, &spec.ip, spec.shell_port), - session_id.clone(), + identity.clone(), hmac_key.clone(), ); let control_comm = DealerComm::new( "control", create_conn_str(&spec.transport, &spec.ip, spec.control_port), - session_id.clone(), + identity.clone(), hmac_key.clone(), ); let stdin_comm = DealerComm::new( "stdin", create_conn_str(&spec.transport, &spec.ip, spec.stdin_port), - session_id.clone(), + identity.clone(), hmac_key, ); let hb_comm = @@ -237,7 +237,7 @@ impl Kernel { control_comm, stdin_comm, hb_comm, - session_id, + identity, execution_count, repl_session, stdio_rx, @@ -309,10 +309,7 @@ impl Kernel { } }; - let comm_ctx = CommContext { - session_id: self.session_id.clone(), - message: req_msg, - }; + let comm_ctx = CommContext { message: req_msg }; self.last_comm_ctx = Some(comm_ctx.clone()); println!("[DENO] set_state busy {:#?}", handler_type); From 558858327de1f164ef75b05a929b567ba41f2a1b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Mon, 3 Jan 2022 23:20:10 +0100 Subject: [PATCH 065/115] execution_count for errors, execution_count for exec results, use -L debug for zmq messages --- cli/tools/jupyter/comm.rs | 8 ++++---- cli/tools/jupyter/message_types.rs | 8 +++++--- cli/tools/jupyter/mod.rs | 6 +++--- 3 files changed, 12 insertions(+), 10 deletions(-) diff --git a/cli/tools/jupyter/comm.rs b/cli/tools/jupyter/comm.rs index 8188b99d07d25b..8d7a1f7c02d298 100644 --- a/cli/tools/jupyter/comm.rs +++ b/cli/tools/jupyter/comm.rs @@ -42,7 +42,7 @@ impl PubComm { } pub async fn send(&mut self, msg: SideEffectMessage) -> Result<(), AnyError> { - println!("==> IoPub SENDING: {:#?}", msg); + log::debug!("==> IoPub SENDING: {:#?}", msg); let zmq_msg = msg.serialize(&self.hmac_key); self.socket.send(zmq_msg).await?; Ok(()) @@ -98,15 +98,15 @@ impl DealerComm { )?; let jup_msg = RequestMessage::try_from(zmq_msg)?; - println!("<== {} RECEIVING: {:#?}", self.name, jup_msg); + log::debug!("<== {} RECEIVING: {:#?}", self.name, jup_msg); Ok(jup_msg) } pub async fn send(&mut self, msg: ReplyMessage) -> Result<(), AnyError> { - println!("==> {} SENDING: {:#?}", self.name, msg); + log::debug!("==> {} SENDING: {:#?}", self.name, msg); let zmq_msg = msg.serialize(&self.hmac_key); self.socket.send(zmq_msg).await?; - println!("==> {} SENT", self.name); + log::debug!("==> {} SENT", self.name); Ok(()) } } diff --git a/cli/tools/jupyter/message_types.rs b/cli/tools/jupyter/message_types.rs index e661d1c855ce17..cfcab9e7821b7b 100644 --- a/cli/tools/jupyter/message_types.rs +++ b/cli/tools/jupyter/message_types.rs @@ -59,7 +59,7 @@ impl TryFrom for RequestMessage { }; let rm = RequestMessage::new(header, mc.0, mc.1); - println!("<== RECEIVING MSG [{}]: {:#?}", msg_type, rm); + log::debug!("<== RECEIVING MSG [{}]: {:#?}", msg_type, rm); Ok(rm) } @@ -123,9 +123,10 @@ impl ReplyMessage { zmq_msg.push_back(parent_header.into()); zmq_msg.push_back(metadata.into()); zmq_msg.push_back(content.into()); - println!( + log::debug!( "==> SENDING MSG [{}]: {:#?}", - &self.header.msg_type, zmq_msg + &self.header.msg_type, + zmq_msg ); zmq_msg @@ -462,6 +463,7 @@ pub struct ExecuteResultContent { /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#messages-on-the-shell-router-dealer-channel #[derive(Debug, Serialize, Deserialize)] pub struct ExecuteErrorContent { + pub execution_count: u32, pub status: String, pub payload: Vec, pub user_expressions: Value, diff --git a/cli/tools/jupyter/mod.rs b/cli/tools/jupyter/mod.rs index e26b6e3d7180cc..58642c7b718c39 100644 --- a/cli/tools/jupyter/mod.rs +++ b/cli/tools/jupyter/mod.rs @@ -139,7 +139,6 @@ pub fn op_jupyter_display( args: DisplayArgs, data: Option, ) -> Result<(), AnyError> { - dbg!(&args); let d = match data { Some(x) => x, None => return Err(anyhow!("op_jupyter_display missing 'data' argument")), @@ -533,7 +532,7 @@ impl Kernel { &mut self, comm_ctx: &CommContext, ) -> Result<(), AnyError> { - println!("sending exec result"); + println!("sending exec result {}", self.execution_count); let msg = ReplyMessage::new( comm_ctx, "execute_reply", @@ -556,6 +555,7 @@ impl Kernel { comm_ctx: &CommContext, result: &ExecResult, ) -> Result<(), AnyError> { + println!("sending exec reply error {}", self.execution_count); let e = match result { ExecResult::Error(e) => e, _ => return Err(anyhow!("send_execute_reply_error: unreachable")), @@ -565,6 +565,7 @@ impl Kernel { "execute_reply", ReplyMetadata::Empty, ReplyContent::ExecuteError(ExecuteErrorContent { + execution_count: self.execution_count, status: "error".to_string(), payload: vec![], user_expressions: json!({}), @@ -680,7 +681,6 @@ impl Kernel { transient: json!({}), }), ); - dbg!(&msg); self.iopub_comm.send(msg).await?; Ok(()) From 09fb24c74f4788fb1f2fd2d78a074b3abe2d6db6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Mon, 3 Jan 2022 23:40:50 +0100 Subject: [PATCH 066/115] add support for DEBUG env var --- cli/tools/jupyter/mod.rs | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/cli/tools/jupyter/mod.rs b/cli/tools/jupyter/mod.rs index 58642c7b718c39..b479bdf840537d 100644 --- a/cli/tools/jupyter/mod.rs +++ b/cli/tools/jupyter/mod.rs @@ -6,6 +6,7 @@ use crate::create_main_worker; use crate::flags::Flags; use crate::flags::JupyterFlags; +use crate::logger; use crate::proc_state::ProcState; use crate::tools::repl::EvaluationOutput; use crate::tools::repl::ReplSession; @@ -61,6 +62,11 @@ pub async fn kernel( return Err(generic_error("Missing --conn flag")); } + // This env var might be set by notebook + if std::env::var("DEBUG").is_ok() { + logger::init(Some(log::Level::Debug)); + } + let conn_file_path = jupyter_flags.conn_file.unwrap(); let mut kernel = Kernel::new(flags, conn_file_path.to_str().unwrap()).await?; From fd9b55c8e921dd81f71364fbd844bb7331de82ad Mon Sep 17 00:00:00 2001 From: Adam Powers Date: Mon, 3 Jan 2022 23:03:37 -0800 Subject: [PATCH 067/115] add display json data format --- cli/tools/jupyter/mod.rs | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) diff --git a/cli/tools/jupyter/mod.rs b/cli/tools/jupyter/mod.rs index b6363efbfefa02..0aa6d8062ada59 100644 --- a/cli/tools/jupyter/mod.rs +++ b/cli/tools/jupyter/mod.rs @@ -379,6 +379,11 @@ impl Kernel { let result = match msg_type { "kernel_info_request" => self.kernel_info_reply(comm_ctx).await, "execute_request" => self.execute_request(comm_ctx).await, + // "inspect_request" => self.inspect_request(comm_ctx).await, + // "complete_request" => self.complete_request(comm_ctx).await, + // "history_request" => self.history_request(comm_ctx).await, + // "is_complete_request" => self.is_complete_request(comm_ctx).await, + // "comm_info_request" => self.comm_info_request(comm_ctx).await, _ => { println!("[shell] no handler for {}", msg_type); Ok(()) @@ -879,12 +884,13 @@ impl MimeSet { None => "default".to_string(), }; - let buf_vec = match fmt_str.as_ref() { - "string" => String::from_utf8(buf.to_vec())?, - "base64" | "default" => base64::encode(buf), + let json_data = match fmt_str.as_ref() { + "string" => json!(String::from_utf8(buf.to_vec())?), + "json" => serde_json::from_str(std::str::from_utf8(&buf.to_vec())?)?, + "base64" | "default" => json!(base64::encode(buf)), _ => return Err(anyhow!("unknown display mime format: {}", fmt_str)), }; - self.add(mime_type, json!(buf_vec)); + self.add(mime_type, json_data); Ok(()) } From 88bc9795141726b5434bac2d51e6be038fdf4194 Mon Sep 17 00:00:00 2001 From: Adam Powers Date: Mon, 3 Jan 2022 23:21:59 -0800 Subject: [PATCH 068/115] add display vega lite --- runtime/js/40_jupyter.js | 17 ++++++++++++++++- 1 file changed, 16 insertions(+), 1 deletion(-) diff --git a/runtime/js/40_jupyter.js b/runtime/js/40_jupyter.js index b86b328f4bc68d..4c3d6a6a769bbf 100644 --- a/runtime/js/40_jupyter.js +++ b/runtime/js/40_jupyter.js @@ -50,6 +50,19 @@ }); } + function displayVegaLite(spec) { + if (typeof spec === "object") { + spec = JSON.stringify(spec); + } + + display("application/vnd.vegalite.v3+json", new TextEncoder().encode(spec), { dataFormat: "json" }); + } + + async function displayVegaLiteFile(path) { + const buf = await Deno.readFile(path); + display("application/vnd.vegalite.v3+json", buf, { dataFormat: "json" }); + } + // from: https://jupyterlab.readthedocs.io/en/stable/user/file_formats.html // application/json // text/markdown @@ -61,7 +74,6 @@ // text/latex // application/pdf // application/vnd.vega.v5+json - // application/vnd.vegalite.v3+json // application/vdom.v1+json function displayFile(path, opt = {}) { @@ -77,6 +89,7 @@ switch (fileType) { case "png": return displayPngFile(path, opt); case "html": return displayHtmlFile(path); + case "vl": return displayVegaLiteFile(path); default: throw new TypeError(`unknown file type: ${fileType}`) } } @@ -86,6 +99,8 @@ jupyter.displayPngFile = displayPngFile; jupyter.displayHtml = displayHtml; jupyter.displayHtmlFile = displayHtmlFile; + jupyter.displayVegaLite = displayVegaLite; + jupyter.displayVegaLiteFile = displayVegaLiteFile; jupyter.displayFile = displayFile; window.__bootstrap.jupyter = jupyter; })(this); \ No newline at end of file From 8903ed4b76303e46824de5b88f7a1d0d151880f1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Tue, 4 Jan 2022 16:58:58 +0100 Subject: [PATCH 069/115] vega in notebook --- integration_test.ipynb | 177 ++++++++++++++++++++++++++++++++++++++++- 1 file changed, 175 insertions(+), 2 deletions(-) diff --git a/integration_test.ipynb b/integration_test.ipynb index 89189139f2fe03..5473cc26116baf 100644 --- a/integration_test.ipynb +++ b/integration_test.ipynb @@ -951,13 +951,186 @@ "source": [ "Deno.readFile(1)" ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cb45353d", + "metadata": {}, + "outputs": [], + "source": [ + "import * as vl from \"https://esm.sh/vega-lite-api@5\";" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "a5040c10", + "metadata": {}, + "outputs": [], + "source": [ + "const data = [{ key: \"A\", value: 4}, {key: \"B\", value:8}, {key:\"C\", value: 2}, {key: \"D\", value: 7}, {key:\"E\", value: 4}];" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "45f822af", + "metadata": {}, + "outputs": [], + "source": [ + "data" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "d918135f", + "metadata": {}, + "outputs": [], + "source": [ + "const vlSpec = vl.markBar()\n", + " .encode(\n", + " vl.x().fieldO(\"key\"),\n", + " vl.y().fieldQ(\"value\")\n", + " )\n", + " .height(200)\n", + " .data(data)\n", + " .toObject();" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "5ad0d21b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{\n", + " mark: { type: \u001b[32m\"bar\"\u001b[39m },\n", + " encoding: {\n", + " x: { field: \u001b[32m\"key\"\u001b[39m, type: \u001b[32m\"ordinal\"\u001b[39m },\n", + " y: { field: \u001b[32m\"value\"\u001b[39m, type: \u001b[32m\"quantitative\"\u001b[39m }\n", + " },\n", + " height: \u001b[33m200\u001b[39m,\n", + " data: {\n", + " values: [\n", + " { key: \u001b[32m\"A\"\u001b[39m, value: \u001b[33m4\u001b[39m },\n", + " { key: \u001b[32m\"B\"\u001b[39m, value: \u001b[33m8\u001b[39m },\n", + " { key: \u001b[32m\"C\"\u001b[39m, value: \u001b[33m2\u001b[39m },\n", + " { key: \u001b[32m\"D\"\u001b[39m, value: \u001b[33m7\u001b[39m },\n", + " { key: \u001b[32m\"E\"\u001b[39m, value: \u001b[33m4\u001b[39m }\n", + " ]\n", + " }\n", + "}" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "vlSpec" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "80da0dcd", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.vegalite.v3+json": { + "data": { + "values": [ + { + "key": "A", + "value": 4 + }, + { + "key": "B", + "value": 8 + }, + { + "key": "C", + "value": 2 + }, + { + "key": "D", + "value": 7 + }, + { + "key": "E", + "value": 4 + } + ] + }, + "encoding": { + "x": { + "field": "key", + "type": "ordinal" + }, + "y": { + "field": "value", + "type": "quantitative" + } + }, + "height": 200, + "mark": { + "type": "bar" + } + } + }, + "metadata": { + "application/vnd.vegalite.v3+json": {} + }, + "output_type": "display_data" + } + ], + "source": [ + "Deno.jupyter.displayVegaLite(vlSpec)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "c6e1c8b9", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "" + ] + }, + "metadata": { + "text/html": {} + }, + "output_type": "display_data" + } + ], + "source": [ + "Deno.jupyter.displayHtml('');" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2c4a440c", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { "kernelspec": { - "display_name": "Deno (Rust)", + "display_name": "Deno", "language": "typescript", - "name": "rusty_deno" + "name": "deno" }, "language_info": { "file_extension": ".ts", From 341ea46d2c85bd9a9fb47b1ff03fbd00432bd302 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Sat, 29 Jan 2022 14:18:02 +0100 Subject: [PATCH 070/115] fix after merge --- cli/flags.rs | 5 +++-- cli/tools/jupyter/mod.rs | 14 +++++++------- runtime/js/40_jupyter.js | 2 +- 3 files changed, 11 insertions(+), 10 deletions(-) diff --git a/cli/flags.rs b/cli/flags.rs index 4043bb9e2499ac..93a0954447e2ad 100644 --- a/cli/flags.rs +++ b/cli/flags.rs @@ -1052,11 +1052,11 @@ These must be added to the path manually if required.") fn jupyter_subcommand<'a>() -> App<'a> { App::new("jupyter") .arg( - Arg::with_name("install") + Arg::new("install") .long("install") ) .arg( - Arg::with_name("conn") + Arg::new("conn") .long("conn") .help("Path to JSON file describing connection parameters, provided by Jupyter") .takes_value(true) @@ -4727,6 +4727,7 @@ mod tests { r.unwrap_err(); } + #[test] fn test_config_path_args() { let flags = flags_from_vec(svec!["deno", "run", "foo.js"]).unwrap(); assert_eq!( diff --git a/cli/tools/jupyter/mod.rs b/cli/tools/jupyter/mod.rs index b8ef9d0265e9ed..7aab0e7c04a9d5 100644 --- a/cli/tools/jupyter/mod.rs +++ b/cli/tools/jupyter/mod.rs @@ -505,24 +505,24 @@ impl Kernel { .evaluate_line_with_object_wrapping(&exec_request_content.code) .await?; - let result = if output.value["exceptionDetails"].is_object() { - let stack_trace: Vec = output.value["exceptionDetails"] - ["exception"]["description"] - .as_str() + let result = if let Some(exception_details) = output.value.exception_details + { + let exception = exception_details.exception.unwrap(); + let stack_trace: Vec = exception + .description .unwrap() .split('\n') .map(|s| s.to_string()) .collect(); ExecResult::Error(ExecError { // TODO(apowers313) this could probably use smarter unwrapping -- for example, someone may throw non-object - err_name: output.value["exceptionDetails"]["exception"]["className"] - .to_string(), + err_name: exception.class_name.unwrap(), err_value: stack_trace.first().unwrap().to_string(), // output.value["exceptionDetails"]["stackTrace"]["callFrames"] stack_trace, }) } else { - ExecResult::Ok(output.value["result"].clone()) + ExecResult::Ok(output.value.result.value.unwrap()) }; match result { diff --git a/runtime/js/40_jupyter.js b/runtime/js/40_jupyter.js index 3af467dfc2eb0c..97ef073ab98a41 100644 --- a/runtime/js/40_jupyter.js +++ b/runtime/js/40_jupyter.js @@ -5,7 +5,7 @@ const core = window.__bootstrap.core; const { TypeError, - JSONStringify + JSONStringify, } = window.__bootstrap.primordials; const jupyter = {}; From e43aab2e2e20231ca567fb8bcf2cfb21774af58d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Mon, 31 Jan 2022 14:01:05 +0100 Subject: [PATCH 071/115] Revert "fix after merge" This reverts commit 341ea46d2c85bd9a9fb47b1ff03fbd00432bd302. --- cli/flags.rs | 5 ++--- cli/tools/jupyter/mod.rs | 14 +++++++------- runtime/js/40_jupyter.js | 2 +- 3 files changed, 10 insertions(+), 11 deletions(-) diff --git a/cli/flags.rs b/cli/flags.rs index 93a0954447e2ad..4043bb9e2499ac 100644 --- a/cli/flags.rs +++ b/cli/flags.rs @@ -1052,11 +1052,11 @@ These must be added to the path manually if required.") fn jupyter_subcommand<'a>() -> App<'a> { App::new("jupyter") .arg( - Arg::new("install") + Arg::with_name("install") .long("install") ) .arg( - Arg::new("conn") + Arg::with_name("conn") .long("conn") .help("Path to JSON file describing connection parameters, provided by Jupyter") .takes_value(true) @@ -4727,7 +4727,6 @@ mod tests { r.unwrap_err(); } - #[test] fn test_config_path_args() { let flags = flags_from_vec(svec!["deno", "run", "foo.js"]).unwrap(); assert_eq!( diff --git a/cli/tools/jupyter/mod.rs b/cli/tools/jupyter/mod.rs index 7aab0e7c04a9d5..b8ef9d0265e9ed 100644 --- a/cli/tools/jupyter/mod.rs +++ b/cli/tools/jupyter/mod.rs @@ -505,24 +505,24 @@ impl Kernel { .evaluate_line_with_object_wrapping(&exec_request_content.code) .await?; - let result = if let Some(exception_details) = output.value.exception_details - { - let exception = exception_details.exception.unwrap(); - let stack_trace: Vec = exception - .description + let result = if output.value["exceptionDetails"].is_object() { + let stack_trace: Vec = output.value["exceptionDetails"] + ["exception"]["description"] + .as_str() .unwrap() .split('\n') .map(|s| s.to_string()) .collect(); ExecResult::Error(ExecError { // TODO(apowers313) this could probably use smarter unwrapping -- for example, someone may throw non-object - err_name: exception.class_name.unwrap(), + err_name: output.value["exceptionDetails"]["exception"]["className"] + .to_string(), err_value: stack_trace.first().unwrap().to_string(), // output.value["exceptionDetails"]["stackTrace"]["callFrames"] stack_trace, }) } else { - ExecResult::Ok(output.value.result.value.unwrap()) + ExecResult::Ok(output.value["result"].clone()) }; match result { diff --git a/runtime/js/40_jupyter.js b/runtime/js/40_jupyter.js index 97ef073ab98a41..3af467dfc2eb0c 100644 --- a/runtime/js/40_jupyter.js +++ b/runtime/js/40_jupyter.js @@ -5,7 +5,7 @@ const core = window.__bootstrap.core; const { TypeError, - JSONStringify, + JSONStringify } = window.__bootstrap.primordials; const jupyter = {}; From fbd7a9e726658128c7756080734b8df73b86aa2c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Mon, 31 Jan 2022 14:03:21 +0100 Subject: [PATCH 072/115] fix after revert --- cli/flags.rs | 5 +++-- runtime/js/40_jupyter.js | 2 +- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/cli/flags.rs b/cli/flags.rs index 4043bb9e2499ac..93a0954447e2ad 100644 --- a/cli/flags.rs +++ b/cli/flags.rs @@ -1052,11 +1052,11 @@ These must be added to the path manually if required.") fn jupyter_subcommand<'a>() -> App<'a> { App::new("jupyter") .arg( - Arg::with_name("install") + Arg::new("install") .long("install") ) .arg( - Arg::with_name("conn") + Arg::new("conn") .long("conn") .help("Path to JSON file describing connection parameters, provided by Jupyter") .takes_value(true) @@ -4727,6 +4727,7 @@ mod tests { r.unwrap_err(); } + #[test] fn test_config_path_args() { let flags = flags_from_vec(svec!["deno", "run", "foo.js"]).unwrap(); assert_eq!( diff --git a/runtime/js/40_jupyter.js b/runtime/js/40_jupyter.js index 3af467dfc2eb0c..97ef073ab98a41 100644 --- a/runtime/js/40_jupyter.js +++ b/runtime/js/40_jupyter.js @@ -5,7 +5,7 @@ const core = window.__bootstrap.core; const { TypeError, - JSONStringify + JSONStringify, } = window.__bootstrap.primordials; const jupyter = {}; From 48dfe9d31e56ea8fb9a3cab03e1afb1753b2bbd7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Mon, 27 Jun 2022 01:28:40 +0200 Subject: [PATCH 073/115] fix after merge --- cli/tools/jupyter/mod.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/cli/tools/jupyter/mod.rs b/cli/tools/jupyter/mod.rs index 14e5d5342139c4..b27ca08b5dc7fa 100644 --- a/cli/tools/jupyter/mod.rs +++ b/cli/tools/jupyter/mod.rs @@ -232,6 +232,7 @@ impl Kernel { main_module.clone(), permissions, vec![jupyter_extension(stdio_tx)], + Default::default(), ); let repl_session = ReplSession::initialize(worker).await?; From f528f581acc9e9efecbd437a58dace6c3c4595ee Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Thu, 31 Aug 2023 14:53:18 +0200 Subject: [PATCH 074/115] some fixes after merge --- cli/args/flags.rs | 18 ++++++------------ cli/main.rs | 2 +- cli/tools/jupyter/mod.rs | 4 ++-- 3 files changed, 9 insertions(+), 15 deletions(-) diff --git a/cli/args/flags.rs b/cli/args/flags.rs index ab33042bc8a25c..c3c28887694d9a 100644 --- a/cli/args/flags.rs +++ b/cli/args/flags.rs @@ -158,7 +158,7 @@ pub struct InstallFlags { pub force: bool, } -#[derive(Clone, Debug, PartialEq, Deserialize, Serialize)] +#[derive(Clone, Debug, Eq, PartialEq)] pub struct JupyterFlags { pub install: bool, pub conn_file: Option, @@ -1621,7 +1621,7 @@ These must be added to the path manually if required.") ) } -fn jupyter_subcommand<'a>() -> Command<'a> { +fn jupyter_subcommand() -> Command { Command::new("jupyter") .arg( Arg::new("install") @@ -1631,8 +1631,8 @@ fn jupyter_subcommand<'a>() -> Command<'a> { Arg::new("conn") .long("conn") .help("Path to JSON file describing connection parameters, provided by Jupyter") - .takes_value(true) - .required(false) + .value_parser(value_parser!(PathBuf)) + .value_hint(ValueHint::FilePath) .conflicts_with("install")) .about("Jupyter kernel") } @@ -3191,14 +3191,8 @@ fn install_parse(flags: &mut Flags, matches: &mut ArgMatches) { } fn jupyter_parse(flags: &mut Flags, matches: &mut ArgMatches) { - let conn_file = if matches.is_present("conn") { - let conn_file = matches.value_of("conn").unwrap(); - Some(PathBuf::from(conn_file)) - } else { - None - }; - - let install = matches.is_present("install"); + let conn_file = matches.remove_one::("conn"); + let install = matches.get_flag("install"); flags.subcommand = DenoSubcommand::Jupyter(JupyterFlags { install, conn_file }); diff --git a/cli/main.rs b/cli/main.rs index 0b41be73c66b77..2b58d3464bccc3 100644 --- a/cli/main.rs +++ b/cli/main.rs @@ -137,7 +137,7 @@ async fn run_subcommand(flags: Flags) -> Result { DenoSubcommand::Jupyter(jupyter_flags) => spawn_subcommand(async { if jupyter_flags.install { tools::jupyter::install()?; - return Ok(); + return Ok(()); } tools::jupyter::kernel(flags, jupyter_flags).await diff --git a/cli/tools/jupyter/mod.rs b/cli/tools/jupyter/mod.rs index b27ca08b5dc7fa..55a22fbd8ff117 100644 --- a/cli/tools/jupyter/mod.rs +++ b/cli/tools/jupyter/mod.rs @@ -3,9 +3,9 @@ // TODO(bartlomieju): remove me #![allow(unused)] +use crate::args::Flags; +use crate::args::JupyterFlags; use crate::create_main_worker; -use crate::flags::Flags; -use crate::flags::JupyterFlags; use crate::logger; use crate::proc_state::ProcState; use crate::tools::repl::EvaluationOutput; From 2a713530a149dfec32779e6cf6785864cf53722d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Thu, 31 Aug 2023 15:46:26 +0200 Subject: [PATCH 075/115] fully rebased --- Cargo.lock | 1 + Cargo.toml | 1 + cli/Cargo.toml | 1 + cli/args/flags.rs | 4 +- cli/tools/jupyter/install.rs | 2 +- cli/tools/jupyter/mod.rs | 90 +++++++++++++++++++++--------------- cli/tools/repl/session.rs | 6 +-- ext/node/Cargo.toml | 2 +- 8 files changed, 64 insertions(+), 43 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 96fabf58fe8795..9a258f71adc875 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -985,6 +985,7 @@ dependencies = [ "clap_complete", "clap_complete_fig", "console_static_text", + "data-encoding", "data-url 0.3.0", "deno_ast", "deno_bench_util", diff --git a/Cargo.toml b/Cargo.toml index 0de04bbcfc84a4..9c4ab19cd5fa56 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -85,6 +85,7 @@ cbc = { version = "=0.1.2", features = ["alloc"] } chrono = { version = "=0.4.26", default-features = false, features = ["std", "serde", "clock"] } console_static_text = "=0.8.1" data-url = "=0.3.0" +data-encoding = "2.3.3" dlopen = "0.1.8" encoding_rs = "=0.8.33" ecb = "=0.1.2" diff --git a/cli/Cargo.toml b/cli/Cargo.toml index 0748d97e54f5ad..88c5dd2bd627c0 100644 --- a/cli/Cargo.toml +++ b/cli/Cargo.toml @@ -71,6 +71,7 @@ clap = { version = "=4.3.3", features = ["string"] } clap_complete = "=4.3.1" clap_complete_fig = "=4.3.1" console_static_text.workspace = true +data-encoding.workspace = true data-url.workspace = true dissimilar = "=1.0.4" dprint-plugin-json = "=0.17.4" diff --git a/cli/args/flags.rs b/cli/args/flags.rs index c3c28887694d9a..1334fa5f7f2b03 100644 --- a/cli/args/flags.rs +++ b/cli/args/flags.rs @@ -685,7 +685,8 @@ impl Flags { std::env::current_dir().ok() } Bundle(_) | Completions(_) | Doc(_) | Fmt(_) | Init(_) | Install(_) - | Uninstall(_) | Lsp | Lint(_) | Types | Upgrade(_) | Vendor(_) => None, + | Uninstall(_) | Jupyter(_) | Lsp | Lint(_) | Types | Upgrade(_) + | Vendor(_) => None, } } @@ -1626,6 +1627,7 @@ fn jupyter_subcommand() -> Command { .arg( Arg::new("install") .long("install") + .action(ArgAction::SetTrue) ) .arg( Arg::new("conn") diff --git a/cli/tools/jupyter/install.rs b/cli/tools/jupyter/install.rs index 2f72ed80093d43..9c29784d680b43 100644 --- a/cli/tools/jupyter/install.rs +++ b/cli/tools/jupyter/install.rs @@ -3,8 +3,8 @@ use deno_core::error::AnyError; use deno_core::serde_json; use deno_core::serde_json::json; -use secure_tempfile::TempDir; use std::env::current_exe; +use tempfile::TempDir; pub fn install() -> Result<(), AnyError> { let temp_dir = TempDir::new().unwrap(); diff --git a/cli/tools/jupyter/mod.rs b/cli/tools/jupyter/mod.rs index 55a22fbd8ff117..87e13621d7d110 100644 --- a/cli/tools/jupyter/mod.rs +++ b/cli/tools/jupyter/mod.rs @@ -5,11 +5,10 @@ use crate::args::Flags; use crate::args::JupyterFlags; -use crate::create_main_worker; -use crate::logger; -use crate::proc_state::ProcState; use crate::tools::repl::EvaluationOutput; use crate::tools::repl::ReplSession; +use crate::util::logger; +use crate::CliFactory; use base64; use data_encoding::HEXLOWER; use deno_core::anyhow::anyhow; @@ -29,17 +28,19 @@ use deno_core::serde_json; use deno_core::serde_json::json; use deno_core::serde_json::Value; use deno_core::Extension; +use deno_core::JsBuffer; use deno_core::JsRuntime; +use deno_core::Op; use deno_core::OpState; -use deno_core::ZeroCopyBuf; use deno_runtime::permissions::Permissions; +use deno_runtime::permissions::PermissionsContainer; use deno_runtime::worker::MainWorker; use ring::hmac; -use secure_tempfile::TempDir; use std::collections::HashMap; use std::env::current_exe; use std::sync::Arc; use std::time::Duration; +use tempfile::TempDir; use tokio::join; use tokio::time::sleep; use zeromq::prelude::*; @@ -110,28 +111,30 @@ enum HandlerType { Stdin, } -type WorkerCommSender = UnboundedSender; -type WorkerCommReceiver = UnboundedReceiver; +pub type WorkerCommSender = UnboundedSender; +pub type WorkerCommReceiver = UnboundedReceiver; -enum WorkerCommMsg { +pub enum WorkerCommMsg { Stderr(String), Stdout(String), - Display(String, ZeroCopyBuf, Option, Option), + Display(String, JsBuffer, Option, Option), } -fn jupyter_extension(sender: WorkerCommSender) -> Extension { - Extension::builder() - .ops(vec![op_jupyter_display::decl()]) - .middleware(|op| match op.name { - "op_print" => op_print::decl(), - _ => op, - }) - .state(move |state| { - state.put(sender.clone()); - Ok(()) - }) - .build() -} +deno_core::extension!(deno_jupyter, + ops = [ + op_jupyter_display + ], + options = { + sender: WorkerCommSender, + }, + middleware = |op| match op.name { + "op_print" => op_print::DECL, + _ => op, + }, + state = |state, options| { + state.put(options.sender); + }, +); #[derive(Deserialize, Debug)] #[serde(rename_all = "camelCase")] @@ -145,7 +148,7 @@ pub struct DisplayArgs { pub fn op_jupyter_display( state: &mut OpState, args: DisplayArgs, - data: Option, + data: Option, ) -> Result<(), AnyError> { let d = match data { Some(x) => x, @@ -223,19 +226,32 @@ impl Kernel { HbComm::new(create_conn_str(&spec.transport, &spec.ip, spec.hb_port)); let (stdio_tx, stdio_rx) = mpsc::unbounded(); - let main_module = resolve_url_or_path("./$deno$jupyter.ts").unwrap(); - // TODO(bartlomieju): should we run with all permissions? - let permissions = Permissions::allow_all(); - let ps = ProcState::build(Arc::new(flags.clone())).await?; - let mut worker = create_main_worker( - &ps, - main_module.clone(), - permissions, - vec![jupyter_extension(stdio_tx)], - Default::default(), - ); - let repl_session = ReplSession::initialize(worker).await?; + let factory = CliFactory::from_flags(flags).await?; + let cli_options = factory.cli_options(); + let main_module = + resolve_url_or_path("./$deno$jupyter.ts", cli_options.initial_cwd()) + .unwrap(); + // TODO(bartlomieju): should we run with all permissions? + let permissions = PermissionsContainer::new(Permissions::allow_all()); + let npm_resolver = factory.npm_resolver().await?.clone(); + let resolver = factory.resolver().await?.clone(); + let file_fetcher = factory.file_fetcher()?; + let worker_factory = factory.create_cli_main_worker_factory().await?; + + let mut worker = worker_factory + .create_custom_worker( + main_module.clone(), + permissions, + vec![deno_jupyter::init_ops(stdio_tx)], + Default::default(), + ) + .await?; + worker.setup_repl().await?; + let worker = worker.into_main_worker(); + let repl_session = + ReplSession::initialize(cli_options, npm_resolver, resolver, worker) + .await?; let kernel = Self { metadata, @@ -901,7 +917,7 @@ impl MimeSet { fn add_buf( &mut self, mime_type: &str, - buf: ZeroCopyBuf, + buf: JsBuffer, format: Option, ) -> Result<(), AnyError> { let fmt_str = match format { @@ -968,7 +984,7 @@ impl Default for KernelMetadata { help_text: "".to_string(), help_url: "https://github.com/denoland/deno".to_string(), implementation_name: "Deno kernel".to_string(), - kernel_version: crate::version::deno(), + kernel_version: crate::version::deno().to_string(), language_version: crate::version::TYPESCRIPT.to_string(), language: "typescript".to_string(), mime: "text/x.typescript".to_string(), diff --git a/cli/tools/repl/session.rs b/cli/tools/repl/session.rs index adb2fbee3c4ea4..ac58af71ccbfd4 100644 --- a/cli/tools/repl/session.rs +++ b/cli/tools/repl/session.rs @@ -116,9 +116,9 @@ pub fn result_to_evaluation_output( } } -struct TsEvaluateResponse { - ts_code: String, - value: cdp::EvaluateResponse, +pub struct TsEvaluateResponse { + pub ts_code: String, + pub value: cdp::EvaluateResponse, } pub struct ReplSession { diff --git a/ext/node/Cargo.toml b/ext/node/Cargo.toml index 2e8b26a7a1f3b5..ed3904a91baa96 100644 --- a/ext/node/Cargo.toml +++ b/ext/node/Cargo.toml @@ -17,7 +17,7 @@ path = "lib.rs" aes.workspace = true brotli.workspace = true cbc.workspace = true -data-encoding = "2.3.3" +data-encoding.workspace = true deno_core.workspace = true deno_fetch.workspace = true deno_fs.workspace = true From 24c17d6c03a55375c7252c2b84d555767f529a5a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Thu, 31 Aug 2023 18:03:59 +0200 Subject: [PATCH 076/115] lint --- cli/tools/jupyter/mod.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cli/tools/jupyter/mod.rs b/cli/tools/jupyter/mod.rs index 87e13621d7d110..fd6a5695a6ce4e 100644 --- a/cli/tools/jupyter/mod.rs +++ b/cli/tools/jupyter/mod.rs @@ -927,7 +927,7 @@ impl MimeSet { let json_data = match fmt_str.as_ref() { "string" => json!(String::from_utf8(buf.to_vec())?), - "json" => serde_json::from_str(std::str::from_utf8(&buf.to_vec())?)?, + "json" => serde_json::from_str(std::str::from_utf8(&buf)?)?, "base64" | "default" => json!(base64::encode(buf)), _ => return Err(anyhow!("unknown display mime format: {}", fmt_str)), }; From a7b9e565da3e9c1a53595317391f96fb5a0a96bc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Thu, 31 Aug 2023 18:24:50 +0200 Subject: [PATCH 077/115] fix installation --- cli/tools/jupyter/install.rs | 1 + runtime/js/40_jupyter.js | 200 +++++++++++++++++------------------ runtime/js/90_deno_ns.js | 2 + runtime/shared.rs | 1 + 4 files changed, 104 insertions(+), 100 deletions(-) diff --git a/cli/tools/jupyter/install.rs b/cli/tools/jupyter/install.rs index 9c29784d680b43..1af8be23b71c42 100644 --- a/cli/tools/jupyter/install.rs +++ b/cli/tools/jupyter/install.rs @@ -26,6 +26,7 @@ pub fn install() -> Result<(), AnyError> { .args([ "kernelspec", "install", + "--user", "--name", "deno", &temp_dir.path().to_string_lossy(), diff --git a/runtime/js/40_jupyter.js b/runtime/js/40_jupyter.js index 97ef073ab98a41..2361e6d337cff3 100644 --- a/runtime/js/40_jupyter.js +++ b/runtime/js/40_jupyter.js @@ -1,118 +1,118 @@ // Copyright 2018-2021 the Deno authors. All rights reserved. MIT license. "use strict"; -((window) => { - const core = window.__bootstrap.core; - const { - TypeError, - JSONStringify, - } = window.__bootstrap.primordials; - const jupyter = {}; +const core = globalThis.Deno.core; +const ops = core.ops; +const primordials = globalThis.__bootstrap.primordials; +const { + TypeError, + JSONStringify, +} = primordials; - function display(mimeType, buf, opt = {}) { - // for known mime types, do the nice thing and select the known dataFormat - let dataFormat = "base64"; - switch (mimeType) { - case "text/plain": - case "text/html": - dataFormat = "string"; - } - - const args = { - mimeType, - dataFormat: opt.dataFormat ?? dataFormat, - metadata: opt.metadata, - }; - - core.opSync("op_jupyter_display", args, buf); +function display(mimeType, buf, opt = {}) { + // for known mime types, do the nice thing and select the known dataFormat + let dataFormat = "base64"; + switch (mimeType) { + case "text/plain": + case "text/html": + dataFormat = "string"; } - function displayPng(buf, opt = {}) { - display("image/png", buf, { - metadata: { - width: opt.width, - height: opt.height, - }, - }); - } + const args = { + mimeType, + dataFormat: opt.dataFormat ?? dataFormat, + metadata: opt.metadata, + }; - async function displayPngFile(path, opt = {}) { - const buf = await Deno.readFile(path); - displayPng(buf, opt); - } + ops.op_jupyter_display(args, buf); +} - function displayHtml(str) { - display("text/html", new TextEncoder().encode(str), { - dataFormat: "string", - }); - } +function displayPng(buf, opt = {}) { + display("image/png", buf, { + metadata: { + width: opt.width, + height: opt.height, + }, + }); +} - async function displayHtmlFile(path) { - const buf = await Deno.readFile(path); - display("text/html", buf, { - dataFormat: "string", - }); - } +async function displayPngFile(path, opt = {}) { + const buf = await Deno.readFile(path); + displayPng(buf, opt); +} - function displayVegaLite(spec) { - if (typeof spec === "object") { - spec = JSONStringify(spec); - } +function displayHtml(str) { + display("text/html", new TextEncoder().encode(str), { + dataFormat: "string", + }); +} - display( - "application/vnd.vegalite.v3+json", - new TextEncoder().encode(spec), - { dataFormat: "json" }, - ); - } +async function displayHtmlFile(path) { + const buf = await Deno.readFile(path); + display("text/html", buf, { + dataFormat: "string", + }); +} - async function displayVegaLiteFile(path) { - const buf = await Deno.readFile(path); - display("application/vnd.vegalite.v3+json", buf, { dataFormat: "json" }); +function displayVegaLite(spec) { + if (typeof spec === "object") { + spec = JSONStringify(spec); } - // from: https://jupyterlab.readthedocs.io/en/stable/user/file_formats.html - // application/json - // text/markdown - // image/bmp - // image/gif - // image/jpeg - // image/svg+xml - // text/html - // text/latex - // application/pdf - // application/vnd.vega.v5+json - // application/vdom.v1+json + display( + "application/vnd.vegalite.v3+json", + new TextEncoder().encode(spec), + { dataFormat: "json" }, + ); +} + +async function displayVegaLiteFile(path) { + const buf = await Deno.readFile(path); + display("application/vnd.vegalite.v3+json", buf, { dataFormat: "json" }); +} - function displayFile(path, opt = {}) { - let fileType; - if (opt.hint) { - fileType = opt.hint; - } else { - const pathParts = path.split("."); - fileType = pathParts[pathParts.length - 1]; - } - fileType = fileType.toLowerCase(); +// from: https://jupyterlab.readthedocs.io/en/stable/user/file_formats.html +// application/json +// text/markdown +// image/bmp +// image/gif +// image/jpeg +// image/svg+xml +// text/html +// text/latex +// application/pdf +// application/vnd.vega.v5+json +// application/vdom.v1+json + +function displayFile(path, opt = {}) { + let fileType; + if (opt.hint) { + fileType = opt.hint; + } else { + const pathParts = path.split("."); + fileType = pathParts[pathParts.length - 1]; + } + fileType = fileType.toLowerCase(); - switch (fileType) { - case "png": - return displayPngFile(path, opt); - case "html": - return displayHtmlFile(path); - case "vl": - return displayVegaLiteFile(path); - default: - throw new TypeError(`unknown file type: ${fileType}`); - } + switch (fileType) { + case "png": + return displayPngFile(path, opt); + case "html": + return displayHtmlFile(path); + case "vl": + return displayVegaLiteFile(path); + default: + throw new TypeError(`unknown file type: ${fileType}`); } +} - jupyter.display = display; - jupyter.displayPng = displayPng; - jupyter.displayPngFile = displayPngFile; - jupyter.displayHtml = displayHtml; - jupyter.displayHtmlFile = displayHtmlFile; - jupyter.displayVegaLite = displayVegaLite; - jupyter.displayVegaLiteFile = displayVegaLiteFile; - jupyter.displayFile = displayFile; - window.__bootstrap.jupyter = jupyter; -})(this); +export { + display, + displayFile, + displayHtml, + displayHtmlFile, + displayPng, + displayPngFile, + displayVegaLite, + displayVegaLiteFile, +}; diff --git a/runtime/js/90_deno_ns.js b/runtime/js/90_deno_ns.js index 00c6d6b475a682..1de47569fccabd 100644 --- a/runtime/js/90_deno_ns.js +++ b/runtime/js/90_deno_ns.js @@ -23,6 +23,7 @@ import * as tty from "ext:runtime/40_tty.js"; // TODO(bartlomieju): this is funky we have two `http` imports import * as httpRuntime from "ext:runtime/40_http.js"; import * as kv from "ext:deno_kv/01_db.ts"; +import * as jupyter from "ext:runtime/40_jupyter.js"; const denoNs = { metrics: core.metrics, @@ -178,6 +179,7 @@ const denoNsUnstable = { Kv: kv.Kv, KvU64: kv.KvU64, KvListIterator: kv.KvListIterator, + jupyter, }; export { denoNs, denoNsUnstable }; diff --git a/runtime/shared.rs b/runtime/shared.rs index e7ba109b09ce12..26545dc686d061 100644 --- a/runtime/shared.rs +++ b/runtime/shared.rs @@ -47,6 +47,7 @@ extension!(runtime, "40_process.js", "40_signals.js", "40_tty.js", + "40_jupyter.js", "41_prompt.js", "90_deno_ns.js", "98_global_scope.js" From cec05189b3c4d99635065d116a76a2d1a63d2994 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Thu, 31 Aug 2023 18:54:33 +0200 Subject: [PATCH 078/115] fix output --- cli/tools/jupyter/mod.rs | 13 +++++++++++-- cli/tools/repl/session.rs | 1 + 2 files changed, 12 insertions(+), 2 deletions(-) diff --git a/cli/tools/jupyter/mod.rs b/cli/tools/jupyter/mod.rs index fd6a5695a6ce4e..487c5d74625c0a 100644 --- a/cli/tools/jupyter/mod.rs +++ b/cli/tools/jupyter/mod.rs @@ -552,8 +552,17 @@ impl Kernel { }) } else { // TODO(bartlomieju): fix this - // ExecResult::Ok(output.value.result.clone()) - ExecResult::Ok(output.value.result.value.as_ref().unwrap().clone()) + eprintln!("output {:#?}", output); + + // TODO(bartlomieju): handle exception + let output = self + .repl_session + .get_eval_value(&output.value.result) + .await?; + + eprintln!("output serialized {:#?}", output); + + ExecResult::Ok(Value::String(output)) }; match result { diff --git a/cli/tools/repl/session.rs b/cli/tools/repl/session.rs index ac58af71ccbfd4..5336590f47dedd 100644 --- a/cli/tools/repl/session.rs +++ b/cli/tools/repl/session.rs @@ -116,6 +116,7 @@ pub fn result_to_evaluation_output( } } +#[derive(Debug)] pub struct TsEvaluateResponse { pub ts_code: String, pub value: cdp::EvaluateResponse, From 6a2b87769dfb37fb8d7ae2dcc42e94b5c4b31555 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Fri, 1 Sep 2023 10:36:53 +0200 Subject: [PATCH 079/115] some cleanup --- cli/tools/jupyter/comm.rs | 10 ++++-- cli/tools/jupyter/install.rs | 7 ++-- cli/tools/jupyter/message_types.rs | 8 +++-- cli/tools/jupyter/mod.rs | 55 ++++++++++++------------------ 4 files changed, 38 insertions(+), 42 deletions(-) diff --git a/cli/tools/jupyter/comm.rs b/cli/tools/jupyter/comm.rs index 8d7a1f7c02d298..c823ee48090df5 100644 --- a/cli/tools/jupyter/comm.rs +++ b/cli/tools/jupyter/comm.rs @@ -13,9 +13,12 @@ use super::SideEffectMessage; pub struct PubComm { conn_str: String, - identity: String, hmac_key: hmac::Key, socket: zeromq::PubSocket, + + // TODO(bartlomieju): + #[allow(unused)] + identity: String, } // TODO(apowers313) connect and send look like traits shared with DealerComm @@ -52,9 +55,12 @@ impl PubComm { pub struct DealerComm { name: String, conn_str: String, - identity: String, hmac_key: hmac::Key, socket: zeromq::DealerSocket, + + // TODO(bartlomieju): + #[allow(unused)] + identity: String, } impl DealerComm { diff --git a/cli/tools/jupyter/install.rs b/cli/tools/jupyter/install.rs index 1af8be23b71c42..759cada2a38979 100644 --- a/cli/tools/jupyter/install.rs +++ b/cli/tools/jupyter/install.rs @@ -1,5 +1,6 @@ // Copyright 2018-2021 the Deno authors. All rights reserved. MIT license. +use deno_core::anyhow::bail; use deno_core::error::AnyError; use deno_core::serde_json; use deno_core::serde_json::json; @@ -12,7 +13,7 @@ pub fn install() -> Result<(), AnyError> { // TODO(bartlomieju): add remaining fields as per // https://jupyter-client.readthedocs.io/en/stable/kernels.html#kernel-specs - // FIXME(bartlomieju): replace `current_exe` + // FIXME(bartlomieju): replace `current_exe` before landing? let json_data = json!({ "argv": [current_exe().unwrap().to_string_lossy(), "--unstable", "jupyter", "--conn", "{connection_file}"], "display_name": "Deno", @@ -40,11 +41,11 @@ pub fn install() -> Result<(), AnyError> { match wait_result { Ok(status) => { if !status.success() { - eprintln!("Failed to install kernelspec, try again."); + bail!("Failed to install kernelspec, try again."); } } Err(err) => { - eprintln!("Failed to install kernelspec: {}", err); + bail!("Failed to install kernelspec: {}", err); } } } diff --git a/cli/tools/jupyter/message_types.rs b/cli/tools/jupyter/message_types.rs index cfcab9e7821b7b..8bb798d638116c 100644 --- a/cli/tools/jupyter/message_types.rs +++ b/cli/tools/jupyter/message_types.rs @@ -1,5 +1,8 @@ // Copyright 2018-2021 the Deno authors. All rights reserved. MIT license. +// TODO(bartlomieju): remove this lint supression +#![allow(dead_code)] + use data_encoding::HEXLOWER; use deno_core::error::AnyError; use deno_core::serde::Deserialize; @@ -8,7 +11,6 @@ use deno_core::serde_json; use deno_core::serde_json::json; use deno_core::serde_json::Value; use ring::hmac; -use zeromq::prelude::*; use zeromq::ZmqMessage; const DELIMITER: &str = ""; @@ -42,7 +44,7 @@ impl TryFrom for RequestMessage { fn try_from(zmq_msg: ZmqMessage) -> Result { // TODO(apowers313) make all unwraps recoverable errors let header_bytes = zmq_msg.get(2).unwrap(); - let metadata_bytes = zmq_msg.get(4).unwrap(); + let _metadata_bytes = zmq_msg.get(4).unwrap(); let content_bytes = zmq_msg.get(5).unwrap(); let header: MessageHeader = serde_json::from_slice(header_bytes).unwrap(); @@ -95,7 +97,7 @@ impl ReplyMessage { // TODO(apowers313) convert unwrap() to recoverable error let header = serde_json::to_string(&self.header).unwrap(); let parent_header = serde_json::to_string(&self.parent_header).unwrap(); - let metadata = serde_json::to_string(&self.metadata).unwrap(); + let _metadata = serde_json::to_string(&self.metadata).unwrap(); let metadata = match &self.metadata { ReplyMetadata::Empty => serde_json::to_string(&json!({})).unwrap(), }; diff --git a/cli/tools/jupyter/mod.rs b/cli/tools/jupyter/mod.rs index 487c5d74625c0a..ff8b712ff52cb4 100644 --- a/cli/tools/jupyter/mod.rs +++ b/cli/tools/jupyter/mod.rs @@ -1,16 +1,11 @@ // Copyright 2018-2021 the Deno authors. All rights reserved. MIT license. -// TODO(bartlomieju): remove me -#![allow(unused)] - use crate::args::Flags; use crate::args::JupyterFlags; -use crate::tools::repl::EvaluationOutput; use crate::tools::repl::ReplSession; use crate::util::logger; use crate::CliFactory; use base64; -use data_encoding::HEXLOWER; use deno_core::anyhow::anyhow; use deno_core::anyhow::Context; use deno_core::error::generic_error; @@ -18,33 +13,19 @@ use deno_core::error::AnyError; use deno_core::futures::channel::mpsc; use deno_core::futures::channel::mpsc::UnboundedReceiver; use deno_core::futures::channel::mpsc::UnboundedSender; -use deno_core::futures::SinkExt; use deno_core::futures::StreamExt; use deno_core::op; use deno_core::resolve_url_or_path; use deno_core::serde::Deserialize; -use deno_core::serde::Serialize; use deno_core::serde_json; use deno_core::serde_json::json; use deno_core::serde_json::Value; -use deno_core::Extension; use deno_core::JsBuffer; -use deno_core::JsRuntime; use deno_core::Op; use deno_core::OpState; use deno_runtime::permissions::Permissions; use deno_runtime::permissions::PermissionsContainer; -use deno_runtime::worker::MainWorker; use ring::hmac; -use std::collections::HashMap; -use std::env::current_exe; -use std::sync::Arc; -use std::time::Duration; -use tempfile::TempDir; -use tokio::join; -use tokio::time::sleep; -use zeromq::prelude::*; -use zeromq::ZmqMessage; mod comm; mod install; @@ -75,7 +56,8 @@ pub async fn kernel( println!("[DENO] kernel created: {:#?}", kernel.identity); println!("running kernel..."); - kernel.run().await; + // TODO(bartlomieju): handle the result + let _r = kernel.run().await; println!("done running kernel."); Ok(()) @@ -85,11 +67,16 @@ pub async fn kernel( enum KernelState { Busy, Idle, + + // TODO(bartlomieju): + #[allow(unused)] Starting, } struct Kernel { metadata: KernelMetadata, + // TODO(bartlomieju): + #[allow(unused)] conn_spec: ConnectionSpec, state: KernelState, iopub_comm: PubComm, @@ -155,8 +142,9 @@ pub fn op_jupyter_display( None => return Err(anyhow!("op_jupyter_display missing 'data' argument")), }; - let mut sender = state.borrow_mut::(); - sender.unbounded_send(WorkerCommMsg::Display( + let sender = state.borrow_mut::(); + // TODO(bartlomieju): should the result be handled? + let _ = sender.unbounded_send(WorkerCommMsg::Display( args.mime_type, d, args.data_format, @@ -172,12 +160,13 @@ pub fn op_print( msg: String, is_err: bool, ) -> Result<(), AnyError> { - let mut sender = state.borrow_mut::(); + let sender = state.borrow_mut::(); + // TODO(bartlomieju): should these results be handled somehow? if is_err { - let r = sender.unbounded_send(WorkerCommMsg::Stderr(msg)); + let _r = sender.unbounded_send(WorkerCommMsg::Stderr(msg)); } else { - let r = sender.unbounded_send(WorkerCommMsg::Stdout(msg)); + let _r = sender.unbounded_send(WorkerCommMsg::Stdout(msg)); } Ok(()) } @@ -236,7 +225,6 @@ impl Kernel { let permissions = PermissionsContainer::new(Permissions::allow_all()); let npm_resolver = factory.npm_resolver().await?.clone(); let resolver = factory.resolver().await?.clone(); - let file_fetcher = factory.file_fetcher()?; let worker_factory = factory.create_cli_main_worker_factory().await?; let mut worker = worker_factory @@ -306,7 +294,8 @@ impl Kernel { }, maybe_stdio_proxy_msg = self.stdio_rx.next() => { if let Some(stdio_proxy_msg) = maybe_stdio_proxy_msg { - self.worker_comm_handler(stdio_proxy_msg).await; + // TODO(bartlomieju): should the result be handled? + let _ = self.worker_comm_handler(stdio_proxy_msg).await; } }, heartbeat_result = self.hb_comm.heartbeat() => { @@ -430,11 +419,11 @@ impl Kernel { Ok(()) } - fn control_handler(&self, comm_ctx: &CommContext) -> Result<(), AnyError> { + fn control_handler(&self, _comm_ctx: &CommContext) -> Result<(), AnyError> { todo!() } - fn stdin_handler(&self, comm_ctx: &CommContext) -> Result<(), AnyError> { + fn stdin_handler(&self, _comm_ctx: &CommContext) -> Result<(), AnyError> { todo!() } @@ -462,7 +451,7 @@ impl Kernel { ); if let Err(e) = self.iopub_comm.send(msg).await { - println!("[IoPub] Error setting state: {}", s); + println!("[IoPub] Error setting state: {}, reason: {}", s, e); } } @@ -664,8 +653,7 @@ impl Kernel { ExecResult::Ok(v) => v, _ => return Err(anyhow!("send_execute_result: unreachable")), }; - let mut display_data = - self.display_data_from_result_value(v.clone()).await?; + let display_data = self.display_data_from_result_value(v.clone()).await?; if display_data.is_empty() { return Ok(()); } @@ -718,7 +706,7 @@ impl Kernel { display_data: MimeSet, metadata: MimeSet, ) -> Result<(), AnyError> { - if (display_data.is_empty()) { + if display_data.is_empty() { return Err(anyhow!("send_display_data called with empty display data")); } @@ -958,7 +946,6 @@ impl MimeSet { data } } -struct ErrorValue {} enum ExecResult { Ok(Value), From 98cf1fa1b2dad4dad73116936ec7e98ab5ddca07 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Fri, 1 Sep 2023 10:40:45 +0200 Subject: [PATCH 080/115] remove js api --- cli/tools/jupyter/mod.rs | 2 + runtime/js/40_jupyter.js | 118 --------------------------------------- runtime/js/90_deno_ns.js | 2 - runtime/shared.rs | 1 - 4 files changed, 2 insertions(+), 121 deletions(-) delete mode 100644 runtime/js/40_jupyter.js diff --git a/cli/tools/jupyter/mod.rs b/cli/tools/jupyter/mod.rs index ff8b712ff52cb4..273e58dbcf726b 100644 --- a/cli/tools/jupyter/mod.rs +++ b/cli/tools/jupyter/mod.rs @@ -104,6 +104,7 @@ pub type WorkerCommReceiver = UnboundedReceiver; pub enum WorkerCommMsg { Stderr(String), Stdout(String), + // TODO(bartlomieju): do we need it? Display(String, JsBuffer, Option, Option), } @@ -514,6 +515,7 @@ impl Kernel { .evaluate_line_with_object_wrapping(&exec_request_content.code) .await?; + // TODO(bartlomieju): clean this up - maybe deduplicate with existing code in `ReplSession`. let result = if let Some(ex_details) = &output.value.exception_details { let stack_trace: Vec = ex_details .exception diff --git a/runtime/js/40_jupyter.js b/runtime/js/40_jupyter.js deleted file mode 100644 index 2361e6d337cff3..00000000000000 --- a/runtime/js/40_jupyter.js +++ /dev/null @@ -1,118 +0,0 @@ -// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license. -"use strict"; - -const core = globalThis.Deno.core; -const ops = core.ops; -const primordials = globalThis.__bootstrap.primordials; -const { - TypeError, - JSONStringify, -} = primordials; - -function display(mimeType, buf, opt = {}) { - // for known mime types, do the nice thing and select the known dataFormat - let dataFormat = "base64"; - switch (mimeType) { - case "text/plain": - case "text/html": - dataFormat = "string"; - } - - const args = { - mimeType, - dataFormat: opt.dataFormat ?? dataFormat, - metadata: opt.metadata, - }; - - ops.op_jupyter_display(args, buf); -} - -function displayPng(buf, opt = {}) { - display("image/png", buf, { - metadata: { - width: opt.width, - height: opt.height, - }, - }); -} - -async function displayPngFile(path, opt = {}) { - const buf = await Deno.readFile(path); - displayPng(buf, opt); -} - -function displayHtml(str) { - display("text/html", new TextEncoder().encode(str), { - dataFormat: "string", - }); -} - -async function displayHtmlFile(path) { - const buf = await Deno.readFile(path); - display("text/html", buf, { - dataFormat: "string", - }); -} - -function displayVegaLite(spec) { - if (typeof spec === "object") { - spec = JSONStringify(spec); - } - - display( - "application/vnd.vegalite.v3+json", - new TextEncoder().encode(spec), - { dataFormat: "json" }, - ); -} - -async function displayVegaLiteFile(path) { - const buf = await Deno.readFile(path); - display("application/vnd.vegalite.v3+json", buf, { dataFormat: "json" }); -} - -// from: https://jupyterlab.readthedocs.io/en/stable/user/file_formats.html -// application/json -// text/markdown -// image/bmp -// image/gif -// image/jpeg -// image/svg+xml -// text/html -// text/latex -// application/pdf -// application/vnd.vega.v5+json -// application/vdom.v1+json - -function displayFile(path, opt = {}) { - let fileType; - if (opt.hint) { - fileType = opt.hint; - } else { - const pathParts = path.split("."); - fileType = pathParts[pathParts.length - 1]; - } - fileType = fileType.toLowerCase(); - - switch (fileType) { - case "png": - return displayPngFile(path, opt); - case "html": - return displayHtmlFile(path); - case "vl": - return displayVegaLiteFile(path); - default: - throw new TypeError(`unknown file type: ${fileType}`); - } -} - -export { - display, - displayFile, - displayHtml, - displayHtmlFile, - displayPng, - displayPngFile, - displayVegaLite, - displayVegaLiteFile, -}; diff --git a/runtime/js/90_deno_ns.js b/runtime/js/90_deno_ns.js index 1de47569fccabd..00c6d6b475a682 100644 --- a/runtime/js/90_deno_ns.js +++ b/runtime/js/90_deno_ns.js @@ -23,7 +23,6 @@ import * as tty from "ext:runtime/40_tty.js"; // TODO(bartlomieju): this is funky we have two `http` imports import * as httpRuntime from "ext:runtime/40_http.js"; import * as kv from "ext:deno_kv/01_db.ts"; -import * as jupyter from "ext:runtime/40_jupyter.js"; const denoNs = { metrics: core.metrics, @@ -179,7 +178,6 @@ const denoNsUnstable = { Kv: kv.Kv, KvU64: kv.KvU64, KvListIterator: kv.KvListIterator, - jupyter, }; export { denoNs, denoNsUnstable }; diff --git a/runtime/shared.rs b/runtime/shared.rs index 26545dc686d061..e7ba109b09ce12 100644 --- a/runtime/shared.rs +++ b/runtime/shared.rs @@ -47,7 +47,6 @@ extension!(runtime, "40_process.js", "40_signals.js", "40_tty.js", - "40_jupyter.js", "41_prompt.js", "90_deno_ns.js", "98_global_scope.js" From 6983f6dd9391a64f86d1d9e172f6bf138bc0475d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Fri, 1 Sep 2023 10:49:22 +0200 Subject: [PATCH 081/115] update copyrights --- cli/tools/jupyter/comm.rs | 2 +- cli/tools/jupyter/install.rs | 2 +- cli/tools/jupyter/message_types.rs | 2 +- cli/tools/jupyter/mod.rs | 17 ++++++++++++----- 4 files changed, 15 insertions(+), 8 deletions(-) diff --git a/cli/tools/jupyter/comm.rs b/cli/tools/jupyter/comm.rs index c823ee48090df5..2723c2c6d03342 100644 --- a/cli/tools/jupyter/comm.rs +++ b/cli/tools/jupyter/comm.rs @@ -1,4 +1,4 @@ -// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license. +// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. use deno_core::error::AnyError; use ring::hmac; diff --git a/cli/tools/jupyter/install.rs b/cli/tools/jupyter/install.rs index 759cada2a38979..62625827e762c9 100644 --- a/cli/tools/jupyter/install.rs +++ b/cli/tools/jupyter/install.rs @@ -1,4 +1,4 @@ -// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license. +// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. use deno_core::anyhow::bail; use deno_core::error::AnyError; diff --git a/cli/tools/jupyter/message_types.rs b/cli/tools/jupyter/message_types.rs index 8bb798d638116c..5eb23023d436e7 100644 --- a/cli/tools/jupyter/message_types.rs +++ b/cli/tools/jupyter/message_types.rs @@ -1,4 +1,4 @@ -// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license. +// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. // TODO(bartlomieju): remove this lint supression #![allow(dead_code)] diff --git a/cli/tools/jupyter/mod.rs b/cli/tools/jupyter/mod.rs index 273e58dbcf726b..38e955b3a86bad 100644 --- a/cli/tools/jupyter/mod.rs +++ b/cli/tools/jupyter/mod.rs @@ -1,4 +1,4 @@ -// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license. +// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. use crate::args::Flags; use crate::args::JupyterFlags; @@ -132,6 +132,7 @@ pub struct DisplayArgs { metadata: Option, } +// TODO(bartlomieju): this op is unused right now. #[op] pub fn op_jupyter_display( state: &mut OpState, @@ -471,7 +472,10 @@ impl Kernel { mimetype: self.metadata.mime.clone(), file_extension: self.metadata.file_ext.clone(), }, - help_links: vec![], // TODO(apowers313) dig up help links + help_links: vec![KernelHelpLink { + text: self.metadata.help_text.clone(), + url: self.metadata.help_url.clone(), + }], banner: self.metadata.banner.clone(), debugger: false, }; @@ -552,7 +556,8 @@ impl Kernel { .await?; eprintln!("output serialized {:#?}", output); - + // TODO(bartlomieju): returning this doesn't print the value in the notebook, + // it should probably send the data to stdio topic. ExecResult::Ok(Value::String(output)) }; @@ -727,6 +732,8 @@ impl Kernel { Ok(()) } + // TODO(bartlomieju): this method shouldn't be using `data: Value` but + // a strongly typed struct. All this handling here, is super brittle. async fn display_data_from_result_value( &mut self, data: Value, @@ -979,8 +986,8 @@ impl Default for KernelMetadata { Self { banner: "Welcome to Deno kernel".to_string(), file_ext: ".ts".to_string(), - help_text: "".to_string(), - help_url: "https://github.com/denoland/deno".to_string(), + help_text: "Visit Deno manual".to_string(), + help_url: "https://deno.land/manual".to_string(), implementation_name: "Deno kernel".to_string(), kernel_version: crate::version::deno().to_string(), language_version: crate::version::TYPESCRIPT.to_string(), From 49111ee532f376a0cb514b9da3ad591673e8def2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Fri, 1 Sep 2023 17:40:35 +0200 Subject: [PATCH 082/115] reorg --- cli/tools/jupyter/comm.rs | 66 +++++++++++++++++--- cli/tools/jupyter/mod.rs | 128 ++++++++++++++++---------------------- 2 files changed, 111 insertions(+), 83 deletions(-) diff --git a/cli/tools/jupyter/comm.rs b/cli/tools/jupyter/comm.rs index 2723c2c6d03342..eaedc2c22ec4fc 100644 --- a/cli/tools/jupyter/comm.rs +++ b/cli/tools/jupyter/comm.rs @@ -7,6 +7,7 @@ use zeromq::util::PeerIdentity; use zeromq::SocketOptions; use super::hmac_verify; +use super::ConnectionSpec; use super::ReplyMessage; use super::RequestMessage; use super::SideEffectMessage; @@ -21,9 +22,18 @@ pub struct PubComm { identity: String, } +fn create_conn_str(transport: &str, ip: &str, port: u32) -> String { + format!("{}://{}:{}", transport, ip, port) +} + // TODO(apowers313) connect and send look like traits shared with DealerComm impl PubComm { - pub fn new(conn_str: String, identity: String, hmac_key: hmac::Key) -> Self { + pub fn new( + spec: &ConnectionSpec, + identity: &str, + hmac_key: &hmac::Key, + ) -> Self { + let conn_str = create_conn_str(&spec.transport, &spec.ip, spec.iopub_port); println!("iopub connection: {}", conn_str); let peer_identity = PeerIdentity::try_from(identity.as_bytes().to_vec()).unwrap(); @@ -32,8 +42,8 @@ impl PubComm { Self { conn_str, - identity, - hmac_key, + identity: identity.to_string(), + hmac_key: hmac_key.to_owned(), socket: zeromq::PubSocket::with_options(options), } } @@ -67,8 +77,8 @@ impl DealerComm { pub fn new( name: &str, conn_str: String, - identity: String, - hmac_key: hmac::Key, + identity: &str, + hmac_key: &hmac::Key, ) -> Self { println!("dealer '{}' connection: {}", name, conn_str); let peer_identity = @@ -79,12 +89,51 @@ impl DealerComm { Self { name: name.to_string(), conn_str, - identity, - hmac_key, + identity: identity.to_string(), + hmac_key: hmac_key.to_owned(), socket: zeromq::DealerSocket::with_options(options), } } + pub fn create_shell( + spec: &ConnectionSpec, + identity: &str, + hmac_key: &hmac::Key, + ) -> Self { + Self::new( + "shell", + create_conn_str(&spec.transport, &spec.ip, spec.shell_port), + identity, + hmac_key, + ) + } + + pub fn create_control( + spec: &ConnectionSpec, + identity: &str, + hmac_key: &hmac::Key, + ) -> Self { + Self::new( + "control", + create_conn_str(&spec.transport, &spec.ip, spec.control_port), + identity, + hmac_key, + ) + } + + pub fn create_stdin( + spec: &ConnectionSpec, + identity: &str, + hmac_key: &hmac::Key, + ) -> Self { + Self::new( + "stdin", + create_conn_str(&spec.transport, &spec.ip, spec.stdin_port), + identity, + hmac_key, + ) + } + pub async fn connect(&mut self) -> Result<(), AnyError> { self.socket.bind(&self.conn_str).await?; @@ -123,7 +172,8 @@ pub struct HbComm { } impl HbComm { - pub fn new(conn_str: String) -> Self { + pub fn new(spec: &ConnectionSpec) -> Self { + let conn_str = create_conn_str(&spec.transport, &spec.ip, spec.hb_port); println!("hb connection: {}", conn_str); Self { conn_str, diff --git a/cli/tools/jupyter/mod.rs b/cli/tools/jupyter/mod.rs index 38e955b3a86bad..6fb91a5a9e942e 100644 --- a/cli/tools/jupyter/mod.rs +++ b/cli/tools/jupyter/mod.rs @@ -1,5 +1,7 @@ // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. +use std::path::Path; + use crate::args::Flags; use crate::args::JupyterFlags; use crate::tools::repl::ReplSession; @@ -41,18 +43,43 @@ pub async fn kernel( flags: Flags, jupyter_flags: JupyterFlags, ) -> Result<(), AnyError> { - if jupyter_flags.conn_file.is_none() { + let Some(connection_filepath) = jupyter_flags.conn_file else { return Err(generic_error("Missing --conn flag")); - } + }; // This env var might be set by notebook if std::env::var("DEBUG").is_ok() { logger::init(Some(log::Level::Debug)); } - let conn_file_path = jupyter_flags.conn_file.unwrap(); + let factory = CliFactory::from_flags(flags).await?; + let cli_options = factory.cli_options(); + let main_module = + resolve_url_or_path("./$deno$jupyter.ts", cli_options.initial_cwd()) + .unwrap(); + // TODO(bartlomieju): should we run with all permissions? + let permissions = PermissionsContainer::new(Permissions::allow_all()); + let npm_resolver = factory.npm_resolver().await?.clone(); + let resolver = factory.resolver().await?.clone(); + let worker_factory = factory.create_cli_main_worker_factory().await?; + let (stdio_tx, stdio_rx) = mpsc::unbounded(); + + let mut worker = worker_factory + .create_custom_worker( + main_module.clone(), + permissions, + vec![deno_jupyter::init_ops(stdio_tx)], + Default::default(), + ) + .await?; + worker.setup_repl().await?; + let worker = worker.into_main_worker(); + let repl_session = + ReplSession::initialize(cli_options, npm_resolver, resolver, worker) + .await?; - let mut kernel = Kernel::new(flags, conn_file_path.to_str().unwrap()).await?; + let mut kernel = + Kernel::new(&connection_filepath, stdio_rx, repl_session).await?; println!("[DENO] kernel created: {:#?}", kernel.identity); println!("running kernel..."); @@ -174,89 +201,42 @@ pub fn op_print( } impl Kernel { - async fn new(flags: Flags, conn_file_path: &str) -> Result { + async fn new( + connection_filepath: &Path, + stdio_rx: mpsc::UnboundedReceiver, + repl_session: ReplSession, + ) -> Result { let conn_file = - std::fs::read_to_string(conn_file_path).with_context(|| { - format!("Couldn't read connection file: {}", conn_file_path) + std::fs::read_to_string(connection_filepath).with_context(|| { + format!("Couldn't read connection file: {:?}", connection_filepath) })?; let spec: ConnectionSpec = serde_json::from_str(&conn_file).with_context(|| { - format!("Connection file isn't proper JSON: {}", conn_file_path) + format!( + "Connection file is not a valid JSON: {:?}", + connection_filepath + ) })?; println!("[DENO] parsed conn file: {:#?}", spec); - let execution_count = 0; let identity = uuid::Uuid::new_v4().to_string(); let hmac_key = hmac::Key::new(hmac::HMAC_SHA256, spec.key.as_ref()); - let metadata = KernelMetadata::default(); - let iopub_comm = PubComm::new( - create_conn_str(&spec.transport, &spec.ip, spec.iopub_port), - identity.clone(), - hmac_key.clone(), - ); - let shell_comm = DealerComm::new( - "shell", - create_conn_str(&spec.transport, &spec.ip, spec.shell_port), - identity.clone(), - hmac_key.clone(), - ); - let control_comm = DealerComm::new( - "control", - create_conn_str(&spec.transport, &spec.ip, spec.control_port), - identity.clone(), - hmac_key.clone(), - ); - let stdin_comm = DealerComm::new( - "stdin", - create_conn_str(&spec.transport, &spec.ip, spec.stdin_port), - identity.clone(), - hmac_key, - ); - let hb_comm = - HbComm::new(create_conn_str(&spec.transport, &spec.ip, spec.hb_port)); - - let (stdio_tx, stdio_rx) = mpsc::unbounded(); - - let factory = CliFactory::from_flags(flags).await?; - let cli_options = factory.cli_options(); - let main_module = - resolve_url_or_path("./$deno$jupyter.ts", cli_options.initial_cwd()) - .unwrap(); - // TODO(bartlomieju): should we run with all permissions? - let permissions = PermissionsContainer::new(Permissions::allow_all()); - let npm_resolver = factory.npm_resolver().await?.clone(); - let resolver = factory.resolver().await?.clone(); - let worker_factory = factory.create_cli_main_worker_factory().await?; - - let mut worker = worker_factory - .create_custom_worker( - main_module.clone(), - permissions, - vec![deno_jupyter::init_ops(stdio_tx)], - Default::default(), - ) - .await?; - worker.setup_repl().await?; - let worker = worker.into_main_worker(); - let repl_session = - ReplSession::initialize(cli_options, npm_resolver, resolver, worker) - .await?; let kernel = Self { - metadata, - conn_spec: spec, + metadata: KernelMetadata::default(), state: KernelState::Idle, - iopub_comm, - shell_comm, - control_comm, - stdin_comm, - hb_comm, + iopub_comm: PubComm::new(&spec, &identity, &hmac_key), + shell_comm: DealerComm::create_shell(&spec, &identity, &hmac_key), + control_comm: DealerComm::create_control(&spec, &identity, &hmac_key), + stdin_comm: DealerComm::create_stdin(&spec, &identity, &hmac_key), + hb_comm: HbComm::new(&spec), identity, - execution_count, + execution_count: 0, repl_session, stdio_rx, last_comm_ctx: None, + conn_spec: spec, }; Ok(kernel) @@ -999,7 +979,7 @@ impl Default for KernelMetadata { } #[derive(Debug, Deserialize)] -struct ConnectionSpec { +pub struct ConnectionSpec { ip: String, transport: String, control_port: u32, @@ -1007,12 +987,10 @@ struct ConnectionSpec { stdin_port: u32, hb_port: u32, iopub_port: u32, - signature_scheme: String, key: String, -} -fn create_conn_str(transport: &str, ip: &str, port: u32) -> String { - format!("{}://{}:{}", transport, ip, port) + #[allow(unused)] + signature_scheme: String, } #[derive(Debug)] From a876055152007821e81af1793454052d35b2a9f4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Fri, 1 Sep 2023 18:21:37 +0200 Subject: [PATCH 083/115] output working --- cli/tools/jupyter/mod.rs | 146 +----- integration_test.ipynb | 1004 +++++++++++++++++++++++++++++++++----- 2 files changed, 909 insertions(+), 241 deletions(-) diff --git a/cli/tools/jupyter/mod.rs b/cli/tools/jupyter/mod.rs index 6fb91a5a9e942e..ae56a69ba2b18b 100644 --- a/cli/tools/jupyter/mod.rs +++ b/cli/tools/jupyter/mod.rs @@ -114,7 +114,7 @@ struct Kernel { identity: String, execution_count: u32, repl_session: ReplSession, - stdio_rx: WorkerCommReceiver, + stdio_rx: mpsc::UnboundedReceiver, last_comm_ctx: Option, } @@ -125,22 +125,14 @@ enum HandlerType { Stdin, } -pub type WorkerCommSender = UnboundedSender; -pub type WorkerCommReceiver = UnboundedReceiver; - pub enum WorkerCommMsg { Stderr(String), Stdout(String), - // TODO(bartlomieju): do we need it? - Display(String, JsBuffer, Option, Option), } deno_core::extension!(deno_jupyter, - ops = [ - op_jupyter_display - ], options = { - sender: WorkerCommSender, + sender: mpsc::UnboundedSender, }, middleware = |op| match op.name { "op_print" => op_print::DECL, @@ -151,45 +143,13 @@ deno_core::extension!(deno_jupyter, }, ); -#[derive(Deserialize, Debug)] -#[serde(rename_all = "camelCase")] -pub struct DisplayArgs { - mime_type: String, - data_format: Option, - metadata: Option, -} - -// TODO(bartlomieju): this op is unused right now. -#[op] -pub fn op_jupyter_display( - state: &mut OpState, - args: DisplayArgs, - data: Option, -) -> Result<(), AnyError> { - let d = match data { - Some(x) => x, - None => return Err(anyhow!("op_jupyter_display missing 'data' argument")), - }; - - let sender = state.borrow_mut::(); - // TODO(bartlomieju): should the result be handled? - let _ = sender.unbounded_send(WorkerCommMsg::Display( - args.mime_type, - d, - args.data_format, - args.metadata, - )); - - Ok(()) -} - #[op] pub fn op_print( state: &mut OpState, msg: String, is_err: bool, ) -> Result<(), AnyError> { - let sender = state.borrow_mut::(); + let sender = state.borrow_mut::>(); // TODO(bartlomieju): should these results be handled somehow? if is_err { @@ -362,12 +322,6 @@ impl Kernel { .send_stdio(&comm_ctx, StdioType::Stderr, s.as_ref()) .await?; } - WorkerCommMsg::Display(mime, buf, format, metadata) => { - let mut dd = MimeSet::new(); - dd.add_buf(mime.as_ref(), buf, format)?; - let md = self.create_display_metadata(mime, metadata)?; - self.send_display_data(&comm_ctx, dd, md).await?; - } }; Ok(()) @@ -401,12 +355,14 @@ impl Kernel { Ok(()) } - fn control_handler(&self, _comm_ctx: &CommContext) -> Result<(), AnyError> { - todo!() + fn control_handler(&self, comm_ctx: &CommContext) -> Result<(), AnyError> { + eprintln!("Unimplemented control_handler {:#?}", comm_ctx); + Ok(()) } - fn stdin_handler(&self, _comm_ctx: &CommContext) -> Result<(), AnyError> { - todo!() + fn stdin_handler(&self, comm_ctx: &CommContext) -> Result<(), AnyError> { + eprintln!("Unimplemented stdin_handler {:#?}", comm_ctx); + Ok(()) } async fn set_state(&mut self, comm_ctx: &CommContext, state: KernelState) { @@ -538,7 +494,7 @@ impl Kernel { eprintln!("output serialized {:#?}", output); // TODO(bartlomieju): returning this doesn't print the value in the notebook, // it should probably send the data to stdio topic. - ExecResult::Ok(Value::String(output)) + ExecResult::Ok(output) }; match result { @@ -612,9 +568,8 @@ impl Kernel { comm_ctx: &CommContext, result: &ExecResult, ) -> Result<(), AnyError> { - let e = match result { - ExecResult::Error(e) => e, - _ => return Err(anyhow!("send_error: unreachable")), + let ExecResult::Error(e) = result else { + unreachable!() }; let msg = SideEffectMessage::new( comm_ctx, @@ -636,14 +591,9 @@ impl Kernel { comm_ctx: &CommContext, result: &ExecResult, ) -> Result<(), AnyError> { - let v = match result { - ExecResult::Ok(v) => v, - _ => return Err(anyhow!("send_execute_result: unreachable")), + let ExecResult::Ok(result_str) = result else { + unreachable!() }; - let display_data = self.display_data_from_result_value(v.clone()).await?; - if display_data.is_empty() { - return Ok(()); - } let msg = SideEffectMessage::new( comm_ctx, @@ -651,7 +601,9 @@ impl Kernel { ReplyMetadata::Empty, ReplyContent::ExecuteResult(ExecuteResultContent { execution_count: self.execution_count, - data: display_data.to_object(), + data: json!({ + "text/plain": result_str, + }), // data: json!(""), metadata: json!({}), }), @@ -687,31 +639,6 @@ impl Kernel { Ok(()) } - async fn send_display_data( - &mut self, - comm_ctx: &CommContext, - display_data: MimeSet, - metadata: MimeSet, - ) -> Result<(), AnyError> { - if display_data.is_empty() { - return Err(anyhow!("send_display_data called with empty display data")); - } - - let msg = SideEffectMessage::new( - comm_ctx, - "display_data", - ReplyMetadata::Empty, - ReplyContent::DisplayData(DisplayDataContent { - data: display_data.to_object(), - metadata: metadata.to_object(), - transient: json!({}), - }), - ); - self.iopub_comm.send(msg).await?; - - Ok(()) - } - // TODO(bartlomieju): this method shouldn't be using `data: Value` but // a strongly typed struct. All this handling here, is super brittle. async fn display_data_from_result_value( @@ -786,43 +713,6 @@ impl Kernel { Ok(ret) } - fn create_display_metadata( - &self, - format: String, - metadata: Option, - ) -> Result { - let mut ms = MimeSet::new(); - let format_str = format.as_ref(); - - let md = match metadata { - Some(m) => m, - None => { - ms.add(format_str, json!({})); - return Ok(ms); - } - }; - - match format_str { - "image/png" | "image/bmp" | "image/gif" | "image/jpeg" - | "image/svg+xml" => ms.add( - format_str, - json!({ - "width": md["width"], - "height": md["height"], - }), - ), - "application/json" => ms.add( - format_str, - json!({ - "expanded": md["width"], - }), - ), - _ => ms.add(format_str, md), - } - - Ok(ms) - } - async fn decode_object( &mut self, obj: Value, @@ -937,7 +827,7 @@ impl MimeSet { } enum ExecResult { - Ok(Value), + Ok(String), Error(ExecError), } diff --git a/integration_test.ipynb b/integration_test.ipynb index 5473cc26116baf..d3121ebdee5f08 100644 --- a/integration_test.ipynb +++ b/integration_test.ipynb @@ -1,6 +1,7 @@ { "cells": [ { + "attachments": {}, "cell_type": "markdown", "id": "182aef1d", "metadata": {}, @@ -10,6 +11,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "d7705d88", "metadata": {}, @@ -18,6 +20,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "669f972e", "metadata": { @@ -28,6 +31,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "e7e8a512", "metadata": { @@ -40,12 +44,22 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "id": "a5d38758", "metadata": { "hidden": true }, "outputs": [ + { + "data": { + "text/plain": [ + "\u001b[90mundefined\u001b[39m" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + }, { "name": "stdout", "output_type": "stream", @@ -59,6 +73,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "bc5ce8e3", "metadata": { @@ -70,17 +85,27 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "id": "f7fa885a", "metadata": { "hidden": true }, "outputs": [ + { + "data": { + "text/plain": [ + "\u001b[90mundefined\u001b[39m" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + }, { "name": "stdout", "output_type": "stream", "text": [ - "x is \u001b[33m42\u001b[39m\n" + "x is 42\n" ] } ], @@ -90,6 +115,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "c21455ae", "metadata": { @@ -102,7 +128,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 3, "id": "08a17340", "metadata": { "hidden": true @@ -114,7 +140,7 @@ "{ color: \u001b[32m\"red\"\u001b[39m, area: \u001b[33m10000\u001b[39m }" ] }, - "execution_count": 5, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } @@ -136,6 +162,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "eaa0ebc0", "metadata": { @@ -146,6 +173,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "52876276", "metadata": { @@ -157,17 +185,29 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "id": "bbf2c09b", "metadata": { "hidden": true }, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "\u001b[90mundefined\u001b[39m" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "undefined" ] }, { + "attachments": {}, "cell_type": "markdown", "id": "e175c803", "metadata": { @@ -179,7 +219,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 5, "id": "d9801d80", "metadata": { "hidden": true @@ -187,12 +227,11 @@ "outputs": [ { "data": { - "application/json": null, "text/plain": [ - "null" + "\u001b[1mnull\u001b[22m" ] }, - "execution_count": 13, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -202,6 +241,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "a2a716dc", "metadata": { @@ -221,9 +261,8 @@ "outputs": [ { "data": { - "application/json": true, "text/plain": [ - "true" + "\u001b[33mtrue\u001b[39m" ] }, "execution_count": 6, @@ -236,6 +275,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "8d9f1aba", "metadata": { @@ -255,9 +295,8 @@ "outputs": [ { "data": { - "application/json": 42, "text/plain": [ - "42" + "\u001b[33m42\u001b[39m" ] }, "execution_count": 7, @@ -270,6 +309,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "60965915", "metadata": { @@ -289,9 +329,8 @@ "outputs": [ { "data": { - "application/json": "this is a test of the emergency broadcast system", "text/plain": [ - "this is a test of the emergency broadcast system" + "\u001b[32m\"this is a test of the emergency broadcast system\"\u001b[39m" ] }, "execution_count": 8, @@ -304,6 +343,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "fe38dc27", "metadata": { @@ -323,9 +363,8 @@ "outputs": [ { "data": { - "application/json": "31337n", "text/plain": [ - "31337n" + "\u001b[33m31337n\u001b[39m" ] }, "execution_count": 9, @@ -338,6 +377,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "843ccb6c", "metadata": { @@ -357,9 +397,8 @@ "outputs": [ { "data": { - "application/json": "Symbol(foo)", "text/plain": [ - "Symbol(foo)" + "\u001b[32mSymbol(foo)\u001b[39m" ] }, "execution_count": 10, @@ -372,6 +411,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "171b817f", "metadata": { @@ -391,7 +431,6 @@ "outputs": [ { "data": { - "application/json": "{ foo: \u001b[32m\"bar\"\u001b[39m }", "text/plain": [ "{ foo: \u001b[32m\"bar\"\u001b[39m }" ] @@ -415,59 +454,13 @@ "outputs": [ { "data": { - "application/json": "{\n core: {\n opcallSync: \u001b[36m[Function: opcallSync]\u001b[39m,\n opcallAsync: \u001b[36m[Function: opcallAsync]\u001b[39m,\n refOp: \u001b[36m[Function: refOp]\u001b[39m,\n unrefOp: \u001b[36m[Function: unrefOp]\u001b[39m,\n setMacrotaskCallback: \u001b[36m[Function: setMacrotaskCallback]\u001b[39m,\n setNextTickCallback: \u001b[36m[Function: setNextTickCallback]\u001b[39m,\n setPromiseRejectCallback: \u001b[36m[Function: setPromiseRejectCallback]\u001b[39m,\n setUncaughtExceptionCallback: \u001b[36m[Function: setUncaughtExceptionCallback]\u001b[39m,\n runMicrotasks: \u001b[36m[Function: runMicrotasks]\u001b[39m,\n hasTickScheduled: \u001b[36m[Function: hasTickScheduled]\u001b[39m,\n setHasTickScheduled: \u001b[36m[Function: setHasTickScheduled]\u001b[39m,\n evalContext: \u001b[36m[Function: evalContext]\u001b[39m,\n encode: \u001b[36m[Function: encode]\u001b[39m,\n decode: \u001b[36m[Function: decode]\u001b[39m,\n serialize: \u001b[36m[Function: serialize]\u001b[39m,\n deserialize: \u001b[36m[Function: deserialize]\u001b[39m,\n getPromiseDetails: \u001b[36m[Function: getPromiseDetails]\u001b[39m,\n getProxyDetails: \u001b[36m[Function: getProxyDetails]\u001b[39m,\n isProxy: \u001b[36m[Function: isProxy]\u001b[39m,\n memoryUsage: \u001b[36m[Function: memoryUsage]\u001b[39m,\n callConsole: \u001b[36m[Function: callConsole]\u001b[39m,\n createHostObject: \u001b[36m[Function: createHostObject]\u001b[39m,\n setWasmStreamingCallback: \u001b[36m[Function: setWasmStreamingCallback]\u001b[39m,\n opAsync: \u001b[36m[Function: opAsync]\u001b[39m,\n opSync: \u001b[36m[Function: opSync]\u001b[39m,\n ops: \u001b[36m[Function: ops]\u001b[39m,\n close: \u001b[36m[Function: close]\u001b[39m,\n tryClose: \u001b[36m[Function: tryClose]\u001b[39m,\n read: \u001b[36m[Function: read]\u001b[39m,\n write: \u001b[36m[Function: write]\u001b[39m,\n shutdown: \u001b[36m[Function: shutdown]\u001b[39m,\n print: \u001b[36m[Function: print]\u001b[39m,\n resources: \u001b[36m[Function: resources]\u001b[39m,\n metrics: \u001b[36m[Function: metrics]\u001b[39m,\n registerErrorBuilder: \u001b[36m[Function: registerErrorBuilder]\u001b[39m,\n registerErrorClass: \u001b[36m[Function: registerErrorClass]\u001b[39m,\n opresolve: \u001b[36m[Function: opresolve]\u001b[39m,\n syncOpsCache: \u001b[36m[Function: syncOpsCache]\u001b[39m,\n BadResource: \u001b[36m[Function: BadResource]\u001b[39m,\n Interrupted: \u001b[36m[Function: Interrupted]\u001b[39m,\n createPrepareStackTrace: \u001b[36m[Function: createPrepareStackTrace]\u001b[39m\n },\n internal: \u001b[32mSymbol(Deno.internal)\u001b[39m,\n resources: \u001b[36m[Function: resources]\u001b[39m,\n close: \u001b[36m[Function: close]\u001b[39m,\n memoryUsage: \u001b[36m[Function: memoryUsage]\u001b[39m,\n metrics: \u001b[36m[Function: metrics]\u001b[39m,\n test: \u001b[36m[Function: test]\u001b[39m,\n Process: \u001b[36m[Function: Process]\u001b[39m,\n run: \u001b[36m[Function: run]\u001b[39m,\n isatty: \u001b[36m[Function: isatty]\u001b[39m,\n writeFileSync: \u001b[36m[Function: writeFileSync]\u001b[39m,\n writeFile: \u001b[36m[AsyncFunction: writeFile]\u001b[39m,\n writeTextFileSync: \u001b[36m[Function: writeTextFileSync]\u001b[39m,\n writeTextFile: \u001b[36m[Function: writeTextFile]\u001b[39m,\n readTextFile: \u001b[36m[AsyncFunction: readTextFile]\u001b[39m,\n readTextFileSync: \u001b[36m[Function: readTextFileSync]\u001b[39m,\n readFile: \u001b[36m[AsyncFunction: readFile]\u001b[39m,\n readFileSync: \u001b[36m[Function: readFileSync]\u001b[39m,\n watchFs: \u001b[36m[Function: watchFs]\u001b[39m,\n chmodSync: \u001b[36m[Function: chmodSync]\u001b[39m,\n chmod: \u001b[36m[AsyncFunction: chmod]\u001b[39m,\n chown: \u001b[36m[AsyncFunction: chown]\u001b[39m,\n chownSync: \u001b[36m[Function: chownSync]\u001b[39m,\n copyFileSync: \u001b[36m[Function: copyFileSync]\u001b[39m,\n cwd: \u001b[36m[Function: cwd]\u001b[39m,\n makeTempDirSync: \u001b[36m[Function: makeTempDirSync]\u001b[39m,\n makeTempDir: \u001b[36m[Function: makeTempDir]\u001b[39m,\n makeTempFileSync: \u001b[36m[Function: makeTempFileSync]\u001b[39m,\n makeTempFile: \u001b[36m[Function: makeTempFile]\u001b[39m,\n mkdirSync: \u001b[36m[Function: mkdirSync]\u001b[39m,\n mkdir: \u001b[36m[AsyncFunction: mkdir]\u001b[39m,\n chdir: \u001b[36m[Function: chdir]\u001b[39m,\n copyFile: \u001b[36m[AsyncFunction: copyFile]\u001b[39m,\n readDirSync: \u001b[36m[Function: readDirSync]\u001b[39m,\n readDir: \u001b[36m[Function: readDir]\u001b[39m,\n readLinkSync: \u001b[36m[Function: readLinkSync]\u001b[39m,\n readLink: \u001b[36m[Function: readLink]\u001b[39m,\n realPathSync: \u001b[36m[Function: realPathSync]\u001b[39m,\n realPath: \u001b[36m[Function: realPath]\u001b[39m,\n removeSync: \u001b[36m[Function: removeSync]\u001b[39m,\n remove: \u001b[36m[AsyncFunction: remove]\u001b[39m,\n renameSync: \u001b[36m[Function: renameSync]\u001b[39m,\n rename: \u001b[36m[AsyncFunction: rename]\u001b[39m,\n version: { deno: \u001b[32m\"1.17.0\"\u001b[39m, v8: \u001b[32m\"9.7.106.15\"\u001b[39m, typescript: \u001b[32m\"4.5.2\"\u001b[39m },\n build: {\n target: \u001b[32m\"x86_64-apple-darwin\"\u001b[39m,\n arch: \u001b[32m\"x86_64\"\u001b[39m,\n os: \u001b[32m\"darwin\"\u001b[39m,\n vendor: \u001b[32m\"apple\"\u001b[39m,\n env: \u001b[90mundefined\u001b[39m\n },\n statSync: \u001b[36m[Function: statSync]\u001b[39m,\n lstatSync: \u001b[36m[Function: lstatSync]\u001b[39m,\n stat: \u001b[36m[AsyncFunction: stat]\u001b[39m,\n lstat: \u001b[36m[AsyncFunction: lstat]\u001b[39m,\n truncateSync: \u001b[36m[Function: truncateSync]\u001b[39m,\n truncate: \u001b[36m[AsyncFunction: truncate]\u001b[39m,\n ftruncateSync: \u001b[36m[Function: ftruncateSync]\u001b[39m,\n ftruncate: \u001b[36m[AsyncFunction: ftruncate]\u001b[39m,\n errors: {\n NotFound: \u001b[36m[Function: NotFound]\u001b[39m,\n PermissionDenied: \u001b[36m[Function: PermissionDenied]\u001b[39m,\n ConnectionRefused: \u001b[36m[Function: ConnectionRefused]\u001b[39m,\n ConnectionReset: \u001b[36m[Function: ConnectionReset]\u001b[39m,\n ConnectionAborted: \u001b[36m[Function: ConnectionAborted]\u001b[39m,\n NotConnected: \u001b[36m[Function: NotConnected]\u001b[39m,\n AddrInUse: \u001b[36m[Function: AddrInUse]\u001b[39m,\n AddrNotAvailable: \u001b[36m[Function: AddrNotAvailable]\u001b[39m,\n BrokenPipe: \u001b[36m[Function: BrokenPipe]\u001b[39m,\n AlreadyExists: \u001b[36m[Function: AlreadyExists]\u001b[39m,\n InvalidData: \u001b[36m[Function: InvalidData]\u001b[39m,\n TimedOut: \u001b[36m[Function: TimedOut]\u001b[39m,\n Interrupted: \u001b[36m[Function: Interrupted]\u001b[39m,\n WriteZero: \u001b[36m[Function: WriteZero]\u001b[39m,\n UnexpectedEof: \u001b[36m[Function: UnexpectedEof]\u001b[39m,\n BadResource: \u001b[36m[Function: BadResource]\u001b[39m,\n Http: \u001b[36m[Function: Http]\u001b[39m,\n Busy: \u001b[36m[Function: Busy]\u001b[39m,\n NotSupported: \u001b[36m[Function: NotSupported]\u001b[39m\n },\n customInspect: \u001b[32mSymbol(Deno.customInspect)\u001b[39m,\n inspect: \u001b[36m[Function: inspect]\u001b[39m,\n env: {\n get: \u001b[36m[Function: getEnv]\u001b[39m,\n toObject: \u001b[36m[Function: toObject]\u001b[39m,\n set: \u001b[36m[Function: setEnv]\u001b[39m,\n delete: \u001b[36m[Function: deleteEnv]\u001b[39m\n },\n exit: \u001b[36m[Function: exit]\u001b[39m,\n execPath: \u001b[36m[Function: execPath]\u001b[39m,\n Buffer: \u001b[36m[Function: Buffer]\u001b[39m,\n readAll: \u001b[36m[AsyncFunction: readAll]\u001b[39m,\n readAllSync: \u001b[36m[Function: readAllSync]\u001b[39m,\n writeAll: \u001b[36m[AsyncFunction: writeAll]\u001b[39m,\n writeAllSync: \u001b[36m[Function: writeAllSync]\u001b[39m,\n copy: \u001b[36m[AsyncFunction: copy]\u001b[39m,\n iter: \u001b[36m[AsyncGeneratorFunction: iter]\u001b[39m,\n iterSync: \u001b[36m[GeneratorFunction: iterSync]\u001b[39m,\n SeekMode: { \"0\": \u001b[32m\"Start\"\u001b[39m, \"1\": \u001b[32m\"Current\"\u001b[39m, \"2\": \u001b[32m\"End\"\u001b[39m, Start: \u001b[33m0\u001b[39m, Current: \u001b[33m1\u001b[39m, End: \u001b[33m2\u001b[39m },\n read: \u001b[36m[AsyncFunction: read]\u001b[39m,\n readSync: \u001b[36m[Function: readSync]\u001b[39m,\n write: \u001b[36m[Function: write]\u001b[39m,\n writeSync: \u001b[36m[Function: writeSync]\u001b[39m,\n File: \u001b[36m[Function: File]\u001b[39m,\n open: \u001b[36m[AsyncFunction: open]\u001b[39m,\n openSync: \u001b[36m[Function: openSync]\u001b[39m,\n create: \u001b[36m[Function: create]\u001b[39m,\n createSync: \u001b[36m[Function: createSync]\u001b[39m,\n stdin: Stdin {},\n stdout: Stdout {},\n stderr: Stderr {},\n seek: \u001b[36m[Function: seek]\u001b[39m,\n seekSync: \u001b[36m[Function: seekSync]\u001b[39m,\n connect: \u001b[36m[AsyncFunction: connect]\u001b[39m,\n listen: \u001b[36m[Function: listen]\u001b[39m,\n connectTls: \u001b[36m[AsyncFunction: connectTls]\u001b[39m,\n listenTls: \u001b[36m[Function: listenTls]\u001b[39m,\n startTls: \u001b[36m[AsyncFunction: startTls]\u001b[39m,\n shutdown: \u001b[36m[Function: shutdown]\u001b[39m,\n fstatSync: \u001b[36m[Function: fstatSync]\u001b[39m,\n fstat: \u001b[36m[AsyncFunction: fstat]\u001b[39m,\n fsyncSync: \u001b[36m[Function: fsyncSync]\u001b[39m,\n fsync: \u001b[36m[AsyncFunction: fsync]\u001b[39m,\n fdatasyncSync: \u001b[36m[Function: fdatasyncSync]\u001b[39m,\n fdatasync: \u001b[36m[AsyncFunction: fdatasync]\u001b[39m,\n symlink: \u001b[36m[AsyncFunction: symlink]\u001b[39m,\n symlinkSync: \u001b[36m[Function: symlinkSync]\u001b[39m,\n link: \u001b[36m[AsyncFunction: link]\u001b[39m,\n linkSync: \u001b[36m[Function: linkSync]\u001b[39m,\n permissions: Permissions {},\n Permissions: \u001b[36m[Function: Permissions]\u001b[39m,\n PermissionStatus: \u001b[36m[Function: PermissionStatus]\u001b[39m,\n serveHttp: \u001b[36m[Function: serveHttp]\u001b[39m,\n resolveDns: \u001b[36m[Function: resolveDns]\u001b[39m,\n upgradeWebSocket: \u001b[36m[Function: upgradeWebSocket]\u001b[39m,\n kill: \u001b[36m[Function: opKill]\u001b[39m,\n pid: \u001b[33m79003\u001b[39m,\n ppid: \u001b[33m78992\u001b[39m,\n noColor: \u001b[33mfalse\u001b[39m,\n args: [],\n mainModule: [Getter],\n [Symbol(Deno.internal)]: {\n Console: \u001b[36m[Function: Console]\u001b[39m,\n cssToAnsi: \u001b[36m[Function: cssToAnsi]\u001b[39m,\n inspectArgs: \u001b[36m[Function: inspectArgs]\u001b[39m,\n parseCss: \u001b[36m[Function: parseCss]\u001b[39m,\n parseCssColor: \u001b[36m[Function: parseCssColor]\u001b[39m,\n pathFromURL: \u001b[36m[Function: pathFromURL]\u001b[39m,\n runTests: \u001b[36m[AsyncFunction: runTests]\u001b[39m,\n enableTestSteps: \u001b[36m[Function: enableTestSteps]\u001b[39m\n }\n}", "text/plain": [ "{\n", - " core: {\n", - " opcallSync: \u001b[36m[Function: opcallSync]\u001b[39m,\n", - " opcallAsync: \u001b[36m[Function: opcallAsync]\u001b[39m,\n", - " refOp: \u001b[36m[Function: refOp]\u001b[39m,\n", - " unrefOp: \u001b[36m[Function: unrefOp]\u001b[39m,\n", - " setMacrotaskCallback: \u001b[36m[Function: setMacrotaskCallback]\u001b[39m,\n", - " setNextTickCallback: \u001b[36m[Function: setNextTickCallback]\u001b[39m,\n", - " setPromiseRejectCallback: \u001b[36m[Function: setPromiseRejectCallback]\u001b[39m,\n", - " setUncaughtExceptionCallback: \u001b[36m[Function: setUncaughtExceptionCallback]\u001b[39m,\n", - " runMicrotasks: \u001b[36m[Function: runMicrotasks]\u001b[39m,\n", - " hasTickScheduled: \u001b[36m[Function: hasTickScheduled]\u001b[39m,\n", - " setHasTickScheduled: \u001b[36m[Function: setHasTickScheduled]\u001b[39m,\n", - " evalContext: \u001b[36m[Function: evalContext]\u001b[39m,\n", - " encode: \u001b[36m[Function: encode]\u001b[39m,\n", - " decode: \u001b[36m[Function: decode]\u001b[39m,\n", - " serialize: \u001b[36m[Function: serialize]\u001b[39m,\n", - " deserialize: \u001b[36m[Function: deserialize]\u001b[39m,\n", - " getPromiseDetails: \u001b[36m[Function: getPromiseDetails]\u001b[39m,\n", - " getProxyDetails: \u001b[36m[Function: getProxyDetails]\u001b[39m,\n", - " isProxy: \u001b[36m[Function: isProxy]\u001b[39m,\n", - " memoryUsage: \u001b[36m[Function: memoryUsage]\u001b[39m,\n", - " callConsole: \u001b[36m[Function: callConsole]\u001b[39m,\n", - " createHostObject: \u001b[36m[Function: createHostObject]\u001b[39m,\n", - " setWasmStreamingCallback: \u001b[36m[Function: setWasmStreamingCallback]\u001b[39m,\n", - " opAsync: \u001b[36m[Function: opAsync]\u001b[39m,\n", - " opSync: \u001b[36m[Function: opSync]\u001b[39m,\n", - " ops: \u001b[36m[Function: ops]\u001b[39m,\n", - " close: \u001b[36m[Function: close]\u001b[39m,\n", - " tryClose: \u001b[36m[Function: tryClose]\u001b[39m,\n", - " read: \u001b[36m[Function: read]\u001b[39m,\n", - " write: \u001b[36m[Function: write]\u001b[39m,\n", - " shutdown: \u001b[36m[Function: shutdown]\u001b[39m,\n", - " print: \u001b[36m[Function: print]\u001b[39m,\n", - " resources: \u001b[36m[Function: resources]\u001b[39m,\n", - " metrics: \u001b[36m[Function: metrics]\u001b[39m,\n", - " registerErrorBuilder: \u001b[36m[Function: registerErrorBuilder]\u001b[39m,\n", - " registerErrorClass: \u001b[36m[Function: registerErrorClass]\u001b[39m,\n", - " opresolve: \u001b[36m[Function: opresolve]\u001b[39m,\n", - " syncOpsCache: \u001b[36m[Function: syncOpsCache]\u001b[39m,\n", - " BadResource: \u001b[36m[Function: BadResource]\u001b[39m,\n", - " Interrupted: \u001b[36m[Function: Interrupted]\u001b[39m,\n", - " createPrepareStackTrace: \u001b[36m[Function: createPrepareStackTrace]\u001b[39m\n", - " },\n", " internal: \u001b[32mSymbol(Deno.internal)\u001b[39m,\n", " resources: \u001b[36m[Function: resources]\u001b[39m,\n", - " close: \u001b[36m[Function: close]\u001b[39m,\n", - " memoryUsage: \u001b[36m[Function: memoryUsage]\u001b[39m,\n", + " close: \u001b[36m[Function: op_close]\u001b[39m,\n", " metrics: \u001b[36m[Function: metrics]\u001b[39m,\n", - " test: \u001b[36m[Function: test]\u001b[39m,\n", - " Process: \u001b[36m[Function: Process]\u001b[39m,\n", + " Process: \u001b[36m[class Process]\u001b[39m,\n", " run: \u001b[36m[Function: run]\u001b[39m,\n", " isatty: \u001b[36m[Function: isatty]\u001b[39m,\n", " writeFileSync: \u001b[36m[Function: writeFileSync]\u001b[39m,\n", @@ -489,6 +482,7 @@ " makeTempDir: \u001b[36m[Function: makeTempDir]\u001b[39m,\n", " makeTempFileSync: \u001b[36m[Function: makeTempFileSync]\u001b[39m,\n", " makeTempFile: \u001b[36m[Function: makeTempFile]\u001b[39m,\n", + " memoryUsage: \u001b[36m[Function: memoryUsage]\u001b[39m,\n", " mkdirSync: \u001b[36m[Function: mkdirSync]\u001b[39m,\n", " mkdir: \u001b[36m[AsyncFunction: mkdir]\u001b[39m,\n", " chdir: \u001b[36m[Function: chdir]\u001b[39m,\n", @@ -503,10 +497,10 @@ " remove: \u001b[36m[AsyncFunction: remove]\u001b[39m,\n", " renameSync: \u001b[36m[Function: renameSync]\u001b[39m,\n", " rename: \u001b[36m[AsyncFunction: rename]\u001b[39m,\n", - " version: { deno: \u001b[32m\"1.17.0\"\u001b[39m, v8: \u001b[32m\"9.7.106.15\"\u001b[39m, typescript: \u001b[32m\"4.5.2\"\u001b[39m },\n", + " version: { deno: \u001b[32m\"1.36.3\"\u001b[39m, v8: \u001b[32m\"11.7.439.6\"\u001b[39m, typescript: \u001b[32m\"5.1.6\"\u001b[39m },\n", " build: {\n", - " target: \u001b[32m\"x86_64-apple-darwin\"\u001b[39m,\n", - " arch: \u001b[32m\"x86_64\"\u001b[39m,\n", + " target: \u001b[32m\"aarch64-apple-darwin\"\u001b[39m,\n", + " arch: \u001b[32m\"aarch64\"\u001b[39m,\n", " os: \u001b[32m\"darwin\"\u001b[39m,\n", " vendor: \u001b[32m\"apple\"\u001b[39m,\n", " env: \u001b[90mundefined\u001b[39m\n", @@ -519,26 +513,33 @@ " truncate: \u001b[36m[AsyncFunction: truncate]\u001b[39m,\n", " ftruncateSync: \u001b[36m[Function: ftruncateSync]\u001b[39m,\n", " ftruncate: \u001b[36m[AsyncFunction: ftruncate]\u001b[39m,\n", + " futime: \u001b[36m[AsyncFunction: futime]\u001b[39m,\n", + " futimeSync: \u001b[36m[Function: futimeSync]\u001b[39m,\n", " errors: {\n", - " NotFound: \u001b[36m[Function: NotFound]\u001b[39m,\n", - " PermissionDenied: \u001b[36m[Function: PermissionDenied]\u001b[39m,\n", - " ConnectionRefused: \u001b[36m[Function: ConnectionRefused]\u001b[39m,\n", - " ConnectionReset: \u001b[36m[Function: ConnectionReset]\u001b[39m,\n", - " ConnectionAborted: \u001b[36m[Function: ConnectionAborted]\u001b[39m,\n", - " NotConnected: \u001b[36m[Function: NotConnected]\u001b[39m,\n", - " AddrInUse: \u001b[36m[Function: AddrInUse]\u001b[39m,\n", - " AddrNotAvailable: \u001b[36m[Function: AddrNotAvailable]\u001b[39m,\n", - " BrokenPipe: \u001b[36m[Function: BrokenPipe]\u001b[39m,\n", - " AlreadyExists: \u001b[36m[Function: AlreadyExists]\u001b[39m,\n", - " InvalidData: \u001b[36m[Function: InvalidData]\u001b[39m,\n", - " TimedOut: \u001b[36m[Function: TimedOut]\u001b[39m,\n", - " Interrupted: \u001b[36m[Function: Interrupted]\u001b[39m,\n", - " WriteZero: \u001b[36m[Function: WriteZero]\u001b[39m,\n", - " UnexpectedEof: \u001b[36m[Function: UnexpectedEof]\u001b[39m,\n", - " BadResource: \u001b[36m[Function: BadResource]\u001b[39m,\n", - " Http: \u001b[36m[Function: Http]\u001b[39m,\n", - " Busy: \u001b[36m[Function: Busy]\u001b[39m,\n", - " NotSupported: \u001b[36m[Function: NotSupported]\u001b[39m\n", + " NotFound: \u001b[36m[class NotFound extends Error]\u001b[39m,\n", + " PermissionDenied: \u001b[36m[class PermissionDenied extends Error]\u001b[39m,\n", + " ConnectionRefused: \u001b[36m[class ConnectionRefused extends Error]\u001b[39m,\n", + " ConnectionReset: \u001b[36m[class ConnectionReset extends Error]\u001b[39m,\n", + " ConnectionAborted: \u001b[36m[class ConnectionAborted extends Error]\u001b[39m,\n", + " NotConnected: \u001b[36m[class NotConnected extends Error]\u001b[39m,\n", + " AddrInUse: \u001b[36m[class AddrInUse extends Error]\u001b[39m,\n", + " AddrNotAvailable: \u001b[36m[class AddrNotAvailable extends Error]\u001b[39m,\n", + " BrokenPipe: \u001b[36m[class BrokenPipe extends Error]\u001b[39m,\n", + " AlreadyExists: \u001b[36m[class AlreadyExists extends Error]\u001b[39m,\n", + " InvalidData: \u001b[36m[class InvalidData extends Error]\u001b[39m,\n", + " TimedOut: \u001b[36m[class TimedOut extends Error]\u001b[39m,\n", + " Interrupted: \u001b[36m[class Interrupted extends Error]\u001b[39m,\n", + " WriteZero: \u001b[36m[class WriteZero extends Error]\u001b[39m,\n", + " WouldBlock: \u001b[36m[class WouldBlock extends Error]\u001b[39m,\n", + " UnexpectedEof: \u001b[36m[class UnexpectedEof extends Error]\u001b[39m,\n", + " BadResource: \u001b[36m[class BadResource extends Error]\u001b[39m,\n", + " Http: \u001b[36m[class Http extends Error]\u001b[39m,\n", + " Busy: \u001b[36m[class Busy extends Error]\u001b[39m,\n", + " NotSupported: \u001b[36m[class NotSupported extends Error]\u001b[39m,\n", + " FilesystemLoop: \u001b[36m[class FilesystemLoop extends Error]\u001b[39m,\n", + " IsADirectory: \u001b[36m[class IsADirectory extends Error]\u001b[39m,\n", + " NetworkUnreachable: \u001b[36m[class NetworkUnreachable extends Error]\u001b[39m,\n", + " NotADirectory: \u001b[36m[class NotADirectory extends Error]\u001b[39m\n", " },\n", " customInspect: \u001b[32mSymbol(Deno.customInspect)\u001b[39m,\n", " inspect: \u001b[36m[Function: inspect]\u001b[39m,\n", @@ -546,11 +547,12 @@ " get: \u001b[36m[Function: getEnv]\u001b[39m,\n", " toObject: \u001b[36m[Function: toObject]\u001b[39m,\n", " set: \u001b[36m[Function: setEnv]\u001b[39m,\n", + " has: \u001b[36m[Function: has]\u001b[39m,\n", " delete: \u001b[36m[Function: deleteEnv]\u001b[39m\n", " },\n", " exit: \u001b[36m[Function: exit]\u001b[39m,\n", " execPath: \u001b[36m[Function: execPath]\u001b[39m,\n", - " Buffer: \u001b[36m[Function: Buffer]\u001b[39m,\n", + " Buffer: \u001b[36m[class Buffer]\u001b[39m,\n", " readAll: \u001b[36m[AsyncFunction: readAll]\u001b[39m,\n", " readAllSync: \u001b[36m[Function: readAllSync]\u001b[39m,\n", " writeAll: \u001b[36m[AsyncFunction: writeAll]\u001b[39m,\n", @@ -558,12 +560,20 @@ " copy: \u001b[36m[AsyncFunction: copy]\u001b[39m,\n", " iter: \u001b[36m[AsyncGeneratorFunction: iter]\u001b[39m,\n", " iterSync: \u001b[36m[GeneratorFunction: iterSync]\u001b[39m,\n", - " SeekMode: { \"0\": \u001b[32m\"Start\"\u001b[39m, \"1\": \u001b[32m\"Current\"\u001b[39m, \"2\": \u001b[32m\"End\"\u001b[39m, Start: \u001b[33m0\u001b[39m, Current: \u001b[33m1\u001b[39m, End: \u001b[33m2\u001b[39m },\n", + " SeekMode: {\n", + " \u001b[32m\"0\"\u001b[39m: \u001b[32m\"Start\"\u001b[39m,\n", + " \u001b[32m\"1\"\u001b[39m: \u001b[32m\"Current\"\u001b[39m,\n", + " \u001b[32m\"2\"\u001b[39m: \u001b[32m\"End\"\u001b[39m,\n", + " Start: \u001b[33m0\u001b[39m,\n", + " Current: \u001b[33m1\u001b[39m,\n", + " End: \u001b[33m2\u001b[39m\n", + " },\n", " read: \u001b[36m[AsyncFunction: read]\u001b[39m,\n", " readSync: \u001b[36m[Function: readSync]\u001b[39m,\n", " write: \u001b[36m[Function: write]\u001b[39m,\n", " writeSync: \u001b[36m[Function: writeSync]\u001b[39m,\n", - " File: \u001b[36m[Function: File]\u001b[39m,\n", + " File: \u001b[36m[class FsFile]\u001b[39m,\n", + " FsFile: \u001b[36m[class FsFile]\u001b[39m,\n", " open: \u001b[36m[AsyncFunction: open]\u001b[39m,\n", " openSync: \u001b[36m[Function: openSync]\u001b[39m,\n", " create: \u001b[36m[Function: create]\u001b[39m,\n", @@ -575,6 +585,7 @@ " seekSync: \u001b[36m[Function: seekSync]\u001b[39m,\n", " connect: \u001b[36m[AsyncFunction: connect]\u001b[39m,\n", " listen: \u001b[36m[Function: listen]\u001b[39m,\n", + " loadavg: \u001b[36m[Function: loadavg]\u001b[39m,\n", " connectTls: \u001b[36m[AsyncFunction: connectTls]\u001b[39m,\n", " listenTls: \u001b[36m[Function: listenTls]\u001b[39m,\n", " startTls: \u001b[36m[AsyncFunction: startTls]\u001b[39m,\n", @@ -590,26 +601,784 @@ " link: \u001b[36m[AsyncFunction: link]\u001b[39m,\n", " linkSync: \u001b[36m[Function: linkSync]\u001b[39m,\n", " permissions: Permissions {},\n", - " Permissions: \u001b[36m[Function: Permissions]\u001b[39m,\n", - " PermissionStatus: \u001b[36m[Function: PermissionStatus]\u001b[39m,\n", + " Permissions: \u001b[36m[class Permissions]\u001b[39m,\n", + " PermissionStatus: \u001b[36m[class PermissionStatus extends EventTarget]\u001b[39m,\n", " serveHttp: \u001b[36m[Function: serveHttp]\u001b[39m,\n", - " resolveDns: \u001b[36m[Function: resolveDns]\u001b[39m,\n", + " serve: \u001b[36m[Function: serve]\u001b[39m,\n", + " resolveDns: \u001b[36m[AsyncFunction: resolveDns]\u001b[39m,\n", " upgradeWebSocket: \u001b[36m[Function: upgradeWebSocket]\u001b[39m,\n", - " kill: \u001b[36m[Function: opKill]\u001b[39m,\n", - " pid: \u001b[33m79003\u001b[39m,\n", - " ppid: \u001b[33m78992\u001b[39m,\n", + " utime: \u001b[36m[AsyncFunction: utime]\u001b[39m,\n", + " utimeSync: \u001b[36m[Function: utimeSync]\u001b[39m,\n", + " kill: \u001b[36m[Function: kill]\u001b[39m,\n", + " addSignalListener: \u001b[36m[Function: addSignalListener]\u001b[39m,\n", + " removeSignalListener: \u001b[36m[Function: removeSignalListener]\u001b[39m,\n", + " refTimer: \u001b[36m[Function: refTimer]\u001b[39m,\n", + " unrefTimer: \u001b[36m[Function: unrefTimer]\u001b[39m,\n", + " osRelease: \u001b[36m[Function: osRelease]\u001b[39m,\n", + " osUptime: \u001b[36m[Function: osUptime]\u001b[39m,\n", + " hostname: \u001b[36m[Function: hostname]\u001b[39m,\n", + " systemMemoryInfo: \u001b[36m[Function: systemMemoryInfo]\u001b[39m,\n", + " networkInterfaces: \u001b[36m[Function: networkInterfaces]\u001b[39m,\n", + " consoleSize: \u001b[36m[Function: consoleSize]\u001b[39m,\n", + " gid: \u001b[36m[Function: gid]\u001b[39m,\n", + " uid: \u001b[36m[Function: uid]\u001b[39m,\n", + " Command: \u001b[36m[class Command]\u001b[39m,\n", + " ChildProcess: \u001b[36m[class ChildProcess]\u001b[39m,\n", + " bench: \u001b[36m[Function: bench]\u001b[39m,\n", + " test: \u001b[36m[Function: test]\u001b[39m,\n", + " pid: \u001b[33m85735\u001b[39m,\n", + " ppid: \u001b[36m[Getter/Setter]\u001b[39m,\n", " noColor: \u001b[33mfalse\u001b[39m,\n", " args: [],\n", - " mainModule: [Getter],\n", - " [Symbol(Deno.internal)]: {\n", - " Console: \u001b[36m[Function: Console]\u001b[39m,\n", + " mainModule: \u001b[36m[Getter/Setter]\u001b[39m,\n", + " listenDatagram: \u001b[36m[Function: listenDatagram]\u001b[39m,\n", + " umask: \u001b[36m[Function: umask]\u001b[39m,\n", + " HttpClient: \u001b[36m[class HttpClient]\u001b[39m,\n", + " createHttpClient: \u001b[36m[Function: createHttpClient]\u001b[39m,\n", + " http: [Module: null prototype] {\n", + " HttpConn: \u001b[36m[class HttpConn]\u001b[39m,\n", + " _ws: \u001b[32mSymbol(\"[[associated_ws]]\")\u001b[39m,\n", + " serve: \u001b[36m[Function: serve]\u001b[39m,\n", + " upgradeHttp: \u001b[36m[Function: upgradeHttp]\u001b[39m,\n", + " upgradeWebSocket: \u001b[36m[Function: upgradeWebSocket]\u001b[39m\n", + " },\n", + " dlopen: \u001b[36m[Function: dlopen]\u001b[39m,\n", + " UnsafeCallback: \u001b[36m[class UnsafeCallback]\u001b[39m,\n", + " UnsafePointer: \u001b[36m[class UnsafePointer]\u001b[39m,\n", + " UnsafePointerView: \u001b[36m[class UnsafePointerView]\u001b[39m,\n", + " UnsafeFnPointer: \u001b[36m[class UnsafeFnPointer]\u001b[39m,\n", + " flock: \u001b[36m[AsyncFunction: flock]\u001b[39m,\n", + " flockSync: \u001b[36m[Function: flockSync]\u001b[39m,\n", + " funlock: \u001b[36m[AsyncFunction: funlock]\u001b[39m,\n", + " funlockSync: \u001b[36m[Function: funlockSync]\u001b[39m,\n", + " upgradeHttp: \u001b[36m[Function: upgradeHttp]\u001b[39m,\n", + " openKv: \u001b[36m[AsyncFunction: openKv]\u001b[39m,\n", + " AtomicOperation: \u001b[36m[class AtomicOperation]\u001b[39m,\n", + " Kv: \u001b[36m[class Kv]\u001b[39m,\n", + " KvU64: \u001b[36m[class KvU64]\u001b[39m,\n", + " KvListIterator: \u001b[36m[class KvListIterator extends Object]\u001b[39m,\n", + " [\u001b[32mSymbol(Deno.internal)\u001b[39m]: {\n", + " Console: \u001b[36m[class Console]\u001b[39m,\n", " cssToAnsi: \u001b[36m[Function: cssToAnsi]\u001b[39m,\n", " inspectArgs: \u001b[36m[Function: inspectArgs]\u001b[39m,\n", " parseCss: \u001b[36m[Function: parseCss]\u001b[39m,\n", " parseCssColor: \u001b[36m[Function: parseCssColor]\u001b[39m,\n", " pathFromURL: \u001b[36m[Function: pathFromURL]\u001b[39m,\n", - " runTests: \u001b[36m[AsyncFunction: runTests]\u001b[39m,\n", - " enableTestSteps: \u001b[36m[Function: enableTestSteps]\u001b[39m\n", + " resourceForReadableStream: \u001b[36m[Function: resourceForReadableStream]\u001b[39m,\n", + " addTrailers: \u001b[36m[Function: addTrailers]\u001b[39m,\n", + " upgradeHttpRaw: \u001b[36m[Function: upgradeHttpRaw]\u001b[39m,\n", + " serveHttpOnListener: \u001b[36m[Function: serveHttpOnListener]\u001b[39m,\n", + " serveHttpOnConnection: \u001b[36m[Function: serveHttpOnConnection]\u001b[39m,\n", + " __initWorkerThreads: \u001b[36m[Function (anonymous)]\u001b[39m,\n", + " node: {\n", + " initialize: \u001b[36m[Function: initialize]\u001b[39m,\n", + " loadCjsModule: \u001b[36m[Function: loadCjsModule]\u001b[39m\n", + " },\n", + " buildCaseInsensitiveCommaValueFinder: \u001b[36m[Function: buildCaseInsensitiveCommaValueFinder]\u001b[39m,\n", + " core: {\n", + " ops: {\n", + " op_close: \u001b[36m[Function: op_close]\u001b[39m,\n", + " op_try_close: \u001b[36m[Function: op_try_close]\u001b[39m,\n", + " op_print: \u001b[36m[Function: op_print]\u001b[39m,\n", + " op_resources: \u001b[36m[Function: op_resources]\u001b[39m,\n", + " op_wasm_streaming_feed: \u001b[36m[Function: op_wasm_streaming_feed]\u001b[39m,\n", + " op_wasm_streaming_set_url: \u001b[36m[Function: op_wasm_streaming_set_url]\u001b[39m,\n", + " op_void_sync: \u001b[36m[Function: op_void_sync]\u001b[39m,\n", + " op_error_async: \u001b[36m[Function: op_error_async]\u001b[39m,\n", + " op_error_async_deferred: \u001b[36m[Function: op_error_async_deferred]\u001b[39m,\n", + " op_void_async: \u001b[36m[Function: op_void_async]\u001b[39m,\n", + " op_void_async_deferred: \u001b[36m[Function: op_void_async_deferred]\u001b[39m,\n", + " op_add: \u001b[36m[Function: op_add]\u001b[39m,\n", + " op_add_async: \u001b[36m[Function: op_add_async]\u001b[39m,\n", + " op_read: \u001b[36m[Function: op_read]\u001b[39m,\n", + " op_read_all: \u001b[36m[Function: op_read_all]\u001b[39m,\n", + " op_write: \u001b[36m[Function: op_write]\u001b[39m,\n", + " op_read_sync: \u001b[36m[Function: op_read_sync]\u001b[39m,\n", + " op_write_sync: \u001b[36m[Function: op_write_sync]\u001b[39m,\n", + " op_write_all: \u001b[36m[Function: op_write_all]\u001b[39m,\n", + " op_write_type_error: \u001b[36m[Function: op_write_type_error]\u001b[39m,\n", + " op_shutdown: \u001b[36m[Function: op_shutdown]\u001b[39m,\n", + " op_metrics: \u001b[36m[Function: op_metrics]\u001b[39m,\n", + " op_format_file_name: \u001b[36m[Function: op_format_file_name]\u001b[39m,\n", + " op_is_proxy: \u001b[36m[Function: op_is_proxy]\u001b[39m,\n", + " op_str_byte_length: \u001b[36m[Function: op_str_byte_length]\u001b[39m,\n", + " op_ref_op: \u001b[36m[Function: op_ref_op]\u001b[39m,\n", + " op_unref_op: \u001b[36m[Function: op_unref_op]\u001b[39m,\n", + " op_set_promise_reject_callback: \u001b[36m[Function: op_set_promise_reject_callback]\u001b[39m,\n", + " op_run_microtasks: \u001b[36m[Function: op_run_microtasks]\u001b[39m,\n", + " op_has_tick_scheduled: \u001b[36m[Function: op_has_tick_scheduled]\u001b[39m,\n", + " op_set_has_tick_scheduled: \u001b[36m[Function: op_set_has_tick_scheduled]\u001b[39m,\n", + " op_eval_context: \u001b[36m[Function: op_eval_context]\u001b[39m,\n", + " op_queue_microtask: \u001b[36m[Function: op_queue_microtask]\u001b[39m,\n", + " op_create_host_object: \u001b[36m[Function: op_create_host_object]\u001b[39m,\n", + " op_encode: \u001b[36m[Function: op_encode]\u001b[39m,\n", + " op_decode: \u001b[36m[Function: op_decode]\u001b[39m,\n", + " op_serialize: \u001b[36m[Function: op_serialize]\u001b[39m,\n", + " op_deserialize: \u001b[36m[Function: op_deserialize]\u001b[39m,\n", + " op_set_promise_hooks: \u001b[36m[Function: op_set_promise_hooks]\u001b[39m,\n", + " op_get_promise_details: \u001b[36m[Function: op_get_promise_details]\u001b[39m,\n", + " op_get_proxy_details: \u001b[36m[Function: op_get_proxy_details]\u001b[39m,\n", + " op_get_non_index_property_names: \u001b[36m[Function: op_get_non_index_property_names]\u001b[39m,\n", + " op_get_constructor_name: \u001b[36m[Function: op_get_constructor_name]\u001b[39m,\n", + " op_memory_usage: \u001b[36m[Function: op_memory_usage]\u001b[39m,\n", + " op_set_wasm_streaming_callback: \u001b[36m[Function: op_set_wasm_streaming_callback]\u001b[39m,\n", + " op_abort_wasm_streaming: \u001b[36m[Function: op_abort_wasm_streaming]\u001b[39m,\n", + " op_destructure_error: \u001b[36m[Function: op_destructure_error]\u001b[39m,\n", + " op_dispatch_exception: \u001b[36m[Function: op_dispatch_exception]\u001b[39m,\n", + " op_op_names: \u001b[36m[Function: op_op_names]\u001b[39m,\n", + " op_apply_source_map: \u001b[36m[Function: op_apply_source_map]\u001b[39m,\n", + " op_set_format_exception_callback: \u001b[36m[Function: op_set_format_exception_callback]\u001b[39m,\n", + " op_event_loop_has_more_work: \u001b[36m[Function: op_event_loop_has_more_work]\u001b[39m,\n", + " op_store_pending_promise_rejection: \u001b[36m[Function: op_store_pending_promise_rejection]\u001b[39m,\n", + " op_remove_pending_promise_rejection: \u001b[36m[Function: op_remove_pending_promise_rejection]\u001b[39m,\n", + " op_has_pending_promise_rejection: \u001b[36m[Function: op_has_pending_promise_rejection]\u001b[39m,\n", + " op_arraybuffer_was_detached: \u001b[36m[Function: op_arraybuffer_was_detached]\u001b[39m,\n", + " op_url_reparse: \u001b[36m[Function: op_url_reparse]\u001b[39m,\n", + " op_url_parse: \u001b[36m[Function: op_url_parse]\u001b[39m,\n", + " op_url_get_serialization: \u001b[36m[Function: op_url_get_serialization]\u001b[39m,\n", + " op_url_parse_with_base: \u001b[36m[Function: op_url_parse_with_base]\u001b[39m,\n", + " op_url_parse_search_params: \u001b[36m[Function: op_url_parse_search_params]\u001b[39m,\n", + " op_url_stringify_search_params: \u001b[36m[Function: op_url_stringify_search_params]\u001b[39m,\n", + " op_urlpattern_parse: \u001b[36m[Function: op_urlpattern_parse]\u001b[39m,\n", + " op_urlpattern_process_match_input: \u001b[36m[Function: op_urlpattern_process_match_input]\u001b[39m,\n", + " op_base64_decode: \u001b[36m[Function: op_base64_decode]\u001b[39m,\n", + " op_base64_encode: \u001b[36m[Function: op_base64_encode]\u001b[39m,\n", + " op_base64_atob: \u001b[36m[Function: op_base64_atob]\u001b[39m,\n", + " op_base64_btoa: \u001b[36m[Function: op_base64_btoa]\u001b[39m,\n", + " op_encoding_normalize_label: \u001b[36m[Function: op_encoding_normalize_label]\u001b[39m,\n", + " op_encoding_decode_single: \u001b[36m[Function: op_encoding_decode_single]\u001b[39m,\n", + " op_encoding_decode_utf8: \u001b[36m[Function: op_encoding_decode_utf8]\u001b[39m,\n", + " op_encoding_new_decoder: \u001b[36m[Function: op_encoding_new_decoder]\u001b[39m,\n", + " op_encoding_decode: \u001b[36m[Function: op_encoding_decode]\u001b[39m,\n", + " op_encoding_encode_into: \u001b[36m[Function: op_encoding_encode_into]\u001b[39m,\n", + " op_encode_binary_string: \u001b[36m[Function: op_encode_binary_string]\u001b[39m,\n", + " op_blob_create_part: \u001b[36m[Function: op_blob_create_part]\u001b[39m,\n", + " op_blob_slice_part: \u001b[36m[Function: op_blob_slice_part]\u001b[39m,\n", + " op_blob_read_part: \u001b[36m[Function: op_blob_read_part]\u001b[39m,\n", + " op_blob_remove_part: \u001b[36m[Function: op_blob_remove_part]\u001b[39m,\n", + " op_blob_create_object_url: \u001b[36m[Function: op_blob_create_object_url]\u001b[39m,\n", + " op_blob_revoke_object_url: \u001b[36m[Function: op_blob_revoke_object_url]\u001b[39m,\n", + " op_blob_from_object_url: \u001b[36m[Function: op_blob_from_object_url]\u001b[39m,\n", + " op_message_port_create_entangled: \u001b[36m[Function: op_message_port_create_entangled]\u001b[39m,\n", + " op_message_port_post_message: \u001b[36m[Function: op_message_port_post_message]\u001b[39m,\n", + " op_message_port_recv_message: \u001b[36m[Function: op_message_port_recv_message]\u001b[39m,\n", + " op_compression_new: \u001b[36m[Function: op_compression_new]\u001b[39m,\n", + " op_compression_write: \u001b[36m[Function: op_compression_write]\u001b[39m,\n", + " op_compression_finish: \u001b[36m[Function: op_compression_finish]\u001b[39m,\n", + " op_now: \u001b[36m[Function: op_now]\u001b[39m,\n", + " op_timer_handle: \u001b[36m[Function: op_timer_handle]\u001b[39m,\n", + " op_cancel_handle: \u001b[36m[Function: op_cancel_handle]\u001b[39m,\n", + " op_sleep: \u001b[36m[Function: op_sleep]\u001b[39m,\n", + " op_transfer_arraybuffer: \u001b[36m[Function: op_transfer_arraybuffer]\u001b[39m,\n", + " op_readable_stream_resource_allocate: \u001b[36m[Function: op_readable_stream_resource_allocate]\u001b[39m,\n", + " op_readable_stream_resource_get_sink: \u001b[36m[Function: op_readable_stream_resource_get_sink]\u001b[39m,\n", + " op_readable_stream_resource_write_error: \u001b[36m[Function: op_readable_stream_resource_write_error]\u001b[39m,\n", + " op_readable_stream_resource_write_buf: \u001b[36m[Function: op_readable_stream_resource_write_buf]\u001b[39m,\n", + " op_readable_stream_resource_close: \u001b[36m[Function: op_readable_stream_resource_close]\u001b[39m,\n", + " op_readable_stream_resource_await_close: \u001b[36m[Function: op_readable_stream_resource_await_close]\u001b[39m,\n", + " op_fetch: \u001b[36m[Function: op_fetch]\u001b[39m,\n", + " op_fetch_send: \u001b[36m[Function: op_fetch_send]\u001b[39m,\n", + " op_fetch_response_upgrade: \u001b[36m[Function: op_fetch_response_upgrade]\u001b[39m,\n", + " op_fetch_custom_client: \u001b[36m[Function: op_fetch_custom_client]\u001b[39m,\n", + " op_cache_storage_open: \u001b[36m[Function: op_cache_storage_open]\u001b[39m,\n", + " op_cache_storage_has: \u001b[36m[Function: op_cache_storage_has]\u001b[39m,\n", + " op_cache_storage_delete: \u001b[36m[Function: op_cache_storage_delete]\u001b[39m,\n", + " op_cache_put: \u001b[36m[Function: op_cache_put]\u001b[39m,\n", + " op_cache_put_finish: \u001b[36m[Function: op_cache_put_finish]\u001b[39m,\n", + " op_cache_match: \u001b[36m[Function: op_cache_match]\u001b[39m,\n", + " op_cache_delete: \u001b[36m[Function: op_cache_delete]\u001b[39m,\n", + " op_ws_check_permission_and_cancel_handle: \u001b[36m[Function: op_ws_check_permission_and_cancel_handle]\u001b[39m,\n", + " op_ws_create: \u001b[36m[Function: op_ws_create]\u001b[39m,\n", + " op_ws_close: \u001b[36m[Function: op_ws_close]\u001b[39m,\n", + " op_ws_next_event: \u001b[36m[Function: op_ws_next_event]\u001b[39m,\n", + " op_ws_get_buffer: \u001b[36m[Function: op_ws_get_buffer]\u001b[39m,\n", + " op_ws_get_buffer_as_string: \u001b[36m[Function: op_ws_get_buffer_as_string]\u001b[39m,\n", + " op_ws_get_error: \u001b[36m[Function: op_ws_get_error]\u001b[39m,\n", + " op_ws_send_binary: \u001b[36m[Function: op_ws_send_binary]\u001b[39m,\n", + " op_ws_send_text: \u001b[36m[Function: op_ws_send_text]\u001b[39m,\n", + " op_ws_send_binary_async: \u001b[36m[Function: op_ws_send_binary_async]\u001b[39m,\n", + " op_ws_send_text_async: \u001b[36m[Function: op_ws_send_text_async]\u001b[39m,\n", + " op_ws_send_ping: \u001b[36m[Function: op_ws_send_ping]\u001b[39m,\n", + " op_ws_send_pong: \u001b[36m[Function: op_ws_send_pong]\u001b[39m,\n", + " op_ws_get_buffered_amount: \u001b[36m[Function: op_ws_get_buffered_amount]\u001b[39m,\n", + " op_webstorage_length: \u001b[36m[Function: op_webstorage_length]\u001b[39m,\n", + " op_webstorage_key: \u001b[36m[Function: op_webstorage_key]\u001b[39m,\n", + " op_webstorage_set: \u001b[36m[Function: op_webstorage_set]\u001b[39m,\n", + " op_webstorage_get: \u001b[36m[Function: op_webstorage_get]\u001b[39m,\n", + " op_webstorage_remove: \u001b[36m[Function: op_webstorage_remove]\u001b[39m,\n", + " op_webstorage_clear: \u001b[36m[Function: op_webstorage_clear]\u001b[39m,\n", + " op_webstorage_iterate_keys: \u001b[36m[Function: op_webstorage_iterate_keys]\u001b[39m,\n", + " op_crypto_get_random_values: \u001b[36m[Function: op_crypto_get_random_values]\u001b[39m,\n", + " op_crypto_generate_key: \u001b[36m[Function: op_crypto_generate_key]\u001b[39m,\n", + " op_crypto_sign_key: \u001b[36m[Function: op_crypto_sign_key]\u001b[39m,\n", + " op_crypto_verify_key: \u001b[36m[Function: op_crypto_verify_key]\u001b[39m,\n", + " op_crypto_derive_bits: \u001b[36m[Function: op_crypto_derive_bits]\u001b[39m,\n", + " op_crypto_import_key: \u001b[36m[Function: op_crypto_import_key]\u001b[39m,\n", + " op_crypto_export_key: \u001b[36m[Function: op_crypto_export_key]\u001b[39m,\n", + " op_crypto_encrypt: \u001b[36m[Function: op_crypto_encrypt]\u001b[39m,\n", + " op_crypto_decrypt: \u001b[36m[Function: op_crypto_decrypt]\u001b[39m,\n", + " op_crypto_subtle_digest: \u001b[36m[Function: op_crypto_subtle_digest]\u001b[39m,\n", + " op_crypto_random_uuid: \u001b[36m[Function: op_crypto_random_uuid]\u001b[39m,\n", + " op_crypto_wrap_key: \u001b[36m[Function: op_crypto_wrap_key]\u001b[39m,\n", + " op_crypto_unwrap_key: \u001b[36m[Function: op_crypto_unwrap_key]\u001b[39m,\n", + " op_crypto_base64url_decode: \u001b[36m[Function: op_crypto_base64url_decode]\u001b[39m,\n", + " op_crypto_base64url_encode: \u001b[36m[Function: op_crypto_base64url_encode]\u001b[39m,\n", + " op_crypto_generate_x25519_keypair: \u001b[36m[Function: op_crypto_generate_x25519_keypair]\u001b[39m,\n", + " op_crypto_derive_bits_x25519: \u001b[36m[Function: op_crypto_derive_bits_x25519]\u001b[39m,\n", + " op_crypto_import_spki_x25519: \u001b[36m[Function: op_crypto_import_spki_x25519]\u001b[39m,\n", + " op_crypto_import_pkcs8_x25519: \u001b[36m[Function: op_crypto_import_pkcs8_x25519]\u001b[39m,\n", + " op_crypto_generate_ed25519_keypair: \u001b[36m[Function: op_crypto_generate_ed25519_keypair]\u001b[39m,\n", + " op_crypto_import_spki_ed25519: \u001b[36m[Function: op_crypto_import_spki_ed25519]\u001b[39m,\n", + " op_crypto_import_pkcs8_ed25519: \u001b[36m[Function: op_crypto_import_pkcs8_ed25519]\u001b[39m,\n", + " op_crypto_sign_ed25519: \u001b[36m[Function: op_crypto_sign_ed25519]\u001b[39m,\n", + " op_crypto_verify_ed25519: \u001b[36m[Function: op_crypto_verify_ed25519]\u001b[39m,\n", + " op_crypto_export_spki_ed25519: \u001b[36m[Function: op_crypto_export_spki_ed25519]\u001b[39m,\n", + " op_crypto_export_pkcs8_ed25519: \u001b[36m[Function: op_crypto_export_pkcs8_ed25519]\u001b[39m,\n", + " op_crypto_jwk_x_ed25519: \u001b[36m[Function: op_crypto_jwk_x_ed25519]\u001b[39m,\n", + " op_crypto_export_spki_x25519: \u001b[36m[Function: op_crypto_export_spki_x25519]\u001b[39m,\n", + " op_crypto_export_pkcs8_x25519: \u001b[36m[Function: op_crypto_export_pkcs8_x25519]\u001b[39m,\n", + " op_broadcast_subscribe: \u001b[36m[Function: op_broadcast_subscribe]\u001b[39m,\n", + " op_broadcast_unsubscribe: \u001b[36m[Function: op_broadcast_unsubscribe]\u001b[39m,\n", + " op_broadcast_send: \u001b[36m[Function: op_broadcast_send]\u001b[39m,\n", + " op_broadcast_recv: \u001b[36m[Function: op_broadcast_recv]\u001b[39m,\n", + " op_ffi_load: \u001b[36m[Function: op_ffi_load]\u001b[39m,\n", + " op_ffi_get_static: \u001b[36m[Function: op_ffi_get_static]\u001b[39m,\n", + " op_ffi_call_nonblocking: \u001b[36m[Function: op_ffi_call_nonblocking]\u001b[39m,\n", + " op_ffi_call_ptr: \u001b[36m[Function: op_ffi_call_ptr]\u001b[39m,\n", + " op_ffi_call_ptr_nonblocking: \u001b[36m[Function: op_ffi_call_ptr_nonblocking]\u001b[39m,\n", + " op_ffi_ptr_create: \u001b[36m[Function: op_ffi_ptr_create]\u001b[39m,\n", + " op_ffi_ptr_equals: \u001b[36m[Function: op_ffi_ptr_equals]\u001b[39m,\n", + " op_ffi_ptr_of: \u001b[36m[Function: op_ffi_ptr_of]\u001b[39m,\n", + " op_ffi_ptr_offset: \u001b[36m[Function: op_ffi_ptr_offset]\u001b[39m,\n", + " op_ffi_ptr_value: \u001b[36m[Function: op_ffi_ptr_value]\u001b[39m,\n", + " op_ffi_get_buf: \u001b[36m[Function: op_ffi_get_buf]\u001b[39m,\n", + " op_ffi_buf_copy_into: \u001b[36m[Function: op_ffi_buf_copy_into]\u001b[39m,\n", + " op_ffi_cstr_read: \u001b[36m[Function: op_ffi_cstr_read]\u001b[39m,\n", + " op_ffi_read_bool: \u001b[36m[Function: op_ffi_read_bool]\u001b[39m,\n", + " op_ffi_read_u8: \u001b[36m[Function: op_ffi_read_u8]\u001b[39m,\n", + " op_ffi_read_i8: \u001b[36m[Function: op_ffi_read_i8]\u001b[39m,\n", + " op_ffi_read_u16: \u001b[36m[Function: op_ffi_read_u16]\u001b[39m,\n", + " op_ffi_read_i16: \u001b[36m[Function: op_ffi_read_i16]\u001b[39m,\n", + " op_ffi_read_u32: \u001b[36m[Function: op_ffi_read_u32]\u001b[39m,\n", + " op_ffi_read_i32: \u001b[36m[Function: op_ffi_read_i32]\u001b[39m,\n", + " op_ffi_read_u64: \u001b[36m[Function: op_ffi_read_u64]\u001b[39m,\n", + " op_ffi_read_i64: \u001b[36m[Function: op_ffi_read_i64]\u001b[39m,\n", + " op_ffi_read_f32: \u001b[36m[Function: op_ffi_read_f32]\u001b[39m,\n", + " op_ffi_read_f64: \u001b[36m[Function: op_ffi_read_f64]\u001b[39m,\n", + " op_ffi_read_ptr: \u001b[36m[Function: op_ffi_read_ptr]\u001b[39m,\n", + " op_ffi_unsafe_callback_create: \u001b[36m[Function: op_ffi_unsafe_callback_create]\u001b[39m,\n", + " op_ffi_unsafe_callback_close: \u001b[36m[Function: op_ffi_unsafe_callback_close]\u001b[39m,\n", + " op_ffi_unsafe_callback_ref: \u001b[36m[Function: op_ffi_unsafe_callback_ref]\u001b[39m,\n", + " op_net_accept_tcp: \u001b[36m[Function: op_net_accept_tcp]\u001b[39m,\n", + " op_net_connect_tcp: \u001b[36m[Function: op_net_connect_tcp]\u001b[39m,\n", + " op_net_listen_tcp: \u001b[36m[Function: op_net_listen_tcp]\u001b[39m,\n", + " op_net_listen_udp: \u001b[36m[Function: op_net_listen_udp]\u001b[39m,\n", + " op_node_unstable_net_listen_udp: \u001b[36m[Function: op_node_unstable_net_listen_udp]\u001b[39m,\n", + " op_net_recv_udp: \u001b[36m[Function: op_net_recv_udp]\u001b[39m,\n", + " op_net_send_udp: \u001b[36m[Function: op_net_send_udp]\u001b[39m,\n", + " op_net_join_multi_v4_udp: \u001b[36m[Function: op_net_join_multi_v4_udp]\u001b[39m,\n", + " op_net_join_multi_v6_udp: \u001b[36m[Function: op_net_join_multi_v6_udp]\u001b[39m,\n", + " op_net_leave_multi_v4_udp: \u001b[36m[Function: op_net_leave_multi_v4_udp]\u001b[39m,\n", + " op_net_leave_multi_v6_udp: \u001b[36m[Function: op_net_leave_multi_v6_udp]\u001b[39m,\n", + " op_net_set_multi_loopback_udp: \u001b[36m[Function: op_net_set_multi_loopback_udp]\u001b[39m,\n", + " op_net_set_multi_ttl_udp: \u001b[36m[Function: op_net_set_multi_ttl_udp]\u001b[39m,\n", + " op_dns_resolve: \u001b[36m[Function: op_dns_resolve]\u001b[39m,\n", + " op_set_nodelay: \u001b[36m[Function: op_set_nodelay]\u001b[39m,\n", + " op_set_keepalive: \u001b[36m[Function: op_set_keepalive]\u001b[39m,\n", + " op_tls_start: \u001b[36m[Function: op_tls_start]\u001b[39m,\n", + " op_net_connect_tls: \u001b[36m[Function: op_net_connect_tls]\u001b[39m,\n", + " op_net_listen_tls: \u001b[36m[Function: op_net_listen_tls]\u001b[39m,\n", + " op_net_accept_tls: \u001b[36m[Function: op_net_accept_tls]\u001b[39m,\n", + " op_tls_handshake: \u001b[36m[Function: op_tls_handshake]\u001b[39m,\n", + " op_net_accept_unix: \u001b[36m[Function: op_net_accept_unix]\u001b[39m,\n", + " op_net_connect_unix: \u001b[36m[Function: op_net_connect_unix]\u001b[39m,\n", + " op_net_listen_unix: \u001b[36m[Function: op_net_listen_unix]\u001b[39m,\n", + " op_net_listen_unixpacket: \u001b[36m[Function: op_net_listen_unixpacket]\u001b[39m,\n", + " op_node_unstable_net_listen_unixpacket: \u001b[36m[Function: op_node_unstable_net_listen_unixpacket]\u001b[39m,\n", + " op_net_recv_unixpacket: \u001b[36m[Function: op_net_recv_unixpacket]\u001b[39m,\n", + " op_net_send_unixpacket: \u001b[36m[Function: op_net_send_unixpacket]\u001b[39m,\n", + " op_kv_database_open: \u001b[36m[Function: op_kv_database_open]\u001b[39m,\n", + " op_kv_snapshot_read: \u001b[36m[Function: op_kv_snapshot_read]\u001b[39m,\n", + " op_kv_atomic_write: \u001b[36m[Function: op_kv_atomic_write]\u001b[39m,\n", + " op_kv_encode_cursor: \u001b[36m[Function: op_kv_encode_cursor]\u001b[39m,\n", + " op_kv_dequeue_next_message: \u001b[36m[Function: op_kv_dequeue_next_message]\u001b[39m,\n", + " op_kv_finish_dequeued_message: \u001b[36m[Function: op_kv_finish_dequeued_message]\u001b[39m,\n", + " op_napi_open: \u001b[36m[Function: op_napi_open]\u001b[39m,\n", + " op_http_accept: \u001b[36m[Function: op_http_accept]\u001b[39m,\n", + " op_http_headers: \u001b[36m[Function: op_http_headers]\u001b[39m,\n", + " op_http_shutdown: \u001b[36m[Function: op_http_shutdown]\u001b[39m,\n", + " op_http_upgrade_websocket: \u001b[36m[Function: op_http_upgrade_websocket]\u001b[39m,\n", + " op_http_websocket_accept_header: \u001b[36m[Function: op_http_websocket_accept_header]\u001b[39m,\n", + " op_http_write_headers: \u001b[36m[Function: op_http_write_headers]\u001b[39m,\n", + " op_http_write_resource: \u001b[36m[Function: op_http_write_resource]\u001b[39m,\n", + " op_http_write: \u001b[36m[Function: op_http_write]\u001b[39m,\n", + " op_http_get_request_header: \u001b[36m[Function: op_http_get_request_header]\u001b[39m,\n", + " op_http_get_request_headers: \u001b[36m[Function: op_http_get_request_headers]\u001b[39m,\n", + " op_http_get_request_method_and_url: \u001b[36m[Function: op_http_get_request_method_and_url]\u001b[39m,\n", + " op_http_read_request_body: \u001b[36m[Function: op_http_read_request_body]\u001b[39m,\n", + " op_http_serve_on: \u001b[36m[Function: op_http_serve_on]\u001b[39m,\n", + " op_http_serve: \u001b[36m[Function: op_http_serve]\u001b[39m,\n", + " op_http_set_promise_complete: \u001b[36m[Function: op_http_set_promise_complete]\u001b[39m,\n", + " op_http_set_response_body_bytes: \u001b[36m[Function: op_http_set_response_body_bytes]\u001b[39m,\n", + " op_http_set_response_body_resource: \u001b[36m[Function: op_http_set_response_body_resource]\u001b[39m,\n", + " op_http_set_response_body_text: \u001b[36m[Function: op_http_set_response_body_text]\u001b[39m,\n", + " op_http_set_response_header: \u001b[36m[Function: op_http_set_response_header]\u001b[39m,\n", + " op_http_set_response_headers: \u001b[36m[Function: op_http_set_response_headers]\u001b[39m,\n", + " op_http_set_response_trailers: \u001b[36m[Function: op_http_set_response_trailers]\u001b[39m,\n", + " op_http_track: \u001b[36m[Function: op_http_track]\u001b[39m,\n", + " op_http_upgrade_websocket_next: \u001b[36m[Function: op_http_upgrade_websocket_next]\u001b[39m,\n", + " op_http_upgrade_raw: \u001b[36m[Function: op_http_upgrade_raw]\u001b[39m,\n", + " op_raw_write_vectored: \u001b[36m[Function: op_raw_write_vectored]\u001b[39m,\n", + " op_can_write_vectored: \u001b[36m[Function: op_can_write_vectored]\u001b[39m,\n", + " op_http_try_wait: \u001b[36m[Function: op_http_try_wait]\u001b[39m,\n", + " op_http_wait: \u001b[36m[Function: op_http_wait]\u001b[39m,\n", + " op_fs_cwd: \u001b[36m[Function: op_fs_cwd]\u001b[39m,\n", + " op_fs_umask: \u001b[36m[Function: op_fs_umask]\u001b[39m,\n", + " op_fs_chdir: \u001b[36m[Function: op_fs_chdir]\u001b[39m,\n", + " op_fs_open_sync: \u001b[36m[Function: op_fs_open_sync]\u001b[39m,\n", + " op_fs_open_async: \u001b[36m[Function: op_fs_open_async]\u001b[39m,\n", + " op_fs_mkdir_sync: \u001b[36m[Function: op_fs_mkdir_sync]\u001b[39m,\n", + " op_fs_mkdir_async: \u001b[36m[Function: op_fs_mkdir_async]\u001b[39m,\n", + " op_fs_chmod_sync: \u001b[36m[Function: op_fs_chmod_sync]\u001b[39m,\n", + " op_fs_chmod_async: \u001b[36m[Function: op_fs_chmod_async]\u001b[39m,\n", + " op_fs_chown_sync: \u001b[36m[Function: op_fs_chown_sync]\u001b[39m,\n", + " op_fs_chown_async: \u001b[36m[Function: op_fs_chown_async]\u001b[39m,\n", + " op_fs_remove_sync: \u001b[36m[Function: op_fs_remove_sync]\u001b[39m,\n", + " op_fs_remove_async: \u001b[36m[Function: op_fs_remove_async]\u001b[39m,\n", + " op_fs_copy_file_sync: \u001b[36m[Function: op_fs_copy_file_sync]\u001b[39m,\n", + " op_fs_copy_file_async: \u001b[36m[Function: op_fs_copy_file_async]\u001b[39m,\n", + " op_fs_stat_sync: \u001b[36m[Function: op_fs_stat_sync]\u001b[39m,\n", + " op_fs_stat_async: \u001b[36m[Function: op_fs_stat_async]\u001b[39m,\n", + " op_fs_lstat_sync: \u001b[36m[Function: op_fs_lstat_sync]\u001b[39m,\n", + " op_fs_lstat_async: \u001b[36m[Function: op_fs_lstat_async]\u001b[39m,\n", + " op_fs_realpath_sync: \u001b[36m[Function: op_fs_realpath_sync]\u001b[39m,\n", + " op_fs_realpath_async: \u001b[36m[Function: op_fs_realpath_async]\u001b[39m,\n", + " op_fs_read_dir_sync: \u001b[36m[Function: op_fs_read_dir_sync]\u001b[39m,\n", + " op_fs_read_dir_async: \u001b[36m[Function: op_fs_read_dir_async]\u001b[39m,\n", + " op_fs_rename_sync: \u001b[36m[Function: op_fs_rename_sync]\u001b[39m,\n", + " op_fs_rename_async: \u001b[36m[Function: op_fs_rename_async]\u001b[39m,\n", + " op_fs_link_sync: \u001b[36m[Function: op_fs_link_sync]\u001b[39m,\n", + " op_fs_link_async: \u001b[36m[Function: op_fs_link_async]\u001b[39m,\n", + " op_fs_symlink_sync: \u001b[36m[Function: op_fs_symlink_sync]\u001b[39m,\n", + " op_fs_symlink_async: \u001b[36m[Function: op_fs_symlink_async]\u001b[39m,\n", + " op_fs_read_link_sync: \u001b[36m[Function: op_fs_read_link_sync]\u001b[39m,\n", + " op_fs_read_link_async: \u001b[36m[Function: op_fs_read_link_async]\u001b[39m,\n", + " op_fs_truncate_sync: \u001b[36m[Function: op_fs_truncate_sync]\u001b[39m,\n", + " op_fs_truncate_async: \u001b[36m[Function: op_fs_truncate_async]\u001b[39m,\n", + " op_fs_utime_sync: \u001b[36m[Function: op_fs_utime_sync]\u001b[39m,\n", + " op_fs_utime_async: \u001b[36m[Function: op_fs_utime_async]\u001b[39m,\n", + " op_fs_make_temp_dir_sync: \u001b[36m[Function: op_fs_make_temp_dir_sync]\u001b[39m,\n", + " op_fs_make_temp_dir_async: \u001b[36m[Function: op_fs_make_temp_dir_async]\u001b[39m,\n", + " op_fs_make_temp_file_sync: \u001b[36m[Function: op_fs_make_temp_file_sync]\u001b[39m,\n", + " op_fs_make_temp_file_async: \u001b[36m[Function: op_fs_make_temp_file_async]\u001b[39m,\n", + " op_fs_write_file_sync: \u001b[36m[Function: op_fs_write_file_sync]\u001b[39m,\n", + " op_fs_write_file_async: \u001b[36m[Function: op_fs_write_file_async]\u001b[39m,\n", + " op_fs_read_file_sync: \u001b[36m[Function: op_fs_read_file_sync]\u001b[39m,\n", + " op_fs_read_file_async: \u001b[36m[Function: op_fs_read_file_async]\u001b[39m,\n", + " op_fs_read_file_text_sync: \u001b[36m[Function: op_fs_read_file_text_sync]\u001b[39m,\n", + " op_fs_read_file_text_async: \u001b[36m[Function: op_fs_read_file_text_async]\u001b[39m,\n", + " op_fs_seek_sync: \u001b[36m[Function: op_fs_seek_sync]\u001b[39m,\n", + " op_fs_seek_async: \u001b[36m[Function: op_fs_seek_async]\u001b[39m,\n", + " op_fs_fdatasync_sync: \u001b[36m[Function: op_fs_fdatasync_sync]\u001b[39m,\n", + " op_fs_fdatasync_async: \u001b[36m[Function: op_fs_fdatasync_async]\u001b[39m,\n", + " op_fs_fsync_sync: \u001b[36m[Function: op_fs_fsync_sync]\u001b[39m,\n", + " op_fs_fsync_async: \u001b[36m[Function: op_fs_fsync_async]\u001b[39m,\n", + " op_fs_fstat_sync: \u001b[36m[Function: op_fs_fstat_sync]\u001b[39m,\n", + " op_fs_fstat_async: \u001b[36m[Function: op_fs_fstat_async]\u001b[39m,\n", + " op_fs_flock_sync: \u001b[36m[Function: op_fs_flock_sync]\u001b[39m,\n", + " op_fs_flock_async: \u001b[36m[Function: op_fs_flock_async]\u001b[39m,\n", + " op_fs_funlock_sync: \u001b[36m[Function: op_fs_funlock_sync]\u001b[39m,\n", + " op_fs_funlock_async: \u001b[36m[Function: op_fs_funlock_async]\u001b[39m,\n", + " op_fs_ftruncate_sync: \u001b[36m[Function: op_fs_ftruncate_sync]\u001b[39m,\n", + " op_fs_ftruncate_async: \u001b[36m[Function: op_fs_ftruncate_async]\u001b[39m,\n", + " op_fs_futime_sync: \u001b[36m[Function: op_fs_futime_sync]\u001b[39m,\n", + " op_fs_futime_async: \u001b[36m[Function: op_fs_futime_async]\u001b[39m,\n", + " op_node_create_decipheriv: \u001b[36m[Function: op_node_create_decipheriv]\u001b[39m,\n", + " op_node_cipheriv_encrypt: \u001b[36m[Function: op_node_cipheriv_encrypt]\u001b[39m,\n", + " op_node_cipheriv_final: \u001b[36m[Function: op_node_cipheriv_final]\u001b[39m,\n", + " op_node_create_cipheriv: \u001b[36m[Function: op_node_create_cipheriv]\u001b[39m,\n", + " op_node_create_hash: \u001b[36m[Function: op_node_create_hash]\u001b[39m,\n", + " op_node_get_hashes: \u001b[36m[Function: op_node_get_hashes]\u001b[39m,\n", + " op_node_decipheriv_decrypt: \u001b[36m[Function: op_node_decipheriv_decrypt]\u001b[39m,\n", + " op_node_decipheriv_final: \u001b[36m[Function: op_node_decipheriv_final]\u001b[39m,\n", + " op_node_hash_update: \u001b[36m[Function: op_node_hash_update]\u001b[39m,\n", + " op_node_hash_update_str: \u001b[36m[Function: op_node_hash_update_str]\u001b[39m,\n", + " op_node_hash_digest: \u001b[36m[Function: op_node_hash_digest]\u001b[39m,\n", + " op_node_hash_digest_hex: \u001b[36m[Function: op_node_hash_digest_hex]\u001b[39m,\n", + " op_node_hash_clone: \u001b[36m[Function: op_node_hash_clone]\u001b[39m,\n", + " op_node_private_encrypt: \u001b[36m[Function: op_node_private_encrypt]\u001b[39m,\n", + " op_node_private_decrypt: \u001b[36m[Function: op_node_private_decrypt]\u001b[39m,\n", + " op_node_public_encrypt: \u001b[36m[Function: op_node_public_encrypt]\u001b[39m,\n", + " op_node_check_prime: \u001b[36m[Function: op_node_check_prime]\u001b[39m,\n", + " op_node_check_prime_async: \u001b[36m[Function: op_node_check_prime_async]\u001b[39m,\n", + " op_node_check_prime_bytes: \u001b[36m[Function: op_node_check_prime_bytes]\u001b[39m,\n", + " op_node_check_prime_bytes_async: \u001b[36m[Function: op_node_check_prime_bytes_async]\u001b[39m,\n", + " op_node_gen_prime: \u001b[36m[Function: op_node_gen_prime]\u001b[39m,\n", + " op_node_gen_prime_async: \u001b[36m[Function: op_node_gen_prime_async]\u001b[39m,\n", + " op_node_pbkdf2: \u001b[36m[Function: op_node_pbkdf2]\u001b[39m,\n", + " op_node_pbkdf2_async: \u001b[36m[Function: op_node_pbkdf2_async]\u001b[39m,\n", + " op_node_hkdf: \u001b[36m[Function: op_node_hkdf]\u001b[39m,\n", + " op_node_hkdf_async: \u001b[36m[Function: op_node_hkdf_async]\u001b[39m,\n", + " op_node_generate_secret: \u001b[36m[Function: op_node_generate_secret]\u001b[39m,\n", + " op_node_generate_secret_async: \u001b[36m[Function: op_node_generate_secret_async]\u001b[39m,\n", + " op_node_sign: \u001b[36m[Function: op_node_sign]\u001b[39m,\n", + " op_node_generate_rsa: \u001b[36m[Function: op_node_generate_rsa]\u001b[39m,\n", + " op_node_generate_rsa_async: \u001b[36m[Function: op_node_generate_rsa_async]\u001b[39m,\n", + " op_node_dsa_generate: \u001b[36m[Function: op_node_dsa_generate]\u001b[39m,\n", + " op_node_dsa_generate_async: \u001b[36m[Function: op_node_dsa_generate_async]\u001b[39m,\n", + " op_node_ec_generate: \u001b[36m[Function: op_node_ec_generate]\u001b[39m,\n", + " op_node_ec_generate_async: \u001b[36m[Function: op_node_ec_generate_async]\u001b[39m,\n", + " op_node_ed25519_generate: \u001b[36m[Function: op_node_ed25519_generate]\u001b[39m,\n", + " op_node_ed25519_generate_async: \u001b[36m[Function: op_node_ed25519_generate_async]\u001b[39m,\n", + " op_node_x25519_generate: \u001b[36m[Function: op_node_x25519_generate]\u001b[39m,\n", + " op_node_x25519_generate_async: \u001b[36m[Function: op_node_x25519_generate_async]\u001b[39m,\n", + " op_node_dh_generate_group: \u001b[36m[Function: op_node_dh_generate_group]\u001b[39m,\n", + " op_node_dh_generate_group_async: \u001b[36m[Function: op_node_dh_generate_group_async]\u001b[39m,\n", + " op_node_dh_generate: \u001b[36m[Function: op_node_dh_generate]\u001b[39m,\n", + " op_node_dh_generate2: \u001b[36m[Function: op_node_dh_generate2]\u001b[39m,\n", + " op_node_dh_compute_secret: \u001b[36m[Function: op_node_dh_compute_secret]\u001b[39m,\n", + " op_node_dh_generate_async: \u001b[36m[Function: op_node_dh_generate_async]\u001b[39m,\n", + " op_node_verify: \u001b[36m[Function: op_node_verify]\u001b[39m,\n", + " op_node_random_int: \u001b[36m[Function: op_node_random_int]\u001b[39m,\n", + " op_node_scrypt_sync: \u001b[36m[Function: op_node_scrypt_sync]\u001b[39m,\n", + " op_node_scrypt_async: \u001b[36m[Function: op_node_scrypt_async]\u001b[39m,\n", + " op_node_ecdh_generate_keys: \u001b[36m[Function: op_node_ecdh_generate_keys]\u001b[39m,\n", + " op_node_ecdh_compute_secret: \u001b[36m[Function: op_node_ecdh_compute_secret]\u001b[39m,\n", + " op_node_ecdh_compute_public_key: \u001b[36m[Function: op_node_ecdh_compute_public_key]\u001b[39m,\n", + " op_node_x509_parse: \u001b[36m[Function: op_node_x509_parse]\u001b[39m,\n", + " op_node_x509_ca: \u001b[36m[Function: op_node_x509_ca]\u001b[39m,\n", + " op_node_x509_check_email: \u001b[36m[Function: op_node_x509_check_email]\u001b[39m,\n", + " op_node_x509_fingerprint: \u001b[36m[Function: op_node_x509_fingerprint]\u001b[39m,\n", + " op_node_x509_fingerprint256: \u001b[36m[Function: op_node_x509_fingerprint256]\u001b[39m,\n", + " op_node_x509_fingerprint512: \u001b[36m[Function: op_node_x509_fingerprint512]\u001b[39m,\n", + " op_node_x509_get_issuer: \u001b[36m[Function: op_node_x509_get_issuer]\u001b[39m,\n", + " op_node_x509_get_subject: \u001b[36m[Function: op_node_x509_get_subject]\u001b[39m,\n", + " op_node_x509_get_valid_from: \u001b[36m[Function: op_node_x509_get_valid_from]\u001b[39m,\n", + " op_node_x509_get_valid_to: \u001b[36m[Function: op_node_x509_get_valid_to]\u001b[39m,\n", + " op_node_x509_get_serial_number: \u001b[36m[Function: op_node_x509_get_serial_number]\u001b[39m,\n", + " op_node_x509_key_usage: \u001b[36m[Function: op_node_x509_key_usage]\u001b[39m,\n", + " op_node_sys_to_uv_error: \u001b[36m[Function: op_node_sys_to_uv_error]\u001b[39m,\n", + " op_v8_cached_data_version_tag: \u001b[36m[Function: op_v8_cached_data_version_tag]\u001b[39m,\n", + " op_v8_get_heap_statistics: \u001b[36m[Function: op_v8_get_heap_statistics]\u001b[39m,\n", + " op_node_idna_domain_to_ascii: \u001b[36m[Function: op_node_idna_domain_to_ascii]\u001b[39m,\n", + " op_node_idna_domain_to_unicode: \u001b[36m[Function: op_node_idna_domain_to_unicode]\u001b[39m,\n", + " op_node_idna_punycode_decode: \u001b[36m[Function: op_node_idna_punycode_decode]\u001b[39m,\n", + " op_node_idna_punycode_encode: \u001b[36m[Function: op_node_idna_punycode_encode]\u001b[39m,\n", + " op_zlib_new: \u001b[36m[Function: op_zlib_new]\u001b[39m,\n", + " op_zlib_close: \u001b[36m[Function: op_zlib_close]\u001b[39m,\n", + " op_zlib_close_if_pending: \u001b[36m[Function: op_zlib_close_if_pending]\u001b[39m,\n", + " op_zlib_write: \u001b[36m[Function: op_zlib_write]\u001b[39m,\n", + " op_zlib_write_async: \u001b[36m[Function: op_zlib_write_async]\u001b[39m,\n", + " op_zlib_init: \u001b[36m[Function: op_zlib_init]\u001b[39m,\n", + " op_zlib_reset: \u001b[36m[Function: op_zlib_reset]\u001b[39m,\n", + " op_brotli_compress: \u001b[36m[Function: op_brotli_compress]\u001b[39m,\n", + " op_brotli_compress_async: \u001b[36m[Function: op_brotli_compress_async]\u001b[39m,\n", + " op_create_brotli_compress: \u001b[36m[Function: op_create_brotli_compress]\u001b[39m,\n", + " op_brotli_compress_stream: \u001b[36m[Function: op_brotli_compress_stream]\u001b[39m,\n", + " op_brotli_compress_stream_end: \u001b[36m[Function: op_brotli_compress_stream_end]\u001b[39m,\n", + " op_brotli_decompress: \u001b[36m[Function: op_brotli_decompress]\u001b[39m,\n", + " op_brotli_decompress_async: \u001b[36m[Function: op_brotli_decompress_async]\u001b[39m,\n", + " op_create_brotli_decompress: \u001b[36m[Function: op_create_brotli_decompress]\u001b[39m,\n", + " op_brotli_decompress_stream: \u001b[36m[Function: op_brotli_decompress_stream]\u001b[39m,\n", + " op_brotli_decompress_stream_end: \u001b[36m[Function: op_brotli_decompress_stream_end]\u001b[39m,\n", + " op_node_http_request: \u001b[36m[Function: op_node_http_request]\u001b[39m,\n", + " op_node_os_get_priority: \u001b[36m[Function: op_node_os_get_priority]\u001b[39m,\n", + " op_node_os_set_priority: \u001b[36m[Function: op_node_os_set_priority]\u001b[39m,\n", + " op_node_os_username: \u001b[36m[Function: op_node_os_username]\u001b[39m,\n", + " op_node_build_os: \u001b[36m[Function: op_node_build_os]\u001b[39m,\n", + " op_is_any_arraybuffer: \u001b[36m[Function: op_is_any_arraybuffer]\u001b[39m,\n", + " op_node_is_promise_rejected: \u001b[36m[Function: op_node_is_promise_rejected]\u001b[39m,\n", + " op_require_init_paths: \u001b[36m[Function: op_require_init_paths]\u001b[39m,\n", + " op_require_node_module_paths: \u001b[36m[Function: op_require_node_module_paths]\u001b[39m,\n", + " op_require_proxy_path: \u001b[36m[Function: op_require_proxy_path]\u001b[39m,\n", + " op_require_is_deno_dir_package: \u001b[36m[Function: op_require_is_deno_dir_package]\u001b[39m,\n", + " op_require_resolve_deno_dir: \u001b[36m[Function: op_require_resolve_deno_dir]\u001b[39m,\n", + " op_require_is_request_relative: \u001b[36m[Function: op_require_is_request_relative]\u001b[39m,\n", + " op_require_resolve_lookup_paths: \u001b[36m[Function: op_require_resolve_lookup_paths]\u001b[39m,\n", + " op_require_try_self_parent_path: \u001b[36m[Function: op_require_try_self_parent_path]\u001b[39m,\n", + " op_require_try_self: \u001b[36m[Function: op_require_try_self]\u001b[39m,\n", + " op_require_real_path: \u001b[36m[Function: op_require_real_path]\u001b[39m,\n", + " op_require_path_is_absolute: \u001b[36m[Function: op_require_path_is_absolute]\u001b[39m,\n", + " op_require_path_dirname: \u001b[36m[Function: op_require_path_dirname]\u001b[39m,\n", + " op_require_stat: \u001b[36m[Function: op_require_stat]\u001b[39m,\n", + " op_require_path_resolve: \u001b[36m[Function: op_require_path_resolve]\u001b[39m,\n", + " op_require_path_basename: \u001b[36m[Function: op_require_path_basename]\u001b[39m,\n", + " op_require_read_file: \u001b[36m[Function: op_require_read_file]\u001b[39m,\n", + " op_require_as_file_path: \u001b[36m[Function: op_require_as_file_path]\u001b[39m,\n", + " op_require_resolve_exports: \u001b[36m[Function: op_require_resolve_exports]\u001b[39m,\n", + " op_require_read_closest_package_json: \u001b[36m[Function: op_require_read_closest_package_json]\u001b[39m,\n", + " op_require_read_package_scope: \u001b[36m[Function: op_require_read_package_scope]\u001b[39m,\n", + " op_require_package_imports_resolve: \u001b[36m[Function: op_require_package_imports_resolve]\u001b[39m,\n", + " op_require_break_on_next_statement: \u001b[36m[Function: op_require_break_on_next_statement]\u001b[39m,\n", + " op_main_module: \u001b[36m[Function: op_main_module]\u001b[39m,\n", + " op_ppid: \u001b[36m[Function: op_ppid]\u001b[39m,\n", + " op_create_worker: \u001b[36m[Function: op_create_worker]\u001b[39m,\n", + " op_host_terminate_worker: \u001b[36m[Function: op_host_terminate_worker]\u001b[39m,\n", + " op_host_post_message: \u001b[36m[Function: op_host_post_message]\u001b[39m,\n", + " op_host_recv_ctrl: \u001b[36m[Function: fn]\u001b[39m,\n", + " op_host_recv_message: \u001b[36m[Function: fn]\u001b[39m,\n", + " op_fs_events_open: \u001b[36m[Function: op_fs_events_open]\u001b[39m,\n", + " op_fs_events_poll: \u001b[36m[Function: fn]\u001b[39m,\n", + " op_env: \u001b[36m[Function: op_env]\u001b[39m,\n", + " op_exec_path: \u001b[36m[Function: op_exec_path]\u001b[39m,\n", + " op_exit: \u001b[36m[Function: op_exit]\u001b[39m,\n", + " op_delete_env: \u001b[36m[Function: op_delete_env]\u001b[39m,\n", + " op_get_env: \u001b[36m[Function: op_get_env]\u001b[39m,\n", + " op_gid: \u001b[36m[Function: op_gid]\u001b[39m,\n", + " op_hostname: \u001b[36m[Function: op_hostname]\u001b[39m,\n", + " op_loadavg: \u001b[36m[Function: op_loadavg]\u001b[39m,\n", + " op_network_interfaces: \u001b[36m[Function: op_network_interfaces]\u001b[39m,\n", + " op_os_release: \u001b[36m[Function: op_os_release]\u001b[39m,\n", + " op_os_uptime: \u001b[36m[Function: op_os_uptime]\u001b[39m,\n", + " op_node_unstable_os_uptime: \u001b[36m[Function: op_node_unstable_os_uptime]\u001b[39m,\n", + " op_set_env: \u001b[36m[Function: op_set_env]\u001b[39m,\n", + " op_set_exit_code: \u001b[36m[Function: op_set_exit_code]\u001b[39m,\n", + " op_system_memory_info: \u001b[36m[Function: op_system_memory_info]\u001b[39m,\n", + " op_uid: \u001b[36m[Function: op_uid]\u001b[39m,\n", + " op_runtime_memory_usage: \u001b[36m[Function: op_runtime_memory_usage]\u001b[39m,\n", + " op_query_permission: \u001b[36m[Function: op_query_permission]\u001b[39m,\n", + " op_revoke_permission: \u001b[36m[Function: op_revoke_permission]\u001b[39m,\n", + " op_request_permission: \u001b[36m[Function: op_request_permission]\u001b[39m,\n", + " op_spawn_child: \u001b[36m[Function: op_spawn_child]\u001b[39m,\n", + " op_spawn_wait: \u001b[36m[Function: fn]\u001b[39m,\n", + " op_spawn_sync: \u001b[36m[Function: op_spawn_sync]\u001b[39m,\n", + " op_spawn_kill: \u001b[36m[Function: op_spawn_kill]\u001b[39m,\n", + " op_run: \u001b[36m[Function: op_run]\u001b[39m,\n", + " op_run_status: \u001b[36m[Function: fn]\u001b[39m,\n", + " op_kill: \u001b[36m[Function: op_kill]\u001b[39m,\n", + " op_signal_bind: \u001b[36m[Function: op_signal_bind]\u001b[39m,\n", + " op_signal_unbind: \u001b[36m[Function: op_signal_unbind]\u001b[39m,\n", + " op_signal_poll: \u001b[36m[Function: fn]\u001b[39m,\n", + " op_stdin_set_raw: \u001b[36m[Function: op_stdin_set_raw]\u001b[39m,\n", + " op_isatty: \u001b[36m[Function: op_isatty]\u001b[39m,\n", + " op_console_size: \u001b[36m[Function: op_console_size]\u001b[39m,\n", + " op_http_start: \u001b[36m[Function: op_http_start]\u001b[39m,\n", + " op_http_upgrade: \u001b[36m[Function: fn]\u001b[39m,\n", + " op_npm_process_state: \u001b[36m[Function: op_npm_process_state]\u001b[39m\n", + " },\n", + " asyncOps: {\n", + " op_error_async: \u001b[36m[Function: op_error_async]\u001b[39m,\n", + " op_error_async_deferred: \u001b[36m[Function: op_error_async_deferred]\u001b[39m,\n", + " op_void_async: \u001b[36m[Function: op_void_async]\u001b[39m,\n", + " op_void_async_deferred: \u001b[36m[Function: op_void_async_deferred]\u001b[39m,\n", + " op_add_async: \u001b[36m[Function: op_add_async]\u001b[39m,\n", + " op_read: \u001b[36m[Function: op_read]\u001b[39m,\n", + " op_read_all: \u001b[36m[Function: op_read_all]\u001b[39m,\n", + " op_write: \u001b[36m[Function: op_write]\u001b[39m,\n", + " op_write_all: \u001b[36m[Function: op_write_all]\u001b[39m,\n", + " op_write_type_error: \u001b[36m[Function: op_write_type_error]\u001b[39m,\n", + " op_shutdown: \u001b[36m[Function: op_shutdown]\u001b[39m,\n", + " op_blob_read_part: \u001b[36m[Function: op_blob_read_part]\u001b[39m,\n", + " op_message_port_recv_message: \u001b[36m[Function: op_message_port_recv_message]\u001b[39m,\n", + " op_sleep: \u001b[36m[Function: op_sleep]\u001b[39m,\n", + " op_readable_stream_resource_write_error: \u001b[36m[Function: op_readable_stream_resource_write_error]\u001b[39m,\n", + " op_readable_stream_resource_write_buf: \u001b[36m[Function: op_readable_stream_resource_write_buf]\u001b[39m,\n", + " op_readable_stream_resource_await_close: \u001b[36m[Function: op_readable_stream_resource_await_close]\u001b[39m,\n", + " op_fetch_send: \u001b[36m[Function: op_fetch_send]\u001b[39m,\n", + " op_fetch_response_upgrade: \u001b[36m[Function: op_fetch_response_upgrade]\u001b[39m,\n", + " op_cache_storage_open: \u001b[36m[Function: op_cache_storage_open]\u001b[39m,\n", + " op_cache_storage_has: \u001b[36m[Function: op_cache_storage_has]\u001b[39m,\n", + " op_cache_storage_delete: \u001b[36m[Function: op_cache_storage_delete]\u001b[39m,\n", + " op_cache_put: \u001b[36m[Function: op_cache_put]\u001b[39m,\n", + " op_cache_put_finish: \u001b[36m[Function: op_cache_put_finish]\u001b[39m,\n", + " op_cache_match: \u001b[36m[Function: op_cache_match]\u001b[39m,\n", + " op_cache_delete: \u001b[36m[Function: op_cache_delete]\u001b[39m,\n", + " op_ws_create: \u001b[36m[Function: op_ws_create]\u001b[39m,\n", + " op_ws_close: \u001b[36m[Function: op_ws_close]\u001b[39m,\n", + " op_ws_next_event: \u001b[36m[Function: op_ws_next_event]\u001b[39m,\n", + " op_ws_send_binary_async: \u001b[36m[Function: op_ws_send_binary_async]\u001b[39m,\n", + " op_ws_send_text_async: \u001b[36m[Function: op_ws_send_text_async]\u001b[39m,\n", + " op_ws_send_ping: \u001b[36m[Function: op_ws_send_ping]\u001b[39m,\n", + " op_ws_send_pong: \u001b[36m[Function: op_ws_send_pong]\u001b[39m,\n", + " op_crypto_generate_key: \u001b[36m[Function: op_crypto_generate_key]\u001b[39m,\n", + " op_crypto_sign_key: \u001b[36m[Function: op_crypto_sign_key]\u001b[39m,\n", + " op_crypto_verify_key: \u001b[36m[Function: op_crypto_verify_key]\u001b[39m,\n", + " op_crypto_derive_bits: \u001b[36m[Function: op_crypto_derive_bits]\u001b[39m,\n", + " op_crypto_encrypt: \u001b[36m[Function: op_crypto_encrypt]\u001b[39m,\n", + " op_crypto_decrypt: \u001b[36m[Function: op_crypto_decrypt]\u001b[39m,\n", + " op_crypto_subtle_digest: \u001b[36m[Function: op_crypto_subtle_digest]\u001b[39m,\n", + " op_broadcast_send: \u001b[36m[Function: op_broadcast_send]\u001b[39m,\n", + " op_broadcast_recv: \u001b[36m[Function: op_broadcast_recv]\u001b[39m,\n", + " op_ffi_call_nonblocking: \u001b[36m[Function: op_ffi_call_nonblocking]\u001b[39m,\n", + " op_ffi_call_ptr_nonblocking: \u001b[36m[Function: op_ffi_call_ptr_nonblocking]\u001b[39m,\n", + " op_ffi_unsafe_callback_ref: \u001b[36m[Function: op_ffi_unsafe_callback_ref]\u001b[39m,\n", + " op_net_accept_tcp: \u001b[36m[Function: op_net_accept_tcp]\u001b[39m,\n", + " op_net_connect_tcp: \u001b[36m[Function: op_net_connect_tcp]\u001b[39m,\n", + " op_net_recv_udp: \u001b[36m[Function: op_net_recv_udp]\u001b[39m,\n", + " op_net_send_udp: \u001b[36m[Function: op_net_send_udp]\u001b[39m,\n", + " op_net_join_multi_v4_udp: \u001b[36m[Function: op_net_join_multi_v4_udp]\u001b[39m,\n", + " op_net_join_multi_v6_udp: \u001b[36m[Function: op_net_join_multi_v6_udp]\u001b[39m,\n", + " op_net_leave_multi_v4_udp: \u001b[36m[Function: op_net_leave_multi_v4_udp]\u001b[39m,\n", + " op_net_leave_multi_v6_udp: \u001b[36m[Function: op_net_leave_multi_v6_udp]\u001b[39m,\n", + " op_net_set_multi_loopback_udp: \u001b[36m[Function: op_net_set_multi_loopback_udp]\u001b[39m,\n", + " op_net_set_multi_ttl_udp: \u001b[36m[Function: op_net_set_multi_ttl_udp]\u001b[39m,\n", + " op_dns_resolve: \u001b[36m[Function: op_dns_resolve]\u001b[39m,\n", + " op_tls_start: \u001b[36m[Function: op_tls_start]\u001b[39m,\n", + " op_net_connect_tls: \u001b[36m[Function: op_net_connect_tls]\u001b[39m,\n", + " op_net_accept_tls: \u001b[36m[Function: op_net_accept_tls]\u001b[39m,\n", + " op_tls_handshake: \u001b[36m[Function: op_tls_handshake]\u001b[39m,\n", + " op_net_accept_unix: \u001b[36m[Function: op_net_accept_unix]\u001b[39m,\n", + " op_net_connect_unix: \u001b[36m[Function: op_net_connect_unix]\u001b[39m,\n", + " op_net_recv_unixpacket: \u001b[36m[Function: op_net_recv_unixpacket]\u001b[39m,\n", + " op_net_send_unixpacket: \u001b[36m[Function: op_net_send_unixpacket]\u001b[39m,\n", + " op_kv_database_open: \u001b[36m[Function: op_kv_database_open]\u001b[39m,\n", + " op_kv_snapshot_read: \u001b[36m[Function: op_kv_snapshot_read]\u001b[39m,\n", + " op_kv_atomic_write: \u001b[36m[Function: op_kv_atomic_write]\u001b[39m,\n", + " op_kv_dequeue_next_message: \u001b[36m[Function: op_kv_dequeue_next_message]\u001b[39m,\n", + " op_kv_finish_dequeued_message: \u001b[36m[Function: op_kv_finish_dequeued_message]\u001b[39m,\n", + " op_http_accept: \u001b[36m[Function: op_http_accept]\u001b[39m,\n", + " op_http_shutdown: \u001b[36m[Function: op_http_shutdown]\u001b[39m,\n", + " op_http_upgrade_websocket: \u001b[36m[Function: op_http_upgrade_websocket]\u001b[39m,\n", + " op_http_write_headers: \u001b[36m[Function: op_http_write_headers]\u001b[39m,\n", + " op_http_write_resource: \u001b[36m[Function: op_http_write_resource]\u001b[39m,\n", + " op_http_write: \u001b[36m[Function: op_http_write]\u001b[39m,\n", + " op_http_track: \u001b[36m[Function: op_http_track]\u001b[39m,\n", + " op_http_upgrade_websocket_next: \u001b[36m[Function: op_http_upgrade_websocket_next]\u001b[39m,\n", + " op_raw_write_vectored: \u001b[36m[Function: op_raw_write_vectored]\u001b[39m,\n", + " op_http_wait: \u001b[36m[Function: op_http_wait]\u001b[39m,\n", + " op_fs_open_async: \u001b[36m[Function: op_fs_open_async]\u001b[39m,\n", + " op_fs_mkdir_async: \u001b[36m[Function: op_fs_mkdir_async]\u001b[39m,\n", + " op_fs_chmod_async: \u001b[36m[Function: op_fs_chmod_async]\u001b[39m,\n", + " op_fs_chown_async: \u001b[36m[Function: op_fs_chown_async]\u001b[39m,\n", + " op_fs_remove_async: \u001b[36m[Function: op_fs_remove_async]\u001b[39m,\n", + " op_fs_copy_file_async: \u001b[36m[Function: op_fs_copy_file_async]\u001b[39m,\n", + " op_fs_stat_async: \u001b[36m[Function: op_fs_stat_async]\u001b[39m,\n", + " op_fs_lstat_async: \u001b[36m[Function: op_fs_lstat_async]\u001b[39m,\n", + " op_fs_realpath_async: \u001b[36m[Function: op_fs_realpath_async]\u001b[39m,\n", + " op_fs_read_dir_async: \u001b[36m[Function: op_fs_read_dir_async]\u001b[39m,\n", + " op_fs_rename_async: \u001b[36m[Function: op_fs_rename_async]\u001b[39m,\n", + " op_fs_link_async: \u001b[36m[Function: op_fs_link_async]\u001b[39m,\n", + " op_fs_symlink_async: \u001b[36m[Function: op_fs_symlink_async]\u001b[39m,\n", + " op_fs_read_link_async: \u001b[36m[Function: op_fs_read_link_async]\u001b[39m,\n", + " op_fs_truncate_async: \u001b[36m[Function: op_fs_truncate_async]\u001b[39m,\n", + " op_fs_utime_async: \u001b[36m[Function: op_fs_utime_async]\u001b[39m,\n", + " op_fs_make_temp_dir_async: \u001b[36m[Function: op_fs_make_temp_dir_async]\u001b[39m,\n", + " op_fs_make_temp_file_async: \u001b[36m[Function: op_fs_make_temp_file_async]\u001b[39m,\n", + " op_fs_write_file_async: \u001b[36m[Function: op_fs_write_file_async]\u001b[39m,\n", + " op_fs_read_file_async: \u001b[36m[Function: op_fs_read_file_async]\u001b[39m,\n", + " op_fs_read_file_text_async: \u001b[36m[Function: op_fs_read_file_text_async]\u001b[39m,\n", + " op_fs_seek_async: \u001b[36m[Function: op_fs_seek_async]\u001b[39m,\n", + " op_fs_fdatasync_async: \u001b[36m[Function: op_fs_fdatasync_async]\u001b[39m,\n", + " op_fs_fsync_async: \u001b[36m[Function: op_fs_fsync_async]\u001b[39m,\n", + " op_fs_fstat_async: \u001b[36m[Function: op_fs_fstat_async]\u001b[39m,\n", + " op_fs_flock_async: \u001b[36m[Function: op_fs_flock_async]\u001b[39m,\n", + " op_fs_funlock_async: \u001b[36m[Function: op_fs_funlock_async]\u001b[39m,\n", + " op_fs_ftruncate_async: \u001b[36m[Function: op_fs_ftruncate_async]\u001b[39m,\n", + " op_fs_futime_async: \u001b[36m[Function: op_fs_futime_async]\u001b[39m,\n", + " op_node_check_prime_async: \u001b[36m[Function: op_node_check_prime_async]\u001b[39m,\n", + " op_node_check_prime_bytes_async: \u001b[36m[Function: op_node_check_prime_bytes_async]\u001b[39m,\n", + " op_node_gen_prime_async: \u001b[36m[Function: op_node_gen_prime_async]\u001b[39m,\n", + " op_node_pbkdf2_async: \u001b[36m[Function: op_node_pbkdf2_async]\u001b[39m,\n", + " op_node_hkdf_async: \u001b[36m[Function: op_node_hkdf_async]\u001b[39m,\n", + " op_node_generate_secret_async: \u001b[36m[Function: op_node_generate_secret_async]\u001b[39m,\n", + " op_node_generate_rsa_async: \u001b[36m[Function: op_node_generate_rsa_async]\u001b[39m,\n", + " op_node_dsa_generate_async: \u001b[36m[Function: op_node_dsa_generate_async]\u001b[39m,\n", + " op_node_ec_generate_async: \u001b[36m[Function: op_node_ec_generate_async]\u001b[39m,\n", + " op_node_ed25519_generate_async: \u001b[36m[Function: op_node_ed25519_generate_async]\u001b[39m,\n", + " op_node_x25519_generate_async: \u001b[36m[Function: op_node_x25519_generate_async]\u001b[39m,\n", + " op_node_dh_generate_group_async: \u001b[36m[Function: op_node_dh_generate_group_async]\u001b[39m,\n", + " op_node_dh_generate_async: \u001b[36m[Function: op_node_dh_generate_async]\u001b[39m,\n", + " op_node_scrypt_async: \u001b[36m[Function: op_node_scrypt_async]\u001b[39m,\n", + " op_zlib_write_async: \u001b[36m[Function: op_zlib_write_async]\u001b[39m,\n", + " op_brotli_compress_async: \u001b[36m[Function: op_brotli_compress_async]\u001b[39m,\n", + " op_brotli_decompress_async: \u001b[36m[Function: op_brotli_decompress_async]\u001b[39m,\n", + " op_host_recv_ctrl: \u001b[36m[Function: op_host_recv_ctrl]\u001b[39m,\n", + " op_host_recv_message: \u001b[36m[Function: op_host_recv_message]\u001b[39m,\n", + " op_fs_events_poll: \u001b[36m[Function: op_fs_events_poll]\u001b[39m,\n", + " op_spawn_wait: \u001b[36m[Function: op_spawn_wait]\u001b[39m,\n", + " op_run_status: \u001b[36m[Function: op_run_status]\u001b[39m,\n", + " op_signal_poll: \u001b[36m[Function: op_signal_poll]\u001b[39m,\n", + " op_http_upgrade: \u001b[36m[Function: op_http_upgrade]\u001b[39m\n", + " },\n", + " callConsole: \u001b[36m[Function (anonymous)]\u001b[39m,\n", + " console: Object [console] {\n", + " debug: \u001b[36m[Function: debug]\u001b[39m,\n", + " error: \u001b[36m[Function: error]\u001b[39m,\n", + " info: \u001b[36m[Function: info]\u001b[39m,\n", + " log: \u001b[36m[Function: log]\u001b[39m,\n", + " warn: \u001b[36m[Function: warn]\u001b[39m,\n", + " dir: \u001b[36m[Function: dir]\u001b[39m,\n", + " dirxml: \u001b[36m[Function: dirxml]\u001b[39m,\n", + " table: \u001b[36m[Function: table]\u001b[39m,\n", + " trace: \u001b[36m[Function: trace]\u001b[39m,\n", + " group: \u001b[36m[Function: group]\u001b[39m,\n", + " groupCollapsed: \u001b[36m[Function: groupCollapsed]\u001b[39m,\n", + " groupEnd: \u001b[36m[Function: groupEnd]\u001b[39m,\n", + " clear: \u001b[36m[Function: clear]\u001b[39m,\n", + " count: \u001b[36m[Function: count]\u001b[39m,\n", + " countReset: \u001b[36m[Function: countReset]\u001b[39m,\n", + " assert: \u001b[36m[Function: assert]\u001b[39m,\n", + " profile: \u001b[36m[Function: profile]\u001b[39m,\n", + " profileEnd: \u001b[36m[Function: profileEnd]\u001b[39m,\n", + " time: \u001b[36m[Function: time]\u001b[39m,\n", + " timeLog: \u001b[36m[Function: timeLog]\u001b[39m,\n", + " timeEnd: \u001b[36m[Function: timeEnd]\u001b[39m,\n", + " timeStamp: \u001b[36m[Function: timeStamp]\u001b[39m,\n", + " context: \u001b[36m[Function: context]\u001b[39m\n", + " },\n", + " asyncStub: \u001b[36m[Function: asyncStub]\u001b[39m,\n", + " ensureFastOps: \u001b[36m[Function: ensureFastOps]\u001b[39m,\n", + " opAsync: \u001b[36m[Function: opAsync]\u001b[39m,\n", + " resources: \u001b[36m[Function: resources]\u001b[39m,\n", + " metrics: \u001b[36m[Function: metrics]\u001b[39m,\n", + " registerErrorBuilder: \u001b[36m[Function: registerErrorBuilder]\u001b[39m,\n", + " registerErrorClass: \u001b[36m[Function: registerErrorClass]\u001b[39m,\n", + " buildCustomError: \u001b[36m[Function: buildCustomError]\u001b[39m,\n", + " eventLoopTick: \u001b[36m[Function: eventLoopTick]\u001b[39m,\n", + " BadResource: \u001b[36m[class BadResource extends Error]\u001b[39m,\n", + " BadResourcePrototype: [Error],\n", + " Interrupted: \u001b[36m[class Interrupted extends Error]\u001b[39m,\n", + " InterruptedPrototype: [Error],\n", + " enableOpCallTracing: \u001b[36m[Function: enableOpCallTracing]\u001b[39m,\n", + " isOpCallTracingEnabled: \u001b[36m[Function: isOpCallTracingEnabled]\u001b[39m,\n", + " opCallTraces: SafeMap(0) [Map] {},\n", + " refOp: \u001b[36m[Function: refOp]\u001b[39m,\n", + " unrefOp: \u001b[36m[Function: unrefOp]\u001b[39m,\n", + " setReportExceptionCallback: \u001b[36m[Function: setReportExceptionCallback]\u001b[39m,\n", + " setPromiseHooks: \u001b[36m[Function: setPromiseHooks]\u001b[39m,\n", + " close: \u001b[36m[Function: op_close]\u001b[39m,\n", + " tryClose: \u001b[36m[Function: op_try_close]\u001b[39m,\n", + " read: \u001b[36m[Function: op_read]\u001b[39m,\n", + " readAll: \u001b[36m[Function: op_read_all]\u001b[39m,\n", + " write: \u001b[36m[Function: op_write]\u001b[39m,\n", + " writeAll: \u001b[36m[Function: op_write_all]\u001b[39m,\n", + " writeTypeError: \u001b[36m[Function: op_write_type_error]\u001b[39m,\n", + " readSync: \u001b[36m[Function: op_read_sync]\u001b[39m,\n", + " writeSync: \u001b[36m[Function: op_write_sync]\u001b[39m,\n", + " shutdown: \u001b[36m[Function: op_shutdown]\u001b[39m,\n", + " print: \u001b[36m[Function: print]\u001b[39m,\n", + " setMacrotaskCallback: \u001b[36m[Function: setMacrotaskCallback]\u001b[39m,\n", + " setNextTickCallback: \u001b[36m[Function: setNextTickCallback]\u001b[39m,\n", + " runMicrotasks: \u001b[36m[Function: runMicrotasks]\u001b[39m,\n", + " hasTickScheduled: \u001b[36m[Function: hasTickScheduled]\u001b[39m,\n", + " setHasTickScheduled: \u001b[36m[Function: setHasTickScheduled]\u001b[39m,\n", + " evalContext: \u001b[36m[Function: evalContext]\u001b[39m,\n", + " createHostObject: \u001b[36m[Function: createHostObject]\u001b[39m,\n", + " encode: \u001b[36m[Function: encode]\u001b[39m,\n", + " decode: \u001b[36m[Function: decode]\u001b[39m,\n", + " serialize: \u001b[36m[Function: serialize]\u001b[39m,\n", + " deserialize: \u001b[36m[Function: deserialize]\u001b[39m,\n", + " getPromiseDetails: \u001b[36m[Function: getPromiseDetails]\u001b[39m,\n", + " getProxyDetails: \u001b[36m[Function: getProxyDetails]\u001b[39m,\n", + " isProxy: \u001b[36m[Function: isProxy]\u001b[39m,\n", + " memoryUsage: \u001b[36m[Function: memoryUsage]\u001b[39m,\n", + " setWasmStreamingCallback: \u001b[36m[Function: setWasmStreamingCallback]\u001b[39m,\n", + " abortWasmStreaming: \u001b[36m[Function: abortWasmStreaming]\u001b[39m,\n", + " destructureError: \u001b[36m[Function: destructureError]\u001b[39m,\n", + " opNames: \u001b[36m[Function: opNames]\u001b[39m,\n", + " eventLoopHasMoreWork: \u001b[36m[Function: eventLoopHasMoreWork]\u001b[39m,\n", + " setPromiseRejectCallback: \u001b[36m[Function: setPromiseRejectCallback]\u001b[39m,\n", + " byteLength: \u001b[36m[Function: byteLength]\u001b[39m,\n", + " build: {\n", + " target: \u001b[32m\"aarch64-apple-darwin\"\u001b[39m,\n", + " arch: \u001b[32m\"aarch64\"\u001b[39m,\n", + " os: \u001b[32m\"darwin\"\u001b[39m,\n", + " vendor: \u001b[32m\"apple\"\u001b[39m,\n", + " env: \u001b[90mundefined\u001b[39m\n", + " },\n", + " setBuildInfo: \u001b[36m[Function: setBuildInfo]\u001b[39m,\n", + " prepareStackTrace: \u001b[36m[Function: prepareStackTrace]\u001b[39m\n", + " }\n", " }\n", "}" ] @@ -624,6 +1393,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "6caeb583", "metadata": { @@ -635,7 +1405,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 13, "id": "43c1581b", "metadata": { "hidden": true @@ -647,7 +1417,7 @@ "Promise { \u001b[32m\"it worked!\"\u001b[39m }" ] }, - "execution_count": 15, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } @@ -658,7 +1428,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 14, "id": "9a34b725", "metadata": { "hidden": true @@ -667,11 +1437,13 @@ { "data": { "text/plain": [ - "Promise { \u001b[31m\u001b[39m Error: it failed!\n", - " at :2:16 }" + "Promise {\n", + " \u001b[36m\u001b[39m Error: it failed!\n", + " at :2:16\n", + "}" ] }, - "execution_count": 16, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } @@ -681,6 +1453,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "3a89dada", "metadata": { @@ -691,6 +1464,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "46da2b23", "metadata": {}, @@ -699,6 +1473,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "64d6cb2c", "metadata": {}, @@ -768,6 +1543,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "887ef658", "metadata": {}, @@ -844,6 +1620,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "85747c36", "metadata": {}, @@ -893,6 +1670,7 @@ ] }, { + "attachments": {}, "cell_type": "markdown", "id": "ed389024", "metadata": {}, @@ -1136,7 +1914,7 @@ "file_extension": ".ts", "mimetype": "text/x.typescript", "name": "typescript", - "version": "4.5.2" + "version": "5.1.6" }, "toc": { "base_numbering": 1, From 60c454e27c8d42dc59e853a1325b6ec75271d3ba Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Mon, 4 Sep 2023 00:33:30 +0200 Subject: [PATCH 084/115] simplify ExecResult --- cli/tools/jupyter/mod.rs | 79 +++++++++++++++++----------------------- cli/tools/repl/mod.rs | 2 +- 2 files changed, 35 insertions(+), 46 deletions(-) diff --git a/cli/tools/jupyter/mod.rs b/cli/tools/jupyter/mod.rs index ae56a69ba2b18b..3de38a6c19756c 100644 --- a/cli/tools/jupyter/mod.rs +++ b/cli/tools/jupyter/mod.rs @@ -4,7 +4,7 @@ use std::path::Path; use crate::args::Flags; use crate::args::JupyterFlags; -use crate::tools::repl::ReplSession; +use crate::tools::repl; use crate::util::logger; use crate::CliFactory; use base64; @@ -75,7 +75,7 @@ pub async fn kernel( worker.setup_repl().await?; let worker = worker.into_main_worker(); let repl_session = - ReplSession::initialize(cli_options, npm_resolver, resolver, worker) + repl::ReplSession::initialize(cli_options, npm_resolver, resolver, worker) .await?; let mut kernel = @@ -113,7 +113,7 @@ struct Kernel { hb_comm: HbComm, identity: String, execution_count: u32, - repl_session: ReplSession, + repl_session: repl::ReplSession, stdio_rx: mpsc::UnboundedReceiver, last_comm_ctx: Option, } @@ -164,7 +164,7 @@ impl Kernel { async fn new( connection_filepath: &Path, stdio_rx: mpsc::UnboundedReceiver, - repl_session: ReplSession, + repl_session: repl::ReplSession, ) -> Result { let conn_file = std::fs::read_to_string(connection_filepath).with_context(|| { @@ -450,61 +450,50 @@ impl Kernel { ); self.iopub_comm.send(input_msg).await?; - let output = self + let evaluate_response = self .repl_session .evaluate_line_with_object_wrapping(&exec_request_content.code) .await?; - // TODO(bartlomieju): clean this up - maybe deduplicate with existing code in `ReplSession`. - let result = if let Some(ex_details) = &output.value.exception_details { - let stack_trace: Vec = ex_details - .exception - .as_ref() - .unwrap() - .description - .as_ref() - .unwrap() - .split('\n') - .map(|s| s.to_string()) - .collect(); + let repl::cdp::EvaluateResponse { + result, + exception_details, + } = evaluate_response.value; + + let exec_result = if let Some(exception_details) = exception_details { + let name = if let Some(exception) = exception_details.exception { + if let Some(description) = exception.description { + description + } else if let Some(value) = exception.value { + value.to_string() + } else { + "undefined".to_string() + } + } else { + "Unknown exception".to_string() + }; ExecResult::Error(ExecError { - // TODO(apowers313) this could probably use smarter unwrapping -- for example, someone may throw non-object - err_name: output - .value - .exception_details - .unwrap() - .exception - .unwrap() - .class_name - .unwrap(), - err_value: stack_trace.first().unwrap().to_string(), - // output.value["exceptionDetails"]["stackTrace"]["callFrames"] - stack_trace, + err_name: name, + err_value: "".to_string(), + stack_trace: vec![], }) } else { - // TODO(bartlomieju): fix this - eprintln!("output {:#?}", output); - - // TODO(bartlomieju): handle exception - let output = self - .repl_session - .get_eval_value(&output.value.result) - .await?; - - eprintln!("output serialized {:#?}", output); - // TODO(bartlomieju): returning this doesn't print the value in the notebook, - // it should probably send the data to stdio topic. + let output = self.repl_session.get_eval_value(&result).await?; ExecResult::Ok(output) }; - match result { + // TODO: remove `send_Execute_result` and `send_error`, they can be inlined + // here + match exec_result { ExecResult::Ok(_) => { self.send_execute_reply_ok(comm_ctx).await?; - self.send_execute_result(comm_ctx, &result).await?; + self.send_execute_result(comm_ctx, &exec_result).await?; } ExecResult::Error(_) => { - self.send_execute_reply_error(comm_ctx, &result).await?; - self.send_error(comm_ctx, &result).await?; + self + .send_execute_reply_error(comm_ctx, &exec_result) + .await?; + self.send_error(comm_ctx, &exec_result).await?; } }; diff --git a/cli/tools/repl/mod.rs b/cli/tools/repl/mod.rs index f86617368324b5..0bca871e57de98 100644 --- a/cli/tools/repl/mod.rs +++ b/cli/tools/repl/mod.rs @@ -13,7 +13,7 @@ use deno_runtime::permissions::Permissions; use deno_runtime::permissions::PermissionsContainer; use rustyline::error::ReadlineError; -mod cdp; +pub(crate) mod cdp; mod channel; mod editor; mod session; From 3fe15b8c69f971e705a5e7966889e3949e814872 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Mon, 4 Sep 2023 04:00:49 +0200 Subject: [PATCH 085/115] remove unnecessary methods --- cli/tools/jupyter/mod.rs | 366 +++++++-------------------------------- 1 file changed, 67 insertions(+), 299 deletions(-) diff --git a/cli/tools/jupyter/mod.rs b/cli/tools/jupyter/mod.rs index 3de38a6c19756c..e0ece66cd72cad 100644 --- a/cli/tools/jupyter/mod.rs +++ b/cli/tools/jupyter/mod.rs @@ -7,22 +7,17 @@ use crate::args::JupyterFlags; use crate::tools::repl; use crate::util::logger; use crate::CliFactory; -use base64; use deno_core::anyhow::anyhow; use deno_core::anyhow::Context; use deno_core::error::generic_error; use deno_core::error::AnyError; use deno_core::futures::channel::mpsc; -use deno_core::futures::channel::mpsc::UnboundedReceiver; -use deno_core::futures::channel::mpsc::UnboundedSender; use deno_core::futures::StreamExt; use deno_core::op; use deno_core::resolve_url_or_path; use deno_core::serde::Deserialize; use deno_core::serde_json; use deno_core::serde_json::json; -use deno_core::serde_json::Value; -use deno_core::JsBuffer; use deno_core::Op; use deno_core::OpState; use deno_runtime::permissions::Permissions; @@ -486,122 +481,81 @@ impl Kernel { // here match exec_result { ExecResult::Ok(_) => { - self.send_execute_reply_ok(comm_ctx).await?; - self.send_execute_result(comm_ctx, &exec_result).await?; + println!("sending exec result {}", self.execution_count); + let msg = ReplyMessage::new( + comm_ctx, + "execute_reply", + ReplyMetadata::Empty, + ReplyContent::ExecuteReply(ExecuteReplyContent { + status: "ok".to_string(), + execution_count: self.execution_count, + // NOTE(bartlomieju): these two fields are always empty + payload: vec![], + user_expressions: json!({}), + }), + ); + self.shell_comm.send(msg).await?; + let ExecResult::Ok(result_str) = exec_result else { + unreachable!() + }; + + let msg = SideEffectMessage::new( + comm_ctx, + "execute_result", + ReplyMetadata::Empty, + ReplyContent::ExecuteResult(ExecuteResultContent { + execution_count: self.execution_count, + data: json!({ + "text/plain": result_str, + }), + // data: json!(""), + metadata: json!({}), + }), + ); + self.iopub_comm.send(msg).await?; } ExecResult::Error(_) => { - self - .send_execute_reply_error(comm_ctx, &exec_result) - .await?; - self.send_error(comm_ctx, &exec_result).await?; + println!("sending exec reply error {}", self.execution_count); + let e = match &exec_result { + ExecResult::Error(e) => e, + _ => return Err(anyhow!("send_execute_reply_error: unreachable")), + }; + let msg = ReplyMessage::new( + comm_ctx, + "execute_reply", + ReplyMetadata::Empty, + ReplyContent::ExecuteError(ExecuteErrorContent { + execution_count: self.execution_count, + status: "error".to_string(), + payload: vec![], + user_expressions: json!({}), + // TODO(apowers313) implement error messages + ename: e.err_name.clone(), + evalue: e.err_value.clone(), + traceback: e.stack_trace.clone(), + }), + ); + self.shell_comm.send(msg).await?; + let ExecResult::Error(e) = &exec_result else { + unreachable!() + }; + let msg = SideEffectMessage::new( + comm_ctx, + "error", + ReplyMetadata::Empty, + ReplyContent::Error(ErrorContent { + ename: e.err_name.clone(), + evalue: e.err_value.clone(), + traceback: e.stack_trace.clone(), + }), + ); + self.iopub_comm.send(msg).await?; } }; Ok(()) } - async fn send_execute_reply_ok( - &mut self, - comm_ctx: &CommContext, - ) -> Result<(), AnyError> { - println!("sending exec result {}", self.execution_count); - let msg = ReplyMessage::new( - comm_ctx, - "execute_reply", - ReplyMetadata::Empty, - ReplyContent::ExecuteReply(ExecuteReplyContent { - status: "ok".to_string(), - execution_count: self.execution_count, - // NOTE(bartlomieju): these two fields are always empty - payload: vec![], - user_expressions: json!({}), - }), - ); - self.shell_comm.send(msg).await?; - - Ok(()) - } - - async fn send_execute_reply_error( - &mut self, - comm_ctx: &CommContext, - result: &ExecResult, - ) -> Result<(), AnyError> { - println!("sending exec reply error {}", self.execution_count); - let e = match result { - ExecResult::Error(e) => e, - _ => return Err(anyhow!("send_execute_reply_error: unreachable")), - }; - let msg = ReplyMessage::new( - comm_ctx, - "execute_reply", - ReplyMetadata::Empty, - ReplyContent::ExecuteError(ExecuteErrorContent { - execution_count: self.execution_count, - status: "error".to_string(), - payload: vec![], - user_expressions: json!({}), - // TODO(apowers313) implement error messages - ename: e.err_name.clone(), - evalue: e.err_value.clone(), - traceback: e.stack_trace.clone(), - }), - ); - self.shell_comm.send(msg).await?; - - Ok(()) - } - - async fn send_error( - &mut self, - comm_ctx: &CommContext, - result: &ExecResult, - ) -> Result<(), AnyError> { - let ExecResult::Error(e) = result else { - unreachable!() - }; - let msg = SideEffectMessage::new( - comm_ctx, - "error", - ReplyMetadata::Empty, - ReplyContent::Error(ErrorContent { - ename: e.err_name.clone(), - evalue: e.err_value.clone(), - traceback: e.stack_trace.clone(), - }), - ); - self.iopub_comm.send(msg).await?; - - Ok(()) - } - - async fn send_execute_result( - &mut self, - comm_ctx: &CommContext, - result: &ExecResult, - ) -> Result<(), AnyError> { - let ExecResult::Ok(result_str) = result else { - unreachable!() - }; - - let msg = SideEffectMessage::new( - comm_ctx, - "execute_result", - ReplyMetadata::Empty, - ReplyContent::ExecuteResult(ExecuteResultContent { - execution_count: self.execution_count, - data: json!({ - "text/plain": result_str, - }), - // data: json!(""), - metadata: json!({}), - }), - ); - self.iopub_comm.send(msg).await?; - - Ok(()) - } - async fn send_stdio( &mut self, comm_ctx: &CommContext, @@ -627,192 +581,6 @@ impl Kernel { Ok(()) } - - // TODO(bartlomieju): this method shouldn't be using `data: Value` but - // a strongly typed struct. All this handling here, is super brittle. - async fn display_data_from_result_value( - &mut self, - data: Value, - ) -> Result { - let mut d = &data; - let mut ret = MimeSet::new(); - // if we passed in a result, unwrap it - d = if d["result"].is_object() { - &d["result"] - } else { - d - }; - - if !d["type"].is_string() { - // not an execution result - return Ok(ret); - } - - let mut t = match &d["type"] { - Value::String(x) => x.to_string(), - _ => return Ok(ret), - }; - - if t == *"object" && d["subtype"] == Value::String("null".to_string()) { - // JavaScript null, the gift that keeps on giving - t = "null".to_string(); - } - - match t.as_ref() { - // TODO(apowers313) inspect object / call toPng, toHtml, toSvg, toText, toMime - "object" => { - // TODO: this description isn't very useful - let type_list = self.decode_object(data, true).await?; - for t in type_list.iter() { - ret.add(t.0, t.1.clone()); - } - } - "string" => { - ret.add("text/plain", d["value"].clone()); - ret.add("application/json", d["value"].clone()); - } - "null" => { - ret.add("text/plain", Value::String("null".to_string())); - ret.add("application/json", Value::Null); - } - "bigint" => { - ret.add("text/plain", d["unserializableValue"].clone()); - ret.add("application/json", d["unserializableValue"].clone()); - } - "symbol" => { - ret.add("text/plain", d["description"].clone()); - ret.add("application/json", d["description"].clone()); - } - "boolean" => { - ret.add("text/plain", Value::String(d["value"].to_string())); - ret.add("application/json", d["value"].clone()); - } - "number" => { - ret.add("text/plain", Value::String(d["value"].to_string())); - ret.add("application/json", d["value"].clone()); - } - // TODO(apowers313) currently ignoring "undefined" return value, I think most kernels make this a configuration option - "undefined" => return Ok(ret), - _ => { - println!("unknown type in display_data_from_result_value: {}", t); - return Ok(ret); - } - }; - - Ok(ret) - } - - async fn decode_object( - &mut self, - obj: Value, - color: bool, - ) -> Result, AnyError> { - // let v = self.repl_session.get_eval_value(&obj).await?; - // TODO(apowers313) copy and paste from `get_eval_value`, consider refactoring API - let obj_inspect_fn = match color { - true => { - r#"function (object) { - try { - return Deno[Deno.internal].inspectArgs(["%o", object], { colors: !Deno.noColor }); - } catch (err) { - return Deno[Deno.internal].inspectArgs(["%o", err]); - } - }"# - } - false => { - r#"function (object) { - try { - return Deno[Deno.internal].inspectArgs(["%o", object], { colors: Deno.noColor }); - } catch (err) { - return Deno[Deno.internal].inspectArgs(["%o", err]); - } - }"# - } - }; - - let v = self.repl_exec(obj_inspect_fn, Some(json!([obj]))).await?; - - match v["result"]["value"]["description"].to_string().as_ref() { - "Symbol(Symbol.toPng)" => println!("found Symbol(Symbol.toPng)"), - "Symbol(Symbol.toSvg)" => println!("found Symbol(Symbol.toSvg)"), - "Symbol(Symbol.toHtml)" => println!("found Symbol(Symbol.toHtml)"), - "Symbol(Symbol.toJson)" => println!("found Symbol(Symbol.toJson)"), - "Symbol(Symbol.toJpg)" => println!("found Symbol(Symbol.toJpg)"), - "Symbol(Symbol.toMime)" => println!("found Symbol(Symbol.toMime)"), - _ => return Ok(vec![("text/plain", v["result"]["value"].clone())]), - }; - - Ok(vec![]) - } - - async fn repl_exec( - &mut self, - code: &str, - args: Option, - ) -> Result { - let v = self - .repl_session - .post_message_with_event_loop( - "Runtime.callFunctionOn", - Some(json!({ - "executionContextId": self.repl_session.context_id, - "functionDeclaration": code, - "arguments": args, - })), - ) - .await?; - - Ok(v) - } -} - -struct MimeSet { - data_list: Vec<(String, Value)>, -} - -impl MimeSet { - fn new() -> MimeSet { - Self { data_list: vec![] } - } - - fn add(&mut self, mime_type: &str, data: Value) { - self.data_list.push((mime_type.to_string(), data)); - } - - fn add_buf( - &mut self, - mime_type: &str, - buf: JsBuffer, - format: Option, - ) -> Result<(), AnyError> { - let fmt_str = match format { - Some(f) => f, - None => "default".to_string(), - }; - - let json_data = match fmt_str.as_ref() { - "string" => json!(String::from_utf8(buf.to_vec())?), - "json" => serde_json::from_str(std::str::from_utf8(&buf)?)?, - "base64" | "default" => json!(base64::encode(buf)), - _ => return Err(anyhow!("unknown display mime format: {}", fmt_str)), - }; - self.add(mime_type, json_data); - - Ok(()) - } - - fn is_empty(&self) -> bool { - self.data_list.is_empty() - } - - fn to_object(&self) -> Value { - let mut data = json!({}); - for d in self.data_list.iter() { - data[&d.0] = json!(&d.1); - } - - data - } } enum ExecResult { From 70d647ee2aa0077fbb6a0dafb389671e26698175 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Mon, 4 Sep 2023 11:43:26 +0200 Subject: [PATCH 086/115] temp --- cli/tools/jupyter/mod.rs | 137 +++++++++++++++++---------------------- 1 file changed, 59 insertions(+), 78 deletions(-) diff --git a/cli/tools/jupyter/mod.rs b/cli/tools/jupyter/mod.rs index e0ece66cd72cad..0ffeb80a587f30 100644 --- a/cli/tools/jupyter/mod.rs +++ b/cli/tools/jupyter/mod.rs @@ -467,90 +467,71 @@ impl Kernel { } else { "Unknown exception".to_string() }; - ExecResult::Error(ExecError { + let e = ExecError { err_name: name, err_value: "".to_string(), stack_trace: vec![], - }) + }; + + println!("sending exec reply error {}", self.execution_count); + let msg = ReplyMessage::new( + comm_ctx, + "execute_reply", + ReplyMetadata::Empty, + ReplyContent::ExecuteError(ExecuteErrorContent { + execution_count: self.execution_count, + status: "error".to_string(), + payload: vec![], + user_expressions: json!({}), + // TODO(apowers313) implement error messages + ename: e.err_name.clone(), + evalue: e.err_value.clone(), + traceback: e.stack_trace.clone(), + }), + ); + self.shell_comm.send(msg).await?; + let msg = SideEffectMessage::new( + comm_ctx, + "error", + ReplyMetadata::Empty, + ReplyContent::Error(ErrorContent { + ename: e.err_name.clone(), + evalue: e.err_value.clone(), + traceback: e.stack_trace.clone(), + }), + ); + self.iopub_comm.send(msg).await?; } else { let output = self.repl_session.get_eval_value(&result).await?; - ExecResult::Ok(output) - }; - - // TODO: remove `send_Execute_result` and `send_error`, they can be inlined - // here - match exec_result { - ExecResult::Ok(_) => { - println!("sending exec result {}", self.execution_count); - let msg = ReplyMessage::new( - comm_ctx, - "execute_reply", - ReplyMetadata::Empty, - ReplyContent::ExecuteReply(ExecuteReplyContent { - status: "ok".to_string(), - execution_count: self.execution_count, - // NOTE(bartlomieju): these two fields are always empty - payload: vec![], - user_expressions: json!({}), + println!("sending exec result {}", self.execution_count); + let msg = ReplyMessage::new( + comm_ctx, + "execute_reply", + ReplyMetadata::Empty, + ReplyContent::ExecuteReply(ExecuteReplyContent { + status: "ok".to_string(), + execution_count: self.execution_count, + // NOTE(bartlomieju): these two fields are always empty + payload: vec![], + user_expressions: json!({}), + }), + ); + self.shell_comm.send(msg).await?; + + let msg = SideEffectMessage::new( + comm_ctx, + "execute_result", + ReplyMetadata::Empty, + ReplyContent::ExecuteResult(ExecuteResultContent { + execution_count: self.execution_count, + data: json!({ + "text/plain": output, }), - ); - self.shell_comm.send(msg).await?; - let ExecResult::Ok(result_str) = exec_result else { - unreachable!() - }; - - let msg = SideEffectMessage::new( - comm_ctx, - "execute_result", - ReplyMetadata::Empty, - ReplyContent::ExecuteResult(ExecuteResultContent { - execution_count: self.execution_count, - data: json!({ - "text/plain": result_str, - }), - // data: json!(""), - metadata: json!({}), - }), - ); - self.iopub_comm.send(msg).await?; - } - ExecResult::Error(_) => { - println!("sending exec reply error {}", self.execution_count); - let e = match &exec_result { - ExecResult::Error(e) => e, - _ => return Err(anyhow!("send_execute_reply_error: unreachable")), - }; - let msg = ReplyMessage::new( - comm_ctx, - "execute_reply", - ReplyMetadata::Empty, - ReplyContent::ExecuteError(ExecuteErrorContent { - execution_count: self.execution_count, - status: "error".to_string(), - payload: vec![], - user_expressions: json!({}), - // TODO(apowers313) implement error messages - ename: e.err_name.clone(), - evalue: e.err_value.clone(), - traceback: e.stack_trace.clone(), - }), - ); - self.shell_comm.send(msg).await?; - let ExecResult::Error(e) = &exec_result else { - unreachable!() - }; - let msg = SideEffectMessage::new( - comm_ctx, - "error", - ReplyMetadata::Empty, - ReplyContent::Error(ErrorContent { - ename: e.err_name.clone(), - evalue: e.err_value.clone(), - traceback: e.stack_trace.clone(), - }), - ); - self.iopub_comm.send(msg).await?; - } + // data: json!(""), + metadata: json!({}), + }), + ); + self.iopub_comm.send(msg).await?; }; Ok(()) From 7a3008ba63f783d7dadc4fa471d957d8e0b374a9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Mon, 4 Sep 2023 16:36:47 +0200 Subject: [PATCH 087/115] simplify --- cli/tools/jupyter/comm.rs | 127 +++++++++++++++++++++++++++- cli/tools/jupyter/mod.rs | 172 ++++++++++++++++---------------------- 2 files changed, 198 insertions(+), 101 deletions(-) diff --git a/cli/tools/jupyter/comm.rs b/cli/tools/jupyter/comm.rs index eaedc2c22ec4fc..f3f7ae7fe039ab 100644 --- a/cli/tools/jupyter/comm.rs +++ b/cli/tools/jupyter/comm.rs @@ -7,6 +7,17 @@ use zeromq::util::PeerIdentity; use zeromq::SocketOptions; use super::hmac_verify; +use super::message_types::CommContext; +use super::message_types::ErrorContent; +use super::message_types::ExecuteErrorContent; +use super::message_types::ExecuteInputContent; +use super::message_types::ExecuteReplyContent; +use super::message_types::ExecuteResultContent; +use super::message_types::KernelInfoReplyContent; +use super::message_types::KernelStatusContent; +use super::message_types::ReplyContent; +use super::message_types::ReplyMetadata; +use super::message_types::StreamContent; use super::ConnectionSpec; use super::ReplyMessage; use super::RequestMessage; @@ -54,12 +65,82 @@ impl PubComm { Ok(()) } - pub async fn send(&mut self, msg: SideEffectMessage) -> Result<(), AnyError> { + async fn send(&mut self, msg: SideEffectMessage) -> Result<(), AnyError> { log::debug!("==> IoPub SENDING: {:#?}", msg); let zmq_msg = msg.serialize(&self.hmac_key); self.socket.send(zmq_msg).await?; Ok(()) } + + pub async fn send_error( + &mut self, + comm_ctx: &CommContext, + content: ErrorContent, + ) -> Result<(), AnyError> { + let msg = SideEffectMessage::new( + comm_ctx, + "error", + ReplyMetadata::Empty, + ReplyContent::Error(content), + ); + self.send(msg).await + } + + pub async fn send_execute_result( + &mut self, + comm_ctx: &CommContext, + content: ExecuteResultContent, + ) -> Result<(), AnyError> { + let msg = SideEffectMessage::new( + comm_ctx, + "execute_result", + ReplyMetadata::Empty, + ReplyContent::ExecuteResult(content), + ); + self.send(msg).await + } + + pub async fn send_stream( + &mut self, + comm_ctx: &CommContext, + content: StreamContent, + ) -> Result<(), AnyError> { + let msg = SideEffectMessage::new( + comm_ctx, + "stream", + ReplyMetadata::Empty, + ReplyContent::Stream(content), + ); + self.send(msg).await + } + + pub async fn send_execute_input( + &mut self, + comm_ctx: &CommContext, + content: ExecuteInputContent, + ) -> Result<(), AnyError> { + let msg = SideEffectMessage::new( + comm_ctx, + "execute_input", + ReplyMetadata::Empty, + ReplyContent::ExecuteInput(content), + ); + self.send(msg).await + } + + pub async fn send_status( + &mut self, + comm_ctx: &CommContext, + content: KernelStatusContent, + ) -> Result<(), AnyError> { + let msg = SideEffectMessage::new( + comm_ctx, + "status", + ReplyMetadata::Empty, + ReplyContent::Status(content), + ); + self.send(msg).await + } } pub struct DealerComm { @@ -157,13 +238,55 @@ impl DealerComm { Ok(jup_msg) } - pub async fn send(&mut self, msg: ReplyMessage) -> Result<(), AnyError> { + async fn send(&mut self, msg: ReplyMessage) -> Result<(), AnyError> { log::debug!("==> {} SENDING: {:#?}", self.name, msg); let zmq_msg = msg.serialize(&self.hmac_key); self.socket.send(zmq_msg).await?; log::debug!("==> {} SENT", self.name); Ok(()) } + + pub async fn send_execute_error( + &mut self, + comm_ctx: &CommContext, + content: ExecuteErrorContent, + ) -> Result<(), AnyError> { + let msg = ReplyMessage::new( + comm_ctx, + "execute_reply", + ReplyMetadata::Empty, + ReplyContent::ExecuteError(content), + ); + self.send(msg).await + } + + pub async fn send_execute_reply( + &mut self, + comm_ctx: &CommContext, + content: ExecuteReplyContent, + ) -> Result<(), AnyError> { + let msg = ReplyMessage::new( + comm_ctx, + "execute_reply", + ReplyMetadata::Empty, + ReplyContent::ExecuteReply(content), + ); + self.send(msg).await + } + + pub async fn send_kernel_info_reply( + &mut self, + comm_ctx: &CommContext, + content: KernelInfoReplyContent, + ) -> Result<(), AnyError> { + let msg = ReplyMessage::new( + comm_ctx, + "kernel_info_repl", + ReplyMetadata::Empty, + ReplyContent::KernelInfo(content), + ); + self.send(msg).await + } } pub struct HbComm { diff --git a/cli/tools/jupyter/mod.rs b/cli/tools/jupyter/mod.rs index 0ffeb80a587f30..c362803bfdcde3 100644 --- a/cli/tools/jupyter/mod.rs +++ b/cli/tools/jupyter/mod.rs @@ -374,16 +374,11 @@ impl Kernel { KernelState::Starting => "starting", }; - let msg = SideEffectMessage::new( - comm_ctx, - "status", - ReplyMetadata::Empty, - ReplyContent::Status(KernelStatusContent { - execution_state: s.to_string(), - }), - ); - - if let Err(e) = self.iopub_comm.send(msg).await { + let content = KernelStatusContent { + execution_state: s.to_string(), + }; + + if let Err(e) = self.iopub_comm.send_status(comm_ctx, content).await { println!("[IoPub] Error setting state: {}, reason: {}", s, e); } } @@ -411,14 +406,10 @@ impl Kernel { debugger: false, }; - let reply = ReplyMessage::new( - comm_ctx, - "kernel_info_reply", - ReplyMetadata::Empty, - ReplyContent::KernelInfo(content), - ); - - self.shell_comm.send(reply).await?; + self + .shell_comm + .send_kernel_info_reply(comm_ctx, content) + .await?; Ok(()) } @@ -434,16 +425,14 @@ impl Kernel { _ => return Err(anyhow!("malformed execution content")), }; - let input_msg = SideEffectMessage::new( - comm_ctx, - "execute_input", - ReplyMetadata::Empty, - ReplyContent::ExecuteInput(ExecuteInputContent { - code: exec_request_content.code.clone(), - execution_count: self.execution_count, - }), - ); - self.iopub_comm.send(input_msg).await?; + let content = ExecuteInputContent { + code: exec_request_content.code.clone(), + execution_count: self.execution_count, + }; + self + .iopub_comm + .send_execute_input(comm_ctx, content) + .await?; let evaluate_response = self .repl_session @@ -455,7 +444,7 @@ impl Kernel { exception_details, } = evaluate_response.value; - let exec_result = if let Some(exception_details) = exception_details { + if let Some(exception_details) = exception_details { let name = if let Some(exception) = exception_details.exception { if let Some(description) = exception.description { description @@ -474,64 +463,63 @@ impl Kernel { }; println!("sending exec reply error {}", self.execution_count); - let msg = ReplyMessage::new( - comm_ctx, - "execute_reply", - ReplyMetadata::Empty, - ReplyContent::ExecuteError(ExecuteErrorContent { - execution_count: self.execution_count, - status: "error".to_string(), - payload: vec![], - user_expressions: json!({}), - // TODO(apowers313) implement error messages - ename: e.err_name.clone(), - evalue: e.err_value.clone(), - traceback: e.stack_trace.clone(), - }), - ); - self.shell_comm.send(msg).await?; - let msg = SideEffectMessage::new( - comm_ctx, - "error", - ReplyMetadata::Empty, - ReplyContent::Error(ErrorContent { - ename: e.err_name.clone(), - evalue: e.err_value.clone(), - traceback: e.stack_trace.clone(), - }), - ); - self.iopub_comm.send(msg).await?; + self + .shell_comm + .send_execute_error( + comm_ctx, + ExecuteErrorContent { + execution_count: self.execution_count, + status: "error".to_string(), + payload: vec![], + user_expressions: json!({}), + // TODO(apowers313) implement error messages + ename: e.err_name.clone(), + evalue: e.err_value.clone(), + traceback: e.stack_trace.clone(), + }, + ) + .await?; + self + .iopub_comm + .send_error( + comm_ctx, + ErrorContent { + ename: e.err_name.clone(), + evalue: e.err_value.clone(), + traceback: e.stack_trace.clone(), + }, + ) + .await?; } else { let output = self.repl_session.get_eval_value(&result).await?; println!("sending exec result {}", self.execution_count); - let msg = ReplyMessage::new( - comm_ctx, - "execute_reply", - ReplyMetadata::Empty, - ReplyContent::ExecuteReply(ExecuteReplyContent { - status: "ok".to_string(), - execution_count: self.execution_count, - // NOTE(bartlomieju): these two fields are always empty - payload: vec![], - user_expressions: json!({}), - }), - ); - self.shell_comm.send(msg).await?; - - let msg = SideEffectMessage::new( - comm_ctx, - "execute_result", - ReplyMetadata::Empty, - ReplyContent::ExecuteResult(ExecuteResultContent { - execution_count: self.execution_count, - data: json!({ - "text/plain": output, - }), - // data: json!(""), - metadata: json!({}), - }), - ); - self.iopub_comm.send(msg).await?; + self + .shell_comm + .send_execute_reply( + comm_ctx, + ExecuteReplyContent { + status: "ok".to_string(), + execution_count: self.execution_count, + // NOTE(bartlomieju): these two fields are always empty + payload: vec![], + user_expressions: json!({}), + }, + ) + .await?; + self + .iopub_comm + .send_execute_result( + comm_ctx, + ExecuteResultContent { + execution_count: self.execution_count, + data: json!({ + "text/plain": output, + }), + // data: json!(""), + metadata: json!({}), + }, + ) + .await?; }; Ok(()) @@ -550,25 +538,11 @@ impl Kernel { }, text: text.to_string(), }; - - let msg = SideEffectMessage::new( - comm_ctx, - "stream", - ReplyMetadata::Empty, - ReplyContent::Stream(content), - ); - - self.iopub_comm.send(msg).await?; - + self.iopub_comm.send_stream(comm_ctx, content).await?; Ok(()) } } -enum ExecResult { - Ok(String), - Error(ExecError), -} - struct ExecError { err_name: String, err_value: String, From 8937b23d86c7ceb9d7d0036204d18fa0c082445d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Mon, 4 Sep 2023 18:18:39 +0200 Subject: [PATCH 088/115] jupyter_msg.rs --- Cargo.lock | 1 + cli/Cargo.toml | 1 + cli/tools/jupyter/jupyter_msg.rs | 290 +++++++++++++++++++++++++++++++ cli/tools/jupyter/mod.rs | 25 ++- 4 files changed, 314 insertions(+), 3 deletions(-) create mode 100644 cli/tools/jupyter/jupyter_msg.rs diff --git a/Cargo.lock b/Cargo.lock index 96f1534fe1c4cb..93105e8979218e 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -979,6 +979,7 @@ dependencies = [ "base32", "base64 0.13.1", "bincode", + "bytes", "cache_control", "chrono", "clap", diff --git a/cli/Cargo.toml b/cli/Cargo.toml index 084385eb1b83fa..0716e8a95e1cca 100644 --- a/cli/Cargo.toml +++ b/cli/Cargo.toml @@ -65,6 +65,7 @@ async-trait.workspace = true base32 = "=0.4.0" base64.workspace = true bincode = "=1.3.3" +bytes.workspace = true cache_control.workspace = true chrono.workspace = true clap = { version = "=4.3.3", features = ["string"] } diff --git a/cli/tools/jupyter/jupyter_msg.rs b/cli/tools/jupyter/jupyter_msg.rs new file mode 100644 index 00000000000000..d6c168f856b1aa --- /dev/null +++ b/cli/tools/jupyter/jupyter_msg.rs @@ -0,0 +1,290 @@ +// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. + +// This file is forked/ported from +// Copyright 2020 The Evcxr Authors. MIT license. + +use bytes::Bytes; +use chrono::Utc; +use data_encoding::HEXLOWER; +use deno_core::anyhow::anyhow; +use deno_core::anyhow::bail; +use deno_core::error::AnyError; +use deno_core::serde_json; +use deno_core::serde_json::json; +use ring::hmac; +use std::fmt; +use uuid::Uuid; + +pub(crate) struct Connection { + pub(crate) socket: S, + /// Will be None if our key was empty (digest authentication disabled). + pub(crate) mac: Option, +} + +impl Connection { + pub(crate) fn new(socket: S, key: &str) -> Self { + let mac = if key.is_empty() { + None + } else { + Some(hmac::Key::new(hmac::HMAC_SHA256, key.as_bytes())) + }; + Connection { socket, mac } + } +} + +struct RawMessage { + zmq_identities: Vec, + jparts: Vec, +} + +impl RawMessage { + pub(crate) async fn read( + connection: &mut Connection, + ) -> Result { + Self::from_multipart(connection.socket.recv().await?, connection) + } + + pub(crate) fn from_multipart( + multipart: zeromq::ZmqMessage, + connection: &Connection, + ) -> Result { + let delimiter_index = multipart + .iter() + .position(|part| &part[..] == DELIMITER) + .ok_or_else(|| anyhow!("Missing delimeter"))?; + let mut parts = multipart.into_vec(); + let jparts: Vec<_> = parts.drain(delimiter_index + 2..).collect(); + let expected_hmac = parts.pop().unwrap(); + // Remove delimiter, so that what's left is just the identities. + parts.pop(); + let zmq_identities = parts; + + let raw_message = RawMessage { + zmq_identities, + jparts, + }; + + if let Some(key) = &connection.mac { + let sig = HEXLOWER.decode(&expected_hmac)?; + let mut msg = Vec::new(); + for part in &raw_message.jparts { + msg.extend(part); + } + + if let Err(err) = hmac::verify(key, msg.as_ref(), sig.as_ref()) { + bail!("{}", err); + } + } + + Ok(raw_message) + } + + async fn send( + self, + connection: &mut Connection, + ) -> Result<(), AnyError> { + let hmac = if let Some(key) = &connection.mac { + let ctx = self.digest(key); + let tag = ctx.sign(); + HEXLOWER.encode(tag.as_ref()) + } else { + String::new() + }; + let mut parts: Vec = Vec::new(); + for part in &self.zmq_identities { + parts.push(part.to_vec().into()); + } + parts.push(DELIMITER.into()); + parts.push(hmac.as_bytes().to_vec().into()); + for part in &self.jparts { + parts.push(part.to_vec().into()); + } + // ZmqMessage::try_from only fails if parts is empty, which it never + // will be here. + let message = zeromq::ZmqMessage::try_from(parts).unwrap(); + connection.socket.send(message).await?; + Ok(()) + } + + fn digest(&self, mac: &hmac::Key) -> hmac::Context { + let mut hmac_ctx = hmac::Context::with_key(mac); + for part in &self.jparts { + hmac_ctx.update(part); + } + hmac_ctx + } +} + +#[derive(Clone)] +pub(crate) struct JupyterMessage { + zmq_identities: Vec, + header: serde_json::Value, + parent_header: serde_json::Value, + metadata: serde_json::Value, + content: serde_json::Value, +} + +const DELIMITER: &[u8] = b""; + +impl JupyterMessage { + pub(crate) async fn read( + connection: &mut Connection, + ) -> Result { + Self::from_raw_message(RawMessage::read(connection).await?) + } + + fn from_raw_message( + raw_message: RawMessage, + ) -> Result { + if raw_message.jparts.len() < 4 { + bail!("Insufficient message parts {}", raw_message.jparts.len()); + } + + Ok(JupyterMessage { + zmq_identities: raw_message.zmq_identities, + header: serde_json::from_slice(&raw_message.jparts[0])?, + parent_header: serde_json::from_slice(&raw_message.jparts[1])?, + metadata: serde_json::from_slice(&raw_message.jparts[2])?, + content: serde_json::from_slice(&raw_message.jparts[3])?, + }) + } + + pub(crate) fn message_type(&self) -> &str { + self.header["msg_type"].as_str().unwrap_or("") + } + + pub(crate) fn code(&self) -> &str { + self.content["code"].as_str().unwrap_or("") + } + + pub(crate) fn cursor_pos(&self) -> u64 { + self.content["cursor_pos"].as_u64().unwrap_or_default() + } + + pub(crate) fn target_name(&self) -> &str { + self.content["target_name"].as_str().unwrap_or("") + } + + pub(crate) fn data(&self) -> &serde_json::Value { + &self.content["data"] + } + + pub(crate) fn comm_id(&self) -> &str { + self.content["comm_id"].as_str().unwrap_or("") + } + + // Creates a new child message of this message. ZMQ identities are not transferred. + pub(crate) fn new_message(&self, msg_type: &str) -> JupyterMessage { + let mut header = self.header.clone(); + header["msg_type"] = serde_json::Value::String(msg_type.to_owned()); + header["username"] = serde_json::Value::String("kernel".to_owned()); + header["msg_id"] = serde_json::Value::String(Uuid::new_v4().to_string()); + header["date"] = serde_json::Value::String(Utc::now().to_rfc3339()); + + JupyterMessage { + zmq_identities: Vec::new(), + header, + parent_header: self.header.clone(), + metadata: json!({}), + content: json!({}), + } + } + + // Creates a reply to this message. This is a child with the message type determined + // automatically by replacing "request" with "reply". ZMQ identities are transferred. + pub(crate) fn new_reply(&self) -> JupyterMessage { + let mut reply = + self.new_message(&self.message_type().replace("_request", "_reply")); + reply.zmq_identities = self.zmq_identities.clone(); + reply + } + + #[must_use = "Need to send this message for it to have any effect"] + pub(crate) fn comm_close_message(&self) -> JupyterMessage { + self.new_message("comm_close").with_content(json!({ + "comm_id": self.comm_id() + })) + } + + pub(crate) fn get_content(&self) -> &serde_json::Value { + &self.content + } + + pub(crate) fn with_content( + mut self, + content: serde_json::Value, + ) -> JupyterMessage { + self.content = content; + self + } + + pub(crate) fn with_message_type(mut self, msg_type: &str) -> JupyterMessage { + self.header["msg_type"] = serde_json::Value::String(msg_type.to_owned()); + self + } + + pub(crate) fn without_parent_header(mut self) -> JupyterMessage { + self.parent_header = json!({}); + self + } + + pub(crate) async fn send( + &self, + connection: &mut Connection, + ) -> Result<(), AnyError> { + // If performance is a concern, we can probably avoid the clone and to_vec calls with a bit + // of refactoring. + let raw_message = RawMessage { + zmq_identities: self.zmq_identities.clone(), + jparts: vec![ + serde_json::to_string(&self.header) + .unwrap() + .as_bytes() + .to_vec() + .into(), + serde_json::to_string(&self.parent_header) + .unwrap() + .as_bytes() + .to_vec() + .into(), + serde_json::to_string(&self.metadata) + .unwrap() + .as_bytes() + .to_vec() + .into(), + serde_json::to_string(&self.content) + .unwrap() + .as_bytes() + .to_vec() + .into(), + ], + }; + raw_message.send(connection).await + } +} + +impl fmt::Debug for JupyterMessage { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + writeln!( + f, + "\nHeader: {}", + serde_json::to_string_pretty(&self.header).unwrap() + )?; + writeln!( + f, + "Parent header: {}", + serde_json::to_string_pretty(&self.parent_header).unwrap() + )?; + writeln!( + f, + "Metadata: {}", + serde_json::to_string_pretty(&self.metadata).unwrap() + )?; + writeln!( + f, + "Content: {}\n", + serde_json::to_string_pretty(&self.content).unwrap() + )?; + Ok(()) + } +} diff --git a/cli/tools/jupyter/mod.rs b/cli/tools/jupyter/mod.rs index c362803bfdcde3..cf97157adb6070 100644 --- a/cli/tools/jupyter/mod.rs +++ b/cli/tools/jupyter/mod.rs @@ -26,6 +26,7 @@ use ring::hmac; mod comm; mod install; +mod jupyter_msg; mod message_types; use comm::DealerComm; @@ -580,6 +581,27 @@ impl Default for KernelMetadata { } } +#[allow(unused)] +fn kernel_info() -> serde_json::Value { + json!({ + "status": "ok", + "protocol_version": "5.3", + "implementation_version": crate::version::deno(), + "implementation": "Deno kernel", + "language_info": { + "name": "typescript", + "version": crate::version::TYPESCRIPT, + "mimetype": "text/x.typescript", + "file_extension": ".ts" + }, + "help_links": [{ + "text": "Visit Deno manual", + "url": "https://deno.land/manual" + }], + "banner": "Welcome to Deno kernel", + }) +} + #[derive(Debug, Deserialize)] pub struct ConnectionSpec { ip: String, @@ -590,9 +612,6 @@ pub struct ConnectionSpec { hb_port: u32, iopub_port: u32, key: String, - - #[allow(unused)] - signature_scheme: String, } #[derive(Debug)] From 48911c6753dc7971b9d8fdd3fdabf7dee710ae83 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Mon, 4 Sep 2023 23:18:22 +0200 Subject: [PATCH 089/115] new server --- cli/tools/jupyter/mod.rs | 22 +--- cli/tools/jupyter/server.rs | 233 ++++++++++++++++++++++++++++++++++++ 2 files changed, 234 insertions(+), 21 deletions(-) create mode 100644 cli/tools/jupyter/server.rs diff --git a/cli/tools/jupyter/mod.rs b/cli/tools/jupyter/mod.rs index cf97157adb6070..e6f27f4571b9a1 100644 --- a/cli/tools/jupyter/mod.rs +++ b/cli/tools/jupyter/mod.rs @@ -28,6 +28,7 @@ mod comm; mod install; mod jupyter_msg; mod message_types; +mod server; use comm::DealerComm; use comm::HbComm; @@ -581,27 +582,6 @@ impl Default for KernelMetadata { } } -#[allow(unused)] -fn kernel_info() -> serde_json::Value { - json!({ - "status": "ok", - "protocol_version": "5.3", - "implementation_version": crate::version::deno(), - "implementation": "Deno kernel", - "language_info": { - "name": "typescript", - "version": crate::version::TYPESCRIPT, - "mimetype": "text/x.typescript", - "file_extension": ".ts" - }, - "help_links": [{ - "text": "Visit Deno manual", - "url": "https://deno.land/manual" - }], - "banner": "Welcome to Deno kernel", - }) -} - #[derive(Debug, Deserialize)] pub struct ConnectionSpec { ip: String, diff --git a/cli/tools/jupyter/server.rs b/cli/tools/jupyter/server.rs new file mode 100644 index 00000000000000..bd36e26aca59bf --- /dev/null +++ b/cli/tools/jupyter/server.rs @@ -0,0 +1,233 @@ +// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. + +// This file is forked/ported from +// Copyright 2020 The Evcxr Authors. MIT license. + +use std::path::Path; + +use crate::args::Flags; +use crate::args::JupyterFlags; +use crate::tools::repl; +use crate::util::logger; +use crate::CliFactory; +use deno_core::anyhow::anyhow; +use deno_core::anyhow::Context; +use deno_core::error::generic_error; +use deno_core::error::AnyError; +use deno_core::futures::channel::mpsc; +use deno_core::futures::StreamExt; +use deno_core::op; +use deno_core::resolve_url_or_path; +use deno_core::serde::Deserialize; +use deno_core::serde_json; +use deno_core::serde_json::json; +use deno_core::Op; +use deno_core::OpState; +use deno_runtime::permissions::Permissions; +use deno_runtime::permissions::PermissionsContainer; +use ring::hmac; +use zeromq::SocketRecv; +use zeromq::SocketSend; + +use super::jupyter_msg::Connection; +use super::jupyter_msg::JupyterMessage; +use super::ConnectionSpec; + +struct JupyterServer { + execution_count: usize, + iopub_socket: Connection, + repl_session: repl::ReplSession, +} + +impl JupyterServer { + async fn start( + connection_filepath: &Path, + stdio_rx: mpsc::UnboundedReceiver<()>, + repl_session: repl::ReplSession, + ) -> Result<(), AnyError> { + let conn_file = + std::fs::read_to_string(connection_filepath).with_context(|| { + format!("Couldn't read connection file: {:?}", connection_filepath) + })?; + let spec: ConnectionSpec = + serde_json::from_str(&conn_file).with_context(|| { + format!( + "Connection file is not a valid JSON: {:?}", + connection_filepath + ) + })?; + + let mut heartbeat = + bind_socket::(&spec, spec.hb_port).await?; + let shell_socket = + bind_socket::(&spec, spec.shell_port).await?; + let control_socket = + bind_socket::(&spec, spec.control_port).await?; + let stdin_socket = + bind_socket::(&spec, spec.stdin_port).await?; + let iopub_socket = + bind_socket::(&spec, spec.iopub_port).await?; + + let mut server = Self { + execution_count: 0, + iopub_socket, + repl_session, + }; + + deno_core::unsync::spawn(async move { + if let Err(err) = Self::handle_heartbeat(&mut heartbeat).await { + eprintln!("Heartbeat error: {}", err); + } + }); + + deno_core::unsync::spawn(async move { + if let Err(err) = Self::handle_control(control_socket).await { + eprintln!("Control error: {}", err); + } + }); + + deno_core::unsync::spawn(async move { + if let Err(err) = server.handle_shell(shell_socket).await { + eprintln!("Shell error: {}", err); + } + }); + + deno_core::unsync::spawn(async move { + if let Err(err) = Self::handle_execution_requests().await { + eprintln!("Execution error: {}", err); + } + }); + todo!() + } + + async fn handle_heartbeat( + connection: &mut Connection, + ) -> Result<(), AnyError> { + loop { + connection.socket.recv().await?; + connection + .socket + .send(zeromq::ZmqMessage::from(b"ping".to_vec())) + .await?; + } + } + + async fn handle_control( + mut connection: Connection, + ) -> Result<(), AnyError> { + loop { + let msg = JupyterMessage::read(&mut connection).await?; + match msg.message_type() { + "kernel_info_request" => { + msg + .new_reply() + .with_content(kernel_info()) + .send(&mut connection) + .await?; + } + "shutdown_request" => todo!(), + "interrupt_request" => todo!(), + _ => { + eprintln!( + "Unrecognized control message type: {}", + msg.message_type() + ); + } + } + } + } + + async fn handle_shell( + &mut self, + mut connection: Connection, + ) -> Result<(), AnyError> { + loop { + let msg = JupyterMessage::read(&mut connection).await?; + self.handle_shell_message(msg, &mut connection).await?; + } + } + + async fn handle_shell_message( + &mut self, + msg: JupyterMessage, + connection: &mut Connection, + ) -> Result<(), AnyError> { + msg + .new_message("status") + .with_content(json!({"execution_state": "busy"})) + .send(&mut self.iopub_socket) + .await?; + + match msg.message_type() { + "kernel_info_request" => { + msg + .new_reply() + .with_content(kernel_info()) + .send(connection) + .await?; + } + "is_complete_request" => { + msg + .new_reply() + .with_content(json!({"status": "complete"})) + .send(connection) + .await?; + } + "execute_request" => todo!(), + "comm_open" => { + msg + .comm_close_message() + .send(&mut self.iopub_socket) + .await?; + } + "complete_request" => todo!(), + "comm_msg" | "comm_info_request" | "history_request" => { + // We don't handle these messages + } + _ => { + eprintln!("Unrecognized shell message type: {}", msg.message_type()); + } + } + + msg + .new_message("status") + .with_content(json!({"execution_state": "idle"})) + .send(&mut self.iopub_socket) + .await?; + Ok(()) + } + + async fn handle_execution_requests() -> Result<(), AnyError> { + todo!(); + } +} + +async fn bind_socket( + config: &ConnectionSpec, + port: u32, +) -> Result, AnyError> { + let endpoint = format!("{}://{}:{}", config.transport, config.ip, port); + let mut socket = S::new(); + socket.bind(&endpoint).await?; + Ok(Connection::new(socket, &config.key)) +} + +fn kernel_info() -> serde_json::Value { + json!({ + "status": "ok", + "protocol_version": "5.3", + "implementation_version": crate::version::deno(), + "implementation": "Deno kernel", + "language_info": { + "name": "typescript", + "version": crate::version::TYPESCRIPT, + "mimetype": "text/x.typescript", + "file_extension": ".ts" + }, + "help_links": [{ + "text": "Visit Deno manual", + "url": "https://deno.land/manual" + }], + "banner": "Welcome to Deno kernel", + }) +} From 01187bd089f3ca590308e809c828d10a6334fa73 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Tue, 5 Sep 2023 00:02:53 +0200 Subject: [PATCH 090/115] JupyterServer working --- cli/tools/jupyter/mod.rs | 21 ++--- cli/tools/jupyter/server.rs | 151 ++++++++++++++++++++++++++++++++---- 2 files changed, 145 insertions(+), 27 deletions(-) diff --git a/cli/tools/jupyter/mod.rs b/cli/tools/jupyter/mod.rs index e6f27f4571b9a1..d192e381c99e8a 100644 --- a/cli/tools/jupyter/mod.rs +++ b/cli/tools/jupyter/mod.rs @@ -75,14 +75,15 @@ pub async fn kernel( repl::ReplSession::initialize(cli_options, npm_resolver, resolver, worker) .await?; - let mut kernel = - Kernel::new(&connection_filepath, stdio_rx, repl_session).await?; - println!("[DENO] kernel created: {:#?}", kernel.identity); + let mut server = + server::JupyterServer::start(&connection_filepath, stdio_rx, repl_session) + .await?; + // println!("[DENO] kernel created: {:#?}", kernel.identity); - println!("running kernel..."); + // println!("running kernel..."); // TODO(bartlomieju): handle the result - let _r = kernel.run().await; - println!("done running kernel."); + // let _r = kernel.run().await; + // println!("done running kernel."); Ok(()) } @@ -129,7 +130,7 @@ pub enum WorkerCommMsg { deno_core::extension!(deno_jupyter, options = { - sender: mpsc::UnboundedSender, + sender: mpsc::UnboundedSender, }, middleware = |op| match op.name { "op_print" => op_print::DECL, @@ -146,13 +147,13 @@ pub fn op_print( msg: String, is_err: bool, ) -> Result<(), AnyError> { - let sender = state.borrow_mut::>(); + let sender = state.borrow_mut::>(); // TODO(bartlomieju): should these results be handled somehow? if is_err { - let _r = sender.unbounded_send(WorkerCommMsg::Stderr(msg)); + let _r = sender.unbounded_send(server::StdioMsg::Stderr(msg)); } else { - let _r = sender.unbounded_send(WorkerCommMsg::Stdout(msg)); + let _r = sender.unbounded_send(server::StdioMsg::Stdout(msg)); } Ok(()) } diff --git a/cli/tools/jupyter/server.rs b/cli/tools/jupyter/server.rs index bd36e26aca59bf..e6d190deacc741 100644 --- a/cli/tools/jupyter/server.rs +++ b/cli/tools/jupyter/server.rs @@ -3,7 +3,9 @@ // This file is forked/ported from // Copyright 2020 The Evcxr Authors. MIT license. +use std::cell::RefCell; use std::path::Path; +use std::rc::Rc; use crate::args::Flags; use crate::args::JupyterFlags; @@ -14,6 +16,7 @@ use deno_core::anyhow::anyhow; use deno_core::anyhow::Context; use deno_core::error::generic_error; use deno_core::error::AnyError; +use deno_core::futures; use deno_core::futures::channel::mpsc; use deno_core::futures::StreamExt; use deno_core::op; @@ -33,16 +36,22 @@ use super::jupyter_msg::Connection; use super::jupyter_msg::JupyterMessage; use super::ConnectionSpec; -struct JupyterServer { +pub enum StdioMsg { + Stdout(String), + Stderr(String), +} + +pub struct JupyterServer { execution_count: usize, + last_execution_request: Rc>>, iopub_socket: Connection, repl_session: repl::ReplSession, } impl JupyterServer { - async fn start( + pub async fn start( connection_filepath: &Path, - stdio_rx: mpsc::UnboundedReceiver<()>, + stdio_rx: mpsc::UnboundedReceiver, repl_session: repl::ReplSession, ) -> Result<(), AnyError> { let conn_file = @@ -63,7 +72,7 @@ impl JupyterServer { bind_socket::(&spec, spec.shell_port).await?; let control_socket = bind_socket::(&spec, spec.control_port).await?; - let stdin_socket = + let _stdin_socket = bind_socket::(&spec, spec.stdin_port).await?; let iopub_socket = bind_socket::(&spec, spec.iopub_port).await?; @@ -71,33 +80,56 @@ impl JupyterServer { let mut server = Self { execution_count: 0, iopub_socket, + last_execution_request: Rc::new(RefCell::new(None)), repl_session, }; - deno_core::unsync::spawn(async move { + let handle1 = deno_core::unsync::spawn(async move { if let Err(err) = Self::handle_heartbeat(&mut heartbeat).await { eprintln!("Heartbeat error: {}", err); } }); - deno_core::unsync::spawn(async move { + let handle2 = deno_core::unsync::spawn(async move { if let Err(err) = Self::handle_control(control_socket).await { eprintln!("Control error: {}", err); } }); - deno_core::unsync::spawn(async move { - if let Err(err) = server.handle_shell(shell_socket).await { + let handle3 = deno_core::unsync::spawn(async move { + if let Err(err) = (&mut server).handle_shell(shell_socket).await { eprintln!("Shell error: {}", err); } }); - deno_core::unsync::spawn(async move { - if let Err(err) = Self::handle_execution_requests().await { - eprintln!("Execution error: {}", err); - } - }); - todo!() + let r = futures::try_join!(handle1, handle2, handle3)?; + + // deno_core::unsync::spawn(async move { + // // TODO: handle only if there's a pending execution request + // while let Some(stdio_msg) = stdio_rx.next().await { + // if let Some(exec_request) = server.last_execution_request.as_ref() { + // let (name, text) = match stdio_msg { + // StdioMsg::Stdout(text) => ("stdout", text), + // StdioMsg::Stderr(text) => ("stderr", text), + // }; + + // let result = exec_request + // .new_message("stream") + // .with_content(json!({ + // "name": name, + // "text": text + // })) + // .send(&mut iopub_socket2) + // .await; + + // if let Err(err) = result { + // eprintln!("Output {} error: {}", name, err); + // } + // } + // } + // }); + + Ok(()) } async fn handle_heartbeat( @@ -173,7 +205,11 @@ impl JupyterServer { .send(connection) .await?; } - "execute_request" => todo!(), + "execute_request" => { + self + .handle_execution_request(msg.clone(), connection) + .await?; + } "comm_open" => { msg .comm_close_message() @@ -197,8 +233,89 @@ impl JupyterServer { Ok(()) } - async fn handle_execution_requests() -> Result<(), AnyError> { - todo!(); + async fn handle_execution_request( + &mut self, + msg: JupyterMessage, + connection: &mut Connection, + ) -> Result<(), AnyError> { + self.execution_count += 1; + *self.last_execution_request.borrow_mut() = Some(msg.clone()); + + msg + .new_message("execute_input") + .with_content(json!({ + "execution_count": self.execution_count, + "code": msg.code() + })) + .send(&mut self.iopub_socket) + .await?; + + let evaluate_response = self + .repl_session + .evaluate_line_with_object_wrapping(msg.code()) + .await?; + + let repl::cdp::EvaluateResponse { + result, + exception_details, + } = evaluate_response.value; + + if exception_details.is_none() { + let output = self.repl_session.get_eval_value(&result).await?; + msg + .new_message("execute_result") + .with_content(json!({ + "execution_count": self.execution_count, + "data": { + "text/plain": output + }, + "metadata": {}, + })) + .send(&mut self.iopub_socket) + .await?; + msg + .new_reply() + .with_content(json!({ + "status": "ok", + "execution_count": self.execution_count, + })) + .send(connection) + .await?; + } else { + let exception_details = exception_details.unwrap(); + let name = if let Some(exception) = exception_details.exception { + if let Some(description) = exception.description { + description + } else if let Some(value) = exception.value { + value.to_string() + } else { + "undefined".to_string() + } + } else { + "Unknown exception".to_string() + }; + + // TODO: fill all the fields + msg + .new_message("error") + .with_content(json!({ + "ename": name, + "evalue": "", + "traceback": [], + })) + .send(&mut self.iopub_socket) + .await?; + msg + .new_reply() + .with_content(json!({ + "status": "error", + "execution_count": self.execution_count, + })) + .send(connection) + .await?; + } + + Ok(()) } } From 00ef3d707fd2110da5ca65b3838657856341bd51 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Tue, 5 Sep 2023 00:23:18 +0200 Subject: [PATCH 091/115] needs cleanup, but it works! --- cli/main.rs | 5 - cli/tools/jupyter/comm.rs | 320 --------------- cli/tools/jupyter/jupyter_msg.rs | 26 -- cli/tools/jupyter/message_types.rs | 605 ----------------------------- cli/tools/jupyter/mod.rs | 511 +----------------------- cli/tools/jupyter/server.rs | 107 ++--- 6 files changed, 57 insertions(+), 1517 deletions(-) delete mode 100644 cli/tools/jupyter/comm.rs delete mode 100644 cli/tools/jupyter/message_types.rs diff --git a/cli/main.rs b/cli/main.rs index 2b58d3464bccc3..b5a79ee772483f 100644 --- a/cli/main.rs +++ b/cli/main.rs @@ -135,11 +135,6 @@ async fn run_subcommand(flags: Flags) -> Result { tools::installer::install_command(flags, install_flags).await }), DenoSubcommand::Jupyter(jupyter_flags) => spawn_subcommand(async { - if jupyter_flags.install { - tools::jupyter::install()?; - return Ok(()); - } - tools::jupyter::kernel(flags, jupyter_flags).await }), DenoSubcommand::Uninstall(uninstall_flags) => spawn_subcommand(async { diff --git a/cli/tools/jupyter/comm.rs b/cli/tools/jupyter/comm.rs deleted file mode 100644 index f3f7ae7fe039ab..00000000000000 --- a/cli/tools/jupyter/comm.rs +++ /dev/null @@ -1,320 +0,0 @@ -// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. - -use deno_core::error::AnyError; -use ring::hmac; -use zeromq::prelude::*; -use zeromq::util::PeerIdentity; -use zeromq::SocketOptions; - -use super::hmac_verify; -use super::message_types::CommContext; -use super::message_types::ErrorContent; -use super::message_types::ExecuteErrorContent; -use super::message_types::ExecuteInputContent; -use super::message_types::ExecuteReplyContent; -use super::message_types::ExecuteResultContent; -use super::message_types::KernelInfoReplyContent; -use super::message_types::KernelStatusContent; -use super::message_types::ReplyContent; -use super::message_types::ReplyMetadata; -use super::message_types::StreamContent; -use super::ConnectionSpec; -use super::ReplyMessage; -use super::RequestMessage; -use super::SideEffectMessage; - -pub struct PubComm { - conn_str: String, - hmac_key: hmac::Key, - socket: zeromq::PubSocket, - - // TODO(bartlomieju): - #[allow(unused)] - identity: String, -} - -fn create_conn_str(transport: &str, ip: &str, port: u32) -> String { - format!("{}://{}:{}", transport, ip, port) -} - -// TODO(apowers313) connect and send look like traits shared with DealerComm -impl PubComm { - pub fn new( - spec: &ConnectionSpec, - identity: &str, - hmac_key: &hmac::Key, - ) -> Self { - let conn_str = create_conn_str(&spec.transport, &spec.ip, spec.iopub_port); - println!("iopub connection: {}", conn_str); - let peer_identity = - PeerIdentity::try_from(identity.as_bytes().to_vec()).unwrap(); - let mut options = SocketOptions::default(); - options.peer_identity(peer_identity); - - Self { - conn_str, - identity: identity.to_string(), - hmac_key: hmac_key.to_owned(), - socket: zeromq::PubSocket::with_options(options), - } - } - - pub async fn connect(&mut self) -> Result<(), AnyError> { - self.socket.bind(&self.conn_str).await?; - - Ok(()) - } - - async fn send(&mut self, msg: SideEffectMessage) -> Result<(), AnyError> { - log::debug!("==> IoPub SENDING: {:#?}", msg); - let zmq_msg = msg.serialize(&self.hmac_key); - self.socket.send(zmq_msg).await?; - Ok(()) - } - - pub async fn send_error( - &mut self, - comm_ctx: &CommContext, - content: ErrorContent, - ) -> Result<(), AnyError> { - let msg = SideEffectMessage::new( - comm_ctx, - "error", - ReplyMetadata::Empty, - ReplyContent::Error(content), - ); - self.send(msg).await - } - - pub async fn send_execute_result( - &mut self, - comm_ctx: &CommContext, - content: ExecuteResultContent, - ) -> Result<(), AnyError> { - let msg = SideEffectMessage::new( - comm_ctx, - "execute_result", - ReplyMetadata::Empty, - ReplyContent::ExecuteResult(content), - ); - self.send(msg).await - } - - pub async fn send_stream( - &mut self, - comm_ctx: &CommContext, - content: StreamContent, - ) -> Result<(), AnyError> { - let msg = SideEffectMessage::new( - comm_ctx, - "stream", - ReplyMetadata::Empty, - ReplyContent::Stream(content), - ); - self.send(msg).await - } - - pub async fn send_execute_input( - &mut self, - comm_ctx: &CommContext, - content: ExecuteInputContent, - ) -> Result<(), AnyError> { - let msg = SideEffectMessage::new( - comm_ctx, - "execute_input", - ReplyMetadata::Empty, - ReplyContent::ExecuteInput(content), - ); - self.send(msg).await - } - - pub async fn send_status( - &mut self, - comm_ctx: &CommContext, - content: KernelStatusContent, - ) -> Result<(), AnyError> { - let msg = SideEffectMessage::new( - comm_ctx, - "status", - ReplyMetadata::Empty, - ReplyContent::Status(content), - ); - self.send(msg).await - } -} - -pub struct DealerComm { - name: String, - conn_str: String, - hmac_key: hmac::Key, - socket: zeromq::DealerSocket, - - // TODO(bartlomieju): - #[allow(unused)] - identity: String, -} - -impl DealerComm { - pub fn new( - name: &str, - conn_str: String, - identity: &str, - hmac_key: &hmac::Key, - ) -> Self { - println!("dealer '{}' connection: {}", name, conn_str); - let peer_identity = - PeerIdentity::try_from(identity.as_bytes().to_vec()).unwrap(); - let mut options = SocketOptions::default(); - options.peer_identity(peer_identity); - - Self { - name: name.to_string(), - conn_str, - identity: identity.to_string(), - hmac_key: hmac_key.to_owned(), - socket: zeromq::DealerSocket::with_options(options), - } - } - - pub fn create_shell( - spec: &ConnectionSpec, - identity: &str, - hmac_key: &hmac::Key, - ) -> Self { - Self::new( - "shell", - create_conn_str(&spec.transport, &spec.ip, spec.shell_port), - identity, - hmac_key, - ) - } - - pub fn create_control( - spec: &ConnectionSpec, - identity: &str, - hmac_key: &hmac::Key, - ) -> Self { - Self::new( - "control", - create_conn_str(&spec.transport, &spec.ip, spec.control_port), - identity, - hmac_key, - ) - } - - pub fn create_stdin( - spec: &ConnectionSpec, - identity: &str, - hmac_key: &hmac::Key, - ) -> Self { - Self::new( - "stdin", - create_conn_str(&spec.transport, &spec.ip, spec.stdin_port), - identity, - hmac_key, - ) - } - - pub async fn connect(&mut self) -> Result<(), AnyError> { - self.socket.bind(&self.conn_str).await?; - - Ok(()) - } - - pub async fn recv(&mut self) -> Result { - let zmq_msg = self.socket.recv().await?; - - hmac_verify( - &self.hmac_key, - zmq_msg.get(1).unwrap(), - zmq_msg.get(2).unwrap(), - zmq_msg.get(3).unwrap(), - zmq_msg.get(4).unwrap(), - zmq_msg.get(5).unwrap(), - )?; - - let jup_msg = RequestMessage::try_from(zmq_msg)?; - log::debug!("<== {} RECEIVING: {:#?}", self.name, jup_msg); - Ok(jup_msg) - } - - async fn send(&mut self, msg: ReplyMessage) -> Result<(), AnyError> { - log::debug!("==> {} SENDING: {:#?}", self.name, msg); - let zmq_msg = msg.serialize(&self.hmac_key); - self.socket.send(zmq_msg).await?; - log::debug!("==> {} SENT", self.name); - Ok(()) - } - - pub async fn send_execute_error( - &mut self, - comm_ctx: &CommContext, - content: ExecuteErrorContent, - ) -> Result<(), AnyError> { - let msg = ReplyMessage::new( - comm_ctx, - "execute_reply", - ReplyMetadata::Empty, - ReplyContent::ExecuteError(content), - ); - self.send(msg).await - } - - pub async fn send_execute_reply( - &mut self, - comm_ctx: &CommContext, - content: ExecuteReplyContent, - ) -> Result<(), AnyError> { - let msg = ReplyMessage::new( - comm_ctx, - "execute_reply", - ReplyMetadata::Empty, - ReplyContent::ExecuteReply(content), - ); - self.send(msg).await - } - - pub async fn send_kernel_info_reply( - &mut self, - comm_ctx: &CommContext, - content: KernelInfoReplyContent, - ) -> Result<(), AnyError> { - let msg = ReplyMessage::new( - comm_ctx, - "kernel_info_repl", - ReplyMetadata::Empty, - ReplyContent::KernelInfo(content), - ); - self.send(msg).await - } -} - -pub struct HbComm { - conn_str: String, - socket: zeromq::RepSocket, -} - -impl HbComm { - pub fn new(spec: &ConnectionSpec) -> Self { - let conn_str = create_conn_str(&spec.transport, &spec.ip, spec.hb_port); - println!("hb connection: {}", conn_str); - Self { - conn_str, - socket: zeromq::RepSocket::new(), - } - } - - pub async fn connect(&mut self) -> Result<(), AnyError> { - self.socket.bind(&self.conn_str).await?; - - Ok(()) - } - - pub async fn heartbeat(&mut self) -> Result<(), AnyError> { - let msg = self.socket.recv().await?; - println!("<== heartbeat received"); - self.socket.send(msg).await?; - println!("==> heartbeat sent"); - Ok(()) - } -} diff --git a/cli/tools/jupyter/jupyter_msg.rs b/cli/tools/jupyter/jupyter_msg.rs index d6c168f856b1aa..d15463c974dbc0 100644 --- a/cli/tools/jupyter/jupyter_msg.rs +++ b/cli/tools/jupyter/jupyter_msg.rs @@ -157,18 +157,6 @@ impl JupyterMessage { self.content["code"].as_str().unwrap_or("") } - pub(crate) fn cursor_pos(&self) -> u64 { - self.content["cursor_pos"].as_u64().unwrap_or_default() - } - - pub(crate) fn target_name(&self) -> &str { - self.content["target_name"].as_str().unwrap_or("") - } - - pub(crate) fn data(&self) -> &serde_json::Value { - &self.content["data"] - } - pub(crate) fn comm_id(&self) -> &str { self.content["comm_id"].as_str().unwrap_or("") } @@ -206,10 +194,6 @@ impl JupyterMessage { })) } - pub(crate) fn get_content(&self) -> &serde_json::Value { - &self.content - } - pub(crate) fn with_content( mut self, content: serde_json::Value, @@ -218,16 +202,6 @@ impl JupyterMessage { self } - pub(crate) fn with_message_type(mut self, msg_type: &str) -> JupyterMessage { - self.header["msg_type"] = serde_json::Value::String(msg_type.to_owned()); - self - } - - pub(crate) fn without_parent_header(mut self) -> JupyterMessage { - self.parent_header = json!({}); - self - } - pub(crate) async fn send( &self, connection: &mut Connection, diff --git a/cli/tools/jupyter/message_types.rs b/cli/tools/jupyter/message_types.rs deleted file mode 100644 index 5eb23023d436e7..00000000000000 --- a/cli/tools/jupyter/message_types.rs +++ /dev/null @@ -1,605 +0,0 @@ -// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. - -// TODO(bartlomieju): remove this lint supression -#![allow(dead_code)] - -use data_encoding::HEXLOWER; -use deno_core::error::AnyError; -use deno_core::serde::Deserialize; -use deno_core::serde::Serialize; -use deno_core::serde_json; -use deno_core::serde_json::json; -use deno_core::serde_json::Value; -use ring::hmac; -use zeromq::ZmqMessage; - -const DELIMITER: &str = ""; - -#[derive(Clone, Debug)] -pub struct RequestMessage { - pub header: MessageHeader, - pub parent_header: Option<()>, - pub metadata: RequestMetadata, - pub content: RequestContent, -} - -impl RequestMessage { - pub fn new( - header: MessageHeader, - metadata: RequestMetadata, - content: RequestContent, - ) -> Self { - Self { - header, - parent_header: None, - metadata, - content, - } - } -} - -impl TryFrom for RequestMessage { - type Error = AnyError; - - fn try_from(zmq_msg: ZmqMessage) -> Result { - // TODO(apowers313) make all unwraps recoverable errors - let header_bytes = zmq_msg.get(2).unwrap(); - let _metadata_bytes = zmq_msg.get(4).unwrap(); - let content_bytes = zmq_msg.get(5).unwrap(); - - let header: MessageHeader = serde_json::from_slice(header_bytes).unwrap(); - let msg_type = header.msg_type.clone(); - - // TODO(apowers313) refactor to an unwrap function to handles unwrapping based on different protocol versions - let mc = match msg_type.as_ref() { - "kernel_info_request" => (RequestMetadata::Empty, RequestContent::Empty), - "execute_request" => ( - RequestMetadata::Empty, - RequestContent::Execute(serde_json::from_slice(content_bytes).unwrap()), - ), - _ => (RequestMetadata::Empty, RequestContent::Empty), - }; - - let rm = RequestMessage::new(header, mc.0, mc.1); - log::debug!("<== RECEIVING MSG [{}]: {:#?}", msg_type, rm); - - Ok(rm) - } -} - -#[derive(Debug)] -pub struct ReplyMessage { - pub header: MessageHeader, - pub parent_header: MessageHeader, - pub metadata: ReplyMetadata, - pub content: ReplyContent, -} - -impl ReplyMessage { - pub fn new( - comm_ctx: &CommContext, - msg_type: &str, - metadata: ReplyMetadata, - content: ReplyContent, - ) -> Self { - Self { - header: MessageHeader::new( - msg_type, - comm_ctx.message.header.session.clone(), - ), - parent_header: comm_ctx.message.header.clone(), - metadata, - content, - } - } - - pub fn serialize(&self, hmac_key: &hmac::Key) -> ZmqMessage { - // TODO(apowers313) convert unwrap() to recoverable error - let header = serde_json::to_string(&self.header).unwrap(); - let parent_header = serde_json::to_string(&self.parent_header).unwrap(); - let _metadata = serde_json::to_string(&self.metadata).unwrap(); - let metadata = match &self.metadata { - ReplyMetadata::Empty => serde_json::to_string(&json!({})).unwrap(), - }; - let content = match &self.content { - ReplyContent::Empty => serde_json::to_string(&json!({})).unwrap(), - // reply messages - ReplyContent::KernelInfo(c) => serde_json::to_string(&c).unwrap(), - ReplyContent::ExecuteReply(c) => serde_json::to_string(&c).unwrap(), - ReplyContent::ExecuteError(c) => serde_json::to_string(&c).unwrap(), - // side effects - ReplyContent::Status(c) => serde_json::to_string(&c).unwrap(), - ReplyContent::Stream(c) => serde_json::to_string(&c).unwrap(), - ReplyContent::ExecuteInput(c) => serde_json::to_string(&c).unwrap(), - ReplyContent::ExecuteResult(c) => serde_json::to_string(&c).unwrap(), - ReplyContent::Error(c) => serde_json::to_string(&c).unwrap(), - ReplyContent::DisplayData(c) => serde_json::to_string(&c).unwrap(), - }; - - let hmac = - hmac_sign(hmac_key, &header, &parent_header, &metadata, &content); - - let mut zmq_msg = ZmqMessage::from(DELIMITER); - zmq_msg.push_back(hmac.into()); - zmq_msg.push_back(header.into()); - zmq_msg.push_back(parent_header.into()); - zmq_msg.push_back(metadata.into()); - zmq_msg.push_back(content.into()); - log::debug!( - "==> SENDING MSG [{}]: {:#?}", - &self.header.msg_type, - zmq_msg - ); - - zmq_msg - } -} - -// side effects messages sent on IOPub look lik ReplyMessages (for now?) -pub type SideEffectMessage = ReplyMessage; - -#[derive(Clone, Debug)] -pub struct CommContext { - pub message: RequestMessage, -} - -#[derive(Debug, Deserialize, Serialize, Clone)] -pub struct MessageHeader { - pub msg_id: String, - pub session: String, - pub username: String, - // TODO(apowers313) -- date as an Option is to address a Jupyter bug - // see also: https://github.com/jupyter/notebook/issues/6257 - #[serde(default = "missing_date")] - pub date: String, - pub msg_type: String, - pub version: String, -} - -impl MessageHeader { - pub fn new(msg_type: &str, session: String) -> Self { - let now = std::time::SystemTime::now(); - let now: chrono::DateTime = now.into(); - let now = now.to_rfc3339(); - - Self { - msg_id: uuid::Uuid::new_v4().to_string(), - session, - // FIXME: - username: "".to_string(), - date: now, - msg_type: msg_type.to_string(), - // TODO: this should be taken from a global, - version: "5.3".to_string(), - } - } -} - -fn missing_date() -> String { - "1970-01-01T00:00:00+00:00".to_string() -} - -// /* ***************** -// * SHELL MESSAGES -// * *****************/ -// Shell Request Message Types -// "execute_request" /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#execute -// "inspect_request" /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#introspection -// "complete_request" /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#completion -// "history_request" /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#history -// "is_complete_request" /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#code-completeness -// "comm_info_request" /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#comm-info -// "kernel_info_request" /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-info - -// Shell Reply Message Types -// "execute_reply" /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#execution-results -// "inspect_reply" /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#introspection -// "complete_reply" /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#completion -// "history_reply" /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#history -// "is_complete_reply" /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#code-completeness -// "comm_info_reply" /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#comm-info -// "kernel_info_reply" /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-info - -#[derive(Clone, Debug, Serialize, Deserialize)] -pub enum RequestContent { - Empty, - Execute(ExecuteRequestContent), -} - -#[derive(Debug, Serialize, Deserialize)] -pub enum ReplyContent { - Empty, - // Reply Messages - KernelInfo(KernelInfoReplyContent), - ExecuteReply(ExecuteReplyContent), - ExecuteError(ExecuteErrorContent), - // Side Effects - Status(KernelStatusContent), - Stream(StreamContent), - ExecuteInput(ExecuteInputContent), - ExecuteResult(ExecuteResultContent), - Error(ErrorContent), - DisplayData(DisplayDataContent), -} - -#[derive(Clone, Debug, Serialize, Deserialize)] -pub enum RequestMetadata { - Empty, - Unknown(Value), -} - -#[derive(Debug, Serialize, Deserialize)] -pub enum ReplyMetadata { - Empty, -} - -//// https://jupyter-client.readthedocs.io/en/latest/messaging.html#execute -#[derive(Clone, Debug, Serialize, Deserialize)] -pub struct ExecuteRequestContent { - pub code: String, - pub silent: bool, - pub store_history: bool, - pub user_expressions: Value, - pub allow_stdin: bool, - pub stop_on_error: bool, -} - -//// https://jupyter-client.readthedocs.io/en/latest/messaging.html#execution-results -#[derive(Debug, Serialize, Deserialize)] -pub struct ExecuteReplyContent { - pub status: String, - pub execution_count: u32, - // These two fields are unused - pub payload: Vec, - // #[serde(skip_serializing_if = "Option::is_none")] - pub user_expressions: Value, -} - -//// https://jupyter-client.readthedocs.io/en/latest/messaging.html#introspection -pub struct InspectRequestContent { - pub code: String, - pub cursor_pos: u32, - pub detail_level: u8, // 0 = Low, 1 = High -} - -/// https://jupyter-client.readthedocs.io/en/latest/messaging.html#introspection -pub struct InspectReplyContent { - pub status: String, - pub found: bool, - pub data: Option, - pub metadata: Option, -} - -/// https://jupyter-client.readthedocs.io/en/latest/messaging.html#completion -pub struct CompleteRequestContent { - pub code: String, - pub cursor_pos: u32, -} - -/// https://jupyter-client.readthedocs.io/en/latest/messaging.html#completion -pub struct CompleteReplyContent { - pub status: String, - pub matches: Option, - pub cursor_start: u32, - pub cursor_end: u32, - pub metadata: Option, -} - -/// https://jupyter-client.readthedocs.io/en/latest/messaging.html#history -pub struct HistoryRequestContent { - pub output: bool, - pub raw: bool, - pub hist_access_type: String, // "range" | "tail" | "search" - pub session: u32, - pub start: u32, - pub stop: u32, - pub n: u32, -} - -/// https://jupyter-client.readthedocs.io/en/latest/messaging.html#history -pub struct HistoryReplyContent { - pub status: String, - pub history: Option, -} - -/// https://jupyter-client.readthedocs.io/en/latest/messaging.html#code-completeness -pub struct CodeCompleteRequestContent { - pub code: String, -} - -/// https://jupyter-client.readthedocs.io/en/latest/messaging.html#code-completeness -pub struct CodeCompleteReplyContent { - pub status: String, // "complete" | "incomplete" | "invalid" | "unknown" - pub indent: String, -} - -/// https://jupyter-client.readthedocs.io/en/latest/messaging.html#comm-info -pub struct CommInfoRequestContent { - pub target_name: String, -} - -/// https://jupyter-client.readthedocs.io/en/latest/messaging.html#comm-info -pub struct CommInfoReplyContent { - pub status: String, - pub comms: Option, -} - -/// https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-info -// pub struct KernelInfoRequest {} // empty - -/// https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-info -#[derive(Debug, Serialize, Deserialize)] -pub struct KernelInfoReplyContent { - pub status: String, - pub protocol_version: String, - pub implementation: String, - pub implementation_version: String, - pub language_info: KernelLanguageInfo, - pub banner: String, - pub debugger: bool, - pub help_links: Vec, -} - -//// https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-info -/// -/// `pygments_lexer`, `codemirror_more` and `nvconvert_exporter` are omitted. -#[derive(Debug, Serialize, Deserialize)] -pub struct KernelLanguageInfo { - pub name: String, - pub version: String, - pub mimetype: String, - pub file_extension: String, -} - -/// https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-info -#[derive(Debug, Serialize, Deserialize)] -pub struct KernelHelpLink { - pub text: String, - pub url: String, -} - -/* ***************** - * CONTROL MESSAGES - * *****************/ - -// Control Request Message Types -// "shutdown_request" /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-shutdown -// "interrupt_request" /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-interrupt -// "debug_request" /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#debug-request - -// Control Reply Message Types -// "shutdown_reply" /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-shutdown -// "interrupt_reply" /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-interrupt -// "debug_reply" /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#debug-request - -/// https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-shutdown -pub struct ShutdownRequestContent { - pub restart: bool, -} - -/// https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-shutdown -pub struct ShutdownReplyContent { - pub status: String, - pub restart: bool, -} - -/// https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-interrupt -// pub struct InterruptRequestContent {} // empty - -/// https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-interrupt -pub struct InterruptReplyContent { - pub status: String, -} - -/// https://jupyter-client.readthedocs.io/en/latest/messaging.html#debug-request -// pub struct DebugRequestContent {} // See Debug Adapter Protocol (DAP) 1.39 or later - -/// https://jupyter-client.readthedocs.io/en/latest/messaging.html#debug-request -// pub struct DebugReplyContent {} // See Debug Adapter Protocol (DAP) 1.39 or later - -/* ***************** - * IOPUB MESSAGES - * *****************/ -// Io Pub Message Types -// "stream" /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#streams-stdout-stderr-etc -// "display_data" /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#display-data -// "update_display_data" /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#update-display-data -// "execute_input" /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#code-inputs -// "execute_result" /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#id6 -// "error" /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#execution-errors -// "status" /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-status -// "clear_output" /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#clear-output -// "debug_event" /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#debug-event -// "comm_open" /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#opening-a-comm -// "comm_msg" /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#comm-messages -// "comm_close" /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#tearing-down-comms - -/// https://jupyter-client.readthedocs.io/en/latest/messaging.html#request-reply -#[derive(Debug, Serialize, Deserialize)] -pub struct ErrorContent { - pub ename: String, - pub evalue: String, - pub traceback: Vec, -} - -/// https://jupyter-client.readthedocs.io/en/latest/messaging.html#request-reply -// #[derive(Debug, Serialize, Deserialize)] -// pub struct StatusContent { -// status: String, // "ok" | "abort" -// } - -/// https://jupyter-client.readthedocs.io/en/latest/messaging.html#streams-stdout-stderr-etc -#[derive(Debug, Serialize, Deserialize)] -pub struct StreamContent { - pub name: String, // "stdout" | "stderr" - pub text: String, -} - -/// https://jupyter-client.readthedocs.io/en/latest/messaging.html#display-data -#[derive(Debug, Serialize, Deserialize)] -pub struct DisplayDataContent { - pub data: Value, - pub metadata: Value, - pub transient: Value, -} - -/// https://jupyter-client.readthedocs.io/en/latest/messaging.html#update-display-data -// pub struct UpdateDisplayDataContent {} // same as DisplayDataContent - -/// https://jupyter-client.readthedocs.io/en/latest/messaging.html#code-inputs -#[derive(Debug, Serialize, Deserialize)] -pub struct ExecuteInputContent { - pub code: String, - pub execution_count: u32, -} - -/// https://jupyter-client.readthedocs.io/en/latest/messaging.html#id6 -#[derive(Debug, Serialize, Deserialize)] -pub struct ExecuteResultContent { - pub execution_count: u32, - pub data: Value, - pub metadata: Value, -} - -/// https://jupyter-client.readthedocs.io/en/latest/messaging.html#execution-errors -/// https://jupyter-client.readthedocs.io/en/latest/messaging.html#messages-on-the-shell-router-dealer-channel -#[derive(Debug, Serialize, Deserialize)] -pub struct ExecuteErrorContent { - pub execution_count: u32, - pub status: String, - pub payload: Vec, - pub user_expressions: Value, - // XXX: the spec says one thing and the ipykernal does another... the following three fields are included by the ipykernel - pub ename: String, - pub evalue: String, - pub traceback: Vec, -} - -/// https://jupyter-client.readthedocs.io/en/latest/messaging.html#kernel-status -#[derive(Debug, Serialize, Deserialize)] -pub struct KernelStatusContent { - pub execution_state: String, // "busy" | "idle" | "starting" -} - -/// https://jupyter-client.readthedocs.io/en/latest/messaging.html#clear-output -pub struct ClearOutputContent { - pub wait: bool, -} - -/// https://jupyter-client.readthedocs.io/en/latest/messaging.html#debug-event -// pub struct DebugEventContent {} // see Event message from the Debug Adapter Protocol (DAP) - -/// https://jupyter-client.readthedocs.io/en/latest/messaging.html#opening-a-comm -pub struct CommOpenMessage { - pub comm_id: uuid::Uuid, - pub target_name: String, - pub data: Option, -} - -/// https://jupyter-client.readthedocs.io/en/latest/messaging.html#comm-messages -pub struct CommMsgMessage { - pub comm_id: uuid::Uuid, - pub data: Option, -} - -/// https://jupyter-client.readthedocs.io/en/latest/messaging.html#comm-messages -pub struct CommCloseMessage { - pub comm_id: uuid::Uuid, - pub data: Option, -} - -/* ***************** - * STDIN MESSAGES - * *****************/ -// Stdin Request Message Types -// "input_request" /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#messages-on-the-stdin-router-dealer-channel - -// Stdin Reply Message Types -// "input_reply" /// https://jupyter-client.readthedocs.io/en/latest/messaging.html#messages-on-the-stdin-router-dealer-channel - -/// https://jupyter-client.readthedocs.io/en/latest/messaging.html#messages-on-the-stdin-router-dealer-channel -pub struct InputRequestContent { - pub prompt: String, - pub password: bool, -} - -/// https://jupyter-client.readthedocs.io/en/latest/messaging.html#messages-on-the-stdin-router-dealer-channel -pub struct InputReplyContent { - pub value: String, -} - -fn hmac_sign( - key: &hmac::Key, - header: &str, - parent_header: &str, - metadata: &str, - content: &str, -) -> String { - let mut hmac_ctx = hmac::Context::with_key(key); - hmac_ctx.update(header.as_bytes()); - hmac_ctx.update(parent_header.as_bytes()); - hmac_ctx.update(metadata.as_bytes()); - hmac_ctx.update(content.as_bytes()); - let tag = hmac_ctx.sign(); - let sig = HEXLOWER.encode(tag.as_ref()); - sig -} - -pub fn hmac_verify( - key: &hmac::Key, - expected_signature: &[u8], - header: &[u8], - parent_header: &[u8], - metadata: &[u8], - content: &[u8], -) -> Result<(), AnyError> { - let mut msg = Vec::::new(); - msg.extend(header); - msg.extend(parent_header); - msg.extend(metadata); - msg.extend(content); - let sig = HEXLOWER.decode(expected_signature)?; - hmac::verify(key, msg.as_ref(), sig.as_ref())?; - Ok(()) -} - -#[test] -fn hmac_verify_test() { - let key_value = "1f5cec86-8eaa942eef7f5a35b51ddcf5"; - let key = hmac::Key::new(hmac::HMAC_SHA256, key_value.as_ref()); - - let expected_signature = - "43a5c45062e0b6bcc59c727f90165ad1d2eb02e1c5317aa25c2c2049d96d3b6a" - .as_bytes() - .to_vec(); - let header = "{\"msg_id\":\"c0fd20872c1b4d1c87e7fc814b75c93e_0\",\"msg_type\":\"kernel_info_request\",\"username\":\"ampower\",\"session\":\"c0fd20872c1b4d1c87e7fc814b75c93e\",\"date\":\"2021-12-10T06:20:40.259695Z\",\"version\":\"5.3\"}".as_bytes().to_vec(); - let parent_header = "{}".as_bytes().to_vec(); - let metadata = "{}".as_bytes().to_vec(); - let content = "{}".as_bytes().to_vec(); - - let result = hmac_verify( - &key, - &expected_signature, - &header, - &parent_header, - &metadata, - &content, - ); - - assert!(result.is_ok(), "signature validation failed"); -} - -#[test] -fn hmac_sign_test() { - let key_value = "1f5cec86-8eaa942eef7f5a35b51ddcf5"; - let key = hmac::Key::new(hmac::HMAC_SHA256, key_value.as_ref()); - let header = "{\"msg_id\":\"c0fd20872c1b4d1c87e7fc814b75c93e_0\",\"msg_type\":\"kernel_info_request\",\"username\":\"ampower\",\"session\":\"c0fd20872c1b4d1c87e7fc814b75c93e\",\"date\":\"2021-12-10T06:20:40.259695Z\",\"version\":\"5.3\"}"; - let parent_header = "{}"; - let metadata = "{}"; - let content = "{}"; - let sig = hmac_sign(&key, header, parent_header, metadata, content); - assert_eq!( - sig, - "43a5c45062e0b6bcc59c727f90165ad1d2eb02e1c5317aa25c2c2049d96d3b6a" - ); -} diff --git a/cli/tools/jupyter/mod.rs b/cli/tools/jupyter/mod.rs index d192e381c99e8a..2af0e06708b2f5 100644 --- a/cli/tools/jupyter/mod.rs +++ b/cli/tools/jupyter/mod.rs @@ -1,47 +1,33 @@ // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. -use std::path::Path; - use crate::args::Flags; use crate::args::JupyterFlags; use crate::tools::repl; use crate::util::logger; use crate::CliFactory; -use deno_core::anyhow::anyhow; use deno_core::anyhow::Context; -use deno_core::error::generic_error; use deno_core::error::AnyError; use deno_core::futures::channel::mpsc; -use deno_core::futures::StreamExt; use deno_core::op; use deno_core::resolve_url_or_path; use deno_core::serde::Deserialize; use deno_core::serde_json; -use deno_core::serde_json::json; use deno_core::Op; use deno_core::OpState; use deno_runtime::permissions::Permissions; use deno_runtime::permissions::PermissionsContainer; -use ring::hmac; -mod comm; mod install; mod jupyter_msg; -mod message_types; mod server; -use comm::DealerComm; -use comm::HbComm; -use comm::PubComm; -pub use install::install; -use message_types::*; - pub async fn kernel( flags: Flags, jupyter_flags: JupyterFlags, ) -> Result<(), AnyError> { let Some(connection_filepath) = jupyter_flags.conn_file else { - return Err(generic_error("Missing --conn flag")); + install::install()?; + return Ok(()); }; // This env var might be set by notebook @@ -61,6 +47,18 @@ pub async fn kernel( let worker_factory = factory.create_cli_main_worker_factory().await?; let (stdio_tx, stdio_rx) = mpsc::unbounded(); + let conn_file = + std::fs::read_to_string(&connection_filepath).with_context(|| { + format!("Couldn't read connection file: {:?}", connection_filepath) + })?; + let spec: ConnectionSpec = + serde_json::from_str(&conn_file).with_context(|| { + format!( + "Connection file is not a valid JSON: {:?}", + connection_filepath + ) + })?; + let mut worker = worker_factory .create_custom_worker( main_module.clone(), @@ -75,59 +73,11 @@ pub async fn kernel( repl::ReplSession::initialize(cli_options, npm_resolver, resolver, worker) .await?; - let mut server = - server::JupyterServer::start(&connection_filepath, stdio_rx, repl_session) - .await?; - // println!("[DENO] kernel created: {:#?}", kernel.identity); - - // println!("running kernel..."); - // TODO(bartlomieju): handle the result - // let _r = kernel.run().await; - // println!("done running kernel."); + server::JupyterServer::start(spec, stdio_rx, repl_session).await?; Ok(()) } -#[derive(Clone, Copy, Debug, PartialEq)] -enum KernelState { - Busy, - Idle, - - // TODO(bartlomieju): - #[allow(unused)] - Starting, -} - -struct Kernel { - metadata: KernelMetadata, - // TODO(bartlomieju): - #[allow(unused)] - conn_spec: ConnectionSpec, - state: KernelState, - iopub_comm: PubComm, - shell_comm: DealerComm, - control_comm: DealerComm, - stdin_comm: DealerComm, - hb_comm: HbComm, - identity: String, - execution_count: u32, - repl_session: repl::ReplSession, - stdio_rx: mpsc::UnboundedReceiver, - last_comm_ctx: Option, -} - -#[derive(Copy, Clone, Debug)] -enum HandlerType { - Shell, - Control, - Stdin, -} - -pub enum WorkerCommMsg { - Stderr(String), - Stdout(String), -} - deno_core::extension!(deno_jupyter, options = { sender: mpsc::UnboundedSender, @@ -158,431 +108,6 @@ pub fn op_print( Ok(()) } -impl Kernel { - async fn new( - connection_filepath: &Path, - stdio_rx: mpsc::UnboundedReceiver, - repl_session: repl::ReplSession, - ) -> Result { - let conn_file = - std::fs::read_to_string(connection_filepath).with_context(|| { - format!("Couldn't read connection file: {:?}", connection_filepath) - })?; - let spec: ConnectionSpec = - serde_json::from_str(&conn_file).with_context(|| { - format!( - "Connection file is not a valid JSON: {:?}", - connection_filepath - ) - })?; - - println!("[DENO] parsed conn file: {:#?}", spec); - - let identity = uuid::Uuid::new_v4().to_string(); - let hmac_key = hmac::Key::new(hmac::HMAC_SHA256, spec.key.as_ref()); - - let kernel = Self { - metadata: KernelMetadata::default(), - state: KernelState::Idle, - iopub_comm: PubComm::new(&spec, &identity, &hmac_key), - shell_comm: DealerComm::create_shell(&spec, &identity, &hmac_key), - control_comm: DealerComm::create_control(&spec, &identity, &hmac_key), - stdin_comm: DealerComm::create_stdin(&spec, &identity, &hmac_key), - hb_comm: HbComm::new(&spec), - identity, - execution_count: 0, - repl_session, - stdio_rx, - last_comm_ctx: None, - conn_spec: spec, - }; - - Ok(kernel) - } - - async fn run(&mut self) -> Result<(), AnyError> { - println!("Connecting to iopub"); - self.iopub_comm.connect().await?; - println!("Connected to iopub"); - println!("Connecting to shell"); - self.shell_comm.connect().await?; - println!("Connected to shell"); - println!("Connecting to control"); - self.control_comm.connect().await?; - println!("Connected to control"); - println!("Connecting to stdin"); - self.stdin_comm.connect().await?; - println!("Connected to stdin"); - println!("Connecting to heartbeat"); - self.hb_comm.connect().await?; - println!("Connected to heartbeat"); - - let mut poll_worker = true; - loop { - tokio::select! { - shell_msg_result = self.shell_comm.recv() => { - self.handler(HandlerType::Shell, shell_msg_result).await; - poll_worker = true; - }, - control_msg_result = self.control_comm.recv() => { - self.handler(HandlerType::Control, control_msg_result).await; - poll_worker = true; - }, - stdin_msg_result = self.stdin_comm.recv() => { - self.handler(HandlerType::Stdin, stdin_msg_result).await; - poll_worker = true; - }, - maybe_stdio_proxy_msg = self.stdio_rx.next() => { - if let Some(stdio_proxy_msg) = maybe_stdio_proxy_msg { - // TODO(bartlomieju): should the result be handled? - let _ = self.worker_comm_handler(stdio_proxy_msg).await; - } - }, - heartbeat_result = self.hb_comm.heartbeat() => { - if let Err(e) = heartbeat_result { - println!("[heartbeat] error: {}", e); - } - }, - _ = self.repl_session.run_event_loop(), if poll_worker => { - poll_worker = false; - } - } - } - } - - async fn handler( - &mut self, - handler_type: HandlerType, - recv_result: Result, - ) { - let req_msg = match recv_result { - Ok(m) => m, - Err(e) => { - println!("error receiving msg: {}", e); - return; - } - }; - - let comm_ctx = CommContext { message: req_msg }; - self.last_comm_ctx = Some(comm_ctx.clone()); - - println!("[DENO] set_state busy {:#?}", handler_type); - self.set_state(&comm_ctx, KernelState::Busy).await; - - let major_version = &comm_ctx.message.header.version.to_string()[0..1]; - let res = match (handler_type, major_version) { - // TODO(apowers313) implement new and old Jupyter protocols here - (HandlerType::Shell, "5") => self.shell_handler(&comm_ctx).await, - (HandlerType::Control, "5") => self.control_handler(&comm_ctx), - (HandlerType::Stdin, "5") => self.stdin_handler(&comm_ctx), - _ => Err(anyhow!( - "No handler for message: '{}' v{}", - comm_ctx.message.header.msg_type, - major_version - )), - }; - - match res { - Ok(_) => {} - Err(e) => { - println!( - "Error handling packet '{}': {}", - comm_ctx.message.header.msg_type, e - ); - } - }; - - println!("[DENO] set_state idle {:#?}", handler_type); - self.set_state(&comm_ctx, KernelState::Idle).await; - } - - async fn worker_comm_handler( - &mut self, - worker_msg: WorkerCommMsg, - ) -> Result<(), AnyError> { - let comm_ctx = match self.last_comm_ctx.clone() { - Some(cc) => cc, - None => { - return Err(anyhow!( - "Received stdio message, but there is no last CommContext" - )); - } - }; - - match worker_msg { - WorkerCommMsg::Stdout(s) => { - self - .send_stdio(&comm_ctx, StdioType::Stdout, s.as_ref()) - .await?; - } - WorkerCommMsg::Stderr(s) => { - self - .send_stdio(&comm_ctx, StdioType::Stderr, s.as_ref()) - .await?; - } - }; - - Ok(()) - } - - async fn shell_handler( - &mut self, - comm_ctx: &CommContext, - ) -> Result<(), AnyError> { - let msg_type = comm_ctx.message.header.msg_type.as_ref(); - let result = match msg_type { - "kernel_info_request" => self.kernel_info_reply(comm_ctx).await, - "execute_request" => self.execute_request(comm_ctx).await, - // "inspect_request" => self.inspect_request(comm_ctx).await, - // "complete_request" => self.complete_request(comm_ctx).await, - // "history_request" => self.history_request(comm_ctx).await, - // "is_complete_request" => self.is_complete_request(comm_ctx).await, - // "comm_info_request" => self.comm_info_request(comm_ctx).await, - _ => { - println!("[shell] no handler for {}", msg_type); - Ok(()) - } - }; - - if let Err(e) = result { - println!("[shell] error handling {}: {}", msg_type, e); - } else { - println!("[shell] ok {}", msg_type); - } - - Ok(()) - } - - fn control_handler(&self, comm_ctx: &CommContext) -> Result<(), AnyError> { - eprintln!("Unimplemented control_handler {:#?}", comm_ctx); - Ok(()) - } - - fn stdin_handler(&self, comm_ctx: &CommContext) -> Result<(), AnyError> { - eprintln!("Unimplemented stdin_handler {:#?}", comm_ctx); - Ok(()) - } - - async fn set_state(&mut self, comm_ctx: &CommContext, state: KernelState) { - if self.state == state { - println!("[DENO] set_state sets the same state: {:#?}", state); - return; - } - - self.state = state; - - let s = match state { - KernelState::Busy => "busy", - KernelState::Idle => "idle", - KernelState::Starting => "starting", - }; - - let content = KernelStatusContent { - execution_state: s.to_string(), - }; - - if let Err(e) = self.iopub_comm.send_status(comm_ctx, content).await { - println!("[IoPub] Error setting state: {}, reason: {}", s, e); - } - } - - async fn kernel_info_reply( - &mut self, - comm_ctx: &CommContext, - ) -> Result<(), AnyError> { - let content = KernelInfoReplyContent { - status: String::from("ok"), - protocol_version: self.metadata.protocol_version.clone(), - implementation_version: self.metadata.kernel_version.clone(), - implementation: self.metadata.implementation_name.clone(), - language_info: KernelLanguageInfo { - name: self.metadata.language.clone(), - version: self.metadata.language_version.clone(), - mimetype: self.metadata.mime.clone(), - file_extension: self.metadata.file_ext.clone(), - }, - help_links: vec![KernelHelpLink { - text: self.metadata.help_text.clone(), - url: self.metadata.help_url.clone(), - }], - banner: self.metadata.banner.clone(), - debugger: false, - }; - - self - .shell_comm - .send_kernel_info_reply(comm_ctx, content) - .await?; - - Ok(()) - } - - async fn execute_request( - &mut self, - comm_ctx: &CommContext, - ) -> Result<(), AnyError> { - self.execution_count += 1; - - let exec_request_content = match &comm_ctx.message.content { - RequestContent::Execute(c) => c, - _ => return Err(anyhow!("malformed execution content")), - }; - - let content = ExecuteInputContent { - code: exec_request_content.code.clone(), - execution_count: self.execution_count, - }; - self - .iopub_comm - .send_execute_input(comm_ctx, content) - .await?; - - let evaluate_response = self - .repl_session - .evaluate_line_with_object_wrapping(&exec_request_content.code) - .await?; - - let repl::cdp::EvaluateResponse { - result, - exception_details, - } = evaluate_response.value; - - if let Some(exception_details) = exception_details { - let name = if let Some(exception) = exception_details.exception { - if let Some(description) = exception.description { - description - } else if let Some(value) = exception.value { - value.to_string() - } else { - "undefined".to_string() - } - } else { - "Unknown exception".to_string() - }; - let e = ExecError { - err_name: name, - err_value: "".to_string(), - stack_trace: vec![], - }; - - println!("sending exec reply error {}", self.execution_count); - self - .shell_comm - .send_execute_error( - comm_ctx, - ExecuteErrorContent { - execution_count: self.execution_count, - status: "error".to_string(), - payload: vec![], - user_expressions: json!({}), - // TODO(apowers313) implement error messages - ename: e.err_name.clone(), - evalue: e.err_value.clone(), - traceback: e.stack_trace.clone(), - }, - ) - .await?; - self - .iopub_comm - .send_error( - comm_ctx, - ErrorContent { - ename: e.err_name.clone(), - evalue: e.err_value.clone(), - traceback: e.stack_trace.clone(), - }, - ) - .await?; - } else { - let output = self.repl_session.get_eval_value(&result).await?; - println!("sending exec result {}", self.execution_count); - self - .shell_comm - .send_execute_reply( - comm_ctx, - ExecuteReplyContent { - status: "ok".to_string(), - execution_count: self.execution_count, - // NOTE(bartlomieju): these two fields are always empty - payload: vec![], - user_expressions: json!({}), - }, - ) - .await?; - self - .iopub_comm - .send_execute_result( - comm_ctx, - ExecuteResultContent { - execution_count: self.execution_count, - data: json!({ - "text/plain": output, - }), - // data: json!(""), - metadata: json!({}), - }, - ) - .await?; - }; - - Ok(()) - } - - async fn send_stdio( - &mut self, - comm_ctx: &CommContext, - t: StdioType, - text: &str, - ) -> Result<(), AnyError> { - let content = StreamContent { - name: match t { - StdioType::Stdout => "stdout".to_string(), - StdioType::Stderr => "stderr".to_string(), - }, - text: text.to_string(), - }; - self.iopub_comm.send_stream(comm_ctx, content).await?; - Ok(()) - } -} - -struct ExecError { - err_name: String, - err_value: String, - stack_trace: Vec, -} - -#[derive(Debug)] -struct KernelMetadata { - banner: String, - file_ext: String, - help_text: String, - help_url: String, - implementation_name: String, - kernel_version: String, - language_version: String, - language: String, - mime: String, - protocol_version: String, -} - -impl Default for KernelMetadata { - fn default() -> Self { - Self { - banner: "Welcome to Deno kernel".to_string(), - file_ext: ".ts".to_string(), - help_text: "Visit Deno manual".to_string(), - help_url: "https://deno.land/manual".to_string(), - implementation_name: "Deno kernel".to_string(), - kernel_version: crate::version::deno().to_string(), - language_version: crate::version::TYPESCRIPT.to_string(), - language: "typescript".to_string(), - mime: "text/x.typescript".to_string(), - protocol_version: "5.3".to_string(), - } - } -} - #[derive(Debug, Deserialize)] pub struct ConnectionSpec { ip: String, @@ -594,9 +119,3 @@ pub struct ConnectionSpec { iopub_port: u32, key: String, } - -#[derive(Debug)] -enum StdioType { - Stdout, - Stderr, -} diff --git a/cli/tools/jupyter/server.rs b/cli/tools/jupyter/server.rs index e6d190deacc741..7558f9d51d3eac 100644 --- a/cli/tools/jupyter/server.rs +++ b/cli/tools/jupyter/server.rs @@ -4,31 +4,17 @@ // Copyright 2020 The Evcxr Authors. MIT license. use std::cell::RefCell; -use std::path::Path; use std::rc::Rc; +use std::sync::Arc; -use crate::args::Flags; -use crate::args::JupyterFlags; use crate::tools::repl; -use crate::util::logger; -use crate::CliFactory; -use deno_core::anyhow::anyhow; -use deno_core::anyhow::Context; -use deno_core::error::generic_error; use deno_core::error::AnyError; use deno_core::futures; use deno_core::futures::channel::mpsc; use deno_core::futures::StreamExt; -use deno_core::op; -use deno_core::resolve_url_or_path; -use deno_core::serde::Deserialize; use deno_core::serde_json; use deno_core::serde_json::json; -use deno_core::Op; -use deno_core::OpState; -use deno_runtime::permissions::Permissions; -use deno_runtime::permissions::PermissionsContainer; -use ring::hmac; +use tokio::sync::Mutex; use zeromq::SocketRecv; use zeromq::SocketSend; @@ -44,28 +30,18 @@ pub enum StdioMsg { pub struct JupyterServer { execution_count: usize, last_execution_request: Rc>>, - iopub_socket: Connection, + // This is Arc>, so we don't hold RefCell borrows across await + // points. + iopub_socket: Arc>>, repl_session: repl::ReplSession, } impl JupyterServer { pub async fn start( - connection_filepath: &Path, - stdio_rx: mpsc::UnboundedReceiver, + spec: ConnectionSpec, + mut stdio_rx: mpsc::UnboundedReceiver, repl_session: repl::ReplSession, ) -> Result<(), AnyError> { - let conn_file = - std::fs::read_to_string(connection_filepath).with_context(|| { - format!("Couldn't read connection file: {:?}", connection_filepath) - })?; - let spec: ConnectionSpec = - serde_json::from_str(&conn_file).with_context(|| { - format!( - "Connection file is not a valid JSON: {:?}", - connection_filepath - ) - })?; - let mut heartbeat = bind_socket::(&spec, spec.hb_port).await?; let shell_socket = @@ -76,11 +52,13 @@ impl JupyterServer { bind_socket::(&spec, spec.stdin_port).await?; let iopub_socket = bind_socket::(&spec, spec.iopub_port).await?; + let iopub_socket = Arc::new(Mutex::new(iopub_socket)); + let last_execution_request = Rc::new(RefCell::new(None)); let mut server = Self { execution_count: 0, - iopub_socket, - last_execution_request: Rc::new(RefCell::new(None)), + iopub_socket: iopub_socket.clone(), + last_execution_request: last_execution_request.clone(), repl_session, }; @@ -97,37 +75,36 @@ impl JupyterServer { }); let handle3 = deno_core::unsync::spawn(async move { - if let Err(err) = (&mut server).handle_shell(shell_socket).await { + if let Err(err) = server.handle_shell(shell_socket).await { eprintln!("Shell error: {}", err); } }); - let r = futures::try_join!(handle1, handle2, handle3)?; - - // deno_core::unsync::spawn(async move { - // // TODO: handle only if there's a pending execution request - // while let Some(stdio_msg) = stdio_rx.next().await { - // if let Some(exec_request) = server.last_execution_request.as_ref() { - // let (name, text) = match stdio_msg { - // StdioMsg::Stdout(text) => ("stdout", text), - // StdioMsg::Stderr(text) => ("stderr", text), - // }; - - // let result = exec_request - // .new_message("stream") - // .with_content(json!({ - // "name": name, - // "text": text - // })) - // .send(&mut iopub_socket2) - // .await; + let handle4 = deno_core::unsync::spawn(async move { + while let Some(stdio_msg) = stdio_rx.next().await { + if let Some(exec_request) = last_execution_request.borrow().clone() { + let (name, text) = match stdio_msg { + StdioMsg::Stdout(text) => ("stdout", text), + StdioMsg::Stderr(text) => ("stderr", text), + }; + + let result = exec_request + .new_message("stream") + .with_content(json!({ + "name": name, + "text": text + })) + .send(&mut *iopub_socket.lock().await) + .await; + + if let Err(err) = result { + eprintln!("Output {} error: {}", name, err); + } + } + } + }); - // if let Err(err) = result { - // eprintln!("Output {} error: {}", name, err); - // } - // } - // } - // }); + futures::try_join!(handle1, handle2, handle3, handle4)?; Ok(()) } @@ -187,7 +164,7 @@ impl JupyterServer { msg .new_message("status") .with_content(json!({"execution_state": "busy"})) - .send(&mut self.iopub_socket) + .send(&mut *self.iopub_socket.lock().await) .await?; match msg.message_type() { @@ -213,7 +190,7 @@ impl JupyterServer { "comm_open" => { msg .comm_close_message() - .send(&mut self.iopub_socket) + .send(&mut *self.iopub_socket.lock().await) .await?; } "complete_request" => todo!(), @@ -228,7 +205,7 @@ impl JupyterServer { msg .new_message("status") .with_content(json!({"execution_state": "idle"})) - .send(&mut self.iopub_socket) + .send(&mut *self.iopub_socket.lock().await) .await?; Ok(()) } @@ -247,7 +224,7 @@ impl JupyterServer { "execution_count": self.execution_count, "code": msg.code() })) - .send(&mut self.iopub_socket) + .send(&mut *self.iopub_socket.lock().await) .await?; let evaluate_response = self @@ -271,7 +248,7 @@ impl JupyterServer { }, "metadata": {}, })) - .send(&mut self.iopub_socket) + .send(&mut *self.iopub_socket.lock().await) .await?; msg .new_reply() @@ -303,7 +280,7 @@ impl JupyterServer { "evalue": "", "traceback": [], })) - .send(&mut self.iopub_socket) + .send(&mut *self.iopub_socket.lock().await) .await?; msg .new_reply() From fc82cf5322db98f01529e64f97d8e3ab9289143e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Tue, 5 Sep 2023 17:14:08 +0200 Subject: [PATCH 092/115] update --- integration_test.ipynb | 400 ++++------------------------------------- 1 file changed, 39 insertions(+), 361 deletions(-) diff --git a/integration_test.ipynb b/integration_test.ipynb index d3121ebdee5f08..083898f9a237db 100644 --- a/integration_test.ipynb +++ b/integration_test.ipynb @@ -1452,232 +1452,6 @@ "Promise.reject(new Error(\"it failed!\"));" ] }, - { - "attachments": {}, - "cell_type": "markdown", - "id": "3a89dada", - "metadata": { - "hidden": true - }, - "source": [ - "#### object with Symbol(\"toPng\") should return an image (TODO)" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "id": "46da2b23", - "metadata": {}, - "source": [ - "### User API" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "id": "64d6cb2c", - "metadata": {}, - "source": [ - "#### Deno.jupyter.display()" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "959bf8a6", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "testing 1 2 3" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "let displayBuf1 = new TextEncoder().encode(\"testing 1 2 3\");\n", - "Deno.jupyter.display(\"text/plain\", displayBuf1, {dataFormat: \"string\"});" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "68203ac8", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "let displayBuf2 = Deno.readFileSync(\"./cli/tests/testdata/jupyter/test.png\");\n", - "Deno.jupyter.display(\"image/png\", displayBuf2);" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "e1fb4d47", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "

This is a heading

And this is some text." - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "let displayBuf3 = new TextEncoder().encode(\"

This is a heading

And this is some text.\");\n", - "Deno.jupyter.display(\"text/html\", displayBuf3, {dataFormat: \"string\"});" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "id": "887ef658", - "metadata": {}, - "source": [ - "#### PNG" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "53e74633", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Promise {\n", - " \u001b[31m\u001b[39m TypeError: Deno.fileRead is not a function\n", - " at Object.displayPngFile (deno:runtime/js/40_jupyter.js:23:28)\n", - " at :2:14\n", - "}" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "await Deno.jupyter.displayPngFile(\"./cli/tests/testdata/jupyter/test.png\");" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "215e9465", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "let pngBuf1 = await Deno.readFile(\"./cli/tests/testdata/jupyter/test.png\");\n", - "Deno.jupyter.displayPng(pngBuf1);" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "de6764fb", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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" - }, - "metadata": { - "image/png": { - "height": 60, - "width": 80 - } - }, - "output_type": "display_data" - } - ], - "source": [ - "let pngBuf1 = await Deno.readFile(\"./cli/tests/testdata/jupyter/test.png\");\n", - "Deno.jupyter.displayPng(pngBuf1, {width: 80, height: 60});" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "id": "85747c36", - "metadata": {}, - "source": [ - "#### HTML" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "1b599abd", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "

Dummy Heading

\n", - "Dummy text." - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "await Deno.jupyter.displayHtmlFile(\"./cli/tests/testdata/jupyter/test.html\");" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "f8e1dbb8", - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "

This is a test

" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "Deno.jupyter.displayHtml(\"

This is a test

\");" - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "id": "ed389024", - "metadata": {}, - "source": [ - "### prints an error message and stack trace" - ] - }, { "cell_type": "code", "execution_count": null, @@ -1732,173 +1506,77 @@ }, { "cell_type": "code", - "execution_count": null, - "id": "cb45353d", - "metadata": {}, - "outputs": [], - "source": [ - "import * as vl from \"https://esm.sh/vega-lite-api@5\";" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "a5040c10", - "metadata": {}, - "outputs": [], - "source": [ - "const data = [{ key: \"A\", value: 4}, {key: \"B\", value:8}, {key:\"C\", value: 2}, {key: \"D\", value: 7}, {key:\"E\", value: 4}];" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "45f822af", - "metadata": {}, - "outputs": [], - "source": [ - "data" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "d918135f", - "metadata": {}, - "outputs": [], - "source": [ - "const vlSpec = vl.markBar()\n", - " .encode(\n", - " vl.x().fieldO(\"key\"),\n", - " vl.y().fieldQ(\"value\")\n", - " )\n", - " .height(200)\n", - " .data(data)\n", - " .toObject();" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "5ad0d21b", + "execution_count": 1, + "id": "0d2c6eaa", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{\n", - " mark: { type: \u001b[32m\"bar\"\u001b[39m },\n", - " encoding: {\n", - " x: { field: \u001b[32m\"key\"\u001b[39m, type: \u001b[32m\"ordinal\"\u001b[39m },\n", - " y: { field: \u001b[32m\"value\"\u001b[39m, type: \u001b[32m\"quantitative\"\u001b[39m }\n", - " },\n", - " height: \u001b[33m200\u001b[39m,\n", - " data: {\n", - " values: [\n", - " { key: \u001b[32m\"A\"\u001b[39m, value: \u001b[33m4\u001b[39m },\n", - " { key: \u001b[32m\"B\"\u001b[39m, value: \u001b[33m8\u001b[39m },\n", - " { key: \u001b[32m\"C\"\u001b[39m, value: \u001b[33m2\u001b[39m },\n", - " { key: \u001b[32m\"D\"\u001b[39m, value: \u001b[33m7\u001b[39m },\n", - " { key: \u001b[32m\"E\"\u001b[39m, value: \u001b[33m4\u001b[39m }\n", - " ]\n", - " }\n", - "}" + "\u001b[90mundefined\u001b[39m" ] }, - "execution_count": 6, + "execution_count": 1, "metadata": {}, "output_type": "execute_result" - } - ], - "source": [ - "vlSpec" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "80da0dcd", - "metadata": {}, - "outputs": [ + }, { - "data": { - "application/vnd.vegalite.v3+json": { - "data": { - "values": [ - { - "key": "A", - "value": 4 - }, - { - "key": "B", - "value": 8 - }, - { - "key": "C", - "value": 2 - }, - { - "key": "D", - "value": 7 - }, - { - "key": "E", - "value": 4 - } - ] - }, - "encoding": { - "x": { - "field": "key", - "type": "ordinal" - }, - "y": { - "field": "value", - "type": "quantitative" - } - }, - "height": 200, - "mark": { - "type": "bar" - } - } - }, - "metadata": { - "application/vnd.vegalite.v3+json": {} - }, - "output_type": "display_data" + "name": "stdout", + "output_type": "stream", + "text": [ + "[ \u001b[32m\"users\"\u001b[39m, \u001b[32m\"alice\"\u001b[39m ]\n", + "{ name: \u001b[32m\"Alice\"\u001b[39m }\n" + ] } ], "source": [ - "Deno.jupyter.displayVegaLite(vlSpec)" + "// Open the default database for the script.\n", + "const kv = await Deno.openKv();\n", + "\n", + "// Persist an object at the users/alice key.\n", + "await kv.set([\"users\", \"alice\"], { name: \"Alice\" });\n", + "\n", + "// Read back this key.\n", + "const res = await kv.get([\"users\", \"alice\"]);\n", + "console.log(res.key); // [ \"users\", \"alice\" ]\n", + "console.log(res.value); // { name: \"Alice\" }" ] }, { "cell_type": "code", "execution_count": 2, - "id": "c6e1c8b9", + "id": "a761bd6c-1eb0-4171-80e9-75e3710cef27", "metadata": {}, "outputs": [ { "data": { - "text/html": [ - "" + "text/plain": [ + "\u001b[90mundefined\u001b[39m" ] }, - "metadata": { - "text/html": {} - }, - "output_type": "display_data" + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ \u001b[32m\"users\"\u001b[39m, \u001b[32m\"alice\"\u001b[39m ]\n", + "{ name: \u001b[32m\"Alice\"\u001b[39m }\n" + ] } ], "source": [ - "Deno.jupyter.displayHtml('');" + "const res2 = await kv.get([\"users\", \"alice\"]);\n", + "console.log(res2.key); // [ \"users\", \"alice\" ]\n", + "console.log(res2.value); // null" ] }, { "cell_type": "code", "execution_count": null, - "id": "2c4a440c", + "id": "08976272-4a23-4371-a253-6cd9c9a1caab", "metadata": {}, "outputs": [], "source": [] From 873b634176e99fa479b1ee6bcbea51a84af7b018 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Fri, 8 Sep 2023 06:55:43 +0200 Subject: [PATCH 093/115] graceful shutdown --- cli/tools/jupyter/server.rs | 34 +++++++++++++++++++++++++++++----- 1 file changed, 29 insertions(+), 5 deletions(-) diff --git a/cli/tools/jupyter/server.rs b/cli/tools/jupyter/server.rs index 7558f9d51d3eac..1281e25cbdd365 100644 --- a/cli/tools/jupyter/server.rs +++ b/cli/tools/jupyter/server.rs @@ -11,6 +11,9 @@ use crate::tools::repl; use deno_core::error::AnyError; use deno_core::futures; use deno_core::futures::channel::mpsc; +use deno_core::futures::future::Either; +use deno_core::futures::FutureExt; +use deno_core::futures::SinkExt; use deno_core::futures::StreamExt; use deno_core::serde_json; use deno_core::serde_json::json; @@ -55,6 +58,8 @@ impl JupyterServer { let iopub_socket = Arc::new(Mutex::new(iopub_socket)); let last_execution_request = Rc::new(RefCell::new(None)); + let (shutdown_tx, mut shutdown_rx) = mpsc::unbounded(); + let mut server = Self { execution_count: 0, iopub_socket: iopub_socket.clone(), @@ -69,7 +74,8 @@ impl JupyterServer { }); let handle2 = deno_core::unsync::spawn(async move { - if let Err(err) = Self::handle_control(control_socket).await { + if let Err(err) = Self::handle_control(control_socket, shutdown_tx).await + { eprintln!("Control error: {}", err); } }); @@ -104,7 +110,17 @@ impl JupyterServer { } }); - futures::try_join!(handle1, handle2, handle3, handle4)?; + let shutdown_fut = async move { + let _ = shutdown_rx.next().await; + } + .boxed_local(); + let join_fut = + futures::future::try_join_all(vec![handle1, handle2, handle3, handle4]); + if let Either::Left((join_fut, _)) = + futures::future::select(join_fut, shutdown_fut).await + { + join_fut?; + }; Ok(()) } @@ -123,6 +139,7 @@ impl JupyterServer { async fn handle_control( mut connection: Connection, + mut shutdown_tx: mpsc::UnboundedSender<()>, ) -> Result<(), AnyError> { loop { let msg = JupyterMessage::read(&mut connection).await?; @@ -134,8 +151,12 @@ impl JupyterServer { .send(&mut connection) .await?; } - "shutdown_request" => todo!(), - "interrupt_request" => todo!(), + "shutdown_request" => { + let _ = shutdown_tx.send(()).await; + } + "interrupt_request" => { + eprintln!("Interrupt request currently not supported"); + } _ => { eprintln!( "Unrecognized control message type: {}", @@ -316,7 +337,10 @@ fn kernel_info() -> serde_json::Value { "name": "typescript", "version": crate::version::TYPESCRIPT, "mimetype": "text/x.typescript", - "file_extension": ".ts" + "file_extension": ".ts", + "pygments_lexer": "typescript", + // TODO(bartlomieju): + // "nb_converter": }, "help_links": [{ "text": "Visit Deno manual", From 433c2c6920ab06a1552b33ca0b25312c6870ef49 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Sun, 10 Sep 2023 12:30:59 +0200 Subject: [PATCH 094/115] fix npm package imports --- cli/module_loader.rs | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/cli/module_loader.rs b/cli/module_loader.rs index 67811304bcbc7d..4a1e0b671bea0c 100644 --- a/cli/module_loader.rs +++ b/cli/module_loader.rs @@ -330,7 +330,10 @@ impl CliModuleLoaderFactory { lib_window: options.ts_type_lib_window(), lib_worker: options.ts_type_lib_worker(), is_inspecting: options.is_inspecting(), - is_repl: matches!(options.sub_command(), DenoSubcommand::Repl(_)), + is_repl: matches!( + options.sub_command(), + DenoSubcommand::Repl(_) | DenoSubcommand::Jupyter(_) + ), prepared_module_loader: PreparedModuleLoader { emitter, graph_container: graph_container.clone(), From e72b5d0c9bfef6685d2e8c7830efa59945afa373 Mon Sep 17 00:00:00 2001 From: Kyle Kelley Date: Sun, 10 Sep 2023 06:48:33 -0700 Subject: [PATCH 095/115] send a completion response --- cli/tools/jupyter/jupyter_msg.rs | 4 ++++ cli/tools/jupyter/mod.rs | 3 ++- cli/tools/jupyter/server.rs | 36 +++++++++++++++++++++++++++++++- 3 files changed, 41 insertions(+), 2 deletions(-) diff --git a/cli/tools/jupyter/jupyter_msg.rs b/cli/tools/jupyter/jupyter_msg.rs index d15463c974dbc0..0cafede224838d 100644 --- a/cli/tools/jupyter/jupyter_msg.rs +++ b/cli/tools/jupyter/jupyter_msg.rs @@ -157,6 +157,10 @@ impl JupyterMessage { self.content["code"].as_str().unwrap_or("") } + pub(crate) fn cursor_pos(&self) -> usize { + self.content["cursor_pos"].as_u64().unwrap_or(0) as usize + } + pub(crate) fn comm_id(&self) -> &str { self.content["comm_id"].as_str().unwrap_or("") } diff --git a/cli/tools/jupyter/mod.rs b/cli/tools/jupyter/mod.rs index 2af0e06708b2f5..d4a6281d3bcbcb 100644 --- a/cli/tools/jupyter/mod.rs +++ b/cli/tools/jupyter/mod.rs @@ -21,6 +21,7 @@ mod install; mod jupyter_msg; mod server; + pub async fn kernel( flags: Flags, jupyter_flags: JupyterFlags, @@ -72,7 +73,7 @@ pub async fn kernel( let repl_session = repl::ReplSession::initialize(cli_options, npm_resolver, resolver, worker) .await?; - + server::JupyterServer::start(spec, stdio_rx, repl_session).await?; Ok(()) diff --git a/cli/tools/jupyter/server.rs b/cli/tools/jupyter/server.rs index 1281e25cbdd365..56b567b170a94a 100644 --- a/cli/tools/jupyter/server.rs +++ b/cli/tools/jupyter/server.rs @@ -214,7 +214,41 @@ impl JupyterServer { .send(&mut *self.iopub_socket.lock().await) .await?; } - "complete_request" => todo!(), + "complete_request" => { + + let user_code = msg.code(); + let cursor_pos = msg.cursor_pos(); + + let completions = self.repl_session.language_server.completions(user_code, cursor_pos).await; + + let matches: Vec = completions + .iter() + .map(|item| item.new_text.clone()) + .collect(); + + let cursor_start = completions + .first() + .map(|item| item.range.start) + .unwrap_or(cursor_pos); + + let cursor_end = completions + .last() + .map(|item| item.range.end) + .unwrap_or(cursor_pos); + + + msg + .new_reply() + .with_content(json!({ + "status": "ok", + "matches": matches, + "cursor_start": cursor_start, + "cursor_end": cursor_end, + "metadata": {}, + })) + .send(connection) + .await?; + } "comm_msg" | "comm_info_request" | "history_request" => { // We don't handle these messages } From 9d07dde485ed6f963cead933ec455dbaeda96bda Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Mon, 11 Sep 2023 00:30:56 +0200 Subject: [PATCH 096/115] make completions work --- cli/tools/jupyter/server.rs | 265 ++++++++++++++++++++++++++++++++---- cli/tools/repl/mod.rs | 3 + 2 files changed, 238 insertions(+), 30 deletions(-) diff --git a/cli/tools/jupyter/server.rs b/cli/tools/jupyter/server.rs index 56b567b170a94a..58951fdb34e550 100644 --- a/cli/tools/jupyter/server.rs +++ b/cli/tools/jupyter/server.rs @@ -8,6 +8,7 @@ use std::rc::Rc; use std::sync::Arc; use crate::tools::repl; +use crate::tools::repl::cdp; use deno_core::error::AnyError; use deno_core::futures; use deno_core::futures::channel::mpsc; @@ -215,39 +216,93 @@ impl JupyterServer { .await?; } "complete_request" => { - let user_code = msg.code(); let cursor_pos = msg.cursor_pos(); + eprintln!("complete request {} {}", user_code, cursor_pos); + + let lsp_completions = self + .repl_session + .language_server + .completions(user_code, cursor_pos) + .await; + + if !lsp_completions.is_empty() { + let matches: Vec = lsp_completions + .iter() + .map(|item| item.new_text.clone()) + .collect(); + + let cursor_start = lsp_completions + .first() + .map(|item| item.range.start) + .unwrap_or(cursor_pos); + + let cursor_end = lsp_completions + .last() + .map(|item| item.range.end) + .unwrap_or(cursor_pos); - let completions = self.repl_session.language_server.completions(user_code, cursor_pos).await; - - let matches: Vec = completions - .iter() - .map(|item| item.new_text.clone()) - .collect(); - - let cursor_start = completions - .first() - .map(|item| item.range.start) - .unwrap_or(cursor_pos); - - let cursor_end = completions - .last() - .map(|item| item.range.end) - .unwrap_or(cursor_pos); - - - msg - .new_reply() - .with_content(json!({ - "status": "ok", - "matches": matches, - "cursor_start": cursor_start, - "cursor_end": cursor_end, - "metadata": {}, - })) - .send(connection) - .await?; + msg + .new_reply() + .with_content(json!({ + "status": "ok", + "matches": matches, + "cursor_start": cursor_start, + "cursor_end": cursor_end, + "metadata": {}, + })) + .send(connection) + .await?; + } else { + let expr = get_expr_from_line_at_pos(user_code, cursor_pos); + // check if the expression is in the form `obj.prop` + let (completions, cursor_start) = if let Some(index) = expr.rfind('.') + { + let sub_expr = &expr[..index]; + let prop_name = &expr[index + 1..]; + let candidates = + get_expression_property_names(&mut self.repl_session, sub_expr) + .await + .into_iter() + .filter(|n| { + !n.starts_with("Symbol(") + && n.starts_with(prop_name) + && n != &*repl::REPL_INTERNALS_NAME + }) + .collect(); + + (candidates, cursor_pos - prop_name.len()) + } else { + // combine results of declarations and globalThis properties + let mut candidates = get_expression_property_names( + &mut self.repl_session, + "globalThis", + ) + .await + .into_iter() + .chain(get_global_lexical_scope_names(&mut self.repl_session).await) + .filter(|n| n.starts_with(expr) && n != &*repl::REPL_INTERNALS_NAME) + .collect::>(); + + // sort and remove duplicates + candidates.sort(); + candidates.dedup(); // make sure to sort first + + (candidates, cursor_pos - expr.len()) + }; + eprintln!("completions {:#?}", completions); + msg + .new_reply() + .with_content(json!({ + "status": "ok", + "matches": completions, + "cursor_start": cursor_start, + "cursor_end": cursor_start, + "metadata": {}, + })) + .send(connection) + .await?; + } } "comm_msg" | "comm_info_request" | "history_request" => { // We don't handle these messages @@ -383,3 +438,153 @@ fn kernel_info() -> serde_json::Value { "banner": "Welcome to Deno kernel", }) } + +// TODO(bartlomieju): dedup with repl::editor +fn get_expr_from_line_at_pos(line: &str, cursor_pos: usize) -> &str { + let start = line[..cursor_pos].rfind(is_word_boundary).unwrap_or(0); + let end = line[cursor_pos..] + .rfind(is_word_boundary) + .map(|i| cursor_pos + i) + .unwrap_or(cursor_pos); + + let word = &line[start..end]; + let word = word.strip_prefix(is_word_boundary).unwrap_or(word); + let word = word.strip_suffix(is_word_boundary).unwrap_or(word); + + word +} + +// TODO(bartlomieju): dedup with repl::editor +fn is_word_boundary(c: char) -> bool { + if matches!(c, '.' | '_' | '$') { + false + } else { + char::is_ascii_whitespace(&c) || char::is_ascii_punctuation(&c) + } +} + +// TODO(bartlomieju): dedup with repl::editor +async fn get_global_lexical_scope_names( + session: &mut repl::ReplSession, +) -> Vec { + let evaluate_response = session + .post_message_with_event_loop( + "Runtime.globalLexicalScopeNames", + Some(cdp::GlobalLexicalScopeNamesArgs { + execution_context_id: Some(session.context_id), + }), + ) + .await + .unwrap(); + let evaluate_response: cdp::GlobalLexicalScopeNamesResponse = + serde_json::from_value(evaluate_response).unwrap(); + evaluate_response.names +} + +// TODO(bartlomieju): dedup with repl::editor +async fn get_expression_property_names( + session: &mut repl::ReplSession, + expr: &str, +) -> Vec { + // try to get the properties from the expression + if let Some(properties) = get_object_expr_properties(session, expr).await { + return properties; + } + + // otherwise fall back to the prototype + let expr_type = get_expression_type(session, expr).await; + let object_expr = match expr_type.as_deref() { + // possibilities: https://chromedevtools.github.io/devtools-protocol/v8/Runtime/#type-RemoteObject + Some("object") => "Object.prototype", + Some("function") => "Function.prototype", + Some("string") => "String.prototype", + Some("boolean") => "Boolean.prototype", + Some("bigint") => "BigInt.prototype", + Some("number") => "Number.prototype", + _ => return Vec::new(), // undefined, symbol, and unhandled + }; + + get_object_expr_properties(session, object_expr) + .await + .unwrap_or_default() +} + +// TODO(bartlomieju): dedup with repl::editor +async fn get_expression_type( + session: &mut repl::ReplSession, + expr: &str, +) -> Option { + evaluate_expression(session, expr) + .await + .map(|res| res.result.kind) +} + +// TODO(bartlomieju): dedup with repl::editor +async fn get_object_expr_properties( + session: &mut repl::ReplSession, + object_expr: &str, +) -> Option> { + let evaluate_result = evaluate_expression(session, object_expr).await?; + let object_id = evaluate_result.result.object_id?; + + let get_properties_response = session + .post_message_with_event_loop( + "Runtime.getProperties", + Some(cdp::GetPropertiesArgs { + object_id, + own_properties: None, + accessor_properties_only: None, + generate_preview: None, + non_indexed_properties_only: Some(true), + }), + ) + .await + .ok()?; + let get_properties_response: cdp::GetPropertiesResponse = + serde_json::from_value(get_properties_response).ok()?; + Some( + get_properties_response + .result + .into_iter() + .map(|prop| prop.name) + .collect(), + ) +} + +// TODO(bartlomieju): dedup with repl::editor +async fn evaluate_expression( + session: &mut repl::ReplSession, + expr: &str, +) -> Option { + let evaluate_response = session + .post_message_with_event_loop( + "Runtime.evaluate", + Some(cdp::EvaluateArgs { + expression: expr.to_string(), + object_group: None, + include_command_line_api: None, + silent: None, + context_id: Some(session.context_id), + return_by_value: None, + generate_preview: None, + user_gesture: None, + await_promise: None, + throw_on_side_effect: Some(true), + timeout: Some(200), + disable_breaks: None, + repl_mode: None, + allow_unsafe_eval_blocked_by_csp: None, + unique_context_id: None, + }), + ) + .await + .ok()?; + let evaluate_response: cdp::EvaluateResponse = + serde_json::from_value(evaluate_response).ok()?; + + if evaluate_response.exception_details.is_some() { + None + } else { + Some(evaluate_response) + } +} diff --git a/cli/tools/repl/mod.rs b/cli/tools/repl/mod.rs index 0bca871e57de98..602b0252a05084 100644 --- a/cli/tools/repl/mod.rs +++ b/cli/tools/repl/mod.rs @@ -26,6 +26,7 @@ use editor::EditorHelper; use editor::ReplEditor; pub use session::EvaluationOutput; pub use session::ReplSession; +pub use session::REPL_INTERNALS_NAME; async fn read_line_and_poll( repl_session: &mut ReplSession, @@ -55,7 +56,9 @@ async fn read_line_and_poll( line_text, position, }) => { + eprintln!("repl completions {} {}", line_text, position); let result = repl_session.language_server.completions(&line_text, position).await; + eprintln!("completion result {:#?}", result); message_handler.send(RustylineSyncResponse::LspCompletions(result)).unwrap(); } None => {}, // channel closed From c8d7348e1b430ed6e8dea6c865a9191bc0d74219 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Mon, 11 Sep 2023 00:38:39 +0200 Subject: [PATCH 097/115] fix cursor position --- cli/tools/jupyter/server.rs | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/cli/tools/jupyter/server.rs b/cli/tools/jupyter/server.rs index 58951fdb34e550..12355c92a672db 100644 --- a/cli/tools/jupyter/server.rs +++ b/cli/tools/jupyter/server.rs @@ -290,14 +290,17 @@ impl JupyterServer { (candidates, cursor_pos - expr.len()) }; - eprintln!("completions {:#?}", completions); + eprintln!( + "completions {} {} {:#?}", + cursor_pos, cursor_start, completions + ); msg .new_reply() .with_content(json!({ "status": "ok", "matches": completions, "cursor_start": cursor_start, - "cursor_end": cursor_start, + "cursor_end": cursor_pos, "metadata": {}, })) .send(connection) From 403e4a394f4a6e316b5eb0aced2a2f0bdbefe114 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Mon, 11 Sep 2023 02:29:46 +0200 Subject: [PATCH 098/115] implement display --- cli/tools/jupyter/server.rs | 87 +++++++++++++++++++++++++++++++++---- cli/tools/repl/session.rs | 54 +++++++++++++++-------- 2 files changed, 115 insertions(+), 26 deletions(-) diff --git a/cli/tools/jupyter/server.rs b/cli/tools/jupyter/server.rs index 12355c92a672db..7d0df272c5e0ab 100644 --- a/cli/tools/jupyter/server.rs +++ b/cli/tools/jupyter/server.rs @@ -4,6 +4,7 @@ // Copyright 2020 The Evcxr Authors. MIT license. use std::cell::RefCell; +use std::collections::HashMap; use std::rc::Rc; use std::sync::Arc; @@ -218,7 +219,6 @@ impl JupyterServer { "complete_request" => { let user_code = msg.code(); let cursor_pos = msg.cursor_pos(); - eprintln!("complete request {} {}", user_code, cursor_pos); let lsp_completions = self .repl_session @@ -290,10 +290,6 @@ impl JupyterServer { (candidates, cursor_pos - expr.len()) }; - eprintln!( - "completions {} {} {:#?}", - cursor_pos, cursor_start, completions - ); msg .new_reply() .with_content(json!({ @@ -351,14 +347,14 @@ impl JupyterServer { } = evaluate_response.value; if exception_details.is_none() { - let output = self.repl_session.get_eval_value(&result).await?; + let output = + get_jupyter_display_or_eval_value(&mut self.repl_session, &result) + .await?; msg .new_message("execute_result") .with_content(json!({ "execution_count": self.execution_count, - "data": { - "text/plain": output - }, + "data": output, "metadata": {}, })) .send(&mut *self.iopub_socket.lock().await) @@ -442,6 +438,79 @@ fn kernel_info() -> serde_json::Value { }) } +async fn get_jupyter_display_or_eval_value( + session: &mut repl::ReplSession, + evaluate_result: &cdp::RemoteObject, +) -> Result, AnyError> { + let mut data = HashMap::default(); + let response = session + .call_function_on_args( + r#"function (object) {{ + return object[Symbol.for("Jupyter.display")](); + }}"# + .to_string(), + &[evaluate_result.clone()], + ) + .await?; + + if response.exception_details.is_none() { + let object_id = response.result.object_id.unwrap(); + + if let Some(get_properties_response) = session + .post_message_with_event_loop( + "Runtime.getProperties", + Some(cdp::GetPropertiesArgs { + object_id, + own_properties: Some(true), + accessor_properties_only: None, + generate_preview: None, + non_indexed_properties_only: Some(true), + }), + ) + .await + .ok() + { + let get_properties_response: cdp::GetPropertiesResponse = + serde_json::from_value(get_properties_response).unwrap(); + + for prop in get_properties_response.result.into_iter() { + if let Some(value) = &prop.value { + data.insert( + prop.name.to_string(), + value + .value + .clone() + .unwrap_or_else(|| serde_json::Value::Null), + ); + } + } + + if !data.is_empty() { + return Ok(data); + } + } + } + + let response = session + .call_function_on_args( + format!( + r#"function (object) {{ + try {{ + return {0}.inspectArgs(["%o", object], {{ colors: !{0}.noColor }}); + }} catch (err) {{ + return {0}.inspectArgs(["%o", err]); + }} + }}"#, + *repl::REPL_INTERNALS_NAME + ), + &[evaluate_result.clone()], + ) + .await?; + let value = response.result.value.unwrap(); + data.insert("text/plain".to_string(), value); + Ok(data) +} + // TODO(bartlomieju): dedup with repl::editor fn get_expr_from_line_at_pos(line: &str, cursor_pos: usize) -> &str { let start = line[..cursor_pos].rfind(is_word_boundary).unwrap_or(0); diff --git a/cli/tools/repl/session.rs b/cli/tools/repl/session.rs index 5336590f47dedd..a1b602b4b5e3ef 100644 --- a/cli/tools/repl/session.rs +++ b/cli/tools/repl/session.rs @@ -396,29 +396,24 @@ impl ReplSession { Ok(()) } - pub async fn get_eval_value( + pub async fn call_function_on_args( &mut self, - evaluate_result: &cdp::RemoteObject, - ) -> Result { - // TODO(caspervonb) we should investigate using previews here but to keep things - // consistent with the previous implementation we just get the preview result from - // Deno.inspectArgs. + function_declaration: String, + args: &[cdp::RemoteObject], + ) -> Result { + let arguments: Option> = if args.is_empty() { + None + } else { + Some(args.iter().map(|a| a.into()).collect()) + }; + let inspect_response = self .post_message_with_event_loop( "Runtime.callFunctionOn", Some(cdp::CallFunctionOnArgs { - function_declaration: format!( - r#"function (object) {{ - try {{ - return {0}.inspectArgs(["%o", object], {{ colors: !{0}.noColor }}); - }} catch (err) {{ - return {0}.inspectArgs(["%o", err]); - }} - }}"#, - *REPL_INTERNALS_NAME - ), + function_declaration, object_id: None, - arguments: Some(vec![evaluate_result.into()]), + arguments, silent: None, return_by_value: None, generate_preview: None, @@ -433,6 +428,31 @@ impl ReplSession { let response: cdp::CallFunctionOnResponse = serde_json::from_value(inspect_response)?; + Ok(response) + } + + pub async fn get_eval_value( + &mut self, + evaluate_result: &cdp::RemoteObject, + ) -> Result { + // TODO(caspervonb) we should investigate using previews here but to keep things + // consistent with the previous implementation we just get the preview result from + // Deno.inspectArgs. + let response = self + .call_function_on_args( + format!( + r#"function (object) {{ + try {{ + return {0}.inspectArgs(["%o", object], {{ colors: !{0}.noColor }}); + }} catch (err) {{ + return {0}.inspectArgs(["%o", err]); + }} + }}"#, + *REPL_INTERNALS_NAME + ), + &[evaluate_result.clone()], + ) + .await?; let value = response.result.value.unwrap(); let s = value.as_str().unwrap(); From 2da3521256bdd142c4c82b48f256e0d032461e19 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Tue, 12 Sep 2023 13:19:59 +0200 Subject: [PATCH 099/115] fmt --- cli/tools/jupyter/mod.rs | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/cli/tools/jupyter/mod.rs b/cli/tools/jupyter/mod.rs index d4a6281d3bcbcb..2af0e06708b2f5 100644 --- a/cli/tools/jupyter/mod.rs +++ b/cli/tools/jupyter/mod.rs @@ -21,7 +21,6 @@ mod install; mod jupyter_msg; mod server; - pub async fn kernel( flags: Flags, jupyter_flags: JupyterFlags, @@ -73,7 +72,7 @@ pub async fn kernel( let repl_session = repl::ReplSession::initialize(cli_options, npm_resolver, resolver, worker) .await?; - + server::JupyterServer::start(spec, stdio_rx, repl_session).await?; Ok(()) From a3016df95f4109cf776adfd0989a10b8aa7d276b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Tue, 12 Sep 2023 13:36:20 +0200 Subject: [PATCH 100/115] simplify --- cli/tools/jupyter/server.rs | 88 ++++++++++++++++++++++--------------- 1 file changed, 52 insertions(+), 36 deletions(-) diff --git a/cli/tools/jupyter/server.rs b/cli/tools/jupyter/server.rs index 7d0df272c5e0ab..4c1d5744b2a8c2 100644 --- a/cli/tools/jupyter/server.rs +++ b/cli/tools/jupyter/server.rs @@ -438,10 +438,10 @@ fn kernel_info() -> serde_json::Value { }) } -async fn get_jupyter_display_or_eval_value( +async fn get_jupyter_display( session: &mut repl::ReplSession, evaluate_result: &cdp::RemoteObject, -) -> Result, AnyError> { +) -> Result>, AnyError> { let mut data = HashMap::default(); let response = session .call_function_on_args( @@ -453,44 +453,59 @@ async fn get_jupyter_display_or_eval_value( ) .await?; - if response.exception_details.is_none() { - let object_id = response.result.object_id.unwrap(); - - if let Some(get_properties_response) = session - .post_message_with_event_loop( - "Runtime.getProperties", - Some(cdp::GetPropertiesArgs { - object_id, - own_properties: Some(true), - accessor_properties_only: None, - generate_preview: None, - non_indexed_properties_only: Some(true), - }), - ) - .await - .ok() - { - let get_properties_response: cdp::GetPropertiesResponse = - serde_json::from_value(get_properties_response).unwrap(); - - for prop in get_properties_response.result.into_iter() { - if let Some(value) = &prop.value { - data.insert( - prop.name.to_string(), - value - .value - .clone() - .unwrap_or_else(|| serde_json::Value::Null), - ); - } - } + if response.exception_details.is_some() { + return Ok(None); + } - if !data.is_empty() { - return Ok(data); - } + let object_id = response.result.object_id.unwrap(); + + let get_properties_response_result = session + .post_message_with_event_loop( + "Runtime.getProperties", + Some(cdp::GetPropertiesArgs { + object_id, + own_properties: Some(true), + accessor_properties_only: None, + generate_preview: None, + non_indexed_properties_only: Some(true), + }), + ) + .await; + + let Ok(get_properties_response) = get_properties_response_result else { + return Ok(None); + }; + + let get_properties_response: cdp::GetPropertiesResponse = + serde_json::from_value(get_properties_response).unwrap(); + + for prop in get_properties_response.result.into_iter() { + if let Some(value) = &prop.value { + data.insert( + prop.name.to_string(), + value + .value + .clone() + .unwrap_or_else(|| serde_json::Value::Null), + ); } } + if !data.is_empty() { + return Ok(Some(data)); + } + + Ok(None) +} + +async fn get_jupyter_display_or_eval_value( + session: &mut repl::ReplSession, + evaluate_result: &cdp::RemoteObject, +) -> Result, AnyError> { + if let Some(data) = get_jupyter_display(session, evaluate_result).await? { + return Ok(data); + } + let response = session .call_function_on_args( format!( @@ -507,6 +522,7 @@ async fn get_jupyter_display_or_eval_value( ) .await?; let value = response.result.value.unwrap(); + let mut data = HashMap::default(); data.insert("text/plain".to_string(), value); Ok(data) } From d276dbf727051ace3b684d48c03398b23d873a2a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Wed, 13 Sep 2023 21:30:31 +0200 Subject: [PATCH 101/115] syntax error forwards error to the frontend --- cli/tools/jupyter/server.rs | 28 ++++++++++++++++++++++++++-- 1 file changed, 26 insertions(+), 2 deletions(-) diff --git a/cli/tools/jupyter/server.rs b/cli/tools/jupyter/server.rs index 4c1d5744b2a8c2..09f377f8c248ef 100644 --- a/cli/tools/jupyter/server.rs +++ b/cli/tools/jupyter/server.rs @@ -336,10 +336,34 @@ impl JupyterServer { .send(&mut *self.iopub_socket.lock().await) .await?; - let evaluate_response = self + let result = self .repl_session .evaluate_line_with_object_wrapping(msg.code()) - .await?; + .await; + + let evaluate_response = match result { + Ok(eval_response) => eval_response, + Err(err) => { + msg + .new_message("error") + .with_content(json!({ + "ename": err.to_string(), + "evalue": "", + "traceback": [], + })) + .send(&mut *self.iopub_socket.lock().await) + .await?; + msg + .new_reply() + .with_content(json!({ + "status": "error", + "execution_count": self.execution_count, + })) + .send(connection) + .await?; + return Ok(()); + } + }; let repl::cdp::EvaluateResponse { result, From 35051c01b80a8b58d599789fe5418c3853f7b5e4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Wed, 13 Sep 2023 21:35:30 +0200 Subject: [PATCH 102/115] set nb converter --- cli/tools/jupyter/server.rs | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/cli/tools/jupyter/server.rs b/cli/tools/jupyter/server.rs index 09f377f8c248ef..9fe3e519d3de31 100644 --- a/cli/tools/jupyter/server.rs +++ b/cli/tools/jupyter/server.rs @@ -451,8 +451,7 @@ fn kernel_info() -> serde_json::Value { "mimetype": "text/x.typescript", "file_extension": ".ts", "pygments_lexer": "typescript", - // TODO(bartlomieju): - // "nb_converter": + "nb_converter": "script" }, "help_links": [{ "text": "Visit Deno manual", From fdaf27cb19a2103abe1e77153410f80276556213 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Wed, 13 Sep 2023 21:40:33 +0200 Subject: [PATCH 103/115] don't print undefined --- cli/tools/jupyter/server.rs | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/cli/tools/jupyter/server.rs b/cli/tools/jupyter/server.rs index 9fe3e519d3de31..006009ee22e965 100644 --- a/cli/tools/jupyter/server.rs +++ b/cli/tools/jupyter/server.rs @@ -525,6 +525,12 @@ async fn get_jupyter_display_or_eval_value( session: &mut repl::ReplSession, evaluate_result: &cdp::RemoteObject, ) -> Result, AnyError> { + // Printing "undefined" generates a lot of noise, so let's skip + // these. + if evaluate_result.kind == "undefined" { + return Ok(HashMap::default()); + } + if let Some(data) = get_jupyter_display(session, evaluate_result).await? { return Ok(data); } @@ -544,9 +550,11 @@ async fn get_jupyter_display_or_eval_value( &[evaluate_result.clone()], ) .await?; - let value = response.result.value.unwrap(); let mut data = HashMap::default(); - data.insert("text/plain".to_string(), value); + if let Some(value) = response.result.value { + data.insert("text/plain".to_string(), value); + } + Ok(data) } From 9ac3d8c3893fc62370c41cf922414b62ae1eb5c9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Fri, 15 Sep 2023 01:00:06 +0200 Subject: [PATCH 104/115] sleep for 5ms before returning from successful execution --- cli/tools/jupyter/server.rs | 5 ++ output_in_the_last_cell.ipynb | 135 ++++++++++++++++++++++++++++++++++ 2 files changed, 140 insertions(+) create mode 100644 output_in_the_last_cell.ipynb diff --git a/cli/tools/jupyter/server.rs b/cli/tools/jupyter/server.rs index 006009ee22e965..89dadb5941db85 100644 --- a/cli/tools/jupyter/server.rs +++ b/cli/tools/jupyter/server.rs @@ -391,6 +391,11 @@ impl JupyterServer { })) .send(connection) .await?; + // Let's sleep here for a few ms, so we give a chance to the task that is + // handling stdout and stderr streams to receive and flush the content. + // Otherwise, executing multiple cells one-by-one might lead to output + // from various cells be grouped together in another cell result. + tokio::time::sleep(std::time::Duration::from_millis(5)).await; } else { let exception_details = exception_details.unwrap(); let name = if let Some(exception) = exception_details.exception { diff --git a/output_in_the_last_cell.ipynb b/output_in_the_last_cell.ipynb new file mode 100644 index 00000000000000..612163a0126393 --- /dev/null +++ b/output_in_the_last_cell.ipynb @@ -0,0 +1,135 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "f84352c6-396a-4ca1-8c0d-454d56cb6ed6", + "metadata": {}, + "outputs": [ + { + "data": {}, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hello from Deno!\n" + ] + } + ], + "source": [ + "console.log(\"Hello from Deno!\")" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "be38548f-1d0c-43a0-93aa-184e8199cf1a", + "metadata": {}, + "outputs": [ + { + "data": {}, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "console.log(\"%c Hello Deno \", \"background-color: #15803d; color: white;\");" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "ba55dcd1-d519-4aed-8013-8c9af3289c1d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\u001b[32m\"Cool 🫡\"\u001b[39m" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\"Cool 🫡\"" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "546b4612-9501-4841-b06e-7988f8041ec2", + "metadata": {}, + "outputs": [ + { + "data": {}, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "console.table([1, 2, 3])" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "d0461ec4-3327-4222-9868-129dc7dd43ec", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\u001b[33m3\u001b[39m" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[48;2;21;128;61m\u001b[37m Hello Deno \u001b[0m\n", + "┌───────┬────────┐\n", + "│ (idx) │ Values │\n", + "├───────┼────────┤\n", + "│ 0 │ 1 │\n", + "│ 1 │ 2 │\n", + "│ 2 │ 3 │\n", + "└───────┴────────┘\n" + ] + } + ], + "source": [ + "3" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Deno", + "language": "typescript", + "name": "deno" + }, + "language_info": { + "file_extension": ".ts", + "mimetype": "text/x.typescript", + "name": "typescript", + "nb_converter": "script", + "pygments_lexer": "typescript", + "version": "5.2.2" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 6df206fa3e05d7a69f9fef3329d2215f2cfe0229 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Fri, 15 Sep 2023 01:04:14 +0200 Subject: [PATCH 105/115] remove stale testdata --- cli/tests/testdata/jupyter/test.html | 2 -- cli/tests/testdata/jupyter/test.jpeg | Bin 32212 -> 0 bytes cli/tests/testdata/jupyter/test.pdf | Bin 13264 -> 0 bytes cli/tests/testdata/jupyter/test.png | Bin 222611 -> 0 bytes cli/tests/testdata/jupyter/test.svg | 11 ----------- 5 files changed, 13 deletions(-) delete mode 100644 cli/tests/testdata/jupyter/test.html delete mode 100644 cli/tests/testdata/jupyter/test.jpeg delete mode 100644 cli/tests/testdata/jupyter/test.pdf delete mode 100644 cli/tests/testdata/jupyter/test.png delete mode 100644 cli/tests/testdata/jupyter/test.svg diff --git a/cli/tests/testdata/jupyter/test.html b/cli/tests/testdata/jupyter/test.html deleted file mode 100644 index bbfcdcc1e54269..00000000000000 --- a/cli/tests/testdata/jupyter/test.html +++ /dev/null @@ -1,2 +0,0 @@ -

Dummy Heading

-Dummy text. \ No newline at end of file diff --git a/cli/tests/testdata/jupyter/test.jpeg b/cli/tests/testdata/jupyter/test.jpeg deleted file mode 100644 index 1e519b6a08062a34bf19197309a8765bf1707c03..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 32212 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 diff --git a/cli/tests/testdata/jupyter/test.png b/cli/tests/testdata/jupyter/test.png deleted file mode 100644 index 3b8a8f148140f3b2d334b9c893812fe103359839..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 222611 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 PHsHdBM~1Z?I(6ZHZ2Z`L diff --git a/cli/tests/testdata/jupyter/test.svg b/cli/tests/testdata/jupyter/test.svg deleted file mode 100644 index 5cbb1d25c355c2..00000000000000 --- a/cli/tests/testdata/jupyter/test.svg +++ /dev/null @@ -1,11 +0,0 @@ - - - - - - From 443335706fa84060a2f2f35c433f3505418c3c20 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Fri, 15 Sep 2023 14:15:33 +0200 Subject: [PATCH 106/115] wip --- cli/tools/jupyter/server.rs | 18 ++++++++++++++++++ integration_test.ipynb | 32 ++++++++++++++++++++++++++++++-- 2 files changed, 48 insertions(+), 2 deletions(-) diff --git a/cli/tools/jupyter/server.rs b/cli/tools/jupyter/server.rs index 89dadb5941db85..d790272f2baece 100644 --- a/cli/tools/jupyter/server.rs +++ b/cli/tools/jupyter/server.rs @@ -303,6 +303,24 @@ impl JupyterServer { .await?; } } + "inspect_request" => { + eprintln!("msg {:#?}", msg); + // Content: { + // "code": "Deno.chmod", + // "cursor_pos": 10, + // "detail_level": 0 + // } + let req = json!({ + "textDocument": { + "uri": uri + }, + "position": { "line": 2, "character": 12 } + }); + // let res = client.write_request( + // "textDocument/hover", + + // ); + } "comm_msg" | "comm_info_request" | "history_request" => { // We don't handle these messages } diff --git a/integration_test.ipynb b/integration_test.ipynb index 083898f9a237db..120a7feb244155 100644 --- a/integration_test.ipynb +++ b/integration_test.ipynb @@ -1575,9 +1575,35 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "id": "08976272-4a23-4371-a253-6cd9c9a1caab", "metadata": {}, + "outputs": [ + { + "data": {}, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "const id = \"swift-fish-98\";\n", + "const deployPreview = {\n", + " id,\n", + " [Symbol.for(\"Jupyter.display\")]() {\n", + " return {\n", + " \"text/plain\": `Preview URL: https://${id}.deno.dev/`,\n", + " \"text/html\": ``\n", + " };\n", + " }\n", + "};" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d903b09c-7094-45d0-b876-2652c94255c2", + "metadata": {}, "outputs": [], "source": [] } @@ -1592,7 +1618,9 @@ "file_extension": ".ts", "mimetype": "text/x.typescript", "name": "typescript", - "version": "5.1.6" + "nb_converter": "script", + "pygments_lexer": "typescript", + "version": "5.2.2" }, "toc": { "base_numbering": 1, From c1b6c9d088f1bfa00194ba7f38b009f6c3830a23 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Fri, 15 Sep 2023 21:18:09 +0200 Subject: [PATCH 107/115] don't handle inspect_request for now --- cli/tools/jupyter/server.rs | 18 ------------------ 1 file changed, 18 deletions(-) diff --git a/cli/tools/jupyter/server.rs b/cli/tools/jupyter/server.rs index d790272f2baece..89dadb5941db85 100644 --- a/cli/tools/jupyter/server.rs +++ b/cli/tools/jupyter/server.rs @@ -303,24 +303,6 @@ impl JupyterServer { .await?; } } - "inspect_request" => { - eprintln!("msg {:#?}", msg); - // Content: { - // "code": "Deno.chmod", - // "cursor_pos": 10, - // "detail_level": 0 - // } - let req = json!({ - "textDocument": { - "uri": uri - }, - "position": { "line": 2, "character": 12 } - }); - // let res = client.write_request( - // "textDocument/hover", - - // ); - } "comm_msg" | "comm_info_request" | "history_request" => { // We don't handle these messages } From cba90fa1da83996c2b2095d13759e4b05f9bc3ae Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Fri, 15 Sep 2023 21:54:48 +0200 Subject: [PATCH 108/115] fix a todo --- cli/tools/jupyter/server.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cli/tools/jupyter/server.rs b/cli/tools/jupyter/server.rs index 89dadb5941db85..b4574c0bad18ce 100644 --- a/cli/tools/jupyter/server.rs +++ b/cli/tools/jupyter/server.rs @@ -410,7 +410,7 @@ impl JupyterServer { "Unknown exception".to_string() }; - // TODO: fill all the fields + // TODO(bartlomieju): fill all the fields msg .new_message("error") .with_content(json!({ From a29bf345e2503cf5d82a5d06397ce2486bb9d8c4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Fri, 15 Sep 2023 22:16:10 +0200 Subject: [PATCH 109/115] reorg subcommands --- cli/args/flags.rs | 55 ++++++++++++++++++++++++++++++++---- cli/tools/jupyter/install.rs | 25 +++++++++++++++- cli/tools/jupyter/mod.rs | 11 ++++++-- 3 files changed, 82 insertions(+), 9 deletions(-) diff --git a/cli/args/flags.rs b/cli/args/flags.rs index fabbae926823e9..40aa7b8e332feb 100644 --- a/cli/args/flags.rs +++ b/cli/args/flags.rs @@ -161,6 +161,7 @@ pub struct InstallFlags { #[derive(Clone, Debug, Eq, PartialEq)] pub struct JupyterFlags { pub install: bool, + pub kernel: bool, pub conn_file: Option, } @@ -1628,6 +1629,16 @@ fn jupyter_subcommand() -> Command { .arg( Arg::new("install") .long("install") + .help("Installs kernelspec, requires 'jupyter' command to be available.") + .conflicts_with("kernel") + .action(ArgAction::SetTrue) + ) + .arg( + Arg::new("kernel") + .long("kernel") + .help("Start the kernel") + .conflicts_with("install") + .requires("conn") .action(ArgAction::SetTrue) ) .arg( @@ -1637,7 +1648,7 @@ fn jupyter_subcommand() -> Command { .value_parser(value_parser!(PathBuf)) .value_hint(ValueHint::FilePath) .conflicts_with("install")) - .about("Jupyter kernel") + .about("Deno kernel for Jupyter notebooks") } fn uninstall_subcommand() -> Command { @@ -3195,10 +3206,14 @@ fn install_parse(flags: &mut Flags, matches: &mut ArgMatches) { fn jupyter_parse(flags: &mut Flags, matches: &mut ArgMatches) { let conn_file = matches.remove_one::("conn"); + let kernel = matches.get_flag("kernel"); let install = matches.get_flag("install"); - flags.subcommand = - DenoSubcommand::Jupyter(JupyterFlags { install, conn_file }); + flags.subcommand = DenoSubcommand::Jupyter(JupyterFlags { + install, + kernel, + conn_file, + }); } fn uninstall_parse(flags: &mut Flags, matches: &mut ArgMatches) { @@ -7867,27 +7882,51 @@ mod tests { #[test] fn jupyter() { - let r = flags_from_vec(svec!["deno", "jupyter", "--install"]); + let r = flags_from_vec(svec!["deno", "jupyter", "--unstable"]); + assert_eq!( + r.unwrap(), + Flags { + subcommand: DenoSubcommand::Jupyter(JupyterFlags { + install: false, + kernel: false, + conn_file: None, + }), + unstable: true, + ..Flags::default() + } + ); + + let r = flags_from_vec(svec!["deno", "jupyter", "--unstable", "--install"]); assert_eq!( r.unwrap(), Flags { subcommand: DenoSubcommand::Jupyter(JupyterFlags { install: true, + kernel: false, conn_file: None, }), + unstable: true, ..Flags::default() } ); - let r = - flags_from_vec(svec!["deno", "jupyter", "--conn", "path/to/conn/file"]); + let r = flags_from_vec(svec![ + "deno", + "jupyter", + "--unstable", + "--kernel", + "--conn", + "path/to/conn/file" + ]); assert_eq!( r.unwrap(), Flags { subcommand: DenoSubcommand::Jupyter(JupyterFlags { install: false, + kernel: true, conn_file: Some(PathBuf::from("path/to/conn/file")), }), + unstable: true, ..Flags::default() } ); @@ -7900,5 +7939,9 @@ mod tests { "path/to/conn/file" ]); r.unwrap_err(); + let r = flags_from_vec(svec!["deno", "jupyter", "--kernel",]); + r.unwrap_err(); + let r = flags_from_vec(svec!["deno", "jupyter", "--install", "--kernel",]); + r.unwrap_err(); } } diff --git a/cli/tools/jupyter/install.rs b/cli/tools/jupyter/install.rs index 62625827e762c9..c9f266fca07306 100644 --- a/cli/tools/jupyter/install.rs +++ b/cli/tools/jupyter/install.rs @@ -1,12 +1,35 @@ // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. use deno_core::anyhow::bail; +use deno_core::anyhow::Context; use deno_core::error::AnyError; use deno_core::serde_json; use deno_core::serde_json::json; use std::env::current_exe; use tempfile::TempDir; +pub fn status() -> Result<(), AnyError> { + let output = std::process::Command::new("jupyter") + .args(["kernelspec", "list", "--json"]) + .output() + .context("Failed to get list of installed kernelspecs")?; + let json_output: serde_json::Value = + serde_json::from_slice(&output.stdout) + .context("Failed to parse JSON from kernelspec list")?; + + if let Some(specs) = json_output.get("kernelspecs") { + if let Some(specs_obj) = specs.as_object() { + if specs_obj.contains_key("deno") { + println!("✅ Deno kernel already installed"); + return Ok(()); + } + } + } + + println!("ℹ️ Deno kernel is not yet installed, run `deno jupyter --unstable --install` to set it up"); + Ok(()) +} + pub fn install() -> Result<(), AnyError> { let temp_dir = TempDir::new().unwrap(); let kernel_json_path = temp_dir.path().join("kernel.json"); @@ -15,7 +38,7 @@ pub fn install() -> Result<(), AnyError> { // https://jupyter-client.readthedocs.io/en/stable/kernels.html#kernel-specs // FIXME(bartlomieju): replace `current_exe` before landing? let json_data = json!({ - "argv": [current_exe().unwrap().to_string_lossy(), "--unstable", "jupyter", "--conn", "{connection_file}"], + "argv": [current_exe().unwrap().to_string_lossy(), "--unstable", "jupyter", "--kernel", "--conn", "{connection_file}"], "display_name": "Deno", "language": "typescript", }); diff --git a/cli/tools/jupyter/mod.rs b/cli/tools/jupyter/mod.rs index 2af0e06708b2f5..48f50100c3ddc8 100644 --- a/cli/tools/jupyter/mod.rs +++ b/cli/tools/jupyter/mod.rs @@ -25,10 +25,17 @@ pub async fn kernel( flags: Flags, jupyter_flags: JupyterFlags, ) -> Result<(), AnyError> { - let Some(connection_filepath) = jupyter_flags.conn_file else { + if !jupyter_flags.install && !jupyter_flags.kernel { + install::status()?; + return Ok(()); + } + + if jupyter_flags.install { install::install()?; return Ok(()); - }; + } + + let connection_filepath = jupyter_flags.conn_file.unwrap(); // This env var might be set by notebook if std::env::var("DEBUG").is_ok() { From 07a15c1c5898abff2fcf4c0fcf33c94c5801e8d5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Fri, 15 Sep 2023 23:04:27 +0200 Subject: [PATCH 110/115] add unstable check --- cli/tools/jupyter/mod.rs | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/cli/tools/jupyter/mod.rs b/cli/tools/jupyter/mod.rs index 48f50100c3ddc8..db78c0b33ca551 100644 --- a/cli/tools/jupyter/mod.rs +++ b/cli/tools/jupyter/mod.rs @@ -25,6 +25,13 @@ pub async fn kernel( flags: Flags, jupyter_flags: JupyterFlags, ) -> Result<(), AnyError> { + if !flags.unstable { + eprintln!( + "Unstable subcommand 'deno jupyter'. The --unstable flag must be provided." + ); + std::process::exit(70); + } + if !jupyter_flags.install && !jupyter_flags.kernel { install::status()?; return Ok(()); From 5cc8f10298c2f0a044673f312560ba6f1250ff66 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Sat, 16 Sep 2023 00:24:27 +0200 Subject: [PATCH 111/115] icons --- cli/tools/jupyter/install.rs | 22 +++++++++++++++--- .../jupyter/resources/deno-logo-32x32.png | Bin 0 -> 1029 bytes .../jupyter/resources/deno-logo-64x64.png | Bin 0 -> 2066 bytes 3 files changed, 19 insertions(+), 3 deletions(-) create mode 100644 cli/tools/jupyter/resources/deno-logo-32x32.png create mode 100644 cli/tools/jupyter/resources/deno-logo-64x64.png diff --git a/cli/tools/jupyter/install.rs b/cli/tools/jupyter/install.rs index c9f266fca07306..d1777d92d5f196 100644 --- a/cli/tools/jupyter/install.rs +++ b/cli/tools/jupyter/install.rs @@ -6,8 +6,13 @@ use deno_core::error::AnyError; use deno_core::serde_json; use deno_core::serde_json::json; use std::env::current_exe; +use std::io::Write; +use std::path::Path; use tempfile::TempDir; +const DENO_ICON_32: &[u8] = include_bytes!("./resources/deno-logo-32x32.png"); +const DENO_ICON_64: &[u8] = include_bytes!("./resources/deno-logo-64x64.png"); + pub fn status() -> Result<(), AnyError> { let output = std::process::Command::new("jupyter") .args(["kernelspec", "list", "--json"]) @@ -30,6 +35,17 @@ pub fn status() -> Result<(), AnyError> { Ok(()) } +fn install_icon( + dir_path: &Path, + filename: &str, + icon_data: &[u8], +) -> Result<(), AnyError> { + let path = dir_path.join(filename); + let mut file = std::fs::File::create(path)?; + file.write_all(icon_data)?; + Ok(()) +} + pub fn install() -> Result<(), AnyError> { let temp_dir = TempDir::new().unwrap(); let kernel_json_path = temp_dir.path().join("kernel.json"); @@ -45,6 +61,8 @@ pub fn install() -> Result<(), AnyError> { let f = std::fs::File::create(kernel_json_path)?; serde_json::to_writer_pretty(f, &json_data)?; + install_icon(temp_dir.path(), "icon-32x32.png", DENO_ICON_32)?; + install_icon(temp_dir.path(), "icon-64x64.png", DENO_ICON_64)?; let child_result = std::process::Command::new("jupyter") .args([ @@ -57,8 +75,6 @@ pub fn install() -> Result<(), AnyError> { ]) .spawn(); - // TODO(bartlomieju): copy icons the the kernelspec directory - if let Ok(mut child) = child_result { let wait_result = child.wait(); match wait_result { @@ -74,6 +90,6 @@ pub fn install() -> Result<(), AnyError> { } let _ = std::fs::remove_dir(temp_dir); - println!("Deno kernelspec installed successfully."); + println!("✅ Deno kernelspec installed successfully."); Ok(()) } diff --git a/cli/tools/jupyter/resources/deno-logo-32x32.png b/cli/tools/jupyter/resources/deno-logo-32x32.png new file mode 100644 index 0000000000000000000000000000000000000000..97871a02ee768c20879cadd36be22e7a6c3d3227 GIT binary patch literal 1029 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 Date: Sat, 16 Sep 2023 00:34:37 +0200 Subject: [PATCH 112/115] review part 1 --- cli/tools/jupyter/jupyter_msg.rs | 2 +- cli/tools/jupyter/mod.rs | 12 +++++--- cli/tools/jupyter/server.rs | 52 ++++++++++++++++++++------------ cli/tools/repl/mod.rs | 2 -- 4 files changed, 42 insertions(+), 26 deletions(-) diff --git a/cli/tools/jupyter/jupyter_msg.rs b/cli/tools/jupyter/jupyter_msg.rs index 0cafede224838d..c28dd3b485f66d 100644 --- a/cli/tools/jupyter/jupyter_msg.rs +++ b/cli/tools/jupyter/jupyter_msg.rs @@ -51,7 +51,7 @@ impl RawMessage { let delimiter_index = multipart .iter() .position(|part| &part[..] == DELIMITER) - .ok_or_else(|| anyhow!("Missing delimeter"))?; + .ok_or_else(|| anyhow!("Missing delimiter"))?; let mut parts = multipart.into_vec(); let jparts: Vec<_> = parts.drain(delimiter_index + 2..).collect(); let expected_hmac = parts.pop().unwrap(); diff --git a/cli/tools/jupyter/mod.rs b/cli/tools/jupyter/mod.rs index db78c0b33ca551..b704d58cd59c3b 100644 --- a/cli/tools/jupyter/mod.rs +++ b/cli/tools/jupyter/mod.rs @@ -113,11 +113,15 @@ pub fn op_print( ) -> Result<(), AnyError> { let sender = state.borrow_mut::>(); - // TODO(bartlomieju): should these results be handled somehow? if is_err { - let _r = sender.unbounded_send(server::StdioMsg::Stderr(msg)); - } else { - let _r = sender.unbounded_send(server::StdioMsg::Stdout(msg)); + if let Err(err) = sender.unbounded_send(server::StdioMsg::Stderr(msg)) { + eprintln!("Failed to send stderr message: {}", err); + } + return Ok(()); + } + + if let Err(err) = sender.unbounded_send(server::StdioMsg::Stdout(msg)) { + eprintln!("Failed to send stdout message: {}", err); } Ok(()) } diff --git a/cli/tools/jupyter/server.rs b/cli/tools/jupyter/server.rs index b4574c0bad18ce..64852b2305b69a 100644 --- a/cli/tools/jupyter/server.rs +++ b/cli/tools/jupyter/server.rs @@ -90,25 +90,12 @@ impl JupyterServer { let handle4 = deno_core::unsync::spawn(async move { while let Some(stdio_msg) = stdio_rx.next().await { - if let Some(exec_request) = last_execution_request.borrow().clone() { - let (name, text) = match stdio_msg { - StdioMsg::Stdout(text) => ("stdout", text), - StdioMsg::Stderr(text) => ("stderr", text), - }; - - let result = exec_request - .new_message("stream") - .with_content(json!({ - "name": name, - "text": text - })) - .send(&mut *iopub_socket.lock().await) - .await; - - if let Err(err) = result { - eprintln!("Output {} error: {}", name, err); - } - } + Self::handle_stdio_msg( + iopub_socket.clone(), + last_execution_request.clone(), + stdio_msg, + ) + .await; } }); @@ -127,6 +114,33 @@ impl JupyterServer { Ok(()) } + async fn handle_stdio_msg( + iopub_socket: Arc>>, + last_execution_request: Rc>>, + stdio_msg: StdioMsg, + ) { + let maybe_exec_result = last_execution_request.borrow().clone(); + if let Some(exec_request) = maybe_exec_result { + let (name, text) = match stdio_msg { + StdioMsg::Stdout(text) => ("stdout", text), + StdioMsg::Stderr(text) => ("stderr", text), + }; + + let result = exec_request + .new_message("stream") + .with_content(json!({ + "name": name, + "text": text + })) + .send(&mut *iopub_socket.lock().await) + .await; + + if let Err(err) = result { + eprintln!("Output {} error: {}", name, err); + } + } + } + async fn handle_heartbeat( connection: &mut Connection, ) -> Result<(), AnyError> { diff --git a/cli/tools/repl/mod.rs b/cli/tools/repl/mod.rs index 9ed8e8c19de99d..a1e741dfddf430 100644 --- a/cli/tools/repl/mod.rs +++ b/cli/tools/repl/mod.rs @@ -56,9 +56,7 @@ async fn read_line_and_poll( line_text, position, }) => { - eprintln!("repl completions {} {}", line_text, position); let result = repl_session.language_server.completions(&line_text, position).await; - eprintln!("completion result {:#?}", result); message_handler.send(RustylineSyncResponse::LspCompletions(result)).unwrap(); } None => {}, // channel closed From 7720770a0ff6d05552d60817bafd3a7714e497ee Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Sat, 16 Sep 2023 00:42:13 +0200 Subject: [PATCH 113/115] review part 2 --- cli/tools/jupyter/server.rs | 28 ++++++++++++---------------- 1 file changed, 12 insertions(+), 16 deletions(-) diff --git a/cli/tools/jupyter/server.rs b/cli/tools/jupyter/server.rs index 64852b2305b69a..c15dab6c256a7a 100644 --- a/cli/tools/jupyter/server.rs +++ b/cli/tools/jupyter/server.rs @@ -13,12 +13,11 @@ use crate::tools::repl::cdp; use deno_core::error::AnyError; use deno_core::futures; use deno_core::futures::channel::mpsc; -use deno_core::futures::future::Either; -use deno_core::futures::FutureExt; -use deno_core::futures::SinkExt; use deno_core::futures::StreamExt; use deno_core::serde_json; use deno_core::serde_json::json; +use deno_core::CancelFuture; +use deno_core::CancelHandle; use tokio::sync::Mutex; use zeromq::SocketRecv; use zeromq::SocketSend; @@ -60,7 +59,8 @@ impl JupyterServer { let iopub_socket = Arc::new(Mutex::new(iopub_socket)); let last_execution_request = Rc::new(RefCell::new(None)); - let (shutdown_tx, mut shutdown_rx) = mpsc::unbounded(); + let cancel_handle = CancelHandle::new_rc(); + let cancel_handle2 = CancelHandle::new_rc(); let mut server = Self { execution_count: 0, @@ -76,7 +76,8 @@ impl JupyterServer { }); let handle2 = deno_core::unsync::spawn(async move { - if let Err(err) = Self::handle_control(control_socket, shutdown_tx).await + if let Err(err) = + Self::handle_control(control_socket, cancel_handle2).await { eprintln!("Control error: {}", err); } @@ -99,17 +100,12 @@ impl JupyterServer { } }); - let shutdown_fut = async move { - let _ = shutdown_rx.next().await; - } - .boxed_local(); let join_fut = futures::future::try_join_all(vec![handle1, handle2, handle3, handle4]); - if let Either::Left((join_fut, _)) = - futures::future::select(join_fut, shutdown_fut).await - { - join_fut?; - }; + + if let Ok(result) = join_fut.or_cancel(cancel_handle).await { + result?; + } Ok(()) } @@ -155,7 +151,7 @@ impl JupyterServer { async fn handle_control( mut connection: Connection, - mut shutdown_tx: mpsc::UnboundedSender<()>, + cancel_handle: Rc, ) -> Result<(), AnyError> { loop { let msg = JupyterMessage::read(&mut connection).await?; @@ -168,7 +164,7 @@ impl JupyterServer { .await?; } "shutdown_request" => { - let _ = shutdown_tx.send(()).await; + cancel_handle.cancel(); } "interrupt_request" => { eprintln!("Interrupt request currently not supported"); From 42d1cfe4440542f7babd310e1fa7ec0dddcf018b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Sat, 16 Sep 2023 00:49:36 +0200 Subject: [PATCH 114/115] update test notebook --- integration_test.ipynb | 1097 ++------------------------------- output_in_the_last_cell.ipynb | 135 ---- 2 files changed, 38 insertions(+), 1194 deletions(-) delete mode 100644 output_in_the_last_cell.ipynb diff --git a/integration_test.ipynb b/integration_test.ipynb index 120a7feb244155..ec6b279735598f 100644 --- a/integration_test.ipynb +++ b/integration_test.ipynb @@ -7,7 +7,7 @@ "metadata": {}, "source": [ "# Integration Tests for Deno Jupyter\n", - "This notebook contains a number of tests to ensure that Jupyter is working as expected. You should be able to select \"Kernel->Restart and Run All\" in Jupyter's notebook UI to run the tests. The first section of tests named \"Passing Tests\" should pass. The second set of tests \"Failing Tests\" should fail. When in doubt, refer to the currently committed notebook file to make sure tests pass." + "This notebook contains a number of tests to ensure that Jupyter is working as expected. You should be able to select \"Kernel -> Restart Kernel and Run All\" in Jupyter's notebook UI to run the tests." ] }, { @@ -44,18 +44,14 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "a5d38758", "metadata": { "hidden": true }, "outputs": [ { - "data": { - "text/plain": [ - "\u001b[90mundefined\u001b[39m" - ] - }, + "data": {}, "execution_count": 1, "metadata": {}, "output_type": "execute_result" @@ -85,18 +81,14 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "f7fa885a", "metadata": { "hidden": true }, "outputs": [ { - "data": { - "text/plain": [ - "\u001b[90mundefined\u001b[39m" - ] - }, + "data": {}, "execution_count": 2, "metadata": {}, "output_type": "execute_result" @@ -105,7 +97,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "x is 42\n" + "x is \u001b[33m42\u001b[39m\n" ] } ], @@ -192,11 +184,7 @@ }, "outputs": [ { - "data": { - "text/plain": [ - "\u001b[90mundefined\u001b[39m" - ] - }, + "data": {}, "execution_count": 4, "metadata": {}, "output_type": "execute_result" @@ -444,954 +432,6 @@ "{foo: \"bar\"}" ] }, - { - "cell_type": "code", - "execution_count": 12, - "id": "c065ff3d", - "metadata": { - "hidden": true - }, - "outputs": [ - { - "data": { - "text/plain": [ - "{\n", - " internal: \u001b[32mSymbol(Deno.internal)\u001b[39m,\n", - " resources: \u001b[36m[Function: resources]\u001b[39m,\n", - " close: \u001b[36m[Function: op_close]\u001b[39m,\n", - " metrics: \u001b[36m[Function: metrics]\u001b[39m,\n", - " Process: \u001b[36m[class Process]\u001b[39m,\n", - " run: \u001b[36m[Function: run]\u001b[39m,\n", - " isatty: \u001b[36m[Function: isatty]\u001b[39m,\n", - " writeFileSync: \u001b[36m[Function: writeFileSync]\u001b[39m,\n", - " writeFile: \u001b[36m[AsyncFunction: writeFile]\u001b[39m,\n", - " writeTextFileSync: \u001b[36m[Function: writeTextFileSync]\u001b[39m,\n", - " writeTextFile: \u001b[36m[Function: writeTextFile]\u001b[39m,\n", - " readTextFile: \u001b[36m[AsyncFunction: readTextFile]\u001b[39m,\n", - " readTextFileSync: \u001b[36m[Function: readTextFileSync]\u001b[39m,\n", - " readFile: \u001b[36m[AsyncFunction: readFile]\u001b[39m,\n", - " readFileSync: \u001b[36m[Function: readFileSync]\u001b[39m,\n", - " watchFs: \u001b[36m[Function: watchFs]\u001b[39m,\n", - " chmodSync: \u001b[36m[Function: chmodSync]\u001b[39m,\n", - " chmod: \u001b[36m[AsyncFunction: chmod]\u001b[39m,\n", - " chown: \u001b[36m[AsyncFunction: chown]\u001b[39m,\n", - " chownSync: \u001b[36m[Function: chownSync]\u001b[39m,\n", - " copyFileSync: \u001b[36m[Function: copyFileSync]\u001b[39m,\n", - " cwd: \u001b[36m[Function: cwd]\u001b[39m,\n", - " makeTempDirSync: \u001b[36m[Function: makeTempDirSync]\u001b[39m,\n", - " makeTempDir: \u001b[36m[Function: makeTempDir]\u001b[39m,\n", - " makeTempFileSync: \u001b[36m[Function: makeTempFileSync]\u001b[39m,\n", - " makeTempFile: \u001b[36m[Function: makeTempFile]\u001b[39m,\n", - " memoryUsage: \u001b[36m[Function: memoryUsage]\u001b[39m,\n", - " mkdirSync: \u001b[36m[Function: mkdirSync]\u001b[39m,\n", - " mkdir: \u001b[36m[AsyncFunction: mkdir]\u001b[39m,\n", - " chdir: \u001b[36m[Function: chdir]\u001b[39m,\n", - " copyFile: \u001b[36m[AsyncFunction: copyFile]\u001b[39m,\n", - " readDirSync: \u001b[36m[Function: readDirSync]\u001b[39m,\n", - " readDir: \u001b[36m[Function: readDir]\u001b[39m,\n", - " readLinkSync: \u001b[36m[Function: readLinkSync]\u001b[39m,\n", - " readLink: \u001b[36m[Function: readLink]\u001b[39m,\n", - " realPathSync: \u001b[36m[Function: realPathSync]\u001b[39m,\n", - " realPath: \u001b[36m[Function: realPath]\u001b[39m,\n", - " removeSync: \u001b[36m[Function: removeSync]\u001b[39m,\n", - " remove: \u001b[36m[AsyncFunction: remove]\u001b[39m,\n", - " renameSync: \u001b[36m[Function: renameSync]\u001b[39m,\n", - " rename: \u001b[36m[AsyncFunction: rename]\u001b[39m,\n", - " version: { deno: \u001b[32m\"1.36.3\"\u001b[39m, v8: \u001b[32m\"11.7.439.6\"\u001b[39m, typescript: \u001b[32m\"5.1.6\"\u001b[39m },\n", - " build: {\n", - " target: \u001b[32m\"aarch64-apple-darwin\"\u001b[39m,\n", - " arch: \u001b[32m\"aarch64\"\u001b[39m,\n", - " os: \u001b[32m\"darwin\"\u001b[39m,\n", - " vendor: \u001b[32m\"apple\"\u001b[39m,\n", - " env: \u001b[90mundefined\u001b[39m\n", - " },\n", - " statSync: \u001b[36m[Function: statSync]\u001b[39m,\n", - " lstatSync: \u001b[36m[Function: lstatSync]\u001b[39m,\n", - " stat: \u001b[36m[AsyncFunction: stat]\u001b[39m,\n", - " lstat: \u001b[36m[AsyncFunction: lstat]\u001b[39m,\n", - " truncateSync: \u001b[36m[Function: truncateSync]\u001b[39m,\n", - " truncate: \u001b[36m[AsyncFunction: truncate]\u001b[39m,\n", - " ftruncateSync: \u001b[36m[Function: ftruncateSync]\u001b[39m,\n", - " ftruncate: \u001b[36m[AsyncFunction: ftruncate]\u001b[39m,\n", - " futime: \u001b[36m[AsyncFunction: futime]\u001b[39m,\n", - " futimeSync: \u001b[36m[Function: futimeSync]\u001b[39m,\n", - " errors: {\n", - " NotFound: \u001b[36m[class NotFound extends Error]\u001b[39m,\n", - " PermissionDenied: \u001b[36m[class PermissionDenied extends Error]\u001b[39m,\n", - " ConnectionRefused: \u001b[36m[class ConnectionRefused extends Error]\u001b[39m,\n", - " ConnectionReset: \u001b[36m[class ConnectionReset extends Error]\u001b[39m,\n", - " ConnectionAborted: \u001b[36m[class ConnectionAborted extends Error]\u001b[39m,\n", - " NotConnected: \u001b[36m[class NotConnected extends Error]\u001b[39m,\n", - " AddrInUse: \u001b[36m[class AddrInUse extends Error]\u001b[39m,\n", - " AddrNotAvailable: \u001b[36m[class AddrNotAvailable extends Error]\u001b[39m,\n", - " BrokenPipe: \u001b[36m[class BrokenPipe extends Error]\u001b[39m,\n", - " AlreadyExists: \u001b[36m[class AlreadyExists extends Error]\u001b[39m,\n", - " InvalidData: \u001b[36m[class InvalidData extends Error]\u001b[39m,\n", - " TimedOut: \u001b[36m[class TimedOut extends Error]\u001b[39m,\n", - " Interrupted: \u001b[36m[class Interrupted extends Error]\u001b[39m,\n", - " WriteZero: \u001b[36m[class WriteZero extends Error]\u001b[39m,\n", - " WouldBlock: \u001b[36m[class WouldBlock extends Error]\u001b[39m,\n", - " UnexpectedEof: \u001b[36m[class UnexpectedEof extends Error]\u001b[39m,\n", - " BadResource: \u001b[36m[class BadResource extends Error]\u001b[39m,\n", - " Http: \u001b[36m[class Http extends Error]\u001b[39m,\n", - " Busy: \u001b[36m[class Busy extends Error]\u001b[39m,\n", - " NotSupported: \u001b[36m[class NotSupported extends Error]\u001b[39m,\n", - " FilesystemLoop: \u001b[36m[class FilesystemLoop extends Error]\u001b[39m,\n", - " IsADirectory: \u001b[36m[class IsADirectory extends Error]\u001b[39m,\n", - " NetworkUnreachable: \u001b[36m[class NetworkUnreachable extends Error]\u001b[39m,\n", - " NotADirectory: \u001b[36m[class NotADirectory extends Error]\u001b[39m\n", - " },\n", - " customInspect: \u001b[32mSymbol(Deno.customInspect)\u001b[39m,\n", - " inspect: \u001b[36m[Function: inspect]\u001b[39m,\n", - " env: {\n", - " get: \u001b[36m[Function: getEnv]\u001b[39m,\n", - " toObject: \u001b[36m[Function: toObject]\u001b[39m,\n", - " set: \u001b[36m[Function: setEnv]\u001b[39m,\n", - " has: \u001b[36m[Function: has]\u001b[39m,\n", - " delete: \u001b[36m[Function: deleteEnv]\u001b[39m\n", - " },\n", - " exit: \u001b[36m[Function: exit]\u001b[39m,\n", - " execPath: \u001b[36m[Function: execPath]\u001b[39m,\n", - " Buffer: \u001b[36m[class Buffer]\u001b[39m,\n", - " readAll: \u001b[36m[AsyncFunction: readAll]\u001b[39m,\n", - " readAllSync: \u001b[36m[Function: readAllSync]\u001b[39m,\n", - " writeAll: \u001b[36m[AsyncFunction: writeAll]\u001b[39m,\n", - " writeAllSync: \u001b[36m[Function: writeAllSync]\u001b[39m,\n", - " copy: \u001b[36m[AsyncFunction: copy]\u001b[39m,\n", - " iter: \u001b[36m[AsyncGeneratorFunction: iter]\u001b[39m,\n", - " iterSync: \u001b[36m[GeneratorFunction: iterSync]\u001b[39m,\n", - " SeekMode: {\n", - " \u001b[32m\"0\"\u001b[39m: \u001b[32m\"Start\"\u001b[39m,\n", - " \u001b[32m\"1\"\u001b[39m: \u001b[32m\"Current\"\u001b[39m,\n", - " \u001b[32m\"2\"\u001b[39m: \u001b[32m\"End\"\u001b[39m,\n", - " Start: \u001b[33m0\u001b[39m,\n", - " Current: \u001b[33m1\u001b[39m,\n", - " End: \u001b[33m2\u001b[39m\n", - " },\n", - " read: \u001b[36m[AsyncFunction: read]\u001b[39m,\n", - " readSync: \u001b[36m[Function: readSync]\u001b[39m,\n", - " write: \u001b[36m[Function: write]\u001b[39m,\n", - " writeSync: \u001b[36m[Function: writeSync]\u001b[39m,\n", - " File: \u001b[36m[class FsFile]\u001b[39m,\n", - " FsFile: \u001b[36m[class FsFile]\u001b[39m,\n", - " open: \u001b[36m[AsyncFunction: open]\u001b[39m,\n", - " openSync: \u001b[36m[Function: openSync]\u001b[39m,\n", - " create: \u001b[36m[Function: create]\u001b[39m,\n", - " createSync: \u001b[36m[Function: createSync]\u001b[39m,\n", - " stdin: Stdin {},\n", - " stdout: Stdout {},\n", - " stderr: Stderr {},\n", - " seek: \u001b[36m[Function: seek]\u001b[39m,\n", - " seekSync: \u001b[36m[Function: seekSync]\u001b[39m,\n", - " connect: \u001b[36m[AsyncFunction: connect]\u001b[39m,\n", - " listen: \u001b[36m[Function: listen]\u001b[39m,\n", - " loadavg: \u001b[36m[Function: loadavg]\u001b[39m,\n", - " connectTls: \u001b[36m[AsyncFunction: connectTls]\u001b[39m,\n", - " listenTls: \u001b[36m[Function: listenTls]\u001b[39m,\n", - " startTls: \u001b[36m[AsyncFunction: startTls]\u001b[39m,\n", - " shutdown: \u001b[36m[Function: shutdown]\u001b[39m,\n", - " fstatSync: \u001b[36m[Function: fstatSync]\u001b[39m,\n", - " fstat: \u001b[36m[AsyncFunction: fstat]\u001b[39m,\n", - " fsyncSync: \u001b[36m[Function: fsyncSync]\u001b[39m,\n", - " fsync: \u001b[36m[AsyncFunction: fsync]\u001b[39m,\n", - " fdatasyncSync: \u001b[36m[Function: fdatasyncSync]\u001b[39m,\n", - " fdatasync: \u001b[36m[AsyncFunction: fdatasync]\u001b[39m,\n", - " symlink: \u001b[36m[AsyncFunction: symlink]\u001b[39m,\n", - " symlinkSync: \u001b[36m[Function: symlinkSync]\u001b[39m,\n", - " link: \u001b[36m[AsyncFunction: link]\u001b[39m,\n", - " linkSync: \u001b[36m[Function: linkSync]\u001b[39m,\n", - " permissions: Permissions {},\n", - " Permissions: \u001b[36m[class Permissions]\u001b[39m,\n", - " PermissionStatus: \u001b[36m[class PermissionStatus extends EventTarget]\u001b[39m,\n", - " serveHttp: \u001b[36m[Function: serveHttp]\u001b[39m,\n", - " serve: \u001b[36m[Function: serve]\u001b[39m,\n", - " resolveDns: \u001b[36m[AsyncFunction: resolveDns]\u001b[39m,\n", - " upgradeWebSocket: \u001b[36m[Function: upgradeWebSocket]\u001b[39m,\n", - " utime: \u001b[36m[AsyncFunction: utime]\u001b[39m,\n", - " utimeSync: \u001b[36m[Function: utimeSync]\u001b[39m,\n", - " kill: \u001b[36m[Function: kill]\u001b[39m,\n", - " addSignalListener: \u001b[36m[Function: addSignalListener]\u001b[39m,\n", - " removeSignalListener: \u001b[36m[Function: removeSignalListener]\u001b[39m,\n", - " refTimer: \u001b[36m[Function: refTimer]\u001b[39m,\n", - " unrefTimer: \u001b[36m[Function: unrefTimer]\u001b[39m,\n", - " osRelease: \u001b[36m[Function: osRelease]\u001b[39m,\n", - " osUptime: \u001b[36m[Function: osUptime]\u001b[39m,\n", - " hostname: \u001b[36m[Function: hostname]\u001b[39m,\n", - " systemMemoryInfo: \u001b[36m[Function: systemMemoryInfo]\u001b[39m,\n", - " networkInterfaces: \u001b[36m[Function: networkInterfaces]\u001b[39m,\n", - " consoleSize: \u001b[36m[Function: consoleSize]\u001b[39m,\n", - " gid: \u001b[36m[Function: gid]\u001b[39m,\n", - " uid: \u001b[36m[Function: uid]\u001b[39m,\n", - " Command: \u001b[36m[class Command]\u001b[39m,\n", - " ChildProcess: \u001b[36m[class ChildProcess]\u001b[39m,\n", - " bench: \u001b[36m[Function: bench]\u001b[39m,\n", - " test: \u001b[36m[Function: test]\u001b[39m,\n", - " pid: \u001b[33m85735\u001b[39m,\n", - " ppid: \u001b[36m[Getter/Setter]\u001b[39m,\n", - " noColor: \u001b[33mfalse\u001b[39m,\n", - " args: [],\n", - " mainModule: \u001b[36m[Getter/Setter]\u001b[39m,\n", - " listenDatagram: \u001b[36m[Function: listenDatagram]\u001b[39m,\n", - " umask: \u001b[36m[Function: umask]\u001b[39m,\n", - " HttpClient: \u001b[36m[class HttpClient]\u001b[39m,\n", - " createHttpClient: \u001b[36m[Function: createHttpClient]\u001b[39m,\n", - " http: [Module: null prototype] {\n", - " HttpConn: \u001b[36m[class HttpConn]\u001b[39m,\n", - " _ws: \u001b[32mSymbol(\"[[associated_ws]]\")\u001b[39m,\n", - " serve: \u001b[36m[Function: serve]\u001b[39m,\n", - " upgradeHttp: \u001b[36m[Function: upgradeHttp]\u001b[39m,\n", - " upgradeWebSocket: \u001b[36m[Function: upgradeWebSocket]\u001b[39m\n", - " },\n", - " dlopen: \u001b[36m[Function: dlopen]\u001b[39m,\n", - " UnsafeCallback: \u001b[36m[class UnsafeCallback]\u001b[39m,\n", - " UnsafePointer: \u001b[36m[class UnsafePointer]\u001b[39m,\n", - " UnsafePointerView: \u001b[36m[class UnsafePointerView]\u001b[39m,\n", - " UnsafeFnPointer: \u001b[36m[class UnsafeFnPointer]\u001b[39m,\n", - " flock: \u001b[36m[AsyncFunction: flock]\u001b[39m,\n", - " flockSync: \u001b[36m[Function: flockSync]\u001b[39m,\n", - " funlock: \u001b[36m[AsyncFunction: funlock]\u001b[39m,\n", - " funlockSync: \u001b[36m[Function: funlockSync]\u001b[39m,\n", - " upgradeHttp: \u001b[36m[Function: upgradeHttp]\u001b[39m,\n", - " openKv: \u001b[36m[AsyncFunction: openKv]\u001b[39m,\n", - " AtomicOperation: \u001b[36m[class AtomicOperation]\u001b[39m,\n", - " Kv: \u001b[36m[class Kv]\u001b[39m,\n", - " KvU64: \u001b[36m[class KvU64]\u001b[39m,\n", - " KvListIterator: \u001b[36m[class KvListIterator extends Object]\u001b[39m,\n", - " [\u001b[32mSymbol(Deno.internal)\u001b[39m]: {\n", - " Console: \u001b[36m[class Console]\u001b[39m,\n", - " cssToAnsi: \u001b[36m[Function: cssToAnsi]\u001b[39m,\n", - " inspectArgs: \u001b[36m[Function: inspectArgs]\u001b[39m,\n", - " parseCss: \u001b[36m[Function: parseCss]\u001b[39m,\n", - " parseCssColor: \u001b[36m[Function: parseCssColor]\u001b[39m,\n", - " pathFromURL: \u001b[36m[Function: pathFromURL]\u001b[39m,\n", - " resourceForReadableStream: \u001b[36m[Function: resourceForReadableStream]\u001b[39m,\n", - " addTrailers: \u001b[36m[Function: addTrailers]\u001b[39m,\n", - " upgradeHttpRaw: \u001b[36m[Function: upgradeHttpRaw]\u001b[39m,\n", - " serveHttpOnListener: \u001b[36m[Function: serveHttpOnListener]\u001b[39m,\n", - " serveHttpOnConnection: \u001b[36m[Function: serveHttpOnConnection]\u001b[39m,\n", - " __initWorkerThreads: \u001b[36m[Function (anonymous)]\u001b[39m,\n", - " node: {\n", - " initialize: \u001b[36m[Function: initialize]\u001b[39m,\n", - " loadCjsModule: \u001b[36m[Function: loadCjsModule]\u001b[39m\n", - " },\n", - " buildCaseInsensitiveCommaValueFinder: \u001b[36m[Function: buildCaseInsensitiveCommaValueFinder]\u001b[39m,\n", - " core: {\n", - " ops: {\n", - " op_close: \u001b[36m[Function: op_close]\u001b[39m,\n", - " op_try_close: \u001b[36m[Function: op_try_close]\u001b[39m,\n", - " op_print: \u001b[36m[Function: op_print]\u001b[39m,\n", - " op_resources: \u001b[36m[Function: op_resources]\u001b[39m,\n", - " op_wasm_streaming_feed: \u001b[36m[Function: op_wasm_streaming_feed]\u001b[39m,\n", - " op_wasm_streaming_set_url: \u001b[36m[Function: op_wasm_streaming_set_url]\u001b[39m,\n", - " op_void_sync: \u001b[36m[Function: op_void_sync]\u001b[39m,\n", - " op_error_async: \u001b[36m[Function: op_error_async]\u001b[39m,\n", - " op_error_async_deferred: \u001b[36m[Function: op_error_async_deferred]\u001b[39m,\n", - " op_void_async: \u001b[36m[Function: op_void_async]\u001b[39m,\n", - " op_void_async_deferred: \u001b[36m[Function: op_void_async_deferred]\u001b[39m,\n", - " op_add: \u001b[36m[Function: op_add]\u001b[39m,\n", - " op_add_async: \u001b[36m[Function: op_add_async]\u001b[39m,\n", - " op_read: \u001b[36m[Function: op_read]\u001b[39m,\n", - " op_read_all: \u001b[36m[Function: op_read_all]\u001b[39m,\n", - " op_write: \u001b[36m[Function: op_write]\u001b[39m,\n", - " op_read_sync: \u001b[36m[Function: op_read_sync]\u001b[39m,\n", - " op_write_sync: \u001b[36m[Function: op_write_sync]\u001b[39m,\n", - " op_write_all: \u001b[36m[Function: op_write_all]\u001b[39m,\n", - " op_write_type_error: \u001b[36m[Function: op_write_type_error]\u001b[39m,\n", - " op_shutdown: \u001b[36m[Function: op_shutdown]\u001b[39m,\n", - " op_metrics: \u001b[36m[Function: op_metrics]\u001b[39m,\n", - " op_format_file_name: \u001b[36m[Function: op_format_file_name]\u001b[39m,\n", - " op_is_proxy: \u001b[36m[Function: op_is_proxy]\u001b[39m,\n", - " op_str_byte_length: \u001b[36m[Function: op_str_byte_length]\u001b[39m,\n", - " op_ref_op: \u001b[36m[Function: op_ref_op]\u001b[39m,\n", - " op_unref_op: \u001b[36m[Function: op_unref_op]\u001b[39m,\n", - " op_set_promise_reject_callback: \u001b[36m[Function: op_set_promise_reject_callback]\u001b[39m,\n", - " op_run_microtasks: \u001b[36m[Function: op_run_microtasks]\u001b[39m,\n", - " op_has_tick_scheduled: \u001b[36m[Function: op_has_tick_scheduled]\u001b[39m,\n", - " op_set_has_tick_scheduled: \u001b[36m[Function: op_set_has_tick_scheduled]\u001b[39m,\n", - " op_eval_context: \u001b[36m[Function: op_eval_context]\u001b[39m,\n", - " op_queue_microtask: \u001b[36m[Function: op_queue_microtask]\u001b[39m,\n", - " op_create_host_object: \u001b[36m[Function: op_create_host_object]\u001b[39m,\n", - " op_encode: \u001b[36m[Function: op_encode]\u001b[39m,\n", - " op_decode: \u001b[36m[Function: op_decode]\u001b[39m,\n", - " op_serialize: \u001b[36m[Function: op_serialize]\u001b[39m,\n", - " op_deserialize: \u001b[36m[Function: op_deserialize]\u001b[39m,\n", - " op_set_promise_hooks: \u001b[36m[Function: op_set_promise_hooks]\u001b[39m,\n", - " op_get_promise_details: \u001b[36m[Function: op_get_promise_details]\u001b[39m,\n", - " op_get_proxy_details: \u001b[36m[Function: op_get_proxy_details]\u001b[39m,\n", - " op_get_non_index_property_names: \u001b[36m[Function: op_get_non_index_property_names]\u001b[39m,\n", - " op_get_constructor_name: \u001b[36m[Function: op_get_constructor_name]\u001b[39m,\n", - " op_memory_usage: \u001b[36m[Function: op_memory_usage]\u001b[39m,\n", - " op_set_wasm_streaming_callback: \u001b[36m[Function: op_set_wasm_streaming_callback]\u001b[39m,\n", - " op_abort_wasm_streaming: \u001b[36m[Function: op_abort_wasm_streaming]\u001b[39m,\n", - " op_destructure_error: \u001b[36m[Function: op_destructure_error]\u001b[39m,\n", - " op_dispatch_exception: \u001b[36m[Function: op_dispatch_exception]\u001b[39m,\n", - " op_op_names: \u001b[36m[Function: op_op_names]\u001b[39m,\n", - " op_apply_source_map: \u001b[36m[Function: op_apply_source_map]\u001b[39m,\n", - " op_set_format_exception_callback: \u001b[36m[Function: op_set_format_exception_callback]\u001b[39m,\n", - " op_event_loop_has_more_work: \u001b[36m[Function: op_event_loop_has_more_work]\u001b[39m,\n", - " op_store_pending_promise_rejection: \u001b[36m[Function: op_store_pending_promise_rejection]\u001b[39m,\n", - " op_remove_pending_promise_rejection: \u001b[36m[Function: op_remove_pending_promise_rejection]\u001b[39m,\n", - " op_has_pending_promise_rejection: \u001b[36m[Function: op_has_pending_promise_rejection]\u001b[39m,\n", - " op_arraybuffer_was_detached: \u001b[36m[Function: op_arraybuffer_was_detached]\u001b[39m,\n", - " op_url_reparse: \u001b[36m[Function: op_url_reparse]\u001b[39m,\n", - " op_url_parse: \u001b[36m[Function: op_url_parse]\u001b[39m,\n", - " op_url_get_serialization: \u001b[36m[Function: op_url_get_serialization]\u001b[39m,\n", - " op_url_parse_with_base: \u001b[36m[Function: op_url_parse_with_base]\u001b[39m,\n", - " op_url_parse_search_params: \u001b[36m[Function: op_url_parse_search_params]\u001b[39m,\n", - " op_url_stringify_search_params: \u001b[36m[Function: op_url_stringify_search_params]\u001b[39m,\n", - " op_urlpattern_parse: \u001b[36m[Function: op_urlpattern_parse]\u001b[39m,\n", - " op_urlpattern_process_match_input: \u001b[36m[Function: op_urlpattern_process_match_input]\u001b[39m,\n", - " op_base64_decode: \u001b[36m[Function: op_base64_decode]\u001b[39m,\n", - " op_base64_encode: \u001b[36m[Function: op_base64_encode]\u001b[39m,\n", - " op_base64_atob: \u001b[36m[Function: op_base64_atob]\u001b[39m,\n", - " op_base64_btoa: \u001b[36m[Function: op_base64_btoa]\u001b[39m,\n", - " op_encoding_normalize_label: \u001b[36m[Function: op_encoding_normalize_label]\u001b[39m,\n", - " op_encoding_decode_single: \u001b[36m[Function: op_encoding_decode_single]\u001b[39m,\n", - " op_encoding_decode_utf8: \u001b[36m[Function: op_encoding_decode_utf8]\u001b[39m,\n", - " op_encoding_new_decoder: \u001b[36m[Function: op_encoding_new_decoder]\u001b[39m,\n", - " op_encoding_decode: \u001b[36m[Function: op_encoding_decode]\u001b[39m,\n", - " op_encoding_encode_into: \u001b[36m[Function: op_encoding_encode_into]\u001b[39m,\n", - " op_encode_binary_string: \u001b[36m[Function: op_encode_binary_string]\u001b[39m,\n", - " op_blob_create_part: \u001b[36m[Function: op_blob_create_part]\u001b[39m,\n", - " op_blob_slice_part: \u001b[36m[Function: op_blob_slice_part]\u001b[39m,\n", - " op_blob_read_part: \u001b[36m[Function: op_blob_read_part]\u001b[39m,\n", - " op_blob_remove_part: \u001b[36m[Function: op_blob_remove_part]\u001b[39m,\n", - " op_blob_create_object_url: \u001b[36m[Function: op_blob_create_object_url]\u001b[39m,\n", - " op_blob_revoke_object_url: \u001b[36m[Function: op_blob_revoke_object_url]\u001b[39m,\n", - " op_blob_from_object_url: \u001b[36m[Function: op_blob_from_object_url]\u001b[39m,\n", - " op_message_port_create_entangled: \u001b[36m[Function: op_message_port_create_entangled]\u001b[39m,\n", - " op_message_port_post_message: \u001b[36m[Function: op_message_port_post_message]\u001b[39m,\n", - " op_message_port_recv_message: \u001b[36m[Function: op_message_port_recv_message]\u001b[39m,\n", - " op_compression_new: \u001b[36m[Function: op_compression_new]\u001b[39m,\n", - " op_compression_write: \u001b[36m[Function: op_compression_write]\u001b[39m,\n", - " op_compression_finish: \u001b[36m[Function: op_compression_finish]\u001b[39m,\n", - " op_now: \u001b[36m[Function: op_now]\u001b[39m,\n", - " op_timer_handle: \u001b[36m[Function: op_timer_handle]\u001b[39m,\n", - " op_cancel_handle: \u001b[36m[Function: op_cancel_handle]\u001b[39m,\n", - " op_sleep: \u001b[36m[Function: op_sleep]\u001b[39m,\n", - " op_transfer_arraybuffer: \u001b[36m[Function: op_transfer_arraybuffer]\u001b[39m,\n", - " op_readable_stream_resource_allocate: \u001b[36m[Function: op_readable_stream_resource_allocate]\u001b[39m,\n", - " op_readable_stream_resource_get_sink: \u001b[36m[Function: op_readable_stream_resource_get_sink]\u001b[39m,\n", - " op_readable_stream_resource_write_error: \u001b[36m[Function: op_readable_stream_resource_write_error]\u001b[39m,\n", - " op_readable_stream_resource_write_buf: \u001b[36m[Function: op_readable_stream_resource_write_buf]\u001b[39m,\n", - " op_readable_stream_resource_close: \u001b[36m[Function: op_readable_stream_resource_close]\u001b[39m,\n", - " op_readable_stream_resource_await_close: \u001b[36m[Function: op_readable_stream_resource_await_close]\u001b[39m,\n", - " op_fetch: \u001b[36m[Function: op_fetch]\u001b[39m,\n", - " op_fetch_send: \u001b[36m[Function: op_fetch_send]\u001b[39m,\n", - " op_fetch_response_upgrade: \u001b[36m[Function: op_fetch_response_upgrade]\u001b[39m,\n", - " op_fetch_custom_client: \u001b[36m[Function: op_fetch_custom_client]\u001b[39m,\n", - " op_cache_storage_open: \u001b[36m[Function: op_cache_storage_open]\u001b[39m,\n", - " op_cache_storage_has: \u001b[36m[Function: op_cache_storage_has]\u001b[39m,\n", - " op_cache_storage_delete: \u001b[36m[Function: op_cache_storage_delete]\u001b[39m,\n", - " op_cache_put: \u001b[36m[Function: op_cache_put]\u001b[39m,\n", - " op_cache_put_finish: \u001b[36m[Function: op_cache_put_finish]\u001b[39m,\n", - " op_cache_match: \u001b[36m[Function: op_cache_match]\u001b[39m,\n", - " op_cache_delete: \u001b[36m[Function: op_cache_delete]\u001b[39m,\n", - " op_ws_check_permission_and_cancel_handle: \u001b[36m[Function: op_ws_check_permission_and_cancel_handle]\u001b[39m,\n", - " op_ws_create: \u001b[36m[Function: op_ws_create]\u001b[39m,\n", - " op_ws_close: \u001b[36m[Function: op_ws_close]\u001b[39m,\n", - " op_ws_next_event: \u001b[36m[Function: op_ws_next_event]\u001b[39m,\n", - " op_ws_get_buffer: \u001b[36m[Function: op_ws_get_buffer]\u001b[39m,\n", - " op_ws_get_buffer_as_string: \u001b[36m[Function: op_ws_get_buffer_as_string]\u001b[39m,\n", - " op_ws_get_error: \u001b[36m[Function: op_ws_get_error]\u001b[39m,\n", - " op_ws_send_binary: \u001b[36m[Function: op_ws_send_binary]\u001b[39m,\n", - " op_ws_send_text: \u001b[36m[Function: op_ws_send_text]\u001b[39m,\n", - " op_ws_send_binary_async: \u001b[36m[Function: op_ws_send_binary_async]\u001b[39m,\n", - " op_ws_send_text_async: \u001b[36m[Function: op_ws_send_text_async]\u001b[39m,\n", - " op_ws_send_ping: \u001b[36m[Function: op_ws_send_ping]\u001b[39m,\n", - " op_ws_send_pong: \u001b[36m[Function: op_ws_send_pong]\u001b[39m,\n", - " op_ws_get_buffered_amount: \u001b[36m[Function: op_ws_get_buffered_amount]\u001b[39m,\n", - " op_webstorage_length: \u001b[36m[Function: op_webstorage_length]\u001b[39m,\n", - " op_webstorage_key: \u001b[36m[Function: op_webstorage_key]\u001b[39m,\n", - " op_webstorage_set: \u001b[36m[Function: op_webstorage_set]\u001b[39m,\n", - " op_webstorage_get: \u001b[36m[Function: op_webstorage_get]\u001b[39m,\n", - " op_webstorage_remove: \u001b[36m[Function: op_webstorage_remove]\u001b[39m,\n", - " op_webstorage_clear: \u001b[36m[Function: op_webstorage_clear]\u001b[39m,\n", - " op_webstorage_iterate_keys: \u001b[36m[Function: op_webstorage_iterate_keys]\u001b[39m,\n", - " op_crypto_get_random_values: \u001b[36m[Function: op_crypto_get_random_values]\u001b[39m,\n", - " op_crypto_generate_key: \u001b[36m[Function: op_crypto_generate_key]\u001b[39m,\n", - " op_crypto_sign_key: \u001b[36m[Function: op_crypto_sign_key]\u001b[39m,\n", - " op_crypto_verify_key: \u001b[36m[Function: op_crypto_verify_key]\u001b[39m,\n", - " op_crypto_derive_bits: \u001b[36m[Function: op_crypto_derive_bits]\u001b[39m,\n", - " op_crypto_import_key: \u001b[36m[Function: op_crypto_import_key]\u001b[39m,\n", - " op_crypto_export_key: \u001b[36m[Function: op_crypto_export_key]\u001b[39m,\n", - " op_crypto_encrypt: \u001b[36m[Function: op_crypto_encrypt]\u001b[39m,\n", - " op_crypto_decrypt: \u001b[36m[Function: op_crypto_decrypt]\u001b[39m,\n", - " op_crypto_subtle_digest: \u001b[36m[Function: op_crypto_subtle_digest]\u001b[39m,\n", - " op_crypto_random_uuid: \u001b[36m[Function: op_crypto_random_uuid]\u001b[39m,\n", - " op_crypto_wrap_key: \u001b[36m[Function: op_crypto_wrap_key]\u001b[39m,\n", - " op_crypto_unwrap_key: \u001b[36m[Function: op_crypto_unwrap_key]\u001b[39m,\n", - " op_crypto_base64url_decode: \u001b[36m[Function: op_crypto_base64url_decode]\u001b[39m,\n", - " op_crypto_base64url_encode: \u001b[36m[Function: op_crypto_base64url_encode]\u001b[39m,\n", - " op_crypto_generate_x25519_keypair: \u001b[36m[Function: op_crypto_generate_x25519_keypair]\u001b[39m,\n", - " op_crypto_derive_bits_x25519: \u001b[36m[Function: op_crypto_derive_bits_x25519]\u001b[39m,\n", - " op_crypto_import_spki_x25519: \u001b[36m[Function: op_crypto_import_spki_x25519]\u001b[39m,\n", - " op_crypto_import_pkcs8_x25519: \u001b[36m[Function: op_crypto_import_pkcs8_x25519]\u001b[39m,\n", - " op_crypto_generate_ed25519_keypair: \u001b[36m[Function: op_crypto_generate_ed25519_keypair]\u001b[39m,\n", - " op_crypto_import_spki_ed25519: \u001b[36m[Function: op_crypto_import_spki_ed25519]\u001b[39m,\n", - " op_crypto_import_pkcs8_ed25519: \u001b[36m[Function: op_crypto_import_pkcs8_ed25519]\u001b[39m,\n", - " op_crypto_sign_ed25519: \u001b[36m[Function: op_crypto_sign_ed25519]\u001b[39m,\n", - " op_crypto_verify_ed25519: \u001b[36m[Function: op_crypto_verify_ed25519]\u001b[39m,\n", - " op_crypto_export_spki_ed25519: \u001b[36m[Function: op_crypto_export_spki_ed25519]\u001b[39m,\n", - " op_crypto_export_pkcs8_ed25519: \u001b[36m[Function: op_crypto_export_pkcs8_ed25519]\u001b[39m,\n", - " op_crypto_jwk_x_ed25519: \u001b[36m[Function: op_crypto_jwk_x_ed25519]\u001b[39m,\n", - " op_crypto_export_spki_x25519: \u001b[36m[Function: op_crypto_export_spki_x25519]\u001b[39m,\n", - " op_crypto_export_pkcs8_x25519: \u001b[36m[Function: op_crypto_export_pkcs8_x25519]\u001b[39m,\n", - " op_broadcast_subscribe: \u001b[36m[Function: op_broadcast_subscribe]\u001b[39m,\n", - " op_broadcast_unsubscribe: \u001b[36m[Function: op_broadcast_unsubscribe]\u001b[39m,\n", - " op_broadcast_send: \u001b[36m[Function: op_broadcast_send]\u001b[39m,\n", - " op_broadcast_recv: \u001b[36m[Function: op_broadcast_recv]\u001b[39m,\n", - " op_ffi_load: \u001b[36m[Function: op_ffi_load]\u001b[39m,\n", - " op_ffi_get_static: \u001b[36m[Function: op_ffi_get_static]\u001b[39m,\n", - " op_ffi_call_nonblocking: \u001b[36m[Function: op_ffi_call_nonblocking]\u001b[39m,\n", - " op_ffi_call_ptr: \u001b[36m[Function: op_ffi_call_ptr]\u001b[39m,\n", - " op_ffi_call_ptr_nonblocking: \u001b[36m[Function: op_ffi_call_ptr_nonblocking]\u001b[39m,\n", - " op_ffi_ptr_create: \u001b[36m[Function: op_ffi_ptr_create]\u001b[39m,\n", - " op_ffi_ptr_equals: \u001b[36m[Function: op_ffi_ptr_equals]\u001b[39m,\n", - " op_ffi_ptr_of: \u001b[36m[Function: op_ffi_ptr_of]\u001b[39m,\n", - " op_ffi_ptr_offset: \u001b[36m[Function: op_ffi_ptr_offset]\u001b[39m,\n", - " op_ffi_ptr_value: \u001b[36m[Function: op_ffi_ptr_value]\u001b[39m,\n", - " op_ffi_get_buf: \u001b[36m[Function: op_ffi_get_buf]\u001b[39m,\n", - " op_ffi_buf_copy_into: \u001b[36m[Function: op_ffi_buf_copy_into]\u001b[39m,\n", - " op_ffi_cstr_read: \u001b[36m[Function: op_ffi_cstr_read]\u001b[39m,\n", - " op_ffi_read_bool: \u001b[36m[Function: op_ffi_read_bool]\u001b[39m,\n", - " op_ffi_read_u8: \u001b[36m[Function: op_ffi_read_u8]\u001b[39m,\n", - " op_ffi_read_i8: \u001b[36m[Function: op_ffi_read_i8]\u001b[39m,\n", - " op_ffi_read_u16: \u001b[36m[Function: op_ffi_read_u16]\u001b[39m,\n", - " op_ffi_read_i16: \u001b[36m[Function: op_ffi_read_i16]\u001b[39m,\n", - " op_ffi_read_u32: \u001b[36m[Function: op_ffi_read_u32]\u001b[39m,\n", - " op_ffi_read_i32: \u001b[36m[Function: op_ffi_read_i32]\u001b[39m,\n", - " op_ffi_read_u64: \u001b[36m[Function: op_ffi_read_u64]\u001b[39m,\n", - " op_ffi_read_i64: \u001b[36m[Function: op_ffi_read_i64]\u001b[39m,\n", - " op_ffi_read_f32: \u001b[36m[Function: op_ffi_read_f32]\u001b[39m,\n", - " op_ffi_read_f64: \u001b[36m[Function: op_ffi_read_f64]\u001b[39m,\n", - " op_ffi_read_ptr: \u001b[36m[Function: op_ffi_read_ptr]\u001b[39m,\n", - " op_ffi_unsafe_callback_create: \u001b[36m[Function: op_ffi_unsafe_callback_create]\u001b[39m,\n", - " op_ffi_unsafe_callback_close: \u001b[36m[Function: op_ffi_unsafe_callback_close]\u001b[39m,\n", - " op_ffi_unsafe_callback_ref: \u001b[36m[Function: op_ffi_unsafe_callback_ref]\u001b[39m,\n", - " op_net_accept_tcp: \u001b[36m[Function: op_net_accept_tcp]\u001b[39m,\n", - " op_net_connect_tcp: \u001b[36m[Function: op_net_connect_tcp]\u001b[39m,\n", - " op_net_listen_tcp: \u001b[36m[Function: op_net_listen_tcp]\u001b[39m,\n", - " op_net_listen_udp: \u001b[36m[Function: op_net_listen_udp]\u001b[39m,\n", - " op_node_unstable_net_listen_udp: \u001b[36m[Function: op_node_unstable_net_listen_udp]\u001b[39m,\n", - " op_net_recv_udp: \u001b[36m[Function: op_net_recv_udp]\u001b[39m,\n", - " op_net_send_udp: \u001b[36m[Function: op_net_send_udp]\u001b[39m,\n", - " op_net_join_multi_v4_udp: \u001b[36m[Function: op_net_join_multi_v4_udp]\u001b[39m,\n", - " op_net_join_multi_v6_udp: \u001b[36m[Function: op_net_join_multi_v6_udp]\u001b[39m,\n", - " op_net_leave_multi_v4_udp: \u001b[36m[Function: op_net_leave_multi_v4_udp]\u001b[39m,\n", - " op_net_leave_multi_v6_udp: \u001b[36m[Function: op_net_leave_multi_v6_udp]\u001b[39m,\n", - " op_net_set_multi_loopback_udp: \u001b[36m[Function: op_net_set_multi_loopback_udp]\u001b[39m,\n", - " op_net_set_multi_ttl_udp: \u001b[36m[Function: op_net_set_multi_ttl_udp]\u001b[39m,\n", - " op_dns_resolve: \u001b[36m[Function: op_dns_resolve]\u001b[39m,\n", - " op_set_nodelay: \u001b[36m[Function: op_set_nodelay]\u001b[39m,\n", - " op_set_keepalive: \u001b[36m[Function: op_set_keepalive]\u001b[39m,\n", - " op_tls_start: \u001b[36m[Function: op_tls_start]\u001b[39m,\n", - " op_net_connect_tls: \u001b[36m[Function: op_net_connect_tls]\u001b[39m,\n", - " op_net_listen_tls: \u001b[36m[Function: op_net_listen_tls]\u001b[39m,\n", - " op_net_accept_tls: \u001b[36m[Function: op_net_accept_tls]\u001b[39m,\n", - " op_tls_handshake: \u001b[36m[Function: op_tls_handshake]\u001b[39m,\n", - " op_net_accept_unix: \u001b[36m[Function: op_net_accept_unix]\u001b[39m,\n", - " op_net_connect_unix: \u001b[36m[Function: op_net_connect_unix]\u001b[39m,\n", - " op_net_listen_unix: \u001b[36m[Function: op_net_listen_unix]\u001b[39m,\n", - " op_net_listen_unixpacket: \u001b[36m[Function: op_net_listen_unixpacket]\u001b[39m,\n", - " op_node_unstable_net_listen_unixpacket: \u001b[36m[Function: op_node_unstable_net_listen_unixpacket]\u001b[39m,\n", - " op_net_recv_unixpacket: \u001b[36m[Function: op_net_recv_unixpacket]\u001b[39m,\n", - " op_net_send_unixpacket: \u001b[36m[Function: op_net_send_unixpacket]\u001b[39m,\n", - " op_kv_database_open: \u001b[36m[Function: op_kv_database_open]\u001b[39m,\n", - " op_kv_snapshot_read: \u001b[36m[Function: op_kv_snapshot_read]\u001b[39m,\n", - " op_kv_atomic_write: \u001b[36m[Function: op_kv_atomic_write]\u001b[39m,\n", - " op_kv_encode_cursor: \u001b[36m[Function: op_kv_encode_cursor]\u001b[39m,\n", - " op_kv_dequeue_next_message: \u001b[36m[Function: op_kv_dequeue_next_message]\u001b[39m,\n", - " op_kv_finish_dequeued_message: \u001b[36m[Function: op_kv_finish_dequeued_message]\u001b[39m,\n", - " op_napi_open: \u001b[36m[Function: op_napi_open]\u001b[39m,\n", - " op_http_accept: \u001b[36m[Function: op_http_accept]\u001b[39m,\n", - " op_http_headers: \u001b[36m[Function: op_http_headers]\u001b[39m,\n", - " op_http_shutdown: \u001b[36m[Function: op_http_shutdown]\u001b[39m,\n", - " op_http_upgrade_websocket: \u001b[36m[Function: op_http_upgrade_websocket]\u001b[39m,\n", - " op_http_websocket_accept_header: \u001b[36m[Function: op_http_websocket_accept_header]\u001b[39m,\n", - " op_http_write_headers: \u001b[36m[Function: op_http_write_headers]\u001b[39m,\n", - " op_http_write_resource: \u001b[36m[Function: op_http_write_resource]\u001b[39m,\n", - " op_http_write: \u001b[36m[Function: op_http_write]\u001b[39m,\n", - " op_http_get_request_header: \u001b[36m[Function: op_http_get_request_header]\u001b[39m,\n", - " op_http_get_request_headers: \u001b[36m[Function: op_http_get_request_headers]\u001b[39m,\n", - " op_http_get_request_method_and_url: \u001b[36m[Function: op_http_get_request_method_and_url]\u001b[39m,\n", - " op_http_read_request_body: \u001b[36m[Function: op_http_read_request_body]\u001b[39m,\n", - " op_http_serve_on: \u001b[36m[Function: op_http_serve_on]\u001b[39m,\n", - " op_http_serve: \u001b[36m[Function: op_http_serve]\u001b[39m,\n", - " op_http_set_promise_complete: \u001b[36m[Function: op_http_set_promise_complete]\u001b[39m,\n", - " op_http_set_response_body_bytes: \u001b[36m[Function: op_http_set_response_body_bytes]\u001b[39m,\n", - " op_http_set_response_body_resource: \u001b[36m[Function: op_http_set_response_body_resource]\u001b[39m,\n", - " op_http_set_response_body_text: \u001b[36m[Function: op_http_set_response_body_text]\u001b[39m,\n", - " op_http_set_response_header: \u001b[36m[Function: op_http_set_response_header]\u001b[39m,\n", - " op_http_set_response_headers: \u001b[36m[Function: op_http_set_response_headers]\u001b[39m,\n", - " op_http_set_response_trailers: \u001b[36m[Function: op_http_set_response_trailers]\u001b[39m,\n", - " op_http_track: \u001b[36m[Function: op_http_track]\u001b[39m,\n", - " op_http_upgrade_websocket_next: \u001b[36m[Function: op_http_upgrade_websocket_next]\u001b[39m,\n", - " op_http_upgrade_raw: \u001b[36m[Function: op_http_upgrade_raw]\u001b[39m,\n", - " op_raw_write_vectored: \u001b[36m[Function: op_raw_write_vectored]\u001b[39m,\n", - " op_can_write_vectored: \u001b[36m[Function: op_can_write_vectored]\u001b[39m,\n", - " op_http_try_wait: \u001b[36m[Function: op_http_try_wait]\u001b[39m,\n", - " op_http_wait: \u001b[36m[Function: op_http_wait]\u001b[39m,\n", - " op_fs_cwd: \u001b[36m[Function: op_fs_cwd]\u001b[39m,\n", - " op_fs_umask: \u001b[36m[Function: op_fs_umask]\u001b[39m,\n", - " op_fs_chdir: \u001b[36m[Function: op_fs_chdir]\u001b[39m,\n", - " op_fs_open_sync: \u001b[36m[Function: op_fs_open_sync]\u001b[39m,\n", - " op_fs_open_async: \u001b[36m[Function: op_fs_open_async]\u001b[39m,\n", - " op_fs_mkdir_sync: \u001b[36m[Function: op_fs_mkdir_sync]\u001b[39m,\n", - " op_fs_mkdir_async: \u001b[36m[Function: op_fs_mkdir_async]\u001b[39m,\n", - " op_fs_chmod_sync: \u001b[36m[Function: op_fs_chmod_sync]\u001b[39m,\n", - " op_fs_chmod_async: \u001b[36m[Function: op_fs_chmod_async]\u001b[39m,\n", - " op_fs_chown_sync: \u001b[36m[Function: op_fs_chown_sync]\u001b[39m,\n", - " op_fs_chown_async: \u001b[36m[Function: op_fs_chown_async]\u001b[39m,\n", - " op_fs_remove_sync: \u001b[36m[Function: op_fs_remove_sync]\u001b[39m,\n", - " op_fs_remove_async: \u001b[36m[Function: op_fs_remove_async]\u001b[39m,\n", - " op_fs_copy_file_sync: \u001b[36m[Function: op_fs_copy_file_sync]\u001b[39m,\n", - " op_fs_copy_file_async: \u001b[36m[Function: op_fs_copy_file_async]\u001b[39m,\n", - " op_fs_stat_sync: \u001b[36m[Function: op_fs_stat_sync]\u001b[39m,\n", - " op_fs_stat_async: \u001b[36m[Function: op_fs_stat_async]\u001b[39m,\n", - " op_fs_lstat_sync: \u001b[36m[Function: op_fs_lstat_sync]\u001b[39m,\n", - " op_fs_lstat_async: \u001b[36m[Function: op_fs_lstat_async]\u001b[39m,\n", - " op_fs_realpath_sync: \u001b[36m[Function: op_fs_realpath_sync]\u001b[39m,\n", - " op_fs_realpath_async: \u001b[36m[Function: op_fs_realpath_async]\u001b[39m,\n", - " op_fs_read_dir_sync: \u001b[36m[Function: op_fs_read_dir_sync]\u001b[39m,\n", - " op_fs_read_dir_async: \u001b[36m[Function: op_fs_read_dir_async]\u001b[39m,\n", - " op_fs_rename_sync: \u001b[36m[Function: op_fs_rename_sync]\u001b[39m,\n", - " op_fs_rename_async: \u001b[36m[Function: op_fs_rename_async]\u001b[39m,\n", - " op_fs_link_sync: \u001b[36m[Function: op_fs_link_sync]\u001b[39m,\n", - " op_fs_link_async: \u001b[36m[Function: op_fs_link_async]\u001b[39m,\n", - " op_fs_symlink_sync: \u001b[36m[Function: op_fs_symlink_sync]\u001b[39m,\n", - " op_fs_symlink_async: \u001b[36m[Function: op_fs_symlink_async]\u001b[39m,\n", - " op_fs_read_link_sync: \u001b[36m[Function: op_fs_read_link_sync]\u001b[39m,\n", - " op_fs_read_link_async: \u001b[36m[Function: op_fs_read_link_async]\u001b[39m,\n", - " op_fs_truncate_sync: \u001b[36m[Function: op_fs_truncate_sync]\u001b[39m,\n", - " op_fs_truncate_async: \u001b[36m[Function: op_fs_truncate_async]\u001b[39m,\n", - " op_fs_utime_sync: \u001b[36m[Function: op_fs_utime_sync]\u001b[39m,\n", - " op_fs_utime_async: \u001b[36m[Function: op_fs_utime_async]\u001b[39m,\n", - " op_fs_make_temp_dir_sync: \u001b[36m[Function: op_fs_make_temp_dir_sync]\u001b[39m,\n", - " op_fs_make_temp_dir_async: \u001b[36m[Function: op_fs_make_temp_dir_async]\u001b[39m,\n", - " op_fs_make_temp_file_sync: \u001b[36m[Function: op_fs_make_temp_file_sync]\u001b[39m,\n", - " op_fs_make_temp_file_async: \u001b[36m[Function: op_fs_make_temp_file_async]\u001b[39m,\n", - " op_fs_write_file_sync: \u001b[36m[Function: op_fs_write_file_sync]\u001b[39m,\n", - " op_fs_write_file_async: \u001b[36m[Function: op_fs_write_file_async]\u001b[39m,\n", - " op_fs_read_file_sync: \u001b[36m[Function: op_fs_read_file_sync]\u001b[39m,\n", - " op_fs_read_file_async: \u001b[36m[Function: op_fs_read_file_async]\u001b[39m,\n", - " op_fs_read_file_text_sync: \u001b[36m[Function: op_fs_read_file_text_sync]\u001b[39m,\n", - " op_fs_read_file_text_async: \u001b[36m[Function: op_fs_read_file_text_async]\u001b[39m,\n", - " op_fs_seek_sync: \u001b[36m[Function: op_fs_seek_sync]\u001b[39m,\n", - " op_fs_seek_async: \u001b[36m[Function: op_fs_seek_async]\u001b[39m,\n", - " op_fs_fdatasync_sync: \u001b[36m[Function: op_fs_fdatasync_sync]\u001b[39m,\n", - " op_fs_fdatasync_async: \u001b[36m[Function: op_fs_fdatasync_async]\u001b[39m,\n", - " op_fs_fsync_sync: \u001b[36m[Function: op_fs_fsync_sync]\u001b[39m,\n", - " op_fs_fsync_async: \u001b[36m[Function: op_fs_fsync_async]\u001b[39m,\n", - " op_fs_fstat_sync: \u001b[36m[Function: op_fs_fstat_sync]\u001b[39m,\n", - " op_fs_fstat_async: \u001b[36m[Function: op_fs_fstat_async]\u001b[39m,\n", - " op_fs_flock_sync: \u001b[36m[Function: op_fs_flock_sync]\u001b[39m,\n", - " op_fs_flock_async: \u001b[36m[Function: op_fs_flock_async]\u001b[39m,\n", - " op_fs_funlock_sync: \u001b[36m[Function: op_fs_funlock_sync]\u001b[39m,\n", - " op_fs_funlock_async: \u001b[36m[Function: op_fs_funlock_async]\u001b[39m,\n", - " op_fs_ftruncate_sync: \u001b[36m[Function: op_fs_ftruncate_sync]\u001b[39m,\n", - " op_fs_ftruncate_async: \u001b[36m[Function: op_fs_ftruncate_async]\u001b[39m,\n", - " op_fs_futime_sync: \u001b[36m[Function: op_fs_futime_sync]\u001b[39m,\n", - " op_fs_futime_async: \u001b[36m[Function: op_fs_futime_async]\u001b[39m,\n", - " op_node_create_decipheriv: \u001b[36m[Function: op_node_create_decipheriv]\u001b[39m,\n", - " op_node_cipheriv_encrypt: \u001b[36m[Function: op_node_cipheriv_encrypt]\u001b[39m,\n", - " op_node_cipheriv_final: \u001b[36m[Function: op_node_cipheriv_final]\u001b[39m,\n", - " op_node_create_cipheriv: \u001b[36m[Function: op_node_create_cipheriv]\u001b[39m,\n", - " op_node_create_hash: \u001b[36m[Function: op_node_create_hash]\u001b[39m,\n", - " op_node_get_hashes: \u001b[36m[Function: op_node_get_hashes]\u001b[39m,\n", - " op_node_decipheriv_decrypt: \u001b[36m[Function: op_node_decipheriv_decrypt]\u001b[39m,\n", - " op_node_decipheriv_final: \u001b[36m[Function: op_node_decipheriv_final]\u001b[39m,\n", - " op_node_hash_update: \u001b[36m[Function: op_node_hash_update]\u001b[39m,\n", - " op_node_hash_update_str: \u001b[36m[Function: op_node_hash_update_str]\u001b[39m,\n", - " op_node_hash_digest: \u001b[36m[Function: op_node_hash_digest]\u001b[39m,\n", - " op_node_hash_digest_hex: \u001b[36m[Function: op_node_hash_digest_hex]\u001b[39m,\n", - " op_node_hash_clone: \u001b[36m[Function: op_node_hash_clone]\u001b[39m,\n", - " op_node_private_encrypt: \u001b[36m[Function: op_node_private_encrypt]\u001b[39m,\n", - " op_node_private_decrypt: \u001b[36m[Function: op_node_private_decrypt]\u001b[39m,\n", - " op_node_public_encrypt: \u001b[36m[Function: op_node_public_encrypt]\u001b[39m,\n", - " op_node_check_prime: \u001b[36m[Function: op_node_check_prime]\u001b[39m,\n", - " op_node_check_prime_async: \u001b[36m[Function: op_node_check_prime_async]\u001b[39m,\n", - " op_node_check_prime_bytes: \u001b[36m[Function: op_node_check_prime_bytes]\u001b[39m,\n", - " op_node_check_prime_bytes_async: \u001b[36m[Function: op_node_check_prime_bytes_async]\u001b[39m,\n", - " op_node_gen_prime: \u001b[36m[Function: op_node_gen_prime]\u001b[39m,\n", - " op_node_gen_prime_async: \u001b[36m[Function: op_node_gen_prime_async]\u001b[39m,\n", - " op_node_pbkdf2: \u001b[36m[Function: op_node_pbkdf2]\u001b[39m,\n", - " op_node_pbkdf2_async: \u001b[36m[Function: op_node_pbkdf2_async]\u001b[39m,\n", - " op_node_hkdf: \u001b[36m[Function: op_node_hkdf]\u001b[39m,\n", - " op_node_hkdf_async: \u001b[36m[Function: op_node_hkdf_async]\u001b[39m,\n", - " op_node_generate_secret: \u001b[36m[Function: op_node_generate_secret]\u001b[39m,\n", - " op_node_generate_secret_async: \u001b[36m[Function: op_node_generate_secret_async]\u001b[39m,\n", - " op_node_sign: \u001b[36m[Function: op_node_sign]\u001b[39m,\n", - " op_node_generate_rsa: \u001b[36m[Function: op_node_generate_rsa]\u001b[39m,\n", - " op_node_generate_rsa_async: \u001b[36m[Function: op_node_generate_rsa_async]\u001b[39m,\n", - " op_node_dsa_generate: \u001b[36m[Function: op_node_dsa_generate]\u001b[39m,\n", - " op_node_dsa_generate_async: \u001b[36m[Function: op_node_dsa_generate_async]\u001b[39m,\n", - " op_node_ec_generate: \u001b[36m[Function: op_node_ec_generate]\u001b[39m,\n", - " op_node_ec_generate_async: \u001b[36m[Function: op_node_ec_generate_async]\u001b[39m,\n", - " op_node_ed25519_generate: \u001b[36m[Function: op_node_ed25519_generate]\u001b[39m,\n", - " op_node_ed25519_generate_async: \u001b[36m[Function: op_node_ed25519_generate_async]\u001b[39m,\n", - " op_node_x25519_generate: \u001b[36m[Function: op_node_x25519_generate]\u001b[39m,\n", - " op_node_x25519_generate_async: \u001b[36m[Function: op_node_x25519_generate_async]\u001b[39m,\n", - " op_node_dh_generate_group: \u001b[36m[Function: op_node_dh_generate_group]\u001b[39m,\n", - " op_node_dh_generate_group_async: \u001b[36m[Function: op_node_dh_generate_group_async]\u001b[39m,\n", - " op_node_dh_generate: \u001b[36m[Function: op_node_dh_generate]\u001b[39m,\n", - " op_node_dh_generate2: \u001b[36m[Function: op_node_dh_generate2]\u001b[39m,\n", - " op_node_dh_compute_secret: \u001b[36m[Function: op_node_dh_compute_secret]\u001b[39m,\n", - " op_node_dh_generate_async: \u001b[36m[Function: op_node_dh_generate_async]\u001b[39m,\n", - " op_node_verify: \u001b[36m[Function: op_node_verify]\u001b[39m,\n", - " op_node_random_int: \u001b[36m[Function: op_node_random_int]\u001b[39m,\n", - " op_node_scrypt_sync: \u001b[36m[Function: op_node_scrypt_sync]\u001b[39m,\n", - " op_node_scrypt_async: \u001b[36m[Function: op_node_scrypt_async]\u001b[39m,\n", - " op_node_ecdh_generate_keys: \u001b[36m[Function: op_node_ecdh_generate_keys]\u001b[39m,\n", - " op_node_ecdh_compute_secret: \u001b[36m[Function: op_node_ecdh_compute_secret]\u001b[39m,\n", - " op_node_ecdh_compute_public_key: \u001b[36m[Function: op_node_ecdh_compute_public_key]\u001b[39m,\n", - " op_node_x509_parse: \u001b[36m[Function: op_node_x509_parse]\u001b[39m,\n", - " op_node_x509_ca: \u001b[36m[Function: op_node_x509_ca]\u001b[39m,\n", - " op_node_x509_check_email: \u001b[36m[Function: op_node_x509_check_email]\u001b[39m,\n", - " op_node_x509_fingerprint: \u001b[36m[Function: op_node_x509_fingerprint]\u001b[39m,\n", - " op_node_x509_fingerprint256: \u001b[36m[Function: op_node_x509_fingerprint256]\u001b[39m,\n", - " op_node_x509_fingerprint512: \u001b[36m[Function: op_node_x509_fingerprint512]\u001b[39m,\n", - " op_node_x509_get_issuer: \u001b[36m[Function: op_node_x509_get_issuer]\u001b[39m,\n", - " op_node_x509_get_subject: \u001b[36m[Function: op_node_x509_get_subject]\u001b[39m,\n", - " op_node_x509_get_valid_from: \u001b[36m[Function: op_node_x509_get_valid_from]\u001b[39m,\n", - " op_node_x509_get_valid_to: \u001b[36m[Function: op_node_x509_get_valid_to]\u001b[39m,\n", - " op_node_x509_get_serial_number: \u001b[36m[Function: op_node_x509_get_serial_number]\u001b[39m,\n", - " op_node_x509_key_usage: \u001b[36m[Function: op_node_x509_key_usage]\u001b[39m,\n", - " op_node_sys_to_uv_error: \u001b[36m[Function: op_node_sys_to_uv_error]\u001b[39m,\n", - " op_v8_cached_data_version_tag: \u001b[36m[Function: op_v8_cached_data_version_tag]\u001b[39m,\n", - " op_v8_get_heap_statistics: \u001b[36m[Function: op_v8_get_heap_statistics]\u001b[39m,\n", - " op_node_idna_domain_to_ascii: \u001b[36m[Function: op_node_idna_domain_to_ascii]\u001b[39m,\n", - " op_node_idna_domain_to_unicode: \u001b[36m[Function: op_node_idna_domain_to_unicode]\u001b[39m,\n", - " op_node_idna_punycode_decode: \u001b[36m[Function: op_node_idna_punycode_decode]\u001b[39m,\n", - " op_node_idna_punycode_encode: \u001b[36m[Function: op_node_idna_punycode_encode]\u001b[39m,\n", - " op_zlib_new: \u001b[36m[Function: op_zlib_new]\u001b[39m,\n", - " op_zlib_close: \u001b[36m[Function: op_zlib_close]\u001b[39m,\n", - " op_zlib_close_if_pending: \u001b[36m[Function: op_zlib_close_if_pending]\u001b[39m,\n", - " op_zlib_write: \u001b[36m[Function: op_zlib_write]\u001b[39m,\n", - " op_zlib_write_async: \u001b[36m[Function: op_zlib_write_async]\u001b[39m,\n", - " op_zlib_init: \u001b[36m[Function: op_zlib_init]\u001b[39m,\n", - " op_zlib_reset: \u001b[36m[Function: op_zlib_reset]\u001b[39m,\n", - " op_brotli_compress: \u001b[36m[Function: op_brotli_compress]\u001b[39m,\n", - " op_brotli_compress_async: \u001b[36m[Function: op_brotli_compress_async]\u001b[39m,\n", - " op_create_brotli_compress: \u001b[36m[Function: op_create_brotli_compress]\u001b[39m,\n", - " op_brotli_compress_stream: \u001b[36m[Function: op_brotli_compress_stream]\u001b[39m,\n", - " op_brotli_compress_stream_end: \u001b[36m[Function: op_brotli_compress_stream_end]\u001b[39m,\n", - " op_brotli_decompress: \u001b[36m[Function: op_brotli_decompress]\u001b[39m,\n", - " op_brotli_decompress_async: \u001b[36m[Function: op_brotli_decompress_async]\u001b[39m,\n", - " op_create_brotli_decompress: \u001b[36m[Function: op_create_brotli_decompress]\u001b[39m,\n", - " op_brotli_decompress_stream: \u001b[36m[Function: op_brotli_decompress_stream]\u001b[39m,\n", - " op_brotli_decompress_stream_end: \u001b[36m[Function: op_brotli_decompress_stream_end]\u001b[39m,\n", - " op_node_http_request: \u001b[36m[Function: op_node_http_request]\u001b[39m,\n", - " op_node_os_get_priority: \u001b[36m[Function: op_node_os_get_priority]\u001b[39m,\n", - " op_node_os_set_priority: \u001b[36m[Function: op_node_os_set_priority]\u001b[39m,\n", - " op_node_os_username: \u001b[36m[Function: op_node_os_username]\u001b[39m,\n", - " op_node_build_os: \u001b[36m[Function: op_node_build_os]\u001b[39m,\n", - " op_is_any_arraybuffer: \u001b[36m[Function: op_is_any_arraybuffer]\u001b[39m,\n", - " op_node_is_promise_rejected: \u001b[36m[Function: op_node_is_promise_rejected]\u001b[39m,\n", - " op_require_init_paths: \u001b[36m[Function: op_require_init_paths]\u001b[39m,\n", - " op_require_node_module_paths: \u001b[36m[Function: op_require_node_module_paths]\u001b[39m,\n", - " op_require_proxy_path: \u001b[36m[Function: op_require_proxy_path]\u001b[39m,\n", - " op_require_is_deno_dir_package: \u001b[36m[Function: op_require_is_deno_dir_package]\u001b[39m,\n", - " op_require_resolve_deno_dir: \u001b[36m[Function: op_require_resolve_deno_dir]\u001b[39m,\n", - " op_require_is_request_relative: \u001b[36m[Function: op_require_is_request_relative]\u001b[39m,\n", - " op_require_resolve_lookup_paths: \u001b[36m[Function: op_require_resolve_lookup_paths]\u001b[39m,\n", - " op_require_try_self_parent_path: \u001b[36m[Function: op_require_try_self_parent_path]\u001b[39m,\n", - " op_require_try_self: \u001b[36m[Function: op_require_try_self]\u001b[39m,\n", - " op_require_real_path: \u001b[36m[Function: op_require_real_path]\u001b[39m,\n", - " op_require_path_is_absolute: \u001b[36m[Function: op_require_path_is_absolute]\u001b[39m,\n", - " op_require_path_dirname: \u001b[36m[Function: op_require_path_dirname]\u001b[39m,\n", - " op_require_stat: \u001b[36m[Function: op_require_stat]\u001b[39m,\n", - " op_require_path_resolve: \u001b[36m[Function: op_require_path_resolve]\u001b[39m,\n", - " op_require_path_basename: \u001b[36m[Function: op_require_path_basename]\u001b[39m,\n", - " op_require_read_file: \u001b[36m[Function: op_require_read_file]\u001b[39m,\n", - " op_require_as_file_path: \u001b[36m[Function: op_require_as_file_path]\u001b[39m,\n", - " op_require_resolve_exports: \u001b[36m[Function: op_require_resolve_exports]\u001b[39m,\n", - " op_require_read_closest_package_json: \u001b[36m[Function: op_require_read_closest_package_json]\u001b[39m,\n", - " op_require_read_package_scope: \u001b[36m[Function: op_require_read_package_scope]\u001b[39m,\n", - " op_require_package_imports_resolve: \u001b[36m[Function: op_require_package_imports_resolve]\u001b[39m,\n", - " op_require_break_on_next_statement: \u001b[36m[Function: op_require_break_on_next_statement]\u001b[39m,\n", - " op_main_module: \u001b[36m[Function: op_main_module]\u001b[39m,\n", - " op_ppid: \u001b[36m[Function: op_ppid]\u001b[39m,\n", - " op_create_worker: \u001b[36m[Function: op_create_worker]\u001b[39m,\n", - " op_host_terminate_worker: \u001b[36m[Function: op_host_terminate_worker]\u001b[39m,\n", - " op_host_post_message: \u001b[36m[Function: op_host_post_message]\u001b[39m,\n", - " op_host_recv_ctrl: \u001b[36m[Function: fn]\u001b[39m,\n", - " op_host_recv_message: \u001b[36m[Function: fn]\u001b[39m,\n", - " op_fs_events_open: \u001b[36m[Function: op_fs_events_open]\u001b[39m,\n", - " op_fs_events_poll: \u001b[36m[Function: fn]\u001b[39m,\n", - " op_env: \u001b[36m[Function: op_env]\u001b[39m,\n", - " op_exec_path: \u001b[36m[Function: op_exec_path]\u001b[39m,\n", - " op_exit: \u001b[36m[Function: op_exit]\u001b[39m,\n", - " op_delete_env: \u001b[36m[Function: op_delete_env]\u001b[39m,\n", - " op_get_env: \u001b[36m[Function: op_get_env]\u001b[39m,\n", - " op_gid: \u001b[36m[Function: op_gid]\u001b[39m,\n", - " op_hostname: \u001b[36m[Function: op_hostname]\u001b[39m,\n", - " op_loadavg: \u001b[36m[Function: op_loadavg]\u001b[39m,\n", - " op_network_interfaces: \u001b[36m[Function: op_network_interfaces]\u001b[39m,\n", - " op_os_release: \u001b[36m[Function: op_os_release]\u001b[39m,\n", - " op_os_uptime: \u001b[36m[Function: op_os_uptime]\u001b[39m,\n", - " op_node_unstable_os_uptime: \u001b[36m[Function: op_node_unstable_os_uptime]\u001b[39m,\n", - " op_set_env: \u001b[36m[Function: op_set_env]\u001b[39m,\n", - " op_set_exit_code: \u001b[36m[Function: op_set_exit_code]\u001b[39m,\n", - " op_system_memory_info: \u001b[36m[Function: op_system_memory_info]\u001b[39m,\n", - " op_uid: \u001b[36m[Function: op_uid]\u001b[39m,\n", - " op_runtime_memory_usage: \u001b[36m[Function: op_runtime_memory_usage]\u001b[39m,\n", - " op_query_permission: \u001b[36m[Function: op_query_permission]\u001b[39m,\n", - " op_revoke_permission: \u001b[36m[Function: op_revoke_permission]\u001b[39m,\n", - " op_request_permission: \u001b[36m[Function: op_request_permission]\u001b[39m,\n", - " op_spawn_child: \u001b[36m[Function: op_spawn_child]\u001b[39m,\n", - " op_spawn_wait: \u001b[36m[Function: fn]\u001b[39m,\n", - " op_spawn_sync: \u001b[36m[Function: op_spawn_sync]\u001b[39m,\n", - " op_spawn_kill: \u001b[36m[Function: op_spawn_kill]\u001b[39m,\n", - " op_run: \u001b[36m[Function: op_run]\u001b[39m,\n", - " op_run_status: \u001b[36m[Function: fn]\u001b[39m,\n", - " op_kill: \u001b[36m[Function: op_kill]\u001b[39m,\n", - " op_signal_bind: \u001b[36m[Function: op_signal_bind]\u001b[39m,\n", - " op_signal_unbind: \u001b[36m[Function: op_signal_unbind]\u001b[39m,\n", - " op_signal_poll: \u001b[36m[Function: fn]\u001b[39m,\n", - " op_stdin_set_raw: \u001b[36m[Function: op_stdin_set_raw]\u001b[39m,\n", - " op_isatty: \u001b[36m[Function: op_isatty]\u001b[39m,\n", - " op_console_size: \u001b[36m[Function: op_console_size]\u001b[39m,\n", - " op_http_start: \u001b[36m[Function: op_http_start]\u001b[39m,\n", - " op_http_upgrade: \u001b[36m[Function: fn]\u001b[39m,\n", - " op_npm_process_state: \u001b[36m[Function: op_npm_process_state]\u001b[39m\n", - " },\n", - " asyncOps: {\n", - " op_error_async: \u001b[36m[Function: op_error_async]\u001b[39m,\n", - " op_error_async_deferred: \u001b[36m[Function: op_error_async_deferred]\u001b[39m,\n", - " op_void_async: \u001b[36m[Function: op_void_async]\u001b[39m,\n", - " op_void_async_deferred: \u001b[36m[Function: op_void_async_deferred]\u001b[39m,\n", - " op_add_async: \u001b[36m[Function: op_add_async]\u001b[39m,\n", - " op_read: \u001b[36m[Function: op_read]\u001b[39m,\n", - " op_read_all: \u001b[36m[Function: op_read_all]\u001b[39m,\n", - " op_write: \u001b[36m[Function: op_write]\u001b[39m,\n", - " op_write_all: \u001b[36m[Function: op_write_all]\u001b[39m,\n", - " op_write_type_error: \u001b[36m[Function: op_write_type_error]\u001b[39m,\n", - " op_shutdown: \u001b[36m[Function: op_shutdown]\u001b[39m,\n", - " op_blob_read_part: \u001b[36m[Function: op_blob_read_part]\u001b[39m,\n", - " op_message_port_recv_message: \u001b[36m[Function: op_message_port_recv_message]\u001b[39m,\n", - " op_sleep: \u001b[36m[Function: op_sleep]\u001b[39m,\n", - " op_readable_stream_resource_write_error: \u001b[36m[Function: op_readable_stream_resource_write_error]\u001b[39m,\n", - " op_readable_stream_resource_write_buf: \u001b[36m[Function: op_readable_stream_resource_write_buf]\u001b[39m,\n", - " op_readable_stream_resource_await_close: \u001b[36m[Function: op_readable_stream_resource_await_close]\u001b[39m,\n", - " op_fetch_send: \u001b[36m[Function: op_fetch_send]\u001b[39m,\n", - " op_fetch_response_upgrade: \u001b[36m[Function: op_fetch_response_upgrade]\u001b[39m,\n", - " op_cache_storage_open: \u001b[36m[Function: op_cache_storage_open]\u001b[39m,\n", - " op_cache_storage_has: \u001b[36m[Function: op_cache_storage_has]\u001b[39m,\n", - " op_cache_storage_delete: \u001b[36m[Function: op_cache_storage_delete]\u001b[39m,\n", - " op_cache_put: \u001b[36m[Function: op_cache_put]\u001b[39m,\n", - " op_cache_put_finish: \u001b[36m[Function: op_cache_put_finish]\u001b[39m,\n", - " op_cache_match: \u001b[36m[Function: op_cache_match]\u001b[39m,\n", - " op_cache_delete: \u001b[36m[Function: op_cache_delete]\u001b[39m,\n", - " op_ws_create: \u001b[36m[Function: op_ws_create]\u001b[39m,\n", - " op_ws_close: \u001b[36m[Function: op_ws_close]\u001b[39m,\n", - " op_ws_next_event: \u001b[36m[Function: op_ws_next_event]\u001b[39m,\n", - " op_ws_send_binary_async: \u001b[36m[Function: op_ws_send_binary_async]\u001b[39m,\n", - " op_ws_send_text_async: \u001b[36m[Function: op_ws_send_text_async]\u001b[39m,\n", - " op_ws_send_ping: \u001b[36m[Function: op_ws_send_ping]\u001b[39m,\n", - " op_ws_send_pong: \u001b[36m[Function: op_ws_send_pong]\u001b[39m,\n", - " op_crypto_generate_key: \u001b[36m[Function: op_crypto_generate_key]\u001b[39m,\n", - " op_crypto_sign_key: \u001b[36m[Function: op_crypto_sign_key]\u001b[39m,\n", - " op_crypto_verify_key: \u001b[36m[Function: op_crypto_verify_key]\u001b[39m,\n", - " op_crypto_derive_bits: \u001b[36m[Function: op_crypto_derive_bits]\u001b[39m,\n", - " op_crypto_encrypt: \u001b[36m[Function: op_crypto_encrypt]\u001b[39m,\n", - " op_crypto_decrypt: \u001b[36m[Function: op_crypto_decrypt]\u001b[39m,\n", - " op_crypto_subtle_digest: \u001b[36m[Function: op_crypto_subtle_digest]\u001b[39m,\n", - " op_broadcast_send: \u001b[36m[Function: op_broadcast_send]\u001b[39m,\n", - " op_broadcast_recv: \u001b[36m[Function: op_broadcast_recv]\u001b[39m,\n", - " op_ffi_call_nonblocking: \u001b[36m[Function: op_ffi_call_nonblocking]\u001b[39m,\n", - " op_ffi_call_ptr_nonblocking: \u001b[36m[Function: op_ffi_call_ptr_nonblocking]\u001b[39m,\n", - " op_ffi_unsafe_callback_ref: \u001b[36m[Function: op_ffi_unsafe_callback_ref]\u001b[39m,\n", - " op_net_accept_tcp: \u001b[36m[Function: op_net_accept_tcp]\u001b[39m,\n", - " op_net_connect_tcp: \u001b[36m[Function: op_net_connect_tcp]\u001b[39m,\n", - " op_net_recv_udp: \u001b[36m[Function: op_net_recv_udp]\u001b[39m,\n", - " op_net_send_udp: \u001b[36m[Function: op_net_send_udp]\u001b[39m,\n", - " op_net_join_multi_v4_udp: \u001b[36m[Function: op_net_join_multi_v4_udp]\u001b[39m,\n", - " op_net_join_multi_v6_udp: \u001b[36m[Function: op_net_join_multi_v6_udp]\u001b[39m,\n", - " op_net_leave_multi_v4_udp: \u001b[36m[Function: op_net_leave_multi_v4_udp]\u001b[39m,\n", - " op_net_leave_multi_v6_udp: \u001b[36m[Function: op_net_leave_multi_v6_udp]\u001b[39m,\n", - " op_net_set_multi_loopback_udp: \u001b[36m[Function: op_net_set_multi_loopback_udp]\u001b[39m,\n", - " op_net_set_multi_ttl_udp: \u001b[36m[Function: op_net_set_multi_ttl_udp]\u001b[39m,\n", - " op_dns_resolve: \u001b[36m[Function: op_dns_resolve]\u001b[39m,\n", - " op_tls_start: \u001b[36m[Function: op_tls_start]\u001b[39m,\n", - " op_net_connect_tls: \u001b[36m[Function: op_net_connect_tls]\u001b[39m,\n", - " op_net_accept_tls: \u001b[36m[Function: op_net_accept_tls]\u001b[39m,\n", - " op_tls_handshake: \u001b[36m[Function: op_tls_handshake]\u001b[39m,\n", - " op_net_accept_unix: \u001b[36m[Function: op_net_accept_unix]\u001b[39m,\n", - " op_net_connect_unix: \u001b[36m[Function: op_net_connect_unix]\u001b[39m,\n", - " op_net_recv_unixpacket: \u001b[36m[Function: op_net_recv_unixpacket]\u001b[39m,\n", - " op_net_send_unixpacket: \u001b[36m[Function: op_net_send_unixpacket]\u001b[39m,\n", - " op_kv_database_open: \u001b[36m[Function: op_kv_database_open]\u001b[39m,\n", - " op_kv_snapshot_read: \u001b[36m[Function: op_kv_snapshot_read]\u001b[39m,\n", - " op_kv_atomic_write: \u001b[36m[Function: op_kv_atomic_write]\u001b[39m,\n", - " op_kv_dequeue_next_message: \u001b[36m[Function: op_kv_dequeue_next_message]\u001b[39m,\n", - " op_kv_finish_dequeued_message: \u001b[36m[Function: op_kv_finish_dequeued_message]\u001b[39m,\n", - " op_http_accept: \u001b[36m[Function: op_http_accept]\u001b[39m,\n", - " op_http_shutdown: \u001b[36m[Function: op_http_shutdown]\u001b[39m,\n", - " op_http_upgrade_websocket: \u001b[36m[Function: op_http_upgrade_websocket]\u001b[39m,\n", - " op_http_write_headers: \u001b[36m[Function: op_http_write_headers]\u001b[39m,\n", - " op_http_write_resource: \u001b[36m[Function: op_http_write_resource]\u001b[39m,\n", - " op_http_write: \u001b[36m[Function: op_http_write]\u001b[39m,\n", - " op_http_track: \u001b[36m[Function: op_http_track]\u001b[39m,\n", - " op_http_upgrade_websocket_next: \u001b[36m[Function: op_http_upgrade_websocket_next]\u001b[39m,\n", - " op_raw_write_vectored: \u001b[36m[Function: op_raw_write_vectored]\u001b[39m,\n", - " op_http_wait: \u001b[36m[Function: op_http_wait]\u001b[39m,\n", - " op_fs_open_async: \u001b[36m[Function: op_fs_open_async]\u001b[39m,\n", - " op_fs_mkdir_async: \u001b[36m[Function: op_fs_mkdir_async]\u001b[39m,\n", - " op_fs_chmod_async: \u001b[36m[Function: op_fs_chmod_async]\u001b[39m,\n", - " op_fs_chown_async: \u001b[36m[Function: op_fs_chown_async]\u001b[39m,\n", - " op_fs_remove_async: \u001b[36m[Function: op_fs_remove_async]\u001b[39m,\n", - " op_fs_copy_file_async: \u001b[36m[Function: op_fs_copy_file_async]\u001b[39m,\n", - " op_fs_stat_async: \u001b[36m[Function: op_fs_stat_async]\u001b[39m,\n", - " op_fs_lstat_async: \u001b[36m[Function: op_fs_lstat_async]\u001b[39m,\n", - " op_fs_realpath_async: \u001b[36m[Function: op_fs_realpath_async]\u001b[39m,\n", - " op_fs_read_dir_async: \u001b[36m[Function: op_fs_read_dir_async]\u001b[39m,\n", - " op_fs_rename_async: \u001b[36m[Function: op_fs_rename_async]\u001b[39m,\n", - " op_fs_link_async: \u001b[36m[Function: op_fs_link_async]\u001b[39m,\n", - " op_fs_symlink_async: \u001b[36m[Function: op_fs_symlink_async]\u001b[39m,\n", - " op_fs_read_link_async: \u001b[36m[Function: op_fs_read_link_async]\u001b[39m,\n", - " op_fs_truncate_async: \u001b[36m[Function: op_fs_truncate_async]\u001b[39m,\n", - " op_fs_utime_async: \u001b[36m[Function: op_fs_utime_async]\u001b[39m,\n", - " op_fs_make_temp_dir_async: \u001b[36m[Function: op_fs_make_temp_dir_async]\u001b[39m,\n", - " op_fs_make_temp_file_async: \u001b[36m[Function: op_fs_make_temp_file_async]\u001b[39m,\n", - " op_fs_write_file_async: \u001b[36m[Function: op_fs_write_file_async]\u001b[39m,\n", - " op_fs_read_file_async: \u001b[36m[Function: op_fs_read_file_async]\u001b[39m,\n", - " op_fs_read_file_text_async: \u001b[36m[Function: op_fs_read_file_text_async]\u001b[39m,\n", - " op_fs_seek_async: \u001b[36m[Function: op_fs_seek_async]\u001b[39m,\n", - " op_fs_fdatasync_async: \u001b[36m[Function: op_fs_fdatasync_async]\u001b[39m,\n", - " op_fs_fsync_async: \u001b[36m[Function: op_fs_fsync_async]\u001b[39m,\n", - " op_fs_fstat_async: \u001b[36m[Function: op_fs_fstat_async]\u001b[39m,\n", - " op_fs_flock_async: \u001b[36m[Function: op_fs_flock_async]\u001b[39m,\n", - " op_fs_funlock_async: \u001b[36m[Function: op_fs_funlock_async]\u001b[39m,\n", - " op_fs_ftruncate_async: \u001b[36m[Function: op_fs_ftruncate_async]\u001b[39m,\n", - " op_fs_futime_async: \u001b[36m[Function: op_fs_futime_async]\u001b[39m,\n", - " op_node_check_prime_async: \u001b[36m[Function: op_node_check_prime_async]\u001b[39m,\n", - " op_node_check_prime_bytes_async: \u001b[36m[Function: op_node_check_prime_bytes_async]\u001b[39m,\n", - " op_node_gen_prime_async: \u001b[36m[Function: op_node_gen_prime_async]\u001b[39m,\n", - " op_node_pbkdf2_async: \u001b[36m[Function: op_node_pbkdf2_async]\u001b[39m,\n", - " op_node_hkdf_async: \u001b[36m[Function: op_node_hkdf_async]\u001b[39m,\n", - " op_node_generate_secret_async: \u001b[36m[Function: op_node_generate_secret_async]\u001b[39m,\n", - " op_node_generate_rsa_async: \u001b[36m[Function: op_node_generate_rsa_async]\u001b[39m,\n", - " op_node_dsa_generate_async: \u001b[36m[Function: op_node_dsa_generate_async]\u001b[39m,\n", - " op_node_ec_generate_async: \u001b[36m[Function: op_node_ec_generate_async]\u001b[39m,\n", - " op_node_ed25519_generate_async: \u001b[36m[Function: op_node_ed25519_generate_async]\u001b[39m,\n", - " op_node_x25519_generate_async: \u001b[36m[Function: op_node_x25519_generate_async]\u001b[39m,\n", - " op_node_dh_generate_group_async: \u001b[36m[Function: op_node_dh_generate_group_async]\u001b[39m,\n", - " op_node_dh_generate_async: \u001b[36m[Function: op_node_dh_generate_async]\u001b[39m,\n", - " op_node_scrypt_async: \u001b[36m[Function: op_node_scrypt_async]\u001b[39m,\n", - " op_zlib_write_async: \u001b[36m[Function: op_zlib_write_async]\u001b[39m,\n", - " op_brotli_compress_async: \u001b[36m[Function: op_brotli_compress_async]\u001b[39m,\n", - " op_brotli_decompress_async: \u001b[36m[Function: op_brotli_decompress_async]\u001b[39m,\n", - " op_host_recv_ctrl: \u001b[36m[Function: op_host_recv_ctrl]\u001b[39m,\n", - " op_host_recv_message: \u001b[36m[Function: op_host_recv_message]\u001b[39m,\n", - " op_fs_events_poll: \u001b[36m[Function: op_fs_events_poll]\u001b[39m,\n", - " op_spawn_wait: \u001b[36m[Function: op_spawn_wait]\u001b[39m,\n", - " op_run_status: \u001b[36m[Function: op_run_status]\u001b[39m,\n", - " op_signal_poll: \u001b[36m[Function: op_signal_poll]\u001b[39m,\n", - " op_http_upgrade: \u001b[36m[Function: op_http_upgrade]\u001b[39m\n", - " },\n", - " callConsole: \u001b[36m[Function (anonymous)]\u001b[39m,\n", - " console: Object [console] {\n", - " debug: \u001b[36m[Function: debug]\u001b[39m,\n", - " error: \u001b[36m[Function: error]\u001b[39m,\n", - " info: \u001b[36m[Function: info]\u001b[39m,\n", - " log: \u001b[36m[Function: log]\u001b[39m,\n", - " warn: \u001b[36m[Function: warn]\u001b[39m,\n", - " dir: \u001b[36m[Function: dir]\u001b[39m,\n", - " dirxml: \u001b[36m[Function: dirxml]\u001b[39m,\n", - " table: \u001b[36m[Function: table]\u001b[39m,\n", - " trace: \u001b[36m[Function: trace]\u001b[39m,\n", - " group: \u001b[36m[Function: group]\u001b[39m,\n", - " groupCollapsed: \u001b[36m[Function: groupCollapsed]\u001b[39m,\n", - " groupEnd: \u001b[36m[Function: groupEnd]\u001b[39m,\n", - " clear: \u001b[36m[Function: clear]\u001b[39m,\n", - " count: \u001b[36m[Function: count]\u001b[39m,\n", - " countReset: \u001b[36m[Function: countReset]\u001b[39m,\n", - " assert: \u001b[36m[Function: assert]\u001b[39m,\n", - " profile: \u001b[36m[Function: profile]\u001b[39m,\n", - " profileEnd: \u001b[36m[Function: profileEnd]\u001b[39m,\n", - " time: \u001b[36m[Function: time]\u001b[39m,\n", - " timeLog: \u001b[36m[Function: timeLog]\u001b[39m,\n", - " timeEnd: \u001b[36m[Function: timeEnd]\u001b[39m,\n", - " timeStamp: \u001b[36m[Function: timeStamp]\u001b[39m,\n", - " context: \u001b[36m[Function: context]\u001b[39m\n", - " },\n", - " asyncStub: \u001b[36m[Function: asyncStub]\u001b[39m,\n", - " ensureFastOps: \u001b[36m[Function: ensureFastOps]\u001b[39m,\n", - " opAsync: \u001b[36m[Function: opAsync]\u001b[39m,\n", - " resources: \u001b[36m[Function: resources]\u001b[39m,\n", - " metrics: \u001b[36m[Function: metrics]\u001b[39m,\n", - " registerErrorBuilder: \u001b[36m[Function: registerErrorBuilder]\u001b[39m,\n", - " registerErrorClass: \u001b[36m[Function: registerErrorClass]\u001b[39m,\n", - " buildCustomError: \u001b[36m[Function: buildCustomError]\u001b[39m,\n", - " eventLoopTick: \u001b[36m[Function: eventLoopTick]\u001b[39m,\n", - " BadResource: \u001b[36m[class BadResource extends Error]\u001b[39m,\n", - " BadResourcePrototype: [Error],\n", - " Interrupted: \u001b[36m[class Interrupted extends Error]\u001b[39m,\n", - " InterruptedPrototype: [Error],\n", - " enableOpCallTracing: \u001b[36m[Function: enableOpCallTracing]\u001b[39m,\n", - " isOpCallTracingEnabled: \u001b[36m[Function: isOpCallTracingEnabled]\u001b[39m,\n", - " opCallTraces: SafeMap(0) [Map] {},\n", - " refOp: \u001b[36m[Function: refOp]\u001b[39m,\n", - " unrefOp: \u001b[36m[Function: unrefOp]\u001b[39m,\n", - " setReportExceptionCallback: \u001b[36m[Function: setReportExceptionCallback]\u001b[39m,\n", - " setPromiseHooks: \u001b[36m[Function: setPromiseHooks]\u001b[39m,\n", - " close: \u001b[36m[Function: op_close]\u001b[39m,\n", - " tryClose: \u001b[36m[Function: op_try_close]\u001b[39m,\n", - " read: \u001b[36m[Function: op_read]\u001b[39m,\n", - " readAll: \u001b[36m[Function: op_read_all]\u001b[39m,\n", - " write: \u001b[36m[Function: op_write]\u001b[39m,\n", - " writeAll: \u001b[36m[Function: op_write_all]\u001b[39m,\n", - " writeTypeError: \u001b[36m[Function: op_write_type_error]\u001b[39m,\n", - " readSync: \u001b[36m[Function: op_read_sync]\u001b[39m,\n", - " writeSync: \u001b[36m[Function: op_write_sync]\u001b[39m,\n", - " shutdown: \u001b[36m[Function: op_shutdown]\u001b[39m,\n", - " print: \u001b[36m[Function: print]\u001b[39m,\n", - " setMacrotaskCallback: \u001b[36m[Function: setMacrotaskCallback]\u001b[39m,\n", - " setNextTickCallback: \u001b[36m[Function: setNextTickCallback]\u001b[39m,\n", - " runMicrotasks: \u001b[36m[Function: runMicrotasks]\u001b[39m,\n", - " hasTickScheduled: \u001b[36m[Function: hasTickScheduled]\u001b[39m,\n", - " setHasTickScheduled: \u001b[36m[Function: setHasTickScheduled]\u001b[39m,\n", - " evalContext: \u001b[36m[Function: evalContext]\u001b[39m,\n", - " createHostObject: \u001b[36m[Function: createHostObject]\u001b[39m,\n", - " encode: \u001b[36m[Function: encode]\u001b[39m,\n", - " decode: \u001b[36m[Function: decode]\u001b[39m,\n", - " serialize: \u001b[36m[Function: serialize]\u001b[39m,\n", - " deserialize: \u001b[36m[Function: deserialize]\u001b[39m,\n", - " getPromiseDetails: \u001b[36m[Function: getPromiseDetails]\u001b[39m,\n", - " getProxyDetails: \u001b[36m[Function: getProxyDetails]\u001b[39m,\n", - " isProxy: \u001b[36m[Function: isProxy]\u001b[39m,\n", - " memoryUsage: \u001b[36m[Function: memoryUsage]\u001b[39m,\n", - " setWasmStreamingCallback: \u001b[36m[Function: setWasmStreamingCallback]\u001b[39m,\n", - " abortWasmStreaming: \u001b[36m[Function: abortWasmStreaming]\u001b[39m,\n", - " destructureError: \u001b[36m[Function: destructureError]\u001b[39m,\n", - " opNames: \u001b[36m[Function: opNames]\u001b[39m,\n", - " eventLoopHasMoreWork: \u001b[36m[Function: eventLoopHasMoreWork]\u001b[39m,\n", - " setPromiseRejectCallback: \u001b[36m[Function: setPromiseRejectCallback]\u001b[39m,\n", - " byteLength: \u001b[36m[Function: byteLength]\u001b[39m,\n", - " build: {\n", - " target: \u001b[32m\"aarch64-apple-darwin\"\u001b[39m,\n", - " arch: \u001b[32m\"aarch64\"\u001b[39m,\n", - " os: \u001b[32m\"darwin\"\u001b[39m,\n", - " vendor: \u001b[32m\"apple\"\u001b[39m,\n", - " env: \u001b[90mundefined\u001b[39m\n", - " },\n", - " setBuildInfo: \u001b[36m[Function: setBuildInfo]\u001b[39m,\n", - " prepareStackTrace: \u001b[36m[Function: prepareStackTrace]\u001b[39m\n", - " }\n", - " }\n", - "}" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "Deno" - ] - }, { "attachments": {}, "cell_type": "markdown", @@ -1454,21 +494,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "id": "b5c7b819", "metadata": { "scrolled": true }, "outputs": [ { - "ename": "\"Error\"", - "evalue": "Error: this is a test", + "ename": "Error: this is a test\n at foo (:3:9)\n at :4:3", + "evalue": "", "output_type": "error", - "traceback": [ - "Error: this is a test", - " at foo (:3:11)", - " at :4:3" - ] + "traceback": [] } ], "source": [ @@ -1479,7 +515,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 16, "id": "72d01fdd", "metadata": {}, "outputs": [ @@ -1487,15 +523,13 @@ "data": { "text/plain": [ "Promise {\n", - " \u001b[31m\u001b[39m TypeError: Error parsing args: serde_v8 error: ExpectedString\n", - " at Object.opAsync (deno:core/01_core.js:141:28)\n", - " at open (deno:runtime/js/40_files.js:51:28)\n", - " at Object.readFile (deno:runtime/js/40_read_file.js:25:24)\n", + " \u001b[36m\u001b[39m TypeError: Expected string at position 0\n", + " at Object.readFile (ext:deno_fs/30_fs.js:716:29)\n", " at :2:6\n", "}" ] }, - "execution_count": 14, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" } @@ -1506,103 +540,48 @@ }, { "cell_type": "code", - "execution_count": 1, - "id": "0d2c6eaa", + "execution_count": null, + "id": "28cf59d0-6908-4edc-bb10-c325beeee362", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "\u001b[90mundefined\u001b[39m" - ] - }, - "execution_count": 1, - "metadata": {}, - "output_type": "execute_result" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[ \u001b[32m\"users\"\u001b[39m, \u001b[32m\"alice\"\u001b[39m ]\n", - "{ name: \u001b[32m\"Alice\"\u001b[39m }\n" - ] - } - ], + "outputs": [], "source": [ - "// Open the default database for the script.\n", - "const kv = await Deno.openKv();\n", - "\n", - "// Persist an object at the users/alice key.\n", - "await kv.set([\"users\", \"alice\"], { name: \"Alice\" });\n", - "\n", - "// Read back this key.\n", - "const res = await kv.get([\"users\", \"alice\"]);\n", - "console.log(res.key); // [ \"users\", \"alice\" ]\n", - "console.log(res.value); // { name: \"Alice\" }" + "console.log(\"Hello from Deno!\")" ] }, { "cell_type": "code", - "execution_count": 2, - "id": "a761bd6c-1eb0-4171-80e9-75e3710cef27", + "execution_count": null, + "id": "8d5485c3-0da3-43fe-8ef5-a61e672f5e81", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "\u001b[90mundefined\u001b[39m" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[ \u001b[32m\"users\"\u001b[39m, \u001b[32m\"alice\"\u001b[39m ]\n", - "{ name: \u001b[32m\"Alice\"\u001b[39m }\n" - ] - } - ], + "outputs": [], "source": [ - "const res2 = await kv.get([\"users\", \"alice\"]);\n", - "console.log(res2.key); // [ \"users\", \"alice\" ]\n", - "console.log(res2.value); // null" + "console.log(\"%c Hello Deno \", \"background-color: #15803d; color: white;\");" ] }, { "cell_type": "code", - "execution_count": 6, - "id": "08976272-4a23-4371-a253-6cd9c9a1caab", + "execution_count": null, + "id": "1401d9d5-6994-4c7b-b55a-db3c16a1e2dc", "metadata": {}, - "outputs": [ - { - "data": {}, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], + "source": [ + "\"Cool 🫡\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7afdaa0a-a2a0-4f52-8c7d-b6c5f237aa0d", + "metadata": {}, + "outputs": [], "source": [ - "const id = \"swift-fish-98\";\n", - "const deployPreview = {\n", - " id,\n", - " [Symbol.for(\"Jupyter.display\")]() {\n", - " return {\n", - " \"text/plain\": `Preview URL: https://${id}.deno.dev/`,\n", - " \"text/html\": ``\n", - " };\n", - " }\n", - "};" + "console.table([1, 2, 3])" ] }, { "cell_type": "code", "execution_count": null, - "id": "d903b09c-7094-45d0-b876-2652c94255c2", + "id": "8e93df23-06eb-414b-98d4-51fbebb53d1f", "metadata": {}, "outputs": [], "source": [] diff --git a/output_in_the_last_cell.ipynb b/output_in_the_last_cell.ipynb deleted file mode 100644 index 612163a0126393..00000000000000 --- a/output_in_the_last_cell.ipynb +++ /dev/null @@ -1,135 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "f84352c6-396a-4ca1-8c0d-454d56cb6ed6", - "metadata": {}, - "outputs": [ - { - "data": {}, - "execution_count": 1, - "metadata": {}, - "output_type": "execute_result" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Hello from Deno!\n" - ] - } - ], - "source": [ - "console.log(\"Hello from Deno!\")" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "be38548f-1d0c-43a0-93aa-184e8199cf1a", - "metadata": {}, - "outputs": [ - { - "data": {}, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "console.log(\"%c Hello Deno \", \"background-color: #15803d; color: white;\");" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "ba55dcd1-d519-4aed-8013-8c9af3289c1d", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "\u001b[32m\"Cool 🫡\"\u001b[39m" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "\"Cool 🫡\"" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "546b4612-9501-4841-b06e-7988f8041ec2", - "metadata": {}, - "outputs": [ - { - "data": {}, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "console.table([1, 2, 3])" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "d0461ec4-3327-4222-9868-129dc7dd43ec", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "\u001b[33m3\u001b[39m" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[48;2;21;128;61m\u001b[37m Hello Deno \u001b[0m\n", - "┌───────┬────────┐\n", - "│ (idx) │ Values │\n", - "├───────┼────────┤\n", - "│ 0 │ 1 │\n", - "│ 1 │ 2 │\n", - "│ 2 │ 3 │\n", - "└───────┴────────┘\n" - ] - } - ], - "source": [ - "3" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Deno", - "language": "typescript", - "name": "deno" - }, - "language_info": { - "file_extension": ".ts", - "mimetype": "text/x.typescript", - "name": "typescript", - "nb_converter": "script", - "pygments_lexer": "typescript", - "version": "5.2.2" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} From 525719ed462c20f58841ba217fb48b4ea9fe0b0f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= Date: Sat, 16 Sep 2023 00:50:15 +0200 Subject: [PATCH 115/115] move integration test notebook to cli/tests/testdata/ --- .../tests/testdata/jupyter/integration_test.ipynb | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename integration_test.ipynb => cli/tests/testdata/jupyter/integration_test.ipynb (100%) diff --git a/integration_test.ipynb b/cli/tests/testdata/jupyter/integration_test.ipynb similarity index 100% rename from integration_test.ipynb rename to cli/tests/testdata/jupyter/integration_test.ipynb