httpx 0.20.0 → 1.3.1

data/lib/httpx.rb

@@ -11,7 +11,6 @@ require "httpx/domain_name"
 require "httpx/altsvc"
 require "httpx/callbacks"
 require "httpx/loggable"
-require "httpx/registry"
 require "httpx/transcoder"
 require "httpx/timers"
 require "httpx/pool"
@@ -21,7 +20,6 @@ require "httpx/response"
 require "httpx/options"
 require "httpx/chainable"
 
-require "mutex_m"
 # Top-Level Namespace
 #
 module HTTPX
@@ -32,16 +30,17 @@ module HTTPX
   #
   module Plugins
     @plugins = {}
-    @plugins.extend(Mutex_m)
+    @plugins_mutex = Thread::Mutex.new
 
     # Loads a plugin based on a name. If the plugin hasn't been loaded, tries to load
     # it from the load path under "httpx/plugins/" directory.
     #
     def self.load_plugin(name)
       h = @plugins
-      unless (plugin = h.synchronize { h[name] })
+      m = @plugins_mutex
+      unless (plugin = m.synchronize { h[name] })
         require "httpx/plugins/#{name}"
-        raise "Plugin #{name} hasn't been registered" unless (plugin = h.synchronize { h[name] })
+        raise "Plugin #{name} hasn't been registered" unless (plugin = m.synchronize { h[name] })
       end
       plugin
     end
@@ -50,20 +49,19 @@ module HTTPX
     #
     def self.register_plugin(name, mod)
       h = @plugins
-      h.synchronize { h[name] = mod }
+      m = @plugins_mutex
+      m.synchronize { h[name] = mod }
     end
   end
 
-  # :nocov:
-  def self.const_missing(const_name)
-    super unless const_name == :Client
-    warn "DEPRECATION WARNING: the class #{self}::Client is deprecated. Use #{self}::Session instead."
-    Session
-  end
-  # :nocov:
-
   extend Chainable
 end
 
 require "httpx/session"
 require "httpx/session_extensions"
+
+# load integrations when possible
+
+require "httpx/adapters/datadog" if defined?(DDTrace) || defined?(Datadog)
+require "httpx/adapters/sentry" if defined?(Sentry)
+require "httpx/adapters/webmock" if defined?(WebMock)

data/sig/altsvc.rbs

@@ -0,0 +1,33 @@
+module HTTPX
+  module AltSvc
+    module ConnectionMixin
+
+      def send: (Request request) -> void
+
+      def match?: (URI::Generic uri, Options options) -> bool
+
+      private
+
+      def match_altsvcs?: (URI::Generic uri) -> bool
+
+      def match_altsvc_options?: (URI::Generic uri, Options options) -> bool
+    end
+
+    type altsvc_params = Hash[String, untyped]
+
+    def self?.cached_altsvc: (String origin) -> Array[altsvc_params]
+
+    def self?.cached_altsvc_set: (String origin, altsvc_params) -> void
+
+    def self?.lookup: (String origin, Integer | Float ttl) -> Array[altsvc_params]
+
+    def self?.emit: (Request request, response response) { (http_uri alt_origin, String origin, altsvc_params alt_params) -> void } -> void
+
+    def self?.parse: (String altsvc) { (http_uri alt_origin, altsvc_params alt_params) -> void } -> void
+                   | (String altsvc) -> Enumerable[[http_uri, altsvc_params]]
+
+    def self?.parse_altsvc_scheme: (String alt_proto) -> String?
+
+    def self.parse_altsvc_origin: (string alt_proto, String alt_origin) -> http_uri?
+  end
+end

data/sig/buffer.rbs

@@ -11,11 +11,12 @@ module HTTPX
 
     def full?: () -> bool
     def shift!: (Integer) -> void
+    def capacity: () -> Integer
 
     # delegated
     def <<: (string data) -> String
     def empty?: () -> bool
-    def bytesize: () -> Integer
+    def bytesize: () -> (Integer | Float)
     def clear: () -> void
     def replace: (string) -> void
 

data/sig/callbacks.rbs

@@ -4,9 +4,9 @@ module HTTPX
   end
 
   module Callbacks
-    def on: (Symbol) { (*untyped) -> void } -> void
-    def once: (Symbol) { (*untyped) -> void } -> void
-    def only: (Symbol) { (*untyped) -> void } -> void
+    def on: (Symbol) { (*untyped) -> void } -> self
+    def once: (Symbol) { (*untyped) -> void } -> self
+    def only: (Symbol) { (*untyped) -> void } -> self
     def emit: (Symbol, *untyped) -> void
 
     def callbacks_for?: (Symbol) -> bool

data/sig/chainable.rbs

@@ -2,9 +2,9 @@ module HTTPX
   module Chainable
     def request: (*Request, **untyped) -> Array[response]
                | (Request, **untyped) -> response
-               | (verb | string, uri | [uri], **untyped) -> response
-               | (Array[[verb | string, uri] | [verb | string, uri, options]], **untyped) -> Array[response]
-               | (verb | string, _Each[uri | [uri, options]], **untyped) -> Array[response]
+               | (verb, uri | [uri], **untyped) -> response
+               | (Array[[verb, uri] | [verb, uri, request_params]], **untyped) -> Array[response]
+               | (verb, _Each[uri | [uri, request_params]], **untyped) -> Array[response]
 
     def accept: (String) -> Session
     def wrap: () { (Session) -> void } -> void
@@ -12,18 +12,17 @@ module HTTPX
     def with: (options) -> Session
             | (options) { (Session) -> void } -> void
 
-    def plugin: (:authentication, ?options) -> Plugins::sessionAuthentication
-              | (:basic_authentication, ?options) -> Plugins::sessionBasicAuth
-              | (:digest_authentication, ?options) -> Plugins::sessionDigestAuth
-              | (:ntlm_authentication, ?options) -> Plugins::sessionNTLMAuth
+    def plugin: (:auth, ?options) -> Plugins::sessionAuthorization
+              | (:basic_auth, ?options) -> Plugins::sessionBasicAuth
+              | (:digest_auth, ?options) -> Plugins::sessionDigestAuth
+              | (:ntlm_auth, ?options) -> Plugins::sessionNTLMAuth
               | (:aws_sdk_authentication, ?options) -> Plugins::sessionAwsSdkAuthentication
-              | (:compression, ?options) -> Session
+              | (:brotli, ?options) -> Session
               | (:cookies, ?options) -> Plugins::sessionCookies
               | (:expect, ?options) -> Session
               | (:follow_redirects, ?options) -> Plugins::sessionFollowRedirects
               | (:upgrade, ?options) -> Session
               | (:h2c, ?options) -> Session
-              | (:multipart, ?options) -> Session
               | (:persistent, ?options) -> Plugins::sessionPersistent
               | (:proxy, ?options) -> (Plugins::sessionProxy & Plugins::httpProxy)
               | (:push_promise, ?options) -> Plugins::sessionPushPromise
@@ -33,6 +32,9 @@ module HTTPX
               | (:aws_sigv4, ?options) -> Plugins::awsSigV4Session
               | (:grpc, ?options) -> Plugins::grpcSession
               | (:response_cache, ?options) -> Plugins::sessionResponseCache
+              | (:circuit_breaker, ?options) -> Plugins::sessionCircuitBreaker
+              | (:oauth, ?options) -> Plugins::sessionOAuth
+              | (:callbacks, ?options) -> Plugins::sessionCallbacks
               | (Symbol | Module, ?options) { (Class) -> void } -> Session
               | (Symbol | Module, ?options) -> Session
 

data/sig/connection/http1.rbs

@@ -10,8 +10,9 @@ module HTTPX
     attr_reader pending: Array[Request]
     attr_reader requests: Array[Request]
 
+    attr_accessor max_concurrent_requests: Integer
+
     @options: Options
-    @max_concurrent_requests: Integer
     @max_requests: Integer
     @parser: Parser::HTTP1
     @buffer: Buffer
@@ -31,13 +32,13 @@ module HTTPX
 
     def exhausted?: () -> bool
 
-    def <<: (String) -> void
+    def <<: (string) -> void
 
     def send: (Request) -> void
 
     def consume: () -> void
 
-    def handle_error: (StandardError ex) -> void
+    def handle_error: (StandardError ex, ?Request? request) -> void
 
     def on_start: () -> void
 
@@ -53,19 +54,19 @@ module HTTPX
 
     def ping: () -> void
 
-    def timeout: () -> Numeric
+    def timeout: () -> Numeric?
 
     private
 
-    def initialize: (Buffer, options) -> untyped
+    def initialize: (Buffer buffer, Options options) -> untyped
 
-    def manage_connection: (Response) -> void
+    def manage_connection: (Request request, Response response) -> void
 
     def disable: () -> void
 
     def disable_pipelining: () -> void
 
-    def set_protocol_headers: (Request) -> _Each[[String, String]]
+    def set_protocol_headers: (Request request) -> _Each[[String, String]]
 
     def handle: (Request request) -> void
 

data/sig/connection/http2.rbs

@@ -5,7 +5,7 @@ module HTTPX
 
     MAX_CONCURRENT_REQUESTS: Integer
 
-    attr_reader streams: Hash[Request, HTTP2Next::Stream]
+    attr_reader streams: Hash[Request, ::HTTP2::Stream]
     attr_reader pending: Array[Request]
 
     @options: Options
@@ -24,7 +24,7 @@ module HTTPX
 
     def exhausted?: () -> bool
 
-    def <<: (String) -> void
+    def <<: (string) -> void
 
     def can_buffer_more_requests?: () -> bool
 
@@ -32,45 +32,45 @@ module HTTPX
 
     def consume: () -> void
 
-    def handle_error: (StandardError ex) -> void
+    def handle_error: (StandardError ex, ?Request? request) -> void
 
     def ping: () -> void
 
     alias reset init_connection
 
-    def timeout: () -> Numeric
+    def timeout: () -> Numeric?
 
     private
 
-    def initialize: (Buffer, options) -> untyped
+    def initialize: (Buffer buffer, Options options) -> untyped
 
     def send_pending: () -> void
 
     def set_protocol_headers: (Request) -> _Each[[String, String]]
 
-    def handle: (Request request, HTTP2Next::Stream stream) -> void
+    def handle: (Request request, ::HTTP2::Stream stream) -> void
 
     def init_connection: () -> void
 
-    def handle_stream: (HTTP2Next::Stream stream, Request request) -> void
+    def handle_stream: (::HTTP2::Stream stream, Request request) -> void
 
     def join_headline: (Request request) -> String
 
-    def join_headers: (HTTP2Next::Stream stream, Request request) -> void
+    def join_headers: (::HTTP2::Stream stream, Request request) -> void
 
-    def join_trailers: (HTTP2Next::Stream stream, Request request) -> void
+    def join_trailers: (::HTTP2::Stream stream, Request request) -> void
 
-    def join_body: (HTTP2Next::Stream stream, Request request) -> void
+    def join_body: (::HTTP2::Stream stream, Request request) -> void
 
-    def on_stream_headers: (HTTP2Next::Stream stream, Request request, Array[[String, String]] headers) -> void
+    def on_stream_headers: (::HTTP2::Stream stream, Request request, Array[[String, String]] headers) -> void
 
-    def on_stream_trailers: (HTTP2Next::Stream stream, Response response, Array[[String, String]] headers) -> void
+    def on_stream_trailers: (::HTTP2::Stream stream, Response response, Array[[String, String]] headers) -> void
 
-    def on_stream_data: (HTTP2Next::Stream stream, Request request, String data) -> void
+    def on_stream_data: (::HTTP2::Stream stream, Request request, String data) -> void
 
-    def on_stream_refuse: (HTTP2Next::Stream stream, Request request, StandardError error) -> void
+    def on_stream_refuse: (::HTTP2::Stream stream, Request request, StandardError error) -> void
 
-    def on_stream_close: (HTTP2Next::Stream stream, Request request, (Symbol | StandardError)? error) -> void
+    def on_stream_close: (::HTTP2::Stream stream, Request request, (Symbol | StandardError)? error) -> void
 
     def on_frame: (string bytes) -> void
 
@@ -78,13 +78,13 @@ module HTTPX
 
     def on_close: (Integer last_frame, Symbol? error, String? payload) -> void
 
-    def on_frame_sent: (HTTP2Next::frame) -> void
+    def on_frame_sent: (::HTTP2::frame) -> void
 
-    def on_frame_received: (HTTP2Next::frame) -> void
+    def on_frame_received: (::HTTP2::frame) -> void
 
-    def on_altsvc: (String origin, HTTP2Next::frame) -> void
+    def on_altsvc: (String origin, ::HTTP2::frame) -> void
 
-    def on_promise: (HTTP2Next::Stream) -> void
+    def on_promise: (::HTTP2::Stream) -> void
 
     def on_origin: (String) -> void
 

data/sig/connection.rbs

@@ -17,42 +17,51 @@ module HTTPX
     extend Forwardable
     include Loggable
     include Callbacks
-    include HTTPX::Registry[String, Class]
 
-    BUFFER_SIZE: Integer
 
-    attr_reader origin: URI::Generic
+    attr_reader type: io_type
+    attr_reader origin: http_uri
     attr_reader origins: Array[String]
     attr_reader state: Symbol
     attr_reader pending: Array[Request]
     attr_reader options: Options
+    attr_reader ssl_session: OpenSSL::SSL::Session?
     attr_writer timers: Timers
 
-    @origins: Array[URI::Generic]
+    attr_accessor family: Integer?
+
     @window_size: Integer
     @read_buffer: Buffer
     @write_buffer: Buffer
     @inflight: Integer
     @keep_alive_timeout: Numeric?
-    @total_timeout: Numeric?
+    @timeout: Numeric?
+    @current_timeout: Numeric?
+    @io: TCP | SSL | UNIX
+    @parser: Object & _Parser
+    @connected_at: Float
+    @response_received_at: Float
+    @intervals: Array[Timers::Interval]
 
     def addresses: () -> Array[ipaddr]?
 
-    def addresses=: (Array[ipaddr]) -> void
+    def addresses=: (Array[ipaddr] addresses) -> void
 
-    def match?: (URI::Generic, options) -> bool
+    def send: (Request request) -> void
 
-    def mergeable?: (Connection) -> bool
+    def match?: (URI::Generic uri, Options options) -> bool
 
-    def coalescable?: (Connection) -> bool
+    def expired?: () -> boolish
 
-    def create_idle: (?Hash[Symbol, untyped] options) -> Connection
+    def mergeable?: (Connection connection) -> bool
+
+    def coalescable?: (Connection connection) -> bool
 
-    def merge: (Connection) -> void
+    def create_idle: (?Hash[Symbol, untyped] options) -> Connection
 
-    def purge_pending: () { (Request) -> void } -> void
+    def merge: (Connection connection) -> void
 
-    def match_altsvcs?: (URI::Generic uri) -> bool
+    def purge_pending: () { (Request request) -> void } -> void
 
     def connecting?: () -> bool
 
@@ -60,21 +69,33 @@ module HTTPX
 
     def interests: () -> io_interests?
 
-    def to_io: () -> IO
+    def to_io: () -> ::IO
 
     def call: () -> void
 
+    def terminate: () -> void
+
     def close: () -> void
-    def reset: () -> void
 
-    def send: (Request) -> void
+    def reset: () -> void
 
     def timeout: () -> Numeric?
 
+    def idling: () -> void
+
+    def used?: () -> boolish
+
     def deactivate: () -> void
+
+    def open?: () -> bool
+
+    def handle_socket_timeout: (Numeric interval) -> void
+
     private
 
-    def initialize: (String, URI::Generic, options) -> untyped
+    def initialize: (http_uri uri, Options options) -> void
+
+    def initialize_type: (http_uri uri, Options options) -> io_type
 
     def connect: () -> void
 
@@ -84,21 +105,40 @@ module HTTPX
 
     def send_pending: () -> void
 
-    def parser: () -> _Parser
+    def parser: () -> (Object & _Parser)
 
     def send_request_to_parser: (Request request) -> void
 
-    def build_parser: () -> _Parser
-                    | (String) -> _Parser
+    def build_parser: (?String protocol) -> (Object & _Parser)
+
+    def set_parser_callbacks: (HTTP1 | HTTP2 parser) -> void
+
+    def transition: (Symbol nextstate) -> void
 
-    def set_parser_callbacks: (_Parser) -> void
+    def handle_transition: (Symbol nextstate) -> void
 
-    def transition: (Symbol) -> void
+    def build_socket: (?Array[ipaddr]? addrs) -> (TCP | SSL | UNIX)
 
-    def on_error: (HTTPX::TimeoutError | Error | StandardError) -> void
+    def on_error: (HTTPX::TimeoutError | Error | StandardError error, ?Request? request) -> void
 
-    def handle_error: (StandardError) -> void
+    def handle_error: (StandardError error, ?Request? request) -> void
 
     def purge_after_closed: () -> void
+
+    def set_request_timeouts: (Request request) -> void
+
+    def set_request_read_timeout: (Request request) -> void
+
+    def set_request_write_timeout: (Request request) -> void
+
+    def set_request_request_timeout: (Request request) -> void
+
+    def write_timeout_callback: (Request request, Numeric write_timeout) -> void
+
+    def read_timeout_callback: (Request request, Numeric read_timeout, ?singleton(RequestTimeoutError) error_type) -> void
+
+    def set_request_timeout: (Request request, Numeric timeout, Symbol start_event, Symbol | Array[Symbol] finish_events) { () -> void } -> void
+
+    def self.parser_type: (String protocol) -> (singleton(HTTP1) | singleton(HTTP2))
   end
 end

data/sig/errors.rbs

@@ -2,6 +2,12 @@ module HTTPX
   class Error < StandardError
   end
 
+  class UnsupportedSchemeError < Error
+  end
+
+  class ConnectionError < Error
+  end
+
   class TimeoutError < Error
     attr_reader timeout: Numeric
 
@@ -11,9 +17,6 @@ module HTTPX
     def initialize: (Numeric timeout, String message) -> untyped
   end
 
-  class TotalTimeoutError < TimeoutError
-  end
-
   class ConnectTimeoutError < TimeoutError
   end
 
@@ -23,6 +26,19 @@ module HTTPX
   class ResolveTimeoutError < TimeoutError
   end
 
+  class RequestTimeoutError < TimeoutError
+    attr_reader request: Request
+    attr_reader response: response?
+
+    def initialize: (Request request, response? response, Numeric timeout) -> void
+  end
+
+  class ReadTimeoutError < RequestTimeoutError
+  end
+
+  class WriteTimeoutError < RequestTimeoutError
+  end
+
   class ResolveError < Error
   end
 
@@ -42,4 +58,7 @@ module HTTPX
 
     def initialize: (Connection connection, String hostname, ?String message) -> untyped
   end
+
+  class MisdirectedRequestError < HTTPError
+  end
 end

data/sig/httpx.rbs

@@ -5,12 +5,13 @@ module HTTPX
 
   VERSION: String
 
-  type uri = URI::HTTP | URI::HTTPS | string
+  type http_uri = URI::HTTP | URI::HTTPS
+  type uri = http_uri | string
   type generic_uri = String | URI::Generic
 
-  type verb = :options | :get | :head | :post | :put | :delete | :trace | :connect |
-              :propfind | :proppatch | :mkcol | :copy | :move | :lock | :unlock | :orderpatch |
-              :acl | :report | :patch | :search
+  type verb = String
+
+  type request_params = Hash[Symbol, untyped]
 
   type ip_family = Integer #Socket::AF_INET6 | Socket::AF_INET
 

data/sig/io/ssl.rbs

@@ -0,0 +1,27 @@
+module HTTPX
+
+  class TLSError < OpenSSL::SSL::SSLError
+  end
+
+  class SSL < TCP
+    TLS_OPTIONS: Hash[Symbol, untyped]
+
+    @ctx: OpenSSL::SSL::SSLContext
+    @verify_hostname: bool
+
+    attr_writer ssl_session: OpenSSL::SSL::Session?
+
+    # TODO: lift when https://github.com/ruby/rbs/issues/1497 fixed
+    # def initialize: (URI::Generic origin, Array[ipaddr]? addresses, options options) ?{ (self) -> void } -> void
+
+    def session_new_cb: { (OpenSSL::SSL::Session sess) -> void } -> void
+    def can_verify_peer?: () -> bool
+
+    def verify_hostname: (String host) -> bool
+
+    def ssl_session_expired?: () -> boolish
+
+    # :nocov:
+    def try_ssl_connect: () -> void
+  end
+end

data/sig/io/tcp.rbs

@@ -0,0 +1,60 @@
+module HTTPX
+  class TCP
+    include Loggable
+
+    attr_reader ip: ipaddr?
+
+    attr_reader port: Integer
+
+    attr_reader addresses: Array[ipaddr]
+
+    attr_reader state: Symbol
+
+    attr_reader interests: io_interests
+
+    alias host ip
+
+    # TODO: lift when https://github.com/ruby/rbs/issues/1497 fixed
+    def initialize: (URI::Generic origin, Array[ipaddr]? addresses, Options options) ?{ (instance) -> void } -> void
+
+    def add_addresses: (Array[ipaddr] addrs) -> void
+
+    def to_io: () -> ::IO
+
+    def protocol: () -> String
+
+    def connect: () -> void
+
+    private
+
+    # :nocov:
+    def try_connect: () -> void
+
+    public
+
+    def read: (Integer size, ?(Buffer | String) buffer) -> (0 | nil | untyped)
+
+    def write: (Buffer buffer) -> Integer?
+
+    def close: () -> void
+
+    def connected?: () -> bool
+
+    def expired?: () -> boolish
+
+    def closed?: () -> bool
+
+    # :nocov:
+    def inspect: () -> ::String
+
+    private
+
+    def build_socket: () -> Socket
+
+    def transition: (Symbol nextstate) -> void
+
+    def do_transition: (Symbol nextstate) -> void
+
+    def log_transition_state: (Symbol nextstate) -> void
+  end
+end

data/sig/io/udp.rbs

@@ -0,0 +1,20 @@
+module HTTPX
+  class UDP
+    include Loggable
+
+    def initialize: (String ip, Integer port, Options options) -> void
+
+    def to_io: () -> ::IO
+
+    def connect: () -> void
+
+    def connected?: () -> bool
+
+    # :nocov:
+    def close: () -> void
+
+    def read: (Integer size, ?(Buffer | String) buffer) -> Integer?
+
+    def write: (Buffer buffer) -> Integer?
+  end
+end

data/sig/io/unix.rbs

@@ -0,0 +1,27 @@
+module HTTPX
+  class UNIX < TCP
+
+    attr_reader path: String
+
+    alias host path
+
+    @hostname: String
+
+    @options: Options
+
+    @fallback_protocol: String
+
+    @keep_open: bool
+
+    @io: Socket
+
+    def initialize: (http_uri origin, String? path, Options options) -> void
+
+    def connect: () -> void
+
+    def expired?: () -> bool
+    private
+
+    def build_socket: () -> Socket
+  end
+end

data/sig/io.rbs

@@ -0,0 +1,6 @@
+module HTTPX
+  type io_type = "udp" | "tcp" | "ssl" | "unix"
+
+  module IO
+  end
+end