mirror of
https://github.com/denoland/deno.git
synced 2025-08-04 19:08:15 +00:00
Revert "Remove dead code: legacy read/write ops"
This is causing a segfault for unknown reasons - see #2787.
This reverts commit 498f6ad431.
This commit is contained in:
Ryan Dahl
parent
52a66c2796
commit
81f809f2a6
9 changed files with 223 additions and 106 deletions
|
|
@ -1,110 +0,0 @@
|
|||
// Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.
|
||||
// Do not add flatbuffer dependencies to this module.
|
||||
//! Connects to js/dispatch_minimal.ts sendAsyncMinimal This acts as a faster
|
||||
//! alternative to flatbuffers using a very simple list of int32s to lay out
|
||||
//! messages. The first i32 is used to determine if a message a flatbuffer
|
||||
//! message or a "minimal" message.
|
||||
use crate::state::ThreadSafeState;
|
||||
use deno::Buf;
|
||||
use deno::CoreOp;
|
||||
use deno::ErrBox;
|
||||
use deno::Op;
|
||||
use deno::PinnedBuf;
|
||||
use futures::Future;
|
||||
|
||||
#[derive(Copy, Clone, Debug, PartialEq)]
|
||||
// This corresponds to RecordMinimal on the TS side.
|
||||
pub struct Record {
|
||||
pub promise_id: i32,
|
||||
pub arg: i32,
|
||||
pub result: i32,
|
||||
}
|
||||
|
||||
impl Into<Buf> for Record {
|
||||
fn into(self) -> Buf {
|
||||
let vec = vec![self.promise_id, self.arg, self.result];
|
||||
let buf32 = vec.into_boxed_slice();
|
||||
let ptr = Box::into_raw(buf32) as *mut [u8; 3 * 4];
|
||||
unsafe { Box::from_raw(ptr) }
|
||||
}
|
||||
}
|
||||
|
||||
pub fn parse_min_record(bytes: &[u8]) -> Option<Record> {
|
||||
if bytes.len() % std::mem::size_of::<i32>() != 0 {
|
||||
return None;
|
||||
}
|
||||
let p = bytes.as_ptr();
|
||||
#[allow(clippy::cast_ptr_alignment)]
|
||||
let p32 = p as *const i32;
|
||||
let s = unsafe { std::slice::from_raw_parts(p32, bytes.len() / 4) };
|
||||
|
||||
if s.len() != 3 {
|
||||
return None;
|
||||
}
|
||||
let ptr = s.as_ptr();
|
||||
let ints = unsafe { std::slice::from_raw_parts(ptr, 3) };
|
||||
Some(Record {
|
||||
promise_id: ints[0],
|
||||
arg: ints[1],
|
||||
result: ints[2],
|
||||
})
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_parse_min_record() {
|
||||
let buf = vec![1, 0, 0, 0, 3, 0, 0, 0, 4, 0, 0, 0];
|
||||
assert_eq!(
|
||||
parse_min_record(&buf),
|
||||
Some(Record {
|
||||
promise_id: 1,
|
||||
arg: 3,
|
||||
result: 4,
|
||||
})
|
||||
);
|
||||
|
||||
let buf = vec![];
|
||||
assert_eq!(parse_min_record(&buf), None);
|
||||
|
||||
let buf = vec![5];
|
||||
assert_eq!(parse_min_record(&buf), None);
|
||||
}
|
||||
|
||||
pub type MinimalOp = dyn Future<Item = i32, Error = ErrBox> + Send;
|
||||
pub type Dispatcher = fn(i32, Option<PinnedBuf>) -> Box<MinimalOp>;
|
||||
|
||||
pub fn dispatch(
|
||||
d: Dispatcher,
|
||||
state: &ThreadSafeState,
|
||||
control: &[u8],
|
||||
zero_copy: Option<PinnedBuf>,
|
||||
) -> CoreOp {
|
||||
let mut record = parse_min_record(control).unwrap();
|
||||
let is_sync = record.promise_id == 0;
|
||||
|
||||
let state = state.clone();
|
||||
|
||||
let rid = record.arg;
|
||||
let min_op = d(rid, zero_copy);
|
||||
|
||||
let fut = Box::new(min_op.then(move |result| -> Result<Buf, ()> {
|
||||
match result {
|
||||
Ok(r) => {
|
||||
record.result = r;
|
||||
}
|
||||
Err(err) => {
|
||||
// TODO(ry) The dispatch_minimal doesn't properly pipe errors back to
|
||||
// the caller.
|
||||
debug!("swallowed err {}", err);
|
||||
record.result = -1;
|
||||
}
|
||||
}
|
||||
let buf: Buf = record.into();
|
||||
state.metrics_op_completed(buf.len());
|
||||
Ok(buf)
|
||||
}));
|
||||
if is_sync {
|
||||
Op::Sync(fut.wait().unwrap())
|
||||
} else {
|
||||
Op::Async(fut)
|
||||
}
|
||||
}
|
||||
|
|
@ -8,6 +8,7 @@ use crate::ops::serialize_response;
|
|||
use crate::ops::CliOpResult;
|
||||
use crate::resources;
|
||||
use crate::state::ThreadSafeState;
|
||||
use crate::tokio_write;
|
||||
use deno::*;
|
||||
use flatbuffers::FlatBufferBuilder;
|
||||
use futures::Future;
|
||||
|
|
@ -118,6 +119,91 @@ pub fn op_close(
|
|||
}
|
||||
}
|
||||
|
||||
pub fn op_read(
|
||||
_state: &ThreadSafeState,
|
||||
base: &msg::Base<'_>,
|
||||
data: Option<PinnedBuf>,
|
||||
) -> CliOpResult {
|
||||
let cmd_id = base.cmd_id();
|
||||
let inner = base.inner_as_read().unwrap();
|
||||
let rid = inner.rid();
|
||||
|
||||
match resources::lookup(rid) {
|
||||
None => Err(deno_error::bad_resource()),
|
||||
Some(resource) => {
|
||||
let op = tokio::io::read(resource, data.unwrap())
|
||||
.map_err(ErrBox::from)
|
||||
.and_then(move |(_resource, _buf, nread)| {
|
||||
let builder = &mut FlatBufferBuilder::new();
|
||||
let inner = msg::ReadRes::create(
|
||||
builder,
|
||||
&msg::ReadResArgs {
|
||||
nread: nread as u32,
|
||||
eof: nread == 0,
|
||||
},
|
||||
);
|
||||
Ok(serialize_response(
|
||||
cmd_id,
|
||||
builder,
|
||||
msg::BaseArgs {
|
||||
inner: Some(inner.as_union_value()),
|
||||
inner_type: msg::Any::ReadRes,
|
||||
..Default::default()
|
||||
},
|
||||
))
|
||||
});
|
||||
if base.sync() {
|
||||
let buf = op.wait()?;
|
||||
Ok(Op::Sync(buf))
|
||||
} else {
|
||||
Ok(Op::Async(Box::new(op)))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn op_write(
|
||||
_state: &ThreadSafeState,
|
||||
base: &msg::Base<'_>,
|
||||
data: Option<PinnedBuf>,
|
||||
) -> CliOpResult {
|
||||
let cmd_id = base.cmd_id();
|
||||
let inner = base.inner_as_write().unwrap();
|
||||
let rid = inner.rid();
|
||||
|
||||
match resources::lookup(rid) {
|
||||
None => Err(deno_error::bad_resource()),
|
||||
Some(resource) => {
|
||||
let op = tokio_write::write(resource, data.unwrap())
|
||||
.map_err(ErrBox::from)
|
||||
.and_then(move |(_resource, _buf, nwritten)| {
|
||||
let builder = &mut FlatBufferBuilder::new();
|
||||
let inner = msg::WriteRes::create(
|
||||
builder,
|
||||
&msg::WriteResArgs {
|
||||
nbyte: nwritten as u32,
|
||||
},
|
||||
);
|
||||
Ok(serialize_response(
|
||||
cmd_id,
|
||||
builder,
|
||||
msg::BaseArgs {
|
||||
inner: Some(inner.as_union_value()),
|
||||
inner_type: msg::Any::WriteRes,
|
||||
..Default::default()
|
||||
},
|
||||
))
|
||||
});
|
||||
if base.sync() {
|
||||
let buf = op.wait()?;
|
||||
Ok(Op::Sync(buf))
|
||||
} else {
|
||||
Ok(Op::Async(Box::new(op)))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn op_seek(
|
||||
_state: &ThreadSafeState,
|
||||
base: &msg::Base<'_>,
|
||||
|
|
|
|||
|
|
@ -1,43 +0,0 @@
|
|||
use super::dispatch_minimal::MinimalOp;
|
||||
use crate::deno_error;
|
||||
use crate::resources;
|
||||
use crate::tokio_write;
|
||||
use deno::ErrBox;
|
||||
use deno::PinnedBuf;
|
||||
use futures::Future;
|
||||
|
||||
pub fn op_read(rid: i32, zero_copy: Option<PinnedBuf>) -> Box<MinimalOp> {
|
||||
debug!("read rid={}", rid);
|
||||
let zero_copy = match zero_copy {
|
||||
None => {
|
||||
return Box::new(futures::future::err(deno_error::no_buffer_specified()))
|
||||
}
|
||||
Some(buf) => buf,
|
||||
};
|
||||
match resources::lookup(rid as u32) {
|
||||
None => Box::new(futures::future::err(deno_error::bad_resource())),
|
||||
Some(resource) => Box::new(
|
||||
tokio::io::read(resource, zero_copy)
|
||||
.map_err(ErrBox::from)
|
||||
.and_then(move |(_resource, _buf, nread)| Ok(nread as i32)),
|
||||
),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn op_write(rid: i32, zero_copy: Option<PinnedBuf>) -> Box<MinimalOp> {
|
||||
debug!("write rid={}", rid);
|
||||
let zero_copy = match zero_copy {
|
||||
None => {
|
||||
return Box::new(futures::future::err(deno_error::no_buffer_specified()))
|
||||
}
|
||||
Some(buf) => buf,
|
||||
};
|
||||
match resources::lookup(rid as u32) {
|
||||
None => Box::new(futures::future::err(deno_error::bad_resource())),
|
||||
Some(resource) => Box::new(
|
||||
tokio_write::write(resource, zero_copy)
|
||||
.map_err(ErrBox::from)
|
||||
.and_then(move |(_resource, _buf, nwritten)| Ok(nwritten as i32)),
|
||||
),
|
||||
}
|
||||
}
|
||||
|
|
@ -1,5 +1,7 @@
|
|||
// Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.
|
||||
use crate::deno_error::GetErrorKind;
|
||||
use crate::dispatch_minimal::dispatch_minimal;
|
||||
use crate::dispatch_minimal::parse_min_record;
|
||||
use crate::msg;
|
||||
use crate::state::ThreadSafeState;
|
||||
use crate::tokio_util;
|
||||
|
|
@ -11,15 +13,12 @@ use hyper;
|
|||
use hyper::rt::Future;
|
||||
use tokio_threadpool;
|
||||
|
||||
mod dispatch_minimal;
|
||||
mod io;
|
||||
|
||||
mod compiler;
|
||||
use compiler::{op_cache, op_fetch_source_file};
|
||||
mod errors;
|
||||
use errors::{op_apply_source_map, op_format_error};
|
||||
mod files;
|
||||
use files::{op_close, op_open, op_seek};
|
||||
use files::{op_close, op_open, op_read, op_seek, op_write};
|
||||
mod fetch;
|
||||
use fetch::op_fetch;
|
||||
mod fs;
|
||||
|
|
@ -72,8 +71,6 @@ fn empty_buf() -> Buf {
|
|||
}
|
||||
|
||||
const FLATBUFFER_OP_ID: OpId = 44;
|
||||
const OP_READ: OpId = 1;
|
||||
const OP_WRITE: OpId = 2;
|
||||
|
||||
pub fn dispatch_all(
|
||||
state: &ThreadSafeState,
|
||||
|
|
@ -84,18 +81,11 @@ pub fn dispatch_all(
|
|||
) -> CoreOp {
|
||||
let bytes_sent_control = control.len();
|
||||
let bytes_sent_zero_copy = zero_copy.as_ref().map(|b| b.len()).unwrap_or(0);
|
||||
|
||||
let op = match op_id {
|
||||
OP_READ => {
|
||||
dispatch_minimal::dispatch(io::op_read, state, control, zero_copy)
|
||||
}
|
||||
OP_WRITE => {
|
||||
dispatch_minimal::dispatch(io::op_write, state, control, zero_copy)
|
||||
}
|
||||
FLATBUFFER_OP_ID => {
|
||||
dispatch_all_legacy(state, control, zero_copy, op_selector)
|
||||
}
|
||||
_ => panic!("bad op_id"),
|
||||
let op = if op_id != FLATBUFFER_OP_ID {
|
||||
let min_record = parse_min_record(control).unwrap();
|
||||
dispatch_minimal(state, op_id, min_record, zero_copy)
|
||||
} else {
|
||||
dispatch_all_legacy(state, control, zero_copy, op_selector)
|
||||
};
|
||||
state.metrics_op_dispatched(bytes_sent_control, bytes_sent_zero_copy);
|
||||
op
|
||||
|
|
@ -236,6 +226,7 @@ pub fn op_selector_std(inner_type: msg::Any) -> Option<CliDispatchFn> {
|
|||
msg::Any::Open => Some(op_open),
|
||||
msg::Any::PermissionRevoke => Some(op_revoke_permission),
|
||||
msg::Any::Permissions => Some(op_permissions),
|
||||
msg::Any::Read => Some(op_read),
|
||||
msg::Any::ReadDir => Some(op_read_dir),
|
||||
msg::Any::Readlink => Some(op_read_link),
|
||||
msg::Any::Remove => Some(op_remove),
|
||||
|
|
@ -254,6 +245,7 @@ pub fn op_selector_std(inner_type: msg::Any) -> Option<CliDispatchFn> {
|
|||
msg::Any::Truncate => Some(op_truncate),
|
||||
msg::Any::HomeDir => Some(op_home_dir),
|
||||
msg::Any::Utime => Some(op_utime),
|
||||
msg::Any::Write => Some(op_write),
|
||||
|
||||
// TODO(ry) split these out so that only the appropriate Workers can access
|
||||
// them.
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue