class HTTPX::Options

  1. lib/httpx/options.rb
  2. lib/httpx/transcoder/utils/deflater.rb
  3. show all
Superclass: Object

Contains a set of options which are passed and shared across from session to its requests or responses.

Constants

BUFFER_SIZE = 1 << 14  
CLOSE_HANDSHAKE_TIMEOUT = 10  
CONNECT_TIMEOUT = READ_TIMEOUT = WRITE_TIMEOUT = 60  
DEFAULT_OPTIONS = { :max_requests => Float::INFINITY, :debug => nil, :debug_level => (ENV["HTTPX_DEBUG"] || 1).to_i, :ssl => EMPTY_HASH, :http2_settings => { settings_enable_push: 0 }.freeze, :fallback_protocol => "http/1.1", :supported_compression_formats => %w[gzip deflate], :decompress_response_body => true, :compress_request_body => true, :timeout => { connect_timeout: CONNECT_TIMEOUT, settings_timeout: SETTINGS_TIMEOUT, close_handshake_timeout: CLOSE_HANDSHAKE_TIMEOUT, operation_timeout: OPERATION_TIMEOUT, keep_alive_timeout: KEEP_ALIVE_TIMEOUT, read_timeout: READ_TIMEOUT, write_timeout: WRITE_TIMEOUT, request_timeout: REQUEST_TIMEOUT, }, :headers_class => Class.new(Headers), :headers => {}, :window_size => WINDOW_SIZE, :buffer_size => BUFFER_SIZE, :body_threshold_size => MAX_BODY_THRESHOLD_SIZE, :request_class => Class.new(Request), :response_class => Class.new(Response), :request_body_class => Class.new(Request::Body), :response_body_class => Class.new(Response::Body), :pool_class => Class.new(Pool), :connection_class => Class.new(Connection), :options_class => Class.new(self), :transport => nil, :addresses => nil, :persistent => false, :resolver_class => (ENV["HTTPX_RESOLVER"] || :native).to_sym, :resolver_options => { cache: true }.freeze, :pool_options => EMPTY_HASH, :ip_families => ip_address_families, }.freeze  
KEEP_ALIVE_TIMEOUT = 20  
MAX_BODY_THRESHOLD_SIZE = (1 << 10) * 112  
REQUEST_BODY_IVARS = %i[@headers].freeze  
REQUEST_TIMEOUT = OPERATION_TIMEOUT = nil  
SETTINGS_TIMEOUT = 10  
WINDOW_SIZE = 1 << 14  

Public Class methods

method_added(meth)
[show source] 
   # File lib/httpx/options.rb
80 def method_added(meth)
81   super
82 
83   return unless meth =~ /^option_(.+)$/
84 
85   optname = Regexp.last_match(1).to_sym
86 
87   attr_reader(optname)
88 end
new(options = {})
[show source] 
   # File lib/httpx/options.rb
72 def new(options = {})
73   # let enhanced options go through
74   return options if self == Options && options.class < self
75   return options if options.is_a?(self)
76 
77   super
78 end
new(options = {})

creates a new options instance from a given hash, which optionally define the following:

:debug

an object which log messages are written to (must respond to <<)

:debug_level

the log level of messages (can be 1, 2, or 3).

:ssl

a hash of options which can be set as params of OpenSSL::SSL::SSLContext (see HTTPX::IO::SSL)

:http2_settings

a hash of options to be passed to a HTTP2::Connection (ex: { max_concurrent_streams: 2 })

:fallback_protocol

version of HTTP protocol to use by default in the absence of protocol negotiation like ALPN (defaults to "http/1.1")

:supported_compression_formats

list of compressions supported by the transcoder layer (defaults to %w[gzip deflate]).

:decompress_response_body

whether to auto-decompress response body (defaults to true).

:compress_request_body

whether to auto-decompress response body (defaults to true)

:timeout

hash of timeout configurations (supports :connect_timeout, :settings_timeout, :operation_timeout, :keep_alive_timeout, :read_timeout, :write_timeout and :request_timeout

:headers

hash of HTTP headers (ex: { "x-custom-foo" => "bar" })

:window_size

number of bytes to read from a socket

:buffer_size

internal read and write buffer size in bytes

:body_threshold_size

maximum size in bytes of response payload that is buffered in memory.

:request_class

class used to instantiate a request

:response_class

class used to instantiate a response

:headers_class

class used to instantiate headers

:request_body_class

class used to instantiate a request body

:response_body_class

class used to instantiate a response body

:connection_class

class used to instantiate connections

:pool_class

class used to instantiate the session connection pool

:options_class

class used to instantiate options

:transport

type of transport to use (set to “unix” for UNIX sockets)

:addresses

bucket of peer addresses (can be a list of IP addresses, a hash of domain to list of adddresses; paths should be used for UNIX sockets instead)

:io

open socket, or domain/ip-to-socket hash, which requests should be sent to

:persistent

whether to persist connections in between requests (defaults to true)

:resolver_class

which resolver to use (defaults to :native, can also be :system<tt> for using getaddrinfo or <tt>:https for DoH resolver, or a custom class)

:resolver_options

hash of options passed to the resolver. Accepted keys depend on the resolver type.

:pool_options

hash of options passed to the connection pool (See Pool#initialize).

:ip_families

which socket families are supported (system-dependent)

:origin

HTTP origin to set on requests with relative path (ex: “api.serv.com”)

:base_path

path to prefix given relative paths with (ex: “/v2”)

:max_concurrent_requests

max number of requests which can be set concurrently

:max_requests

max number of requests which can be made on socket before it reconnects.

This list of options are enhanced with each loaded plugin, see the plugin docs for details.

[show source] 
    # File lib/httpx/options.rb
133 def initialize(options = {})
134   do_initialize(options)
135   freeze
136 end

Public Instance methods

==(other)
[show source] 
    # File lib/httpx/options.rb
235 def ==(other)
236   super || options_equals?(other)
237 end
extend_with_plugin_classes(pl)
[show source] 
    # File lib/httpx/options.rb
296 def extend_with_plugin_classes(pl)
297   if defined?(pl::RequestMethods) || defined?(pl::RequestClassMethods)
298     @request_class = @request_class.dup
299     @request_class.__send__(:include, pl::RequestMethods) if defined?(pl::RequestMethods)
300     @request_class.extend(pl::RequestClassMethods) if defined?(pl::RequestClassMethods)
301   end
302   if defined?(pl::ResponseMethods) || defined?(pl::ResponseClassMethods)
303     @response_class = @response_class.dup
304     @response_class.__send__(:include, pl::ResponseMethods) if defined?(pl::ResponseMethods)
305     @response_class.extend(pl::ResponseClassMethods) if defined?(pl::ResponseClassMethods)
306   end
307   if defined?(pl::HeadersMethods) || defined?(pl::HeadersClassMethods)
308     @headers_class = @headers_class.dup
309     @headers_class.__send__(:include, pl::HeadersMethods) if defined?(pl::HeadersMethods)
310     @headers_class.extend(pl::HeadersClassMethods) if defined?(pl::HeadersClassMethods)
311   end
312   if defined?(pl::RequestBodyMethods) || defined?(pl::RequestBodyClassMethods)
313     @request_body_class = @request_body_class.dup
314     @request_body_class.__send__(:include, pl::RequestBodyMethods) if defined?(pl::RequestBodyMethods)
315     @request_body_class.extend(pl::RequestBodyClassMethods) if defined?(pl::RequestBodyClassMethods)
316   end
317   if defined?(pl::ResponseBodyMethods) || defined?(pl::ResponseBodyClassMethods)
318     @response_body_class = @response_body_class.dup
319     @response_body_class.__send__(:include, pl::ResponseBodyMethods) if defined?(pl::ResponseBodyMethods)
320     @response_body_class.extend(pl::ResponseBodyClassMethods) if defined?(pl::ResponseBodyClassMethods)
321   end
322   if defined?(pl::PoolMethods)
323     @pool_class = @pool_class.dup
324     @pool_class.__send__(:include, pl::PoolMethods)
325   end
326   if defined?(pl::ConnectionMethods)
327     @connection_class = @connection_class.dup
328     @connection_class.__send__(:include, pl::ConnectionMethods)
329   end
330   return unless defined?(pl::OptionsMethods)
331 
332   @options_class = @options_class.dup
333   @options_class.__send__(:include, pl::OptionsMethods)
334 end
freeze()
[show source] 
    # File lib/httpx/options.rb
138 def freeze
139   super
140   @origin.freeze
141   @base_path.freeze
142   @timeout.freeze
143   @headers.freeze
144   @addresses.freeze
145   @supported_compression_formats.freeze
146 end
merge(other)
[show source] 
    # File lib/httpx/options.rb
254 def merge(other)
255   ivar_map = nil
256   other_ivars = case other
257                 when Hash
258                   ivar_map = other.keys.to_h { |k| [:"@#{k}", k] }
259                   ivar_map.keys
260                 else
261                   other.instance_variables
262   end
263 
264   return self if other_ivars.empty?
265 
266   return self if other_ivars.all? { |ivar| instance_variable_get(ivar) == access_option(other, ivar, ivar_map) }
267 
268   opts = dup
269 
270   other_ivars.each do |ivar|
271     v = access_option(other, ivar, ivar_map)
272 
273     unless v
274       opts.instance_variable_set(ivar, v)
275       next
276     end
277 
278     v = opts.__send__(:"option_#{ivar[1..-1]}", v)
279 
280     orig_v = instance_variable_get(ivar)
281 
282     v = orig_v.merge(v) if orig_v.respond_to?(:merge) && v.respond_to?(:merge)
283 
284     opts.instance_variable_set(ivar, v)
285   end
286 
287   opts
288 end
option_addresses(value)
[show source] 
    # File lib/httpx/options.rb
210 def option_addresses(value)
211   Array(value)
212 end
option_base_path(value)
[show source] 
    # File lib/httpx/options.rb
152 def option_base_path(value)
153   String(value)
154 end
option_body_threshold_size(value)
[show source] 
    # File lib/httpx/options.rb
196 def option_body_threshold_size(value)
197   bytes = Integer(value)
198   raise TypeError, ":body_threshold_size must be positive" unless bytes.positive?
199 
200   bytes
201 end
option_buffer_size(value)
[show source] 
    # File lib/httpx/options.rb
188 def option_buffer_size(value)
189   value = Integer(value)
190 
191   raise TypeError, ":buffer_size must be positive" unless value.positive?
192 
193   value
194 end
option_headers(value)
[show source] 
    # File lib/httpx/options.rb
156 def option_headers(value)
157   headers_class.new(value)
158 end
option_ip_families(value)
[show source] 
    # File lib/httpx/options.rb
214 def option_ip_families(value)
215   Array(value)
216 end
option_max_concurrent_requests(value)
[show source] 
    # File lib/httpx/options.rb
168 def option_max_concurrent_requests(value)
169   raise TypeError, ":max_concurrent_requests must be positive" unless value.positive?
170 
171   value
172 end
option_max_requests(value)
[show source] 
    # File lib/httpx/options.rb
174 def option_max_requests(value)
175   raise TypeError, ":max_requests must be positive" unless value.positive?
176 
177   value
178 end
option_origin(value)
[show source] 
    # File lib/httpx/options.rb
148 def option_origin(value)
149   URI(value)
150 end
option_supported_compression_formats(value)
[show source] 
    # File lib/httpx/options.rb
164 def option_supported_compression_formats(value)
165   Array(value).map(&:to_s)
166 end
option_timeout(value)
[show source] 
    # File lib/httpx/options.rb
160 def option_timeout(value)
161   Hash[value]
162 end
option_transport(value)
[show source] 
    # File lib/httpx/options.rb
203 def option_transport(value)
204   transport = value.to_s
205   raise TypeError, "#{transport} is an unsupported transport type" unless %w[unix].include?(transport)
206 
207   transport
208 end
option_window_size(value)
[show source] 
    # File lib/httpx/options.rb
180 def option_window_size(value)
181   value = Integer(value)
182 
183   raise TypeError, ":window_size must be positive" unless value.positive?
184 
185   value
186 end
options_equals?(other, ignore_ivars = REQUEST_BODY_IVARS)
[show source] 
    # File lib/httpx/options.rb
239 def options_equals?(other, ignore_ivars = REQUEST_BODY_IVARS)
240   # headers and other request options do not play a role, as they are
241   # relevant only for the request.
242   ivars = instance_variables - ignore_ivars
243   other_ivars = other.instance_variables - ignore_ivars
244 
245   return false if ivars.size != other_ivars.size
246 
247   return false if ivars.sort != other_ivars.sort
248 
249   ivars.all? do |ivar|
250     instance_variable_get(ivar) == other.instance_variable_get(ivar)
251   end
252 end
to_hash()
[show source] 
    # File lib/httpx/options.rb
290 def to_hash
291   instance_variables.each_with_object({}) do |ivar, hs|
292     hs[ivar[1..-1].to_sym] = instance_variable_get(ivar)
293   end
294 end