tp2 0.3 → 0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 766b9b6217cf2428d6ec31f2e87b6f1c3f51c8b4380f74621123272dc83f123d
-  data.tar.gz: 82f32a760e314bc187ea3ccc84fed2f0def4e15ed89057c6b52cd985c9e1601c
+  metadata.gz: 4d8c8ee2edd1c72a68b21c3ea27dc208c0dbfcbb2a6d78d76abb3ec11f115977
+  data.tar.gz: 5fb43258443827cf5fa44fc1ddd4960740d8694d5469fac70875c46c54558c15
 SHA512:
-  metadata.gz: 228ecf9a5bc7283a541ea609a53028e027587d332b1b527aea66f38084f5247a0248ce06564906fc8c31f552070986590c665d3ae157789606133cb5ac3f5e64
-  data.tar.gz: f52498515bcd2d088b2d8fe8e1079e3a741e0ac0b0f6a0753b0e365d04e8868a07c15bb77fa395b89128766f18c12dcf7ca3d638ee5a5e093c8c2f1c76dd932a
+  metadata.gz: e6c54083c10368f84bd23a0bfd235f01aa74690f7d02667a54c539921e9dc601e7f513858d3a85eee17229d4f4f12a6482d219feb1c1820cd2622c7e70e0dfa9
+  data.tar.gz: 134a0b072495b5d23f02d1d19e86db66f4f78ffea81ce1e20b48660d77c61966bf83e4876f4870b33f8d63102274d3f3e3555e3166d02cfcaa0086aacdff2520

data/Gemfile.lock

@@ -1,25 +1,23 @@
 PATH
   remote: .
   specs:
-    tp2 (0.3)
-      http_parser.rb (= 0.8.0)
+    tp2 (0.4)
       qeweney (= 0.21)
-      uringmachine (= 0.5.1)
+      uringmachine (= 0.7)
 
 GEM
   remote: https://rubygems.org/
   specs:
     docile (1.4.1)
     escape_utils (1.3.0)
-    ffi (1.17.1-aarch64-linux-gnu)
-    ffi (1.17.1-aarch64-linux-musl)
-    ffi (1.17.1-arm-linux-gnu)
-    ffi (1.17.1-arm-linux-musl)
-    ffi (1.17.1-arm64-darwin)
-    ffi (1.17.1-x86_64-darwin)
-    ffi (1.17.1-x86_64-linux-gnu)
-    ffi (1.17.1-x86_64-linux-musl)
-    http_parser.rb (0.8.0)
+    ffi (1.17.2-aarch64-linux-gnu)
+    ffi (1.17.2-aarch64-linux-musl)
+    ffi (1.17.2-arm-linux-gnu)
+    ffi (1.17.2-arm-linux-musl)
+    ffi (1.17.2-arm64-darwin)
+    ffi (1.17.2-x86_64-darwin)
+    ffi (1.17.2-x86_64-linux-gnu)
+    ffi (1.17.2-x86_64-linux-musl)
     listen (3.9.0)
       rb-fsevent (~> 0.10, >= 0.10.3)
       rb-inotify (~> 0.9, >= 0.9.10)
@@ -38,7 +36,7 @@ GEM
       simplecov_json_formatter (~> 0.1)
     simplecov-html (0.13.1)
     simplecov_json_formatter (0.1.4)
-    uringmachine (0.5.1)
+    uringmachine (0.7)
     yard (0.9.37)
 
 PLATFORMS

data/TODO.md

@@ -1 +1,14 @@
-- Write some tests.
+- Add failing tests for request bombs (requests with lots of bytes)
+- Add limits for:
+  - total request size (pre body)
+  - line size
+  - request method size
+  - request path size
+  - header size
+  - limits expressed inside regexps done as follows:
+
+    ```ruby
+    MAX_HEADER_KEY_BYTES = 256
+
+    HEADER_RE = /^\s([^\s^\:]{1, #{MAX_HEADER_KEY_BYTES}}).../
+    ```

data/examples/simple.rb

@@ -14,6 +14,7 @@ app = ->(req) {
 
 machine = UM.new
 server = TP2::Server.new(machine, '0.0.0.0', 1234, &app)
+puts "Listening on port 1234..."
 
 machine.spin { server.run }
 

data/lib/tp2/{http.rb → http1_adapter.rb}

@@ -1,69 +1,79 @@
 # frozen_string_literal: true
 
-require 'http/parser'
 require 'qeweney'
+require 'stringio'
 
 module TP2
-  # Encapsulates a HTTP/1 connection
-  class HTTP1Connection # rubocop:disable Metrics/ClassLength
-    SEND_FLAGS = UM::MSG_NOSIGNAL | UM::MSG_WAITALL
+  class HTTP1Adapter
+    attr_reader :fd
 
-    def initialize(machine, fd, bgid, &app) # rubocop:disable Naming/MethodParameterName
+    def initialize(machine, fd, &app)
       @machine = machine
       @fd = fd
-      @bgid = bgid
-      @parser = Http::Parser.new(self)
+      @buffer = String.new('', capacity: 4096)
+      @sio = StringIO.new(@buffer)
       @app = app
     end
 
-    def on_headers_complete(headers) # rubocop:disable Metrics/MethodLength
-      headers = normalize_headers(headers)
-      headers[':path'] = @parser.request_url
-      headers[':method'] = @parser.http_method.downcase
-      headers[':scheme'] = get_scheme_from_headers(headers)
-      headers[':protocol'] = "http/#{@parser.http_major}.#{@parser.http_minor}"
-      @request = Qeweney::Request.new(headers, self)
-    end
-
-    def get_scheme_from_headers(headers)
-      if (proto = headers['x-forwarded-proto'])
-        proto.downcase
-      else
-        'http'
+    def run
+      while true
+        persist = serve_request
+        break if !persist
       end
+    rescue => e
+      puts '*' * 40
+      p e
+      puts e.backtrace.join("\n")
+      exit!
+    ensure
+      @machine.close(@fd)
     end
 
-    def normalize_headers(headers)
-      headers.each_with_object({}) do |(k, v), h|
-        k = k.downcase
-        hk = h[k]
-        if hk
-          hk = h[k] = [hk] unless hk.is_a?(Array)
-          v.is_a?(Array) ? hk.concat(v) : hk << v
-        else
-          h[k] = v
-        end
-      end
-    end
+    def serve_request
+      headers = parse_headers
+      return false if !headers
 
-    def on_body(chunk)
-      @request.buffer_body_chunk(chunk)
+      request = Qeweney::Request.new(headers, self)
+      @app.call(request)
+      persist_connection?(headers)
     end
 
-    def on_message_complete
-      @done = @request.headers[':protocol'] != 'http/1.1'
-      @app.call(@request)
+    def get_body(req)
+      headers = req.headers
+      content_length = headers['content-length']
+      return read(content_length.to_i) if content_length
+
+      chunked_encoding = headers['transfer-encoding']&.downcase == 'chunked'
+      return get_body_chunked_encoding(headers) if chunked_encoding
+
+      # if content-length is not specified, we read to EOF, up to max 1MB size
+      read(1 << 20, nil, false)
     end
 
-    def run
-      @machine.recv_each(@fd, @bgid, 0) do |buf|
-        @parser << buf
-        break if @done
+    def get_body_chunk(req, buffered_only = false)
+      headers = req.headers
+      content_length = headers['content-length']
+      if content_length
+        return nil if headers[':body-done-reading']
+
+        chunk = read(content_length.to_i)
+        headers[':body-done-reading'] = true
+        return chunk
       end
-    rescue SystemCallError, HTTP::Parser::Error
-      # ignore error, just close the port silently
-    ensure
-      @machine.close(@fd)
+
+      chunked_encoding = headers['transfer-encoding']&.downcase == 'chunked'
+      return read_chunk(headers, nil) if chunked_encoding
+
+      return nil if headers[':body-done-reading']
+
+      # if content-length is not specified, we read to EOF, up to max 1MB size      
+      chunk = read(1 << 20, nil, false)
+      headers[':body-done-reading'] = true
+      chunk
+    end
+
+    def complete?(req)
+      req.headers[':body-done-reading']
     end
 
     # response API
@@ -72,6 +82,8 @@ module TP2
     ZERO_CRLF_CRLF = "0\r\n\r\n"
     CRLF_ZERO_CRLF_CRLF = "\r\n0\r\n\r\n"
 
+    SEND_FLAGS = UM::MSG_NOSIGNAL | UM::MSG_WAITALL
+
     # Sends response including headers and body. Waits for the request to complete
     # if not yet completed. The body is sent using chunked transfer encoding.
     # @param request [Qeweney::Request] HTTP request
@@ -128,6 +140,117 @@ module TP2
       @machine.send(@fd, ZERO_CRLF_CRLF, ZERO_CRLF_CRLF.bytesize, SEND_FLAGS)
     end
 
+    private
+
+    RE_REQUEST_LINE = /^([a-z]+)\s+([^\s]+)\s+(http\/[0-9\.]{1,3})/i
+    RE_HEADER_LINE = /^([a-z0-9\-]+)\:\s+(.+)/i
+
+    class ProtocolError < StandardError
+    end
+
+    def persist_connection?(headers)
+      connection = headers['connection']&.downcase
+      if headers[':protocol'] == 'http/1.1'
+        return connection != 'close'
+      else
+        return connection && connection != 'close'
+      end
+    end
+
+    def parse_headers
+      headers = get_request_line
+      return nil if !headers
+    
+      while true
+        line = get_line
+        break if line.nil? || line.empty?
+
+        m = line.match(RE_HEADER_LINE)
+        raise ProtocolError, 'Invalid header' if !m
+      
+        headers[m[1].downcase] = m[2]
+      end
+    
+      headers
+    end
+
+    def get_line
+      while true
+        line = @sio.gets(chomp: true)
+        return line if line
+      
+        res = @machine.read(@fd, @buffer, 65536, -1)
+        return nil if res == 0
+      end
+    end
+
+    def get_request_line
+      line = get_line
+      return nil if !line
+    
+      m = line.match(RE_REQUEST_LINE)
+      raise ProtocolError, 'Invalid request line' if !m
+    
+      {
+        ':method'   => m[1].downcase,
+        ':path'     => m[2],
+        ':protocol' => m[3].downcase
+      }
+    end
+
+    def get_body_chunked_encoding(headers)
+      buf = String.new(capacity: 65536)
+      while read_chunk(headers, buf)
+      end
+
+      buf
+    end
+
+    def read(len, buf = nil, raise_on_eof = true)
+      from_sio = @sio.read(len)
+      if from_sio
+        left = len - from_sio&.bytesize
+        if buf
+          buf << from_sio
+        else
+          buf = +from_sio
+        end
+      else
+        left = len
+        buf ||= +''
+      end
+
+      while left > 0
+        res = @machine.read(@fd, buf, left, -1)
+        if res == 0
+          raise ProtocolError, "Incomplete body" if raise_on_eof
+
+          return buf
+        end
+        
+
+        left -= res
+      end
+      buf
+    end
+
+    def read_chunk(headers, buf)
+      chunk_size = get_line
+      return nil if !chunk_size
+      
+      chunk_size = chunk_size.to_i(16)
+      if chunk_size == 0
+        headers[':body-done-reading'] = true
+        get_line
+        return nil
+      end
+
+      chunk = read(chunk_size, buf)
+      get_line
+
+      chunk
+    end
+
     def http1_1?(request)
       request.headers[':protocol'] == 'http/1.1'
     end

data/lib/tp2/server.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'tp2/http'
+require 'tp2/http1_adapter'
 require 'tp2/request_extensions'
 
 module TP2
@@ -18,14 +18,13 @@ module TP2
       @machine.bind(@server_fd, @hostname, @port)
       @machine.listen(@server_fd, UM::SOMAXCONN)
 
-      @bgid = @machine.setup_buffer_ring(4096, 1024)
-      puts "Listening on #{@hostname}:#{@port}"
+      # puts "Listening on #{@hostname}:#{@port}"
     end
 
     def run
       setup
       @machine.accept_each(@server_fd) do |fd|
-        conn = HTTP1Connection.new(@machine, fd, @bgid, &@app)
+        conn = HTTP1Adapter.new(@machine, fd, &@app)
         @machine.spin(conn) { it.run }
       end
     end

data/lib/tp2/version.rb

@@ -1,3 +1,3 @@
 module TP2
-  VERSION = '0.3'
+  VERSION = '0.4'
 end

data/test/helper.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'minitest/autorun'
+require 'tp2'
+
+require_relative './coverage' if ENV['COVERAGE']
+
+module Kernel
+  def capture_exception
+    yield
+  rescue Exception => e
+    e
+  end
+
+  def trace(*args)
+    STDOUT.orig_write(format_trace(args))
+  end
+
+  def format_trace(args)
+    if args.first.is_a?(String)
+      if args.size > 1
+        format("%s: %p\n", args.shift, args)
+      else
+        format("%s\n", args.first)
+      end
+    else
+      format("%p\n", args.size == 1 ? args.first : args)
+    end
+  end
+end
+
+module Minitest::Assertions
+  def assert_in_range exp_range, act
+    msg = message(msg) { "Expected #{mu_pp(act)} to be in range #{mu_pp(exp_range)}" }
+    assert exp_range.include?(act), msg
+  end
+end

data/test/run.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+Dir.glob("#{__dir__}/test_*.rb").each do |path|
+  require(path)
+end

data/test/test_http1_adapter.rb

@@ -0,0 +1,532 @@
+# frozen_string_literal: true
+
+require_relative './helper'
+
+class String
+  def crlf_lines
+    chomp.gsub("\n", "\r\n").chomp
+  end
+end
+
+class HTTP1AdapterTest < Minitest::Test
+  def make_socket_pair
+    port = 10000 + rand(30000)
+    server_fd = @machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0)
+    @machine.setsockopt(server_fd, UM::SOL_SOCKET, UM::SO_REUSEADDR, true)
+    @machine.bind(server_fd, '127.0.0.1', port)
+    @machine.listen(server_fd, UM::SOMAXCONN)
+
+    client_conn_fd = @machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0)
+    @machine.connect(client_conn_fd, '127.0.0.1', port)
+
+    server_conn_fd = @machine.accept(server_fd)
+
+    @machine.close(server_fd)
+    [client_conn_fd, server_conn_fd]
+  end
+
+  def setup
+    @machine = UM.new
+    @c_fd, @s_fd = make_socket_pair
+    @reqs = []
+    @hook = nil
+    @app = ->(req) { @hook&.call(req); @reqs << req }
+    @adapter = TP2::HTTP1Adapter.new(@machine, @s_fd, &@app)
+  end
+
+  def teardown
+    @machine.close(@c_fd) rescue nil
+    @machine.close(@s_fd) rescue nil
+  end
+
+  def write_http_request(msg, shutdown_wr = true)
+    @machine.send(@c_fd, msg, msg.bytesize, UM::MSG_WAITALL)
+    @machine.shutdown(@c_fd, UM::SHUT_WR) if shutdown_wr
+  end
+
+  def write_client_side(msg)
+    @machine.send(@c_fd, msg, msg.bytesize, UM::MSG_WAITALL)
+  end
+
+  def read_client_side(len = 65536)
+    buf = +''
+    res = @machine.recv(@c_fd, buf, len, 0)
+    res == 0 ? nil : buf
+  end
+
+  def test_basic_request_parsing
+    write_http_request "GET / HTTP/1.0\r\n\r\n"
+
+    @adapter.serve_request
+    assert_equal 1, @reqs.size
+    req = @reqs.shift
+    headers = req.headers
+    assert_equal({
+      ':method'   => 'get',
+      ':path'     => '/',
+      ':protocol' => 'http/1.0'
+    }, headers)
+  end
+
+  def test_pipelined_requests
+    write_http_request <<~HTTP.crlf_lines
+      GET /foo HTTP/1.1
+      Server: foo.com
+
+      SCHMET /bar HTTP/1.1
+
+    HTTP
+
+    @adapter.run
+    assert_equal 2, @reqs.size
+    req0 = @reqs.shift
+    headers = req0.headers
+    assert_equal({
+      ':method'   => 'get',
+      ':path'     => '/foo',
+      ':protocol' => 'http/1.1',
+      'server'    => 'foo.com'
+    }, headers)
+
+    req1 = @reqs.shift
+    headers = req1.headers
+    assert_equal({
+      ':method'   => 'schmet',
+      ':path'     => '/bar',
+      ':protocol' => 'http/1.1'
+    }, headers)
+  end
+
+  def test_pipelined_requests_with_body
+    write_http_request <<~HTTP.crlf_lines
+      POST /foo HTTP/1.1
+      Server: foo.com
+      Content-Length: 3
+
+      abcSCHMOST /bar HTTP/1.1
+      Server: bar.com
+      Content-Length: 6
+
+      defghi
+    HTTP
+
+    @bodies = []
+    @hook = ->(req) { @bodies << req.read }
+
+    @adapter.run
+    assert_equal 2, @reqs.size
+
+    req0 = @reqs.shift
+    headers = req0.headers
+    assert_equal({
+      ':method' => 'post',
+      ':path' => '/foo',
+      ':protocol' => 'http/1.1',
+      'server' => 'foo.com',
+      'content-length' => '3'
+    }, headers)
+    body = @bodies.shift
+    assert_equal 'abc', body
+
+    req1 = @reqs.shift
+    headers = req1.headers
+    assert_equal({
+      ':method' => 'schmost',
+      ':path' => '/bar',
+      ':protocol' => 'http/1.1',
+      'server' => 'bar.com',
+      'content-length' => '6'
+    }, headers)
+    body = @bodies.shift
+    assert_equal 'defghi', body
+  end
+
+  def test_pipelined_requests_with_body_chunked
+    write_http_request <<~HTTP.crlf_lines
+      POST /foo HTTP/1.1
+      Server: foo.com
+      Transfer-Encoding: chunked
+
+      3
+      abc
+      2
+      de
+      0
+
+      SCHMOST /bar HTTP/1.1
+      Server: bar.com
+      Transfer-Encoding: chunked
+
+      1f
+      123456789abcdefghijklmnopqrstuv
+      0
+
+    HTTP
+
+    @bodies = []
+    @hook = ->(req) { @bodies << req.read }
+
+    @adapter.run
+    assert_equal 2, @reqs.size
+
+    req0 = @reqs.shift
+    headers = req0.headers
+    assert_equal({
+      ':method'             => 'post',
+      ':path'               => '/foo',
+      ':protocol'           => 'http/1.1',
+      'server'              => 'foo.com',
+      'transfer-encoding'   => 'chunked',
+      ':body-done-reading'  => true
+    }, headers)
+    body = @bodies.shift
+    assert_equal 'abcde', body
+
+    req1 = @reqs.shift
+    headers = req1.headers
+    assert_equal({
+      ':method'             => 'schmost',
+      ':path'               => '/bar',
+      ':protocol'           => 'http/1.1',
+      'server'              => 'bar.com',
+      'transfer-encoding'   => 'chunked',
+      ':body-done-reading'  => true
+    }, headers)
+    body = @bodies.shift
+    assert_equal '123456789abcdefghijklmnopqrstuv', body
+  end
+
+  def test_body_to_eof
+    write_http_request <<~HTTP.crlf_lines
+      POST /foo HTTP/1.1
+      Server: foo.com
+
+      barbaz
+    HTTP
+
+    @bodies = []
+    @hook = ->(req) { @bodies << req.read }
+
+    @adapter.run
+    assert_equal 1, @reqs.size
+
+    req0 = @reqs.shift
+    headers = req0.headers
+    assert_equal({
+      ':method' => 'post',
+      ':path' => '/foo',
+      ':protocol' => 'http/1.1',
+      'server' => 'foo.com'
+    }, headers)
+    body = @bodies.shift
+    assert_equal 'barbaz', body
+  end
+
+  def test_each_chunk
+    write_http_request <<~HTTP.crlf_lines
+      POST /foo HTTP/1.1
+      Server: foo.com
+      Transfer-Encoding: chunked
+
+      3
+      abc
+      2
+      de
+      0
+
+      SCHMOST /bar HTTP/1.1
+      Server: bar.com
+      Content-Length: 31
+
+      123456789abcdefghijklmnopqrstuv
+    HTTP
+
+    chunks = []
+    @hook = ->(req) { req.each_chunk { chunks << it } }
+
+    @adapter.serve_request
+    assert_equal 1, @reqs.size
+
+    req0 = @reqs.shift
+    headers = req0.headers
+    assert_equal({
+      ':method'             => 'post',
+      ':path'               => '/foo',
+      ':protocol'           => 'http/1.1',
+      'server'              => 'foo.com',
+      'transfer-encoding'   => 'chunked',
+      ':body-done-reading'  => true
+    }, headers)
+    assert_equal ['abc', 'de'], chunks
+
+    chunks.clear
+    @adapter.serve_request
+    assert_equal 1, @reqs.size
+
+    req1 = @reqs.shift
+    headers = req1.headers
+    assert_equal({
+      ':method'             => 'schmost',
+      ':path'               => '/bar',
+      ':protocol'           => 'http/1.1',
+      'server'              => 'bar.com',
+      'content-length'      => '31',
+      ':body-done-reading'  => true
+    }, headers)
+    assert_equal ['123456789abcdefghijklmnopqrstuv'], chunks
+  end
+
+  def test_that_server_uses_content_length_in_http_1_0
+    @hook = ->(req) {
+      req.respond('Hello, world!', {})
+    }
+
+    write_http_request "GET / HTTP/1.0\r\n\r\n"
+    @adapter.run
+    response = read_client_side
+
+    expected = <<~HTTP.crlf_lines
+      HTTP/1.1 200
+      Content-Length: 13
+
+      Hello, world!
+    HTTP
+    assert_equal(expected, response)
+  end
+
+  def test_204_status_on_empty_response
+    @hook = ->(req) {
+      req.respond(nil, {})
+    }
+
+    write_http_request "GET / HTTP/1.0\r\n\r\n"
+    @adapter.run
+    response = read_client_side
+
+    expected = <<~HTTP.crlf_lines
+      HTTP/1.1 204
+
+
+
+    HTTP
+    assert_equal(expected, response)
+
+  end
+
+  def test_that_server_uses_chunked_encoding_in_http_1_1
+    @hook = ->(req) {
+      req.respond('Hello, world!')
+  }
+
+    # using HTTP 1.0, server should close connection after responding
+    write_http_request "GET / HTTP/1.1\r\n\r\n"
+    @adapter.run
+
+    response = read_client_side
+    expected = <<~HTTP.crlf_lines.chomp
+      HTTP/1.1 200
+      Content-Length: 13
+
+      Hello, world!
+    HTTP
+    assert_equal(expected, response)
+  end
+
+  def test_that_server_maintains_connection_when_using_keep_alives
+    @hook = ->(req) {
+      req.respond('Hi', {})
+    }
+
+    write_http_request "GET / HTTP/1.0\r\nConnection: keep-alive\r\n\r\n", false
+    res = @adapter.serve_request
+    assert_equal true, res
+
+    response = read_client_side
+    assert_equal("HTTP/1.1 200\r\nContent-Length: 2\r\n\r\nHi", response)
+
+    write_http_request "GET / HTTP/1.1\r\n\r\n", false
+    res = @adapter.serve_request
+    assert_equal true, res
+
+    response = read_client_side
+    expected = <<~HTTP.crlf_lines
+      HTTP/1.1 200
+      Content-Length: 2
+
+      Hi
+    HTTP
+    assert_equal(expected, response)
+
+    write_http_request "GET / HTTP/1.0\r\n\r\n"
+    res = @adapter.serve_request
+    assert_equal false, !!res
+
+    response = read_client_side
+    assert_equal("HTTP/1.1 200\r\nContent-Length: 2\r\n\r\nHi", response)
+  end
+
+  def test_pipelining_client
+    @hook = ->(req) {
+      if req.headers['foo'] == 'bar'
+        req.respond('Hello, foobar!', {})
+      else
+        req.respond('Hello, world!', {})
+      end
+
+    }
+
+    write_http_request "GET / HTTP/1.1\r\n\r\nGET / HTTP/1.1\r\nFoo: bar\r\n\r\n"
+    @adapter.run
+    response = read_client_side
+
+    expected = <<~HTTP.crlf_lines.chomp
+      HTTP/1.1 200
+      Content-Length: 13
+
+      Hello, world!HTTP/1.1 200
+      Content-Length: 14
+
+      Hello, foobar!
+    HTTP
+    assert_equal(expected, response)
+  end
+
+  def test_body_chunks
+    chunks = []
+    request = nil
+
+    @hook = ->(req) {
+      request = req
+      req.send_headers
+      req.each_chunk do |c|
+        chunks << c
+        req << c.upcase
+      end
+      req.finish
+    }
+
+    msg = "POST / HTTP/1.1\r\nTransfer-Encoding: chunked\r\n\r\n6\r\nfoobar\r\n"
+    write_http_request msg, false
+    @machine.spin { @adapter.serve_request rescue nil }
+    @machine.sleep(0.01)
+
+    assert request
+    assert_equal %w[foobar], chunks
+    assert !request.complete?
+
+    write_http_request "6\r\nbazbud\r\n", false
+    @machine.sleep(0.01)
+    assert_equal %w[foobar bazbud], chunks
+    assert !request.complete?
+
+    write_http_request "0\r\n\r\n"
+    @machine.sleep(0.01)
+    assert_equal %w[foobar bazbud], chunks
+    assert request.complete?
+
+    @machine.sleep(0.01)
+    response = read_client_side
+
+    expected = "HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\n\r\n6\r\nFOOBAR\r\n6\r\nBAZBUD\r\n0\r\n\r\n"
+    assert_equal(expected, response)
+  end
+
+  def test_upgrade
+    done = nil
+
+    @hook = ->(req) do
+      return if req.upgrade_protocol != 'echo'
+
+      req.upgrade(:echo)
+      @machine.sleep(0.01)
+      buf = +''
+      while true
+        res = @machine.recv(@s_fd, buf, 4096, 0)
+        break if res == 0
+
+        res = @machine.send(@s_fd, buf, res, 0)
+      end
+      done = true
+    rescue Exception > e
+      p e
+      p e.backtrace.join("\n")
+    end
+
+    opts = {
+      upgrade: {
+        echo: lambda do |adapter, _headers|
+          conn = adapter.conn
+          conn << <<~HTTP.crlf_lines
+            HTTP/1.1 101 Switching Protocols
+            Upgrade: echo
+            Connection: Upgrade
+
+          HTTP
+
+          conn.read_loop { |data| conn << data }
+          done = true
+        end
+      }
+    }
+
+    msg = "GET / HTTP/1.1\r\nUpgrade: echo\r\nConnection: upgrade\r\n\r\n"
+    write_http_request(msg, false)
+    @machine.spin { @adapter.serve_request rescue nil }
+    @machine.sleep(0.01)
+
+    response = read_client_side
+    expected = "HTTP/1.1 101\r\nContent-Length: 0\r\nUpgrade: echo\r\nConnection: upgrade\r\n\r\n"
+    assert_equal(expected, response)
+
+    assert !done
+
+    write_client_side 'foo'
+    assert_equal 'foo', read_client_side
+
+    write_client_side 'bar'
+    assert_equal 'bar', read_client_side
+
+    @machine.close(@c_fd)
+    assert !done
+
+    @machine.sleep(0.01)
+    assert done
+  end
+
+  def test_big_download
+    chunk_size = 1000
+    chunk_count = 1000
+    chunk = '*' * chunk_size
+
+    @hook = ->(req) do
+      req.send_headers
+      chunk_count.times do |i|
+        req << chunk
+        @machine.snooze
+      end
+      req.finish
+      @machine.close(@s_fd)
+    rescue Exception => e
+      p e
+      p e.backtrace.join("\n")
+    end
+
+    response = +''
+    count = 0
+
+    write_client_side("GET / HTTP/1.1\r\n\r\n")
+    @machine.spin { @adapter.serve_request }
+
+    while (data = read_client_side(chunk_size))
+      response << data
+      count += 1
+      @machine.snooze
+    end
+
+    chunks = "#{chunk_size.to_s(16)}\r\n#{'*' * chunk_size}\r\n" * chunk_count
+    expected = "HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\n\r\n#{chunks}0\r\n\r\n"
+
+    assert_equal expected, response
+    assert count >= chunk_count
+  end
+end

data/test/test_server.rb

@@ -0,0 +1,218 @@
+# frozen_string_literal: true
+
+require_relative './helper'
+
+class String
+end
+
+class ServerTest < Minitest::Test
+  def make_socket_pair
+    port = 10000 + rand(30000)
+    server_fd = @machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0)
+    @machine.setsockopt(server_fd, UM::SOL_SOCKET, UM::SO_REUSEADDR, true)
+    @machine.bind(server_fd, '127.0.0.1', port)
+    @machine.listen(server_fd, UM::SOMAXCONN)
+
+    client_conn_fd = @machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0)
+    @machine.connect(client_conn_fd, '127.0.0.1', port)
+
+    server_conn_fd = @machine.accept(server_fd)
+
+    @machine.close(server_fd)
+    [client_conn_fd, server_conn_fd]
+  end
+
+  class STOP < StandardError
+  end
+
+  def setup
+    @machine = UM.new
+    @port = 10000 + rand(30000)
+    @server = TP2::Server.new(@machine, '127.0.0.1', @port) { @app&.call(it) }
+    @f_server = @machine.spin do
+      @server.run
+    rescue STOP
+    ensure
+      @server_done = true
+    end
+
+    @machine.sleep(0.01)
+    @client_fd = @machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0)
+    @machine.connect(@client_fd, '127.0.0.1', @port)
+  end
+
+  def teardown
+    @machine.close(@client_fd) rescue nil
+    @machine.schedule(@f_server, STOP.new)
+    @machine.snooze until @server_done
+  end
+
+  def write_http_request(msg, shutdown_wr = true)
+    @machine.send(@client_fd, msg, msg.bytesize, UM::MSG_WAITALL)
+    @machine.shutdown(@client_fd, UM::SHUT_WR) if shutdown_wr
+  end
+
+  def write_client_side(msg)
+    @machine.send(@client_fd, msg, msg.bytesize, UM::MSG_WAITALL)
+  end
+
+  def read_client_side(len = 65536)
+    buf = +''
+    res = @machine.recv(@client_fd, buf, len, 0)
+    res == 0 ? nil : buf
+  end
+
+  def test_basic_app_response
+    @app = ->(req) {
+      req.respond('Hello, world!', {})
+    }
+
+    write_http_request "GET / HTTP/1.0\r\n\r\n"
+    response = read_client_side
+    expected = "HTTP/1.1 200\r\nContent-Length: 13\r\n\r\nHello, world!"
+    assert_equal(expected, response)
+  end
+
+  def test_pipelined_requests
+    @app = ->(req) {
+      req.respond("method: #{req.method}")
+    }
+
+    write_http_request "GET /foo HTTP/1.1\r\nServer: foo.com\r\n\r\nSCHMET /bar HTTP/1.1\r\n\r\n"
+
+    response = read_client_side
+    expected = "HTTP/1.1 200\r\nContent-Length: 11\r\n\r\nmethod: getHTTP/1.1 200\r\nContent-Length: 14\r\n\r\nmethod: schmet"
+    assert_equal(expected, response)
+  end
+
+  def test_pipelined_requests_with_body
+    skip
+
+    write_http_request <<~HTTP.crlf_lines
+      POST /foo HTTP/1.1
+      Server: foo.com
+      Content-Length: 3
+
+      abcSCHMOST /bar HTTP/1.1
+      Server: bar.com
+      Content-Length: 6
+
+      defghi
+    HTTP
+
+    @bodies = []
+    @hook = ->(req) { @bodies << req.read }
+
+    @adapter.run
+    assert_equal 2, @reqs.size
+
+    req0 = @reqs.shift
+    headers = req0.headers
+    assert_equal({
+      ':method' => 'post',
+      ':path' => '/foo',
+      ':protocol' => 'http/1.1',
+      'server' => 'foo.com',
+      'content-length' => '3'
+    }, headers)
+    body = @bodies.shift
+    assert_equal 'abc', body
+
+    req1 = @reqs.shift
+    headers = req1.headers
+    assert_equal({
+      ':method' => 'schmost',
+      ':path' => '/bar',
+      ':protocol' => 'http/1.1',
+      'server' => 'bar.com',
+      'content-length' => '6'
+    }, headers)
+    body = @bodies.shift
+    assert_equal 'defghi', body
+  end
+
+  def test_pipelined_requests_with_body_chunked
+    skip
+
+    write_http_request <<~HTTP.crlf_lines
+      POST /foo HTTP/1.1
+      Server: foo.com
+      Transfer-Encoding: chunked
+
+      3
+      abc
+      2
+      de
+      0
+
+      SCHMOST /bar HTTP/1.1
+      Server: bar.com
+      Transfer-Encoding: chunked
+
+      1f
+      123456789abcdefghijklmnopqrstuv
+      0
+
+    HTTP
+
+    @bodies = []
+    @hook = ->(req) { @bodies << req.read }
+
+    @adapter.run
+    assert_equal 2, @reqs.size
+
+    req0 = @reqs.shift
+    headers = req0.headers
+    assert_equal({
+      ':method'             => 'post',
+      ':path'               => '/foo',
+      ':protocol'           => 'http/1.1',
+      'server'              => 'foo.com',
+      'transfer-encoding'   => 'chunked',
+      ':body-done-reading'  => true
+    }, headers)
+    body = @bodies.shift
+    assert_equal 'abcde', body
+
+    req1 = @reqs.shift
+    headers = req1.headers
+    assert_equal({
+      ':method'             => 'schmost',
+      ':path'               => '/bar',
+      ':protocol'           => 'http/1.1',
+      'server'              => 'bar.com',
+      'transfer-encoding'   => 'chunked',
+      ':body-done-reading'  => true
+    }, headers)
+    body = @bodies.shift
+    assert_equal '123456789abcdefghijklmnopqrstuv', body
+  end
+
+  def test_body_to_eof
+    skip
+
+    write_http_request <<~HTTP.crlf_lines
+      POST /foo HTTP/1.1
+      Server: foo.com
+
+      barbaz
+    HTTP
+
+    @bodies = []
+    @hook = ->(req) { @bodies << req.read }
+
+    @adapter.run
+    assert_equal 1, @reqs.size
+
+    req0 = @reqs.shift
+    headers = req0.headers
+    assert_equal({
+      ':method' => 'post',
+      ':path' => '/foo',
+      ':protocol' => 'http/1.1',
+      'server' => 'foo.com'
+    }, headers)
+    body = @bodies.shift
+    assert_equal 'barbaz', body
+  end
+end

data/tp2.gemspec

@@ -19,7 +19,6 @@ Gem::Specification.new do |s|
   s.require_paths = ['lib']
   s.required_ruby_version = '>= 3.4'
 
-  s.add_dependency 'http_parser.rb',  '0.8.0'
-  s.add_dependency 'uringmachine',    '0.5.1'
+  s.add_dependency 'uringmachine',    '0.7'
   s.add_dependency 'qeweney',         '0.21'
 end

metadata

@@ -1,42 +1,28 @@
 --- !ruby/object:Gem::Specification
 name: tp2
 version: !ruby/object:Gem::Version
-  version: '0.3'
+  version: '0.4'
 platform: ruby
 authors:
 - Sharon Rosner
 bindir: bin
 cert_chain: []
-date: 2025-03-01 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: http_parser.rb
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 0.8.0
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 0.8.0
 - !ruby/object:Gem::Dependency
   name: uringmachine
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.5.1
+        version: '0.7'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.5.1
+        version: '0.7'
 - !ruby/object:Gem::Dependency
   name: qeweney
   requirement: !ruby/object:Gem::Requirement
@@ -65,10 +51,14 @@ files:
 - TODO.md
 - examples/simple.rb
 - lib/tp2.rb
-- lib/tp2/http.rb
+- lib/tp2/http1_adapter.rb
 - lib/tp2/request_extensions.rb
 - lib/tp2/server.rb
 - lib/tp2/version.rb
+- test/helper.rb
+- test/run.rb
+- test/test_http1_adapter.rb
+- test/test_server.rb
 - tp2.gemspec
 homepage: https://github.com/noteflakes/tp2
 licenses:
@@ -95,7 +85,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 3.6.8
 specification_version: 4
 summary: Experimental HTTP/1 server for UringMachine
 test_files: []