cybrid_api_id_ruby 0.129.1137 → 0.129.1138

data/vendor/bundle/ruby/4.0.0/gems/http-2-1.2.3/lib/http/2/header.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module HTTP2
+  # Implementation of header compression for HTTP 2.0 (HPACK) format adapted
+  # to efficiently represent HTTP headers in the context of HTTP 2.0.
+  #
+  # - http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-10
+  module Header
+    # Header representation as defined by the spec.
+    HEADREP = {
+      indexed: { prefix: 7, pattern: 0x80 },
+      incremental: { prefix: 6, pattern: 0x40 },
+      noindex: { prefix: 4, pattern: 0x00 },
+      neverindexed: { prefix: 4, pattern: 0x10 },
+      changetablesize: { prefix: 5, pattern: 0x20 }
+    }.each_value(&:freeze).freeze
+
+    # Predefined options set for Compressor
+    # http://mew.org/~kazu/material/2014-hpack.pdf
+    NAIVE    = { index: :never,  huffman: :never   }.freeze
+    LINEAR   = { index: :all,    huffman: :never   }.freeze
+    STATIC   = { index: :static, huffman: :never   }.freeze
+    SHORTER  = { index: :all,    huffman: :never   }.freeze
+    NAIVEH   = { index: :never,  huffman: :always  }.freeze
+    LINEARH  = { index: :all,    huffman: :always  }.freeze
+    STATICH  = { index: :static, huffman: :always  }.freeze
+    SHORTERH = { index: :all,    huffman: :shorter }.freeze
+  end
+end
+
+require "http/2/header/huffman"
+require "http/2/header/huffman_statemachine"
+require "http/2/header/encoding_context"
+require "http/2/header/compressor"
+require "http/2/header/decompressor"

data/vendor/bundle/ruby/4.0.0/gems/http-2-1.2.3/lib/http/2/server.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+module HTTP2
+  # HTTP 2.0 server connection class that implements appropriate header
+  # compression / decompression algorithms and stream management logic.
+  #
+  # Your code is responsible for feeding request data to the server object,
+  # which in turn performs all of the necessary HTTP 2.0 decoding / encoding,
+  # state management, and the rest. A simple example:
+  #
+  # @example
+  #     socket = YourTransport.new
+  #
+  #     conn = HTTP2::Server.new
+  #     conn.on(:stream) do |stream|
+  #       ...
+  #     end
+  #
+  #     while bytes = socket.read
+  #       conn << bytes
+  #     end
+  #
+  class Server < Connection
+    attr_reader :origin_set
+
+    # Initialize new HTTP 2.0 server object.
+    def initialize(settings = {})
+      @stream_id    = 2
+      @state        = :waiting_magic
+
+      @local_role   = :server
+      @remote_role  = :client
+
+      @origin_set = []
+      @origins_sent = true
+
+      super
+    end
+
+    #   GET / HTTP/1.1
+    #   Host: server.example.com
+    #   Connection: Upgrade, HTTP2-Settings
+    #   Upgrade: h2c
+    #   HTTP2-Settings: <base64url encoding of HTTP/2 SETTINGS payload>
+    #
+    # Requests that contain a payload body MUST be sent in their entirety
+    # before the client can send HTTP/2 frames. This means that a large
+    # request can block the use of the connection until it is completely sent.
+    #
+    # If concurrency of an initial request with subsequent requests is
+    # important, an OPTIONS request can be used to perform the upgrade to
+    # HTTP/2, at the cost of an additional round trip.
+    #
+    #   HTTP/1.1 101 Switching Protocols
+    #   Connection: Upgrade
+    #   Upgrade: h2c
+    #
+    #   [ HTTP/2 connection ...
+    #
+    # - The first HTTP/2 frame sent by the server MUST be a server
+    #   connection preface (Section 3.5) consisting of a SETTINGS frame.
+    # - Upon receiving the 101 response, the client MUST send a connection
+    #   preface (Section 3.5), which includes a SETTINGS frame.
+    #
+    # The HTTP/1.1 request that is sent prior to upgrade is assigned a stream
+    # identifier of 1 (see Section 5.1.1) with default priority values
+    # (Section 5.3.5). Stream 1 is implicitly "half-closed" from the client
+    # toward the server (see Section 5.1), since the request is completed as
+    # an HTTP/1.1 request. After commencing the HTTP/2 connection, stream 1
+    # is used for the response.
+    #
+    def upgrade(settings, headers, body)
+      @h2c_upgrade = :start
+
+      # Pretend that we've received the preface
+      #  - puts us into :waiting_connection_preface state
+      #  - emits a SETTINGS frame to the client
+      receive(CONNECTION_PREFACE_MAGIC)
+
+      # Process received HTTP2-Settings payload
+      receive(@framer.generate(
+                type: :settings,
+                stream: 0,
+                flags: 0,
+                payload: Base64.urlsafe_decode64(settings.to_s)
+              ))
+
+      # Activate stream (id: 1) with on HTTP/1.1 request parameters
+      stream = activate_stream(id: 1)
+      emit(:stream, stream)
+
+      headers_frame = {
+        type: :headers,
+        flags: END_HEADERS,
+        stream: 1,
+        weight: DEFAULT_WEIGHT,
+        dependency: 0,
+        exclusive: false,
+        payload: headers
+      } #: headers_frame
+
+      if body.empty?
+        headers_frame[:flags] |= END_STREAM
+        stream << headers_frame
+      else
+        stream << headers_frame
+        stream << { type: :data, stream: 1, payload: body, flags: END_STREAM }
+      end
+
+      # Mark h2c upgrade as finished
+      @h2c_upgrade = :finished
+
+      # Transition back to :waiting_magic and wait for client's preface
+      @state = :waiting_magic
+    end
+
+    def activate_stream(**)
+      super.tap do |stream|
+        stream.on(:promise, &method(:promise))
+      end
+    end
+
+    def origin_set=(origins)
+      @origin_set = Array(origins).map(&:to_s)
+      @origins_sent = @origin_set.empty?
+    end
+
+    private
+
+    def connection_settings(frame)
+      super
+      return unless frame[:flags].anybits?(ACK) && !@origins_sent
+
+      send(type: :origin, stream: 0, payload: @origin_set)
+    end
+
+    def verify_pseudo_headers(frame)
+      _verify_pseudo_headers(frame, REQUEST_MANDATORY_HEADERS)
+    end
+
+    # Handle locally initiated server-push event emitted by the stream.
+    #
+    # @param parent [Stream]
+    # @param headers [Enumerable[String, String]]
+    # @param flags Integer
+    # @param callback [Proc]
+    def promise(parent, headers, flags)
+      promise = new_stream(parent: parent)
+      promise.send(
+        type: :push_promise,
+        flags: flags,
+        stream: parent.id,
+        promise_stream: promise.id,
+        payload: headers
+      )
+
+      yield(promise)
+    end
+  end
+end

data/vendor/bundle/ruby/4.0.0/gems/http-2-1.2.3/lib/http/2/settings.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module HTTP2
+  MAX_HEADER_LIST_SIZE = (2 << 30) - 1
+
+  # Default values for SETTINGS frame, as defined by the spec.
+  SPEC_DEFAULT_CONNECTION_SETTINGS = {
+    settings_header_table_size: 4096,
+    settings_enable_push: 1, # enabled for servers
+    settings_max_concurrent_streams: Framer::MAX_STREAM_ID, # unlimited
+    settings_initial_window_size: 65_535,
+    settings_max_frame_size: 16_384,
+    settings_max_header_list_size: MAX_HEADER_LIST_SIZE # unlimited
+  }.freeze
+
+  ENCODING_CONTEXT_SETTINGS = %i[huffman index table_size].freeze
+
+  Settings = Struct.new(
+    # connection settings
+    :settings_header_table_size,
+    :settings_enable_push,
+    :settings_max_concurrent_streams,
+    :settings_initial_window_size,
+    :settings_max_frame_size,
+    :settings_max_header_list_size,
+    # encoding context settings
+    :huffman,
+    :index,
+    :table_size,
+    keyword_init: true
+  ) do
+    def initialize(
+      # connection settings
+      settings_header_table_size: 4096,
+      settings_enable_push: 1,
+      settings_max_concurrent_streams: 100,
+      settings_initial_window_size: 65_535,
+      settings_max_frame_size: 16_384,
+      settings_max_header_list_size: MAX_HEADER_LIST_SIZE,
+      # encoding context settings
+      huffman: :shorter,
+      index: :all,
+      table_size: 4096
+    )
+      super
+    end
+
+    def connection_settings
+      return enum_for(__method__) unless block_given?
+
+      each_pair do |k, v|
+        next if ENCODING_CONTEXT_SETTINGS.include?(k)
+
+        yield k, v
+      end
+    end
+  end
+end