diff options
Diffstat (limited to 'src/ops.rs')
-rw-r--r-- | src/ops.rs | 486 |
1 files changed, 232 insertions, 254 deletions
diff --git a/src/ops.rs b/src/ops.rs index 495540b22..33a7d7cdd 100644 --- a/src/ops.rs +++ b/src/ops.rs @@ -1,18 +1,15 @@ // Copyright 2018-2019 the Deno authors. All rights reserved. MIT license. - use atty; use crate::ansi; +use crate::cli::Buf; +use crate::cli::Cli; use crate::errors; use crate::errors::{permission_denied, DenoError, DenoResult, ErrorKind}; use crate::fs as deno_fs; use crate::http_util; -use crate::isolate::Buf; -use crate::isolate::Isolate; -use crate::isolate::IsolateState; -use crate::isolate::Op; +use crate::isolate_state::IsolateState; use crate::js_errors::apply_source_map; use crate::js_errors::JSErrorColor; -use crate::libdeno; use crate::msg; use crate::msg_util; use crate::repl; @@ -22,7 +19,9 @@ use crate::resources::table_entries; use crate::resources::Resource; use crate::tokio_util; use crate::version; +use deno_core::deno_buf; use deno_core::JSError; +use deno_core::Op; use flatbuffers::FlatBufferBuilder; use futures; use futures::Async; @@ -54,11 +53,12 @@ use std::os::unix::process::ExitStatusExt; type OpResult = DenoResult<Buf>; -// TODO Ideally we wouldn't have to box the Op being returned. +pub type OpWithError = dyn Future<Item = Buf, Error = DenoError> + Send; + +// TODO Ideally we wouldn't have to box the OpWithError being returned. // The box is just to make it easier to get a prototype refactor working. type OpCreator = - fn(isolate: &Isolate, base: &msg::Base<'_>, data: libdeno::deno_buf) - -> Box<Op>; + fn(cli: &Cli, base: &msg::Base<'_>, data: deno_buf) -> Box<OpWithError>; #[inline] fn empty_buf() -> Buf { @@ -70,16 +70,18 @@ fn empty_buf() -> Buf { /// control corresponds to the first argument of libdeno.send(). /// data corresponds to the second argument of libdeno.send(). pub fn dispatch( - isolate: &Isolate, - control: libdeno::deno_buf, - data: libdeno::deno_buf, + cli: &Cli, + control: &[u8], + zero_copy: deno_buf, ) -> (bool, Box<Op>) { + let bytes_sent_control = control.len(); + let bytes_sent_zero_copy = zero_copy.len(); let base = msg::get_root_as_base(&control); let is_sync = base.sync(); let inner_type = base.inner_type(); let cmd_id = base.cmd_id(); - let op: Box<Op> = { + let op: Box<OpWithError> = { // Handle regular ops. let op_creator: OpCreator = match inner_type { msg::Any::Accept => op_accept, @@ -132,11 +134,16 @@ pub fn dispatch( msg::enum_name_any(inner_type) )), }; - op_creator(&isolate, &base, data) + op_creator(&cli, &base, zero_copy) }; + cli + .state + .metrics_op_dispatched(bytes_sent_control, bytes_sent_zero_copy); + let state = cli.state.clone(); + let boxed_op = Box::new( - op.or_else(move |err: DenoError| -> DenoResult<Buf> { + op.or_else(move |err: DenoError| -> Result<Buf, ()> { debug!("op err {}", err); // No matter whether we got an Err or Ok, we want a serialized message to // send back. So transform the DenoError into a deno_buf. @@ -151,7 +158,7 @@ pub fn dispatch( ..Default::default() }, )) - }).and_then(move |buf: Buf| -> DenoResult<Buf> { + }).and_then(move |buf: Buf| -> Result<Buf, ()> { // Handle empty responses. For sync responses we just want // to send null. For async we want to send a small message // with the cmd_id. @@ -167,8 +174,9 @@ pub fn dispatch( }, ) }; + state.metrics_op_completed(buf.len()); Ok(buf) - }), + }).map_err(|err| panic!("unexpected error {:?}", err)), ); debug!( @@ -180,10 +188,10 @@ pub fn dispatch( } fn op_now( - _isolate: &Isolate, + _cli: &Cli, base: &msg::Base<'_>, - data: libdeno::deno_buf, -) -> Box<Op> { + data: deno_buf, +) -> Box<OpWithError> { assert_eq!(data.len(), 0); let start = SystemTime::now(); let since_the_epoch = start.duration_since(UNIX_EPOCH).unwrap(); @@ -204,10 +212,10 @@ fn op_now( } fn op_is_tty( - _isolate: &Isolate, + _cli: &Cli, base: &msg::Base<'_>, - _data: libdeno::deno_buf, -) -> Box<Op> { + _data: deno_buf, +) -> Box<OpWithError> { let builder = &mut FlatBufferBuilder::new(); let inner = msg::IsTTYRes::create( builder, @@ -229,23 +237,23 @@ fn op_is_tty( } fn op_exit( - _isolate: &Isolate, + _cli: &Cli, base: &msg::Base<'_>, - _data: libdeno::deno_buf, -) -> Box<Op> { + _data: deno_buf, +) -> Box<OpWithError> { let inner = base.inner_as_exit().unwrap(); std::process::exit(inner.code()) } fn op_start( - isolate: &Isolate, + cli: &Cli, base: &msg::Base<'_>, - data: libdeno::deno_buf, -) -> Box<Op> { + data: deno_buf, +) -> Box<OpWithError> { assert_eq!(data.len(), 0); let mut builder = FlatBufferBuilder::new(); - let argv = isolate + let argv = cli .state .argv .iter() @@ -266,10 +274,7 @@ fn op_start( let deno_version = version::DENO; let deno_version_off = builder.create_string(deno_version); - let main_module = isolate - .state - .main_module() - .map(|m| builder.create_string(&m)); + let main_module = cli.state.main_module().map(|m| builder.create_string(&m)); let inner = msg::StartRes::create( &mut builder, @@ -278,9 +283,9 @@ fn op_start( pid: std::process::id(), argv: Some(argv_off), main_module, - debug_flag: isolate.state.flags.log_debug, - types_flag: isolate.state.flags.types, - version_flag: isolate.state.flags.version, + debug_flag: cli.state.flags.log_debug, + types_flag: cli.state.flags.types, + version_flag: cli.state.flags.version, v8_version: Some(v8_version_off), deno_version: Some(deno_version_off), no_color: !ansi::use_color(), @@ -301,16 +306,16 @@ fn op_start( } fn op_format_error( - isolate: &Isolate, + cli: &Cli, base: &msg::Base<'_>, - data: libdeno::deno_buf, -) -> Box<Op> { + data: deno_buf, +) -> Box<OpWithError> { assert_eq!(data.len(), 0); let inner = base.inner_as_format_error().unwrap(); let orig_error = String::from(inner.error().unwrap()); let js_error = JSError::from_v8_exception(&orig_error).unwrap(); - let js_error_mapped = apply_source_map(&js_error, &isolate.state.dir); + let js_error_mapped = apply_source_map(&js_error, &cli.state.dir); let js_error_string = JSErrorColor(&js_error_mapped).to_string(); let mut builder = FlatBufferBuilder::new(); @@ -349,22 +354,22 @@ fn serialize_response( } #[inline] -pub fn ok_future(buf: Buf) -> Box<Op> { +pub fn ok_future(buf: Buf) -> Box<OpWithError> { Box::new(futures::future::ok(buf)) } // Shout out to Earl Sweatshirt. #[inline] -pub fn odd_future(err: DenoError) -> Box<Op> { +pub fn odd_future(err: DenoError) -> Box<OpWithError> { Box::new(futures::future::err(err)) } // https://github.com/denoland/deno/blob/golang/os.go#L100-L154 fn op_fetch_module_meta_data( - isolate: &Isolate, + cli: &Cli, base: &msg::Base<'_>, - data: libdeno::deno_buf, -) -> Box<Op> { + data: deno_buf, +) -> Box<OpWithError> { assert_eq!(data.len(), 0); let inner = base.inner_as_fetch_module_meta_data().unwrap(); let cmd_id = base.cmd_id(); @@ -372,35 +377,32 @@ fn op_fetch_module_meta_data( let referrer = inner.referrer().unwrap(); // Check for allow read since this operation could be used to read from the file system. - if !isolate.permissions.allows_read() { + if !cli.permissions.allows_read() { debug!("No read permission for fetch_module_meta_data"); return odd_future(permission_denied()); } // Check for allow write since this operation could be used to write to the file system. - if !isolate.permissions.allows_write() { + if !cli.permissions.allows_write() { debug!("No network permission for fetch_module_meta_data"); return odd_future(permission_denied()); } // Check for allow net since this operation could be used to make https/http requests. - if !isolate.permissions.allows_net() { + if !cli.permissions.allows_net() { debug!("No network permission for fetch_module_meta_data"); return odd_future(permission_denied()); } assert_eq!( - isolate.state.dir.root.join("gen"), - isolate.state.dir.gen, + cli.state.dir.root.join("gen"), + cli.state.dir.gen, "Sanity check" ); Box::new(futures::future::result(|| -> OpResult { let builder = &mut FlatBufferBuilder::new(); - let out = isolate - .state - .dir - .fetch_module_meta_data(specifier, referrer)?; + let out = cli.state.dir.fetch_module_meta_data(specifier, referrer)?; let data_off = builder.create_vector(out.source_code.as_slice()); let msg_args = msg::FetchModuleMetaDataResArgs { module_name: Some(builder.create_string(&out.module_name)), @@ -422,10 +424,10 @@ fn op_fetch_module_meta_data( } fn op_chdir( - _isolate: &Isolate, + _cli: &Cli, base: &msg::Base<'_>, - data: libdeno::deno_buf, -) -> Box<Op> { + data: deno_buf, +) -> Box<OpWithError> { assert_eq!(data.len(), 0); let inner = base.inner_as_chdir().unwrap(); let directory = inner.directory().unwrap(); @@ -436,22 +438,22 @@ fn op_chdir( } fn op_global_timer_stop( - isolate: &Isolate, + cli: &Cli, base: &msg::Base<'_>, - data: libdeno::deno_buf, -) -> Box<Op> { + data: deno_buf, +) -> Box<OpWithError> { assert!(base.sync()); assert_eq!(data.len(), 0); - let mut t = isolate.state.global_timer.lock().unwrap(); + let mut t = cli.state.global_timer.lock().unwrap(); t.cancel(); ok_future(empty_buf()) } fn op_global_timer( - isolate: &Isolate, + cli: &Cli, base: &msg::Base<'_>, - data: libdeno::deno_buf, -) -> Box<Op> { + data: deno_buf, +) -> Box<OpWithError> { assert!(!base.sync()); assert_eq!(data.len(), 0); let cmd_id = base.cmd_id(); @@ -459,7 +461,7 @@ fn op_global_timer( let val = inner.timeout(); assert!(val >= 0); - let mut t = isolate.state.global_timer.lock().unwrap(); + let mut t = cli.state.global_timer.lock().unwrap(); let deadline = Instant::now() + Duration::from_millis(val as u64); let f = t.new_timeout(deadline); @@ -480,30 +482,26 @@ fn op_global_timer( } fn op_set_env( - isolate: &Isolate, + cli: &Cli, base: &msg::Base<'_>, - data: libdeno::deno_buf, -) -> Box<Op> { + data: deno_buf, +) -> Box<OpWithError> { assert_eq!(data.len(), 0); let inner = base.inner_as_set_env().unwrap(); let key = inner.key().unwrap(); let value = inner.value().unwrap(); - if let Err(e) = isolate.check_env() { + if let Err(e) = cli.check_env() { return odd_future(e); } std::env::set_var(key, value); ok_future(empty_buf()) } -fn op_env( - isolate: &Isolate, - base: &msg::Base<'_>, - data: libdeno::deno_buf, -) -> Box<Op> { +fn op_env(cli: &Cli, base: &msg::Base<'_>, data: deno_buf) -> Box<OpWithError> { assert_eq!(data.len(), 0); let cmd_id = base.cmd_id(); - if let Err(e) = isolate.check_env() { + if let Err(e) = cli.check_env() { return odd_future(e); } @@ -528,21 +526,21 @@ fn op_env( } fn op_permissions( - isolate: &Isolate, + cli: &Cli, base: &msg::Base<'_>, - data: libdeno::deno_buf, -) -> Box<Op> { + data: deno_buf, +) -> Box<OpWithError> { assert_eq!(data.len(), 0); let cmd_id = base.cmd_id(); let builder = &mut FlatBufferBuilder::new(); let inner = msg::PermissionsRes::create( builder, &msg::PermissionsResArgs { - run: isolate.permissions.allows_run(), - read: isolate.permissions.allows_read(), - write: isolate.permissions.allows_write(), - net: isolate.permissions.allows_net(), - env: isolate.permissions.allows_env(), + run: cli.permissions.allows_run(), + read: cli.permissions.allows_read(), + write: cli.permissions.allows_write(), + net: cli.permissions.allows_net(), + env: cli.permissions.allows_env(), }, ); ok_future(serialize_response( @@ -557,19 +555,19 @@ fn op_permissions( } fn op_revoke_permission( - isolate: &Isolate, + cli: &Cli, base: &msg::Base<'_>, - data: libdeno::deno_buf, -) -> Box<Op> { + data: deno_buf, +) -> Box<OpWithError> { assert_eq!(data.len(), 0); let inner = base.inner_as_permission_revoke().unwrap(); let permission = inner.permission().unwrap(); let result = match permission { - "run" => isolate.permissions.revoke_run(), - "read" => isolate.permissions.revoke_read(), - "write" => isolate.permissions.revoke_write(), - "net" => isolate.permissions.revoke_net(), - "env" => isolate.permissions.revoke_env(), + "run" => cli.permissions.revoke_run(), + "read" => cli.permissions.revoke_read(), + "write" => cli.permissions.revoke_write(), + "net" => cli.permissions.revoke_net(), + "env" => cli.permissions.revoke_env(), _ => Ok(()), }; if let Err(e) = result { @@ -579,10 +577,10 @@ fn op_revoke_permission( } fn op_fetch( - isolate: &Isolate, + cli: &Cli, base: &msg::Base<'_>, - data: libdeno::deno_buf, -) -> Box<Op> { + data: deno_buf, +) -> Box<OpWithError> { let inner = base.inner_as_fetch().unwrap(); let cmd_id = base.cmd_id(); @@ -602,7 +600,7 @@ fn op_fetch( } let req = maybe_req.unwrap(); - if let Err(e) = isolate.check_net(url) { + if let Err(e) = cli.check_net(url) { return odd_future(e); } @@ -650,11 +648,11 @@ where Ok(Ready(Ok(v))) => Ok(v.into()), Ok(Ready(Err(err))) => Err(err), Ok(NotReady) => Ok(NotReady), - Err(_err) => panic!("blocking error"), + Err(err) => panic!("blocking error {}", err), } } -fn blocking<F>(is_sync: bool, f: F) -> Box<Op> +fn blocking<F>(is_sync: bool, f: F) -> Box<OpWithError> where F: 'static + Send + FnOnce() -> DenoResult<Buf>, { @@ -666,17 +664,17 @@ where } fn op_make_temp_dir( - isolate: &Isolate, + cli: &Cli, base: &msg::Base<'_>, - data: libdeno::deno_buf, -) -> Box<Op> { + data: deno_buf, +) -> Box<OpWithError> { assert_eq!(data.len(), 0); let base = Box::new(*base); let inner = base.inner_as_make_temp_dir().unwrap(); let cmd_id = base.cmd_id(); // FIXME - if let Err(e) = isolate.check_write("make_temp") { + if let Err(e) = cli.check_write("make_temp") { return odd_future(e); } @@ -715,17 +713,17 @@ fn op_make_temp_dir( } fn op_mkdir( - isolate: &Isolate, + cli: &Cli, base: &msg::Base<'_>, - data: libdeno::deno_buf, -) -> Box<Op> { + data: deno_buf, +) -> Box<OpWithError> { assert_eq!(data.len(), 0); let inner = base.inner_as_mkdir().unwrap(); let path = String::from(inner.path().unwrap()); let recursive = inner.recursive(); let mode = inner.mode(); - if let Err(e) = isolate.check_write(&path) { + if let Err(e) = cli.check_write(&path) { return odd_future(e); } @@ -737,16 +735,16 @@ fn op_mkdir( } fn op_chmod( - isolate: &Isolate, + cli: &Cli, base: &msg::Base<'_>, - data: libdeno::deno_buf, -) -> Box<Op> { + data: deno_buf, +) -> Box<OpWithError> { assert_eq!(data.len(), 0); let inner = base.inner_as_chmod().unwrap(); let _mode = inner.mode(); let path = String::from(inner.path().unwrap()); - if let Err(e) = isolate.check_write(&path) { + if let Err(e) = cli.check_write(&path) { return odd_future(e); } @@ -776,10 +774,10 @@ fn op_chmod( } fn op_open( - isolate: &Isolate, + cli: &Cli, base: &msg::Base<'_>, - data: libdeno::deno_buf, -) -> Box<Op> { + data: deno_buf, +) -> Box<OpWithError> { assert_eq!(data.len(), 0); let cmd_id = base.cmd_id(); let inner = base.inner_as_open().unwrap(); @@ -825,20 +823,20 @@ fn op_open( match mode { "r" => { - if let Err(e) = isolate.check_read(&filename_str) { + if let Err(e) = cli.check_read(&filename_str) { return odd_future(e); } } "w" | "a" | "x" => { - if let Err(e) = isolate.check_write(&filename_str) { + if let Err(e) = cli.check_write(&filename_str) { return odd_future(e); } } &_ => { - if let Err(e) = isolate.check_read(&filename_str) { + if let Err(e) = cli.check_read(&filename_str) { return odd_future(e); } - if let Err(e) = isolate.check_write(&filename_str) { + if let Err(e) = cli.check_write(&filename_str) { return odd_future(e); } } @@ -866,10 +864,10 @@ fn op_open( } fn op_close( - _isolate: &Isolate, + _cli: &Cli, base: &msg::Base<'_>, - data: libdeno::deno_buf, -) -> Box<Op> { + data: deno_buf, +) -> Box<OpWithError> { assert_eq!(data.len(), 0); let inner = base.inner_as_close().unwrap(); let rid = inner.rid(); @@ -883,10 +881,10 @@ fn op_close( } fn op_shutdown( - _isolate: &Isolate, + _cli: &Cli, base: &msg::Base<'_>, - data: libdeno::deno_buf, -) -> Box<Op> { + data: deno_buf, +) -> Box<OpWithError> { assert_eq!(data.len(), 0); let inner = base.inner_as_shutdown().unwrap(); let rid = inner.rid(); @@ -909,10 +907,10 @@ fn op_shutdown( } fn op_read( - _isolate: &Isolate, + _cli: &Cli, base: &msg::Base<'_>, - data: libdeno::deno_buf, -) -> Box<Op> { + data: deno_buf, +) -> Box<OpWithError> { let cmd_id = base.cmd_id(); let inner = base.inner_as_read().unwrap(); let rid = inner.rid(); @@ -947,10 +945,10 @@ fn op_read( } fn op_write( - _isolate: &Isolate, + _cli: &Cli, base: &msg::Base<'_>, - data: libdeno::deno_buf, -) -> Box<Op> { + data: deno_buf, +) -> Box<OpWithError> { let cmd_id = base.cmd_id(); let inner = base.inner_as_write().unwrap(); let rid = inner.rid(); @@ -984,10 +982,10 @@ fn op_write( } fn op_seek( - _isolate: &Isolate, + _cli: &Cli, base: &msg::Base<'_>, - data: libdeno::deno_buf, -) -> Box<Op> { + data: deno_buf, +) -> Box<OpWithError> { assert_eq!(data.len(), 0); let _cmd_id = base.cmd_id(); let inner = base.inner_as_seek().unwrap(); @@ -1006,17 +1004,17 @@ fn op_seek( } fn op_remove( - isolate: &Isolate, + cli: &Cli, base: &msg::Base<'_>, - data: libdeno::deno_buf, -) -> Box<Op> { + data: deno_buf, +) -> Box<OpWithError> { assert_eq!(data.len(), 0); let inner = base.inner_as_remove().unwrap(); let path_ = inner.path().unwrap(); let path = PathBuf::from(path_); let recursive = inner.recursive(); - if let Err(e) = isolate.check_write(path.to_str().unwrap()) { + if let Err(e) = cli.check_write(path.to_str().unwrap()) { return odd_future(e); } @@ -1036,17 +1034,17 @@ fn op_remove( // Prototype https://github.com/denoland/deno/blob/golang/os.go#L171-L184 fn op_read_file( - isolate: &Isolate, + cli: &Cli, base: &msg::Base<'_>, - data: libdeno::deno_buf, -) -> Box<Op> { + data: deno_buf, +) -> Box<OpWithError> { assert_eq!(data.len(), 0); let inner = base.inner_as_read_file().unwrap(); let cmd_id = base.cmd_id(); let filename_ = inner.filename().unwrap(); let filename = PathBuf::from(filename_); debug!("op_read_file {}", filename.display()); - if let Err(e) = isolate.check_read(&filename_) { + if let Err(e) = cli.check_read(&filename_) { return odd_future(e); } blocking(base.sync(), move || { @@ -1074,10 +1072,10 @@ fn op_read_file( } fn op_copy_file( - isolate: &Isolate, + cli: &Cli, base: &msg::Base<'_>, - data: libdeno::deno_buf, -) -> Box<Op> { + data: deno_buf, +) -> Box<OpWithError> { assert_eq!(data.len(), 0); let inner = base.inner_as_copy_file().unwrap(); let from_ = inner.from().unwrap(); @@ -1085,10 +1083,10 @@ fn op_copy_file( let to_ = inner.to().unwrap(); let to = PathBuf::from(to_); - if let Err(e) = isolate.check_read(&from_) { + if let Err(e) = cli.check_read(&from_) { return odd_future(e); } - if let Err(e) = isolate.check_write(&to_) { + if let Err(e) = cli.check_write(&to_) { return odd_future(e); } @@ -1130,10 +1128,10 @@ fn get_mode(_perm: &fs::Permissions) -> u32 { } fn op_cwd( - _isolate: &Isolate, + _cli: &Cli, base: &msg::Base<'_>, - data: libdeno::deno_buf, -) -> Box<Op> { + data: deno_buf, +) -> Box<OpWithError> { assert_eq!(data.len(), 0); let cmd_id = base.cmd_id(); Box::new(futures::future::result(|| -> OpResult { @@ -1156,10 +1154,10 @@ fn op_cwd( } fn op_stat( - isolate: &Isolate, + cli: &Cli, base: &msg::Base<'_>, - data: libdeno::deno_buf, -) -> Box<Op> { + data: deno_buf, +) -> Box<OpWithError> { assert_eq!(data.len(), 0); let inner = base.inner_as_stat().unwrap(); let cmd_id = base.cmd_id(); @@ -1167,7 +1165,7 @@ fn op_stat( let filename = PathBuf::from(filename_); let lstat = inner.lstat(); - if let Err(e) = isolate.check_read(&filename_) { + if let Err(e) = cli.check_read(&filename_) { return odd_future(e); } @@ -1208,16 +1206,16 @@ fn op_stat( } fn op_read_dir( - isolate: &Isolate, + cli: &Cli, base: &msg::Base<'_>, - data: libdeno::deno_buf, -) -> Box<Op> { + data: deno_buf, +) -> Box<OpWithError> { assert_eq!(data.len(), 0); let inner = base.inner_as_read_dir().unwrap(); let cmd_id = base.cmd_id(); let path = String::from(inner.path().unwrap()); - if let Err(e) = isolate.check_read(&path) { + if let Err(e) = cli.check_read(&path) { return odd_future(e); } @@ -1269,10 +1267,10 @@ fn op_read_dir( } fn op_write_file( - isolate: &Isolate, + cli: &Cli, base: &msg::Base<'_>, - data: libdeno::deno_buf, -) -> Box<Op> { + data: deno_buf, +) -> Box<OpWithError> { let inner = base.inner_as_write_file().unwrap(); let filename = String::from(inner.filename().unwrap()); let update_perm = inner.update_perm(); @@ -1280,7 +1278,7 @@ fn op_write_file( let is_create = inner.is_create(); let is_append = inner.is_append(); - if let Err(e) = isolate.check_write(&filename) { + if let Err(e) = cli.check_write(&filename) { return odd_future(e); } @@ -1299,16 +1297,16 @@ fn op_write_file( } fn op_rename( - isolate: &Isolate, + cli: &Cli, base: &msg::Base<'_>, - data: libdeno::deno_buf, -) -> Box<Op> { + data: deno_buf, +) -> Box<OpWithError> { assert_eq!(data.len(), 0); let inner = base.inner_as_rename().unwrap(); let oldpath = PathBuf::from(inner.oldpath().unwrap()); let newpath_ = inner.newpath().unwrap(); let newpath = PathBuf::from(newpath_); - if let Err(e) = isolate.check_write(&newpath_) { + if let Err(e) = cli.check_write(&newpath_) { return odd_future(e); } blocking(base.sync(), move || -> OpResult { @@ -1319,17 +1317,17 @@ fn op_rename( } fn op_symlink( - isolate: &Isolate, + cli: &Cli, base: &msg::Base<'_>, - data: libdeno::deno_buf, -) -> Box<Op> { + data: deno_buf, +) -> Box<OpWithError> { assert_eq!(data.len(), 0); let inner = base.inner_as_symlink().unwrap(); let oldname = PathBuf::from(inner.oldname().unwrap()); let newname_ = inner.newname().unwrap(); let newname = PathBuf::from(newname_); - if let Err(e) = isolate.check_write(&newname_) { + if let Err(e) = cli.check_write(&newname_) { return odd_future(e); } // TODO Use type for Windows. @@ -1348,17 +1346,17 @@ fn op_symlink( } fn op_read_link( - isolate: &Isolate, + cli: &Cli, base: &msg::Base<'_>, - data: libdeno::deno_buf, -) -> Box<Op> { + data: deno_buf, +) -> Box<OpWithError> { assert_eq!(data.len(), 0); let inner = base.inner_as_readlink().unwrap(); let cmd_id = base.cmd_id(); let name_ = inner.name().unwrap(); let name = PathBuf::from(name_); - if let Err(e) = isolate.check_read(&name_) { + if let Err(e) = cli.check_read(&name_) { return odd_future(e); } @@ -1386,17 +1384,17 @@ fn op_read_link( } fn op_repl_start( - isolate: &Isolate, + cli: &Cli, base: &msg::Base<'_>, - data: libdeno::deno_buf, -) -> Box<Op> { + data: deno_buf, +) -> Box<OpWithError> { assert_eq!(data.len(), 0); let inner = base.inner_as_repl_start().unwrap(); let cmd_id = base.cmd_id(); let history_file = String::from(inner.history_file().unwrap()); debug!("op_repl_start {}", history_file); - let history_path = repl::history_path(&isolate.state.dir, &history_file); + let history_path = repl::history_path(&cli.state.dir, &history_file); let repl = repl::Repl::new(history_path); let resource = resources::add_repl(repl); @@ -1417,10 +1415,10 @@ fn op_repl_start( } fn op_repl_readline( - _isolate: &Isolate, + _cli: &Cli, base: &msg::Base<'_>, - data: libdeno::deno_buf, -) -> Box<Op> { + data: deno_buf, +) -> Box<OpWithError> { assert_eq!(data.len(), 0); let inner = base.inner_as_repl_readline().unwrap(); let cmd_id = base.cmd_id(); @@ -1453,17 +1451,17 @@ fn op_repl_readline( } fn op_truncate( - isolate: &Isolate, + cli: &Cli, base: &msg::Base<'_>, - data: libdeno::deno_buf, -) -> Box<Op> { + data: deno_buf, +) -> Box<OpWithError> { assert_eq!(data.len(), 0); let inner = base.inner_as_truncate().unwrap(); let filename = String::from(inner.name().unwrap()); let len = inner.len(); - if let Err(e) = isolate.check_write(&filename) { + if let Err(e) = cli.check_write(&filename) { return odd_future(e); } @@ -1476,12 +1474,12 @@ fn op_truncate( } fn op_listen( - isolate: &Isolate, + cli: &Cli, base: &msg::Base<'_>, - data: libdeno::deno_buf, -) -> Box<Op> { + data: deno_buf, +) -> Box<OpWithError> { assert_eq!(data.len(), 0); - if let Err(e) = isolate.check_net("listen") { + if let Err(e) = cli.check_net("listen") { return odd_future(e); } @@ -1538,12 +1536,12 @@ fn new_conn(cmd_id: u32, tcp_stream: TcpStream) -> OpResult { } fn op_accept( - isolate: &Isolate, + cli: &Cli, base: &msg::Base<'_>, - data: libdeno::deno_buf, -) -> Box<Op> { + data: deno_buf, +) -> Box<OpWithError> { assert_eq!(data.len(), 0); - if let Err(e) = isolate.check_net("accept") { + if let Err(e) = cli.check_net("accept") { return odd_future(e); } let cmd_id = base.cmd_id(); @@ -1564,12 +1562,12 @@ fn op_accept( } fn op_dial( - isolate: &Isolate, + cli: &Cli, base: &msg::Base<'_>, - data: libdeno::deno_buf, -) -> Box<Op> { + data: deno_buf, +) -> Box<OpWithError> { assert_eq!(data.len(), 0); - if let Err(e) = isolate.check_net("dial") { + if let Err(e) = cli.check_net("dial") { return odd_future(e); } let cmd_id = base.cmd_id(); @@ -1590,17 +1588,17 @@ fn op_dial( } fn op_metrics( - isolate: &Isolate, + cli: &Cli, base: &msg::Base<'_>, - data: libdeno::deno_buf, -) -> Box<Op> { + data: deno_buf, +) -> Box<OpWithError> { assert_eq!(data.len(), 0); let cmd_id = base.cmd_id(); let builder = &mut FlatBufferBuilder::new(); let inner = msg::MetricsRes::create( builder, - &msg::MetricsResArgs::from(&isolate.state.metrics), + &msg::MetricsResArgs::from(&cli.state.metrics), ); ok_future(serialize_response( cmd_id, @@ -1614,10 +1612,10 @@ fn op_metrics( } fn op_resources( - _isolate: &Isolate, + _cli: &Cli, base: &msg::Base<'_>, - data: libdeno::deno_buf, -) -> Box<Op> { + data: deno_buf, +) -> Box<OpWithError> { assert_eq!(data.len(), 0); let cmd_id = base.cmd_id(); @@ -1665,15 +1663,11 @@ fn subprocess_stdio_map(v: msg::ProcessStdio) -> std::process::Stdio { } } -fn op_run( - isolate: &Isolate, - base: &msg::Base<'_>, - data: libdeno::deno_buf, -) -> Box<Op> { +fn op_run(cli: &Cli, base: &msg::Base<'_>, data: deno_buf) -> Box<OpWithError> { assert!(base.sync()); let cmd_id = base.cmd_id(); - if let Err(e) = isolate.check_run() { + if let Err(e) = cli.check_run() { return odd_future(e); } @@ -1739,16 +1733,16 @@ fn op_run( } fn op_run_status( - isolate: &Isolate, + cli: &Cli, base: &msg::Base<'_>, - data: libdeno::deno_buf, -) -> Box<Op> { + data: deno_buf, +) -> Box<OpWithError> { assert_eq!(data.len(), 0); let cmd_id = base.cmd_id(); let inner = base.inner_as_run_status().unwrap(); let rid = inner.rid(); - if let Err(e) = isolate.check_run() { + if let Err(e) = cli.check_run() { return odd_future(e); } @@ -1815,15 +1809,15 @@ impl Future for GetMessageFuture { } fn op_worker_get_message( - isolate: &Isolate, + cli: &Cli, base: &msg::Base<'_>, - data: libdeno::deno_buf, -) -> Box<Op> { + data: deno_buf, +) -> Box<OpWithError> { assert_eq!(data.len(), 0); let cmd_id = base.cmd_id(); let op = GetMessageFuture { - state: isolate.state.clone(), + state: cli.state.clone(), }; let op = op.map_err(move |_| -> DenoError { unimplemented!() }); let op = op.and_then(move |maybe_buf| -> DenoResult<Buf> { @@ -1849,16 +1843,16 @@ fn op_worker_get_message( } fn op_worker_post_message( - isolate: &Isolate, + cli: &Cli, base: &msg::Base<'_>, - data: libdeno::deno_buf, -) -> Box<Op> { + data: deno_buf, +) -> Box<OpWithError> { let cmd_id = base.cmd_id(); let d = Vec::from(data.as_ref()).into_boxed_slice(); - assert!(isolate.state.worker_channels.is_some()); - let tx = match isolate.state.worker_channels { + assert!(cli.state.worker_channels.is_some()); + let tx = match cli.state.worker_channels { None => panic!("expected worker_channels"), Some(ref wc) => { let wc = wc.lock().unwrap(); @@ -1884,13 +1878,13 @@ fn op_worker_post_message( #[cfg(test)] mod tests { use super::*; - use crate::isolate::{Isolate, IsolateState}; + use crate::cli::Cli; use crate::isolate_init::IsolateInit; use crate::permissions::{DenoPermissions, PermissionAccessor}; #[test] fn fetch_module_meta_fails_without_read() { - let state = IsolateState::mock(); + let state = Arc::new(IsolateState::mock()); let permissions = DenoPermissions { allow_write: PermissionAccessor::from(true), allow_env: PermissionAccessor::from(true), @@ -1898,13 +1892,12 @@ mod tests { allow_run: PermissionAccessor::from(true), ..Default::default() }; - let isolate = Isolate::new( + let cli = Cli::new( IsolateInit { snapshot: None, init_script: None, }, state, - dispatch, permissions, ); let builder = &mut FlatBufferBuilder::new(); @@ -1922,11 +1915,8 @@ mod tests { msg::finish_base_buffer(builder, base); let data = builder.finished_data(); let final_msg = msg::get_root_as_base(&data); - let fetch_result = op_fetch_module_meta_data( - &isolate, - &final_msg, - libdeno::deno_buf::empty(), - ).wait(); + let fetch_result = + op_fetch_module_meta_data(&cli, &final_msg, deno_buf::empty()).wait(); match fetch_result { Ok(_) => assert!(true), Err(e) => assert_eq!(e.to_string(), permission_denied().to_string()), @@ -1935,7 +1925,7 @@ mod tests { #[test] fn fetch_module_meta_fails_without_write() { - let state = IsolateState::mock(); + let state = Arc::new(IsolateState::mock()); let permissions = DenoPermissions { allow_read: PermissionAccessor::from(true), allow_env: PermissionAccessor::from(true), @@ -1943,13 +1933,12 @@ mod tests { allow_run: PermissionAccessor::from(true), ..Default::default() }; - let isolate = Isolate::new( + let cli = Cli::new( IsolateInit { snapshot: None, init_script: None, }, state, - dispatch, permissions, ); let builder = &mut FlatBufferBuilder::new(); @@ -1967,11 +1956,8 @@ mod tests { msg::finish_base_buffer(builder, base); let data = builder.finished_data(); let final_msg = msg::get_root_as_base(&data); - let fetch_result = op_fetch_module_meta_data( - &isolate, - &final_msg, - libdeno::deno_buf::empty(), - ).wait(); + let fetch_result = + op_fetch_module_meta_data(&cli, &final_msg, deno_buf::empty()).wait(); match fetch_result { Ok(_) => assert!(true), Err(e) => assert_eq!(e.to_string(), permission_denied().to_string()), @@ -1980,7 +1966,7 @@ mod tests { #[test] fn fetch_module_meta_fails_without_net() { - let state = IsolateState::mock(); + let state = Arc::new(IsolateState::mock()); let permissions = DenoPermissions { allow_read: PermissionAccessor::from(true), allow_write: PermissionAccessor::from(true), @@ -1988,13 +1974,12 @@ mod tests { allow_run: PermissionAccessor::from(true), ..Default::default() }; - let isolate = Isolate::new( + let cli = Cli::new( IsolateInit { snapshot: None, init_script: None, }, state, - dispatch, permissions, ); let builder = &mut FlatBufferBuilder::new(); @@ -2012,11 +1997,8 @@ mod tests { msg::finish_base_buffer(builder, base); let data = builder.finished_data(); let final_msg = msg::get_root_as_base(&data); - let fetch_result = op_fetch_module_meta_data( - &isolate, - &final_msg, - libdeno::deno_buf::empty(), - ).wait(); + let fetch_result = + op_fetch_module_meta_data(&cli, &final_msg, deno_buf::empty()).wait(); match fetch_result { Ok(_) => assert!(true), Err(e) => assert_eq!(e.to_string(), permission_denied().to_string()), @@ -2025,20 +2007,19 @@ mod tests { #[test] fn fetch_module_meta_not_permission_denied_with_permissions() { - let state = IsolateState::mock(); + let state = Arc::new(IsolateState::mock()); let permissions = DenoPermissions { allow_read: PermissionAccessor::from(true), allow_write: PermissionAccessor::from(true), allow_net: PermissionAccessor::from(true), ..Default::default() }; - let isolate = Isolate::new( + let cli = Cli::new( IsolateInit { snapshot: None, init_script: None, }, state, - dispatch, permissions, ); let builder = &mut FlatBufferBuilder::new(); @@ -2056,11 +2037,8 @@ mod tests { msg::finish_base_buffer(builder, base); let data = builder.finished_data(); let final_msg = msg::get_root_as_base(&data); - let fetch_result = op_fetch_module_meta_data( - &isolate, - &final_msg, - libdeno::deno_buf::empty(), - ).wait(); + let fetch_result = + op_fetch_module_meta_data(&cli, &final_msg, deno_buf::empty()).wait(); match fetch_result { Ok(_) => assert!(true), Err(e) => assert!(e.to_string() != permission_denied().to_string()), |