tp2 0.15 → 0.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7c0c245bd1ea541ba0cb2e6c89dabd928c11ecc0e9bba1fe27f0ae69b2ea67c8
-  data.tar.gz: 4c0a8cd775703e03a2cce80f0727f62f39b3c6f171a2356586092ca97b510490
+  metadata.gz: 7f064819fba5d42c4376f3895ee0cce07745149e6b9ed06e864acb1ac3515d9e
+  data.tar.gz: 84767b1d2cd87c6006ba7202f48c2bf1cdc9345ddf258c8fcd716bcf2023c264
 SHA512:
-  metadata.gz: 847c5fa38441c0af9ff06db44b4259edcf2990e8d017cd7a0c706e8ecd6f95a1439bd5c13ae6509c2f1a67fdbbe6002b5c9e9bba7332b0a3c83f8941546c68d1
-  data.tar.gz: 7b41d103bc5235de576efaaa7c69d5309c837ce604c7d15b6c0e316459e5c5ade0a4dfb7073701edf42b0e11134cc1e179ac072d581aceb872453d2f0131c48e
+  metadata.gz: 72b97e276e4abb593566d761f44ac7bfa0a9af5d9ff5dcbece407412dd07eac84a9dfbe6d983c832010fb9a365be27053df471d2b9e76a2955b7332a33b06e69
+  data.tar.gz: 6a13102f1f2008b32aa34fec7da9b2cda496e19f5445525f398b6c4f0a863b15bb68bf94b457e56f0b3c6ace41d3caca4722158ea69fc638d6a828f39e047bbd

data/.gitignore

@@ -54,3 +54,4 @@ Gemfile.lock
 
 # Used by RuboCop. Remote config files pulled in from inherit_from directive.
 # .rubocop-https?--*
+*.json

data/CHANGELOG.md

@@ -1,3 +1,15 @@
+# 0.17 2025-09-14
+
+- Add support for server extensions: `Date`, `Server` headers
+- Add `Request#set_response_headers` for injecting response headers
+- Add support for env[:server_headers]
+
+# 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

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)
+[![Tests](https://github.com/noteflakes/tp2/actions/workflows/test.yml/badge.svg)](https://github.com/noteflakes/tp2/actions/workflows/test.yml)
+[![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
+
+- [v] Remove support for HTTP/0.9, HTTP/1.0
+  - [v] Reply with 505 HTTP version not supported:
+
+    ```
+    < GET / HTTP/0.9
+
+    > HTTP/1.1 505
+    > Connection: close
+    ```
+
+- [v] 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,16 +2,23 @@
 
 require 'qeweney'
 require 'stringio'
+require 'tp2/errors'
 
 module TP2
-  class HTTP1Connection
-    attr_reader :fd, :response_headers
-
-    def initialize(machine, fd, opts, &app)
+  # 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(server, machine, fd, env, &app)
+      @server = server
       @machine = machine
       @fd = fd
-      @opts = opts
-      @logger = opts[:logger]
+      @env = env
+      @logger = env[:logger]
       @stream = UM::Stream.new(machine, fd)
       @app = app
 
@@ -37,37 +44,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)
@@ -110,6 +132,16 @@ module TP2
 
     # response API
 
+    # Sets response headers before sending any response. This method is used to
+    # add headers such as Set-Cookie or cache control headers to a response
+    # before actually responding, specifically in middleware hooks.
+    #
+    # @param headers [Hash] response headers
+    # @return [void]
+    def set_response_headers(headers)
+      @response_headers ? @response_headers.merge!(headers) : @response_headers = headers
+    end
+
     SEND_FLAGS = UM::MSG_NOSIGNAL | UM::MSG_WAITALL
 
     # Sends response including headers and body. Waits for the request to complete
@@ -118,18 +150,19 @@ 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))
+      headers = @response_headers.merge(headers) if @response_headers
+
+      formatted_headers = format_headers(headers, body)
+      @response_headers = headers
+      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
 
     # Sends response headers. If empty_response is truthy, the response status
@@ -137,10 +170,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
@@ -182,28 +214,28 @@ module TP2
       @done = true
     end
 
-    def respond_with_static_file(req, path, opts, cache_headers)
+    def respond_with_static_file(req, path, env, cache_headers)
       fd = @machine.open(path, UM::O_RDONLY)
-      opts ||= {}
-      if opts[:headers]
-        opts[:headers].merge!(cache_headers)
+      env ||= {}
+      if env[:headers]
+        env[:headers].merge!(cache_headers)
       else
-        opts[:headers] = cache_headers
+        env[:headers] = cache_headers
       end
 
-      maxlen = opts[:max_len] || 65_536
+      maxlen = env[:max_len] || 65_536
       buf = String.new(capacity: maxlen)
       headers_sent = nil
       loop do
         res = @machine.read(fd, buf, maxlen, 0)
         if res < maxlen && !headers_sent
-          return respond(req, buf, opts[:headers])
+          return respond(req, buf, env[:headers])
         elsif res == 0
           return finish(req)
         end
 
         if !headers_sent
-          send_headers(req, opts[:headers])
+          send_headers(req, env[:headers])
           headers_sent = true
         end
         done = res < maxlen
@@ -211,7 +243,7 @@ module TP2
         return if done
       end
     ensure
-      @machine.close(fd) if fd
+      @machine.close_async(fd) if fd
     end
 
     def close
@@ -224,20 +256,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 +290,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 +335,17 @@ 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)
+      lines << @env[:server_headers] if @env[:server_headers]
       headers.each do |k, v|
         next if k =~ INTERNAL_HEADER_REGEXP
 
@@ -329,11 +355,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 +371,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/request_extensions.rb

@@ -11,4 +11,8 @@ class Qeweney::Request
 
     adapter.respond_with_static_file(self, path, opts, cache_headers)
   end
+
+  def set_response_headers(headers)
+    adapter.set_response_headers(headers)
+  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'
 
@@ -9,42 +9,42 @@ module TP2
     PENDING_REQUESTS_GRACE_PERIOD = 0.1
     PENDING_REQUESTS_TIMEOUT_PERIOD = 5
 
-    def self.rack_app(opts)
-      raise 'Missing app location' if !opts[:app_location]
+    def self.rack_app(env)
+      raise 'Missing app location' if !env[:app_location]
 
-      TP2::RackAdapter.load(opts[:app_location])
+      TP2::RackAdapter.load(env[:app_location])
     end
 
-    def self.tp2_app(_machine, opts)
-      if opts[:app_location]
-        opts[:logger]&.info(message: 'Loading web app', location: opts[:app_location])
-        require opts[:app_location]
+    def self.tp2_app(_machine, env)
+      if env[:app_location]
+        env[:logger]&.info(message: 'Loading web app', location: env[:app_location])
+        require env[:app_location]
 
-        opts.merge!(TP2.config)
+        env.merge!(TP2.config)
       end
-      opts[:app]
+      env[:app]
     end
 
-    def self.static_app(opts); end
+    def self.static_app(env); end
 
-    def initialize(machine, opts, &app)
+    def initialize(machine, env, &app)
       @machine = machine
-      @opts = opts
-      @app = app || app_from_opts
+      @env = env
+      @app = app || app_from_env
       @server_fds = []
       @accept_fibers = []
     end
 
-    def app_from_opts
-      case @opts[:app_type]
+    def app_from_env
+      case @env[:app_type]
       when nil, :tp2
-        Server.tp2_app(@machine, @opts)
+        Server.tp2_app(@machine, @env)
       when :rack
-        Server.rack_app(@opts)
+        Server.rack_app(@env)
       when :static
-        Server.static_app(@opts)
+        Server.static_app(@env)
       else
-        raise "Invalid app type #{@opts[:app_type].inspect}"
+        raise "Invalid app type #{@env[:app_type].inspect}"
       end
     end
 
@@ -65,14 +65,15 @@ module TP2
         @accept_fibers << @machine.spin { accept_incoming(fd) }
       end
       bind_string = bind_info.map { it.join(':') }.join(', ')
-      @opts[:logger]&.info(message: "Listening on #{bind_string}")
+      @env[:logger]&.info(message: "Listening on #{bind_string}")
+      setup_server_extensions
 
       # map fibers
       @connection_fiber_map = {}
     end
 
     def get_bind_entries
-      bind = @opts[:bind]
+      bind = @env[:bind]
       case bind
       when Array
         bind.map { bind_info(it) }
@@ -98,9 +99,33 @@ module TP2
       fd
     end
 
+    def setup_server_extensions
+      extensions = @env[:server_extensions]
+      return if !extensions
+
+      server_name = extensions[:name]
+      if extensions[:date]
+        @date_header_fiber = @machine.spin {
+          @machine.periodically(1) { update_server_headers(server_name) }
+        }
+        update_server_headers(server_name)
+      elsif server_name
+        @env[:server_headers] = "Server: #{server_name}\r\n"
+      end
+    end
+
+    def update_server_headers(server_name)
+      @env[:server_date] = Time.now
+      if server_name
+        @env[:server_headers] = "Server: #{server_name}\r\nDate: #{@env[:server_date].httpdate}\r\n"
+      else
+        @env[:server_headers] = "Date: #{Time.now.httpdate}\r\n"
+      end
+    end
+
     def accept_incoming(listen_fd)
       @machine.accept_each(listen_fd) do |fd|
-        conn = HTTP1Connection.new(@machine, fd, @opts, &@app)
+        conn = Connection.new(self, @machine, fd, @env, &@app)
         f = @machine.spin(conn) do
           it.run
         ensure
@@ -121,7 +146,7 @@ module TP2
     end
 
     def graceful_shutdown
-      @opts[:logger]&.info(message: 'Shutting down gracefully...')
+      @env[:logger]&.info(message: 'Shutting down gracefully...')
 
       # stop listening
       close_all_server_fds

data/lib/tp2/version.rb

@@ -1,3 +1,3 @@
 module TP2
-  VERSION = '0.15'
+  VERSION = '0.17'
 end

data/lib/tp2.rb

@@ -24,36 +24,35 @@ module TP2
   )
 
   class << self
-    def run(opts = nil, &app)
+    def run(env = {}, &app)
       if @in_run
-        @config = opts if opts
-        @config[:app] = app if app
+        @env = env
+        @env[:app] = app if app
         return
       end
 
-      opts ||= @config || {}
+      env ||= @env || {}
       begin
         @in_run = true
-        machine = opts[:machine] || UM.new
-        machine.puts(opts[:banner]) if opts[:banner]
+        machine = env[:machine] || UM.new
+        machine.puts(env[:banner]) if env[:banner]
 
-        opts[:logger]&.info(message: "Running TP2 #{TP2::VERSION}, UringMachine #{UM::VERSION}, Ruby #{RUBY_VERSION}")
+        env[:logger]&.info(message: "Running TP2 #{TP2::VERSION}, UringMachine #{UM::VERSION}, Ruby #{RUBY_VERSION}")
 
-        server = Server.new(machine, opts, &app)
+        server = Server.new(machine, env, &app)
 
         setup_signal_handling(machine, Fiber.current)
-        app.ready if app.respond_to?(:ready)
         server.run
       ensure
         @in_run = false
       end
     end
 
-    def config(opts = nil, &app)
-      return @config if !opts && !app
+    def env(env = nil, &app)
+      return @env if !env && !app
 
-      @config = opts || {}
-      @config[:app] = app if app
+      @env = env || {}
+      @env[:app] = app if app
     end
 
     private

data/test/bm_connection.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require 'bundler/inline'
+
+gemfile {
+  gem 'tp2', path: '..'
+  gem 'benchmark'
+  gem 'benchmark-ips'
+  gem 'vernier'
+}
+
+require 'vernier'
+require 'securerandom'
+require 'benchmark/ips'
+
+class ConnectionTester
+  def make_socket_pair
+    port = SecureRandom.random_number(10000..40000)
+    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 = []
+    @app = ->(req) { req.respond('foobar', 'Content-Type' => 'text/plain') }
+    @adapter = TP2::Connection.new(nil, @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 run_request
+    write_http_request "GET / HTTP/1.1\r\n\r\n", false
+    @adapter.serve_request
+    read_client_side(len = 65536)
+  end
+end
+
+tester = ConnectionTester.new
+tester.setup
+
+# puts '*' * 40
+# p tester.run_request
+# p tester.run_request
+# puts '*' * 40
+
+# Vernier.profile(out: "profile.vernier.json") {
+#   100000.times { tester.run_request }
+# }
+
+Benchmark.ips do |x|
+  x.report('request') { tester.run_request }
+  x.compare!(order: :baseline)
+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}

@@ -1,10 +1,11 @@
 # frozen_string_literal: true
 
 require_relative './helper'
+require 'securerandom'
 
-class HTTP1ConnectionTest < Minitest::Test
+class ConnectionTest < Minitest::Test
   def make_socket_pair
-    port = 10000 + rand(30000)
+    port = SecureRandom.random_number(10000..40000)
     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)
@@ -25,7 +26,8 @@ class HTTP1ConnectionTest < Minitest::Test
     @reqs = []
     @hook = nil
     @app = ->(req) { @hook&.call(req); @reqs << req }
-    @adapter = TP2::HTTP1Connection.new(@machine, @s_fd, {}, &@app)
+    @env = {}
+    @adapter = TP2::Connection.new(nil, @machine, @s_fd, @env, &@app)
   end
 
   def teardown
@@ -48,8 +50,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 +83,7 @@ class HTTP1ConnectionTest < Minitest::Test
     assert_equal({
       ':method'   => 'get',
       ':path'     => '/',
-      ':protocol' => 'http/1.0'
+      ':protocol' => 'http/1.1'
     }, headers)
   end
 
@@ -196,34 +221,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 +275,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 +304,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 +343,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 +493,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
@@ -567,4 +522,64 @@ class HTTP1ConnectionTest < Minitest::Test
     expected = "HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\n\r\n3\r\nfoo\r\n3\r\nbar\r\n0\r\n\r\n"
     assert_equal expected, response
   end
+
+  def test_connection_server_headers
+    @env[:server_headers] = "Server: TP2\r\n"
+
+    @hook = ->(req) do
+      req.respond('foo')
+    end
+
+    write_client_side("GET / HTTP/1.1\r\n\r\n")
+    @adapter.serve_request
+    response = read_client_side(65536)
+    expected = "HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\nServer: TP2\r\n\r\n3\r\nfoo\r\n0\r\n\r\n"
+    assert_equal expected, response
+
+    @env[:server_headers] = "Server: TP3\r\n"
+
+    write_client_side("GET / HTTP/1.1\r\n\r\n")
+    @adapter.serve_request
+    response = read_client_side(65536)
+    expected = "HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\nServer: TP3\r\n\r\n3\r\nfoo\r\n0\r\n\r\n"
+    assert_equal expected, response
+  end
+
+  def test_set_response_headers
+    @hook = ->(req) {
+      req.set_response_headers("Set-Cookie" => 'foo=bar')
+      req.respond('foo')
+    }
+
+    write_client_side("GET / HTTP/1.1\r\n\r\n")
+    @adapter.serve_request
+    response = read_client_side(65536)
+    expected = "HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\nSet-Cookie: foo=bar\r\n\r\n3\r\nfoo\r\n0\r\n\r\n"
+    assert_equal expected, response
+
+    @hook = ->(req) {
+      req.set_response_headers("Set-Cookie" => 'foo=bar')
+      req.respond('foo', 'Content-Type' => 'text/plain')
+    }
+
+    write_client_side("GET / HTTP/1.1\r\n\r\n")
+    @adapter.serve_request
+    response = read_client_side(65536)
+    expected = "HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\nSet-Cookie: foo=bar\r\nContent-Type: text/plain\r\n\r\n3\r\nfoo\r\n0\r\n\r\n"
+    assert_equal expected, response
+  end
+
+  def test_set_response_headers
+    @hook = ->(req) {
+      req.set_response_headers("Set-Cookie" => 'foo=bar')
+      req.set_response_headers("Foo" => 'bar')
+      req.respond('foo', 'Content-Type' => 'text/plain')
+    }
+
+    write_client_side("GET / HTTP/1.1\r\n\r\n")
+    @adapter.serve_request
+    response = read_client_side(65536)
+    expected = "HTTP/1.1 200\r\nTransfer-Encoding: chunked\r\nSet-Cookie: foo=bar\r\nFoo: bar\r\nContent-Type: text/plain\r\n\r\n3\r\nfoo\r\n0\r\n\r\n"
+    assert_equal expected, response
+  end
 end

data/test/test_server.rb

@@ -22,11 +22,11 @@ class ServerTest < Minitest::Test
   class STOP < StandardError
   end
 
-  def setup
+  def setup(opts = {})
     @machine = UM.new
     @port = 10000 + rand(30000)
-    @opts = { bind: "127.0.0.1:#{@port}" }
-    @server = TP2::Server.new(@machine, @opts) { @app&.call(it) }
+    @env = { bind: "127.0.0.1:#{@port}" }.merge(opts)
+    @server = TP2::Server.new(@machine, @env) { @app&.call(it) }
     @f_server = @machine.spin { run_server }
 
     # let server spin and listen to incoming connections
@@ -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
 
@@ -83,8 +94,10 @@ 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"
 
+    @machine.sleep(0.1)
     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 +117,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 +156,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 +169,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
@@ -266,7 +279,7 @@ class ServerTest < Minitest::Test
   def test_logging
     skip
     reqs = []
-    @opts[:logger] = TestLogger.new
+    @env[:logger] = TestLogger.new
     @app = ->(req) { reqs << req; req.respond('Hello, world!', {}) }
 
     write_http_request "GET / HTTP/1.0\r\n\r\n"
@@ -274,10 +287,68 @@ class ServerTest < Minitest::Test
     expected = "HTTP/1.1 200\r\nContent-Length: 13\r\n\r\nHello, world!"
     assert_equal(expected, response)
 
-    entries = @opts[:logger].entries
+    entries = @env[:logger].entries
     assert_equal 1, entries.size
     assert_equal 1, reqs.size
 
     assert_equal reqs.first, entries.first[:request]
   end
+
+  def test_server_headers
+    @env[:server_headers] = "Server: Tipi\r\n"
+
+    @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\nServer: Tipi\r\n\r\nd\r\nHello, world!\r\n0\r\n\r\n"
+    assert_equal(expected, response)
+  end
+
+  def test_server_headers_date
+    setup({ server_extensions: { date: true } })
+    @machine.sleep(0.1)
+    assert_kind_of Time, @env[:server_date]
+
+    @app = ->(req) {
+      req.respond('foo', {})
+    }
+
+    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\nDate: #{@env[:server_date].httpdate}\r\n\r\n3\r\nfoo\r\n0\r\n\r\n"
+    assert_equal(expected, response)
+  end
+
+  def test_server_headers_date_and_server_name
+    setup({ server_extensions: { date: true, name: 'Foo' } })
+    @machine.sleep(0.1)
+    assert_kind_of Time, @env[:server_date]
+
+    @app = ->(req) {
+      req.respond('foo', {})
+    }
+
+    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\nServer: Foo\r\nDate: #{@env[:server_date].httpdate}\r\n\r\n3\r\nfoo\r\n0\r\n\r\n"
+    assert_equal(expected, response)
+  end
+
+  def test_server_headers_server_name
+    setup({ server_extensions: { name: 'Bar' } })
+    @machine.sleep(0.1)
+    assert_nil @env[:server_date]
+
+    @app = ->(req) {
+      req.respond('foo', {})
+    }
+
+    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\nServer: Bar\r\n\r\n3\r\nfoo\r\n0\r\n\r\n"
+    assert_equal(expected, response)
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tp2
 version: !ruby/object:Gem::Version
-  version: '0.15'
+  version: '0.17'
 platform: ruby
 authors:
 - Sharon Rosner
@@ -71,16 +71,19 @@ 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
 - lib/tp2/server.rb
 - lib/tp2/version.rb
+- test/bm_connection.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 +110,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 3.7.0.dev
 specification_version: 4
 summary: Experimental HTTP/1 server for UringMachine
 test_files: []