Support pre-created responses.

Author: alistairjevans

ext/hyper_ruby/src/lib.rs

@@ -111,42 +111,7 @@ impl Server {
                         let hyper_response = match block.call::<_, Value>([value]) {
                             Ok(result) => {
                                 let ref_response = Obj::<Response>::try_convert(result).unwrap();
-
-                                let mut builder = HyperResponse::builder()
-                                    .status(ref_response.status);
-
-                                // safe because the block result will only ever be called on the ruby thread
-                                let ruby = unsafe { Ruby::get_unchecked() };
-
-                                let ruby_response_headers = ruby.get_inner(ref_response.headers);
-                                let builder_headers = builder.headers_mut().unwrap();
-                                ruby_response_headers.foreach(|key: String, value: String| {
-                                    let header_name = HeaderName::try_from(key).unwrap();
-                                    builder_headers.insert(header_name, value.try_into().unwrap());
-                                    Ok(ForEach::Continue)
-                                }).unwrap();
-
-                                let response_body = ruby.get_inner(ref_response.body);
-                                let response: Result<HyperResponse<Full<Bytes>>, hyper::http::Error>;
-
-                                if response_body.len() > 0 {
-                                    // safe because RString will not be cleared here before we copy the bytes into our own Vector.
-                                    unsafe {
-                                        // copy directly to bytes here so we don't have to worry about encoding checks
-                                        let rust_body = Bytes::copy_from_slice(response_body.as_slice());
-                                        response = builder.body(Full::new(rust_body));
-                                    }
-                                } else {
-                                    response = builder.body(Full::new(Bytes::new()));
-                                }
-
-                                match response {
-                                    Ok(response) => response,
-                                    Err(e) => {
-                                        println!("HTTP request build failed {:?}", e);
-                                        create_error_response("Internal server error")
-                                    }
-                                }
+                                ref_response.response.clone()
                             },
                             Err(e) => {
                                 println!("Block call failed: {:?}", e);

ext/hyper_ruby/src/response.rs

@@ -1,27 +1,41 @@
-use magnus::{gc, DataTypeFunctions, RHash, RString, TypedData, value::Opaque};
+use magnus::{r_hash::ForEach, wrap, RHash, RString, Error as MagnusError};
 
+use hyper::{header::HeaderName, Response as HyperResponse, StatusCode};
+use http_body_util::Full;
+use bytes::Bytes;
 // Response object returned to Ruby; holds reference to the opaque ruby types for the headers and body.
-#[derive(TypedData)]
-#[magnus(class = "HyperRuby::Response", mark)]
+#[wrap(class = "HyperRuby::Response")]
 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);
-    }
+    pub response: HyperResponse<Full<Bytes>>
 }
 
 impl Response {
-    pub fn new(status: u16, headers: RHash, body: RString) -> Self {
-        Self {
-            status,
-            headers: headers.into(),
-            body: body.into(),
+    pub fn new(status: u16, headers: RHash, body: RString) -> Result<Self, MagnusError> {
+        let mut builder = HyperResponse::builder()
+            .status(status);
+
+        let builder_headers = builder.headers_mut().unwrap();
+        headers.foreach(|key: String, value: String| {
+            let header_name = HeaderName::try_from(key).unwrap();
+            builder_headers.insert(header_name, value.try_into().unwrap());
+            Ok(ForEach::Continue)
+        }).unwrap();
+                
+        if body.len() > 0 {
+            // safe because RString will not be cleared here before we copy the bytes into our own Vector.
+            unsafe {
+                // copy directly to bytes here so we don't have to worry about encoding checks
+                let rust_body = Bytes::copy_from_slice(body.as_slice());
+                match builder.body(Full::new(rust_body)) {
+                    Ok(response) => Ok(Self { response }),
+                    Err(_) => Err(MagnusError::new(magnus::exception::runtime_error(), "Failed to create response"))
+                }
+            }
+        } else {
+            match builder.body(Full::new(Bytes::new())) {
+                Ok(response) => Ok(Self { response }),
+                Err(_) => Err(MagnusError::new(magnus::exception::runtime_error(), "Failed to create response"))
+            }
         }
     }
 }

test/test_hyper_ruby.rb

@@ -4,6 +4,9 @@
 require "httpx"
 
 class TestHyperRuby < Minitest::Test
+
+  ACCEPT_RESPONSE = HyperRuby::Response.new(202, { 'Content-Type' => 'text/plain' }, '').freeze
+
   def test_that_it_has_a_version_number
     refute_nil ::HyperRuby::VERSION
   end
@@ -63,7 +66,7 @@ def test_unix_socket_cleans_up_socket
 
   def test_blocking
     buffer = String.new(capacity: 1024)
-    with_server(-> (request) { handler_to_json(request, buffer) }) do |client|
+    with_server(-> (request) { handler_accept(request, buffer) }) do |client|
       gets
     end
   end
@@ -129,4 +132,9 @@ def handler_to_json(request, buffer)
   def handler_return_header(request, header_key)
     HyperRuby::Response.new(200, { 'Content-Type' => 'application/json' }, { message: request.header(header_key) }.to_json)
   end
+
+  def handler_accept(request, buffer)
+    request.fill_body(buffer)
+    ACCEPT_RESPONSE
+  end
 end