cybrid_api_id_ruby 0.129.1137 → 0.129.1138

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

@@ -0,0 +1,336 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Plugins
+    #
+    # This plugin adds support for managing an OAuth Session associated with the given session.
+    #
+    # The scope of OAuth support is limited to the `client_crendentials` and `refresh_token` grants.
+    #
+    # https://gitlab.com/os85/httpx/wikis/OAuth
+    #
+    module OAuth
+      class << self
+        def load_dependencies(klass)
+          require "monitor"
+          require_relative "auth/basic"
+          klass.plugin(:auth)
+        end
+
+        def subplugins
+          {
+            retries: OAuthRetries,
+          }
+        end
+
+        def extra_options(options)
+          options.merge(auth_header_type: "Bearer")
+        end
+      end
+
+      SUPPORTED_GRANT_TYPES = %w[client_credentials refresh_token].freeze
+      SUPPORTED_AUTH_METHODS = %w[client_secret_basic client_secret_post].freeze
+
+      # Implements the bulk of functionality and maintains the state associated with the
+      # management of the the lifecycle of an OAuth session.
+      class OAuthSession
+        def initialize(
+          issuer:,
+          client_id:,
+          client_secret:,
+          access_token: nil,
+          refresh_token: nil,
+          scope: nil,
+          audience: nil,
+          token_endpoint: nil,
+          grant_type: nil,
+          token_endpoint_auth_method: nil
+        )
+          @issuer = URI(issuer)
+          @client_id = client_id
+          @client_secret = client_secret
+          @token_endpoint = URI(token_endpoint) if token_endpoint
+          @scope = case scope
+                   when String
+                     scope.split
+                   when Array
+                     scope
+          end
+          @audience = audience
+          @access_token = access_token
+          @refresh_token = refresh_token
+          @token_endpoint_auth_method = String(token_endpoint_auth_method) if token_endpoint_auth_method
+          @grant_type = grant_type || (@refresh_token ? "refresh_token" : "client_credentials")
+          @expires_at = nil
+          @token_mon = Monitor.new
+
+          unless @token_endpoint_auth_method.nil? || SUPPORTED_AUTH_METHODS.include?(@token_endpoint_auth_method)
+            raise Error, "#{@token_endpoint_auth_method} is not a supported auth method"
+          end
+
+          return if SUPPORTED_GRANT_TYPES.include?(@grant_type)
+
+          raise Error, "#{@grant_type} is not a supported grant type"
+        end
+
+        # returns the URL where to request access and refresh tokens from.
+        def token_endpoint
+          @token_endpoint || "#{@issuer}/token"
+        end
+
+        # returns the oauth-documented authorization method to use when requesting a token.
+        def token_endpoint_auth_method
+          @token_endpoint_auth_method || "client_secret_basic"
+        end
+
+        def expires_at
+          @token_mon.synchronize { @expires_at }
+        end
+
+        def access_token
+          @token_mon.synchronize do
+            if (expires_at = @expires_at) && expires_at < Time.now.to_i
+              reset!
+            end
+
+            @access_token
+          end
+        end
+
+        def reset!
+          @token_mon.synchronize do
+            @access_token = @expires_at = nil
+          end
+        end
+
+        # when not available, it uses the +http+ object to request new access and refresh tokens.
+        def fetch_access_token(http)
+          return access_token if access_token
+
+          load(http)
+
+          # always prefer refresh token grant if a refresh token is available
+          grant_type = @refresh_token ? "refresh_token" : @grant_type
+
+          headers = {} # : Hash[String ,String]
+          form_post = {
+            "grant_type" => @grant_type,
+            "scope" => Array(@scope).join(" "),
+            "audience" => @audience,
+          }.compact
+
+          # auth
+          case token_endpoint_auth_method
+          when "client_secret_post"
+            form_post["client_id"] = @client_id
+            form_post["client_secret"] = @client_secret
+          when "client_secret_basic"
+            headers["authorization"] = Authentication::Basic.new(@client_id, @client_secret).authenticate
+          end
+
+          case grant_type
+          when "client_credentials"
+            # do nothing
+          when "refresh_token"
+            ref_token = refresh_token
+
+            raise Error, "cannot use the `\"refresh_token\"` grant type without a refresh token" unless ref_token
+
+            form_post["refresh_token"] = ref_token
+          end
+
+          # POST /token
+          token_request = http.build_request("POST", token_endpoint, headers: headers, form: form_post)
+
+          token_request.headers.delete("authorization") unless token_endpoint_auth_method == "client_secret_basic"
+
+          token_response = http.skip_auth_header { http.request(token_request) }
+
+          begin
+            token_response.raise_for_status
+          rescue HTTPError => e
+            @refresh_token = nil if e.response.status == 401 && (grant_type == "refresh_token")
+            raise e
+          end
+
+          payload = token_response.json
+
+          @token_mon.synchronize do
+            @refresh_token = payload.fetch("refresh_token", @refresh_token)
+            if (expires_in = payload["expires_in"])
+              @expires_at = Time.now.to_i + Integer(expires_in)
+            end
+            @access_token = payload["access_token"]
+          end
+        end
+
+        # TODO: remove this after deprecating the `:oauth_session` option
+        def merge(other)
+          obj = dup
+
+          case other
+          when OAuthSession
+            other.instance_variables.each do |ivar|
+              val = other.instance_variable_get(ivar)
+              next unless val
+
+              obj.instance_variable_set(ivar, val)
+            end
+          when Hash
+            other.each do |k, v|
+              obj.instance_variable_set(:"@#{k}", v) if obj.instance_variable_defined?(:"@#{k}")
+            end
+          end
+          obj
+        end
+
+        private
+
+        def refresh_token
+          @token_mon.synchronize { @refresh_token }
+        end
+
+        # uses +http+ to fetch for the oauth server metadata.
+        def load(http)
+          return if @grant_type && @scope
+
+          metadata = http.skip_auth_header { http.get("#{@issuer}/.well-known/oauth-authorization-server").raise_for_status.json }
+
+          @token_mon.synchronize do
+            @token_endpoint = metadata["token_endpoint"]
+            @scope = metadata["scopes_supported"]
+            @grant_type = Array(metadata["grant_types_supported"]).find { |gr| SUPPORTED_GRANT_TYPES.include?(gr) }
+            @token_endpoint_auth_method = Array(metadata["token_endpoint_auth_methods_supported"]).find do |am|
+              SUPPORTED_AUTH_METHODS.include?(am)
+            end
+          end
+          nil
+        end
+      end
+
+      # adds support for the following options:
+      #
+      # :oauth_options :: an hash of options to be used during session management.
+      #                   check the parameters to initialize the OAuthSession class.
+      module OptionsMethods
+        private
+
+        def option_oauth_session(value)
+          warn "DEPRECATION WARNING: option `:oauth_session` is deprecated. " \
+               "Use `:oauth_options` instead."
+
+          case value
+          when Hash
+            OAuthSession.new(**value)
+          when OAuthSession
+            value
+          else
+            raise TypeError, ":oauth_session must be a #{OAuthSession}"
+          end
+        end
+
+        def option_oauth_options(value)
+          value = Hash[value] unless value.is_a?(Hash)
+          value
+        end
+      end
+
+      module InstanceMethods
+        attr_reader :oauth_session
+        protected :oauth_session
+
+        def initialize(*)
+          super
+
+          @oauth_session = if @options.oauth_options
+            OAuthSession.new(**@options.oauth_options)
+          elsif @options.oauth_session
+            @oauth_session = @options.oauth_session.dup
+          end
+        end
+
+        def initialize_dup(other)
+          super
+          @oauth_session = other.instance_variable_get(:@oauth_session).dup
+        end
+
+        def oauth_auth(**args)
+          warn "DEPRECATION WARNING: `#{__method__}` is deprecated. " \
+               "Use `with(oauth_options: options)` instead."
+
+          with(oauth_options: args)
+        end
+
+        # will eagerly negotiate new oauth tokens with the issuer
+        def refresh_oauth_tokens!
+          return unless @oauth_session
+
+          @oauth_session.reset!
+          @oauth_session.fetch_access_token(self)
+          if (expires_at = @oauth_session.expires_at)
+            @auth_header_value_mtx.synchronize do
+              @auth_header_expires_at = expires_at
+            end
+          end
+        end
+
+        # TODO: deprecate
+        def with_access_token
+          warn "DEPRECATION WARNING: `#{__method__}` is deprecated. " \
+               "The session will automatically handle token lifecycles for you."
+
+          other_session = dup # : instance
+          oauth_session = other_session.oauth_session
+          oauth_session.fetch_access_token(other_session)
+          if (expires_at = oauth_session.expires_at)
+            @auth_header_expires_at = expires_at
+          end
+          other_session
+        end
+
+        def reset_auth_header_value!
+          super.tap do
+            @oauth_session.reset if @oauth_session
+          end
+        end
+
+        private
+
+        def generate_auth_token(*)
+          return super unless @oauth_session
+
+          # should_regenerate arg ignored, as there's no way to check
+          # for token expiration yet.
+          @oauth_session.fetch_access_token(self)
+        end
+
+        def set_auth_header_expires_at(_)
+          return super unless @oauth_session
+
+          expires_at = @oauth_session.expires_at
+
+          return super unless expires_at
+
+          @auth_header_expires_at = expires_at
+        end
+
+        def dynamic_auth_token?(_)
+          @oauth_session
+        end
+      end
+
+      module OAuthRetries
+        module InstanceMethods
+          private
+
+          def prepare_to_retry(_request, response)
+            @oauth_session.reset! if @oauth_session
+
+            super
+          end
+        end
+      end
+    end
+    register_plugin :oauth, OAuth
+  end
+end

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

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Plugins
+    # This plugin implements a session that persists connections over the duration of the process.
+    #
+    # This will improve connection reuse in a long-running process.
+    #
+    # One important caveat to note is, although this session might not close connections,
+    # other sessions from the same process that don't have this plugin turned on might.
+    #
+    # This session will still be able to work with it, as if, when expecting a connection
+    # terminated by a different session, it will just retry on a new one and keep it open.
+    #
+    # This plugin is also not recommendable when connecting to >9000 (like, a lot) different origins.
+    # So when you use this, make sure that you don't fall into this trap.
+    #
+    # https://gitlab.com/os85/httpx/wikis/Persistent
+    #
+    module Persistent
+      SAFE_REONNECTABLE_ERRORS = [
+        PingTimeoutError,
+        Connection::HTTP2::GoawayError,
+        Connection::HTTP2::PingError,
+      ].freeze
+
+      class << self
+        def load_dependencies(klass)
+          klass.plugin(:fiber_concurrency)
+
+          max_retries = if klass.default_options.respond_to?(:max_retries)
+            [klass.default_options.max_retries, 1].max
+          else
+            1
+          end
+          klass.plugin(:retries, max_retries: max_retries)
+        end
+      end
+
+      def self.extra_options(options)
+        options.merge(persistent: true)
+      end
+
+      module InstanceMethods
+        def close(*)
+          super
+
+          # traverse other threads and unlink respective selector
+          # WARNING: this is not thread safe, make sure that the session isn't being
+          # used anymore, or all non-main threads are stopped.
+          Thread.list.each do |th|
+            store = thread_selector_store(th)
+
+            next unless store && store.key?(self)
+
+            selector = store.delete(self)
+
+            selector_close(selector)
+          end
+        end
+
+        private
+
+        def reconnectable_error?(error)
+          Retries::RECONNECTABLE_ERRORS.any? { |klass| error.is_a?(klass) }
+        end
+
+        # whether the error can be safely retried without booking threshold attempts.
+        def safe_reconnectable_error?(error)
+          SAFE_REONNECTABLE_ERRORS.any? { |klass| error.is_a?(klass) }
+        end
+
+        def can_reconnect?(_, response)
+          super || (response.is_a?(ErrorResponse) && safe_reconnectable_error?(response.error))
+        end
+
+        def when_to_retry(request, response, *)
+          return super unless response.is_a?(ErrorResponse)
+
+          error = response.error
+          # allow request to be retried immediately if the request failed right after the keep alive timeout.
+          # the chances are, the request failed because the connect has been dropped by the peer server, so it's
+          # fine to reopen.
+          return if request.ping? && reconnectable_error?(error)
+
+          super
+        end
+
+        def retryable_request?(request, response, *)
+          super || begin
+            return false unless response.is_a?(ErrorResponse)
+
+            error = response.error
+
+            reconnectable_error?(error)
+          end
+        end
+
+        def retryable_error?(ex, options)
+          super &&
+            # under the persistent plugin rules, requests are only retried for connection related errors,
+            # which do not include request timeout related errors. This only gets overriden if the end user
+            # manually changed +:max_retries+ to something else, which means it is aware of the
+            # consequences.
+            (!ex.is_a?(RequestTimeoutError) || options.max_retries != 1)
+        end
+      end
+    end
+    register_plugin :persistent, Persistent
+  end
+end

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

@@ -0,0 +1,236 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Plugins
+    module Proxy
+      module HTTP
+        class << self
+          def extra_options(options)
+            options.merge(supported_proxy_protocols: options.supported_proxy_protocols + %w[http])
+          end
+        end
+
+        module InstanceMethods
+          def with_proxy_basic_auth(opts)
+            with(proxy: opts.merge(scheme: "basic"))
+          end
+
+          def with_proxy_digest_auth(opts)
+            with(proxy: opts.merge(scheme: "digest"))
+          end
+
+          def with_proxy_ntlm_auth(opts)
+            with(proxy: opts.merge(scheme: "ntlm"))
+          end
+
+          def fetch_response(request, selector, options)
+            response = super
+
+            if response &&
+               response.is_a?(Response) &&
+               response.status == 407 &&
+               !request.headers.key?("proxy-authorization") &&
+               response.headers.key?("proxy-authenticate") && options.proxy.can_authenticate?(response.headers["proxy-authenticate"])
+              request.transition(:idle)
+              request.headers["proxy-authorization"] =
+                options.proxy.authenticate(request, response.headers["proxy-authenticate"])
+              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
+
+            response
+          end
+        end
+
+        module ConnectionMethods
+          def initialize(*)
+            @tunnel_parser = nil
+            super
+          end
+
+          def force_close(*)
+            if @state == :connecting
+              # proxy connect related requests should not be reenqueed
+              @parser.reset
+              @inflight -= @parser.pending.size
+              @parser.pending.clear
+            end
+
+            super
+          end
+
+          private
+
+          def purge_after_closed
+            super
+
+            @tunnel_parser = nil
+          end
+
+          def handle_transition(nextstate)
+            return super unless @options.proxy && @options.proxy.uri.scheme == "http"
+
+            case nextstate
+            when :connecting
+              return unless @state == :idle
+
+              @io.connect
+              return unless @io.connected?
+
+              @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
+                  next unless @parser
+
+                  reset
+                end
+                parser.on(:reset) do
+                  if parser.pending.empty? && parser.empty?
+                    reset
+                  else
+                    enqueue_pending_requests_from_parser(parser)
+
+                    initial_state = @state
+
+                    # because #reset will nillify @parser...
+                    tunnel_parser = @parser
+
+                    reset
+
+                    if @pending.empty?
+                      @parser = nil
+                      next
+                    end
+                    # keep parser state around due to proxy auth protocol;
+                    # intermediate authenticated request is already inside
+                    # the parser
+                    connect_request = parser = nil
+
+                    if initial_state == :connecting
+                      parser = tunnel_parser
+                      parser.reset
+                      if @pending.first.is_a?(ConnectRequest)
+                        connect_request = @pending.shift # this happened when reenqueing
+                      end
+                    end
+
+                    idling
+
+                    @tunnel_parser = @parser = parser
+                    if connect_request
+                      @inflight += 1
+                      parser.send(connect_request)
+                    end
+                    transition(:connecting)
+                  end
+                end
+                __http_proxy_connect(parser)
+              end
+              return if @state == :connected
+            when :connected
+              return unless @state == :idle || @state == :connecting
+
+              case @state
+              when :connecting
+                parser = @parser
+                @tunnel_parser = @parser = nil
+                parser.close
+              when :idle
+                @parser.callbacks.clear
+                set_parser_callbacks(@parser)
+              end
+            end
+            super
+          end
+
+          def __http_proxy_connect(parser)
+            req = @pending.first
+            if req && req.uri.scheme == "https"
+              # if the first request after CONNECT is to an https address, it is assumed that
+              # all requests in the queue are not only ALL HTTPS, but they also share the certificate,
+              # and therefore, will share the connection.
+              #
+              connect_request = ConnectRequest.new(req.uri, @options)
+              @inflight += 1
+              parser.send(connect_request)
+            else
+              handle_transition(:connected)
+            end
+          end
+
+          def __http_on_connect(request, response)
+            @inflight -= 1
+            if response.is_a?(Response) && response.status == 200
+              req = @pending.first
+              request_uri = req.uri
+              @io = ProxySSL.new(@io, request_uri, @options)
+              transition(:connected)
+              throw(:called)
+            elsif response.is_a?(Response) &&
+                  response.status == 407 &&
+                  !request.headers.key?("proxy-authorization") &&
+                  @options.proxy.can_authenticate?(response.headers["proxy-authenticate"])
+
+              request.transition(:idle)
+              request.headers["proxy-authorization"] = @options.proxy.authenticate(request, response.headers["proxy-authenticate"])
+              @parser.send(request)
+              @inflight += 1
+            else
+              pending = @pending + @parser.pending
+              while (req = pending.shift)
+                response.finish!
+                req.response = response
+                req.emit_response(response)
+              end
+              reset
+            end
+          end
+        end
+
+        module ProxyParser
+          def join_headline(request)
+            return super if request.verb == "CONNECT"
+
+            "#{request.verb} #{request.uri} HTTP/#{@version.join(".")}"
+          end
+
+          def set_protocol_headers(request)
+            extra_headers = super
+
+            proxy_params = @options.proxy
+            if proxy_params.scheme == "basic"
+              # opt for basic auth
+              extra_headers["proxy-authorization"] = proxy_params.authenticate(extra_headers)
+            end
+            extra_headers["proxy-connection"] = extra_headers.delete("connection") if extra_headers.key?("connection")
+            extra_headers
+          end
+        end
+
+        class ConnectRequest < Request
+          def initialize(uri, options)
+            super("CONNECT", uri, options)
+            @headers.delete("accept")
+          end
+
+          def path
+            "#{@uri.hostname}:#{@uri.port}"
+          end
+        end
+      end
+    end
+    register_plugin :"proxy/http", Proxy::HTTP
+  end
+end