biryani 0.0.1

data/lib/biryani/state.rb

@@ -0,0 +1,224 @@
+module Biryani
+  class State
+    def initialize
+      @state = :idle
+    end
+
+    # @param frame [Object]
+    # @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)
+
+      @state = obj
+    end
+
+    #                          +--------+
+    #                  send PP |        | recv PP
+    #                 ,--------+  idle  +--------.
+    #                /         |        |         \
+    #               v          +--------+          v
+    #        +----------+          |           +----------+
+    #        |          |          | send H /  |          |
+    # ,------+ reserved |          | recv H    | reserved +------.
+    # |      | (local)  |          |           | (remote) |      |
+    # |      +---+------+          v           +------+---+      |
+    # |          |             +--------+             |          |
+    # |          |     recv ES |        | send ES     |          |
+    # |   send H |     ,-------+  open  +-------.     | recv H   |
+    # |          |    /        |        |        \    |          |
+    # |          v   v         +---+----+         v   v          |
+    # |      +----------+          |           +----------+      |
+    # |      |   half-  |          |           |   half-  |      |
+    # |      |  closed  |          | send R /  |  closed  |      |
+    # |      | (remote) |          | recv R    | (local)  |      |
+    # |      +----+-----+          |           +-----+----+      |
+    # |           |                |                 |           |
+    # |           | send ES /      |       recv ES / |           |
+    # |           |  send R /      v        send R / |           |
+    # |           |  recv R    +--------+   recv R   |           |
+    # | send R /  `----------->|        |<-----------'  send R / |
+    # | recv R                 | closed |               recv R   |
+    # `----------------------->|        |<-----------------------'
+    #                          +--------+
+    # https://datatracker.ietf.org/doc/html/rfc9113#section-5.1
+    #
+    # @param state [Symbol]
+    # @param frame [Object]
+    # @param direction [:send, :recv]
+    #
+    # @raise [StandardError]
+    #
+    # @return [Symbol, ConnectionError]
+    # rubocop: disable Metrics/AbcSize
+    # rubocop: disable Metrics/CyclomaticComplexity
+    # rubocop: disable Metrics/MethodLength
+    # rubocop: disable Metrics/PerceivedComplexity
+    def self.next(state, frame, direction)
+      typ = frame.f_type
+      case [state, typ, direction]
+      # idle
+      in [:idle, FrameType::HEADERS, :recv] if frame.end_stream? && frame.end_headers?
+        :half_closed_remote
+      in [:idle, FrameType::HEADERS, :recv] if frame.end_headers?
+        :receiving_data
+      in [:idle, FrameType::HEADERS, :recv] if frame.end_stream?
+        :receiving_continuation
+      in [:idle, FrameType::HEADERS, :recv]
+        :receiving_continuation_data
+      in [:idle, FrameType::PRIORITY, :recv]
+        state
+      in [:idle, FrameType::PUSH_PROMISE, :send]
+        :reserved_local
+      in [:idle, _, _]
+        unexpected(ErrorCode::PROTOCOL_ERROR, state, typ, direction)
+
+      # receiving_continuation_data
+      in [:receiving_continuation_data, FrameType::RST_STREAM, _]
+        :closed
+      in [:receiving_continuation_data, FrameType::CONTINUATION, :recv] if frame.end_headers?
+        :receiving_data
+      in [:receiving_continuation_data, FrameType::CONTINUATION, :recv]
+        state
+      in [:receiving_continuation_data, _, _]
+        unexpected(ErrorCode::PROTOCOL_ERROR, state, typ, direction)
+
+      # receiving_continuation
+      in [:receiving_continuation, FrameType::RST_STREAM, _]
+        :closed
+      in [:receiving_continuation, FrameType::CONTINUATION, :recv] if frame.end_headers?
+        :half_closed_remote
+      in [:receiving_continuation, FrameType::CONTINUATION, :recv]
+        state
+      in [:receiving_continuation, _, _]
+        unexpected(ErrorCode::PROTOCOL_ERROR, state, typ, direction)
+
+      # receiving_data
+      in [:receiving_data, FrameType::DATA, :recv] if frame.end_stream?
+        :half_closed_remote
+      in [:receiving_data, FrameType::DATA, :recv]
+        state
+      in [:receiving_data, FrameType::RST_STREAM, _]
+        :closed
+      in [:receiving_data, _, _]
+        unexpected(ErrorCode::PROTOCOL_ERROR, state, typ, direction)
+
+      # reserved_remote
+      in [:reserved_remote, _, _]
+        # TODO
+        state
+
+      # reserved_local
+      in [:reserved_local, _, _]
+        # TODO
+        state
+
+      # half_closed_remote
+      in [:half_closed_remote, FrameType::HEADERS, :send] if frame.end_stream? && frame.end_headers?
+        :closed
+      in [:half_closed_remote, FrameType::HEADERS, :send] if frame.end_headers?
+        :sending_data
+      in [:half_closed_remote, FrameType::HEADERS, :send] if frame.end_stream?
+        :sending_continuation
+      in [:half_closed_remote, FrameType::HEADERS, :send]
+        :sending_continuation_data
+      in [:half_closed_remote, FrameType::PRIORITY, :recv]
+        state
+      in [:half_closed_remote, FrameType::RST_STREAM, _]
+        :closed
+      in [half_closed_remote, FrameType::WINDOW_UPDATE, :recv]
+        state
+      in [:half_closed_remote, _, :recv]
+        unexpected(ErrorCode::STREAM_CLOSED, state, typ, direction)
+      in [:half_closed_local, _, :send]
+        unreachable(state, typ, direction)
+
+      # sending_continuation_data
+      in [:sending_continuation_data, FrameType::RST_STREAM, :send]
+        :closed
+      in [:sending_continuation_data, FrameType::CONTINUATION, :send] if frame.end_headers?
+        :sending_data
+      in [:sending_continuation_data, FrameType::CONTINUATION, :send]
+        state
+      in [:sending_continuation_data, _, :send]
+        unreachable(state, typ, direction)
+      in [:sending_continuation_data, _, :recv]
+        unexpected(ErrorCode::PROTOCOL_ERROR, state, typ, direction)
+
+      # sending_continuation
+      in [:sending_continuation, FrameType::RST_STREAM, :send]
+        :closed
+      in [:sending_continuation, FrameType::CONTINUATION, :send] if frame.end_headers?
+        :closed
+      in [:sending_continuation, FrameType::CONTINUATION, :send]
+        state
+      in [:sending_continuation, _, :send]
+        unreachable(state, typ, direction)
+      in [:sending_continuation, _, :recv]
+        unexpected(ErrorCode::PROTOCOL_ERROR, state, typ, direction)
+
+      # sending_data
+      in [:sending_data, FrameType::DATA, :send] if frame.end_stream?
+        :closed
+      in [:sending_data, FrameType::DATA, :send]
+        state
+      in [:sending_data, FrameType::RST_STREAM, :send]
+        :closed
+      in [:sending_continuation, _, :send]
+        unreachable(state, typ, direction)
+      in [:sending_continuation, _, :recv]
+        unexpected(ErrorCode::PROTOCOL_ERROR, state, typ, direction)
+
+      # closed
+      in [:closed, FrameType::RST_STREAM, :recv]
+        state
+      in [:closed, _, :send]
+        unreachable(state, typ, direction)
+      in [:closed, _, :recv]
+        unexpected(ErrorCode::STREAM_CLOSED, state, typ, direction)
+
+      # other
+      in [_, _, :send]
+        unreachable(state, typ, direction)
+      in [_, _, :recv]
+        unexpected(ErrorCode::STREAM_CLOSED, state, typ, direction)
+      end
+    end
+    # rubocop: enable Metrics/AbcSize
+    # rubocop: enable Metrics/CyclomaticComplexity
+    # rubocop: enable Metrics/MethodLength
+    # rubocop: enable Metrics/PerceivedComplexity
+
+    def self.unexpected(error_code, state, typ, direction)
+      ConnectionError.new(error_code, "#{direction} unexpected #{format('0x%02x', typ)} frame in #{state}")
+    end
+
+    def self.unreachable(state, typ, direction)
+      raise "#{direction} unexpected #{format('0x%02x', typ)} frame in #{state}"
+    end
+
+    def close
+      @state = :closed
+    end
+
+    # @return [Boolean]
+    def closed?
+      @state == :closed
+    end
+
+    # @return [Boolean]
+    def idle?
+      @state == :idle
+    end
+
+    # @return [Boolean]
+    def active?
+      @state == :open || @state == :half_closed_local || @state == :half_closed_remote
+    end
+
+    # @return [Boolean]
+    def half_closed_remote?
+      @state == :half_closed_remote
+    end
+  end
+end

data/lib/biryani/stream.rb

@@ -0,0 +1,19 @@
+module Biryani
+  class Stream
+    attr_accessor :rx
+
+    # @param tx [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.new(0, {}, '')
+
+          proc.call(req, res)
+          tx << [res, stream_id]
+        end
+      end
+    end
+  end
+end

data/lib/biryani/stream_error.rb

@@ -0,0 +1,17 @@
+module Biryani
+  class StreamError
+    # @param code [Integer]
+    # @param stream_id [stream_id]
+    # @param debug [String]
+    def initialize(code, stream_id, debug)
+      @code = code
+      @stream_id = stream_id
+      @debug = debug
+    end
+
+    # @return [RstStream]
+    def rst_stream
+      Frame::RstStream.new(@stream_id, @code)
+    end
+  end
+end

data/lib/biryani/streams_context.rb

@@ -0,0 +1,89 @@
+module Biryani
+  class StreamsContext
+    def initialize
+      @h = {}
+    end
+
+    # @param stream_id [Integer]
+    # @param proc [Proc]
+    #
+    # @return [StreamContext]
+    def new_context(stream_id, proc)
+      ctx = StreamContext.new(stream_id, proc)
+      @h[stream_id] = ctx
+      ctx
+    end
+
+    # @param stream_id [Integer]
+    def delete(stream_id)
+      @h.delete(stream_id)
+    end
+
+    # @param stream_id [Integer]
+    #
+    # @return [StreamContext, nil]
+    def [](stream_id)
+      @h[stream_id]
+    end
+
+    # @return [Integer]
+    def length
+      @h.length
+    end
+
+    def each(&block)
+      @h.each_value(&block)
+    end
+
+    # @return [Array<Port>]
+    def txs
+      @h.values.filter { |ctx| !ctx.closed? }.map(&:tx)
+    end
+
+    # @return [Integer]
+    def count_active
+      @h.values.filter(&:active?).length
+    end
+
+    # @return [Array<Integer>]
+    def closed_stream_ids
+      @h.filter { |_, ctx| ctx.closed? }.keys
+    end
+
+    # @return [Integer]
+    def last_stream_id
+      @h.reject { |_, ctx| ctx.idle? }.keys.max || 0
+    end
+  end
+
+  class StreamContext
+    attr_accessor :stream, :tx, :send_window, :recv_window, :fragment, :content, :state
+
+    # @param stream_id [Integer]
+    # @param proc [Proc]
+    def initialize(stream_id, proc)
+      @tx = Ractor::Port.new
+      @stream = Stream.new(@tx, stream_id, proc)
+      @send_window = Window.new
+      @recv_window = Window.new
+      @fragment = StringIO.new
+      @content = StringIO.new
+      @state = State.new
+    end
+
+    # @return [Boolean]
+    def closed?
+      @state.closed?
+    end
+
+    # @return [Boolean]
+    def idle?
+      @state.idle?
+    end
+
+    # @return [Boolean]
+    def active?
+      @state.active?
+    end
+  end
+end

data/lib/biryani/version.rb

@@ -0,0 +1,3 @@
+module Biryani
+  VERSION = '0.0.1'.freeze
+end

data/lib/biryani/window.rb

@@ -0,0 +1,29 @@
+module Biryani
+  class Window
+    def initialize
+      @window = 2**16 - 1
+    end
+
+    # @param length [Integer]
+    #
+    # @return [Boolean]
+    def available?(length)
+      @window > length
+    end
+
+    # @param length [Integer]
+    def consume!(length)
+      @window -= length
+    end
+
+    # @param length [Integer]
+    def increase!(length)
+      @window += length
+    end
+
+    # @return [Integer]
+    def length
+      @window
+    end
+  end
+end

data/lib/biryani.rb

@@ -0,0 +1,17 @@
+require 'stringio'
+require 'uri'
+
+require_relative 'biryani/connection'
+require_relative 'biryani/connection_error'
+require_relative 'biryani/data_buffer'
+require_relative 'biryani/frame'
+require_relative 'biryani/hpack'
+require_relative 'biryani/http_request'
+require_relative 'biryani/http_response'
+require_relative 'biryani/server'
+require_relative 'biryani/state'
+require_relative 'biryani/streams_context'
+require_relative 'biryani/stream_error'
+require_relative 'biryani/stream'
+require_relative 'biryani/version'
+require_relative 'biryani/window'

data/spec/connection/close_all_streams_spec.rb

@@ -0,0 +1,17 @@
+require_relative '../spec_helper'
+
+RSpec.describe Connection do
+  context 'close_all_streams' do
+    let(:streams_ctx) do
+      streams_ctx = StreamsContext.new
+      streams_ctx.new_context(1, do_nothing_proc)
+      streams_ctx.new_context(2, do_nothing_proc)
+      streams_ctx
+    end
+    it 'should close' do
+      Connection.close_all_streams(streams_ctx)
+      expect { streams_ctx[1].tx << nil }.to raise_error Ractor::ClosedError
+      expect { streams_ctx[2].tx << nil }.to raise_error Ractor::ClosedError
+    end
+  end
+end

data/spec/connection/handle_connection_window_update_spec.rb

@@ -0,0 +1,16 @@
+require_relative '../spec_helper'
+
+RSpec.describe Connection do
+  context 'handle_connection_window_update' do
+    let(:window_update) do
+      Frame::WindowUpdate.new(0, 1000)
+    end
+    let(:send_window) do
+      Window.new
+    end
+    it 'should handle' do
+      expect { Connection.handle_connection_window_update(window_update, send_window) }.not_to raise_error
+      expect(send_window.length).to eq 2**16 - 1 + 1000
+    end
+  end
+end

data/spec/connection/handle_ping_spec.rb

@@ -0,0 +1,21 @@
+require_relative '../spec_helper'
+
+RSpec.describe Connection do
+  context 'handle_ping' do
+    let(:ping1) do
+      Frame::Ping.new(true, 0, "\x00" * 8)
+    end
+    it 'should handle' do
+      expect(Connection.handle_ping(ping1)).to eq nil
+    end
+
+    let(:ping2) do
+      Frame::Ping.new(false, 0, "\x00" * 8)
+    end
+    it 'should handle' do
+      expect(Connection.handle_ping(ping2)).to_not eq nil
+      expect(Connection.handle_ping(ping2).ack?).to eq true
+      expect(Connection.handle_ping(ping2).opaque).to eq "\x00" * 8
+    end
+  end
+end

data/spec/connection/handle_rst_stream_spec.rb

@@ -0,0 +1,21 @@
+require_relative '../spec_helper'
+
+RSpec.describe Connection do
+  context 'handle_rst_stream' do
+    let(:rst_stream) do
+      Frame::RstStream.new(2, 0)
+    end
+    let(:streams_ctx) do
+      streams_ctx = StreamsContext.new
+      streams_ctx.new_context(1, do_nothing_proc)
+      streams_ctx.new_context(2, do_nothing_proc)
+      streams_ctx
+    end
+    it 'should handle' do
+      Connection.handle_rst_stream(rst_stream, streams_ctx)
+      expect(streams_ctx.length).to eq 2
+      expect(streams_ctx.count_active).to eq 0
+      expect(streams_ctx.closed_stream_ids.length).to eq 1
+    end
+  end
+end

data/spec/connection/handle_settings_spec.rb

@@ -0,0 +1,31 @@
+require_relative '../spec_helper'
+
+RSpec.describe Connection do
+  context 'handle_settings' do
+    let(:send_settings) do
+      Connection.default_settings
+    end
+    let(:decoder) do
+      HPACK::Decoder.new(4_096)
+    end
+
+    let(:settings1) do
+      Frame::Settings.new(false, 0, { SettingsID::SETTINGS_HEADER_TABLE_SIZE => 8_192 })
+    end
+    it 'should handle' do
+      reply_settings = Connection.handle_settings(settings1, send_settings, decoder)
+      expect(reply_settings.ack?).to eq true
+      expect(reply_settings.setting.empty?).to eq true
+      expect(send_settings[SettingsID::SETTINGS_MAX_CONCURRENT_STREAMS]).to eq 0xffffffff
+      expect(send_settings[SettingsID::SETTINGS_MAX_FRAME_SIZE]).to eq 16_384
+      expect(send_settings[SettingsID::SETTINGS_HEADER_TABLE_SIZE]).to eq 8_192
+    end
+
+    let(:settings2) do
+      Frame::Settings.new(true, 0, {})
+    end
+    it 'should handle' do
+      expect(Connection.handle_settings(settings2, send_settings, decoder)).to eq nil
+    end
+  end
+end

data/spec/connection/handle_stream_window_update_spec.rb

@@ -0,0 +1,20 @@
+require_relative '../spec_helper'
+
+RSpec.describe Connection do
+  context 'handle_stream_window_update' do
+    let(:window_update) do
+      Frame::WindowUpdate.new(1, 1000)
+    end
+    let(:streams_ctx) do
+      streams_ctx = StreamsContext.new
+      streams_ctx.new_context(1, do_nothing_proc)
+      streams_ctx.new_context(2, do_nothing_proc)
+      streams_ctx
+    end
+    it 'should handle' do
+      expect { Connection.handle_stream_window_update(window_update, streams_ctx) }.not_to raise_error
+      expect(streams_ctx[1].send_window.length).to eq 2**16 - 1 + 1000
+      expect(streams_ctx[2].send_window.length).to eq 2**16 - 1
+    end
+  end
+end

data/spec/connection/read_http2_magic_spec.rb

@@ -0,0 +1,26 @@
+require_relative '../spec_helper'
+
+RSpec.describe Connection do
+  context 'read_http2_magic' do
+    let(:io1) do
+      StringIO.new("PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n")
+    end
+    it 'should read' do
+      expect(Connection.read_http2_magic(io1)).to eq nil
+    end
+
+    let(:io2) do
+      StringIO.new("PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n\x00xff")
+    end
+    it 'should read' do
+      expect(Connection.read_http2_magic(io2)).to eq nil
+    end
+
+    let(:io3) do
+      StringIO.new("\x00xffPRI * HTTP/2.0\r\n\r\nSM\r\n\r\n")
+    end
+    it 'should not read' do
+      expect(Connection.read_http2_magic(io3)).to be_kind_of ConnectionError
+    end
+  end
+end

data/spec/connection/remove_closed_streams_spec.rb

@@ -0,0 +1,51 @@
+require_relative '../spec_helper'
+
+RSpec.describe Connection do
+  context 'remove_closed_streams' do
+    let(:streams_ctx1) do
+      streams_ctx = StreamsContext.new
+      streams_ctx.new_context(1, do_nothing_proc)
+      streams_ctx.new_context(2, do_nothing_proc)
+      streams_ctx
+    end
+    let(:data_buffer1) do
+      DataBuffer.new
+    end
+    it 'should close' do
+      Connection.remove_closed_streams(streams_ctx1, data_buffer1)
+      expect(streams_ctx1.length).to eq 2
+    end
+
+    let(:streams_ctx2) do
+      streams_ctx = StreamsContext.new
+      streams_ctx.new_context(1, do_nothing_proc)
+      streams_ctx.new_context(2, do_nothing_proc)
+      streams_ctx[2].state.close
+      streams_ctx
+    end
+    let(:data_buffer2) do
+      DataBuffer.new
+    end
+    it 'should close' do
+      Connection.remove_closed_streams(streams_ctx2, data_buffer2)
+      expect(streams_ctx2.length).to eq 2 # remain stream_id
+    end
+
+    let(:streams_ctx3) do
+      streams_ctx = StreamsContext.new
+      streams_ctx.new_context(1, do_nothing_proc)
+      streams_ctx.new_context(2, do_nothing_proc)
+      streams_ctx[2].state.close
+      streams_ctx
+    end
+    let(:data_buffer3) do
+      data_buffer = DataBuffer.new
+      data_buffer << Frame::Data.new(false, 2, 'two', nil)
+      data_buffer
+    end
+    it 'should close' do
+      Connection.remove_closed_streams(streams_ctx3, data_buffer3)
+      expect(streams_ctx3.length).to eq 2
+    end
+  end
+end