outpunch-ruby 0.5.1 → 0.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3ec879b4be7ad61501c03feb26f617df557016c6c57190fc799fa596df8fb5d5
-  data.tar.gz: 2f59a5f6fd106d67baa2df00ede7656cc6b5f1e7f0eb5ca44d9766723925e357
+  metadata.gz: a0fde3ed16a529184039dde0c3143e09b131961a13fb2adc3e165b2748260e5c
+  data.tar.gz: d65b4b5de98d43b4b53413c5e56b10a2c628032f4510057c104d1142a97e6869
 SHA512:
-  metadata.gz: 3414f515a0c1b501d1e4934b1c780e87ef13b3cc6fbfe1493be63e7974b694c849a6fb4cb0cda79b2af444d499142c1cad0136545f06bd1823646366c26a2b95
-  data.tar.gz: b7f562121df9ab1ccb1e36097474a4225dae2ce20e91e2fbc66c8e79fccfb578f7bfc83777939eaf4cf5119831bd32c7cd24c1f3c492c6cbb782fa51a3da7cc4
+  metadata.gz: cf33afb82f7144a1326cc1fcc908dc750514d9cf9f88e78561bc171d6ca9ecc00eab2ab9e9cef8281796285fd21c0db0a96cabde4dbddebf202f5a9fb30b94c6
+  data.tar.gz: b3a9a6e390b5feaa49a0de162975098cd43054a6ef0e7541e1a7aa13eaf26bb138ae309ed3e7852ee918ab9b4fa528b3a415958991d6195d558c0a0c8c3476f1

data/ext/outpunch/Cargo.toml

@@ -8,11 +8,11 @@ name = "outpunch"
 crate-type = ["cdylib"]
 
 [dependencies]
-outpunch-client = { version = "0.5.1" }
+outpunch-client = { version = "0.5.2" }
 magnus = { version = "0.8" }
 rb-sys = { version = "0.9", features = ["stable-api-compiled-fallback"] }
 tokio = { version = "1.50.0", features = ["full"] }
-outpunch_core = { version = "0.5.1", package = "outpunch" }
+outpunch_core = { version = "0.5.2", package = "outpunch" }
 
 [build-dependencies]
 rb-sys-build = "0.9"

data/ext/outpunch/src/gvl.rs

@@ -30,38 +30,43 @@ unsafe extern "C" fn unblock(data: *mut c_void) {
 }
 
 /// Run `func` with the GVL released. `func` receives a `Notify` that fires when Ruby
-/// interrupts the thread (Thread#kill, Thread#raise, Timeout); it returns `None` when
-/// it stopped early because of that.
+/// interrupts the thread (Thread#raise, Thread#kill, Timeout, Thread#wakeup, signals); it
+/// returns `None` when it stopped early because of that.
 ///
-/// Returns `Ok(None)` when the call was cancelled and Ruby had no exception pending.
-pub fn without_gvl<F, R>(ruby: &Ruby, func: F) -> Result<Option<R>, Error>
+/// `rb_thread_call_without_gvl2` does not call `func` at all while an interrupt is pending,
+/// and the VM timer makes one pending whenever threads compete for the GVL. So when `func` did
+/// not run, the interrupt is handled and `func` is called again.
+///
+/// Returns `Err` when Ruby has an exception to raise, `Ok(None)` when `func` was cancelled by an
+/// interrupt that raised nothing (the caller decides whether to try again), `Ok(Some)` otherwise.
+pub fn without_gvl<F, R>(ruby: &Ruby, mut func: F) -> Result<Option<R>, Error>
 where
-    F: FnOnce(Arc<Notify>) -> Option<R>,
+    F: FnMut(Arc<Notify>) -> Option<R>,
 {
-    let cancel = Arc::new(Notify::new());
-    let mut state = Call {
-        func: Some({
-            let cancel = cancel.clone();
-            move || func(cancel)
-        }),
-        result: None,
-    };
+    loop {
+        let cancel = Arc::new(Notify::new());
+        let mut state = Call {
+            func: Some(|| func(cancel.clone())),
+            result: None,
+        };
 
-    unsafe {
-        rb_sys::rb_thread_call_without_gvl2(
-            Some(trampoline(&state)),
-            &mut state as *mut _ as *mut c_void,
-            Some(unblock),
-            Arc::as_ptr(&cancel) as *mut c_void,
-        );
-    }
+        unsafe {
+            rb_sys::rb_thread_call_without_gvl2(
+                Some(trampoline(&state)),
+                &mut state as *mut _ as *mut c_void,
+                Some(unblock),
+                Arc::as_ptr(&cancel) as *mut c_void,
+            );
+        }
 
-    match state.result {
-        Some(Ok(Some(value))) => Ok(Some(value)),
-        Some(Ok(None)) | None => {
-            ruby.thread_check_ints()?;
-            Ok(None)
+        match state.result {
+            Some(Ok(Some(value))) => return Ok(Some(value)),
+            Some(Ok(None)) => {
+                ruby.thread_check_ints()?;
+                return Ok(None);
+            }
+            Some(Err(payload)) => panic::resume_unwind(payload),
+            None => ruby.thread_check_ints()?,
         }
-        Some(Err(payload)) => panic::resume_unwind(payload),
     }
 }

data/ext/outpunch/src/server.rs

@@ -1,4 +1,5 @@
 use std::collections::HashMap;
+use std::panic;
 use std::sync::OnceLock;
 use std::time::Duration;
 
@@ -9,6 +10,7 @@ use outpunch_core::server::{
 };
 use tokio::runtime::Runtime;
 use tokio::sync::{Mutex, mpsc};
+use tokio::task::{JoinError, JoinHandle};
 
 use crate::gvl::without_gvl;
 
@@ -23,6 +25,35 @@ fn runtime() -> &'static Runtime {
     })
 }
 
+/// Wait for a task on the runtime with the GVL released. An interrupt that raises nothing
+/// (Thread#wakeup, the VM timer) keeps waiting; one that raises returns `Err` and leaves the
+/// task running for the caller to stop.
+fn wait_for<T>(ruby: &Ruby, task: &mut JoinHandle<T>) -> Result<T, Error> {
+    loop {
+        let joined = without_gvl(ruby, |cancel| {
+            runtime().block_on(async {
+                tokio::select! {
+                    joined = &mut *task => Some(joined),
+                    _ = cancel.notified() => None,
+                }
+            })
+        })?;
+        if let Some(joined) = joined {
+            return joined.map_err(|err| task_failed(ruby, err));
+        }
+    }
+}
+
+fn task_failed(ruby: &Ruby, err: JoinError) -> Error {
+    if err.is_panic() {
+        panic::resume_unwind(err.into_panic());
+    }
+    Error::new(
+        ruby.exception_runtime_error(),
+        format!("outpunch task failed: {err}"),
+    )
+}
+
 fn outpunch_error(ruby: &Ruby, name: &str) -> Result<ExceptionClass, Error> {
     ruby.class_object()
         .const_get::<_, RModule>("Outpunch")?
@@ -61,12 +92,10 @@ impl Server {
 
     fn is_connected(ruby: &Ruby, rb_self: &Self, service: String) -> Result<bool, Error> {
         loop {
-            let server = rb_self.inner.clone();
-            let service = service.clone();
-            let result = without_gvl(ruby, move |cancel| {
+            let result = without_gvl(ruby, |cancel| {
                 runtime().block_on(async {
                     tokio::select! {
-                        connected = server.is_connected(&service) => Some(connected),
+                        connected = rb_self.inner.is_connected(&service) => Some(connected),
                         _ = cancel.notified() => None,
                     }
                 })
@@ -102,30 +131,20 @@ impl Server {
         };
 
         let server = rb_self.inner.clone();
-        let result = without_gvl(ruby, move |cancel| {
-            runtime().block_on(async {
-                tokio::select! {
-                    result = server.try_handle_request(incoming) => Some(result),
-                    _ = cancel.notified() => None,
-                }
-            })
-        })?;
+        let mut task = runtime().spawn(async move { server.try_handle_request(incoming).await });
+        let result = wait_for(ruby, &mut task).inspect_err(|_| task.abort())?;
 
         match result {
-            None => Err(Error::new(
-                ruby.exception_runtime_error(),
-                "tunnel request interrupted",
-            )),
-            Some(Ok(response)) => response_hash(ruby, response),
-            Some(Err(TunnelError::NotConnected)) => Err(Error::new(
+            Ok(response) => response_hash(ruby, response),
+            Err(TunnelError::NotConnected) => Err(Error::new(
                 outpunch_error(ruby, "NotConnectedError")?,
                 format!("Service '{service}' not connected"),
             )),
-            Some(Err(TunnelError::Timeout)) => Err(Error::new(
+            Err(TunnelError::Timeout) => Err(Error::new(
                 outpunch_error(ruby, "TunnelTimeoutError")?,
                 format!("Tunnel timeout for service '{service}'"),
             )),
-            Some(Err(err)) => Err(Error::new(
+            Err(err) => Err(Error::new(
                 outpunch_error(ruby, "TunnelError")?,
                 err.to_string(),
             )),
@@ -150,18 +169,23 @@ pub struct Connection {
 }
 
 impl Connection {
-    /// Feed one WebSocket text message from the tunnel client into the core.
+    /// Feed one WebSocket text message from the tunnel client into the core. Blocks while the
+    /// core's queue is full.
     fn push_message(ruby: &Ruby, rb_self: &Self, text: String) -> Result<(), Error> {
-        let inner = rb_self.inner.clone();
-        without_gvl(ruby, move |cancel| {
-            runtime().block_on(async {
-                tokio::select! {
-                    _ = inner.push_message(text) => Some(()),
-                    _ = cancel.notified() => None,
-                }
-            })
-        })?;
-        Ok(())
+        // A cancelled send delivered nothing, so send again until it lands or Ruby raises.
+        loop {
+            let sent = without_gvl(ruby, |cancel| {
+                runtime().block_on(async {
+                    tokio::select! {
+                        _ = rb_self.inner.push_message(text.clone()) => Some(()),
+                        _ = cancel.notified() => None,
+                    }
+                })
+            })?;
+            if sent.is_some() {
+                return Ok(());
+            }
+        }
     }
 
     /// Block until the core has a message for the tunnel client. Returns nil once the
@@ -187,25 +211,16 @@ impl Connection {
         self.inner.close();
     }
 
-    /// Run the connection lifecycle (auth, relay, cleanup). Blocks until the
-    /// connection ends; an interrupt closes the connection.
+    /// Run the connection lifecycle (auth, relay, cleanup). Blocks until the connection ends.
+    /// An exception raised into this thread (Thread#raise, Thread#kill, Timeout) closes the
+    /// connection and then propagates.
     fn run(ruby: &Ruby, rb_self: &Self) -> Result<(), Error> {
         let inner = rb_self.inner.clone();
-        without_gvl(ruby, move |cancel| {
-            runtime().block_on(async {
-                let run = inner.run();
-                tokio::pin!(run);
-                tokio::select! {
-                    _ = &mut run => {}
-                    _ = cancel.notified() => {
-                        inner.close();
-                        run.await;
-                    }
-                }
-                Some(())
-            })
-        })?;
-        Ok(())
+        let mut task = runtime().spawn(async move { inner.run().await });
+        wait_for(ruby, &mut task).inspect_err(|_| {
+            rb_self.inner.close();
+            let _ = runtime().block_on(task);
+        })
     }
 }
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: outpunch-ruby
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.5.2
 platform: ruby
 authors:
 - TechyCorp