cybrid_api_organization_ruby 0.129.1137 → 0.129.1138

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/lib/httpx/plugins/stream_bidi.rb

@@ -0,0 +1,410 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Plugins
+    #
+    # This plugin adds support for bidirectional HTTP/2 streams.
+    #
+    # https://gitlab.com/os85/httpx/wikis/StreamBidi
+    #
+    # It is required that the request body allows chunk to be buffered, (i.e., responds to +#<<(chunk)+).
+    module StreamBidi
+      # Extension of the Connection::HTTP2 class, which adds functionality to
+      # deal with a request that can't be drained and must be interleaved with
+      # the response streams.
+      #
+      # The streams keeps send DATA frames while there's data; when they're ain't,
+      # the stream is kept open; it must be explicitly closed by the end user.
+      #
+      module HTTP2Methods
+        def initialize(*)
+          super
+          @lock = Thread::Mutex.new
+        end
+
+        %i[close empty? exhausted? send <<].each do |lock_meth|
+          class_eval(<<-METH, __FILE__, __LINE__ + 1)
+            # lock.aware version of +#{lock_meth}+
+            def #{lock_meth}(*)                # def close(*)
+              return super unless @options.stream
+
+              return super if @lock.owned?
+
+              # small race condition between
+              # checking for ownership and
+              # acquiring lock.
+              # TODO: fix this at the parser.
+              @lock.synchronize { super }
+            end
+          METH
+        end
+
+        private
+
+        %i[join_headers join_trailers join_body].each do |lock_meth|
+          class_eval(<<-METH, __FILE__, __LINE__ + 1)
+            # lock.aware version of +#{lock_meth}+
+            private def #{lock_meth}(*)                # private def join_headers(*)
+              return super unless @options.stream
+
+              return super if @lock.owned?
+
+              # small race condition between
+              # checking for ownership and
+              # acquiring lock.
+              # TODO: fix this at the parser.
+              @lock.synchronize { super }
+            end
+          METH
+        end
+
+        def handle_stream(stream, request)
+          return super unless @options.stream
+
+          request.flush_buffer_on_body do
+            next unless request.headers_sent
+
+            handle(request, stream)
+
+            emit(:flush_buffer)
+          end
+          super
+        end
+
+        # when there ain't more chunks, it makes the buffer as full.
+        def send_chunk(request, stream, chunk, next_chunk)
+          return super unless @options.stream
+
+          super
+
+          return if next_chunk
+
+          request.transition(:waiting_for_chunk)
+          throw(:buffer_full)
+        end
+
+        # sets end-stream flag when the request is closed.
+        def end_stream?(request, next_chunk)
+          return super unless @options.stream
+
+          request.closed? && next_chunk.nil?
+        end
+      end
+
+      # BidiBuffer is a thread-safe Buffer which can receive data from any thread.
+      #
+      # It uses a dual-buffer strategy with mutex protection:
+      # - +@buffer+ is the main buffer, protected by +@buffer_mutex+
+      # - +@oob_buffer+ receives data when +@buffer_mutex+ is contended
+      #
+      # This allows non-blocking writes from any thread while maintaining thread safety.
+      class BidiBuffer < Buffer
+        def initialize(*)
+          super
+          @buffer_mutex = Thread::Mutex.new
+          @oob_mutex = Thread::Mutex.new
+          @oob_buffer = "".b
+        end
+
+        # buffers the +chunk+ to be sent (thread-safe, non-blocking)
+        def <<(chunk)
+          if @buffer_mutex.try_lock
+            begin
+              super
+            ensure
+              @buffer_mutex.unlock
+            end
+          else
+            # another thread holds the lock, use OOB buffer to avoid blocking
+            @oob_mutex.synchronize { @oob_buffer << chunk }
+          end
+        end
+
+        # reconciles the main and secondary buffer (thread-safe, callable from any thread).
+        def rebuffer
+          @buffer_mutex.synchronize do
+            @oob_mutex.synchronize do
+              return if @oob_buffer.empty?
+
+              @buffer << @oob_buffer
+              @oob_buffer.clear
+            end
+          end
+        end
+
+        Buffer.instance_methods - Object.instance_methods - %i[<<].each do |meth|
+          class_eval(<<-MOD, __FILE__, __LINE__ + 1)
+            def #{meth}(*) # def empty?
+              @buffer_mutex.synchronize { super }
+            end
+          MOD
+        end
+      end
+
+      # Proxy to wake up the session main loop when one
+      # of the connections has buffered data to write. It abides by the HTTPX::_Selectable API,
+      # which allows it to be registered in the selector alongside actual HTTP-based
+      # HTTPX::Connection objects.
+      class Signal
+        attr_reader :error
+
+        def initialize
+          @closed = false
+          @error = nil
+          @pipe_read, @pipe_write = IO.pipe
+        end
+
+        def state
+          @closed ? :closed : :open
+        end
+
+        # noop
+        def log(**, &_); end
+
+        def to_io
+          @pipe_read.to_io
+        end
+
+        def wakeup
+          return if @closed
+
+          @pipe_write.write("\0")
+        end
+
+        def call
+          return if @closed
+
+          @pipe_read.readpartial(1)
+        end
+
+        def initial_call; end
+
+        def interests
+          return if @closed
+
+          :r
+        end
+
+        def timeout; end
+
+        def inflight?
+          !@closed
+        end
+
+        def force_close(*)
+          terminate
+        end
+
+        def terminate
+          return if @closed
+
+          @pipe_write.close
+          @pipe_read.close
+          @closed = true
+        end
+
+        def on_error(error)
+          @error = error
+          terminate
+        end
+
+        alias_method :on_io_error, :on_error
+
+        # noop (the owner connection will take of it)
+        def handle_socket_timeout(interval); end
+      end
+
+      class << self
+        def load_dependencies(klass)
+          klass.plugin(:stream)
+        end
+
+        def extra_options(options)
+          options.merge(fallback_protocol: "h2")
+        end
+      end
+
+      module InstanceMethods
+        def initialize(*)
+          @signal = Signal.new
+          super
+        end
+
+        def close(selector = Selector.new)
+          @signal.terminate
+          selector.deregister(@signal)
+          super
+        end
+
+        def select_connection(connection, selector)
+          return super unless connection.options.stream
+
+          super
+          selector.register(@signal)
+          connection.signal = @signal
+        end
+
+        def deselect_connection(connection, *)
+          return super unless connection.options.stream
+
+          super
+
+          connection.signal = nil
+        end
+      end
+
+      # Adds synchronization to request operations which may buffer payloads from different
+      # threads.
+      module RequestMethods
+        attr_accessor :headers_sent
+
+        def initialize(*)
+          super
+          @headers_sent = false
+          @closed = false
+          @flush_buffer_on_body_cb = nil
+          @mutex = Thread::Mutex.new
+        end
+
+        def flush_buffer_on_body(&cb)
+          @flush_buffer_on_body_cb = on(:body, &cb)
+        end
+
+        def closed?
+          return super unless @options.stream
+
+          @closed
+        end
+
+        def can_buffer?
+          return super unless @options.stream
+
+          super && @state != :waiting_for_chunk
+        end
+
+        # overrides state management transitions to introduce an intermediate
+        # +:waiting_for_chunk+ state, which the request transitions to once payload
+        # is buffered.
+        def transition(nextstate)
+          return super unless @options.stream
+
+          headers_sent = @headers_sent
+
+          case nextstate
+          when :idle
+            headers_sent = false
+
+            if @flush_buffer_on_body_cb
+              callbacks(:body).delete(@flush_buffer_on_body_cb)
+              @flush_buffer_on_body_cb = nil
+            end
+          when :waiting_for_chunk
+            return unless @state == :body
+          when :body
+            case @state
+            when :headers
+              headers_sent = true
+            when :waiting_for_chunk
+              # HACK: to allow super to pass through
+              @state = :headers
+            end
+          end
+
+          super.tap do
+            # delay setting this up until after the first transition to :body
+            @headers_sent = headers_sent
+          end
+        end
+
+        def <<(chunk)
+          @mutex.synchronize do
+            if @drainer
+              @body.clear if @body.respond_to?(:clear)
+              @drainer = nil
+            end
+            @body << chunk
+
+            transition(:body)
+          end
+        end
+
+        def close
+          return super unless @options.stream
+
+          @mutex.synchronize do
+            return if @closed
+
+            @closed = true
+          end
+
+          # last chunk to send which ends the stream
+          self << ""
+        end
+      end
+
+      module RequestBodyMethods
+        def initialize(*, **)
+          super
+
+          return unless @options.stream
+
+          @headers.delete("content-length")
+
+          return unless @body
+
+          return if @body.is_a?(Transcoder::Body::Encoder)
+
+          raise Error, "bidirectional streams only allow the usage of the `:body` param to set request bodies." \
+                       "You must encode it yourself if you wish to do so."
+        end
+
+        def empty?
+          return super unless @options.stream
+
+          false
+        end
+      end
+
+      # overrides the declaration of +@write_buffer+, which is now a thread-safe buffer
+      # responding to the same API.
+      module ConnectionMethods
+        attr_writer :signal
+
+        def initialize(*)
+          super
+
+          return unless @options.stream
+
+          @write_buffer = BidiBuffer.new(@options.buffer_size)
+        end
+
+        # rebuffers the +@write_buffer+ before calculating interests.
+        def interests
+          return super unless @options.stream
+
+          @write_buffer.rebuffer
+
+          super
+        end
+
+        def call
+          return super unless @options.stream && (error = @signal.error)
+
+          on_error(error)
+        end
+
+        private
+
+        def set_parser_callbacks(parser)
+          return super unless @options.stream
+
+          super
+          parser.on(:flush_buffer) do
+            @signal.wakeup if @signal
+          end
+        end
+      end
+    end
+    register_plugin :stream_bidi, StreamBidi
+  end
+end

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/lib/httpx/plugins/tracing.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+module HTTPX::Plugins
+  #
+  # This plugin adds a simple interface to integrate request tracing SDKs.
+  #
+  # An example of such an integration is the datadog adapter.
+  #
+  # https://gitlab.com/os85/httpx/wikis/Tracing
+  #
+  module Tracing
+    class Wrapper
+      attr_reader :tracers
+      protected :tracers
+
+      def initialize(*tracers)
+        @tracers = tracers.flat_map do |tracer|
+          case tracer
+          when Wrapper
+            tracer.tracers
+          else
+            tracer
+          end
+        end.uniq
+      end
+
+      def merge(tracer)
+        Wrapper.new(*@tracers, *tracer.tracers)
+      end
+
+      def freeze
+        @tracers.each(&:freeze).freeze
+        super
+      end
+
+      %i[start finish reset enabled?].each do |callback|
+        class_eval(<<-OUT, __FILE__, __LINE__ + 1)
+          # proxies ##{callback} calls to wrapper tracers.
+          def #{callback}(...)                        # def start(...)
+            @tracers.each { |t| t.#{callback}(...) }  # @tracers.each { |t| t.start(....) }
+          end                                         # end
+        OUT
+      end
+    end
+
+    # adds support for the following options:
+    #
+    # :tracer :: object which responds to #start, #finish and #reset.
+    module OptionsMethods
+      private
+
+      def option_tracer(tracer)
+        unless tracer.respond_to?(:start) &&
+               tracer.respond_to?(:finish) &&
+               tracer.respond_to?(:reset) &&
+               tracer.respond_to?(:enabled?)
+          raise TypeError, "#{tracer} must to respond to `#start(r)`, `#finish` and `#reset` and `#enabled?"
+        end
+
+        tracer = Wrapper.new(@tracer, tracer) if @tracer
+        tracer
+      end
+    end
+
+    module RequestMethods
+      attr_accessor :init_time
+
+      # intercepts request initialization to inject the tracing logic.
+      def initialize(*)
+        super
+
+        @init_time = nil
+
+        tracer = @options.tracer
+
+        return unless tracer && tracer.enabled?(self)
+
+        on(:idle) do
+          tracer.reset(self)
+
+          # request is reset when it's retried.
+          @init_time = nil
+        end
+        on(:headers) do
+          # the usual request init time (when not including the connection handshake)
+          # should be the time the request is buffered the first time.
+          @init_time ||= ::Time.now.utc
+
+          tracer.start(self)
+        end
+        on(:response) { |response| tracer.finish(self, response) }
+      end
+
+      def response=(*)
+        # init_time should be set when it's send to a connection.
+        # However, there are situations where connection initialization fails.
+        # Example is the :ssrf_filter plugin, which raises an error on
+        # initialize if the host is an IP which matches against the known set.
+        # in such cases, we'll just set here right here.
+        @init_time ||= ::Time.now.utc
+
+        super
+      end
+    end
+
+    # Connection mixin
+    module ConnectionMethods
+      def initialize(*)
+        super
+
+        @init_time = nil
+      end
+
+      def send_request_to_parser(request)
+        if connecting?
+          @init_time ||= ::Time.now.utc
+
+          # request span timeframe should include the time it took to connect.
+          request.init_time ||= @init_time
+        end
+
+        super
+      end
+
+      def idling
+        super
+
+        @init_time = nil
+      end
+
+      def terminate
+        super
+
+        # ensure that connections which go back to the pool reset their init time.
+        @init_time = nil
+      end
+
+      private
+
+      def connect
+        @init_time ||= ::Time.now.utc
+
+        super
+      end
+
+      def ping(request)
+        # if a connection is probed for liveness, the request timeframe should include
+        # it too.
+        request.init_time ||= ::Time.now.utc
+
+        super
+      end
+    end
+  end
+  register_plugin :tracing, Tracing
+end

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/lib/httpx/plugins/upgrade/h2.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Plugins
+    #
+    # This plugin adds support for upgrading an HTTP/1.1 connection to HTTP/2
+    # via an Upgrade: h2 response declaration
+    #
+    # https://gitlab.com/os85/httpx/wikis/Connection-Upgrade#h2
+    #
+    module H2
+      class << self
+        def extra_options(options)
+          options.merge(upgrade_handlers: options.upgrade_handlers.merge("h2" => self))
+        end
+
+        def call(connection, _request, _response)
+          connection.upgrade_to_h2
+        end
+      end
+
+      module ConnectionMethods
+        using URIExtensions
+
+        def interests
+          return super unless connecting? && @parser
+
+          connect
+
+          return @io.interests if connecting?
+
+          super
+        end
+
+        def upgrade_to_h2
+          enqueue_pending_requests_from_parser(@parser)
+
+          @parser = @options.http2_class.new(@write_buffer, @options)
+          set_parser_callbacks(@parser)
+          @upgrade_protocol = "h2"
+
+          # what's happening here:
+          # a deviation from the state machine is done to perform the actions when a
+          # connection is closed, without transitioning, so the connection is kept in the pool.
+          # the state is reset to initial, so that the socket reconnect works out of the box,
+          # while the parser is already here.
+          purge_after_closed
+          transition(:idle)
+        end
+      end
+    end
+    register_plugin(:"upgrade/h2", H2)
+  end
+end

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/lib/httpx/plugins/upgrade.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Plugins
+    #
+    # This plugin helps negotiating a new protocol from an HTTP/1.1 connection, via the
+    # Upgrade header.
+    #
+    # https://gitlab.com/os85/httpx/wikis/Upgrade
+    #
+    module Upgrade
+      class << self
+        def configure(klass)
+          klass.plugin(:"upgrade/h2")
+        end
+
+        def extra_options(options)
+          options.merge(upgrade_handlers: {})
+        end
+      end
+
+      module OptionsMethods
+        private
+
+        def option_upgrade_handlers(value)
+          raise TypeError, ":upgrade_handlers must be a Hash" unless value.is_a?(Hash)
+
+          value
+        end
+      end
+
+      module InstanceMethods
+        def fetch_response(request, selector, options)
+          response = super
+
+          return unless response
+
+          return response unless response.is_a?(Response)
+
+          return response unless response.headers.key?("upgrade")
+
+          upgrade_protocol = response.headers["upgrade"].split(/ *, */).first
+
+          return response unless upgrade_protocol && options.upgrade_handlers.key?(upgrade_protocol)
+
+          protocol_handler = options.upgrade_handlers[upgrade_protocol]
+
+          return response unless protocol_handler
+
+          log { "upgrading to #{upgrade_protocol}..." }
+          connection = find_connection(request.uri, selector, options)
+
+          # do not upgrade already upgraded connections
+          return if connection.upgrade_protocol == upgrade_protocol
+
+          protocol_handler.call(connection, request, response)
+
+          # keep in the loop if the server is switching, unless
+          # the connection has been hijacked, in which case you want
+          # to terminante immediately
+          return fetch_response(request, selector, options) if response.status == 101 && !connection.hijacked
+
+          response
+        end
+      end
+
+      module ConnectionMethods
+        attr_reader :upgrade_protocol, :hijacked
+
+        def initialize(*)
+          super
+
+          @upgrade_protocol = nil
+        end
+
+        def hijack_io
+          @hijacked = true
+
+          # connection is taken away from selector and not given back to the pool.
+          @current_session.deselect_connection(self, @current_selector, true)
+        end
+      end
+    end
+    register_plugin(:upgrade, Upgrade)
+  end
+end