httpx-patched 1.6.2.1

data/lib/httpx/plugins/grpc.rb

@@ -0,0 +1,282 @@
+# frozen_string_literal: true
+
+module HTTPX
+  GRPCError = Class.new(Error) do
+    attr_reader :status, :details, :metadata
+
+    def initialize(status, details, metadata)
+      @status = status
+      @details = details
+      @metadata = metadata
+      super("GRPC error, code=#{status}, details=#{details}, metadata=#{metadata}")
+    end
+  end
+
+  module Plugins
+    #
+    # This plugin adds DSL to build GRPC interfaces.
+    #
+    # https://gitlab.com/os85/httpx/wikis/GRPC
+    #
+    module GRPC
+      unless String.method_defined?(:underscore)
+        module StringExtensions
+          refine String do
+            def underscore
+              s = dup # Avoid mutating the argument, as it might be frozen.
+              s.gsub!(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+              s.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
+              s.tr!("-", "_")
+              s.downcase!
+              s
+            end
+          end
+        end
+        using StringExtensions
+      end
+
+      DEADLINE = 60
+      MARSHAL_METHOD = :encode
+      UNMARSHAL_METHOD = :decode
+      HEADERS = {
+        "content-type" => "application/grpc",
+        "te" => "trailers",
+        "accept" => "application/grpc",
+        # metadata fits here
+        # ex "foo-bin" => base64("bar")
+      }.freeze
+
+      class << self
+        def load_dependencies(*)
+          require "stringio"
+          require "httpx/plugins/grpc/grpc_encoding"
+          require "httpx/plugins/grpc/message"
+          require "httpx/plugins/grpc/call"
+        end
+
+        def configure(klass)
+          klass.plugin(:persistent)
+          klass.plugin(:stream)
+        end
+
+        def extra_options(options)
+          options.merge(
+            fallback_protocol: "h2",
+            grpc_rpcs: {}.freeze,
+            grpc_compression: false,
+            grpc_deadline: DEADLINE
+          )
+        end
+      end
+
+      module OptionsMethods
+        private
+
+        def option_grpc_service(value)
+          String(value)
+        end
+
+        def option_grpc_compression(value)
+          case value
+          when true, false
+            value
+          else
+            value.to_s
+          end
+        end
+
+        def option_grpc_rpcs(value)
+          Hash[value]
+        end
+
+        def option_grpc_deadline(value)
+          raise TypeError, ":grpc_deadline must be positive" unless value.positive?
+
+          value
+        end
+
+        def option_call_credentials(value)
+          raise TypeError, ":call_credentials must respond to #call" unless value.respond_to?(:call)
+
+          value
+        end
+      end
+
+      module ResponseMethods
+        attr_reader :trailing_metadata
+
+        def merge_headers(trailers)
+          @trailing_metadata = Hash[trailers]
+          super
+        end
+      end
+
+      module RequestBodyMethods
+        def initialize(*, **)
+          super
+
+          if (compression = @headers["grpc-encoding"])
+            deflater_body = self.class.initialize_deflater_body(@body, compression)
+            @body = Transcoder::GRPCEncoding.encode(deflater_body || @body, compressed: !deflater_body.nil?)
+          else
+            @body = Transcoder::GRPCEncoding.encode(@body, compressed: false)
+          end
+        end
+      end
+
+      module InstanceMethods
+        def with_channel_credentials(ca_path, key = nil, cert = nil, **ssl_opts)
+          # @type var ssl_params: ::Hash[::Symbol, untyped]
+          ssl_params = {
+            **ssl_opts,
+            ca_file: ca_path,
+          }
+          if key
+            key = File.read(key) if File.file?(key)
+            ssl_params[:key] = OpenSSL::PKey.read(key)
+          end
+
+          if cert
+            cert = File.read(cert) if File.file?(cert)
+            ssl_params[:cert] = OpenSSL::X509::Certificate.new(cert)
+          end
+
+          with(ssl: ssl_params)
+        end
+
+        def rpc(rpc_name, input, output, **opts)
+          rpc_name = rpc_name.to_s
+          raise Error, "rpc #{rpc_name} already defined" if @options.grpc_rpcs.key?(rpc_name)
+
+          rpc_opts = {
+            deadline: @options.grpc_deadline,
+          }.merge(opts)
+
+          local_rpc_name = rpc_name.underscore
+
+          session_class = Class.new(self.class) do
+            # define rpc method with ruby style name
+            class_eval(<<-OUT, __FILE__, __LINE__ + 1)
+              def #{local_rpc_name}(input, **opts)              # def grpc_action(input, **opts)
+                rpc_execute("#{local_rpc_name}", input, **opts) #   rpc_execute("grpc_action", input, **opts)
+              end                                               # end
+            OUT
+
+            # define rpc method with original name
+            unless local_rpc_name == rpc_name
+              class_eval(<<-OUT, __FILE__, __LINE__ + 1)
+                def #{rpc_name}(input, **opts)                    # def grpcAction(input, **opts)
+                  rpc_execute("#{local_rpc_name}", input, **opts) #   rpc_execute("grpc_action", input, **opts)
+                end                                               # end
+              OUT
+            end
+          end
+
+          session_class.new(@options.merge(
+                              grpc_rpcs: @options.grpc_rpcs.merge(
+                                local_rpc_name => [rpc_name, input, output, rpc_opts]
+                              ).freeze
+                            ))
+        end
+
+        def build_stub(origin, service: nil, compression: false)
+          scheme = @options.ssl.empty? ? "http" : "https"
+
+          origin = URI.parse("#{scheme}://#{origin}")
+
+          session = self
+
+          if service && service.respond_to?(:rpc_descs)
+            # it's a grpc generic service
+            service.rpc_descs.each do |rpc_name, rpc_desc|
+              rpc_opts = {
+                marshal_method: rpc_desc.marshal_method,
+                unmarshal_method: rpc_desc.unmarshal_method,
+              }
+
+              input = rpc_desc.input
+              input = input.type if input.respond_to?(:type)
+
+              output = rpc_desc.output
+              if output.respond_to?(:type)
+                rpc_opts[:stream] = true
+                output = output.type
+              end
+
+              session = session.rpc(rpc_name, input, output, **rpc_opts)
+            end
+
+            service = service.service_name
+          end
+
+          session.with(origin: origin, grpc_service: service, grpc_compression: compression)
+        end
+
+        def execute(rpc_method, input,
+                    deadline: DEADLINE,
+                    metadata: nil,
+                    **opts)
+          grpc_request = build_grpc_request(rpc_method, input, deadline: deadline, metadata: metadata, **opts)
+          response = request(grpc_request, **opts)
+          response.raise_for_status unless opts[:stream]
+          GRPC::Call.new(response)
+        end
+
+        private
+
+        def rpc_execute(rpc_name, input, **opts)
+          rpc_name, input_enc, output_enc, rpc_opts = @options.grpc_rpcs[rpc_name]
+
+          exec_opts = rpc_opts.merge(opts)
+
+          marshal_method ||= exec_opts.delete(:marshal_method) || MARSHAL_METHOD
+          unmarshal_method ||= exec_opts.delete(:unmarshal_method) || UNMARSHAL_METHOD
+
+          messages = if input.respond_to?(:each)
+            Enumerator.new do |y|
+              input.each do |message|
+                y << input_enc.__send__(marshal_method, message)
+              end
+            end
+          else
+            input_enc.__send__(marshal_method, input)
+          end
+
+          call = execute(rpc_name, messages, **exec_opts)
+
+          call.decoder = output_enc.method(unmarshal_method)
+
+          call
+        end
+
+        def build_grpc_request(rpc_method, input, deadline:, metadata: nil, **)
+          uri = @options.origin.dup
+          rpc_method = "/#{rpc_method}" unless rpc_method.start_with?("/")
+          rpc_method = "/#{@options.grpc_service}#{rpc_method}" if @options.grpc_service
+          uri.path = rpc_method
+
+          headers = HEADERS.merge(
+            "grpc-accept-encoding" => ["identity", *@options.supported_compression_formats]
+          )
+          unless deadline == Float::INFINITY
+            # convert to milliseconds
+            deadline = (deadline * 1000.0).to_i
+            headers["grpc-timeout"] = "#{deadline}m"
+          end
+
+          headers = headers.merge(metadata.transform_keys(&:to_s)) if metadata
+
+          # prepare compressor
+          compression = @options.grpc_compression == true ? "gzip" : @options.grpc_compression
+
+          headers["grpc-encoding"] = compression if compression
+
+          headers.merge!(@options.call_credentials.call.transform_keys(&:to_s)) if @options.call_credentials
+
+          build_request("POST", uri, headers: headers, body: input)
+        end
+      end
+    end
+    register_plugin :grpc, GRPC
+  end
+end

data/lib/httpx/plugins/h2c.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Plugins
+    #
+    # This plugin adds support for upgrading a plaintext HTTP/1.1 connection to HTTP/2
+    # (https://datatracker.ietf.org/doc/html/rfc7540#section-3.2)
+    #
+    # https://gitlab.com/os85/httpx/wikis/Connection-Upgrade#h2c
+    #
+    module H2C
+      VALID_H2C_VERBS = %w[GET OPTIONS HEAD].freeze
+
+      class << self
+        def load_dependencies(klass)
+          klass.plugin(:upgrade)
+        end
+
+        def call(connection, request, response)
+          connection.upgrade_to_h2c(request, response)
+        end
+
+        def extra_options(options)
+          options.merge(
+            h2c_class: Class.new(options.http2_class) { include(H2CParser) },
+            max_concurrent_requests: 1,
+            upgrade_handlers: options.upgrade_handlers.merge("h2c" => self),
+          )
+        end
+      end
+
+      module OptionsMethods
+        def option_h2c_class(value)
+          value
+        end
+      end
+
+      module RequestMethods
+        def valid_h2c_verb?
+          VALID_H2C_VERBS.include?(@verb)
+        end
+      end
+
+      module ConnectionMethods
+        using URIExtensions
+
+        def initialize(*)
+          super
+          @h2c_handshake = false
+        end
+
+        def send(request)
+          return super if @h2c_handshake
+
+          return super unless request.valid_h2c_verb? && request.scheme == "http"
+
+          return super if @upgrade_protocol == "h2c"
+
+          @h2c_handshake = true
+
+          # build upgrade request
+          request.headers.add("connection", "upgrade")
+          request.headers.add("connection", "http2-settings")
+          request.headers["upgrade"] = "h2c"
+          request.headers["http2-settings"] = ::HTTP2::Client.settings_header(request.options.http2_settings)
+
+          super
+        end
+
+        def upgrade_to_h2c(request, response)
+          prev_parser = @parser
+
+          if prev_parser
+            prev_parser.reset
+            @inflight -= prev_parser.requests.size
+          end
+
+          @parser = request.options.h2c_class.new(@write_buffer, @options)
+          set_parser_callbacks(@parser)
+          @inflight += 1
+          @parser.upgrade(request, response)
+          @upgrade_protocol = "h2c"
+
+          prev_parser.requests.each do |req|
+            req.transition(:idle)
+            send(req)
+          end
+        end
+
+        private
+
+        def send_request_to_parser(request)
+          super
+
+          return unless request.headers["upgrade"] == "h2c" && parser.is_a?(Connection::HTTP1)
+
+          max_concurrent_requests = parser.max_concurrent_requests
+
+          return if max_concurrent_requests == 1
+
+          parser.max_concurrent_requests = 1
+          request.once(:response) do
+            parser.max_concurrent_requests = max_concurrent_requests
+          end
+        end
+      end
+
+      module H2CParser
+        def upgrade(request, response)
+          # skip checks, it is assumed that this is the first
+          # request in the connection
+          stream = @connection.upgrade
+
+          # on_settings
+          handle_stream(stream, request)
+          @streams[request] = stream
+
+          # clean up data left behind in the buffer, if the server started
+          # sending frames
+          data = response.read
+          @connection << data
+        end
+      end
+    end
+    register_plugin(:h2c, H2C)
+  end
+end

data/lib/httpx/plugins/internal_telemetry.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Plugins
+    #
+    # The InternalTelemetry plugin is for internal use only. It is therefore undocumented, and
+    # its use is disencouraged, as API compatiblity will **not be guaranteed**.
+    #
+    # The gist of it is: when debug_level of logger is enabled to 3 or greater, considered internal-only
+    # supported log levels, it'll be loaded by default.
+    #
+    # Against a specific point of time, which will be by default the session initialization, but can be set
+    # by the end user in $http_init_time, different diff metrics can be shown. The "point of time" is calculated
+    # using the monotonic clock.
+    module InternalTelemetry
+      DEBUG_LEVEL = 3
+
+      def self.extra_options(options)
+        options.merge(debug_level: 3)
+      end
+
+      module TrackTimeMethods
+        private
+
+        def elapsed_time
+          yield
+        ensure
+          meter_elapsed_time("#{self.class.superclass}##{caller_locations(1, 1)[0].label}")
+        end
+
+        def meter_elapsed_time(label)
+          $http_init_time ||= Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond)
+          prev_time = $http_init_time
+          after_time = Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond)
+          # $http_init_time = after_time
+          elapsed = after_time - prev_time
+          # klass = self.class
+
+          # until (class_name = klass.name)
+          #   klass = klass.superclass
+          # end
+          log(
+            level: DEBUG_LEVEL,
+            color: :red,
+            debug_level: @options ? @options.debug_level : DEBUG_LEVEL,
+            debug: nil
+          ) do
+            "[ELAPSED TIME]: #{label}: #{elapsed} (ms)" << "\e[0m"
+          end
+        end
+      end
+
+      module InstanceMethods
+        def self.included(klass)
+          klass.prepend TrackTimeMethods
+          super
+        end
+
+        def initialize(*)
+          meter_elapsed_time("Session: initializing...")
+          super
+          meter_elapsed_time("Session: initialized!!!")
+        end
+
+        def close(*)
+          super
+          meter_elapsed_time("Session -> close")
+        end
+
+        private
+
+        def build_requests(*)
+          elapsed_time { super }
+        end
+
+        def fetch_response(*)
+          response = super
+          meter_elapsed_time("Session -> response") if response
+          response
+        end
+
+        def coalesce_connections(conn1, conn2, selector, *)
+          result = super
+
+          meter_elapsed_time("Connection##{conn2.object_id} coalescing to Connection##{conn1.object_id}") if result
+
+          result
+        end
+      end
+
+      module PoolMethods
+        def self.included(klass)
+          klass.prepend Loggable
+          klass.prepend TrackTimeMethods
+          super
+        end
+
+        def checkin_connection(connection)
+          super.tap do
+            meter_elapsed_time("Pool##{object_id}: checked in connection for Connection##{connection.object_id}[#{connection.origin}]}")
+          end
+        end
+      end
+    end
+    register_plugin :internal_telemetry, InternalTelemetry
+  end
+end

data/lib/httpx/plugins/ntlm_auth.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Plugins
+    #
+    # https://gitlab.com/os85/httpx/wikis/Auth#ntlm-auth
+    #
+    module NTLMAuth
+      class << self
+        def load_dependencies(_klass)
+          require_relative "auth/ntlm"
+        end
+
+        def extra_options(options)
+          options.merge(max_concurrent_requests: 1)
+        end
+      end
+
+      module OptionsMethods
+        private
+
+        def option_ntlm(value)
+          raise TypeError, ":ntlm must be a #{Authentication::Ntlm}" unless value.is_a?(Authentication::Ntlm)
+
+          value
+        end
+      end
+
+      module InstanceMethods
+        def ntlm_auth(user, password, domain = nil)
+          with(ntlm: Authentication::Ntlm.new(user, password, domain: domain))
+        end
+
+        private
+
+        def send_requests(*requests)
+          requests.flat_map do |request|
+            ntlm = request.options.ntlm
+
+            if ntlm
+              request.headers["authorization"] = ntlm.negotiate
+              probe_response = wrap { super(request).first }
+
+              return probe_response unless probe_response.is_a?(Response)
+
+              if probe_response.status == 401 && ntlm.can_authenticate?(probe_response.headers["www-authenticate"])
+                request.transition(:idle)
+                request.headers["authorization"] = ntlm.authenticate(request, probe_response.headers["www-authenticate"])
+                super(request)
+              else
+                probe_response
+              end
+            else
+              super(request)
+            end
+          end
+        end
+      end
+    end
+    register_plugin :ntlm_auth, NTLMAuth
+  end
+end