use crate::hook::{CancelToken, EnterGuard, CANCELLED_SENTINEL};
use crate::hooks;
use mlua::{Function, Lua, MultiValue, Value};
use std::cell::{Cell, RefCell};
use std::future::Future;
use std::pin::Pin;
use std::rc::Rc;
use std::task::{Context, Poll};
use std::time::Duration;
pub(crate) const WRAP_CALL: &str = "local mark, f = ... \
local pack, unpack = table.pack, table.unpack \
return function(...) \
mark() \
local r = pack(pcall(f, ...)) \
if r[1] then return unpack(r, 2, r.n) end \
error(r[2], 0) \
end";
pub(crate) const WRAP_PCALL: &str =
"local mark, f = ... return function(...) mark() return pcall(f, ...) end";
thread_local! {
static SCOPE: RefCell<Option<Rc<Scope>>> = const { RefCell::new(None) };
}
pub(crate) fn current_scope() -> Option<Rc<Scope>> {
SCOPE.with(|s| s.borrow().clone())
}
#[derive(Default)]
pub(crate) struct Scope {
children: RefCell<Vec<Rc<TaskState>>>,
}
impl Scope {
pub(crate) fn add(&self, child: Rc<TaskState>) {
let mut children = self.children.borrow_mut();
children.retain(|c| !c.is_done());
children.push(child);
}
fn cancel_all(&self) {
for c in self.children.borrow().iter() {
c.token.cancel();
}
}
async fn wait_all(&self) {
let children = self.children.borrow().clone();
for c in children {
c.wait_done().await;
}
}
fn abort_all(&self) {
for c in self.children.borrow().iter() {
c.token.cancel();
if let Some(h) = c.abort.borrow_mut().take() {
h.abort();
}
}
}
}
pub(crate) enum Outcome {
Values(MultiValue),
Cancelled,
}
pub(crate) struct TaskState {
pub(crate) token: CancelToken,
done: Cell<bool>,
notify: tokio::sync::Notify,
outcome: RefCell<Option<Outcome>>,
pub(crate) abort: RefCell<Option<tokio::task::AbortHandle>>,
}
impl TaskState {
pub(crate) fn new(token: CancelToken) -> Self {
Self {
token,
done: Cell::new(false),
notify: tokio::sync::Notify::new(),
outcome: RefCell::new(None),
abort: RefCell::new(None),
}
}
pub(crate) fn is_done(&self) -> bool {
self.done.get()
}
pub(crate) fn finish(&self, outcome: Outcome) {
if self.done.replace(true) {
return;
}
*self.outcome.borrow_mut() = Some(outcome);
self.abort.borrow_mut().take();
self.notify.notify_waiters();
}
pub(crate) async fn wait_done(&self) {
loop {
let notified = self.notify.notified();
tokio::pin!(notified);
notified.as_mut().enable();
if self.done.get() {
return;
}
notified.await;
}
}
pub(crate) fn take_outcome(&self) -> Option<Outcome> {
self.outcome.borrow_mut().take()
}
}
pub(crate) struct FinishOnDrop(pub(crate) Rc<TaskState>);
impl Drop for FinishOnDrop {
fn drop(&mut self) {
self.0.finish(Outcome::Cancelled);
}
}
struct Scoped<F> {
token: CancelToken,
scope: Rc<Scope>,
root: Rc<Cell<Option<usize>>>,
fut: Pin<Box<F>>,
}
impl<F: Future> Future for Scoped<F> {
type Output = F::Output;
fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<F::Output> {
let _enter = EnterGuard::new(&self.token);
let prev = SCOPE.with(|s| s.replace(Some(self.scope.clone())));
let out = self.fut.as_mut().poll(cx);
SCOPE.with(|s| *s.borrow_mut() = prev);
out
}
}
impl<F> Drop for Scoped<F> {
fn drop(&mut self) {
if let Some(ptr) = self.root.take() {
hooks::unmark_root(ptr);
}
}
}
struct AbortOnDrop(Option<Rc<Scope>>);
impl AbortOnDrop {
fn disarm(mut self) {
self.0 = None;
}
}
impl Drop for AbortOnDrop {
fn drop(&mut self) {
if let Some(scope) = self.0.take() {
scope.abort_all();
}
}
}
pub(crate) fn scoped_call(
lua: &Lua,
token: CancelToken,
wrap: &str,
func: Function,
args: MultiValue,
) -> mlua::Result<impl Future<Output = mlua::Result<MultiValue>>> {
let root = Rc::new(Cell::new(None));
let r = root.clone();
let mark = lua.create_function(move |lua, ()| {
let ptr = lua.current_thread().to_pointer() as usize;
hooks::mark_root(ptr);
r.set(Some(ptr));
Ok(())
})?;
let body: Function = lua.load(wrap).call((mark, func))?;
let scope = Rc::new(Scope::default());
let run = Scoped {
token,
scope: scope.clone(),
root,
fut: Box::pin(body.call_async::<MultiValue>(args)),
};
Ok(async move {
let guard = AbortOnDrop(Some(scope.clone()));
let out = run.await;
scope.cancel_all();
scope.wait_all().await;
guard.disarm();
out
})
}
pub(crate) async fn with_grace<F: Future>(
token: &CancelToken,
grace: Duration,
fut: F,
) -> Option<F::Output> {
tokio::pin!(fut);
tokio::select! {
biased;
out = &mut fut => return Some(out),
_ = token.cancelled() => {}
}
tokio::time::timeout(grace, fut).await.ok()
}
pub async fn cancellable<F, T>(fut: F) -> mlua::Result<T>
where
F: Future<Output = mlua::Result<T>>,
{
match crate::hook::current_token() {
None => fut.await,
Some(token) => tokio::select! {
biased;
_ = token.cancelled() => Err(mlua::Error::runtime(CANCELLED_SENTINEL)),
out = fut => out,
},
}
}
pub async fn run_root(
lua: &Lua,
token: CancelToken,
func: Function,
args: MultiValue,
) -> Result<MultiValue, crate::IsleError> {
hooks::ensure_installed(lua)?;
let grace = hooks::config(lua).grace;
let run = scoped_call(lua, token.clone(), WRAP_CALL, func, args)?;
let out = with_grace(&token, grace, run).await;
if token.is_cancelled() {
return Err(crate::IsleError::Cancelled);
}
match out {
Some(r) => r.map_err(crate::IsleError::from),
None => Err(crate::IsleError::Cancelled),
}
}
pub(crate) fn error_value(e: mlua::Error) -> Value {
Value::Error(Box::new(e))
}