biryani 0.0.14 → 0.0.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 96b9dc1294ce1840c02e6cf1700b1ebae51409b586dffd25b7df814acdd65034
-  data.tar.gz: 66d417773c04e090101661650748415566e9f4ca0f91ff95720b2cb7f8668f7b
+  metadata.gz: 1a92a6898bad6aab7de417a5eff15af74a99a41d33e380fd93447f8b15d77ba5
+  data.tar.gz: 473061a7d89df0b3956bc396a29102f76f6205b7e3795a452244f30f1f84da3e
 SHA512:
-  metadata.gz: '079d3ab7c12394a9fd340757c5f076cbe937bd1f1a1e60cd24e98f7535526e320189a35f6baa2a5dab3c621b467fec52566e2cfec43a9b994d9f4e5c9dd818cf'
-  data.tar.gz: 7eed1c453cef71438ee5e625bd7b954c38c8cb4aa417db79c00894bf00e4f1f500a759a16d8c6ea58d3c90f273b5bcbbbefbe3a2de1059367b087095921aaec8
+  metadata.gz: c76936ffedc6058d29c946a526217f47840248b0e7a1042a2fee816a3488f79aa2a848621f3c443d5d58eed16df8c3f013906fc3f34730eb71a24da6b2022287
+  data.tar.gz: e9b25fdf0d6d1481d12faae276941d80d8910361e0916f22d617b059982c3a56cc7310579e63c0b0466797181b2976eb4213b9650b613be55717f7d05060c250

data/.ruby-version

@@ -1 +1 @@
-4.0.2
+4.1-dev

data/Gemfile

@@ -1,9 +1,12 @@
 source 'https://rubygems.org'
 
 group :development do
+  gem 'ractor-sharing'
   gem 'rake', '13.3.1'
   gem 'rspec'
   gem 'rubocop', '1.82.1'
+  gem 'sqlite3'
+  gem 'webrick'
 end
 
 gemspec

data/conformance/server_spec.rb

@@ -4,7 +4,7 @@ RSpec.describe Server do
   before do
     @tcpserver = TCPServer.open(PORT)
 
-    Ractor.new(@tcpserver) do |socket|
+    r = Ractor.new do
       server = Server.new(
         Ractor.shareable_proc do |_, res|
           res.status = 200
@@ -12,8 +12,9 @@ RSpec.describe Server do
         end
       )
 
-      server.run(socket)
+      server.run(Ractor.receive)
     end
+    r.send(@tcpserver.dup, move: true)
   end
 
   let(:junit_report_file_path) do

data/example/README.md

@@ -0,0 +1,30 @@
+## Usage
+
+The examples run as follows:
+
+```bash
+$ cd /path/to/biryani/example/
+
+$ bundle exec ruby hello_world.rb
+
+$ curl --http2-prior-knowledge http://localhost:8888
+Hello, world!
+```
+
+Web browsers do NOT support h2c. If you access the examples from a browser, you could use [nginx](https://nginx.org/en/docs/stream/ngx_stream_core_module.html) as a TLS termination proxy.
+
+To terminate TLS, `nginx` requires PEM files of certificate and private key. For example, you could generate a locally-trusted certificate, `server.crt` and `server.key`, using [mkcert](https://github.com/FiloSottile/mkcert).
+
+```bash
+$ mkcert -install
+
+$ mkcert -cert-file server.crt -key-file server.key localhost 127.0.0.1
+```
+
+Run `nginx` with [nginx.conf](nginx.conf) in this directory.
+
+```bash
+$ nginx -p "$PWD" -c nginx.conf -g 'daemon off; pid /dev/null; error_log stderr;'
+```
+
+Then open https://localhost:4433 in your browser.

data/example/echo.rb

@@ -22,5 +22,5 @@ server = Biryani::Server.new(
 )
 server.run(socket)
 
-# $ bundle exec ruby example/echo.rb
+# $ bundle exec ruby echo.rb
 # $ curl -v --http2-prior-knowledge http://localhost:8888 -X POST -d hi

data/example/hello_world.rb

@@ -18,5 +18,5 @@ server = Biryani::Server.new(
 )
 server.run(socket)
 
-# $ bundle exec ruby example/hello_world.rb
+# $ bundle exec ruby hello_world.rb
 # $ curl -v --http2-prior-knowledge http://localhost:8888

data/example/kv_store.rb

@@ -0,0 +1,112 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH << "#{__dir__}/../lib"
+
+require 'json'
+require 'socket'
+require 'ractor/keylockhash'
+require 'ractor/lockvar'
+require 'biryani'
+
+# `Ractor::LockVar` and `Ractor::KeyLockHash` (ko1/ractor-sharing) are shareable, so every stream Ractor uses NEXT_ID and STORE directly.
+#
+#   +-- stream Ractor (POST /) --------------+         +-- NEXT_ID ---------------------+
+#   |  NEXT_ID.increment --------------------+-------->|  Ractor::LockVar               |
+#   |  STORE[id] = value --------------------+----+    +--------------------------------+
+#   +----------------------------------------+    |
+#                                                 |    +-- STORE -----------------------+
+#                                                 +--->|  Ractor::KeyLockHash           |
+#                                                 |    |  1 => "hoge"                   |
+#   +-- stream Ractor (PUT /:id) ------------+    |    |  2 => "piyo"                   |
+#   |  STORE.update(id) { ... } -------------+----+    |                                |
+#   +----------------------------------------+         +--------------------------------+
+NEXT_ID = Ractor::LockVar.new(0) # plays the role of AUTOINCREMENT in SQL
+STORE = Ractor::KeyLockHash.new
+
+module App
+  # @param req [Biryani::HTTP::Request]
+  # @param res [Biryani::HTTP::Response]
+  def self.call(req, res)
+    case req.method
+    when 'POST'
+      do_post(req.content, res)
+    when 'GET'
+      req.uri.path == '/' ? do_list(res) : do_get(item_id(req), res)
+    when 'PUT'
+      do_put(item_id(req), req.content, res)
+    when 'DELETE'
+      do_delete(item_id(req), res)
+    else
+      respond(res, 405, { error: 'HTTP Method not allowed' })
+    end
+  end
+
+  def self.do_post(value, res)
+    id = NEXT_ID.increment
+    STORE[id] = value
+    respond(res, 201, { status: 'created', id: id })
+  end
+
+  def self.do_list(res)
+    items = STORE.to_h.compact.sort.map { |id, value| { id: id, value: value } }
+    respond(res, 200, items)
+  end
+
+  def self.do_get(id, res)
+    value = STORE[id]
+    return respond(res, 404, { error: 'not found' }) if value.nil?
+
+    respond(res, 200, { id: id, value: value })
+  end
+
+  def self.do_put(id, value, res)
+    updated = false
+    STORE.update(id) do |old|
+      next if old.nil?
+
+      updated = true
+      value
+    end
+    return respond(res, 404, { error: 'not found' }) unless updated
+
+    respond(res, 200, { status: 'ok' })
+  end
+
+  def self.do_delete(id, res)
+    return respond(res, 404, { error: 'not found' }) if STORE.delete(id).nil?
+
+    respond(res, 200, { status: 'ok' })
+  end
+
+  # @param req [Biryani::HTTP::Request]
+  #
+  # @return [Integer]
+  def self.item_id(req)
+    req.uri.path.split('/').reject(&:empty?).first.to_i
+  end
+
+  def self.respond(res, status, body)
+    res.status = status
+    res.fields['content-type'] = 'application/json'
+    res.content = JSON.generate(body)
+  end
+end
+
+port = ARGV[0] || 8888
+socket = TCPServer.new(port)
+
+server = Biryani::Server.new(
+  # @param req [Biryani::HTTP::Request]
+  # @param res [Biryani::HTTP::Response]
+  Ractor.shareable_proc do |req, res|
+    App.call(req, res)
+  end
+)
+server.run(socket)
+
+# $ bundle exec ruby kv_store.rb
+# $ curl -v --http2-prior-knowledge http://localhost:8888 -X POST -d 'hoge'
+# $ curl -v --http2-prior-knowledge http://localhost:8888/
+# $ curl -v --http2-prior-knowledge http://localhost:8888/1 -X PUT -d 'piyo'
+# $ curl -v --http2-prior-knowledge http://localhost:8888/1
+# $ curl -v --http2-prior-knowledge http://localhost:8888/1 -X DELETE

data/example/nginx.conf

@@ -0,0 +1,11 @@
+events {}
+
+stream {
+  server {
+    listen 127.0.0.1:4433 ssl;
+    ssl_certificate     server.crt;
+    ssl_certificate_key server.key;
+    ssl_alpn h2;
+    proxy_pass 127.0.0.1:8888;
+  }
+}

data/example/raise_error.rb

@@ -15,5 +15,5 @@ server = Biryani::Server.new(
 )
 server.run(socket)
 
-# $ bundle exec ruby example/raise_error.rb
+# $ bundle exec ruby raise_error.rb
 # $ curl -v --http2-prior-knowledge http://localhost:8888

data/example/sqlite3.rb

@@ -0,0 +1,171 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH << "#{__dir__}/../lib"
+
+require 'json'
+require 'socket'
+require 'sqlite3'
+require 'biryani'
+
+# `sqlite3` is not Ractor-safe, so the main Ractor owns the database, and handlers send queries to it through DB_PORT.
+#
+#   +-- main Ractor ---------------------+           +-- stream Ractor (1 Ractor / stream) ------------+
+#   |                                    |           |                                                 |
+#   |  +-- DB -----------------------+   |           |  +-- handler -------------------------------+   |
+#   |  | SQLite3::Database           |   |           |  | App.call(req, res)                       |   |
+#   |  +-----------------------------+   |           |  |   DB.execute(sql, *binds)                |   |
+#   |      ^                             |           |  |     |                                    |   |
+#   |      | sql                         |           |  |     | sql                                |   |
+#   |      |                             |           |  |     v                                    |   |
+#   |    DB_PORT.receive <---------------+-----------+--+---- DB_PORT.send                         |   |
+#   |    reply.send ---------------------+-----------+--+---> reply.receive                        |   |
+#   |                                    |           |  +------------------------------------------+   |
+#   |  r.send(socket, move: true)        |           |                                                 |
+#   +----+-------------------------------+           +-------------------------------------------------+
+#        |                                                                                          ^
+#        v                                                                                          |
+#   +-- server Ractor ----------------------+       +-- connection Ractor (1 Ractor / connection) --+--+
+#   |  server.run(socket)                   |       |  Stream.new(tx, stream_id, proc)              |  |
+#   |    r.send(io, move: true) ------------+------>|    Ractor.new(tx, stream_id, proc) -----------+  |
+#   +---------------------------------------+       +--------------------------------------------------+
+DB_PORT = Ractor::Port.new
+
+module DB
+  class Error < StandardError; end
+
+  # @param sql [String]
+  # @param binds [Array<Object>]
+  #
+  # @raise [DB::Error] if the query fails on the main Ractor
+  #
+  # @return [Array<Hash>] rows
+  # @return [Integer] changes
+  def self.execute(sql, *binds)
+    reply = Ractor::Port.new
+    DB_PORT.send([sql, binds, reply])
+    case reply.receive
+    in [:ok, rows, changes]
+      [rows, changes]
+    in [:error, klass, message]
+      raise Error, "#{klass}: #{message}"
+    end
+  end
+
+  # @param path [String]
+  def self.serve(path)
+    db = SQLite3::Database.new(path)
+    db.results_as_hash = true
+    db.execute('CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY, name TEXT);')
+
+    loop do
+      sql, binds, reply = DB_PORT.receive
+      begin
+        rows = db.execute(sql, binds)
+        reply.send([:ok, rows, db.changes])
+      rescue StandardError => e
+        reply.send([:error, e.class.name, e.message])
+      end
+    end
+  end
+end
+
+module App
+  # @param req [Biryani::HTTP::Request]
+  # @param res [Biryani::HTTP::Response]
+  def self.call(req, res)
+    case req.method
+    when 'POST'
+      do_post(req, res)
+    when 'GET'
+      do_get(req, res)
+    when 'PUT'
+      do_put(req, res)
+    when 'DELETE'
+      do_delete(req, res)
+    else
+      respond(res, 405, { error: 'HTTP Method not allowed' })
+    end
+  end
+
+  def self.do_post(req, res)
+    name = parse_name(req.content)
+    return respond(res, 400, { error: 'not found `name`' }) if name.nil?
+
+    DB.execute('INSERT INTO users (name) VALUES (?);', name)
+    respond(res, 201, { status: 'created' })
+  end
+
+  def self.do_get(req, res)
+    if req.uri.path == '/'
+      users, = DB.execute('SELECT id, name FROM users ORDER BY id;')
+      return respond(res, 200, users)
+    end
+
+    users, = DB.execute('SELECT id, name FROM users WHERE id = ?;', user_id(req))
+    return respond(res, 404, { error: 'not found' }) if users.empty?
+
+    respond(res, 200, users.first)
+  end
+
+  def self.do_put(req, res)
+    name = parse_name(req.content)
+    return respond(res, 400, { error: 'not found `name`' }) if name.nil?
+
+    _, changes = DB.execute('UPDATE users SET name = ? WHERE id = ?;', name, user_id(req))
+    return respond(res, 404, { error: 'not found' }) if changes.zero?
+
+    respond(res, 200, { status: 'ok' })
+  end
+
+  def self.do_delete(req, res)
+    _, changes = DB.execute('DELETE FROM users WHERE id = ?;', user_id(req))
+    return respond(res, 404, { error: 'not found' }) if changes.zero?
+
+    respond(res, 200, { status: 'ok' })
+  end
+
+  # @param content [String]
+  #
+  # @return [String, nil]
+  def self.parse_name(content)
+    user = JSON.parse(content)
+    user['name']&.to_s if user.is_a?(Hash)
+  rescue JSON::ParserError
+    nil
+  end
+
+  # @param req [Biryani::HTTP::Request]
+  #
+  # @return [Integer]
+  def self.user_id(req)
+    req.uri.path.split('/').reject(&:empty?).first.to_i
+  end
+
+  def self.respond(res, status, body)
+    res.status = status
+    res.fields['content-type'] = 'application/json'
+    res.content = JSON.generate(body)
+  end
+end
+
+port = ARGV[0] || 8888
+path = ARGV[1] || '/tmp/sqlite3.db'
+socket = TCPServer.new(port)
+
+server = Biryani::Server.new(
+  # @param req [Biryani::HTTP::Request]
+  # @param res [Biryani::HTTP::Response]
+  Ractor.shareable_proc do |req, res|
+    App.call(req, res)
+  end
+)
+r = Ractor.new(server) { |s| s.run(Ractor.receive) }
+r.send(socket, move: true)
+DB.serve(path)
+
+# $ bundle exec ruby sqlite3.rb
+# $ curl -v --http2-prior-knowledge http://localhost:8888 -X POST -H "Content-Type: application/json" -d '{"name":"Alice","age":18}'
+# $ curl -v --http2-prior-knowledge http://localhost:8888/
+# $ curl -v --http2-prior-knowledge http://localhost:8888/1 -X PUT -H "Content-Type: application/json" -d '{"name":"Bob","age":20}'
+# $ curl -v --http2-prior-knowledge http://localhost:8888/
+# $ curl -v --http2-prior-knowledge http://localhost:8888/1 -X DELETE

data/example/tiles/index.html

@@ -0,0 +1,47 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <title>svg tiles</title>
+    <style>
+      #tiles {
+        display: grid;
+        grid-template-columns: repeat(15, 32px);
+      }
+      #tiles img {
+        display: block;
+        width: 32px;
+        height: 32px;
+      }
+    </style>
+  </head>
+  <body>
+    <p>
+      <a href="?latency=0">0 ms</a> | <a href="?latency=100">100 ms</a> |
+      <a href="?latency=500">500 ms</a>
+    </p>
+    <p id="result">loading...</p>
+    <div id="tiles"></div>
+    <script>
+      const GRID = 15;
+      const latency =
+        new URLSearchParams(location.search).get("latency") || "0";
+      const tiles = document.getElementById("tiles");
+      for (let y = 0; y < GRID; y++) {
+        for (let x = 0; x < GRID; x++) {
+          const img = document.createElement("img");
+          img.src = `/tile/${x}/${y}.svg?latency=${latency}`;
+          tiles.appendChild(img);
+        }
+      }
+
+      window.addEventListener("load", () => {
+        const protocol =
+          performance.getEntriesByType("navigation")[0].nextHopProtocol;
+        const time = Math.round(performance.now());
+        document.getElementById("result").textContent =
+          `${protocol}, latency: ${latency} ms / tile, loaded in ${time} ms`;
+      });
+    </script>
+  </body>
+</html>

data/example/tiles.rb

@@ -0,0 +1,85 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH << "#{__dir__}/../lib"
+
+require 'optparse'
+require 'uri'
+
+INDEX_HTML = File.read("#{__dir__}/tiles/index.html").freeze
+TILE_SIZE = 32
+
+module App
+  def self.call(path, query)
+    case path
+    when '/', '/index.html'
+      [200, 'text/html; charset=utf-8', INDEX_HTML]
+    when %r{^/tile/(\d+)/(\d+)\.svg$}
+      do_tile(Regexp.last_match(1).to_i, Regexp.last_match(2).to_i, latency(query))
+    else
+      [404, 'text/plain', 'not found']
+    end
+  end
+
+  def self.do_tile(x, y, latency)
+    sleep(latency / 1000.0)
+    hue = (x + y) * 12 % 360
+    svg = <<~SVG
+      <svg xmlns="http://www.w3.org/2000/svg" width="#{TILE_SIZE}" height="#{TILE_SIZE}">
+        <rect width="#{TILE_SIZE}" height="#{TILE_SIZE}" fill="hsl(#{hue}, 70%, 70%)"/>
+      </svg>
+    SVG
+    [200, 'image/svg+xml', svg]
+  end
+
+  def self.latency(query)
+    query = URI.decode_www_form(query || '').to_h
+    query['latency'].to_i.clamp(0, 500)
+  end
+end
+
+http1 = false
+opt = OptionParser.new
+opt.banner = 'Usage: tiles.rb [--http2 | --http1.1] [port]'
+opt.on('--http2', 'serve over HTTP/2 with biryani (default)') { http1 = false }
+opt.on('--http1.1', 'serve over HTTP/1.1 with WEBrick') { http1 = true }
+opt.parse!
+port = ARGV[0] || 8888
+
+if http1
+  require 'webrick'
+
+  server = WEBrick::HTTPServer.new(Port: port)
+  server.mount_proc('/') do |req, res|
+    status, content_type, content = App.call(req.path, req.query_string)
+    res.status = status
+    res['content-type'] = content_type
+    res['cache-control'] = 'no-store'
+    res.body = content
+  end
+  trap('INT') { server.shutdown }
+  server.start
+else
+  require 'socket'
+  require 'biryani'
+
+  socket = TCPServer.new(port)
+  server = Biryani::Server.new(
+    # @param req [Biryani::HTTP::Request]
+    # @param res [Biryani::HTTP::Response]
+    Ractor.shareable_proc do |req, res|
+      status, content_type, content = App.call(req.uri.path, req.uri.query)
+      res.status = status
+      res.fields['content-type'] = content_type
+      res.content = content
+      res.fields['cache-control'] = 'no-store'
+    end
+  )
+  server.run(socket)
+end
+
+# $ bundle exec ruby tiles.rb --http1.1 8889
+# $ open http://localhost:8889/?latency=500
+#
+# $ bundle exec ruby tiles.rb --http2
+# $ nginx -p "$PWD" -c nginx.conf -g 'daemon off; pid /dev/null; error_log stderr;'
+# $ open https://localhost:4433/?latency=500

data/lib/biryani/connection.rb

@@ -14,8 +14,10 @@ module Biryani
     CONNECTION_PREFACE_LENGTH = CONNECTION_PREFACE.length
     DEFAULT_HEADER_TABLE_SIZE = 4_096
     INITIAL_CONNECTION_WINDOW_SIZE = 65_535
+    LINGER_TIMEOUT = 5
 
-    private_constant :CONNECTION_PREFACE, :CONNECTION_PREFACE_LENGTH, :DEFAULT_HEADER_TABLE_SIZE, :INITIAL_CONNECTION_WINDOW_SIZE
+    private_constant :CONNECTION_PREFACE, :CONNECTION_PREFACE_LENGTH, :DEFAULT_HEADER_TABLE_SIZE, :INITIAL_CONNECTION_WINDOW_SIZE,
+                     :LINGER_TIMEOUT
     Ractor.make_shareable(CONNECTION_PREFACE)
     Ractor.make_shareable(CONNECTION_PREFACE_LENGTH)
 
@@ -47,32 +49,33 @@ module Biryani
 
       recv_loop(io.clone)
       select_loop(io)
+    rescue *PEER_CLOSED_ERRORS
+      # peer has already closed the connection
     rescue StandardError => e
       puts e.backtrace
-      self.class.do_send(io, Frame::Goaway.new(@streams_ctx.last_stream_id, ErrorCode::INTERNAL_ERROR, 'internal error'), true)
+      Biryani.ignore_peer_closed do
+        self.class.do_send(io, Frame::Goaway.new(@streams_ctx.last_stream_id, ErrorCode::INTERNAL_ERROR, 'internal error'), true)
+      end
     ensure
-      io.close_write
+      Biryani.ignore_peer_closed { io.close_write }
     end
 
     # @param io [IO]
     def recv_loop(io)
-      Ractor.new(io, @port) do |io_, port_|
-        loop do
-          obj = Frame.read(io_)
-          if obj.nil?
-            port_.send(:eof, move: true)
-            break
-          end
-
-          port_.send([:frame, obj], move: true)
-        end
+      r = Ractor.new(@port) do |port_|
+        io_ = Ractor.receive
+        Connection.recv_frames(io_, port_)
+      ensure
+        Biryani.ignore_peer_closed { io_&.close }
       end
+      r.send(io, move: true)
     end
 
     # @param io [IO]
     def select_loop(io)
       loop do
-        break if @recv_done && @streams_ctx.empty?
+        # After EOF, no frames arrive from the peer, so only half_closed_remote streams can still progress: by the handler's response.
+        break if closed? || (@recv_done && @streams_ctx.none_half_closed_remote?)
 
         case @port.receive
         in :eof
@@ -82,8 +85,6 @@ module Biryani
         in [:response, res, stream_id]
           handle_response(io, res, stream_id)
         end
-
-        break if closed?
       end
     end
 
@@ -148,7 +149,8 @@ module Biryani
         return [] if obj.nil?
 
         settings_ack = obj
-        [settings_ack]
+        max_frame_size = @peer_settings[SettingsID::SETTINGS_MAX_FRAME_SIZE]
+        [settings_ack] + @data_buffer.take!(@send_window, @streams_ctx, max_frame_size)
       when FrameType::PING
         obj = self.class.handle_ping(frame)
         return [] if obj.nil?
@@ -185,7 +187,7 @@ module Biryani
       return [ConnectionError.new(ErrorCode::PROTOCOL_ERROR, "invalid frame type #{format('0x%02x', typ)} for stream identifier #{format('0x%02x', stream_id)}")] \
         if [FrameType::SETTINGS, FrameType::PING, FrameType::GOAWAY].include?(typ)
 
-      max_streams = @peer_settings[SettingsID::SETTINGS_MAX_CONCURRENT_STREAMS]
+      max_streams = @settings[SettingsID::SETTINGS_MAX_CONCURRENT_STREAMS]
       send_initial_window_size = @peer_settings[SettingsID::SETTINGS_INITIAL_WINDOW_SIZE]
       recv_initial_window_size = @settings[SettingsID::SETTINGS_INITIAL_WINDOW_SIZE]
       obj = self.class.transition_stream_state_recv(frame, @streams_ctx, @data_buffer, stream_id, max_streams, send_initial_window_size, recv_initial_window_size)
@@ -235,6 +237,14 @@ module Biryani
     # @param res [HTTP::Response]
     # @param stream_id [Integer]
     def handle_response(io, res, stream_id)
+      ctx = @streams_ctx[stream_id]
+      # The RST_STREAM frame fully terminates the referenced stream and
+      # causes it to enter the "closed" state.  After receiving a RST_STREAM
+      # on a stream, the receiver MUST NOT send additional frames for that
+      # stream, except for PRIORITY.
+      # https://datatracker.ietf.org/doc/html/rfc9113#section-6.4-5
+      return if ctx.nil? || ctx.closed?
+
       fragment, data = self.class.http_response(res, @encoder)
       max_frame_size = @peer_settings[SettingsID::SETTINGS_MAX_FRAME_SIZE]
       self.class.send_headers(io, stream_id, fragment, data.empty?, max_frame_size, @streams_ctx)
@@ -359,14 +369,44 @@ module Biryani
       ConnectionError.new(ErrorCode::PROTOCOL_ERROR, 'invalid connection preface') if s != CONNECTION_PREFACE
     end
 
+    # @param io [IO]
+    # @param port [Ractor::Port]
+    def self.recv_frames(io, port)
+      loop do
+        obj = Frame.read(io)
+        break if obj.nil?
+
+        port.send([:frame, obj], move: true)
+      rescue Ractor::ClosedError
+        # the connection has finished before the peer closes
+        return linger(io)
+      end
+
+      port.send(:eof, move: true)
+    rescue Ractor::ClosedError
+      # the connection has finished after the peer closes
+    end
+
+    # Lingering close: discard incoming data until EOF so that close does not send RST.
+    #
+    # @param io [IO]
+    def self.linger(io)
+      Timeout.timeout(LINGER_TIMEOUT) do
+        loop { io.readpartial(16_384) }
+      end
+    rescue *PEER_CLOSED_ERRORS, Timeout::Error
+      # EOF, timeout, connection reset, etc.
+    end
+
     # @param stream_id [Integer]
     # @param data [String]
     # @param recv_window [Window]
     # @param streams_ctx [StreamsContext]
     # @param decoder [Decoder]
     #
-    # @return [Array<WindowUpdate>, ConnectionError]
+    # @return [Array<WindowUpdate>, ConnectionError, StreamError]
     # rubocop: disable Metrics/AbcSize
+    # rubocop: disable Metrics/CyclomaticComplexity
     def self.handle_data(stream_id, data, recv_window, streams_ctx, decoder)
       ctx = streams_ctx[stream_id]
       return ConnectionError.new(ErrorCode::FLOW_CONTROL_ERROR, 'DATA Frame length exceeds flow-control window size') \
@@ -374,7 +414,8 @@ module Biryani
 
       ctx.content << data
       if ctx.half_closed_remote?
-        obj = http_request(ctx.fragment, ctx.content, decoder)
+        obj = http_request(stream_id, ctx.fragment, ctx.content, decoder)
+        ctx << nil if Biryani.err?(obj) # terminate the Stream Ractor waiting for a request
         return obj if Biryani.err?(obj)
 
         ctx << obj
@@ -386,16 +427,18 @@ module Biryani
       window_updates
     end
     # rubocop: enable Metrics/AbcSize
+    # rubocop: enable Metrics/CyclomaticComplexity
 
     # @param headers [Headers]
     # @param ctx [StreamContext]
     # @param decoder [Decoder]
     #
-    # @return [nil, ConnectionError]
+    # @return [nil, ConnectionError, StreamError]
     def self.handle_headers(headers, ctx, decoder)
       ctx.fragment << headers.fragment
       if ctx.half_closed_remote?
-        obj = http_request(ctx.fragment, ctx.content, decoder)
+        obj = http_request(headers.stream_id, ctx.fragment, ctx.content, decoder)
+        ctx << nil if Biryani.err?(obj) # terminate the Stream Ractor waiting for a request
         return obj if Biryani.err?(obj)
 
         ctx << obj
@@ -463,21 +506,23 @@ module Biryani
       nil
     end
 
+    # @param stream_id [Integer]
     # @param fragment [String]
     # @param content [String]
     # @param decoder [Decoder]
     #
-    # @return [HTTP::Request, ConnectionError]
-    def self.http_request(fragment, content, decoder)
-      obj = decoder.decode(fragment)
-      return obj if Biryani.err?(obj)
-
-      fields = obj
+    # @return [HTTP::Request, ConnectionError, StreamError]
+    def self.http_request(stream_id, fragment, content, decoder)
+      fields = decoder.decode(fragment)
       builder = HTTP::RequestBuilder.new
-      err = builder.fields(fields)
-      return err unless err.nil?
-
+      builder.fields(fields)
       builder.build(content)
+    rescue HPACK::Error::Error => e
+      # https://datatracker.ietf.org/doc/html/rfc9113#section-4.3-3
+      ConnectionError.new(ErrorCode::COMPRESSION_ERROR, e.message)
+    rescue HTTP::Error::MalformedRequestError => e
+      # https://datatracker.ietf.org/doc/html/rfc9113#section-8.1.1-3
+      StreamError.new(ErrorCode::PROTOCOL_ERROR, stream_id, e.message)
     end
 
     # @param res [HTTP::Response]

data/lib/biryani/frame.rb

@@ -157,10 +157,13 @@ module Biryani
 
       payload_length, f_type, flags, stream_id = read_header(s)
       payload = io.read(payload_length)
-      return ConnectionError.new(ErrorCode::PROTOCOL_ERROR, 'invalid frame') if payload.bytesize != payload_length
+      return ConnectionError.new(ErrorCode::PROTOCOL_ERROR, 'invalid frame') if payload.nil? || payload.bytesize != payload_length
       return Frame::Unknown.new(f_type, flags, stream_id, payload) unless FRAME_MAP.key?(f_type)
 
       FRAME_MAP[f_type].read(payload, flags, stream_id)
+    rescue *PEER_CLOSED_ERRORS
+      # the peer has closed the connection (e.g. ECONNRESET): treat it as EOF
+      nil
     rescue StandardError
       ConnectionError.new(ErrorCode::FRAME_SIZE_ERROR, 'invalid frame')
     end

data/lib/biryani/hpack/decoder.rb

@@ -8,6 +8,8 @@ module Biryani
 
       # @param s [String]
       #
+      # @raise [HPACK::Error::Error]
+      #
       # @return [Array]
       def decode(s)
         Fields.decode(s.force_encoding(Encoding::ASCII_8BIT), @dynamic_table)

data/lib/biryani/hpack/dynamic_table.rb

@@ -51,7 +51,7 @@ module Biryani
       #
       # @return [Array] [name, value]
       def entry_at(index)
-        raise Error::HPACKDecodeError if index.zero? || index > STATIC_TABLE_SIZE + count_entries
+        raise Error::HPACKDecodeError, "invalid index #{index}" if index.zero? || index > STATIC_TABLE_SIZE + count_entries
 
         if index <= STATIC_TABLE_SIZE
           STATIC_TABLE[index - 1]

data/lib/biryani/hpack/field.rb

@@ -215,10 +215,11 @@ module Biryani
       # @return [nil]
       # @return [Integer]
       def self.decode_dynamic_table_size_update(io, cursor, dynamic_table)
-        raise Error::HPACKDecodeError unless cursor.zero? || (io.get_value(:U8, 0) & 0b00100000).positive? && Integer.decode(io, 5, 0)[1] == cursor
+        raise Error::HPACKDecodeError, 'misplaced dynamic table size update' \
+          unless cursor.zero? || (io.get_value(:U8, 0) & 0b00100000).positive? && Integer.decode(io, 5, 0)[1] == cursor
 
         max_size, c = Integer.decode(io, 5, cursor)
-        raise Error::HPACKDecodeError if max_size > dynamic_table.limit
+        raise Error::HPACKDecodeError, 'dynamic table size update exceeds the limit' if max_size > dynamic_table.limit
 
         dynamic_table.chomp!(max_size)
         [nil, c]

data/lib/biryani/hpack/huffman.rb

@@ -550,7 +550,7 @@ module Biryani
         (length * 8).times do |i|
           bits_len += 1
           bits += 1 if (bytes[i / 8] & (1 << 7 - (i % 8))).positive?
-          raise Error::HuffmanDecodeError if bits == EOS
+          raise Error::HuffmanDecodeError, 'EOS in huffman-encoded string' if bits == EOS
 
           if (chr = DECODE_TABLE[[bits, bits_len]])
             res << chr
@@ -560,7 +560,7 @@ module Biryani
             bits <<= 1
           end
         end
-        raise Error::HuffmanDecodeError if bits_len.positive? && bits != (2 << bits_len) - 2 || bits_len >= 8
+        raise Error::HuffmanDecodeError, 'invalid huffman padding' if bits_len.positive? && bits != (2 << bits_len) - 2 || bits_len >= 8
 
         res
       end

data/lib/biryani/hpack/integer.rb

@@ -1,6 +1,10 @@
 module Biryani
   module HPACK
     module Integer
+      # https://datatracker.ietf.org/doc/html/rfc7541#section-7.4
+      MAX_DECODED_INTEGER = (1 << 32) - 1
+      private_constant :MAX_DECODED_INTEGER
+
       # if I < 2^N - 1, encode I on N bits
       # else
       #     encode (2^N - 1) on N bits
@@ -44,10 +48,14 @@ module Biryani
       # @param cursor [Integer]
       # @param n [Integer]
       #
+      # @raise [HPACKDecodeError]
+      #
       # @return [Integer]
       # @return [Integer]
       def self.decode(io, n, cursor)
         limit = (1 << n) - 1
+        raise Error::HPACKDecodeError, 'integer exceeds field block' if cursor >= io.size
+
         h = io.get_value(:U8, cursor)
         return [h & limit, cursor + 1] if (h & limit) != limit
 
@@ -55,8 +63,11 @@ module Biryani
         c = cursor + 1
         i = 0
         loop do
+          raise Error::HPACKDecodeError, 'integer exceeds field block' if c + i >= io.size
+
           byte = io.get_value(:U8, c + i)
           res += (byte & 127) << (i * 7)
+          raise Error::HPACKDecodeError, 'integer overflow' if res > MAX_DECODED_INTEGER
 
           break if (byte & 128).zero?
 

data/lib/biryani/hpack/string.rb

@@ -26,11 +26,18 @@ module Biryani
       # @param io [IO::Buffer]
       # @param cursor [Integer]
       #
+      # @raise [HPACKDecodeError]
+      # @raise [HuffmanDecodeError]
+      #
       # @return [String]
       # @return [Integer]
       def self.decode(io, cursor)
+        raise Error::HPACKDecodeError, 'string exceeds field block' if cursor >= io.size
+
         h = (io.get_value(:U8, cursor) & 0b10000000).positive?
         len, c = Integer.decode(io, 7, cursor)
+        raise Error::HPACKDecodeError, 'string exceeds field block' if c + len > io.size
+
         return [Huffman.decode(io, c, len), c + len] if h
 
         [io.get_string(c, len), c + len]

data/lib/biryani/http/error.rb

@@ -4,7 +4,9 @@ module Biryani
       # Generic error, common for all classes under Biryani::HTTP::Error module.
       class Error < StandardError; end
 
-      class InvalidHTTPResponseError < Error; end
+      class InvalidResponseError < Error; end
+
+      class MalformedRequestError < Error; end
     end
   end
 end

data/lib/biryani/http/request.rb

@@ -25,6 +25,8 @@ module Biryani
     class RequestBuilder
       PSEUDO_HEADER_FIELDS = [':authority', ':method', ':path', ':scheme'].freeze
       Ractor.make_shareable(PSEUDO_HEADER_FIELDS)
+      REQUIRED_PSEUDO_HEADER_FIELDS = [':method', ':path', ':scheme'].freeze
+      Ractor.make_shareable(REQUIRED_PSEUDO_HEADER_FIELDS)
 
       def initialize
         @h = {}
@@ -33,23 +35,21 @@ module Biryani
       # @param name [String]
       # @param value [String]
       #
-      # @return [nil, ConnectioError]
+      # @raise [Error::MalformedRequestError]
       # rubocop: disable Metrics/AbcSize
       # rubocop: disable Metrics/CyclomaticComplexity
       # rubocop: disable Metrics/PerceivedComplexity
       def field(name, value)
-        return ConnectionError.new(ErrorCode::PROTOCOL_ERROR, 'field name has uppercase letter') if name.downcase != name
-        return ConnectionError.new(ErrorCode::PROTOCOL_ERROR, 'unknown pseudo-header field name') if name[0] == ':' && !PSEUDO_HEADER_FIELDS.include?(name)
-        return ConnectionError.new(ErrorCode::PROTOCOL_ERROR, 'appear pseudo-header fields after regular fields') if name[0] == ':' && @h.any? { |name_, _| name_[0] != ':' }
-        return ConnectionError.new(ErrorCode::PROTOCOL_ERROR, 'duplicated pseudo-header fields') if PSEUDO_HEADER_FIELDS.include?(name) && @h.key?(name)
-        return ConnectionError.new(ErrorCode::PROTOCOL_ERROR, "invalid `#{name}` field") if PSEUDO_HEADER_FIELDS.include?(name) && value.empty?
-        return ConnectionError.new(ErrorCode::PROTOCOL_ERROR, 'connection-specific field is forbidden') if name == 'connection'
-        return ConnectionError.new(ErrorCode::PROTOCOL_ERROR, '`TE` field has a value other than `trailers`') if name == 'te' && value != 'trailers'
+        raise Error::MalformedRequestError, 'field name has uppercase letter' if name.downcase != name
+        raise Error::MalformedRequestError, 'unknown pseudo-header field name' if name[0] == ':' && !PSEUDO_HEADER_FIELDS.include?(name)
+        raise Error::MalformedRequestError, 'appear pseudo-header fields after regular fields' if name[0] == ':' && @h.any? { |name_, _| name_[0] != ':' }
+        raise Error::MalformedRequestError, 'duplicated pseudo-header fields' if PSEUDO_HEADER_FIELDS.include?(name) && @h.key?(name)
+        raise Error::MalformedRequestError, "invalid `#{name}` field" if PSEUDO_HEADER_FIELDS.include?(name) && value.empty?
+        raise Error::MalformedRequestError, 'connection-specific field is forbidden' if name == 'connection'
+        raise Error::MalformedRequestError, '`TE` field has a value other than `trailers`' if name == 'te' && value != 'trailers'
 
         @h[name] = [] unless @h.key?(name)
         @h[name] << value
-
-        nil
       end
       # rubocop: enable Metrics/AbcSize
       # rubocop: enable Metrics/CyclomaticComplexity
@@ -57,19 +57,18 @@ module Biryani
 
       # @param arr [Array]
       #
-      # @return [nil, ConnectioError]
+      # @raise [Error::MalformedRequestError]
       def fields(arr)
         arr.each do |name, value|
-          err = field(name, value)
-          return err unless err.nil?
+          field(name, value)
         end
-
-        nil
       end
 
       # @param s [String]
       #
       # @return [Request]
+      #
+      # @raise [Error::MalformedRequestError]
       def build(s)
         # `Ractor.send(req, move: true)` moves entries in HPACK::DynamicTable; therefore, a `dup` call is required.
         h = @h.transform_values { |x| x.map(&:dup) }
@@ -79,19 +78,48 @@ module Biryani
       # @param h [Hash<String, Array<String>>]
       # @param s [String]
       #
-      # @return [Request, ConnectionError]
+      # @return [Request]
+      #
+      # @raise [Error::MalformedRequestError]
       def self.build(h, s)
-        return ConnectionError.new(ErrorCode::PROTOCOL_ERROR, 'missing pseudo-header fields') unless PSEUDO_HEADER_FIELDS.all? { |x| h.key?(x) }
-        return ConnectionError.new(ErrorCode::PROTOCOL_ERROR, 'invalid content-length') if h.key?('content-length') && !s.empty? && s.length != h['content-length'][0].to_i
+        # https://datatracker.ietf.org/doc/html/rfc9113#section-8.3.1-3
+        raise Error::MalformedRequestError, 'missing pseudo-header fields' unless REQUIRED_PSEUDO_HEADER_FIELDS.all? { |x| h.key?(x) }
+        raise Error::MalformedRequestError, 'invalid content-length' if h.key?('content-length') && !s.empty? && s.length != h['content-length'][0].to_i
 
+        authority = authority(h)
         scheme = h[':scheme'][0]
-        domain = h[':authority'][0]
         path = h[':path'][0]
-        uri = URI("#{scheme}://#{domain}#{path}")
+        uri = URI("#{scheme}://#{authority}#{path}")
         method = h[':method'][0].upcase
         h['cookie'] = [h['cookie'].join('; ')] if h.key?('cookie')
         Request.new(method, uri, h.except(*PSEUDO_HEADER_FIELDS), s)
       end
+
+      # @param h [Hash<String, Array<String>>]
+      #
+      # @return [String]
+      #
+      # @raise [Error::MalformedRequestError]
+      # rubocop: disable Metrics/CyclomaticComplexity
+      # rubocop: disable Metrics/PerceivedComplexity
+      def self.authority(h)
+        host = h['host']
+        # https://datatracker.ietf.org/doc/html/rfc9110#section-5.3-3
+        raise Error::MalformedRequestError, 'duplicated host fields' if !host.nil? && host.length > 1
+
+        authority = h[':authority']&.first
+        # https://datatracker.ietf.org/doc/html/rfc9113#section-8.3.1-2.3.3
+        raise Error::MalformedRequestError, 'mismatched :authority and host fields' if !authority.nil? && !host.nil? && authority.downcase != host[0].downcase
+
+        s = authority || host&.first
+        # https://datatracker.ietf.org/doc/html/rfc9110#section-4.2.1-4
+        # https://datatracker.ietf.org/doc/html/rfc9110#section-4.2.2-4
+        raise Error::MalformedRequestError, 'missing :authority and host fields' if s.nil? || s.empty?
+
+        s
+      end
+      # rubocop: enable Metrics/CyclomaticComplexity
+      # rubocop: enable Metrics/PerceivedComplexity
     end
   end
 end

data/lib/biryani/http/response.rb

@@ -15,14 +15,14 @@ module Biryani
         @content = content
       end
 
-      # @raise [InvalidHTTPResponseError]
+      # @raise [InvalidResponseError]
       # rubocop: disable Metrics/CyclomaticComplexity
       def validate
         # https://datatracker.ietf.org/doc/html/rfc9113#section-8.2.1
-        raise Error::InvalidHTTPResponseError, 'invalid HTTP status' if @status < 100 || @status >= 600
-        raise Error::InvalidHTTPResponseError, 'HTTP field name contains invalid characters' if (@fields.keys.join.downcase.bytes.uniq & FORBIDDEN_KEY_CHARS).any?
-        raise Error::InvalidHTTPResponseError, 'HTTP field value contains NUL, LF or CR' if (@fields.values.join.bytes.uniq & FORBIDDEN_VALUE_CHARS).any?
-        raise Error::InvalidHTTPResponseError, 'HTTP field value starts/ends with SP or HTAB' if @fields.values.filter { |s| s.start_with?("\t", ' ') || s.end_with?("\t", ' ') }.any?
+        raise Error::InvalidResponseError, 'invalid HTTP status' if @status < 100 || @status >= 600
+        raise Error::InvalidResponseError, 'HTTP field name contains invalid characters' if (@fields.keys.join.downcase.bytes.uniq & FORBIDDEN_KEY_CHARS).any?
+        raise Error::InvalidResponseError, 'HTTP field value contains NUL, LF or CR' if (@fields.values.join.bytes.uniq & FORBIDDEN_VALUE_CHARS).any?
+        raise Error::InvalidResponseError, 'HTTP field value starts/ends with SP or HTAB' if @fields.values.filter { |s| s.start_with?("\t", ' ') || s.end_with?("\t", ' ') }.any?
       end
       # rubocop: enable Metrics/CyclomaticComplexity
 

data/lib/biryani/server.rb

@@ -8,11 +8,15 @@ module Biryani
     # @param socket [Socket]
     def run(socket)
       loop do
-        Ractor.new(socket.accept, @proc) do |io, proc|
+        io = socket.accept
+        r = Ractor.new(@proc) do |proc|
+          io_ = Ractor.receive
           conn = Connection.new(proc)
-          conn.serve(io)
-          io.close
+          conn.serve(io_)
+        ensure
+          Biryani.ignore_peer_closed { io_&.close }
         end
+        r.send(io, move: true)
       end
     end
   end

data/lib/biryani/stream.rb

@@ -18,7 +18,11 @@ module Biryani
             res = HTTP::Response.internal_server_error
           end
 
-          tx.send([:response, res, stream_id], move: true)
+          begin
+            tx.send([:response, res, stream_id], move: true)
+          rescue Ractor::ClosedError
+            # the Connection has already finished, so discard the response
+          end
         end
       end
     end

data/lib/biryani/streams_context.rb

@@ -50,6 +50,11 @@ module Biryani
       @h.values.filter(&:active?).length
     end
 
+    # @return [Boolean]
+    def none_half_closed_remote?
+      @h.each_value.none?(&:half_closed_remote?)
+    end
+
     # @return [Integer, nil]
     def receiving_continuation_stream_id
       @h.find { |_, ctx| ctx.receiving_continuation? }&.first

data/lib/biryani/utils.rb

@@ -20,4 +20,13 @@ module Biryani
       obj
     end
   end
+
+  # Errors raised when the peer has already closed the connection (EOF, EPIPE, ECONNRESET, etc.)
+  PEER_CLOSED_ERRORS = Ractor.make_shareable([IOError, SystemCallError])
+
+  def self.ignore_peer_closed
+    yield
+  rescue *PEER_CLOSED_ERRORS
+    nil
+  end
 end

data/lib/biryani/version.rb

@@ -1,3 +1,3 @@
 module Biryani
-  VERSION = '0.0.14'.freeze
+  VERSION = '0.0.16'.freeze
 end

data/lib/biryani.rb

@@ -1,3 +1,4 @@
+require 'timeout'
 require 'uri'
 
 require_relative 'biryani/connection_error'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: biryani
 version: !ruby/object:Gem::Version
-  version: 0.0.14
+  version: 0.0.16
 platform: ruby
 authors:
 - thekuwayama
@@ -39,9 +39,15 @@ files:
 - biryani.gemspec
 - conformance/server_spec.rb
 - conformance/spec_helper.rb
+- example/README.md
 - example/echo.rb
 - example/hello_world.rb
+- example/kv_store.rb
+- example/nginx.conf
 - example/raise_error.rb
+- example/sqlite3.rb
+- example/tiles.rb
+- example/tiles/index.html
 - lib/biryani.rb
 - lib/biryani/connection.rb
 - lib/biryani/connection_error.rb
@@ -99,7 +105,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.6
+rubygems_version: 4.0.20
 specification_version: 4
 summary: An HTTP/2 server implemented using Ruby Ractor
 test_files: []