httpx 1.7.7 → 1.8.0

data/lib/httpx/response/body.rb

@@ -20,10 +20,10 @@ module HTTPX
       @headers = response.headers
       @options = options
       @window_size = options.window_size
+      @max_response_body_size = options.max_response_body_size
       @encodings = []
       @length = 0
-      @buffer = nil
-      @reader = nil
+      @buffer = @reader = nil
       @state = :idle
 
       # initialize response encoding
@@ -59,6 +59,8 @@ module HTTPX
 
       chunk = decode_chunk(chunk)
 
+      raise Error, "maximum response body size exceeded" if @max_response_body_size < @length
+
       transition(:open)
       @buffer.write(chunk)
 

data/lib/httpx/response.rb

@@ -68,7 +68,7 @@ module HTTPX
       @headers = @options.headers_class.new(headers)
       @body = @options.response_body_class.new(self, @options)
       @finished = complete?
-      @content_type = nil
+      @content_type = @content_length = nil
     end
 
     # dupped initialization
@@ -88,6 +88,7 @@ module HTTPX
     # merges headers defined in +h+ into the response headers.
     def merge_headers(h)
       @headers = @headers.merge(h)
+      @content_type = @content_length = nil
     end
 
     # writes +data+ chunk into the response body.
@@ -103,6 +104,13 @@ module HTTPX
       @content_type ||= ContentType.new(@headers["content-type"])
     end
 
+    # returns the response content length as advertised in the HTTP Content-Length header value.
+    def content_length
+      return @content_length if defined?(@content_length)
+
+      @content_length = @headers["content-length"]&.to_i
+    end
+
     # returns whether the response has been fully fetched.
     def finished?
       @finished

data/lib/httpx/selector.rb

@@ -134,7 +134,13 @@ module HTTPX
       # the connections to be reaped (such as the total timeout error) before #select
       # gets called.
       if @selectables.empty?
-        sleep(interval) if interval
+        begin
+          sleep(interval)
+        rescue IOError
+          # @fiber-switch-guard
+          # in a fiber scheduler scenario, IOs may be closed by the scheduler and raised in a separate fiber
+          # on wakeup, which includes a sleep call.
+        end if interval
         return
       end
 

data/lib/httpx/version.rb

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

data/sig/chainable.rbs

@@ -16,6 +16,7 @@ module HTTPX
               | (:basic_auth, ?options) -> Plugins::sessionBasicAuth
               | (:digest_auth, ?options) -> Plugins::sessionDigestAuth
               | (:ntlm_auth, ?options) -> Plugins::sessionNTLMAuth
+              | (:ntlm_v2_auth, ?options) -> Plugins::sessionNTLMV2Auth
               | (:aws_sdk_authentication, ?options) -> Plugins::sessionAwsSdkAuthentication
               | (:brotli, ?options) -> Session
               | (:cookies, ?options) -> Plugins::sessionCookies
@@ -32,8 +33,10 @@ module HTTPX
               | (:rate_limiter, ?options) -> Plugins::sessionRateLimiter
               | (:stream, ?options) -> Plugins::sessionStream
               | (:stream_bidi, ?options) -> Plugins::sessionStreamBidi
+              | (:server_sent_events, ?options) -> Plugins::sessionServerSentEvents
               | (:aws_sigv4, ?options) -> Plugins::awsSigV4Session
               | (:grpc, ?options) -> Plugins::grpcSession
+              | (:cache, ?options) -> Plugins::sessionCache
               | (:response_cache, ?options) -> Plugins::sessionResponseCache
               | (:circuit_breaker, ?options) -> Plugins::sessionCircuitBreaker
               | (:oauth, ?options) -> Plugins::sessionOAuth

data/sig/connection/http1.rbs

@@ -58,7 +58,7 @@ module HTTPX
 
     def waiting_for_ping?: () -> bool
 
-    def timeout: () -> Numeric?
+    def timeout: () -> interval?
 
     private
 

data/sig/connection/http2.rbs

@@ -42,7 +42,7 @@ module HTTPX
 
     alias reset init_connection
 
-    def timeout: () -> Numeric?
+    def timeout: () -> interval?
 
     def reset_requests: () -> void
 

data/sig/connection.rbs

@@ -38,9 +38,9 @@ module HTTPX
     @write_buffer: Buffer
     @inflight: Integer
     @max_concurrent_requests: Integer?
-    @keep_alive_timeout: Numeric?
-    @timeout: Numeric?
-    @current_timeout: Numeric?
+    @keep_alive_timeout: interval?
+    @timeout: interval?
+    @current_timeout: interval?
     @parser: Object & _Parser
     @connected_at: Float
     @response_received_at: Float
@@ -51,6 +51,7 @@ module HTTPX
     @sibling: instance?
     @main_sibling: bool
     @no_more_requests_counter: Integer
+    @ping_timer: Timers::Timer?
 
 
     def addresses: () -> Array[Resolver::Entry]?
@@ -101,7 +102,7 @@ module HTTPX
 
     def reset: () -> void
 
-    def timeout: () -> Numeric?
+    def timeout: () -> interval?
 
     def idling: () -> void
 
@@ -111,7 +112,7 @@ module HTTPX
 
     def open?: () -> bool
 
-    def handle_socket_timeout: (Numeric interval) -> void
+    def handle_socket_timeout: (interval interval) -> void
 
     def sibling=: (instance? connection) -> void
 
@@ -157,7 +158,7 @@ module HTTPX
 
     def build_socket: (?Array[Resolver::Entry]? addrs) -> (TCP | SSL | UNIX)
 
-    def ping: () -> void
+    def ping: (Request request) -> void
 
     def pong: () -> void
 
@@ -179,11 +180,13 @@ module HTTPX
 
     def set_request_request_timeout: (Request request) -> void
 
+    def set_request_total_request_timeout: (Request request) -> void
+
     def write_timeout_callback: (Request request, Numeric timeout) -> void
 
-    def read_timeout_callback: (Request request, Numeric timeout, ?singleton(RequestTimeoutError) error_type) -> void
+    def read_timeout_callback: (Request request, interval timeout, ?singleton(RequestTimeoutError) error_type) -> void
 
-    def set_request_timeout: (Symbol label, Request request, Numeric timeout, Symbol start_event, Symbol | Array[Symbol] finish_events) { () -> void } -> void
+    def set_request_timeout: (Symbol label, Request request, interval timeout, Symbol start_event, Symbol | Array[Symbol] finish_events) { () -> void } -> void
 
     def parser_type: (String protocol) -> (singleton(HTTP1) | singleton(HTTP2))
   end

data/sig/errors.rbs

@@ -9,12 +9,12 @@ module HTTPX
   end
 
   class TimeoutError < Error
-    attr_reader timeout: Numeric
+    attr_reader timeout: interval
 
     def to_connection_error: () -> ConnectTimeoutError
     private
 
-    def initialize: (Numeric timeout, String message) -> untyped
+    def initialize: (interval timeout, String message) -> untyped
   end
 
   class PoolTimeoutError < TimeoutError
@@ -33,7 +33,7 @@ module HTTPX
     attr_reader request: Request
     attr_reader response: response?
 
-    def initialize: (Request request, response? response, Numeric timeout) -> void
+    def initialize: (Request request, response? response, interval timeout) -> void
   end
 
   class ReadTimeoutError < RequestTimeoutError
@@ -42,9 +42,15 @@ module HTTPX
   class WriteTimeoutError < RequestTimeoutError
   end
 
+  class TotalRequestTimeoutError < RequestTimeoutError
+  end
+
   class OperationTimeoutError < TimeoutError
   end
 
+  class PingTimeoutError < TimeoutError
+  end
+
   class ResolveError < Error
   end
 

data/sig/httpx.rbs

@@ -10,6 +10,8 @@ module HTTPX
   type uri = http_uri | string
   type generic_uri = String | URI::Generic
 
+  type interval = Numeric & _ToF & Time::_Timeout?
+
   type verb = String
 
   type request_params = Hash[Symbol, untyped]

data/sig/io/tcp.rbs

@@ -52,6 +52,8 @@ module HTTPX
 
     def close: () -> void
 
+    def can_disconnect?: () -> bool
+
     def connected?: () -> bool
 
     def closed?: () -> bool

data/sig/loggable.rbs

@@ -3,6 +3,10 @@ module HTTPX
     def <<: (string?) -> void
   end
 
+  interface _Loggable
+    def log: (?level: Integer?, ?color: Symbol?, ?debug_level: Integer, ?debug: _IOLogger?) { () -> String } -> void
+  end
+
   module Loggable
     USE_DEBUG_LOG: bool
 

data/sig/options.rbs

@@ -2,6 +2,8 @@ module HTTPX
   class Options
     # include _ToHash
 
+    type maybe_unbounded = Integer | Float # because infinity
+
     BUFFER_SIZE: Integer
     WINDOW_SIZE: Integer
     MAX_BODY_THRESHOLD_SIZE: Integer
@@ -9,8 +11,10 @@ module HTTPX
     READ_TIMEOUT: Integer
     WRITE_TIMEOUT: Integer
     REQUEST_TIMEOUT: Integer
+    TOTAL_REQUEST_TIMEOUT: Integer
     OPERATION_TIMEOUT: Integer
     KEEP_ALIVE_TIMEOUT: Integer
+    PING_TIMEOUT: Integer
     SETTINGS_TIMEOUT: Integer
     CLOSE_HANDSHAKE_TIMEOUT: Integer
     SET_TEMPORARY_NAME: ^(Class klass, ?Symbol pl) -> void
@@ -21,8 +25,8 @@ module HTTPX
     RESOLVER_TYPES: Array[Symbol]
     USER_AGENT: String
 
-    type timeout_type = :connect_timeout | :settings_timeout | :close_handshake_timeout | :operation_timeout | :keep_alive_timeout | :read_timeout | :write_timeout | :request_timeout
-    type timeout = Hash[timeout_type, Numeric?]
+    type timeout_type = :connect_timeout | :settings_timeout | :close_handshake_timeout | :operation_timeout | :keep_alive_timeout | :read_timeout | :write_timeout | :total_request_timeout | :request_timeout | :ping_timeout
+    type timeout = Hash[timeout_type, interval?]
     type redact_value = :headers | :body | bool
     type resolver_cache_option = :memory | :file | (Object & Resolver::_Cache)
 
@@ -43,10 +47,10 @@ module HTTPX
     attr_reader http2_settings: Hash[Symbol, Integer | bool]
 
     # max_concurrent_requests
-    attr_reader max_concurrent_requests: Integer?
+    attr_reader max_concurrent_requests: maybe_unbounded?
 
     # max_requests
-    attr_reader max_requests: Numeric?
+    attr_reader max_requests: maybe_unbounded?
 
     # window_size
     attr_reader window_size: Integer
@@ -57,6 +61,15 @@ module HTTPX
     # body_threshold_size
     attr_reader body_threshold_size: Integer
 
+    # max_response_headers
+    attr_reader max_response_headers: Integer
+
+    # max_response_header_value_size
+    attr_reader max_response_header_value_size: maybe_unbounded?
+
+    # max_response_body_size
+    attr_reader max_response_body_size: maybe_unbounded
+
     # transport
     attr_reader transport: io_type | nil
 
@@ -164,12 +177,12 @@ module HTTPX
     def access_option: (Hash[Symbol, untyped] | Object | nil obj, Symbol k, Hash[Symbol, Symbol]? ivar_map) -> untyped
 
     # integer
-    def option_max_concurrent_requests: (Numeric value) -> Numeric
-    def option_max_requests: (Numeric value) -> Numeric
-    def option_window_size: (Numeric value) -> Numeric
-    def option_buffer_size: (Numeric value) -> Numeric
-    def option_body_threshold_size: (Numeric value) -> Numeric
-    def option_debug_level: (Numeric value) -> Numeric
+    def option_max_concurrent_requests: (int value) -> maybe_unbounded
+    def option_max_requests: (int value) -> maybe_unbounded
+    def option_window_size: (int value) -> Integer
+    def option_buffer_size: (int value) -> Integer
+    def option_body_threshold_size: (int value) -> Integer
+    def option_debug_level: (int value) -> Integer
 
     # to hash
     def option_ssl: (_ToHash[Symbol, untyped] value) -> Hash[Symbol, untyped]
@@ -186,7 +199,7 @@ module HTTPX
     def option_connection_class: (singleton(Connection) value) -> singleton(Connection)
     def option_options_class: (singleton(Options) value) -> singleton(Options)
     def option_pool_class: (singleton(Pool) value) -> singleton(Pool)
-    def option_resolver_class: (Symbol | singleton(Resolver::Resolver) value) -> (Symbol | singleton(Resolver::Resolver))
+    def option_resolver_class: (Symbol | resolver_type value) -> (Symbol | resolver_type)
     def option_io: (io_option value) -> io_option
     def option_fallback_protocol: (String value) -> String
     def option_debug: (_IOLogger value) -> _IOLogger
@@ -204,7 +217,7 @@ module HTTPX
 
     def option_headers: (headers_input | Headers value) -> Headers
 
-    def option_timeout: (_ToHash[timeout_type, Numeric?]) -> timeout
+    def option_timeout: (_ToHash[timeout_type, interval?]) -> timeout
 
     def option_supported_compression_formats: (_ToS | _ToAry[_ToS] value) -> Array[String]
 

data/sig/parser/http1.rbs

@@ -28,6 +28,8 @@ module HTTPX
       @content_length: Integer
       @_has_trailers: bool
       @upgrade: bool
+      @max_headers: Options::maybe_unbounded
+      @max_header_value_size: Options::maybe_unbounded?
 
       def <<: (string chunk) -> void
 
@@ -39,7 +41,7 @@ module HTTPX
 
       private
 
-      def initialize: (_HTTP1Events observer) -> untyped
+      def initialize: (_HTTP1Events observer, Options::maybe_unbounded max_headers, Options::maybe_unbounded? max_header_value_size) -> void
 
       def nextstate: (Symbol state) -> void
 

data/sig/plugins/auth/ntlm.rbs

@@ -10,7 +10,7 @@ module HTTPX
 
         def authenticate: (Request request, String authenticate) -> String
 
-        def negotiate: () -> void
+        def negotiate: () -> String
 
         private
 

data/sig/plugins/{response_cache → cache}/file_store.rbs

@@ -1,12 +1,12 @@
 module HTTPX
   module Plugins
-    module ResponseCache
+    module Cache
       class FileStore
         CRLF: String
 
         @dir: Pathname
 
-        include _ResponseCacheStore
+        include _CacheStore
 
         def initialize: (?path dir) -> void
 

data/sig/plugins/{response_cache → cache}/store.rbs

@@ -1,12 +1,12 @@
 module HTTPX
   module Plugins
-    module ResponseCache
+    module Cache
       class Store
         @store: Hash[String, cacheResponse]
 
         @store_mutex: Thread::Mutex
 
-        include _ResponseCacheStore
+        include _CacheStore
       end
     end
   end

data/sig/plugins/cache.rbs

@@ -0,0 +1,69 @@
+module HTTPX
+  module Plugins
+    module Cache
+      interface _CacheStore
+        def get: (cacheRequest request) -> cacheResponse?
+
+        def set: (cacheRequest request, cacheResponse response) -> void
+
+        def clear: () -> void
+      end
+
+      interface _CacheOptions
+        def cache_key: () -> String?
+
+        def cacheable_request: () -> ^(cacheRequest request) -> boolish
+
+        def cacheable_response: () -> ^(cacheRequest request, cacheResponse response) -> boolish
+
+        def valid_cached_response: () -> ^(cacheRequest request, cacheResponse response) -> boolish
+
+         def response_cache_store: () -> Store
+      end
+
+      module InstanceMethods
+        def clear_response_cache: () -> void
+
+        private
+
+        def cacheable_request?: (cacheRequest request) -> boolish
+
+        def cacheable_response?: (cacheRequest request, cacheResponse response) -> boolish
+
+        def valid_cached_response?: (cacheRequest request, cacheResponse cached_response) -> boolish
+
+        def prepare_cache: (cacheRequest request) -> void
+
+        def retrieve_cached_response: (cacheRequest request) -> cacheResponse?
+      end
+
+      module RequestMethods
+        attr_accessor cached_response: cacheResponse?
+        attr_reader options: cacheOptions
+
+        def response_cache_key: () -> String?
+      end
+
+      module ResponseMethods
+        attr_writer original_request: cacheRequest
+
+        @cached: bool
+
+        def original_request: () -> cacheRequest?
+
+        def cached?: () -> bool
+
+        def mark_as_cached!: () -> void
+      end
+
+
+      type cacheOptions = Options & _CacheOptions
+
+      type cacheRequest = Request & RequestMethods
+
+      type cacheResponse = Response & ResponseMethods
+    end
+
+    type sessionCache = Session & Cache::InstanceMethods
+  end
+end

data/sig/plugins/fiber_concurrency.rbs

@@ -17,6 +17,10 @@ module HTTPX
         def current_context?: () -> boolish
 
         def send: (request request) -> void
+
+        private
+
+        def backlog?: () -> bool
       end
 
       module HTTP1Methods

data/sig/plugins/ntlm_v2_auth.rbs

@@ -0,0 +1,36 @@
+module HTTPX
+  module Plugins
+    module NTLMV2Auth
+      class Authenticator
+        @user: String
+        @password: String
+        @domain: String?
+
+        def can_authenticate?: (String? www_authenticate) -> boolish
+
+        def authenticate: (Request request, String authenticate) -> String
+
+        def negotiate: () -> String
+
+        private
+
+        def initialize: (string user, string password, ?domain: String?) -> void
+      end
+
+      interface _NTLMV2Options
+        def ntlm: () -> Authentication?
+      end
+
+      def self.extra_options: (Options) -> (Options & _NTLMV2Options)
+
+      def self.load_dependencies: (singleton(Session) klass) -> void
+
+      module InstanceMethods
+        def ntlm_auth: (string user, string password, ?string? domain) -> instance
+      end
+
+    end
+
+    type sessionNTLMV2Auth = sessionAuth & NTLMV2Auth::InstanceMethods
+  end
+end

data/sig/plugins/response_cache.rbs

@@ -5,72 +5,47 @@ module HTTPX
       CACHEABLE_STATUS_CODES: Array[Integer]
       SUPPORTED_VARY_HEADERS: Array[String]
 
-      def self?.cacheable_response?: (::HTTPX::ErrorResponse | cacheResponse response) -> bool
+      def self?.cacheable_response?: (::HTTPX::ErrorResponse | responseCacheResponse response) -> bool
 
       def self?.not_modified?: (response response) -> bool
 
       interface _ResponseCacheOptions
-        def response_cache_store: () -> Store
-
         def supported_vary_headers: () -> Array[String]
       end
 
-      interface _ResponseCacheStore
-        def get: (cacheRequest request) -> cacheResponse?
-
-        def set: (cacheRequest request, cacheResponse response) -> void
-
-        def clear: () -> void
-      end
-
       module InstanceMethods
-        @response_cache: Store
-
-        def clear_response_cache: () -> void
-
         private
 
-        def prepare_cache: (cacheRequest request) -> void
-
-        def cacheable_request?: (cacheRequest request) -> bool
-
-        def match_by_vary?: (cacheRequest request, cacheResponse response) -> bool
+        def match_by_vary?: (responseCacheRequest request, responseCacheResponse response) -> bool
       end
 
       module RequestMethods
-        attr_accessor cached_response: cacheResponse?
-        attr_reader options: cacheOptions
+        attr_accessor cached_response: responseCacheResponse?
+        attr_reader options: responseCacheOptions
 
         @response_cache_key: String
 
-        def response_cache_key: () -> String
+        private
 
         def cacheable_verb?: () -> bool
       end
 
       module ResponseMethods
-        attr_writer original_request: cacheRequest
-
         attr_writer revalidated_at: Time
 
-        @cached: bool
         @cache_control: Array[String]?
-        @vary: Array[String]?
-        @date: Time?
-
-        def original_request: () -> cacheRequest?
 
-        def cached?: () -> bool
+        @vary: Array[String]?
 
-        def mark_as_cached!: () -> void
+        @date: Time?
 
         def copy_from_cached!: () -> void
 
         def fresh?: () -> bool
 
-         %a{pure} def cache_control: () -> Array[String]?
+        %a{pure} def cache_control: () -> Array[String]?
 
-         %a{pure} def vary: () -> Array[String]?
+        %a{pure} def vary: () -> Array[String]?
 
         private
 
@@ -80,13 +55,13 @@ module HTTPX
       end
 
 
-      type cacheOptions = Options & _ResponseCacheOptions
+      type responseCacheOptions = Options & Cache::_CacheOptions & _ResponseCacheOptions
 
-      type cacheRequest = Request & RequestMethods
+      type responseCacheRequest = Request & Cache::RequestMethods & RequestMethods
 
-      type cacheResponse = Response & ResponseMethods
+      type responseCacheResponse = Response & Cache::ResponseMethods & ResponseMethods
     end
 
-    type sessionResponseCache = Session & ResponseCache::InstanceMethods
+    type sessionResponseCache = Session & Cache::InstanceMethods & ResponseCache::InstanceMethods
   end
 end

data/sig/plugins/retries.rbs

@@ -5,21 +5,21 @@ module HTTPX
       IDEMPOTENT_METHODS: Array[String]
       RECONNECTABLE_ERRORS: Array[singleton(StandardError)]
       RETRYABLE_ERRORS: Array[singleton(StandardError)]
-      DEFAULT_JITTER: ^(Numeric) -> Numeric
+      DEFAULT_JITTER: ^(interval) -> interval
       BACKOFF_ALGORITHMS: Array[Symbol]
 
-      def self?.retry_after_polynomial_backoff: (retriesRequest request, retriesResponse response) -> Numeric
+      def self?.retry_after_polynomial_backoff: (retriesRequest request, retriesResponse response) -> interval
 
-      def self?.retry_after_exponential_backoff: (retriesRequest request, retriesResponse response) -> Numeric
+      def self?.retry_after_exponential_backoff: (retriesRequest request, retriesResponse response) -> interval
 
       interface _RetryCallback
         def call: (retriesResponse response) -> bool?
       end
 
       interface _RetriesOptions
-        def retry_after: () -> (^(retriesRequest request, retriesResponse response) -> Numeric | Numeric)?
+        def retry_after: () -> (^(retriesRequest request, retriesResponse response) -> interval | interval)?
 
-        def retry_jitter: () -> ^(Numeric jitter) -> Numeric
+        def retry_jitter: () -> ^(interval jitter) -> interval
 
         def max_retries: () -> Integer