alogram_payrisk 0.3.2 → 0.3.4

data/vendor/bundle/ruby/3.3.0/gems/{httpx-1.8.0 → httpx-1.8.4}/lib/httpx/plugins/proxy/http.rb

@@ -46,6 +46,11 @@ module HTTPX
         end
 
         module ConnectionMethods
+          def initialize(*)
+            @tunnel_parser = nil
+            super
+          end
+
           def force_close(*)
             if @state == :connecting
               # proxy connect related requests should not be reenqueed
@@ -59,6 +64,12 @@ module HTTPX
 
           private
 
+          def purge_after_closed
+            super
+
+            @tunnel_parser = nil
+          end
+
           def handle_transition(nextstate)
             return super unless @options.proxy && @options.proxy.uri.scheme == "http"
 
@@ -69,8 +80,15 @@ module HTTPX
               @io.connect
               return unless @io.connected?
 
-              @parser || begin
-                @parser = parser = parser_type(@io.protocol).new(@write_buffer, @options.merge(max_concurrent_requests: 1))
+              @tunnel_parser || begin
+                if @parser
+                  # in case this happens, requests from @parser need to be reenqueued for delivery.
+                  enqueue_pending_requests_from_parser(@parser)
+                  @parser = nil
+                end
+
+                @tunnel_parser = @parser = parser =
+                                   parser_type(@io.protocol).new(@write_buffer, @options.merge(max_concurrent_requests: 1))
                 parser.extend(ProxyParser)
                 parser.on(:response, &method(:__http_on_connect))
                 parser.on(:close) do
@@ -86,6 +104,9 @@ module HTTPX
 
                     initial_state = @state
 
+                    # because #reset will nillify @parser...
+                    tunnel_parser = @parser
+
                     reset
 
                     if @pending.empty?
@@ -98,8 +119,8 @@ module HTTPX
                     connect_request = parser = nil
 
                     if initial_state == :connecting
-                      parser = @parser
-                      @parser.reset
+                      parser = tunnel_parser
+                      parser.reset
                       if @pending.first.is_a?(ConnectRequest)
                         connect_request = @pending.shift # this happened when reenqueing
                       end
@@ -107,7 +128,7 @@ module HTTPX
 
                     idling
 
-                    @parser = parser
+                    @tunnel_parser = @parser = parser
                     if connect_request
                       @inflight += 1
                       parser.send(connect_request)
@@ -124,7 +145,7 @@ module HTTPX
               case @state
               when :connecting
                 parser = @parser
-                @parser = nil
+                @tunnel_parser = @parser = nil
                 parser.close
               when :idle
                 @parser.callbacks.clear

data/vendor/bundle/ruby/3.3.0/gems/{httpx-1.8.0 → httpx-1.8.4}/lib/httpx/plugins/proxy.rb

@@ -92,16 +92,16 @@ module HTTPX
           @authenticator = load_authenticator(scheme, @username, @password)
         end
 
-        def can_authenticate?(*args)
+        def can_authenticate?(...)
           return false unless @authenticator && @authenticator.respond_to?(:can_authenticate?)
 
-          @authenticator.can_authenticate?(*args)
+          @authenticator.can_authenticate?(...)
         end
 
-        def authenticate(*args)
+        def authenticate(...)
           return unless @authenticator
 
-          @authenticator.authenticate(*args)
+          @authenticator.authenticate(...)
         end
 
         def ==(other)
@@ -182,9 +182,11 @@ module HTTPX
           if (no_proxy = proxy.no_proxy)
             no_proxy = no_proxy.join(",") if no_proxy.is_a?(Array)
 
-            # TODO: setting proxy to nil leaks the connection object in the pool
-            return super(request_uri, selector, options.merge(proxy: nil)) unless URI::Generic.use_proxy?(request_uri.host, next_proxy.host,
-                                                                                                          next_proxy.port, no_proxy)
+            unless no_proxy != "*" && # NO_PROXY=* bypasses proxy use
+                   URI::Generic.use_proxy?(request_uri.host, next_proxy.host, next_proxy.port, no_proxy)
+              # TODO: setting proxy to nil leaks the connection object in the pool
+              return super(request_uri, selector, options.merge(proxy: nil))
+            end
           end
 
           super(request_uri, selector, options.merge(proxy: proxy))
@@ -341,6 +343,10 @@ module HTTPX
         module InstanceMethods
           private
 
+          def proxy_error?(request, response, _)
+            super && !request.retries.positive?
+          end
+
           def retryable_error?(ex, *)
             super || ex.is_a?(ProxyConnectionError)
           end

data/vendor/bundle/ruby/3.3.0/gems/{httpx-1.8.0 → httpx-1.8.4}/lib/httpx/plugins/push_promise.rb

@@ -44,9 +44,9 @@ module HTTPX
 
         def __on_promise_request(parser, stream, h)
           log(level: 1, color: :yellow) do
-            # :nocov:
+            # simplecov:disable
             h.map { |k, v| "#{stream.id}: -> PROMISE HEADER: #{k}: #{v}" }.join("\n")
-            # :nocov:
+            # simplecov:enable
           end
           headers = @options.headers_class.new(h)
           path = headers[":path"]

data/vendor/bundle/ruby/3.3.0/gems/{httpx-1.8.0 → httpx-1.8.4}/lib/httpx/plugins/retries.rb

@@ -29,10 +29,23 @@ module HTTPX
         Errno::ETIMEDOUT,
         ConnectionError,
         TLSError,
-        Connection::HTTP2::Error,
+        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
@@ -148,10 +161,13 @@ module HTTPX
              retryable_response?(response, options)
             try_partial_retry(request, response)
             log { "failed to get response, #{request.retries} tries to go..." }
-            prepare_to_retry(request, response)
 
-            if (retry_after = when_to_retry(request, response, options)) && retry_after.positive?
+            # 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
@@ -191,13 +207,14 @@ module HTTPX
           RETRYABLE_ERRORS.any? { |klass| ex.is_a?(klass) } && !ex.is_a?(TotalRequestTimeoutError)
         end
 
-        def proxy_error?(request, response, _)
-          super && !request.retries.positive?
+        def prepare_to_retry(request, response)
+          request.retries -= 1 unless can_reconnect?(request, response)
+          request.transition(:idle)
         end
 
-        def prepare_to_retry(request, _response)
-          request.retries -= 1 unless request.ping? # do not exhaust retries on connection liveness probes
-          request.transition(:idle)
+        # do not exhaust retries on connection liveness probes
+        def can_reconnect?(request, _)
+          request.ping?
         end
 
         def when_to_retry(request, response, options)
@@ -249,7 +266,7 @@ module HTTPX
         attr_writer :partial_response
 
         # initializes the request instance, sets the number of retries for the request.
-        def initialize(*args)
+        def initialize(*)
           super
           @retries = @options.max_retries
           @partial_response = nil

data/vendor/bundle/ruby/3.3.0/gems/{httpx-1.8.0 → httpx-1.8.4}/lib/httpx/plugins/server_sent_events.rb

@@ -40,7 +40,7 @@ module HTTPX
       end
 
       module InstanceMethods
-        def request(*args, **options)
+        def request(*, **options)
           options[:stream] = true if options[:event_stream]
 
           super
@@ -146,7 +146,7 @@ module HTTPX
           def when_to_retry(request, *)
             retry_after = request.last_server_sent_message&.retry_after
 
-            retry_after / 1_000.0 if retry_after # original in milliseconds
+            retry_after.to_i / 1_000.0 if retry_after # original in milliseconds
 
             request.last_server_sent_message&.retry_after && super
           end

data/vendor/bundle/ruby/3.3.0/gems/{httpx-1.8.0 → httpx-1.8.4}/lib/httpx/plugins/ssrf_filter.rb

@@ -149,7 +149,7 @@ module HTTPX
             SsrfFilter.unsafe_ip_address?(ipaddr) || @options.extra_unsafe_ranges&.any? { |r| r.include?(ipaddr) }
           end
 
-          raise ServerSideRequestForgeryError, "#{@origin.host} has no public IP addresses" if addrs.empty?
+          raise ServerSideRequestForgeryError, "#{@origin.host} has no allowed IP addresses" if addrs.empty?
 
           super
         end

data/vendor/bundle/ruby/3.3.0/gems/{httpx-1.8.0 → httpx-1.8.4}/lib/httpx/plugins/stream.rb

@@ -75,11 +75,11 @@ module HTTPX
       @on_chunk.call(chunk)
     end
 
-    # :nocov:
+    # simplecov:disable
     def inspect
       "#<#{self.class}:#{object_id}>"
     end
-    # :nocov:
+    # simplecov:enable
 
     def to_s
       if @request.response
@@ -111,10 +111,10 @@ module HTTPX
       end || super
     end
 
-    def method_missing(meth, *args, **kwargs, &block)
+    def method_missing(meth, ...)
       return super unless response.respond_to?(meth)
 
-      response.__send__(meth, *args, **kwargs, &block)
+      response.__send__(meth, ...)
     end
   end
 

data/vendor/bundle/ruby/3.3.0/gems/{httpx-1.8.0 → httpx-1.8.4}/lib/httpx/plugins/stream_bidi.rb

@@ -177,6 +177,8 @@ module HTTPX
           @pipe_read.readpartial(1)
         end
 
+        def initial_call; end
+
         def interests
           return if @closed
 

data/vendor/bundle/ruby/3.3.0/gems/{httpx-1.8.0 → httpx-1.8.4}/lib/httpx/plugins/tracing.rb

@@ -36,9 +36,9 @@ module HTTPX::Plugins
       %i[start finish reset enabled?].each do |callback|
         class_eval(<<-OUT, __FILE__, __LINE__ + 1)
           # proxies ##{callback} calls to wrapper tracers.
-          def #{callback}(*args)                        # def start(*args)
-            @tracers.each { |t| t.#{callback}(*args) }  # @tracers.each { |t| t.start(*args) }
-          end                                           # end
+          def #{callback}(...)                        # def start(...)
+            @tracers.each { |t| t.#{callback}(...) }  # @tracers.each { |t| t.start(....) }
+          end                                         # end
         OUT
       end
     end
@@ -108,11 +108,13 @@ module HTTPX::Plugins
       def initialize(*)
         super
 
-        @init_time = ::Time.now.utc
+        @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
@@ -123,13 +125,24 @@ module HTTPX::Plugins
       def idling
         super
 
-        # time of initial request(s) is accounted from the moment
-        # the connection is back to :idle, and ready to connect again.
-        @init_time = ::Time.now.utc
+        @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.

data/vendor/bundle/ruby/3.3.0/gems/{httpx-1.8.0 → httpx-1.8.4}/lib/httpx/pool.rb

@@ -173,7 +173,7 @@ module HTTPX
       end
     end
 
-    # :nocov:
+    # simplecov:disable
     def inspect
       "#<#{self.class}:#{object_id} " \
         "@max_connections=#{@max_connections} " \
@@ -181,7 +181,7 @@ module HTTPX
         "@pool_timeout=#{@pool_timeout} " \
         "@connections=#{@connections.size}>"
     end
-    # :nocov:
+    # simplecov:enable
 
     private
 

data/vendor/bundle/ruby/3.3.0/gems/{httpx-1.8.0 → httpx-1.8.4}/lib/httpx/request/body.rb

@@ -4,14 +4,17 @@ module HTTPX
   # Implementation of the HTTP Request body as a delegator which iterates (responds to +each+) payload chunks.
   class Request::Body < SimpleDelegator
     class << self
-      def new(_, options, body: nil, **params)
-        if body.is_a?(self)
+      def new(h, options, body: nil, **params)
+        case body
+        when self
           # request derives its options from body
           body.options = options.merge(params)
-          return body
+          body
+        when nil
+          super(h, options, **params)
+        else
+          super
         end
-
-        super
       end
     end
 
@@ -114,12 +117,12 @@ module HTTPX
       @headers.add("transfer-encoding", "chunked")
     end
 
-    # :nocov:
+    # simplecov:disable
     def inspect
       "#<#{self.class}:#{object_id} " \
         "#{unbounded_body? ? "stream" : "@bytesize=#{bytesize}"}>"
     end
-    # :nocov:
+    # simplecov:enable
 
     class << self
       def initialize_body(params)

data/vendor/bundle/ruby/3.3.0/gems/{httpx-1.8.0 → httpx-1.8.4}/lib/httpx/request.rb

@@ -105,9 +105,9 @@ module HTTPX
 
       @state = :idle
       @connection = @response =
-        @drainer = @peer_address =
-          @informational_status = @on_response_arrived = nil
-      @ping = @started = false
+        @drainer = @peer_address = @callbacks =
+                     @informational_status = @on_response_arrived = nil
+      @ping = @started = @complete = false
       @persistent = @options.persistent
       @active_timeouts = []
     end
@@ -115,13 +115,17 @@ module HTTPX
     # dupped initialization
     def initialize_dup(orig)
       super
-      @uri = orig.instance_variable_get(:@uri).dup
       @headers = orig.instance_variable_get(:@headers).dup
       @body = orig.instance_variable_get(:@body).dup
+      @active_timeouts = orig.instance_variable_get(:@active_timeouts).dup
     end
 
     def complete!(response = @response)
+      return false if @complete
+
       emit(:complete, response)
+      reset_timers(true)
+      @complete = true
     end
 
     # whether request has been buffered with a ping
@@ -268,21 +272,19 @@ module HTTPX
 
     # consumes and returns the next available chunk of request body that can be sent
     def drain_body
-      return nil if @body.nil?
+      return if @body.nil?
 
       @drainer ||= @body.each
-      chunk = @drainer.next.dup
-
-      emit(:body_chunk, chunk)
-      chunk
+      @drainer.next.dup
     rescue StopIteration
       nil
     rescue StandardError => e
+      # in case an error occurs while emitting body chunks
       @drain_error = e
       nil
     end
 
-    # :nocov:
+    # simplecov:disable
     def inspect
       "#<#{self.class}:#{object_id} " \
         "#{@verb} " \
@@ -290,16 +292,19 @@ module HTTPX
         "@headers=#{@headers} " \
         "@body=#{@body}>"
     end
-    # :nocov:
+    # simplecov:enable
 
     # moves on to the +nextstate+ of the request state machine (when all preconditions are met)
     def transition(nextstate)
       case nextstate
       when :idle
         @body.rewind
-        @ping = false
+        @ping = @complete = false
         @response = @drainer = nil
-        @active_timeouts.clear
+
+        # request may be sent to a different connection and will be
+        # reassigned a new set of timers.
+        reset_timers(false)
       when :headers
         return unless @state == :idle
 
@@ -326,7 +331,7 @@ module HTTPX
         return if @state == :expect
 
       end
-      log(level: 3) { "#{@state}] -> #{nextstate}" }
+      log(level: 3) { "#{@state} -> #{nextstate}" }
       @state = nextstate
       emit(@state, self)
       nil
@@ -363,6 +368,19 @@ module HTTPX
 
       @on_response_arrived.call
     end
+
+    private
+
+    def reset_timers(reset_total_request_timers)
+      timers = @active_timeouts
+
+      until (timer = timers.shift).nil?
+        next if !reset_total_request_timers && timer.label == :total_request_timeout
+
+        # cancel active timers.
+        timer.cancel
+      end
+    end
   end
 end
 

data/vendor/bundle/ruby/3.3.0/gems/{httpx-1.8.0 → httpx-1.8.4}/lib/httpx/resolver/cache/base.rb

@@ -106,14 +106,7 @@ module HTTPX
           name = entry["name"]
           next unless name != hostname
 
-          lookups[name] ||= []
-
-          case family
-          when Socket::AF_INET6
-            lookups[name] << entry
-          when Socket::AF_INET
-            lookups[name].unshift(entry)
-          end
+          _set(name, family, [entry], lookups, hostnames)
         end
       end
 

data/vendor/bundle/ruby/3.3.0/gems/{httpx-1.8.0 → httpx-1.8.4}/lib/httpx/resolver/https.rb

@@ -126,27 +126,27 @@ module HTTPX
     end
 
     def on_response(request, response)
-      response.raise_for_status
-    rescue StandardError => e
-      hostname = @requests.delete(request)
-      connection = reset_hostname(hostname)
-      emit_resolve_error(connection, connection.peer.host, e)
-      close_or_resolve
-    else
-      # @type var response: HTTPX::Response
-      if response.status.between?(300, 399) && response.headers.key?("location")
-        hostname = @requests[request]
-        connection = @queries[hostname]
-        location_uri = URI(response.headers["location"])
-        location_uri = response.uri.merge(location_uri) if location_uri.relative?
-
-        # we assume that the DNS server URI changed permanently and move on
-        @uri = location_uri
-        send_request(hostname, connection)
-        return
-      end
+      if (e = response.error)
+        hostname = @requests.delete(request)
+        connection = reset_hostname(hostname)
+        emit_resolve_error(connection, connection.peer.host, e)
+        close_or_resolve
+      else
+        # @type var response: HTTPX::Response
+        if response.status.between?(300, 399) && response.headers.key?("location")
+          hostname = @requests[request]
+          connection = @queries[hostname]
+          location_uri = URI(response.headers["location"])
+          location_uri = response.uri.merge(location_uri) if location_uri.relative?
 
-      parse(request, response)
+          # we assume that the DNS server URI changed permanently and move on
+          @uri = location_uri
+          send_request(hostname, connection)
+          return
+        end
+
+        parse(request, response)
+      end
     ensure
       @requests.delete(request)
     end

data/vendor/bundle/ruby/3.3.0/gems/{httpx-1.8.0 → httpx-1.8.4}/lib/httpx/resolver/multi.rb

@@ -35,8 +35,8 @@ module HTTPX
       @resolvers.each { |r| r.current_session = s }
     end
 
-    def log(*args, **kwargs, &blk)
-      @resolvers.each { |r| r.log(*args, **kwargs, &blk) }
+    def log(...)
+      @resolvers.each { |r| r.log(...) }
     end
 
     def closed?

data/vendor/bundle/ruby/3.3.0/gems/{httpx-1.8.0 → httpx-1.8.4}/lib/httpx/resolver/native.rb

@@ -75,6 +75,13 @@ module HTTPX
 
     def call
       case @state
+      when :idle, :closed
+        return if @connections.empty?
+
+        transition(:idle) if @state == :closed
+        transition(:open)
+
+        consume if @state == :open
       when :open
         consume
       end
@@ -532,6 +539,10 @@ module HTTPX
         return unless @io.connected?
 
         resolve if @queries.empty? && !@connections.empty?
+
+        # #resolve may have closed the resolver already as part of error handling.
+        # @fiber-switch-guard
+        return unless @io
       when :closed
         return if @state == :closed
 

data/vendor/bundle/ruby/3.3.0/gems/{httpx-1.8.0 → httpx-1.8.4}/lib/httpx/resolver/resolver.rb

@@ -52,9 +52,13 @@ module HTTPX
 
     alias_method :terminate, :close
 
-    def force_close(*args)
+    def initial_call
+      call
+    end
+
+    def force_close(...)
       while (connection = @connections.shift)
-        connection.force_close(*args)
+        connection.force_close(...)
       end
     end
 

data/vendor/bundle/ruby/3.3.0/gems/{httpx-1.8.0 → httpx-1.8.4}/lib/httpx/resolver/system.rb

@@ -23,6 +23,9 @@ module HTTPX
     DONE = 1
     ERROR = 2
 
+    class AddrinfoTimeoutError < StandardError
+    end
+
     class << self
       def multi?
         false
@@ -227,7 +230,7 @@ module HTTPX
         begin
           addrs = if resolve_timeout
 
-            Timeout.timeout(resolve_timeout) do
+            Timeout.timeout(resolve_timeout, AddrinfoTimeoutError) do
               __addrinfo_resolve(hostname, scheme)
             end
           else
@@ -246,7 +249,7 @@ module HTTPX
             end
           end
         rescue StandardError => e
-          if e.is_a?(Timeout::Error)
+          if e.is_a?(AddrinfoTimeoutError)
             timeouts.shift
             retry unless timeouts.empty?
             e = ResolveTimeoutError.new(resolve_timeout, e.message)