cybrid_api_id_ruby 0.129.1137 → 0.129.1138

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

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Plugins
+    #
+    # This plugin adds support for caching and reusing responses
+    #
+    # https://gitlab.com/os85/httpx/wikis/Cache
+    #
+    module Cache
+      class << self
+        def load_dependencies(*)
+          require_relative "cache/store"
+          require_relative "cache/file_store"
+        end
+
+        def extra_options(options)
+          options.merge(
+            response_cache_store: :store,
+          )
+        end
+      end
+
+      # adds support for the following options:
+      #
+      # :cache_key :: callable which receives a request and returns the corresponding cache key as a string
+      #               (to be used by the cache store when storing cached responses)
+      # :cacheable_request :: callable which receives a request and returns whether this request can use a previously cached response,
+      #                       or for which a freshly retrieved response can be cached.
+      # :cacheable_response :: callable which receives a request and a (freshly retrieved) response and returns whether the response
+      #                        can be cached.
+      # :valid_cached_response :: callable which receives a request and a (previously cached) response and returns whether the response
+      #                           can still be used / returned to the caller.
+      # :response_cache_store :: object where cached responses are fetch from or stored in; defaults to <tt>:store</tt> (in-memory
+      #                          cache), can be set to <tt>:file_store</tt> (file system cache store) as well, or any object which
+      #                          abides by the Cache Store Interface
+      #
+      # The Cache Store Interface requires implementation of the following methods:
+      #
+      # * +#get(request) -> response or nil+
+      # * +#set(request, response) -> void+
+      # * +#clear() -> void+)
+      #
+      module OptionsMethods
+        private
+
+        def option_cache_key(v)
+          raise TypeError, "`:cache_key` must be a callable" unless v.respond_to?(:call)
+
+          v
+        end
+
+        def option_cacheable_request(v)
+          raise TypeError, "`:cacheable_request` must be a callable" unless v.respond_to?(:call)
+
+          v
+        end
+
+        def option_cacheable_response(v)
+          raise TypeError, "`:cacheable_response` must be a callable" unless v.respond_to?(:call)
+
+          v
+        end
+
+        def option_valid_cached_response(v)
+          raise TypeError, "`:valid_cached_response` must be a callable" unless v.respond_to?(:call)
+
+          v
+        end
+
+        def option_response_cache_store(value)
+          case value
+          when :store
+            Store.new
+          when :file_store
+            FileStore.new
+          else
+            value
+          end
+        end
+      end
+
+      module InstanceMethods
+        # wipes out all cached responses from the cache store.
+        def clear_response_cache
+          @options.response_cache_store.clear
+        end
+
+        def build_request(*)
+          request = super
+          return request unless cacheable_request?(request)
+
+          prepare_cache(request)
+
+          request
+        end
+
+        private
+
+        def send_request(request, *)
+          return request if request.response
+
+          super
+        end
+
+        def fetch_response(request, *)
+          response = super
+
+          return unless response
+
+          if cacheable_request?(request) && cacheable_response?(request, response) && !response.cached?
+            log { "caching response for #{request.uri}..." }
+            request.options.response_cache_store.set(request, response)
+          end
+
+          response
+        end
+
+        # whether +request+ can use cached responses.
+        def cacheable_request?(request)
+          return false unless (call = request.options.cacheable_request)
+
+          call[request]
+        end
+
+        # whether the retrieved +response+ can be cached.
+        def cacheable_response?(request, response)
+          return false unless (call = request.options.cacheable_response)
+
+          call[request, response]
+        end
+
+        # whether the cached +cached_response+ is still valid for the current +request+
+        def valid_cached_response?(request, cached_response)
+          return false unless (call = request.options.valid_cached_response)
+
+          call[request, cached_response]
+        end
+
+        # will either assign a still-fresh cached response to +request+, or set up its HTTP
+        # cache invalidation headers in case it's not fresh anymore.
+        def prepare_cache(request)
+          cached_response = retrieve_cached_response(request)
+
+          return unless cached_response && valid_cached_response?(request, cached_response)
+
+          request.cached_response = nil
+
+          # if the cached response is still usable, we use it
+          cached_response.body.rewind
+          cached_response = cached_response.dup
+          cached_response.mark_as_cached!
+          request.response = cached_response
+          request.emit_response(cached_response)
+        end
+
+        # calls the cache store to retrieve the cached response for +request+. Caches it
+        # for convenience of subplugins in order to minimize overhead of retrieval (which may
+        # involve network).
+        def retrieve_cached_response(request)
+          request.cached_response ||= request.options.response_cache_store.get(request)
+        end
+      end
+
+      module RequestMethods
+        # points to a previously cached Response corresponding to this request.
+        attr_accessor :cached_response
+
+        def initialize(*)
+          super
+          @cached_response = nil
+        end
+
+        def merge_headers(*)
+          super
+          @response_cache_key = nil
+        end
+
+        # returns a unique cache key as a String identifying this request
+        def response_cache_key
+          return unless (call = @options.cache_key)
+
+          call[self]
+        end
+      end
+
+      module ResponseMethods
+        attr_writer :original_request
+
+        def initialize(*)
+          super
+          @cached = false
+        end
+
+        # a copy of the request this response was originally cached from
+        def original_request
+          @original_request || @request
+        end
+
+        # whether this Response was duplicated from a previously {RequestMethods#cached_response}.
+        def cached?
+          @cached
+        end
+
+        # sets this Response as being duplicated from a previously cached response.
+        def mark_as_cached!
+          @cached = true
+        end
+      end
+
+      module ResponseBodyMethods
+        def decode_chunk(chunk)
+          return chunk if @response.cached?
+
+          super
+        end
+      end
+    end
+    register_plugin :cache, Cache
+  end
+end

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

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Plugins
+    #
+    # This plugin adds suppoort for callbacks around the request/response lifecycle.
+    #
+    # https://gitlab.com/os85/httpx/-/wikis/Events
+    #
+    module Callbacks
+      CALLBACKS = %i[
+        connection_opened connection_closed
+        request_error
+        request_started request_body_chunk request_completed
+        response_started response_body_chunk response_completed
+      ].freeze
+
+      # connection closed user-space errors happen after errors can be surfaced to requests,
+      # so they need to pierce through the scheduler, which is only possible by simulating an
+      # interrupt.
+      class CallbackError < Exception; end # rubocop:disable Lint/InheritException
+
+      module InstanceMethods
+        include HTTPX::Callbacks
+
+        CALLBACKS.each do |meth|
+          class_eval(<<-MOD, __FILE__, __LINE__ + 1)
+            def on_#{meth}(&blk)   # def on_connection_opened(&blk)
+              on(:#{meth}, &blk)   #   on(:connection_opened, &blk)
+              self                 #   self
+            end                    # end
+          MOD
+        end
+
+        def plugin(*args, &blk)
+          super(*args).tap do |sess|
+            CALLBACKS.each do |cb|
+              next unless callbacks_for?(cb)
+
+              sess.callbacks(cb).concat(callbacks(cb))
+            end
+
+            sess.wrap(&blk) if blk
+          end
+        end
+
+        private
+
+        def branch(options, &blk)
+          super(options).tap do |sess|
+            CALLBACKS.each do |cb|
+              next unless callbacks_for?(cb)
+
+              sess.callbacks(cb).concat(callbacks(cb))
+            end
+            sess.wrap(&blk) if blk
+          end
+        end
+
+        def do_init_connection(connection, selector)
+          super
+          connection.on(:open) do
+            next unless connection.current_session == self
+
+            emit_or_callback_error(:connection_opened, connection.origin, connection.io.socket)
+          end
+          connection.on(:callback_connection_closed) do
+            next unless connection.current_session == self
+
+            emit_or_callback_error(:connection_closed, connection.origin) if connection.used?
+          end
+
+          connection
+        end
+
+        def set_request_callbacks(request)
+          super
+
+          request.on(:headers) do
+            emit_or_callback_error(:request_started, request)
+          end
+          request.on(:body_chunk) do |chunk|
+            emit_or_callback_error(:request_body_chunk, request, chunk)
+          end
+          request.on(:done) do
+            emit_or_callback_error(:request_completed, request)
+          end
+
+          request.on(:response_started) do |res|
+            if res.is_a?(Response)
+              emit_or_callback_error(:response_started, request, res)
+              res.on(:chunk_received) do |chunk|
+                emit_or_callback_error(:response_body_chunk, request, res, chunk)
+              end
+            else
+              emit_or_callback_error(:request_error, request, res.error)
+            end
+          end
+          request.on(:response) do |res|
+            emit_or_callback_error(:response_completed, request, res) if res.is_a?(Response)
+          end
+        end
+
+        def emit_or_callback_error(*args)
+          emit(*args)
+        rescue StandardError => e
+          ex = CallbackError.new(e.message)
+          ex.set_backtrace(e.backtrace)
+          raise ex
+        end
+
+        def receive_requests(*)
+          super
+        rescue CallbackError => e
+          raise e.cause
+        end
+
+        def close(*)
+          super
+        rescue CallbackError => e
+          raise e.cause
+        end
+      end
+
+      module RequestMethods
+        def drain_body
+          super.tap do |chunk|
+            emit(:body_chunk, chunk) if chunk
+          rescue StandardError => e
+            # in case an error occurs in callback code
+            @drain_error = e
+            nil
+          end
+        end
+      end
+
+      module ConnectionMethods
+        private
+
+        def disconnect
+          return if @exhausted
+
+          return unless @current_session && @current_selector
+
+          emit(:callback_connection_closed)
+
+          super
+        end
+      end
+    end
+    register_plugin :callbacks, Callbacks
+  end
+end

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

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Plugins::CircuitBreaker
+    #
+    # A circuit is assigned to a given absoolute url or origin.
+    #
+    # It sets +max_attempts+, the number of attempts the circuit allows, before it is opened.
+    # It sets +reset_attempts_in+, the time a circuit stays open at most, before it resets.
+    # It sets +break_in+, the time that must elapse before an open circuit can transit to the half-open state.
+    # It sets +circuit_breaker_half_open_drip_rate+, the rate of requests a circuit allows to be performed when in an half-open state.
+    #
+    class Circuit
+      def initialize(max_attempts, reset_attempts_in, break_in, circuit_breaker_half_open_drip_rate)
+        @max_attempts = max_attempts
+        @reset_attempts_in = reset_attempts_in
+        @break_in = break_in
+        @circuit_breaker_half_open_drip_rate = circuit_breaker_half_open_drip_rate
+        @attempts = 0
+        @opened_at = @attempted_at = @response = nil
+
+        total_real_attempts = @max_attempts * @circuit_breaker_half_open_drip_rate
+        @drip_factor = (@max_attempts / total_real_attempts).round
+        @state = :closed
+      end
+
+      def respond
+        try_close
+
+        case @state
+        when :closed
+          nil
+        when :half_open
+          @attempts += 1
+
+          # do real requests while drip rate valid
+          if (@real_attempts % @drip_factor).zero?
+            @real_attempts += 1
+            return
+          end
+
+          @response
+        when :open
+
+          @response
+        end
+      end
+
+      def try_open(response)
+        case @state
+        when :closed
+          now = Utils.now
+
+          if @attempts.positive?
+            # reset if error happened long ago
+            @attempts = 0 if now - @attempted_at > @reset_attempts_in
+          else
+            @attempted_at = now
+          end
+
+          @attempts += 1
+
+          return unless @attempts >= @max_attempts
+
+          @state = :open
+          @opened_at = now
+          @response = response
+        when :half_open
+          # open immediately
+
+          @state = :open
+          @attempted_at = @opened_at = Utils.now
+          @response = response
+        end
+      end
+
+      def try_close
+        case @state
+        when :closed
+          nil
+        when :half_open
+
+          # do not close circuit unless attempts exhausted
+          return unless @attempts >= @max_attempts
+
+          # reset!
+          @attempts = 0
+          @opened_at = @attempted_at = @response = nil
+          @state = :closed
+
+        when :open
+          if Utils.elapsed_time(@opened_at) > @break_in
+            @state = :half_open
+            @attempts = 0
+            @real_attempts = 0
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module HTTPX::Plugins::CircuitBreaker
+  using HTTPX::URIExtensions
+
+  class CircuitStore
+    def initialize(options)
+      @circuits = Hash.new do |h, k|
+        h[k] = Circuit.new(
+          options.circuit_breaker_max_attempts,
+          options.circuit_breaker_reset_attempts_in,
+          options.circuit_breaker_break_in,
+          options.circuit_breaker_half_open_drip_rate
+        )
+      end
+      @circuits_mutex = Thread::Mutex.new
+    end
+
+    def try_open(uri, response)
+      circuit = @circuits_mutex.synchronize { get_circuit_for_uri(uri) }
+
+      circuit.try_open(response)
+    end
+
+    def try_close(uri)
+      circuit = @circuits_mutex.synchronize do
+        return unless @circuits.key?(uri.origin) || @circuits.key?(uri.to_s)
+
+        get_circuit_for_uri(uri)
+      end
+
+      circuit.try_close
+    end
+
+    # if circuit is open, it'll respond with the stored response.
+    # if not, nil.
+    def try_respond(request)
+      circuit = @circuits_mutex.synchronize { get_circuit_for_uri(request.uri) }
+
+      circuit.respond
+    end
+
+    private
+
+    def get_circuit_for_uri(uri)
+      if uri.respond_to?(:origin) && @circuits.key?(uri.origin)
+        @circuits[uri.origin]
+      else
+        @circuits[uri.to_s]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Plugins
+    #
+    # This plugin implements a circuit breaker around connection errors.
+    #
+    # https://gitlab.com/os85/httpx/wikis/Circuit-Breaker
+    #
+    module CircuitBreaker
+      using URIExtensions
+
+      def self.load_dependencies(*)
+        require_relative "circuit_breaker/circuit"
+        require_relative "circuit_breaker/circuit_store"
+      end
+
+      def self.extra_options(options)
+        options.merge(
+          circuit_breaker_max_attempts: 3,
+          circuit_breaker_reset_attempts_in: 60,
+          circuit_breaker_break_in: 60,
+          circuit_breaker_half_open_drip_rate: 1
+        )
+      end
+
+      module InstanceMethods
+        include HTTPX::Callbacks
+
+        def initialize(*)
+          super
+          @circuit_store = CircuitStore.new(@options)
+        end
+
+        %i[circuit_open].each do |meth|
+          class_eval(<<-MOD, __FILE__, __LINE__ + 1)
+        def on_#{meth}(&blk)   # def on_circuit_open(&blk)
+          on(:#{meth}, &blk)   #   on(:circuit_open, &blk)
+          self                 #   self
+        end                    # end
+          MOD
+        end
+
+        private
+
+        def send_requests(*requests)
+          # @type var short_circuit_responses: Array[response]
+          short_circuit_responses = []
+
+          # run all requests through the circuit breaker, see if the circuit is
+          # open for any of them.
+          real_requests = requests.each_with_index.with_object([]) do |(req, idx), real_reqs|
+            short_circuit_response = @circuit_store.try_respond(req)
+            if short_circuit_response.nil?
+              real_reqs << req
+              next
+            end
+            short_circuit_responses[idx] = short_circuit_response
+          end
+
+          # run requests for the remainder
+          unless real_requests.empty?
+            responses = super(*real_requests)
+
+            real_requests.each_with_index do |request, idx|
+              short_circuit_responses[requests.index(request)] = responses[idx]
+            end
+          end
+
+          short_circuit_responses
+        end
+
+        def set_request_callbacks(request)
+          super
+          request.on(:response) do |response|
+            emit(:circuit_open, request) if try_circuit_open(request, response)
+          end
+        end
+
+        def try_circuit_open(request, response)
+          if response.is_a?(ErrorResponse)
+            case response.error
+            when RequestTimeoutError
+              @circuit_store.try_open(request.uri, response)
+            else
+              @circuit_store.try_open(request.origin, response)
+            end
+          elsif (break_on = request.options.circuit_breaker_break_on) && break_on.call(response)
+            @circuit_store.try_open(request.uri, response)
+          else
+            @circuit_store.try_close(request.uri)
+            nil
+          end
+        end
+      end
+
+      # adds support for the following options:
+      #
+      # :circuit_breaker_max_attempts :: the number of attempts the circuit allows, before it is opened (defaults to <tt>3</tt>).
+      # :circuit_breaker_reset_attempts_in :: the time a circuit stays open at most, before it resets (defaults to <tt>60</tt>).
+      # :circuit_breaker_break_on :: callable defining an alternative rule for a response to break
+      #                              (i.e. <tt>->(res) { res.status == 429 } </tt>)
+      # :circuit_breaker_break_in :: the time that must elapse before an open circuit can transit to the half-open state
+      #                              (defaults to <tt><60</tt>).
+      # :circuit_breaker_half_open_drip_rate :: the rate of requests a circuit allows to be performed when in an half-open state
+      #                                         (defaults to <tt>1</tt>).
+      module OptionsMethods
+        private
+
+        def option_circuit_breaker_max_attempts(value)
+          attempts = Integer(value)
+          raise TypeError, ":circuit_breaker_max_attempts must be positive" unless attempts.positive?
+
+          attempts
+        end
+
+        def option_circuit_breaker_reset_attempts_in(value)
+          timeout = Float(value)
+          raise TypeError, ":circuit_breaker_reset_attempts_in must be positive" unless timeout.positive?
+
+          timeout
+        end
+
+        def option_circuit_breaker_break_in(value)
+          timeout = Float(value)
+          raise TypeError, ":circuit_breaker_break_in must be positive" unless timeout.positive?
+
+          timeout
+        end
+
+        def option_circuit_breaker_half_open_drip_rate(value)
+          ratio = Float(value)
+          raise TypeError, ":circuit_breaker_half_open_drip_rate must be a number between 0 and 1" unless (0..1).cover?(ratio)
+
+          ratio
+        end
+
+        def option_circuit_breaker_break_on(value)
+          raise TypeError, ":circuit_breaker_break_on must be called with the response" unless value.respond_to?(:call)
+
+          value
+        end
+      end
+    end
+    register_plugin :circuit_breaker, CircuitBreaker
+  end
+end