forked from Orchid/orchid
308 lines
11 KiB
Rust
308 lines
11 KiB
Rust
use std::cell::RefCell;
|
|
use std::future::Future;
|
|
use std::io;
|
|
use std::num::NonZeroU64;
|
|
use std::pin::pin;
|
|
use std::rc::{Rc, Weak};
|
|
|
|
use async_fn_stream::stream;
|
|
use derive_destructure::destructure;
|
|
use futures::channel::mpsc::{Sender, channel};
|
|
use futures::future::{join, join_all};
|
|
use futures::lock::Mutex;
|
|
use futures::{SinkExt, StreamExt, stream};
|
|
use hashbrown::HashMap;
|
|
use itertools::Itertools;
|
|
use orchid_api_traits::Request;
|
|
use orchid_base::builtin::ExtInit;
|
|
use orchid_base::clone;
|
|
use orchid_base::format::{FmtCtxImpl, Format};
|
|
use orchid_base::interner::Tok;
|
|
use orchid_base::logging::Logger;
|
|
use orchid_base::name::Sym;
|
|
use orchid_base::reqnot::{DynRequester, ReqNot, Requester as _};
|
|
|
|
use crate::api;
|
|
use crate::atom::AtomHand;
|
|
use crate::ctx::Ctx;
|
|
use crate::dealias::{ChildError, ChildErrorKind, walk};
|
|
use crate::expr_store::ExprStore;
|
|
use crate::system::SystemCtor;
|
|
use crate::tree::MemberKind;
|
|
|
|
pub struct ReqPair<R: Request>(R, Sender<R::Response>);
|
|
|
|
/// Data held about an Extension. This is refcounted within [Extension]. It's
|
|
/// important to only ever access parts of this struct through the [Arc] because
|
|
/// the components reference each other through [Weak]s of it, and will panic if
|
|
/// upgrading fails.
|
|
#[derive(destructure)]
|
|
pub struct ExtensionData {
|
|
ctx: Ctx,
|
|
reqnot: ReqNot<api::HostMsgSet>,
|
|
systems: Vec<SystemCtor>,
|
|
logger: Logger,
|
|
next_pars: RefCell<NonZeroU64>,
|
|
exprs: ExprStore,
|
|
exiting_snd: Sender<()>,
|
|
lex_recur: Mutex<HashMap<api::ParsId, Sender<ReqPair<api::SubLex>>>>,
|
|
}
|
|
impl Drop for ExtensionData {
|
|
fn drop(&mut self) {
|
|
let reqnot = self.reqnot.clone();
|
|
let mut exiting_snd = self.exiting_snd.clone();
|
|
(self.ctx.spawn)(Box::pin(async move {
|
|
reqnot.notify(api::HostExtNotif::Exit).await;
|
|
exiting_snd.send(()).await.unwrap()
|
|
}))
|
|
}
|
|
}
|
|
|
|
#[derive(Clone)]
|
|
pub struct Extension(Rc<ExtensionData>);
|
|
impl Extension {
|
|
pub fn new(init: ExtInit, logger: Logger, msg_logger: Logger, ctx: Ctx) -> io::Result<Self> {
|
|
Ok(Self(Rc::new_cyclic(|weak: &Weak<ExtensionData>| {
|
|
let init = Rc::new(init);
|
|
let (exiting_snd, exiting_rcv) = channel::<()>(0);
|
|
(ctx.spawn)(clone!(init, weak, ctx; Box::pin(async move {
|
|
let rcv_stream = stream(async |mut cx| loop { cx.emit( init.recv().await).await });
|
|
let mut event_stream = pin!(stream::select(exiting_rcv.map(|()| None), rcv_stream));
|
|
while let Some(Some(msg)) = event_stream.next().await {
|
|
if let Some(reqnot) = weak.upgrade().map(|rc| rc.reqnot.clone()) {
|
|
let reqnot = reqnot.clone();
|
|
(ctx.spawn)(Box::pin(async move {
|
|
reqnot.receive(&msg).await;
|
|
}))
|
|
}
|
|
}
|
|
})));
|
|
ExtensionData {
|
|
exiting_snd,
|
|
exprs: ctx.common_exprs.derive(),
|
|
ctx: ctx.clone(),
|
|
systems: (init.systems.iter().cloned())
|
|
.map(|decl| SystemCtor { decl, ext: WeakExtension(weak.clone()) })
|
|
.collect(),
|
|
logger: logger.clone(),
|
|
next_pars: RefCell::new(NonZeroU64::new(1).unwrap()),
|
|
lex_recur: Mutex::default(),
|
|
reqnot: ReqNot::new(
|
|
msg_logger,
|
|
move |sfn, _| clone!(init; Box::pin(async move { init.send(sfn).await })),
|
|
clone!(weak; move |notif, _| {
|
|
clone!(weak; Box::pin(async move {
|
|
let this = Extension(weak.upgrade().unwrap());
|
|
match notif {
|
|
api::ExtHostNotif::ExprNotif(api::ExprNotif::Acquire(acq)) => {
|
|
let target = this.0.exprs.get_expr(acq.1).expect("Invalid ticket");
|
|
this.0.exprs.give_expr(target)
|
|
}
|
|
api::ExtHostNotif::ExprNotif(api::ExprNotif::Release(rel)) => {
|
|
this.assert_own_sys(rel.0).await;
|
|
this.0.exprs.take_expr(rel.1)
|
|
}
|
|
api::ExtHostNotif::ExprNotif(api::ExprNotif::Move(mov)) => {
|
|
this.assert_own_sys(mov.dec).await;
|
|
let recp = this.ctx().system_inst(mov.inc).await.expect("invallid recipient sys id");
|
|
let expr = this.0.exprs.get_expr(mov.expr).expect("invalid ticket");
|
|
recp.ext().0.exprs.give_expr(expr);
|
|
this.0.exprs.take_expr(mov.expr);
|
|
},
|
|
api::ExtHostNotif::Log(api::Log(str)) => this.logger().log(str),
|
|
}
|
|
}))}),
|
|
{
|
|
clone!(weak, ctx);
|
|
move |hand, req| {
|
|
clone!(weak, ctx);
|
|
Box::pin(async move {
|
|
let this = Self(weak.upgrade().unwrap());
|
|
writeln!(this.reqnot().logger(), "Host received request {req:?}");
|
|
let i = this.ctx().i.clone();
|
|
match req {
|
|
api::ExtHostReq::Ping(ping) => hand.handle(&ping, &()).await,
|
|
api::ExtHostReq::IntReq(intreq) => match intreq {
|
|
api::IntReq::InternStr(s) => hand.handle(&s, &i.i(&*s.0).await.to_api()).await,
|
|
api::IntReq::InternStrv(v) => {
|
|
let tokens = join_all(v.0.iter().map(|m| i.ex(*m))).await;
|
|
hand.handle(&v, &i.i(&tokens).await.to_api()).await
|
|
},
|
|
api::IntReq::ExternStr(si) =>
|
|
hand.handle(&si, &Tok::<String>::from_api(si.0, &i).await.rc()).await,
|
|
api::IntReq::ExternStrv(vi) => {
|
|
let markerv = (i.ex(vi.0).await.iter()).map(|t| t.to_api()).collect_vec();
|
|
hand.handle(&vi, &markerv).await
|
|
},
|
|
},
|
|
api::ExtHostReq::Fwd(ref fw @ api::Fwd(ref atom, ref key, ref body)) => {
|
|
let sys =
|
|
ctx.system_inst(atom.owner).await.expect("owner of live atom dropped");
|
|
let reply =
|
|
sys.reqnot().request(api::Fwded(fw.0.clone(), *key, body.clone())).await;
|
|
hand.handle(fw, &reply).await
|
|
},
|
|
api::ExtHostReq::SysFwd(ref fw @ api::SysFwd(id, ref body)) => {
|
|
let sys = ctx.system_inst(id).await.unwrap();
|
|
hand.handle(fw, &sys.request(body.clone()).await).await
|
|
},
|
|
api::ExtHostReq::SubLex(sl) => {
|
|
let (rep_in, mut rep_out) = channel(0);
|
|
{
|
|
let lex_g = this.0.lex_recur.lock().await;
|
|
let mut req_in =
|
|
lex_g.get(&sl.id).cloned().expect("Sublex for nonexistent lexid");
|
|
req_in.send(ReqPair(sl.clone(), rep_in)).await.unwrap();
|
|
}
|
|
hand.handle(&sl, &rep_out.next().await.unwrap()).await
|
|
},
|
|
api::ExtHostReq::ExprReq(api::ExprReq::Inspect(
|
|
ins @ api::Inspect { target },
|
|
)) => {
|
|
let expr = this.exprs().get_expr(target).expect("Invalid ticket");
|
|
hand
|
|
.handle(&ins, &api::Inspected {
|
|
refcount: expr.strong_count() as u32,
|
|
location: expr.pos().to_api(),
|
|
kind: expr.to_api().await,
|
|
})
|
|
.await
|
|
},
|
|
api::ExtHostReq::LsModule(ref ls @ api::LsModule(_sys, path)) => {
|
|
let reply: <api::LsModule as Request>::Response = 'reply: {
|
|
let path = i.ex(path).await;
|
|
let root = (ctx.root.read().await.upgrade())
|
|
.expect("LSModule called when root isn't in context");
|
|
let root_data = &mut *root.0.write().await;
|
|
let mut walk_ctx = (ctx.clone(), &mut root_data.consts);
|
|
let module =
|
|
match walk(&root_data.root, false, path.iter().cloned(), &mut walk_ctx)
|
|
.await
|
|
{
|
|
Ok(module) => module,
|
|
Err(ChildError { kind, .. }) =>
|
|
break 'reply Err(match kind {
|
|
ChildErrorKind::Private => panic!("Access checking was disabled"),
|
|
ChildErrorKind::Constant => api::LsModuleError::IsConstant,
|
|
ChildErrorKind::Missing => api::LsModuleError::InvalidPath,
|
|
}),
|
|
};
|
|
let mut members = std::collections::HashMap::new();
|
|
for (k, v) in &module.members {
|
|
let kind = match v.kind(ctx.clone(), &mut root_data.consts).await {
|
|
MemberKind::Const => api::MemberInfoKind::Constant,
|
|
MemberKind::Module(_) => api::MemberInfoKind::Module,
|
|
};
|
|
members.insert(k.to_api(), api::MemberInfo { public: v.public, kind });
|
|
}
|
|
Ok(api::ModuleInfo { members })
|
|
};
|
|
hand.handle(ls, &reply).await
|
|
},
|
|
api::ExtHostReq::ResolveNames(ref rn) => {
|
|
let api::ResolveNames { constid, names, sys } = rn;
|
|
let mut resolver = {
|
|
let systems = ctx.systems.read().await;
|
|
let weak_sys = systems.get(sys).expect("ResolveNames for invalid sys");
|
|
let sys = weak_sys.upgrade().expect("ResolveNames after sys drop");
|
|
sys.name_resolver(*constid).await
|
|
};
|
|
let responses = stream(async |mut cx| {
|
|
for name in names {
|
|
cx.emit(match resolver(&ctx.i.ex(*name).await[..]).await {
|
|
Ok(abs) => Ok(abs.to_sym(&ctx.i).await.to_api()),
|
|
Err(e) => Err(e.to_api()),
|
|
})
|
|
.await
|
|
}
|
|
})
|
|
.collect()
|
|
.await;
|
|
hand.handle(rn, &responses).await
|
|
},
|
|
api::ExtHostReq::ExtAtomPrint(ref eap @ api::ExtAtomPrint(ref atom)) => {
|
|
let atom = AtomHand::new(atom.clone(), &ctx).await;
|
|
let unit = atom.print(&FmtCtxImpl { i: &this.ctx().i }).await;
|
|
hand.handle(eap, &unit.to_api()).await
|
|
},
|
|
}
|
|
})
|
|
}
|
|
},
|
|
),
|
|
}
|
|
})))
|
|
}
|
|
#[must_use]
|
|
pub(crate) fn reqnot(&self) -> &ReqNot<api::HostMsgSet> { &self.0.reqnot }
|
|
#[must_use]
|
|
pub fn ctx(&self) -> &Ctx { &self.0.ctx }
|
|
#[must_use]
|
|
pub fn logger(&self) -> &Logger { &self.0.logger }
|
|
pub fn system_ctors(&self) -> impl Iterator<Item = &SystemCtor> { self.0.systems.iter() }
|
|
#[must_use]
|
|
pub fn exprs(&self) -> &ExprStore { &self.0.exprs }
|
|
#[must_use]
|
|
pub async fn is_own_sys(&self, id: api::SysId) -> bool {
|
|
let sys = self.ctx().system_inst(id).await.expect("invalid sender sys id");
|
|
Rc::ptr_eq(&self.0, &sys.ext().0)
|
|
}
|
|
pub async fn assert_own_sys(&self, id: api::SysId) {
|
|
assert!(self.is_own_sys(id).await, "Incoming message impersonates separate system");
|
|
}
|
|
#[must_use]
|
|
pub fn next_pars(&self) -> NonZeroU64 {
|
|
let mut next_pars = self.0.next_pars.borrow_mut();
|
|
*next_pars = next_pars.checked_add(1).unwrap_or(NonZeroU64::new(1).unwrap());
|
|
*next_pars
|
|
}
|
|
pub(crate) async fn lex_req<F: Future<Output = Option<api::SubLexed>>>(
|
|
&self,
|
|
source: Tok<String>,
|
|
src: Sym,
|
|
pos: u32,
|
|
sys: api::SysId,
|
|
mut r: impl FnMut(u32) -> F,
|
|
) -> api::OrcResult<Option<api::LexedExpr>> {
|
|
// get unique lex ID
|
|
let id = api::ParsId(self.next_pars());
|
|
// create and register channel
|
|
let (req_in, mut req_out) = channel(0);
|
|
self.0.lex_recur.lock().await.insert(id, req_in); // lex_recur released
|
|
let (ret, ()) = join(
|
|
async {
|
|
let res = (self.reqnot())
|
|
.request(api::LexExpr { id, pos, sys, src: src.to_api(), text: source.to_api() })
|
|
.await;
|
|
// collect sender to unblock recursion handler branch before returning
|
|
self.0.lex_recur.lock().await.remove(&id);
|
|
res
|
|
},
|
|
async {
|
|
while let Some(ReqPair(sublex, mut rep_in)) = req_out.next().await {
|
|
(rep_in.send(r(sublex.pos).await).await)
|
|
.expect("Response channel dropped while request pending")
|
|
}
|
|
},
|
|
)
|
|
.await;
|
|
ret.transpose()
|
|
}
|
|
pub fn system_drop(&self, id: api::SysId) {
|
|
let rc = self.clone();
|
|
(self.ctx().spawn)(Box::pin(async move {
|
|
rc.reqnot().notify(api::SystemDrop(id)).await;
|
|
rc.ctx().systems.write().await.remove(&id);
|
|
}))
|
|
}
|
|
#[must_use]
|
|
pub fn downgrade(&self) -> WeakExtension { WeakExtension(Rc::downgrade(&self.0)) }
|
|
}
|
|
|
|
#[derive(Clone)]
|
|
pub struct WeakExtension(Weak<ExtensionData>);
|
|
impl WeakExtension {
|
|
#[must_use]
|
|
pub fn upgrade(&self) -> Option<Extension> { self.0.upgrade().map(Extension) }
|
|
}
|