use tokio::sync::mpsc::UnboundedSender;
use vertigo::JsValue;
use wasmtime::{Caller, Engine, Func, Instance, Module, Store};
use crate::serve::request_state::RequestState;
use super::{
data_context::DataContext,
decode_commands::*,
message::{CallWebsocketResult, Message},
FetchResponse,
};
pub struct WasmInstance {
instance: Instance,
store: Store<RequestState>,
}
impl WasmInstance {
pub fn new(
sender: UnboundedSender<Message>,
engine: &Engine,
module: &Module,
request: RequestState,
) -> Self {
let url = request.url.clone();
let mut store = Store::new(engine, request.clone());
let import_panic_message = Func::wrap(&mut store, {
let sender = sender.clone();
move |caller: Caller<'_, RequestState>, ptr: u32, offset: u32| {
let mut data_context = DataContext::from_caller(caller);
let message = data_context.get_string_from(ptr, offset);
log::error!("wasm panic: {message:?}");
sender.send(Message::Panic(message)).unwrap_or_default();
}
});
let import_dom_access = {
Func::wrap(
&mut store,
move |caller: Caller<'_, RequestState>, ptr: u32, offset: u32| -> u32 {
let mut data_context = DataContext::from_caller(caller);
let value = data_context.get_value(ptr, offset);
if let Ok(()) = match_cookie_command(&value) {
return 0;
}
if let Ok(body) = match_plain_response(&value) {
sender
.send(Message::PlainResponse(body))
.inspect_err(|err| log::error!("Error sending plain body: {err}"))
.unwrap_or_default();
return 0;
}
if let Ok(()) = match_history_router(&value) {
let result = JsValue::str(url.clone());
return data_context.save_value(result);
}
if let Ok(env_name) = match_get_env(&value) {
let env_value = request.env(env_name);
let result = match env_value {
Some(value) => JsValue::String(value),
None => JsValue::Null,
};
return data_context.save_value(result);
}
if match_history_router_callback(&value).is_ok() {
return 0;
}
if let Ok(data) = match_dom_bulk_update(&value) {
sender
.send(Message::DomUpdate(data))
.inspect_err(|err| log::error!("Error sending DomUpdate: {err}"))
.unwrap_or_default();
return 0;
}
if let Ok((log_type, log_message)) = match_log(&value) {
if log_type == "error" {
log::warn!("{log_message}");
} else {
log::info!("{log_message}");
}
return 0;
}
if let Ok(current_time) = match_date_now(&value) {
return data_context.save_value(current_time);
}
if let Ok(result) = match_interval(&value) {
match result {
CallWebsocketResult::TimeoutSet { time, callback_id } => {
if time == 0 {
sender
.send(Message::SetTimeoutZero { callback_id })
.inspect_err(|err| {
log::error!("Error sending SetTimeoutZero: {err}")
})
.unwrap_or_default();
}
let result = JsValue::I32(0); return data_context.save_value(result);
}
CallWebsocketResult::NoResult => {
return 0;
}
}
}
if let Ok(()) = match_websocket(&value) {
return 0;
}
if let Ok((callback_id, request)) = match_fetch(&value) {
sender
.send(Message::FetchRequest {
callback_id,
request,
})
.inspect_err(|err| log::error!("Error sending FetchRequest: {err}"))
.unwrap_or_default();
return 0;
}
if let Ok(()) = match_is_browser(&value) {
let result = JsValue::bool(false);
return data_context.save_value(result);
}
if let Ok(status) = match_is_set_status(&value) {
sender
.send(Message::SetStatus(status))
.inspect_err(|err| log::error!("Error setting status code: {err}"))
.unwrap_or_default();
return 0;
}
log::error!("unsupported message: {value:#?}");
0
},
)
};
let imports = [import_panic_message.into(), import_dom_access.into()];
let instance = Instance::new(&mut store, module, &imports).unwrap();
WasmInstance { instance, store }
}
fn call_function<Params: wasmtime::WasmParams, Results: wasmtime::WasmResults>(
&mut self,
name: &'static str,
params: Params,
) -> Result<Results, String> {
let vertigo_entry_function = {
self.instance
.get_typed_func::<Params, Results>(&mut self.store, name)
.map_err(|err| {
log::error!("Error calling function: {err}");
err.to_string()
})?
};
vertigo_entry_function
.call(&mut self.store, params)
.map_err(|error| format!("{error}"))
}
pub fn call_vertigo_entry_function(&mut self) {
self.call_function::<(u32, u32), ()>(
"vertigo_entry_function",
(super::VERTIGO_VERSION_MAJOR, super::VERTIGO_VERSION_MINOR),
)
.inspect_err(|err| log::error!("Error calling entry function: {err}"))
.unwrap_or_default();
}
pub fn wasm_callback(&mut self, callback_id: u64, params: JsValue) -> JsValue {
let mut data_context = DataContext::from_store(&mut self.store, self.instance);
let params_ptr = data_context.save_value(params);
let result = self
.call_function::<(u64, u32), u64>("wasm_callback", (callback_id, params_ptr))
.inspect_err(|err| log::error!("Error calling callback: {err}"))
.unwrap_or_default();
if result == 0 {
JsValue::Undefined
} else {
todo!()
}
}
pub fn send_fetch_response(&mut self, callback_id: u64, response: FetchResponse) {
let params = JsValue::List(vec![
JsValue::bool(response.success),
JsValue::U32(response.status),
convert_body_to_value(response.body),
]);
let result = self.wasm_callback(callback_id, params);
assert_eq!(result, JsValue::Undefined);
}
}