cybrid_api_id_ruby 0.129.1137 → 0.129.1138

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

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+require "resolv"
+
+module HTTPX
+  # Base class for all internal internet name resolvers. It handles basic blocks
+  # from the Selectable API.
+  #
+  class Resolver::Resolver
+    include Loggable
+
+    using ArrayExtensions::Intersect
+
+    RECORD_TYPES = {
+      Socket::AF_INET6 => Resolv::DNS::Resource::IN::AAAA,
+      Socket::AF_INET => Resolv::DNS::Resource::IN::A,
+    }.freeze
+
+    FAMILY_TYPES = {
+      Resolv::DNS::Resource::IN::AAAA => "AAAA",
+      Resolv::DNS::Resource::IN::A => "A",
+    }.freeze
+
+    class << self
+      def multi?
+        true
+      end
+    end
+
+    attr_reader :family, :options
+
+    attr_writer :current_selector, :current_session
+
+    attr_accessor :multi
+
+    def initialize(family, options)
+      @family = family
+      @record_type = RECORD_TYPES[family]
+      @options = options
+      @connections = []
+    end
+
+    def each_connection(&block)
+      enum_for(__method__) unless block
+
+      return unless @connections
+
+      @connections.each(&block)
+    end
+
+    def close; end
+
+    alias_method :terminate, :close
+
+    def initial_call
+      call
+    end
+
+    def force_close(...)
+      while (connection = @connections.shift)
+        connection.force_close(...)
+      end
+    end
+
+    def closed?
+      true
+    end
+
+    def empty?
+      true
+    end
+
+    def inflight?
+      false
+    end
+
+    def emit_addresses(connection, family, addresses, early_resolve = false)
+      addresses.map! { |address| address.is_a?(Resolver::Entry) ? address : Resolver::Entry.new(address) }
+
+      # double emission check, but allow early resolution to work
+      conn_addrs = connection.addresses
+      return if !early_resolve && conn_addrs && !conn_addrs.empty? && !addresses.intersect?(conn_addrs)
+
+      log do
+        "resolver #{FAMILY_TYPES[RECORD_TYPES[family]]}: " \
+          "answer #{connection.peer.host}: #{addresses.inspect} (early resolve: #{early_resolve})"
+      end
+
+      # do not apply resolution delay for non-dns name resolution
+      if !early_resolve &&
+         # just in case...
+         @current_selector &&
+         # resolution delay only applies to IPv4
+         family == Socket::AF_INET &&
+         # connection already has addresses and initiated/ended handshake
+         !connection.io &&
+         # no need to delay if not supporting dual stack / multi-homed IP
+         (connection.options.ip_families || Resolver.supported_ip_families).size > 1 &&
+         # connection URL host is already the IP (early resolve included perhaps?)
+         addresses.first.to_s != connection.peer.host.to_s
+        log { "resolver #{FAMILY_TYPES[RECORD_TYPES[family]]}: applying resolution delay..." }
+
+        @current_selector.after(0.05) do
+          # double emission check
+          unless connection.addresses && addresses.intersect?(connection.addresses)
+            emit_resolved_connection(connection, addresses, early_resolve)
+          end
+        end
+      else
+        emit_resolved_connection(connection, addresses, early_resolve)
+      end
+    end
+
+    def handle_error(error)
+      if error.respond_to?(:connection) &&
+         error.respond_to?(:host)
+        @connections.delete(error.connection)
+        emit_resolve_error(error.connection, error.host, error)
+      else
+        while (connection = @connections.shift)
+          emit_resolve_error(connection, connection.peer.host, error)
+        end
+      end
+    end
+
+    def on_io_error(e)
+      on_error(e)
+      force_close(true)
+    end
+
+    def on_error(error)
+      handle_error(error)
+      disconnect
+    end
+
+    def early_resolve(connection, hostname: connection.peer.host) # rubocop:disable Naming/PredicateMethod
+      addresses = @resolver_options[:cache] && (connection.addresses || @options.resolver_cache.resolve(hostname))
+
+      return false unless addresses
+
+      addresses = addresses.select { |addr| addr.family == @family }
+
+      return false if addresses.empty?
+
+      emit_addresses(connection, @family, addresses, true)
+
+      true
+    end
+
+    def lazy_resolve(connection)
+      return unless @current_session && @current_selector
+
+      conn_to_resolve = @current_session.try_clone_connection(connection, @current_selector, @family)
+      self << conn_to_resolve
+
+      return if empty?
+
+      # both the resolver and the connection it's resolving must be pinned to the session
+      @current_session.pin(conn_to_resolve, @current_selector)
+      @current_session.select_resolver(self, @current_selector)
+    end
+
+    private
+
+    def emit_resolved_connection(connection, addresses, early_resolve)
+      begin
+        connection.addresses = addresses
+
+        return if connection.state == :closed
+
+        resolve_connection(connection)
+      rescue StandardError => e
+        if early_resolve
+          connection.force_close
+          throw(:resolve_error, e)
+        else
+          emit_connection_error(connection, e)
+        end
+      end
+    end
+
+    def emit_resolve_error(connection, hostname = connection.peer.host, ex = nil)
+      emit_connection_error(connection, resolve_error(hostname, ex))
+    end
+
+    def resolve_error(hostname, ex = nil)
+      return ex if ex.is_a?(ResolveError) || ex.is_a?(ResolveTimeoutError)
+
+      message = ex ? ex.message : "Can't resolve #{hostname}"
+      error = ResolveError.new(message)
+      error.set_backtrace(ex ? ex.backtrace : caller)
+      error
+    end
+
+    def resolve_connection(connection)
+      @current_session.__send__(:on_resolver_connection, connection, @current_selector)
+    end
+
+    def emit_connection_error(connection, error)
+      return connection.handle_connect_error(error) if connection.connecting?
+
+      connection.on_error(error)
+    end
+
+    def disconnect
+      close
+
+      return unless closed?
+
+      @current_session.deselect_resolver(self, @current_selector)
+    end
+  end
+end

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

@@ -0,0 +1,284 @@
+# frozen_string_literal: true
+
+require "resolv"
+
+module HTTPX
+  # Implementation of a synchronous name resolver which relies on the system resolver,
+  # which is lib'c getaddrinfo function (abstracted in ruby via Addrinfo.getaddrinfo).
+  #
+  # Its main advantage is relying on the reference implementation for name resolution
+  # across most/all OSs which deploy ruby (it's what TCPSocket also uses), its main
+  # disadvantage is the inability to set timeouts / check socket for readiness events,
+  # hence why it relies on using the Timeout module, which poses a lot of problems for
+  # the selector loop, specially when network is unstable.
+  #
+  class Resolver::System < Resolver::Resolver
+    using URIExtensions
+
+    RESOLV_ERRORS = [Resolv::ResolvError,
+                     Resolv::DNS::Requester::RequestError,
+                     Resolv::DNS::EncodeError,
+                     Resolv::DNS::DecodeError].freeze
+
+    DONE = 1
+    ERROR = 2
+
+    class AddrinfoTimeoutError < StandardError
+    end
+
+    class << self
+      def multi?
+        false
+      end
+    end
+
+    attr_reader :state
+
+    def initialize(options)
+      super(0, options)
+      @resolver_options = @options.resolver_options
+      resolv_options = @resolver_options.dup
+      timeouts = resolv_options.delete(:timeouts) || Resolver::RESOLVE_TIMEOUT
+      @_timeouts = Array(timeouts)
+      @timeouts = Hash.new { |tims, host| tims[host] = @_timeouts.dup }
+      resolv_options.delete(:cache)
+      @queries = []
+      @ips = []
+      @pipe_mutex = Thread::Mutex.new
+      @state = :idle
+    end
+
+    def resolvers
+      return enum_for(__method__) unless block_given?
+
+      yield self
+    end
+
+    def multi
+      self
+    end
+
+    def empty?
+      @connections.empty?
+    end
+
+    def close
+      transition(:closed)
+    end
+
+    def force_close(*)
+      close
+      @queries.clear
+      @timeouts.clear
+      @ips.clear
+      super
+    end
+
+    def closed?
+      @state == :closed
+    end
+
+    def to_io
+      @pipe_read.to_io
+    end
+
+    def call
+      case @state
+      when :open
+        consume
+      end
+      nil
+    end
+
+    def interests
+      return if @queries.empty?
+
+      :r
+    end
+
+    def timeout
+      _, connection = @queries.first
+
+      return unless connection
+
+      timeouts = @timeouts[connection.peer.host]
+
+      return if timeouts.empty?
+
+      log(level: 2) { "resolver #{FAMILY_TYPES[@record_type]}: next timeout #{timeouts.first} secs... (#{timeouts.size - 1} left)" }
+
+      timeouts.first
+    end
+
+    def lazy_resolve(connection)
+      @connections << connection
+      resolve
+
+      return if empty?
+
+      @current_session.select_resolver(self, @current_selector)
+    end
+
+    def early_resolve(_, **) # rubocop:disable Naming/PredicateMethod
+      false
+    end
+
+    def handle_socket_timeout(interval)
+      error = HTTPX::ResolveTimeoutError.new(interval, "timed out while waiting on select")
+      error.set_backtrace(caller)
+      @queries.each do |_, connection| # rubocop:disable Style/HashEachMethods
+        emit_resolve_error(connection, connection.peer.host, error) if @connections.delete(connection)
+      end
+
+      while (connection = @connections.shift)
+        emit_resolve_error(connection, connection.peer.host, error)
+      end
+
+      close_or_resolve
+    end
+
+    private
+
+    def transition(nextstate)
+      case nextstate
+      when :idle
+        @timeouts.clear
+      when :open
+        return unless @state == :idle
+
+        @pipe_read, @pipe_write = IO.pipe
+      when :closed
+        return unless @state == :open
+
+        @pipe_write.close
+        @pipe_read.close
+      end
+      @state = nextstate
+    end
+
+    def consume
+      return if @connections.empty?
+
+      event = @pipe_read.read_nonblock(1, exception: false)
+
+      return if event == :wait_readable
+
+      raise ResolveError, "socket pipe closed unexpectedly" if event.nil?
+
+      case event.unpack1("C")
+      when DONE
+        *pair, addrs = @pipe_mutex.synchronize { @ips.pop }
+        if pair
+          @queries.delete(pair)
+          family, connection = pair
+          @connections.delete(connection)
+
+          catch(:coalesced) { emit_addresses(connection, family, addrs) }
+        end
+      when ERROR
+        *pair, error = @pipe_mutex.synchronize { @ips.pop }
+        if pair && error
+          @queries.delete(pair)
+          _, connection = pair
+          @connections.delete(connection)
+
+          emit_resolve_error(connection, connection.peer.host, error)
+        end
+      end
+
+      return disconnect if @connections.empty?
+
+      resolve
+    rescue StandardError => e
+      on_error(e)
+    end
+
+    def resolve(connection = nil, hostname = nil)
+      @connections.shift until @connections.empty? || @connections.first.state != :closed
+
+      connection ||= @connections.first
+
+      raise Error, "no URI to resolve" unless connection
+
+      return unless @queries.empty?
+
+      hostname ||= connection.peer.host
+      scheme = connection.origin.scheme
+      log do
+        "resolver: resolve IDN #{connection.peer.non_ascii_hostname} as #{hostname}"
+      end if connection.peer.non_ascii_hostname
+
+      transition(:open)
+
+      ip_families = connection.options.ip_families || Resolver.supported_ip_families
+
+      ip_families.each do |family|
+        @queries << [family, connection]
+      end
+      async_resolve(connection, hostname, scheme)
+      consume
+    end
+
+    def async_resolve(connection, hostname, scheme)
+      families = connection.options.ip_families || Resolver.supported_ip_families
+      log { "resolver: query for #{hostname}" }
+      timeouts = @timeouts[connection.peer.host]
+      resolve_timeout = timeouts.first
+
+      Thread.start do
+        Thread.current.report_on_exception = false
+        begin
+          addrs = if resolve_timeout
+
+            Timeout.timeout(resolve_timeout, AddrinfoTimeoutError) do
+              __addrinfo_resolve(hostname, scheme)
+            end
+          else
+            __addrinfo_resolve(hostname, scheme)
+          end
+          addrs = addrs.sort_by(&:afamily).group_by(&:afamily)
+          families.each do |family|
+            addresses = addrs[family]
+            next unless addresses
+
+            addresses.map!(&:ip_address)
+            addresses.uniq!
+            @pipe_mutex.synchronize do
+              @ips.unshift([family, connection, addresses])
+              @pipe_write.putc(DONE) unless @pipe_write.closed?
+            end
+          end
+        rescue StandardError => e
+          if e.is_a?(AddrinfoTimeoutError)
+            timeouts.shift
+            retry unless timeouts.empty?
+            e = ResolveTimeoutError.new(resolve_timeout, e.message)
+            e.set_backtrace(e.backtrace)
+          end
+          @pipe_mutex.synchronize do
+            families.each do |family|
+              @ips.unshift([family, connection, e])
+              @pipe_write.putc(ERROR) unless @pipe_write.closed?
+            end
+          end
+        end
+      end
+      Thread.pass
+    end
+
+    def close_or_resolve
+      # drop already closed connections
+      @connections.shift until @connections.empty? || @connections.first.state != :closed
+
+      if (@connections - @queries.map(&:last)).empty?
+        disconnect
+      else
+        resolve
+      end
+    end
+
+    def __addrinfo_resolve(host, scheme)
+      Addrinfo.getaddrinfo(host, scheme, Socket::AF_UNSPEC, Socket::SOCK_STREAM)
+    end
+  end
+end

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

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require "socket"
+require "resolv"
+
+module HTTPX
+  module Resolver
+    extend self
+
+    RESOLVE_TIMEOUT = [2, 3].freeze
+    require "httpx/resolver/entry"
+    require "httpx/resolver/cache"
+    require "httpx/resolver/resolver"
+    require "httpx/resolver/system"
+    require "httpx/resolver/native"
+    require "httpx/resolver/https"
+    require "httpx/resolver/multi"
+
+    @identifier_mutex = Thread::Mutex.new
+    @identifier = 1
+
+    def supported_ip_families
+      if Utils.in_ractor?
+        Ractor.store_if_absent(:httpx_supported_ip_families) { find_supported_ip_families }
+      else
+        @supported_ip_families ||= find_supported_ip_families
+      end
+    end
+
+    def generate_id
+      if Utils.in_ractor?
+        identifier = Ractor.store_if_absent(:httpx_resolver_identifier) { -1 }
+        Ractor.current[:httpx_resolver_identifier] = (identifier + 1) & 0xFFFF
+      else
+        id_synchronize { @identifier = (@identifier + 1) & 0xFFFF }
+      end
+    end
+
+    def encode_dns_query(hostname, type: Resolv::DNS::Resource::IN::A, message_id: generate_id)
+      Resolv::DNS::Message.new(message_id).tap do |query|
+        query.rd = 1
+        query.add_question(hostname, type)
+      end.encode
+    end
+
+    def decode_dns_answer(payload)
+      begin
+        message = Resolv::DNS::Message.decode(payload)
+      rescue Resolv::DNS::DecodeError => e
+        return :decode_error, e
+      end
+
+      # no domain was found
+      return :no_domain_found if message.rcode == Resolv::DNS::RCode::NXDomain
+
+      return :message_truncated if message.tc == 1
+
+      if message.rcode != Resolv::DNS::RCode::NoError
+        case message.rcode
+        when Resolv::DNS::RCode::ServFail
+          return :retriable_error, message.rcode
+        else
+          return :dns_error, message.rcode
+        end
+      end
+
+      addresses = []
+
+      now = Utils.now
+      message.each_answer do |question, _, value|
+        case value
+        when Resolv::DNS::Resource::IN::CNAME
+          addresses << {
+            "name" => question.to_s,
+            "TTL" => (now + value.ttl),
+            "alias" => value.name.to_s,
+          }
+        when Resolv::DNS::Resource::IN::A,
+             Resolv::DNS::Resource::IN::AAAA
+          addresses << {
+            "name" => question.to_s,
+            "TTL" => (now + value.ttl),
+            "data" => value.address.to_s,
+          }
+        end
+      end
+
+      [:ok, addresses]
+    end
+
+    private
+
+    def id_synchronize(&block)
+      @identifier_mutex.synchronize(&block)
+    end
+
+    def find_supported_ip_families
+      list = Socket.ip_address_list
+
+      begin
+        if list.any? { |a| a.ipv6? && !a.ipv6_loopback? && !a.ipv6_linklocal? }
+          [Socket::AF_INET6, Socket::AF_INET]
+        else
+          [Socket::AF_INET]
+        end
+      rescue NotImplementedError
+        [Socket::AF_INET]
+      end.freeze
+    end
+  end
+end