summaryrefslogtreecommitdiff
path: root/cli/ops
diff options
context:
space:
mode:
Diffstat (limited to 'cli/ops')
-rw-r--r--cli/ops/compiler.rs10
-rw-r--r--cli/ops/dispatch_json.rs53
-rw-r--r--cli/ops/dispatch_minimal.rs76
-rw-r--r--cli/ops/errors.rs6
-rw-r--r--cli/ops/fetch.rs15
-rw-r--r--cli/ops/fs.rs122
-rw-r--r--cli/ops/fs_events.rs14
-rw-r--r--cli/ops/idna.rs16
-rw-r--r--cli/ops/io.rs68
-rw-r--r--cli/ops/net.rs61
-rw-r--r--cli/ops/net_unix.rs16
-rw-r--r--cli/ops/os.rs20
-rw-r--r--cli/ops/permissions.rs29
-rw-r--r--cli/ops/plugin.rs8
-rw-r--r--cli/ops/process.rs24
-rw-r--r--cli/ops/random.rs4
-rw-r--r--cli/ops/repl.rs8
-rw-r--r--cli/ops/resources.rs8
-rw-r--r--cli/ops/runtime.rs8
-rw-r--r--cli/ops/runtime_compiler.rs6
-rw-r--r--cli/ops/signal.rs17
-rw-r--r--cli/ops/timers.rs16
-rw-r--r--cli/ops/tls.rs44
-rw-r--r--cli/ops/tty.rs49
-rw-r--r--cli/ops/web_worker.rs18
-rw-r--r--cli/ops/worker_host.rs16
26 files changed, 379 insertions, 353 deletions
diff --git a/cli/ops/compiler.rs b/cli/ops/compiler.rs
index 7ad4aece3..c35043e2d 100644
--- a/cli/ops/compiler.rs
+++ b/cli/ops/compiler.rs
@@ -1,10 +1,10 @@
// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
use super::dispatch_json::{JsonOp, Value};
-use crate::op_error::OpError;
use crate::ops::json_op;
use crate::state::State;
use deno_core::CoreIsolate;
use deno_core::CoreIsolateState;
+use deno_core::ErrBox;
use deno_core::ZeroCopyBuf;
use std::rc::Rc;
use std::sync::Arc;
@@ -36,18 +36,18 @@ pub fn compiler_op<D>(
&mut deno_core::CoreIsolateState,
Value,
&mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError>
+) -> Result<JsonOp, ErrBox>
where
D: Fn(
Arc<Mutex<Option<String>>>,
Value,
&mut [ZeroCopyBuf],
- ) -> Result<JsonOp, OpError>,
+ ) -> Result<JsonOp, ErrBox>,
{
move |_isolate_state: &mut CoreIsolateState,
args: Value,
zero_copy: &mut [ZeroCopyBuf]|
- -> Result<JsonOp, OpError> {
+ -> Result<JsonOp, ErrBox> {
dispatcher(response.clone(), args, zero_copy)
}
}
@@ -56,7 +56,7 @@ fn op_compiler_respond(
response: Arc<Mutex<Option<String>>>,
args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
let mut r = response.lock().unwrap();
assert!(
r.is_none(),
diff --git a/cli/ops/dispatch_json.rs b/cli/ops/dispatch_json.rs
index 5ed7e6c6d..6e0eddac8 100644
--- a/cli/ops/dispatch_json.rs
+++ b/cli/ops/dispatch_json.rs
@@ -1,7 +1,7 @@
// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
-use crate::op_error::OpError;
use deno_core::Buf;
use deno_core::CoreIsolateState;
+use deno_core::ErrBox;
use deno_core::Op;
use deno_core::ZeroCopyBuf;
use futures::future::FutureExt;
@@ -11,7 +11,7 @@ pub use serde_json::Value;
use std::future::Future;
use std::pin::Pin;
-pub type JsonResult = Result<Value, OpError>;
+pub type JsonResult = Result<Value, ErrBox>;
pub type AsyncJsonOp = Pin<Box<dyn Future<Output = JsonResult>>>;
@@ -23,17 +23,18 @@ pub enum JsonOp {
AsyncUnref(AsyncJsonOp),
}
-fn json_err(err: OpError) -> Value {
- json!({
- "message": err.msg,
- "kind": err.kind_str,
- })
-}
-
-pub fn serialize_result(promise_id: Option<u64>, result: JsonResult) -> Buf {
+pub fn serialize_result(
+ rust_err_to_json_fn: &'static dyn deno_core::RustErrToJsonFn,
+ promise_id: Option<u64>,
+ result: JsonResult,
+) -> Buf {
let value = match result {
Ok(v) => json!({ "ok": v, "promiseId": promise_id }),
- Err(err) => json!({ "err": json_err(err), "promiseId": promise_id }),
+ Err(err) => {
+ let serialized_err = (&rust_err_to_json_fn)(&err);
+ let err_value: Value = serde_json::from_slice(&serialized_err).unwrap();
+ json!({ "err": err_value, "promiseId": promise_id })
+ }
};
serde_json::to_vec(&value).unwrap().into_boxed_slice()
}
@@ -52,14 +53,15 @@ where
&mut CoreIsolateState,
Value,
&mut [ZeroCopyBuf],
- ) -> Result<JsonOp, OpError>,
+ ) -> Result<JsonOp, ErrBox>,
{
move |isolate_state: &mut CoreIsolateState, zero_copy: &mut [ZeroCopyBuf]| {
assert!(!zero_copy.is_empty(), "Expected JSON string at position 0");
+ let rust_err_to_json_fn = isolate_state.rust_err_to_json_fn;
let async_args: AsyncArgs = match serde_json::from_slice(&zero_copy[0]) {
Ok(args) => args,
Err(e) => {
- let buf = serialize_result(None, Err(OpError::from(e)));
+ let buf = serialize_result(rust_err_to_json_fn, None, Err(e.into()));
return Op::Sync(buf);
}
};
@@ -67,31 +69,44 @@ where
let is_sync = promise_id.is_none();
let result = serde_json::from_slice(&zero_copy[0])
- .map_err(OpError::from)
+ .map_err(ErrBox::from)
.and_then(|args| d(isolate_state, args, &mut zero_copy[1..]));
// Convert to Op
match result {
Ok(JsonOp::Sync(sync_value)) => {
assert!(promise_id.is_none());
- Op::Sync(serialize_result(promise_id, Ok(sync_value)))
+ Op::Sync(serialize_result(
+ rust_err_to_json_fn,
+ promise_id,
+ Ok(sync_value),
+ ))
}
Ok(JsonOp::Async(fut)) => {
assert!(promise_id.is_some());
let fut2 = fut.then(move |result| {
- futures::future::ready(serialize_result(promise_id, result))
+ futures::future::ready(serialize_result(
+ rust_err_to_json_fn,
+ promise_id,
+ result,
+ ))
});
Op::Async(fut2.boxed_local())
}
Ok(JsonOp::AsyncUnref(fut)) => {
assert!(promise_id.is_some());
let fut2 = fut.then(move |result| {
- futures::future::ready(serialize_result(promise_id, result))
+ futures::future::ready(serialize_result(
+ rust_err_to_json_fn,
+ promise_id,
+ result,
+ ))
});
Op::AsyncUnref(fut2.boxed_local())
}
Err(sync_err) => {
- let buf = serialize_result(promise_id, Err(sync_err));
+ let buf =
+ serialize_result(rust_err_to_json_fn, promise_id, Err(sync_err));
if is_sync {
Op::Sync(buf)
} else {
@@ -102,7 +117,7 @@ where
}
}
-pub fn blocking_json<F>(is_sync: bool, f: F) -> Result<JsonOp, OpError>
+pub fn blocking_json<F>(is_sync: bool, f: F) -> Result<JsonOp, ErrBox>
where
F: 'static + Send + FnOnce() -> JsonResult,
{
diff --git a/cli/ops/dispatch_minimal.rs b/cli/ops/dispatch_minimal.rs
index df7d48b4e..b0dc7ad8a 100644
--- a/cli/ops/dispatch_minimal.rs
+++ b/cli/ops/dispatch_minimal.rs
@@ -4,19 +4,22 @@
//! alternative to flatbuffers using a very simple list of int32s to lay out
//! messages. The first i32 is used to determine if a message a flatbuffer
//! message or a "minimal" message.
-use crate::op_error::OpError;
-use byteorder::{LittleEndian, WriteBytesExt};
+use crate::errors::get_error_class;
use deno_core::Buf;
use deno_core::CoreIsolateState;
+use deno_core::ErrBox;
use deno_core::Op;
use deno_core::ZeroCopyBuf;
use futures::future::FutureExt;
use std::future::Future;
+use std::iter::repeat;
+use std::mem::size_of_val;
use std::pin::Pin;
+use std::slice;
pub enum MinimalOp {
- Sync(Result<i32, OpError>),
- Async(Pin<Box<dyn Future<Output = Result<i32, OpError>>>>),
+ Sync(Result<i32, ErrBox>),
+ Async(Pin<Box<dyn Future<Output = Result<i32, ErrBox>>>>),
}
#[derive(Copy, Clone, Debug, PartialEq)]
@@ -40,24 +43,38 @@ pub struct ErrorRecord {
pub promise_id: i32,
pub arg: i32,
pub error_len: i32,
- pub error_code: Vec<u8>,
+ pub error_class: &'static [u8],
pub error_message: Vec<u8>,
}
impl Into<Buf> for ErrorRecord {
fn into(self) -> Buf {
- let v32: Vec<i32> = vec![self.promise_id, self.arg, self.error_len];
- let mut v8: Vec<u8> = Vec::new();
- for n in v32 {
- v8.write_i32::<LittleEndian>(n).unwrap();
- }
- let mut code = self.error_code;
- let mut message = self.error_message;
- v8.append(&mut code);
- v8.append(&mut message);
- // Align to 32bit word, padding with the space character.
- v8.resize((v8.len() + 3usize) & !3usize, b' ');
- v8.into_boxed_slice()
+ let Self {
+ promise_id,
+ arg,
+ error_len,
+ error_class,
+ error_message,
+ ..
+ } = self;
+ let header_i32 = [promise_id, arg, error_len];
+ let header_u8 = unsafe {
+ slice::from_raw_parts(
+ &header_i32 as *const _ as *const u8,
+ size_of_val(&header_i32),
+ )
+ };
+ let padded_len =
+ (header_u8.len() + error_class.len() + error_message.len() + 3usize)
+ & !3usize;
+ header_u8
+ .iter()
+ .cloned()
+ .chain(error_class.iter().cloned())
+ .chain(error_message.into_iter())
+ .chain(repeat(b' '))
+ .take(padded_len)
+ .collect()
}
}
@@ -71,7 +88,7 @@ fn test_error_record() {
promise_id: 1,
arg: -1,
error_len: 11,
- error_code: "BadResource".to_string().as_bytes().to_owned(),
+ error_class: b"BadResource",
error_message: "Error".to_string().as_bytes().to_owned(),
};
let buf: Buf = err_record.into();
@@ -129,13 +146,14 @@ where
let mut record = match parse_min_record(&zero_copy[0]) {
Some(r) => r,
None => {
- let e = OpError::type_error("Unparsable control buffer".to_string());
+ let error = ErrBox::type_error("Unparsable control buffer");
+ let error_class = get_error_class(&error);
let error_record = ErrorRecord {
promise_id: 0,
arg: -1,
- error_len: e.kind_str.len() as i32,
- error_code: e.kind_str.as_bytes().to_owned(),
- error_message: e.msg.as_bytes().to_owned(),
+ error_len: error_class.len() as i32,
+ error_class: error_class.as_bytes(),
+ error_message: error.to_string().as_bytes().to_owned(),
};
return Op::Sync(error_record.into());
}
@@ -151,12 +169,13 @@ where
record.into()
}
Err(err) => {
+ let error_class = get_error_class(&err);
let error_record = ErrorRecord {
promise_id: record.promise_id,
arg: -1,
- error_len: err.kind_str.len() as i32,
- error_code: err.kind_str.as_bytes().to_owned(),
- error_message: err.msg.as_bytes().to_owned(),
+ error_len: error_class.len() as i32,
+ error_class: error_class.as_bytes(),
+ error_message: err.to_string().as_bytes().to_owned(),
};
error_record.into()
}
@@ -169,12 +188,13 @@ where
record.into()
}
Err(err) => {
+ let error_class = get_error_class(&err);
let error_record = ErrorRecord {
promise_id: record.promise_id,
arg: -1,
- error_len: err.kind_str.len() as i32,
- error_code: err.kind_str.as_bytes().to_owned(),
- error_message: err.msg.as_bytes().to_owned(),
+ error_len: error_class.len() as i32,
+ error_class: error_class.as_bytes(),
+ error_message: err.to_string().as_bytes().to_owned(),
};
error_record.into()
}
diff --git a/cli/ops/errors.rs b/cli/ops/errors.rs
index 02295d7f8..b9405fe54 100644
--- a/cli/ops/errors.rs
+++ b/cli/ops/errors.rs
@@ -1,11 +1,11 @@
// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
use super::dispatch_json::{Deserialize, JsonOp, Value};
use crate::diagnostics::Diagnostic;
-use crate::op_error::OpError;
use crate::source_maps::get_orig_position;
use crate::source_maps::CachedMaps;
use crate::state::State;
use deno_core::CoreIsolate;
+use deno_core::ErrBox;
use deno_core::ZeroCopyBuf;
use std::collections::HashMap;
use std::rc::Rc;
@@ -33,7 +33,7 @@ fn op_apply_source_map(
state: &Rc<State>,
args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
let args: ApplySourceMap = serde_json::from_value(args)?;
let mut mappings_map: CachedMaps = HashMap::new();
@@ -57,7 +57,7 @@ fn op_format_diagnostic(
_state: &Rc<State>,
args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
let diagnostic = serde_json::from_value::<Diagnostic>(args)?;
Ok(JsonOp::Sync(json!(diagnostic.to_string())))
}
diff --git a/cli/ops/fetch.rs b/cli/ops/fetch.rs
index b320222ed..c7bfaf9f1 100644
--- a/cli/ops/fetch.rs
+++ b/cli/ops/fetch.rs
@@ -2,10 +2,10 @@
use super::dispatch_json::{Deserialize, JsonOp, Value};
use super::io::{StreamResource, StreamResourceHolder};
use crate::http_util::{create_http_client, HttpBody};
-use crate::op_error::OpError;
use crate::state::State;
use deno_core::CoreIsolate;
use deno_core::CoreIsolateState;
+use deno_core::ErrBox;
use deno_core::ZeroCopyBuf;
use futures::future::FutureExt;
use http::header::HeaderName;
@@ -38,7 +38,7 @@ pub fn op_fetch(
state: &Rc<State>,
args: Value,
data: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
let args: FetchArgs = serde_json::from_value(args)?;
let url = args.url;
let resource_table_ = isolate_state.resource_table.borrow();
@@ -47,7 +47,7 @@ pub fn op_fetch(
let client = if let Some(rid) = args.client_rid {
let r = resource_table_
.get::<HttpClientResource>(rid)
- .ok_or_else(OpError::bad_resource_id)?;
+ .ok_or_else(ErrBox::bad_resource_id)?;
&r.client
} else {
client_ref_mut = state.http_client.borrow_mut();
@@ -55,17 +55,16 @@ pub fn op_fetch(
};
let method = match args.method {
- Some(method_str) => Method::from_bytes(method_str.as_bytes())
- .map_err(|e| OpError::other(e.to_string()))?,
+ Some(method_str) => Method::from_bytes(method_str.as_bytes())?,
None => Method::GET,
};
- let url_ = url::Url::parse(&url).map_err(OpError::from)?;
+ let url_ = url::Url::parse(&url)?;
// Check scheme before asking for net permission
let scheme = url_.scheme();
if scheme != "http" && scheme != "https" {
- return Err(OpError::type_error(format!(
+ return Err(ErrBox::type_error(format!(
"scheme '{}' not supported",
scheme
)));
@@ -142,7 +141,7 @@ fn op_create_http_client(
state: &Rc<State>,
args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
let args: CreateHttpClientOptions = serde_json::from_value(args)?;
let mut resource_table = isolate_state.resource_table.borrow_mut();
diff --git a/cli/ops/fs.rs b/cli/ops/fs.rs
index 0fd6ad5ef..00736b813 100644
--- a/cli/ops/fs.rs
+++ b/cli/ops/fs.rs
@@ -3,12 +3,12 @@
use super::dispatch_json::{blocking_json, Deserialize, JsonOp, Value};
use super::io::std_file_resource;
use super::io::{FileMetadata, StreamResource, StreamResourceHolder};
-use crate::op_error::OpError;
use crate::ops::dispatch_json::JsonResult;
use crate::state::State;
use deno_core::BufVec;
use deno_core::CoreIsolate;
use deno_core::CoreIsolateState;
+use deno_core::ErrBox;
use deno_core::ResourceTable;
use deno_core::ZeroCopyBuf;
use futures::future::FutureExt;
@@ -55,8 +55,11 @@ pub fn init(i: &mut CoreIsolate, s: &Rc<State>) {
i.register_op("op_utime", s.stateful_json_op(op_utime));
}
-fn into_string(s: std::ffi::OsString) -> Result<String, OpError> {
- s.into_string().map_err(|_| OpError::invalid_utf8())
+fn into_string(s: std::ffi::OsString) -> Result<String, ErrBox> {
+ s.into_string().map_err(|s| {
+ let message = format!("File name or path {:?} is not valid UTF-8", s);
+ ErrBox::new("InvalidData", message)
+ })
}
#[derive(Deserialize)]
@@ -82,7 +85,7 @@ struct OpenOptions {
fn open_helper(
state: &State,
args: Value,
-) -> Result<(PathBuf, std::fs::OpenOptions), OpError> {
+) -> Result<(PathBuf, std::fs::OpenOptions), ErrBox> {
let args: OpenArgs = serde_json::from_value(args)?;
let path = Path::new(&args.path).to_path_buf();
@@ -125,7 +128,7 @@ fn op_open_sync(
resource_table: &mut ResourceTable,
args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<Value, OpError> {
+) -> Result<Value, ErrBox> {
let (path, open_options) = open_helper(state, args)?;
let std_file = open_options.open(path)?;
let tokio_file = tokio::fs::File::from_std(std_file);
@@ -144,7 +147,7 @@ async fn op_open_async(
resource_table: Rc<RefCell<ResourceTable>>,
args: Value,
_zero_copy: BufVec,
-) -> Result<Value, OpError> {
+) -> Result<Value, ErrBox> {
let (path, open_options) = open_helper(&state, args)?;
let tokio_file = tokio::fs::OpenOptions::from(open_options)
.open(path)
@@ -173,7 +176,7 @@ fn op_seek(
_state: &Rc<State>,
args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
use std::io::{Seek, SeekFrom};
let args: SeekArgs = serde_json::from_value(args)?;
let rid = args.rid as u32;
@@ -185,10 +188,7 @@ fn op_seek(
1 => SeekFrom::Current(offset),
2 => SeekFrom::End(offset),
_ => {
- return Err(OpError::type_error(format!(
- "Invalid seek mode: {}",
- whence
- )));
+ return Err(ErrBox::type_error(format!("Invalid seek mode: {}", whence)));
}
};
@@ -198,8 +198,8 @@ fn op_seek(
if is_sync {
let mut resource_table = resource_table.borrow_mut();
let pos = std_file_resource(&mut resource_table, rid, |r| match r {
- Ok(std_file) => std_file.seek(seek_from).map_err(OpError::from),
- Err(_) => Err(OpError::type_error(
+ Ok(std_file) => std_file.seek(seek_from).map_err(ErrBox::from),
+ Err(_) => Err(ErrBox::type_error(
"cannot seek on this type of resource".to_string(),
)),
})?;
@@ -210,8 +210,8 @@ fn op_seek(
let fut = async move {
let mut resource_table = resource_table.borrow_mut();
let pos = std_file_resource(&mut resource_table, rid, |r| match r {
- Ok(std_file) => std_file.seek(seek_from).map_err(OpError::from),
- Err(_) => Err(OpError::type_error(
+ Ok(std_file) => std_file.seek(seek_from).map_err(ErrBox::from),
+ Err(_) => Err(ErrBox::type_error(
"cannot seek on this type of resource".to_string(),
)),
})?;
@@ -233,7 +233,7 @@ fn op_fdatasync(
state: &Rc<State>,
args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
state.check_unstable("Deno.fdatasync");
let args: FdatasyncArgs = serde_json::from_value(args)?;
let rid = args.rid as u32;
@@ -244,8 +244,8 @@ fn op_fdatasync(
if is_sync {
let mut resource_table = resource_table.borrow_mut();
std_file_resource(&mut resource_table, rid, |r| match r {
- Ok(std_file) => std_file.sync_data().map_err(OpError::from),
- Err(_) => Err(OpError::type_error(
+ Ok(std_file) => std_file.sync_data().map_err(ErrBox::from),
+ Err(_) => Err(ErrBox::type_error(
"cannot sync this type of resource".to_string(),
)),
})?;
@@ -254,8 +254,8 @@ fn op_fdatasync(
let fut = async move {
let mut resource_table = resource_table.borrow_mut();
std_file_resource(&mut resource_table, rid, |r| match r {
- Ok(std_file) => std_file.sync_data().map_err(OpError::from),
- Err(_) => Err(OpError::type_error(
+ Ok(std_file) => std_file.sync_data().map_err(ErrBox::from),
+ Err(_) => Err(ErrBox::type_error(
"cannot sync this type of resource".to_string(),
)),
})?;
@@ -277,7 +277,7 @@ fn op_fsync(
state: &Rc<State>,
args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
state.check_unstable("Deno.fsync");
let args: FsyncArgs = serde_json::from_value(args)?;
let rid = args.rid as u32;
@@ -288,8 +288,8 @@ fn op_fsync(
if is_sync {
let mut resource_table = resource_table.borrow_mut();
std_file_resource(&mut resource_table, rid, |r| match r {
- Ok(std_file) => std_file.sync_all().map_err(OpError::from),
- Err(_) => Err(OpError::type_error(
+ Ok(std_file) => std_file.sync_all().map_err(ErrBox::from),
+ Err(_) => Err(ErrBox::type_error(
"cannot sync this type of resource".to_string(),
)),
})?;
@@ -298,8 +298,8 @@ fn op_fsync(
let fut = async move {
let mut resource_table = resource_table.borrow_mut();
std_file_resource(&mut resource_table, rid, |r| match r {
- Ok(std_file) => std_file.sync_all().map_err(OpError::from),
- Err(_) => Err(OpError::type_error(
+ Ok(std_file) => std_file.sync_all().map_err(ErrBox::from),
+ Err(_) => Err(ErrBox::type_error(
"cannot sync this type of resource".to_string(),
)),
})?;
@@ -321,7 +321,7 @@ fn op_fstat(
state: &Rc<State>,
args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
state.check_unstable("Deno.fstat");
let args: FstatArgs = serde_json::from_value(args)?;
let rid = args.rid as u32;
@@ -332,8 +332,8 @@ fn op_fstat(
if is_sync {
let mut resource_table = resource_table.borrow_mut();
let metadata = std_file_resource(&mut resource_table, rid, |r| match r {
- Ok(std_file) => std_file.metadata().map_err(OpError::from),
- Err(_) => Err(OpError::type_error(
+ Ok(std_file) => std_file.metadata().map_err(ErrBox::from),
+ Err(_) => Err(ErrBox::type_error(
"cannot stat this type of resource".to_string(),
)),
})?;
@@ -343,8 +343,8 @@ fn op_fstat(
let mut resource_table = resource_table.borrow_mut();
let metadata =
std_file_resource(&mut resource_table, rid, |r| match r {
- Ok(std_file) => std_file.metadata().map_err(OpError::from),
- Err(_) => Err(OpError::type_error(
+ Ok(std_file) => std_file.metadata().map_err(ErrBox::from),
+ Err(_) => Err(ErrBox::type_error(
"cannot stat this type of resource".to_string(),
)),
})?;
@@ -363,7 +363,7 @@ fn op_umask(
state: &Rc<State>,
args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
state.check_unstable("Deno.umask");
let args: UmaskArgs = serde_json::from_value(args)?;
// TODO implement umask for Windows
@@ -372,7 +372,7 @@ fn op_umask(
#[cfg(not(unix))]
{
let _ = args.mask; // avoid unused warning.
- Err(OpError::not_implemented())
+ Err(ErrBox::not_supported())
}
#[cfg(unix)]
{
@@ -401,7 +401,7 @@ fn op_chdir(
state: &Rc<State>,
args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
let args: ChdirArgs = serde_json::from_value(args)?;
let d = PathBuf::from(&args.directory);
state.check_read(&d)?;
@@ -422,7 +422,7 @@ fn op_mkdir(
state: &Rc<State>,
args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
let args: MkdirArgs = serde_json::from_value(args)?;
let path = Path::new(&args.path).to_path_buf();
let mode = args.mode.unwrap_or(0o777) & 0o777;
@@ -456,7 +456,7 @@ fn op_chmod(
state: &Rc<State>,
args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
let args: ChmodArgs = serde_json::from_value(args)?;
let path = Path::new(&args.path).to_path_buf();
let mode = args.mode & 0o777;
@@ -478,7 +478,7 @@ fn op_chmod(
{
// Still check file/dir exists on Windows
let _metadata = std::fs::metadata(&path)?;
- Err(OpError::not_implemented())
+ Err(ErrBox::not_supported())
}
})
}
@@ -496,7 +496,7 @@ fn op_chown(
state: &Rc<State>,
args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
let args: ChownArgs = serde_json::from_value(args)?;
let path = Path::new(&args.path).to_path_buf();
@@ -515,9 +515,7 @@ fn op_chown(
}
// TODO Implement chown for Windows
#[cfg(not(unix))]
- {
- Err(OpError::not_implemented())
- }
+ Err(ErrBox::not_supported())
})
}
@@ -533,7 +531,7 @@ fn op_remove(
state: &Rc<State>,
args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
let args: RemoveArgs = serde_json::from_value(args)?;
let path = PathBuf::from(&args.path);
let recursive = args.recursive;
@@ -587,7 +585,7 @@ fn op_copy_file(
state: &Rc<State>,
args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
let args: CopyFileArgs = serde_json::from_value(args)?;
let from = PathBuf::from(&args.from);
let to = PathBuf::from(&args.to);
@@ -602,7 +600,7 @@ fn op_copy_file(
// See https://github.com/rust-lang/rust/issues/54800
// Once the issue is resolved, we should remove this workaround.
if cfg!(unix) && !from.is_file() {
- return Err(OpError::not_found("File not found".to_string()));
+ return Err(ErrBox::new("NotFound", "File not found"));
}
// returns size of from as u64 (we ignore)
@@ -681,7 +679,7 @@ fn op_stat(
state: &Rc<State>,
args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
let args: StatArgs = serde_json::from_value(args)?;
let path = PathBuf::from(&args.path);
let lstat = args.lstat;
@@ -711,7 +709,7 @@ fn op_realpath(
state: &Rc<State>,
args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
let args: RealpathArgs = serde_json::from_value(args)?;
let path = PathBuf::from(&args.path);
@@ -746,7 +744,7 @@ fn op_read_dir(
state: &Rc<State>,
args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
let args: ReadDirArgs = serde_json::from_value(args)?;
let path = PathBuf::from(&args.path);
@@ -789,7 +787,7 @@ fn op_rename(
state: &Rc<State>,
args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
let args: RenameArgs = serde_json::from_value(args)?;
let oldpath = PathBuf::from(&args.oldpath);
let newpath = PathBuf::from(&args.newpath);
@@ -818,7 +816,7 @@ fn op_link(
state: &Rc<State>,
args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
state.check_unstable("Deno.link");
let args: LinkArgs = serde_json::from_value(args)?;
let oldpath = PathBuf::from(&args.oldpath);
@@ -856,7 +854,7 @@ fn op_symlink(
state: &Rc<State>,
args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
state.check_unstable("Deno.symlink");
let args: SymlinkArgs = serde_json::from_value(args)?;
let oldpath = PathBuf::from(&args.oldpath);
@@ -881,7 +879,7 @@ fn op_symlink(
Some(options) => match options._type.as_ref() {
"file" => symlink_file(&oldpath, &newpath)?,
"dir" => symlink_dir(&oldpath, &newpath)?,
- _ => return Err(OpError::type_error("unsupported type".to_string())),
+ _ => return Err(ErrBox::type_error("unsupported type".to_string())),
},
None => {
let old_meta = std::fs::metadata(&oldpath);
@@ -893,7 +891,7 @@ fn op_symlink(
symlink_dir(&oldpath, &newpath)?
}
}
- Err(_) => return Err(OpError::type_error(
+ Err(_) => return Err(ErrBox::type_error(
"you must pass a `options` argument for non-existent target path in windows"
.to_string(),
)),
@@ -916,7 +914,7 @@ fn op_read_link(
state: &Rc<State>,
args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
let args: ReadLinkArgs = serde_json::from_value(args)?;
let path = PathBuf::from(&args.path);
@@ -944,7 +942,7 @@ fn op_ftruncate(
state: &Rc<State>,
args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
state.check_unstable("Deno.ftruncate");
let args: FtruncateArgs = serde_json::from_value(args)?;
let rid = args.rid as u32;
@@ -956,8 +954,8 @@ fn op_ftruncate(
if is_sync {
let mut resource_table = resource_table.borrow_mut();
std_file_resource(&mut resource_table, rid, |r| match r {
- Ok(std_file) => std_file.set_len(len).map_err(OpError::from),
- Err(_) => Err(OpError::type_error(
+ Ok(std_file) => std_file.set_len(len).map_err(ErrBox::from),
+ Err(_) => Err(ErrBox::type_error(
"cannot truncate this type of resource".to_string(),
)),
})?;
@@ -966,8 +964,8 @@ fn op_ftruncate(
let fut = async move {
let mut resource_table = resource_table.borrow_mut();
std_file_resource(&mut resource_table, rid, |r| match r {
- Ok(std_file) => std_file.set_len(len).map_err(OpError::from),
- Err(_) => Err(OpError::type_error(
+ Ok(std_file) => std_file.set_len(len).map_err(ErrBox::from),
+ Err(_) => Err(ErrBox::type_error(
"cannot truncate this type of resource".to_string(),
)),
})?;
@@ -989,7 +987,7 @@ fn op_truncate(
state: &Rc<State>,
args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
let args: TruncateArgs = serde_json::from_value(args)?;
let path = PathBuf::from(&args.path);
let len = args.len;
@@ -1063,7 +1061,7 @@ fn op_make_temp_dir(
state: &Rc<State>,
args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
let args: MakeTempArgs = serde_json::from_value(args)?;
let dir = args.dir.map(|s| PathBuf::from(&s));
@@ -1094,7 +1092,7 @@ fn op_make_temp_file(
state: &Rc<State>,
args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
let args: MakeTempArgs = serde_json::from_value(args)?;
let dir = args.dir.map(|s| PathBuf::from(&s));
@@ -1134,7 +1132,7 @@ fn op_utime(
state: &Rc<State>,
args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
state.check_unstable("Deno.utime");
let args: UtimeArgs = serde_json::from_value(args)?;
@@ -1154,7 +1152,7 @@ fn op_cwd(
state: &Rc<State>,
_args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
let path = current_dir()?;
state.check_read_blind(&path, "CWD")?;
let path_str = into_string(path.into_os_string())?;
diff --git a/cli/ops/fs_events.rs b/cli/ops/fs_events.rs
index fcaf138f8..e798796be 100644
--- a/cli/ops/fs_events.rs
+++ b/cli/ops/fs_events.rs
@@ -1,6 +1,5 @@
// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
use super::dispatch_json::{Deserialize, JsonOp, Value};
-use crate::op_error::OpError;
use crate::state::State;
use deno_core::CoreIsolate;
use deno_core::CoreIsolateState;
@@ -68,7 +67,7 @@ pub fn op_fs_events_open(
state: &Rc<State>,
args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
#[derive(Deserialize)]
struct OpenArgs {
recursive: bool,
@@ -84,8 +83,7 @@ pub fn op_fs_events_open(
// Ignore result, if send failed it means that watcher was already closed,
// but not all messages have been flushed.
let _ = sender.try_send(res2);
- })
- .map_err(ErrBox::from)?;
+ })?;
let recursive_mode = if args.recursive {
RecursiveMode::Recursive
} else {
@@ -93,7 +91,7 @@ pub fn op_fs_events_open(
};
for path in &args.paths {
state.check_read(&PathBuf::from(path))?;
- watcher.watch(path, recursive_mode).map_err(ErrBox::from)?;
+ watcher.watch(path, recursive_mode)?;
}
let resource = FsEventsResource { watcher, receiver };
let mut resource_table = isolate_state.resource_table.borrow_mut();
@@ -106,7 +104,7 @@ pub fn op_fs_events_poll(
_state: &Rc<State>,
args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
#[derive(Deserialize)]
struct PollArgs {
rid: u32,
@@ -117,13 +115,13 @@ pub fn op_fs_events_poll(
let mut resource_table = resource_table.borrow_mut();
let watcher = resource_table
.get_mut::<FsEventsResource>(rid)
- .ok_or_else(OpError::bad_resource_id)?;
+ .ok_or_else(ErrBox::bad_resource_id)?;
watcher
.receiver
.poll_recv(cx)
.map(|maybe_result| match maybe_result {
Some(Ok(value)) => Ok(json!({ "value": value, "done": false })),
- Some(Err(err)) => Err(OpError::from(err)),
+ Some(Err(err)) => Err(err),
None => Ok(json!({ "done": true })),
})
});
diff --git a/cli/ops/idna.rs b/cli/ops/idna.rs
index c76ceba89..9585e0977 100644
--- a/cli/ops/idna.rs
+++ b/cli/ops/idna.rs
@@ -3,9 +3,9 @@
//! https://url.spec.whatwg.org/#idna
use super::dispatch_json::{Deserialize, JsonOp, Value};
-use crate::op_error::OpError;
use crate::state::State;
use deno_core::CoreIsolate;
+use deno_core::ErrBox;
use deno_core::ZeroCopyBuf;
use idna::{domain_to_ascii, domain_to_ascii_strict};
use std::rc::Rc;
@@ -25,14 +25,16 @@ fn op_domain_to_ascii(
_state: &Rc<State>,
args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
let args: DomainToAscii = serde_json::from_value(args)?;
- let domain = if args.be_strict {
+ if args.be_strict {
domain_to_ascii_strict(args.domain.as_str())
- .map_err(|_| OpError::invalid_domain_error())?
} else {
domain_to_ascii(args.domain.as_str())
- .map_err(|_| OpError::invalid_domain_error())?
- };
- Ok(JsonOp::Sync(json!(domain)))
+ }
+ .map_err(|err| {
+ let message = format!("Invalid IDNA encoded domain name: {:?}", err);
+ ErrBox::new("URIError", message)
+ })
+ .map(|domain| JsonOp::Sync(json!(domain)))
}
diff --git a/cli/ops/io.rs b/cli/ops/io.rs
index 4d03e0ef7..6b97f542c 100644
--- a/cli/ops/io.rs
+++ b/cli/ops/io.rs
@@ -1,9 +1,9 @@
use super::dispatch_minimal::MinimalOp;
use crate::http_util::HttpBody;
-use crate::op_error::OpError;
use crate::state::State;
use deno_core::CoreIsolate;
use deno_core::CoreIsolateState;
+use deno_core::ErrBox;
use deno_core::ResourceTable;
use deno_core::ZeroCopyBuf;
use futures::future::poll_fn;
@@ -116,8 +116,8 @@ fn get_stdio_stream(
}
}
-fn no_buffer_specified() -> OpError {
- OpError::type_error("no buffer specified".to_string())
+fn no_buffer_specified() -> ErrBox {
+ ErrBox::type_error("no buffer specified".to_string())
}
#[cfg(unix)]
@@ -159,7 +159,7 @@ impl Drop for StreamResourceHolder {
}
impl StreamResourceHolder {
- pub fn track_task(&mut self, cx: &Context) -> Result<usize, OpError> {
+ pub fn track_task(&mut self, cx: &Context) -> Result<usize, ErrBox> {
let waker = futures::task::AtomicWaker::new();
waker.register(cx.waker());
// Its OK if it overflows
@@ -200,13 +200,13 @@ impl<T: AsyncRead + Unpin> UnpinAsyncRead for T {}
impl<T: AsyncWrite + Unpin> UnpinAsyncWrite for T {}
/// `DenoAsyncRead` is the same as the `tokio_io::AsyncRead` trait
-/// but uses an `OpError` error instead of `std::io:Error`
+/// but uses an `ErrBox` error instead of `std::io:Error`
pub trait DenoAsyncRead {
fn poll_read(
&mut self,
cx: &mut Context,
buf: &mut [u8],
- ) -> Poll<Result<usize, OpError>>;
+ ) -> Poll<Result<usize, ErrBox>>;
}
impl DenoAsyncRead for StreamResource {
@@ -214,11 +214,11 @@ impl DenoAsyncRead for StreamResource {
&mut self,
cx: &mut Context,
buf: &mut [u8],
- ) -> Poll<Result<usize, OpError>> {
+ ) -> Poll<Result<usize, ErrBox>> {
use StreamResource::*;
let f: &mut dyn UnpinAsyncRead = match self {
FsFile(Some((f, _))) => f,
- FsFile(None) => return Poll::Ready(Err(OpError::resource_unavailable())),
+ FsFile(None) => return Poll::Ready(Err(ErrBox::resource_unavailable())),
Stdin(f, _) => f,
TcpStream(Some(f)) => f,
#[cfg(not(windows))]
@@ -228,7 +228,7 @@ impl DenoAsyncRead for StreamResource {
ChildStdout(f) => f,
ChildStderr(f) => f,
HttpBody(f) => f,
- _ => return Err(OpError::bad_resource_id()).into(),
+ _ => return Err(ErrBox::bad_resource_id()).into(),
};
let v = ready!(Pin::new(f).poll_read(cx, buf))?;
Ok(v).into()
@@ -260,9 +260,9 @@ pub fn op_read(
std_file
.read(&mut zero_copy[0])
.map(|n: usize| n as i32)
- .map_err(OpError::from)
+ .map_err(ErrBox::from)
}
- Err(_) => Err(OpError::type_error(
+ Err(_) => Err(ErrBox::type_error(
"sync read not allowed on this resource".to_string(),
)),
})
@@ -274,13 +274,10 @@ pub fn op_read(
let mut resource_table = resource_table.borrow_mut();
let resource_holder = resource_table
.get_mut::<StreamResourceHolder>(rid as u32)
- .ok_or_else(OpError::bad_resource_id)?;
+ .ok_or_else(ErrBox::bad_resource_id)?;
let mut task_tracker_id: Option<usize> = None;
- let nread = match resource_holder
- .resource
- .poll_read(cx, &mut zero_copy)
- .map_err(OpError::from)
+ let nread = match resource_holder.resource.poll_read(cx, &mut zero_copy)
{
Poll::Ready(t) => {
if let Some(id) = task_tracker_id {
@@ -301,17 +298,17 @@ pub fn op_read(
}
/// `DenoAsyncWrite` is the same as the `tokio_io::AsyncWrite` trait
-/// but uses an `OpError` error instead of `std::io:Error`
+/// but uses an `ErrBox` error instead of `std::io:Error`
pub trait DenoAsyncWrite {
fn poll_write(
&mut self,
cx: &mut Context,
buf: &[u8],
- ) -> Poll<Result<usize, OpError>>;
+ ) -> Poll<Result<usize, ErrBox>>;
- fn poll_close(&mut self, cx: &mut Context) -> Poll<Result<(), OpError>>;
+ fn poll_close(&mut self, cx: &mut Context) -> Poll<Result<(), ErrBox>>;
- fn poll_flush(&mut self, cx: &mut Context) -> Poll<Result<(), OpError>>;
+ fn poll_flush(&mut self, cx: &mut Context) -> Poll<Result<(), ErrBox>>;
}
impl DenoAsyncWrite for StreamResource {
@@ -319,7 +316,7 @@ impl DenoAsyncWrite for StreamResource {
&mut self,
cx: &mut Context,
buf: &[u8],
- ) -> Poll<Result<usize, OpError>> {
+ ) -> Poll<Result<usize, ErrBox>> {
use StreamResource::*;
let f: &mut dyn UnpinAsyncWrite = match self {
FsFile(Some((f, _))) => f,
@@ -330,14 +327,14 @@ impl DenoAsyncWrite for StreamResource {
ClientTlsStream(f) => f,
ServerTlsStream(f) => f,
ChildStdin(f) => f,
- _ => return Err(OpError::bad_resource_id()).into(),
+ _ => return Err(ErrBox::bad_resource_id()).into(),
};
let v = ready!(Pin::new(f).poll_write(cx, buf))?;
Ok(v).into()
}
- fn poll_flush(&mut self, cx: &mut Context) -> Poll<Result<(), OpError>> {
+ fn poll_flush(&mut self, cx: &mut Context) -> Poll<Result<(), ErrBox>> {
use StreamResource::*;
let f: &mut dyn UnpinAsyncWrite = match self {
FsFile(Some((f, _))) => f,
@@ -348,14 +345,14 @@ impl DenoAsyncWrite for StreamResource {
ClientTlsStream(f) => f,
ServerTlsStream(f) => f,
ChildStdin(f) => f,
- _ => return Err(OpError::bad_resource_id()).into(),
+ _ => return Err(ErrBox::bad_resource_id()).into(),
};
ready!(Pin::new(f).poll_flush(cx))?;
Ok(()).into()
}
- fn poll_close(&mut self, _cx: &mut Context) -> Poll<Result<(), OpError>> {
+ fn poll_close(&mut self, _cx: &mut Context) -> Poll<Result<(), ErrBox>> {
unimplemented!()
}
}
@@ -384,9 +381,9 @@ pub fn op_write(
std_file
.write(&zero_copy[0])
.map(|nwritten: usize| nwritten as i32)
- .map_err(OpError::from)
+ .map_err(ErrBox::from)
}
- Err(_) => Err(OpError::type_error(
+ Err(_) => Err(ErrBox::type_error(
"sync read not allowed on this resource".to_string(),
)),
})
@@ -400,7 +397,7 @@ pub fn op_write(
let mut resource_table = resource_table.borrow_mut();
let resource_holder = resource_table
.get_mut::<StreamResourceHolder>(rid as u32)
- .ok_or_else(OpError::bad_resource_id)?;
+ .ok_or_else(ErrBox::bad_resource_id)?;
resource_holder.resource.poll_write(cx, &zero_copy)
})
.await?;
@@ -413,7 +410,7 @@ pub fn op_write(
let mut resource_table = resource_table.borrow_mut();
let resource_holder = resource_table
.get_mut::<StreamResourceHolder>(rid as u32)
- .ok_or_else(OpError::bad_resource_id)?;
+ .ok_or_else(ErrBox::bad_resource_id)?;
resource_holder.resource.poll_flush(cx)
})
.await?;
@@ -436,11 +433,10 @@ pub fn std_file_resource<F, T>(
resource_table: &mut ResourceTable,
rid: u32,
mut f: F,
-) -> Result<T, OpError>
+) -> Result<T, ErrBox>
where
- F: FnMut(
- Result<&mut std::fs::File, &mut StreamResource>,
- ) -> Result<T, OpError>,
+ F:
+ FnMut(Result<&mut std::fs::File, &mut StreamResource>) -> Result<T, ErrBox>,
{
// First we look up the rid in the resource table.
let mut r = resource_table.get_mut::<StreamResourceHolder>(rid);
@@ -469,16 +465,16 @@ where
// some operation is in-flight.
resource_holder.resource =
StreamResource::FsFile(Some((tokio_file, metadata)));
- Err(OpError::resource_unavailable())
+ Err(ErrBox::resource_unavailable())
}
}
} else {
- Err(OpError::resource_unavailable())
+ Err(ErrBox::resource_unavailable())
}
}
_ => f(Err(&mut resource_holder.resource)),
}
} else {
- Err(OpError::bad_resource_id())
+ Err(ErrBox::bad_resource_id())
}
}
diff --git a/cli/ops/net.rs b/cli/ops/net.rs
index 445c69106..25639cb79 100644
--- a/cli/ops/net.rs
+++ b/cli/ops/net.rs
@@ -1,16 +1,15 @@
// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
use super::dispatch_json::{Deserialize, JsonOp, Value};
use super::io::{StreamResource, StreamResourceHolder};
-use crate::op_error::OpError;
use crate::resolve_addr::resolve_addr;
use crate::state::State;
use deno_core::CoreIsolate;
use deno_core::CoreIsolateState;
+use deno_core::ErrBox;
use deno_core::ResourceTable;
use deno_core::ZeroCopyBuf;
use futures::future::poll_fn;
use futures::future::FutureExt;
-use std::convert::From;
use std::net::Shutdown;
use std::net::SocketAddr;
use std::rc::Rc;
@@ -45,7 +44,7 @@ fn accept_tcp(
isolate_state: &mut CoreIsolateState,
args: AcceptArgs,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
let rid = args.rid as u32;
let resource_table = isolate_state.resource_table.clone();
@@ -55,10 +54,10 @@ fn accept_tcp(
let listener_resource = resource_table
.get_mut::<TcpListenerResource>(rid)
.ok_or_else(|| {
- OpError::bad_resource("Listener has been closed".to_string())
+ ErrBox::bad_resource("Listener has been closed".to_string())
})?;
let listener = &mut listener_resource.listener;
- match listener.poll_accept(cx).map_err(OpError::from) {
+ match listener.poll_accept(cx).map_err(ErrBox::from) {
Poll::Ready(Ok((stream, addr))) => {
listener_resource.untrack_task();
Poll::Ready(Ok((stream, addr)))
@@ -106,13 +105,13 @@ fn op_accept(
_state: &Rc<State>,
args: Value,
zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
let args: AcceptArgs = serde_json::from_value(args)?;
match args.transport.as_str() {
"tcp" => accept_tcp(isolate_state, args, zero_copy),
#[cfg(unix)]
"unix" => net_unix::accept_unix(isolate_state, args.rid as u32, zero_copy),
- _ => Err(OpError::other(format!(
+ _ => Err(ErrBox::error(format!(
"Unsupported transport protocol {}",
args.transport
))),
@@ -130,7 +129,7 @@ fn receive_udp(
_state: &Rc<State>,
args: ReceiveArgs,
zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
assert_eq!(zero_copy.len(), 1, "Invalid number of arguments");
let mut zero_copy = zero_copy[0].clone();
@@ -144,12 +143,12 @@ fn receive_udp(
let resource = resource_table
.get_mut::<UdpSocketResource>(rid)
.ok_or_else(|| {
- OpError::bad_resource("Socket has been closed".to_string())
+ ErrBox::bad_resource("Socket has been closed".to_string())
})?;
let socket = &mut resource.socket;
socket
.poll_recv_from(cx, &mut zero_copy)
- .map_err(OpError::from)
+ .map_err(ErrBox::from)
});
let (size, remote_addr) = receive_fut.await?;
Ok(json!({
@@ -170,7 +169,7 @@ fn op_datagram_receive(
state: &Rc<State>,
args: Value,
zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
assert_eq!(zero_copy.len(), 1, "Invalid number of arguments");
let args: ReceiveArgs = serde_json::from_value(args)?;
@@ -180,7 +179,7 @@ fn op_datagram_receive(
"unixpacket" => {
net_unix::receive_unix_packet(isolate_state, args.rid as u32, zero_copy)
}
- _ => Err(OpError::other(format!(
+ _ => Err(ErrBox::error(format!(
"Unsupported transport protocol {}",
args.transport
))),
@@ -200,7 +199,7 @@ fn op_datagram_send(
state: &Rc<State>,
args: Value,
zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
assert_eq!(zero_copy.len(), 1, "Invalid number of arguments");
let zero_copy = zero_copy[0].clone();
@@ -218,13 +217,13 @@ fn op_datagram_send(
let resource = resource_table
.get_mut::<UdpSocketResource>(rid as u32)
.ok_or_else(|| {
- OpError::bad_resource("Socket has been closed".to_string())
+ ErrBox::bad_resource("Socket has been closed".to_string())
})?;
resource
.socket
.poll_send_to(cx, &zero_copy, &addr)
- .map_err(OpError::from)
.map_ok(|byte_length| json!(byte_length))
+ .map_err(ErrBox::from)
});
Ok(JsonOp::Async(f.boxed_local()))
}
@@ -241,9 +240,8 @@ fn op_datagram_send(
let resource = resource_table
.get_mut::<net_unix::UnixDatagramResource>(rid as u32)
.ok_or_else(|| {
- OpError::other("Socket has been closed".to_string())
+ ErrBox::new("NotConnected", "Socket has been closed")
})?;
-
let socket = &mut resource.socket;
let byte_length = socket
.send_to(&zero_copy, &resource.local_addr.as_pathname().unwrap())
@@ -254,7 +252,7 @@ fn op_datagram_send(
Ok(JsonOp::Async(op.boxed_local()))
}
- _ => Err(OpError::other("Wrong argument format!".to_owned())),
+ _ => Err(ErrBox::type_error("Wrong argument format!")),
}
}
@@ -270,7 +268,7 @@ fn op_connect(
state: &Rc<State>,
args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
let resource_table = isolate_state.resource_table.clone();
match serde_json::from_value(args)? {
ConnectArgs {
@@ -341,7 +339,7 @@ fn op_connect(
};
Ok(JsonOp::Async(op.boxed_local()))
}
- _ => Err(OpError::other("Wrong argument format!".to_owned())),
+ _ => Err(ErrBox::type_error("Wrong argument format!")),
}
}
@@ -356,7 +354,7 @@ fn op_shutdown(
state: &Rc<State>,
args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
state.check_unstable("Deno.shutdown");
let args: ShutdownArgs = serde_json::from_value(args)?;
@@ -373,17 +371,16 @@ fn op_shutdown(
let mut resource_table = isolate_state.resource_table.borrow_mut();
let resource_holder = resource_table
.get_mut::<StreamResourceHolder>(rid)
- .ok_or_else(OpError::bad_resource_id)?;
+ .ok_or_else(ErrBox::bad_resource_id)?;
match resource_holder.resource {
StreamResource::TcpStream(Some(ref mut stream)) => {
- TcpStream::shutdown(stream, shutdown_mode).map_err(OpError::from)?;
+ TcpStream::shutdown(stream, shutdown_mode)?;
}
#[cfg(unix)]
StreamResource::UnixStream(ref mut stream) => {
- net_unix::UnixStream::shutdown(stream, shutdown_mode)
- .map_err(OpError::from)?;
+ net_unix::UnixStream::shutdown(stream, shutdown_mode)?;
}
- _ => return Err(OpError::bad_resource_id()),
+ _ => return Err(ErrBox::bad_resource_id()),
}
Ok(JsonOp::Sync(json!({})))
@@ -407,13 +404,13 @@ impl TcpListenerResource {
/// can be notified when listener is closed.
///
/// Throws an error if another task is already tracked.
- pub fn track_task(&mut self, cx: &Context) -> Result<(), OpError> {
+ pub fn track_task(&mut self, cx: &Context) -> Result<(), ErrBox> {
// Currently, we only allow tracking a single accept task for a listener.
// This might be changed in the future with multiple workers.
// Caveat: TcpListener by itself also only tracks an accept task at a time.
// See https://github.com/tokio-rs/tokio/issues/846#issuecomment-454208883
if self.waker.is_some() {
- return Err(OpError::other("Another accept task is ongoing".to_string()));
+ return Err(ErrBox::new("Busy", "Another accept task is ongoing"));
}
let waker = futures::task::AtomicWaker::new();
@@ -466,7 +463,7 @@ struct ListenArgs {
fn listen_tcp(
resource_table: &mut ResourceTable,
addr: SocketAddr,
-) -> Result<(u32, SocketAddr), OpError> {
+) -> Result<(u32, SocketAddr), ErrBox> {
let std_listener = std::net::TcpListener::bind(&addr)?;
let listener = TcpListener::from_std(std_listener)?;
let local_addr = listener.local_addr()?;
@@ -483,7 +480,7 @@ fn listen_tcp(
fn listen_udp(
resource_table: &mut ResourceTable,
addr: SocketAddr,
-) -> Result<(u32, SocketAddr), OpError> {
+) -> Result<(u32, SocketAddr), ErrBox> {
let std_socket = std::net::UdpSocket::bind(&addr)?;
let socket = UdpSocket::from_std(std_socket)?;
let local_addr = socket.local_addr()?;
@@ -498,7 +495,7 @@ fn op_listen(
state: &Rc<State>,
args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
let mut resource_table = isolate_state.resource_table.borrow_mut();
match serde_json::from_value(args)? {
ListenArgs {
@@ -563,6 +560,6 @@ fn op_listen(
})))
}
#[cfg(unix)]
- _ => Err(OpError::other("Wrong argument format!".to_owned())),
+ _ => Err(ErrBox::type_error("Wrong argument format!")),
}
}
diff --git a/cli/ops/net_unix.rs b/cli/ops/net_unix.rs
index 0b2ceb75a..d8f6c6736 100644
--- a/cli/ops/net_unix.rs
+++ b/cli/ops/net_unix.rs
@@ -1,7 +1,7 @@
use super::dispatch_json::{Deserialize, JsonOp};
use super::io::{StreamResource, StreamResourceHolder};
-use crate::op_error::OpError;
use deno_core::CoreIsolateState;
+use deno_core::ErrBox;
use deno_core::ResourceTable;
use deno_core::ZeroCopyBuf;
use futures::future::FutureExt;
@@ -30,13 +30,13 @@ pub fn accept_unix(
isolate_state: &mut CoreIsolateState,
rid: u32,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
let resource_table = isolate_state.resource_table.clone();
{
let _ = resource_table
.borrow()
.get::<UnixListenerResource>(rid)
- .ok_or_else(OpError::bad_resource_id)?;
+ .ok_or_else(ErrBox::bad_resource_id)?;
}
let op = async move {
let mut resource_table_ = resource_table.borrow_mut();
@@ -44,7 +44,7 @@ pub fn accept_unix(
resource_table_
.get_mut::<UnixListenerResource>(rid)
.ok_or_else(|| {
- OpError::bad_resource("Listener has been closed".to_string())
+ ErrBox::bad_resource("Listener has been closed".to_string())
})?
};
@@ -81,7 +81,7 @@ pub fn receive_unix_packet(
isolate_state: &mut CoreIsolateState,
rid: u32,
zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
assert_eq!(zero_copy.len(), 1, "Invalid number of arguments");
let mut zero_copy = zero_copy[0].clone();
let resource_table = isolate_state.resource_table.clone();
@@ -91,7 +91,7 @@ pub fn receive_unix_packet(
let resource = resource_table_
.get_mut::<UnixDatagramResource>(rid)
.ok_or_else(|| {
- OpError::bad_resource("Socket has been closed".to_string())
+ ErrBox::bad_resource("Socket has been closed".to_string())
})?;
let (size, remote_addr) = resource.socket.recv_from(&mut zero_copy).await?;
Ok(json!({
@@ -109,7 +109,7 @@ pub fn receive_unix_packet(
pub fn listen_unix(
resource_table: &mut ResourceTable,
addr: &Path,
-) -> Result<(u32, unix::net::SocketAddr), OpError> {
+) -> Result<(u32, unix::net::SocketAddr), ErrBox> {
if addr.exists() {
remove_file(&addr).unwrap();
}
@@ -124,7 +124,7 @@ pub fn listen_unix(
pub fn listen_unix_packet(
resource_table: &mut ResourceTable,
addr: &Path,
-) -> Result<(u32, unix::net::SocketAddr), OpError> {
+) -> Result<(u32, unix::net::SocketAddr), ErrBox> {
if addr.exists() {
remove_file(&addr).unwrap();
}
diff --git a/cli/ops/os.rs b/cli/ops/os.rs
index e46aff3e6..1b961164e 100644
--- a/cli/ops/os.rs
+++ b/cli/ops/os.rs
@@ -1,8 +1,8 @@
// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
use super::dispatch_json::{Deserialize, JsonOp, Value};
-use crate::op_error::OpError;
use crate::state::State;
use deno_core::CoreIsolate;
+use deno_core::ErrBox;
use deno_core::ZeroCopyBuf;
use std::collections::HashMap;
use std::env;
@@ -25,7 +25,7 @@ fn op_exec_path(
state: &Rc<State>,
_args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
let current_exe = env::current_exe().unwrap();
state.check_read_blind(&current_exe, "exec_path")?;
// Now apply URL parser to current exe to get fully resolved path, otherwise
@@ -45,7 +45,7 @@ fn op_set_env(
state: &Rc<State>,
args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
let args: SetEnv = serde_json::from_value(args)?;
state.check_env()?;
env::set_var(args.key, args.value);
@@ -56,7 +56,7 @@ fn op_env(
state: &Rc<State>,
_args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
state.check_env()?;
let v = env::vars().collect::<HashMap<String, String>>();
Ok(JsonOp::Sync(json!(v)))
@@ -71,7 +71,7 @@ fn op_get_env(
state: &Rc<State>,
args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
let args: GetEnv = serde_json::from_value(args)?;
state.check_env()?;
let r = match env::var(args.key) {
@@ -90,7 +90,7 @@ fn op_delete_env(
state: &Rc<State>,
args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
let args: DeleteEnv = serde_json::from_value(args)?;
state.check_env()?;
env::remove_var(args.key);
@@ -106,7 +106,7 @@ fn op_exit(
_s: &Rc<State>,
args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
let args: Exit = serde_json::from_value(args)?;
std::process::exit(args.code)
}
@@ -115,7 +115,7 @@ fn op_loadavg(
state: &Rc<State>,
_args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
state.check_unstable("Deno.loadavg");
state.check_env()?;
match sys_info::loadavg() {
@@ -132,7 +132,7 @@ fn op_hostname(
state: &Rc<State>,
_args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
state.check_unstable("Deno.hostname");
state.check_env()?;
let hostname = sys_info::hostname().unwrap_or_else(|_| "".to_string());
@@ -143,7 +143,7 @@ fn op_os_release(
state: &Rc<State>,
_args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
state.check_unstable("Deno.osRelease");
state.check_env()?;
let release = sys_info::os_release().unwrap_or_else(|_| "".to_string());
diff --git a/cli/ops/permissions.rs b/cli/ops/permissions.rs
index 4cb998536..6ebabfa5c 100644
--- a/cli/ops/permissions.rs
+++ b/cli/ops/permissions.rs
@@ -1,8 +1,8 @@
// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
use super::dispatch_json::{Deserialize, JsonOp, Value};
-use crate::op_error::OpError;
use crate::state::State;
use deno_core::CoreIsolate;
+use deno_core::ErrBox;
use deno_core::ZeroCopyBuf;
use std::path::Path;
use std::rc::Rc;
@@ -33,7 +33,7 @@ pub fn op_query_permission(
state: &Rc<State>,
args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
let args: PermissionArgs = serde_json::from_value(args)?;
let permissions = state.permissions.borrow();
let path = args.path.as_deref();
@@ -45,7 +45,12 @@ pub fn op_query_permission(
"run" => permissions.query_run(),
"plugin" => permissions.query_plugin(),
"hrtime" => permissions.query_hrtime(),
- n => return Err(OpError::other(format!("No such permission name: {}", n))),
+ n => {
+ return Err(ErrBox::new(
+ "ReferenceError",
+ format!("No such permission name: {}", n),
+ ))
+ }
};
Ok(JsonOp::Sync(json!({ "state": perm.to_string() })))
}
@@ -54,7 +59,7 @@ pub fn op_revoke_permission(
state: &Rc<State>,
args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
let args: PermissionArgs = serde_json::from_value(args)?;
let mut permissions = state.permissions.borrow_mut();
let path = args.path.as_deref();
@@ -66,7 +71,12 @@ pub fn op_revoke_permission(
"run" => permissions.revoke_run(),
"plugin" => permissions.revoke_plugin(),
"hrtime" => permissions.revoke_hrtime(),
- n => return Err(OpError::other(format!("No such permission name: {}", n))),
+ n => {
+ return Err(ErrBox::new(
+ "ReferenceError",
+ format!("No such permission name: {}", n),
+ ))
+ }
};
Ok(JsonOp::Sync(json!({ "state": perm.to_string() })))
}
@@ -75,7 +85,7 @@ pub fn op_request_permission(
state: &Rc<State>,
args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
let args: PermissionArgs = serde_json::from_value(args)?;
let permissions = &mut state.permissions.borrow_mut();
let path = args.path.as_deref();
@@ -87,7 +97,12 @@ pub fn op_request_permission(
"run" => permissions.request_run(),
"plugin" => permissions.request_plugin(),
"hrtime" => permissions.request_hrtime(),
- n => return Err(OpError::other(format!("No such permission name: {}", n))),
+ n => {
+ return Err(ErrBox::new(
+ "ReferenceError",
+ format!("No such permission name: {}", n),
+ ))
+ }
};
Ok(JsonOp::Sync(json!({ "state": perm.to_string() })))
}
diff --git a/cli/ops/plugin.rs b/cli/ops/plugin.rs
index 3fb149404..f06105498 100644
--- a/cli/ops/plugin.rs
+++ b/cli/ops/plugin.rs
@@ -1,5 +1,4 @@
// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
-use crate::op_error::OpError;
use crate::ops::dispatch_json::Deserialize;
use crate::ops::dispatch_json::JsonOp;
use crate::ops::dispatch_json::Value;
@@ -8,6 +7,7 @@ use crate::state::State;
use deno_core::plugin_api;
use deno_core::CoreIsolate;
use deno_core::CoreIsolateState;
+use deno_core::ErrBox;
use deno_core::Op;
use deno_core::OpAsyncFuture;
use deno_core::OpId;
@@ -38,7 +38,7 @@ pub fn op_open_plugin(
state: &Rc<State>,
args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
state.check_unstable("Deno.openPlugin");
let args: OpenPluginArgs = serde_json::from_value(args).unwrap();
let filename = PathBuf::from(&args.filename);
@@ -46,9 +46,7 @@ pub fn op_open_plugin(
state.check_plugin(&filename)?;
debug!("Loading Plugin: {:#?}", filename);
- let plugin_lib = Library::open(filename)
- .map(Rc::new)
- .map_err(OpError::from)?;
+ let plugin_lib = Library::open(filename).map(Rc::new)?;
let plugin_resource = PluginResource::new(&plugin_lib);
let mut resource_table = isolate_state.resource_table.borrow_mut();
diff --git a/cli/ops/process.rs b/cli/ops/process.rs
index bf733a78e..1754812a2 100644
--- a/cli/ops/process.rs
+++ b/cli/ops/process.rs
@@ -1,17 +1,15 @@
// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
use super::dispatch_json::{Deserialize, JsonOp, Value};
use super::io::{std_file_resource, StreamResource, StreamResourceHolder};
-use crate::op_error::OpError;
use crate::signal::kill;
use crate::state::State;
use deno_core::CoreIsolate;
use deno_core::CoreIsolateState;
+use deno_core::ErrBox;
use deno_core::ResourceTable;
use deno_core::ZeroCopyBuf;
use futures::future::poll_fn;
use futures::future::FutureExt;
-use futures::TryFutureExt;
-use std::convert::From;
use std::rc::Rc;
use tokio::process::Command;
@@ -27,19 +25,19 @@ pub fn init(i: &mut CoreIsolate, s: &Rc<State>) {
fn clone_file(
rid: u32,
resource_table: &mut ResourceTable,
-) -> Result<std::fs::File, OpError> {
+) -> Result<std::fs::File, ErrBox> {
std_file_resource(resource_table, rid, move |r| match r {
- Ok(std_file) => std_file.try_clone().map_err(OpError::from),
- Err(_) => Err(OpError::bad_resource_id()),
+ Ok(std_file) => std_file.try_clone().map_err(ErrBox::from),
+ Err(_) => Err(ErrBox::bad_resource_id()),
})
}
-fn subprocess_stdio_map(s: &str) -> Result<std::process::Stdio, OpError> {
+fn subprocess_stdio_map(s: &str) -> Result<std::process::Stdio, ErrBox> {
match s {
"inherit" => Ok(std::process::Stdio::inherit()),
"piped" => Ok(std::process::Stdio::piped()),
"null" => Ok(std::process::Stdio::null()),
- _ => Err(OpError::other("Invalid resource for stdio".to_string())),
+ _ => Err(ErrBox::type_error("Invalid resource for stdio")),
}
}
@@ -66,7 +64,7 @@ fn op_run(
state: &Rc<State>,
args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
let run_args: RunArgs = serde_json::from_value(args)?;
state.check_run()?;
@@ -177,7 +175,7 @@ fn op_run_status(
state: &Rc<State>,
args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
let args: RunStatusArgs = serde_json::from_value(args)?;
let rid = args.rid as u32;
@@ -189,9 +187,9 @@ fn op_run_status(
let mut resource_table = resource_table.borrow_mut();
let child_resource = resource_table
.get_mut::<ChildResource>(rid)
- .ok_or_else(OpError::bad_resource_id)?;
+ .ok_or_else(ErrBox::bad_resource_id)?;
let child = &mut child_resource.child;
- child.map_err(OpError::from).poll_unpin(cx)
+ child.poll_unpin(cx).map_err(ErrBox::from)
})
.await?;
@@ -227,7 +225,7 @@ fn op_kill(
state: &Rc<State>,
args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
state.check_unstable("Deno.kill");
state.check_run()?;
diff --git a/cli/ops/random.rs b/cli/ops/random.rs
index 275f264f9..3ff5ad49f 100644
--- a/cli/ops/random.rs
+++ b/cli/ops/random.rs
@@ -1,8 +1,8 @@
// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
use super::dispatch_json::{JsonOp, Value};
-use crate::op_error::OpError;
use crate::state::State;
use deno_core::CoreIsolate;
+use deno_core::ErrBox;
use deno_core::ZeroCopyBuf;
use rand::thread_rng;
use rand::Rng;
@@ -19,7 +19,7 @@ fn op_get_random_values(
state: &Rc<State>,
_args: Value,
zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
assert_eq!(zero_copy.len(), 1);
if let Some(seeded_rng) = &state.seeded_rng {
diff --git a/cli/ops/repl.rs b/cli/ops/repl.rs
index 88b7de881..b051dd574 100644
--- a/cli/ops/repl.rs
+++ b/cli/ops/repl.rs
@@ -1,11 +1,11 @@
// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
use super::dispatch_json::{blocking_json, Deserialize, JsonOp, Value};
-use crate::op_error::OpError;
use crate::repl;
use crate::repl::Repl;
use crate::state::State;
use deno_core::CoreIsolate;
use deno_core::CoreIsolateState;
+use deno_core::ErrBox;
use deno_core::ZeroCopyBuf;
use std::rc::Rc;
use std::sync::Arc;
@@ -29,7 +29,7 @@ fn op_repl_start(
state: &Rc<State>,
args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
let args: ReplStartArgs = serde_json::from_value(args)?;
debug!("op_repl_start {}", args.history_file);
let history_path =
@@ -52,7 +52,7 @@ fn op_repl_readline(
_state: &Rc<State>,
args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
let args: ReplReadlineArgs = serde_json::from_value(args)?;
let rid = args.rid as u32;
let prompt = args.prompt;
@@ -60,7 +60,7 @@ fn op_repl_readline(
let resource_table = isolate_state.resource_table.borrow();
let resource = resource_table
.get::<ReplResource>(rid)
- .ok_or_else(OpError::bad_resource_id)?;
+ .ok_or_else(ErrBox::bad_resource_id)?;
let repl = resource.0.clone();
blocking_json(false, move || {
diff --git a/cli/ops/resources.rs b/cli/ops/resources.rs
index a24b3b382..fb3c1bc79 100644
--- a/cli/ops/resources.rs
+++ b/cli/ops/resources.rs
@@ -1,9 +1,9 @@
// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
use super::dispatch_json::{Deserialize, JsonOp, Value};
-use crate::op_error::OpError;
use crate::state::State;
use deno_core::CoreIsolate;
use deno_core::CoreIsolateState;
+use deno_core::ErrBox;
use deno_core::ZeroCopyBuf;
use std::rc::Rc;
@@ -17,7 +17,7 @@ fn op_resources(
_state: &Rc<State>,
_args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
let serialized_resources = isolate_state.resource_table.borrow().entries();
Ok(JsonOp::Sync(json!(serialized_resources)))
}
@@ -28,7 +28,7 @@ fn op_close(
_state: &Rc<State>,
args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
#[derive(Deserialize)]
struct CloseArgs {
rid: i32,
@@ -37,6 +37,6 @@ fn op_close(
let mut resource_table = isolate_state.resource_table.borrow_mut();
resource_table
.close(args.rid as u32)
- .ok_or_else(OpError::bad_resource_id)?;
+ .ok_or_else(ErrBox::bad_resource_id)?;
Ok(JsonOp::Sync(json!({})))
}
diff --git a/cli/ops/runtime.rs b/cli/ops/runtime.rs
index b4fb3c496..26e1b2a33 100644
--- a/cli/ops/runtime.rs
+++ b/cli/ops/runtime.rs
@@ -1,11 +1,11 @@
// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
use super::dispatch_json::{JsonOp, Value};
use crate::colors;
-use crate::op_error::OpError;
use crate::state::State;
use crate::version;
use crate::DenoSubcommand;
use deno_core::CoreIsolate;
+use deno_core::ErrBox;
use deno_core::ModuleSpecifier;
use deno_core::ZeroCopyBuf;
use std::env;
@@ -21,7 +21,7 @@ fn op_start(
state: &Rc<State>,
_args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
let gs = &state.global_state;
Ok(JsonOp::Sync(json!({
@@ -46,7 +46,7 @@ fn op_main_module(
state: &Rc<State>,
_args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
let main = &state.main_module.to_string();
let main_url = ModuleSpecifier::resolve_url_or_path(&main)?;
if main_url.as_url().scheme() == "file" {
@@ -60,7 +60,7 @@ fn op_metrics(
state: &Rc<State>,
_args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
let m = &state.metrics.borrow();
Ok(JsonOp::Sync(json!({
diff --git a/cli/ops/runtime_compiler.rs b/cli/ops/runtime_compiler.rs
index d77ab8f08..3aaaf019d 100644
--- a/cli/ops/runtime_compiler.rs
+++ b/cli/ops/runtime_compiler.rs
@@ -1,12 +1,12 @@
// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
use super::dispatch_json::{Deserialize, JsonOp, Value};
use crate::futures::FutureExt;
-use crate::op_error::OpError;
use crate::state::State;
use crate::tsc::runtime_bundle;
use crate::tsc::runtime_compile;
use crate::tsc::runtime_transpile;
use deno_core::CoreIsolate;
+use deno_core::ErrBox;
use deno_core::ZeroCopyBuf;
use std::collections::HashMap;
use std::rc::Rc;
@@ -29,7 +29,7 @@ fn op_compile(
state: &Rc<State>,
args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
state.check_unstable("Deno.compile");
let args: CompileArgs = serde_json::from_value(args)?;
let global_state = state.global_state.clone();
@@ -71,7 +71,7 @@ fn op_transpile(
state: &Rc<State>,
args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
state.check_unstable("Deno.transpile");
let args: TranspileArgs = serde_json::from_value(args)?;
let global_state = state.global_state.clone();
diff --git a/cli/ops/signal.rs b/cli/ops/signal.rs
index cb83427c8..3868c6e17 100644
--- a/cli/ops/signal.rs
+++ b/cli/ops/signal.rs
@@ -1,15 +1,16 @@
// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
use super::dispatch_json::{JsonOp, Value};
-use crate::op_error::OpError;
use crate::state::State;
use deno_core::CoreIsolate;
use deno_core::CoreIsolateState;
+use deno_core::ErrBox;
use deno_core::ZeroCopyBuf;
use std::rc::Rc;
#[cfg(unix)]
use super::dispatch_json::Deserialize;
#[cfg(unix)]
+#[cfg(unix)]
use futures::future::{poll_fn, FutureExt};
#[cfg(unix)]
use std::task::Waker;
@@ -45,7 +46,7 @@ fn op_signal_bind(
state: &Rc<State>,
args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
state.check_unstable("Deno.signal");
let args: BindSignalArgs = serde_json::from_value(args)?;
let mut resource_table = isolate_state.resource_table.borrow_mut();
@@ -67,7 +68,7 @@ fn op_signal_poll(
state: &Rc<State>,
args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
state.check_unstable("Deno.signal");
let args: SignalArgs = serde_json::from_value(args)?;
let rid = args.rid as u32;
@@ -94,7 +95,7 @@ pub fn op_signal_unbind(
state: &Rc<State>,
args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
state.check_unstable("Deno.signal");
let args: SignalArgs = serde_json::from_value(args)?;
let rid = args.rid as u32;
@@ -109,7 +110,7 @@ pub fn op_signal_unbind(
}
resource_table
.close(rid)
- .ok_or_else(OpError::bad_resource_id)?;
+ .ok_or_else(ErrBox::bad_resource_id)?;
Ok(JsonOp::Sync(json!({})))
}
@@ -119,7 +120,7 @@ pub fn op_signal_bind(
_state: &Rc<State>,
_args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
unimplemented!();
}
@@ -129,7 +130,7 @@ fn op_signal_unbind(
_state: &Rc<State>,
_args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
unimplemented!();
}
@@ -139,6 +140,6 @@ fn op_signal_poll(
_state: &Rc<State>,
_args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
unimplemented!();
}
diff --git a/cli/ops/timers.rs b/cli/ops/timers.rs
index e3fe14c2c..379bacf98 100644
--- a/cli/ops/timers.rs
+++ b/cli/ops/timers.rs
@@ -1,8 +1,8 @@
// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
use super::dispatch_json::{Deserialize, JsonOp, Value};
-use crate::op_error::OpError;
use crate::state::State;
use deno_core::CoreIsolate;
+use deno_core::ErrBox;
use deno_core::ZeroCopyBuf;
use futures::future::FutureExt;
use std::rc::Rc;
@@ -22,7 +22,7 @@ fn op_global_timer_stop(
state: &Rc<State>,
_args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
state.global_timer.borrow_mut().cancel();
Ok(JsonOp::Sync(json!({})))
}
@@ -36,7 +36,7 @@ fn op_global_timer(
state: &Rc<State>,
args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
let args: GlobalTimerArgs = serde_json::from_value(args)?;
let val = args.timeout;
@@ -58,7 +58,7 @@ fn op_now(
state: &Rc<State>,
_args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> 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
@@ -66,12 +66,8 @@ fn op_now(
// If the permission is not enabled
// Round the nano result on 2 milliseconds
// see: https://developer.mozilla.org/en-US/docs/Web/API/DOMHighResTimeStamp#Reduced_time_precision
- if let Err(op_error) = state.check_hrtime() {
- if op_error.kind_str == "PermissionDenied" {
- subsec_nanos -= subsec_nanos % reduced_time_precision;
- } else {
- return Err(op_error);
- }
+ if state.check_hrtime().is_err() {
+ subsec_nanos -= subsec_nanos % reduced_time_precision;
}
Ok(JsonOp::Sync(json!({
diff --git a/cli/ops/tls.rs b/cli/ops/tls.rs
index 76962f5c8..97dca9d90 100644
--- a/cli/ops/tls.rs
+++ b/cli/ops/tls.rs
@@ -1,11 +1,11 @@
// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
use super::dispatch_json::{Deserialize, JsonOp, Value};
use super::io::{StreamResource, StreamResourceHolder};
-use crate::op_error::OpError;
use crate::resolve_addr::resolve_addr;
use crate::state::State;
use deno_core::CoreIsolate;
use deno_core::CoreIsolateState;
+use deno_core::ErrBox;
use deno_core::ZeroCopyBuf;
use futures::future::poll_fn;
use futures::future::FutureExt;
@@ -59,7 +59,7 @@ pub fn op_start_tls(
state: &Rc<State>,
args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
state.check_unstable("Deno.startTls");
let args: StartTLSArgs = serde_json::from_value(args)?;
let rid = args.rid as u32;
@@ -81,7 +81,7 @@ pub fn op_start_tls(
let mut resource_table_ = resource_table.borrow_mut();
match resource_table_.remove::<StreamResourceHolder>(rid) {
Some(resource) => *resource,
- None => return Err(OpError::bad_resource_id()),
+ None => return Err(ErrBox::bad_resource_id()),
}
};
@@ -127,7 +127,7 @@ pub fn op_start_tls(
}
}))
} else {
- Err(OpError::bad_resource_id())
+ Err(ErrBox::bad_resource_id())
}
};
Ok(JsonOp::Async(op.boxed_local()))
@@ -138,7 +138,7 @@ pub fn op_connect_tls(
state: &Rc<State>,
args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
let args: ConnectTLSArgs = serde_json::from_value(args)?;
let cert_file = args.cert_file.clone();
let resource_table = isolate_state.resource_table.clone();
@@ -195,31 +195,31 @@ pub fn op_connect_tls(
Ok(JsonOp::Async(op.boxed_local()))
}
-fn load_certs(path: &str) -> Result<Vec<Certificate>, OpError> {
+fn load_certs(path: &str) -> Result<Vec<Certificate>, ErrBox> {
let cert_file = File::open(path)?;
let reader = &mut BufReader::new(cert_file);
let certs = certs(reader)
- .map_err(|_| OpError::other("Unable to decode certificate".to_string()))?;
+ .map_err(|_| ErrBox::new("InvalidData", "Unable to decode certificate"))?;
if certs.is_empty() {
- let e = OpError::other("No certificates found in cert file".to_string());
+ let e = ErrBox::new("InvalidData", "No certificates found in cert file");
return Err(e);
}
Ok(certs)
}
-fn key_decode_err() -> OpError {
- OpError::other("Unable to decode key".to_string())
+fn key_decode_err() -> ErrBox {
+ ErrBox::new("InvalidData", "Unable to decode key")
}
-fn key_not_found_err() -> OpError {
- OpError::other("No keys found in key file".to_string())
+fn key_not_found_err() -> ErrBox {
+ ErrBox::new("InvalidData", "No keys found in key file")
}
/// Starts with -----BEGIN RSA PRIVATE KEY-----
-fn load_rsa_keys(path: &str) -> Result<Vec<PrivateKey>, OpError> {
+fn load_rsa_keys(path: &str) -> Result<Vec<PrivateKey>, ErrBox> {
let key_file = File::open(path)?;
let reader = &mut BufReader::new(key_file);
let keys = rsa_private_keys(reader).map_err(|_| key_decode_err())?;
@@ -227,14 +227,14 @@ fn load_rsa_keys(path: &str) -> Result<Vec<PrivateKey>, OpError> {
}
/// Starts with -----BEGIN PRIVATE KEY-----
-fn load_pkcs8_keys(path: &str) -> Result<Vec<PrivateKey>, OpError> {
+fn load_pkcs8_keys(path: &str) -> Result<Vec<PrivateKey>, ErrBox> {
let key_file = File::open(path)?;
let reader = &mut BufReader::new(key_file);
let keys = pkcs8_private_keys(reader).map_err(|_| key_decode_err())?;
Ok(keys)
}
-fn load_keys(path: &str) -> Result<Vec<PrivateKey>, OpError> {
+fn load_keys(path: &str) -> Result<Vec<PrivateKey>, ErrBox> {
let path = path.to_string();
let mut keys = load_rsa_keys(&path)?;
@@ -268,13 +268,13 @@ impl TlsListenerResource {
/// can be notified when listener is closed.
///
/// Throws an error if another task is already tracked.
- pub fn track_task(&mut self, cx: &Context) -> Result<(), OpError> {
+ pub fn track_task(&mut self, cx: &Context) -> Result<(), ErrBox> {
// Currently, we only allow tracking a single accept task for a listener.
// This might be changed in the future with multiple workers.
// Caveat: TcpListener by itself also only tracks an accept task at a time.
// See https://github.com/tokio-rs/tokio/issues/846#issuecomment-454208883
if self.waker.is_some() {
- return Err(OpError::other("Another accept task is ongoing".to_string()));
+ return Err(ErrBox::new("Busy", "Another accept task is ongoing"));
}
let waker = futures::task::AtomicWaker::new();
@@ -312,7 +312,7 @@ fn op_listen_tls(
state: &Rc<State>,
args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
let args: ListenTlsArgs = serde_json::from_value(args)?;
assert_eq!(args.transport, "tcp");
@@ -362,7 +362,7 @@ fn op_accept_tls(
_state: &Rc<State>,
args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
let args: AcceptTlsArgs = serde_json::from_value(args)?;
let rid = args.rid as u32;
let resource_table = isolate_state.resource_table.clone();
@@ -372,10 +372,10 @@ fn op_accept_tls(
let listener_resource = resource_table
.get_mut::<TlsListenerResource>(rid)
.ok_or_else(|| {
- OpError::bad_resource("Listener has been closed".to_string())
+ ErrBox::bad_resource("Listener has been closed".to_string())
})?;
let listener = &mut listener_resource.listener;
- match listener.poll_accept(cx).map_err(OpError::from) {
+ match listener.poll_accept(cx).map_err(ErrBox::from) {
Poll::Ready(Ok((stream, addr))) => {
listener_resource.untrack_task();
Poll::Ready(Ok((stream, addr)))
@@ -397,7 +397,7 @@ fn op_accept_tls(
let resource_table = resource_table.borrow();
let resource = resource_table
.get::<TlsListenerResource>(rid)
- .ok_or_else(OpError::bad_resource_id)
+ .ok_or_else(ErrBox::bad_resource_id)
.expect("Can't find tls listener");
resource.tls_acceptor.clone()
};
diff --git a/cli/ops/tty.rs b/cli/ops/tty.rs
index d6aaeb785..b62b727c3 100644
--- a/cli/ops/tty.rs
+++ b/cli/ops/tty.rs
@@ -1,10 +1,10 @@
use super::dispatch_json::JsonOp;
use super::io::std_file_resource;
use super::io::{StreamResource, StreamResourceHolder};
-use crate::op_error::OpError;
use crate::state::State;
use deno_core::CoreIsolate;
use deno_core::CoreIsolateState;
+use deno_core::ErrBox;
use deno_core::ZeroCopyBuf;
#[cfg(unix)]
use nix::sys::termios;
@@ -23,15 +23,15 @@ const RAW_MODE_MASK: DWORD = wincon::ENABLE_LINE_INPUT
#[cfg(windows)]
fn get_windows_handle(
f: &std::fs::File,
-) -> Result<std::os::windows::io::RawHandle, OpError> {
+) -> Result<std::os::windows::io::RawHandle, ErrBox> {
use std::os::windows::io::AsRawHandle;
use winapi::um::handleapi;
let handle = f.as_raw_handle();
if handle == handleapi::INVALID_HANDLE_VALUE {
- return Err(OpError::from(std::io::Error::last_os_error()));
+ return Err(ErrBox::last_os_error());
} else if handle.is_null() {
- return Err(OpError::other("null handle".to_owned()));
+ return Err(ErrBox::new("ReferenceError", "null handle"));
}
Ok(handle)
}
@@ -53,7 +53,7 @@ pub fn op_set_raw(
state: &Rc<State>,
args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
state.check_unstable("Deno.setRaw");
let args: SetRawArgs = serde_json::from_value(args)?;
let rid = args.rid;
@@ -73,7 +73,7 @@ pub fn op_set_raw(
let mut resource_table = isolate_state.resource_table.borrow_mut();
let resource_holder = resource_table.get_mut::<StreamResourceHolder>(rid);
if resource_holder.is_none() {
- return Err(OpError::bad_resource_id());
+ return Err(ErrBox::bad_resource_id());
}
let resource_holder = resource_holder.unwrap();
@@ -98,28 +98,28 @@ pub fn op_set_raw(
// some operation is in-flight.
resource_holder.resource =
StreamResource::FsFile(Some((tokio_file, metadata)));
- return Err(OpError::resource_unavailable());
+ return Err(ErrBox::resource_unavailable());
}
}
} else {
- return Err(OpError::resource_unavailable());
+ return Err(ErrBox::resource_unavailable());
}
}
_ => {
- return Err(OpError::bad_resource_id());
+ return Err(ErrBox::bad_resource_id());
}
};
if handle == handleapi::INVALID_HANDLE_VALUE {
- return Err(OpError::from(std::io::Error::last_os_error()));
+ return Err(ErrBox::last_os_error());
} else if handle.is_null() {
- return Err(OpError::other("null handle".to_owned()));
+ return Err(ErrBox::new("ReferenceError", "null handle"));
}
let mut original_mode: DWORD = 0;
if unsafe { consoleapi::GetConsoleMode(handle, &mut original_mode) }
== FALSE
{
- return Err(OpError::from(std::io::Error::last_os_error()));
+ return Err(ErrBox::last_os_error());
}
let new_mode = if is_raw {
original_mode & !RAW_MODE_MASK
@@ -127,7 +127,7 @@ pub fn op_set_raw(
original_mode | RAW_MODE_MASK
};
if unsafe { consoleapi::SetConsoleMode(handle, new_mode) } == FALSE {
- return Err(OpError::from(std::io::Error::last_os_error()));
+ return Err(ErrBox::last_os_error());
}
Ok(JsonOp::Sync(json!({})))
@@ -139,7 +139,7 @@ pub fn op_set_raw(
let mut resource_table = isolate_state.resource_table.borrow_mut();
let resource_holder = resource_table.get_mut::<StreamResourceHolder>(rid);
if resource_holder.is_none() {
- return Err(OpError::bad_resource_id());
+ return Err(ErrBox::bad_resource_id());
}
if is_raw {
@@ -152,10 +152,10 @@ pub fn op_set_raw(
(f.as_raw_fd(), &mut metadata.tty.mode)
}
StreamResource::FsFile(None) => {
- return Err(OpError::resource_unavailable())
+ return Err(ErrBox::resource_unavailable())
}
_ => {
- return Err(OpError::other("Not supported".to_owned()));
+ return Err(ErrBox::not_supported());
}
};
@@ -196,10 +196,10 @@ pub fn op_set_raw(
(f.as_raw_fd(), &mut metadata.tty.mode)
}
StreamResource::FsFile(None) => {
- return Err(OpError::resource_unavailable());
+ return Err(ErrBox::resource_unavailable());
}
_ => {
- return Err(OpError::bad_resource_id());
+ return Err(ErrBox::bad_resource_id());
}
};
@@ -222,7 +222,7 @@ pub fn op_isatty(
_state: &Rc<State>,
args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
let args: IsattyArgs = serde_json::from_value(args)?;
let rid = args.rid;
@@ -269,7 +269,7 @@ pub fn op_console_size(
state: &Rc<State>,
args: Value,
_zero_copy: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
state.check_unstable("Deno.consoleSize");
let args: ConsoleSizeArgs = serde_json::from_value(args)?;
let rid = args.rid;
@@ -292,10 +292,7 @@ pub fn op_console_size(
&mut bufinfo,
) == 0
{
- // TODO (caspervonb) use GetLastError
- return Err(OpError::other(
- winapi::um::errhandlingapi::GetLastError().to_string(),
- ));
+ return Err(ErrBox::last_os_error());
}
Ok(ConsoleSize {
@@ -313,7 +310,7 @@ pub fn op_console_size(
unsafe {
let mut size: libc::winsize = std::mem::zeroed();
if libc::ioctl(fd, libc::TIOCGWINSZ, &mut size as *mut _) != 0 {
- return Err(OpError::from(std::io::Error::last_os_error()));
+ return Err(ErrBox::last_os_error());
}
// TODO (caspervonb) return a tuple instead
@@ -324,7 +321,7 @@ pub fn op_console_size(
}
}
}
- Err(_) => Err(OpError::bad_resource_id()),
+ Err(_) => Err(ErrBox::bad_resource_id()),
})?;
Ok(JsonOp::Sync(json!(size)))
diff --git a/cli/ops/web_worker.rs b/cli/ops/web_worker.rs
index 8ad497d5c..023a4708c 100644
--- a/cli/ops/web_worker.rs
+++ b/cli/ops/web_worker.rs
@@ -1,12 +1,12 @@
// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
use super::dispatch_json::{JsonOp, Value};
-use crate::op_error::OpError;
use crate::ops::json_op;
use crate::state::State;
use crate::web_worker::WebWorkerHandle;
use crate::worker::WorkerEvent;
use deno_core::CoreIsolate;
use deno_core::CoreIsolateState;
+use deno_core::ErrBox;
use deno_core::ZeroCopyBuf;
use futures::channel::mpsc;
use std::convert::From;
@@ -19,18 +19,18 @@ pub fn web_worker_op<D>(
&mut CoreIsolateState,
Value,
&mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError>
+) -> Result<JsonOp, ErrBox>
where
D: Fn(
&mpsc::Sender<WorkerEvent>,
Value,
&mut [ZeroCopyBuf],
- ) -> Result<JsonOp, OpError>,
+ ) -> Result<JsonOp, ErrBox>,
{
move |_isolate_state: &mut CoreIsolateState,
args: Value,
zero_copy: &mut [ZeroCopyBuf]|
- -> Result<JsonOp, OpError> { dispatcher(&sender, args, zero_copy) }
+ -> Result<JsonOp, ErrBox> { dispatcher(&sender, args, zero_copy) }
}
pub fn web_worker_op2<D>(
@@ -41,19 +41,19 @@ pub fn web_worker_op2<D>(
&mut CoreIsolateState,
Value,
&mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError>
+) -> Result<JsonOp, ErrBox>
where
D: Fn(
WebWorkerHandle,
&mpsc::Sender<WorkerEvent>,
Value,
&mut [ZeroCopyBuf],
- ) -> Result<JsonOp, OpError>,
+ ) -> Result<JsonOp, ErrBox>,
{
move |_isolate_state: &mut CoreIsolateState,
args: Value,
zero_copy: &mut [ZeroCopyBuf]|
- -> Result<JsonOp, OpError> {
+ -> Result<JsonOp, ErrBox> {
dispatcher(handle.clone(), &sender, args, zero_copy)
}
}
@@ -86,7 +86,7 @@ fn op_worker_post_message(
sender: &mpsc::Sender<WorkerEvent>,
_args: Value,
data: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
assert_eq!(data.len(), 1, "Invalid number of arguments");
let d = Vec::from(&*data[0]).into_boxed_slice();
let mut sender = sender.clone();
@@ -102,7 +102,7 @@ fn op_worker_close(
sender: &mpsc::Sender<WorkerEvent>,
_args: Value,
_data: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
let mut sender = sender.clone();
// Notify parent that we're finished
sender.close_channel();
diff --git a/cli/ops/worker_host.rs b/cli/ops/worker_host.rs
index 47ebd9c7f..4cd55fef1 100644
--- a/cli/ops/worker_host.rs
+++ b/cli/ops/worker_host.rs
@@ -2,7 +2,6 @@
use super::dispatch_json::{Deserialize, JsonOp, Value};
use crate::fmt_errors::JSError;
use crate::global_state::GlobalState;
-use crate::op_error::OpError;
use crate::ops::io::get_stdio;
use crate::permissions::Permissions;
use crate::startup_data;
@@ -184,7 +183,7 @@ fn op_create_worker(
state: &Rc<State>,
args: Value,
_data: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
let args: CreateWorkerArgs = serde_json::from_value(args)?;
let specifier = args.specifier.clone();
@@ -215,8 +214,7 @@ fn op_create_worker(
module_specifier,
use_deno_namespace,
maybe_source_code,
- )
- .map_err(|e| OpError::other(e.to_string()))?;
+ )?;
// At this point all interactions with worker happen using thread
// safe handler returned from previous function call
parent_state
@@ -236,7 +234,7 @@ fn op_host_terminate_worker(
state: &Rc<State>,
args: Value,
_data: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
let args: WorkerArgs = serde_json::from_value(args)?;
let id = args.id as u32;
let (join_handle, worker_handle) = state
@@ -304,7 +302,7 @@ fn op_host_get_message(
state: &Rc<State>,
args: Value,
_data: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
let args: WorkerArgs = serde_json::from_value(args)?;
let id = args.id as u32;
let state = state.clone();
@@ -345,7 +343,7 @@ fn op_host_post_message(
state: &Rc<State>,
args: Value,
data: &mut [ZeroCopyBuf],
-) -> Result<JsonOp, OpError> {
+) -> Result<JsonOp, ErrBox> {
assert_eq!(data.len(), 1, "Invalid number of arguments");
let args: WorkerArgs = serde_json::from_value(args)?;
let id = args.id as u32;
@@ -354,8 +352,6 @@ fn op_host_post_message(
debug!("post message to worker {}", id);
let workers = state.workers.borrow();
let worker_handle = workers[&id].1.clone();
- worker_handle
- .post_message(msg)
- .map_err(|e| OpError::other(e.to_string()))?;
+ worker_handle.post_message(msg)?;
Ok(JsonOp::Sync(json!({})))
}
generated by cgit v1.2.3 (git 2.25.1) at 2025-08-03 08:36:47 +0000