cybrid_api_bank_ruby 0.129.1137 → 0.129.1139

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

@@ -0,0 +1,268 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Plugins
+    #
+    # This plugin caches and reuses responses based on HTTP caching directives defined by
+    # the [HTTP Caching RFC](https://www.rfc-editor.org/rfc/rfc9111.html)
+    #
+    # https://gitlab.com/os85/httpx/wikis/Response-Cache
+    #
+    module ResponseCache
+      CACHEABLE_VERBS = %w[GET HEAD].freeze
+      CACHEABLE_STATUS_CODES = [200, 203, 206, 300, 301, 410].freeze
+      SUPPORTED_VARY_HEADERS = %w[accept accept-encoding accept-language cookie origin].sort.freeze
+      private_constant :CACHEABLE_VERBS
+      private_constant :CACHEABLE_STATUS_CODES
+
+      class << self
+        def load_dependencies(klass)
+          klass.plugin(:cache)
+        end
+
+        # whether the +response+ can be stored in the response cache.
+        # (i.e. has a cacheable body, does not contain directives prohibiting storage, etc...)
+        def cacheable_response?(response)
+          response.is_a?(Response) &&
+            (
+              response.cache_control.nil? ||
+              # TODO: !response.cache_control.include?("private") && is shared cache
+              !response.cache_control.include?("no-store")
+            ) &&
+            CACHEABLE_STATUS_CODES.include?(response.status) &&
+            # RFC 2616 13.4 - A response received with a status code of 200, 203, 206, 300, 301 or
+            # 410 MAY be stored by a cache and used in reply to a subsequent
+            # request, subject to the expiration mechanism, unless a cache-control
+            # directive prohibits caching. However, a cache that does not support
+            # the Range and Content-Range headers MUST NOT cache 206 (Partial
+            # Content) responses.
+            response.status != 206
+        end
+
+        # whether the +response+
+        def not_modified?(response)
+          response.is_a?(Response) && response.status == 304
+        end
+
+        def extra_options(options)
+          options.merge(
+            supported_vary_headers: SUPPORTED_VARY_HEADERS,
+          )
+        end
+      end
+
+      # adds support for the following options:
+      #
+      # :supported_vary_headers :: array of header values that will be considered for a "vary" header based cache validation
+      #                            (defaults to {SUPPORTED_VARY_HEADERS}).
+      #
+      module OptionsMethods
+        private
+
+        def option_supported_vary_headers(value)
+          Array(value).sort
+        end
+      end
+
+      module InstanceMethods
+        private
+
+        def fetch_response(request, *)
+          response = super
+
+          return unless response
+
+          if ResponseCache.not_modified?(response)
+            log { "returning cached response for #{request.uri}" }
+
+            response.copy_from_cached!
+
+          end
+
+          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)
+          super
+
+          return if request.response # already cached
+
+          cached_response = retrieve_cached_response(request)
+
+          return unless cached_response && match_by_vary?(request, cached_response)
+
+          if !request.headers.key?("if-modified-since") && (last_modified = cached_response.headers["last-modified"])
+            request.headers.add("if-modified-since", last_modified)
+          end
+
+          if !request.headers.key?("if-none-match") && (etag = cached_response.headers["etag"])
+            request.headers.add("if-none-match", etag)
+          end
+        end
+
+        def cacheable_request?(request)
+          (
+            request.cacheable_verb? &&
+            (
+              !request.headers.key?("cache-control") || !request.headers.get("cache-control").include?("no-store")
+            )
+          ) || super
+        end
+
+        def cacheable_response?(_, response)
+          ResponseCache.cacheable_response?(response) || super
+        end
+
+        # +cached_response+ is still valid if it's still fresh
+        def valid_cached_response?(_, cached_response)
+          cached_response.fresh?
+        end
+
+        # whether the +cached_response+ complies with the directives set by the +request+ "vary" header
+        # (true when none is available).
+        def match_by_vary?(request, cached_response)
+          vary = cached_response.vary
+
+          return true unless vary
+
+          original_request = cached_response.original_request
+
+          if vary == %w[*]
+            request.options.supported_vary_headers.each do |field|
+              return false unless request.headers[field] == original_request.headers[field]
+            end
+
+            return true
+          end
+
+          vary.all? do |field|
+            !original_request.headers.key?(field) || request.headers[field] == original_request.headers[field]
+          end
+        end
+      end
+
+      module RequestMethods
+        # returns whether this request is cacheable as per HTTP caching rules.
+        def cacheable_verb?
+          CACHEABLE_VERBS.include?(@verb)
+        end
+
+        # returns a unique cache key as a String identifying this request
+        def response_cache_key
+          @response_cache_key ||= begin
+            keys = [@verb, @uri.merge(path)]
+
+            @options.supported_vary_headers.each do |field|
+              value = @headers[field]
+
+              keys << value if value
+            end
+            Digest::SHA1.hexdigest("httpx-response-cache-#{keys.join("-")}")
+          end
+        end
+      end
+
+      module ResponseMethods
+        attr_writer :revalidated_at
+
+        def initialize(*)
+          super
+          @revalidated_at = nil
+        end
+
+        # eager-copies the response headers and body from {RequestMethods#cached_response}.
+        def copy_from_cached!
+          cached_response = @request.cached_response
+
+          return unless cached_response
+
+          # 304 responses do not have content-type, which are needed for decoding.
+          @headers = @headers.class.new(cached_response.headers.merge(@headers))
+
+          @body = cached_response.body.dup
+
+          @body.rewind
+
+          cached_response.revalidated_at = date
+        end
+
+        # A response is fresh if its age has not yet exceeded its freshness lifetime.
+        # other (#cache_control} directives may influence the outcome, as per the rules
+        # from the {rfc}[https://www.rfc-editor.org/rfc/rfc7234]
+        def fresh?
+          if cache_control
+            return false if cache_control.include?("no-cache")
+
+            return true if cache_control.include?("immutable")
+
+            # check age: max-age
+            max_age = cache_control.find { |directive| directive.start_with?("s-maxage") }
+
+            max_age ||= cache_control.find { |directive| directive.start_with?("max-age") }
+
+            max_age = max_age[/age=(\d+)/, 1] if max_age
+
+            max_age = max_age.to_i if max_age
+
+            return max_age > age if max_age
+          end
+
+          # check age: expires
+          if @headers.key?("expires")
+            begin
+              expires = Time.httpdate(@headers["expires"])
+            rescue ArgumentError
+              return false
+            end
+
+            return (expires - Time.now).to_i.positive?
+          end
+
+          false
+        end
+
+        # returns the "cache-control" directives as an Array of String(s).
+        def cache_control
+          return @cache_control if defined?(@cache_control)
+
+          @cache_control = begin
+            @headers["cache-control"].split(/ *, */) if @headers.key?("cache-control")
+          end
+        end
+
+        # returns the "vary" header value as an Array of (String) headers.
+        def vary
+          return @vary if defined?(@vary)
+
+          @vary = begin
+            @headers["vary"].split(/ *, */).map(&:downcase) if @headers.key?("vary")
+          end
+        end
+
+        private
+
+        # returns the value of the "age" header as an Integer (time since epoch).
+        # if no "age" of header exists, it returns the number of seconds since {#date}.
+        def age
+          if (revalidated_at = @revalidated_at)
+            (Time.now - revalidated_at).to_i
+          else
+            return @headers["age"].to_i if @headers.key?("age")
+
+            (Time.now - date).to_i
+          end
+        end
+
+        # returns the value of the "date" header as a Time object
+        def date
+          @date ||= Time.httpdate(@headers["date"])
+        rescue NoMethodError, ArgumentError
+          Time.now
+        end
+      end
+    end
+    register_plugin :response_cache, ResponseCache
+  end
+end

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

@@ -0,0 +1,299 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Plugins
+    #
+    # This plugin adds support for retrying requests when errors happen.
+    #
+    # It has a default max number of retries (see *MAX_RETRIES* and the *max_retries* option),
+    # after which it will return the last response, error or not. It will **not** raise an exception.
+    #
+    # It does not retry which are not considered idempotent (see *retry_change_requests* to override).
+    #
+    # https://gitlab.com/os85/httpx/wikis/Retries
+    #
+    module Retries
+      MAX_RETRIES = 3
+      # TODO: pass max_retries in a configure/load block
+
+      IDEMPOTENT_METHODS = %w[GET OPTIONS HEAD PUT DELETE].freeze
+
+      # subset of retryable errors which are safe to retry when reconnecting
+      RECONNECTABLE_ERRORS = [
+        IOError,
+        EOFError,
+        Errno::ECONNRESET,
+        Errno::ECONNABORTED,
+        Errno::EPIPE,
+        Errno::EINVAL,
+        Errno::ETIMEDOUT,
+        ConnectionError,
+        TLSError,
+        Zlib::BufError,
+        PingTimeoutError,
+        # HTTP/2 GOAWAY or RST_STREAM errors guaranteed to be retriable for all
+        # types of requests.
+        Connection::HTTP2::RefusedStreamError,
+        Connection::HTTP2::GoawayError,
+        Connection::HTTP2::PingError,
+
+        # happens if connections were somehow sent to a closed or closing
+        # HTTP2::Connection, request guaranteed to not have been processed.
+        ::HTTP2::Error::ConnectionClosed,
+      ].freeze
+
+      RETRYABLE_ERRORS = (RECONNECTABLE_ERRORS + [
+        # most RST_STREAM errors aren't safely retriable, as request may have
+        # been partially processed.
+        Connection::HTTP2::RstStreamError,
+        Parser::Error,
+        TimeoutError,
+      ]).freeze
+
+      DEFAULT_JITTER = ->(interval) { interval * ((rand + 1) * 0.5) }.freeze
+
+      # list of supported backoff algorithms
+      BACKOFF_ALGORITHMS = %i[exponential_backoff polynomial_backoff].freeze
+
+      class << self
+        if ENV.key?("HTTPX_NO_JITTER")
+          def extra_options(options)
+            options.merge(max_retries: MAX_RETRIES)
+          end
+        else
+          def extra_options(options)
+            options.merge(max_retries: MAX_RETRIES, retry_jitter: DEFAULT_JITTER)
+          end
+        end
+
+        # returns the time to wait before resending +request+ as per the polynomial backoff retry strategy,
+        # where base is 1 and exponent is 2.
+        def retry_after_polynomial_backoff(request, _)
+          offset = request.options.max_retries - request.retries
+          1 * ((offset - 1)**2)
+        end
+
+        # returns the time to wait before resending +request+ as per the exponential backoff retry strategy,
+        # where base is 2
+        def retry_after_exponential_backoff(request, _)
+          offset = request.options.max_retries - request.retries
+          2**(offset - 1)
+        end
+      end
+
+      # adds support for the following options:
+      #
+      # :max_retries :: max number of times a request will be retried (defaults to <tt>3</tt>).
+      # :retry_change_requests :: whether idempotent requests are retried (defaults to <tt>false</tt>).
+      # :retry_after:: seconds after which a request is retried; can also be a callable object (i.e. <tt>->(req, res) { ... } </tt>)
+      #                or the name of a supported backoff algorithm (i.e. <tt>:exponential_backoff</tt>).
+      # :retry_jitter :: number of seconds applied to *:retry_after* (must be a callable, i.e. <tt>->(retry_after) { ... } </tt>).
+      # :retry_on :: callable which alternatively defines a different rule for when a response is to be retried
+      #              (i.e. <tt>->(res) { ... }</tt>).
+      module OptionsMethods
+        private
+
+        def option_retry_after(value)
+          if value.respond_to?(:call)
+            value1 = value
+            value1 = value1.method(:call) unless value1.respond_to?(:arity)
+
+            # allow ->(*) arity as well, which is < 0
+            raise TypeError, "`:retry_after` proc has invalid number of parameters" unless value1.arity.negative? || value1.arity.between?(
+              1, 2
+            )
+
+          else
+            case value
+            when Symbol
+              raise TypeError, "`retry_after`: `#{value}` is not a supported backoff algorithm" unless BACKOFF_ALGORITHMS.include?(value)
+
+              value = Retries.method(:"retry_after_#{value}")
+
+            else
+              value = Float(value)
+              raise TypeError, "`:retry_after` must be positive" unless value.positive?
+            end
+          end
+
+          value
+        end
+
+        def option_retry_jitter(value)
+          # return early if callable
+          raise TypeError, ":retry_jitter must be callable" unless value.respond_to?(:call)
+
+          value
+        end
+
+        def option_max_retries(value)
+          num = Integer(value)
+          raise TypeError, ":max_retries must be positive" unless num >= 0
+
+          num
+        end
+
+        def option_retry_change_requests(v)
+          v
+        end
+
+        def option_retry_on(value)
+          raise TypeError, ":retry_on must be called with the response" unless value.respond_to?(:call)
+
+          value
+        end
+      end
+
+      module InstanceMethods
+        # returns a `:retries` plugin enabled session with +n+ maximum retries per request setting.
+        def max_retries(n)
+          with(max_retries: n)
+        end
+
+        private
+
+        def fetch_response(request, selector, options)
+          response = super
+
+          if response &&
+             request.retries.positive? &&
+             retryable_request?(request, response, options) &&
+             retryable_response?(response, options)
+            try_partial_retry(request, response)
+            log { "failed to get response, #{request.retries} tries to go..." }
+
+            # retry-after must be calculated before prepare_to_retry, as it relies on
+            # state changed byit.
+            retry_after = when_to_retry(request, response, options)
+            prepare_to_retry(request, response)
+
+            if retry_after&.positive?
+              retry_start = Utils.now
+              log { "retrying after #{retry_after} secs..." }
+              selector.after(retry_after) do
+                if (response = request.response)
+                  response.finish!
+                  # request has terminated abruptly meanwhile
+                  request.emit_response(response)
+                else
+                  log { "retrying (elapsed time: #{Utils.elapsed_time(retry_start)})!!" }
+                  send_request(request, selector, options)
+                end
+              end
+
+              return
+            else
+              send_request(request, selector, options)
+
+              # recalling itself, in case an error was triggered by the above, and we can
+              # verify retriability again.
+              return fetch_response(request, selector, options)
+            end
+          end
+          response
+        end
+
+        # returns whether +request+ can be retried.
+        def retryable_request?(request, _, options)
+          IDEMPOTENT_METHODS.include?(request.verb) || options.retry_change_requests
+        end
+
+        def retryable_response?(response, options)
+          (response.is_a?(ErrorResponse) && retryable_error?(response.error, options)) || options.retry_on&.call(response)
+        end
+
+        # returns whether the +ex+ exception happend for a retriable request.
+        def retryable_error?(ex, _)
+          RETRYABLE_ERRORS.any? { |klass| ex.is_a?(klass) } && !ex.is_a?(TotalRequestTimeoutError)
+        end
+
+        def prepare_to_retry(request, response)
+          request.retries -= 1 unless can_reconnect?(request, response)
+          request.transition(:idle)
+        end
+
+        # do not exhaust retries on connection liveness probes
+        def can_reconnect?(request, _)
+          request.ping?
+        end
+
+        def when_to_retry(request, response, options)
+          retry_after = options.retry_after
+
+          return unless retry_after
+
+          retry_after = retry_after.call(request, response) if retry_after.respond_to?(:call)
+
+          return unless retry_after
+
+          # apply jitter
+          if (jitter = request.options.retry_jitter)
+            retry_after = jitter.call(retry_after)
+          end
+          retry_after
+        end
+
+        #
+        # Attempt to set the request to perform a partial range request.
+        # This happens if the peer server accepts byte-range requests, and
+        # the last response contains some body payload.
+        #
+        def try_partial_retry(request, response)
+          response = response.response if response.is_a?(ErrorResponse)
+
+          return unless response
+
+          unless response.headers.key?("accept-ranges") &&
+                 response.headers["accept-ranges"] == "bytes" && # there's nothing else supported though...
+                 (original_body = response.body)
+            response.body.close
+            return
+          end
+
+          request.partial_response = response
+
+          size = original_body.bytesize
+
+          request.headers["range"] = "bytes=#{size}-"
+        end
+      end
+
+      module RequestMethods
+        # number of retries left.
+        attr_accessor :retries
+
+        # a response partially received before.
+        attr_writer :partial_response
+
+        # initializes the request instance, sets the number of retries for the request.
+        def initialize(*)
+          super
+          @retries = @options.max_retries
+          @partial_response = nil
+        end
+
+        def response=(response)
+          if (partial_response = @partial_response)
+            if response.is_a?(Response) && response.status == 206
+              response.from_partial_response(partial_response)
+            else
+              partial_response.close
+            end
+            @partial_response = nil
+          end
+
+          super
+        end
+      end
+
+      module ResponseMethods
+        def from_partial_response(response)
+          @status = response.status
+          @headers = response.headers
+          @body = response.body
+        end
+      end
+    end
+    register_plugin :retries, Retries
+  end
+end