Move code around

Author: alistairjevans

ext/hyper_ruby/src/gvl_helpers.rs

@@ -0,0 +1,26 @@
+use std::{ffi::c_void, mem::MaybeUninit, ptr::null_mut};
+use rb_sys::rb_thread_call_without_gvl;
+
+// Call a specified function, having released the GVL. Acquires the GVL before returning.
+pub(crate) fn nogvl<F, R>(mut func: F) -> R
+where
+    F: FnMut() -> R,
+    R: Sized,
+{
+    unsafe extern "C" fn call_without_gvl<F, R>(arg: *mut c_void) -> *mut c_void
+    where
+        F: FnMut() -> R,
+        R: Sized,
+    {
+        let arg = arg as *mut (&mut F, &mut MaybeUninit<R>);
+        let (func, result) = unsafe { &mut *arg };
+        result.write(func());
+        null_mut()
+    }
+    let result = MaybeUninit::uninit();
+    let arg_ptr = &(&mut func, &result) as *const _ as *mut c_void;
+    unsafe {
+        rb_thread_call_without_gvl(Some(call_without_gvl::<F, R>), arg_ptr, None, null_mut());
+        result.assume_init()
+    }
+} 

ext/hyper_ruby/src/lib.rs

@@ -1,14 +1,17 @@
+mod request;
+mod response;
+mod gvl_helpers;
+
+use request::Request;
+use response::Response;
+use gvl_helpers::nogvl;
+
 use magnus::block::block_proc;
 use magnus::r_hash::ForEach;
 use magnus::typed_data::Obj;
-use magnus::value::{qnil, Opaque};
-use magnus::{function, gc, method, prelude::*, DataTypeFunctions, Error as MagnusError, RString, Ruby, TypedData, Value};
+use magnus::{function, method, prelude::*, Error as MagnusError, Ruby, Value};
 use bytes::Bytes;
 
-use std::{ffi::c_void, mem::MaybeUninit, ptr::null_mut};
-
-use rb_sys::rb_thread_call_without_gvl;
-
 use warp::Filter;
 use warp::http::Response as WarpResponse;
 use std::cell::RefCell;
@@ -35,84 +38,13 @@ impl ServerConfig {
     }
 }
 
+// Sent on the work channel with the request, and a oneshot channel to send the response back on.
 struct RequestWithCompletion {
     request: Request,
     // sent a response back on this thread
     response_tx: oneshot::Sender<WarpResponse<Bytes>>,
 }
 
-// Request type that will be sent to worker threads
-#[derive(Debug)]
-#[magnus::wrap(class = "HyperRuby::Request")]
-struct Request {
-    method: warp::http::Method,
-    path: String,
-    headers: warp::http::HeaderMap,
-    body: Bytes,
-}
-
-impl Request {
-    pub fn method(&self) -> String {
-        self.method.to_string()
-    }
-
-    pub fn path(&self) -> RString {
-        RString::new(&self.path)
-    }
-
-    pub fn header(&self, key: String) -> Value {
-        match self.headers.get(key) {
-            Some(value) => match value.to_str() {
-                Ok(value) => RString::new(value).as_value(),
-                Err(_) => qnil().as_value(),
-            },
-            None => qnil().as_value(),
-        }
-    }
-
-    pub fn body_size(&self) -> usize {
-        self.body.len()
-    }
-
-    pub fn body(&self) -> Value {
-        if self.body.is_empty() {
-            return qnil().as_value();
-        }
-
-        let result = RString::buf_new(self.body_size());
-
-        // cat to the end of the string directly from the byte buffer
-        result.cat(self.body.as_ref());
-        result.as_value()
-    }
-}
-
-
-#[derive(TypedData)]
-#[magnus(class = "HyperRuby::Response", mark)]
-struct Response {
-    status: u16,
-    headers: Opaque<magnus::RHash>,
-    body: Opaque<magnus::RString>,
-}
-
-impl DataTypeFunctions for Response {
-    fn mark(&self, marker: &gc::Marker) {
-        marker.mark(self.headers);
-        marker.mark(self.body);
-    }
-}
-
-impl Response {
-    pub fn new(status: u16, headers: magnus::RHash, body: RString) -> Self {
-        Self {
-            status,
-            headers: headers.into(),
-            body: body.into(),
-        }
-    }
-}
-
 #[magnus::wrap(class = "HyperRuby::Server")]
 struct Server {
     server_handle: Arc<Mutex<Option<JoinHandle<()>>>>,
@@ -121,30 +53,6 @@ struct Server {
     work_tx: RefCell<Option<Arc<crossbeam_channel::Sender<RequestWithCompletion>>>>,
 }
 
-
-pub(crate) fn nogvl<F, R>(mut func: F) -> R
-where
-    F: FnMut() -> R,
-    R: Sized,
-{
-    unsafe extern "C" fn call_without_gvl<F, R>(arg: *mut c_void) -> *mut c_void
-    where
-        F: FnMut() -> R,
-        R: Sized,
-    {
-        let arg = arg as *mut (&mut F, &mut MaybeUninit<R>);
-        let (func, result) = unsafe { &mut *arg };
-        result.write(func());
-        null_mut()
-    }
-    let result = MaybeUninit::uninit();
-    let arg_ptr = &(&mut func, &result) as *const _ as *mut c_void;
-    unsafe {
-        rb_thread_call_without_gvl(Some(call_without_gvl::<F, R>), arg_ptr, None, null_mut());
-        result.assume_init()
-    }
-}
-
 impl Server {
     pub fn new() -> Self {
         let (work_tx, work_rx) = crossbeam_channel::bounded(1000);

ext/hyper_ruby/src/request.rs

@@ -0,0 +1,47 @@
+use magnus::{value::{qnil, ReprValue}, RString, Value};
+use bytes::Bytes;
+use warp::http::HeaderMap;
+
+// Type passed to ruby giving access to the request properties.
+#[derive(Debug)]
+#[magnus::wrap(class = "HyperRuby::Request")]
+pub struct Request {
+    pub method: warp::http::Method,
+    pub path: String,
+    pub headers: HeaderMap,
+    pub body: Bytes,
+}
+
+impl Request {
+    pub fn method(&self) -> String {
+        self.method.to_string()
+    }
+
+    pub fn path(&self) -> RString {
+        RString::new(&self.path)
+    }
+
+    pub fn header(&self, key: String) -> Value {
+        match self.headers.get(key) {
+            Some(value) => match value.to_str() {
+                Ok(value) => RString::new(value).as_value(),
+                Err(_) => qnil().as_value(),
+            },
+            None => qnil().as_value(),
+        }
+    }
+
+    pub fn body_size(&self) -> usize {
+        self.body.len()
+    }
+
+    pub fn body(&self) -> Value {
+        if self.body.is_empty() {
+            return qnil().as_value();
+        }
+
+        let result = RString::buf_new(self.body_size());
+        result.cat(self.body.as_ref());
+        result.as_value()
+    }
+} 

ext/hyper_ruby/src/response.rs

@@ -0,0 +1,27 @@
+use magnus::{gc, DataTypeFunctions, RHash, RString, TypedData, value::Opaque};
+
+// Response object returned to Ruby; holds reference to the opaque ruby types for the headers and body.
+#[derive(TypedData)]
+#[magnus(class = "HyperRuby::Response", mark)]
+pub struct Response {
+    pub status: u16,
+    pub headers: Opaque<RHash>,
+    pub body: Opaque<RString>,
+}
+
+impl DataTypeFunctions for Response {
+    fn mark(&self, marker: &gc::Marker) {
+        marker.mark(self.headers);
+        marker.mark(self.body);
+    }
+}
+
+impl Response {
+    pub fn new(status: u16, headers: RHash, body: RString) -> Self {
+        Self {
+            status,
+            headers: headers.into(),
+            body: body.into(),
+        }
+    }
+}