741 lines
27 KiB
Rust
741 lines
27 KiB
Rust
use bytes::Buf;
|
|
use bytes::BytesMut;
|
|
|
|
use crate::language;
|
|
use crate::actor::*;
|
|
use crate::during;
|
|
use crate::error::Error;
|
|
use crate::error::error;
|
|
use crate::schemas::gatekeeper;
|
|
use crate::schemas::protocol as P;
|
|
use crate::schemas::sturdy;
|
|
|
|
use futures::Sink;
|
|
use futures::SinkExt;
|
|
use futures::Stream;
|
|
use futures::StreamExt;
|
|
|
|
use parking_lot::Mutex;
|
|
|
|
use preserves::error::Error as PreservesError;
|
|
use preserves::error::is_eof_io_error;
|
|
use preserves::value::BinarySource;
|
|
use preserves::value::BytesBinarySource;
|
|
use preserves::value::DomainDecode;
|
|
use preserves::value::DomainEncode;
|
|
use preserves::value::Map;
|
|
use preserves::value::NestedValue;
|
|
use preserves::value::NoEmbeddedDomainCodec;
|
|
use preserves::value::PackedWriter;
|
|
use preserves::value::TextWriter;
|
|
use preserves::value::ViaCodec;
|
|
use preserves::value::Writer;
|
|
use preserves::value::signed_integer::SignedInteger;
|
|
|
|
use preserves_schema::Codec;
|
|
use preserves_schema::Deserialize;
|
|
use preserves_schema::ParseError;
|
|
|
|
use std::io;
|
|
use std::pin::Pin;
|
|
use std::sync::Arc;
|
|
use std::sync::atomic::AtomicUsize;
|
|
use std::sync::atomic::Ordering;
|
|
|
|
use tokio::io::AsyncRead;
|
|
use tokio::io::AsyncReadExt;
|
|
use tokio::io::AsyncWrite;
|
|
use tokio::io::AsyncWriteExt;
|
|
|
|
use tokio::sync::mpsc::{unbounded_channel, UnboundedSender, UnboundedReceiver};
|
|
|
|
#[derive(Debug, Clone, Copy)]
|
|
enum WireSymbolSide {
|
|
Imported,
|
|
Exported,
|
|
}
|
|
|
|
struct WireSymbol {
|
|
oid: sturdy::Oid,
|
|
obj: Arc<Cap>,
|
|
ref_count: AtomicUsize,
|
|
side: WireSymbolSide,
|
|
}
|
|
|
|
struct Membrane {
|
|
side: WireSymbolSide,
|
|
oid_map: Map<sturdy::Oid, Arc<WireSymbol>>,
|
|
ref_map: Map<Arc<Cap>, Arc<WireSymbol>>,
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
struct Membranes {
|
|
exported: Membrane,
|
|
imported: Membrane,
|
|
next_export_oid: usize,
|
|
}
|
|
|
|
pub enum Input {
|
|
Packets(Pin<Box<dyn Stream<Item = Result<Vec<u8>, Error>> + Send>>),
|
|
Bytes(Pin<Box<dyn AsyncRead + Send>>),
|
|
}
|
|
|
|
pub enum Output {
|
|
Packets(Pin<Box<dyn Sink<Vec<u8>, Error = Error> + Send>>),
|
|
Bytes(Pin<Box<dyn AsyncWrite + Send>>),
|
|
}
|
|
|
|
type TunnelRelayRef = Arc<Mutex<Option<TunnelRelay>>>;
|
|
|
|
// There are other kinds of relay. This one has exactly two participants connected to each other.
|
|
pub struct TunnelRelay
|
|
{
|
|
self_ref: TunnelRelayRef,
|
|
inbound_assertions: Map</* remote */ P::Handle, (/* local */ Handle, Vec<Arc<WireSymbol>>)>,
|
|
outbound_assertions: Map<P::Handle, Vec<Arc<WireSymbol>>>,
|
|
membranes: Membranes,
|
|
pending_outbound: Vec<P::TurnEvent<AnyValue>>,
|
|
self_entity: Arc<Ref<()>>,
|
|
output: UnboundedSender<LoanedItem<Vec<u8>>>,
|
|
output_text: bool,
|
|
}
|
|
|
|
struct RelayEntity {
|
|
relay_ref: TunnelRelayRef,
|
|
oid: sturdy::Oid,
|
|
}
|
|
|
|
struct TunnelRefEntity {
|
|
relay_ref: TunnelRelayRef,
|
|
}
|
|
|
|
struct ActivatedMembranes<'a, 'activation, 'm> {
|
|
turn: &'a mut Activation<'activation>,
|
|
tr_ref: &'m TunnelRelayRef,
|
|
membranes: &'m mut Membranes,
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
impl WireSymbol {
|
|
#[inline]
|
|
fn inc_ref<'a>(self: &'a Arc<Self>) -> &'a Arc<Self> {
|
|
self.ref_count.fetch_add(1, Ordering::SeqCst);
|
|
tracing::trace!(?self, "after inc_ref");
|
|
self
|
|
}
|
|
|
|
#[inline]
|
|
fn dec_ref(&self) -> bool {
|
|
let old_count = self.ref_count.fetch_sub(1, Ordering::SeqCst);
|
|
tracing::trace!(?self, "after dec_ref");
|
|
old_count == 1
|
|
}
|
|
|
|
#[inline]
|
|
fn current_ref_count(&self) -> usize {
|
|
self.ref_count.load(Ordering::SeqCst)
|
|
}
|
|
}
|
|
|
|
impl std::fmt::Debug for WireSymbol {
|
|
fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
|
|
write!(f, "#<WireSymbol oid={:?}:{} obj={:?} ref_count={}>",
|
|
self.side,
|
|
self.oid.0,
|
|
self.obj,
|
|
self.current_ref_count())
|
|
}
|
|
}
|
|
|
|
impl Membrane {
|
|
fn new(side: WireSymbolSide) -> Self {
|
|
Membrane {
|
|
side,
|
|
oid_map: Map::new(),
|
|
ref_map: Map::new(),
|
|
}
|
|
}
|
|
|
|
fn insert(&mut self, oid: sturdy::Oid, obj: Arc<Cap>) -> Arc<WireSymbol> {
|
|
let ws = Arc::new(WireSymbol {
|
|
oid: oid.clone(),
|
|
obj: Arc::clone(&obj),
|
|
ref_count: AtomicUsize::new(0),
|
|
side: self.side,
|
|
});
|
|
self.oid_map.insert(oid, Arc::clone(&ws));
|
|
self.ref_map.insert(obj, Arc::clone(&ws));
|
|
ws
|
|
}
|
|
|
|
fn insert_inert_entity(&mut self, t: &mut Activation, oid: sturdy::Oid) -> Arc<WireSymbol> {
|
|
self.insert(oid, Cap::new(&t.inert_entity()))
|
|
}
|
|
}
|
|
|
|
pub fn connect_stream<I, O, E, F>(
|
|
t: &mut Activation,
|
|
i: I,
|
|
o: O,
|
|
output_text: bool,
|
|
sturdyref: sturdy::SturdyRef,
|
|
initial_state: E,
|
|
mut f: F,
|
|
) where
|
|
I: 'static + Send + AsyncRead,
|
|
O: 'static + Send + AsyncWrite,
|
|
E: 'static + Send,
|
|
F: 'static + Send + FnMut(&mut E, &mut Activation, Arc<Cap>) -> during::DuringResult<E>
|
|
{
|
|
let i = Input::Bytes(Box::pin(i));
|
|
let o = Output::Bytes(Box::pin(o));
|
|
let gatekeeper = TunnelRelay::run(t, i, o, None, Some(sturdy::Oid(0.into())), output_text).unwrap();
|
|
let main_entity = t.create(during::entity(initial_state).on_asserted(move |state, t, a: AnyValue| {
|
|
let denotation = a.value().to_embedded()?;
|
|
f(state, t, Arc::clone(denotation))
|
|
}));
|
|
gatekeeper.assert(t, language(), &gatekeeper::Resolve {
|
|
sturdyref,
|
|
observer: Cap::new(&main_entity),
|
|
});
|
|
}
|
|
|
|
impl std::fmt::Debug for Membrane {
|
|
fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
|
|
f.debug_struct("Membrane")
|
|
.field("side", &self.side)
|
|
.field("refs", &self.oid_map.values())
|
|
.finish()
|
|
}
|
|
}
|
|
|
|
macro_rules! dump_membranes { ($e:expr) => { tracing::trace!("membranes: {:#?}", $e); } }
|
|
// macro_rules! dump_membranes { ($e:expr) => { (); } }
|
|
|
|
impl TunnelRelay {
|
|
pub fn run(
|
|
t: &mut Activation,
|
|
i: Input,
|
|
o: Output,
|
|
initial_ref: Option<Arc<Cap>>,
|
|
initial_oid: Option<sturdy::Oid>,
|
|
output_text: bool,
|
|
) -> Option<Arc<Cap>> {
|
|
let (output_tx, output_rx) = unbounded_channel();
|
|
let tr_ref = Arc::new(Mutex::new(None));
|
|
let self_entity = t.create(TunnelRefEntity {
|
|
relay_ref: Arc::clone(&tr_ref),
|
|
});
|
|
let mut tr = TunnelRelay {
|
|
self_ref: Arc::clone(&tr_ref),
|
|
output: output_tx,
|
|
output_text,
|
|
inbound_assertions: Map::new(),
|
|
outbound_assertions: Map::new(),
|
|
membranes: Membranes {
|
|
exported: Membrane::new(WireSymbolSide::Exported),
|
|
imported: Membrane::new(WireSymbolSide::Imported),
|
|
next_export_oid: 0,
|
|
},
|
|
pending_outbound: Vec::new(),
|
|
self_entity: self_entity.clone(),
|
|
};
|
|
if let Some(ir) = initial_ref {
|
|
tr.membranes.export_ref(ir).inc_ref();
|
|
}
|
|
let result = initial_oid.map(
|
|
|io| Arc::clone(&tr.membranes.import_oid(t, &tr_ref, io).inc_ref().obj));
|
|
dump_membranes!(tr.membranes);
|
|
*tr_ref.lock() = Some(tr);
|
|
t.linked_task(crate::name!("writer"), output_loop(o, output_rx));
|
|
t.linked_task(crate::name!("reader"), input_loop(t.facet.clone(), i, tr_ref));
|
|
t.state.add_exit_hook(&self_entity);
|
|
result
|
|
}
|
|
|
|
fn deserialize_one(&mut self, t: &mut Activation, bs: &[u8]) -> (Result<P::Packet<AnyValue>, ParseError>, usize) {
|
|
let mut src = BytesBinarySource::new(&bs);
|
|
let mut dec = ActivatedMembranes {
|
|
turn: t,
|
|
tr_ref: &self.self_ref,
|
|
membranes: &mut self.membranes,
|
|
};
|
|
match src.peek() {
|
|
Ok(v) => if v >= 128 {
|
|
self.output_text = false;
|
|
let mut r = src.packed(&mut dec);
|
|
let res = P::Packet::deserialize(&mut r);
|
|
(res, r.source.index)
|
|
} else {
|
|
self.output_text = true;
|
|
let mut dec = ViaCodec::new(dec);
|
|
let mut r = src.text::<AnyValue, _>(&mut dec);
|
|
let res = P::Packet::deserialize(&mut r);
|
|
(res, r.source.index)
|
|
},
|
|
Err(e) => (Err(e.into()), 0)
|
|
}
|
|
}
|
|
|
|
fn handle_inbound_datagram(&mut self, t: &mut Activation, bs: &[u8]) -> ActorResult {
|
|
tracing::trace!(bytes = ?bs, "inbound datagram");
|
|
let item = self.deserialize_one(t, bs).0?;
|
|
self.handle_inbound_packet(t, item)
|
|
}
|
|
|
|
fn handle_inbound_stream(&mut self, t: &mut Activation, buf: &mut BytesMut) -> ActorResult {
|
|
loop {
|
|
tracing::trace!(buffer = ?buf, "inbound stream");
|
|
let (result, count) = self.deserialize_one(t, buf);
|
|
match result {
|
|
Err(ParseError::Preserves(PreservesError::Io(e)))
|
|
if is_eof_io_error(&e) => return Ok(()),
|
|
Err(e) => return Err(e)?,
|
|
Ok(item) => {
|
|
buf.advance(count);
|
|
self.handle_inbound_packet(t, item)?;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn handle_inbound_packet(&mut self, t: &mut Activation, p: P::Packet<AnyValue>) -> ActorResult {
|
|
tracing::debug!(packet = ?p, "-->");
|
|
match p {
|
|
P::Packet::Error(b) => {
|
|
tracing::info!(message = ?b.message.clone(),
|
|
detail = ?b.detail.clone(),
|
|
"received Error from peer");
|
|
Err(*b)
|
|
},
|
|
P::Packet::Turn(b) => {
|
|
let P::Turn(events) = *b;
|
|
for P::TurnEvent { oid, event } in events {
|
|
tracing::trace!(?oid, ?event, "handle_inbound");
|
|
let target = match self.membranes.exported.oid_map.get(&sturdy::Oid(oid.0.clone())) {
|
|
Some(ws) =>
|
|
ws.inc_ref(),
|
|
None => {
|
|
tracing::debug!(
|
|
event = ?language().unparse(&P::TurnEvent { oid, event }),
|
|
"Cannot deliver event: nonexistent oid");
|
|
continue;
|
|
}
|
|
};
|
|
let mut pins = vec![target.clone()];
|
|
let target = Arc::clone(&target.obj);
|
|
match event {
|
|
P::Event::Assert(b) => {
|
|
let P::Assert { assertion: P::Assertion(a), handle: remote_handle } = *b;
|
|
a.foreach_embedded::<_, Error>(
|
|
&mut |r| Ok(pins.push(self.membranes.lookup_ref(r))))?;
|
|
if let Some(local_handle) = target.assert(t, &(), &a) {
|
|
if let Some(_) = self.inbound_assertions.insert(remote_handle, (local_handle, pins)) {
|
|
return Err(error("Assertion with duplicate handle", AnyValue::new(false)));
|
|
}
|
|
} else {
|
|
self.membranes.release(pins);
|
|
}
|
|
dump_membranes!(self.membranes);
|
|
}
|
|
P::Event::Retract(b) => {
|
|
let P::Retract { handle: remote_handle } = *b;
|
|
let (local_handle, previous_pins) = match self.inbound_assertions.remove(&remote_handle) {
|
|
None => return Err(error("Retraction of nonexistent handle", language().unparse(&remote_handle))),
|
|
Some(wss) => wss,
|
|
};
|
|
self.membranes.release(previous_pins);
|
|
self.membranes.release(pins);
|
|
t.retract(local_handle);
|
|
dump_membranes!(self.membranes);
|
|
}
|
|
P::Event::Message(b) => {
|
|
let P::Message { body: P::Assertion(a) } = *b;
|
|
a.foreach_embedded(&mut |r| {
|
|
let ws = self.membranes.lookup_ref(r);
|
|
let rc = ws.current_ref_count();
|
|
pins.push(ws);
|
|
match rc {
|
|
1 => Err(error("Cannot receive transient reference", AnyValue::new(false))),
|
|
_ => Ok(())
|
|
}
|
|
})?;
|
|
target.message(t, &(), &a);
|
|
self.membranes.release(pins);
|
|
dump_membranes!(self.membranes);
|
|
}
|
|
P::Event::Sync(b) => {
|
|
let P::Sync { peer } = *b;
|
|
pins.push(self.membranes.lookup_ref(&peer));
|
|
dump_membranes!(self.membranes);
|
|
struct SyncPeer {
|
|
relay_ref: TunnelRelayRef,
|
|
peer: Arc<Cap>,
|
|
pins: Vec<Arc<WireSymbol>>,
|
|
}
|
|
impl Entity<Synced> for SyncPeer {
|
|
fn message(&mut self, t: &mut Activation, _a: Synced) -> ActorResult {
|
|
self.peer.message(t, &(), &AnyValue::new(true));
|
|
let mut g = self.relay_ref.lock();
|
|
let tr = g.as_mut().expect("initialized");
|
|
tr.membranes.release(std::mem::take(&mut self.pins));
|
|
dump_membranes!(tr.membranes);
|
|
Ok(())
|
|
}
|
|
}
|
|
let k = t.create(SyncPeer {
|
|
relay_ref: Arc::clone(&self.self_ref),
|
|
peer: Arc::clone(&peer),
|
|
pins,
|
|
});
|
|
t.sync(&peer.underlying, k);
|
|
}
|
|
}
|
|
}
|
|
t.deliver();
|
|
Ok(())
|
|
}
|
|
}
|
|
}
|
|
|
|
fn outbound_event_bookkeeping(
|
|
&mut self,
|
|
_t: &mut Activation,
|
|
remote_oid: sturdy::Oid,
|
|
event: &P::Event<AnyValue>,
|
|
) -> ActorResult {
|
|
match event {
|
|
P::Event::Assert(b) => {
|
|
let P::Assert { assertion: P::Assertion(a), handle } = &**b;
|
|
if let Some(target_ws) = self.membranes.imported.oid_map.get(&remote_oid).map(Arc::clone) {
|
|
target_ws.inc_ref(); // encoding won't do this; target oid is syntactically special
|
|
let mut pins = vec![target_ws];
|
|
a.foreach_embedded::<_, Error>(
|
|
&mut |r| Ok(pins.push(self.membranes.lookup_ref(r))))?;
|
|
self.outbound_assertions.insert(handle.clone(), pins);
|
|
dump_membranes!(self.membranes);
|
|
} else {
|
|
// This can happen if
|
|
// 1. remote peer asserts a value causing remote_oid to be allocated
|
|
// 2. some local actor holds a reference to that entity
|
|
// 3. remote peer retracts the value
|
|
// 4. local actor uses the ref
|
|
tracing::trace!(?remote_oid, "not registered in imported membrane (ok)");
|
|
}
|
|
}
|
|
P::Event::Retract(b) => {
|
|
let P::Retract { handle } = &**b;
|
|
if let Some(pins) = self.outbound_assertions.remove(handle) {
|
|
self.membranes.release(pins);
|
|
dump_membranes!(self.membranes);
|
|
} else {
|
|
// This can happen e.g. if an assert leads to no
|
|
// outbound message as in the scenario in the
|
|
// P::Event::Assert stanza above, and then the
|
|
// local actor retracts their assertion again.
|
|
tracing::trace!(?handle, "not registered in outbound_assertions (ok)");
|
|
}
|
|
}
|
|
P::Event::Message(b) => {
|
|
let P::Message { body: P::Assertion(a) } = &**b;
|
|
a.foreach_embedded(&mut |r| {
|
|
let ws = self.membranes.lookup_ref(r);
|
|
if self.membranes.release_one(ws) { // undo the inc_ref from encoding
|
|
Err(error("Sent transient reference", AnyValue::new(false)))
|
|
} else {
|
|
Ok(())
|
|
}
|
|
})?;
|
|
dump_membranes!(self.membranes);
|
|
},
|
|
P::Event::Sync(_b) =>
|
|
todo!(),
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
pub fn send_packet(&mut self, account: &Arc<Account>, cost: usize, p: P::Packet<AnyValue>) -> ActorResult {
|
|
let item = language().unparse(&p);
|
|
tracing::debug!(packet = ?item, "<--");
|
|
|
|
let bs = if self.output_text {
|
|
let mut s = TextWriter::encode(&mut self.membranes, &item)?;
|
|
s.push('\n');
|
|
s.into_bytes()
|
|
} else {
|
|
PackedWriter::encode(&mut self.membranes, &item)?
|
|
};
|
|
|
|
let _ = self.output.send(LoanedItem::new(account, cost, bs));
|
|
Ok(())
|
|
}
|
|
|
|
pub fn send_event(&mut self, t: &mut Activation, remote_oid: sturdy::Oid, event: P::Event<AnyValue>) -> ActorResult {
|
|
if self.pending_outbound.is_empty() {
|
|
t.message_for_myself(&self.self_entity, ());
|
|
}
|
|
self.pending_outbound.push(P::TurnEvent { oid: P::Oid(remote_oid.0), event });
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl Membranes {
|
|
fn export_ref(&mut self, obj: Arc<Cap>) -> Arc<WireSymbol> {
|
|
let oid = sturdy::Oid(SignedInteger::from(self.next_export_oid as u128));
|
|
self.next_export_oid += 1;
|
|
self.exported.insert(oid, obj)
|
|
}
|
|
|
|
fn import_oid(
|
|
&mut self,
|
|
t: &mut Activation,
|
|
relay_ref: &TunnelRelayRef,
|
|
oid: sturdy::Oid,
|
|
) -> Arc<WireSymbol> {
|
|
let obj = t.create(RelayEntity { relay_ref: Arc::clone(relay_ref), oid: oid.clone() });
|
|
self.imported.insert(oid, Cap::new(&obj))
|
|
}
|
|
|
|
#[inline]
|
|
fn lookup_ref(&mut self, r: &Arc<Cap>) -> Arc<WireSymbol> {
|
|
self.imported.ref_map.get(r).or_else(|| self.exported.ref_map.get(r)).map(Arc::clone)
|
|
.expect("WireSymbol must be present at lookup_ref() time")
|
|
}
|
|
|
|
#[inline]
|
|
fn membrane(&mut self, side: WireSymbolSide) -> &mut Membrane {
|
|
match side {
|
|
WireSymbolSide::Imported => &mut self.imported,
|
|
WireSymbolSide::Exported => &mut self.exported,
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
fn release_one(&mut self, ws: Arc<WireSymbol>) -> bool {
|
|
if ws.dec_ref() {
|
|
let membrane = self.membrane(ws.side);
|
|
membrane.oid_map.remove(&ws.oid);
|
|
membrane.ref_map.remove(&ws.obj);
|
|
true
|
|
} else {
|
|
false
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
fn release<I: IntoIterator<Item = Arc<WireSymbol>>>(&mut self, wss: I) {
|
|
for ws in wss {
|
|
self.release_one(ws);
|
|
}
|
|
}
|
|
|
|
fn decode_embedded<'de, 'src, S: BinarySource<'de>>(
|
|
&mut self,
|
|
t: &mut Activation,
|
|
relay_ref: &TunnelRelayRef,
|
|
src: &'src mut S,
|
|
_read_annotations: bool,
|
|
) -> io::Result<Arc<Cap>> {
|
|
let ws = match sturdy::WireRef::deserialize(&mut src.packed(NoEmbeddedDomainCodec))? {
|
|
sturdy::WireRef::Mine{ oid: b } => {
|
|
let oid = *b;
|
|
self.imported.oid_map.get(&oid).map(Arc::clone)
|
|
.unwrap_or_else(|| self.import_oid(t, relay_ref, oid))
|
|
}
|
|
sturdy::WireRef::Yours { oid: b, attenuation } => {
|
|
let oid = *b;
|
|
if attenuation.is_empty() {
|
|
self.exported.oid_map.get(&oid).map(Arc::clone).unwrap_or_else(
|
|
|| self.exported.insert_inert_entity(t, oid))
|
|
} else {
|
|
match self.exported.oid_map.get(&oid) {
|
|
None => self.exported.insert_inert_entity(t, oid),
|
|
Some(ws) => {
|
|
let attenuated_obj = ws.obj.attenuate(&sturdy::Attenuation(attenuation))
|
|
.map_err(|e| {
|
|
io::Error::new(
|
|
io::ErrorKind::InvalidInput,
|
|
format!("Invalid capability attenuation: {:?}", e))
|
|
})?;
|
|
self.exported.insert(oid, attenuated_obj)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
Ok(Arc::clone(&ws.inc_ref().obj))
|
|
}
|
|
}
|
|
|
|
impl<'a, 'activation, 'm> DomainDecode<Arc<Cap>> for ActivatedMembranes<'a, 'activation, 'm> {
|
|
fn decode_embedded<'de, 'src, S: BinarySource<'de>>(
|
|
&mut self,
|
|
src: &'src mut S,
|
|
read_annotations: bool,
|
|
) -> io::Result<Arc<Cap>> {
|
|
self.membranes.decode_embedded(self.turn, self.tr_ref, src, read_annotations)
|
|
}
|
|
}
|
|
|
|
impl DomainEncode<Arc<Cap>> for Membranes {
|
|
fn encode_embedded<W: Writer>(
|
|
&mut self,
|
|
w: &mut W,
|
|
d: &Arc<Cap>,
|
|
) -> io::Result<()> {
|
|
w.write(&mut NoEmbeddedDomainCodec, &language().unparse(&match self.exported.ref_map.get(d) {
|
|
Some(ws) => sturdy::WireRef::Mine {
|
|
oid: Box::new(ws.inc_ref().oid.clone()),
|
|
},
|
|
None => match self.imported.ref_map.get(d) {
|
|
Some(ws) => {
|
|
if d.attenuation.is_empty() {
|
|
sturdy::WireRef::Yours {
|
|
oid: Box::new(ws.inc_ref().oid.clone()),
|
|
attenuation: vec![],
|
|
}
|
|
} else {
|
|
// We may trust the peer to enforce attenuation on our behalf, in
|
|
// which case we can return sturdy::WireRef::Yours with an attenuation
|
|
// attached here, but for now we don't.
|
|
sturdy::WireRef::Mine {
|
|
oid: Box::new(self.export_ref(Arc::clone(d)).inc_ref().oid.clone()),
|
|
}
|
|
}
|
|
}
|
|
None =>
|
|
sturdy::WireRef::Mine {
|
|
oid: Box::new(self.export_ref(Arc::clone(d)).inc_ref().oid.clone()),
|
|
},
|
|
}
|
|
}))
|
|
}
|
|
}
|
|
|
|
async fn input_loop(
|
|
facet: FacetRef,
|
|
i: Input,
|
|
relay: TunnelRelayRef,
|
|
) -> Result<LinkedTaskTermination, Error> {
|
|
let account = Account::new(crate::name!("input-loop"));
|
|
match i {
|
|
Input::Packets(mut src) => {
|
|
loop {
|
|
account.ensure_clear_funds().await;
|
|
match src.next().await {
|
|
None => return Ok(LinkedTaskTermination::Normal),
|
|
Some(bs) => {
|
|
let r = facet.activate(Arc::clone(&account), |t| {
|
|
let mut g = relay.lock();
|
|
let tr = g.as_mut().expect("initialized");
|
|
tr.handle_inbound_datagram(t, &bs?)
|
|
});
|
|
if !r.is_success() { return Ok(LinkedTaskTermination::Normal); }
|
|
}
|
|
}
|
|
}
|
|
}
|
|
Input::Bytes(mut r) => {
|
|
const BUFSIZE: usize = 65536;
|
|
let mut buf = BytesMut::with_capacity(BUFSIZE);
|
|
loop {
|
|
account.ensure_clear_funds().await;
|
|
buf.reserve(BUFSIZE);
|
|
let n = match r.read_buf(&mut buf).await {
|
|
Ok(n) => n,
|
|
Err(e) =>
|
|
if e.kind() == io::ErrorKind::ConnectionReset {
|
|
return Ok(LinkedTaskTermination::Normal);
|
|
} else {
|
|
return Err(e)?;
|
|
},
|
|
};
|
|
match n {
|
|
0 => return Ok(LinkedTaskTermination::Normal),
|
|
_ => {
|
|
let r = facet.activate(Arc::clone(&account), |t| {
|
|
let mut g = relay.lock();
|
|
let tr = g.as_mut().expect("initialized");
|
|
tr.handle_inbound_stream(t, &mut buf)
|
|
});
|
|
if !r.is_success() { return Ok(LinkedTaskTermination::Normal); }
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
async fn output_loop(
|
|
mut o: Output,
|
|
mut output_rx: UnboundedReceiver<LoanedItem<Vec<u8>>>,
|
|
) -> Result<LinkedTaskTermination, Error> {
|
|
loop {
|
|
match output_rx.recv().await {
|
|
None =>
|
|
return Ok(LinkedTaskTermination::KeepFacet),
|
|
Some(mut loaned_item) => {
|
|
match &mut o {
|
|
Output::Packets(sink) => sink.send(std::mem::take(&mut loaned_item.item)).await?,
|
|
Output::Bytes(w) => {
|
|
w.write_all(&loaned_item.item).await?;
|
|
w.flush().await?;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Entity<()> for TunnelRefEntity {
|
|
fn message(&mut self, t: &mut Activation, _m: ()) -> ActorResult {
|
|
let mut g = self.relay_ref.lock();
|
|
let tr = g.as_mut().expect("initialized");
|
|
let events = std::mem::take(&mut tr.pending_outbound);
|
|
tr.send_packet(&t.account(), events.len(), P::Packet::Turn(Box::new(P::Turn(events.clone()))))?;
|
|
for P::TurnEvent { oid, event } in events.into_iter() {
|
|
tr.outbound_event_bookkeeping(t, sturdy::Oid(oid.0), &event)?;
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn exit_hook(&mut self, t: &mut Activation, exit_status: &Arc<ActorResult>) -> ActorResult {
|
|
if let Err(e) = &**exit_status {
|
|
let e = e.clone();
|
|
let mut g = self.relay_ref.lock();
|
|
let tr = g.as_mut().expect("initialized");
|
|
tr.send_packet(&t.account(), 1, P::Packet::Error(Box::new(e)))?;
|
|
}
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl Entity<AnyValue> for RelayEntity {
|
|
fn assert(&mut self, t: &mut Activation, a: AnyValue, h: Handle) -> ActorResult {
|
|
self.relay_ref.lock().as_mut().expect("initialized")
|
|
.send_event(t, self.oid.clone(), P::Event::Assert(Box::new(P::Assert {
|
|
assertion: P::Assertion(a),
|
|
handle: P::Handle(h.into()),
|
|
})))
|
|
}
|
|
fn retract(&mut self, t: &mut Activation, h: Handle) -> ActorResult {
|
|
self.relay_ref.lock().as_mut().expect("initialized")
|
|
.send_event(t, self.oid.clone(), P::Event::Retract(Box::new(P::Retract {
|
|
handle: P::Handle(h.into()),
|
|
})))
|
|
}
|
|
fn message(&mut self, t: &mut Activation, m: AnyValue) -> ActorResult {
|
|
self.relay_ref.lock().as_mut().expect("initialized")
|
|
.send_event(t, self.oid.clone(), P::Event::Message(Box::new(P::Message {
|
|
body: P::Assertion(m)
|
|
})))
|
|
}
|
|
fn sync(&mut self, t: &mut Activation, peer: Arc<Ref<Synced>>) -> ActorResult {
|
|
self.relay_ref.lock().as_mut().expect("initialized")
|
|
.send_event(t, self.oid.clone(), P::Event::Sync(Box::new(P::Sync {
|
|
peer: Cap::guard(Arc::new(()), peer)
|
|
})))
|
|
}
|
|
}
|