cybrid_api_id_ruby 0.129.1137 → 0.129.1138

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

@@ -0,0 +1,387 @@
+# frozen_string_literal: true
+
+require "delegate"
+require "forwardable"
+
+module HTTPX
+  # Defines how an HTTP request is handled internally, both in terms of making attributes accessible,
+  # as well as maintaining the state machine which manages streaming the request onto the wire.
+  class Request
+    extend Forwardable
+    include Loggable
+    include Callbacks
+
+    using URIExtensions
+
+    ALLOWED_URI_SCHEMES = %w[https http].freeze
+
+    # the upcased string HTTP verb for this request.
+    attr_reader :verb
+
+    # the absolute URI object for this request.
+    attr_reader :uri
+
+    # an HTTPX::Headers object containing the request HTTP headers.
+    attr_reader :headers
+
+    # an HTTPX::Request::Body object containing the request body payload (or +nil+, whenn there is none).
+    attr_reader :body
+
+    # a symbol describing which frame is currently being flushed.
+    attr_reader :state
+
+    # an HTTPX::Options object containing request options.
+    attr_reader :options
+
+    # the corresponding HTTPX::Response object, when there is one.
+    attr_reader :response
+
+    # Exception raised during enumerable body writes.
+    attr_reader :drain_error
+
+    # when this request is sent via HTTP/2, it'll use this hash of options to set the priority of the
+    # respective HTTP/2 frame.
+    attr_reader :http2_stream_options
+
+    # The IP address from the peer server.
+    attr_accessor :peer_address
+
+    # the connection the request is currently being sent to (none if before or after transaction)
+    attr_writer :connection
+
+    # callback triggered when a response (which may not be the final response) was assigned to the request.
+    attr_writer :on_response_arrived
+
+    attr_writer :persistent
+
+    attr_reader :active_timeouts
+
+    # will be +true+ when request body has been completely flushed.
+    def_delegator :@body, :empty?
+
+    # closes the body
+    def_delegator :@body, :close
+
+    # initializes the instance with the given +verb+ (an upppercase String, ex. 'GEt'),
+    # an absolute or relative +uri+ (either as String or URI::HTTP object), the
+    # request +options+ (instance of HTTPX::Options) and an optional Hash of +params+.
+    #
+    # Besides any of the options documented in HTTPX::Options (which would override or merge with what
+    # +options+ sets), it accepts also the following:
+    #
+    # :params :: hash or array of key-values which will be encoded and set in the query string of request uris.
+    # :body :: to be encoded in the request body payload. can be a String, an IO object (i.e. a File), or an Enumerable.
+    # :form :: hash of array of key-values which will be form-urlencoded- or multipart-encoded in requests body payload.
+    # :json :: hash of array of key-values which will be JSON-encoded in requests body payload.
+    # :xml :: Nokogiri XML nodes which will be encoded in requests body payload.
+    # :http2_stream_options :: hash of options to be used to set the HTTP/2 priority by sending an initial PRIORITY frame.
+    #
+    # :body, :form, :json and :xml are all mutually exclusive, i.e. only one of them gets picked up.
+    def initialize(verb, uri, options, params = EMPTY_HASH)
+      @verb    = verb.to_s.upcase
+      @uri     = Utils.to_uri(uri)
+
+      @headers = options.headers.dup
+      merge_headers(params.delete(:headers)) if params.key?(:headers)
+
+      @query_params = params.delete(:params) if params.key?(:params)
+
+      @http2_stream_options = params.key?(:http2_stream_options) ? params.delete(:http2_stream_options) : EMPTY_HASH
+
+      @body = options.request_body_class.new(@headers, options, **params)
+
+      @options = @body.options
+
+      if @uri.relative? || @uri.host.nil?
+        origin = @options.origin
+        raise(Error, "invalid URI: #{@uri}") unless origin
+
+        base_path = @options.base_path
+
+        @uri = origin.merge("#{base_path}#{@uri}")
+      end
+
+      raise UnsupportedSchemeError, "#{@uri}: #{@uri.scheme}: unsupported URI scheme" unless ALLOWED_URI_SCHEMES.include?(@uri.scheme)
+
+      @state = :idle
+      @connection = @response =
+        @drainer = @peer_address = @callbacks =
+                     @informational_status = @on_response_arrived = nil
+      @ping = @started = @complete = false
+      @persistent = @options.persistent
+      @active_timeouts = []
+    end
+
+    # dupped initialization
+    def initialize_dup(orig)
+      super
+      @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
+    def ping?
+      @ping
+    end
+
+    # marks the request as having been buffered with a ping
+    def ping!
+      @ping = true
+    end
+
+    # the read timeout defined for this request.
+    def read_timeout
+      @options.timeout[:read_timeout]
+    end
+
+    # the write timeout defined for this request.
+    def write_timeout
+      @options.timeout[:write_timeout]
+    end
+
+    # the request timeout defined for this request.
+    def request_timeout
+      @options.timeout[:request_timeout]
+    end
+
+    # the total request timeout defined for this request.
+    def total_request_timeout
+      @options.timeout[:total_request_timeout]
+    end
+
+    def persistent?
+      @persistent
+    end
+
+    # if the request contains trailer headers
+    def trailers?
+      defined?(@trailers)
+    end
+
+    # returns an instance of HTTPX::Headers containing the trailer headers
+    def trailers
+      @trailers ||= @options.headers_class.new
+    end
+
+    # returns +:r+ or +:w+, depending on whether the request is waiting for a response or flushing.
+    def interests
+      return :r if @state == :done || @state == :expect
+
+      :w
+    end
+
+    def can_buffer?
+      @state != :done
+    end
+
+    def started?
+      @started
+    end
+
+    # merges +h+ into the instance of HTTPX::Headers of the request.
+    def merge_headers(h)
+      @headers = @headers.merge(h)
+      return unless @headers.key?("range")
+
+      @headers.delete("accept-encoding")
+    end
+
+    # the URI scheme of the request +uri+.
+    def scheme
+      @uri.scheme
+    end
+
+    # sets the +response+ on this request.
+    def response=(response)
+      return unless response
+
+      case response
+      when Response
+        if response.status < 200
+          # deal with informational responses
+
+          if response.status == 100 && @headers.key?("expect")
+            @informational_status = response.status
+            return
+          end
+
+          # 103 Early Hints advertises resources in document to browsers.
+          # not very relevant for an HTTP client, discard.
+          return if response.status >= 103
+
+        end
+      when ErrorResponse
+        response.error.connection = nil if response.error.respond_to?(:connection=)
+      end
+
+      @response = response
+
+      emit(:response_started, response)
+    end
+
+    # returnns the URI path of the request +uri+.
+    def path
+      path = uri.path.dup
+      path =  +"" if path.nil?
+      path << "/" if path.empty?
+      path << "?#{query}" unless query.empty?
+      path
+    end
+
+    # returs the URI authority of the request.
+    #
+    #   session.build_request("GET", "https://google.com/query").authority #=> "google.com"
+    #   session.build_request("GET", "http://internal:3182/a").authority #=> "internal:3182"
+    def authority
+      @uri.authority
+    end
+
+    # returs the URI origin of the request.
+    #
+    #   session.build_request("GET", "https://google.com/query").authority #=> "https://google.com"
+    #   session.build_request("GET", "http://internal:3182/a").authority #=> "http://internal:3182"
+    def origin
+      @uri.origin
+    end
+
+    # returs the URI query string of the request (when available).
+    #
+    #   session.build_request("GET", "https://search.com").query #=> ""
+    #   session.build_request("GET", "https://search.com?q=a").query #=> "q=a"
+    #   session.build_request("GET", "https://search.com", params: { q: "a"}).query #=> "q=a"
+    #   session.build_request("GET", "https://search.com?q=a", params: { foo: "bar"}).query #=> "q=a&foo&bar"
+    def query
+      return @query if defined?(@query)
+
+      query = []
+      if (q = @query_params) && !q.empty?
+        query << Transcoder::Form.encode(q)
+      end
+      query << @uri.query if @uri.query
+      @query = query.join("&")
+    end
+
+    # consumes and returns the next available chunk of request body that can be sent
+    def drain_body
+      return if @body.nil?
+
+      @drainer ||= @body.each
+      @drainer.next.dup
+    rescue StopIteration
+      nil
+    rescue StandardError => e
+      # in case an error occurs while emitting body chunks
+      @drain_error = e
+      nil
+    end
+
+    # simplecov:disable
+    def inspect
+      "#<#{self.class}:#{object_id} " \
+        "#{@verb} " \
+        "#{uri} " \
+        "@headers=#{@headers} " \
+        "@body=#{@body}>"
+    end
+    # 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 = @complete = false
+        @response = @drainer = nil
+
+        # 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
+
+        @started = true
+      when :body
+        return unless @state == :headers ||
+                      @state == :expect
+
+        if @headers.key?("expect")
+          if @informational_status && @informational_status == 100
+            # check for 100 Continue response, and deallocate the var
+            # if @informational_status == 100
+            #   @response = nil
+            # end
+          else
+            return if @state == :expect # do not re-set it
+
+            nextstate = :expect
+          end
+        end
+      when :trailers
+        return unless @state == :body
+      when :done
+        return if @state == :expect
+
+      end
+      log(level: 3) { "#{@state} -> #{nextstate}" }
+      @state = nextstate
+      emit(@state, self)
+      nil
+    end
+
+    # whether the request supports the 100-continue handshake and already processed the 100 response.
+    def expects?
+      @headers["expect"] == "100-continue" && @informational_status == 100 && !@response
+    end
+
+    def set_timeout_callback(event, &callback)
+      clb = once(event, &callback)
+
+      # reset timeout callbacks when requests get rerouted to a different connection
+      once(:idle) do
+        callbacks(event).delete(clb)
+      end
+    end
+
+    def handle_error(error)
+      if (connection = @connection)
+        connection.on_error(error, self)
+      else
+        response = ErrorResponse.new(self, error)
+        self.response = response
+        emit_response(response)
+      end
+    end
+
+    def emit_response(response)
+      emit(:response, response)
+
+      return unless @on_response_arrived
+
+      @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
+
+require_relative "request/body"

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

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require "resolv"
+
+module HTTPX
+  module Resolver::Cache
+    # Base class of the Resolver Cache adapter implementations.
+    #
+    # While resolver caches are not required to inherit from this class, it nevertheless provides
+    # common useful functions for desired functionality, such as singleton object ractor-safe access,
+    # or a default #resolve implementation which deals with IPs and the system hosts file.
+    #
+    class Base
+      MAX_CACHE_SIZE = 512
+      CACHE_MUTEX = Thread::Mutex.new
+      HOSTS = Resolv::Hosts.new
+      @cache = nil
+
+      class << self
+        attr_reader :hosts_resolver
+
+        # returns the singleton instance to be used within the current ractor.
+        def cache(label)
+          return Ractor.store_if_absent(:"httpx_resolver_cache_#{label}") { new } if Utils.in_ractor?
+
+          @cache ||= CACHE_MUTEX.synchronize do
+            @cache || new
+          end
+        end
+      end
+
+      # resolves +hostname+ into an instance of HTTPX::Resolver::Entry if +hostname+ is an IP,
+      # or can be found in the cache, or can be found in the system hosts file.
+      def resolve(hostname)
+        ip_resolve(hostname) || get(hostname) || hosts_resolve(hostname)
+      end
+
+      private
+
+      # tries to convert +hostname+ into an IPAddr, returns <tt>nil</tt> otherwise.
+      def ip_resolve(hostname)
+        [Resolver::Entry.new(hostname)]
+      rescue ArgumentError
+      end
+
+      # matches +hostname+ to entries in the hosts file, returns <tt>nil</nil> if none is
+      # found, or there is no hosts file.
+      def hosts_resolve(hostname)
+        ips = if Utils.in_ractor?
+          Ractor.store_if_absent(:httpx_hosts_resolver) { Resolv::Hosts.new }
+        else
+          HOSTS
+        end.getaddresses(hostname)
+
+        return if ips.empty?
+
+        ips.map { |ip| Resolver::Entry.new(ip) }
+      rescue IOError
+      end
+
+      # not to be used directly!
+      def _get(hostname, lookups, hostnames, ttl)
+        return unless lookups.key?(hostname)
+
+        entries = lookups[hostname]
+
+        return unless entries
+
+        entries.delete_if do |address|
+          address["TTL"] < ttl
+        end
+
+        if entries.empty?
+          lookups.delete(hostname)
+          hostnames.delete(hostname)
+        end
+
+        ips = entries.flat_map do |address|
+          if (als = address["alias"])
+            _get(als, lookups, hostnames, ttl)
+          else
+            Resolver::Entry.new(address["data"], address["TTL"])
+          end
+        end.compact
+
+        ips unless ips.empty?
+      end
+
+      def _set(hostname, family, entries, lookups, hostnames)
+        # lru cleanup
+        while lookups.size >= MAX_CACHE_SIZE
+          hs = hostnames.shift
+          lookups.delete(hs)
+        end
+        hostnames << hostname
+
+        lookups[hostname] ||= [] # when there's no default proc
+
+        case family
+        when Socket::AF_INET6
+          lookups[hostname].concat(entries)
+        when Socket::AF_INET
+          lookups[hostname].unshift(*entries)
+        end
+        entries.each do |entry|
+          name = entry["name"]
+          next unless name != hostname
+
+          _set(name, family, [entry], lookups, hostnames)
+        end
+      end
+
+      def _evict(hostname, ip, lookups, hostnames)
+        return unless lookups.key?(hostname)
+
+        entries = lookups[hostname]
+
+        return unless entries
+
+        entries.delete_if { |entry| entry["data"] == ip }
+
+        return unless entries.empty?
+
+        lookups.delete(hostname)
+        hostnames.delete(hostname)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "pstore"
+require "tmpdir"
+
+module HTTPX
+  module Resolver::Cache
+    # Implementation of a file resolver cache.
+    class File < Base
+      # default path where the resolver cache is stored. It's versioned, as the file may
+      # change format in-between releases, and it'd signal it as corrupted.
+      DEFAULT_PATH = ::File.join(Dir.tmpdir, "httpx-ruby-#{VERSION}.cache")
+
+      def initialize(path = DEFAULT_PATH)
+        super()
+        @store = PStore.new(path, true)
+      end
+
+      def get(hostname)
+        now = Utils.now
+        @store.transaction do
+          lookups = @store[:lookups] || EMPTY_HASH
+          hostnames = @store[:hostnames] || EMPTY
+
+          _get(hostname, lookups, hostnames, now)
+        end
+      end
+
+      def set(hostname, family, entries)
+        @store.transaction do
+          lookups = @store[:lookups] || {}
+          hostnames = @store[:hostnames] || []
+
+          _set(hostname, family, entries, lookups, hostnames)
+
+          @store[:lookups] = lookups
+          @store[:hostnames] = hostnames
+        end
+      end
+
+      def evict(hostname, ip)
+        ip = ip.to_s
+
+        @store.transaction do
+          lookups = @store[:lookups] || EMPTY_HASH
+          hostnames = @store[:hostnames] || EMPTY
+
+          _evict(hostname, ip, lookups, hostnames)
+
+          @store[:lookups] = lookups
+          @store[:hostnames] = hostnames
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Resolver::Cache
+    # Implementation of a thread-safe in-memory LRU resolver cache.
+    class Memory < Base
+      def initialize
+        super
+        @hostnames = []
+        @lookups = Hash.new { |h, k| h[k] = [] }
+        @lookup_mutex = Thread::Mutex.new
+      end
+
+      def get(hostname)
+        now = Utils.now
+        synchronize do |lookups, hostnames|
+          _get(hostname, lookups, hostnames, now)
+        end
+      end
+
+      def set(hostname, family, entries)
+        synchronize do |lookups, hostnames|
+          _set(hostname, family, entries, lookups, hostnames)
+        end
+      end
+
+      def evict(hostname, ip)
+        ip = ip.to_s
+
+        synchronize do |lookups, hostnames|
+          _evict(hostname, ip, lookups, hostnames)
+        end
+      end
+
+      private
+
+      def synchronize
+        @lookup_mutex.synchronize { yield(@lookups, @hostnames) }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "httpx/resolver/cache/base"
+require "httpx/resolver/cache/memory"
+
+module HTTPX::Resolver
+  # The internal resolvers cache adapters are defined under this namespace.
+  #
+  # Adapters must comply with the Resolver Cache Adapter API and implement the following methods:
+  #
+  # * #resolve: (String hostname) -> Array[HTTPX::Entry]? => resolves hostname to a list of cached IPs (if found in cache or system)
+  # * #get: (String hostname) -> Array[HTTPX::Entry]? => resolves hostname to a list of cached IPs (if found in cache)
+  # * #set: (String hostname, Integer ip_family, Array[dns_result]) -> void => stores the set of results in the cache indexes for
+  #         the hostname and the IP family
+  # * #evict: (String hostname, _ToS ip) -> void => evicts the ip for the hostname from the cache (usually done when no longer reachable)
+  module Cache
+  end
+end

data/vendor/bundle/ruby/4.0.0/gems/httpx-1.8.4/lib/httpx/resolver/entry.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "ipaddr"
+
+module HTTPX
+  module Resolver
+    class Entry < SimpleDelegator
+      attr_reader :address
+
+      def self.convert(address)
+        new(address, rescue_on_convert: true)
+      end
+
+      def initialize(address, expires_in = Float::INFINITY, rescue_on_convert: false)
+        @expires_in = expires_in
+        @address = address.is_a?(IPAddr) ? address : IPAddr.new(address.to_s)
+        super(@address)
+      rescue IPAddr::InvalidAddressError
+        raise unless rescue_on_convert
+
+        @address = address.to_s
+        super(@address)
+      end
+
+      def expired?
+        @expires_in < Utils.now
+      end
+    end
+  end
+end