cybrid_api_bank_ruby 0.129.1294 → 0.129.1295

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.9.0/doc/release_notes/1_9_0.md

@@ -0,0 +1,75 @@
+# 1.9.0
+
+## Features
+
+### `:hedging` plugin
+
+The `:hedging` implements a strategy called "request hedging", whereby a request is sent a request two times, over different connections, and picking up whichever arrives first.
+
+```ruby
+http = HTTP.plugin(:hedging)
+http.get("http://www.example.com")
+# sent two times, only the fastest one comes back...
+```
+
+ou can read more about it in https://gitlab.com/os85/httpx/wikis/Hedging .
+
+### `:proxy/http` plugin: new options `:proxy_headers` and `:enable_proxy_tunnel`
+
+The `:proxy/http` plugin (which gets automatically loaded by the `:proxy` plugin) gains two new options.
+
+#### `:proxy_headers`
+
+Can be passed a separate set of HTTP headers, which are going to be sent to the proxy when establishing the the CONNECT proxy tunnel.
+
+```ruby
+http = HTTPX.plugin(:proxy).with(proxy_headers: { "x-proxy-1" => "foo" }, headers: { "x-header-1" => "bar" }).get("https://example.com")
+# -> CONNECT example.com HTTP/1.1
+# -> Host: example.com
+# -> X-Proxy-1: foo
+# ...
+# <- 200 OK
+# ...
+# -> GET / HTTP/1.1
+# -> X-Headers-1: bar
+# ...
+```
+
+#### `:enable_proxy_tunnel`
+
+When set to `true`, it forces the establishment of a CONNECT proxy tunnel before sending the request. Bear in mind that this will be the norm for `https://` requests, so only use this in cases where the requests are to be sent to an `http://` URL and a CONNECT proxy tunnel is required.
+
+## Improvements
+
+* `:request_timeout` will also observe the connect phase, in case a request is sent to an idle connection. This means that, if you're using `:request_timeout`, you no longer need to specify `:connect_timeout`.
+  * The same will happen if you're using `:total_request_timeout`.
+* do not require "io/wait" anymore for ruby 3.2 or higher.
+* `:proxy/http` plugin: raise a `HTTPX::ConnectTimeoutError` if there was a timeout error while waiting for the CONNECT request to complete.
+
+## Bugfixes
+
+* `:auth` plugin: fixed clause inverted check, which caused caused a new token to always be generated on retry.
+* `:auth` plugin: take auth_header_expires_at into account when deciding to regenerate on retry (token may have been expired by the time the request will be retried).
+* `:tracing` plugin: fixed request initial time calculation in order to take into account the time to wait for a PING correctly.
+* `:tracing` plugin: fixed request initial time calculation for pending requests which were waiting for the connect phase and errored meanwhie.
+* `:proxy/http` plugin: `:headers` will not be sent anymore to the proxy when establishing the CONNECT proxy tunnel.
+* socket connect timeout bookkeeping is fixed, where in a multi request scenario, connect timeout errors shall not be raised too early if an error happens before the remainder of connections elapses.
+* `:proxy` plugin: allow proxy params to be frozen, which also fixes an issue where proxies identified as unhealthy by a previous request, would still be retried on for different hostnames.
+* `:callbacks` plugin: fix broken visibility of session `#close` method.
+* native resolver: retry dns queries on not-imp and refused errors (treats them as transient resolver errors).
+* `webmock` adapter: fix emission of `:response` callback so that this only happens after the body is fully buffered (which makes the `:callbacks` plugin `.on_response_completed` callback works the same way when and when not stubbed).
+* `:addresses`: fix support for the documented variant where a hostname/ips hash is passed.
+* `http2`: fix interests calculation, so that:
+  * a connection expects to read from connections which still have in-transit streams.
+  * an HTTP/2 with no available flow control window in its streams will wait for incoming WINDOW_UPDATE frames.
+* `http2`: pause buffering the request body if there's no available control window in the corresponding stream or connection.
+* `http2`: reset the ping timer too if a connection receives a GOAWAY frame while waiting for a PING to be ack'ed.
+* wait for read or write for any operation, considering that `OpenSSL::SSL::SSLSocket` objects may return both `.wait_readable` and `:wait_writable` for reads and writes.
+* when using `:max_requests`, also account for inflight requests when deciding to send it to the parser or the pending queue.
+* fixed `HTTPX::Options#merge` which was not freezing the resulting options object, something which happens when enabling plugins, which made resulting sessions unusable across Ractors.
+* fixed the `Alt-Svc` header parser to be able to parse values with multiple authorities.
+* fixed request params handling so that they are passed to all requests invoked (instead of only the first of them).
+
+## Chore
+
+* Emit warning message whenever connection is deactivated with pending requests; the message contains internal state which should help debug it.

data/vendor/bundle/ruby/4.0.0/gems/{httpx-1.8.4 → httpx-1.9.0}/lib/httpx/altsvc.rb

@@ -10,7 +10,7 @@ module HTTPX
 
       H2_ALTSVC_SCHEMES = %w[https h2].freeze
 
-      ALTSVC_IGNORE_IVARS = %i[@ssl].freeze
+      ALTSVC_IGNORE_IVARS = %i[ssl].freeze
 
       def send(request)
         request.headers["alt-used"] = @origin.authority if @parser && !@write_buffer.full? && match_altsvcs?(request.uri)
@@ -30,7 +30,7 @@ module HTTPX
       # +uri+
       def match_altsvcs?(uri)
         @origins.any? { |origin| altsvc_match?(uri, origin) } ||
-          AltSvc.cached_altsvc(@origin).any? do |altsvc|
+          AltSvc.cached_altsvc(@origin.to_s).any? do |altsvc|
             origin = altsvc["origin"]
             altsvc_match?(origin, uri.origin)
           end
@@ -115,33 +115,45 @@ module HTTPX
         return
       end
 
-      parse(altsvc) do |alt_origin, alt_params|
+      parse(altsvc, host: host) do |alt_origin, alt_params|
         alt_origin.host ||= host
         yield(alt_origin, origin, alt_params)
       end
     end
 
-    def parse(altsvc)
-      return enum_for(__method__, altsvc) unless block_given?
+    def parse(altsvc, host: nil)
+      return enum_for(__method__, altsvc, host: host) unless block_given?
 
       scanner = StringScanner.new(altsvc)
       until scanner.eos?
-        alt_service = scanner.scan(/[^=]+=("[^"]+"|[^;,]+)/)
+        alt_services = [] #: Array[String]
 
-        alt_params = []
+        while (alt_service = scanner.scan(/[^=]+=("[^"]+")/))
+          alt_services << alt_service
+          scanner.skip(/[, ]+/)
+        end
+
+        scanner.skip(/;/)
+
+        alt_params = [] #: Array[String]
         loop do
           alt_param = scanner.scan(/[^=]+=("[^"]+"|[^;,]+)/)
           alt_params << alt_param.strip if alt_param
           scanner.skip(/;/)
           break if scanner.eos? || scanner.scan(/ *, */)
         end
-        alt_params = Hash[alt_params.map { |field| field.split("=", 2) }]
+        alt_params = Hash[alt_params.map do |field|
+          field.split("=", 2)
+        end]
 
-        alt_proto, alt_authority = alt_service.split("=", 2)
-        alt_origin = parse_altsvc_origin(alt_proto, alt_authority)
-        return unless alt_origin
+        alt_services.each do |alt_service|
+          alt_proto, alt_authority = alt_service.split("=", 2)
+          alt_origin = parse_altsvc_origin(alt_proto, alt_authority, host: host)
 
-        yield(alt_origin, alt_params.merge("proto" => alt_proto))
+          next unless alt_origin
+
+          yield(alt_origin, alt_params.merge("proto" => alt_proto))
+        end
       end
     end
 
@@ -149,19 +161,21 @@ module HTTPX
       case alt_proto
       when "h2c"
         "http"
-      when "h2"
+      when "h2", "quic", /^h3/
         "https"
       end
     end
 
-    def parse_altsvc_origin(alt_proto, alt_origin)
+    def parse_altsvc_origin(alt_proto, alt_origin, host: nil)
       alt_scheme = parse_altsvc_scheme(alt_proto)
 
       return unless alt_scheme
 
       alt_origin = alt_origin[1..-2] if alt_origin.start_with?("\"") && alt_origin.end_with?("\"")
 
-      URI.parse("#{alt_scheme}://#{alt_origin}")
+      uri = URI.parse("#{alt_scheme}://#{alt_origin}")
+      uri.host = host if uri.host.nil? || uri.host.empty?
+      uri
     end
   end
 end

data/vendor/bundle/ruby/4.0.0/gems/{httpx-1.8.4 → httpx-1.9.0}/lib/httpx/chainable.rb

@@ -5,9 +5,11 @@ module HTTPX
   # delegates to a default session when extended.
   module Chainable
     %w[head get post put delete trace options connect patch].each do |meth|
+      http_verb = meth.upcase
       class_eval(<<-MOD, __FILE__, __LINE__ + 1)
+        # sends a #{http_verb} request for the given +uri+, using +options+ for each.
         def #{meth}(*uri, **options)                # def get(*uri, **options)
-          request("#{meth.upcase}", uri, **options) #   request("GET", uri, **options)
+          request("#{http_verb}", uri, **options)   #   request("GET", uri, **options)
         end                                         # end
       MOD
     end
@@ -17,6 +19,7 @@ module HTTPX
       branch(default_options).request(...)
     end
 
+    # returns a new session with the "Accept" header set to +type+.
     def accept(type)
       with(headers: { "accept" => String(type) })
     end

data/vendor/bundle/ruby/4.0.0/gems/{httpx-1.8.4 → httpx-1.9.0}/lib/httpx/connection/http1.rb

@@ -34,7 +34,7 @@ module HTTPX
     end
 
     def timeout
-      @options.timeout[:operation_timeout]
+      @options.timeout.operation_timeout
     end
 
     def interests
@@ -48,10 +48,6 @@ module HTTPX
     end
 
     def reset
-      if @ping_timer
-        @ping_timer.cancel
-        @ping_timer = nil
-      end
       @max_requests = @options.max_requests || MAX_REQUESTS
       @parser.reset!
       @handshake_completed = false
@@ -92,14 +88,12 @@ module HTTPX
       @parser << data
     end
 
-    def send(request)
-      unless @max_requests.positive?
-        @pending << request
+    def send(request, head = false)
+      unless @max_requests.positive? && @max_requests > @requests.size
+        head ? @pending.unshift(request) : @pending << request
         return
       end
 
-      return if @requests.include?(request)
-
       @requests << request
       @pipelining = @max_concurrent_requests > 1 && @requests.size > 1
     end
@@ -132,9 +126,9 @@ module HTTPX
       headers = request.options.headers_class.new(h)
       response = request.options.response_class.new(request,
                                                     @parser.status_code,
-                                                    @parser.http_version.join("."),
+                                                    @parser.http_version,
                                                     headers)
-      request.log(color: :yellow) { "-> HEADLINE: #{response.status} HTTP/#{@parser.http_version.join(".")}" }
+      request.log(color: :yellow) { "-> HEADLINE: #{response.status} HTTP/#{@parser.http_version}" }
       request.log(color: :yellow) { response.headers.each.map { |f, v| "-> HEADER: #{f}: #{log_redact_headers(v)}" }.join("\n") }
 
       if response.content_length && response.content_length > request.options.max_response_body_size
@@ -187,7 +181,7 @@ module HTTPX
 
       @request = nil
       @requests.shift
-      response = request.response
+      response = request.response #: Response
       emit(:response, request, response)
 
       if @parser.upgrade?
@@ -198,19 +192,17 @@ module HTTPX
 
       @parser.reset!
       @max_requests -= 1
-      if response.is_a?(ErrorResponse)
-        disable
-      else
-        manage_connection(request, response)
-      end
+      manage_connection(request, response)
 
       if exhausted?
         @pending.unshift(*@requests)
         @requests.clear
 
         emit(:exhausted)
+      elsif @requests.any?
+        consume
       else
-        send(@pending.shift) unless @pending.empty?
+        send(@pending.shift, true) unless @pending.empty?
       end
     end
 

data/vendor/bundle/ruby/4.0.0/gems/{httpx-1.8.4 → httpx-1.9.0}/lib/httpx/connection/http2.rb

@@ -68,9 +68,9 @@ module HTTPX
     end
 
     def timeout
-      return @options.timeout[:operation_timeout] if @handshake_completed
+      return @options.timeout.operation_timeout if @handshake_completed
 
-      @options.timeout[:settings_timeout]
+      @options.timeout.settings_timeout
     end
 
     def interests
@@ -97,27 +97,45 @@ module HTTPX
         return :r
       end
 
+      # only wait for writable if we're not waiting on more streams,
+      # or waiting on ping ACKs.
+      nothing_to_wait_for = @streams.empty? && @pings.empty?
+
       # there are pending bufferable requests
-      return :w if !@pending.empty? && can_buffer_more_requests?
+      if !@pending.empty? && can_buffer_more_requests?
+        # only wait for writable if we're not waiting on more streams,
+        # or waiting on ping ACKs.
+        return nothing_to_wait_for ? :w : :rw
+      end
+
+      unless @drains.empty?
+        return :w unless @buffer.empty?
+
+        streams_with_no_window = @drains.none? do |stream, _|
+          # if an existing stream has buffered bytes, it must wait for
+          # WINDOW_UPDATE frames
+          stream.send_buffer.empty?
+        end
+
+        return streams_with_no_window ? :r : :rw
 
-      # there are pending frames from the last run
-      return :w unless @drains.empty?
+      end
 
       if @buffer.empty?
         # skip if no more requests or pings to process
-        return if @streams.empty? && @pings.empty?
+        return if nothing_to_wait_for
 
         :r
       else
         # buffered frames
-        :w
+        nothing_to_wait_for ? :w : :rw
       end
     end
 
     def close
       unless @connection.closed?
         @connection.goaway
-        emit(:timeout, @options.timeout[:close_handshake_timeout])
+        emit(:timeout, @options.timeout.close_handshake_timeout)
       end
       emit(:close)
     end
@@ -186,6 +204,8 @@ module HTTPX
       inflight_unprocessed_requests = [] #: Array[Request]
 
       while (req, stream = @streams.shift)
+        @drains.delete(stream)
+
         next if request && request == req
 
         if stream.id > last_stream_id
@@ -322,13 +342,23 @@ module HTTPX
     def join_body(stream, request)
       return if request.body.empty?
 
-      chunk = @drains.delete(request) || request.drain_body
+      # the next chunk waits until the peer grants more window.
+      throw(:buffer_full) if @drains.key?(stream) && (!stream.send_buffer.empty? || !@connection.send_buffer.empty?)
+
+      chunk = @drains.delete(stream) || request.drain_body
       while chunk
         next_chunk = request.drain_body
         send_chunk(request, stream, chunk, next_chunk)
 
-        if next_chunk && (@buffer.full? || request.body.unbounded_body?)
-          @drains[request] = next_chunk
+        if next_chunk && (
+          # send window is full
+          @buffer.full? ||
+          # stream / chunked request, must write a chunk at a time
+          request.body.unbounded_body? ||
+          # peer window is full, must wait for WINDOW_UPDATE frame(s)
+          !stream.send_buffer.empty? || !@connection.send_buffer.empty?
+        )
+          @drains[stream] = next_chunk
           throw(:buffer_full)
         end
 
@@ -462,7 +492,10 @@ module HTTPX
           end
         end
       end
-      send(@pending.shift) unless @pending.empty?
+
+      consume
+
+      send(@pending.shift, true) unless @pending.empty?
 
       return unless @streams.empty? && exhausted?
 
@@ -590,8 +623,9 @@ module HTTPX
 
     def teardown(request = nil)
       if request
-        @drains.delete(request)
-        @streams.delete(request)
+        if (stream = @streams.delete(request))
+          @drains.delete(stream)
+        end
       else
         @drains.clear
         @streams.clear