httpx 0.12.0 → 0.14.1

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

@@ -0,0 +1,85 @@
+# 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)
+          decode(response.to_s, encodings: response.headers.get("grpc-encoding"), encoders: response.encoders)
+        end
+
+        # lazy decodes a grpc stream response
+        def stream(response, &block)
+          return enum_for(__method__, response) unless block_given?
+
+          response.each do |frame|
+            decode(frame, encodings: response.headers.get("grpc-encoding"), encoders: response.encoders, &block)
+          end
+
+          verify_status(response)
+        end
+
+        # encodes a single grpc message
+        def encode(bytes, deflater:)
+          if deflater
+            compressed_flag = 1
+            bytes = deflater.deflate(StringIO.new(bytes))
+          else
+            compressed_flag = 0
+          end
+
+          "".b << [compressed_flag, bytes.bytesize].pack("CL>") << bytes.to_s
+        end
+
+        # decodes a single grpc message
+        def decode(message, encodings:, encoders:)
+          until message.empty?
+
+            compressed, size = message.unpack("CL>")
+
+            data = message.byteslice(5..size + 5 - 1)
+            if compressed == 1
+              encodings.reverse_each do |algo|
+                inflater = encoders.registry(algo).inflater(size)
+                data = inflater.inflate(data)
+                size = data.bytesize
+              end
+            end
+
+            return data unless block_given?
+
+            yield data
+
+            message = message.byteslice(5 + size..-1)
+          end
+        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

data/lib/httpx/plugins/h2c.rb

@@ -6,68 +6,53 @@ module HTTPX
     # This plugin adds support for upgrading a plaintext HTTP/1.1 connection to HTTP/2
     # (https://tools.ietf.org/html/rfc7540#section-3.2)
     #
-    # https://gitlab.com/honeyryderchuck/httpx/wikis/Follow-Redirects
+    # https://gitlab.com/honeyryderchuck/httpx/wikis/Upgrade#h2c
     #
     module H2C
-      def self.load_dependencies(*)
-        require "base64"
+      VALID_H2C_VERBS = %i[get options head].freeze
+
+      class << self
+        def load_dependencies(*)
+          require "base64"
+        end
+
+        def configure(klass)
+          klass.plugin(:upgrade)
+          klass.default_options.upgrade_handlers.register "h2c", self
+        end
+
+        def call(connection, request, response)
+          connection.upgrade_to_h2c(request, response)
+        end
       end
 
       module InstanceMethods
-        def request(*args, **options)
-          h2c_options = options.merge(fallback_protocol: "h2c")
+        def send_requests(*requests, options)
+          upgrade_request, *remainder = requests
+
+          return super unless VALID_H2C_VERBS.include?(upgrade_request.verb) && upgrade_request.scheme == "http"
 
-          requests = build_requests(*args, h2c_options)
+          connection = pool.find_connection(upgrade_request.uri, @options.merge(options))
 
-          upgrade_request = requests.first
-          return super unless valid_h2c_upgrade_request?(upgrade_request)
+          return super if connection && connection.upgrade_protocol == :h2c
 
+          # build upgrade request
           upgrade_request.headers.add("connection", "upgrade")
           upgrade_request.headers.add("connection", "http2-settings")
           upgrade_request.headers["upgrade"] = "h2c"
           upgrade_request.headers["http2-settings"] = HTTP2Next::Client.settings_header(upgrade_request.options.http2_settings)
-          wrap { send_requests(*upgrade_request, h2c_options).first }
 
-          responses = send_requests(*requests, h2c_options)
-
-          responses.size == 1 ? responses.first : responses
-        end
-
-        private
-
-        def fetch_response(request, connections, options)
-          response = super
-          if response && valid_h2c_upgrade?(request, response, options)
-            log { "upgrading to h2c..." }
-            connection = find_connection(request, connections, options)
-            connections << connection unless connections.include?(connection)
-            connection.upgrade(request, response)
-          end
-          response
-        end
-
-        VALID_H2C_METHODS = %i[get options head].freeze
-        private_constant :VALID_H2C_METHODS
-
-        def valid_h2c_upgrade_request?(request)
-          VALID_H2C_METHODS.include?(request.verb) &&
-            request.scheme == "http"
-        end
-
-        def valid_h2c_upgrade?(request, response, options)
-          options.fallback_protocol == "h2c" &&
-            request.headers.get("connection").include?("upgrade") &&
-            request.headers.get("upgrade").include?("h2c") &&
-            response.status == 101
+          super(upgrade_request, *remainder, options.merge(max_concurrent_requests: 1))
         end
       end
 
       class H2CParser < Connection::HTTP2
         def upgrade(request, response)
-          @connection.send_connection_preface
           # 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
 
@@ -81,29 +66,29 @@ module HTTPX
       module ConnectionMethods
         using URIExtensions
 
-        def match?(uri, options)
-          return super unless uri.scheme == "http" && @options.fallback_protocol == "h2c"
-
-          super && options.fallback_protocol == "h2c"
-        end
-
-        def coalescable?(connection)
-          return super unless @options.fallback_protocol == "h2c" && @origin.scheme == "http"
+        def upgrade_to_h2c(request, response)
+          prev_parser = @parser
 
-          @origin == connection.origin && connection.options.fallback_protocol == "h2c"
-        end
+          if prev_parser
+            prev_parser.reset
+            @inflight -= prev_parser.requests.size
+          end
 
-        def upgrade(request, response)
-          @parser.reset if @parser
-          @parser = H2CParser.new(@write_buffer, @options)
+          parser_options = @options.merge(max_concurrent_requests: request.options.max_concurrent_requests)
+          @parser = H2CParser.new(@write_buffer, parser_options)
           set_parser_callbacks(@parser)
+          @inflight += 1
           @parser.upgrade(request, response)
-        end
+          @upgrade_protocol = :h2c
 
-        def build_parser(*)
-          return super unless @origin.scheme == "http"
+          if request.options.max_concurrent_requests != @options.max_concurrent_requests
+            @options = @options.merge(max_concurrent_requests: nil)
+          end
 
-          super("http/1.1")
+          prev_parser.requests.each do |req|
+            req.transition(:idle)
+            send(req)
+          end
         end
       end
     end

data/lib/httpx/plugins/internal_telemetry.rb

@@ -71,7 +71,7 @@ module HTTPX
         def transition(nextstate)
           state = @state
           super
-          meter_elapsed_time("Request[#{@verb} #{@uri}: #{state}] -> #{nextstate}") if nextstate == @state
+          meter_elapsed_time("Request##{object_id}[#{@verb} #{@uri}: #{state}] -> #{nextstate}") if nextstate == @state
         end
       end
 

data/lib/httpx/plugins/multipart/part.rb

@@ -19,14 +19,14 @@ module HTTPX
           value = value[:body]
         end
 
-        value = value.open(:binmode => true) if value.is_a?(Pathname)
+        value = value.open(:binmode => true) if Object.const_defined?(:Pathname) && value.is_a?(Pathname)
 
         if value.is_a?(File)
           filename ||= File.basename(value.path)
           content_type ||= MimeTypeDetector.call(value, filename) || "application/octet-stream"
           [value, content_type, filename]
         else
-          [StringIO.new(value.to_s), "text/plain"]
+          [StringIO.new(value.to_s), content_type || "text/plain"]
         end
       end
     end

data/lib/httpx/plugins/proxy.rb

@@ -67,13 +67,9 @@ module HTTPX
 
         def extra_options(options)
           Class.new(options.class) do
-            def_option(:proxy) do |pr|
-              if pr.is_a?(Parameters)
-                pr
-              else
-                Hash[pr]
-              end
-            end
+            def_option(:proxy, <<-OUT)
+              value.is_a?(#{Parameters}) ? value : Hash[value]
+            OUT
           end.new(options)
         end
       end

data/lib/httpx/plugins/proxy/http.rb

@@ -82,11 +82,12 @@ module HTTPX
           end
 
           def set_protocol_headers(request)
-            super
+            extra_headers = super
+
             proxy_params = @options.proxy
-            request.headers["proxy-authorization"] = "Basic #{proxy_params.token_authentication}" if proxy_params.authenticated?
-            request.headers["proxy-connection"] = request.headers["connection"]
-            request.headers.delete("connection")
+            extra_headers["proxy-authorization"] = "Basic #{proxy_params.token_authentication}" if proxy_params.authenticated?
+            extra_headers["proxy-connection"] = extra_headers.delete("connection") if extra_headers.key?("connection")
+            extra_headers
           end
         end
 

data/lib/httpx/plugins/proxy/ssh.rb

@@ -12,9 +12,9 @@ module HTTPX
 
         def self.extra_options(options)
           Class.new(options.class) do
-            def_option(:proxy) do |pr|
-              Hash[pr]
-            end
+            def_option(:proxy, <<-OUT)
+              Hash[value]
+            OUT
           end.new(options)
         end
 

data/lib/httpx/plugins/rate_limiter.rb

@@ -15,7 +15,7 @@ module HTTPX
       class << self
         RATE_LIMIT_CODES = [429, 503].freeze
 
-        def load_dependencies(klass)
+        def configure(klass)
           klass.plugin(:retries,
                        retry_change_requests: true,
                        retry_on: method(:retry_on_rate_limited_response),

data/lib/httpx/plugins/retries.rb

@@ -25,37 +25,36 @@ module HTTPX
 
       def self.extra_options(options)
         Class.new(options.class) do
-          # number of seconds after which one can retry the request
-          def_option(:retry_after) do |num|
+          def_option(:retry_after, <<-OUT)
             # return early if callable
-            unless num.respond_to?(:call)
-              num = Integer(num)
-              raise Error, ":retry_after must be positive" unless num.positive?
+            unless value.respond_to?(:call)
+              value = Integer(value)
+              raise Error, ":retry_after must be positive" unless value.positive?
             end
 
-            num
-          end
+            value
+          OUT
 
-          def_option(:max_retries) do |num|
-            num = Integer(num)
+          def_option(:max_retries, <<-OUT)
+            num = Integer(value)
             raise Error, ":max_retries must be positive" unless num.positive?
 
             num
-          end
+          OUT
 
           def_option(:retry_change_requests)
 
-          def_option(:retry_on) do |callback|
-            raise ":retry_on must be called with the response" unless callback.respond_to?(:call)
+          def_option(:retry_on, <<-OUT)
+            raise ":retry_on must be called with the response" unless value.respond_to?(:call)
 
-            callback
-          end
+            value
+          OUT
         end.new(options).merge(max_retries: MAX_RETRIES)
       end
 
       module InstanceMethods
         def max_retries(n)
-          branch(default_options.with_max_retries(n.to_i))
+          with(max_retries: n.to_i)
         end
 
         private

data/lib/httpx/plugins/stream.rb

@@ -1,10 +1,99 @@
 # frozen_string_literal: true
 
 module HTTPX
+  class StreamResponse
+    def initialize(request, session, connections)
+      @request = request
+      @session = session
+      @connections = connections
+      @options = @request.options
+    end
+
+    def each(&block)
+      return enum_for(__method__) unless block_given?
+
+      raise Error, "response already streamed" if @response
+
+      @request.stream = self
+
+      begin
+        @on_chunk = block
+
+        if @request.response
+          # if we've already started collecting the payload, yield it first
+          # before proceeding
+          body = @request.response.body
+
+          body.each do |chunk|
+            on_chunk(chunk)
+          end
+        end
+
+        response.raise_for_status
+        response.close
+      ensure
+        @on_chunk = nil
+      end
+    end
+
+    def each_line
+      return enum_for(__method__) unless block_given?
+
+      line = +""
+
+      each do |chunk|
+        line << chunk
+
+        while (idx = line.index("\n"))
+          yield line.byteslice(0..idx - 1)
+
+          line = line.byteslice(idx + 1..-1)
+        end
+      end
+    end
+
+    # This is a ghost method. It's to be used ONLY internally, when processing streams
+    def on_chunk(chunk)
+      raise NoMethodError unless @on_chunk
+
+      @on_chunk.call(chunk)
+    end
+
+    # :nocov:
+    def inspect
+      "#<StreamResponse:#{object_id}>"
+    end
+    # :nocov:
+
+    def to_s
+      response.to_s
+    end
+
+    private
+
+    def response
+      @session.__send__(:receive_requests, [@request], @connections, @options) until @request.response
+
+      @request.response
+    end
+
+    def respond_to_missing?(meth, *args)
+      response.respond_to?(meth, *args) || super
+    end
+
+    def method_missing(meth, *args, &block)
+      return super unless response.respond_to?(meth)
+
+      response.__send__(meth, *args, &block)
+    end
+  end
+
   module Plugins
     #
     # This plugin adds support for stream response (text/event-stream).
     #
+    # https://gitlab.com/honeyryderchuck/httpx/wikis/Stream
+    #
     module Stream
       module InstanceMethods
         private
@@ -13,10 +102,13 @@ module HTTPX
           return super(*args, **options) unless stream
 
           requests = args.first.is_a?(Request) ? args : build_requests(*args, options)
-
           raise Error, "only 1 response at a time is supported for streaming requests" unless requests.size == 1
 
-          StreamResponse.new(requests.first, self)
+          request = requests.first
+
+          connections = _send_requests(requests, request.options)
+
+          StreamResponse.new(request, self, connections)
         end
       end
 
@@ -31,7 +123,7 @@ module HTTPX
       end
 
       module ResponseBodyMethods
-        def initialize(*, **)
+        def initialize(*)
           super
           @stream = @response.stream
         end
@@ -51,78 +143,10 @@ module HTTPX
         end
       end
 
-      class StreamResponse
-        def initialize(request, session)
-          @request = request
-          @session = session
-          @options = @request.options
-        end
-
-        def each(&block)
-          return enum_for(__method__) unless block_given?
-
-          raise Error, "response already streamed" if @response
-
-          @request.stream = self
-
-          begin
-            @on_chunk = block
-
-            response.raise_for_status
-            response.close
-          ensure
-            @on_chunk = nil
-          end
-        end
-
-        def each_line
-          return enum_for(__method__) unless block_given?
-
-          line = +""
-
-          each do |chunk|
-            line << chunk
-
-            while (idx = line.index("\n"))
-              yield line.byteslice(0..idx - 1)
-
-              line = line.byteslice(idx + 1..-1)
-            end
-          end
-        end
-
-        # This is a ghost method. It's to be used ONLY internally, when processing streams
-        def on_chunk(chunk)
-          raise NoMethodError unless @on_chunk
-
-          @on_chunk.call(chunk)
-        end
-
-        # :nocov:
-        def inspect
-          "#<StreamResponse:#{object_id}>"
-        end
-        # :nocov:
-
-        def to_s
-          response.to_s
-        end
-
-        private
-
-        def response
-          @response ||= @session.__send__(:send_requests, @request, @options).first
-        end
-
-        def respond_to_missing?(*args)
-          @options.response_class.respond_to?(*args) || super
-        end
-
-        def method_missing(meth, *args, &block)
-          return super unless @options.response_class.public_method_defined?(meth)
-
-          response.__send__(meth, *args, &block)
-        end
+      def self.const_missing(const_name)
+        super unless const_name == :StreamResponse
+        warn "DEPRECATION WARNING: the class #{self}::StreamResponse is deprecated. Use HTTPX::StreamResponse instead."
+        HTTPX::StreamResponse
       end
     end
     register_plugin :stream, Stream