biryani 0.0.1 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 00cbfab00ec034ee2b79096e4192e363426dbcd0c70e59578b9ead09b2a05865
-  data.tar.gz: d0f78a6b2541464bbf9e0295b13ce576defd8f7a057c200c0c9118a8650ca882
+  metadata.gz: 890de8c1fbcd3833f63207a420161b289a4497275fbdbb747625d1350b1f0d6c
+  data.tar.gz: 1c587a3643953d2acbd1b0022c1ff1b228cc382cc10c75442fb99d68b370f2b4
 SHA512:
-  metadata.gz: 11759d99704bbd2d7fc525c30e30022eebd42396c6db918802b8424832fa4abfc9a47390e1abbb0bcbd9063e2acb74f9fb95b685fac9dd9a389a931e71ef433d
-  data.tar.gz: 4c55e5e2a86a5b65e0e92d34b1e216fc699b18fc5d84486d07c0103a3b813173039bd7ec123b5b781b46c396d87d6d87ae263a1215150df3633ca012e2070238
+  metadata.gz: fe5ed688fe4aff77533de4b37ee5e668f7904435a2c345410c4b87c85ab68af33d03b3741fc3266e605554e057c81cfe28e267b1d94e2f916718e2190d6ee948
+  data.tar.gz: 19cfdad4968d33626135242e33629ed5105069a30f50e377367fa0aae45e2c594e2cfa388c7ea8b635ab17541749a147c04414738633787a3b720043b38ac6aa

data/.rubocop.yml

@@ -17,6 +17,9 @@ Metrics/ClassLength:
 Metrics/MethodLength:
   Max: 30
 
+Metrics/ParameterLists:
+  Max: 7
+
 Naming/MethodParameterName:
   MinNameLength: 1
 

data/README.md

@@ -32,8 +32,8 @@ port = ARGV[0] || 8888
 socket = TCPServer.new(port)
 
 server = Biryani::Server.new(
-  # @params _req [Biryani::HTTPRequest]
-  # @params res [Biryani::HTTPResponse]
+  # @param _req [Biryani::HTTPRequest]
+  # @param res [Biryani::HTTPResponse]
   Ractor.shareable_proc do |_req, res|
     res.status = 200
     res.content = 'Hello, world!'
@@ -42,6 +42,11 @@ server = Biryani::Server.new(
 server.run(socket)
 ```
 
+```sh-session
+$ curl --http2-prior-knowledge http://localhost:8888
+Hello, world!
+```
+
 
 ## License
 

data/example/echo.rb

@@ -9,8 +9,8 @@ port = ARGV[0] || 8888
 socket = TCPServer.new(port)
 
 server = Biryani::Server.new(
-  # @params req [Biryani::HTTPRequest]
-  # @params res [Biryani::HTTPResponse]
+  # @param req [Biryani::HTTPRequest]
+  # @param res [Biryani::HTTPResponse]
   Ractor.shareable_proc do |req, res|
     res.status = 200
 

data/example/hello_world.rb

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

data/lib/biryani/connection.rb

@@ -21,14 +21,14 @@ module Biryani
     def initialize(proc)
       @sock = nil # Ractor
       @proc = proc
-      @streams_ctx = StreamsContext.new
+      @streams_ctx = StreamsContext.new(proc)
       @encoder = HPACK::Encoder.new(4_096)
       @decoder = HPACK::Decoder.new(4_096)
-      @send_window = Window.new
-      @recv_window = Window.new
+      @send_window = Window.new(65_535)
+      @recv_window = Window.new(65_535)
       @data_buffer = DataBuffer.new
-      @send_settings = self.class.default_settings # Hash<Integer, Integer>
-      @recv_settings = self.class.default_settings # Hash<Integer, Integer>
+      @settings = self.class.default_settings # Hash<Integer, Integer>
+      @peer_settings = self.class.default_settings # Hash<Integer, Integer>
       @closed = false
     end
 
@@ -66,6 +66,7 @@ module Biryani
     # rubocop: disable Metrics/AbcSize
     # rubocop: disable Metrics/BlockLength
     # rubocop: disable Metrics/CyclomaticComplexity
+    # rubocop: disable Metrics/MethodLength
     # rubocop: disable Metrics/PerceivedComplexity
     def send_loop(io)
       loop do
@@ -75,36 +76,43 @@ module Biryani
 
         port, obj = Ractor.select(*ports)
         if port == @sock
-          if obj.is_a?(StreamError) || obj.is_a?(ConnectionError)
-            reply_frame = self.class.unwrap(obj, @streams_ctx.last_stream_id)
+          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_state_send(reply_frame, @streams_ctx)
-          elsif obj.length > @send_settings[SettingsID::SETTINGS_MAX_FRAME_SIZE]
+          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 = self.class.unwrap(frame, @streams_ctx.last_stream_id)
+              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_state_send(reply_frame, @streams_ctx)
             end
           end
         else
-          self.class.http_response(*obj, @encoder, @send_settings[SettingsID::SETTINGS_MAX_FRAME_SIZE]).each do |send_frame|
-            close if self.class.send(io, send_frame, @send_window, @streams_ctx, @data_buffer)
-          end
+          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?
 
-          self.class.remove_closed_streams(@streams_ctx, @data_buffer)
+          @streams_ctx.remove_closed(@data_buffer)
         end
 
         break if closed?
       end
-    ensure
-      self.class.clear_all_streams(@streams_ctx)
     end
     # rubocop: enable Metrics/AbcSize
     # rubocop: enable Metrics/BlockLength
     # rubocop: enable Metrics/CyclomaticComplexity
+    # rubocop: enable Metrics/MethodLength
     # rubocop: enable Metrics/PerceivedComplexity
 
     # @param frame [Object]
@@ -128,7 +136,7 @@ module Biryani
       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")]
       when FrameType::SETTINGS
-        obj = self.class.handle_settings(frame, @send_settings, @decoder)
+        obj = self.class.handle_settings(frame, @peer_settings, @decoder, @streams_ctx)
         return [] if obj.nil?
 
         settings_ack = obj
@@ -137,18 +145,21 @@ module Biryani
         obj = self.class.handle_ping(frame)
         return [] if obj.nil?
 
-        [obj]
+        ping_ack = obj
+        [ping_ack]
       when FrameType::GOAWAY
         self.class.handle_goaway(frame)
-        # TODO: logging error
+
         []
       when FrameType::WINDOW_UPDATE
         err = self.class.handle_connection_window_update(frame, @send_window)
         return [err] unless err.nil?
 
-        @data_buffer.take!(@send_window, @streams_ctx)
+        max_frame_size = @peer_settings[SettingsID::SETTINGS_MAX_FRAME_SIZE]
+        @data_buffer.take!(@send_window, @streams_ctx, max_frame_size) # return DATA Frames
       else
-        # ignore unknown frame type
+        # ignore UNKNOWN Frame
+
         []
       end
     end
@@ -160,61 +171,57 @@ module Biryani
     # rubocop: disable Metrics/AbcSize
     # rubocop: disable Metrics/CyclomaticComplexity
     # rubocop: disable Metrics/MethodLength
-    # rubocop: disable Metrics/PerceivedComplexity
     def handle_stream_frame(frame)
       stream_id = frame.stream_id
       typ = frame.f_type
       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)
 
-      obj = self.class.transition_state_recv(frame, @streams_ctx, stream_id, @send_settings[SettingsID::SETTINGS_MAX_CONCURRENT_STREAMS], @proc)
-      return [obj] if obj.is_a?(StreamError) || obj.is_a?(ConnectionError)
+      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_state_recv(frame, @streams_ctx, stream_id, max_streams, send_initial_window_size, recv_initial_window_size)
+      return [obj] if Biryani.err?(obj)
 
       ctx = obj
       case typ
       when FrameType::DATA
-        ctx.content << frame.data
-        if ctx.state.half_closed_remote?
-          obj = self.class.http_request(ctx.fragment.string, ctx.content.string, @decoder)
-          return [obj] if obj.is_a?(StreamError) || obj.is_a?(ConnectionError)
+        obj = self.class.handle_data(stream_id, frame.data, @recv_window, @streams_ctx, @decoder)
+        return [obj] if Biryani.err?(obj)
 
-          ctx.stream.rx << obj
-        end
-
-        []
+        obj # return WINDOW_UPDATE Frames
       when FrameType::HEADERS, FrameType::CONTINUATION
-        ctx.fragment << frame.fragment
-        if ctx.state.half_closed_remote?
-          obj = self.class.http_request(ctx.fragment.string, ctx.content.string, @decoder)
-          return [obj] if obj.is_a?(StreamError) || obj.is_a?(ConnectionError)
-
-          ctx.stream.rx << obj
-        end
+        err = self.class.handle_headers(frame, ctx, @decoder)
+        return [err] unless err.nil?
 
         []
       when FrameType::PRIORITY
         # ignore PRIORITY Frame
+
         []
       when FrameType::PUSH_PROMISE
         # TODO
+
         []
       when FrameType::RST_STREAM
-        self.class.handle_rst_stream(frame, @streams_ctx)
+        self.class.handle_rst_stream(frame, ctx)
+
         []
       when FrameType::WINDOW_UPDATE
         err = self.class.handle_stream_window_update(frame, @streams_ctx)
         return [err] unless err.nil?
 
-        @data_buffer.take!(@send_window, @streams_ctx)
+        max_frame_size = @peer_settings[SettingsID::SETTINGS_MAX_FRAME_SIZE]
+        @data_buffer.take!(@send_window, @streams_ctx, max_frame_size)
       else
         # ignore UNKNOWN Frame
+
         []
       end
     end
     # rubocop: enable Metrics/AbcSize
     # rubocop: enable Metrics/CyclomaticComplexity
     # rubocop: enable Metrics/MethodLength
-    # rubocop: enable Metrics/PerceivedComplexity
 
     def close
       @closed = true
@@ -225,39 +232,25 @@ module Biryani
       @closed
     end
 
-    # @param obj [Object, ConnectionError, StreamError] frame or error
-    # @param last_stream_id [Integer]
-    #
-    # @return [Frame]
-    def self.unwrap(obj, last_stream_id)
-      case obj
-      when ConnectionError
-        obj.goaway(last_stream_id)
-      when StreamError
-        obj.rst_stream
-      else
-        obj
-      end
-    end
-
     # @param recv_frame [Object]
     # @param streams_ctx [StreamsContext]
     # @param stream_id [Integer]
     # @param max_streams [Integer]
-    # @param proc [Proc]
+    # @param send_initial_window_size [Integer]
+    # @param recv_initial_window_size [Integer]
     #
     # @return [StreamContext, StreamError, ConnectionError]
     # rubocop: disable Metrics/CyclomaticComplexity
     # rubocop: disable Metrics/PerceivedComplexity
-    def self.transition_state_recv(recv_frame, streams_ctx, stream_id, max_streams, proc)
+    def self.transition_state_recv(recv_frame, streams_ctx, 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, proc) if ctx.nil?
+      ctx = streams_ctx.new_context(stream_id, send_initial_window_size, recv_initial_window_size) if ctx.nil?
       obj = ctx.state.transition!(recv_frame, :recv)
-      return obj if obj.is_a?(StreamError) || obj.is_a?(ConnectionError)
+      return obj if Biryani.err?(obj)
 
       ctx
     end
@@ -275,46 +268,14 @@ module Biryani
       when FrameType::SETTINGS, FrameType::PING
         false
       when FrameType::GOAWAY
-        close_all_streams(streams_ctx)
+        streams_ctx.close_all
         true
       else
-        streams_ctx[stream_id].state.transition!(send_frame, :send)
+        streams_ctx[stream_id].state.transition!(send_frame, :send) unless stream_id.zero?
         false
       end
     end
 
-    # @param streams_ctx [StreamsContext]
-    def self.clear_all_streams(streams_ctx)
-      streams_ctx.each do |ctx|
-        ctx.tx.close
-        ctx.stream.rx << nil
-        ctx.fragment.close
-        ctx.content.close
-      end
-    end
-
-    # @param streams_ctx [StreamsContext]
-    def self.close_all_streams(streams_ctx)
-      streams_ctx.each do |ctx|
-        ctx.tx.close
-        ctx.fragment.close
-        ctx.content.close
-        ctx.state.close
-      end
-    end
-
-    # @param streams_ctx [StreamsContext]
-    # @param data_buffer [DataBuffer]
-    def self.remove_closed_streams(streams_ctx, data_buffer)
-      closed_ids = streams_ctx.closed_stream_ids.filter { |id| !data_buffer.has?(id) }
-      closed_ids.each do |id|
-        streams_ctx[id].tx.close
-        streams_ctx[id].stream.rx << nil
-        streams_ctx[id].fragment.close
-        streams_ctx[id].content.close
-      end
-    end
-
     # @param io [IO]
     # @param frame [Object]
     # @param flush [Boolean]
@@ -324,39 +285,46 @@ module Biryani
     end
 
     # @param io [IO]
-    # @param frame [Object]
+    # @param stream_id [Integer]
+    # @param data [String]
     # @param send_window [Window]
+    # @param max_frame_size [Integer]
     # @param streams_ctx [StreamsContext]
     # @param data_buffer [DataBuffer]
-    #
-    # @return [Boolean] should close connection?
-    def self.send(io, frame, send_window, streams_ctx, data_buffer)
-      if frame.f_type != FrameType::DATA
-        do_send(io, frame, false)
-        return transition_state_send(frame, streams_ctx)
-      end
+    def self.send_data(io, stream_id, data, send_window, max_frame_size, streams_ctx, data_buffer)
+      frames, remains = streams_ctx.sendable_datas(stream_id, data, send_window, max_frame_size)
 
-      data = frame
-      if sendable?(data, send_window, streams_ctx)
-        do_send(io, data, false)
-        send_window.consume!(data.length)
-        streams_ctx[data.stream_id].send_window.consume!(data.length)
-        return transition_state_send(frame, streams_ctx)
+      frames.each do |frame|
+        do_send(io, frame, false)
+        send_window.consume!(frame.length)
+        streams_ctx[stream_id].send_window.consume!(frame.length)
+        transition_state_send(frame, streams_ctx)
       end
 
-      data_buffer << data
-      false
+      data_buffer.store(stream_id, remains) unless remains.empty?
     end
 
-    # @param data [Data]
-    # @param send_window [Window]
+    # @param io [IO]
+    # @param stream_id [Integer]
+    # @param fragment [String]
+    # @param only_headers [Boolean]
+    # @param max_frame_size [Integer]
     # @param streams_ctx [StreamsContext]
-    #
-    # @return [Boolean]
-    def self.sendable?(data, send_window, streams_ctx)
-      length = data.length
-      stream_id = data.stream_id
-      send_window.available?(length) && streams_ctx[stream_id].send_window.available?(length)
+    def self.send_headers(io, stream_id, fragment, only_headers, max_frame_size, streams_ctx)
+      len = (fragment.bytesize + max_frame_size - 1) / max_frame_size
+      frames = fragment.gsub(/.{1,#{max_frame_size}}/m).with_index.map do |s, index|
+        end_headers = index == len - 1
+        if index.zero?
+          Frame::Headers.new(end_headers, only_headers, stream_id, nil, nil, s, nil)
+        else
+          Frame::Continuation.new(end_headers, stream_id, s)
+        end
+      end
+
+      frames.each do |frame|
+        do_send(io, frame, false)
+        transition_state_send(frame, streams_ctx)
+      end
     end
 
     # @param io [IO]
@@ -367,29 +335,80 @@ module Biryani
       ConnectionError.new(ErrorCode::PROTOCOL_ERROR, 'invalid connection preface') if s != CONNECTION_PREFACE
     end
 
-    # @param rst_stream [RstStream]
+    # @param stream_id [Integer]
+    # @param data [String]
+    # @param recv_window [Window]
     # @param streams_ctx [StreamsContext]
-    def self.handle_rst_stream(rst_stream, streams_ctx)
-      stream_id = rst_stream.stream_id
-      streams_ctx[stream_id].state.close
+    # @param decoder [Decoder]
+    #
+    # @return [Array<WindowUpdate>, ConnectionError]
+    # rubocop: disable Metrics/AbcSize
+    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') \
+        if recv_window.consume!(data.bytesize).negative? || ctx.recv_window.consume!(data.bytesize).negative?
+
+      ctx.content << data
+      if ctx.state.half_closed_remote?
+        obj = http_request(ctx.fragment.string, ctx.content.string, decoder)
+        return obj if Biryani.err?(obj)
+
+        ctx.stream.rx << obj
+      end
+
+      window_updates = []
+      window_updates << Frame::WindowUpdate.new(0, recv_window.capacity - recv_window.length) if recv_window.length < recv_window.capacity / 2
+      window_updates << Frame::WindowUpdate.new(stream_id, ctx.recv_window.capacity - ctx.recv_window.length) if ctx.recv_window.length < ctx.recv_window.capacity / 2
+      window_updates
+    end
+    # rubocop: enable Metrics/AbcSize
+
+    # @param headers [Headers]
+    # @param ctx [StreamContext]
+    # @param decoder [Decoder]
+    #
+    # @return [nil, ConnectionError]
+    def self.handle_headers(headers, ctx, decoder)
+      ctx.fragment << headers.fragment
+      if ctx.state.half_closed_remote?
+        obj = http_request(ctx.fragment.string, ctx.content.string, decoder)
+        return [obj] if Biryani.err?(obj)
+
+        ctx.stream.rx << obj
+      end
+
+      nil
+    end
+
+    # @param _rst_stream [RstStream]
+    # @param ctx [StreamContext]
+    def self.handle_rst_stream(_rst_stream, ctx)
+      ctx.state.close
     end
 
     # @param settings [Settings]
-    # @param send_settings [Hash<Integer, Integer>]
+    # @param peer_settings [Hash<Integer, Integer>]
     # @param decoder [Decoder]
+    # @param streams_ctx [StreamsContext]
     #
     # @return [Settings]
-    def self.handle_settings(settings, send_settings, decoder)
+    def self.handle_settings(settings, peer_settings, decoder, streams_ctx)
       return nil if settings.ack?
 
-      send_settings.merge!(settings.setting)
-      decoder.limit!(send_settings[SettingsID::SETTINGS_HEADER_TABLE_SIZE])
+      peer_settings.merge!(settings.setting)
+      new_limit = peer_settings[SettingsID::SETTINGS_HEADER_TABLE_SIZE]
+      decoder.limit!(new_limit)
+      send_initial_window_size = peer_settings[SettingsID::SETTINGS_INITIAL_WINDOW_SIZE]
+      streams_ctx.each do |ctx|
+        ctx.send_window.update!(send_initial_window_size)
+      end
+
       Frame::Settings.new(true, 0, {})
     end
 
     # @param ping [Ping]
     #
-    # @return [Ping, nil, ConnectionError]
+    # @return [Ping, nil]
     def self.handle_ping(ping)
       Frame::Ping.new(true, 0, ping.opaque) unless ping.ack?
     end
@@ -402,21 +421,21 @@ module Biryani
     #
     # @return [nil, ConnectionError]
     def self.handle_connection_window_update(window_update, send_window)
-      # TODO: send WINDOW_UPDATE
       send_window.increase!(window_update.window_size_increment)
+      return ConnectionError.new(ErrorCode::FLOW_CONTROL_ERROR, 'flow-control window exceeds 2^31-1') if send_window.length > 2**31 - 1
+
       nil
     end
 
     # @param window_update [WindowUpdate]
     # @param streams_ctx [StreamsContext]
     #
-    # @return [nil, ConnectionError]
+    # @return [nil, StreamError]
     def self.handle_stream_window_update(window_update, streams_ctx)
-      return ConnectionError.new(ErrorCode::PROTOCOL_ERROR, 'WINDOW_UPDATE invalid window size increment 0') if window_update.window_size_increment.zero?
-      return StreamError.new(ErrorCode::FLOW_CONTROL_ERROR, window_update.stream_id, 'WINDOW_UPDATE invalid window size increment greater than 2^31-1') \
-        if window_update.window_size_increment > 2**31 - 1
+      stream_id = window_update.stream_id
+      streams_ctx[stream_id].send_window.increase!(window_update.window_size_increment)
+      return StreamError.new(ErrorCode::FLOW_CONTROL_ERROR, stream_id, 'flow-control window exceeds 2^31-1') if streams_ctx[stream_id].send_window.length > 2**31 - 1
 
-      streams_ctx[window_update.stream_id].send_window.increase!(window_update.window_size_increment)
       nil
     end
 
@@ -427,7 +446,7 @@ module Biryani
     # @return [HTTPRequest, ConnectionError]
     def self.http_request(fragment, content, decoder)
       obj = decoder.decode(fragment)
-      return obj if obj.is_a?(StreamError) || obj.is_a?(ConnectionError)
+      return obj if Biryani.err?(obj)
 
       fields = obj
       builder = HTTPRequestBuilder.new
@@ -438,13 +457,12 @@ module Biryani
     end
 
     # @param res [HTTPResponse]
-    # @param stream_id [Integer]
     # @param encoder [Encoder]
-    # @param max_frame_size [Integer]
     #
-    # @return [Array<Object>] frames
-    def self.http_response(res, stream_id, encoder, max_frame_size)
-      HTTPResponseParser.new(res).parse(stream_id, encoder, max_frame_size)
+    # @return [String] fragment
+    # @return [String] data
+    def self.http_response(res, encoder)
+      HTTPResponseParser.new(res).parse(encoder)
     end
 
     # @return [Hash<Integer, Integer>]

data/lib/biryani/data_buffer.rb

@@ -1,30 +1,38 @@
 module Biryani
   class DataBuffer
     def initialize
-      @buffer = [] # Array<Data>
+      @buffer = {} # Hash<Integer, String>
     end
 
-    # @param data [Data]
-    def <<(data)
-      @buffer << data
+    # @param stream_id [Integer]
+    # @param data [String]
+    def store(stream_id, data)
+      @buffer[stream_id] = '' unless @buffer.key?(stream_id)
+      @buffer[stream_id] += data
     end
 
     # @param send_window [Window]
-    # @param stream_ctxs [Hash<Integer, StreamContext>]
+    # @param streams_ctx [StreamsContext]
+    # @param max_frame_size [Intger]
     #
-    # @return [Array<Data>]
-    def take!(send_window, stream_ctxs)
-      datas = {}
-      @buffer.each_with_index.each do |data, i|
-        next unless Connection.sendable?(data, send_window, stream_ctxs)
+    # @return [Array<Object>] frames
+    def take!(send_window, streams_ctx, max_frame_size)
+      datas = []
+      @buffer.each do |stream_id, data|
+        frames, remains = streams_ctx.sendable_datas(stream_id, data, send_window, max_frame_size)
+        datas += frames
+        if remains.empty?
+          @buffer.delete(stream_id)
+        else
+          @buffer[stream_id] = remains
+        end
 
-        send_window.consume!(data.length)
-        stream_ctxs[data.stream_id].send_window.consume!(data.length)
-        datas[i] = data
+        len = frames.map(&:length).sum
+        send_window.consume!(len)
+        streams_ctx[stream_id].send_window.consume!(len)
       end
 
-      @buffer = @buffer.each_with_index.filter { |_, i| datas.keys.include?(i) }.map(&:first)
-      datas.values
+      datas
     end
 
     # @return [Integer]
@@ -36,7 +44,7 @@ module Biryani
     #
     # @return [Boolean]
     def has?(stream_id)
-      @buffer.filter { |data| data.stream_id == stream_id }.any?
+      @buffer.key?(stream_id)
     end
   end
 end

data/lib/biryani/frame/headers.rb

@@ -10,7 +10,6 @@ module Biryani
       # @param weight [Integer, nil]
       # @param fragment [String]
       # @param padding [String, nil]
-      # rubocop: disable Metrics/ParameterLists
       def initialize(end_headers, end_stream, stream_id, stream_dependency, weight, fragment, padding)
         @f_type = FrameType::HEADERS
         @end_headers = end_headers
@@ -21,7 +20,6 @@ module Biryani
         @fragment = fragment
         @padding = padding
       end
-      # rubocop: enable Metrics/ParameterLists
 
       # @return [Boolean]
       def priority?