2020-01-02 15:13:47 -05:00
|
|
|
// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
|
2019-05-03 00:06:43 -04:00
|
|
|
// 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.
|
2019-10-24 17:22:31 -04:00
|
|
|
use crate::deno_error::GetErrorKind;
|
2019-10-25 13:23:16 -04:00
|
|
|
use crate::msg::ErrorKind;
|
2019-10-24 17:22:31 -04:00
|
|
|
use byteorder::{LittleEndian, WriteBytesExt};
|
2019-05-03 00:06:43 -04:00
|
|
|
use deno::Buf;
|
2019-06-17 21:02:08 -04:00
|
|
|
use deno::CoreOp;
|
2019-08-21 20:42:48 -04:00
|
|
|
use deno::ErrBox;
|
2019-05-03 00:06:43 -04:00
|
|
|
use deno::Op;
|
|
|
|
use deno::PinnedBuf;
|
2019-11-16 19:17:47 -05:00
|
|
|
use futures::future::FutureExt;
|
|
|
|
use std::future::Future;
|
|
|
|
use std::pin::Pin;
|
2019-05-03 00:06:43 -04:00
|
|
|
|
2019-11-16 19:17:47 -05:00
|
|
|
pub type MinimalOp = dyn Future<Output = Result<i32, ErrBox>> + Send;
|
2019-08-16 11:05:24 -04:00
|
|
|
|
2019-05-03 00:06:43 -04:00
|
|
|
#[derive(Copy, Clone, Debug, PartialEq)]
|
|
|
|
// This corresponds to RecordMinimal on the TS side.
|
|
|
|
pub struct Record {
|
2019-06-14 13:58:20 -04:00
|
|
|
pub promise_id: i32,
|
2019-05-03 00:06:43 -04:00
|
|
|
pub arg: i32,
|
|
|
|
pub result: i32,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Into<Buf> for Record {
|
|
|
|
fn into(self) -> Buf {
|
2019-08-07 14:02:29 -04:00
|
|
|
let vec = vec![self.promise_id, self.arg, self.result];
|
2019-05-03 00:06:43 -04:00
|
|
|
let buf32 = vec.into_boxed_slice();
|
2019-08-07 14:02:29 -04:00
|
|
|
let ptr = Box::into_raw(buf32) as *mut [u8; 3 * 4];
|
2019-05-03 00:06:43 -04:00
|
|
|
unsafe { Box::from_raw(ptr) }
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-10-24 17:22:31 -04:00
|
|
|
pub struct ErrorRecord {
|
|
|
|
pub promise_id: i32,
|
|
|
|
pub arg: i32,
|
|
|
|
pub error_code: i32,
|
|
|
|
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_code];
|
|
|
|
let mut v8: Vec<u8> = Vec::new();
|
|
|
|
for n in v32 {
|
|
|
|
v8.write_i32::<LittleEndian>(n).unwrap();
|
|
|
|
}
|
|
|
|
let mut message = self.error_message;
|
|
|
|
// Align to 32bit word, padding with the space character.
|
|
|
|
message.resize((message.len() + 3usize) & !3usize, b' ');
|
|
|
|
v8.append(&mut message);
|
|
|
|
v8.into_boxed_slice()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_error_record() {
|
|
|
|
let expected = vec![
|
|
|
|
1, 0, 0, 0, 255, 255, 255, 255, 10, 0, 0, 0, 69, 114, 114, 111, 114, 32,
|
|
|
|
32, 32,
|
|
|
|
];
|
|
|
|
let err_record = ErrorRecord {
|
|
|
|
promise_id: 1,
|
|
|
|
arg: -1,
|
|
|
|
error_code: 10,
|
|
|
|
error_message: "Error".to_string().as_bytes().to_owned(),
|
|
|
|
};
|
|
|
|
let buf: Buf = err_record.into();
|
|
|
|
assert_eq!(buf, expected.into_boxed_slice());
|
|
|
|
}
|
|
|
|
|
2019-05-03 00:06:43 -04:00
|
|
|
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;
|
2019-06-14 13:58:20 -04:00
|
|
|
let s = unsafe { std::slice::from_raw_parts(p32, bytes.len() / 4) };
|
2019-05-03 00:06:43 -04:00
|
|
|
|
2019-08-07 14:02:29 -04:00
|
|
|
if s.len() != 3 {
|
2019-05-03 00:06:43 -04:00
|
|
|
return None;
|
|
|
|
}
|
|
|
|
let ptr = s.as_ptr();
|
2019-08-07 14:02:29 -04:00
|
|
|
let ints = unsafe { std::slice::from_raw_parts(ptr, 3) };
|
2019-05-03 00:06:43 -04:00
|
|
|
Some(Record {
|
2019-08-07 14:02:29 -04:00
|
|
|
promise_id: ints[0],
|
|
|
|
arg: ints[1],
|
|
|
|
result: ints[2],
|
2019-05-03 00:06:43 -04:00
|
|
|
})
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_parse_min_record() {
|
2019-08-07 14:02:29 -04:00
|
|
|
let buf = vec![1, 0, 0, 0, 3, 0, 0, 0, 4, 0, 0, 0];
|
2019-05-03 00:06:43 -04:00
|
|
|
assert_eq!(
|
|
|
|
parse_min_record(&buf),
|
|
|
|
Some(Record {
|
2019-06-14 13:58:20 -04:00
|
|
|
promise_id: 1,
|
|
|
|
arg: 3,
|
|
|
|
result: 4,
|
2019-05-03 00:06:43 -04:00
|
|
|
})
|
|
|
|
);
|
|
|
|
|
|
|
|
let buf = vec![];
|
|
|
|
assert_eq!(parse_min_record(&buf), None);
|
|
|
|
|
|
|
|
let buf = vec![5];
|
|
|
|
assert_eq!(parse_min_record(&buf), None);
|
|
|
|
}
|
|
|
|
|
2019-11-14 12:10:25 -05:00
|
|
|
pub fn minimal_op<D>(d: D) -> impl Fn(&[u8], Option<PinnedBuf>) -> CoreOp
|
|
|
|
where
|
2019-11-16 19:17:47 -05:00
|
|
|
D: Fn(i32, Option<PinnedBuf>) -> Pin<Box<MinimalOp>>,
|
2019-11-14 12:10:25 -05:00
|
|
|
{
|
2019-10-01 18:51:05 -04:00
|
|
|
move |control: &[u8], zero_copy: Option<PinnedBuf>| {
|
2019-10-25 13:23:16 -04:00
|
|
|
let mut record = match parse_min_record(control) {
|
|
|
|
Some(r) => r,
|
|
|
|
None => {
|
|
|
|
let error_record = ErrorRecord {
|
|
|
|
promise_id: 0,
|
|
|
|
arg: -1,
|
|
|
|
error_code: ErrorKind::InvalidInput as i32,
|
|
|
|
error_message: "Unparsable control buffer"
|
|
|
|
.to_string()
|
|
|
|
.as_bytes()
|
|
|
|
.to_owned(),
|
|
|
|
};
|
|
|
|
return Op::Sync(error_record.into());
|
|
|
|
}
|
|
|
|
};
|
2019-10-01 18:51:05 -04:00
|
|
|
let is_sync = record.promise_id == 0;
|
|
|
|
let rid = record.arg;
|
|
|
|
let min_op = d(rid, zero_copy);
|
2019-08-21 20:42:48 -04:00
|
|
|
|
2019-10-01 18:51:05 -04:00
|
|
|
// Convert to CoreOp
|
2020-01-04 05:20:52 -05:00
|
|
|
let fut = async move {
|
|
|
|
match min_op.await {
|
|
|
|
Ok(r) => {
|
|
|
|
record.result = r;
|
|
|
|
Ok(record.into())
|
|
|
|
}
|
|
|
|
Err(err) => {
|
|
|
|
let error_record = ErrorRecord {
|
|
|
|
promise_id: record.promise_id,
|
|
|
|
arg: -1,
|
|
|
|
error_code: err.kind() as i32,
|
|
|
|
error_message: err.to_string().as_bytes().to_owned(),
|
|
|
|
};
|
|
|
|
Ok(error_record.into())
|
|
|
|
}
|
2019-11-16 19:17:47 -05:00
|
|
|
}
|
2020-01-04 05:20:52 -05:00
|
|
|
};
|
2019-08-23 01:30:14 -04:00
|
|
|
|
2019-10-01 18:51:05 -04:00
|
|
|
if is_sync {
|
|
|
|
// Warning! Possible deadlocks can occur if we try to wait for a future
|
|
|
|
// while in a future. The safe but expensive alternative is to use
|
|
|
|
// tokio_util::block_on.
|
|
|
|
// This block is only exercised for readSync and writeSync, which I think
|
|
|
|
// works since they're simple polling futures.
|
2019-11-16 19:17:47 -05:00
|
|
|
Op::Sync(futures::executor::block_on(fut).unwrap())
|
2019-10-01 18:51:05 -04:00
|
|
|
} else {
|
2019-11-16 19:17:47 -05:00
|
|
|
Op::Async(fut.boxed())
|
2019-10-01 18:51:05 -04:00
|
|
|
}
|
2019-06-14 13:58:20 -04:00
|
|
|
}
|
2019-05-03 00:06:43 -04:00
|
|
|
}
|