httpx 0.12.0 → 0.14.1

data/lib/httpx/plugins/upgrade.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Plugins
+    #
+    # This plugin helps negotiating a new protocol from an HTTP/1.1 connection, via the
+    # Upgrade header.
+    #
+    # https://gitlab.com/honeyryderchuck/httpx/wikis/Upgrade
+    #
+    module Upgrade
+      class << self
+        def configure(klass)
+          klass.plugin(:"upgrade/h2")
+        end
+
+        def extra_options(options)
+          upgrade_handlers = Module.new do
+            extend Registry
+          end
+
+          Class.new(options.class) do
+            def_option(:upgrade_handlers, <<-OUT)
+              raise Error, ":upgrade_handlers must be a registry" unless value.respond_to?(:registry)
+
+              value
+            OUT
+          end.new(options).merge(upgrade_handlers: upgrade_handlers)
+        end
+      end
+
+      module InstanceMethods
+        def fetch_response(request, connections, options)
+          response = super
+
+          if response
+            return response unless response.respond_to?(:headers) && response.headers.key?("upgrade")
+
+            upgrade_protocol = response.headers["upgrade"].split(/ *, */).first
+
+            return response unless upgrade_protocol && options.upgrade_handlers.registry.key?(upgrade_protocol)
+
+            protocol_handler = options.upgrade_handlers.registry(upgrade_protocol)
+
+            return response unless protocol_handler
+
+            log { "upgrading to #{upgrade_protocol}..." }
+            connection = find_connection(request, connections, options)
+            connections << connection unless connections.include?(connection)
+
+            # do not upgrade already upgraded connections
+            return if connection.upgrade_protocol == upgrade_protocol
+
+            protocol_handler.call(connection, request, response)
+
+            # keep in the loop if the server is switching, unless
+            # the connection has been hijacked, in which case you want
+            # to terminante immediately
+            return if response.status == 101 && !connection.hijacked
+          end
+
+          response
+        end
+
+        def close(*args)
+          return super if args.empty?
+
+          connections, = args
+
+          pool.close(connections.reject(&:hijacked))
+        end
+      end
+
+      module ConnectionMethods
+        attr_reader :upgrade_protocol, :hijacked
+
+        def hijack_io
+          @hijacked = true
+        end
+      end
+    end
+    register_plugin(:upgrade, Upgrade)
+  end
+end

data/lib/httpx/plugins/upgrade/h2.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Plugins
+    #
+    # This plugin adds support for upgrading an HTTP/1.1 connection to HTTP/2
+    # via an Upgrade: h2 response declaration
+    #
+    # https://gitlab.com/honeyryderchuck/httpx/wikis/Upgrade#h2
+    #
+    module H2
+      class << self
+        def configure(klass)
+          klass.default_options.upgrade_handlers.register "h2", self
+        end
+
+        def call(connection, _request, _response)
+          connection.upgrade_to_h2
+        end
+      end
+
+      module ConnectionMethods
+        using URIExtensions
+
+        def upgrade_to_h2
+          prev_parser = @parser
+
+          if prev_parser
+            prev_parser.reset
+            @inflight -= prev_parser.requests.size
+          end
+
+          @parser = Connection::HTTP2.new(@write_buffer, @options)
+          set_parser_callbacks(@parser)
+          @upgrade_protocol = :h2
+
+          # what's happening here:
+          # a deviation from the state machine is done to perform the actions when a
+          # connection is closed, without transitioning, so the connection is kept in the pool.
+          # the state is reset to initial, so that the socket reconnect works out of the box,
+          # while the parser is already here.
+          purge_after_closed
+          transition(:idle)
+
+          prev_parser.requests.each do |req|
+            req.transition(:idle)
+            send(req)
+          end
+        end
+      end
+    end
+    register_plugin(:"upgrade/h2", H2)
+  end
+end

data/lib/httpx/pool.rb

@@ -64,11 +64,6 @@ module HTTPX
       connection.on(:open) do
         @connected_connections += 1
       end
-      connection.on(:unreachable) do
-        resolver = find_resolver_for(connection)
-        resolver.uncache(connection) if resolver
-        resolve_connection(connection)
-      end
     end
 
     # opens a connection to the IP reachable through +uri+.
@@ -85,6 +80,20 @@ module HTTPX
 
     def resolve_connection(connection)
       @connections << connection unless @connections.include?(connection)
+
+      if connection.addresses || connection.state == :open
+        #
+        # there are two cases in which we want to activate initialization of
+        # connection immediately:
+        #
+        # 1. when the connection already has addresses, i.e. it doesn't need to
+        #    resolve a name (not the same as name being an IP, yet)
+        # 2. when the connection is initialized with an external already open IO.
+        #
+        on_resolver_connection(connection)
+        return
+      end
+
       resolver = find_resolver_for(connection)
       resolver << connection
       return if resolver.empty?

data/lib/httpx/request.rb

@@ -35,14 +35,22 @@ module HTTPX
 
     attr_reader :verb, :uri, :headers, :body, :state, :options, :response
 
+    # Exception raised during enumerable body writes
+    attr_reader :drain_error
+
     def_delegator :@body, :empty?
 
     def_delegator :@body, :chunk!
 
     def initialize(verb, uri, options = {})
       @verb    = verb.to_s.downcase.to_sym
-      @uri     = Utils.uri(uri)
       @options = Options.new(options)
+      @uri     = Utils.uri(uri)
+      if @uri.relative?
+        raise(Error, "invalid URI: #{@uri}") unless @options.origin
+
+        @uri = @options.origin.merge(@uri)
+      end
 
       raise(Error, "unknown method: #{verb}") unless METHODS.include?(@verb)
 
@@ -54,6 +62,14 @@ module HTTPX
       @state = :idle
     end
 
+    def trailers?
+      defined?(@trailers)
+    end
+
+    def trailers
+      @trailers ||= @options.headers_class.new
+    end
+
     def interests
       return :r if @state == :done || @state == :expect
 
@@ -124,6 +140,9 @@ module HTTPX
       chunk.dup
     rescue StopIteration
       nil
+    rescue StandardError => e
+      @drain_error = e
+      nil
     end
 
     # :nocov:
@@ -200,7 +219,9 @@ module HTTPX
       end
 
       def unbounded_body?
-        chunked? || @body.bytesize == Float::INFINITY
+        return @unbounded_body if defined?(@unbounded_body)
+
+        @unbounded_body = (chunked? || @body.bytesize == Float::INFINITY)
       end
 
       def chunked?
@@ -253,6 +274,8 @@ module HTTPX
             nextstate = :expect
           end
         end
+      when :trailers
+        return unless @state == :body
       when :done
         return if @state == :expect
       end

data/lib/httpx/resolver/native.rb

@@ -101,7 +101,7 @@ module HTTPX
         transition(:open)
       end
 
-      !@write_buffer.empty? || @queries.empty? ? :w : :r
+      calculate_interests
     end
 
     def <<(connection)
@@ -127,10 +127,14 @@ module HTTPX
 
     private
 
+    def calculate_interests
+      !@write_buffer.empty? || @queries.empty? ? :w : :r
+    end
+
     def consume
-      dread
+      dread if calculate_interests == :r
       do_retry
-      dwrite
+      dwrite if calculate_interests == :w
     end
 
     def do_retry

data/lib/httpx/response.rb

@@ -27,8 +27,7 @@ module HTTPX
       @version = version
       @status = Integer(status)
       @headers = @options.headers_class.new(headers)
-      @body = @options.response_body_class.new(self, threshold_size: @options.body_threshold_size,
-                                                     window_size: @options.window_size)
+      @body = @options.response_body_class.new(self, @options)
     end
 
     def merge_headers(h)
@@ -83,17 +82,22 @@ module HTTPX
     end
 
     class Body
-      def initialize(response, threshold_size:, window_size: 1 << 14)
+      def initialize(response, options)
         @response = response
         @headers = response.headers
-        @threshold_size = threshold_size
-        @window_size = window_size
+        @options = options
+        @threshold_size = options.body_threshold_size
+        @window_size = options.window_size
         @encoding = response.content_type.charset || Encoding::BINARY
         @length = 0
         @buffer = nil
         @state = :idle
       end
 
+      def closed?
+        @state == :closed
+      end
+
       def write(chunk)
         return if @state == :closed
 

data/lib/httpx/session.rb

@@ -77,7 +77,7 @@ module HTTPX
     end
 
     def set_connection_callbacks(connection, connections, options)
-      connection.on(:misdirected) do |misdirected_request|
+      connection.only(:misdirected) do |misdirected_request|
         other_connection = connection.create_idle(ssl: { alpn_protocols: %w[http/1.1] })
         other_connection.merge(connection)
         catch(:coalesced) do
@@ -88,11 +88,11 @@ module HTTPX
         misdirected_request.transition(:idle)
         other_connection.send(misdirected_request)
       end
-      connection.on(:altsvc) do |alt_origin, origin, alt_params|
+      connection.only(:altsvc) do |alt_origin, origin, alt_params|
         other_connection = build_altsvc_connection(connection, connections, alt_origin, origin, alt_params, options)
         connections << other_connection if other_connection
       end
-      connection.on(:exhausted) do
+      connection.only(:exhausted) do
         other_connection = connection.create_idle
         other_connection.merge(connection)
         catch(:coalesced) do
@@ -175,12 +175,18 @@ module HTTPX
     end
 
     def send_requests(*requests, options)
-      connections = []
       request_options = @options.merge(options)
 
+      connections = _send_requests(requests, request_options)
+      receive_requests(requests, connections, request_options)
+    end
+
+    def _send_requests(requests, options)
+      connections = []
+
       requests.each do |request|
         error = catch(:resolve_error) do
-          connection = find_connection(request, connections, request_options)
+          connection = find_connection(request, connections, options)
           connection.send(request)
         end
         next unless error.is_a?(ResolveError)
@@ -188,13 +194,17 @@ module HTTPX
         request.emit(:response, ErrorResponse.new(request, error, options))
       end
 
+      connections
+    end
+
+    def receive_requests(requests, connections, options)
       responses = []
 
       begin
         # guarantee ordered responses
         loop do
           request = requests.first
-          pool.next_tick until (response = fetch_response(request, connections, request_options))
+          pool.next_tick until (response = fetch_response(request, connections, options))
 
           responses << response
           requests.shift
@@ -208,7 +218,7 @@ module HTTPX
           # opportunity to traverse the requests, hence we're returning only a fraction of the errors
           # we were supposed to. This effectively fetches the existing responses and return them.
           while (request = requests.shift)
-            responses << fetch_response(request, connections, request_options)
+            responses << fetch_response(request, connections, options)
           end
           break
         end

data/lib/httpx/transcoder/chunker.rb

@@ -20,7 +20,7 @@ module HTTPX::Transcoder
         @raw.each do |chunk|
           yield "#{chunk.bytesize.to_s(16)}#{CRLF}#{chunk}#{CRLF}"
         end
-        yield "0#{CRLF}#{CRLF}"
+        yield "0#{CRLF}"
       end
 
       def respond_to_missing?(meth, *args)

data/lib/httpx/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module HTTPX
-  VERSION = "0.12.0"
+  VERSION = "0.14.1"
 end

data/sig/callbacks.rbs

@@ -6,8 +6,10 @@ module HTTPX
   module Callbacks
     def on: (Symbol) { (*untyped) -> void } -> void
     def once: (Symbol) { (*untyped) -> void } -> void
+    def only: (Symbol) { (*untyped) -> void } -> void
     def emit: (Symbol, *untyped) -> void
 
+    def callbacks_for?: (Symbol) -> bool
     def callbacks: () -> Hash[Symbol, Array[_Callable]]
                   | (Symbol) -> Array[_Callable]
   end

data/sig/chainable.rbs

@@ -18,7 +18,8 @@ module HTTPX
               | (:cookies) -> Plugins::sessionCookies
               | (:expect) -> Session
               | (:follow_redirects) -> Plugins::sessionFollowRedirects
-              | (:h2c) -> Plugins::sessionH2C
+              | (:upgrade) -> Session
+              | (:h2c) -> Session
               | (:multipart) -> Session
               | (:persistent) -> Plugins::sessionPersistent
               | (:proxy) -> Plugins::sessionProxy

data/sig/connection/http1.rbs

@@ -4,6 +4,7 @@ module HTTPX
     include Loggable
 
     attr_reader pending: Array[Request]
+    attr_reader requests: Array[Request]
 
     @options: Options
     @max_concurrent_requests: Integer
@@ -51,7 +52,7 @@ module HTTPX
 
     def disable_pipelining: () -> void
 
-    def set_protocol_headers: (Request) -> void
+    def set_protocol_headers: (Request) -> _Each[headers_key, String]
 
     def headline_uri: (Request) -> String
 
@@ -59,6 +60,10 @@ module HTTPX
 
     def join_headers: (Request request) -> void
 
+    def join_trailers: (Request request) -> void
+
+    def join_headers2: (_Each[headers_key, String] headers) -> void
+
     def join_body: (Request request) -> void
 
     def capitalized: (String field) -> String

data/sig/connection/http2.rbs

@@ -43,7 +43,7 @@ module HTTPX
 
     def headline_uri: (Request) -> String
 
-    def set_protocol_headers: (Request) -> void
+    def set_protocol_headers: (Request) -> _Each[headers_key, String]
 
     def handle: (Request request, HTTP2Next::Stream stream) -> void
 
@@ -53,13 +53,17 @@ module HTTPX
 
     def join_headers: (HTTP2Next::Stream stream, Request request) -> void
 
+    def join_trailers: (HTTP2Next::Stream stream, Request request) -> void
+
     def join_body: (HTTP2Next::Stream stream, Request request) -> void
 
     def on_stream_headers: (HTTP2Next::Stream stream, Request request, Array[[String, String]] headers) -> void
 
+    def on_stream_trailers: (HTTP2Next::Stream stream, Request request, Array[[String, String]] headers) -> void
+
     def on_stream_data: (HTTP2Next::Stream stream, Request request, string data) -> void
 
-    def on_stream_close: (HTTP2Next::Stream stream, Request request, Symbol? error) -> void
+    def on_stream_close: (HTTP2Next::Stream stream, Request request, (Symbol | StandardError)? error) -> void
 
     def on_frame: (string bytes) -> void