biryani 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 00cbfab00ec034ee2b79096e4192e363426dbcd0c70e59578b9ead09b2a05865
-  data.tar.gz: d0f78a6b2541464bbf9e0295b13ce576defd8f7a057c200c0c9118a8650ca882
+  metadata.gz: 5e8b17b7b795ee787a07fe5be9e453d4486fdce914609539446932e4fb988912
+  data.tar.gz: 45f9196ca41aecf8efecaee4e29e459e20a6ac05116b8e384858f52d365c4726
 SHA512:
-  metadata.gz: 11759d99704bbd2d7fc525c30e30022eebd42396c6db918802b8424832fa4abfc9a47390e1abbb0bcbd9063e2acb74f9fb95b685fac9dd9a389a931e71ef433d
-  data.tar.gz: 4c55e5e2a86a5b65e0e92d34b1e216fc699b18fc5d84486d07c0103a3b813173039bd7ec123b5b781b46c396d87d6d87ae263a1215150df3633ca012e2070238
+  metadata.gz: 13ba324d9792cde457634d20d72bb7f276772aa6b1eacd878dd82cd3f2fade7f5025472e7bf4b057208f71b68bf8f6df7e2f07bfaeda62baa0c9c6f7c5f58018
+  data.tar.gz: ed9846fa55648102b94242338429b45d6bea100eb1427a736c5a90886c6e3933602138407f0bd474f5c3f024887100f2fc241b46c16bfa2f035ca0ce08f8c1f2

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

@@ -24,11 +24,11 @@ module Biryani
       @streams_ctx = StreamsContext.new
       @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,11 +76,11 @@ module Biryani
 
         port, obj = Ractor.select(*ports)
         if port == @sock
-          if obj.is_a?(StreamError) || obj.is_a?(ConnectionError)
+          if Biryani.err?(obj)
             reply_frame = self.class.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
@@ -90,21 +91,24 @@ module Biryani
             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)
+      @streams_ctx.clear_all
     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 +132,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,7 +141,8 @@ 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
@@ -146,7 +151,8 @@ module Biryani
         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)
       else
         # ignore unknown frame type
         []
@@ -167,16 +173,20 @@ 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)
 
-      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, @proc)
+      return [obj] if Biryani.err?(obj)
 
       ctx = obj
       case typ
       when FrameType::DATA
+        # TODO: flow-control using @recv_window & ctx.recv_window
         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)
+          return [obj] if Biryani.err?(obj)
 
           ctx.stream.rx << obj
         end
@@ -186,7 +196,7 @@ module Biryani
         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)
+          return [obj] if Biryani.err?(obj)
 
           ctx.stream.rx << obj
         end
@@ -205,7 +215,8 @@ module Biryani
         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
         []
@@ -244,20 +255,22 @@ module Biryani
     # @param streams_ctx [StreamsContext]
     # @param stream_id [Integer]
     # @param max_streams [Integer]
+    # @param send_initial_window_size [Integer]
+    # @param recv_initial_window_size [Integer]
     # @param proc [Proc]
     #
     # @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, proc)
       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, proc) 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,7 +288,7 @@ 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)
@@ -283,38 +296,6 @@ module Biryani
       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 +305,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_data_frames(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]
@@ -375,21 +363,28 @@ module Biryani
     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 +397,22 @@ module Biryani
     #
     # @return [nil, ConnectionError]
     def self.handle_connection_window_update(window_update, send_window)
-      # TODO: send WINDOW_UPDATE
+      # TODO: send WINDOW_UPDATE to do the flow-conrol
       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 +423,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 +434,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,40 @@
 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_data_frames(stream_id, data, send_window, max_frame_size)
+        next if frames.empty?
+
+        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 +46,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?

data/lib/biryani/http_response.rb

@@ -34,28 +34,12 @@ module Biryani
       @res.content
     end
 
-    # @param stream_id [Integer]
     # @param encoder [Encoder]
-    # @param max_frame_size [Integer]
     #
-    # @return [Array<Object>] frames
-    def parse(stream_id, encoder, max_frame_size)
-      fragment = encoder.encode(fields)
-      len = (fragment.bytesize + max_frame_size - 1) / max_frame_size
-      frames = fragment.gsub(/.{1,#{max_frame_size}}/m).with_index.map do |s, index|
-        if index.zero?
-          Frame::Headers.new(len < 2, content.empty?, stream_id, nil, nil, s, nil)
-        else
-          Frame::Continuation.new(index == len - 1, stream_id, s)
-        end
-      end
-
-      len = (content.bytesize + max_frame_size - 1) / max_frame_size
-      frames += content.gsub(/.{1,#{max_frame_size}}/m).with_index.map do |s, index|
-        Frame::Data.new(index == len - 1, stream_id, s, nil)
-      end
-
-      frames
+    # @return [String] fragment
+    # @return [String] data
+    def parse(encoder)
+      [encoder.encode(fields), content]
     end
   end
 end

data/lib/biryani/state.rb

@@ -8,7 +8,7 @@ module Biryani
     # @param direction [:send, :recv]
     def transition!(frame, direction)
       obj = self.class.next(@state, frame, direction)
-      return obj if obj.is_a?(StreamError) || obj.is_a?(ConnectionError)
+      return obj if Biryani.err?(obj)
 
       @state = obj
     end
@@ -76,6 +76,8 @@ module Biryani
       # receiving_continuation_data
       in [:receiving_continuation_data, FrameType::RST_STREAM, _]
         :closed
+      in [:receiving_continuation_data, FrameType::WINDOW_UPDATE, :recv]
+        state
       in [:receiving_continuation_data, FrameType::CONTINUATION, :recv] if frame.end_headers?
         :receiving_data
       in [:receiving_continuation_data, FrameType::CONTINUATION, :recv]
@@ -86,6 +88,8 @@ module Biryani
       # receiving_continuation
       in [:receiving_continuation, FrameType::RST_STREAM, _]
         :closed
+      in [:receiving_continuation, FrameType::WINDOW_UPDATE, :recv]
+        state
       in [:receiving_continuation, FrameType::CONTINUATION, :recv] if frame.end_headers?
         :half_closed_remote
       in [:receiving_continuation, FrameType::CONTINUATION, :recv]
@@ -96,6 +100,8 @@ module Biryani
       # receiving_data
       in [:receiving_data, FrameType::DATA, :recv] if frame.end_stream?
         :half_closed_remote
+      in [:receiving_data, FrameType::WINDOW_UPDATE, :recv]
+        state
       in [:receiving_data, FrameType::DATA, :recv]
         state
       in [:receiving_data, FrameType::RST_STREAM, _]
@@ -136,6 +142,8 @@ module Biryani
       # sending_continuation_data
       in [:sending_continuation_data, FrameType::RST_STREAM, :send]
         :closed
+      in [:sending_continuation_data, FrameType::WINDOW_UPDATE, :recv]
+        state
       in [:sending_continuation_data, FrameType::CONTINUATION, :send] if frame.end_headers?
         :sending_data
       in [:sending_continuation_data, FrameType::CONTINUATION, :send]
@@ -148,6 +156,8 @@ module Biryani
       # sending_continuation
       in [:sending_continuation, FrameType::RST_STREAM, :send]
         :closed
+      in [:sending_continuation, FrameType::WINDOW_UPDATE, :recv]
+        state
       in [:sending_continuation, FrameType::CONTINUATION, :send] if frame.end_headers?
         :closed
       in [:sending_continuation, FrameType::CONTINUATION, :send]
@@ -160,6 +170,8 @@ module Biryani
       # sending_data
       in [:sending_data, FrameType::DATA, :send] if frame.end_stream?
         :closed
+      in [:sending_data, FrameType::WINDOW_UPDATE, :recv]
+        state
       in [:sending_data, FrameType::DATA, :send]
         state
       in [:sending_data, FrameType::RST_STREAM, :send]
@@ -213,7 +225,7 @@ module Biryani
 
     # @return [Boolean]
     def active?
-      @state == :open || @state == :half_closed_local || @state == :half_closed_remote
+      !%i[idle reserved_local reserved_remote closed].include?(@state)
     end
 
     # @return [Boolean]