biryani 0.0.12 → 0.0.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2182695aff86f0885189fd0f2387a3e1807ad4d44986cac3eafb7a5452cf3ea0
-  data.tar.gz: 1c66dbdc500aea8cfacc6ca8dd415531dc46ad989852154effd8bba7998ac6af
+  metadata.gz: 68d7513a831a0ea2e4b4bf55400d1e1d464a5c16aa7577ba2c6c7937d0a62019
+  data.tar.gz: dad97d0529ef59f2e233da2a7042b6eeacbc95f77328ac0172ad45fcc24fd9db
 SHA512:
-  metadata.gz: fa61f7da21c1802542365734855aac5c805b8c211fd6f8b2a40fea793947841e4ac6a237f5bfccf57daf61dcc14f592702c7e5ca55ccaf48c6e7d0b3f6e7104b
-  data.tar.gz: 66b276311e545cf440bda25787b17ee63c1de8aa1bb18c951fb91dd44c44818bfbf816f92e5f55d3483af418147015a70752aac4ff24b64d7fdc025589b39204
+  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

@@ -12,20 +12,23 @@ module Biryani
   class Connection
     CONNECTION_PREFACE = "PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n".freeze
     CONNECTION_PREFACE_LENGTH = CONNECTION_PREFACE.length
+    DEFAULT_HEADER_TABLE_SIZE = 4_096
+    INITIAL_CONNECTION_WINDOW_SIZE = 65_535
 
-    private_constant :CONNECTION_PREFACE, :CONNECTION_PREFACE_LENGTH
+    private_constant :CONNECTION_PREFACE, :CONNECTION_PREFACE_LENGTH, :DEFAULT_HEADER_TABLE_SIZE, :INITIAL_CONNECTION_WINDOW_SIZE
     Ractor.make_shareable(CONNECTION_PREFACE)
     Ractor.make_shareable(CONNECTION_PREFACE_LENGTH)
 
     # proc [Proc]
     def initialize(proc)
-      @sock = nil # Ractor::Port
+      @port = Ractor::Port.new
+      @recv_done = false
       @proc = proc
-      @streams_ctx = StreamsContext.new(proc)
-      @encoder = HPACK::Encoder.new(4_096)
-      @decoder = HPACK::Decoder.new(4_096)
-      @send_window = Window.new(65_535)
-      @recv_window = Window.new(65_535)
+      @streams_ctx = StreamsContext.new(proc, @port)
+      @encoder = HPACK::Encoder.new(DEFAULT_HEADER_TABLE_SIZE)
+      @decoder = HPACK::Decoder.new(DEFAULT_HEADER_TABLE_SIZE)
+      @send_window = Window.new(INITIAL_CONNECTION_WINDOW_SIZE)
+      @recv_window = Window.new(INITIAL_CONNECTION_WINDOW_SIZE)
       @data_buffer = DataBuffer.new
       @settings = self.class.default_settings # Hash<Integer, Integer>
       @peer_settings = self.class.default_settings # Hash<Integer, Integer>
@@ -53,12 +56,15 @@ module Biryani
 
     # @param io [IO]
     def recv_loop(io)
-      Ractor.new(io, @sock = Ractor::Port.new) do |io_, sock_|
+      Ractor.new(io, @port) do |io_, port_|
         loop do
           obj = Frame.read(io_)
-          break if obj.nil?
+          if obj.nil?
+            port_.send(:eof, move: true)
+            break
+          end
 
-          sock_.send(obj, move: true)
+          port_.send([:frame, obj], move: true)
         end
       end
     end
@@ -66,13 +72,14 @@ module Biryani
     # @param io [IO]
     def select_loop(io)
       loop do
-        break if @sock.closed? && @streams_ctx.empty?
+        break if @recv_done && @streams_ctx.empty?
 
-        port, obj = Ractor.select(@sock, @streams_ctx.tx)
-        if port == @sock
+        case @port.receive
+        in :eof
+          @recv_done = true
+        in [:frame, obj]
           recv_dispatch(io, obj)
-        else
-          res, stream_id = obj
+        in [:response, res, stream_id]
           handle_response(io, res, stream_id)
         end
 
@@ -118,7 +125,7 @@ module Biryani
     # @return [Array<Object>, Array<ConnectionError>, Array<StreamError>] frames or errors
     def do_recv_dispatch(frame)
       receiving_continuation_stream_id = @streams_ctx.receiving_continuation_stream_id
-      return [ConnectionError.new(ErrorCode::PROTOCOL_ERROR, "invalid frame type #{format('0x%02x', typ)} for stream identifier #{format('0x%02x', stream_id)}")] \
+      return [ConnectionError.new(ErrorCode::PROTOCOL_ERROR, "invalid frame type #{format('0x%02x', frame.f_type)} for stream identifier #{format('0x%02x', frame.stream_id)}")] \
         if !receiving_continuation_stream_id.nil? && frame.stream_id != receiving_continuation_stream_id
 
       if frame.stream_id.zero?
@@ -135,13 +142,14 @@ module Biryani
     def handle_connection_frame(frame)
       case frame.f_type
       when FrameType::DATA, FrameType::HEADERS, FrameType::PRIORITY, FrameType::RST_STREAM, FrameType::PUSH_PROMISE, FrameType::CONTINUATION
-        [ConnectionError.new(ErrorCode::PROTOCOL_ERROR, "invalid frame type #{format('0x%02x', typ)} for stream identifier 0x00")]
+        [ConnectionError.new(ErrorCode::PROTOCOL_ERROR, "invalid frame type #{format('0x%02x', frame.f_type)} for stream identifier 0x00")]
       when FrameType::SETTINGS
         obj = self.class.handle_settings(frame, @peer_settings, @decoder, @streams_ctx)
         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?
@@ -178,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)
@@ -358,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') \
@@ -367,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
@@ -379,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
@@ -456,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]
@@ -486,7 +500,7 @@ module Biryani
     def self.default_settings
       # https://datatracker.ietf.org/doc/html/rfc9113#section-6.5.2
       {
-        SettingsID::SETTINGS_HEADER_TABLE_SIZE => 4_096,
+        SettingsID::SETTINGS_HEADER_TABLE_SIZE => DEFAULT_HEADER_TABLE_SIZE,
         SettingsID::SETTINGS_ENABLE_PUSH => 1,
         SettingsID::SETTINGS_MAX_CONCURRENT_STREAMS => 0xffffffff,
         SettingsID::SETTINGS_INITIAL_WINDOW_SIZE => 65_535,

data/lib/biryani/data_buffer.rb

@@ -20,14 +20,14 @@ module Biryani
       datas = []
       @buffer.each do |stream_id, data|
         frames, remains = streams_ctx.sendable_datas(stream_id, data, send_window, max_frame_size)
-        datas += frames
+        datas.concat(frames)
         if remains.empty?
           @buffer.delete(stream_id)
         else
           @buffer[stream_id] = remains
         end
 
-        len = frames.map(&:length).sum
+        len = frames.sum(&:length)
         send_window.consume!(len)
         streams_ctx[stream_id].send_window.consume!(len)
       end

data/lib/biryani/frame/data.rb

@@ -51,10 +51,7 @@ module Biryani
 
         if padded
           io = IO::Buffer.for(s)
-          pad_length = io.get_value(:U8, 0)
-          data_length = s.bytesize - pad_length - 1
-          data = io.get_string(1, data_length)
-          padding = io.get_string(1 + data_length)
+          data, padding, pad_length = Frame.read_padded_payload(io, s, 1)
           return ConnectionError.new(ErrorCode::PROTOCOL_ERROR, 'invalid frame') if padding.bytesize != pad_length
         else
           data = s

data/lib/biryani/frame/headers.rb

@@ -64,7 +64,6 @@ module Biryani
       # @return [Headers]
       # rubocop: disable Metrics/AbcSize
       # rubocop: disable Metrics/CyclomaticComplexity
-      # rubocop: disable Metrics/MethodLength
       # rubocop: disable Metrics/PerceivedComplexity
       def self.read(s, flags, stream_id)
         priority = Frame.read_priority(flags)
@@ -74,14 +73,12 @@ module Biryani
 
         if priority && padded
           io = IO::Buffer.for(s)
-          pad_length, stream_dependency, weight = io.get_values(%i[U8 U32 U8], 0)
-          fragment_length = s.bytesize - pad_length - 6
+          _pad_length, stream_dependency, weight = io.get_values(%i[U8 U32 U8], 0)
           # exclusive = (stream_dependency / 2**31).positive?
           stream_dependency %= 2**31
           return ConnectionError.new(ErrorCode::PROTOCOL_ERROR, 'cannot depend on itself') if stream_dependency == stream_id
 
-          fragment = io.get_string(6, fragment_length)
-          padding = io.get_string(6 + fragment_length)
+          fragment, padding, pad_length = Frame.read_padded_payload(io, s, 6)
           return ConnectionError.new(ErrorCode::FRAME_SIZE_ERROR, 'invalid frame') if padding.bytesize != pad_length
         elsif priority
           io = IO::Buffer.for(s)
@@ -94,10 +91,7 @@ module Biryani
           return ConnectionError.new(ErrorCode::FRAME_SIZE_ERROR, 'invalid frame') if fragment.bytesize + 5 != s.bytesize
         elsif padded
           io = IO::Buffer.for(s)
-          pad_length = io.get_value(:U8, 0)
-          fragment_length = s.bytesize - pad_length - 1
-          fragment = io.get_string(1, fragment_length)
-          padding = io.get_string(1 + fragment_length)
+          fragment, padding, pad_length = Frame.read_padded_payload(io, s, 1)
           return ConnectionError.new(ErrorCode::PROTOCOL_ERROR, 'invalid frame') if pad_length >= s.bytesize
           return ConnectionError.new(ErrorCode::PROTOCOL_ERROR, 'invalid frame') if padding.bytesize != pad_length
         else
@@ -108,7 +102,6 @@ module Biryani
       end
       # rubocop: enable Metrics/AbcSize
       # rubocop: enable Metrics/CyclomaticComplexity
-      # rubocop: enable Metrics/MethodLength
       # rubocop: enable Metrics/PerceivedComplexity
     end
   end

data/lib/biryani/frame/push_promise.rb

@@ -53,11 +53,9 @@ module Biryani
 
         io = IO::Buffer.for(s)
         if padded
-          pad_length, promised_stream_id = io.get_values(%i[U8 U32], 0)
+          _pad_length, promised_stream_id = io.get_values(%i[U8 U32], 0)
           promised_stream_id %= 2**31 # Promised Stream ID (31)
-          fragment_length = s.bytesize - pad_length - 5
-          fragment = io.get_string(5, fragment_length)
-          padding = io.get_string(5 + fragment_length)
+          fragment, padding, pad_length = Frame.read_padded_payload(io, s, 5)
           return ConnectionError.new(ErrorCode::PROTOCOL_ERROR, 'invalid frame') if pad_length >= s.bytesize
           return ConnectionError.new(ErrorCode::PROTOCOL_ERROR, 'invalid frame') if padding.bytesize != pad_length
         else

data/lib/biryani/frame.rb

@@ -98,6 +98,22 @@ module Biryani
     def self.to_binary_s_header(payload_length, f_type, flags, stream_id)
       [payload_length, f_type, flags, stream_id].pack('NCCN')[1..]
     end
+
+    # @param io [IO::Buffer]
+    # @param s [String]
+    # @param header_length [Integer] bytes preceding the payload, including the 1-byte Pad Length field
+    #
+    # @return [String] payload
+    # @return [String] padding
+    # @return [Integer] pad_length
+    def self.read_padded_payload(io, s, header_length)
+      pad_length = io.get_value(:U8, 0)
+      payload_length = s.bytesize - pad_length - header_length
+      payload = io.get_string(header_length, payload_length)
+      padding = io.get_string(header_length + payload_length)
+
+      [payload, padding, pad_length]
+    end
   end
 end
 

data/lib/biryani/hpack/dynamic_table.rb

@@ -47,6 +47,26 @@ module Biryani
         @table[index]
       end
 
+      # @param index [Integer]
+      #
+      # @return [Array] [name, value]
+      def entry_at(index)
+        raise Error::HPACKDecodeError if index.zero? || index > STATIC_TABLE_SIZE + count_entries
+
+        if index <= STATIC_TABLE_SIZE
+          STATIC_TABLE[index - 1]
+        else
+          self[index - 1 - STATIC_TABLE_SIZE]
+        end
+      end
+
+      # @param index [Integer]
+      #
+      # @return [String]
+      def name_at(index)
+        entry_at(index)[0]
+      end
+
       # @param new_limit [Integer]
       def chomp!(new_limit)
         while @size > new_limit

data/lib/biryani/hpack/field.rb

@@ -145,15 +145,8 @@ module Biryani
       # @return [Integer]
       def self.decode_indexed(io, cursor, dynamic_table)
         index, c = Integer.decode(io, 7, cursor)
-        raise Error::HPACKDecodeError if index.zero? || index > STATIC_TABLE_SIZE + dynamic_table.count_entries
 
-        field = if index <= STATIC_TABLE_SIZE
-                  STATIC_TABLE[index - 1]
-                else
-                  dynamic_table[index - 1 - STATIC_TABLE_SIZE]
-                end
-
-        [field, c]
+        [dynamic_table.entry_at(index), c]
       end
 
       #   0   1   2   3   4   5   6   7
@@ -202,13 +195,7 @@ module Biryani
       # @return [Integer]
       def self.decode_literal_value_incremental_indexing(io, cursor, dynamic_table)
         index, c = Integer.decode(io, 6, cursor)
-        raise Error::HPACKDecodeError if index.zero? || index > STATIC_TABLE_SIZE + dynamic_table.count_entries
-
-        name = if index <= STATIC_TABLE_SIZE
-                 STATIC_TABLE[index - 1][0]
-               else
-                 dynamic_table[index - 1 - STATIC_TABLE_SIZE][0]
-               end
+        name = dynamic_table.name_at(index)
         value, c = String.decode(io, c)
         dynamic_table.store(name, value)
 
@@ -281,13 +268,7 @@ module Biryani
       # @return [Integer]
       def self.decode_literal_value_never_indexed(io, cursor, dynamic_table)
         index, c = Integer.decode(io, 4, cursor)
-        raise Error::HPACKDecodeError if index.zero? || index > STATIC_TABLE_SIZE + dynamic_table.count_entries
-
-        name = if index <= STATIC_TABLE_SIZE
-                 STATIC_TABLE[index - 1][0]
-               else
-                 dynamic_table[index - 1 - STATIC_TABLE_SIZE][0]
-               end
+        name = dynamic_table.name_at(index)
         value, c = String.decode(io, c)
 
         [[name, value], c]
@@ -336,13 +317,7 @@ module Biryani
       # @return [Integer]
       def self.decode_literal_value_without_indexing(io, cursor, dynamic_table)
         index, c = Integer.decode(io, 4, cursor)
-        raise Error::HPACKDecodeError if index.zero? || index > STATIC_TABLE_SIZE + dynamic_table.count_entries
-
-        name = if index <= STATIC_TABLE_SIZE
-                 STATIC_TABLE[index - 1][0]
-               else
-                 dynamic_table[index - 1 - STATIC_TABLE_SIZE][0]
-               end
+        name = dynamic_table.name_at(index)
         value, c = String.decode(io, c)
 
         [[name, value], c]

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/stream.rb

@@ -18,7 +18,7 @@ module Biryani
             res = HTTP::Response.internal_server_error
           end
 
-          tx.send([res, stream_id], move: true)
+          tx.send([:response, res, stream_id], move: true)
         end
       end
     end

data/lib/biryani/streams_context.rb

@@ -2,10 +2,10 @@ module Biryani
   class StreamsContext
     attr_accessor :tx
 
-    def initialize(proc)
+    def initialize(proc, tx)
       @h = {} # Hash<Integer, StreamContext>
       @proc = proc
-      @tx = Ractor::Port.new
+      @tx = tx
     end
 
     # @param stream_id [Integer]

data/lib/biryani/version.rb

@@ -1,3 +1,3 @@
 module Biryani
-  VERSION = '0.0.12'.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.12
+  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: []