httpx 0.12.0 → 0.13.0

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/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,11 +82,12 @@ 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

data/lib/httpx/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module HTTPX
-  VERSION = "0.12.0"
+  VERSION = "0.13.0"
 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

data/sig/options.rbs

@@ -11,62 +11,54 @@ module HTTPX
     # headers
     attr_reader headers: Headers?
     def headers=: (headers) -> void
-    def with_headers: (headers) -> instance 
 
     # timeout
     attr_reader timeout: Timeout?
     def timeout=: (Hash[Symbol, untyped] | Timeout) -> void
-    def with_timeout: (Hash[Symbol, untyped] | Timeout) -> instance
 
     # max_concurrent_requests
     attr_reader max_concurrent_requests: Integer?
     def max_concurrent_requests=: (Integer) -> void
-    def with_max_concurrent_requests: (Integer) -> instance
 
     # max_requests
     attr_reader max_requests: Integer?
     def max_requests=: (Integer) -> void
-    def with_max_requests: (Integer) -> instance
 
     # window_size
     attr_reader window_size: int?
     def window_size=: (int) -> void
-    def with_window_size: (int) -> instance
 
     # body_threshold_size
     attr_reader body_threshold_size: int?
     def body_threshold_size=: (int) -> void
-    def with_body_threshold_size: (int) -> instance
 
     # transport
     attr_reader transport: _ToS?
     def transport=: (_ToS) -> void
-    def with_transport: (_ToS) -> instance
 
     # transport_options
     attr_reader transport_options: Hash[untyped, untyped]?
     def transport_options=: (Hash[untyped, untyped]) -> void
-    def with_transport_options: (Hash[untyped, untyped]) -> instance
+
+    # addresses
+    attr_reader addresses: _ToAry[untyped]?
+    def addresses=: (_ToAry[untyped]) -> void
 
     # params
     attr_reader params: Transcoder::urlencoded_input?
     def params=: (Transcoder::urlencoded_input) -> void
-    def with_params: (Transcoder::urlencoded_input) -> instance
 
     # form
     attr_reader form: Transcoder::urlencoded_input?
     def form=: (Transcoder::urlencoded_input) -> void
-    def with_form: (Transcoder::urlencoded_input) -> instance
 
     # json
     attr_reader json: _ToJson?
     def json=: (_ToJson) -> void
-    def with_json: (_ToJson) -> instance
 
     # body
     attr_reader body: bodyIO?
     def body=: (bodyIO) -> void
-    def with_body: (bodyIO) -> instance
 
     # ssl
 
@@ -79,32 +71,27 @@ module HTTPX
     # request_class
     attr_reader request_class: singleton(Request)
     def request_class=: (singleton(Request)) -> void
-    def with_request_class: (singleton(Request)) -> instance
 
     # io
-    attr_reader io: _ToIO?
-    def io=: (_ToIO) -> void
-    def with_io: (_ToIO) -> instance
+    type io_option = _ToIO | Hash[String, _ToIO]
+    attr_reader io: io_option?
+    def io=: (io_option) -> void
 
     # fallback_protocol
     attr_reader fallback_protocol: String?
     def fallback_protocol=: (String) -> void
-    def with_fallback_protocol: (String) -> instance
 
     # debug
     attr_reader debug: _IOLogger?
     def debug=: (_IOLogger) -> void
-    def with_debug: (_IOLogger) -> instance
 
     # debug_level
     attr_reader debug_level: Integer?
     def debug_level=: (Integer) -> void
-    def with_debug_level: (Integer) -> instance
 
     # persistent
     attr_reader persistent: bool?
     def persistent=: (bool) -> void
-    def with_persistent: (bool) -> instance
 
     def ==: (untyped other) -> bool
     def merge: (_ToHash other) -> instance

data/sig/plugins/aws_sigv4.rbs

@@ -43,7 +43,6 @@ module HTTPX
       interface _SigV4Options
         def sigv4_signer: () -> Signer?
         def sigv4_signer=: (Signer) -> Signer
-        def with_sigv4_signer: (Signer) -> instance
       end
 
       def self.extra_options: (Options) -> (Options & _SigV4Options)

data/sig/plugins/compression.rbs

@@ -1,7 +1,7 @@
 module HTTPX
   module Plugins
     module Compression
-      extend Registry[Symbol, Class]
+      type encodings_registry = Registry[Symbol, Class]
 
       type deflatable = _Reader | _ToS
 
@@ -16,12 +16,14 @@ module HTTPX
         def initialize: (Numeric bytesize) -> untyped
       end
        
-      def self.load_dependencies: (singleton(Session)) -> void
+      def self.configure: (singleton(Session)) -> void
 
       interface _CompressionOptions
         def compression_threshold_size: () -> _Integer?
         def compression_threshold_size=: (int) -> int
-        def with_compression_threshold_size: (int) -> instance
+
+        def encodings: () -> encodings_registry?
+        def encodings=: (encodings_registry) -> encodings_registry
       end
  
       def self.extra_options: (Options) -> (Options & _CompressionOptions)

data/sig/plugins/compression/brotli.rbs

@@ -3,7 +3,7 @@ module HTTPX
     module Compression
       module Brotli
         def self.load_dependencies: (singleton(Session)) -> void
-        def self.configure: (*untyped) -> void
+        def self.configure: (singleton(Session)) -> void
 
         def self?.deflater: () -> _Deflater
         def self?.decoder: (Numeric bytesize) -> Inflater

data/sig/plugins/compression/deflate.rbs

@@ -3,7 +3,7 @@ module HTTPX
     module Compression
       module Deflate
         def self.load_dependencies: (singleton(Session)) -> void
-        def self.configure: (*untyped) -> void
+        def self.configure: (singleton(Session)) -> void
 
         def self?.deflater: () -> _Deflater
         def self?.inflater: (Numeric bytesize) -> GZIP::Inflater

data/sig/plugins/compression/gzip.rbs

@@ -3,7 +3,7 @@ module HTTPX
     module Compression
       module GZIP
         def self.load_dependencies: (singleton(Session)) -> void
-        def self.configure: (*untyped) -> void
+        def self.configure: (singleton(Session)) -> void
 
         def self?.deflater: () -> _Deflater
         def self?.inflater: (Numeric bytesize) -> Inflater

data/sig/plugins/cookies.rbs

@@ -6,7 +6,6 @@ module HTTPX
       interface _CookieOptions
         def cookies: () -> Jar?
         def cookies=: (jar) -> Jar
-        def with_cookies: (jar) -> instance
       end
  
       def self.extra_options: (Options) -> (Options & _CookieOptions)

data/sig/plugins/digest_authentication.rbs

@@ -6,7 +6,6 @@ module HTTPX
       interface _DigestOptions
         def digest: () -> Digest?
         def digest=: (Digest) -> Digest
-        def with_digest: (Digest) -> instance
       end
  
       def self.extra_options: (Options) -> (Options & _DigestOptions)

data/sig/plugins/expect.rbs

@@ -6,11 +6,9 @@ module HTTPX
       interface _ExpectOptions
         def expect_timeout: () -> Integer?
         def expect_timeout=: (int) -> Integer
-        def with_expect_timeout: (int) -> instance
 
         def expect_threshold_size: () -> Integer?
         def expect_threshold_size=: (int) -> Integer
-        def with_expect_threshold_size: (int) -> instance
       end
  
       def self.extra_options: (Options) -> (Options & _ExpectOptions)

data/sig/plugins/follow_redirects.rbs

@@ -9,11 +9,9 @@ module HTTPX
       interface _FollowRedirectsOptions
         def max_redirects: () -> Integer?
         def max_redirects=: (int) -> Integer
-        def with_max_redirects: (int) -> instance
 
         def follow_insecure_redirects: () -> bool?
         def follow_insecure_redirects=: (bool) -> bool
-        def with_follow_insecure_redirects: (bool) -> instance
       end
  
       def self.extra_options: (Options) -> (Options & _FollowRedirectsOptions)

data/sig/plugins/h2c.rbs

@@ -1,23 +1,18 @@
 module HTTPX
   module Plugins
     module H2C
-      def self.load_dependencies: (singleton(Session)) -> void
-      
-      module InstanceMethods
-        VALID_H2C_METHODS: Array[Symbol]
-        
-        private
+      VALID_H2C_VERBS: Array[Symbol]
 
-        def valid_h2c_upgrade_request: (Request) -> bool
-        def valid_h2c_upgrade?: (Request, Response, Options) -> bool
-      end
+      def self.load_dependencies: (*untyped) -> void
+      def self.configure: (singleton(Session)) -> void
+      def self.call: (Connection, Request, response) -> void
 
       class H2CParser < Connection::HTTP2
         def upgrade: (Request, Response) -> void
       end
 
       module ConnectionMethods
-        def upgrade: (Request, Response) -> void
+        def upgrade_to_h2c: (Request, Response) -> void
       end
     end
 

data/sig/plugins/persistent.rbs

@@ -6,7 +6,6 @@ module HTTPX
       interface _PersistentOptions
         def persistent: () -> bool?
         def persistent=: (bool) -> bool
-        def with_persistent: (bool) -> instance
       end
  
       def self.extra_options: (Options) -> (Options & _PersistentOptions)

data/sig/plugins/proxy.rbs

@@ -28,7 +28,6 @@ module HTTPX
       interface _ProxyOptions
         def proxy: () -> proxyParam?
         def proxy=: (Parameters | _ToHash) -> proxyParam
-        def with_proxy: (Parameters | _ToHash) -> instance
       end
  
       def self.extra_options: (Options) -> (Options & _ProxyOptions)

data/sig/plugins/retries.rbs

@@ -12,19 +12,15 @@ module HTTPX
       interface _RetriesOptions
         def retry_after: () -> Numeric?
         def retry_after=: (Numeric) -> Numeric
-        def with_retry_after: (Numeric) -> instance
 
         def max_retries: () -> Integer?
         def max_retries=: (int) -> Integer
-        def with_max_retries: (int) -> instance
 
         def retry_change_requests: () -> bool?
         def retry_change_requests=: (bool) -> bool
-        def with_retry_change_requests: (bool) -> instance
 
         def retry_on: () -> _RetryCallback?
         def retry_on=: (_RetryCallback) -> _RetryCallback
-        def with_retry_on: (_RetryCallback) -> instance
       end
  
       def self.extra_options: (Options) -> (Options & _RetriesOptions)

data/sig/plugins/upgrade.rbs

@@ -0,0 +1,23 @@
+module HTTPX
+  module Plugins
+    module Upgrade
+      type handlers_registry = Registry[Symbol, Class]
+
+      def self.configure: (singleton(Session)) -> void
+
+      interface _UpgradeOptions
+        def upgrade_handlers: () -> handlers_registry?
+        def upgrade_handlers=: (handlers_registry) -> handlers_registry
+      end
+ 
+      def self.extra_options: (Options) -> (Options & _UpgradeOptions)
+
+      module ConnectionMethods
+        attr_reader upgrade_protocol: Symbol?
+        attr_reader hijacked: boolish
+
+        def hijack_io: () -> void
+      end
+    end      
+  end
+end