handle single-threaded rt

src/context.rs

@@ -1,7 +1,9 @@
-use tokio::runtime::Handle;
+use std::sync::Arc;
+
+use tokio::runtime::Runtime;
 
 pub trait Context: Send + Sync + 'static {
-    fn runtime(&self) -> Handle {
-        Handle::current()
+    fn runtime(&self) -> Option<Arc<Runtime>> {
+        None
     }
 }

src/handler/mod.rs

@@ -213,10 +213,11 @@ pub trait HandlerFor<Context: crate::Context>:
         &self,
         handle_args: HandlerArgsFor<Context, Self>,
     ) -> Result<Self::Ok, Self::Err> {
-        handle_args
-            .context
-            .runtime()
-            .block_on(self.handle_async(handle_args))
+        if let Some(rt) = handle_args.context.runtime() {
+            rt.block_on(self.handle_async(handle_args))
+        } else {
+            tokio::runtime::Handle::current().block_on(self.handle_async(handle_args))
+        }
     }
     fn handle_async(
         &self,
@@ -234,11 +235,13 @@ pub trait HandlerFor<Context: crate::Context>:
     ) -> impl Future<Output = Result<Self::Ok, Self::Err>> + Send + 'a {
         async move {
             let s = self.clone();
-            handle_args
-                .context
-                .runtime()
+            if let Some(rt) = handle_args.context.runtime() {
+                rt.spawn_blocking(move || s.handle_sync(handle_args)).await
+            } else {
+                tokio::runtime::Handle::current()
                     .spawn_blocking(move || s.handle_sync(handle_args))
                     .await
+            }
             .unwrap()
         }
     }

tests/handler.rs

@@ -48,16 +48,19 @@ impl CliConfig {
 
 struct CliContextSeed {
     host: PathBuf,
-    rt: OnceCell<Runtime>,
+    rt: OnceCell<Arc<Runtime>>,
 }
 #[derive(Clone)]
 struct CliContext(Arc<CliContextSeed>);
 impl Context for CliContext {
-    fn runtime(&self) -> Handle {
+    fn runtime(&self) -> Option<Arc<Runtime>> {
         if self.0.rt.get().is_none() {
-            self.0.rt.set(Runtime::new().unwrap()).unwrap();
+            let rt = Arc::new(Runtime::new().unwrap());
+            self.0.rt.set(rt.clone()).unwrap_or_default();
+            Some(rt)
+        } else {
+            self.0.rt.get().cloned()
         }
-        self.0.rt.get().unwrap().handle().clone()
     }
 }