biryani 0.0.14 → 0.0.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 96b9dc1294ce1840c02e6cf1700b1ebae51409b586dffd25b7df814acdd65034
-  data.tar.gz: 66d417773c04e090101661650748415566e9f4ca0f91ff95720b2cb7f8668f7b
+  metadata.gz: 68d7513a831a0ea2e4b4bf55400d1e1d464a5c16aa7577ba2c6c7937d0a62019
+  data.tar.gz: dad97d0529ef59f2e233da2a7042b6eeacbc95f77328ac0172ad45fcc24fd9db
 SHA512:
-  metadata.gz: '079d3ab7c12394a9fd340757c5f076cbe937bd1f1a1e60cd24e98f7535526e320189a35f6baa2a5dab3c621b467fec52566e2cfec43a9b994d9f4e5c9dd818cf'
-  data.tar.gz: 7eed1c453cef71438ee5e625bd7b954c38c8cb4aa417db79c00894bf00e4f1f500a759a16d8c6ea58d3c90f273b5bcbbbefbe3a2de1059367b087095921aaec8
+  metadata.gz: eb4574ee23c377e4919f64f8c84d8798e3f52224788555456cac185e923694bc9dec8647a2e495727652aa398ca44ce1bb5dc4ef57b850f066c1621f0714dcde
+  data.tar.gz: efed6f174ab3a74b6fb33d110ed53cb6cd56fef824a928723800b78c7629b620ef6ee647138cdd22b3e8094235eb49b484e7a2a6c88c1e4c9d3fedac354768dc

data/.ruby-version

@@ -1 +1 @@
-4.0.2
+4.0.7

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/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,170 @@
+#!/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                        |   |
+#   |                                    |           |  +------------------------------------------+   |
+#   |  Ractor.new(server, socket)        |           |                                                 |
+#   +----+-------------------------------+           +-------------------------------------------------+
+#        |                                                                                          ^
+#        v                                                                                          |
+#   +-- server Ractor ----------------------+       +-- connection Ractor (1 Ractor / connection) --+--+
+#   |  server.run(socket)                   |       |  Stream.new(tx, stream_id, proc)              |  |
+#   |    Ractor.new(socket.accept, @proc) --+------>|    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
+)
+Ractor.new(server, socket) { |s, sock| s.run(sock) }
+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

@@ -148,7 +148,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 +186,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)
@@ -365,8 +366,9 @@ module Biryani
     # @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 +376,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 obj.is_a?(StreamError) # terminate the Stream Ractor waiting for a request
         return obj if Biryani.err?(obj)
 
         ctx << obj
@@ -386,16 +389,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 obj.is_a?(StreamError) # terminate the Stream Ractor waiting for a request
         return obj if Biryani.err?(obj)
 
         ctx << obj
@@ -463,21 +468,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)
+    # @return [HTTP::Request, ConnectionError, StreamError]
+    def self.http_request(stream_id, fragment, content, decoder)
       obj = decoder.decode(fragment)
       return obj if Biryani.err?(obj)
 
       fields = obj
       builder = HTTP::RequestBuilder.new
-      err = builder.fields(fields)
-      return err unless err.nil?
-
+      builder.fields(fields)
       builder.build(content)
+    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/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/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: biryani
 version: !ruby/object:Gem::Version
-  version: 0.0.14
+  version: 0.0.15
 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: []