Smol executor isolated

Author: martin-kolarik

Cargo.lock

@@ -35,7 +35,8 @@ authors = [
     "Chloe Ross <orangesnowfox@gmail.com>",
     "Daniel Akhterov <akhterovd@gmail.com>",
 ]
-rust-version = "1.80.0"
+# TODO: enable this for 0.9.0
+# rust-version = "1.80.0"
 
 [package]
 name = "sqlx"
@@ -75,7 +76,6 @@ _unstable-all-types = [
 ]
 
 # Base runtime features without TLS
-runtime-async-global-executor = ["_rt-async-global-executor", "sqlx-core/_rt-async-global-executor", "sqlx-macros?/_rt-async-global-executor"]
 runtime-async-std = ["_rt-async-std", "sqlx-core/_rt-async-std", "sqlx-macros?/_rt-async-std"]
 runtime-smol = ["_rt-smol", "sqlx-core/_rt-smol", "sqlx-macros?/_rt-smol"]
 runtime-tokio = ["_rt-tokio", "sqlx-core/_rt-tokio", "sqlx-macros?/_rt-tokio"]
@@ -93,9 +93,6 @@ tls-none = []
 
 # Legacy Runtime + TLS features
 
-runtime-async-global-executor-native-tls = ["runtime-async-global-executor", "tls-native-tls"]
-runtime-async-global-executor-rustls = ["runtime-async-global-executor", "tls-rustls-ring"]
-
 runtime-async-std-native-tls = ["runtime-async-std", "tls-native-tls"]
 runtime-async-std-rustls = ["runtime-async-std", "tls-rustls-ring"]
 
@@ -106,7 +103,6 @@ runtime-tokio-native-tls = ["runtime-tokio", "tls-native-tls"]
 runtime-tokio-rustls = ["runtime-tokio", "tls-rustls-ring"]
 
 # for conditional compilation
-_rt-async-global-executor = []
 _rt-async-std = []
 _rt-smol = []
 _rt-tokio = []
@@ -164,11 +160,6 @@ cfg-if = "1.0.0"
 dotenvy = { version = "0.15.0", default-features = false }
 
 # Runtimes
-[workspace.dependencies.async-global-executor]
-version = "3.1"
-default-features = false
-features = ["async-io"]
-
 [workspace.dependencies.async-std]
 version = "1.12"
 

Cargo.toml

@@ -1,4 +1,4 @@
 # Note: should NOT increase during a minor/patch release cycle
 [toolchain]
-channel = "1.80"
+channel = "1.78"
 profile = "minimal"

rust-toolchain.toml

@@ -19,13 +19,7 @@ any = []
 json = ["serde", "serde_json"]
 
 # for conditional compilation
-_rt-async-global-executor = [
-    "async-global-executor",
-    "async-io-global-executor",
-    "async-lock",
-    "async-net",
-]
-_rt-async-std = ["async-std", "async-io-std"]
+_rt-async-std = ["async-std", "async-io"]
 _rt-smol = ["smol"]
 _rt-tokio = ["tokio", "tokio-stream"]
 _tls-native-tls = ["native-tls"]
@@ -40,7 +34,6 @@ offline = ["serde", "either/serde"]
 
 [dependencies]
 # Runtimes
-async-global-executor = { workspace = true, optional = true }
 async-std = { workspace = true, optional = true }
 smol = { workspace = true, optional = true }
 tokio = { workspace = true, optional = true }
@@ -61,10 +54,7 @@ ipnetwork = { workspace = true, optional = true }
 mac_address = { workspace = true, optional = true }
 uuid = { workspace = true, optional = true }
 
-async-io-global-executor = { package = "async-io", version = "2.2", optional = true }
-async-io-std = { package = "async-io", version = "1.9.0", optional = true }
-async-lock = { version = "3.4.0", optional = true }
-async-net = { package = "async-net", version = "2.0.0", optional = true }
+async-io = { package = "async-io", version = "1.9.0", optional = true }
 base64 = { version = "0.22.0", default-features = false, features = ["std"] }
 bytes = "1.1.0"
 cfg-if = { workspace = true }

sqlx-core/Cargo.toml

@@ -204,39 +204,8 @@ pub async fn connect_tcp<Ws: WithSocket>(
     }
 
     cfg_if! {
-        if #[cfg(feature = "_rt-async-global-executor")] {
-            use async_io_global_executor::Async;
-            use async_net::resolve;
-            use std::net::TcpStream;
-
-            let mut last_err = None;
-
-            // Loop through all the Socket Addresses that the hostname resolves to
-            for socket_addr in resolve((host, port)).await? {
-                let stream = Async::<TcpStream>::connect(socket_addr)
-                    .await
-                    .and_then(|s| {
-                        s.get_ref().set_nodelay(true)?;
-                        Ok(s)
-                    });
-                match stream {
-                    Ok(stream) => return Ok(with_socket.with_socket(stream).await),
-                    Err(e) => last_err = Some(e),
-                }
-            }
-
-            // If we reach this point, it means we failed to connect to any of the addresses.
-            // Return the last error we encountered, or a custom error if the hostname didn't resolve to any address.
-            Err(match last_err {
-                Some(err) => err,
-                None => io::Error::new(
-                    io::ErrorKind::AddrNotAvailable,
-                    "Hostname did not resolve to any addresses",
-                ),
-            }
-            .into())
-        } else if #[cfg(feature = "_rt-async-std")] {
-            use async_io_std::Async;
+        if #[cfg(feature = "_rt-async-std")] {
+            use async_io::Async;
             use async_std::net::ToSocketAddrs;
             use std::net::TcpStream;
 
@@ -322,15 +291,8 @@ pub async fn connect_uds<P: AsRef<Path>, Ws: WithSocket>(
         }
 
         cfg_if! {
-            if #[cfg(feature = "_rt-async-global-executor")] {
-                use async_io_global_executor::Async;
-                use std::os::unix::net::UnixStream;
-
-                let stream = Async::<UnixStream>::connect(path).await?;
-
-                Ok(with_socket.with_socket(stream).await)
-            } else if #[cfg(feature = "_rt-async-std")] {
-                use async_io_std::Async;
+            if #[cfg(feature = "_rt-async-std")] {
+                use async_io::Async;
                 use std::os::unix::net::UnixStream;
 
                 let stream = Async::<UnixStream>::connect(path).await?;

sqlx-core/src/net/socket/mod.rs

@@ -7,15 +7,11 @@ use std::time::Duration;
 use cfg_if::cfg_if;
 
 #[cfg(any(
-    feature = "_rt-async-global-executor",
     feature = "_rt-async-std",
     feature = "_rt-smol"
 ))]
 pub mod rt_async_io;
 
-#[cfg(feature = "_rt-async-global-executor")]
-pub mod rt_async_global_executor;
-
 #[cfg(feature = "_rt-smol")]
 pub mod rt_smol;
 
@@ -27,8 +23,6 @@ pub mod rt_tokio;
 pub struct TimeoutError;
 
 pub enum JoinHandle<T> {
-    #[cfg(feature = "_rt-async-global-executor")]
-    AsyncGlobalExecutor(rt_async_global_executor::JoinHandle<T>),
     #[cfg(feature = "_rt-async-std")]
     AsyncStd(async_std::task::JoinHandle<T>),
     #[cfg(feature = "_rt-smol")]
@@ -48,9 +42,7 @@ pub async fn timeout<F: Future>(duration: Duration, f: F) -> Result<F::Output, T
     }
 
     cfg_if! {
-        if #[cfg(feature = "_rt-async-global-executor")] {
-            rt_async_global_executor::timeout(duration, f).await
-        } else if #[cfg(feature = "_rt-async-std")] {
+        if #[cfg(feature = "_rt-async-std")] {
             async_std::future::timeout(duration, f)
                 .await
                 .map_err(|_| TimeoutError)
@@ -69,9 +61,7 @@ pub async fn sleep(duration: Duration) {
     }
 
     cfg_if! {
-        if #[cfg(feature = "_rt-async-global-executor")] {
-            rt_async_global_executor::sleep(duration).await
-        } else if #[cfg(feature = "_rt-async-std")] {
+        if #[cfg(feature = "_rt-async-std")] {
             async_std::task::sleep(duration).await
         } else if #[cfg(feature = "_rt-smol")] {
             rt_smol::sleep(duration).await
@@ -93,11 +83,7 @@ where
     }
 
     cfg_if! {
-        if #[cfg(feature = "_rt-async-global-executor")] {
-            JoinHandle::AsyncGlobalExecutor(rt_async_global_executor::JoinHandle {
-                task: Some(async_global_executor::spawn(fut)),
-            })
-        } else if #[cfg(feature = "_rt-async-std")] {
+        if #[cfg(feature = "_rt-async-std")] {
             JoinHandle::AsyncStd(async_std::task::spawn(fut))
         } else if #[cfg(feature = "_rt-smol")] {
             JoinHandle::Smol(rt_smol::JoinHandle {
@@ -121,11 +107,7 @@ where
     }
 
     cfg_if! {
-        if #[cfg(feature = "_rt-async-global-executor")] {
-            JoinHandle::AsyncGlobalExecutor(rt_async_global_executor::JoinHandle {
-                task: Some(async_global_executor::spawn_blocking(f)),
-            })
-        } else if #[cfg(feature = "_rt-async-std")] {
+        if #[cfg(feature = "_rt-async-std")] {
             JoinHandle::AsyncStd(async_std::task::spawn_blocking(f))
         } else if #[cfg(feature = "_rt-smol")] {
             JoinHandle::Smol(rt_smol::JoinHandle {
@@ -144,9 +126,7 @@ pub async fn yield_now() {
     }
 
     cfg_if! {
-        if #[cfg(feature = "_rt-async-global-executor")] {
-            rt_async_global_executor::yield_now().await
-        } else if #[cfg(feature = "_rt-async-std")] {
+        if #[cfg(feature = "_rt-async-std")] {
             async_std::task::yield_now().await
         } else if #[cfg(feature = "_rt-smol")] {
             smol::future::yield_now().await
@@ -170,9 +150,7 @@ pub fn test_block_on<F: Future>(f: F) -> F::Output {
     }
 
     cfg_if! {
-        if #[cfg(feature = "_rt-async-global-executor")] {
-            async_io_global_executor::block_on(f)
-        } else if #[cfg(feature = "_rt-async-std")] {
+        if #[cfg(feature = "_rt-async-std")] {
             async_std::task::block_on(f)
         } else if #[cfg(feature = "_rt-smol")] {
             smol::block_on(f)
@@ -188,7 +166,7 @@ pub fn missing_rt<T>(_unused: T) -> ! {
         panic!("this functionality requires a Tokio context")
     }
 
-    panic!("one of the `runtime-async-global-executor`, `runtime-async-std`, `runtime-smol`, or `runtime-tokio` feature must be enabled")
+    panic!("one of the `runtime-async-std`, `runtime-smol`, or `runtime-tokio` feature must be enabled")
 }
 
 impl<T: Send + 'static> Future for JoinHandle<T> {
@@ -197,8 +175,6 @@ impl<T: Send + 'static> Future for JoinHandle<T> {
     #[track_caller]
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         match &mut *self {
-            #[cfg(feature = "_rt-async-global-executor")]
-            Self::AsyncGlobalExecutor(handle) => Pin::new(handle).poll(cx),
             #[cfg(feature = "_rt-async-std")]
             Self::AsyncStd(handle) => Pin::new(handle).poll(cx),
             #[cfg(feature = "_rt-smol")]