httpx-patched 1.6.2.1

data/lib/httpx/plugins/fiber_concurrency.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Plugins
+    # This plugin makes a session reuse the same selector across all fibers in a given thread.
+    #
+    # This enables integration with fiber scheduler implementations such as [async](https://github.com/async).
+    #
+    # # https://gitlab.com/os85/httpx/wikis/FiberConcurrency
+    #
+    module FiberConcurrency
+      def self.subplugins
+        {
+          h2c: FiberConcurrencyH2C,
+        }
+      end
+
+      module InstanceMethods
+        private
+
+        def send_request(request, *)
+          request.set_context!
+
+          super
+        end
+
+        def get_current_selector
+          super(&nil) || begin
+            return unless block_given?
+
+            default = yield
+
+            set_current_selector(default)
+
+            default
+          end
+        end
+      end
+
+      module RequestMethods
+        # the execution context (fiber) this request was sent on.
+        attr_reader :context
+
+        def initialize(*)
+          super
+          @context = nil
+        end
+
+        # sets the execution context for this request. the default is the current fiber.
+        def set_context!
+          @context ||= Fiber.current # rubocop:disable Naming/MemoizedInstanceVariableName
+        end
+
+        # checks whether the current execution context is the one where the request was created.
+        def current_context?
+          @context == Fiber.current
+        end
+
+        def complete!(response = @response)
+          @context = nil
+          super
+        end
+      end
+
+      module ConnectionMethods
+        def current_context?
+          @pending.any?(&:current_context?) || (
+            @sibling && @sibling.pending.any?(&:current_context?)
+          )
+        end
+
+        def interests
+          return if connecting? && @pending.none?(&:current_context?)
+
+          super
+        end
+
+        def send(request)
+          # DoH requests bypass the session, so context needs to be set here.
+          request.set_context!
+
+          super
+        end
+      end
+
+      module HTTP1Methods
+        def interests
+          request = @request || @requests.first
+
+          return unless request
+
+          return unless request.current_context? || @requests.any?(&:current_context?) || @pending.any?(&:current_context?)
+
+          super
+        end
+      end
+
+      module HTTP2Methods
+        def initialize(*)
+          super
+          @contexts = Hash.new { |hs, k| hs[k] = Set.new }
+        end
+
+        def interests
+          if @connection.state == :connected && @handshake_completed && !@contexts.key?(Fiber.current)
+            return :w unless @pings.empty?
+
+            return
+          end
+
+          super
+        end
+
+        def send(request, *)
+          add_to_context(request)
+
+          super
+        end
+
+        private
+
+        def on_close(_, error, _)
+          if error == :http_1_1_required
+            # remove all pending requests context
+            @pending.each do |req|
+              clear_from_context(req)
+            end
+          end
+
+          super
+        end
+
+        def on_stream_close(_, request, error)
+          clear_from_context(request) if error != :stream_closed && @streams.key?(request)
+
+          super
+        end
+
+        def teardown(request = nil)
+          super
+
+          if request
+            clear_from_context(request)
+          else
+            @contexts.clear
+          end
+        end
+
+        def add_to_context(request)
+          @contexts[request.context] << request
+        end
+
+        def clear_from_context(request)
+          requests = @contexts[request.context]
+
+          requests.delete(request)
+
+          @contexts.delete(request.context) if requests.empty?
+        end
+      end
+
+      module NativeResolverMethods
+        private
+
+        def calculate_interests
+          return if @queries.empty?
+
+          return unless @queries.values.any?(&:current_context?) || @connections.any?(&:current_context?)
+
+          super
+        end
+      end
+
+      module SystemResolverMethods
+        def interests
+          return unless @queries.any? { |_, conn| conn.current_context? }
+
+          super
+        end
+      end
+
+      module FiberConcurrencyH2C
+        module HTTP2Methods
+          def upgrade(request, *)
+            @contexts[request.context] << request
+
+            super
+          end
+        end
+      end
+    end
+
+    register_plugin :fiber_concurrency, FiberConcurrency
+  end
+end

data/lib/httpx/plugins/follow_redirects.rb

@@ -0,0 +1,233 @@
+# frozen_string_literal: true
+
+module HTTPX
+  InsecureRedirectError = Class.new(Error)
+  module Plugins
+    #
+    # This plugin adds support for automatically following redirect (status 30X) responses.
+    #
+    # It has a default upper bound of followed redirects (see *MAX_REDIRECTS* and the *max_redirects* option),
+    # after which it will return the last redirect response. It will **not** raise an exception.
+    #
+    # It doesn't follow insecure redirects (https -> http) by default (see *follow_insecure_redirects*).
+    #
+    # It doesn't propagate authorization related headers to requests redirecting to different origins
+    # (see *allow_auth_to_other_origins*) to override.
+    #
+    # It allows customization of when to redirect via the *redirect_on* callback option).
+    #
+    # https://gitlab.com/os85/httpx/wikis/Follow-Redirects
+    #
+    module FollowRedirects
+      MAX_REDIRECTS = 3
+      REDIRECT_STATUS = (300..399).freeze
+      REQUEST_BODY_HEADERS = %w[transfer-encoding content-encoding content-type content-length content-language content-md5 trailer].freeze
+
+      using URIExtensions
+
+      # adds support for the following options:
+      #
+      # :max_redirects :: max number of times a request will be redirected (defaults to <tt>3</tt>).
+      # :follow_insecure_redirects :: whether redirects to an "http://" URI, when coming from an "https//", are allowed
+      #                               (defaults to <tt>false</tt>).
+      # :allow_auth_to_other_origins :: whether auth-related headers, such as "Authorization", are propagated on redirection
+      #                                 (defaults to <tt>false</tt>).
+      # :redirect_on :: optional callback which receives the redirect location and can halt the redirect chain if it returns <tt>false</tt>.
+      module OptionsMethods
+        private
+
+        def option_max_redirects(value)
+          num = Integer(value)
+          raise TypeError, ":max_redirects must be positive" if num.negative?
+
+          num
+        end
+
+        def option_follow_insecure_redirects(value)
+          value
+        end
+
+        def option_allow_auth_to_other_origins(value)
+          value
+        end
+
+        def option_redirect_on(value)
+          raise TypeError, ":redirect_on must be callable" unless value.respond_to?(:call)
+
+          value
+        end
+      end
+
+      module InstanceMethods
+        # returns a session with the *max_redirects* option set to +n+
+        def max_redirects(n)
+          with(max_redirects: n.to_i)
+        end
+
+        private
+
+        def fetch_response(request, selector, options)
+          redirect_request = request.redirect_request
+          response = super(redirect_request, selector, options)
+          return unless response
+
+          max_redirects = redirect_request.max_redirects
+
+          return response unless response.is_a?(Response)
+          return response unless REDIRECT_STATUS.include?(response.status) && response.headers.key?("location")
+          return response unless max_redirects.positive?
+
+          redirect_uri = __get_location_from_response(response)
+
+          if options.redirect_on
+            redirect_allowed = options.redirect_on.call(redirect_uri)
+            return response unless redirect_allowed
+          end
+
+          # build redirect request
+          request_body = redirect_request.body
+          redirect_method = "GET"
+          redirect_params = {}
+
+          if response.status == 305 && options.respond_to?(:proxy)
+            request_body.rewind
+            # The requested resource MUST be accessed through the proxy given by
+            # the Location field. The Location field gives the URI of the proxy.
+            redirect_options = options.merge(headers: redirect_request.headers,
+                                             proxy: { uri: redirect_uri },
+                                             max_redirects: max_redirects - 1)
+
+            redirect_params[:body] = request_body
+            redirect_uri = redirect_request.uri
+            options = redirect_options
+          else
+            redirect_headers = redirect_request_headers(redirect_request.uri, redirect_uri, request.headers, options)
+            redirect_opts = Hash[options]
+            redirect_params[:max_redirects] = max_redirects - 1
+
+            unless request_body.empty?
+              if response.status == 307
+                # The method and the body of the original request are reused to perform the redirected request.
+                redirect_method = redirect_request.verb
+                request_body.rewind
+                redirect_params[:body] = request_body
+              else
+                # redirects are **ALWAYS** GET, so remove body-related headers
+                REQUEST_BODY_HEADERS.each do |h|
+                  redirect_headers.delete(h)
+                end
+                redirect_params[:body] = nil
+              end
+            end
+
+            options = options.class.new(redirect_opts.merge(headers: redirect_headers.to_h))
+          end
+
+          redirect_uri = Utils.to_uri(redirect_uri)
+
+          if !options.follow_insecure_redirects &&
+             response.uri.scheme == "https" &&
+             redirect_uri.scheme == "http"
+            error = InsecureRedirectError.new(redirect_uri.to_s)
+            error.set_backtrace(caller)
+            return ErrorResponse.new(request, error)
+          end
+
+          retry_request = build_request(redirect_method, redirect_uri, redirect_params, options)
+
+          request.redirect_request = retry_request
+
+          redirect_after = response.headers["retry-after"]
+
+          if redirect_after
+            # Servers send the "Retry-After" header field to indicate how long the
+            # user agent ought to wait before making a follow-up request.
+            # When sent with any 3xx (Redirection) response, Retry-After indicates
+            # the minimum time that the user agent is asked to wait before issuing
+            # the redirected request.
+            #
+            redirect_after = Utils.parse_retry_after(redirect_after)
+
+            retry_start = Utils.now
+            log { "redirecting after #{redirect_after} secs..." }
+            selector.after(redirect_after) do
+              if (response = request.response)
+                response.finish!
+                retry_request.response = response
+                # request has terminated abruptly meanwhile
+                retry_request.emit(:response, response)
+              else
+                log { "redirecting (elapsed time: #{Utils.elapsed_time(retry_start)})!!" }
+                send_request(retry_request, selector, options)
+              end
+            end
+          else
+            send_request(retry_request, selector, options)
+          end
+          nil
+        end
+
+        # :nodoc:
+        def redirect_request_headers(original_uri, redirect_uri, headers, options)
+          headers = headers.dup
+
+          return headers if options.allow_auth_to_other_origins
+
+          return headers unless headers.key?("authorization")
+
+          return headers if original_uri.origin == redirect_uri.origin
+
+          headers.delete("authorization")
+
+          headers
+        end
+
+        # :nodoc:
+        def __get_location_from_response(response)
+          # @type var location_uri: http_uri
+          location_uri = URI(response.headers["location"])
+          location_uri = response.uri.merge(location_uri) if location_uri.relative?
+          location_uri
+        end
+      end
+
+      module RequestMethods
+        # returns the top-most original HTTPX::Request from the redirect chain
+        attr_accessor :root_request
+
+        # returns the follow-up redirect request, or itself
+        def redirect_request
+          @redirect_request || self
+        end
+
+        # sets the follow-up redirect request
+        def redirect_request=(req)
+          @redirect_request = req
+          req.root_request = @root_request || self
+          @response = nil
+        end
+
+        def response
+          return super unless @redirect_request && @response.nil?
+
+          @redirect_request.response
+        end
+
+        def max_redirects
+          @options.max_redirects || MAX_REDIRECTS
+        end
+      end
+
+      module ConnectionMethods
+        private
+
+        def set_request_request_timeout(request)
+          return unless request.root_request.nil?
+
+          super
+        end
+      end
+    end
+    register_plugin :follow_redirects, FollowRedirects
+  end
+end

data/lib/httpx/plugins/grpc/call.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Plugins
+    module GRPC
+      # Encapsulates call information
+      class Call
+        attr_writer :decoder
+
+        def initialize(response)
+          @response = response
+          @decoder = ->(z) { z }
+          @consumed = false
+          @grpc_response = nil
+        end
+
+        def inspect
+          "#{self.class}(#{grpc_response})"
+        end
+
+        def to_s
+          grpc_response.to_s
+        end
+
+        def metadata
+          response.headers
+        end
+
+        def trailing_metadata
+          return unless @consumed
+
+          @response.trailing_metadata
+        end
+
+        private
+
+        def grpc_response
+          @grpc_response ||= if @response.respond_to?(:each)
+            Enumerator.new do |y|
+              Message.stream(@response).each do |message|
+                y << @decoder.call(message)
+              end
+              @consumed = true
+            end
+          else
+            @consumed = true
+            @decoder.call(Message.unary(@response))
+          end
+        end
+
+        def respond_to_missing?(meth, *args, &blk)
+          grpc_response.respond_to?(meth, *args) || super
+        end
+
+        def method_missing(meth, *args, &blk)
+          return grpc_response.__send__(meth, *args, &blk) if grpc_response.respond_to?(meth)
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/httpx/plugins/grpc/grpc_encoding.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Transcoder
+    module GRPCEncoding
+      class Deflater
+        extend Forwardable
+
+        attr_reader :content_type
+
+        def initialize(body, compressed:)
+          @content_type = body.content_type
+          @body = BodyReader.new(body)
+          @compressed = compressed
+        end
+
+        def bytesize
+          return @body.bytesize if @body.respond_to?(:bytesize)
+
+          Float::INFINITY
+        end
+
+        def read(length = nil, outbuf = nil)
+          buf = @body.read(length, outbuf)
+
+          return unless buf
+
+          compressed_flag = @compressed ? 1 : 0
+
+          buf = outbuf if outbuf
+
+          buf = buf.b if buf.frozen?
+
+          buf.prepend([compressed_flag, buf.bytesize].pack("CL>"))
+          buf
+        end
+      end
+
+      class Inflater
+        def initialize(response)
+          @response = response
+          @grpc_encodings = nil
+        end
+
+        def call(message, &blk)
+          data = "".b
+
+          until message.empty?
+            compressed, size = message.unpack("CL>")
+
+            encoded_data = message.byteslice(5..size + 5 - 1)
+
+            if compressed == 1
+              grpc_encodings.reverse_each do |encoding|
+                decoder = @response.body.class.initialize_inflater_by_encoding(encoding, @response, bytesize: encoded_data.bytesize)
+                encoded_data = decoder.call(encoded_data)
+
+                blk.call(encoded_data) if blk
+
+                data << encoded_data
+              end
+            else
+              blk.call(encoded_data) if blk
+
+              data << encoded_data
+            end
+
+            message = message.byteslice((size + 5)..-1)
+          end
+
+          data
+        end
+
+        private
+
+        def grpc_encodings
+          @grpc_encodings ||= @response.headers.get("grpc-encoding")
+        end
+      end
+
+      def self.encode(*args, **kwargs)
+        Deflater.new(*args, **kwargs)
+      end
+
+      def self.decode(response)
+        Inflater.new(response)
+      end
+    end
+  end
+end

data/lib/httpx/plugins/grpc/message.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Plugins
+    module GRPC
+      # Encoding module for GRPC responses
+      #
+      # Can encode and decode grpc messages.
+      module Message
+        module_function
+
+        # decodes a unary grpc response
+        def unary(response)
+          verify_status(response)
+
+          decoder = Transcoder::GRPCEncoding.decode(response)
+
+          decoder.call(response.to_s)
+        end
+
+        # lazy decodes a grpc stream response
+        def stream(response, &block)
+          return enum_for(__method__, response) unless block
+
+          decoder = Transcoder::GRPCEncoding.decode(response)
+
+          response.each do |frame|
+            decoder.call(frame, &block)
+          end
+
+          verify_status(response)
+        end
+
+        def cancel(request)
+          request.emit(:refuse, :client_cancellation)
+        end
+
+        # interprets the grpc call trailing metadata, and raises an
+        # exception in case of error code
+        def verify_status(response)
+          # return standard errors if need be
+          response.raise_for_status
+
+          status = Integer(response.headers["grpc-status"])
+          message = response.headers["grpc-message"]
+
+          return if status.zero?
+
+          response.close
+          raise GRPCError.new(status, message, response.trailing_metadata)
+        end
+      end
+    end
+  end
+end