diff options
Diffstat (limited to 'cli/ops')
| -rw-r--r-- | cli/ops/compiler.rs | 66 | ||||
| -rw-r--r-- | cli/ops/dispatch_json.rs | 121 | ||||
| -rw-r--r-- | cli/ops/dispatch_minimal.rs | 152 | ||||
| -rw-r--r-- | cli/ops/errors.rs | 23 | ||||
| -rw-r--r-- | cli/ops/fetch.rs | 33 | ||||
| -rw-r--r-- | cli/ops/fs.rs | 310 | ||||
| -rw-r--r-- | cli/ops/fs_events.rs | 33 | ||||
| -rw-r--r-- | cli/ops/idna.rs | 18 | ||||
| -rw-r--r-- | cli/ops/io.rs | 38 | ||||
| -rw-r--r-- | cli/ops/mod.rs | 8 | ||||
| -rw-r--r-- | cli/ops/net.rs | 112 | ||||
| -rw-r--r-- | cli/ops/net_unix.rs | 58 | ||||
| -rw-r--r-- | cli/ops/os.rs | 38 | ||||
| -rw-r--r-- | cli/ops/permissions.rs | 29 | ||||
| -rw-r--r-- | cli/ops/plugin.rs | 68 | ||||
| -rw-r--r-- | cli/ops/process.rs | 47 | ||||
| -rw-r--r-- | cli/ops/random.rs | 16 | ||||
| -rw-r--r-- | cli/ops/repl.rs | 30 | ||||
| -rw-r--r-- | cli/ops/resources.rs | 26 | ||||
| -rw-r--r-- | cli/ops/runtime.rs | 19 | ||||
| -rw-r--r-- | cli/ops/runtime_compiler.rs | 18 | ||||
| -rw-r--r-- | cli/ops/signal.rs | 40 | ||||
| -rw-r--r-- | cli/ops/timers.rs | 27 | ||||
| -rw-r--r-- | cli/ops/tls.rs | 52 | ||||
| -rw-r--r-- | cli/ops/tty.rs | 69 | ||||
| -rw-r--r-- | cli/ops/web_worker.rs | 119 | ||||
| -rw-r--r-- | cli/ops/websocket.rs | 279 | ||||
| -rw-r--r-- | cli/ops/worker_host.rs | 38 |
28 files changed, 661 insertions, 1226 deletions
diff --git a/cli/ops/compiler.rs b/cli/ops/compiler.rs index c35043e2d..0b8379fa3 100644 --- a/cli/ops/compiler.rs +++ b/cli/ops/compiler.rs @@ -1,67 +1,27 @@ // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license. -use super::dispatch_json::{JsonOp, Value}; -use crate::ops::json_op; + use crate::state::State; -use deno_core::CoreIsolate; -use deno_core::CoreIsolateState; -use deno_core::ErrBox; -use deno_core::ZeroCopyBuf; +use deno_core::OpRegistry; use std::rc::Rc; use std::sync::Arc; use std::sync::Mutex; -pub fn init( - i: &mut CoreIsolate, - _s: &Rc<State>, - response: Arc<Mutex<Option<String>>>, -) { +pub fn init(s: &Rc<State>, response: Arc<Mutex<Option<String>>>) { let custom_assets = std::collections::HashMap::new(); // TODO(ry) use None. // TODO(bartlomieju): is this op even required? - i.register_op( + s.register_op( "op_fetch_asset", crate::op_fetch_asset::op_fetch_asset(custom_assets), ); - i.register_op( - "op_compiler_respond", - json_op(compiler_op(response, op_compiler_respond)), - ); -} - -pub fn compiler_op<D>( - response: Arc<Mutex<Option<String>>>, - dispatcher: D, -) -> impl Fn( - &mut deno_core::CoreIsolateState, - Value, - &mut [ZeroCopyBuf], -) -> Result<JsonOp, ErrBox> -where - D: Fn( - Arc<Mutex<Option<String>>>, - Value, - &mut [ZeroCopyBuf], - ) -> Result<JsonOp, ErrBox>, -{ - move |_isolate_state: &mut CoreIsolateState, - args: Value, - zero_copy: &mut [ZeroCopyBuf]| - -> Result<JsonOp, ErrBox> { - dispatcher(response.clone(), args, zero_copy) - } -} - -fn op_compiler_respond( - response: Arc<Mutex<Option<String>>>, - args: Value, - _zero_copy: &mut [ZeroCopyBuf], -) -> Result<JsonOp, ErrBox> { - let mut r = response.lock().unwrap(); - assert!( - r.is_none(), - "op_compiler_respond found unexpected existing compiler output" - ); - *r = Some(args.to_string()); - Ok(JsonOp::Sync(json!({}))) + s.register_op_json_sync("op_compiler_respond", move |_state, args, _bufs| { + let mut response_slot = response.lock().unwrap(); + let replaced_value = response_slot.replace(args.to_string()); + assert!( + replaced_value.is_none(), + "op_compiler_respond found unexpected existing compiler output", + ); + Ok(json!({})) + }); } diff --git a/cli/ops/dispatch_json.rs b/cli/ops/dispatch_json.rs deleted file mode 100644 index e28c32382..000000000 --- a/cli/ops/dispatch_json.rs +++ /dev/null @@ -1,121 +0,0 @@ -// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license. -use deno_core::Buf; -use deno_core::CoreIsolateState; -use deno_core::ErrBox; -use deno_core::Op; -use deno_core::ZeroCopyBuf; -use futures::future::FutureExt; -pub use serde_derive::Deserialize; -use serde_json::json; -pub use serde_json::Value; -use std::future::Future; -use std::pin::Pin; - -pub type JsonResult = Result<Value, ErrBox>; - -pub type AsyncJsonOp = Pin<Box<dyn Future<Output = JsonResult>>>; - -pub enum JsonOp { - Sync(Value), - Async(AsyncJsonOp), - /// AsyncUnref is the variation of Async, which doesn't block the program - /// exiting. - AsyncUnref(AsyncJsonOp), -} - -pub fn serialize_result( - promise_id: Option<u64>, - result: JsonResult, - get_error_class_fn: deno_core::GetErrorClassFn, -) -> Buf { - let value = match result { - Ok(v) => json!({ "ok": v, "promiseId": promise_id }), - Err(err) => json!({ - "err": { - "className": (get_error_class_fn)(&err), - "message": err.to_string() - }, - "promiseId": promise_id - }), - }; - serde_json::to_vec(&value).unwrap().into_boxed_slice() -} - -#[derive(Deserialize)] -#[serde(rename_all = "camelCase")] -struct AsyncArgs { - promise_id: Option<u64>, -} - -pub fn json_op<D>( - d: D, -) -> impl Fn(&mut CoreIsolateState, &mut [ZeroCopyBuf]) -> Op -where - D: Fn( - &mut CoreIsolateState, - Value, - &mut [ZeroCopyBuf], - ) -> Result<JsonOp, ErrBox>, -{ - move |isolate_state: &mut CoreIsolateState, zero_copy: &mut [ZeroCopyBuf]| { - let get_error_class_fn = isolate_state.get_error_class_fn; - - assert!(!zero_copy.is_empty(), "Expected JSON string at position 0"); - let async_args: AsyncArgs = match serde_json::from_slice(&zero_copy[0]) { - Ok(args) => args, - Err(e) => { - let buf = serialize_result(None, Err(e.into()), get_error_class_fn); - return Op::Sync(buf); - } - }; - let promise_id = async_args.promise_id; - let is_sync = promise_id.is_none(); - - let result = serde_json::from_slice(&zero_copy[0]) - .map_err(ErrBox::from) - .and_then(|args| d(isolate_state, args, &mut zero_copy[1..])); - - // Convert to Op - match result { - Ok(JsonOp::Sync(sync_value)) => { - assert!(promise_id.is_none()); - Op::Sync(serialize_result( - promise_id, - Ok(sync_value), - get_error_class_fn, - )) - } - Ok(JsonOp::Async(fut)) => { - assert!(promise_id.is_some()); - let fut2 = fut.then(move |result| { - futures::future::ready(serialize_result( - promise_id, - result, - get_error_class_fn, - )) - }); - Op::Async(fut2.boxed_local()) - } - Ok(JsonOp::AsyncUnref(fut)) => { - assert!(promise_id.is_some()); - let fut2 = fut.then(move |result| { - futures::future::ready(serialize_result( - promise_id, - result, - get_error_class_fn, - )) - }); - Op::AsyncUnref(fut2.boxed_local()) - } - Err(sync_err) => { - let buf = - serialize_result(promise_id, Err(sync_err), get_error_class_fn); - if is_sync { - Op::Sync(buf) - } else { - Op::Async(futures::future::ready(buf).boxed_local()) - } - } - } - } -} diff --git a/cli/ops/dispatch_minimal.rs b/cli/ops/dispatch_minimal.rs index 20e8160ff..9d941682d 100644 --- a/cli/ops/dispatch_minimal.rs +++ b/cli/ops/dispatch_minimal.rs @@ -1,20 +1,17 @@ // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license. -// Do not add flatbuffer dependencies to this module. -//! Connects to js/dispatch_minimal.ts sendAsyncMinimal This acts as a faster -//! alternative to flatbuffers using a very simple list of int32s to lay out -//! messages. The first i32 is used to determine if a message a flatbuffer -//! message or a "minimal" message. -use crate::errors::get_error_class; -use deno_core::Buf; -use deno_core::CoreIsolateState; + +use crate::state::State; +use deno_core::BufVec; use deno_core::ErrBox; use deno_core::Op; -use deno_core::ZeroCopyBuf; +use deno_core::OpId; +use deno_core::OpRegistry; use futures::future::FutureExt; use std::future::Future; use std::iter::repeat; use std::mem::size_of_val; use std::pin::Pin; +use std::rc::Rc; use std::slice; pub enum MinimalOp { @@ -30,8 +27,8 @@ pub struct Record { pub result: i32, } -impl Into<Buf> for Record { - fn into(self) -> Buf { +impl Into<Box<[u8]>> for Record { + fn into(self) -> Box<[u8]> { let vec = vec![self.promise_id, self.arg, self.result]; let buf32 = vec.into_boxed_slice(); let ptr = Box::into_raw(buf32) as *mut [u8; 3 * 4]; @@ -47,8 +44,8 @@ pub struct ErrorRecord { pub error_message: Vec<u8>, } -impl Into<Buf> for ErrorRecord { - fn into(self) -> Buf { +impl Into<Box<[u8]>> for ErrorRecord { + fn into(self) -> Box<[u8]> { let Self { promise_id, arg, @@ -91,7 +88,7 @@ fn test_error_record() { error_class: b"BadResource", error_message: b"Error".to_vec(), }; - let buf: Buf = err_record.into(); + let buf: Box<[u8]> = err_record.into(); assert_eq!(buf, expected.into_boxed_slice()); } @@ -124,7 +121,7 @@ fn test_parse_min_record() { Some(Record { promise_id: 1, arg: 3, - result: 4, + result: 4 }) ); @@ -135,73 +132,78 @@ fn test_parse_min_record() { assert_eq!(parse_min_record(&buf), None); } -pub fn minimal_op<D>( - d: D, -) -> impl Fn(&mut CoreIsolateState, &mut [ZeroCopyBuf]) -> Op -where - D: Fn(&mut CoreIsolateState, bool, i32, &mut [ZeroCopyBuf]) -> MinimalOp, -{ - move |isolate_state: &mut CoreIsolateState, zero_copy: &mut [ZeroCopyBuf]| { - assert!(!zero_copy.is_empty(), "Expected record at position 0"); - let mut record = match parse_min_record(&zero_copy[0]) { - Some(r) => r, - None => { - let error = ErrBox::type_error("Unparsable control buffer"); - let error_class = get_error_class(&error); - let error_record = ErrorRecord { - promise_id: 0, - arg: -1, - error_len: error_class.len() as i32, - error_class: error_class.as_bytes(), - error_message: error.to_string().as_bytes().to_owned(), - }; - return Op::Sync(error_record.into()); - } - }; - let is_sync = record.promise_id == 0; - let rid = record.arg; - let min_op = d(isolate_state, is_sync, rid, &mut zero_copy[1..]); - - match min_op { - MinimalOp::Sync(sync_result) => Op::Sync(match sync_result { - Ok(r) => { - record.result = r; - record.into() - } - Err(err) => { - let error_class = get_error_class(&err); +impl State { + pub fn register_op_minimal<F>(self: &Rc<Self>, name: &str, op_fn: F) -> OpId + where + F: Fn(Rc<Self>, bool, i32, BufVec) -> MinimalOp + 'static, + { + let base_op_fn = move |state: Rc<Self>, bufs: BufVec| { + let mut bufs_iter = bufs.into_iter(); + let record_buf = bufs_iter.next().expect("Expected record at position 0"); + let zero_copy = bufs_iter.collect::<BufVec>(); + + let mut record = match parse_min_record(&record_buf) { + Some(r) => r, + None => { + let error = ErrBox::type_error("Unparsable control buffer"); + let error_class = state.get_error_class_name(&error); let error_record = ErrorRecord { - promise_id: record.promise_id, + promise_id: 0, arg: -1, error_len: error_class.len() as i32, error_class: error_class.as_bytes(), - error_message: err.to_string().as_bytes().to_owned(), + error_message: error.to_string().as_bytes().to_owned(), }; - error_record.into() + return Op::Sync(error_record.into()); } - }), - MinimalOp::Async(min_fut) => { - let fut = async move { - match min_fut.await { - Ok(r) => { - record.result = r; - record.into() - } - Err(err) => { - let error_class = get_error_class(&err); - let error_record = ErrorRecord { - promise_id: record.promise_id, - arg: -1, - error_len: error_class.len() as i32, - error_class: error_class.as_bytes(), - error_message: err.to_string().as_bytes().to_owned(), - }; - error_record.into() - } + }; + let is_sync = record.promise_id == 0; + let rid = record.arg; + let min_op = op_fn(state.clone(), is_sync, rid, zero_copy); + + match min_op { + MinimalOp::Sync(sync_result) => Op::Sync(match sync_result { + Ok(r) => { + record.result = r; + record.into() + } + Err(err) => { + let error_class = state.get_error_class_name(&err); + let error_record = ErrorRecord { + promise_id: record.promise_id, + arg: -1, + error_len: error_class.len() as i32, + error_class: error_class.as_bytes(), + error_message: err.to_string().as_bytes().to_owned(), + }; + error_record.into() } - }; - Op::Async(fut.boxed_local()) + }), + MinimalOp::Async(min_fut) => { + let fut = async move { + match min_fut.await { + Ok(r) => { + record.result = r; + record.into() + } + Err(err) => { + let error_class = state.get_error_class_name(&err); + let error_record = ErrorRecord { + promise_id: record.promise_id, + arg: -1, + error_len: error_class.len() as i32, + error_class: error_class.as_bytes(), + error_message: err.to_string().as_bytes().to_owned(), + }; + error_record.into() + } + } + }; + Op::Async(fut.boxed_local()) + } } - } + }; + + self.register_op(name, base_op_fn) } } diff --git a/cli/ops/errors.rs b/cli/ops/errors.rs index 558f9af2a..a4f4665e2 100644 --- a/cli/ops/errors.rs +++ b/cli/ops/errors.rs @@ -1,27 +1,20 @@ // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license. -use super::dispatch_json::{Deserialize, Value}; + use crate::diagnostics::Diagnostic; use crate::source_maps::get_orig_position; use crate::source_maps::CachedMaps; use crate::state::State; -use deno_core::CoreIsolate; use deno_core::ErrBox; -use deno_core::ResourceTable; +use deno_core::OpRegistry; use deno_core::ZeroCopyBuf; +use serde_derive::Deserialize; +use serde_json::Value; use std::collections::HashMap; use std::rc::Rc; -pub fn init(i: &mut CoreIsolate, s: &Rc<State>) { - let t = &CoreIsolate::state(i).borrow().resource_table.clone(); - - i.register_op( - "op_apply_source_map", - s.stateful_json_op_sync(t, op_apply_source_map), - ); - i.register_op( - "op_format_diagnostic", - s.stateful_json_op_sync(t, op_format_diagnostic), - ); +pub fn init(s: &Rc<State>) { + s.register_op_json_sync("op_apply_source_map", op_apply_source_map); + s.register_op_json_sync("op_format_diagnostic", op_format_diagnostic); } #[derive(Deserialize)] @@ -34,7 +27,6 @@ struct ApplySourceMap { fn op_apply_source_map( state: &State, - _resource_table: &mut ResourceTable, args: Value, _zero_copy: &mut [ZeroCopyBuf], ) -> Result<Value, ErrBox> { @@ -59,7 +51,6 @@ fn op_apply_source_map( fn op_format_diagnostic( _state: &State, - _resource_table: &mut ResourceTable, args: Value, _zero_copy: &mut [ZeroCopyBuf], ) -> Result<Value, ErrBox> { diff --git a/cli/ops/fetch.rs b/cli/ops/fetch.rs index aea7bc7fc..690cbc592 100644 --- a/cli/ops/fetch.rs +++ b/cli/ops/fetch.rs @@ -1,30 +1,25 @@ // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license. -use super::dispatch_json::{Deserialize, Value}; + use super::io::{StreamResource, StreamResourceHolder}; use crate::http_util::{create_http_client, HttpBody}; use crate::state::State; use deno_core::BufVec; -use deno_core::CoreIsolate; use deno_core::ErrBox; -use deno_core::ResourceTable; +use deno_core::OpRegistry; use deno_core::ZeroCopyBuf; use http::header::HeaderName; use http::header::HeaderValue; use http::Method; use reqwest::Client; -use std::cell::RefCell; +use serde_derive::Deserialize; +use serde_json::Value; use std::convert::From; use std::path::PathBuf; use std::rc::Rc; -pub fn init(i: &mut CoreIsolate, s: &Rc<State>) { - let t = &CoreIsolate::state(i).borrow().resource_table.clone(); - - i.register_op("op_fetch", s.stateful_json_op_async(t, op_fetch)); - i.register_op( - "op_create_http_client", - s.stateful_json_op_sync(t, op_create_http_client), - ); +pub fn init(s: &Rc<State>) { + s.register_op_json_async("op_fetch", op_fetch); + s.register_op_json_sync("op_create_http_client", op_create_http_client); } #[derive(Deserialize)] @@ -38,16 +33,14 @@ struct FetchArgs { async fn op_fetch( state: Rc<State>, - resource_table: Rc<RefCell<ResourceTable>>, args: Value, data: BufVec, ) -> Result<Value, ErrBox> { let args: FetchArgs = serde_json::from_value(args)?; let url = args.url; - let resource_table2 = resource_table.clone(); let client = if let Some(rid) = args.client_rid { - let resource_table_ = resource_table.borrow(); + let resource_table_ = state.resource_table.borrow(); let r = resource_table_ .get::<HttpClientResource>(rid) .ok_or_else(ErrBox::bad_resource_id)?; @@ -100,8 +93,7 @@ async fn op_fetch( } let body = HttpBody::from(res); - let mut resource_table = resource_table2.borrow_mut(); - let rid = resource_table.add( + let rid = state.resource_table.borrow_mut().add( "httpBody", Box::new(StreamResourceHolder::new(StreamResource::HttpBody( Box::new(body), @@ -137,7 +129,6 @@ struct CreateHttpClientOptions { fn op_create_http_client( state: &State, - resource_table: &mut ResourceTable, args: Value, _zero_copy: &mut [ZeroCopyBuf], ) -> Result<Value, ErrBox> { @@ -149,7 +140,9 @@ fn op_create_http_client( let client = create_http_client(args.ca_file.as_deref()).unwrap(); - let rid = - resource_table.add("httpClient", Box::new(HttpClientResource::new(client))); + let rid = state + .resource_table + .borrow_mut() + .add("httpClient", Box::new(HttpClientResource::new(client))); Ok(json!(rid)) } diff --git a/cli/ops/fs.rs b/cli/ops/fs.rs index 490ecd52f..e281f947e 100644 --- a/cli/ops/fs.rs +++ b/cli/ops/fs.rs @@ -1,16 +1,16 @@ // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license. // Some deserializer fields are only used on Unix and Windows build fails without it -use super::dispatch_json::{Deserialize, Value}; use super::io::std_file_resource; use super::io::{FileMetadata, StreamResource, StreamResourceHolder}; -use crate::ops::dispatch_json::JsonResult; use crate::state::State; use deno_core::BufVec; -use deno_core::CoreIsolate; use deno_core::ErrBox; -use deno_core::ResourceTable; +use deno_core::OpRegistry; use deno_core::ZeroCopyBuf; -use std::cell::RefCell; +use rand::thread_rng; +use rand::Rng; +use serde_derive::Deserialize; +use serde_json::Value; use std::convert::From; use std::env::{current_dir, set_current_dir, temp_dir}; use std::io; @@ -20,171 +20,80 @@ use std::rc::Rc; use std::time::SystemTime; use std::time::UNIX_EPOCH; -use rand::{thread_rng, Rng}; +pub fn init(s: &Rc<State>) { + s.register_op_json_sync("op_open_sync", op_open_sync); + s.register_op_json_async("op_open_async", op_open_async); -pub fn init(i: &mut CoreIsolate, s: &Rc<State>) { - let t = &CoreIsolate::state(i).borrow().resource_table.clone(); + s.register_op_json_sync("op_seek_sync", op_seek_sync); + s.register_op_json_async("op_seek_async", op_seek_async); - i.register_op("op_open_sync", s.stateful_json_op_sync(t, op_open_sync)); - i.register_op("op_open_async", s.stateful_json_op_async(t, op_open_async)); + s.register_op_json_sync("op_fdatasync_sync", op_fdatasync_sync); + s.register_op_json_async("op_fdatasync_async", op_fdatasync_async); - i.register_op("op_seek_sync", s.stateful_json_op_sync(t, op_seek_sync)); - i.register_op("op_seek_async", s.stateful_json_op_async(t, op_seek_async)); + s.register_op_json_sync("op_fsync_sync", op_fsync_sync); + s.register_op_json_async("op_fsync_async", op_fsync_async); - i.register_op( - "op_fdatasync_sync", - s.stateful_json_op_sync(t, op_fdatasync_sync), - ); - i.register_op( - "op_fdatasync_async", - s.stateful_json_op_async(t, op_fdatasync_async), - ); + s.register_op_json_sync("op_fstat_sync", op_fstat_sync); + s.register_op_json_async("op_fstat_async", op_fstat_async); - i.register_op("op_fsync_sync", s.stateful_json_op_sync(t, op_fsync_sync)); - i.register_op( - "op_fsync_async", - s.stateful_json_op_async(t, op_fsync_async), - ); + s.register_op_json_sync("op_umask", op_umask); + s.register_op_json_sync("op_chdir", op_chdir); - i.register_op("op_fstat_sync", s.stateful_json_op_sync(t, op_fstat_sync)); - i.register_op( - "op_fstat_async", - s.stateful_json_op_async(t, op_fstat_async), - ); + s.register_op_json_sync("op_mkdir_sync", op_mkdir_sync); + s.register_op_json_async("op_mkdir_async", op_mkdir_async); - i.register_op("op_umask", s.stateful_json_op_sync(t, op_umask)); - i.register_op("op_chdir", s.stateful_json_op_sync(t, op_chdir)); + s.register_op_json_sync("op_chmod_sync", op_chmod_sync); + s.register_op_json_async("op_chmod_async", op_chmod_async); - i.register_op("op_mkdir_sync", s.stateful_json_op_sync(t, op_mkdir_sync)); - i.register_op( - "op_mkdir_async", - s.stateful_json_op_async(t, op_mkdir_async), - ); + s.register_op_json_sync("op_chown_sync", op_chown_sync); + s.register_op_json_async("op_chown_async", op_chown_async); - i.register_op("op_chmod_sync", s.stateful_json_op_sync(t, op_chmod_sync)); - i.register_op( - "op_chmod_async", - s.stateful_json_op_async(t, op_chmod_async), - ); + s.register_op_json_sync("op_remove_sync", op_remove_sync); + s.register_op_json_async("op_remove_async", op_remove_async); - i.register_op("op_chown_sync", s.stateful_json_op_sync(t, op_chown_sync)); - i.register_op( - "op_chown_async", - s.stateful_json_op_async(t, op_chown_async), - ); + s.register_op_json_sync("op_copy_file_sync", op_copy_file_sync); + s.register_op_json_async("op_copy_file_async", op_copy_file_async); - i.register_op("op_remove_sync", s.stateful_json_op_sync(t, op_remove_sync)); - i.register_op( - "op_remove_async", - s.stateful_json_op_async(t, op_remove_async), - ); + s.register_op_json_sync("op_stat_sync", op_stat_sync); + s.register_op_json_async("op_stat_async", op_stat_async); - i.register_op( - "op_copy_file_sync", - s.stateful_json_op_sync(t, op_copy_file_sync), - ); - i.register_op( - "op_copy_file_async", - s.stateful_json_op_async(t, op_copy_file_async), - ); + s.register_op_json_sync("op_realpath_sync", op_realpath_sync); + s.register_op_json_async("op_realpath_async", op_realpath_async); - i.register_op("op_stat_sync", s.stateful_json_op_sync(t, op_stat_sync)); - i.register_op("op_stat_async", s.stateful_json_op_async(t, op_stat_async)); + s.register_op_json_sync("op_read_dir_sync", op_read_dir_sync); + s.register_op_json_async("op_read_dir_async", op_read_dir_async); - i.register_op( - "op_realpath_sync", - s.stateful_json_op_sync(t, op_realpath_sync), - ); - i.register_op( - "op_realpath_async", - s.stateful_json_op_async(t, op_realpath_async), - ); + s.register_op_json_sync("op_rename_sync", op_rename_sync); + s.register_op_json_async("op_rename_async", op_rename_async); - i.register_op( - "op_read_dir_sync", - s.stateful_json_op_sync(t, op_read_dir_sync), - ); - i.register_op( - "op_read_dir_async", - s.stateful_json_op_async(t, op_read_dir_async), - ); + s.register_op_json_sync("op_link_sync", op_link_sync); + s.register_op_json_async("op_link_async", op_link_async); - i.register_op("op_rename_sync", s.stateful_json_op_sync(t, op_rename_sync)); - i.register_op( - "op_rename_async", - s.stateful_json_op_async(t, op_rename_async), - ); + s.register_op_json_sync("op_symlink_sync", op_symlink_sync); + s.register_op_json_async("op_symlink_async", op_symlink_async); - i.register_op("op_link_sync", s.stateful_json_op_sync(t, op_link_sync)); - i.register_op("op_link_async", s.stateful_json_op_async(t, op_link_async)); + s.register_op_json_sync("op_read_link_sync", op_read_link_sync); + s.register_op_json_async("op_read_link_async", op_read_link_async); - i.register_op( - "op_symlink_sync", - s.stateful_json_op_sync(t, op_symlink_sync), - ); - i.register_op( - "op_symlink_async", - s.stateful_json_op_async(t, op_symlink_async), - ); + s.register_op_json_sync("op_ftruncate_sync", op_ftruncate_sync); + s.register_op_json_async("op_ftruncate_async", op_ftruncate_async); - i.register_op( - "op_read_link_sync", - s.stateful_json_op_sync(t, op_read_link_sync), - ); - i.register_op( - "op_read_link_async", - s.stateful_json_op_async(t, op_read_link_async), - ); - - i.register_op( - "op_ftruncate_sync", - s.stateful_json_op_sync(t, op_ftruncate_sync), - ); - i.register_op( - "op_ftruncate_async", - s.stateful_json_op_async(t, op_ftruncate_async), - ); - - i.register_op( - "op_truncate_sync", - s.stateful_json_op_sync(t, op_truncate_sync), - ); - i.register_op( - "op_truncate_async", - s.stateful_json_op_async(t, op_truncate_async), - ); + s.register_op_json_sync("op_truncate_sync", op_truncate_sync); + s.register_op_json_async("op_truncate_async", op_truncate_async); - i.register_op( - "op_make_temp_dir_sync", - s.stateful_json_op_sync(t, op_make_temp_dir_sync), - ); - i.register_op( - "op_make_temp_dir_async", - s.stateful_json_op_async(t, op_make_temp_dir_async), - ); + s.register_op_json_sync("op_make_temp_dir_sync", op_make_temp_dir_sync); + s.register_op_json_async("op_make_temp_dir_async", op_make_temp_dir_async); - i.register_op( - "op_make_temp_file_sync", - s.stateful_json_op_sync(t, op_make_temp_file_sync), - ); - i.register_op( - "op_make_temp_file_async", - s.stateful_json_op_async(t, op_make_temp_file_async), - ); + s.register_op_json_sync("op_make_temp_file_sync", op_make_temp_file_sync); + s.register_op_json_async("op_make_temp_file_async", op_make_temp_file_async); - i.register_op("op_cwd", s.stateful_json_op_sync(t, op_cwd)); + s.register_op_json_sync("op_cwd", op_cwd); - i.register_op("op_futime_sync", s.stateful_json_op_sync(t, op_futime_sync)); - i.register_op( - "op_futime_async", - s.stateful_json_op_async(t, op_futime_async), - ); + s.register_op_json_sync("op_futime_sync", op_futime_sync); + s.register_op_json_async("op_futime_async", op_futime_async); - i.register_op("op_utime_sync", s.stateful_json_op_sync(t, op_utime_sync)); - i.register_op( - "op_utime_async", - s.stateful_json_op_async(t, op_utime_async), - ); + s.register_op_json_sync("op_utime_sync", op_utime_sync); + s.register_op_json_async("op_utime_async", op_utime_async); } fn into_string(s: std::ffi::OsString) -> Result<String, ErrBox> { @@ -257,14 +166,13 @@ fn open_helper( fn op_open_sync( state: &State, - resource_table: &mut ResourceTable, args: Value, _zero_copy: &mut [ZeroCopyBuf], ) -> Result<Value, ErrBox> { let (path, open_options) = open_helper(state, args)?; let std_file = open_options.open(path)?; let tokio_file = tokio::fs::File::from_std(std_file); - let rid = resource_table.add( + let rid = state.resource_table.borrow_mut().add( "fsFile", Box::new(StreamResourceHolder::new(StreamResource::FsFile(Some(( tokio_file, @@ -276,7 +184,6 @@ fn op_open_sync( async fn op_open_async( state: Rc<State>, - resource_table: Rc<RefCell<ResourceTable>>, args: Value, _zero_copy: BufVec, ) -> Result<Value, ErrBox> { @@ -284,7 +191,7 @@ async fn op_open_async( let tokio_file = tokio::fs::OpenOptions::from(open_options) .open(path) .await?; - let rid = resource_table.borrow_mut().add( + let rid = state.resource_table.borrow_mut().add( "fsFile", Box::new(StreamResourceHolder::new(StreamResource::FsFile(Some(( tokio_file, @@ -321,13 +228,12 @@ fn seek_helper(args: Value) -> Result<(u32, SeekFrom), ErrBox> { } fn op_seek_sync( - _state: &State, - resource_table: &mut ResourceTable, + state: &State, args: Value, _zero_copy: &mut [ZeroCopyBuf], ) -> Result<Value, ErrBox> { let (rid, seek_from) = seek_helper(args)?; - let pos = std_file_resource(resource_table, rid, |r| match r { + let pos = std_file_resource(state, rid, |r| match r { Ok(std_file) => std_file.seek(seek_from).map_err(ErrBox::from), Err(_) => Err(ErrBox::type_error( "cannot seek on this type of resource".to_string(), @@ -337,16 +243,14 @@ fn op_seek_sync( } async fn op_seek_async( - _state: Rc<State>, - resource_table: Rc<RefCell<ResourceTable>>, + state: Rc<State>, args: Value, _zero_copy: BufVec, ) -> Result<Value, ErrBox> { let (rid, seek_from) = seek_helper(args)?; // TODO(ry) This is a fake async op. We need to use poll_fn, // tokio::fs::File::start_seek and tokio::fs::File::poll_complete - let mut resource_table = resource_table.borrow_mut(); - let pos = std_file_resource(&mut resource_table, rid, |r| match r { + let pos = std_file_resource(&state, rid, |r| match r { Ok(std_file) => std_file.seek(seek_from).map_err(ErrBox::from), Err(_) => Err(ErrBox::type_error( "cannot seek on this type of resource".to_string(), @@ -363,14 +267,13 @@ struct FdatasyncArgs { fn op_fdatasync_sync( state: &State, - resource_table: &mut ResourceTable, args: Value, _zero_copy: &mut [ZeroCopyBuf], ) -> Result<Value, ErrBox> { state.check_unstable("Deno.fdatasync"); let args: FdatasyncArgs = serde_json::from_value(args)?; let rid = args.rid as u32; - std_file_resource(resource_table, rid, |r| match r { + std_file_resource(state, rid, |r| match r { Ok(std_file) => std_file.sync_data().map_err(ErrBox::from), Err(_) => Err(ErrBox::type_error( "cannot sync this type of resource".to_string(), @@ -381,15 +284,13 @@ fn op_fdatasync_sync( async fn op_fdatasync_async( state: Rc<State>, - resource_table: Rc<RefCell<ResourceTable>>, args: Value, _zero_copy: BufVec, ) -> Result<Value, ErrBox> { state.check_unstable("Deno.fdatasync"); let args: FdatasyncArgs = serde_json::from_value(args)?; let rid = args.rid as u32; - let mut resource_table = resource_table.borrow_mut(); - std_file_resource(&mut resource_table, rid, |r| match r { + std_file_resource(&state, rid, |r| match r { Ok(std_file) => std_file.sync_data().map_err(ErrBox::from), Err(_) => Err(ErrBox::type_error( "cannot sync this type of resource".to_string(), @@ -406,14 +307,13 @@ struct FsyncArgs { fn op_fsync_sync( state: &State, - resource_table: &mut ResourceTable, args: Value, _zero_copy: &mut [ZeroCopyBuf], ) -> Result<Value, ErrBox> { state.check_unstable("Deno.fsync"); let args: FsyncArgs = serde_json::from_value(args)?; let rid = args.rid as u32; - std_file_resource(resource_table, rid, |r| match r { + std_file_resource(state, rid, |r| match r { Ok(std_file) => std_file.sync_all().map_err(ErrBox::from), Err(_) => Err(ErrBox::type_error( "cannot sync this type of resource".to_string(), @@ -424,15 +324,13 @@ fn op_fsync_sync( async fn op_fsync_async( state: Rc<State>, - resource_table: Rc<RefCell<ResourceTable>>, args: Value, _zero_copy: BufVec, ) -> Result<Value, ErrBox> { state.check_unstable("Deno.fsync"); let args: FsyncArgs = serde_json::from_value(args)?; let rid = args.rid as u32; - let mut resource_table = resource_table.borrow_mut(); - std_file_resource(&mut resource_table, rid, |r| match r { + std_file_resource(&state, rid, |r| match r { Ok(std_file) => std_file.sync_all().map_err(ErrBox::from), Err(_) => Err(ErrBox::type_error( "cannot sync this type of resource".to_string(), @@ -449,14 +347,13 @@ struct FstatArgs { fn op_fstat_sync( state: &State, - resource_table: &mut ResourceTable, args: Value, _zero_copy: &mut [ZeroCopyBuf], ) -> Result<Value, ErrBox> { state.check_unstable("Deno.fstat"); let args: FstatArgs = serde_json::from_value(args)?; let rid = args.rid as u32; - let metadata = std_file_resource(resource_table, rid, |r| match r { + let metadata = std_file_resource(state, rid, |r| match r { Ok(std_file) => std_file.metadata().map_err(ErrBox::from), Err(_) => Err(ErrBox::type_error( "cannot stat this type of resource".to_string(), @@ -467,15 +364,13 @@ fn op_fstat_sync( async fn op_fstat_async( state: Rc<State>, - resource_table: Rc<RefCell<ResourceTable>>, args: Value, _zero_copy: BufVec, ) -> Result<Value, ErrBox> { state.check_unstable("Deno.fstat"); let args: FstatArgs = serde_json::from_value(args)?; let rid = args.rid as u32; - let mut resource_table = resource_table.borrow_mut(); - let metadata = std_file_resource(&mut resource_table, rid, |r| match r { + let metadata = std_file_resource(&state, rid, |r| match r { Ok(std_file) => std_file.metadata().map_err(ErrBox::from), Err(_) => Err(ErrBox::type_error( "cannot stat this type of resource".to_string(), @@ -491,7 +386,6 @@ struct UmaskArgs { fn op_umask( state: &State, - _resource_table: &mut ResourceTable, args: Value, _zero_copy: &mut [ZeroCopyBuf], ) -> Result<Value, ErrBox> { @@ -530,7 +424,6 @@ struct ChdirArgs { fn op_chdir( state: &State, - _resource_table: &mut ResourceTable, args: Value, _zero_copy: &mut [ZeroCopyBuf], ) -> Result<Value, ErrBox> { @@ -551,7 +444,6 @@ struct MkdirArgs { fn op_mkdir_sync( state: &State, - _resource_table: &mut ResourceTable, args: Value, _zero_copy: &mut [ZeroCopyBuf], ) -> Result<Value, ErrBox> { @@ -573,7 +465,6 @@ fn op_mkdir_sync( async fn op_mkdir_async( state: Rc<State>, - _resource_table: Rc<RefCell<ResourceTable>>, args: Value, _zero_copy: BufVec, ) -> Result<Value, ErrBox> { @@ -606,7 +497,6 @@ struct ChmodArgs { fn op_chmod_sync( state: &State, - _resource_table: &mut ResourceTable, args: Value, _zero_copy: &mut [ZeroCopyBuf], ) -> Result<Value, ErrBox> { @@ -634,7 +524,6 @@ fn op_chmod_sync( async fn op_chmod_async( state: Rc<State>, - _resource_table: Rc<RefCell<ResourceTable>>, args: Value, _zero_copy: BufVec, ) -> Result<Value, ErrBox> { @@ -673,7 +562,6 @@ struct ChownArgs { fn op_chown_sync( state: &State, - _resource_table: &mut ResourceTable, args: Value, _zero_copy: &mut [ZeroCopyBuf], ) -> Result<Value, ErrBox> { @@ -703,7 +591,6 @@ fn op_chown_sync( async fn op_chown_async( state: Rc<State>, - _resource_table: Rc<RefCell<ResourceTable>>, args: Value, _zero_copy: BufVec, ) -> Result<Value, ErrBox> { @@ -742,7 +629,6 @@ struct RemoveArgs { fn op_remove_sync( state: &State, - _resource_table: &mut ResourceTable, args: Value, _zero_copy: &mut [ZeroCopyBuf], ) -> Result<Value, ErrBox> { @@ -786,7 +672,6 @@ fn op_remove_sync( async fn op_remove_async( state: Rc<State>, - _resource_table: Rc<RefCell<ResourceTable>>, args: Value, _zero_copy: BufVec, ) -> Result<Value, ErrBox> { @@ -841,7 +726,6 @@ struct CopyFileArgs { fn op_copy_file_sync( state: &State, - _resource_table: &mut ResourceTable, args: Value, _zero_copy: &mut [ZeroCopyBuf], ) -> Result<Value, ErrBox> { @@ -867,7 +751,6 @@ fn op_copy_file_sync( async fn op_copy_file_async( state: Rc<State>, - _resource_table: Rc<RefCell<ResourceTable>>, args: Value, _zero_copy: BufVec, ) -> Result<Value, ErrBox> { @@ -895,7 +778,7 @@ async fn op_copy_file_async( .unwrap() } -fn to_msec(maybe_time: Result<SystemTime, io::Error>) -> serde_json::Value { +fn to_msec(maybe_time: Result<SystemTime, io::Error>) -> Value { match maybe_time { Ok(time) => { let msec = time @@ -903,18 +786,18 @@ fn to_msec(maybe_time: Result<SystemTime, io::Error>) -> serde_json::Value { .map(|t| t.as_secs_f64() * 1000f64) .unwrap_or_else(|err| err.duration().as_secs_f64() * -1000f64); serde_json::Number::from_f64(msec) - .map(serde_json::Value::Number) - .unwrap_or(serde_json::Value::Null) + .map(Value::Number) + .unwrap_or(Value::Null) } - Err(_) => serde_json::Value::Null, + Err(_) => Value::Null, } } #[inline(always)] -fn get_stat_json(metadata: std::fs::Metadata) -> JsonResult { +fn get_stat_json(metadata: std::fs::Metadata) -> Result<Value, ErrBox> { // Unix stat member (number types only). 0 if not on unix. macro_rules! usm { - ($member: ident) => {{ + ($member:ident) => {{ #[cfg(unix)] { metadata.$member() @@ -962,7 +845,6 @@ struct StatArgs { fn op_stat_sync( state: &State, - _resource_table: &mut ResourceTable, args: Value, _zero_copy: &mut [ZeroCopyBuf], ) -> Result<Value, ErrBox> { @@ -981,7 +863,6 @@ fn op_stat_sync( async fn op_stat_async( state: Rc<State>, - _resource_table: Rc<RefCell<ResourceTable>>, args: Value, _zero_copy: BufVec, ) -> Result<Value, ErrBox> { @@ -1012,7 +893,6 @@ struct RealpathArgs { fn op_realpath_sync( state: &State, - _resource_table: &mut ResourceTable, args: Value, _zero_copy: &mut [ZeroCopyBuf], ) -> Result<Value, ErrBox> { @@ -1038,7 +918,6 @@ fn op_realpath_sync( async fn op_realpath_async( state: Rc<State>, - _resource_table: Rc<RefCell<ResourceTable>>, args: Value, _zero_copy: BufVec, ) -> Result<Value, ErrBox> { @@ -1074,7 +953,6 @@ struct ReadDirArgs { fn op_read_dir_sync( state: &State, - _resource_table: &mut ResourceTable, args: Value, _zero_copy: &mut [ZeroCopyBuf], ) -> Result<Value, ErrBox> { @@ -1107,7 +985,6 @@ fn op_read_dir_sync( async fn op_read_dir_async( state: Rc<State>, - _resource_table: Rc<RefCell<ResourceTable>>, args: Value, _zero_copy: BufVec, ) -> Result<Value, ErrBox> { @@ -1151,7 +1028,6 @@ struct RenameArgs { fn op_rename_sync( state: &State, - _resource_table: &mut ResourceTable, args: Value, _zero_copy: &mut [ZeroCopyBuf], ) -> Result<Value, ErrBox> { @@ -1169,7 +1045,6 @@ fn op_rename_sync( async fn op_rename_async( state: Rc<State>, - _resource_table: Rc<RefCell<ResourceTable>>, args: Value, _zero_copy: BufVec, ) -> Result<Value, ErrBox> { @@ -1203,7 +1078,6 @@ struct LinkArgs { fn op_link_sync( state: &State, - _resource_table: &mut ResourceTable, args: Value, _zero_copy: &mut [ZeroCopyBuf], ) -> Result<Value, ErrBox> { @@ -1222,7 +1096,6 @@ fn op_link_sync( async fn op_link_async( state: Rc<State>, - _resource_table: Rc<RefCell<ResourceTable>>, args: Value, _zero_copy: BufVec, ) -> Result<Value, ErrBox> { @@ -1261,7 +1134,6 @@ struct SymlinkOptions { fn op_symlink_sync( state: &State, - _resource_table: &mut ResourceTable, args: Value, _zero_copy: &mut [ZeroCopyBuf], ) -> Result<Value, ErrBox> { @@ -1303,10 +1175,7 @@ fn op_symlink_sync( symlink_dir(&oldpath, &newpath)? } } - Err(_) => return Err(ErrBox::type_error( - "you must pass a `options` argument for non-existent target path in windows" - .to_string(), - )), + Err(_) => return Err(ErrBox::type_error("you must pass a `options` argument for non-existent target path in windows".to_string())), } } }; @@ -1316,7 +1185,6 @@ fn op_symlink_sync( async fn op_symlink_async( state: Rc<State>, - _resource_table: Rc<RefCell<ResourceTable>>, args: Value, _zero_copy: BufVec, ) -> Result<Value, ErrBox> { @@ -1355,10 +1223,7 @@ async fn op_symlink_async( symlink_dir(&oldpath, &newpath)? } } - Err(_) => return Err(ErrBox::type_error( - "you must pass a `options` argument for non-existent target path in windows" - .to_string(), - )), + Err(_) => return Err(ErrBox::type_error("you must pass a `options` argument for non-existent target path in windows".to_string())), } } }; @@ -1377,7 +1242,6 @@ struct ReadLinkArgs { fn op_read_link_sync( state: &State, - _resource_table: &mut ResourceTable, args: Value, _zero_copy: &mut [ZeroCopyBuf], ) -> Result<Value, ErrBox> { @@ -1394,7 +1258,6 @@ fn op_read_link_sync( async fn op_read_link_async( state: Rc<State>, - _resource_table: Rc<RefCell<ResourceTable>>, args: Value, _zero_copy: BufVec, ) -> Result<Value, ErrBox> { @@ -1422,7 +1285,6 @@ struct FtruncateArgs { fn op_ftruncate_sync( state: &State, - resource_table: &mut ResourceTable, args: Value, _zero_copy: &mut [ZeroCopyBuf], ) -> Result<Value, ErrBox> { @@ -1430,7 +1292,7 @@ fn op_ftruncate_sync( let args: FtruncateArgs = serde_json::from_value(args)?; let rid = args.rid as u32; let len = args.len as u64; - std_file_resource(resource_table, rid, |r| match r { + std_file_resource(state, rid, |r| match r { Ok(std_file) => std_file.set_len(len).map_err(ErrBox::from), Err(_) => Err(ErrBox::type_error("cannot truncate this type of resource")), })?; @@ -1439,7 +1301,6 @@ fn op_ftruncate_sync( async fn op_ftruncate_async( state: Rc<State>, - resource_table: Rc<RefCell<ResourceTable>>, args: Value, _zero_copy: BufVec, ) -> Result<Value, ErrBox> { @@ -1447,8 +1308,7 @@ async fn op_ftruncate_async( let args: FtruncateArgs = serde_json::from_value(args)?; let rid = args.rid as u32; let len = args.len as u64; - let mut resource_table = resource_table.borrow_mut(); - std_file_resource(&mut resource_table, rid, |r| match r { + std_file_resource(&state, rid, |r| match r { Ok(std_file) => std_file.set_len(len).map_err(ErrBox::from), Err(_) => Err(ErrBox::type_error("cannot truncate this type of resource")), })?; @@ -1464,7 +1324,6 @@ struct TruncateArgs { fn op_truncate_sync( state: &State, - _resource_table: &mut ResourceTable, args: Value, _zero_copy: &mut [ZeroCopyBuf], ) -> Result<Value, ErrBox> { @@ -1482,7 +1341,6 @@ fn op_truncate_sync( async fn op_truncate_async( state: Rc<State>, - _resource_table: Rc<RefCell<ResourceTable>>, args: Value, _zero_copy: BufVec, ) -> Result<Value, ErrBox> { @@ -1557,7 +1415,6 @@ struct MakeTempArgs { fn op_make_temp_dir_sync( state: &State, - _resource_table: &mut ResourceTable, args: Value, _zero_copy: &mut [ZeroCopyBuf], ) -> Result<Value, ErrBox> { @@ -1586,7 +1443,6 @@ fn op_make_temp_dir_sync( async fn op_make_temp_dir_async( state: Rc<State>, - _resource_table: Rc<RefCell<ResourceTable>>, args: Value, _zero_copy: BufVec, ) -> Result<Value, ErrBox> { @@ -1619,7 +1475,6 @@ async fn op_make_temp_dir_async( fn op_make_temp_file_sync( state: &State, - _resource_table: &mut ResourceTable, args: Value, _zero_copy: &mut [ZeroCopyBuf], ) -> Result<Value, ErrBox> { @@ -1648,7 +1503,6 @@ fn op_make_temp_file_sync( async fn op_make_temp_file_async( state: Rc<State>, - _resource_table: Rc<RefCell<ResourceTable>>, args: Value, _zero_copy: BufVec, ) -> Result<Value, ErrBox> { @@ -1689,7 +1543,6 @@ struct FutimeArgs { fn op_futime_sync( state: &State, - resource_table: &mut ResourceTable, args: Value, _zero_copy: &mut [ZeroCopyBuf], ) -> Result<Value, ErrBox> { @@ -1699,7 +1552,7 @@ fn op_futime_sync( let atime = filetime::FileTime::from_unix_time(args.atime.0, args.atime.1); let mtime = filetime::FileTime::from_unix_time(args.mtime.0, args.mtime.1); - std_file_resource(resource_table, rid, |r| match r { + std_file_resource(state, rid, |r| match r { Ok(std_file) => { filetime::set_file_handle_times(std_file, Some(atime), Some(mtime)) .map_err(ErrBox::from) @@ -1714,7 +1567,6 @@ fn op_futime_sync( async fn op_futime_async( state: Rc<State>, - resource_table: Rc<RefCell<ResourceTable>>, args: Value, _zero_copy: BufVec, ) -> Result<Value, ErrBox> { @@ -1724,8 +1576,7 @@ async fn op_futime_async( let atime = filetime::FileTime::from_unix_time(args.atime.0, args.atime.1); let mtime = filetime::FileTime::from_unix_time(args.mtime.0, args.mtime.1); - let mut resource_table = resource_table.borrow_mut(); - std_file_resource(&mut resource_table, rid, |r| match r { + std_file_resource(&state, rid, |r| match r { Ok(std_file) => { filetime::set_file_handle_times(std_file, Some(atime), Some(mtime)) .map_err(ErrBox::from) @@ -1748,7 +1599,6 @@ struct UtimeArgs { fn op_utime_sync( state: &State, - _resource_table: &mut ResourceTable, args: Value, _zero_copy: &mut [ZeroCopyBuf], ) -> Result<Value, ErrBox> { @@ -1766,7 +1616,6 @@ fn op_utime_sync( async fn op_utime_async( state: Rc<State>, - _resource_table: Rc<RefCell<ResourceTable>>, args: Value, _zero_copy: BufVec, ) -> Result<Value, ErrBox> { @@ -1789,7 +1638,6 @@ async fn op_utime_async( fn op_cwd( state: &State, - _resource_table: &mut ResourceTable, _args: Value, _zero_copy: &mut [ZeroCopyBuf], ) -> Result<Value, ErrBox> { diff --git a/cli/ops/fs_events.rs b/cli/ops/fs_events.rs index e1c98b8de..142aa3ccf 100644 --- a/cli/ops/fs_events.rs +++ b/cli/ops/fs_events.rs @@ -1,10 +1,9 @@ // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license. -use super::dispatch_json::{Deserialize, Value}; + use crate::state::State; use deno_core::BufVec; -use deno_core::CoreIsolate; use deno_core::ErrBox; -use deno_core::ResourceTable; +use deno_core::OpRegistry; use deno_core::ZeroCopyBuf; use futures::future::poll_fn; use notify::event::Event as NotifyEvent; @@ -14,23 +13,16 @@ use notify::RecommendedWatcher; use notify::RecursiveMode; use notify::Watcher; use serde::Serialize; -use std::cell::RefCell; +use serde_derive::Deserialize; +use serde_json::Value; use std::convert::From; use std::path::PathBuf; use std::rc::Rc; use tokio::sync::mpsc; -pub fn init(i: &mut CoreIsolate, s: &Rc<State>) { - let t = &CoreIsolate::state(i).borrow().resource_table.clone(); - - i.register_op( - "op_fs_events_open", - s.stateful_json_op_sync(t, op_fs_events_open), - ); - i.register_op( - "op_fs_events_poll", - s.stateful_json_op_async(t, op_fs_events_poll), - ); +pub fn init(s: &Rc<State>) { + s.register_op_json_sync("op_fs_events_open", op_fs_events_open); + s.register_op_json_async("op_fs_events_poll", op_fs_events_poll); } struct FsEventsResource { @@ -73,7 +65,6 @@ impl From<NotifyEvent> for FsEvent { fn op_fs_events_open( state: &State, - resource_table: &mut ResourceTable, args: Value, _zero_copy: &mut [ZeroCopyBuf], ) -> Result<Value, ErrBox> { @@ -103,13 +94,15 @@ fn op_fs_events_open( watcher.watch(path, recursive_mode)?; } let resource = FsEventsResource { watcher, receiver }; - let rid = resource_table.add("fsEvents", Box::new(resource)); + let rid = state + .resource_table + .borrow_mut() + .add("fsEvents", Box::new(resource)); Ok(json!(rid)) } async fn op_fs_events_poll( - _state: Rc<State>, - resource_table: Rc<RefCell<ResourceTable>>, + state: Rc<State>, args: Value, _zero_copy: BufVec, ) -> Result<Value, ErrBox> { @@ -119,7 +112,7 @@ async fn op_fs_events_poll( } let PollArgs { rid } = serde_json::from_value(args)?; poll_fn(move |cx| { - let mut resource_table = resource_table.borrow_mut(); + let mut resource_table = state.resource_table.borrow_mut(); let watcher = resource_table .get_mut::<FsEventsResource>(rid) .ok_or_else(ErrBox::bad_resource_id)?; diff --git a/cli/ops/idna.rs b/cli/ops/idna.rs index 392eceb24..8e83a03ba 100644 --- a/cli/ops/idna.rs +++ b/cli/ops/idna.rs @@ -2,21 +2,18 @@ //! https://url.spec.whatwg.org/#idna -use super::dispatch_json::{Deserialize, Value}; use crate::state::State; -use deno_core::CoreIsolate; use deno_core::ErrBox; -use deno_core::ResourceTable; +use deno_core::OpRegistry; use deno_core::ZeroCopyBuf; -use idna::{domain_to_ascii, domain_to_ascii_strict}; +use idna::domain_to_ascii; +use idna::domain_to_ascii_strict; +use serde_derive::Deserialize; +use serde_json::Value; use std::rc::Rc; -pub fn init(i: &mut CoreIsolate, s: &Rc<State>) { - let t = &CoreIsolate::state(i).borrow().resource_table.clone(); - i.register_op( - "op_domain_to_ascii", - s.stateful_json_op_sync(t, op_domain_to_ascii), - ); +pub fn init(s: &Rc<State>) { + s.register_op_json_sync("op_domain_to_ascii", op_domain_to_ascii); } #[derive(Deserialize)] @@ -28,7 +25,6 @@ struct DomainToAscii { fn op_domain_to_ascii( _state: &State, - _resource_table: &mut ResourceTable, args: Value, _zero_copy: &mut [ZeroCopyBuf], ) -> Result<Value, ErrBox> { diff --git a/cli/ops/io.rs b/cli/ops/io.rs index 14d32a39b..4a8f6d96d 100644 --- a/cli/ops/io.rs +++ b/cli/ops/io.rs @@ -1,11 +1,8 @@ use super::dispatch_minimal::MinimalOp; use crate::http_util::HttpBody; use crate::state::State; -use deno_core::CoreIsolate; -use deno_core::CoreIsolateState; +use deno_core::BufVec; use deno_core::ErrBox; -use deno_core::ResourceTable; -use deno_core::ZeroCopyBuf; use futures::future::poll_fn; use futures::future::FutureExt; use futures::ready; @@ -85,9 +82,9 @@ lazy_static! { }; } -pub fn init(i: &mut CoreIsolate, s: &Rc<State>) { - i.register_op("op_read", s.stateful_minimal_op2(op_read)); - i.register_op("op_write", s.stateful_minimal_op2(op_write)); +pub fn init(s: &Rc<State>) { + s.register_op_minimal("op_read", op_read); + s.register_op_minimal("op_write", op_write); } pub fn get_stdio() -> ( @@ -236,11 +233,10 @@ impl DenoAsyncRead for StreamResource { } pub fn op_read( - isolate_state: &mut CoreIsolateState, - _state: &Rc<State>, + state: Rc<State>, is_sync: bool, rid: i32, - zero_copy: &mut [ZeroCopyBuf], + mut zero_copy: BufVec, ) -> MinimalOp { debug!("read rid={}", rid); match zero_copy.len() { @@ -248,13 +244,11 @@ pub fn op_read( 1 => {} _ => panic!("Invalid number of arguments"), } - let resource_table = isolate_state.resource_table.clone(); if is_sync { MinimalOp::Sync({ // First we look up the rid in the resource table. - let mut resource_table = resource_table.borrow_mut(); - std_file_resource(&mut resource_table, rid as u32, move |r| match r { + std_file_resource(&state, rid as u32, move |r| match r { Ok(std_file) => { use std::io::Read; std_file @@ -271,7 +265,7 @@ pub fn op_read( let mut zero_copy = zero_copy[0].clone(); MinimalOp::Async( poll_fn(move |cx| { - let mut resource_table = resource_table.borrow_mut(); + let mut resource_table = state.resource_table.borrow_mut(); let resource_holder = resource_table .get_mut::<StreamResourceHolder>(rid as u32) .ok_or_else(ErrBox::bad_resource_id)?; @@ -358,11 +352,10 @@ impl DenoAsyncWrite for StreamResource { } pub fn op_write( - isolate_state: &mut CoreIsolateState, - _state: &Rc<State>, + state: Rc<State>, is_sync: bool, rid: i32, - zero_copy: &mut [ZeroCopyBuf], + zero_copy: BufVec, ) -> MinimalOp { debug!("write rid={}", rid); match zero_copy.len() { @@ -374,8 +367,7 @@ pub fn op_write( if is_sync { MinimalOp::Sync({ // First we look up the rid in the resource table. - let mut resource_table = isolate_state.resource_table.borrow_mut(); - std_file_resource(&mut resource_table, rid as u32, move |r| match r { + std_file_resource(&state, rid as u32, move |r| match r { Ok(std_file) => { use std::io::Write; std_file @@ -390,11 +382,10 @@ pub fn op_write( }) } else { let zero_copy = zero_copy[0].clone(); - let resource_table = isolate_state.resource_table.clone(); MinimalOp::Async( async move { let nwritten = poll_fn(|cx| { - let mut resource_table = resource_table.borrow_mut(); + let mut resource_table = state.resource_table.borrow_mut(); let resource_holder = resource_table .get_mut::<StreamResourceHolder>(rid as u32) .ok_or_else(ErrBox::bad_resource_id)?; @@ -407,7 +398,7 @@ pub fn op_write( // Figure out why it's needed and preferably remove it. // https://github.com/denoland/deno/issues/3565 poll_fn(|cx| { - let mut resource_table = resource_table.borrow_mut(); + let mut resource_table = state.resource_table.borrow_mut(); let resource_holder = resource_table .get_mut::<StreamResourceHolder>(rid as u32) .ok_or_else(ErrBox::bad_resource_id)?; @@ -430,7 +421,7 @@ pub fn op_write( /// /// Returns ErrorKind::Busy if the resource is being used by another op. pub fn std_file_resource<F, T>( - resource_table: &mut ResourceTable, + state: &State, rid: u32, mut f: F, ) -> Result<T, ErrBox> @@ -439,6 +430,7 @@ where FnMut(Result<&mut std::fs::File, &mut StreamResource>) -> Result<T, ErrBox>, { // First we look up the rid in the resource table. + let mut resource_table = state.resource_table.borrow_mut(); let mut r = resource_table.get_mut::<StreamResourceHolder>(rid); if let Some(ref mut resource_holder) = r { // Sync write only works for FsFile. It doesn't make sense to do this diff --git a/cli/ops/mod.rs b/cli/ops/mod.rs index bc6b4f377..06a55bade 100644 --- a/cli/ops/mod.rs +++ b/cli/ops/mod.rs @@ -1,12 +1,6 @@ // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license. -mod dispatch_json; -mod dispatch_minimal; -pub use dispatch_json::json_op; -pub use dispatch_json::serialize_result; -pub use dispatch_json::JsonOp; -pub use dispatch_json::JsonResult; -pub use dispatch_minimal::minimal_op; +mod dispatch_minimal; pub use dispatch_minimal::MinimalOp; pub mod compiler; diff --git a/cli/ops/net.rs b/cli/ops/net.rs index 9cb6eb79d..91a9079d4 100644 --- a/cli/ops/net.rs +++ b/cli/ops/net.rs @@ -1,15 +1,15 @@ // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license. -use super::dispatch_json::{Deserialize, Value}; -use super::io::{StreamResource, StreamResourceHolder}; + +use crate::ops::io::{StreamResource, StreamResourceHolder}; use crate::resolve_addr::resolve_addr; use crate::state::State; use deno_core::BufVec; -use deno_core::CoreIsolate; use deno_core::ErrBox; -use deno_core::ResourceTable; +use deno_core::OpRegistry; use deno_core::ZeroCopyBuf; use futures::future::poll_fn; -use std::cell::RefCell; +use serde_derive::Deserialize; +use serde_json::Value; use std::net::Shutdown; use std::net::SocketAddr; use std::rc::Rc; @@ -22,38 +22,30 @@ use tokio::net::UdpSocket; #[cfg(unix)] use super::net_unix; -pub fn init(i: &mut CoreIsolate, s: &Rc<State>) { - let t = &CoreIsolate::state(i).borrow().resource_table.clone(); - - i.register_op("op_accept", s.stateful_json_op_async(t, op_accept)); - i.register_op("op_connect", s.stateful_json_op_async(t, op_connect)); - i.register_op("op_shutdown", s.stateful_json_op_sync(t, op_shutdown)); - i.register_op("op_listen", s.stateful_json_op_sync(t, op_listen)); - i.register_op( - "op_datagram_receive", - s.stateful_json_op_async(t, op_datagram_receive), - ); - i.register_op( - "op_datagram_send", - s.stateful_json_op_async(t, op_datagram_send), - ); +pub fn init(s: &Rc<State>) { + s.register_op_json_async("op_accept", op_accept); + s.register_op_json_async("op_connect", op_connect); + s.register_op_json_sync("op_shutdown", op_shutdown); + s.register_op_json_sync("op_listen", op_listen); + s.register_op_json_async("op_datagram_receive", op_datagram_receive); + s.register_op_json_async("op_datagram_send", op_datagram_send); } #[derive(Deserialize)] -struct AcceptArgs { - rid: i32, - transport: String, +pub(crate) struct AcceptArgs { + pub rid: i32, + pub transport: String, } async fn accept_tcp( - resource_table: Rc<RefCell<ResourceTable>>, + state: Rc<State>, args: AcceptArgs, _zero_copy: BufVec, ) -> Result<Value, ErrBox> { let rid = args.rid as u32; let accept_fut = poll_fn(|cx| { - let mut resource_table = resource_table.borrow_mut(); + let mut resource_table = state.resource_table.borrow_mut(); let listener_resource = resource_table .get_mut::<TcpListenerResource>(rid) .ok_or_else(|| ErrBox::bad_resource("Listener has been closed"))?; @@ -76,8 +68,7 @@ async fn accept_tcp( let (tcp_stream, _socket_addr) = accept_fut.await?; let local_addr = tcp_stream.local_addr()?; let remote_addr = tcp_stream.peer_addr()?; - let mut resource_table = resource_table.borrow_mut(); - let rid = resource_table.add( + let rid = state.resource_table.borrow_mut().add( "tcpStream", Box::new(StreamResourceHolder::new(StreamResource::TcpStream(Some( tcp_stream, @@ -99,18 +90,15 @@ async fn accept_tcp( } async fn op_accept( - _state: Rc<State>, - resource_table: Rc<RefCell<ResourceTable>>, + state: Rc<State>, args: Value, - zero_copy: BufVec, + bufs: BufVec, ) -> Result<Value, ErrBox> { let args: AcceptArgs = serde_json::from_value(args)?; match args.transport.as_str() { - "tcp" => accept_tcp(resource_table, args, zero_copy).await, + "tcp" => accept_tcp(state, args, bufs).await, #[cfg(unix)] - "unix" => { - net_unix::accept_unix(resource_table, args.rid as u32, zero_copy).await - } + "unix" => net_unix::accept_unix(state, args, bufs).await, _ => Err(ErrBox::error(format!( "Unsupported transport protocol {}", args.transport @@ -119,14 +107,13 @@ async fn op_accept( } #[derive(Deserialize)] -struct ReceiveArgs { - rid: i32, - transport: String, +pub(crate) struct ReceiveArgs { + pub rid: i32, + pub transport: String, } async fn receive_udp( - resource_table: Rc<RefCell<ResourceTable>>, - _state: &Rc<State>, + state: Rc<State>, args: ReceiveArgs, zero_copy: BufVec, ) -> Result<Value, ErrBox> { @@ -136,7 +123,7 @@ async fn receive_udp( let rid = args.rid as u32; let receive_fut = poll_fn(|cx| { - let mut resource_table = resource_table.borrow_mut(); + let mut resource_table = state.resource_table.borrow_mut(); let resource = resource_table .get_mut::<UdpSocketResource>(rid) .ok_or_else(|| ErrBox::bad_resource("Socket has been closed"))?; @@ -158,7 +145,6 @@ async fn receive_udp( async fn op_datagram_receive( state: Rc<State>, - resource_table: Rc<RefCell<ResourceTable>>, args: Value, zero_copy: BufVec, ) -> Result<Value, ErrBox> { @@ -166,12 +152,9 @@ async fn op_datagram_receive( let args: ReceiveArgs = serde_json::from_value(args)?; match args.transport.as_str() { - "udp" => receive_udp(resource_table, &state, args, zero_copy).await, + "udp" => receive_udp(state, args, zero_copy).await, #[cfg(unix)] - "unixpacket" => { - net_unix::receive_unix_packet(resource_table, args.rid as u32, zero_copy) - .await - } + "unixpacket" => net_unix::receive_unix_packet(state, args, zero_copy).await, _ => Err(ErrBox::error(format!( "Unsupported transport protocol {}", args.transport @@ -189,7 +172,6 @@ struct SendArgs { async fn op_datagram_send( state: Rc<State>, - resource_table: Rc<RefCell<ResourceTable>>, args: Value, zero_copy: BufVec, ) -> Result<Value, ErrBox> { @@ -205,7 +187,7 @@ async fn op_datagram_send( state.check_net(&args.hostname, args.port)?; let addr = resolve_addr(&args.hostname, args.port)?; poll_fn(move |cx| { - let mut resource_table = resource_table.borrow_mut(); + let mut resource_table = state.resource_table.borrow_mut(); let resource = resource_table .get_mut::<UdpSocketResource>(rid as u32) .ok_or_else(|| ErrBox::bad_resource("Socket has been closed"))?; @@ -225,7 +207,7 @@ async fn op_datagram_send( } if transport == "unixpacket" => { let address_path = net_unix::Path::new(&args.path); state.check_read(&address_path)?; - let mut resource_table = resource_table.borrow_mut(); + let mut resource_table = state.resource_table.borrow_mut(); let resource = resource_table .get_mut::<net_unix::UnixDatagramResource>(rid as u32) .ok_or_else(|| ErrBox::new("NotConnected", "Socket has been closed"))?; @@ -249,7 +231,6 @@ struct ConnectArgs { async fn op_connect( state: Rc<State>, - resource_table: Rc<RefCell<ResourceTable>>, args: Value, _zero_copy: BufVec, ) -> Result<Value, ErrBox> { @@ -263,8 +244,7 @@ async fn op_connect( let tcp_stream = TcpStream::connect(&addr).await?; let local_addr = tcp_stream.local_addr()?; let remote_addr = tcp_stream.peer_addr()?; - let mut resource_table = resource_table.borrow_mut(); - let rid = resource_table.add( + let rid = state.resource_table.borrow_mut().add( "tcpStream", Box::new(StreamResourceHolder::new(StreamResource::TcpStream(Some( tcp_stream, @@ -297,8 +277,7 @@ async fn op_connect( net_unix::UnixStream::connect(net_unix::Path::new(&path)).await?; let local_addr = unix_stream.local_addr()?; let remote_addr = unix_stream.peer_addr()?; - let mut resource_table = resource_table.borrow_mut(); - let rid = resource_table.add( + let rid = state.resource_table.borrow_mut().add( "unixStream", Box::new(StreamResourceHolder::new(StreamResource::UnixStream( unix_stream, @@ -328,7 +307,6 @@ struct ShutdownArgs { fn op_shutdown( state: &State, - resource_table: &mut ResourceTable, args: Value, _zero_copy: &mut [ZeroCopyBuf], ) -> Result<Value, ErrBox> { @@ -345,6 +323,7 @@ fn op_shutdown( _ => unimplemented!(), }; + let mut resource_table = state.resource_table.borrow_mut(); let resource_holder = resource_table .get_mut::<StreamResourceHolder>(rid) .ok_or_else(ErrBox::bad_resource_id)?; @@ -437,7 +416,7 @@ struct ListenArgs { } fn listen_tcp( - resource_table: &mut ResourceTable, + state: &State, addr: SocketAddr, ) -> Result<(u32, SocketAddr), ErrBox> { let std_listener = std::net::TcpListener::bind(&addr)?; @@ -448,27 +427,32 @@ fn listen_tcp( waker: None, local_addr, }; - let rid = resource_table.add("tcpListener", Box::new(listener_resource)); + let rid = state + .resource_table + .borrow_mut() + .add("tcpListener", Box::new(listener_resource)); Ok((rid, local_addr)) } fn listen_udp( - resource_table: &mut ResourceTable, + state: &State, addr: SocketAddr, ) -> Result<(u32, SocketAddr), ErrBox> { let std_socket = std::net::UdpSocket::bind(&addr)?; let socket = UdpSocket::from_std(std_socket)?; let local_addr = socket.local_addr()?; let socket_resource = UdpSocketResource { socket }; - let rid = resource_table.add("udpSocket", Box::new(socket_resource)); + let rid = state + .resource_table + .borrow_mut() + .add("udpSocket", Box::new(socket_resource)); Ok((rid, local_addr)) } fn op_listen( state: &State, - resource_table: &mut ResourceTable, args: Value, _zero_copy: &mut [ZeroCopyBuf], ) -> Result<Value, ErrBox> { @@ -483,9 +467,9 @@ fn op_listen( state.check_net(&args.hostname, args.port)?; let addr = resolve_addr(&args.hostname, args.port)?; let (rid, local_addr) = if transport == "tcp" { - listen_tcp(resource_table, addr)? + listen_tcp(state, addr)? } else { - listen_udp(resource_table, addr)? + listen_udp(state, addr)? }; debug!( "New listener {} {}:{}", @@ -517,9 +501,9 @@ fn op_listen( state.check_read(&address_path)?; state.check_write(&address_path)?; let (rid, local_addr) = if transport == "unix" { - net_unix::listen_unix(resource_table, &address_path)? + net_unix::listen_unix(state, &address_path)? } else { - net_unix::listen_unix_packet(resource_table, &address_path)? + net_unix::listen_unix_packet(state, &address_path)? }; debug!( "New listener {} {}", diff --git a/cli/ops/net_unix.rs b/cli/ops/net_unix.rs index 29851b093..a73db89b2 100644 --- a/cli/ops/net_unix.rs +++ b/cli/ops/net_unix.rs @@ -1,9 +1,12 @@ -use super::dispatch_json::{Deserialize, Value}; -use super::io::{StreamResource, StreamResourceHolder}; +use crate::ops::io::StreamResource; +use crate::ops::io::StreamResourceHolder; +use crate::ops::net::AcceptArgs; +use crate::ops::net::ReceiveArgs; +use crate::state::State; use deno_core::BufVec; use deno_core::ErrBox; -use deno_core::ResourceTable; -use std::cell::RefCell; +use serde_derive::Deserialize; +use serde_json::Value; use std::fs::remove_file; use std::os::unix; pub use std::path::Path; @@ -26,24 +29,25 @@ pub struct UnixListenArgs { pub path: String, } -pub async fn accept_unix( - resource_table: Rc<RefCell<ResourceTable>>, - rid: u32, - _zero_copy: BufVec, +pub(crate) async fn accept_unix( + state: Rc<State>, + args: AcceptArgs, + _bufs: BufVec, ) -> Result<Value, ErrBox> { - let mut resource_table_ = resource_table.borrow_mut(); + let rid = args.rid as u32; + + let mut resource_table_ = state.resource_table.borrow_mut(); let listener_resource = { resource_table_ .get_mut::<UnixListenerResource>(rid) .ok_or_else(|| ErrBox::bad_resource("Listener has been closed"))? }; - let (unix_stream, _socket_addr) = listener_resource.listener.accept().await?; drop(resource_table_); let local_addr = unix_stream.local_addr()?; let remote_addr = unix_stream.peer_addr()?; - let mut resource_table_ = resource_table.borrow_mut(); + let mut resource_table_ = state.resource_table.borrow_mut(); let rid = resource_table_.add( "unixStream", Box::new(StreamResourceHolder::new(StreamResource::UnixStream( @@ -63,19 +67,21 @@ pub async fn accept_unix( })) } -pub async fn receive_unix_packet( - resource_table: Rc<RefCell<ResourceTable>>, - rid: u32, - zero_copy: BufVec, +pub(crate) async fn receive_unix_packet( + state: Rc<State>, + args: ReceiveArgs, + bufs: BufVec, ) -> Result<Value, ErrBox> { - assert_eq!(zero_copy.len(), 1, "Invalid number of arguments"); - let mut zero_copy = zero_copy[0].clone(); + assert_eq!(bufs.len(), 1, "Invalid number of arguments"); + + let rid = args.rid as u32; + let mut buf = bufs.into_iter().next().unwrap(); - let mut resource_table_ = resource_table.borrow_mut(); + let mut resource_table_ = state.resource_table.borrow_mut(); let resource = resource_table_ .get_mut::<UnixDatagramResource>(rid) .ok_or_else(|| ErrBox::bad_resource("Socket has been closed"))?; - let (size, remote_addr) = resource.socket.recv_from(&mut zero_copy).await?; + let (size, remote_addr) = resource.socket.recv_from(&mut buf).await?; Ok(json!({ "size": size, "remoteAddr": { @@ -86,7 +92,7 @@ pub async fn receive_unix_packet( } pub fn listen_unix( - resource_table: &mut ResourceTable, + state: &State, addr: &Path, ) -> Result<(u32, unix::net::SocketAddr), ErrBox> { if addr.exists() { @@ -95,13 +101,16 @@ pub fn listen_unix( let listener = UnixListener::bind(&addr)?; let local_addr = listener.local_addr()?; let listener_resource = UnixListenerResource { listener }; - let rid = resource_table.add("unixListener", Box::new(listener_resource)); + let rid = state + .resource_table + .borrow_mut() + .add("unixListener", Box::new(listener_resource)); Ok((rid, local_addr)) } pub fn listen_unix_packet( - resource_table: &mut ResourceTable, + state: &State, addr: &Path, ) -> Result<(u32, unix::net::SocketAddr), ErrBox> { if addr.exists() { @@ -113,7 +122,10 @@ pub fn listen_unix_packet( socket, local_addr: local_addr.clone(), }; - let rid = resource_table.add("unixDatagram", Box::new(datagram_resource)); + let rid = state + .resource_table + .borrow_mut() + .add("unixDatagram", Box::new(datagram_resource)); Ok((rid, local_addr)) } diff --git a/cli/ops/os.rs b/cli/ops/os.rs index 7a2a7155e..4778d49a4 100644 --- a/cli/ops/os.rs +++ b/cli/ops/os.rs @@ -1,32 +1,30 @@ // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license. -use super::dispatch_json::{Deserialize, Value}; + use crate::state::State; -use deno_core::CoreIsolate; use deno_core::ErrBox; -use deno_core::ResourceTable; +use deno_core::OpRegistry; use deno_core::ZeroCopyBuf; +use serde_derive::Deserialize; +use serde_json::Value; use std::collections::HashMap; use std::env; use std::rc::Rc; use url::Url; -pub fn init(i: &mut CoreIsolate, s: &Rc<State>) { - let t = &CoreIsolate::state(i).borrow().resource_table.clone(); - - i.register_op("op_exit", s.stateful_json_op_sync(t, op_exit)); - i.register_op("op_env", s.stateful_json_op_sync(t, op_env)); - i.register_op("op_exec_path", s.stateful_json_op_sync(t, op_exec_path)); - i.register_op("op_set_env", s.stateful_json_op_sync(t, op_set_env)); - i.register_op("op_get_env", s.stateful_json_op_sync(t, op_get_env)); - i.register_op("op_delete_env", s.stateful_json_op_sync(t, op_delete_env)); - i.register_op("op_hostname", s.stateful_json_op_sync(t, op_hostname)); - i.register_op("op_loadavg", s.stateful_json_op_sync(t, op_loadavg)); - i.register_op("op_os_release", s.stateful_json_op_sync(t, op_os_release)); +pub fn init(s: &Rc<State>) { + s.register_op_json_sync("op_exit", op_exit); + s.register_op_json_sync("op_env", op_env); + s.register_op_json_sync("op_exec_path", op_exec_path); + s.register_op_json_sync("op_set_env", op_set_env); + s.register_op_json_sync("op_get_env", op_get_env); + s.register_op_json_sync("op_delete_env", op_delete_env); + s.register_op_json_sync("op_hostname", op_hostname); + s.register_op_json_sync("op_loadavg", op_loadavg); + s.register_op_json_sync("op_os_release", op_os_release); } fn op_exec_path( state: &State, - _resource_table: &mut ResourceTable, _args: Value, _zero_copy: &mut [ZeroCopyBuf], ) -> Result<Value, ErrBox> { @@ -47,7 +45,6 @@ struct SetEnv { fn op_set_env( state: &State, - _resource_table: &mut ResourceTable, args: Value, _zero_copy: &mut [ZeroCopyBuf], ) -> Result<Value, ErrBox> { @@ -59,7 +56,6 @@ fn op_set_env( fn op_env( state: &State, - _resource_table: &mut ResourceTable, _args: Value, _zero_copy: &mut [ZeroCopyBuf], ) -> Result<Value, ErrBox> { @@ -75,7 +71,6 @@ struct GetEnv { fn op_get_env( state: &State, - _resource_table: &mut ResourceTable, args: Value, _zero_copy: &mut [ZeroCopyBuf], ) -> Result<Value, ErrBox> { @@ -95,7 +90,6 @@ struct DeleteEnv { fn op_delete_env( state: &State, - _resource_table: &mut ResourceTable, args: Value, _zero_copy: &mut [ZeroCopyBuf], ) -> Result<Value, ErrBox> { @@ -112,7 +106,6 @@ struct Exit { fn op_exit( _state: &State, - _resource_table: &mut ResourceTable, args: Value, _zero_copy: &mut [ZeroCopyBuf], ) -> Result<Value, ErrBox> { @@ -122,7 +115,6 @@ fn op_exit( fn op_loadavg( state: &State, - _resource_table: &mut ResourceTable, _args: Value, _zero_copy: &mut [ZeroCopyBuf], ) -> Result<Value, ErrBox> { @@ -136,7 +128,6 @@ fn op_loadavg( fn op_hostname( state: &State, - _resource_table: &mut ResourceTable, _args: Value, _zero_copy: &mut [ZeroCopyBuf], ) -> Result<Value, ErrBox> { @@ -148,7 +139,6 @@ fn op_hostname( fn op_os_release( state: &State, - _resource_table: &mut ResourceTable, _args: Value, _zero_copy: &mut [ZeroCopyBuf], ) -> Result<Value, ErrBox> { diff --git a/cli/ops/permissions.rs b/cli/ops/permissions.rs index 1d19f91d4..90d21a726 100644 --- a/cli/ops/permissions.rs +++ b/cli/ops/permissions.rs @@ -1,28 +1,18 @@ // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license. -use super::dispatch_json::{Deserialize, Value}; + use crate::state::State; -use deno_core::CoreIsolate; use deno_core::ErrBox; -use deno_core::ResourceTable; +use deno_core::OpRegistry; use deno_core::ZeroCopyBuf; +use serde_derive::Deserialize; +use serde_json::Value; use std::path::Path; use std::rc::Rc; -pub fn init(i: &mut CoreIsolate, s: &Rc<State>) { - let t = &CoreIsolate::state(i).borrow().resource_table.clone(); - - i.register_op( - "op_query_permission", - s.stateful_json_op_sync(t, op_query_permission), - ); - i.register_op( - "op_revoke_permission", - s.stateful_json_op_sync(t, op_revoke_permission), - ); - i.register_op( - "op_request_permission", - s.stateful_json_op_sync(t, op_request_permission), - ); +pub fn init(s: &Rc<State>) { + s.register_op_json_sync("op_query_permission", op_query_permission); + s.register_op_json_sync("op_revoke_permission", op_revoke_permission); + s.register_op_json_sync("op_request_permission", op_request_permission); } #[derive(Deserialize)] @@ -34,7 +24,6 @@ struct PermissionArgs { pub fn op_query_permission( state: &State, - _resource_table: &mut ResourceTable, args: Value, _zero_copy: &mut [ZeroCopyBuf], ) -> Result<Value, ErrBox> { @@ -61,7 +50,6 @@ pub fn op_query_permission( pub fn op_revoke_permission( state: &State, - _resource_table: &mut ResourceTable, args: Value, _zero_copy: &mut [ZeroCopyBuf], ) -> Result<Value, ErrBox> { @@ -88,7 +76,6 @@ pub fn op_revoke_permission( pub fn op_request_permission( state: &State, - _resource_table: &mut ResourceTable, args: Value, _zero_copy: &mut [ZeroCopyBuf], ) -> Result<Value, ErrBox> { diff --git a/cli/ops/plugin.rs b/cli/ops/plugin.rs index bd1a0a002..9cab05011 100644 --- a/cli/ops/plugin.rs +++ b/cli/ops/plugin.rs @@ -1,26 +1,26 @@ // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license. -use crate::ops::dispatch_json::Deserialize; -use crate::ops::dispatch_json::JsonOp; -use crate::ops::dispatch_json::Value; + use crate::state::State; use deno_core::plugin_api; -use deno_core::CoreIsolate; -use deno_core::CoreIsolateState; +use deno_core::BufVec; use deno_core::ErrBox; use deno_core::Op; use deno_core::OpAsyncFuture; use deno_core::OpId; +use deno_core::OpRegistry; use deno_core::ZeroCopyBuf; use dlopen::symbor::Library; use futures::prelude::*; +use serde_derive::Deserialize; +use serde_json::Value; use std::path::PathBuf; use std::pin::Pin; use std::rc::Rc; use std::task::Context; use std::task::Poll; -pub fn init(i: &mut CoreIsolate, s: &Rc<State>) { - i.register_op("op_open_plugin", s.stateful_json_op2(op_open_plugin)); +pub fn init(s: &Rc<State>) { + s.register_op_json_sync("op_open_plugin", op_open_plugin); } #[derive(Deserialize)] @@ -30,12 +30,12 @@ struct OpenPluginArgs { } pub fn op_open_plugin( - isolate_state: &mut CoreIsolateState, - state: &Rc<State>, + state: &State, args: Value, _zero_copy: &mut [ZeroCopyBuf], -) -> Result<JsonOp, ErrBox> { +) -> Result<Value, ErrBox> { state.check_unstable("Deno.openPlugin"); + let args: OpenPluginArgs = serde_json::from_value(args).unwrap(); let filename = PathBuf::from(&args.filename); @@ -45,22 +45,25 @@ pub fn op_open_plugin( let plugin_lib = Library::open(filename).map(Rc::new)?; let plugin_resource = PluginResource::new(&plugin_lib); - let mut resource_table = isolate_state.resource_table.borrow_mut(); - let rid = resource_table.add("plugin", Box::new(plugin_resource)); - let plugin_resource = resource_table.get::<PluginResource>(rid).unwrap(); - - let deno_plugin_init = *unsafe { - plugin_resource - .lib - .symbol::<plugin_api::InitFn>("deno_plugin_init") + let rid; + let deno_plugin_init; + { + let mut resource_table = state.resource_table.borrow_mut(); + rid = resource_table.add("plugin", Box::new(plugin_resource)); + deno_plugin_init = *unsafe { + resource_table + .get::<PluginResource>(rid) + .unwrap() + .lib + .symbol::<plugin_api::InitFn>("deno_plugin_init") + .unwrap() + }; } - .unwrap(); - drop(resource_table); - let mut interface = PluginInterface::new(isolate_state, &plugin_lib); + let mut interface = PluginInterface::new(state, &plugin_lib); deno_plugin_init(&mut interface); - Ok(JsonOp::Sync(json!(rid))) + Ok(json!(rid)) } struct PluginResource { @@ -74,19 +77,13 @@ impl PluginResource { } struct PluginInterface<'a> { - isolate_state: &'a mut CoreIsolateState, + state: &'a State, plugin_lib: &'a Rc<Library>, } impl<'a> PluginInterface<'a> { - fn new( - isolate_state: &'a mut CoreIsolateState, - plugin_lib: &'a Rc<Library>, - ) -> Self { - Self { - isolate_state, - plugin_lib, - } + fn new(state: &'a State, plugin_lib: &'a Rc<Library>) -> Self { + Self { state, plugin_lib } } } @@ -102,11 +99,11 @@ impl<'a> plugin_api::Interface for PluginInterface<'a> { dispatch_op_fn: plugin_api::DispatchOpFn, ) -> OpId { let plugin_lib = self.plugin_lib.clone(); - self.isolate_state.op_registry.register( + self.state.register_op( name, - move |isolate_state, zero_copy| { - let mut interface = PluginInterface::new(isolate_state, &plugin_lib); - let op = dispatch_op_fn(&mut interface, zero_copy); + move |state: Rc<State>, mut zero_copy: BufVec| { + let mut interface = PluginInterface::new(&state, &plugin_lib); + let op = dispatch_op_fn(&mut interface, &mut zero_copy); match op { sync_op @ Op::Sync(..) => sync_op, Op::Async(fut) => { @@ -115,6 +112,7 @@ impl<'a> plugin_api::Interface for PluginInterface<'a> { Op::AsyncUnref(fut) => { Op::AsyncUnref(PluginOpAsyncFuture::new(&plugin_lib, fut)) } + _ => unreachable!(), } }, ) diff --git a/cli/ops/process.rs b/cli/ops/process.rs index 836db08cd..fb8675db9 100644 --- a/cli/ops/process.rs +++ b/cli/ops/process.rs @@ -1,35 +1,30 @@ // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license. -use super::dispatch_json::{Deserialize, Value}; + use super::io::{std_file_resource, StreamResource, StreamResourceHolder}; use crate::signal::kill; use crate::state::State; use deno_core::BufVec; -use deno_core::CoreIsolate; use deno_core::ErrBox; -use deno_core::ResourceTable; +use deno_core::OpRegistry; use deno_core::ZeroCopyBuf; use futures::future::poll_fn; use futures::future::FutureExt; -use std::cell::RefCell; +use serde_derive::Deserialize; +use serde_json::Value; use std::rc::Rc; use tokio::process::Command; #[cfg(unix)] use std::os::unix::process::ExitStatusExt; -pub fn init(i: &mut CoreIsolate, s: &Rc<State>) { - let t = &CoreIsolate::state(i).borrow().resource_table.clone(); - - i.register_op("op_run", s.stateful_json_op_sync(t, op_run)); - i.register_op("op_run_status", s.stateful_json_op_async(t, op_run_status)); - i.register_op("op_kill", s.stateful_json_op_sync(t, op_kill)); +pub fn init(s: &Rc<State>) { + s.register_op_json_sync("op_run", op_run); + s.register_op_json_async("op_run_status", op_run_status); + s.register_op_json_sync("op_kill", op_kill); } -fn clone_file( - rid: u32, - resource_table: &mut ResourceTable, -) -> Result<std::fs::File, ErrBox> { - std_file_resource(resource_table, rid, move |r| match r { +fn clone_file(state: &State, rid: u32) -> Result<std::fs::File, ErrBox> { + std_file_resource(state, rid, move |r| match r { Ok(std_file) => std_file.try_clone().map_err(ErrBox::from), Err(_) => Err(ErrBox::bad_resource_id()), }) @@ -64,7 +59,6 @@ struct ChildResource { fn op_run( state: &State, - resource_table: &mut ResourceTable, args: Value, _zero_copy: &mut [ZeroCopyBuf], ) -> Result<Value, ErrBox> { @@ -90,21 +84,21 @@ fn op_run( if run_args.stdin != "" { c.stdin(subprocess_stdio_map(run_args.stdin.as_ref())?); } else { - let file = clone_file(run_args.stdin_rid, resource_table)?; + let file = clone_file(state, run_args.stdin_rid)?; c.stdin(file); } if run_args.stdout != "" { c.stdout(subprocess_stdio_map(run_args.stdout.as_ref())?); } else { - let file = clone_file(run_args.stdout_rid, resource_table)?; + let file = clone_file(state, run_args.stdout_rid)?; c.stdout(file); } if run_args.stderr != "" { c.stderr(subprocess_stdio_map(run_args.stderr.as_ref())?); } else { - let file = clone_file(run_args.stderr_rid, resource_table)?; + let file = clone_file(state, run_args.stderr_rid)?; c.stderr(file); } @@ -117,7 +111,7 @@ fn op_run( let stdin_rid = match child.stdin.take() { Some(child_stdin) => { - let rid = resource_table.add( + let rid = state.resource_table.borrow_mut().add( "childStdin", Box::new(StreamResourceHolder::new(StreamResource::ChildStdin( child_stdin, @@ -130,7 +124,7 @@ fn op_run( let stdout_rid = match child.stdout.take() { Some(child_stdout) => { - let rid = resource_table.add( + let rid = state.resource_table.borrow_mut().add( "childStdout", Box::new(StreamResourceHolder::new(StreamResource::ChildStdout( child_stdout, @@ -143,7 +137,7 @@ fn op_run( let stderr_rid = match child.stderr.take() { Some(child_stderr) => { - let rid = resource_table.add( + let rid = state.resource_table.borrow_mut().add( "childStderr", Box::new(StreamResourceHolder::new(StreamResource::ChildStderr( child_stderr, @@ -155,7 +149,10 @@ fn op_run( }; let child_resource = ChildResource { child }; - let child_rid = resource_table.add("child", Box::new(child_resource)); + let child_rid = state + .resource_table + .borrow_mut() + .add("child", Box::new(child_resource)); Ok(json!({ "rid": child_rid, @@ -174,7 +171,6 @@ struct RunStatusArgs { async fn op_run_status( state: Rc<State>, - resource_table: Rc<RefCell<ResourceTable>>, args: Value, _zero_copy: BufVec, ) -> Result<Value, ErrBox> { @@ -184,7 +180,7 @@ async fn op_run_status( state.check_run()?; let run_status = poll_fn(|cx| { - let mut resource_table = resource_table.borrow_mut(); + let mut resource_table = state.resource_table.borrow_mut(); let child_resource = resource_table .get_mut::<ChildResource>(rid) .ok_or_else(ErrBox::bad_resource_id)?; @@ -220,7 +216,6 @@ struct KillArgs { fn op_kill( state: &State, - _resource_table: &mut ResourceTable, args: Value, _zero_copy: &mut [ZeroCopyBuf], ) -> Result<Value, ErrBox> { diff --git a/cli/ops/random.rs b/cli/ops/random.rs index fb2286116..4ce1411b8 100644 --- a/cli/ops/random.rs +++ b/cli/ops/random.rs @@ -1,26 +1,20 @@ // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license. -use super::dispatch_json::Value; + use crate::state::State; -use deno_core::CoreIsolate; use deno_core::ErrBox; -use deno_core::ResourceTable; +use deno_core::OpRegistry; use deno_core::ZeroCopyBuf; use rand::thread_rng; use rand::Rng; +use serde_json::Value; use std::rc::Rc; -pub fn init(i: &mut CoreIsolate, s: &Rc<State>) { - let t = &CoreIsolate::state(i).borrow().resource_table.clone(); - - i.register_op( - "op_get_random_values", - s.stateful_json_op_sync(t, op_get_random_values), - ); +pub fn init(s: &Rc<State>) { + s.register_op_json_sync("op_get_random_values", op_get_random_values); } fn op_get_random_values( state: &State, - _resource_table: &mut ResourceTable, _args: Value, zero_copy: &mut [ZeroCopyBuf], ) -> Result<Value, ErrBox> { diff --git a/cli/ops/repl.rs b/cli/ops/repl.rs index 82fa3e23e..300432832 100644 --- a/cli/ops/repl.rs +++ b/cli/ops/repl.rs @@ -1,26 +1,21 @@ // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license. -use super::dispatch_json::{Deserialize, Value}; + use crate::repl; use crate::repl::Repl; use crate::state::State; use deno_core::BufVec; -use deno_core::CoreIsolate; use deno_core::ErrBox; -use deno_core::ResourceTable; +use deno_core::OpRegistry; use deno_core::ZeroCopyBuf; -use std::cell::RefCell; +use serde_derive::Deserialize; +use serde_json::Value; use std::rc::Rc; use std::sync::Arc; use std::sync::Mutex; -pub fn init(i: &mut CoreIsolate, s: &Rc<State>) { - let t = &CoreIsolate::state(i).borrow().resource_table.clone(); - - i.register_op("op_repl_start", s.stateful_json_op_sync(t, op_repl_start)); - i.register_op( - "op_repl_readline", - s.stateful_json_op_async(t, op_repl_readline), - ); +pub fn init(s: &Rc<State>) { + s.register_op_json_sync("op_repl_start", op_repl_start); + s.register_op_json_async("op_repl_readline", op_repl_readline); } struct ReplResource(Arc<Mutex<Repl>>); @@ -33,7 +28,6 @@ struct ReplStartArgs { fn op_repl_start( state: &State, - resource_table: &mut ResourceTable, args: Value, _zero_copy: &mut [ZeroCopyBuf], ) -> Result<Value, ErrBox> { @@ -43,7 +37,10 @@ fn op_repl_start( repl::history_path(&state.global_state.dir, &args.history_file); let repl = repl::Repl::new(history_path); let resource = ReplResource(Arc::new(Mutex::new(repl))); - let rid = resource_table.add("repl", Box::new(resource)); + let rid = state + .resource_table + .borrow_mut() + .add("repl", Box::new(resource)); Ok(json!(rid)) } @@ -54,8 +51,7 @@ struct ReplReadlineArgs { } async fn op_repl_readline( - _state: Rc<State>, - resource_table: Rc<RefCell<ResourceTable>>, + state: Rc<State>, args: Value, _zero_copy: BufVec, ) -> Result<Value, ErrBox> { @@ -63,7 +59,7 @@ async fn op_repl_readline( let rid = args.rid as u32; let prompt = args.prompt; debug!("op_repl_readline {} {}", rid, prompt); - let resource_table = resource_table.borrow(); + let resource_table = state.resource_table.borrow(); let resource = resource_table .get::<ReplResource>(rid) .ok_or_else(ErrBox::bad_resource_id)?; diff --git a/cli/ops/resources.rs b/cli/ops/resources.rs index 0493aeed3..d7c2fd142 100644 --- a/cli/ops/resources.rs +++ b/cli/ops/resources.rs @@ -1,33 +1,31 @@ // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license. -use super::dispatch_json::{Deserialize, Value}; + use crate::state::State; -use deno_core::CoreIsolate; use deno_core::ErrBox; -use deno_core::ResourceTable; +use deno_core::OpRegistry; use deno_core::ZeroCopyBuf; +use serde_derive::Deserialize; +use serde_json::Value; use std::rc::Rc; -pub fn init(i: &mut CoreIsolate, s: &Rc<State>) { - let t = &CoreIsolate::state(i).borrow().resource_table.clone(); - - i.register_op("op_resources", s.stateful_json_op_sync(t, op_resources)); - i.register_op("op_close", s.stateful_json_op_sync(t, op_close)); +pub fn init(s: &Rc<State>) { + s.register_op_json_sync("op_resources", op_resources); + s.register_op_json_sync("op_close", op_close); } fn op_resources( - _state: &State, - resource_table: &mut ResourceTable, + state: &State, _args: Value, _zero_copy: &mut [ZeroCopyBuf], ) -> Result<Value, ErrBox> { + let resource_table = state.resource_table.borrow(); let serialized_resources = resource_table.entries(); Ok(json!(serialized_resources)) } /// op_close removes a resource from the resource table. fn op_close( - _state: &State, - resource_table: &mut ResourceTable, + state: &State, args: Value, _zero_copy: &mut [ZeroCopyBuf], ) -> Result<Value, ErrBox> { @@ -36,7 +34,9 @@ fn op_close( rid: i32, } let args: CloseArgs = serde_json::from_value(args)?; - resource_table + state + .resource_table + .borrow_mut() .close(args.rid as u32) .ok_or_else(ErrBox::bad_resource_id)?; Ok(json!({})) diff --git a/cli/ops/runtime.rs b/cli/ops/runtime.rs index 119e152c8..10aac11fa 100644 --- a/cli/ops/runtime.rs +++ b/cli/ops/runtime.rs @@ -1,28 +1,25 @@ // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license. -use super::dispatch_json::Value; + use crate::colors; use crate::state::State; use crate::version; use crate::DenoSubcommand; -use deno_core::CoreIsolate; use deno_core::ErrBox; use deno_core::ModuleSpecifier; -use deno_core::ResourceTable; +use deno_core::OpRegistry; use deno_core::ZeroCopyBuf; +use serde_json::Value; use std::env; use std::rc::Rc; -pub fn init(i: &mut CoreIsolate, s: &Rc<State>) { - let t = &CoreIsolate::state(i).borrow().resource_table.clone(); - - i.register_op("op_start", s.stateful_json_op_sync(t, op_start)); - i.register_op("op_main_module", s.stateful_json_op_sync(t, op_main_module)); - i.register_op("op_metrics", s.stateful_json_op_sync(t, op_metrics)); +pub fn init(s: &Rc<State>) { + s.register_op_json_sync("op_start", op_start); + s.register_op_json_sync("op_main_module", op_main_module); + s.register_op_json_sync("op_metrics", op_metrics); } fn op_start( state: &State, - _resource_table: &mut ResourceTable, _args: Value, _zero_copy: &mut [ZeroCopyBuf], ) -> Result<Value, ErrBox> { @@ -48,7 +45,6 @@ fn op_start( fn op_main_module( state: &State, - _resource_table: &mut ResourceTable, _args: Value, _zero_copy: &mut [ZeroCopyBuf], ) -> Result<Value, ErrBox> { @@ -63,7 +59,6 @@ fn op_main_module( fn op_metrics( state: &State, - _resource_table: &mut ResourceTable, _args: Value, _zero_copy: &mut [ZeroCopyBuf], ) -> Result<Value, ErrBox> { diff --git a/cli/ops/runtime_compiler.rs b/cli/ops/runtime_compiler.rs index a5991dabf..71974e6da 100644 --- a/cli/ops/runtime_compiler.rs +++ b/cli/ops/runtime_compiler.rs @@ -1,23 +1,21 @@ // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license. -use super::dispatch_json::{Deserialize, Value}; + use crate::futures::FutureExt; use crate::state::State; use crate::tsc::runtime_bundle; use crate::tsc::runtime_compile; use crate::tsc::runtime_transpile; use deno_core::BufVec; -use deno_core::CoreIsolate; use deno_core::ErrBox; -use deno_core::ResourceTable; -use std::cell::RefCell; +use deno_core::OpRegistry; +use serde_derive::Deserialize; +use serde_json::Value; use std::collections::HashMap; use std::rc::Rc; -pub fn init(i: &mut CoreIsolate, s: &Rc<State>) { - let t = &CoreIsolate::state(i).borrow().resource_table.clone(); - - i.register_op("op_compile", s.stateful_json_op_async(t, op_compile)); - i.register_op("op_transpile", s.stateful_json_op_async(t, op_transpile)); +pub fn init(s: &Rc<State>) { + s.register_op_json_async("op_compile", op_compile); + s.register_op_json_async("op_transpile", op_transpile); } #[derive(Deserialize, Debug)] @@ -31,7 +29,6 @@ struct CompileArgs { async fn op_compile( state: Rc<State>, - _resource_table: Rc<RefCell<ResourceTable>>, args: Value, _data: BufVec, ) -> Result<Value, ErrBox> { @@ -70,7 +67,6 @@ struct TranspileArgs { async fn op_transpile( state: Rc<State>, - _resource_table: Rc<RefCell<ResourceTable>>, args: Value, _data: BufVec, ) -> Result<Value, ErrBox> { diff --git a/cli/ops/signal.rs b/cli/ops/signal.rs index 8c0b338b3..c0b1220e0 100644 --- a/cli/ops/signal.rs +++ b/cli/ops/signal.rs @@ -1,35 +1,26 @@ // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license. -use super::dispatch_json::Value; + use crate::state::State; use deno_core::BufVec; -use deno_core::CoreIsolate; use deno_core::ErrBox; -use deno_core::ResourceTable; +use deno_core::OpRegistry; use deno_core::ZeroCopyBuf; -use std::cell::RefCell; +use serde_json::Value; use std::rc::Rc; #[cfg(unix)] -use super::dispatch_json::Deserialize; -#[cfg(unix)] use futures::future::poll_fn; #[cfg(unix)] +use serde_derive::Deserialize; +#[cfg(unix)] use std::task::Waker; #[cfg(unix)] use tokio::signal::unix::{signal, Signal, SignalKind}; -pub fn init(i: &mut CoreIsolate, s: &Rc<State>) { - let t = &CoreIsolate::state(i).borrow().resource_table.clone(); - - i.register_op("op_signal_bind", s.stateful_json_op_sync(t, op_signal_bind)); - i.register_op( - "op_signal_unbind", - s.stateful_json_op_sync(t, op_signal_unbind), - ); - i.register_op( - "op_signal_poll", - s.stateful_json_op_async(t, op_signal_poll), - ); +pub fn init(s: &Rc<State>) { + s.register_op_json_sync("op_signal_bind", op_signal_bind); + s.register_op_json_sync("op_signal_unbind", op_signal_unbind); + s.register_op_json_async("op_signal_poll", op_signal_poll); } #[cfg(unix)] @@ -52,13 +43,12 @@ struct SignalArgs { #[cfg(unix)] fn op_signal_bind( state: &State, - resource_table: &mut ResourceTable, args: Value, _zero_copy: &mut [ZeroCopyBuf], ) -> Result<Value, ErrBox> { state.check_unstable("Deno.signal"); let args: BindSignalArgs = serde_json::from_value(args)?; - let rid = resource_table.add( + let rid = state.resource_table.borrow_mut().add( "signal", Box::new(SignalStreamResource( signal(SignalKind::from_raw(args.signo)).expect(""), @@ -73,7 +63,6 @@ fn op_signal_bind( #[cfg(unix)] async fn op_signal_poll( state: Rc<State>, - resource_table: Rc<RefCell<ResourceTable>>, args: Value, _zero_copy: BufVec, ) -> Result<Value, ErrBox> { @@ -82,7 +71,7 @@ async fn op_signal_poll( let rid = args.rid as u32; let future = poll_fn(move |cx| { - let mut resource_table = resource_table.borrow_mut(); + let mut resource_table = state.resource_table.borrow_mut(); if let Some(mut signal) = resource_table.get_mut::<SignalStreamResource>(rid) { @@ -98,14 +87,14 @@ async fn op_signal_poll( #[cfg(unix)] pub fn op_signal_unbind( state: &State, - resource_table: &mut ResourceTable, args: Value, _zero_copy: &mut [ZeroCopyBuf], ) -> Result<Value, ErrBox> { state.check_unstable("Deno.signal"); + let mut resource_table = state.resource_table.borrow_mut(); let args: SignalArgs = serde_json::from_value(args)?; let rid = args.rid as u32; - let resource = resource_table.get::<SignalStreamResource>(rid); + let resource = resource_table.get_mut::<SignalStreamResource>(rid); if let Some(signal) = resource { if let Some(waker) = &signal.1 { // Wakes up the pending poll if exists. @@ -122,7 +111,6 @@ pub fn op_signal_unbind( #[cfg(not(unix))] pub fn op_signal_bind( _state: &State, - _resource_table: &mut ResourceTable, _args: Value, _zero_copy: &mut [ZeroCopyBuf], ) -> Result<Value, ErrBox> { @@ -132,7 +120,6 @@ pub fn op_signal_bind( #[cfg(not(unix))] fn op_signal_unbind( _state: &State, - _resource_table: &mut ResourceTable, _args: Value, _zero_copy: &mut [ZeroCopyBuf], ) -> Result<Value, ErrBox> { @@ -142,7 +129,6 @@ fn op_signal_unbind( #[cfg(not(unix))] async fn op_signal_poll( _state: Rc<State>, - _resource_table: Rc<RefCell<ResourceTable>>, _args: Value, _zero_copy: BufVec, ) -> Result<Value, ErrBox> { diff --git a/cli/ops/timers.rs b/cli/ops/timers.rs index 66a9b007b..36d617a85 100644 --- a/cli/ops/timers.rs +++ b/cli/ops/timers.rs @@ -1,34 +1,25 @@ // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license. -use super::dispatch_json::{Deserialize, Value}; + use crate::state::State; use deno_core::BufVec; -use deno_core::CoreIsolate; use deno_core::ErrBox; -use deno_core::ResourceTable; +use deno_core::OpRegistry; use deno_core::ZeroCopyBuf; use futures::future::FutureExt; -use std::cell::RefCell; +use serde_derive::Deserialize; +use serde_json::Value; use std::rc::Rc; use std::time::Duration; use std::time::Instant; -pub fn init(i: &mut CoreIsolate, s: &Rc<State>) { - let t = &CoreIsolate::state(i).borrow().resource_table.clone(); - - i.register_op( - "op_global_timer_stop", - s.stateful_json_op_sync(t, op_global_timer_stop), - ); - i.register_op( - "op_global_timer", - s.stateful_json_op_async(t, op_global_timer), - ); - i.register_op("op_now", s.stateful_json_op_sync(t, op_now)); +pub fn init(s: &Rc<State>) { + s.register_op_json_sync("op_global_timer_stop", op_global_timer_stop); + s.register_op_json_async("op_global_timer", op_global_timer); + s.register_op_json_sync("op_now", op_now); } fn op_global_timer_stop( state: &State, - _resource_table: &mut ResourceTable, _args: Value, _zero_copy: &mut [ZeroCopyBuf], ) -> Result<Value, ErrBox> { @@ -43,7 +34,6 @@ struct GlobalTimerArgs { async fn op_global_timer( state: Rc<State>, - _resource_table: Rc<RefCell<ResourceTable>>, args: Value, _zero_copy: BufVec, ) -> Result<Value, ErrBox> { @@ -66,7 +56,6 @@ async fn op_global_timer( // nanoseconds are rounded on 2ms. fn op_now( state: &State, - _resource_table: &mut ResourceTable, _args: Value, _zero_copy: &mut [ZeroCopyBuf], ) -> Result<Value, ErrBox> { diff --git a/cli/ops/tls.rs b/cli/ops/tls.rs index 4a7b9613e..3a478c3ad 100644 --- a/cli/ops/tls.rs +++ b/cli/ops/tls.rs @@ -1,15 +1,15 @@ // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license. -use super::dispatch_json::{Deserialize, Value}; + use super::io::{StreamResource, StreamResourceHolder}; use crate::resolve_addr::resolve_addr; use crate::state::State; use deno_core::BufVec; -use deno_core::CoreIsolate; use deno_core::ErrBox; -use deno_core::ResourceTable; +use deno_core::OpRegistry; use deno_core::ZeroCopyBuf; use futures::future::poll_fn; -use std::cell::RefCell; +use serde_derive::Deserialize; +use serde_json::Value; use std::convert::From; use std::fs::File; use std::io::BufReader; @@ -31,16 +31,11 @@ use tokio_rustls::{ }; use webpki::DNSNameRef; -pub fn init(i: &mut CoreIsolate, s: &Rc<State>) { - let t = &CoreIsolate::state(i).borrow().resource_table.clone(); - - i.register_op("op_start_tls", s.stateful_json_op_async(t, op_start_tls)); - i.register_op( - "op_connect_tls", - s.stateful_json_op_async(t, op_connect_tls), - ); - i.register_op("op_listen_tls", s.stateful_json_op_sync(t, op_listen_tls)); - i.register_op("op_accept_tls", s.stateful_json_op_async(t, op_accept_tls)); +pub fn init(s: &Rc<State>) { + s.register_op_json_async("op_start_tls", op_start_tls); + s.register_op_json_async("op_connect_tls", op_connect_tls); + s.register_op_json_sync("op_listen_tls", op_listen_tls); + s.register_op_json_async("op_accept_tls", op_accept_tls); } #[derive(Deserialize)] @@ -62,7 +57,6 @@ struct StartTLSArgs { async fn op_start_tls( state: Rc<State>, - resource_table: Rc<RefCell<ResourceTable>>, args: Value, _zero_copy: BufVec, ) -> Result<Value, ErrBox> { @@ -82,8 +76,8 @@ async fn op_start_tls( } let mut resource_holder = { - let mut resource_table_ = resource_table.borrow_mut(); - match resource_table_.remove::<StreamResourceHolder>(rid) { + let mut resource_table = state.resource_table.borrow_mut(); + match resource_table.remove::<StreamResourceHolder>(rid) { Some(resource) => *resource, None => return Err(ErrBox::bad_resource_id()), } @@ -110,8 +104,8 @@ async fn op_start_tls( DNSNameRef::try_from_ascii_str(&domain).expect("Invalid DNS lookup"); let tls_stream = tls_connector.connect(dnsname, tcp_stream).await?; - let mut resource_table_ = resource_table.borrow_mut(); - let rid = resource_table_.add( + let mut resource_table = state.resource_table.borrow_mut(); + let rid = resource_table.add( "clientTlsStream", Box::new(StreamResourceHolder::new(StreamResource::ClientTlsStream( Box::new(tls_stream), @@ -137,7 +131,6 @@ async fn op_start_tls( async fn op_connect_tls( state: Rc<State>, - resource_table: Rc<RefCell<ResourceTable>>, args: Value, _zero_copy: BufVec, ) -> Result<Value, ErrBox> { @@ -170,8 +163,8 @@ async fn op_connect_tls( let dnsname = DNSNameRef::try_from_ascii_str(&domain).expect("Invalid DNS lookup"); let tls_stream = tls_connector.connect(dnsname, tcp_stream).await?; - let mut resource_table_ = resource_table.borrow_mut(); - let rid = resource_table_.add( + let mut resource_table = state.resource_table.borrow_mut(); + let rid = resource_table.add( "clientTlsStream", Box::new(StreamResourceHolder::new(StreamResource::ClientTlsStream( Box::new(tls_stream), @@ -306,7 +299,6 @@ struct ListenTlsArgs { fn op_listen_tls( state: &State, - resource_table: &mut ResourceTable, args: Value, _zero_copy: &mut [ZeroCopyBuf], ) -> Result<Value, ErrBox> { @@ -336,7 +328,10 @@ fn op_listen_tls( local_addr, }; - let rid = resource_table.add("tlsListener", Box::new(tls_listener_resource)); + let rid = state + .resource_table + .borrow_mut() + .add("tlsListener", Box::new(tls_listener_resource)); Ok(json!({ "rid": rid, @@ -354,15 +349,14 @@ struct AcceptTlsArgs { } async fn op_accept_tls( - _state: Rc<State>, - resource_table: Rc<RefCell<ResourceTable>>, + state: Rc<State>, args: Value, _zero_copy: BufVec, ) -> Result<Value, ErrBox> { let args: AcceptTlsArgs = serde_json::from_value(args)?; let rid = args.rid as u32; let accept_fut = poll_fn(|cx| { - let mut resource_table = resource_table.borrow_mut(); + let mut resource_table = state.resource_table.borrow_mut(); let listener_resource = resource_table .get_mut::<TlsListenerResource>(rid) .ok_or_else(|| ErrBox::bad_resource("Listener has been closed"))?; @@ -386,7 +380,7 @@ async fn op_accept_tls( let local_addr = tcp_stream.local_addr()?; let remote_addr = tcp_stream.peer_addr()?; let tls_acceptor = { - let resource_table = resource_table.borrow(); + let resource_table = state.resource_table.borrow(); let resource = resource_table .get::<TlsListenerResource>(rid) .ok_or_else(ErrBox::bad_resource_id) @@ -395,7 +389,7 @@ async fn op_accept_tls( }; let tls_stream = tls_acceptor.accept(tcp_stream).await?; let rid = { - let mut resource_table = resource_table.borrow_mut(); + let mut resource_table = state.resource_table.borrow_mut(); resource_table.add( "serverTlsStream", Box::new(StreamResourceHolder::new(StreamResource::ServerTlsStream( diff --git a/cli/ops/tty.rs b/cli/ops/tty.rs index bb8ad8714..9079ca57e 100644 --- a/cli/ops/tty.rs +++ b/cli/ops/tty.rs @@ -1,10 +1,10 @@ // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license. + use super::io::std_file_resource; use super::io::{StreamResource, StreamResourceHolder}; use crate::state::State; -use deno_core::CoreIsolate; use deno_core::ErrBox; -use deno_core::ResourceTable; +use deno_core::OpRegistry; use deno_core::ZeroCopyBuf; #[cfg(unix)] use nix::sys::termios; @@ -36,15 +36,10 @@ fn get_windows_handle( Ok(handle) } -pub fn init(i: &mut CoreIsolate, s: &Rc<State>) { - let t = &CoreIsolate::state(i).borrow().resource_table.clone(); - - i.register_op("op_set_raw", s.stateful_json_op_sync(t, op_set_raw)); - i.register_op("op_isatty", s.stateful_json_op_sync(t, op_isatty)); - i.register_op( - "op_console_size", - s.stateful_json_op_sync(t, op_console_size), - ); +pub fn init(s: &Rc<State>) { + s.register_op_json_sync("op_set_raw", op_set_raw); + s.register_op_json_sync("op_isatty", op_isatty); + s.register_op_json_sync("op_console_size", op_console_size); } #[derive(Deserialize)] @@ -55,7 +50,6 @@ struct SetRawArgs { fn op_set_raw( state: &State, - resource_table: &mut ResourceTable, args: Value, _zero_copy: &mut [ZeroCopyBuf], ) -> Result<Value, ErrBox> { @@ -75,6 +69,7 @@ fn op_set_raw( use winapi::shared::minwindef::FALSE; use winapi::um::{consoleapi, handleapi}; + let mut resource_table = state.resource_table.borrow_mut(); let resource_holder = resource_table.get_mut::<StreamResourceHolder>(rid); if resource_holder.is_none() { return Err(ErrBox::bad_resource_id()); @@ -140,6 +135,7 @@ fn op_set_raw( { use std::os::unix::io::AsRawFd; + let mut resource_table = state.resource_table.borrow_mut(); let resource_holder = resource_table.get_mut::<StreamResourceHolder>(rid); if resource_holder.is_none() { return Err(ErrBox::bad_resource_id()); @@ -221,37 +217,35 @@ struct IsattyArgs { } fn op_isatty( - _state: &State, - resource_table: &mut ResourceTable, + state: &State, args: Value, _zero_copy: &mut [ZeroCopyBuf], ) -> Result<Value, ErrBox> { let args: IsattyArgs = serde_json::from_value(args)?; let rid = args.rid; - let isatty: bool = - std_file_resource(resource_table, rid as u32, move |r| match r { - Ok(std_file) => { - #[cfg(windows)] - { - use winapi::um::consoleapi; - - let handle = get_windows_handle(&std_file)?; - let mut test_mode: DWORD = 0; - // If I cannot get mode out of console, it is not a console. - Ok(unsafe { consoleapi::GetConsoleMode(handle, &mut test_mode) != 0 }) - } - #[cfg(unix)] - { - use std::os::unix::io::AsRawFd; - let raw_fd = std_file.as_raw_fd(); - Ok(unsafe { libc::isatty(raw_fd as libc::c_int) == 1 }) - } + let isatty: bool = std_file_resource(state, rid as u32, move |r| match r { + Ok(std_file) => { + #[cfg(windows)] + { + use winapi::um::consoleapi; + + let handle = get_windows_handle(&std_file)?; + let mut test_mode: DWORD = 0; + // If I cannot get mode out of console, it is not a console. + Ok(unsafe { consoleapi::GetConsoleMode(handle, &mut test_mode) != 0 }) } - Err(StreamResource::FsFile(_)) => unreachable!(), - Err(StreamResource::Stdin(..)) => Ok(atty::is(atty::Stream::Stdin)), - _ => Ok(false), - })?; + #[cfg(unix)] + { + use std::os::unix::io::AsRawFd; + let raw_fd = std_file.as_raw_fd(); + Ok(unsafe { libc::isatty(raw_fd as libc::c_int) == 1 }) + } + } + Err(StreamResource::FsFile(_)) => unreachable!(), + Err(StreamResource::Stdin(..)) => Ok(atty::is(atty::Stream::Stdin)), + _ => Ok(false), + })?; Ok(json!(isatty)) } @@ -268,7 +262,6 @@ struct ConsoleSize { fn op_console_size( state: &State, - resource_table: &mut ResourceTable, args: Value, _zero_copy: &mut [ZeroCopyBuf], ) -> Result<Value, ErrBox> { @@ -276,7 +269,7 @@ fn op_console_size( let args: ConsoleSizeArgs = serde_json::from_value(args)?; let rid = args.rid; - let size = std_file_resource(resource_table, rid as u32, move |r| match r { + let size = std_file_resource(state, rid as u32, move |r| match r { Ok(std_file) => { #[cfg(windows)] { diff --git a/cli/ops/web_worker.rs b/cli/ops/web_worker.rs index 023a4708c..9d8140d7b 100644 --- a/cli/ops/web_worker.rs +++ b/cli/ops/web_worker.rs @@ -1,112 +1,39 @@ // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license. -use super::dispatch_json::{JsonOp, Value}; -use crate::ops::json_op; + use crate::state::State; use crate::web_worker::WebWorkerHandle; use crate::worker::WorkerEvent; -use deno_core::CoreIsolate; -use deno_core::CoreIsolateState; -use deno_core::ErrBox; -use deno_core::ZeroCopyBuf; +use deno_core::OpRegistry; use futures::channel::mpsc; -use std::convert::From; use std::rc::Rc; -pub fn web_worker_op<D>( - sender: mpsc::Sender<WorkerEvent>, - dispatcher: D, -) -> impl Fn( - &mut CoreIsolateState, - Value, - &mut [ZeroCopyBuf], -) -> Result<JsonOp, ErrBox> -where - D: Fn( - &mpsc::Sender<WorkerEvent>, - Value, - &mut [ZeroCopyBuf], - ) -> Result<JsonOp, ErrBox>, -{ - move |_isolate_state: &mut CoreIsolateState, - args: Value, - zero_copy: &mut [ZeroCopyBuf]| - -> Result<JsonOp, ErrBox> { dispatcher(&sender, args, zero_copy) } -} - -pub fn web_worker_op2<D>( - handle: WebWorkerHandle, - sender: mpsc::Sender<WorkerEvent>, - dispatcher: D, -) -> impl Fn( - &mut CoreIsolateState, - Value, - &mut [ZeroCopyBuf], -) -> Result<JsonOp, ErrBox> -where - D: Fn( - WebWorkerHandle, - &mpsc::Sender<WorkerEvent>, - Value, - &mut [ZeroCopyBuf], - ) -> Result<JsonOp, ErrBox>, -{ - move |_isolate_state: &mut CoreIsolateState, - args: Value, - zero_copy: &mut [ZeroCopyBuf]| - -> Result<JsonOp, ErrBox> { - dispatcher(handle.clone(), &sender, args, zero_copy) - } -} - pub fn init( - i: &mut CoreIsolate, s: &Rc<State>, sender: &mpsc::Sender<WorkerEvent>, handle: WebWorkerHandle, ) { - i.register_op( + // Post message to host as guest worker. + let sender_ = sender.clone(); + s.register_op_json_sync( "op_worker_post_message", - s.core_op(json_op(web_worker_op( - sender.clone(), - op_worker_post_message, - ))), - ); - i.register_op( - "op_worker_close", - s.core_op(json_op(web_worker_op2( - handle, - sender.clone(), - op_worker_close, - ))), + move |_state, _args, bufs| { + assert_eq!(bufs.len(), 1, "Invalid number of arguments"); + let msg_buf: Box<[u8]> = (*bufs[0]).into(); + sender_ + .clone() + .try_send(WorkerEvent::Message(msg_buf)) + .expect("Failed to post message to host"); + Ok(json!({})) + }, ); -} - -/// Post message to host as guest worker -fn op_worker_post_message( - sender: &mpsc::Sender<WorkerEvent>, - _args: Value, - data: &mut [ZeroCopyBuf], -) -> Result<JsonOp, ErrBox> { - assert_eq!(data.len(), 1, "Invalid number of arguments"); - let d = Vec::from(&*data[0]).into_boxed_slice(); - let mut sender = sender.clone(); - sender - .try_send(WorkerEvent::Message(d)) - .expect("Failed to post message to host"); - Ok(JsonOp::Sync(json!({}))) -} -/// Notify host that guest worker closes -fn op_worker_close( - handle: WebWorkerHandle, - sender: &mpsc::Sender<WorkerEvent>, - _args: Value, - _data: &mut [ZeroCopyBuf], -) -> Result<JsonOp, ErrBox> { - let mut sender = sender.clone(); - // Notify parent that we're finished - sender.close_channel(); - // Terminate execution of current worker - handle.terminate(); - Ok(JsonOp::Sync(json!({}))) + // Notify host that guest worker closes. + let sender_ = sender.clone(); + s.register_op_json_sync("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(json!({})) + }); } diff --git a/cli/ops/websocket.rs b/cli/ops/websocket.rs index 126d67861..131c52179 100644 --- a/cli/ops/websocket.rs +++ b/cli/ops/websocket.rs @@ -1,15 +1,16 @@ // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license. -use super::dispatch_json::{Deserialize, JsonOp, Value}; use crate::state::State; use core::task::Poll; +use deno_core::BufVec; use deno_core::ErrBox; -use deno_core::ZeroCopyBuf; -use deno_core::{CoreIsolate, CoreIsolateState}; -use futures::future::{poll_fn, FutureExt}; +use deno_core::OpRegistry; +use futures::future::poll_fn; use futures::StreamExt; use futures::{ready, SinkExt}; use http::{Method, Request, Uri}; +use serde_derive::Deserialize; +use serde_json::Value; use std::borrow::Cow; use std::fs::File; use std::io::BufReader; @@ -25,11 +26,11 @@ use tokio_tungstenite::tungstenite::{ use tokio_tungstenite::{client_async, WebSocketStream}; use webpki::DNSNameRef; -pub fn init(i: &mut CoreIsolate, s: &Rc<State>) { - i.register_op("op_ws_create", s.stateful_json_op2(op_ws_create)); - i.register_op("op_ws_send", s.stateful_json_op2(op_ws_send)); - i.register_op("op_ws_close", s.stateful_json_op2(op_ws_close)); - i.register_op("op_ws_next_event", s.stateful_json_op2(op_ws_next_event)); +pub fn init(s: &Rc<State>) { + s.register_op_json_async("op_ws_create", op_ws_create); + s.register_op_json_async("op_ws_send", op_ws_send); + s.register_op_json_async("op_ws_close", op_ws_close); + s.register_op_json_async("op_ws_next_event", op_ws_next_event); } type MaybeTlsStream = @@ -44,86 +45,81 @@ struct CreateArgs { protocols: String, } -pub fn op_ws_create( - isolate_state: &mut CoreIsolateState, - state: &Rc<State>, +pub async fn op_ws_create( + state: Rc<State>, args: Value, - _zero_copy: &mut [ZeroCopyBuf], -) -> Result<JsonOp, ErrBox> { + _bufs: BufVec, +) -> Result<Value, ErrBox> { let args: CreateArgs = serde_json::from_value(args)?; state.check_net_url(&url::Url::parse(&args.url)?)?; - let resource_table = isolate_state.resource_table.clone(); let ca_file = state.global_state.flags.ca_file.clone(); - let future = async move { - let uri: Uri = args.url.parse().unwrap(); - let request = Request::builder() - .method(Method::GET) - .uri(&uri) - .header("Sec-WebSocket-Protocol", args.protocols) - .body(()) - .unwrap(); - let domain = &uri.host().unwrap().to_string(); - let port = &uri.port_u16().unwrap_or(match uri.scheme_str() { - Some("wss") => 443, - Some("ws") => 80, - _ => unreachable!(), - }); - let addr = format!("{}:{}", domain, port); - let try_socket = TcpStream::connect(addr).await; - let tcp_socket = match try_socket.map_err(Error::Io) { - Ok(socket) => socket, - Err(_) => return Ok(json!({"success": false})), - }; + let uri: Uri = args.url.parse().unwrap(); + let request = Request::builder() + .method(Method::GET) + .uri(&uri) + .header("Sec-WebSocket-Protocol", args.protocols) + .body(()) + .unwrap(); + let domain = &uri.host().unwrap().to_string(); + let port = &uri.port_u16().unwrap_or(match uri.scheme_str() { + Some("wss") => 443, + Some("ws") => 80, + _ => unreachable!(), + }); + let addr = format!("{}:{}", domain, port); + let try_socket = TcpStream::connect(addr).await; + let tcp_socket = match try_socket.map_err(Error::Io) { + Ok(socket) => socket, + Err(_) => return Ok(json!({"success": false})), + }; - let socket: MaybeTlsStream = match uri.scheme_str() { - Some("ws") => StreamSwitcher::Plain(tcp_socket), - Some("wss") => { - let mut config = ClientConfig::new(); - config - .root_store - .add_server_trust_anchors(&webpki_roots::TLS_SERVER_ROOTS); + let socket: MaybeTlsStream = match uri.scheme_str() { + Some("ws") => StreamSwitcher::Plain(tcp_socket), + Some("wss") => { + let mut config = ClientConfig::new(); + config + .root_store + .add_server_trust_anchors(&webpki_roots::TLS_SERVER_ROOTS); - if let Some(path) = ca_file { - let key_file = File::open(path)?; - let reader = &mut BufReader::new(key_file); - config.root_store.add_pem_file(reader).unwrap(); - } - - let tls_connector = TlsConnector::from(Arc::new(config)); - let dnsname = - DNSNameRef::try_from_ascii_str(&domain).expect("Invalid DNS lookup"); - let tls_socket = tls_connector.connect(dnsname, tcp_socket).await?; - StreamSwitcher::Tls(tls_socket) + if let Some(path) = ca_file { + let key_file = File::open(path)?; + let reader = &mut BufReader::new(key_file); + config.root_store.add_pem_file(reader).unwrap(); } - _ => unreachable!(), - }; - let (stream, response): (WsStream, Response) = - client_async(request, socket).await.unwrap(); + let tls_connector = TlsConnector::from(Arc::new(config)); + let dnsname = + DNSNameRef::try_from_ascii_str(&domain).expect("Invalid DNS lookup"); + let tls_socket = tls_connector.connect(dnsname, tcp_socket).await?; + StreamSwitcher::Tls(tls_socket) + } + _ => unreachable!(), + }; + + let (stream, response): (WsStream, Response) = + client_async(request, socket).await.unwrap(); - let rid = { - let mut resource_table = resource_table.borrow_mut(); - resource_table.add("webSocketStream", Box::new(stream)) - }; + let rid = state + .resource_table + .borrow_mut() + .add("webSocketStream", Box::new(stream)); - let protocol = match response.headers().get("Sec-WebSocket-Protocol") { - Some(header) => header.to_str().unwrap(), - None => "", - }; - let extensions = response - .headers() - .get_all("Sec-WebSocket-Extensions") - .iter() - .map(|header| header.to_str().unwrap()) - .collect::<String>(); - Ok(json!({ + let protocol = match response.headers().get("Sec-WebSocket-Protocol") { + Some(header) => header.to_str().unwrap(), + None => "", + }; + let extensions = response + .headers() + .get_all("Sec-WebSocket-Extensions") + .iter() + .map(|header| header.to_str().unwrap()) + .collect::<String>(); + Ok(json!({ "success": true, "rid": rid, "protocol": protocol, "extensions": extensions - })) - }; - Ok(JsonOp::Async(future.boxed_local())) + })) } #[derive(Deserialize)] @@ -133,23 +129,21 @@ struct SendArgs { text: Option<String>, } -pub fn op_ws_send( - isolate_state: &mut CoreIsolateState, - _state: &Rc<State>, +pub async fn op_ws_send( + state: Rc<State>, args: Value, - zero_copy: &mut [ZeroCopyBuf], -) -> Result<JsonOp, ErrBox> { + bufs: BufVec, +) -> Result<Value, ErrBox> { let args: SendArgs = serde_json::from_value(args)?; let mut maybe_msg = Some(match args.text { Some(text) => Message::Text(text), - None => Message::Binary(zero_copy[0].to_owned().to_vec()), + None => Message::Binary(bufs[0].to_vec()), }); - let resource_table = isolate_state.resource_table.clone(); let rid = args.rid; - let future = poll_fn(move |cx| { - let mut resource_table = resource_table.borrow_mut(); + poll_fn(move |cx| { + let mut resource_table = state.resource_table.borrow_mut(); let stream = resource_table .get_mut::<WsStream>(rid) .ok_or_else(ErrBox::bad_resource_id)?; @@ -164,8 +158,8 @@ pub fn op_ws_send( ready!(stream.poll_flush_unpin(cx)).unwrap(); Poll::Ready(Ok(json!({}))) - }); - Ok(JsonOp::Async(future.boxed_local())) + }) + .await } #[derive(Deserialize)] @@ -176,14 +170,12 @@ struct CloseArgs { reason: Option<String>, } -pub fn op_ws_close( - isolate_state: &mut CoreIsolateState, - _state: &Rc<State>, +pub async fn op_ws_close( + state: Rc<State>, args: Value, - _zero_copy: &mut [ZeroCopyBuf], -) -> Result<JsonOp, ErrBox> { + _bufs: BufVec, +) -> Result<Value, ErrBox> { let args: CloseArgs = serde_json::from_value(args)?; - let resource_table = isolate_state.resource_table.clone(); let rid = args.rid; let mut maybe_msg = Some(Message::Close(args.code.map(|c| CloseFrame { code: CloseCode::from(c), @@ -193,8 +185,8 @@ pub fn op_ws_close( }, }))); - let future = poll_fn(move |cx| { - let mut resource_table = resource_table.borrow_mut(); + poll_fn(move |cx| { + let mut resource_table = state.resource_table.borrow_mut(); let stream = resource_table .get_mut::<WsStream>(rid) .ok_or_else(ErrBox::bad_resource_id)?; @@ -210,9 +202,8 @@ pub fn op_ws_close( ready!(stream.poll_close_unpin(cx)).unwrap(); Poll::Ready(Ok(json!({}))) - }); - - Ok(JsonOp::Async(future.boxed_local())) + }) + .await } #[derive(Deserialize)] @@ -221,68 +212,48 @@ struct NextEventArgs { rid: u32, } -pub fn op_ws_next_event( - isolate_state: &mut CoreIsolateState, - _state: &Rc<State>, +pub async fn op_ws_next_event( + state: Rc<State>, args: Value, - _zero_copy: &mut [ZeroCopyBuf], -) -> Result<JsonOp, ErrBox> { + _bufs: BufVec, +) -> Result<Value, ErrBox> { let args: NextEventArgs = serde_json::from_value(args)?; - let resource_table = isolate_state.resource_table.clone(); - let future = poll_fn(move |cx| { - let mut resource_table = resource_table.borrow_mut(); + poll_fn(move |cx| { + let mut resource_table = state.resource_table.borrow_mut(); let stream = resource_table .get_mut::<WsStream>(args.rid) .ok_or_else(ErrBox::bad_resource_id)?; - - stream.poll_next_unpin(cx).map(|val| { - match val { - Some(val) => { - match val { - Ok(message) => { - match message { - Message::Text(text) => Ok(json!({ - "type": "string", - "data": text - })), - Message::Binary(data) => { - Ok(json!({ //TODO: don't use json to send binary data - "type": "binary", - "data": data - })) - } - Message::Close(frame) => { - if let Some(frame) = frame { - let code: u16 = frame.code.into(); - Ok(json!({ - "type": "close", - "code": code, - "reason": frame.reason.as_ref() - })) - } else { - Ok(json!({ "type": "close" })) - } - } - Message::Ping(_) => Ok(json!({"type": "ping"})), - Message::Pong(_) => Ok(json!({"type": "pong"})), - } - } - Err(_) => Ok(json!({ - "type": "error", - })), + stream + .poll_next_unpin(cx) + .map(|val| { + match val { + Some(Ok(Message::Text(text))) => json!({ + "type": "string", + "data": text + }), + Some(Ok(Message::Binary(data))) => { + // TODO(ry): don't use json to send binary data. + json!({ + "type": "binary", + "data": data + }) + } + Some(Ok(Message::Close(Some(frame)))) => json!({ + "type": "close", + "code": u16::from(frame.code), + "reason": frame.reason.as_ref() + }), + Some(Ok(Message::Close(None))) => json!({ "type": "close" }), + Some(Ok(Message::Ping(_))) => json!({"type": "ping"}), + Some(Ok(Message::Pong(_))) => json!({"type": "pong"}), + Some(Err(_)) => json!({"type": "error"}), + None => { + resource_table.close(args.rid).unwrap(); + json!({"type": "closed"}) } } - None => { - resource_table - .close(args.rid) - .ok_or_else(ErrBox::bad_resource_id)?; - Ok(json!({ - "type": "closed", - })) - } - } - }) - }); - - Ok(JsonOp::Async(future.boxed_local())) + }) + .map(Ok) + }) + .await } diff --git a/cli/ops/worker_host.rs b/cli/ops/worker_host.rs index 35ec11223..d2c33f005 100644 --- a/cli/ops/worker_host.rs +++ b/cli/ops/worker_host.rs @@ -1,5 +1,5 @@ // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license. -use super::dispatch_json::{Deserialize, Value}; + use crate::fmt_errors::JSError; use crate::global_state::GlobalState; use crate::ops::io::get_stdio; @@ -11,37 +11,23 @@ use crate::web_worker::WebWorker; use crate::web_worker::WebWorkerHandle; use crate::worker::WorkerEvent; use deno_core::BufVec; -use deno_core::CoreIsolate; use deno_core::ErrBox; use deno_core::ModuleSpecifier; -use deno_core::ResourceTable; +use deno_core::OpRegistry; use deno_core::ZeroCopyBuf; use futures::future::FutureExt; -use std::cell::RefCell; +use serde_derive::Deserialize; +use serde_json::Value; use std::convert::From; use std::rc::Rc; use std::sync::Arc; use std::thread::JoinHandle; -pub fn init(i: &mut CoreIsolate, s: &Rc<State>) { - let t = &CoreIsolate::state(i).borrow().resource_table.clone(); - - i.register_op( - "op_create_worker", - s.stateful_json_op_sync(t, op_create_worker), - ); - i.register_op( - "op_host_terminate_worker", - s.stateful_json_op_sync(t, op_host_terminate_worker), - ); - i.register_op( - "op_host_post_message", - s.stateful_json_op_sync(t, op_host_post_message), - ); - i.register_op( - "op_host_get_message", - s.stateful_json_op_async(t, op_host_get_message), - ); +pub fn init(s: &Rc<State>) { + s.register_op_json_sync("op_create_worker", op_create_worker); + s.register_op_json_sync("op_host_terminate_worker", op_host_terminate_worker); + s.register_op_json_sync("op_host_post_message", op_host_post_message); + s.register_op_json_async("op_host_get_message", op_host_get_message); } fn create_web_worker( @@ -63,8 +49,6 @@ fn create_web_worker( ); if has_deno_namespace { - let state_rc = CoreIsolate::state(&worker.isolate); - let state = state_rc.borrow(); let mut resource_table = state.resource_table.borrow_mut(); let (stdin, stdout, stderr) = get_stdio(); if let Some(stream) = stdin { @@ -189,7 +173,6 @@ struct CreateWorkerArgs { /// Create worker as the host fn op_create_worker( state: &State, - _resource_table: &mut ResourceTable, args: Value, _data: &mut [ZeroCopyBuf], ) -> Result<Value, ErrBox> { @@ -240,7 +223,6 @@ struct WorkerArgs { fn op_host_terminate_worker( state: &State, - _resource_table: &mut ResourceTable, args: Value, _data: &mut [ZeroCopyBuf], ) -> Result<Value, ErrBox> { @@ -309,7 +291,6 @@ fn serialize_worker_event(event: WorkerEvent) -> Value { /// Get message from guest worker as host async fn op_host_get_message( state: Rc<State>, - _resource_table: Rc<RefCell<ResourceTable>>, args: Value, _zero_copy: BufVec, ) -> Result<Value, ErrBox> { @@ -358,7 +339,6 @@ async fn op_host_get_message( /// Post message to guest worker as host fn op_host_post_message( state: &State, - _resource_table: &mut ResourceTable, args: Value, data: &mut [ZeroCopyBuf], ) -> Result<Value, ErrBox> { |