Let us use a reshareable string buffer.

Author: alistairjevans

ext/hyper_ruby/src/lib.rs

@@ -10,7 +10,7 @@ use gvl_helpers::nogvl;
 use magnus::block::block_proc;
 use magnus::r_hash::ForEach;
 use magnus::typed_data::Obj;
-use magnus::{function, method, prelude::*, Error as MagnusError, IntoValue, Ruby, Value};
+use magnus::{function, method, prelude::*, Error as MagnusError, IntoValue, RString, Ruby, Value};
 use bytes::Bytes;
 
 use std::cell::RefCell;
@@ -46,7 +46,7 @@ impl ServerConfig {
 
 // Sent on the work channel with the request, and a oneshot channel to send the response back on.
 struct RequestWithCompletion {
-    request: Request,
+    request: HyperRequest<Bytes>,
     // sent a response back on this thread
     response_tx: oneshot::Sender<HyperResponse<Full<Bytes>>>,
 }
@@ -85,13 +85,17 @@ impl Server {
     pub fn run_worker(&self) -> Result<(), MagnusError> {
         let block = block_proc().unwrap();
         if let Some(work_rx) = self.work_rx.borrow().as_ref() {
+           
             loop {
                  // Use nogvl to wait for requests outside the GVL
                  let work_request = nogvl(|| work_rx.recv());
 
                  match work_request {
                     Ok(work_request) => {
-                        let value = unsafe { work_request.request.into_value_unchecked() };
+                        let request = Request {
+                            request: work_request.request,
+                        };
+                        let value = request.into_value();
                         let hyper_response = match block.call::<_, Value>([value]) {
                             Ok(result) => {
                                 let ref_response = Obj::<Response>::try_convert(result).unwrap();
@@ -253,14 +257,10 @@ async fn handle_request(
     let (parts, body) = req.into_parts();
     let body_bytes = body.collect().await?.to_bytes();
 
-    let request = Request {
-        request: HyperRequest::from_parts(parts, body_bytes),
-    };
-
     let (response_tx, response_rx) = oneshot::channel();
 
     let with_completion = RequestWithCompletion {
-        request,
+        request: HyperRequest::from_parts(parts, body_bytes),
         response_tx,
     };
 
@@ -311,7 +311,7 @@ fn init(ruby: &Ruby) -> Result<(), MagnusError> {
     request_class.define_method("http_method", method!(Request::method, 0))?;
     request_class.define_method("path", method!(Request::path, 0))?;
     request_class.define_method("header", method!(Request::header, 1))?;
-    request_class.define_method("body", method!(Request::body, 0))?;
+    request_class.define_method("fill_body", method!(Request::fill_body, 1))?;
     request_class.define_method("body_size", method!(Request::body_size, 0))?;
     request_class.define_method("inspect", method!(Request::inspect, 0))?;
 

ext/hyper_ruby/src/request.rs

@@ -1,10 +1,12 @@
-use magnus::{value::{qnil, ReprValue}, RString, Value};
+use magnus::{gc, value::{qnil, Opaque, ReprValue}, DataTypeFunctions, IntoValue, RString, Ruby, TypedData, Value};
+
 use bytes::Bytes;
 use hyper::Request as HyperRequest;
 
+use rb_sys::{rb_str_resize, rb_str_cat, VALUE};
+
 // Type passed to ruby giving access to the request properties.
-#[derive(Debug)]
-#[magnus::wrap(class = "HyperRuby::Request", free_immediately)]
+#[magnus::wrap(class = "HyperRuby::Request")]
 pub struct Request {
     pub request: HyperRequest<Bytes>
 }
@@ -34,15 +36,22 @@ impl Request {
         self.request.body().len()
     }
 
-    pub fn body(&self) -> Value {
+    pub fn fill_body(&self, buffer: RString) -> usize {
         let body = self.request.body();
-        if body.is_empty() {
-            return qnil().as_value();
+        let body_len = body.len();
+
+        // Access the ruby string VALUE directly, and resize to 0 (keeping the capacity), 
+        // then copy our buffer into it.
+        unsafe {
+            let rb_value = buffer.as_value();
+            let inner: VALUE = std::ptr::read(&rb_value as *const _ as *const VALUE);
+            rb_str_resize(inner, 0);
+            if body_len > 0 {
+                rb_str_cat(inner, body.as_ptr() as *const i8, body.len().try_into().unwrap());
+            }
         }
 
-        let result = RString::buf_new(body.len());
-        result.cat(body.as_ref());
-        result.as_value()
+        body_len
     }
 
     pub fn inspect(&self) -> RString {

test/test_hyper_ruby.rb

@@ -26,7 +26,8 @@ def test_header_fetch_get
   end
 
   def test_simple_post
-    with_server(-> (request) { handler_to_json(request) }) do |client|
+    buffer = String.new(capacity: 1024)
+    with_server(-> (request) { handler_to_json(request, buffer) }) do |client|
       response = client.post("/", body: "Hello")
       assert_equal 200, response.status
       assert_equal "application/json", response.headers["content-type"]
@@ -35,7 +36,8 @@ def test_simple_post
   end
 
   def test_large_post
-    with_server(-> (request) { handler_to_json(request) }) do |client|
+    buffer = String.new(capacity: 1024)
+    with_server(-> (request) { handler_to_json(request, buffer) }) do |client|
       response = client.post("/", body: "a" * 10_000_000)
       assert_equal 200, response.status
       assert_equal "application/json", response.headers["content-type"]
@@ -59,11 +61,12 @@ def test_unix_socket_cleans_up_socket
     end
   end
 
-  # def test_blocking
-  #   with_server(-> (request) { handler_simple(request) }) do |client|
-  #     gets
-  #   end
-  # end
+  def test_blocking
+    buffer = String.new(capacity: 1024)
+    with_server(-> (request) { handler_to_json(request, buffer) }) do |client|
+      gets
+    end
+  end
 
   def with_server(request_handler, &block)
     server = HyperRuby::Server.new
@@ -118,11 +121,11 @@ def handler_simple(request)
     HyperRuby::Response.new(200, { 'Content-Type' => 'text/plain' }, request.http_method)
   end
 
-  def handler_to_json(request)
-    HyperRuby::Response.new(200, { 'Content-Type' => 'application/json' }, { message: request.body }.to_json)
+  def handler_to_json(request, buffer)
+    request.fill_body(buffer)
+    HyperRuby::Response.new(200, { 'Content-Type' => 'application/json' }, { message: buffer }.to_json)
   end
 
-
   def handler_return_header(request, header_key)
     HyperRuby::Response.new(200, { 'Content-Type' => 'application/json' }, { message: request.header(header_key) }.to_json)
   end