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/aws_sdk_authentication.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Plugins
+    #
+    # This plugin applies AWS Sigv4 to requests, using the AWS SDK credentials and configuration.
+    #
+    # It requires the "aws-sdk-core" gem.
+    #
+    module AwsSdkAuthentication
+      # Mock configuration, to be used only when resolving credentials
+      class Configuration
+        attr_reader :profile
+
+        def initialize(profile)
+          @profile = profile
+        end
+
+        def respond_to_missing?(*)
+          true
+        end
+
+        def method_missing(*); end
+      end
+
+      #
+      # encapsulates access to an AWS SDK credentials store.
+      #
+      class Credentials
+        def initialize(aws_credentials)
+          @aws_credentials = aws_credentials
+        end
+
+        def username
+          @aws_credentials.access_key_id
+        end
+
+        def password
+          @aws_credentials.secret_access_key
+        end
+
+        def security_token
+          @aws_credentials.session_token
+        end
+      end
+
+      class << self
+        def load_dependencies(_klass)
+          require "aws-sdk-core"
+        end
+
+        def configure(klass)
+          klass.plugin(:aws_sigv4)
+        end
+
+        def extra_options(options)
+          options.merge(max_concurrent_requests: 1)
+        end
+
+        def credentials(profile)
+          mock_configuration = Configuration.new(profile)
+          Credentials.new(Aws::CredentialProviderChain.new(mock_configuration).resolve)
+        end
+
+        def region(profile)
+          # https://github.com/aws/aws-sdk-ruby/blob/version-3/gems/aws-sdk-core/lib/aws-sdk-core/plugins/regional_endpoint.rb#L62
+          keys = %w[AWS_REGION AMAZON_REGION AWS_DEFAULT_REGION]
+          env_region = ENV.values_at(*keys).compact.first
+          env_region = nil if env_region == ""
+          cfg_region = Aws.shared_config.region(profile: profile)
+          env_region || cfg_region
+        end
+      end
+
+      # adds support for the following options:
+      #
+      # :aws_profile :: AWS account profile to retrieve credentials from.
+      module OptionsMethods
+        private
+
+        def option_aws_profile(value)
+          String(value)
+        end
+      end
+
+      module InstanceMethods
+        #
+        # aws_authentication
+        # aws_authentication(credentials: Aws::Credentials.new('akid', 'secret'))
+        # aws_authentication()
+        #
+        def aws_sdk_authentication(
+          credentials: AwsSdkAuthentication.credentials(@options.aws_profile),
+          region: AwsSdkAuthentication.region(@options.aws_profile),
+          **options
+        )
+          aws_sigv4_authentication(
+            credentials: credentials,
+            region: region,
+            provider_prefix: "aws",
+            header_provider_field: "amz",
+            **options
+          )
+        end
+        alias_method :aws_auth, :aws_sdk_authentication
+      end
+    end
+    register_plugin :aws_sdk_authentication, AwsSdkAuthentication
+  end
+end

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

@@ -0,0 +1,239 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Plugins
+    #
+    # This plugin adds AWS Sigv4 authentication.
+    #
+    # https://docs.aws.amazon.com/IAM/latest/UserGuide/signing-elements.html
+    #
+    # https://gitlab.com/os85/httpx/wikis/AWS-SigV4
+    #
+    module AWSSigV4
+      Credentials = Struct.new(:username, :password, :security_token)
+
+      # Signs requests using the AWS sigv4 signing.
+      class Signer
+        def initialize(
+          service:,
+          region:,
+          credentials: nil,
+          username: nil,
+          password: nil,
+          security_token: nil,
+          provider_prefix: "aws",
+          header_provider_field: "amz",
+          unsigned_headers: [],
+          apply_checksum_header: true,
+          algorithm: "SHA256"
+        )
+          @credentials = credentials || Credentials.new(username, password, security_token)
+          @service = service
+          @region = region
+
+          @unsigned_headers = Set.new(unsigned_headers.map(&:downcase))
+          @unsigned_headers << "authorization"
+          @unsigned_headers << "x-amzn-trace-id"
+          @unsigned_headers << "expect"
+
+          @apply_checksum_header = apply_checksum_header
+          @provider_prefix = provider_prefix
+          @header_provider_field = header_provider_field
+
+          @algorithm = algorithm
+        end
+
+        def sign!(request)
+          lower_provider_prefix = "#{@provider_prefix}4"
+          upper_provider_prefix = lower_provider_prefix.upcase
+
+          downcased_algorithm = @algorithm.downcase
+
+          datetime = (request.headers["x-#{@header_provider_field}-date"] ||= Time.now.utc.strftime("%Y%m%dT%H%M%SZ"))
+          date = datetime[0, 8]
+
+          content_hashed = request.headers["x-#{@header_provider_field}-content-#{downcased_algorithm}"] || hexdigest(request.body)
+
+          request.headers["x-#{@header_provider_field}-content-#{downcased_algorithm}"] ||= content_hashed if @apply_checksum_header
+          request.headers["x-#{@header_provider_field}-security-token"] ||= @credentials.security_token if @credentials.security_token
+
+          signature_headers = request.headers.each.reject do |k, _|
+            @unsigned_headers.include?(k)
+          end
+          # aws sigv4 needs to declare the host, regardless of protocol version
+          signature_headers << ["host", request.authority] unless request.headers.key?("host")
+          signature_headers.sort_by!(&:first)
+
+          signed_headers = signature_headers.map(&:first).join(";")
+
+          canonical_headers = signature_headers.map do |k, v|
+            # eliminate whitespace between value fields, unless it's a quoted value
+            "#{k}:#{v.start_with?("\"") && v.end_with?("\"") ? v : v.gsub(/\s+/, " ").strip}\n"
+          end.join
+
+          # canonical request
+          creq = "#{request.verb}" \
+                 "\n#{request.canonical_path}" \
+                 "\n#{request.canonical_query}" \
+                 "\n#{canonical_headers}" \
+                 "\n#{signed_headers}" \
+                 "\n#{content_hashed}"
+
+          credential_scope = "#{date}" \
+                             "/#{@region}" \
+                             "/#{@service}" \
+                             "/#{lower_provider_prefix}_request"
+
+          algo_line = "#{upper_provider_prefix}-HMAC-#{@algorithm}"
+          # string to sign
+          sts = "#{algo_line}" \
+                "\n#{datetime}" \
+                "\n#{credential_scope}" \
+                "\n#{OpenSSL::Digest.new(@algorithm).hexdigest(creq)}"
+
+          # signature
+          k_date = hmac("#{upper_provider_prefix}#{@credentials.password}", date)
+          k_region = hmac(k_date, @region)
+          k_service = hmac(k_region, @service)
+          k_credentials = hmac(k_service, "#{lower_provider_prefix}_request")
+          sig = hexhmac(k_credentials, sts)
+
+          credential = "#{@credentials.username}/#{credential_scope}"
+          # apply signature
+          request.headers["authorization"] =
+            "#{algo_line} " \
+            "Credential=#{credential}, " \
+            "SignedHeaders=#{signed_headers}, " \
+            "Signature=#{sig}"
+        end
+
+        private
+
+        def hexdigest(value)
+          digest = OpenSSL::Digest.new(@algorithm)
+
+          if value.respond_to?(:read)
+            if value.respond_to?(:to_path)
+              # files, pathnames
+              digest.file(value.to_path).hexdigest
+            else
+              # gzipped request bodies
+              raise Error, "request body must be rewindable" unless value.respond_to?(:rewind)
+
+              buffer = Tempfile.new("httpx", encoding: Encoding::BINARY, mode: File::RDWR)
+              begin
+                IO.copy_stream(value, buffer)
+                buffer.flush
+
+                digest.file(buffer.to_path).hexdigest
+              ensure
+                value.rewind
+                buffer.close
+                buffer.unlink
+              end
+            end
+          else
+            # error on endless generators
+            raise Error, "hexdigest for endless enumerators is not supported" if value.unbounded_body?
+
+            mb_buffer = value.each.with_object("".b) do |chunk, b|
+              b << chunk
+              break if b.bytesize >= 1024 * 1024
+            end
+
+            digest.hexdigest(mb_buffer)
+          end
+        end
+
+        def hmac(key, value)
+          OpenSSL::HMAC.digest(OpenSSL::Digest.new(@algorithm), key, value)
+        end
+
+        def hexhmac(key, value)
+          OpenSSL::HMAC.hexdigest(OpenSSL::Digest.new(@algorithm), key, value)
+        end
+      end
+
+      class << self
+        def load_dependencies(*)
+          require "set"
+          require "digest/sha2"
+          require "cgi/escape"
+        end
+
+        def configure(klass)
+          klass.plugin(:expect)
+        end
+      end
+
+      # adds support for the following options:
+      #
+      # :sigv4_signer :: instance of HTTPX::Plugins::AWSSigV4 used to sign requests.
+      module OptionsMethods
+        private
+
+        def option_sigv4_signer(value)
+          value.is_a?(Signer) ? value : Signer.new(value)
+        end
+      end
+
+      module InstanceMethods
+        def aws_sigv4_authentication(**options)
+          with(sigv4_signer: Signer.new(**options))
+        end
+
+        def build_request(*)
+          request = super
+
+          return request if request.headers.key?("authorization")
+
+          signer = request.options.sigv4_signer
+
+          return request unless signer
+
+          signer.sign!(request)
+
+          request
+        end
+      end
+
+      module RequestMethods
+        def canonical_path
+          path = uri.path.dup
+          path << "/" if path.empty?
+          path.gsub(%r{[^/]+}) { |part| CGI.escape(part.encode("UTF-8")).gsub("+", "%20").gsub("%7E", "~") }
+        end
+
+        def canonical_query
+          params = query.split("&")
+          # params = params.map { |p| p.match(/=/) ? p : p + '=' }
+          # From: https://docs.aws.amazon.com/IAM/latest/UserGuide/create-signed-request.html#create-canonical-request
+          # Sort the parameter names by character code point in ascending order.
+          # Parameters with duplicate names should be sorted by value.
+          #
+          # Default sort <=> in JRuby will swap members
+          # occasionally when <=> is 0 (considered still sorted), but this
+          # causes our normalized query string to not match the sent querystring.
+          # When names match, we then sort by their values.  When values also
+          # match then we sort by their original order
+          params.each.with_index.sort do |a, b|
+            a, a_offset = a
+            b, b_offset = b
+            a_name, a_value = a.split("=", 2)
+            b_name, b_value = b.split("=", 2)
+            if a_name == b_name
+              if a_value == b_value
+                a_offset <=> b_offset
+              else
+                a_value <=> b_value
+              end
+            else
+              a_name <=> b_name
+            end
+          end.map(&:first).join("&")
+        end
+      end
+    end
+    register_plugin :aws_sigv4, AWSSigV4
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Plugins
+    #
+    # This plugin adds helper methods to implement HTTP Basic Auth (https://datatracker.ietf.org/doc/html/rfc7617)
+    #
+    # https://gitlab.com/os85/httpx/wikis/Auth#basic-auth
+    #
+    module BasicAuth
+      class << self
+        def load_dependencies(_klass)
+          require_relative "auth/basic"
+        end
+
+        def configure(klass)
+          klass.plugin(:auth)
+        end
+      end
+
+      module InstanceMethods
+        def basic_auth(user, password)
+          authorization(Authentication::Basic.new(user, password).authenticate)
+        end
+      end
+    end
+    register_plugin :basic_auth, BasicAuth
+  end
+end

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Plugins
+    module Brotli
+      class Error < HTTPX::Error; end
+
+      class Deflater < Transcoder::Deflater
+        def initialize(body)
+          @compressor = ::Brotli::Compressor.new
+          super
+        end
+
+        def deflate(chunk)
+          return @compressor.process(chunk) << @compressor.flush if chunk
+
+          @compressor.finish
+        end
+      end
+
+      class Inflater
+        def initialize(bytesize)
+          @inflater = ::Brotli::Decompressor.new
+          @bytesize = bytesize
+        end
+
+        def call(chunk)
+          buffer = @inflater.process(chunk)
+          @bytesize -= chunk.bytesize
+          raise Error, "Unexpected end of compressed stream" if @bytesize <= 0 && !@inflater.finished?
+
+          buffer
+        end
+      end
+
+      module RequestBodyClassMethods
+        def initialize_deflater_body(body, encoding)
+          return Brotli.encode(body) if encoding == "br"
+
+          super
+        end
+      end
+
+      module ResponseBodyClassMethods
+        def initialize_inflater_by_encoding(encoding, response, **kwargs)
+          return Brotli.decode(response, **kwargs) if encoding == "br"
+
+          super
+        end
+      end
+
+      module_function
+
+      def load_dependencies(*)
+        gem "brotli", ">= 0.8.0"
+        require "brotli"
+      end
+
+      def self.extra_options(options)
+        supported_compression_formats = (%w[br] + options.supported_compression_formats).freeze
+        options.merge(
+          supported_compression_formats: supported_compression_formats,
+          headers: options.headers_class.new(options.headers.merge("accept-encoding" => supported_compression_formats))
+        )
+      end
+
+      def encode(body)
+        Deflater.new(body)
+      end
+
+      def decode(response, bytesize: nil)
+        bytesize ||= response.headers.key?("content-length") ? response.headers["content-length"].to_i : Float::INFINITY
+        Inflater.new(bytesize)
+      end
+    end
+    register_plugin :brotli, Brotli
+  end
+end

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

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module HTTPX::Plugins
+  module Cache
+    # Implementation of a file system based cache store.
+    #
+    # It stores cached responses in a file under a directory pointed by the +dir+
+    # variable (defaults to the default temp directory from the OS), in a custom
+    # format (similar but different from HTTP/1.1 request/response framing).
+    class FileStore
+      CRLF = HTTPX::Connection::HTTP1::CRLF
+
+      attr_reader :dir
+
+      def initialize(dir = Dir.tmpdir)
+        @dir = Pathname.new(dir).join("httpx-response-cache")
+
+        FileUtils.mkdir_p(@dir)
+      end
+
+      def clear
+        FileUtils.rm_rf(@dir)
+      end
+
+      def get(request)
+        path = file_path(request)
+
+        return unless File.exist?(path)
+
+        File.open(path, mode: File::RDONLY | File::BINARY) do |f|
+          f.flock(File::Constants::LOCK_SH)
+
+          read_from_file(request, f)
+        end
+      end
+
+      def set(request, response)
+        path = file_path(request)
+
+        file_exists = File.exist?(path)
+
+        mode = file_exists ? File::RDWR : File::CREAT | File::Constants::WRONLY
+
+        File.open(path, mode: mode | File::BINARY) do |f|
+          f.flock(File::Constants::LOCK_EX)
+
+          if file_exists
+            cached_response = read_from_file(request, f)
+
+            if cached_response
+              next if cached_response == request.cached_response
+
+              cached_response.close
+
+              f.truncate(0)
+
+              f.rewind
+            end
+          end
+          # cache the request headers
+          f << request.verb << CRLF
+          f << request.uri << CRLF
+
+          request.headers.each do |field, value|
+            f << field << ":" << value << CRLF
+          end
+
+          f << CRLF
+
+          # cache the response
+          f << response.status << CRLF
+          f << response.version << CRLF
+
+          response.headers.each do |field, value|
+            f << field << ":" << value << CRLF
+          end
+
+          f << CRLF
+
+          response.body.rewind
+
+          IO.copy_stream(response.body, f)
+        end
+      end
+
+      private
+
+      def file_path(request)
+        @dir.join(request.response_cache_key)
+      end
+
+      def read_from_file(request, f)
+        # if it's an empty file
+        return if f.eof?
+
+        # read request data
+        verb = f.readline.delete_suffix!(CRLF)
+        uri = f.readline.delete_suffix!(CRLF)
+
+        request_headers = {}
+        while (line = f.readline) != CRLF
+          line.delete_suffix!(CRLF)
+          sep_index = line.index(":")
+
+          field = line.byteslice(0..(sep_index - 1))
+          value = line.byteslice((sep_index + 1)..-1)
+
+          request_headers[field] = value
+        end
+
+        status = f.readline.delete_suffix!(CRLF)
+        version = f.readline.delete_suffix!(CRLF)
+
+        response_headers = {}
+        while (line = f.readline) != CRLF
+          line.delete_suffix!(CRLF)
+          sep_index = line.index(":")
+
+          field = line.byteslice(0..(sep_index - 1))
+          value = line.byteslice((sep_index + 1)..-1)
+
+          response_headers[field] = value
+        end
+
+        original_request = request.options.request_class.new(verb, uri, request.options)
+        original_request.merge_headers(request_headers)
+
+        response = request.options.response_class.new(request, status, version, response_headers)
+        response.original_request = original_request
+        response.finish!
+        response.mark_as_cached!
+
+        IO.copy_stream(f, response.body)
+
+        response
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module HTTPX::Plugins
+  module Cache
+    # Implementation of a thread-safe in-memory cache store.
+    class Store
+      def initialize
+        @store = {}
+        @store_mutex = Thread::Mutex.new
+      end
+
+      def clear
+        @store_mutex.synchronize { @store.clear }
+      end
+
+      def get(request)
+        @store_mutex.synchronize do
+          @store[request.response_cache_key]
+        end
+      end
+
+      def set(request, response)
+        @store_mutex.synchronize do
+          cached_response = @store[request.response_cache_key]
+
+          cached_response.close if cached_response
+
+          @store[request.response_cache_key] = response
+        end
+      end
+    end
+  end
+end