diff options
45 files changed, 1055 insertions, 1978 deletions
diff --git a/cli/deno_error.rs b/cli/deno_error.rs index e024a396c..3b7dbcde8 100644 --- a/cli/deno_error.rs +++ b/cli/deno_error.rs @@ -205,6 +205,18 @@ impl GetErrorKind for ReadlineError { } } +impl GetErrorKind for serde_json::error::Error { + fn kind(&self) -> ErrorKind { + use serde_json::error::*; + match self.classify() { + Category::Io => ErrorKind::InvalidInput, + Category::Syntax => ErrorKind::InvalidInput, + Category::Data => ErrorKind::InvalidData, + Category::Eof => ErrorKind::UnexpectedEof, + } + } +} + #[cfg(unix)] mod unix { use super::{ErrorKind, GetErrorKind}; @@ -251,6 +263,11 @@ impl GetErrorKind for dyn AnyError { .or_else(|| self.downcast_ref::<uri::InvalidUri>().map(Get::kind)) .or_else(|| self.downcast_ref::<url::ParseError>().map(Get::kind)) .or_else(|| self.downcast_ref::<ReadlineError>().map(Get::kind)) + .or_else(|| { + self + .downcast_ref::<serde_json::error::Error>() + .map(Get::kind) + }) .or_else(|| unix_error_kind(self)) .unwrap_or_else(|| { panic!("Can't get ErrorKind for {:?}", self); diff --git a/cli/main.rs b/cli/main.rs index 2e82b8ee8..a601e68af 100644 --- a/cli/main.rs +++ b/cli/main.rs @@ -32,7 +32,6 @@ mod http_body; mod http_util; mod import_map; pub mod msg; -pub mod msg_util; pub mod ops; pub mod permissions; mod progress; diff --git a/cli/msg.fbs b/cli/msg.fbs index 3a40b80f5..a7359c527 100644 --- a/cli/msg.fbs +++ b/cli/msg.fbs @@ -1,48 +1,14 @@ union Any { - Accept, - ApplySourceMap, - Cache, Chdir, Chmod, Chown, - Close, CopyFile, - CreateWorker, - CreateWorkerRes, Cwd, CwdRes, - Dial, - Fetch, - FetchSourceFile, - FetchSourceFileRes, - FetchRes, - FormatError, - FormatErrorRes, - GetRandomValues, - GlobalTimer, - GlobalTimerRes, - GlobalTimerStop, - HostGetMessage, - HostGetMessageRes, - HostGetWorkerClosed, - HostPostMessage, - Kill, Link, - Listen, - ListenRes, MakeTempDir, MakeTempDirRes, - Metrics, - MetricsRes, Mkdir, - NewConn, - Now, - NowRes, - Open, - OpenRes, - PermissionRevoke, - Permissions, - PermissionsRes, Read, ReadDir, ReadDirRes, @@ -51,30 +17,11 @@ union Any { ReadlinkRes, Remove, Rename, - ReplReadline, - ReplReadlineRes, - ReplStart, - ReplStartRes, - Resources, - ResourcesRes, - Run, - RunRes, - RunStatus, - RunStatusRes, Seek, - SetEnv, - Shutdown, - Start, - StartRes, Stat, StatRes, Symlink, Truncate, - HomeDir, - HomeDirRes, - WorkerGetMessage, - WorkerGetMessageRes, - WorkerPostMessage, Write, WriteRes, } @@ -167,25 +114,6 @@ table Base { inner: Any; } -table Start { - unused: int8; -} - -table StartRes { - cwd: string; - pid: uint32; - argv: [string]; - main_module: string; // Absolute URL. - debug_flag: bool; - deps_flag: bool; - types_flag: bool; - version_flag: bool; - deno_version: string; - v8_version: string; - no_color: bool; - xeval_delim: string; -} - table FormatError { error: string; } @@ -194,138 +122,15 @@ table FormatErrorRes { error: string; } -// Create worker as host -table CreateWorker { - specifier: string; - include_deno_namespace: bool; - has_source_code: bool; - source_code: string; -} - -table CreateWorkerRes { - rid: uint32; -} - -table HostGetWorkerClosed { - rid: uint32; -} - -// Get message from guest worker as host -table HostGetMessage { - rid: uint32; -} - -table HostGetMessageRes { - data: [ubyte]; -} - -// Post message to guest worker as host -table HostPostMessage { - rid: uint32; - // data passed thru the zero-copy data parameter. -} - -// Get message from host as guest worker -table WorkerGetMessage { - unused: int8; -} - -table WorkerGetMessageRes { - data: [ubyte]; -} - -// Post message to host as guest worker -table WorkerPostMessage { - // data passed thru the zero-copy data parameter. -} - -table FetchSourceFile { - specifier: string; - referrer: string; -} - -table FetchSourceFileRes { - // If it's a non-http module, moduleName and filename will be the same. - // For http modules, module_name is its resolved http URL, and filename - // is the location of the locally downloaded source code. - module_name: string; - filename: string; - media_type: MediaType; - data: [ubyte]; -} - -table ApplySourceMap { - filename: string; - line: int; - column: int; -} - -table Cache { - extension: string; - module_id: string; - contents: string; -} - table Chdir { directory: string; } -table GlobalTimer { - timeout: int; -} - -table GlobalTimerRes { } - -table GlobalTimerStop { } - -table SetEnv { - key: string; - value: string; -} - table KeyValue { key: string; value: string; } -table Permissions {} - -table PermissionRevoke { - permission: string; -} - -table PermissionsRes { - run: bool; - read: bool; - write: bool; - net: bool; - env: bool; - hrtime: bool; -} - -// Note this represents The WHOLE header of an http message, not just the key -// value pairs. That means it includes method and url for Requests and status -// for responses. This is why it is singular "Header" instead of "Headers". -table HttpHeader { - is_request: bool; - // Request only: - method: string; - url: string; - // Response only: - status: uint16; - // Both: - fields: [KeyValue]; -} - -table Fetch { - header: HttpHeader; -} - -table FetchRes { - header: HttpHeader; - body_rid: uint32; -} - table MakeTempDir { dir: string; prefix: string; @@ -384,35 +189,6 @@ table ReadlinkRes { path: string; } -table ReplStart { - history_file: string; - // TODO add config -} - -table ReplStartRes { - rid: uint32; -} - -table ReplReadline { - rid: uint32; - prompt: string; -} - -table ReplReadlineRes { - line: string; -} - -table Resources {} - -table Resource { - rid: uint32; - repr: string; -} - -table ResourcesRes { - resources: [Resource]; -} - table Symlink { oldname: string; newname: string; @@ -445,22 +221,6 @@ table Truncate { len: uint; } -table HomeDir {} - -table HomeDirRes { - path: string; -} - -table Open { - filename: string; - perm: uint; - mode: string; -} - -table OpenRes { - rid: uint32; -} - table Read { rid: uint32; // (ptr, len) is passed as second parameter to Deno.core.send(). @@ -479,103 +239,10 @@ table WriteRes { nbyte: uint; } -table Close { - rid: uint32; -} - -table Kill { - pid: int32; - signo: int32; -} - -table Shutdown { - rid: uint32; - how: uint; -} - -table Listen { - network: string; - address: string; -} - -table ListenRes { - rid: uint32; -} - -table Accept { - rid: uint32; -} - -table Dial { - network: string; - address: string; -} - -// Response to Accept and Dial. -table NewConn { - rid: uint32; - remote_addr: string; - local_addr: string; -} - -table Metrics {} - -table MetricsRes { - ops_dispatched: uint64; - ops_completed: uint64; - bytes_sent_control: uint64; - bytes_sent_data: uint64; - bytes_received: uint64; -} - -enum ProcessStdio: byte { Inherit, Piped, Null } - -table Run { - args: [string]; - cwd: string; - env: [KeyValue]; - stdin: ProcessStdio; - stdout: ProcessStdio; - stderr: ProcessStdio; - stdin_rid: uint32; - stdout_rid: uint32; - stderr_rid: uint32; -} - -table RunRes { - rid: uint32; - pid: uint32; - // The following stdio rids are only valid if "Piped" was specified for the - // corresponding stdio stream. The caller MUST issue a close op for all valid - // stdio streams. - stdin_rid: uint32; - stdout_rid: uint32; - stderr_rid: uint32; -} - -table RunStatus { - rid: uint32; -} - -table RunStatusRes { - got_signal: bool; - exit_code: int; - exit_signal: int; -} - -table Now {} - -table NowRes { - seconds: uint64; - subsec_nanos: uint32; -} - table Seek { rid: uint32; offset: int; whence: uint; } -table GetRandomValues {} - root_type Base; diff --git a/cli/msg.rs b/cli/msg.rs index 51726b572..db4c771f8 100644 --- a/cli/msg.rs +++ b/cli/msg.rs @@ -1,22 +1,8 @@ // Copyright 2018-2019 the Deno authors. All rights reserved. MIT license. #![allow(dead_code)] #![cfg_attr(feature = "cargo-clippy", allow(clippy::all, clippy::pedantic))] -use crate::state; use flatbuffers; -use std::sync::atomic::Ordering; // GN_OUT_DIR is set either by build.rs (for the Cargo build), or by // build_extra/rust/run.py (for the GN+Ninja build). include!(concat!(env!("GN_OUT_DIR"), "/gen/cli/msg_generated.rs")); - -impl<'a> From<&'a state::Metrics> for MetricsResArgs { - fn from(m: &'a state::Metrics) -> Self { - MetricsResArgs { - ops_dispatched: m.ops_dispatched.load(Ordering::SeqCst) as u64, - ops_completed: m.ops_completed.load(Ordering::SeqCst) as u64, - bytes_sent_control: m.bytes_sent_control.load(Ordering::SeqCst) as u64, - bytes_sent_data: m.bytes_sent_data.load(Ordering::SeqCst) as u64, - bytes_received: m.bytes_received.load(Ordering::SeqCst) as u64, - } - } -} diff --git a/cli/msg_util.rs b/cli/msg_util.rs deleted file mode 100644 index e37a91f3a..000000000 --- a/cli/msg_util.rs +++ /dev/null @@ -1,124 +0,0 @@ -// Copyright 2018-2019 the Deno authors. All rights reserved. MIT license. -// Helpers for serialization. -use crate::msg; -use deno::ErrBox; -use flatbuffers; -use http::header::HeaderName; -use http::uri::Uri; -use http::Method; -use hyper::header::HeaderMap; -use hyper::header::HeaderValue; -use hyper::Body; -use hyper::Request; -use hyper::Response; -use std::str::FromStr; - -type Headers = HeaderMap<HeaderValue>; - -pub fn serialize_key_value<'bldr>( - builder: &mut flatbuffers::FlatBufferBuilder<'bldr>, - key: &str, - value: &str, -) -> flatbuffers::WIPOffset<msg::KeyValue<'bldr>> { - let key = builder.create_string(&key); - let value = builder.create_string(&value); - msg::KeyValue::create( - builder, - &msg::KeyValueArgs { - key: Some(key), - value: Some(value), - }, - ) -} - -pub fn serialize_request_header<'bldr>( - builder: &mut flatbuffers::FlatBufferBuilder<'bldr>, - r: &Request<Body>, -) -> flatbuffers::WIPOffset<msg::HttpHeader<'bldr>> { - let method = builder.create_string(r.method().as_str()); - let url = builder.create_string(r.uri().to_string().as_ref()); - - let mut fields = Vec::new(); - for (key, val) in r.headers().iter() { - let kv = serialize_key_value(builder, key.as_ref(), val.to_str().unwrap()); - fields.push(kv); - } - let fields = builder.create_vector(fields.as_ref()); - - msg::HttpHeader::create( - builder, - &msg::HttpHeaderArgs { - is_request: true, - method: Some(method), - url: Some(url), - fields: Some(fields), - ..Default::default() - }, - ) -} - -pub fn serialize_fields<'bldr>( - builder: &mut flatbuffers::FlatBufferBuilder<'bldr>, - headers: &Headers, -) -> flatbuffers::WIPOffset< - flatbuffers::Vector< - 'bldr, - flatbuffers::ForwardsUOffset<msg::KeyValue<'bldr>>, - >, -> { - let mut fields = Vec::new(); - for (key, val) in headers.iter() { - let kv = serialize_key_value(builder, key.as_ref(), val.to_str().unwrap()); - fields.push(kv); - } - builder.create_vector(fields.as_ref()) -} - -// Not to be confused with serialize_response which has nothing to do with HTTP. -pub fn serialize_http_response<'bldr>( - builder: &mut flatbuffers::FlatBufferBuilder<'bldr>, - r: &Response<Body>, -) -> flatbuffers::WIPOffset<msg::HttpHeader<'bldr>> { - let status = r.status().as_u16(); - let fields = serialize_fields(builder, r.headers()); - msg::HttpHeader::create( - builder, - &msg::HttpHeaderArgs { - is_request: false, - status, - fields: Some(fields), - ..Default::default() - }, - ) -} - -pub fn deserialize_request( - header_msg: msg::HttpHeader<'_>, - body: Body, -) -> Result<Request<Body>, ErrBox> { - let mut r = Request::new(body); - - assert!(header_msg.is_request()); - - let u = header_msg.url().unwrap(); - let u = Uri::from_str(u).map_err(ErrBox::from)?; - *r.uri_mut() = u; - - if let Some(method) = header_msg.method() { - let method = Method::from_str(method).unwrap(); - *r.method_mut() = method; - } - - if let Some(fields) = header_msg.fields() { - let headers = r.headers_mut(); - for i in 0..fields.len() { - let kv = fields.get(i); - let key = kv.key().unwrap(); - let name = HeaderName::from_bytes(key.as_bytes()).unwrap(); - let value = kv.value().unwrap(); - let v = HeaderValue::from_str(value).unwrap(); - headers.insert(name, v); - } - } - Ok(r) -} diff --git a/cli/ops/compiler.rs b/cli/ops/compiler.rs index efdcd2c9b..39d3a6d7f 100644 --- a/cli/ops/compiler.rs +++ b/cli/ops/compiler.rs @@ -1,86 +1,68 @@ // Copyright 2018-2019 the Deno authors. All rights reserved. MIT license. -use super::dispatch_flatbuffers::serialize_response; -use super::utils::*; -use crate::deno_error; -use crate::msg; +use super::dispatch_json::{Deserialize, JsonOp, Value}; use crate::state::ThreadSafeState; use crate::tokio_util; use deno::*; -use flatbuffers::FlatBufferBuilder; -use futures::Future; + +#[derive(Deserialize)] +#[serde(rename_all = "camelCase")] +struct CacheArgs { + module_id: String, + contents: String, + extension: String, +} pub fn op_cache( state: &ThreadSafeState, - base: &msg::Base<'_>, - data: Option<PinnedBuf>, -) -> CliOpResult { - assert!(data.is_none()); - let inner = base.inner_as_cache().unwrap(); - let extension = inner.extension().unwrap(); - // TODO: rename to something with 'url' - let module_id = inner.module_id().unwrap(); - let contents = inner.contents().unwrap(); + args: Value, + _zero_copy: Option<PinnedBuf>, +) -> Result<JsonOp, ErrBox> { + let args: CacheArgs = serde_json::from_value(args)?; - let module_specifier = ModuleSpecifier::resolve_url(module_id) + let module_specifier = ModuleSpecifier::resolve_url(&args.module_id) .expect("Should be valid module specifier"); state.ts_compiler.cache_compiler_output( &module_specifier, - extension, - contents, + &args.extension, + &args.contents, )?; - ok_buf(empty_buf()) + Ok(JsonOp::Sync(json!({}))) +} + +#[derive(Deserialize)] +struct FetchSourceFileArgs { + specifier: String, + referrer: String, } pub fn op_fetch_source_file( state: &ThreadSafeState, - base: &msg::Base<'_>, - data: Option<PinnedBuf>, -) -> CliOpResult { - if !base.sync() { - return Err(deno_error::no_async_support()); - } - assert!(data.is_none()); - let inner = base.inner_as_fetch_source_file().unwrap(); - let cmd_id = base.cmd_id(); - let specifier = inner.specifier().unwrap(); - let referrer = inner.referrer().unwrap(); + args: Value, + _zero_copy: Option<PinnedBuf>, +) -> Result<JsonOp, ErrBox> { + let args: FetchSourceFileArgs = serde_json::from_value(args)?; // TODO(ry) Maybe a security hole. Only the compiler worker should have access // to this. Need a test to demonstrate the hole. let is_dyn_import = false; let resolved_specifier = - state.resolve(specifier, referrer, false, is_dyn_import)?; + state.resolve(&args.specifier, &args.referrer, false, is_dyn_import)?; let fut = state .file_fetcher - .fetch_source_file_async(&resolved_specifier) - .and_then(move |out| { - let builder = &mut FlatBufferBuilder::new(); - let data_off = builder.create_vector(out.source_code.as_slice()); - let msg_args = msg::FetchSourceFileResArgs { - module_name: Some(builder.create_string(&out.url.to_string())), - filename: Some(builder.create_string(&out.filename.to_str().unwrap())), - media_type: out.media_type, - data: Some(data_off), - }; - let inner = msg::FetchSourceFileRes::create(builder, &msg_args); - Ok(serialize_response( - cmd_id, - builder, - msg::BaseArgs { - inner: Some(inner.as_union_value()), - inner_type: msg::Any::FetchSourceFileRes, - ..Default::default() - }, - )) - }); + .fetch_source_file_async(&resolved_specifier); // WARNING: Here we use tokio_util::block_on() which starts a new Tokio // runtime for executing the future. This is so we don't inadvernently run // out of threads in the main runtime. - let result_buf = tokio_util::block_on(fut)?; - Ok(Op::Sync(result_buf)) + let out = tokio_util::block_on(fut)?; + Ok(JsonOp::Sync(json!({ + "moduleName": out.url.to_string(), + "filename": out.filename.to_str().unwrap(), + "mediaType": out.media_type as i32, + "sourceCode": String::from_utf8(out.source_code).unwrap(), + }))) } diff --git a/cli/ops/dispatch_flatbuffers.rs b/cli/ops/dispatch_flatbuffers.rs index b9dd4d9fa..bd0158751 100644 --- a/cli/ops/dispatch_flatbuffers.rs +++ b/cli/ops/dispatch_flatbuffers.rs @@ -6,29 +6,12 @@ use deno::*; use flatbuffers::FlatBufferBuilder; use hyper::rt::Future; -use super::compiler::{op_cache, op_fetch_source_file}; -use super::errors::{op_apply_source_map, op_format_error}; -use super::fetch::op_fetch; -use super::files::{op_close, op_open, op_read, op_seek, op_write}; +use super::files::{op_read, op_write}; use super::fs::{ op_chdir, op_chmod, op_chown, op_copy_file, op_cwd, op_link, op_make_temp_dir, op_mkdir, op_read_dir, op_read_link, op_remove, op_rename, op_stat, op_symlink, op_truncate, }; -use super::metrics::op_metrics; -use super::net::{op_accept, op_dial, op_listen, op_shutdown}; -use super::os::{op_home_dir, op_set_env, op_start}; -use super::performance::op_now; -use super::permissions::{op_permissions, op_revoke_permission}; -use super::process::{op_kill, op_run, op_run_status}; -use super::random::op_get_random_values; -use super::repl::{op_repl_readline, op_repl_start}; -use super::resources::op_resources; -use super::timers::{op_global_timer, op_global_timer_stop}; -use super::workers::{ - op_create_worker, op_host_get_message, op_host_get_worker_closed, - op_host_post_message, op_worker_get_message, op_worker_post_message, -}; type CliDispatchFn = fn( state: &ThreadSafeState, @@ -142,61 +125,24 @@ pub fn serialize_response( /// Standard ops set for most isolates pub fn op_selector_std(inner_type: msg::Any) -> Option<CliDispatchFn> { match inner_type { - msg::Any::Accept => Some(op_accept), - msg::Any::ApplySourceMap => Some(op_apply_source_map), - msg::Any::Cache => Some(op_cache), msg::Any::Chdir => Some(op_chdir), msg::Any::Chmod => Some(op_chmod), msg::Any::Chown => Some(op_chown), - msg::Any::Close => Some(op_close), msg::Any::CopyFile => Some(op_copy_file), - msg::Any::CreateWorker => Some(op_create_worker), msg::Any::Cwd => Some(op_cwd), - msg::Any::Dial => Some(op_dial), - msg::Any::Fetch => Some(op_fetch), - msg::Any::FetchSourceFile => Some(op_fetch_source_file), - msg::Any::FormatError => Some(op_format_error), - msg::Any::GetRandomValues => Some(op_get_random_values), - msg::Any::GlobalTimer => Some(op_global_timer), - msg::Any::GlobalTimerStop => Some(op_global_timer_stop), - msg::Any::HostGetMessage => Some(op_host_get_message), - msg::Any::HostGetWorkerClosed => Some(op_host_get_worker_closed), - msg::Any::HostPostMessage => Some(op_host_post_message), - msg::Any::Kill => Some(op_kill), msg::Any::Link => Some(op_link), - msg::Any::Listen => Some(op_listen), msg::Any::MakeTempDir => Some(op_make_temp_dir), - msg::Any::Metrics => Some(op_metrics), msg::Any::Mkdir => Some(op_mkdir), - msg::Any::Now => Some(op_now), - msg::Any::Open => Some(op_open), - msg::Any::PermissionRevoke => Some(op_revoke_permission), - msg::Any::Permissions => Some(op_permissions), msg::Any::Read => Some(op_read), msg::Any::ReadDir => Some(op_read_dir), msg::Any::Readlink => Some(op_read_link), msg::Any::Remove => Some(op_remove), msg::Any::Rename => Some(op_rename), - msg::Any::ReplReadline => Some(op_repl_readline), - msg::Any::ReplStart => Some(op_repl_start), - msg::Any::Resources => Some(op_resources), - msg::Any::Run => Some(op_run), - msg::Any::RunStatus => Some(op_run_status), - msg::Any::Seek => Some(op_seek), - msg::Any::SetEnv => Some(op_set_env), - msg::Any::Shutdown => Some(op_shutdown), - msg::Any::Start => Some(op_start), msg::Any::Stat => Some(op_stat), msg::Any::Symlink => Some(op_symlink), msg::Any::Truncate => Some(op_truncate), - msg::Any::HomeDir => Some(op_home_dir), msg::Any::Write => Some(op_write), - // TODO(ry) split these out so that only the appropriate Workers can access - // them. - msg::Any::WorkerGetMessage => Some(op_worker_get_message), - msg::Any::WorkerPostMessage => Some(op_worker_post_message), - _ => None, } } diff --git a/cli/ops/errors.rs b/cli/ops/errors.rs index a27f3656e..cd21a3880 100644 --- a/cli/ops/errors.rs +++ b/cli/ops/errors.rs @@ -1,88 +1,56 @@ // Copyright 2018-2019 the Deno authors. All rights reserved. MIT license. -use super::dispatch_flatbuffers::serialize_response; -use super::utils::*; -use crate::deno_error; +use super::dispatch_json::{Deserialize, JsonOp, Value}; use crate::fmt_errors::JSError; -use crate::msg; use crate::source_maps::get_orig_position; use crate::source_maps::CachedMaps; use crate::state::ThreadSafeState; use deno::*; -use flatbuffers::FlatBufferBuilder; use std::collections::HashMap; +#[derive(Deserialize)] +struct FormatErrorArgs { + error: String, +} + pub fn op_format_error( state: &ThreadSafeState, - base: &msg::Base<'_>, - data: Option<PinnedBuf>, -) -> CliOpResult { - assert!(data.is_none()); - let inner = base.inner_as_format_error().unwrap(); - let json_str = inner.error().unwrap(); - let error = JSError::from_json(json_str, &state.ts_compiler); - let error_string = error.to_string(); - - let mut builder = FlatBufferBuilder::new(); - let new_error = builder.create_string(&error_string); - - let inner = msg::FormatErrorRes::create( - &mut builder, - &msg::FormatErrorResArgs { - error: Some(new_error), - }, - ); - - let response_buf = serialize_response( - base.cmd_id(), - &mut builder, - msg::BaseArgs { - inner_type: msg::Any::FormatErrorRes, - inner: Some(inner.as_union_value()), - ..Default::default() - }, - ); + args: Value, + _zero_copy: Option<PinnedBuf>, +) -> Result<JsonOp, ErrBox> { + let args: FormatErrorArgs = serde_json::from_value(args)?; + let error = JSError::from_json(&args.error, &state.ts_compiler); + + Ok(JsonOp::Sync(json!({ + "error": error.to_string(), + }))) +} - ok_buf(response_buf) +#[derive(Deserialize)] +struct ApplySourceMap { + filename: String, + line: i32, + column: i32, } pub fn op_apply_source_map( state: &ThreadSafeState, - base: &msg::Base<'_>, - data: Option<PinnedBuf>, -) -> CliOpResult { - if !base.sync() { - return Err(deno_error::no_async_support()); - } - assert!(data.is_none()); - let inner = base.inner_as_apply_source_map().unwrap(); - let cmd_id = base.cmd_id(); - let filename = inner.filename().unwrap(); - let line = inner.line(); - let column = inner.column(); + args: Value, + _zero_copy: Option<PinnedBuf>, +) -> Result<JsonOp, ErrBox> { + let args: ApplySourceMap = serde_json::from_value(args)?; let mut mappings_map: CachedMaps = HashMap::new(); let (orig_filename, orig_line, orig_column) = get_orig_position( - filename.to_owned(), - line.into(), - column.into(), + args.filename, + args.line.into(), + args.column.into(), &mut mappings_map, &state.ts_compiler, ); - let builder = &mut FlatBufferBuilder::new(); - let msg_args = msg::ApplySourceMapArgs { - filename: Some(builder.create_string(&orig_filename)), - line: orig_line as i32, - column: orig_column as i32, - }; - let res_inner = msg::ApplySourceMap::create(builder, &msg_args); - ok_buf(serialize_response( - cmd_id, - builder, - msg::BaseArgs { - inner: Some(res_inner.as_union_value()), - inner_type: msg::Any::ApplySourceMap, - ..Default::default() - }, - )) + Ok(JsonOp::Sync(json!({ + "filename": orig_filename.to_string(), + "line": orig_line as u32, + "column": orig_column as u32, + }))) } diff --git a/cli/ops/fetch.rs b/cli/ops/fetch.rs index 7661eb6e9..e2ab81a81 100644 --- a/cli/ops/fetch.rs +++ b/cli/ops/fetch.rs @@ -1,38 +1,57 @@ // Copyright 2018-2019 the Deno authors. All rights reserved. MIT license. -use super::dispatch_flatbuffers::serialize_response; -use super::utils::CliOpResult; +use super::dispatch_json::{Deserialize, JsonOp, Value}; use crate::http_util; -use crate::msg; -use crate::msg_util; use crate::resources; use crate::state::ThreadSafeState; use deno::*; -use flatbuffers::FlatBufferBuilder; +use http::header::HeaderName; +use http::uri::Uri; +use http::Method; use hyper; +use hyper::header::HeaderValue; use hyper::rt::Future; +use hyper::Request; use std; use std::convert::From; +use std::str::FromStr; + +#[derive(Deserialize)] +struct FetchArgs { + method: Option<String>, + url: String, + headers: Vec<(String, String)>, +} pub fn op_fetch( state: &ThreadSafeState, - base: &msg::Base<'_>, + args: Value, data: Option<PinnedBuf>, -) -> CliOpResult { - let inner = base.inner_as_fetch().unwrap(); - let cmd_id = base.cmd_id(); - - let header = inner.header().unwrap(); - assert!(header.is_request()); - let url = header.url().unwrap(); +) -> Result<JsonOp, ErrBox> { + let args: FetchArgs = serde_json::from_value(args)?; + let url = args.url; let body = match data { None => hyper::Body::empty(), Some(buf) => hyper::Body::from(Vec::from(&*buf)), }; - let req = msg_util::deserialize_request(header, body)?; + let mut req = Request::new(body); + let uri = Uri::from_str(&url).map_err(ErrBox::from)?; + *req.uri_mut() = uri; + + if let Some(method) = args.method { + let method = Method::from_str(&method).unwrap(); + *req.method_mut() = method; + } + + let headers = req.headers_mut(); + for header_pair in args.headers { + let name = HeaderName::from_bytes(header_pair.0.as_bytes()).unwrap(); + let v = HeaderValue::from_str(&header_pair.1).unwrap(); + headers.insert(name, v); + } - let url_ = url::Url::parse(url).map_err(ErrBox::from)?; + let url_ = url::Url::parse(&url).map_err(ErrBox::from)?; state.check_net_url(&url_)?; let client = http_util::get_client(); @@ -42,32 +61,22 @@ pub fn op_fetch( .request(req) .map_err(ErrBox::from) .and_then(move |res| { - let builder = &mut FlatBufferBuilder::new(); - let header_off = msg_util::serialize_http_response(builder, &res); + let status = res.status().as_u16(); + let mut res_headers = Vec::new(); + for (key, val) in res.headers().iter() { + res_headers.push((key.to_string(), val.to_str().unwrap().to_owned())); + } let body = res.into_body(); let body_resource = resources::add_hyper_body(body); - let inner = msg::FetchRes::create( - builder, - &msg::FetchResArgs { - header: Some(header_off), - body_rid: body_resource.rid, - }, - ); - Ok(serialize_response( - cmd_id, - builder, - msg::BaseArgs { - inner: Some(inner.as_union_value()), - inner_type: msg::Any::FetchRes, - ..Default::default() - }, - )) + let json_res = json!({ + "bodyRid": body_resource.rid, + "status": status, + "headers": res_headers + }); + + futures::future::ok(json_res) }); - if base.sync() { - let result_buf = future.wait()?; - Ok(Op::Sync(result_buf)) - } else { - Ok(Op::Async(Box::new(future))) - } + + Ok(JsonOp::Async(Box::new(future))) } diff --git a/cli/ops/files.rs b/cli/ops/files.rs index 023bd65f9..c02a69b9c 100644 --- a/cli/ops/files.rs +++ b/cli/ops/files.rs @@ -1,5 +1,6 @@ // Copyright 2018-2019 the Deno authors. All rights reserved. MIT license. use super::dispatch_flatbuffers::serialize_response; +use super::dispatch_json::{Deserialize, JsonOp, Value}; use super::utils::*; use crate::deno_error; use crate::fs as deno_fs; @@ -14,17 +15,22 @@ use std; use std::convert::From; use tokio; +#[derive(Deserialize)] +#[serde(rename_all = "camelCase")] +struct OpenArgs { + promise_id: Option<u64>, + filename: String, + mode: String, +} + pub fn op_open( state: &ThreadSafeState, - base: &msg::Base<'_>, - data: Option<PinnedBuf>, -) -> CliOpResult { - assert!(data.is_none()); - let cmd_id = base.cmd_id(); - let inner = base.inner_as_open().unwrap(); - let (filename, filename_) = - deno_fs::resolve_from_cwd(inner.filename().unwrap())?; - let mode = inner.mode().unwrap(); + args: Value, + _zero_copy: Option<PinnedBuf>, +) -> Result<JsonOp, ErrBox> { + let args: OpenArgs = serde_json::from_value(args)?; + let (filename, filename_) = deno_fs::resolve_from_cwd(&args.filename)?; + let mode = args.mode.as_ref(); let mut open_options = tokio::fs::OpenOptions::new(); @@ -75,44 +81,39 @@ pub fn op_open( } } + let is_sync = args.promise_id.is_none(); let op = open_options.open(filename).map_err(ErrBox::from).and_then( move |fs_file| { let resource = resources::add_fs_file(fs_file); - let builder = &mut FlatBufferBuilder::new(); - let inner = - msg::OpenRes::create(builder, &msg::OpenResArgs { rid: resource.rid }); - Ok(serialize_response( - cmd_id, - builder, - msg::BaseArgs { - inner: Some(inner.as_union_value()), - inner_type: msg::Any::OpenRes, - ..Default::default() - }, - )) + futures::future::ok(json!(resource.rid)) }, ); - if base.sync() { + + if is_sync { let buf = op.wait()?; - Ok(Op::Sync(buf)) + Ok(JsonOp::Sync(buf)) } else { - Ok(Op::Async(Box::new(op))) + Ok(JsonOp::Async(Box::new(op))) } } +#[derive(Deserialize)] +struct CloseArgs { + rid: i32, +} + pub fn op_close( _state: &ThreadSafeState, - base: &msg::Base<'_>, - data: Option<PinnedBuf>, -) -> CliOpResult { - assert!(data.is_none()); - let inner = base.inner_as_close().unwrap(); - let rid = inner.rid(); - match resources::lookup(rid) { + args: Value, + _zero_copy: Option<PinnedBuf>, +) -> Result<JsonOp, ErrBox> { + let args: CloseArgs = serde_json::from_value(args)?; + + match resources::lookup(args.rid as u32) { None => Err(deno_error::bad_resource()), Some(resource) => { resource.close(); - ok_buf(empty_buf()) + Ok(JsonOp::Sync(json!({}))) } } } @@ -202,27 +203,32 @@ pub fn op_write( } } +#[derive(Deserialize)] +#[serde(rename_all = "camelCase")] +struct SeekArgs { + promise_id: Option<u64>, + rid: i32, + offset: i32, + whence: i32, +} + pub fn op_seek( _state: &ThreadSafeState, - base: &msg::Base<'_>, - data: Option<PinnedBuf>, -) -> CliOpResult { - assert!(data.is_none()); - let inner = base.inner_as_seek().unwrap(); - let rid = inner.rid(); - let offset = inner.offset(); - let whence = inner.whence(); + args: Value, + _zero_copy: Option<PinnedBuf>, +) -> Result<JsonOp, ErrBox> { + let args: SeekArgs = serde_json::from_value(args)?; - match resources::lookup(rid) { + match resources::lookup(args.rid as u32) { None => Err(deno_error::bad_resource()), Some(resource) => { - let op = resources::seek(resource, offset, whence) - .and_then(move |_| Ok(empty_buf())); - if base.sync() { + let op = resources::seek(resource, args.offset, args.whence as u32) + .and_then(move |_| futures::future::ok(json!({}))); + if args.promise_id.is_none() { let buf = op.wait()?; - Ok(Op::Sync(buf)) + Ok(JsonOp::Sync(buf)) } else { - Ok(Op::Async(Box::new(op))) + Ok(JsonOp::Async(Box::new(op))) } } } diff --git a/cli/ops/metrics.rs b/cli/ops/metrics.rs index 76f36c390..e1a23f6c8 100644 --- a/cli/ops/metrics.rs +++ b/cli/ops/metrics.rs @@ -1,31 +1,21 @@ // Copyright 2018-2019 the Deno authors. All rights reserved. MIT license. -use super::dispatch_flatbuffers::serialize_response; -use super::utils::*; -use crate::msg; +use super::dispatch_json::{JsonOp, Value}; use crate::state::ThreadSafeState; use deno::*; -use flatbuffers::FlatBufferBuilder; +use std::sync::atomic::Ordering; pub fn op_metrics( state: &ThreadSafeState, - base: &msg::Base<'_>, - data: Option<PinnedBuf>, -) -> CliOpResult { - assert!(data.is_none()); - let cmd_id = base.cmd_id(); + _args: Value, + _zero_copy: Option<PinnedBuf>, +) -> Result<JsonOp, ErrBox> { + let m = &state.metrics; - let builder = &mut FlatBufferBuilder::new(); - let inner = msg::MetricsRes::create( - builder, - &msg::MetricsResArgs::from(&state.metrics), - ); - ok_buf(serialize_response( - cmd_id, - builder, - msg::BaseArgs { - inner: Some(inner.as_union_value()), - inner_type: msg::Any::MetricsRes, - ..Default::default() - }, - )) + Ok(JsonOp::Sync(json!({ + "opsDispatched": m.ops_dispatched.load(Ordering::SeqCst) as u64, + "opsCompleted": m.ops_completed.load(Ordering::SeqCst) as u64, + "bytesSentControl": m.bytes_sent_control.load(Ordering::SeqCst) as u64, + "bytesSentData": m.bytes_sent_data.load(Ordering::SeqCst) as u64, + "bytesReceived": m.bytes_received.load(Ordering::SeqCst) as u64 + }))) } diff --git a/cli/ops/mod.rs b/cli/ops/mod.rs index 240132960..4636754c9 100644 --- a/cli/ops/mod.rs +++ b/cli/ops/mod.rs @@ -34,6 +34,40 @@ pub const OP_IS_TTY: OpId = 4; pub const OP_ENV: OpId = 5; pub const OP_EXEC_PATH: OpId = 6; pub const OP_UTIME: OpId = 7; +pub const OP_SET_ENV: OpId = 8; +pub const OP_HOME_DIR: OpId = 9; +pub const OP_START: OpId = 10; +pub const OP_APPLY_SOURCE_MAP: OpId = 11; +pub const OP_FORMAT_ERROR: OpId = 12; +pub const OP_CACHE: OpId = 13; +pub const OP_FETCH_SOURCE_FILE: OpId = 14; +pub const OP_OPEN: OpId = 15; +pub const OP_CLOSE: OpId = 16; +pub const OP_SEEK: OpId = 17; +pub const OP_FETCH: OpId = 18; +pub const OP_METRICS: OpId = 19; +pub const OP_REPL_START: OpId = 20; +pub const OP_REPL_READLINE: OpId = 21; +pub const OP_ACCEPT: OpId = 22; +pub const OP_DIAL: OpId = 23; +pub const OP_SHUTDOWN: OpId = 24; +pub const OP_LISTEN: OpId = 25; +pub const OP_RESOURCES: OpId = 26; +pub const OP_GET_RANDOM_VALUES: OpId = 27; +pub const OP_GLOBAL_TIMER_STOP: OpId = 28; +pub const OP_GLOBAL_TIMER: OpId = 29; +pub const OP_NOW: OpId = 30; +pub const OP_PERMISSIONS: OpId = 31; +pub const OP_REVOKE_PERMISSION: OpId = 32; +pub const OP_CREATE_WORKER: OpId = 33; +pub const OP_HOST_GET_WORKER_CLOSED: OpId = 34; +pub const OP_HOST_POST_MESSAGE: OpId = 35; +pub const OP_HOST_GET_MESSAGE: OpId = 36; +pub const OP_WORKER_POST_MESSAGE: OpId = 37; +pub const OP_WORKER_GET_MESSAGE: OpId = 38; +pub const OP_RUN: OpId = 39; +pub const OP_RUN_STATUS: OpId = 40; +pub const OP_KILL: OpId = 41; pub fn dispatch( state: &ThreadSafeState, @@ -59,9 +93,155 @@ pub fn dispatch( OP_EXEC_PATH => { dispatch_json::dispatch(os::op_exec_path, state, control, zero_copy) } + OP_HOME_DIR => { + dispatch_json::dispatch(os::op_home_dir, state, control, zero_copy) + } OP_UTIME => { dispatch_json::dispatch(fs::op_utime, state, control, zero_copy) } + OP_SET_ENV => { + dispatch_json::dispatch(os::op_set_env, state, control, zero_copy) + } + OP_START => { + dispatch_json::dispatch(os::op_start, state, control, zero_copy) + } + OP_APPLY_SOURCE_MAP => dispatch_json::dispatch( + errors::op_apply_source_map, + state, + control, + zero_copy, + ), + OP_FORMAT_ERROR => dispatch_json::dispatch( + errors::op_format_error, + state, + control, + zero_copy, + ), + OP_CACHE => { + dispatch_json::dispatch(compiler::op_cache, state, control, zero_copy) + } + OP_FETCH_SOURCE_FILE => dispatch_json::dispatch( + compiler::op_fetch_source_file, + state, + control, + zero_copy, + ), + OP_OPEN => { + dispatch_json::dispatch(files::op_open, state, control, zero_copy) + } + OP_CLOSE => { + dispatch_json::dispatch(files::op_close, state, control, zero_copy) + } + OP_SEEK => { + dispatch_json::dispatch(files::op_seek, state, control, zero_copy) + } + OP_METRICS => { + dispatch_json::dispatch(metrics::op_metrics, state, control, zero_copy) + } + OP_FETCH => { + dispatch_json::dispatch(fetch::op_fetch, state, control, zero_copy) + } + OP_REPL_START => { + dispatch_json::dispatch(repl::op_repl_start, state, control, zero_copy) + } + OP_REPL_READLINE => { + dispatch_json::dispatch(repl::op_repl_readline, state, control, zero_copy) + } + OP_ACCEPT => { + dispatch_json::dispatch(net::op_accept, state, control, zero_copy) + } + OP_DIAL => dispatch_json::dispatch(net::op_dial, state, control, zero_copy), + OP_SHUTDOWN => { + dispatch_json::dispatch(net::op_shutdown, state, control, zero_copy) + } + OP_LISTEN => { + dispatch_json::dispatch(net::op_listen, state, control, zero_copy) + } + OP_RESOURCES => dispatch_json::dispatch( + resources::op_resources, + state, + control, + zero_copy, + ), + OP_GET_RANDOM_VALUES => dispatch_json::dispatch( + random::op_get_random_values, + state, + control, + zero_copy, + ), + OP_GLOBAL_TIMER_STOP => dispatch_json::dispatch( + timers::op_global_timer_stop, + state, + control, + zero_copy, + ), + OP_GLOBAL_TIMER => dispatch_json::dispatch( + timers::op_global_timer, + state, + control, + zero_copy, + ), + OP_NOW => { + dispatch_json::dispatch(performance::op_now, state, control, zero_copy) + } + OP_PERMISSIONS => dispatch_json::dispatch( + permissions::op_permissions, + state, + control, + zero_copy, + ), + OP_REVOKE_PERMISSION => dispatch_json::dispatch( + permissions::op_revoke_permission, + state, + control, + zero_copy, + ), + OP_CREATE_WORKER => dispatch_json::dispatch( + workers::op_create_worker, + state, + control, + zero_copy, + ), + OP_HOST_GET_WORKER_CLOSED => dispatch_json::dispatch( + workers::op_host_get_worker_closed, + state, + control, + zero_copy, + ), + OP_HOST_POST_MESSAGE => dispatch_json::dispatch( + workers::op_host_post_message, + state, + control, + zero_copy, + ), + OP_HOST_GET_MESSAGE => dispatch_json::dispatch( + workers::op_host_get_message, + state, + control, + zero_copy, + ), + // TODO: make sure these two ops are only accessible to appropriate Workers + OP_WORKER_POST_MESSAGE => dispatch_json::dispatch( + workers::op_worker_post_message, + state, + control, + zero_copy, + ), + OP_WORKER_GET_MESSAGE => dispatch_json::dispatch( + workers::op_worker_get_message, + state, + control, + zero_copy, + ), + OP_RUN => { + dispatch_json::dispatch(process::op_run, state, control, zero_copy) + } + OP_RUN_STATUS => { + dispatch_json::dispatch(process::op_run_status, state, control, zero_copy) + } + OP_KILL => { + dispatch_json::dispatch(process::op_kill, state, control, zero_copy) + } OP_FLATBUFFER => dispatch_flatbuffers::dispatch(state, control, zero_copy), _ => panic!("bad op_id"), }; diff --git a/cli/ops/net.rs b/cli/ops/net.rs index 5ce562492..650127fad 100644 --- a/cli/ops/net.rs +++ b/cli/ops/net.rs @@ -1,15 +1,12 @@ // Copyright 2018-2019 the Deno authors. All rights reserved. MIT license. -use super::dispatch_flatbuffers::serialize_response; -use super::utils::*; +use super::dispatch_json::{Deserialize, JsonOp, Value}; use crate::deno_error; -use crate::msg; use crate::resolve_addr::resolve_addr; use crate::resources; use crate::resources::Resource; use crate::state::ThreadSafeState; use crate::tokio_util; use deno::*; -use flatbuffers::FlatBufferBuilder; use futures::Future; use std; use std::convert::From; @@ -18,15 +15,18 @@ use tokio; use tokio::net::TcpListener; use tokio::net::TcpStream; +#[derive(Deserialize)] +struct AcceptArgs { + rid: i32, +} + pub fn op_accept( _state: &ThreadSafeState, - base: &msg::Base<'_>, - data: Option<PinnedBuf>, -) -> CliOpResult { - assert!(data.is_none()); - let cmd_id = base.cmd_id(); - let inner = base.inner_as_accept().unwrap(); - let server_rid = inner.rid(); + args: Value, + _zero_copy: Option<PinnedBuf>, +) -> Result<JsonOp, ErrBox> { + let args: AcceptArgs = serde_json::from_value(args)?; + let server_rid = args.rid as u32; match resources::lookup(server_rid) { None => Err(deno_error::bad_resource()), @@ -34,55 +34,65 @@ pub fn op_accept( let op = tokio_util::accept(server_resource) .map_err(ErrBox::from) .and_then(move |(tcp_stream, _socket_addr)| { - new_conn(cmd_id, tcp_stream) + let tcp_stream_resource = resources::add_tcp_stream(tcp_stream); + futures::future::ok(json!({ + "rid": tcp_stream_resource.rid + })) }); - if base.sync() { - let buf = op.wait()?; - Ok(Op::Sync(buf)) - } else { - Ok(Op::Async(Box::new(op))) - } + + Ok(JsonOp::Async(Box::new(op))) } } } +#[derive(Deserialize)] +struct DialArgs { + network: String, + address: String, +} + pub fn op_dial( state: &ThreadSafeState, - base: &msg::Base<'_>, - data: Option<PinnedBuf>, -) -> CliOpResult { - assert!(data.is_none()); - let cmd_id = base.cmd_id(); - let inner = base.inner_as_dial().unwrap(); - let network = inner.network().unwrap(); + args: Value, + _zero_copy: Option<PinnedBuf>, +) -> Result<JsonOp, ErrBox> { + let args: DialArgs = serde_json::from_value(args)?; + let network = args.network; assert_eq!(network, "tcp"); // TODO Support others. - let address = inner.address().unwrap(); + let address = args.address; state.check_net(&address)?; - let op = resolve_addr(address).and_then(move |addr| { - TcpStream::connect(&addr) - .map_err(ErrBox::from) - .and_then(move |tcp_stream| new_conn(cmd_id, tcp_stream)) + let op = resolve_addr(&address).and_then(move |addr| { + TcpStream::connect(&addr).map_err(ErrBox::from).and_then( + move |tcp_stream| { + let tcp_stream_resource = resources::add_tcp_stream(tcp_stream); + futures::future::ok(json!({ + "rid": tcp_stream_resource.rid + })) + }, + ) }); - if base.sync() { - let buf = op.wait()?; - Ok(Op::Sync(buf)) - } else { - Ok(Op::Async(Box::new(op))) - } + + Ok(JsonOp::Async(Box::new(op))) +} + +#[derive(Deserialize)] +struct ShutdownArgs { + rid: i32, + how: i32, } pub fn op_shutdown( _state: &ThreadSafeState, - base: &msg::Base<'_>, - data: Option<PinnedBuf>, -) -> CliOpResult { - assert!(data.is_none()); - let inner = base.inner_as_shutdown().unwrap(); - let rid = inner.rid(); - let how = inner.how(); - match resources::lookup(rid) { + args: Value, + _zero_copy: Option<PinnedBuf>, +) -> Result<JsonOp, ErrBox> { + let args: ShutdownArgs = serde_json::from_value(args)?; + + let rid = args.rid; + let how = args.how; + match resources::lookup(rid as u32) { None => Err(deno_error::bad_resource()), Some(mut resource) => { let shutdown_mode = match how { @@ -90,67 +100,36 @@ pub fn op_shutdown( 1 => Shutdown::Write, _ => unimplemented!(), }; - blocking(base.sync(), move || { - // Use UFCS for disambiguation - Resource::shutdown(&mut resource, shutdown_mode)?; - Ok(empty_buf()) - }) + + // Use UFCS for disambiguation + Resource::shutdown(&mut resource, shutdown_mode)?; + Ok(JsonOp::Sync(json!({}))) } } } +#[derive(Deserialize)] +struct ListenArgs { + network: String, + address: String, +} + pub fn op_listen( state: &ThreadSafeState, - base: &msg::Base<'_>, - data: Option<PinnedBuf>, -) -> CliOpResult { - assert!(data.is_none()); - let cmd_id = base.cmd_id(); - let inner = base.inner_as_listen().unwrap(); - let network = inner.network().unwrap(); + args: Value, + _zero_copy: Option<PinnedBuf>, +) -> Result<JsonOp, ErrBox> { + let args: ListenArgs = serde_json::from_value(args)?; + + let network = args.network; assert_eq!(network, "tcp"); - let address = inner.address().unwrap(); + let address = args.address; state.check_net(&address)?; - let addr = resolve_addr(address).wait()?; + let addr = resolve_addr(&address).wait()?; let listener = TcpListener::bind(&addr)?; let resource = resources::add_tcp_listener(listener); - let builder = &mut FlatBufferBuilder::new(); - let inner = - msg::ListenRes::create(builder, &msg::ListenResArgs { rid: resource.rid }); - let response_buf = serialize_response( - cmd_id, - builder, - msg::BaseArgs { - inner: Some(inner.as_union_value()), - inner_type: msg::Any::ListenRes, - ..Default::default() - }, - ); - ok_buf(response_buf) -} - -fn new_conn(cmd_id: u32, tcp_stream: TcpStream) -> Result<Buf, ErrBox> { - let tcp_stream_resource = resources::add_tcp_stream(tcp_stream); - // TODO forward socket_addr to client. - - let builder = &mut FlatBufferBuilder::new(); - let inner = msg::NewConn::create( - builder, - &msg::NewConnArgs { - rid: tcp_stream_resource.rid, - ..Default::default() - }, - ); - Ok(serialize_response( - cmd_id, - builder, - msg::BaseArgs { - inner: Some(inner.as_union_value()), - inner_type: msg::Any::NewConn, - ..Default::default() - }, - )) + Ok(JsonOp::Sync(json!(resource.rid))) } diff --git a/cli/ops/os.rs b/cli/ops/os.rs index 53ef63c60..afb87539f 100644 --- a/cli/ops/os.rs +++ b/cli/ops/os.rs @@ -1,15 +1,11 @@ // Copyright 2018-2019 the Deno authors. All rights reserved. MIT license. -use super::dispatch_flatbuffers::serialize_response; use super::dispatch_json::{Deserialize, JsonOp, Value}; -use super::utils::*; use crate::ansi; use crate::fs as deno_fs; -use crate::msg; use crate::state::ThreadSafeState; use crate::version; use atty; use deno::*; -use flatbuffers::FlatBufferBuilder; use log; use std::collections::HashMap; use std::env; @@ -17,97 +13,38 @@ use url::Url; pub fn op_start( state: &ThreadSafeState, - base: &msg::Base<'_>, - data: Option<PinnedBuf>, -) -> CliOpResult { - assert!(data.is_none()); - let mut builder = FlatBufferBuilder::new(); - - let state = state; - let argv = state.argv.iter().map(String::as_str).collect::<Vec<_>>(); - let argv_off = builder.create_vector_of_strings(argv.as_slice()); - - let cwd_path = env::current_dir().unwrap(); - let cwd_off = - builder.create_string(deno_fs::normalize_path(cwd_path.as_ref()).as_ref()); - - let v8_version = version::v8(); - let v8_version_off = builder.create_string(v8_version); - - let deno_version = version::DENO; - let deno_version_off = builder.create_string(deno_version); - - let main_module = state - .main_module() - .map(|m| builder.create_string(&m.to_string())); - - let xeval_delim = state - .flags - .xeval_delim - .clone() - .map(|m| builder.create_string(&m)); - - let debug_flag = state - .flags - .log_level - .map_or(false, |l| l == log::Level::Debug); - - let inner = msg::StartRes::create( - &mut builder, - &msg::StartResArgs { - cwd: Some(cwd_off), - pid: std::process::id(), - argv: Some(argv_off), - main_module, - debug_flag, - version_flag: state.flags.version, - v8_version: Some(v8_version_off), - deno_version: Some(deno_version_off), - no_color: !ansi::use_color(), - xeval_delim, - ..Default::default() - }, - ); - - ok_buf(serialize_response( - base.cmd_id(), - &mut builder, - msg::BaseArgs { - inner_type: msg::Any::StartRes, - inner: Some(inner.as_union_value()), - ..Default::default() - }, - )) + _args: Value, + _zero_copy: Option<PinnedBuf>, +) -> Result<JsonOp, ErrBox> { + Ok(JsonOp::Sync(json!({ + "cwd": deno_fs::normalize_path(&env::current_dir().unwrap()), + "pid": std::process::id(), + "argv": state.argv, + "mainModule": state.main_module().map(|x| x.as_str().to_string()), + "debugFlag": state + .flags + .log_level + .map_or(false, |l| l == log::Level::Debug), + "versionFlag": state.flags.version, + "v8Version": version::v8(), + "denoVersion": version::DENO, + "noColor": !ansi::use_color(), + "xevalDelim": state.flags.xeval_delim.clone(), + }))) } pub fn op_home_dir( state: &ThreadSafeState, - base: &msg::Base<'_>, - data: Option<PinnedBuf>, -) -> CliOpResult { - assert!(data.is_none()); - let cmd_id = base.cmd_id(); - + _args: Value, + _zero_copy: Option<PinnedBuf>, +) -> Result<JsonOp, ErrBox> { state.check_env()?; - - let builder = &mut FlatBufferBuilder::new(); let path = dirs::home_dir() .unwrap_or_default() .into_os_string() .into_string() .unwrap_or_default(); - let path = Some(builder.create_string(&path)); - let inner = msg::HomeDirRes::create(builder, &msg::HomeDirResArgs { path }); - - ok_buf(serialize_response( - cmd_id, - builder, - msg::BaseArgs { - inner: Some(inner.as_union_value()), - inner_type: msg::Any::HomeDirRes, - ..Default::default() - }, - )) + Ok(JsonOp::Sync(json!(path))) } pub fn op_exec_path( @@ -124,18 +61,21 @@ pub fn op_exec_path( Ok(JsonOp::Sync(json!(path))) } +#[derive(Deserialize)] +struct SetEnv { + key: String, + value: String, +} + pub fn op_set_env( state: &ThreadSafeState, - base: &msg::Base<'_>, - data: Option<PinnedBuf>, -) -> CliOpResult { - assert!(data.is_none()); - let inner = base.inner_as_set_env().unwrap(); - let key = inner.key().unwrap(); - let value = inner.value().unwrap(); + args: Value, + _zero_copy: Option<PinnedBuf>, +) -> Result<JsonOp, ErrBox> { + let args: SetEnv = serde_json::from_value(args)?; state.check_env()?; - env::set_var(key, value); - ok_buf(empty_buf()) + env::set_var(args.key, args.value); + Ok(JsonOp::Sync(json!({}))) } pub fn op_env( diff --git a/cli/ops/performance.rs b/cli/ops/performance.rs index 94f6dbc38..090fc3323 100644 --- a/cli/ops/performance.rs +++ b/cli/ops/performance.rs @@ -1,10 +1,7 @@ // Copyright 2018-2019 the Deno authors. All rights reserved. MIT license. -use super::dispatch_flatbuffers::serialize_response; -use super::utils::*; -use crate::msg; +use super::dispatch_json::{JsonOp, Value}; use crate::state::ThreadSafeState; use deno::*; -use flatbuffers::FlatBufferBuilder; // Returns a milliseconds and nanoseconds subsec // since the start time of the deno runtime. @@ -12,10 +9,9 @@ use flatbuffers::FlatBufferBuilder; // nanoseconds are rounded on 2ms. pub fn op_now( state: &ThreadSafeState, - base: &msg::Base<'_>, - data: Option<PinnedBuf>, -) -> CliOpResult { - assert!(data.is_none()); + _args: Value, + _zero_copy: Option<PinnedBuf>, +) -> Result<JsonOp, ErrBox> { let seconds = state.start_time.elapsed().as_secs(); let mut subsec_nanos = state.start_time.elapsed().subsec_nanos(); let reduced_time_precision = 2_000_000; // 2ms in nanoseconds @@ -27,22 +23,8 @@ pub fn op_now( subsec_nanos -= subsec_nanos % reduced_time_precision } - let builder = &mut FlatBufferBuilder::new(); - let inner = msg::NowRes::create( - builder, - &msg::NowResArgs { - seconds, - subsec_nanos, - }, - ); - - ok_buf(serialize_response( - base.cmd_id(), - builder, - msg::BaseArgs { - inner: Some(inner.as_union_value()), - inner_type: msg::Any::NowRes, - ..Default::default() - }, - )) + Ok(JsonOp::Sync(json!({ + "seconds": seconds, + "subsecNanos": subsec_nanos, + }))) } diff --git a/cli/ops/permissions.rs b/cli/ops/permissions.rs index 6249581fb..5d14f39be 100644 --- a/cli/ops/permissions.rs +++ b/cli/ops/permissions.rs @@ -1,50 +1,35 @@ // Copyright 2018-2019 the Deno authors. All rights reserved. MIT license. -use super::dispatch_flatbuffers::serialize_response; -use super::utils::*; -use crate::msg; +use super::dispatch_json::{Deserialize, JsonOp, Value}; use crate::state::ThreadSafeState; use deno::*; -use flatbuffers::FlatBufferBuilder; pub fn op_permissions( state: &ThreadSafeState, - base: &msg::Base<'_>, - data: Option<PinnedBuf>, -) -> CliOpResult { - assert!(data.is_none()); - let cmd_id = base.cmd_id(); - let builder = &mut FlatBufferBuilder::new(); - let inner = msg::PermissionsRes::create( - builder, - &msg::PermissionsResArgs { - run: state.permissions.allows_run(), - read: state.permissions.allows_read(), - write: state.permissions.allows_write(), - net: state.permissions.allows_net(), - env: state.permissions.allows_env(), - hrtime: state.permissions.allows_hrtime(), - }, - ); - let response_buf = serialize_response( - cmd_id, - builder, - msg::BaseArgs { - inner: Some(inner.as_union_value()), - inner_type: msg::Any::PermissionsRes, - ..Default::default() - }, - ); - ok_buf(response_buf) + _args: Value, + _zero_copy: Option<PinnedBuf>, +) -> Result<JsonOp, ErrBox> { + Ok(JsonOp::Sync(json!({ + "run": state.permissions.allows_run(), + "read": state.permissions.allows_read(), + "write": state.permissions.allows_write(), + "net": state.permissions.allows_net(), + "env": state.permissions.allows_env(), + "hrtime": state.permissions.allows_hrtime(), + }))) +} + +#[derive(Deserialize)] +struct RevokePermissionArgs { + permission: String, } pub fn op_revoke_permission( state: &ThreadSafeState, - base: &msg::Base<'_>, - data: Option<PinnedBuf>, -) -> CliOpResult { - assert!(data.is_none()); - let inner = base.inner_as_permission_revoke().unwrap(); - let permission = inner.permission().unwrap(); + args: Value, + _zero_copy: Option<PinnedBuf>, +) -> Result<JsonOp, ErrBox> { + let args: RevokePermissionArgs = serde_json::from_value(args)?; + let permission = args.permission.as_ref(); match permission { "run" => state.permissions.revoke_run(), "read" => state.permissions.revoke_read(), @@ -54,5 +39,6 @@ pub fn op_revoke_permission( "hrtime" => state.permissions.revoke_hrtime(), _ => Ok(()), }?; - ok_buf(empty_buf()) + + Ok(JsonOp::Sync(json!({}))) } diff --git a/cli/ops/process.rs b/cli/ops/process.rs index d7b326d14..8dff53c6e 100644 --- a/cli/ops/process.rs +++ b/cli/ops/process.rs @@ -1,13 +1,9 @@ // Copyright 2018-2019 the Deno authors. All rights reserved. MIT license. -use super::dispatch_flatbuffers::serialize_response; -use super::utils::*; -use crate::deno_error; -use crate::msg; +use super::dispatch_json::{Deserialize, JsonOp, Value}; use crate::resources; use crate::signal::kill; use crate::state::ThreadSafeState; use deno::*; -use flatbuffers::FlatBufferBuilder; use futures; use futures::Future; use std; @@ -18,63 +14,72 @@ use tokio_process::CommandExt; #[cfg(unix)] use std::os::unix::process::ExitStatusExt; -fn subprocess_stdio_map(v: msg::ProcessStdio) -> std::process::Stdio { - match v { - msg::ProcessStdio::Inherit => std::process::Stdio::inherit(), - msg::ProcessStdio::Piped => std::process::Stdio::piped(), - msg::ProcessStdio::Null => std::process::Stdio::null(), +fn subprocess_stdio_map(s: &str) -> std::process::Stdio { + match s { + "inherit" => std::process::Stdio::inherit(), + "piped" => std::process::Stdio::piped(), + "null" => std::process::Stdio::null(), + _ => unreachable!(), } } +#[derive(Deserialize)] +#[serde(rename_all = "camelCase")] +struct RunArgs { + args: Vec<String>, + cwd: Option<String>, + env: Vec<(String, String)>, + stdin: String, + stdout: String, + stderr: String, + stdin_rid: u32, + stdout_rid: u32, + stderr_rid: u32, +} + pub fn op_run( state: &ThreadSafeState, - base: &msg::Base<'_>, - data: Option<PinnedBuf>, -) -> CliOpResult { - if !base.sync() { - return Err(deno_error::no_async_support()); - } - let cmd_id = base.cmd_id(); + args: Value, + _zero_copy: Option<PinnedBuf>, +) -> Result<JsonOp, ErrBox> { + let run_args: RunArgs = serde_json::from_value(args)?; state.check_run()?; - assert!(data.is_none()); - let inner = base.inner_as_run().unwrap(); - let args = inner.args().unwrap(); - let env = inner.env().unwrap(); - let cwd = inner.cwd(); + let args = run_args.args; + let env = run_args.env; + let cwd = run_args.cwd; - let mut c = Command::new(args.get(0)); + let mut c = Command::new(args.get(0).unwrap()); (1..args.len()).for_each(|i| { - let arg = args.get(i); + let arg = args.get(i).unwrap(); c.arg(arg); }); cwd.map(|d| c.current_dir(d)); - (0..env.len()).for_each(|i| { - let entry = env.get(i); - c.env(entry.key().unwrap(), entry.value().unwrap()); - }); + for (key, value) in &env { + c.env(key, value); + } // TODO: make this work with other resources, eg. sockets - let stdin_rid = inner.stdin_rid(); + let stdin_rid = run_args.stdin_rid; if stdin_rid > 0 { c.stdin(resources::get_file(stdin_rid)?); } else { - c.stdin(subprocess_stdio_map(inner.stdin())); + c.stdin(subprocess_stdio_map(run_args.stdin.as_ref())); } - let stdout_rid = inner.stdout_rid(); + let stdout_rid = run_args.stdout_rid; if stdout_rid > 0 { c.stdout(resources::get_file(stdout_rid)?); } else { - c.stdout(subprocess_stdio_map(inner.stdout())); + c.stdout(subprocess_stdio_map(run_args.stdout.as_ref())); } - let stderr_rid = inner.stderr_rid(); + let stderr_rid = run_args.stderr_rid; if stderr_rid > 0 { c.stderr(resources::get_file(stderr_rid)?); } else { - c.stderr(subprocess_stdio_map(inner.stderr())); + c.stderr(subprocess_stdio_map(run_args.stderr.as_ref())); } // Spawn the command. @@ -83,44 +88,28 @@ pub fn op_run( let pid = child.id(); let resources = resources::add_child(child); - let mut res_args = msg::RunResArgs { - rid: resources.child_rid, - pid, - ..Default::default() - }; - - if let Some(stdin_rid) = resources.stdin_rid { - res_args.stdin_rid = stdin_rid; - } - if let Some(stdout_rid) = resources.stdout_rid { - res_args.stdout_rid = stdout_rid; - } - if let Some(stderr_rid) = resources.stderr_rid { - res_args.stderr_rid = stderr_rid; - } + Ok(JsonOp::Sync(json!({ + "rid": resources.child_rid, + "pid": pid, + "stdinRid": resources.stdin_rid, + "stdoutRid": resources.stdout_rid, + "stderrRid": resources.stderr_rid, + }))) +} - let builder = &mut FlatBufferBuilder::new(); - let inner = msg::RunRes::create(builder, &res_args); - Ok(Op::Sync(serialize_response( - cmd_id, - builder, - msg::BaseArgs { - inner: Some(inner.as_union_value()), - inner_type: msg::Any::RunRes, - ..Default::default() - }, - ))) +#[derive(Deserialize)] +#[serde(rename_all = "camelCase")] +struct RunStatusArgs { + rid: i32, } pub fn op_run_status( state: &ThreadSafeState, - base: &msg::Base<'_>, - data: Option<PinnedBuf>, -) -> CliOpResult { - assert!(data.is_none()); - let cmd_id = base.cmd_id(); - let inner = base.inner_as_run_status().unwrap(); - let rid = inner.rid(); + args: Value, + _zero_copy: Option<PinnedBuf>, +) -> Result<JsonOp, ErrBox> { + let args: RunStatusArgs = serde_json::from_value(args)?; + let rid = args.rid as u32; state.check_run()?; @@ -139,44 +128,30 @@ pub fn op_run_status( .expect("Should have either an exit code or a signal."); let got_signal = signal.is_some(); - let builder = &mut FlatBufferBuilder::new(); - let inner = msg::RunStatusRes::create( - builder, - &msg::RunStatusResArgs { - got_signal, - exit_code: code.unwrap_or(-1), - exit_signal: signal.unwrap_or(-1), - }, - ); - Ok(serialize_response( - cmd_id, - builder, - msg::BaseArgs { - inner: Some(inner.as_union_value()), - inner_type: msg::Any::RunStatusRes, - ..Default::default() - }, - )) + futures::future::ok(json!({ + "gotSignal": got_signal, + "exitCode": code.unwrap_or(-1), + "exitSignal": signal.unwrap_or(-1), + })) }); - if base.sync() { - let buf = future.wait()?; - Ok(Op::Sync(buf)) - } else { - Ok(Op::Async(Box::new(future))) - } + + Ok(JsonOp::Async(Box::new(future))) +} + +#[derive(Deserialize)] +struct KillArgs { + pid: i32, + signo: i32, } pub fn op_kill( state: &ThreadSafeState, - base: &msg::Base<'_>, - data: Option<PinnedBuf>, -) -> CliOpResult { + args: Value, + _zero_copy: Option<PinnedBuf>, +) -> Result<JsonOp, ErrBox> { state.check_run()?; - assert!(data.is_none()); - let inner = base.inner_as_kill().unwrap(); - let pid = inner.pid(); - let signo = inner.signo(); - kill(pid, signo)?; - ok_buf(empty_buf()) + let args: KillArgs = serde_json::from_value(args)?; + kill(args.pid, args.signo)?; + Ok(JsonOp::Sync(json!({}))) } diff --git a/cli/ops/random.rs b/cli/ops/random.rs index 0c302a080..7470eab40 100644 --- a/cli/ops/random.rs +++ b/cli/ops/random.rs @@ -1,6 +1,5 @@ // Copyright 2018-2019 the Deno authors. All rights reserved. MIT license. -use super::utils::*; -use crate::msg; +use super::dispatch_json::{JsonOp, Value}; use crate::state::ThreadSafeState; use deno::*; use rand::thread_rng; @@ -8,16 +7,18 @@ use rand::Rng; pub fn op_get_random_values( state: &ThreadSafeState, - _base: &msg::Base<'_>, - data: Option<PinnedBuf>, -) -> CliOpResult { + _args: Value, + zero_copy: Option<PinnedBuf>, +) -> Result<JsonOp, ErrBox> { + assert!(zero_copy.is_some()); + if let Some(ref seeded_rng) = state.seeded_rng { let mut rng = seeded_rng.lock().unwrap(); - rng.fill(&mut data.unwrap()[..]); + rng.fill(&mut zero_copy.unwrap()[..]); } else { let mut rng = thread_rng(); - rng.fill(&mut data.unwrap()[..]); + rng.fill(&mut zero_copy.unwrap()[..]); } - ok_buf(empty_buf()) + Ok(JsonOp::Sync(json!({}))) } diff --git a/cli/ops/repl.rs b/cli/ops/repl.rs index affe78739..7ab7509de 100644 --- a/cli/ops/repl.rs +++ b/cli/ops/repl.rs @@ -1,78 +1,50 @@ // Copyright 2018-2019 the Deno authors. All rights reserved. MIT license. -use super::dispatch_flatbuffers::serialize_response; -use super::utils::blocking; -use super::utils::ok_buf; -use super::utils::CliOpResult; -use crate::msg; +use super::dispatch_json::{blocking_json, Deserialize, JsonOp, Value}; use crate::repl; use crate::resources; use crate::state::ThreadSafeState; use deno::*; -use flatbuffers::FlatBufferBuilder; + +#[derive(Deserialize)] +#[serde(rename_all = "camelCase")] +struct ReplStartArgs { + history_file: String, +} pub fn op_repl_start( state: &ThreadSafeState, - base: &msg::Base<'_>, - data: Option<PinnedBuf>, -) -> CliOpResult { - assert!(data.is_none()); - let inner = base.inner_as_repl_start().unwrap(); - let cmd_id = base.cmd_id(); - let history_file = String::from(inner.history_file().unwrap()); + args: Value, + _zero_copy: Option<PinnedBuf>, +) -> Result<JsonOp, ErrBox> { + let args: ReplStartArgs = serde_json::from_value(args)?; - debug!("op_repl_start {}", history_file); - let history_path = repl::history_path(&state.dir, &history_file); + debug!("op_repl_start {}", args.history_file); + let history_path = repl::history_path(&state.dir, &args.history_file); let repl = repl::Repl::new(history_path); let resource = resources::add_repl(repl); - let builder = &mut FlatBufferBuilder::new(); - let inner = msg::ReplStartRes::create( - builder, - &msg::ReplStartResArgs { rid: resource.rid }, - ); - ok_buf(serialize_response( - cmd_id, - builder, - msg::BaseArgs { - inner: Some(inner.as_union_value()), - inner_type: msg::Any::ReplStartRes, - ..Default::default() - }, - )) + Ok(JsonOp::Sync(json!(resource.rid))) +} + +#[derive(Deserialize)] +struct ReplReadlineArgs { + rid: i32, + prompt: String, } pub fn op_repl_readline( _state: &ThreadSafeState, - base: &msg::Base<'_>, - data: Option<PinnedBuf>, -) -> CliOpResult { - assert!(data.is_none()); - let inner = base.inner_as_repl_readline().unwrap(); - let cmd_id = base.cmd_id(); - let rid = inner.rid(); - let prompt = inner.prompt().unwrap().to_owned(); + args: Value, + _zero_copy: Option<PinnedBuf>, +) -> Result<JsonOp, ErrBox> { + let args: ReplReadlineArgs = serde_json::from_value(args)?; + let rid = args.rid; + let prompt = args.prompt; debug!("op_repl_readline {} {}", rid, prompt); - blocking(base.sync(), move || { - let repl = resources::get_repl(rid)?; + blocking_json(false, move || { + let repl = resources::get_repl(rid as u32)?; let line = repl.lock().unwrap().readline(&prompt)?; - - let builder = &mut FlatBufferBuilder::new(); - let line_off = builder.create_string(&line); - let inner = msg::ReplReadlineRes::create( - builder, - &msg::ReplReadlineResArgs { - line: Some(line_off), - }, - ); - Ok(serialize_response( - cmd_id, - builder, - msg::BaseArgs { - inner: Some(inner.as_union_value()), - inner_type: msg::Any::ReplReadlineRes, - ..Default::default() - }, - )) + Ok(json!(line)) }) } diff --git a/cli/ops/resources.rs b/cli/ops/resources.rs index 975d94490..dafd01d08 100644 --- a/cli/ops/resources.rs +++ b/cli/ops/resources.rs @@ -1,54 +1,14 @@ // Copyright 2018-2019 the Deno authors. All rights reserved. MIT license. -use super::dispatch_flatbuffers::serialize_response; -use super::utils::ok_buf; -use super::utils::CliOpResult; -use crate::msg; +use super::dispatch_json::{JsonOp, Value}; use crate::resources::table_entries; use crate::state::ThreadSafeState; use deno::*; -use flatbuffers::FlatBufferBuilder; pub fn op_resources( _state: &ThreadSafeState, - base: &msg::Base<'_>, - data: Option<PinnedBuf>, -) -> CliOpResult { - assert!(data.is_none()); - let cmd_id = base.cmd_id(); - - let builder = &mut FlatBufferBuilder::new(); + _args: Value, + _zero_copy: Option<PinnedBuf>, +) -> Result<JsonOp, ErrBox> { let serialized_resources = table_entries(); - - let res: Vec<_> = serialized_resources - .iter() - .map(|(key, value)| { - let repr = builder.create_string(value); - - msg::Resource::create( - builder, - &msg::ResourceArgs { - rid: *key, - repr: Some(repr), - }, - ) - }) - .collect(); - - let resources = builder.create_vector(&res); - let inner = msg::ResourcesRes::create( - builder, - &msg::ResourcesResArgs { - resources: Some(resources), - }, - ); - - ok_buf(serialize_response( - cmd_id, - builder, - msg::BaseArgs { - inner: Some(inner.as_union_value()), - inner_type: msg::Any::ResourcesRes, - ..Default::default() - }, - )) + Ok(JsonOp::Sync(json!(serialized_resources))) } diff --git a/cli/ops/timers.rs b/cli/ops/timers.rs index 550d91f2c..46217a188 100644 --- a/cli/ops/timers.rs +++ b/cli/ops/timers.rs @@ -1,12 +1,7 @@ // Copyright 2018-2019 the Deno authors. All rights reserved. MIT license. -use super::dispatch_flatbuffers::serialize_response; -use super::utils::empty_buf; -use super::utils::CliOpResult; -use crate::deno_error; -use crate::msg; +use super::dispatch_json::{Deserialize, JsonOp, Value}; use crate::state::ThreadSafeState; use deno::*; -use flatbuffers::FlatBufferBuilder; use futures::Future; use std; use std::time::Duration; @@ -14,50 +9,34 @@ use std::time::Instant; pub fn op_global_timer_stop( state: &ThreadSafeState, - base: &msg::Base<'_>, - data: Option<PinnedBuf>, -) -> CliOpResult { - if !base.sync() { - return Err(deno_error::no_async_support()); - } - assert!(data.is_none()); + _args: Value, + _zero_copy: Option<PinnedBuf>, +) -> Result<JsonOp, ErrBox> { let state = state; let mut t = state.global_timer.lock().unwrap(); t.cancel(); - Ok(Op::Sync(empty_buf())) + Ok(JsonOp::Sync(json!({}))) +} + +#[derive(Deserialize)] +struct GlobalTimerArgs { + timeout: u64, } pub fn op_global_timer( state: &ThreadSafeState, - base: &msg::Base<'_>, - data: Option<PinnedBuf>, -) -> CliOpResult { - if base.sync() { - return Err(deno_error::no_sync_support()); - } - assert!(data.is_none()); - let cmd_id = base.cmd_id(); - let inner = base.inner_as_global_timer().unwrap(); - let val = inner.timeout(); - assert!(val >= 0); + args: Value, + _zero_copy: Option<PinnedBuf>, +) -> Result<JsonOp, ErrBox> { + let args: GlobalTimerArgs = serde_json::from_value(args)?; + let val = args.timeout; let state = state; let mut t = state.global_timer.lock().unwrap(); let deadline = Instant::now() + Duration::from_millis(val as u64); - let f = t.new_timeout(deadline); + let f = t + .new_timeout(deadline) + .then(move |_| futures::future::ok(json!({}))); - Ok(Op::Async(Box::new(f.then(move |_| { - let builder = &mut FlatBufferBuilder::new(); - let inner = - msg::GlobalTimerRes::create(builder, &msg::GlobalTimerResArgs {}); - Ok(serialize_response( - cmd_id, - builder, - msg::BaseArgs { - inner: Some(inner.as_union_value()), - inner_type: msg::Any::GlobalTimerRes, - ..Default::default() - }, - )) - })))) + Ok(JsonOp::Async(Box::new(f))) } diff --git a/cli/ops/workers.rs b/cli/ops/workers.rs index 1eb11420f..4eeecd068 100644 --- a/cli/ops/workers.rs +++ b/cli/ops/workers.rs @@ -1,17 +1,12 @@ // Copyright 2018-2019 the Deno authors. All rights reserved. MIT license. -use super::dispatch_flatbuffers::serialize_response; -use super::utils::ok_buf; -use super::utils::CliOpResult; -use crate::deno_error; +use super::dispatch_json::{Deserialize, JsonOp, Value}; use crate::deno_error::DenoError; use crate::deno_error::ErrorKind; -use crate::msg; use crate::resources; use crate::startup_data; use crate::state::ThreadSafeState; use crate::worker::Worker; use deno::*; -use flatbuffers::FlatBufferBuilder; use futures; use futures::Async; use futures::Future; @@ -39,48 +34,32 @@ impl Future for GetMessageFuture { /// Get message from host as guest worker pub fn op_worker_get_message( state: &ThreadSafeState, - base: &msg::Base<'_>, - data: Option<PinnedBuf>, -) -> CliOpResult { - if base.sync() { - return Err(deno_error::no_sync_support()); - } - assert!(data.is_none()); - let cmd_id = base.cmd_id(); - + _args: Value, + _data: Option<PinnedBuf>, +) -> Result<JsonOp, ErrBox> { let op = GetMessageFuture { state: state.clone(), }; - let op = op.map_err(move |_| -> ErrBox { unimplemented!() }); - let op = op.and_then(move |maybe_buf| -> Result<Buf, ErrBox> { - debug!("op_worker_get_message"); - let builder = &mut FlatBufferBuilder::new(); - - let data = maybe_buf.as_ref().map(|buf| builder.create_vector(buf)); - let inner = msg::WorkerGetMessageRes::create( - builder, - &msg::WorkerGetMessageResArgs { data }, - ); - Ok(serialize_response( - cmd_id, - builder, - msg::BaseArgs { - inner: Some(inner.as_union_value()), - inner_type: msg::Any::WorkerGetMessageRes, - ..Default::default() - }, - )) - }); - Ok(Op::Async(Box::new(op))) + + let op = op + .map_err(move |_| -> ErrBox { unimplemented!() }) + .and_then(move |maybe_buf| { + debug!("op_worker_get_message"); + + futures::future::ok(json!({ + "data": maybe_buf.map(|buf| buf.to_owned()) + })) + }); + + Ok(JsonOp::Async(Box::new(op))) } /// Post message to host as guest worker pub fn op_worker_post_message( state: &ThreadSafeState, - base: &msg::Base<'_>, + _args: Value, data: Option<PinnedBuf>, -) -> CliOpResult { - let cmd_id = base.cmd_id(); +) -> Result<JsonOp, ErrBox> { let d = Vec::from(data.unwrap().as_ref()).into_boxed_slice(); let tx = { @@ -90,33 +69,34 @@ pub fn op_worker_post_message( tx.send(d) .wait() .map_err(|e| DenoError::new(ErrorKind::Other, e.to_string()))?; - let builder = &mut FlatBufferBuilder::new(); - - ok_buf(serialize_response( - cmd_id, - builder, - msg::BaseArgs { - ..Default::default() - }, - )) + + Ok(JsonOp::Sync(json!({}))) +} + +#[derive(Deserialize)] +#[serde(rename_all = "camelCase")] +struct CreateWorkerArgs { + specifier: String, + include_deno_namespace: bool, + has_source_code: bool, + source_code: String, } /// Create worker as the host pub fn op_create_worker( state: &ThreadSafeState, - base: &msg::Base<'_>, - data: Option<PinnedBuf>, -) -> CliOpResult { - assert!(data.is_none()); - let cmd_id = base.cmd_id(); - let inner = base.inner_as_create_worker().unwrap(); - let specifier = inner.specifier().unwrap(); + args: Value, + _data: Option<PinnedBuf>, +) -> Result<JsonOp, ErrBox> { + let args: CreateWorkerArgs = serde_json::from_value(args)?; + + let specifier = args.specifier.as_ref(); // Only include deno namespace if requested AND current worker // has included namespace (to avoid escalation). let include_deno_namespace = - inner.include_deno_namespace() && state.include_deno_namespace; - let has_source_code = inner.has_source_code(); - let source_code = inner.source_code().unwrap(); + args.include_deno_namespace && state.include_deno_namespace; + let has_source_code = args.has_source_code; + let source_code = args.source_code; let parent_state = state.clone(); @@ -150,24 +130,13 @@ pub fn op_create_worker( let exec_cb = move |worker: Worker| { let mut workers_tl = parent_state.workers.lock().unwrap(); workers_tl.insert(rid, worker.shared()); - let builder = &mut FlatBufferBuilder::new(); - let msg_inner = - msg::CreateWorkerRes::create(builder, &msg::CreateWorkerResArgs { rid }); - serialize_response( - cmd_id, - builder, - msg::BaseArgs { - inner: Some(msg_inner.as_union_value()), - inner_type: msg::Any::CreateWorkerRes, - ..Default::default() - }, - ) + json!(rid) }; // Has provided source code, execute immediately. if has_source_code { worker.execute(&source_code).unwrap(); - return ok_buf(exec_cb(worker)); + return Ok(JsonOp::Sync(exec_cb(worker))); } let op = worker @@ -175,22 +144,23 @@ pub fn op_create_worker( .and_then(move |()| Ok(exec_cb(worker))); let result = op.wait()?; - Ok(Op::Sync(result)) + Ok(JsonOp::Sync(result)) +} + +#[derive(Deserialize)] +struct HostGetWorkerClosedArgs { + rid: i32, } /// Return when the worker closes pub fn op_host_get_worker_closed( state: &ThreadSafeState, - base: &msg::Base<'_>, - data: Option<PinnedBuf>, -) -> CliOpResult { - if base.sync() { - return Err(deno_error::no_sync_support()); - } - assert!(data.is_none()); - let cmd_id = base.cmd_id(); - let inner = base.inner_as_host_get_worker_closed().unwrap(); - let rid = inner.rid(); + args: Value, + _data: Option<PinnedBuf>, +) -> Result<JsonOp, ErrBox> { + let args: HostGetWorkerClosedArgs = serde_json::from_value(args)?; + + let rid = args.rid as u32; let state = state.clone(); let shared_worker_future = { @@ -199,79 +169,58 @@ pub fn op_host_get_worker_closed( worker.clone() }; - let op = Box::new(shared_worker_future.then(move |_result| { - let builder = &mut FlatBufferBuilder::new(); - - Ok(serialize_response( - cmd_id, - builder, - msg::BaseArgs { - ..Default::default() - }, - )) - })); - Ok(Op::Async(Box::new(op))) + let op = Box::new( + shared_worker_future.then(move |_result| futures::future::ok(json!({}))), + ); + + Ok(JsonOp::Async(Box::new(op))) +} + +#[derive(Deserialize)] +struct HostGetMessageArgs { + rid: i32, } /// Get message from guest worker as host pub fn op_host_get_message( _state: &ThreadSafeState, - base: &msg::Base<'_>, - data: Option<PinnedBuf>, -) -> CliOpResult { - if base.sync() { - return Err(deno_error::no_sync_support()); - } - assert!(data.is_none()); - let cmd_id = base.cmd_id(); - let inner = base.inner_as_host_get_message().unwrap(); - let rid = inner.rid(); - - let op = resources::get_message_from_worker(rid); - let op = op.map_err(move |_| -> ErrBox { unimplemented!() }); - let op = op.and_then(move |maybe_buf| -> Result<Buf, ErrBox> { - let builder = &mut FlatBufferBuilder::new(); - - let data = maybe_buf.as_ref().map(|buf| builder.create_vector(buf)); - let msg_inner = msg::HostGetMessageRes::create( - builder, - &msg::HostGetMessageResArgs { data }, - ); - Ok(serialize_response( - cmd_id, - builder, - msg::BaseArgs { - inner: Some(msg_inner.as_union_value()), - inner_type: msg::Any::HostGetMessageRes, - ..Default::default() - }, - )) - }); - Ok(Op::Async(Box::new(op))) + args: Value, + _data: Option<PinnedBuf>, +) -> Result<JsonOp, ErrBox> { + let args: HostGetMessageArgs = serde_json::from_value(args)?; + + let rid = args.rid as u32; + let op = resources::get_message_from_worker(rid) + .map_err(move |_| -> ErrBox { unimplemented!() }) + .and_then(move |maybe_buf| { + futures::future::ok(json!({ + "data": maybe_buf.map(|buf| buf.to_owned()) + })) + }); + + Ok(JsonOp::Async(Box::new(op))) +} + +#[derive(Deserialize)] +struct HostPostMessageArgs { + rid: i32, } /// Post message to guest worker as host pub fn op_host_post_message( _state: &ThreadSafeState, - base: &msg::Base<'_>, + args: Value, data: Option<PinnedBuf>, -) -> CliOpResult { - let cmd_id = base.cmd_id(); - let inner = base.inner_as_host_post_message().unwrap(); - let rid = inner.rid(); +) -> Result<JsonOp, ErrBox> { + let args: HostPostMessageArgs = serde_json::from_value(args)?; + + let rid = args.rid as u32; let d = Vec::from(data.unwrap().as_ref()).into_boxed_slice(); resources::post_message_to_worker(rid, d) .wait() .map_err(|e| DenoError::new(ErrorKind::Other, e.to_string()))?; - let builder = &mut FlatBufferBuilder::new(); - - ok_buf(serialize_response( - cmd_id, - builder, - msg::BaseArgs { - ..Default::default() - }, - )) + + Ok(JsonOp::Sync(json!({}))) } diff --git a/js/compiler.ts b/js/compiler.ts index 7519c5115..5399d59ad 100644 --- a/js/compiler.ts +++ b/js/compiler.ts @@ -7,9 +7,11 @@ import { Console } from "./console"; import { core } from "./core"; import { Diagnostic, fromTypeScriptDiagnostic } from "./diagnostics"; import { cwd } from "./dir"; -import { sendSync, msg, flatbuffers } from "./dispatch_flatbuffers"; +import * as dispatch from "./dispatch"; +import { sendSync } from "./dispatch_json"; +import { msg } from "./dispatch_flatbuffers"; import * as os from "./os"; -import { TextDecoder, TextEncoder } from "./text_encoding"; +import { TextEncoder } from "./text_encoding"; import { getMappedModuleName, parseTypeDirectives } from "./type_directives"; import { assert, notImplemented } from "./util"; import * as util from "./util"; @@ -121,35 +123,15 @@ interface EmitResult { /** Ops to Rust to resolve and fetch a modules meta data. */ function fetchSourceFile(specifier: string, referrer: string): SourceFile { - util.log("fetchSourceFile", { specifier, referrer }); - // Send FetchSourceFile message - const builder = flatbuffers.createBuilder(); - const specifier_ = builder.createString(specifier); - const referrer_ = builder.createString(referrer); - const inner = msg.FetchSourceFile.createFetchSourceFile( - builder, - specifier_, - referrer_ - ); - const baseRes = sendSync(builder, msg.Any.FetchSourceFile, inner); - assert(baseRes != null); - assert( - msg.Any.FetchSourceFileRes === baseRes!.innerType(), - `base.innerType() unexpectedly is ${baseRes!.innerType()}` - ); - const fetchSourceFileRes = new msg.FetchSourceFileRes(); - assert(baseRes!.inner(fetchSourceFileRes) != null); - const dataArray = fetchSourceFileRes.dataArray(); - const decoder = new TextDecoder(); - const sourceCode = dataArray ? decoder.decode(dataArray) : undefined; - // flatbuffers returns `null` for an empty value, this does not fit well with - // idiomatic TypeScript under strict null checks, so converting to `undefined` + util.log("compiler.fetchSourceFile", { specifier, referrer }); + const res = sendSync(dispatch.OP_FETCH_SOURCE_FILE, { + specifier, + referrer + }); + return { - moduleName: fetchSourceFileRes.moduleName() || undefined, - filename: fetchSourceFileRes.filename() || undefined, - mediaType: fetchSourceFileRes.mediaType(), - sourceCode, - typeDirectives: parseTypeDirectives(sourceCode) + ...res, + typeDirectives: parseTypeDirectives(res.sourceCode) }; } @@ -171,19 +153,7 @@ function humanFileSize(bytes: number): string { /** Ops to rest for caching source map and compiled js */ function cache(extension: string, moduleId: string, contents: string): void { - util.log("cache", extension, moduleId); - const builder = flatbuffers.createBuilder(); - const extension_ = builder.createString(extension); - const moduleId_ = builder.createString(moduleId); - const contents_ = builder.createString(contents); - const inner = msg.Cache.createCache( - builder, - extension_, - moduleId_, - contents_ - ); - const baseRes = sendSync(builder, msg.Any.Cache, inner); - assert(baseRes == null); + sendSync(dispatch.OP_CACHE, { extension, moduleId, contents }); } const encoder = new TextEncoder(); diff --git a/js/dispatch.ts b/js/dispatch.ts index 0c5c59553..6c7551441 100644 --- a/js/dispatch.ts +++ b/js/dispatch.ts @@ -12,6 +12,40 @@ export const OP_IS_TTY = 4; export const OP_ENV = 5; export const OP_EXEC_PATH = 6; export const OP_UTIME = 7; +export const OP_SET_ENV = 8; +export const OP_HOME_DIR = 9; +export const OP_START = 10; +export const OP_APPLY_SOURCE_MAP = 11; +export const OP_FORMAT_ERROR = 12; +export const OP_CACHE = 13; +export const OP_FETCH_SOURCE_FILE = 14; +export const OP_OPEN = 15; +export const OP_CLOSE = 16; +export const OP_SEEK = 17; +export const OP_FETCH = 18; +export const OP_METRICS = 19; +export const OP_REPL_START = 20; +export const OP_REPL_READLINE = 21; +export const OP_ACCEPT = 22; +export const OP_DIAL = 23; +export const OP_SHUTDOWN = 24; +export const OP_LISTEN = 25; +export const OP_RESOURCES = 26; +export const OP_GET_RANDOM_VALUES = 27; +export const OP_GLOBAL_TIMER_STOP = 28; +export const OP_GLOBAL_TIMER = 29; +export const OP_NOW = 30; +export const OP_PERMISSIONS = 31; +export const OP_REVOKE_PERMISSION = 32; +export const OP_CREATE_WORKER = 33; +export const OP_HOST_GET_WORKER_CLOSED = 34; +export const OP_HOST_POST_MESSAGE = 35; +export const OP_HOST_GET_MESSAGE = 36; +export const OP_WORKER_POST_MESSAGE = 37; +export const OP_WORKER_GET_MESSAGE = 38; +export const OP_RUN = 39; +export const OP_RUN_STATUS = 40; +export const OP_KILL = 41; export function asyncMsgFromRust(opId: number, ui8: Uint8Array): void { switch (opId) { @@ -22,10 +56,26 @@ export function asyncMsgFromRust(opId: number, ui8: Uint8Array): void { case OP_READ: minimal.asyncMsgFromRust(opId, ui8); break; + case OP_EXIT: + case OP_IS_TTY: + case OP_ENV: + case OP_EXEC_PATH: case OP_UTIME: + case OP_OPEN: + case OP_SEEK: + case OP_FETCH: + case OP_REPL_START: + case OP_REPL_READLINE: + case OP_ACCEPT: + case OP_DIAL: + case OP_GLOBAL_TIMER: + case OP_HOST_GET_WORKER_CLOSED: + case OP_HOST_GET_MESSAGE: + case OP_WORKER_GET_MESSAGE: + case OP_RUN_STATUS: json.asyncMsgFromRust(opId, ui8); break; default: - throw Error("bad opId"); + throw Error("bad async opId"); } } diff --git a/js/error_stack.ts b/js/error_stack.ts index 003717a72..7d41b9cf4 100644 --- a/js/error_stack.ts +++ b/js/error_stack.ts @@ -1,8 +1,8 @@ // Copyright 2018-2019 the Deno authors. All rights reserved. MIT license. // Some of the code here is adapted directly from V8 and licensed under a BSD // style license available here: https://github.com/v8/v8/blob/24886f2d1c565287d33d71e4109a53bf0b54b75c/LICENSE.v8 - -import { sendSync, msg, flatbuffers } from "./dispatch_flatbuffers"; +import * as dispatch from "./dispatch"; +import { sendSync } from "./dispatch_json"; import { assert } from "./util"; export interface Location { @@ -17,40 +17,6 @@ export interface Location { column: number; } -function req( - filename: string, - line: number, - column: number -): [flatbuffers.Builder, msg.Any.ApplySourceMap, flatbuffers.Offset] { - const builder = flatbuffers.createBuilder(); - const filename_ = builder.createString(filename); - const inner = msg.ApplySourceMap.createApplySourceMap( - builder, - filename_, - // On this side, line/column are 1 based, but in the source maps, they are - // 0 based, so we have to convert back and forth - line - 1, - column - 1 - ); - return [builder, msg.Any.ApplySourceMap, inner]; -} - -function res(baseRes: msg.Base | null): Location { - assert(baseRes != null); - assert(baseRes!.innerType() === msg.Any.ApplySourceMap); - const res = new msg.ApplySourceMap(); - assert(baseRes!.inner(res) != null); - const filename = res.filename()!; - assert(filename != null); - return { - filename, - // On this side, line/column are 1 based, but in the source maps, they are - // 0 based, so we have to convert back and forth - line: res.line() + 1, - column: res.column() + 1 - }; -} - /** Given a current location in a module, lookup the source location and * return it. * @@ -75,7 +41,18 @@ function res(baseRes: msg.Base | null): Location { */ export function applySourceMap(location: Location): Location { const { filename, line, column } = location; - return res(sendSync(...req(filename, line, column))); + // On this side, line/column are 1 based, but in the source maps, they are + // 0 based, so we have to convert back and forth + const res = sendSync(dispatch.OP_APPLY_SOURCE_MAP, { + filename, + line: line - 1, + column: column - 1 + }); + return { + filename: res.filename, + line: res.line + 1, + column: res.column + 1 + }; } /** Mutate the call site so that it returns the location, instead of its diff --git a/js/fetch.ts b/js/fetch.ts index 505da218c..317239630 100644 --- a/js/fetch.ts +++ b/js/fetch.ts @@ -1,6 +1,5 @@ // Copyright 2018-2019 the Deno authors. All rights reserved. MIT license. import { assert, createResolvable, notImplemented, isTypedArray } from "./util"; -import { sendAsync, msg, flatbuffers } from "./dispatch_flatbuffers"; import * as domTypes from "./dom_types"; import { TextDecoder, TextEncoder } from "./text_encoding"; import { DenoBlob, bytesSymbol as blobBytesSymbol } from "./blob"; @@ -10,6 +9,8 @@ import { read, close } from "./files"; import { Buffer } from "./buffer"; import { FormData } from "./form_data"; import { URLSearchParams } from "./url_search_params"; +import * as dispatch from "./dispatch"; +import { sendAsync } from "./dispatch_json"; function getHeaderValueParams(value: string): Map<string, string> { const params = new Map(); @@ -320,67 +321,35 @@ export class Response implements domTypes.Response { } } -function msgHttpRequest( - builder: flatbuffers.Builder, - url: string, - method: null | string, - headers: null | domTypes.Headers -): flatbuffers.Offset { - const methodOffset = !method ? 0 : builder.createString(method); - let fieldsOffset: flatbuffers.Offset = 0; - const urlOffset = builder.createString(url); - if (headers) { - const kvOffsets: flatbuffers.Offset[] = []; - for (const [key, val] of headers.entries()) { - const keyOffset = builder.createString(key); - const valOffset = builder.createString(val); - kvOffsets.push( - msg.KeyValue.createKeyValue(builder, keyOffset, valOffset) - ); - } - fieldsOffset = msg.HttpHeader.createFieldsVector(builder, kvOffsets); - } else { - } - return msg.HttpHeader.createHttpHeader( - builder, - true, - methodOffset, - urlOffset, - 0, - fieldsOffset - ); -} - -function deserializeHeaderFields(m: msg.HttpHeader): Array<[string, string]> { - const out: Array<[string, string]> = []; - for (let i = 0; i < m.fieldsLength(); i++) { - const item = m.fields(i)!; - out.push([item.key()!, item.value()!]); - } - return out; +interface FetchResponse { + bodyRid: number; + status: number; + headers: Array<[string, string]>; } -async function getFetchRes( +async function sendFetchReq( url: string, method: string | null, headers: domTypes.Headers | null, body: ArrayBufferView | undefined -): Promise<msg.FetchRes> { - // Send Fetch message - const builder = flatbuffers.createBuilder(); - const headerOff = msgHttpRequest(builder, url, method, headers); - const resBase = await sendAsync( - builder, - msg.Any.Fetch, - msg.Fetch.createFetch(builder, headerOff), - body - ); - - // Decode FetchRes - assert(msg.Any.FetchRes === resBase.innerType()); - const inner = new msg.FetchRes(); - assert(resBase.inner(inner) != null); - return inner; +): Promise<FetchResponse> { + let headerArray: Array<[string, string]> = []; + if (headers) { + headerArray = Array.from(headers.entries()); + } + + let zeroCopy = undefined; + if (body) { + zeroCopy = new Uint8Array(body.buffer, body.byteOffset, body.byteLength); + } + + const args = { + method, + url, + headers: headerArray + }; + + return (await sendAsync(dispatch.OP_FETCH, args, zeroCopy)) as FetchResponse; } /** Fetch a resource from the network. */ @@ -448,20 +417,13 @@ export async function fetch( } while (remRedirectCount) { - const inner = await getFetchRes(url, method, headers, body); - - const header = inner.header()!; - const bodyRid = inner.bodyRid(); - assert(!header.isRequest()); - const status = header.status(); - - const headersList = deserializeHeaderFields(header); + const fetchResponse = await sendFetchReq(url, method, headers, body); const response = new Response( url, - status, - headersList, - bodyRid, + fetchResponse.status, + fetchResponse.headers, + fetchResponse.bodyRid, redirected ); if ([301, 302, 303, 307, 308].includes(response.status)) { diff --git a/js/files.ts b/js/files.ts index 6f0e523c9..4eff17aac 100644 --- a/js/files.ts +++ b/js/files.ts @@ -12,37 +12,22 @@ import { } from "./io"; import { sendAsyncMinimal } from "./dispatch_minimal"; import { assert } from "./util"; -import { sendAsync, sendSync, msg, flatbuffers } from "./dispatch_flatbuffers"; +import * as dispatch from "./dispatch"; +import { + sendSync as sendSyncJson, + sendAsync as sendAsyncJson +} from "./dispatch_json"; +import { sendSync, msg, flatbuffers } from "./dispatch_flatbuffers"; import { OP_READ, OP_WRITE } from "./dispatch"; -function reqOpen( - filename: string, - mode: OpenMode -): [flatbuffers.Builder, msg.Any, flatbuffers.Offset] { - const builder = flatbuffers.createBuilder(); - const filename_ = builder.createString(filename); - const mode_ = builder.createString(mode); - const inner = msg.Open.createOpen(builder, filename_, 0, mode_); - return [builder, msg.Any.Open, inner]; -} - -function resOpen(baseRes: null | msg.Base): File { - assert(baseRes != null); - assert(msg.Any.OpenRes === baseRes!.innerType()); - const res = new msg.OpenRes(); - assert(baseRes!.inner(res) != null); - const rid = res.rid(); - // eslint-disable-next-line @typescript-eslint/no-use-before-define - return new File(rid); -} - /** Open a file and return an instance of the `File` object * synchronously. * * const file = Deno.openSync("/foo/bar.txt"); */ export function openSync(filename: string, mode: OpenMode = "r"): File { - return resOpen(sendSync(...reqOpen(filename, mode))); + const rid = sendSyncJson(dispatch.OP_OPEN, { filename, mode }); + return new File(rid); } /** Open a file and return an instance of the `File` object. @@ -55,7 +40,8 @@ export async function open( filename: string, mode: OpenMode = "r" ): Promise<File> { - return resOpen(await sendAsync(...reqOpen(filename, mode))); + const rid = await sendAsyncJson(dispatch.OP_OPEN, { filename, mode }); + return new File(rid); } function reqRead( @@ -165,23 +151,13 @@ export async function write(rid: number, p: Uint8Array): Promise<number> { } } -function reqSeek( - rid: number, - offset: number, - whence: SeekMode -): [flatbuffers.Builder, msg.Any, flatbuffers.Offset] { - const builder = flatbuffers.createBuilder(); - const inner = msg.Seek.createSeek(builder, rid, offset, whence); - return [builder, msg.Any.Seek, inner]; -} - /** Seek a file ID synchronously to the given offset under mode given by `whence`. * * const file = Deno.openSync("/foo/bar.txt"); * Deno.seekSync(file.rid, 0, 0); */ export function seekSync(rid: number, offset: number, whence: SeekMode): void { - sendSync(...reqSeek(rid, offset, whence)); + sendSyncJson(dispatch.OP_SEEK, { rid, offset, whence }); } /** Seek a file ID to the given offset under mode given by `whence`. @@ -196,14 +172,12 @@ export async function seek( offset: number, whence: SeekMode ): Promise<void> { - await sendAsync(...reqSeek(rid, offset, whence)); + await sendAsyncJson(dispatch.OP_SEEK, { rid, offset, whence }); } /** Close the file ID. */ export function close(rid: number): void { - const builder = flatbuffers.createBuilder(); - const inner = msg.Close.createClose(builder, rid); - sendSync(builder, msg.Any.Close, inner); + sendSyncJson(dispatch.OP_CLOSE, { rid }); } /** The Deno abstraction for reading and writing files. */ diff --git a/js/format_error.ts b/js/format_error.ts index 6670b05e2..dde0f6a58 100644 --- a/js/format_error.ts +++ b/js/format_error.ts @@ -1,17 +1,9 @@ // Copyright 2018-2019 the Deno authors. All rights reserved. MIT license. -import { sendSync, msg, flatbuffers } from "./dispatch_flatbuffers"; -import { assert } from "./util"; +import * as dispatch from "./dispatch"; +import { sendSync } from "./dispatch_json"; +// TODO(bartlomieju): move to `repl.ts`? export function formatError(errString: string): string { - const builder = flatbuffers.createBuilder(); - const errString_ = builder.createString(errString); - const offset = msg.FormatError.createFormatError(builder, errString_); - const baseRes = sendSync(builder, msg.Any.FormatError, offset); - assert(baseRes != null); - assert(msg.Any.FormatErrorRes === baseRes!.innerType()); - const formatErrorResMsg = new msg.FormatErrorRes(); - assert(baseRes!.inner(formatErrorResMsg) != null); - const formattedError = formatErrorResMsg.error(); - assert(formatError != null); - return formattedError!; + const res = sendSync(dispatch.OP_FORMAT_ERROR, { error: errString }); + return res.error; } diff --git a/js/get_random_values.ts b/js/get_random_values.ts index d5c0828c5..154e77f75 100644 --- a/js/get_random_values.ts +++ b/js/get_random_values.ts @@ -1,15 +1,8 @@ // Copyright 2018-2019 the Deno authors. All rights reserved. MIT license. -import { sendSync, msg, flatbuffers } from "./dispatch_flatbuffers"; +import * as dispatch from "./dispatch"; +import { sendSync } from "./dispatch_json"; import { assert } from "./util"; -function req( - typedArray: ArrayBufferView -): [flatbuffers.Builder, msg.Any, flatbuffers.Offset, ArrayBufferView] { - const builder = flatbuffers.createBuilder(); - const inner = msg.GetRandomValues.createGetRandomValues(builder); - return [builder, msg.Any.GetRandomValues, inner, typedArray]; -} - /** Synchronously collects cryptographically secure random values. The * underlying CSPRNG in use is Rust's `rand::rngs::ThreadRng`. * @@ -28,6 +21,11 @@ export function getRandomValues< >(typedArray: T): T { assert(typedArray !== null, "Input must not be null"); assert(typedArray.length <= 65536, "Input must not be longer than 65536"); - sendSync(...req(typedArray as ArrayBufferView)); + const ui8 = new Uint8Array( + typedArray.buffer, + typedArray.byteOffset, + typedArray.byteLength + ); + sendSync(dispatch.OP_GET_RANDOM_VALUES, {}, ui8); return typedArray; } diff --git a/js/main.ts b/js/main.ts index 769f522a6..25e27b69f 100644 --- a/js/main.ts +++ b/js/main.ts @@ -22,12 +22,12 @@ export default function denoMain( preserveDenoNamespace: boolean = true, name?: string ): void { - const startResMsg = os.start(preserveDenoNamespace, name); + const s = os.start(preserveDenoNamespace, name); - setVersions(startResMsg.denoVersion()!, startResMsg.v8Version()!); + setVersions(s.denoVersion, s.v8Version); // handle `--version` - if (startResMsg.versionFlag()) { + if (s.versionFlag) { console.log("deno:", deno.version.deno); console.log("v8:", deno.version.v8); console.log("typescript:", deno.version.typescript); @@ -36,24 +36,22 @@ export default function denoMain( setPrepareStackTrace(Error); - const mainModule = startResMsg.mainModule(); - if (mainModule) { - assert(mainModule.length > 0); - setLocation(mainModule); + if (s.mainModule) { + assert(s.mainModule.length > 0); + setLocation(s.mainModule); } - const cwd = startResMsg.cwd(); - log("cwd", cwd); + log("cwd", s.cwd); - for (let i = 1; i < startResMsg.argvLength(); i++) { - args.push(startResMsg.argv(i)); + for (let i = 1; i < s.argv.length; i++) { + args.push(s.argv[i]); } log("args", args); Object.freeze(args); if (window["_xevalWrapper"] !== undefined) { - xevalMain(window["_xevalWrapper"] as XevalFunc, startResMsg.xevalDelim()); - } else if (!mainModule) { + xevalMain(window["_xevalWrapper"] as XevalFunc, s.xevalDelim); + } else if (!s.mainModule) { replLoop(); } } diff --git a/js/metrics.ts b/js/metrics.ts index e93e9528c..48e3102e5 100644 --- a/js/metrics.ts +++ b/js/metrics.ts @@ -1,6 +1,6 @@ // Copyright 2018-2019 the Deno authors. All rights reserved. MIT license. -import { assert } from "./util"; -import { sendSync, msg, flatbuffers } from "./dispatch_flatbuffers"; +import * as dispatch from "./dispatch"; +import { sendSync } from "./dispatch_json"; export interface Metrics { opsDispatched: number; @@ -10,27 +10,6 @@ export interface Metrics { bytesReceived: number; } -function req(): [flatbuffers.Builder, msg.Any, flatbuffers.Offset] { - const builder = flatbuffers.createBuilder(); - const inner = msg.Metrics.createMetrics(builder); - return [builder, msg.Any.Metrics, inner]; -} - -function res(baseRes: null | msg.Base): Metrics { - assert(baseRes !== null); - assert(msg.Any.MetricsRes === baseRes!.innerType()); - const res = new msg.MetricsRes(); - assert(baseRes!.inner(res) !== null); - - return { - opsDispatched: res.opsDispatched().toFloat64(), - opsCompleted: res.opsCompleted().toFloat64(), - bytesSentControl: res.bytesSentControl().toFloat64(), - bytesSentData: res.bytesSentData().toFloat64(), - bytesReceived: res.bytesReceived().toFloat64() - }; -} - /** Receive metrics from the privileged side of Deno. * * > console.table(Deno.metrics()) @@ -45,5 +24,5 @@ function res(baseRes: null | msg.Base): Metrics { * └──────────────────┴────────┘ */ export function metrics(): Metrics { - return res(sendSync(...req())); + return sendSync(dispatch.OP_METRICS); } @@ -1,8 +1,9 @@ // Copyright 2018-2019 the Deno authors. All rights reserved. MIT license. import { EOF, Reader, Writer, Closer } from "./io"; -import { assert, notImplemented } from "./util"; -import { sendSync, sendAsync, msg, flatbuffers } from "./dispatch_flatbuffers"; +import { notImplemented } from "./util"; import { read, write, close } from "./files"; +import * as dispatch from "./dispatch"; +import { sendSync, sendAsync } from "./dispatch_json"; export type Network = "tcp"; // TODO support other types: @@ -36,10 +37,7 @@ enum ShutdownMode { } function shutdown(rid: number, how: ShutdownMode): void { - const builder = flatbuffers.createBuilder(); - const inner = msg.Shutdown.createShutdown(builder, rid, how); - const baseRes = sendSync(builder, msg.Any.Shutdown, inner); - assert(baseRes == null); + sendSync(dispatch.OP_SHUTDOWN, { rid, how }); } class ConnImpl implements Conn { @@ -80,14 +78,9 @@ class ListenerImpl implements Listener { constructor(readonly rid: number) {} async accept(): Promise<Conn> { - const builder = flatbuffers.createBuilder(); - const inner = msg.Accept.createAccept(builder, this.rid); - const baseRes = await sendAsync(builder, msg.Any.Accept, inner); - assert(baseRes != null); - assert(msg.Any.NewConn === baseRes!.innerType()); - const res = new msg.NewConn(); - assert(baseRes!.inner(res) != null); - return new ConnImpl(res.rid(), res.remoteAddr()!, res.localAddr()!); + const res = await sendAsync(dispatch.OP_ACCEPT, { rid: this.rid }); + // TODO(bartlomieju): add remoteAddr and localAddr on Rust side + return new ConnImpl(res.rid, res.remoteAddr!, res.localAddr!); } close(): void { @@ -143,16 +136,8 @@ export interface Conn extends Reader, Writer, Closer { * See `dial()` for a description of the network and address parameters. */ export function listen(network: Network, address: string): Listener { - const builder = flatbuffers.createBuilder(); - const network_ = builder.createString(network); - const address_ = builder.createString(address); - const inner = msg.Listen.createListen(builder, network_, address_); - const baseRes = sendSync(builder, msg.Any.Listen, inner); - assert(baseRes != null); - assert(msg.Any.ListenRes === baseRes!.innerType()); - const res = new msg.ListenRes(); - assert(baseRes!.inner(res) != null); - return new ListenerImpl(res.rid()); + const rid = sendSync(dispatch.OP_LISTEN, { network, address }); + return new ListenerImpl(rid); } /** Dial connects to the address on the named network. @@ -183,16 +168,9 @@ export function listen(network: Network, address: string): Listener { * dial("tcp", ":80") */ export async function dial(network: Network, address: string): Promise<Conn> { - const builder = flatbuffers.createBuilder(); - const network_ = builder.createString(network); - const address_ = builder.createString(address); - const inner = msg.Dial.createDial(builder, network_, address_); - const baseRes = await sendAsync(builder, msg.Any.Dial, inner); - assert(baseRes != null); - assert(msg.Any.NewConn === baseRes!.innerType()); - const res = new msg.NewConn(); - assert(baseRes!.inner(res) != null); - return new ConnImpl(res.rid(), res.remoteAddr()!, res.localAddr()!); + const res = await sendAsync(dispatch.OP_DIAL, { network, address }); + // TODO(bartlomieju): add remoteAddr and localAddr on Rust side + return new ConnImpl(res.rid, res.remoteAddr!, res.localAddr!); } /** **RESERVED** */ @@ -1,8 +1,7 @@ // Copyright 2018-2019 the Deno authors. All rights reserved. MIT license. import { core } from "./core"; import * as dispatch from "./dispatch"; -import { sendSync, msg, flatbuffers } from "./dispatch_flatbuffers"; -import * as dispatchJson from "./dispatch_json"; +import { sendSync } from "./dispatch_json"; import { assert } from "./util"; import * as util from "./util"; import { window } from "./window"; @@ -24,21 +23,17 @@ function setGlobals(pid_: number, noColor_: boolean): void { * console.log(Deno.isTTY().stdout); */ export function isTTY(): { stdin: boolean; stdout: boolean; stderr: boolean } { - return dispatchJson.sendSync(dispatch.OP_IS_TTY); + return sendSync(dispatch.OP_IS_TTY); } /** Exit the Deno process with optional exit code. */ export function exit(code = 0): never { - dispatchJson.sendSync(dispatch.OP_EXIT, { code }); + sendSync(dispatch.OP_EXIT, { code }); return util.unreachable(); } function setEnv(key: string, value: string): void { - const builder = flatbuffers.createBuilder(); - const key_ = builder.createString(key); - const value_ = builder.createString(value); - const inner = msg.SetEnv.createSetEnv(builder, key_, value_); - sendSync(builder, msg.Any.SetEnv, inner); + sendSync(dispatch.OP_SET_ENV, { key, value }); } /** Returns a snapshot of the environment variables at invocation. Mutating a @@ -53,7 +48,7 @@ function setEnv(key: string, value: string): void { * console.log(myEnv.TEST_VAR == newEnv.TEST_VAR); */ export function env(): { [index: string]: string } { - const env = dispatchJson.sendSync(dispatch.OP_ENV); + const env = sendSync(dispatch.OP_ENV); return new Proxy(env, { set(obj, prop: string, value: string): boolean { setEnv(prop, value); @@ -62,35 +57,35 @@ export function env(): { [index: string]: string } { }); } -/** Send to the privileged side that we have setup and are ready. */ -function sendStart(): msg.StartRes { - const builder = flatbuffers.createBuilder(); - const startOffset = msg.Start.createStart(builder, 0 /* unused */); - const baseRes = sendSync(builder, msg.Any.Start, startOffset); - assert(baseRes != null); - assert(msg.Any.StartRes === baseRes!.innerType()); - const startResMsg = new msg.StartRes(); - assert(baseRes!.inner(startResMsg) != null); - return startResMsg; +interface Start { + cwd: string; + pid: number; + argv: string[]; + mainModule: string; // Absolute URL. + debugFlag: boolean; + depsFlag: boolean; + typesFlag: boolean; + versionFlag: boolean; + denoVersion: string; + v8Version: string; + noColor: boolean; + xevalDelim: string; } // This function bootstraps an environment within Deno, it is shared both by // the runtime and the compiler environments. // @internal -export function start( - preserveDenoNamespace = true, - source?: string -): msg.StartRes { +export function start(preserveDenoNamespace = true, source?: string): Start { core.setAsyncHandler(dispatch.asyncMsgFromRust); // First we send an empty `Start` message to let the privileged side know we // are ready. The response should be a `StartRes` message containing the CLI // args and other info. - const startResMsg = sendStart(); + const s = sendSync(dispatch.OP_START); - util.setLogDebug(startResMsg.debugFlag(), source); + util.setLogDebug(s.debugFlag, source); - setGlobals(startResMsg.pid(), startResMsg.noColor()); + setGlobals(s.pid, s.noColor); if (preserveDenoNamespace) { util.immutableDefine(window, "Deno", window.Deno); @@ -105,7 +100,7 @@ export function start( assert(window.Deno === undefined); } - return startResMsg; + return s; } /** @@ -113,18 +108,10 @@ export function start( * Requires the `--allow-env` flag. */ export function homeDir(): string { - const builder = flatbuffers.createBuilder(); - const inner = msg.HomeDir.createHomeDir(builder); - const baseRes = sendSync(builder, msg.Any.HomeDir, inner)!; - assert(msg.Any.HomeDirRes === baseRes.innerType()); - const res = new msg.HomeDirRes(); - assert(baseRes.inner(res) != null); - const path = res.path(); - + const path = sendSync(dispatch.OP_HOME_DIR); if (!path) { throw new Error("Could not get home directory."); } - return path; } @@ -133,5 +120,5 @@ export function homeDir(): string { * Requires the `--allow-env` flag. */ export function execPath(): string { - return dispatchJson.sendSync(dispatch.OP_EXEC_PATH); + return sendSync(dispatch.OP_EXEC_PATH); } diff --git a/js/performance.ts b/js/performance.ts index 7aaa7ae45..d2f339c46 100644 --- a/js/performance.ts +++ b/js/performance.ts @@ -1,6 +1,11 @@ // Copyright 2018-2019 the Deno authors. All rights reserved. MIT license. -import { sendSync, msg, flatbuffers } from "./dispatch_flatbuffers"; -import { assert } from "./util"; +import * as dispatch from "./dispatch"; +import { sendSync } from "./dispatch_json"; + +interface NowResponse { + seconds: number; + subsecNanos: number; +} export class Performance { /** Returns a current time from Deno's start in milliseconds. @@ -11,12 +16,7 @@ export class Performance { * console.log(`${t} ms since start!`); */ now(): number { - const builder = flatbuffers.createBuilder(); - const inner = msg.Now.createNow(builder); - const baseRes = sendSync(builder, msg.Any.Now, inner)!; - assert(msg.Any.NowRes === baseRes.innerType()); - const res = new msg.NowRes(); - assert(baseRes.inner(res) != null); - return res.seconds().toFloat64() * 1e3 + res.subsecNanos() / 1e6; + const res = sendSync(dispatch.OP_NOW) as NowResponse; + return res.seconds * 1e3 + res.subsecNanos / 1e6; } } diff --git a/js/permissions.ts b/js/permissions.ts index 822ae8cbd..bc969f3a8 100644 --- a/js/permissions.ts +++ b/js/permissions.ts @@ -1,6 +1,6 @@ // Copyright 2018-2019 the Deno authors. All rights reserved. MIT license. -import { sendSync, msg, flatbuffers } from "./dispatch_flatbuffers"; -import { assert } from "./util"; +import * as dispatch from "./dispatch"; +import { sendSync } from "./dispatch_json"; /** Permissions as granted by the caller */ export interface Permissions { @@ -15,23 +15,6 @@ export interface Permissions { export type Permission = keyof Permissions; -function getReq(): [flatbuffers.Builder, msg.Any, flatbuffers.Offset] { - const builder = flatbuffers.createBuilder(); - const inner = msg.Permissions.createPermissions(builder); - return [builder, msg.Any.Permissions, inner]; -} - -function createPermissions(inner: msg.PermissionsRes): Permissions { - return { - read: inner.read(), - write: inner.write(), - net: inner.net(), - env: inner.env(), - run: inner.run(), - hrtime: inner.hrtime() - }; -} - /** Inspect granted permissions for the current program. * * if (Deno.permissions().read) { @@ -40,24 +23,7 @@ function createPermissions(inner: msg.PermissionsRes): Permissions { * } */ export function permissions(): Permissions { - const baseRes = sendSync(...getReq())!; - assert(msg.Any.PermissionsRes === baseRes.innerType()); - const res = new msg.PermissionsRes(); - assert(baseRes.inner(res) != null); - // TypeScript cannot track assertion above, therefore not null assertion - return createPermissions(res); -} - -function revokeReq( - permission: string -): [flatbuffers.Builder, msg.Any, flatbuffers.Offset] { - const builder = flatbuffers.createBuilder(); - const permission_ = builder.createString(permission); - const inner = msg.PermissionRevoke.createPermissionRevoke( - builder, - permission_ - ); - return [builder, msg.Any.PermissionRevoke, inner]; + return sendSync(dispatch.OP_PERMISSIONS) as Permissions; } /** Revoke a permission. When the permission was already revoked nothing changes @@ -69,5 +35,5 @@ function revokeReq( * Deno.readFile("example.test"); // -> error or permission prompt */ export function revokePermission(permission: Permission): void { - sendSync(...revokeReq(permission)); + sendSync(dispatch.OP_REVOKE_PERMISSION, { permission }); } diff --git a/js/process.ts b/js/process.ts index b2b6d4734..dd4f70103 100644 --- a/js/process.ts +++ b/js/process.ts @@ -1,6 +1,6 @@ // Copyright 2018-2019 the Deno authors. All rights reserved. MIT license. -import { sendSync, sendAsync, msg, flatbuffers } from "./dispatch_flatbuffers"; - +import { sendSync, sendAsync } from "./dispatch_json"; +import * as dispatch from "./dispatch"; import { File, close } from "./files"; import { ReadCloser, WriteCloser } from "./io"; import { readAll } from "./buffer"; @@ -31,21 +31,22 @@ export interface RunOptions { stdin?: ProcessStdio | number; } -async function runStatus(rid: number): Promise<ProcessStatus> { - const builder = flatbuffers.createBuilder(); - const inner = msg.RunStatus.createRunStatus(builder, rid); +interface RunStatusResponse { + gotSignal: boolean; + exitCode: number; + exitSignal: number; +} - const baseRes = await sendAsync(builder, msg.Any.RunStatus, inner); - assert(baseRes != null); - assert(msg.Any.RunStatusRes === baseRes!.innerType()); - const res = new msg.RunStatusRes(); - assert(baseRes!.inner(res) != null); +async function runStatus(rid: number): Promise<ProcessStatus> { + const res = (await sendAsync(dispatch.OP_RUN_STATUS, { + rid + })) as RunStatusResponse; - if (res.gotSignal()) { - const signal = res.exitSignal(); + if (res.gotSignal) { + const signal = res.exitSignal; return { signal, success: false }; } else { - const code = res.exitCode(); + const code = res.exitCode; return { code, success: code === 0 }; } } @@ -56,9 +57,7 @@ async function runStatus(rid: number): Promise<ProcessStatus> { * Requires the `--allow-run` flag. */ export function kill(pid: number, signo: number): void { - const builder = flatbuffers.createBuilder(); - const inner = msg.Kill.createKill(builder, pid, signo); - sendSync(builder, msg.Any.Kill, inner); + sendSync(dispatch.OP_KILL, { pid, signo }); } export class Process { @@ -69,20 +68,20 @@ export class Process { readonly stderr?: ReadCloser; // @internal - constructor(res: msg.RunRes) { - this.rid = res.rid(); - this.pid = res.pid(); + constructor(res: RunResponse) { + this.rid = res.rid; + this.pid = res.pid; - if (res.stdinRid() > 0) { - this.stdin = new File(res.stdinRid()); + if (res.stdinRid && res.stdinRid > 0) { + this.stdin = new File(res.stdinRid); } - if (res.stdoutRid() > 0) { - this.stdout = new File(res.stdoutRid()); + if (res.stdoutRid && res.stdoutRid > 0) { + this.stdout = new File(res.stdoutRid); } - if (res.stderrRid() > 0) { - this.stderr = new File(res.stderrRid()); + if (res.stderrRid && res.stderrRid > 0) { + this.stderr = new File(res.stderrRid); } } @@ -135,14 +134,13 @@ export interface ProcessStatus { signal?: number; // TODO: Make this a string, e.g. 'SIGTERM'. } -function stdioMap(s: ProcessStdio): msg.ProcessStdio { +// TODO: this method is only used to validate proper option, probably can be renamed +function stdioMap(s: string): string { switch (s) { case "inherit": - return msg.ProcessStdio.Inherit; case "piped": - return msg.ProcessStdio.Piped; case "null": - return msg.ProcessStdio.Null; + return s; default: return unreachable(); } @@ -152,6 +150,13 @@ function isRid(arg: unknown): arg is number { return !isNaN(arg as number); } +interface RunResponse { + rid: number; + pid: number; + stdinRid: number | null; + stdoutRid: number | null; + stderrRid: number | null; +} /** * Spawns new subprocess. * @@ -166,71 +171,56 @@ function isRid(arg: unknown): arg is number { * they can be set to either `ProcessStdio` or `rid` of open file. */ export function run(opt: RunOptions): Process { - const builder = flatbuffers.createBuilder(); - const argsOffset = msg.Run.createArgsVector( - builder, - opt.args.map((a): number => builder.createString(a)) - ); - const cwdOffset = opt.cwd == null ? 0 : builder.createString(opt.cwd); - const kvOffset: flatbuffers.Offset[] = []; + assert(opt.args.length > 0); + let env: Array<[string, string]> = []; if (opt.env) { - for (const [key, val] of Object.entries(opt.env)) { - const keyOffset = builder.createString(key); - const valOffset = builder.createString(String(val)); - kvOffset.push(msg.KeyValue.createKeyValue(builder, keyOffset, valOffset)); - } + env = Array.from(Object.entries(opt.env)); } - const envOffset = msg.Run.createEnvVector(builder, kvOffset); - let stdInOffset = stdioMap("inherit"); - let stdOutOffset = stdioMap("inherit"); - let stdErrOffset = stdioMap("inherit"); - let stdinRidOffset = 0; - let stdoutRidOffset = 0; - let stderrRidOffset = 0; + let stdin = stdioMap("inherit"); + let stdout = stdioMap("inherit"); + let stderr = stdioMap("inherit"); + let stdinRid = 0; + let stdoutRid = 0; + let stderrRid = 0; if (opt.stdin) { if (isRid(opt.stdin)) { - stdinRidOffset = opt.stdin; + stdinRid = opt.stdin; } else { - stdInOffset = stdioMap(opt.stdin); + stdin = stdioMap(opt.stdin); } } if (opt.stdout) { if (isRid(opt.stdout)) { - stdoutRidOffset = opt.stdout; + stdoutRid = opt.stdout; } else { - stdOutOffset = stdioMap(opt.stdout); + stdout = stdioMap(opt.stdout); } } if (opt.stderr) { if (isRid(opt.stderr)) { - stderrRidOffset = opt.stderr; + stderrRid = opt.stderr; } else { - stdErrOffset = stdioMap(opt.stderr); + stderr = stdioMap(opt.stderr); } } - const inner = msg.Run.createRun( - builder, - argsOffset, - cwdOffset, - envOffset, - stdInOffset, - stdOutOffset, - stdErrOffset, - stdinRidOffset, - stdoutRidOffset, - stderrRidOffset - ); - const baseRes = sendSync(builder, msg.Any.Run, inner); - assert(baseRes != null); - assert(msg.Any.RunRes === baseRes!.innerType()); - const res = new msg.RunRes(); - assert(baseRes!.inner(res) != null); + const req = { + args: opt.args.map(String), + cwd: opt.cwd, + env, + stdin, + stdout, + stderr, + stdinRid, + stdoutRid, + stderrRid + }; + const res = sendSync(dispatch.OP_RUN, req) as RunResponse; return new Process(res); } diff --git a/js/repl.ts b/js/repl.ts index c971e4420..ac6700657 100644 --- a/js/repl.ts +++ b/js/repl.ts @@ -1,12 +1,12 @@ // Copyright 2018-2019 the Deno authors. All rights reserved. MIT license. -import { assert } from "./util"; import { close } from "./files"; -import { sendSync, sendAsync, msg, flatbuffers } from "./dispatch_flatbuffers"; import { exit } from "./os"; import { window } from "./window"; import { core } from "./core"; import { formatError } from "./format_error"; import { stringifyArgs } from "./console"; +import * as dispatch from "./dispatch"; +import { sendSync, sendAsync } from "./dispatch_json"; /** * REPL logging. @@ -43,34 +43,12 @@ const replCommands = { }; function startRepl(historyFile: string): number { - const builder = flatbuffers.createBuilder(); - const historyFile_ = builder.createString(historyFile); - const inner = msg.ReplStart.createReplStart(builder, historyFile_); - - const baseRes = sendSync(builder, msg.Any.ReplStart, inner); - assert(baseRes != null); - assert(msg.Any.ReplStartRes === baseRes!.innerType()); - const innerRes = new msg.ReplStartRes(); - assert(baseRes!.inner(innerRes) != null); - const rid = innerRes.rid(); - return rid; + return sendSync(dispatch.OP_REPL_START, { historyFile }); } // @internal export async function readline(rid: number, prompt: string): Promise<string> { - const builder = flatbuffers.createBuilder(); - const prompt_ = builder.createString(prompt); - const inner = msg.ReplReadline.createReplReadline(builder, rid, prompt_); - - const baseRes = await sendAsync(builder, msg.Any.ReplReadline, inner); - - assert(baseRes != null); - assert(msg.Any.ReplReadlineRes === baseRes!.innerType()); - const innerRes = new msg.ReplReadlineRes(); - assert(baseRes!.inner(innerRes) != null); - const line = innerRes.line(); - assert(line !== null); - return line || ""; + return sendAsync(dispatch.OP_REPL_READLINE, { rid, prompt }); } // Error messages that allow users to continue input diff --git a/js/resources.ts b/js/resources.ts index 49093fab1..6e2ec202b 100644 --- a/js/resources.ts +++ b/js/resources.ts @@ -1,6 +1,6 @@ // Copyright 2018-2019 the Deno authors. All rights reserved. MIT license. -import { assert } from "./util"; -import { sendSync, msg, flatbuffers } from "./dispatch_flatbuffers"; +import * as dispatch from "./dispatch"; +import { sendSync } from "./dispatch_json"; export interface ResourceMap { [rid: number]: string; @@ -10,20 +10,10 @@ export interface ResourceMap { * representation. */ export function resources(): ResourceMap { - const builder = flatbuffers.createBuilder(); - const inner = msg.Resource.createResource(builder, 0, 0); - const baseRes = sendSync(builder, msg.Any.Resources, inner); - assert(baseRes !== null); - assert(msg.Any.ResourcesRes === baseRes!.innerType()); - const res = new msg.ResourcesRes(); - assert(baseRes!.inner(res) !== null); - + const res = sendSync(dispatch.OP_RESOURCES) as Array<[number, string]>; const resources: ResourceMap = {}; - - for (let i = 0; i < res.resourcesLength(); i++) { - const item = res.resources(i)!; - resources[item.rid()!] = item.repr()!; + for (const resourceTuple of res) { + resources[resourceTuple[0]] = resourceTuple[1]; } - return resources; } diff --git a/js/timers.ts b/js/timers.ts index cb0fd531c..079e779c4 100644 --- a/js/timers.ts +++ b/js/timers.ts @@ -1,7 +1,8 @@ // Copyright 2018-2019 the Deno authors. All rights reserved. MIT license. import { assert } from "./util"; -import { sendAsync, sendSync, msg, flatbuffers } from "./dispatch_flatbuffers"; import { window } from "./window"; +import * as dispatch from "./dispatch"; +import { sendSync, sendAsync } from "./dispatch_json"; interface Timer { id: number; @@ -37,11 +38,8 @@ function getTime(): number { } function clearGlobalTimeout(): void { - const builder = flatbuffers.createBuilder(); - const inner = msg.GlobalTimerStop.createGlobalTimerStop(builder); globalTimeoutDue = null; - let res = sendSync(builder, msg.Any.GlobalTimerStop, inner); - assert(res == null); + sendSync(dispatch.OP_GLOBAL_TIMER_STOP); } async function setGlobalTimeout(due: number, now: number): Promise<void> { @@ -52,12 +50,8 @@ async function setGlobalTimeout(due: number, now: number): Promise<void> { assert(timeout >= 0); // Send message to the backend. - const builder = flatbuffers.createBuilder(); - msg.GlobalTimer.startGlobalTimer(builder); - msg.GlobalTimer.addTimeout(builder, timeout); - const inner = msg.GlobalTimer.endGlobalTimer(builder); globalTimeoutDue = due; - await sendAsync(builder, msg.Any.GlobalTimer, inner); + await sendAsync(dispatch.OP_GLOBAL_TIMER, { timeout }); // eslint-disable-next-line @typescript-eslint/no-use-before-define fireTimers(); } diff --git a/js/workers.ts b/js/workers.ts index e59e853c5..7bcbe6279 100644 --- a/js/workers.ts +++ b/js/workers.ts @@ -1,7 +1,8 @@ // Copyright 2018-2019 the Deno authors. All rights reserved. MIT license. /* eslint-disable @typescript-eslint/no-explicit-any */ -import { sendAsync, sendSync, msg, flatbuffers } from "./dispatch_flatbuffers"; -import { assert, log } from "./util"; +import * as dispatch from "./dispatch"; +import { sendAsync, sendSync } from "./dispatch_json"; +import { log } from "./util"; import { TextDecoder, TextEncoder } from "./text_encoding"; import { window } from "./window"; import { blobURLMap } from "./url"; @@ -26,61 +27,28 @@ function createWorker( hasSourceCode: boolean, sourceCode: Uint8Array ): number { - const builder = flatbuffers.createBuilder(); - const specifier_ = builder.createString(specifier); - const sourceCode_ = builder.createString(sourceCode); - const inner = msg.CreateWorker.createCreateWorker( - builder, - specifier_, + return sendSync(dispatch.OP_CREATE_WORKER, { + specifier, includeDenoNamespace, hasSourceCode, - sourceCode_ - ); - const baseRes = sendSync(builder, msg.Any.CreateWorker, inner); - assert(baseRes != null); - assert( - msg.Any.CreateWorkerRes === baseRes!.innerType(), - `base.innerType() unexpectedly is ${baseRes!.innerType()}` - ); - const res = new msg.CreateWorkerRes(); - assert(baseRes!.inner(res) != null); - return res.rid(); + sourceCode: new TextDecoder().decode(sourceCode) + }); } async function hostGetWorkerClosed(rid: number): Promise<void> { - const builder = flatbuffers.createBuilder(); - const inner = msg.HostGetWorkerClosed.createHostGetWorkerClosed(builder, rid); - await sendAsync(builder, msg.Any.HostGetWorkerClosed, inner); + await sendAsync(dispatch.OP_HOST_GET_WORKER_CLOSED, { rid }); } function hostPostMessage(rid: number, data: any): void { const dataIntArray = encodeMessage(data); - const builder = flatbuffers.createBuilder(); - const inner = msg.HostPostMessage.createHostPostMessage(builder, rid); - const baseRes = sendSync( - builder, - msg.Any.HostPostMessage, - inner, - dataIntArray - ); - assert(baseRes != null); + sendSync(dispatch.OP_HOST_POST_MESSAGE, { rid }, dataIntArray); } async function hostGetMessage(rid: number): Promise<any> { - const builder = flatbuffers.createBuilder(); - const inner = msg.HostGetMessage.createHostGetMessage(builder, rid); - const baseRes = await sendAsync(builder, msg.Any.HostGetMessage, inner); - assert(baseRes != null); - assert( - msg.Any.HostGetMessageRes === baseRes!.innerType(), - `base.innerType() unexpectedly is ${baseRes!.innerType()}` - ); - const res = new msg.HostGetMessageRes(); - assert(baseRes!.inner(res) != null); - - const dataArray = res.dataArray(); - if (dataArray != null) { - return decodeMessage(dataArray); + const res = await sendAsync(dispatch.OP_HOST_GET_MESSAGE, { rid }); + + if (res.data != null) { + return decodeMessage(new Uint8Array(res.data)); } else { return null; } @@ -91,36 +59,15 @@ export let onmessage: (e: { data: any }) => void = (): void => {}; export function postMessage(data: any): void { const dataIntArray = encodeMessage(data); - const builder = flatbuffers.createBuilder(); - const inner = msg.WorkerPostMessage.createWorkerPostMessage(builder); - const baseRes = sendSync( - builder, - msg.Any.WorkerPostMessage, - inner, - dataIntArray - ); - assert(baseRes != null); + sendSync(dispatch.OP_WORKER_POST_MESSAGE, {}, dataIntArray); } export async function getMessage(): Promise<any> { log("getMessage"); - const builder = flatbuffers.createBuilder(); - const inner = msg.WorkerGetMessage.createWorkerGetMessage( - builder, - 0 /* unused */ - ); - const baseRes = await sendAsync(builder, msg.Any.WorkerGetMessage, inner); - assert(baseRes != null); - assert( - msg.Any.WorkerGetMessageRes === baseRes!.innerType(), - `base.innerType() unexpectedly is ${baseRes!.innerType()}` - ); - const res = new msg.WorkerGetMessageRes(); - assert(baseRes!.inner(res) != null); - - const dataArray = res.dataArray(); - if (dataArray != null) { - return decodeMessage(dataArray); + const res = await sendAsync(dispatch.OP_WORKER_GET_MESSAGE); + + if (res.data != null) { + return decodeMessage(new Uint8Array(res.data)); } else { return null; } diff --git a/tests/error_004_missing_module.ts.out b/tests/error_004_missing_module.ts.out index cb0f3bc5a..e8d672739 100644 --- a/tests/error_004_missing_module.ts.out +++ b/tests/error_004_missing_module.ts.out @@ -1,12 +1,12 @@ [WILDCARD]error: Uncaught NotFound: Cannot resolve module "[WILDCARD]/bad-module.ts" -[WILDCARD] js/dispatch_flatbuffers.ts:[WILDCARD] +[WILDCARD] js/dispatch_json.ts:[WILDCARD] at DenoError (js/errors.ts:[WILDCARD]) - at maybeError (js/dispatch_flatbuffers.ts:[WILDCARD]) - at maybeThrowError (js/dispatch_flatbuffers.ts:[WILDCARD]) - at sendSync (js/dispatch_flatbuffers.ts:[WILDCARD]) + at toDenoError (js/dispatch_json.ts:[WILDCARD]) + at sendSync$1 (js/dispatch_json.ts:[WILDCARD]) at fetchSourceFile (js/compiler.ts:[WILDCARD]) at _resolveModule (js/compiler.ts:[WILDCARD]) at js/compiler.ts:[WILDCARD] at resolveModuleNames (js/compiler.ts:[WILDCARD]) at resolveModuleNamesWorker ([WILDCARD]typescript.js:[WILDCARD]) at resolveModuleNamesReusingOldState ([WILDCARD]typescript.js:[WILDCARD]) + at processImportedModules ([WILDCARD]typescript.js:[WILDCARD]) diff --git a/tests/error_005_missing_dynamic_import.ts.out b/tests/error_005_missing_dynamic_import.ts.out index fbc25f701..2f39dc853 100644 --- a/tests/error_005_missing_dynamic_import.ts.out +++ b/tests/error_005_missing_dynamic_import.ts.out @@ -1,11 +1,11 @@ [WILDCARD]error: Uncaught NotFound: Cannot resolve module "[WILDCARD]/bad-module.ts" -[WILDCARD] js/dispatch_flatbuffers.ts:[WILDCARD] +[WILDCARD] js/dispatch_json.ts:[WILDCARD] at DenoError (js/errors.ts:[WILDCARD]) - at maybeError (js/dispatch_flatbuffers.ts:[WILDCARD]) - at maybeThrowError (js/dispatch_flatbuffers.ts:[WILDCARD]) - at sendSync (js/dispatch_flatbuffers.ts:[WILDCARD]) + at toDenoError (js/dispatch_json.ts:[WILDCARD]) + at sendSync$1 (js/dispatch_json.ts:[WILDCARD]) at fetchSourceFile (js/compiler.ts:[WILDCARD]) at _resolveModule (js/compiler.ts:[WILDCARD]) at js/compiler.ts:[WILDCARD] at resolveModuleNamesWorker ([WILDCARD]) at resolveModuleNamesReusingOldState ([WILDCARD]typescript.js:[WILDCARD]) + at processImportedModules ([WILDCARD]typescript.js:[WILDCARD]) diff --git a/tests/error_006_import_ext_failure.ts.out b/tests/error_006_import_ext_failure.ts.out index cb7ccee85..b381fa96d 100644 --- a/tests/error_006_import_ext_failure.ts.out +++ b/tests/error_006_import_ext_failure.ts.out @@ -1,11 +1,11 @@ [WILDCARD]error: Uncaught NotFound: Cannot resolve module "[WILDCARD]/non-existent" -[WILDCARD] js/dispatch_flatbuffers.ts:[WILDCARD] +[WILDCARD] js/dispatch_json.ts:[WILDCARD] at DenoError (js/errors.ts:[WILDCARD]) - at maybeError (js/dispatch_flatbuffers.ts:[WILDCARD]) - at maybeThrowError (js/dispatch_flatbuffers.ts:[WILDCARD]) - at sendSync (js/dispatch_flatbuffers.ts:[WILDCARD]) + at toDenoError (js/dispatch_json.ts:[WILDCARD]) + at sendSync$1 (js/dispatch_json.ts:[WILDCARD]) at fetchSourceFile (js/compiler.ts:[WILDCARD]) at _resolveModule (js/compiler.ts:[WILDCARD]) at js/compiler.ts:[WILDCARD] at resolveModuleNamesWorker ([WILDCARD]) at resolveModuleNamesReusingOldState ([WILDCARD]typescript.js:[WILDCARD]) + at processImportedModules ([WILDCARD]typescript.js:[WILDCARD]) diff --git a/tests/error_011_bad_module_specifier.ts.out b/tests/error_011_bad_module_specifier.ts.out index 1590f4e15..1d8e8c97e 100644 --- a/tests/error_011_bad_module_specifier.ts.out +++ b/tests/error_011_bad_module_specifier.ts.out @@ -1,12 +1,11 @@ [WILDCARD]error: Uncaught ImportPrefixMissing: relative import path "bad-module.ts" not prefixed with / or ./ or ../ -[WILDCARD] js/dispatch_flatbuffers.ts:[WILDCARD] +[WILDCARD] js/dispatch_json.ts:[WILDCARD] at DenoError (js/errors.ts:[WILDCARD]) - at maybeError (js/dispatch_flatbuffers.ts:[WILDCARD]) - at maybeThrowError (js/dispatch_flatbuffers.ts:[WILDCARD]) - at sendSync (js/dispatch_flatbuffers.ts:[WILDCARD]) + at toDenoError (js/dispatch_json.ts:[WILDCARD]) + at sendSync$1 (js/dispatch_json.ts:[WILDCARD]) at fetchSourceFile (js/compiler.ts:[WILDCARD]) at _resolveModule (js/compiler.ts:[WILDCARD]) at js/compiler.ts:[WILDCARD] - at resolveModuleNames (js/compiler.ts:[WILDCARD]) - at resolveModuleNamesWorker ([WILDCARD]typescript.js:[WILDCARD]) + at resolveModuleNamesWorker ([WILDCARD]) at resolveModuleNamesReusingOldState ([WILDCARD]typescript.js:[WILDCARD]) + at processImportedModules ([WILDCARD]typescript.js:[WILDCARD]) diff --git a/tests/error_012_bad_dynamic_import_specifier.ts.out b/tests/error_012_bad_dynamic_import_specifier.ts.out index ec5cba6f7..1d8e8c97e 100644 --- a/tests/error_012_bad_dynamic_import_specifier.ts.out +++ b/tests/error_012_bad_dynamic_import_specifier.ts.out @@ -1,12 +1,11 @@ [WILDCARD]error: Uncaught ImportPrefixMissing: relative import path "bad-module.ts" not prefixed with / or ./ or ../ -[WILDCARD] js/dispatch_flatbuffers.ts:[WILDCARD] +[WILDCARD] js/dispatch_json.ts:[WILDCARD] at DenoError (js/errors.ts:[WILDCARD]) - at maybeError (js/dispatch_flatbuffers.ts:[WILDCARD]) - at maybeThrowError (js/dispatch_flatbuffers.ts:[WILDCARD]) - at sendSync (js/dispatch_flatbuffers.ts:[WILDCARD]) + at toDenoError (js/dispatch_json.ts:[WILDCARD]) + at sendSync$1 (js/dispatch_json.ts:[WILDCARD]) at fetchSourceFile (js/compiler.ts:[WILDCARD]) at _resolveModule (js/compiler.ts:[WILDCARD]) at js/compiler.ts:[WILDCARD] - at resolveModuleNames (js/compiler.ts:[WILDCARD]) at resolveModuleNamesWorker ([WILDCARD]) at resolveModuleNamesReusingOldState ([WILDCARD]typescript.js:[WILDCARD]) + at processImportedModules ([WILDCARD]typescript.js:[WILDCARD]) |