biryani 0.0.8 → 0.0.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 62514e8d943c7f5b5c21f863faabb9e45ec813225f6b5f0b60f2afb5c784c1ce
-  data.tar.gz: 9767186d0fbef80e454f7e5a5fb3183cf36637160bb73c969bf9ce20075764d0
+  metadata.gz: 1aa3fb4dd49abcba22df142cd67d38c5eedc6c8beb6ca8fbcb130147c7e7506a
+  data.tar.gz: 54bd5a493c027047eeaada80b4ff938ab806c29b80069a6cc112a54f5bb78efc
 SHA512:
-  metadata.gz: 3127dc1a2ac8bd3b7c46c7cb6bab33f62a3f74aee3a9a645a1e3afe08705ceee7c35365f7e3d4374c08f80c473fc6dd712ff4cdc0713d1cc9e0da17605294a19
-  data.tar.gz: 2af8f94e69c662da0b69a39fa8c41adcc506352a9db81bc4c469283f457fd724a5d56cd966916648a44d3a12bd8f392f9fb816010d28c141b0a7d611d7070ba7
+  metadata.gz: 3a8c93ee8ce069cfe77854f7792abadf528addc7e258cd55c84f1b8b2da0b25b278b768e3c8b41a0897a9adc1ee497a9cac4d2ced4c3dd5c644d17f9eb1327c8
+  data.tar.gz: 2909206008b7794ce6ec3a7c850acf66c475c33bc543d55defd9222d8f606fb661d31b99443cc4ba7a0d3d1da920d3a85209d0f8e0cca3de1cd611ccc43634ac

data/.ruby-version

@@ -1 +1 @@
-4.0.1
+4.0.2

data/README.md

@@ -32,8 +32,8 @@ port = ARGV[0] || 8888
 socket = TCPServer.new(port)
 
 server = Biryani::Server.new(
-  # @param _req [Biryani::HTTPRequest]
-  # @param res [Biryani::HTTPResponse]
+  # @param _req [Biryani::HTTP::Request]
+  # @param res [Biryani::HTTP::Response]
   Ractor.shareable_proc do |_req, res|
     res.status = 200
     res.content = 'Hello, world!'

data/biryani.gemspec

@@ -13,8 +13,11 @@ Gem::Specification.new do |spec|
   spec.license       = 'MIT'
   spec.required_ruby_version = '>=4.0'
 
-  spec.files         = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
+    end
+  end
   spec.require_paths = ['lib']
 
   spec.add_development_dependency 'bundler'

data/example/echo.rb

@@ -9,8 +9,8 @@ port = ARGV[0] || 8888
 socket = TCPServer.new(port)
 
 server = Biryani::Server.new(
-  # @param req [Biryani::HTTPRequest]
-  # @param res [Biryani::HTTPResponse]
+  # @param req [Biryani::HTTP::Request]
+  # @param res [Biryani::HTTP::Response]
   Ractor.shareable_proc do |req, res|
     res.status = 200
     res.content = if req.method.upcase == 'POST'

data/example/hello_world.rb

@@ -9,8 +9,8 @@ port = ARGV[0] || 8888
 socket = TCPServer.new(port)
 
 server = Biryani::Server.new(
-  # @param _req [Biryani::HTTPRequest]
-  # @param res [Biryani::HTTPResponse]
+  # @param _req [Biryani::HTTP::Request]
+  # @param res [Biryani::HTTP::Response]
   Ractor.shareable_proc do |_req, res|
     res.status = 200
     res.content = 'Hello, world!'

data/lib/biryani/connection.rb

@@ -19,7 +19,7 @@ module Biryani
 
     # proc [Proc]
     def initialize(proc)
-      @sock = nil # Ractor
+      @sock = nil # Ractor::Port
       @proc = proc
       @streams_ctx = StreamsContext.new(proc)
       @encoder = HPACK::Encoder.new(4_096)
@@ -43,10 +43,10 @@ module Biryani
       self.class.do_send(io, Frame::Settings.new(false, 0, {}), true)
 
       recv_loop(io.clone)
-      send_loop(io)
+      select_loop(io)
     rescue StandardError => e
       puts e.backtrace
-      self.class.do_send(io, Frame::Goaway.new(0, @streams_ctx.last_stream_id, ErrorCode::INTERNAL_ERROR, 'internal error'), true)
+      self.class.do_send(io, Frame::Goaway.new(@streams_ctx.last_stream_id, ErrorCode::INTERNAL_ERROR, 'internal error'), true)
     ensure
       io.close_write
     end
@@ -64,60 +64,59 @@ module Biryani
     end
 
     # @param io [IO]
-    # rubocop: disable Metrics/AbcSize
-    # rubocop: disable Metrics/BlockLength
-    # rubocop: disable Metrics/CyclomaticComplexity
-    # rubocop: disable Metrics/MethodLength
-    # rubocop: disable Metrics/PerceivedComplexity
-    def send_loop(io)
+    def select_loop(io)
       loop do
-        ports = @streams_ctx.txs
-        break if ports.empty? && @sock.closed?
+        break if @sock.closed? && @streams_ctx.empty?
 
-        port, obj = Ractor.select(@sock, *ports)
+        port, obj = Ractor.select(@sock, @streams_ctx.tx)
         if port == @sock
-          if Biryani.err?(obj)
-            reply_frame = Biryani.unwrap(obj, @streams_ctx.last_stream_id)
-            self.class.do_send(io, reply_frame, true)
-            close if self.class.transition_stream_state_send(reply_frame, @streams_ctx)
-          elsif obj.length > @settings[SettingsID::SETTINGS_MAX_FRAME_SIZE]
-            self.class.do_send(io, Frame::Goaway.new(0, @streams_ctx.last_stream_id, ErrorCode::FRAME_SIZE_ERROR, 'payload length greater than SETTINGS_MAX_FRAME_SIZE'), true)
-            close
-          else
-            recv_dispatch(obj).each do |frame|
-              reply_frame = Biryani.unwrap(frame, @streams_ctx.last_stream_id)
-              self.class.do_send(io, reply_frame, true)
-              if reply_frame.f_type == FrameType::WINDOW_UPDATE && reply_frame.stream_id.zero?
-                @recv_window.increase!(reply_frame.window_size_increment)
-              elsif reply_frame.f_type == FrameType::WINDOW_UPDATE
-                @streams_ctx[reply_frame.stream_id].recv_window.increase!(reply_frame.window_size_increment)
-              end
-
-              close if self.class.transition_stream_state_send(reply_frame, @streams_ctx)
-            end
-          end
+          recv_dispatch(io, obj)
         else
           res, stream_id = obj
-          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)
-          self.class.send_data(io, stream_id, data, @send_window, max_frame_size, @streams_ctx, @data_buffer) unless data.empty?
+          handle_response(io, res, stream_id)
         end
 
-        @streams_ctx.remove_closed(@data_buffer)
         break if closed?
       end
     end
+
+    # @param io [IO]
+    # @param obj [Object]
+    #
+    # @return [Array<Object>, Array<ConnectionError>, Array<StreamError>] frames or errors
+    # rubocop: disable Metrics/AbcSize
+    # rubocop: disable Metrics/CyclomaticComplexity
+    # rubocop: disable Metrics/PerceivedComplexity
+    def recv_dispatch(io, obj)
+      if Biryani.err?(obj)
+        reply_frame = Biryani.unwrap(obj, @streams_ctx.last_stream_id)
+        self.class.do_send(io, reply_frame, true)
+        close if self.class.transition_stream_state_send(reply_frame, @streams_ctx)
+      elsif obj.length > @settings[SettingsID::SETTINGS_MAX_FRAME_SIZE]
+        self.class.do_send(io, Frame::Goaway.new(@streams_ctx.last_stream_id, ErrorCode::FRAME_SIZE_ERROR, 'payload length greater than SETTINGS_MAX_FRAME_SIZE'), true)
+        close
+      else
+        do_recv_dispatch(obj).each do |frame|
+          reply_frame = Biryani.unwrap(frame, @streams_ctx.last_stream_id)
+          self.class.do_send(io, reply_frame, true)
+          if reply_frame.f_type == FrameType::WINDOW_UPDATE && reply_frame.stream_id.zero?
+            @recv_window.increase!(reply_frame.window_size_increment)
+          elsif reply_frame.f_type == FrameType::WINDOW_UPDATE
+            @streams_ctx[reply_frame.stream_id].recv_window.increase!(reply_frame.window_size_increment)
+          end
+
+          close if self.class.transition_stream_state_send(reply_frame, @streams_ctx)
+        end
+      end
+    end
     # rubocop: enable Metrics/AbcSize
-    # rubocop: enable Metrics/BlockLength
     # rubocop: enable Metrics/CyclomaticComplexity
-    # rubocop: enable Metrics/MethodLength
     # rubocop: enable Metrics/PerceivedComplexity
 
     # @param frame [Object]
     #
     # @return [Array<Object>, Array<ConnectionError>, Array<StreamError>] frames or errors
-    def recv_dispatch(frame)
+    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)}")] \
         if !receiving_continuation_stream_id.nil? && frame.stream_id != receiving_continuation_stream_id
@@ -182,7 +181,7 @@ module Biryani
       max_streams = @peer_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, stream_id, max_streams, send_initial_window_size, recv_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)
       return [obj] if Biryani.err?(obj)
 
       ctx = obj
@@ -225,6 +224,16 @@ module Biryani
     # rubocop: enable Metrics/CyclomaticComplexity
     # rubocop: enable Metrics/MethodLength
 
+    # @param io [IO]
+    # @param res [HTTP::Response]
+    # @param stream_id [Integer]
+    def handle_response(io, res, stream_id)
+      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)
+      self.class.send_data(io, stream_id, data, @send_window, max_frame_size, @streams_ctx, @data_buffer) unless data.empty?
+    end
+
     def close
       @closed = true
     end
@@ -237,6 +246,7 @@ module Biryani
     # @param recv_frame [Object]
     # @param streams_ctx [StreamsContext]
     # @param stream_id [Integer]
+    # @param data_buffer [DataBuffer]
     # @param max_streams [Integer]
     # @param send_initial_window_size [Integer]
     # @param recv_initial_window_size [Integer]
@@ -244,13 +254,18 @@ module Biryani
     # @return [StreamContext, StreamError, ConnectionError]
     # rubocop: disable Metrics/CyclomaticComplexity
     # rubocop: disable Metrics/PerceivedComplexity
-    def self.transition_stream_state_recv(recv_frame, streams_ctx, stream_id, max_streams, send_initial_window_size, recv_initial_window_size)
+    def self.transition_stream_state_recv(recv_frame, streams_ctx, data_buffer, stream_id, max_streams, send_initial_window_size, recv_initial_window_size)
       ctx = streams_ctx[stream_id]
       return StreamError.new(ErrorCode::PROTOCOL_ERROR, stream_id, 'exceed max concurrent streams') if ctx.nil? && streams_ctx.count_active + 1 > max_streams
       return ConnectionError.new(ErrorCode::PROTOCOL_ERROR, 'even-numbered stream identifier') if ctx.nil? && stream_id.even?
       return ConnectionError.new(ErrorCode::PROTOCOL_ERROR, 'new stream identifier is less than the existing stream identifiers') if ctx.nil? && streams_ctx.last_stream_id > stream_id
 
-      ctx = streams_ctx.new_context(stream_id, send_initial_window_size, recv_initial_window_size) if ctx.nil?
+      if ctx.nil?
+        ctx = streams_ctx.new_context(stream_id, send_initial_window_size, recv_initial_window_size)
+        # An ideal implementation would wait the RTT before removing the stream.
+        streams_ctx.remove_closed(data_buffer)
+      end
+
       obj = ctx.state_transition!(recv_frame, :recv)
       return obj if Biryani.err?(obj)
 
@@ -445,26 +460,26 @@ module Biryani
     # @param content [String]
     # @param decoder [Decoder]
     #
-    # @return [HTTPRequest, ConnectionError]
+    # @return [HTTP::Request, ConnectionError]
     def self.http_request(fragment, content, decoder)
       obj = decoder.decode(fragment)
       return obj if Biryani.err?(obj)
 
       fields = obj
-      builder = HTTPRequestBuilder.new
+      builder = HTTP::RequestBuilder.new
       err = builder.fields(fields)
       return err unless err.nil?
 
       builder.build(content)
     end
 
-    # @param res [HTTPResponse]
+    # @param res [HTTP::Response]
     # @param encoder [Encoder]
     #
     # @return [String] fragment
     # @return [String] data
     def self.http_response(res, encoder)
-      HTTPResponseParser.new(res).parse(encoder)
+      HTTP::ResponseParser.new(res).parse(encoder)
     end
 
     # @return [Hash<Integer, Integer>]

data/lib/biryani/connection_error.rb

@@ -11,7 +11,7 @@ module Biryani
     #
     # @return [Goaway]
     def goaway(last_stream_id)
-      Frame::Goaway.new(0, last_stream_id, @code, @debug)
+      Frame::Goaway.new(last_stream_id, @code, @debug)
     end
   end
 end

data/lib/biryani/frame/goaway.rb

@@ -6,9 +6,9 @@ module Biryani
       # @param last_stream_id [Integer]
       # @param error_code [Integer]
       # @param debug [String]
-      def initialize(stream_id, last_stream_id, error_code, debug)
+      def initialize(last_stream_id, error_code, debug)
         @f_type = FrameType::GOAWAY
-        @stream_id = stream_id
+        @stream_id = 0
         @last_stream_id = last_stream_id
         @error_code = error_code
         @debug = debug
@@ -33,11 +33,13 @@ module Biryani
       #
       # @return [Goaway]
       def self.read(s, _flags, stream_id)
+        return ConnectionError.new(ErrorCode::PROTOCOL_ERROR, 'invalid frame') unless stream_id.zero?
+
         io = IO::Buffer.for(s)
         last_stream_id, error_code = io.get_values(%i[U32 U32], 0)
         debug = io.get_string(8)
 
-        Goaway.new(stream_id, last_stream_id, error_code, debug)
+        Goaway.new(last_stream_id, error_code, debug)
       end
     end
   end

data/lib/biryani/hpack/field.rb

@@ -9,7 +9,7 @@ module Biryani
       # @return [String]
       def self.encode(name, value, dynamic_table)
         case find(name, value, dynamic_table)
-        in Some(index, v) if v.nil?
+        in Some(index, nil)
           res = encode_indexed(index)
         in Some(index, v)
           res = encode_literal_value(index, v)
@@ -145,8 +145,7 @@ 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?
-        raise Error::HPACKDecodeError if index > STATIC_TABLE_SIZE + dynamic_table.count_entries
+        raise Error::HPACKDecodeError if index.zero? || index > STATIC_TABLE_SIZE + dynamic_table.count_entries
 
         field = if index <= STATIC_TABLE_SIZE
                   STATIC_TABLE[index - 1]
@@ -203,8 +202,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?
-        raise Error::HPACKDecodeError if index > STATIC_TABLE_SIZE + dynamic_table.count_entries
+        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]
@@ -283,8 +281,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?
-        raise Error::HPACKDecodeError if index > STATIC_TABLE_SIZE + dynamic_table.count_entries
+        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]
@@ -339,8 +336,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?
-        raise Error::HPACKDecodeError if index > STATIC_TABLE_SIZE + dynamic_table.count_entries
+        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]

data/lib/biryani/http/error.rb

@@ -0,0 +1,10 @@
+module Biryani
+  module HTTP
+    module Error
+      # Generic error, common for all classes under Biryani::HTTP::Error module.
+      class Error < StandardError; end
+
+      class InvalidHTTPResponseError < Error; end
+    end
+  end
+end

data/lib/biryani/http/request.rb

@@ -0,0 +1,97 @@
+module Biryani
+  module HTTP
+    class Request
+      attr_accessor :method, :uri, :fields, :content
+
+      # @param method [String]
+      # @param uri [URI]
+      # @param fields [Hash<String, Array<String>>]
+      # @param content [String]
+      def initialize(method, uri, fields, content)
+        @method = method
+        @uri = uri
+        @fields = fields
+        @content = content
+      end
+
+      # @return [Array<String>, nil]
+      def trailers
+        # https://datatracker.ietf.org/doc/html/rfc9110#section-6.6.2-4
+        keys = (@fields['trailer'] || []).flat_map { |x| x.split(',').map(&:strip) }
+        @fields.slice(*keys)
+      end
+    end
+
+    class RequestBuilder
+      PSEUDO_HEADER_FIELDS = [':authority', ':method', ':path', ':scheme'].freeze
+      Ractor.make_shareable(PSEUDO_HEADER_FIELDS)
+
+      def initialize
+        @h = {}
+      end
+
+      # @param name [String]
+      # @param value [String]
+      #
+      # @return [nil, ConnectioError]
+      # 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'
+
+        @h[name] = [] unless @h.key?(name)
+        @h[name] << value
+
+        nil
+      end
+      # rubocop: enable Metrics/AbcSize
+      # rubocop: enable Metrics/CyclomaticComplexity
+      # rubocop: enable Metrics/PerceivedComplexity
+
+      # @param arr [Array]
+      #
+      # @return [nil, ConnectioError]
+      def fields(arr)
+        arr.each do |name, value|
+          err = field(name, value)
+          return err unless err.nil?
+        end
+
+        nil
+      end
+
+      # @param s [String]
+      #
+      # @return [Request]
+      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) }
+        self.class.build(h, s)
+      end
+
+      # @param h [Hash<String, Array<String>>]
+      # @param s [String]
+      #
+      # @return [Request, ConnectionError]
+      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'].to_i
+
+        scheme = h[':scheme'][0]
+        domain = h[':authority'][0]
+        path = h[':path'][0]
+        uri = URI("#{scheme}://#{domain}#{path}")
+        method = h[':method'][0]
+        h['cookie'] = [h['cookie'].join('; ')] if h.key?('cookie')
+        Request.new(method, uri, h, s)
+      end
+    end
+  end
+end

data/lib/biryani/http/response.rb

@@ -0,0 +1,68 @@
+module Biryani
+  module HTTP
+    class Response
+      FORBIDDEN_KEY_CHARS = (0x00..0x20).chain([0x3a]).chain(0x41..0x5a).chain(0x7f..0xff).to_a.freeze
+      FORBIDDEN_VALUE_CHARS = [0x00, 0x0a, 0x0d].freeze
+
+      attr_accessor :status, :fields, :content
+
+      # @param status [Integer]
+      # @param fields [Hash]
+      # @param content [String, nil]
+      def initialize(status, fields, content)
+        @status = status
+        @fields = fields
+        @content = content
+      end
+
+      # @raise [InvalidHTTPResponseError]
+      # 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?
+      end
+      # rubocop: enable Metrics/CyclomaticComplexity
+
+      def self.default
+        Response.new(0, {}, nil)
+      end
+
+      def self.internal_server_error
+        Response.new(500, {}, 'Internal Server Error')
+      end
+    end
+
+    class ResponseParser
+      # @param res [Response]
+      def initialize(res)
+        @res = res
+      end
+
+      # @return [Array]
+      def fields
+        fields = [[':status', @res.status.to_s]]
+        @res.fields.each do |name, value|
+          fields << [name.to_s.downcase, value.to_s]
+        end
+
+        fields
+      end
+
+      # @return [String]
+      def content
+        @res.content
+      end
+
+      # @param encoder [Encoder]
+      #
+      # @return [String] fragment
+      # @return [String] data
+      def parse(encoder)
+        [encoder.encode(fields), content]
+      end
+    end
+  end
+end

data/lib/biryani/http.rb

@@ -0,0 +1,3 @@
+require_relative 'http/error'
+require_relative 'http/request'
+require_relative 'http/response'

data/lib/biryani/state.rb

@@ -255,7 +255,7 @@ module Biryani
 
     # @return [Boolean]
     def receiving_continuation?
-      %i[receiving_continuation receiving_continuation_and_data].include?(@state)
+      %i[receiving_continuation receiving_continuation_and_data receiving_trailer_continuation].include?(@state)
     end
   end
 end

data/lib/biryani/stream.rb

@@ -2,20 +2,20 @@ module Biryani
   class Stream
     attr_accessor :rx
 
-    # @param tx [Port]
+    # @param tx [Ractor::Port]
     # @param stream_id [Integer]
     # @param proc [Proc]
     def initialize(tx, stream_id, proc)
       @rx = Ractor.new(tx, stream_id, proc) do |tx, stream_id, proc|
         unless (req = Ractor.recv).nil?
-          res = HTTPResponse.default
+          res = HTTP::Response.default
 
           begin
             proc.call(req, res)
             res.validate
           rescue StandardError => e
             puts e.backtrace
-            res = HTTPResponse.internal_server_error
+            res = HTTP::Response.internal_server_error
           end
 
           tx.send([res, stream_id], move: true)

data/lib/biryani/streams_context.rb

@@ -1,8 +1,11 @@
 module Biryani
   class StreamsContext
+    attr_accessor :tx
+
     def initialize(proc)
       @h = {} # Hash<Integer, StreamContext>
       @proc = proc
+      @tx = Ractor::Port.new
     end
 
     # @param stream_id [Integer]
@@ -11,7 +14,7 @@ module Biryani
     #
     # @return [StreamContext]
     def new_context(stream_id, send_initial_window_size, recv_initial_window_size)
-      ctx = StreamContext.new(stream_id, send_initial_window_size, recv_initial_window_size, @proc)
+      ctx = StreamContext.new(stream_id, send_initial_window_size, recv_initial_window_size, @proc, @tx)
       @h[stream_id] = ctx
       ctx
     end
@@ -33,13 +36,13 @@ module Biryani
       @h.length
     end
 
-    def each(&block)
-      @h.each_value(&block)
+    # @return [Boolean]
+    def empty?
+      @h.empty?
     end
 
-    # @return [Array<Port>]
-    def txs
-      @h.values.filter { |ctx| !ctx.closed? }.map(&:tx)
+    def each(&block)
+      @h.each_value(&block)
     end
 
     # @return [Integer]
@@ -88,28 +91,25 @@ module Biryani
     def remove_closed(data_buffer)
       closed_ids = closed_stream_ids.filter { |id| !data_buffer.has?(id) }
       closed_ids.each do |id|
-        @h[id].tx.close
+        @h.delete(id)
       end
     end
 
     def close_all
-      each do |ctx|
-        ctx.tx.close
-        ctx.close
-      end
+      each(&:close)
     end
   end
 
   class StreamContext
-    attr_accessor :tx, :send_window, :recv_window, :fragment, :content
+    attr_accessor :send_window, :recv_window, :fragment, :content
 
     # @param stream_id [Integer]
     # @param send_initial_window_size [Integer]
     # @param recv_initial_window_size [Integer]
     # @param proc [Proc]
-    def initialize(stream_id, send_initial_window_size, recv_initial_window_size, proc)
-      @tx = Ractor::Port.new
-      @stream = Stream.new(@tx, stream_id, proc)
+    # @param tx [Ractor::Port]
+    def initialize(stream_id, send_initial_window_size, recv_initial_window_size, proc, tx)
+      @stream = Stream.new(tx, stream_id, proc)
       @send_window = Window.new(send_initial_window_size)
       @recv_window = Window.new(recv_initial_window_size)
       @fragment = ''.b
@@ -117,7 +117,7 @@ module Biryani
       @state = State.new
     end
 
-    # @param req [HTTPRequest]
+    # @param req [HTTP::Request]
     def <<(req)
       @stream.rx.send(req, move: true)
     end

data/lib/biryani/version.rb

@@ -1,3 +1,3 @@
 module Biryani
-  VERSION = '0.0.8'.freeze
+  VERSION = '0.0.10'.freeze
 end