fix(bindings): run func call until completion even when future is cancelled

Author: sehnryr

midoku-bindings/Cargo.toml

@@ -16,8 +16,6 @@ midoku-types.workspace = true
 wasmtime.workspace = true
 
 parking_lot = "0.12.3"
-
-[dev-dependencies]
 tokio.workspace = true
 
 [build-dependencies]

midoku-bindings/src/bindings.rs

@@ -1,5 +1,6 @@
 use std::collections::HashMap;
 use std::path::Path;
+use std::sync::Arc;
 
 use midoku_settings::types::Value;
 use midoku_types::chapter::Chapter;
@@ -23,7 +24,7 @@ use crate::state::State;
 /// This struct contains the bindings to a Midoku source. It is used to call
 /// functions in the WebAssembly component.
 pub struct Bindings {
-    store: RwLock<Store<State>>,
+    store: Arc<RwLock<Store<State>>>,
     initialize: Func<(), Result<(), ()>>,
     get_manga_list: Func<(Vec<Filter>, u32), Result<(Vec<Manga>, bool), ()>>,
     get_manga_details: Func<(String,), Result<Manga, ()>>,
@@ -84,7 +85,7 @@ impl Bindings {
         let get_page_list = get_typed_func!(instance, store, api, "get-page-list")?.into();
 
         Ok(Self {
-            store: RwLock::new(store),
+            store: Arc::new(RwLock::new(store)),
             initialize,
             get_manga_list,
             get_manga_details,
@@ -99,9 +100,7 @@ impl Bindings {
     /// calling other functions. This may include setting up rate limiters or
     /// other configuration.
     pub async fn initialize(&self) -> Result<(), ()> {
-        let mut store = self.store.write();
-
-        self.initialize.call(&mut store, ()).await?
+        self.initialize.call(self.store.clone(), ()).await?
     }
 
     /// Get a list of manga from the source.
@@ -115,10 +114,8 @@ impl Bindings {
         filters: Vec<Filter>,
         page: u32,
     ) -> Result<(Vec<Manga>, bool), ()> {
-        let mut store = self.store.write();
-
         self.get_manga_list
-            .call(&mut store, (filters, page))
+            .call(self.store.clone(), (filters, page))
             .await?
     }
 
@@ -128,9 +125,9 @@ impl Bindings {
     ///
     /// * `id` - The ID of the manga to get details for.
     pub async fn get_manga_details(&self, id: String) -> Result<Manga, ()> {
-        let mut store = self.store.write();
-
-        self.get_manga_details.call(&mut store, (id,)).await?
+        self.get_manga_details
+            .call(self.store.clone(), (id,))
+            .await?
     }
 
     /// Get a list of chapters for a specific manga.
@@ -139,9 +136,9 @@ impl Bindings {
     ///
     /// * `id` - The ID of the manga to get chapters for.
     pub async fn get_chapter_list(&self, id: String) -> Result<Vec<Chapter>, ()> {
-        let mut store = self.store.write();
-
-        self.get_chapter_list.call(&mut store, (id,)).await?
+        self.get_chapter_list
+            .call(self.store.clone(), (id,))
+            .await?
     }
 
     /// Get a list of pages for a specific chapter.
@@ -151,10 +148,8 @@ impl Bindings {
     /// * `id` - The ID of the manga.
     /// * `chapter_id` - The ID of the chapter.
     pub async fn get_page_list(&self, id: String, chapter_id: String) -> Result<Vec<Page>, ()> {
-        let mut store = self.store.write();
-
         self.get_page_list
-            .call(&mut store, (id, chapter_id))
+            .call(self.store.clone(), (id, chapter_id))
             .await?
     }
 

midoku-bindings/src/func.rs

@@ -1,7 +1,11 @@
+use std::sync::Arc;
+
+use parking_lot::RwLock;
+use tokio::task::{spawn_local, LocalSet};
 use wasmtime::component::{ComponentNamedList, Lift, Lower, TypedFunc};
-use wasmtime::{AsContextMut, Store};
+use wasmtime::Store;
 
-pub(crate) struct Func<Params, Return>(TypedFunc<Params, (Return,)>)
+pub(crate) struct Func<Params, Return>(Arc<TypedFunc<Params, (Return,)>>)
 where
     Params: Send + Sync,
     Return: Send + Sync,
@@ -18,33 +22,61 @@ where
     (Return,): ComponentNamedList + Lift,
 {
     fn from(value: TypedFunc<Params, (Return,)>) -> Self {
-        Func(value)
+        Func(Arc::new(value))
     }
 }
 
 impl<Params, Return> Func<Params, Return>
 where
-    Params: Send + Sync,
-    Return: Send + Sync,
+    Params: Send + Sync + 'static,
+    Return: Send + Sync + 'static,
     // Bounds from [`TypedFunc`]:
     Params: ComponentNamedList + Lower,
     (Return,): ComponentNamedList + Lift,
 {
-    pub async fn call<T: Send>(&self, store: &mut Store<T>, params: Params) -> Result<Return, ()> {
-        // function call
-        let result = self
-            .0
-            .call_async(store.as_context_mut(), params)
+    async fn call_async<T>(
+        store: &mut Store<T>,
+        func: &TypedFunc<Params, (Return,)>,
+        params: Params,
+    ) -> Result<Return, ()>
+    where
+        T: Send + 'static,
+    {
+        func.call_async(store, params)
             .await
-            .map_err(|_| ())?
-            .0;
+            .map_err(|_| ())
+            .map(|res| res.0)
+    }
 
-        // mandatory cleanup after successful call
-        self.0
-            .post_return_async(store.as_context_mut())
-            .await
-            .map_err(|_| ())?;
+    async fn post_return_async<T>(
+        store: &mut Store<T>,
+        func: &TypedFunc<Params, (Return,)>,
+    ) -> Result<(), ()>
+    where
+        T: Send + 'static,
+    {
+        func.post_return_async(store).await.map_err(|_| ())
+    }
 
-        Ok(result)
+    pub async fn call<T: Send + 'static>(
+        &self,
+        store: Arc<RwLock<Store<T>>>,
+        params: Params,
+    ) -> Result<Return, ()> {
+        let func = self.0.clone();
+
+        let local = LocalSet::new();
+        local
+            .run_until(async move {
+                spawn_local(async move {
+                    let mut store = store.write();
+                    let result = Self::call_async(&mut store, &func, params).await?;
+                    Self::post_return_async(&mut store, &func).await?;
+                    Ok(result)
+                })
+                .await
+            })
+            .await
+            .expect("could not join handle")
     }
 }