summaryrefslogtreecommitdiff
path: root/src/ops.rs
diff options
context:
space:
mode:
Diffstat (limited to 'src/ops.rs')
-rw-r--r--src/ops.rs486
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()),