tp2 0.14.1 → 0.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3c99469ae66a0fa3a184c3196d2e7978a5ae1cdac9b55820a4badc176030033a
-  data.tar.gz: 4e4f7646de8efdc89c23af826f2502c0aabc5ef8e7773272e4596ccf1c106822
+  metadata.gz: 9b39e332d3140ec95dee3edc265fec814873208d8b17797fccd5513b843b614b
+  data.tar.gz: f39b677a8e703b9d9f8a48aa223365b6355eb5810735812cf600ae1645351d89
 SHA512:
-  metadata.gz: 3dc15dc21f2d199cf3d807cc99e82d2f624269862e9adbf49e0d1bcd29bf00046f6c90bdb9523decfa9ad78377278e2e56a0cb8b6cc30f990273aa9349fe5bed
-  data.tar.gz: c236ef22298ffca5c23a432dfa31e83c243821b0c95d1705eeb109d0fd9312669e43551a9ca64d90e5f16abd9ec593f77416aa04306ab86d675e06a6890effb5
+  metadata.gz: 0cab6849c05ca00890073e2ef7fe2db7410fbda9ac10f4d908fba7c04e02452dc31ec4f9c24c56dd5719ca11c6bcd57de325b1e422fab4114515674e3273c854
+  data.tar.gz: 7cb455c7da2207024e6ce8d41435dee1c6ed2d4357b259d9b34a750f829504576304aac7cc8e998a5bd06eeca61db8e643311bcf67c0726528bf3a0f7d04699a

data/CHANGELOG.md

@@ -1,3 +1,14 @@
+# 0.16 2025-09-11
+
+- Remove support for HTTP/0.9, HTTP/1.0, use chunked transfer encoding
+  exclusively for HTTP responses
+- Remove call to app.ready
+
+# 0.15 2025-08-30
+
+- Call app.ready after setting up, if method available
+- Update uringmachine, qeweney deps
+
 # 0.14.1 2025-07-08
 
 - Add request elapsed time to log

data/README.md

@@ -1,4 +1,10 @@
-# TP2
+<p align="center"><img src="tp2-logo.png" /></p>
+
+# TP2 - a io_uring-based app server for Ruby
+
+[![Gem Version](https://badge.fury.io/rb/tp2.svg)](http://rubygems.org/gems/tp2)
+[![Tipi Test](https://github.com/digital-fabric/tp2/workflows/Tests/badge.svg)](https://github.com/digital-fabric/tp2/actions?query=workflow%3ATests)
+[![MIT licensed](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/digital-fabric/tp2/blob/master/LICENSE)
 
 TP2 is an experimental HTTP server based on
 [UringMachine](https://github.com/digital-fabric/uringmachine) and [Qeweney](https://github.com/digital-fabric/qeweney).

data/TODO.md

@@ -1,3 +1,25 @@
+## Immediate
+
+- [ ] Remove support for HTTP/0.9, HTTP/1.0
+  - [ ] Reply with 505 HTTP version not supported:
+
+    ```
+    < GET / HTTP/0.9
+
+    > HTTP/1.1 505
+    > Connection: close
+    ```
+
+- [ ] Use chunked transfer encoding exclusively
+- [ ] Cache rendered headers
+  - [ ] Look at sketch in ~/Desktop/docs/
+
+- [ ] Add options for:
+  - [ ] Date header
+  - [ ] Server header
+
+##
+
 - Add failing tests for request bombs (requests with lots of bytes)
 - Add test for `ProtocolError` handling
 - Add limits with tests for:

data/lib/tp2/{http1_connection.rb → connection.rb}

@@ -2,10 +2,16 @@
 
 require 'qeweney'
 require 'stringio'
+require 'tp2/errors'
 
 module TP2
-  class HTTP1Connection
-    attr_reader :fd, :response_headers
+  # Implements an HTTP/1.1 connection received by the TP2 server. This
+  # implementation rejects incoming HTTP/0.9 or HTTP/1.0 requests. The response
+  # body is sent exclusively using chunked transfer encoding. Request bodies are
+  # accepted using either fixed length (Content-Length header) or chunked
+  # transfer encoding.
+  class Connection
+    attr_reader :fd, :response_headers, :logger
 
     def initialize(machine, fd, opts, &app)
       @machine = machine
@@ -37,37 +43,52 @@ module TP2
       @machine.close_async(@fd)
     end
 
-    # Returns true if connection should persist
+    # Processes an incoming request by parsing the headers, creating a request
+    # object and handing it off to the app handler. Returns true if the
+    # connection should be persisted.
     def serve_request
       headers = parse_headers
       return false if !headers
 
       request = Qeweney::Request.new(headers, self)
+
       request.start_stamp = monotonic_clock
       @app.call(request)
       persist_connection?(headers)
-    rescue ProtocolError => e
-      @logger&.error(
-        message: 'Protocol error, closing connection',
-        error: e
-      )
-      false
-    rescue SystemCallError => e
-      @logger&.error(
-        message: 'I/O error, closing connection',
-        error: e
-      )
-      false
     rescue StandardError => e
-      @logger&.error(
-        message: 'Internal error while serving request, abandoning connection',
-        error: e
-      )
+      handle_error(request, e)
+      false
+    end
+
+    # Handles an error encountered while serving a request by logging the error
+    # and optionally sending an error response with the relevant HTTP status
+    # code. For I/O errors, no response is sent.
+    # 
+    # @param request [Qeweney::Request] HTTP request
+    # @param err [Exception] error
+    # @return [void]
+    def handle_error(request, err)
+      case err
+      when SystemCallError
+        log_error(err, 'I/O error')
+      when ProtocolError
+        log_error(err, err.message)
+        respond(request, err.message, ':status' => err.http_status)
+      else
+        log_error(err, 'Internal error')
+        return if !request || @done
 
-      if request && !@done
         respond(request, 'Internal server error', ':status' => Qeweney::Status::INTERNAL_SERVER_ERROR)
       end
-      false
+    end
+
+    # Logs the given err and given message.
+    # 
+    # @param err [Exception] error
+    # @param message [String] error message
+    # @return [void]
+    def log_error(err, message)
+      @logger&.error(message: "#{message}, closing connection", error: err)
     end
 
     def get_body(req)
@@ -118,16 +139,15 @@ module TP2
     # @param body [String] response body
     # @param headers
     def respond(request, body, headers)
-      formatted_headers = format_headers(headers, body, false)
-      request.tx_incr(formatted_headers.bytesize + (body ? body.bytesize : 0))
+      formatted_headers = format_headers(headers, body)
+      request&.tx_incr(formatted_headers.bytesize + (body ? body.bytesize : 0))
       if body
-        buf = formatted_headers + body
+        buf = "#{formatted_headers}#{body.bytesize.to_s(16)}\r\n#{body}\r\n#{EMPTY_CHUNK}"
         @machine.send(@fd, buf, buf.bytesize, SEND_FLAGS)
-        # handle_write(formatted_headers + body)
       else
         @machine.send(@fd, formatted_headers, formatted_headers.bytesize, SEND_FLAGS)
       end
-      @logger&.info(request: request, response_headers: headers)
+      @logger&.info(request: request, response_headers: headers) if request
       @done = true
       @response_headers = headers
     end
@@ -137,10 +157,9 @@ module TP2
     # @param request [Qeweney::Request] HTTP request
     # @param headers [Hash] response headers
     # @param empty_response [boolean] whether a response body will be sent
-    # @param chunked [boolean] whether to use chunked transfer encoding
     # @return [void]
-    def send_headers(request, headers, empty_response: false, chunked: true)
-      formatted_headers = format_headers(headers, !empty_response, http1_1?(request) && chunked)
+    def send_headers(request, headers, empty_response: false)
+      formatted_headers = format_headers(headers, !empty_response)
       request.tx_incr(formatted_headers.bytesize)
       @machine.send(@fd, formatted_headers, formatted_headers.bytesize, SEND_FLAGS)
       @response_headers = headers
@@ -224,20 +243,15 @@ module TP2
 
     private
 
-    RE_REQUEST_LINE = %r{^([a-z]+)\s+([^\s]+)\s+(http/[0-9.]{1,3})}i
+    RE_REQUEST_LINE = /^([a-z]+)\s+([^\s]+)\s+http\/([019\.]{1,3})/i
     RE_HEADER_LINE = /^([a-z0-9-]+):\s+(.+)/i
     MAX_REQUEST_LINE_LEN = 1 << 14 # 16KB
     MAX_HEADER_LINE_LEN = 1 << 10 # 1KB
     MAX_CHUNK_SIZE_LEN = 16
 
-    class ProtocolError < StandardError
-    end
-
     def persist_connection?(headers)
       connection = headers['connection']&.downcase
-      return connection != 'close' if headers[':protocol'] == 'http/1.1'
-
-      connection && connection != 'close'
+      return connection != 'close'
     end
 
     def parse_headers
@@ -263,12 +277,15 @@ module TP2
       return nil if !line
 
       m = line.match(RE_REQUEST_LINE)
-      raise ProtocolError, "Invalid request line: #{line[0..2047].inspect}" if !m
+      raise ProtocolError, 'Invalid request line' if !m
+
+      http_version = m[3]
+      raise UnsupportedHTTPVersionError, 'HTTP version not supported' if http_version != '1.1'
 
       {
         ':method'   => m[1].downcase,
         ':path'     => m[2],
-        ':protocol' => m[3].downcase
+        ':protocol' => 'http/1.1'
       }
     end
 
@@ -305,21 +322,16 @@ module TP2
       buffer ? (buffer << chunk) : chunk
     end
 
-    def http1_1?(request)
-      request.headers[':protocol'] == 'http/1.1'
-    end
-
     INTERNAL_HEADER_REGEXP = /^:/
 
     # Formats response headers into an array. If empty_response is true(thy),
     # the response status code will default to 204, otherwise to 200.
     # @param headers [Hash] response headers
     # @param body [boolean] whether a response body will be sent
-    # @param chunked [boolean] whether to use chunked transfer encoding
     # @return [String] formatted response headers
-    def format_headers(headers, body, chunked)
+    def format_headers(headers, body)
       status = headers[':status'] || (body ? Qeweney::Status::OK : Qeweney::Status::NO_CONTENT)
-      lines = format_status_line(body, status, chunked)
+      lines = format_status_line(body, status)
       headers.each do |k, v|
         next if k =~ INTERNAL_HEADER_REGEXP
 
@@ -329,11 +341,11 @@ module TP2
       lines
     end
 
-    def format_status_line(body, status, chunked)
+    def format_status_line(body, status)
       if !body
         empty_status_line(status)
       else
-        with_body_status_line(status, body, chunked)
+        with_body_status_line(status, body)
       end
     end
 
@@ -345,12 +357,8 @@ module TP2
       end
     end
 
-    def with_body_status_line(status, body, chunked)
-      if chunked
-        +"HTTP/1.1 #{status}\r\nTransfer-Encoding: chunked\r\n"
-      else
-        +"HTTP/1.1 #{status}\r\nContent-Length: #{body.bytesize}\r\n"
-      end
+    def with_body_status_line(status, body)
+      +"HTTP/1.1 #{status}\r\nTransfer-Encoding: chunked\r\n"
     end
 
     def collect_header_lines(lines, key, value)

data/lib/tp2/errors.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module TP2
+  class ProtocolError < StandardError
+    def http_status
+      Qeweney::Status::BAD_REQUEST
+    end
+  end
+
+  class UnsupportedHTTPVersionError < ProtocolError
+    def http_status
+      Qeweney::Status::HTTP_VERSION_NOT_SUPPORTED
+    end
+  end
+end

data/lib/tp2/server.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'tp2/http1_connection'
+require 'tp2/connection'
 require 'tp2/request_extensions'
 require 'tp2/rack_adapter'
 
@@ -100,7 +100,7 @@ module TP2
 
     def accept_incoming(listen_fd)
       @machine.accept_each(listen_fd) do |fd|
-        conn = HTTP1Connection.new(@machine, fd, @opts, &@app)
+        conn = Connection.new(@machine, fd, @opts, &@app)
         f = @machine.spin(conn) do
           it.run
         ensure

data/lib/tp2/version.rb

@@ -1,3 +1,3 @@
 module TP2
-  VERSION = '0.14.1'
+  VERSION = '0.16'
 end

data/test/helper.rb

@@ -36,6 +36,29 @@ module Kernel
   end
 end
 
+class Qeweney::Request
+  def response_headers
+    adapter.headers
+  end
+
+  def response_status
+    adapter.status
+  end
+
+  def response_body
+    adapter.body
+  end
+
+  def response_json
+    raise if response_content_type != 'application/json'
+    JSON.parse(response_body, symbolize_names: true)
+  end
+
+  def response_content_type
+    response_headers['Content-Type']
+  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)}" }

data/test/{test_http1_connection.rb → test_connection.rb}

@@ -2,7 +2,7 @@
 
 require_relative './helper'
 
-class HTTP1ConnectionTest < Minitest::Test
+class ConnectionTest < Minitest::Test
   def make_socket_pair
     port = 10000 + rand(30000)
     server_fd = @machine.socket(UM::AF_INET, UM::SOCK_STREAM, 0, 0)
@@ -25,7 +25,7 @@ class HTTP1ConnectionTest < Minitest::Test
     @reqs = []
     @hook = nil
     @app = ->(req) { @hook&.call(req); @reqs << req }
-    @adapter = TP2::HTTP1Connection.new(@machine, @s_fd, {}, &@app)
+    @adapter = TP2::Connection.new(@machine, @s_fd, {}, &@app)
   end
 
   def teardown
@@ -48,8 +48,31 @@ class HTTP1ConnectionTest < Minitest::Test
     res == 0 ? nil : buf
   end
 
-  def test_basic_request_parsing
+  def test_http_unsupported_versions
+    write_http_request "GET / HTTP/0.9\r\n\r\n"
+    @adapter.serve_request
+    response = read_client_side
+    assert_equal "HTTP/1.1 505\r\nTransfer-Encoding: chunked\r\n\r\n1a\r\nHTTP version not supported\r\n0\r\n\r\n", response
+
+    setup
+
     write_http_request "GET / HTTP/1.0\r\n\r\n"
+    @adapter.serve_request
+    response = read_client_side
+    assert_equal "HTTP/1.1 505\r\nTransfer-Encoding: chunked\r\n\r\n1a\r\nHTTP version not supported\r\n0\r\n\r\n", response
+
+    setup
+
+    @hook = ->(req) { req.respond('hi') }
+    write_http_request "GET / HTTP/1.1\r\n\r\n"
+    @adapter.serve_request
+    @machine.close(@s_fd)
+    response = read_client_side
+    assert_equal "HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\n\r\n2\r\nhi\r\n0\r\n\r\n", response
+  end
+
+  def test_basic_request_parsing
+    write_http_request "GET / HTTP/1.1\r\n\r\n"
 
     @adapter.serve_request
     assert_equal 1, @reqs.size
@@ -58,7 +81,7 @@ class HTTP1ConnectionTest < Minitest::Test
     assert_equal({
       ':method'   => 'get',
       ':path'     => '/',
-      ':protocol' => 'http/1.0'
+      ':protocol' => 'http/1.1'
     }, headers)
   end
 
@@ -196,34 +219,6 @@ class HTTP1ConnectionTest < Minitest::Test
     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
-
   def test_each_chunk
     write_http_request <<~HTTP.crlf_lines
       POST /foo HTTP/1.1
@@ -278,30 +273,12 @@ class HTTP1ConnectionTest < Minitest::Test
     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"
+    write_http_request "GET / HTTP/1.1\r\n\r\n"
     @adapter.run
     response = read_client_side
 
@@ -325,46 +302,29 @@ class HTTP1ConnectionTest < Minitest::Test
     @adapter.run
 
     response = read_client_side
-    expected = <<~HTTP.crlf_lines.chomp
-      HTTP/1.1 200
-      Content-Length: 13
-
-      Hello, world!
-    HTTP
+    expected = "HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\n\r\nd\r\nHello, world!\r\n0\r\n\r\n"
     assert_equal(expected, response)
   end
 
-  def test_that_server_maintains_connection_when_using_keep_alives
+  def test_that_server_maintains_connection_if_no_connection_close_header
     @hook = ->(req) {
       req.respond('Hi', {})
     }
 
-    write_http_request "GET / HTTP/1.0\r\nConnection: keep-alive\r\n\r\n", false
+    write_http_request "GET / HTTP/1.1\r\nConnection: close\r\n\r\n", false
     res = @adapter.serve_request
-    assert_equal true, res
+    assert_equal false, res
 
     response = read_client_side
-    assert_equal("HTTP/1.1 200\r\nContent-Length: 2\r\n\r\nHi", response)
+    assert_equal("HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\n\r\n2\r\nHi\r\n0\r\n\r\n", 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
+    expected = "HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\n\r\n2\r\nHi\r\n0\r\n\r\n"
     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
@@ -381,15 +341,8 @@ class HTTP1ConnectionTest < Minitest::Test
     @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
+    expected = "HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\n\r\nd\r\nHello, world!\r\n0\r\n\r\n" + 
+               "HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\n\r\ne\r\nHello, foobar!\r\n0\r\n\r\n"
     assert_equal(expected, response)
   end
 
@@ -538,7 +491,7 @@ class HTTP1ConnectionTest < Minitest::Test
 
     content = IO.read(__FILE__)
     file_size = content.bytesize
-    expected = "HTTP/1.1 200\r\nContent-Length: 6\r\n\r\nfoobar"
+    expected = "HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\n\r\n6\r\nfoobar\r\n0\r\n\r\n"
 
     assert_equal expected, response
   end

data/test/test_server.rb

@@ -65,14 +65,25 @@ class ServerTest < Minitest::Test
     res == 0 ? nil : buf
   end
 
-  def test_basic_app_response
+  def test_http_1_0_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!"
+    expected = "HTTP/1.1 505\r\nTransfer-Encoding: chunked\r\n\r\n1a\r\nHTTP version not supported\r\n0\r\n\r\n"
+    assert_equal(expected, response)
+  end
+
+  def test_basic_app_response
+    @app = ->(req) {
+      req.respond('Hello, world!', {})
+    }
+
+    write_http_request "GET / HTTP/1.1\r\n\r\n"
+    response = read_client_side
+    expected = "HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\n\r\nd\r\nHello, world!\r\n0\r\n\r\n"
     assert_equal(expected, response)
   end
 
@@ -84,7 +95,8 @@ class ServerTest < Minitest::Test
     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"
+    expected = "HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\n\r\nb\r\nmethod: get\r\n0\r\n\r\n" + 
+               "HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\n\r\ne\r\nmethod: schmet\r\n0\r\n\r\n"
     assert_equal(expected, response)
   end
 
@@ -104,7 +116,7 @@ class ServerTest < Minitest::Test
     @machine.snooze
 
     response = read_client_side
-    expected = "HTTP/1.1 200\r\nContent-Length: 11\r\n\r\nTerminated!"
+    expected = "HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\n\r\nb\r\nTerminated!\r\n0\r\n\r\n"
     assert_equal(expected, response)
   end
 
@@ -143,7 +155,7 @@ class ServerTest < Minitest::Test
       ':protocol' => 'http/1.1',
       'server' => 'foo.com',
       'content-length' => '3',
-      ':tx' => 48,
+      ':tx' => 56,
     }, headers)
     body = @bodies.shift
     assert_equal 'abc', body
@@ -156,7 +168,7 @@ class ServerTest < Minitest::Test
       ':protocol' => 'http/1.1',
       'server' => 'bar.com',
       'content-length' => '6',
-      ':tx' => 51,
+      ':tx' => 59,
     }, headers)
     body = @bodies.shift
     assert_equal 'defghi', body

data/tp2.gemspec

@@ -20,7 +20,7 @@ Gem::Specification.new do |s|
   s.required_ruby_version = '>= 3.4'
   s.executables   = ['tp2']
 
-  s.add_dependency 'uringmachine',    '~> 0.16'
-  s.add_dependency 'qeweney',         '~> 0.21'
+  s.add_dependency 'uringmachine',    '~> 0.18'
+  s.add_dependency 'qeweney',         '~> 0.22'
   s.add_dependency 'rack',            '~> 3.1.15'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tp2
 version: !ruby/object:Gem::Version
-  version: 0.14.1
+  version: '0.16'
 platform: ruby
 authors:
 - Sharon Rosner
@@ -15,28 +15,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.16'
+        version: '0.18'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.16'
+        version: '0.18'
 - !ruby/object:Gem::Dependency
   name: qeweney
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.21'
+        version: '0.22'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.21'
+        version: '0.22'
 - !ruby/object:Gem::Dependency
   name: rack
   requirement: !ruby/object:Gem::Requirement
@@ -71,7 +71,8 @@ files:
 - examples/rack.ru
 - examples/simple.rb
 - lib/tp2.rb
-- lib/tp2/http1_connection.rb
+- lib/tp2/connection.rb
+- lib/tp2/errors.rb
 - lib/tp2/logger.rb
 - lib/tp2/rack_adapter.rb
 - lib/tp2/request_extensions.rb
@@ -79,8 +80,9 @@ files:
 - lib/tp2/version.rb
 - test/helper.rb
 - test/run.rb
-- test/test_http1_connection.rb
+- test/test_connection.rb
 - test/test_server.rb
+- tp2-logo.png
 - tp2.gemspec
 homepage: https://github.com/noteflakes/tp2
 licenses:
@@ -107,7 +109,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.8
+rubygems_version: 3.7.0.dev
 specification_version: 4
 summary: Experimental HTTP/1 server for UringMachine
 test_files: []