add tokio02 feature

Signed-off-by: Marc-Antoine Perennou <[email protected]>

Author: Keruspe

Cargo.toml

@@ -14,6 +14,7 @@ readme = "README.md"
 
 [features]
 default = ["async-io"]
+tokio02 = ["tokio"]
 
 [dependencies]
 async-executor = "^1.3"
@@ -25,5 +26,11 @@ once_cell = "^1.4"
 version = "^1.0"
 optional = true
 
+[dependencies.tokio]
+version = "^0.2"
+default-features = false
+features = ["rt-threaded"]
+optional = true
+
 [dev-dependencies]
 doc-comment = "^0.3"

src/lib.rs

@@ -129,10 +129,12 @@ pub fn init_with_config(config: GlobalExecutorConfig) {
                     use future::block_on;
                     loop {
                         let _ = std::panic::catch_unwind(|| {
-                            LOCAL_EXECUTOR.with(|executor| {
-                                let local = executor.run(future::pending::<()>());
-                                let global = GLOBAL_EXECUTOR.run(future::pending::<()>());
-                                block_on(future::or(local, global))
+                            enter02(|| {
+                                LOCAL_EXECUTOR.with(|executor| {
+                                    let local = executor.run(future::pending::<()>());
+                                    let global = GLOBAL_EXECUTOR.run(future::pending::<()>());
+                                    block_on(future::or(local, global))
+                                })
                             })
                         });
                     }
@@ -174,7 +176,7 @@ pub fn block_on<F: Future<Output = T>, T>(future: F) -> T {
     use async_io::block_on;
     #[cfg(not(feature = "async-io"))]
     use future::block_on;
-    LOCAL_EXECUTOR.with(|executor| block_on(executor.run(future)))
+    enter02(|| LOCAL_EXECUTOR.with(|executor| block_on(executor.run(future))))
 }
 
 /// Spawns a task onto the multi-threaded global executor.
@@ -226,3 +228,36 @@ pub fn spawn<F: Future<Output = T> + Send + 'static, T: Send + 'static>(future:
 pub fn spawn_local<F: Future<Output = T> + 'static, T: 'static>(future: F) -> Task<T> {
     LOCAL_EXECUTOR.with(|executor| executor.spawn(future))
 }
+
+/// Enters the tokio context if the `tokio02` feature is enabled.
+fn enter02<T>(f: impl FnOnce() -> T) -> T {
+    #[cfg(not(feature = "tokio02"))]
+    return f();
+
+    #[cfg(feature = "tokio02")]
+    {
+        use std::cell::Cell;
+        use tokio::runtime::Runtime;
+
+        thread_local! {
+            /// The level of nested `enter` calls we are in, to ensure that the outermost always
+            /// has a runtime spawned.
+            static NESTING: Cell<usize> = Cell::new(0);
+        }
+
+        /// The global tokio runtime.
+        static RT: Lazy<Runtime> = new(|| Runtime::new().expect("cannot initialize tokio"));
+
+        NESTING.with(|nesting| {
+            let res = if nesting.get() == 0 {
+                nesting.replace(1);
+                RT.enter(f)
+            } else {
+                nesting.replace(nesting.get() + 1);
+                f()
+            };
+            nesting.replace(nesting.get() - 1);
+            res
+        })
+    }
+}