Give the handler a request object rather than copying every header out.

Author: alistairjevans

.gitignore

@@ -12,3 +12,4 @@
 *.a
 mkmf.log
 target/
+.idea/

Gemfile

@@ -11,3 +11,5 @@ gem "rake-compiler"
 gem "rb_sys", "~> 0.9.63"
 
 gem "minitest", "~> 5.16"
+
+gem "httpx", "~> 1.4"

Gemfile.lock

@@ -6,6 +6,9 @@ PATH
 GEM
   remote: https://rubygems.org/
   specs:
+    http-2 (1.0.2)
+    httpx (1.4.0)
+      http-2 (>= 1.0.0)
     minitest (5.25.4)
     rake (13.2.1)
     rake-compiler (1.2.9)
@@ -19,6 +22,7 @@ PLATFORMS
   ruby
 
 DEPENDENCIES
+  httpx (~> 1.4)
   hyper_ruby!
   minitest (~> 5.16)
   rake (~> 13.0)

ext/hyper_ruby/src/lib.rs

@@ -1,7 +1,7 @@
 use magnus::block::block_proc;
 use magnus::r_hash::ForEach;
 use magnus::typed_data::Obj;
-use magnus::value::Opaque;
+use magnus::value::{qnil, Opaque};
 use magnus::{function, gc, method, prelude::*, DataTypeFunctions, Error as MagnusError, RString, Ruby, TypedData, Value};
 use bytes::Bytes;
 
@@ -35,15 +35,56 @@ impl ServerConfig {
     }
 }
 
+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)]
-struct WorkRequest {
+#[magnus::wrap(class = "HyperRuby::Request")]
+struct Request {
     method: warp::http::Method,
     path: String,
     headers: warp::http::HeaderMap,
     body: Bytes,
-    // sent a response back on this thread
-    response_tx: oneshot::Sender<WarpResponse<Vec<u8>>>,
+}
+
+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()
+    }
 }
 
 
@@ -76,8 +117,8 @@ impl Response {
 struct Server {
     server_handle: Arc<Mutex<Option<JoinHandle<()>>>>,
     config: RefCell<ServerConfig>,
-    work_rx: RefCell<Option<crossbeam_channel::Receiver<WorkRequest>>>,
-    work_tx: RefCell<Option<Arc<crossbeam_channel::Sender<WorkRequest>>>>,
+    work_rx: RefCell<Option<crossbeam_channel::Receiver<RequestWithCompletion>>>,
+    work_tx: RefCell<Option<Arc<crossbeam_channel::Sender<RequestWithCompletion>>>>,
 }
 
 
@@ -134,39 +175,20 @@ impl Server {
 
                  match work_request {
                     Ok(work_request) => {
-                        
-                        // Create Ruby hash with request data
-                        let req_hash = magnus::RHash::new();
-                        req_hash.aset(magnus::Symbol::new("method"), work_request.method.to_string())?;
-                        req_hash.aset(magnus::Symbol::new("path"), work_request.path)?;
-                        
-                        // Convert headers to Ruby hash
-                        let headers_hash = magnus::RHash::new();
-                        for (key, value) in work_request.headers.iter() {
-                            if let Ok(value_str) = value.to_str() {
-                                headers_hash.aset(key.as_str(), value_str)?;
-                            }
-                        }
-                        req_hash.aset(magnus::Symbol::new("headers"), headers_hash)?;
-                        
-                        // Convert body to Ruby string
-                        req_hash.aset(magnus::Symbol::new("body"), magnus::RString::from_slice(&work_request.body[..]))?;
-                            
                         // Call the Ruby block and handle the response
-                        let warp_response = match block.call::<_, Value>([req_hash]) {
+                        let warp_response = match block.call::<_, Value>((work_request.request,)) {
                             Ok(result) => {
                                 let ref_response = Obj::<Response>::try_convert(result).unwrap();
 
-                                let mut response: WarpResponse<Vec<u8>>;
+                                let mut response: WarpResponse<Bytes>;
                                 let ruby = Ruby::get().unwrap(); // errors on non-Ruby thread
                                 let response_body = ruby.get_inner(ref_response.body);
                                 let ruby_response_headers = ruby.get_inner(ref_response.headers);
 
                                 // 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 = Vec::from(response_body.as_slice());
-                                    
+                                    let rust_body = Bytes::copy_from_slice(response_body.as_slice());
                                     response = WarpResponse::new(rust_body);
                                 }
 
@@ -287,8 +309,8 @@ impl Server {
 
 
 // Helper function to create error responses
-fn create_error_response(error_message: &str) -> WarpResponse<Vec<u8>> {
-    let mut response = WarpResponse::new(format!(r#"{{"error": "{}"}}"#, error_message).into_bytes());
+fn create_error_response(error_message: &str) -> WarpResponse<Bytes> {
+    let mut response = WarpResponse::new(Bytes::from(format!(r#"{{"error": "{}"}}"#, error_message)));
     *response.status_mut() = warp::http::StatusCode::INTERNAL_SERVER_ERROR;
     response.headers_mut().insert(
         warp::http::header::CONTENT_TYPE,
@@ -302,19 +324,23 @@ async fn handle_request(
     path: warp::path::FullPath,
     headers: warp::http::HeaderMap,
     body: Bytes,
-    work_tx: Arc<crossbeam_channel::Sender<WorkRequest>>,
-) -> Result<WarpResponse<Vec<u8>>, warp::Rejection> {
+    work_tx: Arc<crossbeam_channel::Sender<RequestWithCompletion>>,
+) -> Result<WarpResponse<Bytes>, warp::Rejection> {
     let (response_tx, response_rx) = oneshot::channel();
 
-    let work_request = WorkRequest {
+    let request = Request {
         method,
         path: path.as_str().to_string(),
         headers,
-        body,
+        body
+    };
+
+    let with_completion = RequestWithCompletion {
+        request,
         response_tx,
     };
 
-    if let Err(_) = work_tx.send(work_request) {
+    if let Err(_) = work_tx.send(with_completion) {
         return Err(warp::reject::reject());
     }
 
@@ -338,5 +364,12 @@ fn init(ruby: &Ruby) -> Result<(), MagnusError> {
     let response_class = module.define_class("Response", ruby.class_object())?;
     response_class.define_singleton_method("new", function!(Response::new, 3))?;
 
+    let request_class = module.define_class("Request", ruby.class_object())?;
+    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("body_size", method!(Request::body_size, 0))?;
+
     Ok(())
 }

test/test_hyper_ruby.rb

@@ -1,40 +1,69 @@
 # frozen_string_literal: true
 
 require "test_helper"
+require "httpx"
 
 class TestHyperRuby < Minitest::Test
   def test_that_it_has_a_version_number
     refute_nil ::HyperRuby::VERSION
   end
 
-  def test_it_does_something_useful
+  def test_simple_get
+    with_server(-> (request) { handler_simple(request) }) do |client|
+      response = client.get("/")
+      assert_equal 200, response.status
+      assert_equal "text/plain", response.headers["content-type"]
+      assert_equal 'GET', response.body
+    end
+  end
+
+  def test_simple_post
+    with_server(-> (request) { handler_to_json(request) }) do |client|
+      response = client.post("/", body: "Hello")
+      assert_equal 200, response.status
+      assert_equal "application/json", response.headers["content-type"]
+      assert_equal 'Hello', JSON.parse(response.body)["message"]
+    end
+  end
+
+  def test_large_post
+    with_server(-> (request) { handler_to_json(request) }) do |client|
+      response = client.post("/", body: "a" * 10_000_000)
+      assert_equal 200, response.status
+      assert_equal "application/json", response.headers["content-type"]
+      assert_equal 'a' * 10_000_000, JSON.parse(response.body)["message"]
+    end
+  end
+
+  def with_server(request_handler, &block)
     server = HyperRuby::Server.new
     server.configure({ bind_address: "127.0.0.1:3010" })
-    handler = Handler.new
     server.start
-
+    
     # Create ruby worker threads that process requests;
-    # 1 is usually enough, and generally handles better than multiple threads
-    threads = 1.times.map do
-      Thread.new do
-        server.run_worker do |request|
-          # Process the request in Ruby
-          # request is a hash with :method, :path, :headers, and :body keys
-          #puts "Processing #{request[:method]} request to #{request[:path]}"
-          
-          # Return response string
-          HyperRuby::Response.new(200, { 'Content-Type' => 'application/json' }, '{ "message": "Hello from Ruby worker!" }')
-        end
+    # 1 is usually enough, and generally handles better than multiple threads 
+    # if there's no IO (because of the GIL)
+    worker = Thread.new do
+      server.run_worker do |request|
+        # Process the request in Ruby
+        # request is a hash with :method, :path, :headers, and :body keys
+        request_handler.call(request)
       end
     end
 
-    gets
-    server.stop
+    client = HTTPX.with(origin: "http://127.0.0.1:3010")
+    block.call(client)
+
+  ensure
+    server.stop if server
+    worker.join if worker
   end
 
-  class Handler
-    def call(req_info)
-      "Hello, world!"
-    end
+  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)
   end
 end