2024-01-01 19:58:21 +00:00
|
|
|
// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
|
2023-01-13 07:51:32 +00:00
|
|
|
|
2021-06-21 17:53:52 +00:00
|
|
|
use std::borrow::Cow;
|
|
|
|
use std::cell::RefCell;
|
|
|
|
use std::rc::Rc;
|
|
|
|
|
|
|
|
use deno_core::error::type_error;
|
|
|
|
use deno_core::error::AnyError;
|
2023-09-14 21:05:18 +00:00
|
|
|
use deno_core::op2;
|
2022-03-14 17:44:15 +00:00
|
|
|
|
2023-01-15 04:18:58 +00:00
|
|
|
use deno_core::CancelFuture;
|
|
|
|
use deno_core::CancelHandle;
|
2022-07-11 15:27:33 +00:00
|
|
|
use deno_core::DetachedBuffer;
|
2023-01-15 04:18:58 +00:00
|
|
|
use deno_core::OpState;
|
|
|
|
use deno_core::RcRef;
|
|
|
|
use deno_core::Resource;
|
|
|
|
use deno_core::ResourceId;
|
2021-06-21 17:53:52 +00:00
|
|
|
use serde::Deserialize;
|
|
|
|
use serde::Serialize;
|
|
|
|
use tokio::sync::mpsc::unbounded_channel;
|
|
|
|
use tokio::sync::mpsc::UnboundedReceiver;
|
|
|
|
use tokio::sync::mpsc::UnboundedSender;
|
|
|
|
|
|
|
|
enum Transferable {
|
|
|
|
MessagePort(MessagePort),
|
2021-08-25 11:48:53 +00:00
|
|
|
ArrayBuffer(u32),
|
2021-06-21 17:53:52 +00:00
|
|
|
}
|
|
|
|
|
2022-07-11 15:27:33 +00:00
|
|
|
type MessagePortMessage = (DetachedBuffer, Vec<Transferable>);
|
2021-06-21 17:53:52 +00:00
|
|
|
|
|
|
|
pub struct MessagePort {
|
|
|
|
rx: RefCell<UnboundedReceiver<MessagePortMessage>>,
|
2021-06-22 14:30:16 +00:00
|
|
|
tx: RefCell<Option<UnboundedSender<MessagePortMessage>>>,
|
2021-06-21 17:53:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
impl MessagePort {
|
|
|
|
pub fn send(
|
|
|
|
&self,
|
|
|
|
state: &mut OpState,
|
|
|
|
data: JsMessageData,
|
|
|
|
) -> Result<(), AnyError> {
|
|
|
|
let transferables =
|
|
|
|
deserialize_js_transferables(state, data.transferables)?;
|
|
|
|
|
|
|
|
// Swallow the failed to send error. It means the channel was disentangled,
|
|
|
|
// but not cleaned up.
|
2021-06-22 14:30:16 +00:00
|
|
|
if let Some(tx) = &*self.tx.borrow() {
|
2022-07-11 15:27:33 +00:00
|
|
|
tx.send((data.data, transferables)).ok();
|
2021-06-22 14:30:16 +00:00
|
|
|
}
|
2021-06-21 17:53:52 +00:00
|
|
|
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
2023-09-11 23:12:33 +00:00
|
|
|
#[allow(clippy::await_holding_refcell_ref)] // TODO(ry) remove!
|
2021-06-21 17:53:52 +00:00
|
|
|
pub async fn recv(
|
|
|
|
&self,
|
|
|
|
state: Rc<RefCell<OpState>>,
|
|
|
|
) -> Result<Option<JsMessageData>, AnyError> {
|
|
|
|
let mut rx = self
|
|
|
|
.rx
|
|
|
|
.try_borrow_mut()
|
|
|
|
.map_err(|_| type_error("Port receiver is already borrowed"))?;
|
|
|
|
if let Some((data, transferables)) = rx.recv().await {
|
|
|
|
let js_transferables =
|
|
|
|
serialize_transferables(&mut state.borrow_mut(), transferables);
|
|
|
|
return Ok(Some(JsMessageData {
|
2022-07-11 15:27:33 +00:00
|
|
|
data,
|
2021-06-21 17:53:52 +00:00
|
|
|
transferables: js_transferables,
|
|
|
|
}));
|
|
|
|
}
|
|
|
|
Ok(None)
|
|
|
|
}
|
2021-06-22 14:30:16 +00:00
|
|
|
|
|
|
|
/// This forcefully disconnects the message port from its paired port. This
|
|
|
|
/// will wake up the `.recv` on the paired port, which will return `Ok(None)`.
|
|
|
|
pub fn disentangle(&self) {
|
|
|
|
let mut tx = self.tx.borrow_mut();
|
|
|
|
tx.take();
|
|
|
|
}
|
2021-06-21 17:53:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
pub fn create_entangled_message_port() -> (MessagePort, MessagePort) {
|
|
|
|
let (port1_tx, port2_rx) = unbounded_channel::<MessagePortMessage>();
|
|
|
|
let (port2_tx, port1_rx) = unbounded_channel::<MessagePortMessage>();
|
|
|
|
|
|
|
|
let port1 = MessagePort {
|
|
|
|
rx: RefCell::new(port1_rx),
|
2021-06-22 14:30:16 +00:00
|
|
|
tx: RefCell::new(Some(port1_tx)),
|
2021-06-21 17:53:52 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
let port2 = MessagePort {
|
|
|
|
rx: RefCell::new(port2_rx),
|
2021-06-22 14:30:16 +00:00
|
|
|
tx: RefCell::new(Some(port2_tx)),
|
2021-06-21 17:53:52 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
(port1, port2)
|
|
|
|
}
|
|
|
|
|
|
|
|
pub struct MessagePortResource {
|
|
|
|
port: MessagePort,
|
|
|
|
cancel: CancelHandle,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Resource for MessagePortResource {
|
|
|
|
fn name(&self) -> Cow<str> {
|
|
|
|
"messagePort".into()
|
|
|
|
}
|
|
|
|
|
|
|
|
fn close(self: Rc<Self>) {
|
|
|
|
self.cancel.cancel();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-09-14 21:05:18 +00:00
|
|
|
#[op2]
|
|
|
|
#[serde]
|
2021-06-21 17:53:52 +00:00
|
|
|
pub fn op_message_port_create_entangled(
|
|
|
|
state: &mut OpState,
|
2022-05-13 08:36:31 +00:00
|
|
|
) -> (ResourceId, ResourceId) {
|
2021-06-21 17:53:52 +00:00
|
|
|
let (port1, port2) = create_entangled_message_port();
|
|
|
|
|
|
|
|
let port1_id = state.resource_table.add(MessagePortResource {
|
|
|
|
port: port1,
|
|
|
|
cancel: CancelHandle::new(),
|
|
|
|
});
|
|
|
|
|
|
|
|
let port2_id = state.resource_table.add(MessagePortResource {
|
|
|
|
port: port2,
|
|
|
|
cancel: CancelHandle::new(),
|
|
|
|
});
|
|
|
|
|
2022-05-13 08:36:31 +00:00
|
|
|
(port1_id, port2_id)
|
2021-06-21 17:53:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#[derive(Deserialize, Serialize)]
|
|
|
|
#[serde(tag = "kind", content = "data", rename_all = "camelCase")]
|
|
|
|
pub enum JsTransferable {
|
|
|
|
#[serde(rename_all = "camelCase")]
|
|
|
|
MessagePort(ResourceId),
|
2021-08-25 11:48:53 +00:00
|
|
|
ArrayBuffer(u32),
|
2021-06-21 17:53:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
fn deserialize_js_transferables(
|
|
|
|
state: &mut OpState,
|
|
|
|
js_transferables: Vec<JsTransferable>,
|
|
|
|
) -> Result<Vec<Transferable>, AnyError> {
|
|
|
|
let mut transferables = Vec::with_capacity(js_transferables.len());
|
|
|
|
for js_transferable in js_transferables {
|
|
|
|
match js_transferable {
|
|
|
|
JsTransferable::MessagePort(id) => {
|
|
|
|
let resource = state
|
|
|
|
.resource_table
|
|
|
|
.take::<MessagePortResource>(id)
|
2021-08-15 11:29:19 +00:00
|
|
|
.map_err(|_| type_error("Invalid message port transfer"))?;
|
2021-06-21 17:53:52 +00:00
|
|
|
resource.cancel.cancel();
|
|
|
|
let resource = Rc::try_unwrap(resource)
|
|
|
|
.map_err(|_| type_error("Message port is not ready for transfer"))?;
|
|
|
|
transferables.push(Transferable::MessagePort(resource.port));
|
|
|
|
}
|
2021-08-25 11:48:53 +00:00
|
|
|
JsTransferable::ArrayBuffer(id) => {
|
|
|
|
transferables.push(Transferable::ArrayBuffer(id));
|
|
|
|
}
|
2021-06-21 17:53:52 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
Ok(transferables)
|
|
|
|
}
|
|
|
|
|
|
|
|
fn serialize_transferables(
|
|
|
|
state: &mut OpState,
|
|
|
|
transferables: Vec<Transferable>,
|
|
|
|
) -> Vec<JsTransferable> {
|
|
|
|
let mut js_transferables = Vec::with_capacity(transferables.len());
|
|
|
|
for transferable in transferables {
|
|
|
|
match transferable {
|
|
|
|
Transferable::MessagePort(port) => {
|
|
|
|
let rid = state.resource_table.add(MessagePortResource {
|
|
|
|
port,
|
|
|
|
cancel: CancelHandle::new(),
|
|
|
|
});
|
|
|
|
js_transferables.push(JsTransferable::MessagePort(rid));
|
|
|
|
}
|
2021-08-25 11:48:53 +00:00
|
|
|
Transferable::ArrayBuffer(id) => {
|
|
|
|
js_transferables.push(JsTransferable::ArrayBuffer(id));
|
|
|
|
}
|
2021-06-21 17:53:52 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
js_transferables
|
|
|
|
}
|
|
|
|
|
|
|
|
#[derive(Deserialize, Serialize)]
|
|
|
|
pub struct JsMessageData {
|
2022-07-11 15:27:33 +00:00
|
|
|
data: DetachedBuffer,
|
2021-06-21 17:53:52 +00:00
|
|
|
transferables: Vec<JsTransferable>,
|
|
|
|
}
|
|
|
|
|
2023-09-14 21:05:18 +00:00
|
|
|
#[op2]
|
2021-06-21 17:53:52 +00:00
|
|
|
pub fn op_message_port_post_message(
|
|
|
|
state: &mut OpState,
|
2023-09-14 21:05:18 +00:00
|
|
|
#[smi] rid: ResourceId,
|
|
|
|
#[serde] data: JsMessageData,
|
2021-06-21 17:53:52 +00:00
|
|
|
) -> Result<(), AnyError> {
|
|
|
|
for js_transferable in &data.transferables {
|
2021-08-25 11:48:53 +00:00
|
|
|
if let JsTransferable::MessagePort(id) = js_transferable {
|
|
|
|
if *id == rid {
|
|
|
|
return Err(type_error("Can not transfer self message port"));
|
2021-06-21 17:53:52 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-08-15 11:29:19 +00:00
|
|
|
let resource = state.resource_table.get::<MessagePortResource>(rid)?;
|
2021-06-21 17:53:52 +00:00
|
|
|
|
|
|
|
resource.port.send(state, data)
|
|
|
|
}
|
|
|
|
|
2023-09-14 21:05:18 +00:00
|
|
|
#[op2(async)]
|
|
|
|
#[serde]
|
2021-06-21 17:53:52 +00:00
|
|
|
pub async fn op_message_port_recv_message(
|
|
|
|
state: Rc<RefCell<OpState>>,
|
2023-09-14 21:05:18 +00:00
|
|
|
#[smi] rid: ResourceId,
|
2021-06-21 17:53:52 +00:00
|
|
|
) -> Result<Option<JsMessageData>, AnyError> {
|
|
|
|
let resource = {
|
|
|
|
let state = state.borrow();
|
|
|
|
match state.resource_table.get::<MessagePortResource>(rid) {
|
2021-08-15 11:29:19 +00:00
|
|
|
Ok(resource) => resource,
|
|
|
|
Err(_) => return Ok(None),
|
2021-06-21 17:53:52 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
let cancel = RcRef::map(resource.clone(), |r| &r.cancel);
|
2021-06-22 14:30:16 +00:00
|
|
|
resource.port.recv(state).or_cancel(cancel).await?
|
2021-06-21 17:53:52 +00:00
|
|
|
}
|