use crate::async_task::AsyncTask;
use crate::error::{panic_message, IsleError, LuaErrorKind, LuaFailure};
use crate::hook::CancelToken;
use crate::runtime::Config;
use crate::thread;
use crate::Request;
use std::fmt;
use std::sync::Arc;
use std::thread::JoinHandle;
const DEFAULT_CHANNEL_CAPACITY: usize = 256;
#[derive(Clone)]
pub struct AsyncIsle {
tx: tokio::sync::mpsc::Sender<Request>,
id: Arc<IsleId>,
}
struct IsleId;
#[derive(Clone)]
pub struct IsleFunction {
key: Arc<mlua::RegistryKey>,
isle: Arc<IsleId>,
}
impl fmt::Debug for IsleFunction {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("IsleFunction").finish_non_exhaustive()
}
}
#[must_use = "call .shutdown().await for clean thread join; dropping without shutdown detaches the thread"]
pub struct AsyncIsleDriver {
tx: tokio::sync::mpsc::Sender<Request>,
done_rx: Option<tokio::sync::oneshot::Receiver<()>>,
join: Option<JoinHandle<()>>,
}
pub struct AsyncIsleBuilder {
channel_capacity: usize,
thread_name: String,
config: Option<Config>,
lua: Option<LuaFactory>,
}
type LuaFactory = Box<dyn FnOnce() -> mlua::Lua + Send>;
struct Settings {
channel_capacity: usize,
thread_name: String,
config: Option<Config>,
lua: Option<LuaFactory>,
}
impl Default for AsyncIsleBuilder {
fn default() -> Self {
Self {
channel_capacity: DEFAULT_CHANNEL_CAPACITY,
thread_name: "mlua-isle-async".into(),
config: None,
lua: None,
}
}
}
impl AsyncIsleBuilder {
pub fn channel_capacity(mut self, capacity: usize) -> Self {
self.channel_capacity = capacity;
self
}
pub fn thread_name(mut self, name: &str) -> Self {
self.thread_name = name.to_string();
self
}
pub fn config(mut self, config: Config) -> Self {
self.config = Some(config);
self
}
pub fn lua<F>(mut self, factory: F) -> Self
where
F: FnOnce() -> mlua::Lua + Send + 'static,
{
self.lua = Some(Box::new(factory));
self
}
pub async fn spawn<F>(self, init: F) -> Result<(AsyncIsle, AsyncIsleDriver), IsleError>
where
F: FnOnce(&mlua::Lua) -> Result<(), mlua::Error> + Send + 'static,
{
let (isle, driver, ()) = self.spawn_with(init).await?;
Ok((isle, driver))
}
pub async fn spawn_with<F, T>(
self,
init: F,
) -> Result<(AsyncIsle, AsyncIsleDriver, T), IsleError>
where
F: FnOnce(&mlua::Lua) -> Result<T, mlua::Error> + Send + 'static,
T: Send + 'static,
{
AsyncIsle::spawn_inner(
init,
Settings {
channel_capacity: self.channel_capacity,
thread_name: self.thread_name,
config: self.config,
lua: self.lua,
},
)
.await
}
}
impl AsyncIsle {
pub fn builder() -> AsyncIsleBuilder {
AsyncIsleBuilder::default()
}
pub async fn spawn<F>(init: F) -> Result<(Self, AsyncIsleDriver), IsleError>
where
F: FnOnce(&mlua::Lua) -> Result<(), mlua::Error> + Send + 'static,
{
Self::builder().spawn(init).await
}
async fn spawn_inner<F, T>(
init: F,
settings: Settings,
) -> Result<(Self, AsyncIsleDriver, T), IsleError>
where
F: FnOnce(&mlua::Lua) -> Result<T, mlua::Error> + Send + 'static,
T: Send + 'static,
{
let Settings {
channel_capacity,
thread_name,
config,
lua: factory,
} = settings;
let (tx, rx) = tokio::sync::mpsc::channel::<Request>(channel_capacity);
let (init_tx, init_rx) = tokio::sync::oneshot::channel::<Result<T, IsleError>>();
let (done_tx, done_rx) = tokio::sync::oneshot::channel::<()>();
let join = std::thread::Builder::new()
.name(thread_name)
.spawn(move || {
let rt = match tokio::runtime::Builder::new_current_thread()
.enable_all()
.build()
{
Ok(rt) => rt,
Err(e) => {
let _ = init_tx.send(Err(IsleError::Init(LuaFailure::new(
LuaErrorKind::External,
format!("tokio runtime build failed: {e}"),
))));
let _ = done_tx.send(());
return;
}
};
let lua = match factory {
Some(factory) => factory(),
None => mlua::Lua::new(),
};
match crate::protect::install(&lua)
.and_then(|()| {
init(&lua).map_err(|e| IsleError::Init(LuaFailure::from_mlua(&e)))
})
.and_then(|value| {
crate::runtime::attach_after_init(&lua, config).map(|_| value)
}) {
Ok(value) => {
let _ = init_tx.send(Ok(value));
run_async_loop(lua, rx, rt);
}
Err(e) => {
let _ = init_tx.send(Err(e));
}
}
let _ = done_tx.send(());
})
.map_err(|e| IsleError::Init(LuaFailure::from_mlua(&mlua::Error::external(e))))?;
let init_result = init_rx.await;
let init_result = match init_result {
Ok(result) => result,
Err(_) => {
let _ = done_rx.await;
let payload = join.join().err();
return Err(IsleError::ThreadPanic(
payload.as_deref().and_then(panic_message),
));
}
};
let value = init_result?;
let handle = Self {
tx: tx.clone(),
id: Arc::new(IsleId),
};
let driver = AsyncIsleDriver {
tx,
done_rx: Some(done_rx),
join: Some(join),
};
Ok((handle, driver, value))
}
pub async fn eval<T>(&self, code: &str) -> Result<T, IsleError>
where
T: mlua::FromLuaMulti + Send + 'static,
{
self.spawn_eval(code).await
}
pub fn spawn_eval<T>(&self, code: &str) -> AsyncTask<T>
where
T: mlua::FromLuaMulti + Send + 'static,
{
let code = code.to_string();
self.submit_sync(move |lua, cancel| thread::execute_eval(lua, &code, cancel))
}
pub async fn call<A, T>(&self, func: &str, args: A) -> Result<T, IsleError>
where
A: mlua::IntoLuaMulti + Send + 'static,
T: mlua::FromLuaMulti + Send + 'static,
{
self.spawn_call(func, args).await
}
pub fn spawn_call<A, T>(&self, func: &str, args: A) -> AsyncTask<T>
where
A: mlua::IntoLuaMulti + Send + 'static,
T: mlua::FromLuaMulti + Send + 'static,
{
let func = func.to_string();
self.submit_sync(move |lua, cancel| thread::execute_call(lua, &func, args, cancel))
}
pub async fn exec<F, T>(&self, f: F) -> Result<T, IsleError>
where
F: FnOnce(&mlua::Lua) -> Result<T, IsleError> + Send + 'static,
T: Send + 'static,
{
self.spawn_exec(f).await
}
pub fn spawn_exec<F, T>(&self, f: F) -> AsyncTask<T>
where
F: FnOnce(&mlua::Lua) -> Result<T, IsleError> + Send + 'static,
T: Send + 'static,
{
self.submit_sync(move |lua, cancel| thread::execute_exec(lua, f, cancel))
}
pub async fn coroutine_eval<T>(&self, code: &str) -> Result<T, IsleError>
where
T: mlua::FromLuaMulti + Send + 'static,
{
self.spawn_coroutine_eval(code).await
}
pub fn spawn_coroutine_eval<T>(&self, code: &str) -> AsyncTask<T>
where
T: mlua::FromLuaMulti + Send + 'static,
{
let code = code.to_string();
self.submit_coroutine(move |lua, cancel| async move {
execute_coroutine_eval(&lua, &code, &cancel).await
})
}
pub async fn coroutine_call<A, T>(&self, func: &str, args: A) -> Result<T, IsleError>
where
A: mlua::IntoLuaMulti + Send + 'static,
T: mlua::FromLuaMulti + Send + 'static,
{
self.spawn_coroutine_call(func, args).await
}
pub fn spawn_coroutine_call<A, T>(&self, func: &str, args: A) -> AsyncTask<T>
where
A: mlua::IntoLuaMulti + Send + 'static,
T: mlua::FromLuaMulti + Send + 'static,
{
let func = func.to_string();
self.submit_coroutine(move |lua, cancel| async move {
execute_coroutine_call(&lua, &func, args, &cancel).await
})
}
pub async fn function<F>(&self, f: F) -> Result<IsleFunction, IsleError>
where
F: FnOnce(&mlua::Lua) -> mlua::Result<mlua::Function> + Send + 'static,
{
let key = self
.exec(move |lua| {
let func = f(lua)?;
Ok(lua.create_registry_value(func)?)
})
.await?;
Ok(IsleFunction {
key: Arc::new(key),
isle: self.id.clone(),
})
}
pub async fn call_fn<A, T>(&self, func: &IsleFunction, args: A) -> Result<T, IsleError>
where
A: mlua::IntoLuaMulti + Send + 'static,
T: mlua::FromLuaMulti + Send + 'static,
{
self.spawn_call_fn(func, args).await
}
pub fn spawn_call_fn<A, T>(&self, func: &IsleFunction, args: A) -> AsyncTask<T>
where
A: mlua::IntoLuaMulti + Send + 'static,
T: mlua::FromLuaMulti + Send + 'static,
{
if let Some(task) = self.refuse_foreign(func) {
return task;
}
let key = func.key.clone();
self.submit_sync(move |lua, cancel| thread::execute_call_fn(lua, &key, args, cancel))
}
pub async fn coroutine_call_fn<A, T>(
&self,
func: &IsleFunction,
args: A,
) -> Result<T, IsleError>
where
A: mlua::IntoLuaMulti + Send + 'static,
T: mlua::FromLuaMulti + Send + 'static,
{
self.spawn_coroutine_call_fn(func, args).await
}
pub fn spawn_coroutine_call_fn<A, T>(&self, func: &IsleFunction, args: A) -> AsyncTask<T>
where
A: mlua::IntoLuaMulti + Send + 'static,
T: mlua::FromLuaMulti + Send + 'static,
{
if let Some(task) = self.refuse_foreign(func) {
return task;
}
let key = func.key.clone();
self.submit_coroutine(move |lua, cancel| async move {
execute_coroutine_call_fn(&lua, &key, args, &cancel).await
})
}
fn refuse_foreign<T>(&self, func: &IsleFunction) -> Option<AsyncTask<T>> {
if Arc::ptr_eq(&func.isle, &self.id) {
None
} else {
Some(make_error_task(IsleError::WrongIsle, CancelToken::new()))
}
}
fn submit_sync<T, R>(&self, run: R) -> AsyncTask<T>
where
T: Send + 'static,
R: FnOnce(&mlua::Lua, &CancelToken) -> Result<T, IsleError> + Send + 'static,
{
self.submit(move |tx| {
Box::new(move |lua, cancel| {
let _ = tx.send(run(lua, cancel));
})
})
}
fn submit_coroutine<T, R, Fut>(&self, run: R) -> AsyncTask<T>
where
T: Send + 'static,
R: FnOnce(mlua::Lua, CancelToken) -> Fut + Send + 'static,
Fut: std::future::Future<Output = Result<T, IsleError>> + 'static,
{
self.submit(move |tx| {
Box::new(move |lua, cancel| {
let fut = run(lua.clone(), cancel.clone());
tokio::task::spawn_local(async move {
let _ = tx.send(fut.await);
});
})
})
}
fn submit<T>(
&self,
make_job: impl FnOnce(tokio::sync::oneshot::Sender<Result<T, IsleError>>) -> crate::Job,
) -> AsyncTask<T> {
let cancel = CancelToken::new();
let (resp_tx, resp_rx) = tokio::sync::oneshot::channel();
let req = Request::Run {
job: make_job(resp_tx),
cancel: cancel.clone(),
};
match self.tx.try_send(req) {
Ok(()) => AsyncTask::new(resp_rx, cancel),
Err(e) => make_error_task(try_send_to_isle_error(e), cancel),
}
}
pub fn is_alive(&self) -> bool {
!self.tx.is_closed()
}
}
impl AsyncIsleDriver {
pub async fn shutdown(mut self) -> Result<(), IsleError> {
let _ = self.tx.send(Request::Shutdown).await;
let mut done = true;
if let Some(done_rx) = self.done_rx.take() {
done = done_rx.await.is_ok();
}
if let Some(join) = self.join.take() {
join.join()
.map_err(|p| IsleError::ThreadPanic(panic_message(p.as_ref())))?;
}
if done {
Ok(())
} else {
Err(IsleError::ThreadPanic(None))
}
}
pub fn is_alive(&self) -> bool {
self.join.as_ref().is_some_and(|j| !j.is_finished())
}
}
fn make_error_task<T>(err: IsleError, cancel: CancelToken) -> AsyncTask<T> {
let (tx, rx) = tokio::sync::oneshot::channel();
let _ = tx.send(Err(err));
AsyncTask::new(rx, cancel)
}
fn try_send_to_isle_error<T>(err: tokio::sync::mpsc::error::TrySendError<T>) -> IsleError {
match err {
tokio::sync::mpsc::error::TrySendError::Full(_) => IsleError::ChannelFull,
tokio::sync::mpsc::error::TrySendError::Closed(_) => IsleError::Shutdown,
}
}
fn run_async_loop(
lua: mlua::Lua,
mut rx: tokio::sync::mpsc::Receiver<Request>,
rt: tokio::runtime::Runtime,
) {
let local = tokio::task::LocalSet::new();
local.spawn_local(async move {
while let Some(req) = rx.recv().await {
match req {
Request::Run { job, cancel } => job(&lua, &cancel),
Request::Shutdown => break,
}
tokio::task::yield_now().await;
}
});
rt.block_on(local);
}
fn vm(lua: &mlua::Lua) -> Result<crate::runtime::Vm, IsleError> {
crate::runtime::of_or_attach(lua)
}
async fn execute_coroutine_eval<T: mlua::FromLuaMulti>(
lua: &mlua::Lua,
code: &str,
cancel: &CancelToken,
) -> Result<T, IsleError> {
let func = lua
.load(code)
.set_name("=coroutine_eval")
.into_function()
.map_err(IsleError::from)?;
let values = vm(lua)?.run(cancel, func, ()).await?;
convert(lua, values, cancel)
}
async fn execute_coroutine_call<A: mlua::IntoLuaMulti, T: mlua::FromLuaMulti>(
lua: &mlua::Lua,
func_name: &str,
args: A,
cancel: &CancelToken,
) -> Result<T, IsleError> {
let func = thread::global_function(lua, func_name)?;
let multi = args.into_lua_multi(lua)?;
let values = vm(lua)?.run(cancel, func, multi).await?;
convert(lua, values, cancel)
}
async fn execute_coroutine_call_fn<A: mlua::IntoLuaMulti, T: mlua::FromLuaMulti>(
lua: &mlua::Lua,
key: &mlua::RegistryKey,
args: A,
cancel: &CancelToken,
) -> Result<T, IsleError> {
let func: mlua::Function = lua.registry_value(key)?;
let multi = args.into_lua_multi(lua)?;
let values = vm(lua)?.run(cancel, func, multi).await?;
convert(lua, values, cancel)
}
fn convert<T: mlua::FromLuaMulti>(
lua: &mlua::Lua,
values: mlua::MultiValue,
cancel: &CancelToken,
) -> Result<T, IsleError> {
let _enter = crate::hook::EnterGuard::new(cancel);
Ok(T::from_lua_multi(values, lua)?)
}