From 8377957666d6ca80d48d6fa78afd3e16bf3f7aa8 Mon Sep 17 00:00:00 2001 From: Aaron O'Mullan Date: Mon, 3 May 2021 01:22:57 +0200 Subject: [PATCH] refactor(runtime): use Extensions (#10461) --- runtime/ops/fs.rs | 131 ++++++++++++++++--------------------- runtime/ops/fs_events.rs | 13 +++- runtime/ops/http.rs | 23 ++++--- runtime/ops/io.rs | 39 ++++++++--- runtime/ops/net.rs | 21 ++++-- runtime/ops/os.rs | 30 +++++---- runtime/ops/permissions.rs | 14 ++-- runtime/ops/plugin.rs | 9 ++- runtime/ops/process.rs | 15 +++-- runtime/ops/runtime.rs | 17 +++-- runtime/ops/signal.rs | 15 +++-- runtime/ops/tls.rs | 17 +++-- runtime/ops/tty.rs | 14 ++-- runtime/ops/web_worker.rs | 61 +++++++++-------- runtime/ops/worker_host.rs | 68 +++++++++++-------- runtime/web_worker.rs | 100 ++++++++++++++-------------- runtime/worker.rs | 80 ++++++++-------------- 17 files changed, 366 insertions(+), 301 deletions(-) diff --git a/runtime/ops/fs.rs b/runtime/ops/fs.rs index 19933dcb6d..e22fe0c5a6 100644 --- a/runtime/ops/fs.rs +++ b/runtime/ops/fs.rs @@ -8,6 +8,9 @@ use deno_core::error::bad_resource_id; use deno_core::error::custom_error; use deno_core::error::type_error; use deno_core::error::AnyError; +use deno_core::op_async; +use deno_core::op_sync; +use deno_core::Extension; use deno_core::OpState; use deno_core::RcRef; use deno_core::ResourceId; @@ -33,80 +36,60 @@ use deno_core::error::generic_error; #[cfg(not(unix))] use deno_core::error::not_supported; -pub fn init(rt: &mut deno_core::JsRuntime) { - super::reg_sync(rt, "op_open_sync", op_open_sync); - super::reg_async(rt, "op_open_async", op_open_async); - - super::reg_sync(rt, "op_seek_sync", op_seek_sync); - super::reg_async(rt, "op_seek_async", op_seek_async); - - super::reg_sync(rt, "op_fdatasync_sync", op_fdatasync_sync); - super::reg_async(rt, "op_fdatasync_async", op_fdatasync_async); - - super::reg_sync(rt, "op_fsync_sync", op_fsync_sync); - super::reg_async(rt, "op_fsync_async", op_fsync_async); - - super::reg_sync(rt, "op_fstat_sync", op_fstat_sync); - super::reg_async(rt, "op_fstat_async", op_fstat_async); - - super::reg_sync(rt, "op_umask", op_umask); - super::reg_sync(rt, "op_chdir", op_chdir); - - super::reg_sync(rt, "op_mkdir_sync", op_mkdir_sync); - super::reg_async(rt, "op_mkdir_async", op_mkdir_async); - - super::reg_sync(rt, "op_chmod_sync", op_chmod_sync); - super::reg_async(rt, "op_chmod_async", op_chmod_async); - - super::reg_sync(rt, "op_chown_sync", op_chown_sync); - super::reg_async(rt, "op_chown_async", op_chown_async); - - super::reg_sync(rt, "op_remove_sync", op_remove_sync); - super::reg_async(rt, "op_remove_async", op_remove_async); - - super::reg_sync(rt, "op_copy_file_sync", op_copy_file_sync); - super::reg_async(rt, "op_copy_file_async", op_copy_file_async); - - super::reg_sync(rt, "op_stat_sync", op_stat_sync); - super::reg_async(rt, "op_stat_async", op_stat_async); - - super::reg_sync(rt, "op_realpath_sync", op_realpath_sync); - super::reg_async(rt, "op_realpath_async", op_realpath_async); - - super::reg_sync(rt, "op_read_dir_sync", op_read_dir_sync); - super::reg_async(rt, "op_read_dir_async", op_read_dir_async); - - super::reg_sync(rt, "op_rename_sync", op_rename_sync); - super::reg_async(rt, "op_rename_async", op_rename_async); - - super::reg_sync(rt, "op_link_sync", op_link_sync); - super::reg_async(rt, "op_link_async", op_link_async); - - super::reg_sync(rt, "op_symlink_sync", op_symlink_sync); - super::reg_async(rt, "op_symlink_async", op_symlink_async); - - super::reg_sync(rt, "op_read_link_sync", op_read_link_sync); - super::reg_async(rt, "op_read_link_async", op_read_link_async); - - super::reg_sync(rt, "op_ftruncate_sync", op_ftruncate_sync); - super::reg_async(rt, "op_ftruncate_async", op_ftruncate_async); - - super::reg_sync(rt, "op_truncate_sync", op_truncate_sync); - super::reg_async(rt, "op_truncate_async", op_truncate_async); - - super::reg_sync(rt, "op_make_temp_dir_sync", op_make_temp_dir_sync); - super::reg_async(rt, "op_make_temp_dir_async", op_make_temp_dir_async); - - super::reg_sync(rt, "op_make_temp_file_sync", op_make_temp_file_sync); - super::reg_async(rt, "op_make_temp_file_async", op_make_temp_file_async); - - super::reg_sync(rt, "op_cwd", op_cwd); - - super::reg_sync(rt, "op_futime_sync", op_futime_sync); - super::reg_async(rt, "op_futime_async", op_futime_async); - - super::reg_sync(rt, "op_utime_sync", op_utime_sync); - super::reg_async(rt, "op_utime_async", op_utime_async); +pub fn init() -> Extension { + Extension::builder() + .ops(vec![ + ("op_open_sync", op_sync(op_open_sync)), + ("op_open_async", op_async(op_open_async)), + ("op_seek_sync", op_sync(op_seek_sync)), + ("op_seek_async", op_async(op_seek_async)), + ("op_fdatasync_sync", op_sync(op_fdatasync_sync)), + ("op_fdatasync_async", op_async(op_fdatasync_async)), + ("op_fsync_sync", op_sync(op_fsync_sync)), + ("op_fsync_async", op_async(op_fsync_async)), + ("op_fstat_sync", op_sync(op_fstat_sync)), + ("op_fstat_async", op_async(op_fstat_async)), + ("op_umask", op_sync(op_umask)), + ("op_chdir", op_sync(op_chdir)), + ("op_mkdir_sync", op_sync(op_mkdir_sync)), + ("op_mkdir_async", op_async(op_mkdir_async)), + ("op_chmod_sync", op_sync(op_chmod_sync)), + ("op_chmod_async", op_async(op_chmod_async)), + ("op_chown_sync", op_sync(op_chown_sync)), + ("op_chown_async", op_async(op_chown_async)), + ("op_remove_sync", op_sync(op_remove_sync)), + ("op_remove_async", op_async(op_remove_async)), + ("op_copy_file_sync", op_sync(op_copy_file_sync)), + ("op_copy_file_async", op_async(op_copy_file_async)), + ("op_stat_sync", op_sync(op_stat_sync)), + ("op_stat_async", op_async(op_stat_async)), + ("op_realpath_sync", op_sync(op_realpath_sync)), + ("op_realpath_async", op_async(op_realpath_async)), + ("op_read_dir_sync", op_sync(op_read_dir_sync)), + ("op_read_dir_async", op_async(op_read_dir_async)), + ("op_rename_sync", op_sync(op_rename_sync)), + ("op_rename_async", op_async(op_rename_async)), + ("op_link_sync", op_sync(op_link_sync)), + ("op_link_async", op_async(op_link_async)), + ("op_symlink_sync", op_sync(op_symlink_sync)), + ("op_symlink_async", op_async(op_symlink_async)), + ("op_read_link_sync", op_sync(op_read_link_sync)), + ("op_read_link_async", op_async(op_read_link_async)), + ("op_ftruncate_sync", op_sync(op_ftruncate_sync)), + ("op_ftruncate_async", op_async(op_ftruncate_async)), + ("op_truncate_sync", op_sync(op_truncate_sync)), + ("op_truncate_async", op_async(op_truncate_async)), + ("op_make_temp_dir_sync", op_sync(op_make_temp_dir_sync)), + ("op_make_temp_dir_async", op_async(op_make_temp_dir_async)), + ("op_make_temp_file_sync", op_sync(op_make_temp_file_sync)), + ("op_make_temp_file_async", op_async(op_make_temp_file_async)), + ("op_cwd", op_sync(op_cwd)), + ("op_futime_sync", op_sync(op_futime_sync)), + ("op_futime_async", op_async(op_futime_async)), + ("op_utime_sync", op_sync(op_utime_sync)), + ("op_utime_async", op_async(op_utime_async)), + ]) + .build() } #[derive(Deserialize)] diff --git a/runtime/ops/fs_events.rs b/runtime/ops/fs_events.rs index 8bc9c4c579..6212080b09 100644 --- a/runtime/ops/fs_events.rs +++ b/runtime/ops/fs_events.rs @@ -12,6 +12,9 @@ use deno_core::Resource; use deno_core::ResourceId; use deno_core::ZeroCopyBuf; +use deno_core::op_async; +use deno_core::op_sync; +use deno_core::Extension; use notify::event::Event as NotifyEvent; use notify::Error as NotifyError; use notify::EventKind; @@ -27,9 +30,13 @@ use std::path::PathBuf; use std::rc::Rc; use tokio::sync::mpsc; -pub fn init(rt: &mut deno_core::JsRuntime) { - super::reg_sync(rt, "op_fs_events_open", op_fs_events_open); - super::reg_async(rt, "op_fs_events_poll", op_fs_events_poll); +pub fn init() -> Extension { + Extension::builder() + .ops(vec![ + ("op_fs_events_open", op_sync(op_fs_events_open)), + ("op_fs_events_poll", op_async(op_fs_events_poll)), + ]) + .build() } struct FsEventsResource { diff --git a/runtime/ops/http.rs b/runtime/ops/http.rs index 4d9787cdef..1ab8cb9981 100644 --- a/runtime/ops/http.rs +++ b/runtime/ops/http.rs @@ -10,10 +10,13 @@ use deno_core::futures::future::poll_fn; use deno_core::futures::FutureExt; use deno_core::futures::Stream; use deno_core::futures::StreamExt; +use deno_core::op_async; +use deno_core::op_sync; use deno_core::AsyncRefCell; use deno_core::CancelFuture; use deno_core::CancelHandle; use deno_core::CancelTryFuture; +use deno_core::Extension; use deno_core::OpState; use deno_core::RcRef; use deno_core::Resource; @@ -43,15 +46,17 @@ use tokio::sync::oneshot; use tokio_rustls::server::TlsStream; use tokio_util::io::StreamReader; -pub fn init(rt: &mut deno_core::JsRuntime) { - super::reg_sync(rt, "op_http_start", op_http_start); - - super::reg_async(rt, "op_http_request_next", op_http_request_next); - super::reg_async(rt, "op_http_request_read", op_http_request_read); - - super::reg_async(rt, "op_http_response", op_http_response); - super::reg_async(rt, "op_http_response_write", op_http_response_write); - super::reg_async(rt, "op_http_response_close", op_http_response_close); +pub fn init() -> Extension { + Extension::builder() + .ops(vec![ + ("op_http_start", op_sync(op_http_start)), + ("op_http_request_next", op_async(op_http_request_next)), + ("op_http_request_read", op_async(op_http_request_read)), + ("op_http_response", op_async(op_http_response)), + ("op_http_response_write", op_async(op_http_response_write)), + ("op_http_response_close", op_async(op_http_response_close)), + ]) + .build() } struct ServiceInner { diff --git a/runtime/ops/io.rs b/runtime/ops/io.rs index 0e4e3f42a1..f3b588f21d 100644 --- a/runtime/ops/io.rs +++ b/runtime/ops/io.rs @@ -4,11 +4,13 @@ use deno_core::error::null_opbuf; use deno_core::error::resource_unavailable; use deno_core::error::AnyError; use deno_core::error::{bad_resource_id, not_supported}; +use deno_core::op_async; +use deno_core::op_sync; use deno_core::AsyncMutFuture; use deno_core::AsyncRefCell; use deno_core::CancelHandle; use deno_core::CancelTryFuture; -use deno_core::JsRuntime; +use deno_core::Extension; use deno_core::OpState; use deno_core::RcRef; use deno_core::Resource; @@ -95,14 +97,35 @@ lazy_static::lazy_static! { }; } -pub fn init(rt: &mut JsRuntime) { - super::reg_async(rt, "op_read_async", op_read_async); - super::reg_async(rt, "op_write_async", op_write_async); +pub fn init() -> Extension { + Extension::builder() + .ops(vec![ + ("op_read_async", op_async(op_read_async)), + ("op_write_async", op_async(op_write_async)), + ("op_read_sync", op_sync(op_read_sync)), + ("op_write_sync", op_sync(op_write_sync)), + ("op_shutdown", op_async(op_shutdown)), + ]) + .build() +} - super::reg_sync(rt, "op_read_sync", op_read_sync); - super::reg_sync(rt, "op_write_sync", op_write_sync); - - super::reg_async(rt, "op_shutdown", op_shutdown); +pub fn init_stdio() -> Extension { + Extension::builder() + .state(|state| { + let t = &mut state.resource_table; + let (stdin, stdout, stderr) = get_stdio(); + if let Some(stream) = stdin { + t.add(stream); + } + if let Some(stream) = stdout { + t.add(stream); + } + if let Some(stream) = stderr { + t.add(stream); + } + Ok(()) + }) + .build() } pub fn get_stdio() -> ( diff --git a/runtime/ops/net.rs b/runtime/ops/net.rs index ee762ed471..f7c8eeac4d 100644 --- a/runtime/ops/net.rs +++ b/runtime/ops/net.rs @@ -9,9 +9,12 @@ use deno_core::error::generic_error; use deno_core::error::null_opbuf; use deno_core::error::type_error; use deno_core::error::AnyError; +use deno_core::op_async; +use deno_core::op_sync; use deno_core::AsyncRefCell; use deno_core::CancelHandle; use deno_core::CancelTryFuture; +use deno_core::Extension; use deno_core::OpState; use deno_core::RcRef; use deno_core::Resource; @@ -42,13 +45,17 @@ use crate::ops::io::UnixStreamResource; #[cfg(unix)] use std::path::Path; -pub fn init(rt: &mut deno_core::JsRuntime) { - super::reg_async(rt, "op_accept", op_accept); - super::reg_async(rt, "op_connect", op_connect); - super::reg_sync(rt, "op_listen", op_listen); - super::reg_async(rt, "op_datagram_receive", op_datagram_receive); - super::reg_async(rt, "op_datagram_send", op_datagram_send); - super::reg_async(rt, "op_dns_resolve", op_dns_resolve); +pub fn init() -> Extension { + Extension::builder() + .ops(vec![ + ("op_accept", op_async(op_accept)), + ("op_connect", op_async(op_connect)), + ("op_listen", op_sync(op_listen)), + ("op_datagram_receive", op_async(op_datagram_receive)), + ("op_datagram_send", op_async(op_datagram_send)), + ("op_dns_resolve", op_async(op_dns_resolve)), + ]) + .build() } #[derive(Serialize)] diff --git a/runtime/ops/os.rs b/runtime/ops/os.rs index c2c9fb5508..801a4252ac 100644 --- a/runtime/ops/os.rs +++ b/runtime/ops/os.rs @@ -3,7 +3,9 @@ use super::utils::into_string; use crate::permissions::Permissions; use deno_core::error::{type_error, AnyError}; +use deno_core::op_sync; use deno_core::url::Url; +use deno_core::Extension; use deno_core::OpState; use deno_core::ZeroCopyBuf; use serde::Deserialize; @@ -11,18 +13,22 @@ use serde::Serialize; use std::collections::HashMap; use std::env; -pub fn init(rt: &mut deno_core::JsRuntime) { - super::reg_sync(rt, "op_exit", op_exit); - super::reg_sync(rt, "op_env", op_env); - super::reg_sync(rt, "op_exec_path", op_exec_path); - super::reg_sync(rt, "op_set_env", op_set_env); - super::reg_sync(rt, "op_get_env", op_get_env); - super::reg_sync(rt, "op_delete_env", op_delete_env); - super::reg_sync(rt, "op_hostname", op_hostname); - super::reg_sync(rt, "op_loadavg", op_loadavg); - super::reg_sync(rt, "op_os_release", op_os_release); - super::reg_sync(rt, "op_system_memory_info", op_system_memory_info); - super::reg_sync(rt, "op_system_cpu_info", op_system_cpu_info); +pub fn init() -> Extension { + Extension::builder() + .ops(vec![ + ("op_exit", op_sync(op_exit)), + ("op_env", op_sync(op_env)), + ("op_exec_path", op_sync(op_exec_path)), + ("op_set_env", op_sync(op_set_env)), + ("op_get_env", op_sync(op_get_env)), + ("op_delete_env", op_sync(op_delete_env)), + ("op_hostname", op_sync(op_hostname)), + ("op_loadavg", op_sync(op_loadavg)), + ("op_os_release", op_sync(op_os_release)), + ("op_system_memory_info", op_sync(op_system_memory_info)), + ("op_system_cpu_info", op_sync(op_system_cpu_info)), + ]) + .build() } fn op_exec_path( diff --git a/runtime/ops/permissions.rs b/runtime/ops/permissions.rs index 832af485b3..d3d0da7124 100644 --- a/runtime/ops/permissions.rs +++ b/runtime/ops/permissions.rs @@ -4,16 +4,22 @@ use crate::permissions::Permissions; use deno_core::error::custom_error; use deno_core::error::uri_error; use deno_core::error::AnyError; +use deno_core::op_sync; use deno_core::url; +use deno_core::Extension; use deno_core::OpState; use deno_core::ZeroCopyBuf; use serde::Deserialize; use std::path::Path; -pub fn init(rt: &mut deno_core::JsRuntime) { - super::reg_sync(rt, "op_query_permission", op_query_permission); - super::reg_sync(rt, "op_revoke_permission", op_revoke_permission); - super::reg_sync(rt, "op_request_permission", op_request_permission); +pub fn init() -> Extension { + Extension::builder() + .ops(vec![ + ("op_query_permission", op_sync(op_query_permission)), + ("op_revoke_permission", op_sync(op_revoke_permission)), + ("op_request_permission", op_sync(op_request_permission)), + ]) + .build() } #[derive(Deserialize)] diff --git a/runtime/ops/plugin.rs b/runtime/ops/plugin.rs index c265c757f4..6892b66c3e 100644 --- a/runtime/ops/plugin.rs +++ b/runtime/ops/plugin.rs @@ -3,8 +3,9 @@ use crate::metrics::metrics_op; use crate::permissions::Permissions; use deno_core::error::AnyError; use deno_core::futures::prelude::*; +use deno_core::op_sync; use deno_core::plugin_api; -use deno_core::JsRuntime; +use deno_core::Extension; use deno_core::Op; use deno_core::OpAsyncFuture; use deno_core::OpFn; @@ -22,8 +23,10 @@ use std::rc::Rc; use std::task::Context; use std::task::Poll; -pub fn init(rt: &mut JsRuntime) { - super::reg_sync(rt, "op_open_plugin", op_open_plugin); +pub fn init() -> Extension { + Extension::builder() + .ops(vec![("op_open_plugin", op_sync(op_open_plugin))]) + .build() } pub fn op_open_plugin( diff --git a/runtime/ops/process.rs b/runtime/ops/process.rs index bf074db2ca..5712109d01 100644 --- a/runtime/ops/process.rs +++ b/runtime/ops/process.rs @@ -8,8 +8,11 @@ use crate::permissions::Permissions; use deno_core::error::bad_resource_id; use deno_core::error::type_error; use deno_core::error::AnyError; +use deno_core::op_async; +use deno_core::op_sync; use deno_core::AsyncMutFuture; use deno_core::AsyncRefCell; +use deno_core::Extension; use deno_core::OpState; use deno_core::RcRef; use deno_core::Resource; @@ -25,10 +28,14 @@ use tokio::process::Command; #[cfg(unix)] use std::os::unix::process::ExitStatusExt; -pub fn init(rt: &mut deno_core::JsRuntime) { - super::reg_sync(rt, "op_run", op_run); - super::reg_async(rt, "op_run_status", op_run_status); - super::reg_sync(rt, "op_kill", op_kill); +pub fn init() -> Extension { + Extension::builder() + .ops(vec![ + ("op_run", op_sync(op_run)), + ("op_run_status", op_async(op_run_status)), + ("op_kill", op_sync(op_kill)), + ]) + .build() } fn clone_file( diff --git a/runtime/ops/runtime.rs b/runtime/ops/runtime.rs index 7d84fadff6..6c9f027847 100644 --- a/runtime/ops/runtime.rs +++ b/runtime/ops/runtime.rs @@ -3,17 +3,20 @@ use crate::permissions::Permissions; use deno_core::error::AnyError; use deno_core::error::Context; +use deno_core::op_sync; +use deno_core::Extension; use deno_core::ModuleSpecifier; use deno_core::OpState; use deno_core::ZeroCopyBuf; -pub fn init(rt: &mut deno_core::JsRuntime, main_module: ModuleSpecifier) { - { - let op_state = rt.op_state(); - let mut state = op_state.borrow_mut(); - state.put::(main_module); - } - super::reg_sync(rt, "op_main_module", op_main_module); +pub fn init(main_module: ModuleSpecifier) -> Extension { + Extension::builder() + .ops(vec![("op_main_module", op_sync(op_main_module))]) + .state(move |state| { + state.put::(main_module.clone()); + Ok(()) + }) + .build() } fn op_main_module( diff --git a/runtime/ops/signal.rs b/runtime/ops/signal.rs index 2a19e4e981..9d884a532b 100644 --- a/runtime/ops/signal.rs +++ b/runtime/ops/signal.rs @@ -1,5 +1,8 @@ // Copyright 2018-2021 the Deno authors. All rights reserved. MIT license. use deno_core::error::AnyError; +use deno_core::op_async; +use deno_core::op_sync; +use deno_core::Extension; use deno_core::OpState; use deno_core::ZeroCopyBuf; use std::cell::RefCell; @@ -24,10 +27,14 @@ use std::borrow::Cow; #[cfg(unix)] use tokio::signal::unix::{signal, Signal, SignalKind}; -pub fn init(rt: &mut deno_core::JsRuntime) { - super::reg_sync(rt, "op_signal_bind", op_signal_bind); - super::reg_sync(rt, "op_signal_unbind", op_signal_unbind); - super::reg_async(rt, "op_signal_poll", op_signal_poll); +pub fn init() -> Extension { + Extension::builder() + .ops(vec![ + ("op_signal_bind", op_sync(op_signal_bind)), + ("op_signal_unbind", op_sync(op_signal_unbind)), + ("op_signal_poll", op_async(op_signal_poll)), + ]) + .build() } #[cfg(unix)] diff --git a/runtime/ops/tls.rs b/runtime/ops/tls.rs index 0dbf35cc41..e1a9a737f4 100644 --- a/runtime/ops/tls.rs +++ b/runtime/ops/tls.rs @@ -15,9 +15,12 @@ use deno_core::error::custom_error; use deno_core::error::generic_error; use deno_core::error::invalid_hostname; use deno_core::error::AnyError; +use deno_core::op_async; +use deno_core::op_sync; use deno_core::AsyncRefCell; use deno_core::CancelHandle; use deno_core::CancelTryFuture; +use deno_core::Extension; use deno_core::OpState; use deno_core::RcRef; use deno_core::Resource; @@ -71,11 +74,15 @@ impl StoresClientSessions for ClientSessionMemoryCache { } } -pub fn init(rt: &mut deno_core::JsRuntime) { - super::reg_async(rt, "op_start_tls", op_start_tls); - super::reg_async(rt, "op_connect_tls", op_connect_tls); - super::reg_sync(rt, "op_listen_tls", op_listen_tls); - super::reg_async(rt, "op_accept_tls", op_accept_tls); +pub fn init() -> Extension { + Extension::builder() + .ops(vec![ + ("op_start_tls", op_async(op_start_tls)), + ("op_connect_tls", op_async(op_connect_tls)), + ("op_listen_tls", op_sync(op_listen_tls)), + ("op_accept_tls", op_async(op_accept_tls)), + ]) + .build() } #[derive(Deserialize)] diff --git a/runtime/ops/tty.rs b/runtime/ops/tty.rs index a62a9ba029..c8ed54db09 100644 --- a/runtime/ops/tty.rs +++ b/runtime/ops/tty.rs @@ -5,6 +5,8 @@ use deno_core::error::bad_resource_id; use deno_core::error::not_supported; use deno_core::error::resource_unavailable; use deno_core::error::AnyError; +use deno_core::op_sync; +use deno_core::Extension; use deno_core::OpState; use deno_core::RcRef; use deno_core::ResourceId; @@ -43,10 +45,14 @@ fn get_windows_handle( Ok(handle) } -pub fn init(rt: &mut deno_core::JsRuntime) { - super::reg_sync(rt, "op_set_raw", op_set_raw); - super::reg_sync(rt, "op_isatty", op_isatty); - super::reg_sync(rt, "op_console_size", op_console_size); +pub fn init() -> Extension { + Extension::builder() + .ops(vec![ + ("op_set_raw", op_sync(op_set_raw)), + ("op_isatty", op_sync(op_isatty)), + ("op_console_size", op_sync(op_console_size)), + ]) + .build() } #[derive(Deserialize)] diff --git a/runtime/ops/web_worker.rs b/runtime/ops/web_worker.rs index 68cef110c7..17b72cb382 100644 --- a/runtime/ops/web_worker.rs +++ b/runtime/ops/web_worker.rs @@ -4,34 +4,37 @@ use crate::web_worker::WebWorkerHandle; use crate::web_worker::WorkerEvent; use deno_core::error::null_opbuf; use deno_core::futures::channel::mpsc; +use deno_core::op_sync; +use deno_core::Extension; -pub fn init( - rt: &mut deno_core::JsRuntime, - sender: mpsc::Sender, - handle: WebWorkerHandle, -) { - // Post message to host as guest worker. - let sender_ = sender.clone(); - super::reg_sync( - rt, - "op_worker_post_message", - move |_state, _args: (), buf| { - let buf = buf.ok_or_else(null_opbuf)?; - let msg_buf: Box<[u8]> = (*buf).into(); - sender_ - .clone() - .try_send(WorkerEvent::Message(msg_buf)) - .expect("Failed to post message to host"); - Ok(()) - }, - ); - - // Notify host that guest worker closes. - super::reg_sync(rt, "op_worker_close", move |_state, _args: (), _bufs| { - // Notify parent that we're finished - sender.clone().close_channel(); - // Terminate execution of current worker - handle.terminate(); - Ok(()) - }); +pub fn init() -> Extension { + Extension::builder() + .ops(vec![ + ( + "op_worker_post_message", + op_sync(move |state, _args: (), buf| { + let buf = buf.ok_or_else(null_opbuf)?; + let msg_buf: Box<[u8]> = (*buf).into(); + let mut sender = state.borrow::>().clone(); + sender + .try_send(WorkerEvent::Message(msg_buf)) + .expect("Failed to post message to host"); + Ok(()) + }), + ), + // Notify host that guest worker closes. + ( + "op_worker_close", + op_sync(move |state, _args: (), _bufs| { + // Notify parent that we're finished + let mut sender = state.borrow::>().clone(); + sender.close_channel(); + // Terminate execution of current worker + let handle = state.borrow::(); + handle.terminate(); + Ok(()) + }), + ), + ]) + .build() } diff --git a/runtime/ops/worker_host.rs b/runtime/ops/worker_host.rs index ff861c01d3..3a45542264 100644 --- a/runtime/ops/worker_host.rs +++ b/runtime/ops/worker_host.rs @@ -21,12 +21,15 @@ use deno_core::error::null_opbuf; use deno_core::error::AnyError; use deno_core::error::JsError; use deno_core::futures::channel::mpsc; +use deno_core::op_async; +use deno_core::op_sync; use deno_core::serde::de; use deno_core::serde::de::SeqAccess; use deno_core::serde::Deserialize; use deno_core::serde::Deserializer; use deno_core::serde_json::json; use deno_core::serde_json::Value; +use deno_core::Extension; use deno_core::ModuleSpecifier; use deno_core::OpState; use deno_core::ZeroCopyBuf; @@ -69,37 +72,44 @@ pub type WorkersTable = HashMap; pub type WorkerId = u32; pub fn init( - rt: &mut deno_core::JsRuntime, - sender: Option>, + is_main_worker: bool, create_web_worker_cb: Arc, -) { - { - let op_state = rt.op_state(); - let mut state = op_state.borrow_mut(); - state.put::(WorkersTable::default()); - state.put::(WorkerId::default()); +) -> Extension { + Extension::builder() + .state(move |state| { + state.put::(WorkersTable::default()); + state.put::(WorkerId::default()); - let create_module_loader = CreateWebWorkerCbHolder(create_web_worker_cb); - state.put::(create_module_loader); - } - super::reg_sync(rt, "op_create_worker", op_create_worker); - super::reg_sync(rt, "op_host_terminate_worker", op_host_terminate_worker); - super::reg_sync(rt, "op_host_post_message", op_host_post_message); - super::reg_async(rt, "op_host_get_message", op_host_get_message); - super::reg_sync( - rt, - "op_host_unhandled_error", - move |_state, message: String, _zero_copy| { - if let Some(mut sender) = sender.clone() { - sender - .try_send(WorkerEvent::Error(generic_error(message))) - .expect("Failed to propagate error event to parent worker"); - Ok(true) - } else { - Err(generic_error("Cannot be called from main worker.")) - } - }, - ); + let create_module_loader = + CreateWebWorkerCbHolder(create_web_worker_cb.clone()); + state.put::(create_module_loader); + + Ok(()) + }) + .ops(vec![ + ("op_create_worker", op_sync(op_create_worker)), + ( + "op_host_terminate_worker", + op_sync(op_host_terminate_worker), + ), + ("op_host_post_message", op_sync(op_host_post_message)), + ("op_host_get_message", op_async(op_host_get_message)), + ( + "op_host_unhandled_error", + op_sync(move |state, message: String, _| { + if is_main_worker { + return Err(generic_error("Cannot be called from main worker.")); + } + + let mut sender = state.borrow::>().clone(); + sender + .try_send(WorkerEvent::Error(generic_error(message))) + .expect("Failed to propagate error event to parent worker"); + Ok(true) + }), + ), + ]) + .build() } fn merge_boolean_permission( diff --git a/runtime/web_worker.rs b/runtime/web_worker.rs index aa219084c1..690b6fb58a 100644 --- a/runtime/web_worker.rs +++ b/runtime/web_worker.rs @@ -177,7 +177,17 @@ impl WebWorker { worker_id: u32, options: &WebWorkerOptions, ) -> Self { - let extensions: Vec = vec![ + // Permissions: many ops depend on this + let unstable = options.unstable; + let perm_ext = Extension::builder() + .state(move |state| { + state.put::(permissions.clone()); + state.put(ops::UnstableChecker { unstable }); + Ok(()) + }) + .build(); + + let mut extensions: Vec = vec![ // Web APIs deno_webidl::init(), deno_console::init(), @@ -200,8 +210,42 @@ impl WebWorker { deno_timers::init::(), // Metrics metrics::init(), + // Permissions ext (worker specific state) + perm_ext, ]; + // Runtime ops that are always initialized for WebWorkers + let runtime_exts = vec![ + ops::web_worker::init(), + ops::runtime::init(main_module.clone()), + ops::worker_host::init(false, options.create_web_worker_cb.clone()), + ops::io::init(), + ]; + + // Extensions providing Deno.* features + let deno_ns_exts = if options.use_deno_namespace { + vec![ + ops::fs_events::init(), + ops::fs::init(), + ops::net::init(), + ops::os::init(), + ops::http::init(), + ops::permissions::init(), + ops::plugin::init(), + ops::process::init(), + ops::signal::init(), + ops::tls::init(), + ops::tty::init(), + ops::io::init_stdio(), + ] + } else { + vec![] + }; + + // Append exts + extensions.extend(runtime_exts); + extensions.extend(deno_ns_exts); // May be empty + let mut js_runtime = JsRuntime::new(RuntimeOptions { module_loader: Some(options.module_loader.clone()), startup_snapshot: Some(js::deno_isolate_init()), @@ -236,60 +280,20 @@ impl WebWorker { terminate_rx, handle, use_deno_namespace: options.use_deno_namespace, - main_module: main_module.clone(), + main_module, }; + // Setup worker-dependant OpState and return worker { let handle = worker.thread_safe_handle(); let sender = worker.internal_channels.sender.clone(); let js_runtime = &mut worker.js_runtime; - // All ops registered in this function depend on these - { - let op_state = js_runtime.op_state(); - let mut op_state = op_state.borrow_mut(); - op_state.put::(permissions); - op_state.put(ops::UnstableChecker { - unstable: options.unstable, - }); - } + let op_state = js_runtime.op_state(); + let mut op_state = op_state.borrow_mut(); - ops::web_worker::init(js_runtime, sender.clone(), handle); - ops::runtime::init(js_runtime, main_module); - ops::worker_host::init( - js_runtime, - Some(sender), - options.create_web_worker_cb.clone(), - ); - ops::io::init(js_runtime); - - if options.use_deno_namespace { - ops::fs_events::init(js_runtime); - ops::fs::init(js_runtime); - ops::net::init(js_runtime); - ops::os::init(js_runtime); - ops::http::init(js_runtime); - ops::permissions::init(js_runtime); - ops::plugin::init(js_runtime); - ops::process::init(js_runtime); - ops::signal::init(js_runtime); - ops::tls::init(js_runtime); - ops::tty::init(js_runtime); - - let op_state = js_runtime.op_state(); - let mut op_state = op_state.borrow_mut(); - let t = &mut op_state.resource_table; - let (stdin, stdout, stderr) = ops::io::get_stdio(); - if let Some(stream) = stdin { - t.add(stream); - } - if let Some(stream) = stdout { - t.add(stream); - } - if let Some(stream) = stderr { - t.add(stream); - } - } - js_runtime.sync_ops_cache(); + // Required by runtime::ops::worker_host/web_worker + op_state.put(handle); + op_state.put(sender); worker } diff --git a/runtime/worker.rs b/runtime/worker.rs index 81cb038cd8..b4c27b4f4a 100644 --- a/runtime/worker.rs +++ b/runtime/worker.rs @@ -78,6 +78,16 @@ impl MainWorker { permissions: Permissions, options: &WorkerOptions, ) -> Self { + // Permissions: many ops depend on this + let unstable = options.unstable; + let perm_ext = Extension::builder() + .state(move |state| { + state.put::(permissions.clone()); + state.put(ops::UnstableChecker { unstable }); + Ok(()) + }) + .build(); + // Internal modules let extensions: Vec = vec![ // Web APIs @@ -99,6 +109,24 @@ impl MainWorker { deno_timers::init::(), // Metrics metrics::init(), + // Runtime ops + ops::runtime::init(main_module), + ops::worker_host::init(true, options.create_web_worker_cb.clone()), + ops::fs_events::init(), + ops::fs::init(), + ops::http::init(), + ops::io::init(), + ops::io::init_stdio(), + ops::net::init(), + ops::os::init(), + ops::permissions::init(), + ops::plugin::init(), + ops::process::init(), + ops::signal::init(), + ops::tls::init(), + ops::tty::init(), + // Permissions ext (worker specific state) + perm_ext, ]; let mut js_runtime = JsRuntime::new(RuntimeOptions { @@ -122,61 +150,11 @@ impl MainWorker { let should_break_on_first_statement = inspector.is_some() && options.should_break_on_first_statement; - let mut worker = Self { + Self { inspector, js_runtime, should_break_on_first_statement, - }; - - let js_runtime = &mut worker.js_runtime; - { - // All ops registered in this function depend on these - { - let op_state = js_runtime.op_state(); - let mut op_state = op_state.borrow_mut(); - op_state.put::(permissions); - op_state.put(ops::UnstableChecker { - unstable: options.unstable, - }); - } - - ops::runtime::init(js_runtime, main_module); - ops::worker_host::init( - js_runtime, - None, - options.create_web_worker_cb.clone(), - ); - ops::fs_events::init(js_runtime); - ops::fs::init(js_runtime); - ops::http::init(js_runtime); - ops::io::init(js_runtime); - ops::net::init(js_runtime); - ops::os::init(js_runtime); - ops::permissions::init(js_runtime); - ops::plugin::init(js_runtime); - ops::process::init(js_runtime); - ops::signal::init(js_runtime); - ops::tls::init(js_runtime); - ops::tty::init(js_runtime); } - { - let op_state = js_runtime.op_state(); - let mut op_state = op_state.borrow_mut(); - let t = &mut op_state.resource_table; - let (stdin, stdout, stderr) = ops::io::get_stdio(); - if let Some(stream) = stdin { - t.add(stream); - } - if let Some(stream) = stdout { - t.add(stream); - } - if let Some(stream) = stderr { - t.add(stream); - } - } - js_runtime.sync_ops_cache(); - - worker } pub fn bootstrap(&mut self, options: &WorkerOptions) {