-
# frozen_string_literal: true
-
-
1
require "httpx/version"
-
-
1
require "httpx/extensions"
-
-
1
require "httpx/errors"
-
1
require "httpx/altsvc"
-
1
require "httpx/callbacks"
-
1
require "httpx/loggable"
-
1
require "httpx/registry"
-
1
require "httpx/transcoder"
-
1
require "httpx/options"
-
1
require "httpx/timeout"
-
1
require "httpx/pool"
-
1
require "httpx/headers"
-
1
require "httpx/request"
-
1
require "httpx/response"
-
1
require "httpx/chainable"
-
1
require "httpx/session"
-
-
# Top-Level Namespace
-
#
-
1
module HTTPX
-
# All plugins should be stored under this module/namespace. Can register and load
-
# plugins.
-
#
-
1
module Plugins
-
1
@plugins = {}
-
-
# 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.
-
#
-
1
def self.load_plugin(name)
-
130
h = @plugins
-
130
unless (plugin = h[name])
-
19
require "httpx/plugins/#{name}"
-
19
raise "Plugin #{name} hasn't been registered" unless (plugin = h[name])
-
end
-
130
plugin
-
end
-
-
# Registers a plugin (+mod+) in the central store indexed by +name+.
-
#
-
1
def self.register_plugin(name, mod)
-
19
@plugins[name] = mod
-
end
-
end
-
-
1
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
-
-
1
extend Chainable
-
end
-
# frozen_string_literal: true
-
-
1
require "httpx"
-
1
require "faraday"
-
-
1
module Faraday
-
1
class Adapter
-
1
class HTTPX < Faraday::Adapter
-
1
SSL_ERROR = if defined?(Faraday::SSLError)
-
1
Faraday::SSLError
-
else
-
Faraday::Error::SSLError
-
end
-
-
1
CONNECTION_FAILED_ERROR = if defined?(Faraday::ConnectionFailed)
-
1
Faraday::ConnectionFailed
-
else
-
Faraday::Error::ConnectionFailed
-
end
-
-
1
module RequestMixin
-
1
private
-
-
1
def build_request(env)
-
20
meth = env[:method]
-
-
request_options = {
-
20
headers: env.request_headers,
-
body: env.body,
-
}
-
20
[meth, env.url, request_options]
-
end
-
-
1
def options_from_env(env)
-
timeout_options = {
-
19
connect_timeout: env.request.open_timeout,
-
operation_timeout: env.request.timeout,
-
38
}.reject { |_, v| v.nil? }
-
-
options = {
-
19
ssl: {},
-
timeout: timeout_options,
-
}
-
-
19
options[:ssl][:verify_mode] = OpenSSL::SSL::VERIFY_PEER if env.ssl.verify
-
19
options[:ssl][:ca_file] = env.ssl.ca_file if env.ssl.ca_file
-
19
options[:ssl][:ca_path] = env.ssl.ca_path if env.ssl.ca_path
-
19
options[:ssl][:cert_store] = env.ssl.cert_store if env.ssl.cert_store
-
19
options[:ssl][:cert] = env.ssl.client_cert if env.ssl.client_cert
-
19
options[:ssl][:key] = env.ssl.client_key if env.ssl.client_key
-
19
options[:ssl][:ssl_version] = env.ssl.version if env.ssl.version
-
19
options[:ssl][:verify_depth] = env.ssl.verify_depth if env.ssl.verify_depth
-
19
options[:ssl][:min_version] = env.ssl.min_version if env.ssl.min_version
-
19
options[:ssl][:max_version] = env.ssl.max_version if env.ssl.max_version
-
-
19
options
-
end
-
end
-
-
1
include RequestMixin
-
-
1
class Session < ::HTTPX::Session
-
1
plugin(:compression)
-
1
plugin(:persistent)
-
-
1
module ReasonPlugin
-
1
if RUBY_VERSION < "2.5"
-
def self.load_dependencies(*)
-
require "webrick"
-
end
-
else
-
1
def self.load_dependencies(*)
-
1
require "net/http/status"
-
end
-
end
-
1
module ResponseMethods
-
1
if RUBY_VERSION < "2.5"
-
def reason
-
WEBrick::HTTPStatus::StatusMessage.fetch(@status)
-
end
-
else
-
1
def reason
-
18
Net::HTTP::STATUS_CODES.fetch(@status)
-
end
-
end
-
end
-
end
-
1
plugin(ReasonPlugin)
-
end
-
-
1
class ParallelManager
-
1
class ResponseHandler
-
1
attr_reader :env
-
-
1
def initialize(env)
-
2
@env = env
-
end
-
-
1
def on_response(&blk)
-
4
if block_given?
-
2
@on_response = lambda do |response|
-
2
blk.call(response)
-
end
-
2
self
-
else
-
2
@on_response
-
end
-
end
-
-
1
def on_complete(&blk)
-
4
if block_given?
-
2
@on_complete = blk
-
2
self
-
else
-
2
@on_complete
-
end
-
end
-
-
1
def respond_to_missing?(meth)
-
@env.respond_to?(meth)
-
end
-
-
1
def method_missing(meth, *args, &blk)
-
4
if @env && @env.respond_to?(meth)
-
4
@env.__send__(meth, *args, &blk)
-
else
-
super
-
end
-
end
-
end
-
-
1
include RequestMixin
-
-
1
def initialize
-
1
@session = Session.new
-
1
@handlers = []
-
end
-
-
1
def enqueue(request)
-
2
handler = ResponseHandler.new(request)
-
2
@handlers << handler
-
2
handler
-
end
-
-
1
def run
-
3
requests = @handlers.map { |handler| build_request(handler.env) }
-
1
env = @handlers.last.env
-
-
1
proxy_options = { uri: env.request.proxy }
-
-
1
session = @session.with(options_from_env(env))
-
1
session = session.plugin(:proxy).with_proxy(proxy_options) if env.request.proxy
-
-
1
responses = session.request(requests)
-
1
Array(responses).each_with_index do |response, index|
-
2
handler = @handlers[index]
-
2
handler.on_response.call(response)
-
2
handler.on_complete.call(handler.env)
-
end
-
end
-
end
-
-
1
self.supports_parallel = true
-
-
1
class << self
-
1
def setup_parallel_manager
-
1
ParallelManager.new
-
end
-
end
-
-
1
def initialize(app)
-
19
super(app)
-
19
@session = Session.new
-
end
-
-
1
def call(env)
-
20
super
-
20
if parallel?(env)
-
2
handler = env[:parallel_manager].enqueue(env)
-
2
handler.on_response do |response|
-
2
save_response(env, response.status, response.body.to_s, response.headers, response.reason) do |response_headers|
-
2
response_headers.merge!(response.headers)
-
end
-
end
-
2
return handler
-
end
-
-
18
request_options = build_request(env)
-
-
18
session = @session.with(options_from_env(env))
-
18
session = session.plugin(:proxy).with_proxy(proxy_options) if env.request.proxy
-
18
response = session.__send__(*request_options)
-
18
response.raise_for_status unless response.is_a?(::HTTPX::Response)
-
16
save_response(env, response.status, response.body.to_s, response.headers, response.reason) do |response_headers|
-
16
response_headers.merge!(response.headers)
-
end
-
16
@app.call(env)
-
rescue OpenSSL::SSL::SSLError => err
-
1
raise SSL_ERROR, err
-
rescue Errno::ECONNABORTED,
-
Errno::ECONNREFUSED,
-
Errno::ECONNRESET,
-
Errno::EHOSTUNREACH,
-
Errno::EINVAL,
-
Errno::ENETUNREACH,
-
Errno::EPIPE => err
-
1
raise CONNECTION_FAILED_ERROR, err
-
end
-
-
1
private
-
-
1
def parallel?(env)
-
20
env[:parallel_manager]
-
end
-
end
-
-
1
register_middleware httpx: HTTPX
-
end
-
end
-
# frozen_string_literal: true
-
-
1
require "strscan"
-
-
1
module HTTPX
-
1
module AltSvc
-
1
@altsvc_mutex = Mutex.new
-
2
@altsvcs = Hash.new { |h, k| h[k] = [] }
-
-
1
module_function
-
-
1
def cached_altsvc(origin)
-
200
now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-
200
@altsvc_mutex.synchronize do
-
200
lookup(origin, now)
-
end
-
end
-
-
1
def cached_altsvc_set(origin, entry)
-
4
now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-
4
@altsvc_mutex.synchronize do
-
7
return if @altsvcs[origin].any? { |altsvc| altsvc["origin"] == entry["origin"] }
-
-
1
entry["TTL"] = Integer(entry["ma"]) + now if entry.key?("ma")
-
1
@altsvcs[origin] << entry
-
1
entry
-
end
-
end
-
-
1
def lookup(origin, ttl)
-
200
return [] unless @altsvcs.key?(origin)
-
-
@altsvcs[origin] = @altsvcs[origin].select do |entry|
-
!entry.key?("TTL") || entry["TTL"] > ttl
-
end
-
@altsvcs[origin].reject { |entry| entry["noop"] }
-
end
-
-
1
def emit(request, response)
-
# Alt-Svc
-
202
return unless response.headers.key?("alt-svc")
-
-
4
origin = request.origin
-
4
host = request.uri.host
-
4
parse(response.headers["alt-svc"]) do |alt_origin, alt_params|
-
4
alt_origin.host ||= host
-
4
yield(alt_origin, origin, alt_params)
-
end
-
end
-
-
1
def parse(altsvc)
-
18
return enum_for(__method__, altsvc) unless block_given?
-
-
11
scanner = StringScanner.new(altsvc)
-
11
until scanner.eos?
-
13
alt_origin = scanner.scan(/[^=]+=("[^"]+"|[^;,]+)/)
-
-
13
alt_params = []
-
13
loop do
-
16
alt_param = scanner.scan(/[^=]+=("[^"]+"|[^;,]+)/)
-
16
alt_params << alt_param.strip if alt_param
-
16
scanner.skip(/;/)
-
16
break if scanner.eos? || scanner.scan(/ *, */)
-
end
-
27
alt_params = Hash[alt_params.map { |field| field.split("=") }]
-
13
yield(parse_altsvc_origin(alt_origin), alt_params)
-
end
-
end
-
-
1
if RUBY_VERSION < "2.2"
-
def parse_altsvc_origin(alt_origin)
-
alt_proto, alt_origin = alt_origin.split("=")
-
alt_origin = alt_origin[1..-2] if alt_origin.start_with?("\"") && alt_origin.end_with?("\"")
-
if alt_origin.start_with?(":")
-
alt_origin = "dummy#{alt_origin}"
-
uri = URI.parse(alt_origin)
-
uri.host = nil
-
uri
-
else
-
URI.parse("#{alt_proto}://#{alt_origin}")
-
end
-
end
-
else
-
1
def parse_altsvc_origin(alt_origin)
-
13
alt_proto, alt_origin = alt_origin.split("=")
-
13
alt_origin = alt_origin[1..-2] if alt_origin.start_with?("\"") && alt_origin.end_with?("\"")
-
13
URI.parse("#{alt_proto}://#{alt_origin}")
-
end
-
end
-
end
-
end
-
# frozen_string_literal: true
-
-
1
require "forwardable"
-
-
1
module HTTPX
-
1
class Buffer
-
1
extend Forwardable
-
-
1
def_delegator :@buffer, :<<
-
-
1
def_delegator :@buffer, :to_s
-
-
1
def_delegator :@buffer, :to_str
-
-
1
def_delegator :@buffer, :empty?
-
-
1
def_delegator :@buffer, :bytesize
-
-
1
def_delegator :@buffer, :clear
-
-
1
def_delegator :@buffer, :replace
-
-
1
attr_reader :limit
-
-
1
def initialize(limit)
-
514
@buffer = "".b
-
514
@limit = limit
-
end
-
-
1
def full?
-
533
@buffer.bytesize >= @limit
-
end
-
-
1
def shift!(fin)
-
464
@buffer = @buffer.byteslice(fin..-1)
-
end
-
end
-
end
-
# frozen_string_literal: true
-
-
1
module HTTPX
-
1
module Callbacks
-
1
def on(type, &action)
-
3174
callbacks(type) << action
-
end
-
-
1
def once(event, &block)
-
6
on(event) do |*args, &callback|
-
5
block.call(*args, &callback)
-
:delete
-
end
-
end
-
-
1
def emit(type, *args)
-
2541
callbacks(type).delete_if { |pr| pr[*args] == :delete }
-
end
-
-
1
protected
-
-
1
def callbacks(type = nil)
-
4452
return @callbacks unless type
-
-
7620
@callbacks ||= Hash.new { |h, k| h[k] = [] }
-
4452
@callbacks[type]
-
end
-
end
-
end
-
# frozen_string_literal: true
-
-
1
module HTTPX
-
1
module Chainable
-
1
%i[head get post put delete trace options connect patch].each do |meth|
-
9
define_method meth do |*uri, **options|
-
186
request(meth, uri, **options)
-
end
-
end
-
-
1
def request(verb, uri, **options)
-
72
branch(default_options).request(verb, uri, **options)
-
end
-
-
1
def timeout(**args)
-
8
branch(default_options.with_timeout(args))
-
end
-
-
1
def headers(headers)
-
22
branch(default_options.with_headers(headers))
-
end
-
-
1
def accept(type)
-
headers("accept" => String(type))
-
end
-
-
1
def wrap(&blk)
-
branch(default_options).wrap(&blk)
-
end
-
-
1
def plugin(*plugins)
-
71
klass = is_a?(Session) ? self.class : Session
-
71
klass = Class.new(klass)
-
71
klass.instance_variable_set(:@default_options, klass.default_options.merge(default_options))
-
71
klass.plugins(plugins).new
-
end
-
1
alias_method :plugins, :plugin
-
-
1
def with(options, &blk)
-
23
branch(default_options.merge(options), &blk)
-
end
-
-
1
private
-
-
1
def default_options
-
222
@options || Options.new
-
end
-
-
# :nodoc:
-
1
def branch(options, &blk)
-
151
return self.class.new(options, &blk) if is_a?(Session)
-
-
86
Session.new(options, &blk)
-
end
-
end
-
end
-
# frozen_string_literal: true
-
-
1
require "resolv"
-
1
require "forwardable"
-
1
require "httpx/io"
-
1
require "httpx/buffer"
-
-
1
module HTTPX
-
# The Connection can be watched for IO events.
-
#
-
# It contains the +io+ object to read/write from, and knows what to do when it can.
-
#
-
# It defers connecting until absolutely necessary. Connection should be triggered from
-
# the IO selector (until then, any request will be queued).
-
#
-
# A connection boots up its parser after connection is established. All pending requests
-
# will be redirected there after connection.
-
#
-
# A connection can be prevented from closing by the parser, that is, if there are pending
-
# requests. This will signal that the connection was prematurely closed, due to a possible
-
# number of conditions:
-
#
-
# * Remote peer closed the connection ("Connection: close");
-
# * Remote peer doesn't support pipelining;
-
#
-
# A connection may also route requests for a different host for which the +io+ was connected
-
# to, provided that the IP is the same and the port and scheme as well. This will allow to
-
# share the same socket to send HTTP/2 requests to different hosts.
-
#
-
1
class Connection
-
1
extend Forwardable
-
1
include Registry
-
1
include Loggable
-
1
include Callbacks
-
-
1
using URIExtensions
-
-
1
require "httpx/connection/http2"
-
1
require "httpx/connection/http1"
-
-
1
BUFFER_SIZE = 1 << 14
-
-
1
def_delegator :@io, :closed?
-
-
1
def_delegator :@write_buffer, :empty?
-
-
1
attr_reader :origin, :state, :pending, :options
-
-
1
def initialize(type, uri, options)
-
223
@type = type
-
223
@origins = [uri.origin]
-
223
@origin = URI(uri.origin)
-
223
@options = Options.new(options)
-
223
@window_size = @options.window_size
-
223
@read_buffer = Buffer.new(BUFFER_SIZE)
-
223
@write_buffer = Buffer.new(BUFFER_SIZE)
-
223
@pending = []
-
223
on(:error, &method(:on_error))
-
223
if @options.io
-
# if there's an already open IO, get its
-
# peer address, and force-initiate the parser
-
4
transition(:already_open)
-
4
@io = IO.registry(@type).new(@origin, nil, @options)
-
4
parser
-
else
-
219
transition(:idle)
-
end
-
end
-
-
# this is a semi-private method, to be used by the resolver
-
# to initiate the io object.
-
1
def addresses=(addrs)
-
203
@io ||= IO.registry(@type).new(@origin, addrs, @options) # rubocop:disable Naming/MemoizedInstanceVariableName
-
end
-
-
1
def addresses
-
507
@io && @io.addresses
-
end
-
-
1
def match?(uri, options)
-
360
return false if @state == :closing || @state == :closed
-
-
349
(@origins.include?(uri.origin) || match_altsvcs?(uri)) && @options == options
-
end
-
-
1
def mergeable?(connection)
-
315
return false if @state == :closing || @state == :closed || !@io
-
-
304
!(@io.addresses & connection.addresses).empty? && @options == connection.options
-
end
-
-
# coalescable connections need to be mergeable!
-
# but internally, #mergeable? is called before #coalescable?
-
1
def coalescable?(connection)
-
if @io.protocol == "h2" && @origin.scheme == "https"
-
@io.verify_hostname(connection.origin.host)
-
else
-
@origin == connection.origin
-
end
-
end
-
-
1
def merge(connection)
-
@origins += connection.instance_variable_get(:@origins)
-
pending = connection.instance_variable_get(:@pending)
-
pending.each do |req, args|
-
send(req, args)
-
end
-
end
-
-
1
def unmerge(connection)
-
@origins -= connection.instance_variable_get(:@origins)
-
purge_pending do |request|
-
request.uri.origin == connection.origin && begin
-
request.transition(:idle)
-
connection.send(request)
-
true
-
end
-
end
-
end
-
-
1
def purge_pending
-
[@parser.pending, @pending].each do |pending|
-
pending.reject! do |request, *args|
-
yield(request, args)
-
end
-
end
-
end
-
-
# checks if this is connection is an alternative service of
-
# +uri+
-
1
def match_altsvcs?(uri)
-
200
AltSvc.cached_altsvc(@origin).any? do |altsvc|
-
origin = altsvc["origin"]
-
origin.altsvc_match?(uri.origin)
-
end
-
end
-
-
1
def connecting?
-
8
@state == :idle
-
end
-
-
1
def inflight?
-
189
@parser && !@parser.empty? && !@write_buffer.empty?
-
end
-
-
1
def interests
-
894119
return :w if @state == :idle
-
-
890854
:rw
-
end
-
-
1
def to_io
-
3567522
case @state
-
when :idle
-
7639
transition(:open)
-
end
-
3567522
@io.to_io
-
end
-
-
1
def close
-
189
@parser.close if @parser
-
189
transition(:closing)
-
end
-
-
1
def reset
-
18
transition(:closing)
-
18
transition(:closed)
-
18
emit(:close)
-
end
-
-
1
def send(request)
-
222
if @parser && !@write_buffer.full?
-
24
request.headers["alt-used"] = @origin.authority if match_altsvcs?(request.uri)
-
24
parser.send(request)
-
else
-
198
@pending << request
-
end
-
end
-
-
1
def call
-
894119
case @state
-
when :closed
-
return
-
when :closing
-
170
dwrite
-
170
transition(:closed)
-
170
emit(:close)
-
when :open
-
890611
consume
-
end
-
nil
-
end
-
-
1
def timeout
-
894463
return @timeout if defined?(@timeout)
-
-
894463
return @options.timeout.connect_timeout if @state == :idle
-
-
890619
@options.timeout.operation_timeout
-
end
-
-
1
private
-
-
1
def consume
-
890627
catch(:called) do
-
890627
dread
-
890534
dwrite
-
890534
parser.consume
-
end
-
end
-
-
1
def dread(wsize = @window_size)
-
890627
loop do
-
891606
siz = @io.read(wsize, @read_buffer)
-
891606
unless siz
-
ex = EOFError.new("descriptor closed")
-
ex.set_backtrace(caller)
-
on_error(ex)
-
return
-
end
-
891606
return if siz.zero?
-
-
1072
log { "READ: #{siz} bytes..." }
-
1072
parser << @read_buffer.to_s
-
979
return if @state == :closing || @state == :closed
-
end
-
end
-
-
1
def dwrite
-
890704
loop do
-
891071
return if @write_buffer.empty?
-
-
444
siz = @io.write(@write_buffer)
-
444
unless siz
-
ex = EOFError.new("descriptor closed")
-
ex.set_backtrace(caller)
-
on_error(ex)
-
return
-
end
-
444
log { "WRITE: #{siz} bytes..." }
-
444
return if siz.zero?
-
444
return if @state == :closing || @state == :closed
-
end
-
end
-
-
1
def send_pending
-
588
while !@write_buffer.full? && (req_args = @pending.shift)
-
196
request = req_args
-
196
parser.send(request)
-
end
-
end
-
-
1
def parser
-
891831
@parser ||= build_parser
-
end
-
-
1
def build_parser(protocol = @io.protocol)
-
197
parser = registry(protocol).new(@write_buffer, @options)
-
197
set_parser_callbacks(parser)
-
197
parser
-
end
-
-
1
def set_parser_callbacks(parser)
-
199
parser.on(:response) do |request, response|
-
202
AltSvc.emit(request, response) do |alt_origin, origin, alt_params|
-
4
emit(:altsvc, alt_origin, origin, alt_params)
-
end
-
202
request.emit(:response, response)
-
end
-
199
parser.on(:altsvc) do |alt_origin, origin, alt_params|
-
emit(:altsvc, alt_origin, origin, alt_params)
-
end
-
-
199
parser.on(:promise) do |request, stream|
-
2
request.emit(:promise, parser, stream)
-
end
-
199
parser.on(:close) do
-
101
transition(:closing)
-
end
-
199
parser.on(:reset) do
-
85
transition(:closing)
-
85
unless parser.empty?
-
transition(:closed)
-
emit(:reset)
-
transition(:idle)
-
transition(:open)
-
end
-
end
-
199
parser.on(:timeout) do |tout|
-
@timeout = tout
-
end
-
199
parser.on(:error) do |request, ex|
-
case ex
-
when MisdirectedRequestError
-
emit(:uncoalesce, request.uri)
-
else
-
response = ErrorResponse.new(request, ex, @options)
-
request.emit(:response, response)
-
end
-
end
-
end
-
-
1
def transition(nextstate)
-
8708
case nextstate
-
when :open
-
7885
return if @state == :closed
-
-
7885
@io.connect
-
7880
return unless @io.connected?
-
-
194
send_pending
-
194
emit(:open)
-
when :closing
-
395
return unless @state == :open
-
when :closed
-
188
return unless @state == :closing
-
188
return unless @write_buffer.empty?
-
-
188
@io.close
-
188
@read_buffer.clear
-
188
remove_instance_variable(:@timeout) if defined?(@timeout)
-
when :already_open
-
4
nextstate = :open
-
4
send_pending
-
end
-
810
@state = nextstate
-
rescue Errno::EHOSTUNREACH
-
# at this point, all addresses from the IO object have failed
-
reset
-
emit(:unreachable)
-
throw(:jump_tick)
-
rescue Errno::ECONNREFUSED,
-
Errno::EADDRNOTAVAIL,
-
Errno::EHOSTUNREACH,
-
OpenSSL::SSL::SSLError => e
-
# connect errors, exit gracefully
-
5
handle_error(e)
-
5
@state = :closed
-
5
emit(:close)
-
end
-
-
1
def on_error(ex)
-
handle_error(ex)
-
reset
-
end
-
-
1
def handle_error(error)
-
5
if error.instance_of?(TimeoutError) && @timeout
-
@timeout -= error.timeout
-
return unless @timeout <= 0
-
-
error = error.to_connection_error if connecting?
-
end
-
-
5
parser.handle_error(error) if @parser && parser.respond_to?(:handle_error)
-
5
@pending.each do |request, _|
-
5
request.emit(:response, ErrorResponse.new(request, error, @options))
-
end
-
end
-
end
-
end
-
# frozen_string_literal: true
-
-
1
require "httpx/parser/http1"
-
-
1
module HTTPX
-
1
class Connection::HTTP1
-
1
include Callbacks
-
1
include Loggable
-
-
1
CRLF = "\r\n"
-
-
1
def initialize(buffer, options)
-
105
@options = Options.new(options)
-
105
@max_concurrent_requests = @options.max_concurrent_requests
-
105
@max_requests = Float::INFINITY
-
105
@parser = Parser::HTTP1.new(self)
-
105
@buffer = buffer
-
105
@version = [1, 1]
-
105
@pending = []
-
105
@requests = []
-
end
-
-
1
def reset
-
200
@parser.reset!
-
end
-
-
1
def close
-
102
reset
-
102
emit(:close)
-
end
-
-
1
def empty?
-
# this means that for every request there's an available
-
# partial response, so there are no in-flight requests waiting.
-
195
@requests.empty? || @requests.all? { |request| !request.response.nil? }
-
end
-
-
1
def <<(data)
-
377
@parser << data
-
end
-
-
1
def send(request)
-
104
if @max_requests.positive? &&
-
@requests.size >= @max_concurrent_requests
-
@pending << request
-
return
-
end
-
104
unless @requests.include?(request)
-
104
@requests << request
-
104
@pipelining = true if @requests.size > 1
-
end
-
104
handle(request)
-
end
-
-
1
def reenqueue!
-
requests = @requests.dup
-
@requests.clear
-
requests.each do |request|
-
send(request)
-
end
-
end
-
-
1
def consume
-
52154
@requests.each do |request|
-
52146
handle(request)
-
end
-
end
-
-
# HTTP Parser callbacks
-
#
-
# must be public methods, or else they won't be reachable
-
-
1
def on_start
-
99
log(level: 2) { "parsing begins" }
-
end
-
-
1
def on_headers(h)
-
99
@request = @requests.first
-
99
return if @request.response
-
-
99
log(level: 2) { "headers received" }
-
99
headers = @request.options.headers_class.new(h)
-
99
response = @request.options.response_class.new(@request,
-
@parser.status_code,
-
@parser.http_version.join("."),
-
headers)
-
99
log(color: :yellow) { "-> HEADLINE: #{response.status} HTTP/#{@parser.http_version.join(".")}" }
-
99
log(color: :yellow) { response.headers.each.map { |f, v| "-> HEADER: #{f}: #{v}" }.join("\n") }
-
-
99
@request.response = response
-
99
on_complete if response.complete?
-
end
-
-
1
def on_trailers(h)
-
return unless @request
-
-
response = @request.response
-
log(level: 2) { "trailer headers received" }
-
-
log(color: :yellow) { h.each.map { |f, v| "-> HEADER: #{f}: #{v}" }.join("\n") }
-
response.merge_headers(h)
-
end
-
-
1
def on_data(chunk)
-
112
return unless @request
-
-
112
log(color: :green) { "-> DATA: #{chunk.bytesize} bytes..." }
-
112
log(level: 2, color: :green) { "-> #{chunk.inspect}" }
-
112
response = @request.response
-
-
112
response << chunk
-
end
-
-
1
def on_complete
-
99
return unless @request
-
-
99
log(level: 2) { "parsing complete" }
-
99
dispatch
-
end
-
-
1
def dispatch
-
99
if @request.expects?
-
4
reset
-
4
return handle(@request)
-
end
-
-
95
request = @request
-
95
@request = nil
-
95
@requests.shift
-
95
response = request.response
-
95
emit(:response, request, response)
-
-
94
if @parser.upgrade?
-
1
response << @parser.upgrade_data
-
1
throw(:called)
-
end
-
-
93
reset
-
93
@max_requests -= 1
-
93
send(@pending.shift) unless @pending.empty?
-
93
manage_connection(response)
-
end
-
-
1
def handle_error(ex)
-
if @pipelining
-
disable
-
else
-
@requests.each do |request|
-
emit(:error, request, ex)
-
end
-
end
-
end
-
-
1
private
-
-
1
def manage_connection(response)
-
93
connection = response.headers["connection"]
-
93
case connection
-
when /keep\-alive/i
-
3
keep_alive = response.headers["keep-alive"]
-
3
return unless keep_alive
-
-
parameters = Hash[keep_alive.split(/ *, */).map do |pair|
-
pair.split(/ *= */)
-
end]
-
@max_requests = parameters["max"].to_i if parameters.key?("max")
-
if parameters.key?("timeout")
-
keep_alive_timeout = parameters["timeout"].to_i
-
emit(:timeout, keep_alive_timeout)
-
end
-
when /close/i
-
85
@max_requests = Float::INFINITY
-
85
disable
-
when nil
-
# In HTTP/1.1, it's keep alive by default
-
5
return if response.version == "1.1"
-
-
@max_requests = Float::INFINITY
-
disable
-
end
-
end
-
-
1
def disable
-
85
disable_pipelining
-
85
emit(:reset)
-
85
throw(:called)
-
end
-
-
1
def disable_pipelining
-
85
return if @requests.empty?
-
-
@requests.each { |r| r.transition(:idle) }
-
# server doesn't handle pipelining, and probably
-
# doesn't support keep-alive. Fallback to send only
-
# 1 keep alive request.
-
@max_concurrent_requests = 1
-
@pipelining = false
-
end
-
-
1
def set_request_headers(request)
-
52254
request.headers["host"] ||= request.authority
-
52254
request.headers["connection"] ||= "keep-alive"
-
52254
if !request.headers.key?("content-length") &&
-
request.body.bytesize == Float::INFINITY
-
request.chunk!
-
end
-
end
-
-
1
def headline_uri(request)
-
102
request.path
-
end
-
-
1
def handle(request)
-
52254
set_request_headers(request)
-
52254
catch(:buffer_full) do
-
52254
request.transition(:headers)
-
52254
join_headers(request) if request.state == :headers
-
52254
request.transition(:body)
-
52254
join_body(request) if request.state == :body
-
52246
request.transition(:done)
-
end
-
end
-
-
1
def join_headers(request)
-
104
buffer = +""
-
104
buffer << "#{request.verb.to_s.upcase} #{headline_uri(request)} HTTP/#{@version.join(".")}" << CRLF
-
104
log(color: :yellow) { "<- HEADLINE: #{buffer.chomp.inspect}" }
-
104
@buffer << buffer
-
104
buffer.clear
-
104
request.headers.each do |field, value|
-
513
buffer << "#{capitalized(field)}: #{value}" << CRLF
-
513
log(color: :yellow) { "<- HEADER: #{buffer.chomp}" }
-
513
@buffer << buffer
-
513
buffer.clear
-
end
-
104
log { "<- " }
-
104
@buffer << CRLF
-
end
-
-
1
def join_body(request)
-
112
return if request.empty?
-
-
90
while (chunk = request.drain_body)
-
55
log(color: :green) { "<- DATA: #{chunk.bytesize} bytes..." }
-
55
log(level: 2, color: :green) { "<- #{chunk.inspect}" }
-
55
@buffer << chunk
-
55
throw(:buffer_full, request) if @buffer.full?
-
end
-
end
-
-
UPCASED = {
-
1
"www-authenticate" => "WWW-Authenticate",
-
"http2-settings" => "HTTP2-Settings",
-
}.freeze
-
-
1
def capitalized(field)
-
513
UPCASED[field] || field.to_s.split("-").map(&:capitalize).join("-")
-
end
-
end
-
1
Connection.register "http/1.1", Connection::HTTP1
-
end
-
# frozen_string_literal: true
-
-
1
require "io/wait"
-
1
require "http/2/next"
-
-
1
module HTTPX
-
1
class Connection::HTTP2
-
1
include Callbacks
-
1
include Loggable
-
-
1
Error = Class.new(Error) do
-
1
def initialize(id, code)
-
super("stream #{id} closed with error: #{code}")
-
end
-
end
-
-
1
attr_reader :streams, :pending
-
-
1
def initialize(buffer, options)
-
96
@options = Options.new(options)
-
96
@max_concurrent_requests = @options.max_concurrent_requests
-
96
@pending = []
-
96
@streams = {}
-
96
@drains = {}
-
96
@buffer = buffer
-
96
@handshake_completed = false
-
96
init_connection
-
end
-
-
1
def close
-
86
@connection.goaway
-
end
-
-
1
def empty?
-
86
@connection.state == :closed || @streams.empty?
-
end
-
-
1
def <<(data)
-
687
@connection << data
-
end
-
-
1
def send(request, **)
-
214
if !@handshake_completed ||
-
@connection.active_stream_count >= @max_concurrent_requests
-
99
@pending << request
-
99
return
-
end
-
115
unless (stream = @streams[request])
-
115
stream = @connection.new_stream
-
115
handle_stream(stream, request)
-
115
@streams[request] = stream
-
end
-
115
handle(request, stream)
-
115
true
-
end
-
-
1
def reenqueue!
-
requests = @streams.keys
-
@streams.clear
-
init_connection
-
requests.each do |request|
-
send(request)
-
end
-
end
-
-
1
def consume
-
838372
@streams.each do |request, stream|
-
286293
handle(request, stream)
-
end
-
end
-
-
1
def handle_error(ex)
-
@streams.each_key do |request|
-
emit(:error, request, ex)
-
end
-
@pending.each do |request|
-
emit(:error, request, ex)
-
end
-
end
-
-
1
private
-
-
1
def send_pending
-
286
while (request = @pending.shift)
-
97
break unless send(request)
-
end
-
end
-
-
1
def headline_uri(request)
-
115
request.path
-
end
-
-
1
def set_request_headers(request); end
-
-
1
def handle(request, stream)
-
286408
catch(:buffer_full) do
-
286408
request.transition(:headers)
-
286408
join_headers(stream, request) if request.state == :headers
-
286408
request.transition(:body)
-
286408
join_body(stream, request) if request.state == :body
-
286400
request.transition(:done)
-
end
-
end
-
-
1
def init_connection
-
96
@connection = HTTP2Next::Client.new(@options.http2_settings)
-
96
@connection.on(:frame, &method(:on_frame))
-
96
@connection.on(:frame_sent, &method(:on_frame_sent))
-
96
@connection.on(:frame_received, &method(:on_frame_received))
-
96
@connection.on(:promise, &method(:on_promise))
-
96
@connection.on(:altsvc) { |frame| on_altsvc(frame[:origin], frame) }
-
96
@connection.on(:settings_ack, &method(:on_settings))
-
96
@connection.on(:goaway, &method(:on_close))
-
#
-
# Some servers initiate HTTP/2 negotiation right away, some don't.
-
# As such, we have to check the socket buffer. If there is something
-
# to read, the server initiated the negotiation. If not, we have to
-
# initiate it.
-
#
-
96
@connection.send_connection_preface
-
end
-
-
1
def handle_stream(stream, request)
-
116
stream.on(:close, &method(:on_stream_close).curry[stream, request])
-
116
stream.on(:half_close) do
-
115
log(level: 2, label: "#{stream.id}: ") { "waiting for response..." }
-
end
-
116
stream.on(:altsvc, &method(:on_altsvc).curry[request.origin])
-
116
stream.on(:headers, &method(:on_stream_headers).curry[stream, request])
-
116
stream.on(:data, &method(:on_stream_data).curry[stream, request])
-
end
-
-
1
def join_headers(stream, request)
-
115
set_request_headers(request)
-
115
headers = {}
-
115
headers[":scheme"] = request.scheme
-
115
headers[":method"] = request.verb.to_s.upcase
-
115
headers[":path"] = headline_uri(request)
-
115
headers[":authority"] = request.authority
-
115
headers = headers.merge(request.headers)
-
115
log(level: 1, label: "#{stream.id}: ", color: :yellow) do
-
headers.map { |k, v| "-> HEADER: #{k}: #{v}" }.join("\n")
-
end
-
115
stream.headers(headers, end_stream: request.empty?)
-
end
-
-
1
def join_body(stream, request)
-
123
return if request.empty?
-
-
49
chunk = @drains.delete(request) || request.drain_body
-
49
while chunk
-
61
next_chunk = request.drain_body
-
61
log(level: 1, label: "#{stream.id}: ", color: :green) { "-> DATA: #{chunk.bytesize} bytes..." }
-
61
log(level: 2, label: "#{stream.id}: ", color: :green) { "-> #{chunk.inspect}" }
-
61
stream.data(chunk, end_stream: !next_chunk)
-
61
if next_chunk && @buffer.full?
-
8
@drains[request] = next_chunk
-
8
throw(:buffer_full)
-
end
-
53
chunk = next_chunk
-
end
-
end
-
-
######
-
# HTTP/2 Callbacks
-
######
-
-
1
def on_stream_headers(stream, request, h)
-
112
log(label: "#{stream.id}:", color: :yellow) do
-
h.map { |k, v| "<- HEADER: #{k}: #{v}" }.join("\n")
-
end
-
112
_, status = h.shift
-
112
headers = request.options.headers_class.new(h)
-
112
response = request.options.response_class.new(request, status, "2.0", headers)
-
112
request.response = response
-
112
@streams[request] = stream
-
end
-
-
1
def on_stream_data(stream, request, data)
-
189
log(level: 1, label: "#{stream.id}: ", color: :green) { "<- DATA: #{data.bytesize} bytes..." }
-
189
log(level: 2, label: "#{stream.id}: ", color: :green) { "<- #{data.inspect}" }
-
189
request.response << data
-
end
-
-
1
def on_stream_close(stream, request, error)
-
108
return handle(request, stream) if request.expects?
-
-
108
if error && error != :no_error
-
ex = Error.new(stream.id, error)
-
ex.set_backtrace(caller)
-
emit(:error, request, ex)
-
else
-
108
response = request.response
-
108
if response.status == 421
-
ex = MisdirectedRequestError.new(response)
-
ex.set_backtrace(caller)
-
emit(:error, request, ex)
-
else
-
108
emit(:response, request, response)
-
end
-
end
-
108
log(level: 2, label: "#{stream.id}: ") { "closing stream" }
-
-
108
@streams.delete(request)
-
108
send(@pending.shift) unless @pending.empty?
-
end
-
-
1
def on_frame(bytes)
-
567
@buffer << bytes
-
end
-
-
1
def on_settings(*)
-
95
@handshake_completed = true
-
95
@max_concurrent_requests = [@max_concurrent_requests,
-
@connection.remote_settings[:settings_max_concurrent_streams]].min
-
95
send_pending
-
end
-
-
1
def on_close(_last_frame, error, _payload)
-
if error && error != :no_error
-
ex = Error.new(0, error)
-
ex.set_backtrace(caller)
-
@streams.each_key do |request|
-
emit(:error, request, ex)
-
end
-
end
-
return unless @connection.state == :closed && @connection.active_stream_count.zero?
-
-
emit(:close)
-
end
-
-
1
def on_frame_sent(frame)
-
471
log(level: 2, label: "#{frame[:stream]}: ") { "frame was sent!" }
-
471
log(level: 2, label: "#{frame[:stream]}: ", color: :blue) do
-
case frame[:type]
-
when :data
-
frame.merge(payload: frame[:payload].bytesize).inspect
-
else
-
frame.inspect
-
end
-
end
-
end
-
-
1
def on_frame_received(frame)
-
504
log(level: 2, label: "#{frame[:stream]}: ") { "frame was received!" }
-
504
log(level: 2, label: "#{frame[:stream]}: ", color: :magenta) do
-
case frame[:type]
-
when :data
-
frame.merge(payload: frame[:payload].bytesize).inspect
-
else
-
frame.inspect
-
end
-
end
-
end
-
-
1
def on_altsvc(origin, frame)
-
log(level: 2, label: "#{frame[:stream]}: ") { "altsvc frame was received" }
-
log(level: 2, label: "#{frame[:stream]}: ") { frame.inspect }
-
alt_origin = URI.parse("#{frame[:proto]}://#{frame[:host]}:#{frame[:port]}")
-
params = { "ma" => frame[:max_age] }
-
emit(:altsvc, origin, alt_origin, origin, params)
-
end
-
-
1
def on_promise(stream)
-
2
emit(:promise, @streams.key(stream.parent), stream)
-
end
-
-
1
def respond_to_missing?(meth, *args)
-
@connection.respond_to?(meth, *args) || super
-
end
-
-
1
def method_missing(meth, *args, &blk)
-
if @connection.respond_to?(meth)
-
@connection.__send__(meth, *args, &blk)
-
else
-
super
-
end
-
end
-
end
-
1
Connection.register "h2", Connection::HTTP2
-
end
-
# frozen_string_literal: true
-
-
1
module HTTPX
-
1
Error = Class.new(StandardError)
-
-
1
UnsupportedSchemeError = Class.new(Error)
-
-
1
TimeoutError = Class.new(Error) do
-
1
attr_reader :timeout
-
-
1
def initialize(timeout, message)
-
18
@timeout = timeout
-
18
super(message)
-
end
-
-
1
def to_connection_error
-
ex = ConnectTimeoutError.new(@timeout, message)
-
ex.set_backtrace(backtrace)
-
ex
-
end
-
end
-
-
1
TotalTimeoutError = Class.new(TimeoutError)
-
-
1
ConnectTimeoutError = Class.new(TimeoutError)
-
-
1
ResolveError = Class.new(Error)
-
-
1
NativeResolveError = Class.new(ResolveError) do
-
1
attr_reader :connection, :host
-
1
def initialize(connection, host, message = "Can't resolve #{host}")
-
1
@connection = connection
-
1
@host = host
-
1
super(message)
-
end
-
end
-
-
1
HTTPError = Class.new(Error) do
-
1
attr_reader :response
-
-
1
def initialize(response)
-
2
@response = response
-
2
super("HTTP Error: #{@response.status}")
-
end
-
-
1
def status
-
@response.status
-
end
-
end
-
-
1
MisdirectedRequestError = Class.new(HTTPError)
-
end
-
# frozen_string_literal: true
-
-
1
module HTTPX
-
1
class Headers
-
1
EMPTY = [].freeze # :nodoc:
-
-
1
class << self
-
1
def new(headers = nil)
-
2223
return headers if headers.is_a?(self)
-
-
795
super
-
end
-
end
-
-
1
def initialize(headers = nil)
-
795
@headers = {}
-
795
return unless headers
-
-
794
headers.each do |field, value|
-
1821
array_value(value).each do |v|
-
1836
add(downcased(field), v)
-
end
-
end
-
end
-
-
# cloned initialization
-
1
def initialize_clone(orig)
-
super
-
@headers = orig.instance_variable_get(:@headers).clone
-
end
-
-
# dupped initialization
-
1
def initialize_dup(orig)
-
739
super
-
739
@headers = orig.instance_variable_get(:@headers).dup
-
end
-
-
# freezes the headers hash
-
1
def freeze
-
139
@headers.freeze
-
139
super
-
end
-
-
1
def same_headers?(headers)
-
385
@headers.empty? || begin
-
370
headers.each do |k, v|
-
125
return false unless v == self[k]
-
end
-
291
true
-
end
-
end
-
-
# merges headers with another header-quack.
-
# the merge rule is, if the header already exists,
-
# ignore what the +other+ headers has. Otherwise, set
-
#
-
1
def merge(other)
-
541
headers = dup
-
541
other.each do |field, value|
-
425
headers[field] = value
-
end
-
541
headers
-
end
-
-
# returns the comma-separated values of the header field
-
# identified by +field+, or nil otherwise.
-
#
-
1
def [](field)
-
106283
a = @headers[downcased(field)] || return
-
104943
a.join(",")
-
end
-
-
# sets +value+ (if not nil) as single value for the +field+ header.
-
#
-
1
def []=(field, value)
-
1285
return unless value
-
-
1285
@headers[downcased(field)] = array_value(value)
-
end
-
-
# deletes all values associated with +field+ header.
-
#
-
1
def delete(field)
-
27
canonical = downcased(field)
-
27
@headers.delete(canonical) if @headers.key?(canonical)
-
end
-
-
# adds additional +value+ to the existing, for header +field+.
-
#
-
1
def add(field, value)
-
1849
(@headers[downcased(field)] ||= []) << String(value)
-
end
-
-
# helper to be used when adding an header field as a value to another field
-
#
-
# h2_headers.add_header("vary", "accept-encoding")
-
# h2_headers["vary"] #=> "accept-encoding"
-
# h1_headers.add_header("vary", "accept-encoding")
-
# h1_headers["vary"] #=> "Accept-Encoding"
-
#
-
1
alias_method :add_header, :add
-
-
# returns the enumerable headers store in pairs of header field + the values in
-
# the comma-separated string format
-
#
-
1
def each
-
1461
return enum_for(__method__) { @headers.size } unless block_given?
-
-
1340
@headers.each do |field, value|
-
1731
yield(field, value.join(", ")) unless value.empty?
-
end
-
end
-
-
1
def ==(other)
-
1
to_hash == Headers.new(other).to_hash
-
end
-
-
# the headers store in Hash format
-
1
def to_hash
-
117
Hash[to_a]
-
end
-
-
# the headers store in array of pairs format
-
1
def to_a
-
120
Array(each)
-
end
-
-
# headers as string
-
1
def to_s
-
@headers.to_s
-
end
-
-
# this is internal API and doesn't abide to other public API
-
# guarantees, like downcasing strings.
-
# Please do not use this outside of core!
-
#
-
1
def key?(downcased_key)
-
53567
@headers.key?(downcased_key)
-
end
-
-
# returns the values for the +field+ header in array format.
-
# This method is more internal, and for this reason doesn't try
-
# to "correct" the user input, i.e. it doesn't downcase the key.
-
#
-
1
def get(field)
-
37
@headers[field] || EMPTY
-
end
-
-
1
private
-
-
1
def array_value(value)
-
3106
case value
-
when Array
-
1719
value.map { |val| String(val).strip }
-
else
-
2263
[String(value).strip]
-
end
-
end
-
-
1
def downcased(field)
-
111280
String(field).downcase
-
end
-
end
-
end
-
# frozen_string_literal: true
-
-
1
require "socket"
-
1
require "httpx/io/tcp"
-
1
require "httpx/io/ssl"
-
1
require "httpx/io/unix"
-
1
require "httpx/io/udp"
-
-
1
module HTTPX
-
1
module IO
-
1
extend Registry
-
1
register "tcp", TCP
-
1
register "ssl", SSL
-
1
register "udp", UDP
-
1
register "unix", HTTPX::UNIX
-
end
-
end
-
# frozen_string_literal: true
-
-
1
require "resolv"
-
1
require "ipaddr"
-
-
1
module HTTPX
-
1
class TCP
-
1
include Loggable
-
-
1
attr_reader :ip, :port
-
-
1
attr_reader :addresses
-
-
1
alias_method :host, :ip
-
-
1
def initialize(origin, addresses, options)
-
206
@state = :idle
-
206
@hostname = origin.host
-
206
@addresses = addresses
-
206
@options = Options.new(options)
-
206
@fallback_protocol = @options.fallback_protocol
-
206
@port = origin.port
-
206
if @options.io
-
4
@io = case @options.io
-
when Hash
-
@options.io[origin.authority]
-
else
-
4
@options.io
-
end
-
4
_, _, _, @ip = @io.addr
-
4
@addresses ||= [@ip]
-
4
@ip_index = @addresses.size - 1
-
4
unless @io.nil?
-
4
@keep_open = true
-
4
@state = :connected
-
end
-
else
-
202
@ip_index = @addresses.size - 1
-
202
@ip = @addresses[@ip_index]
-
end
-
206
@io ||= build_socket
-
end
-
-
1
def scheme
-
"http"
-
end
-
-
1
def to_io
-
3570338
@io.to_io
-
end
-
-
1
def protocol
-
97
@fallback_protocol
-
end
-
-
1
def connect
-
7900
return unless closed?
-
-
begin
-
1146
if @io.closed?
-
transition(:idle)
-
@io = build_socket
-
end
-
1146
@io.connect_nonblock(Socket.sockaddr_in(@port, @ip.to_s))
-
rescue Errno::EISCONN
-
end
-
195
transition(:connected)
-
rescue Errno::EHOSTUNREACH => e
-
raise e if @ip_index <= 0
-
-
@ip_index -= 1
-
retry
-
rescue Errno::EINPROGRESS,
-
Errno::EALREADY,
-
::IO::WaitReadable
-
end
-
-
1
if RUBY_VERSION < "2.3"
-
def read(size, buffer)
-
@io.read_nonblock(size, buffer)
-
buffer.bytesize
-
rescue ::IO::WaitReadable
-
0
-
rescue EOFError
-
nil
-
end
-
-
def write(buffer)
-
siz = @io.write_nonblock(buffer)
-
buffer.shift!(siz)
-
siz
-
rescue ::IO::WaitWritable
-
0
-
rescue EOFError
-
nil
-
end
-
else
-
1
def read(size, buffer)
-
891606
ret = @io.read_nonblock(size, buffer, exception: false)
-
891606
return 0 if ret == :wait_readable
-
1072
return if ret.nil?
-
-
1072
buffer.bytesize
-
end
-
-
1
def write(buffer)
-
444
siz = @io.write_nonblock(buffer, exception: false)
-
444
return 0 if siz == :wait_writable
-
444
return if siz.nil?
-
-
444
buffer.shift!(siz)
-
444
siz
-
end
-
end
-
-
1
def close
-
188
return if @keep_open || closed?
-
-
begin
-
184
@io.close
-
ensure
-
184
transition(:closed)
-
end
-
end
-
-
1
def connected?
-
345
@state == :connected
-
end
-
-
1
def closed?
-
902209
@state == :idle || @state == :closed
-
end
-
-
1
def inspect
-
id = @io.closed? ? "closed" : @io.fileno
-
"#<TCP(fd: #{id}): #{@ip}:#{@port} (state: #{@state})>"
-
end
-
-
1
private
-
-
1
def build_socket
-
198
Socket.new(@ip.family, :STREAM, 0)
-
end
-
-
1
def transition(nextstate)
-
198
case nextstate
-
# when :idle
-
when :connected
-
101
return unless @state == :idle
-
when :closed
-
97
return unless @state == :connected
-
end
-
198
do_transition(nextstate)
-
end
-
-
1
def do_transition(nextstate)
-
477
log(level: 1) do
-
log_transition_state(nextstate)
-
end
-
477
@state = nextstate
-
end
-
-
1
def log_transition_state(nextstate)
-
case nextstate
-
when :connected
-
"Connected to #{@hostname} (#{@ip}) port #{@port} (##{@io.fileno})"
-
else
-
"#{@ip}:#{@port} #{@state} -> #{nextstate}"
-
end
-
end
-
end
-
end
-
# frozen_string_literal: true
-
-
1
require "socket"
-
1
require "ipaddr"
-
-
1
module HTTPX
-
1
class UDP
-
1
include Loggable
-
-
1
def initialize(uri, _, _)
-
20
ip = IPAddr.new(uri.host)
-
20
@host = ip.to_s
-
20
@port = uri.port
-
20
@io = UDPSocket.new(ip.family)
-
end
-
-
1
def to_io
-
80
@io.to_io
-
end
-
-
1
def connect; end
-
-
1
def connected?
-
20
true
-
end
-
-
1
def close
-
20
@io.close
-
end
-
-
1
def write(buffer)
-
20
siz = @io.send(buffer, 0, @host, @port)
-
20
buffer.shift!(siz)
-
20
siz
-
end
-
-
1
if RUBY_VERSION < "2.3"
-
def read(size, buffer)
-
data, _ = @io.recvfrom_nonblock(size)
-
buffer.replace(data)
-
buffer.bytesize
-
rescue ::IO::WaitReadable
-
0
-
rescue IOError
-
end
-
else
-
1
def read(size, buffer)
-
60
ret = @io.recvfrom_nonblock(size, 0, buffer, exception: false)
-
40
return 0 if ret == :wait_readable
-
20
return if ret.nil?
-
-
20
buffer.bytesize
-
rescue IOError
-
end
-
end
-
end
-
end
-
# frozen_string_literal: true
-
-
1
require "forwardable"
-
-
1
module HTTPX
-
1
class UNIX < TCP
-
1
extend Forwardable
-
-
1
def_delegator :@uri, :port, :scheme
-
-
1
def initialize(uri, addresses, options)
-
1
@uri = uri
-
1
@addresses = addresses
-
1
@state = :idle
-
1
@options = Options.new(options)
-
1
@path = @options.transport_options[:path]
-
1
@fallback_protocol = @options.fallback_protocol
-
1
if @options.io
-
@io = case @options.io
-
when Hash
-
@options.io[@path]
-
else
-
@options.io
-
end
-
unless @io.nil?
-
@keep_open = true
-
@state = :connected
-
end
-
end
-
1
@io ||= build_socket
-
end
-
-
1
def hostname
-
@uri.host
-
end
-
-
1
def connect
-
1
return unless closed?
-
-
begin
-
1
if @io.closed?
-
transition(:idle)
-
@io = build_socket
-
end
-
1
@io.connect_nonblock(Socket.sockaddr_un(@path))
-
rescue Errno::EISCONN
-
end
-
1
transition(:connected)
-
rescue Errno::EINPROGRESS,
-
Errno::EALREADY,
-
::IO::WaitReadable
-
end
-
-
1
private
-
-
1
def build_socket
-
1
Socket.new(Socket::PF_UNIX, :STREAM, 0)
-
end
-
end
-
end
-
# frozen_string_literal: true
-
-
1
module HTTPX
-
1
class Options
-
1
MAX_CONCURRENT_REQUESTS = 100
-
1
WINDOW_SIZE = 1 << 14 # 16K
-
1
MAX_BODY_THRESHOLD_SIZE = (1 << 10) * 112 # 112K
-
-
1
class << self
-
1
def inherited(klass)
-
34
super
-
34
klass.instance_variable_set(:@defined_options, @defined_options.dup)
-
end
-
-
1
def new(options = {})
-
# let enhanced options go through
-
2459
return options if self == Options && options.class > self
-
2459
return options if options.is_a?(self)
-
-
1530
super
-
end
-
-
1
def defined_options
-
1731
@defined_options ||= []
-
end
-
-
1
def def_option(name, &interpreter)
-
76
defined_options << name.to_sym
-
79
interpreter ||= ->(v) { v }
-
-
76
attr_accessor name
-
76
protected :"#{name}="
-
-
76
define_method(:"with_#{name}") do |value|
-
60
other = dup
-
60
other.send(:"#{name}=", other.instance_exec(value, &interpreter))
-
60
other
-
end
-
end
-
end
-
-
1
def initialize(options = {})
-
defaults = {
-
3060
:debug => ENV.key?("HTTPX_DEBUG") ? $stderr : nil,
-
1530
:debug_level => (ENV["HTTPX_DEBUG"] || 1).to_i,
-
:ssl => {},
-
:http2_settings => { settings_enable_push: 0 },
-
:fallback_protocol => "http/1.1",
-
:timeout => Timeout.new,
-
:headers => {},
-
:max_concurrent_requests => MAX_CONCURRENT_REQUESTS,
-
:window_size => WINDOW_SIZE,
-
:body_threshold_size => MAX_BODY_THRESHOLD_SIZE,
-
:request_class => Class.new(Request),
-
:response_class => Class.new(Response),
-
:headers_class => Class.new(Headers),
-
:request_body_class => Class.new(Request::Body),
-
:response_body_class => Class.new(Response::Body),
-
:connection_class => Class.new(Connection),
-
:transport => nil,
-
:transport_options => nil,
-
:persistent => false,
-
1530
:resolver_class => (ENV["HTTPX_RESOLVER"] || :native).to_sym,
-
}
-
-
1530
defaults.merge!(options)
-
1530
defaults[:headers] = Headers.new(defaults[:headers])
-
41395
defaults.each { |(k, v)| self[k] = v }
-
end
-
-
1
def_option(:headers) do |headers|
-
23
self.headers.merge(headers)
-
end
-
-
1
def_option(:timeout) do |opts|
-
8
self.timeout = Timeout.new(opts)
-
end
-
-
1
def_option(:max_concurrent_requests) do |num|
-
max = Integer(num)
-
raise Error, ":max_concurrent_requests must be positive" unless max.positive?
-
-
self.max_concurrent_requests = max
-
end
-
-
1
def_option(:window_size) do |num|
-
self.window_size = Integer(num)
-
end
-
-
1
def_option(:body_threshold_size) do |num|
-
self.body_threshold_size = Integer(num)
-
end
-
-
1
def_option(:transport) do |tr|
-
transport = tr.to_s
-
raise Error, "#{transport} is an unsupported transport type" unless IO.registry.key?(transport)
-
-
self.transport = transport
-
end
-
-
1
%w[
-
params form json body
-
follow ssl http2_settings
-
request_class response_class headers_class request_body_class response_body_class connection_class
-
io fallback_protocol debug debug_level transport_options resolver_class resolver_options
-
persistent
-
].each do |method_name|
-
21
def_option(method_name)
-
end
-
-
1
REQUEST_IVARS = %i[@params @form @json @body].freeze
-
-
1
def ==(other)
-
441
ivars = instance_variables | other.instance_variables
-
441
ivars.all? do |ivar|
-
4657
case ivar
-
when :@headers
-
385
headers = instance_variable_get(ivar)
-
385
headers.same_headers?(other.instance_variable_get(ivar))
-
when *REQUEST_IVARS
-
92
true
-
else
-
4180
instance_variable_get(ivar) == other.instance_variable_get(ivar)
-
end
-
end
-
end
-
-
1
def merge(other)
-
1183
h1 = to_hash
-
1183
h2 = other.to_hash
-
-
1183
merged = h1.merge(h2) do |k, v1, v2|
-
12409
case k
-
when :headers, :ssl, :http2_settings, :timeout
-
1865
v1.merge(v2)
-
else
-
10544
v2
-
end
-
end
-
-
1183
self.class.new(merged)
-
end
-
-
1
def to_hash
-
1655
hash_pairs = self.class
-
.defined_options
-
45653
.flat_map { |opt_name| [opt_name, send(opt_name)] }
-
1655
Hash[*hash_pairs]
-
end
-
-
1
def initialize_dup(other)
-
198
self.headers = other.headers.dup
-
198
self.ssl = other.ssl.dup
-
198
self.request_class = other.request_class.dup
-
198
self.response_class = other.response_class.dup
-
198
self.headers_class = other.headers_class.dup
-
198
self.request_body_class = other.request_body_class.dup
-
198
self.response_body_class = other.response_body_class.dup
-
198
self.connection_class = other.connection_class.dup
-
end
-
-
1
def freeze
-
139
super
-
-
139
headers.freeze
-
139
ssl.freeze
-
139
request_class.freeze
-
139
response_class.freeze
-
139
headers_class.freeze
-
139
request_body_class.freeze
-
139
response_body_class.freeze
-
139
connection_class.freeze
-
end
-
-
1
protected
-
-
1
def []=(option, val)
-
39865
send(:"#{option}=", val)
-
end
-
end
-
end
-
# frozen_string_literal: true
-
-
1
module HTTPX
-
1
module Parser
-
1
Error = Class.new(Error)
-
-
1
class HTTP1
-
1
VERSIONS = %w[1.0 1.1].freeze
-
-
1
attr_reader :status_code, :http_version, :headers
-
-
1
def initialize(observer, header_separator: ":")
-
124
@observer = observer
-
124
@state = :idle
-
124
@header_separator = header_separator
-
124
@buffer = "".b
-
124
@headers = {}
-
end
-
-
1
def <<(chunk)
-
396
@buffer << chunk
-
396
parse
-
end
-
-
1
def reset!
-
214
@state = :idle
-
214
@headers.clear
-
214
@content_length = nil
-
214
@_has_trailers = nil
-
end
-
-
1
def upgrade?
-
94
@upgrade
-
end
-
-
1
def upgrade_data
-
1
@buffer
-
end
-
-
1
private
-
-
1
def parse
-
599
state = @state
-
599
case @state
-
when :idle
-
118
parse_headline
-
when :headers
-
122
parse_headers
-
when :trailers
-
parse_headers
-
when :data
-
359
parse_data
-
end
-
512
parse if !@buffer.empty? && state != @state
-
end
-
-
1
def parse_headline
-
118
idx = @buffer.index("\n")
-
118
return unless idx
-
-
118
(m = %r{\AHTTP(?:\/(\d+\.\d+))?\s+(\d\d\d)(?:\s+(.*))?}in.match(@buffer)) ||
-
raise(Error, "wrong head line format")
-
118
version, code, _ = m.captures
-
118
raise(Error, "unsupported HTTP version (HTTP/#{version})") unless VERSIONS.include?(version)
-
-
118
@http_version = version.split(".").map(&:to_i)
-
118
@status_code = code.to_i
-
118
raise(Error, "wrong status code (#{@status_code})") unless (100..599).cover?(@status_code)
-
-
# @buffer.slice!(0, idx + 1)
-
118
@buffer = @buffer.byteslice((idx + 1)..-1)
-
118
nextstate(:headers)
-
end
-
-
1
def parse_headers
-
122
headers = @headers
-
1138
while (idx = @buffer.index("\n"))
-
1012
line = @buffer.slice!(0, idx + 1).sub(/\s+\z/, "")
-
1012
if line.empty?
-
118
case @state
-
when :headers
-
118
prepare_data(headers)
-
118
@observer.on_headers(headers)
-
103
return unless @state == :headers
-
-
# state might have been reset
-
# in the :headers callback
-
99
nextstate(:data)
-
99
headers.clear
-
when :trailers
-
@observer.on_trailers(headers)
-
headers.clear
-
nextstate(:complete)
-
else
-
raise Error, "wrong header format"
-
end
-
99
return
-
end
-
894
separator_index = line.index(@header_separator)
-
894
raise Error, "wrong header format" unless separator_index
-
-
894
key = line[0..separator_index - 1]
-
894
raise Error, "wrong header format" if key.start_with?("\s", "\t")
-
-
894
key.strip!
-
894
value = line[separator_index + 1..-1]
-
894
value.strip!
-
894
raise Error, "wrong header format" if value.nil?
-
-
894
(headers[key.downcase] ||= []) << value
-
end
-
end
-
-
1
def parse_data
-
359
if @buffer.respond_to?(:each)
-
263
@buffer.each do |chunk|
-
24
@observer.on_data(chunk)
-
end
-
96
elsif @content_length
-
93
data = @buffer.byteslice(0, @content_length)
-
93
@buffer = @buffer.byteslice(@content_length..-1) || "".b
-
93
@content_length -= data.bytesize
-
93
@observer.on_data(data)
-
93
data.clear
-
else
-
3
@observer.on_data(@buffer)
-
3
@buffer.clear
-
end
-
359
return unless no_more_data?
-
-
86
@buffer = @buffer.to_s
-
86
if @_has_trailers
-
nextstate(:trailers)
-
else
-
86
nextstate(:complete)
-
end
-
end
-
-
1
def prepare_data(headers)
-
118
@upgrade = headers.key?("upgrade")
-
-
118
@_has_trailers = headers.key?("trailer")
-
-
118
if (tr_encodings = headers["transfer-encoding"])
-
9
tr_encodings.reverse_each do |tr_encoding|
-
9
tr_encoding.split(/ *, */).each do |encoding|
-
9
case encoding
-
when "chunked"
-
9
@buffer = Transcoder::Chunker::Decoder.new(@buffer, @_has_trailers)
-
end
-
end
-
end
-
else
-
109
@content_length = headers["content-length"][0].to_i if headers.key?("content-length")
-
end
-
end
-
-
1
def no_more_data?
-
359
if @content_length
-
93
@content_length <= 0
-
266
elsif @buffer.respond_to?(:finished?)
-
263
@buffer.finished?
-
else
-
3
false
-
end
-
end
-
-
1
def nextstate(state)
-
303
@state = state
-
303
case state
-
when :headers
-
118
@observer.on_start
-
when :complete
-
86
@observer.on_complete
-
14
reset!
-
14
nextstate(:idle) unless @buffer.empty?
-
end
-
end
-
end
-
end
-
end
-
# frozen_string_literal: true
-
-
1
module HTTPX
-
1
module Plugins
-
#
-
# This plugin adds a shim +authentication+ method to the session, which will fill
-
# the HTTP Authorization header.
-
#
-
# https://gitlab.com/honeyryderchuck/httpx/wikis/Authentication#authentication
-
#
-
1
module Authentication
-
1
module InstanceMethods
-
1
def authentication(token)
-
4
headers("authorization" => token)
-
end
-
end
-
end
-
1
register_plugin :authentication, Authentication
-
end
-
end
-
# frozen_string_literal: true
-
-
1
module HTTPX
-
1
module Plugins
-
#
-
# This plugin adds helper methods to implement HTTP Basic Auth (https://tools.ietf.org/html/rfc7617)
-
#
-
# https://gitlab.com/honeyryderchuck/httpx/wikis/Authentication#basic-authentication
-
#
-
1
module BasicAuthentication
-
1
def self.load_dependencies(klass)
-
2
require "base64"
-
2
klass.plugin(:authentication)
-
end
-
-
1
module InstanceMethods
-
1
def basic_authentication(user, password)
-
4
authentication("Basic #{Base64.strict_encode64("#{user}:#{password}")}")
-
end
-
1
alias_method :basic_auth, :basic_authentication
-
end
-
end
-
1
register_plugin :basic_authentication, BasicAuthentication
-
end
-
end
-
# frozen_string_literal: true
-
-
1
module HTTPX
-
1
module Plugins
-
#
-
# This plugin adds compression support. Namely it:
-
#
-
# * Compresses the request body when passed a supported "Content-Encoding" mime-type;
-
# * Decompresses the response body from a supported "Content-Encoding" mime-type;
-
#
-
# It supports both *gzip* and *deflate*.
-
#
-
# https://gitlab.com/honeyryderchuck/httpx/wikis/Compression
-
#
-
1
module Compression
-
1
extend Registry
-
1
def self.load_dependencies(klass)
-
15
klass.plugin(:"compression/gzip")
-
15
klass.plugin(:"compression/deflate")
-
end
-
-
1
def self.extra_options(options)
-
15
options.merge(headers: { "accept-encoding" => Compression.registry.keys })
-
end
-
-
1
module RequestMethods
-
1
def initialize(*)
-
34
super
-
# forego compression in the Range cases
-
34
@headers.delete("accept-encoding") if @headers.key?("range")
-
end
-
end
-
-
1
module RequestBodyMethods
-
1
def initialize(*)
-
34
super
-
34
return if @body.nil?
-
-
14
@headers.get("content-encoding").each do |encoding|
-
6
@body = Encoder.new(@body, Compression.registry(encoding).encoder)
-
end
-
14
@headers["content-length"] = @body.bytesize unless chunked?
-
end
-
end
-
-
1
module ResponseBodyMethods
-
1
attr_reader :encodings
-
-
1
def initialize(*)
-
32
@encodings = []
-
-
32
super
-
-
32
return unless @headers.key?("content-encoding")
-
-
9
@_decoders = @headers.get("content-encoding").map do |encoding|
-
9
decoder = Compression.registry(encoding).decoder
-
# do not uncompress if there is no decoder available. In fact, we can't reliably
-
# continue decompressing beyond that, so ignore.
-
9
break unless decoder
-
-
9
@encodings << encoding
-
9
decoder
-
end
-
-
# remove encodings that we are able to decode
-
9
@headers["content-encoding"] = @headers.get("content-encoding") - @encodings
-
-
9
@_compressed_length = if @headers.key?("content-length")
-
7
@headers["content-length"].to_i
-
else
-
2
Float::INFINITY
-
end
-
end
-
-
1
def write(chunk)
-
44
return super unless defined?(@_compressed_length)
-
-
11
@_compressed_length -= chunk.bytesize
-
11
chunk = decompress(chunk)
-
11
super(chunk)
-
end
-
-
1
def close
-
30
super
-
-
30
return unless defined?(@_decoders)
-
-
7
@_decoders.each(&:close)
-
end
-
-
1
private
-
-
1
def decompress(buffer)
-
11
@_decoders.reverse_each do |decoder|
-
11
buffer = decoder.decode(buffer)
-
11
buffer << decoder.finish if @_compressed_length <= 0
-
end
-
11
buffer
-
end
-
end
-
-
1
class Encoder
-
1
def initialize(body, deflater)
-
6
@body = body.respond_to?(:read) ? body : StringIO.new(body.to_s)
-
6
@buffer = StringIO.new("".b, File::RDWR)
-
6
@deflater = deflater
-
end
-
-
1
def each(&blk)
-
6
return enum_for(__method__) unless block_given?
-
-
6
unless @buffer.size.zero?
-
6
@buffer.rewind
-
6
return @buffer.each(&blk)
-
end
-
deflate(&blk)
-
end
-
-
1
def bytesize
-
15
deflate
-
15
@buffer.size
-
end
-
-
1
def to_s
-
deflate
-
@buffer.rewind
-
@buffer.read
-
end
-
-
1
def close
-
@buffer.close
-
@body.close
-
end
-
-
1
private
-
-
1
def deflate(&blk)
-
15
return unless @buffer.size.zero?
-
-
6
@body.rewind
-
6
@deflater.deflate(@body, @buffer, chunk_size: 16_384, &blk)
-
end
-
end
-
-
1
class Decoder
-
1
extend Forwardable
-
-
1
def_delegator :@inflater, :finish
-
-
1
def_delegator :@inflater, :close
-
-
1
def initialize(inflater)
-
9
@inflater = inflater
-
end
-
-
1
def decode(chunk)
-
11
@inflater.inflate(chunk)
-
end
-
end
-
end
-
1
register_plugin :compression, Compression
-
end
-
end
-
# frozen_string_literal: true
-
-
1
module HTTPX
-
1
module Plugins
-
1
module Compression
-
1
module Brotli
-
1
def self.load_dependencies(klass)
-
4
klass.plugin(:compression)
-
4
require "brotli"
-
end
-
-
1
def self.configure(*)
-
4
Compression.register "br", self
-
end
-
-
1
module Encoder
-
1
module_function
-
-
1
def deflate(raw, buffer, chunk_size:)
-
6
while (chunk = raw.read(chunk_size))
-
2
compressed = ::Brotli.deflate(chunk)
-
2
buffer << compressed
-
2
yield compressed if block_given?
-
end
-
end
-
end
-
-
1
module BrotliWrapper
-
1
module_function
-
-
1
def inflate(text)
-
2
::Brotli.inflate(text)
-
end
-
-
1
def close; end
-
-
1
def finish
-
2
""
-
end
-
end
-
-
1
module_function
-
-
1
def encoder
-
2
Encoder
-
end
-
-
1
def decoder
-
2
Decoder.new(BrotliWrapper)
-
end
-
end
-
end
-
1
register_plugin :"compression/brotli", Compression::Brotli
-
end
-
end
-
# frozen_string_literal: true
-
-
1
module HTTPX
-
1
module Plugins
-
1
module Compression
-
1
module Deflate
-
1
def self.load_dependencies(*)
-
15
require "stringio"
-
15
require "zlib"
-
end
-
-
1
def self.configure(*)
-
15
Compression.register "deflate", self
-
end
-
-
1
module Encoder
-
1
module_function
-
-
1
def deflate(raw, buffer, chunk_size:)
-
2
deflater = Zlib::Deflate.new(Zlib::BEST_COMPRESSION,
-
Zlib::MAX_WBITS,
-
Zlib::MAX_MEM_LEVEL,
-
Zlib::HUFFMAN_ONLY)
-
6
while (chunk = raw.read(chunk_size))
-
2
compressed = deflater.deflate(chunk)
-
2
buffer << compressed
-
2
yield compressed if block_given?
-
end
-
2
last = deflater.finish
-
2
buffer << last
-
2
yield last if block_given?
-
ensure
-
2
deflater.close
-
end
-
end
-
-
1
module_function
-
-
1
def encoder
-
2
Encoder
-
end
-
-
1
def decoder
-
2
Decoder.new(Zlib::Inflate.new(32 + Zlib::MAX_WBITS))
-
end
-
end
-
end
-
1
register_plugin :"compression/deflate", Compression::Deflate
-
end
-
end
-
# frozen_string_literal: true
-
-
1
require "forwardable"
-
-
1
module HTTPX
-
1
module Plugins
-
1
module Compression
-
1
module GZIP
-
1
def self.load_dependencies(*)
-
15
require "zlib"
-
end
-
-
1
def self.configure(*)
-
15
Compression.register "gzip", self
-
end
-
-
1
class Encoder
-
1
def deflate(raw, buffer, chunk_size:)
-
2
gzip = Zlib::GzipWriter.new(self)
-
-
6
while (chunk = raw.read(chunk_size))
-
2
gzip.write(chunk)
-
2
gzip.flush
-
2
compressed = compressed_chunk
-
2
buffer << compressed
-
2
yield compressed if block_given?
-
end
-
ensure
-
2
gzip.close
-
end
-
-
1
private
-
-
1
def write(chunk)
-
6
@compressed_chunk = chunk
-
end
-
-
1
def compressed_chunk
-
2
compressed = @compressed_chunk
-
2
compressed
-
ensure
-
2
@compressed_chunk = nil
-
end
-
end
-
-
1
module_function
-
-
1
def encoder
-
2
Encoder.new
-
end
-
-
1
def decoder
-
5
Decoder.new(Zlib::Inflate.new(32 + Zlib::MAX_WBITS))
-
end
-
end
-
end
-
1
register_plugin :"compression/gzip", Compression::GZIP
-
end
-
end
-
# frozen_string_literal: true
-
-
1
require "forwardable"
-
-
1
module HTTPX
-
1
module Plugins
-
#
-
# This plugin implements a persistent cookie jar for the duration of a session.
-
#
-
# It also adds a *#cookies* helper, so that you can pre-fill the cookies of a session.
-
#
-
# https://gitlab.com/honeyryderchuck/httpx/wikis/Cookies
-
#
-
1
module Cookies
-
1
using URIExtensions
-
-
1
def self.extra_options(options)
-
6
Class.new(options.class) do
-
6
def_option(:cookies) do |cookies|
-
6
return cookies if cookies.is_a?(Store)
-
-
6
Store.new(cookies)
-
end
-
end.new(options)
-
end
-
-
1
class Store
-
1
def initialize(cookies = nil)
-
30
@store = Hash.new { |hash, origin| hash[origin] = HTTP::CookieJar.new }
-
18
return unless cookies
-
-
6
cookies = cookies.split(/ *; */) if cookies.is_a?(String)
-
6
@default_cookies = cookies.map do |cookie, v|
-
6
if cookie.is_a?(HTTP::Cookie)
-
cookie
-
else
-
6
HTTP::Cookie.new(cookie.to_s, v.to_s)
-
end
-
end
-
end
-
-
1
def set(origin, cookies)
-
16
return unless cookies
-
-
4
@store[origin].parse(cookies, origin)
-
end
-
-
1
def [](uri)
-
18
store = @store[uri.origin]
-
@default_cookies.each do |cookie|
-
6
c = cookie.dup
-
6
c.domain ||= uri.authority
-
6
c.path ||= uri.path
-
6
store.add(c)
-
18
end if @default_cookies
-
18
store
-
end
-
-
1
def ==(other)
-
1
@store == other.instance_variable_get(:@store)
-
end
-
end
-
-
1
def self.load_dependencies(*)
-
6
require "http/cookie"
-
end
-
-
1
module InstanceMethods
-
1
extend Forwardable
-
-
1
def_delegator :@options, :cookies
-
-
1
def initialize(options = {}, &blk)
-
12
super({ cookies: Store.new }.merge(options), &blk)
-
end
-
-
1
def with_cookies(cookies)
-
6
branch(default_options.with_cookies(cookies))
-
end
-
-
1
def wrap
-
return super unless block_given?
-
-
super do |session|
-
old_cookies_store = @options.cookies.dup
-
begin
-
yield session
-
ensure
-
@options = @options.with_cookies(old_cookies_store)
-
end
-
end
-
end
-
-
1
private
-
-
1
def on_response(request, response)
-
16
@options.cookies.set(request.origin, response.headers["set-cookie"]) if response.respond_to?(:headers)
-
-
16
super
-
end
-
-
1
def build_request(*, _)
-
16
request = super
-
16
request.headers.set_cookie(@options.cookies[request.uri])
-
16
request
-
end
-
end
-
-
1
module HeadersMethods
-
1
def set_cookie(jar)
-
16
return unless jar
-
-
16
cookie_value = HTTP::Cookie.cookie_value(jar.cookies)
-
16
return if cookie_value.empty?
-
-
10
add("cookie", cookie_value)
-
end
-
end
-
end
-
1
register_plugin :cookies, Cookies
-
end
-
end
-
# frozen_string_literal: true
-
-
1
module HTTPX
-
1
module Plugins
-
#
-
# This plugin adds helper methods to implement HTTP Digest Auth (https://tools.ietf.org/html/rfc7616)
-
#
-
# https://gitlab.com/honeyryderchuck/httpx/wikis/Authentication#authentication
-
#
-
1
module DigestAuthentication
-
1
DigestError = Class.new(Error)
-
-
1
def self.extra_options(options)
-
2
Class.new(options.class) do
-
2
def_option(:digest) do |digest|
-
2
raise Error, ":digest must be a Digest" unless digest.is_a?(Digest)
-
-
2
digest
-
end
-
end.new(options)
-
end
-
-
1
def self.load_dependencies(*)
-
2
require "securerandom"
-
2
require "digest"
-
end
-
-
1
module InstanceMethods
-
1
def digest_authentication(user, password)
-
2
branch(default_options.with_digest(Digest.new(user, password)))
-
end
-
-
1
alias_method :digest_auth, :digest_authentication
-
-
1
def request(*args, **options)
-
2
requests = build_requests(*args, options)
-
2
probe_request = requests.first
-
2
digest = probe_request.options.digest
-
-
2
return super unless digest
-
-
4
prev_response = wrap { send_requests(*probe_request, options).first }
-
-
2
raise Error, "request doesn't require authentication (status: #{prev_response.status})" unless prev_response.status == 401
-
-
2
probe_request.transition(:idle)
-
-
2
responses = []
-
-
6
while (request = requests.shift)
-
2
token = digest.generate_header(request, prev_response)
-
2
request.headers["authorization"] = "Digest #{token}"
-
2
response = if requests.empty?
-
2
send_requests(*request, options).first
-
else
-
wrap { send_requests(*request, options).first }
-
end
-
2
responses << response
-
2
prev_response = response
-
end
-
-
2
return responses.first if responses.size == 1
-
-
responses
-
end
-
end
-
-
1
class Digest
-
1
def initialize(user, password)
-
2
@user = user
-
2
@password = password
-
2
@nonce = 0
-
end
-
-
1
def generate_header(request, response, _iis = false)
-
2
meth = request.verb.to_s.upcase
-
2
www = response.headers["www-authenticate"]
-
-
# discard first token, it's Digest
-
2
auth_info = www[/^(\w+) (.*)/, 2]
-
-
2
uri = request.path
-
-
2
params = Hash[auth_info.scan(/(\w+)="(.*?)"/)]
-
-
2
nonce = params["nonce"]
-
2
nc = next_nonce
-
-
# verify qop
-
2
qop = params["qop"]
-
-
2
if params["algorithm"] =~ /(.*?)(-sess)?$/
-
algorithm = case Regexp.last_match(1)
-
when "MD5" then ::Digest::MD5
-
when "SHA1" then ::Digest::SHA1
-
when "SHA2" then ::Digest::SHA2
-
when "SHA256" then ::Digest::SHA256
-
when "SHA384" then ::Digest::SHA384
-
when "SHA512" then ::Digest::SHA512
-
when "RMD160" then ::Digest::RMD160
-
else raise DigestError, "unknown algorithm \"#{Regexp.last_match(1)}\""
-
end
-
sess = Regexp.last_match(2)
-
else
-
2
algorithm = ::Digest::MD5
-
end
-
-
2
if qop || sess
-
2
cnonce = make_cnonce
-
2
nc = format("%08x", nc)
-
end
-
-
2
a1 = if sess
-
[algorithm.hexdigest("#{@user}:#{params["realm"]}:#{@password}"),
-
nonce,
-
cnonce].join ":"
-
else
-
2
"#{@user}:#{params["realm"]}:#{@password}"
-
end
-
-
2
ha1 = algorithm.hexdigest(a1)
-
2
ha2 = algorithm.hexdigest("#{meth}:#{uri}")
-
2
request_digest = [ha1, nonce]
-
2
request_digest.push(nc, cnonce, qop) if qop
-
2
request_digest << ha2
-
2
request_digest = request_digest.join(":")
-
-
header = [
-
2
%(username="#{@user}"),
-
%(nonce="#{nonce}"),
-
%(uri="#{uri}"),
-
%(response="#{algorithm.hexdigest(request_digest)}"),
-
]
-
2
header << %(realm="#{params["realm"]}") if params.key?("realm")
-
2
header << %(algorithm=#{params["algorithm"]}") if params.key?("algorithm")
-
2
header << %(opaque="#{params["opaque"]}") if params.key?("opaque")
-
2
header << %(cnonce="#{cnonce}") if cnonce
-
2
header << %(nc=#{nc})
-
2
header << %(qop=#{qop}) if qop
-
2
header.join ", "
-
end
-
-
1
private
-
-
1
def make_cnonce
-
2
::Digest::MD5.hexdigest [
-
Time.now.to_i,
-
Process.pid,
-
SecureRandom.random_number(2**32),
-
].join ":"
-
end
-
-
1
def next_nonce
-
2
@nonce += 1
-
end
-
end
-
end
-
-
1
register_plugin :digest_authentication, DigestAuthentication
-
end
-
end
-
# frozen_string_literal: true
-
-
1
module HTTPX
-
1
InsecureRedirectError = Class.new(Error)
-
1
module Plugins
-
#
-
# This plugin adds support for following redirect (status 30X) responses.
-
#
-
# It has an upper bound of followed redirects (see *MAX_REDIRECTS*), after which it
-
# will return the last redirect response. It will **not** raise an exception.
-
#
-
# It also doesn't follow insecure redirects (https -> http) by default (see *follow_insecure_redirects*).
-
#
-
# https://gitlab.com/honeyryderchuck/httpx/wikis/Follow-Redirects
-
#
-
1
module FollowRedirects
-
1
MAX_REDIRECTS = 3
-
1
REDIRECT_STATUS = (300..399).freeze
-
-
1
def self.extra_options(options)
-
10
Class.new(options.class) do
-
10
def_option(:max_redirects) do |num|
-
6
num = Integer(num)
-
6
raise Error, ":max_redirects must be positive" unless num.positive?
-
-
6
num
-
end
-
-
10
def_option(:follow_insecure_redirects)
-
end.new(options)
-
end
-
-
1
module InstanceMethods
-
1
def max_redirects(n)
-
6
branch(default_options.with_max_redirects(n.to_i))
-
end
-
-
1
private
-
-
1
def fetch_response(request, connections, options)
-
54831
redirect_request = request.redirect_request
-
54831
response = super(redirect_request, connections, options)
-
54831
return unless response
-
-
35
max_redirects = redirect_request.max_redirects
-
-
35
return response unless REDIRECT_STATUS.include?(response.status)
-
26
return response unless max_redirects.positive?
-
-
22
retry_request = build_redirect_request(redirect_request, response, options)
-
-
22
request.redirect_request = retry_request
-
-
22
if !options.follow_insecure_redirects &&
-
response.uri.scheme == "https" &&
-
retry_request.uri.scheme == "http"
-
1
error = InsecureRedirectError.new(retry_request.uri.to_s)
-
1
error.set_backtrace(caller)
-
1
return ErrorResponse.new(request, error, options)
-
end
-
-
21
connection = find_connection(retry_request, connections, options)
-
21
connection.send(retry_request)
-
21
set_request_timeout(connection, retry_request, options)
-
nil
-
end
-
-
1
def build_redirect_request(request, response, options)
-
22
redirect_uri = __get_location_from_response(response)
-
22
max_redirects = request.max_redirects
-
-
# redirects are **ALWAYS** GET
-
22
retry_options = options.merge(headers: request.headers,
-
body: request.body,
-
max_redirects: max_redirects - 1)
-
22
build_request(:get, redirect_uri, retry_options)
-
end
-
-
1
def __get_location_from_response(response)
-
22
location_uri = URI(response.headers["location"])
-
22
location_uri = response.uri.merge(location_uri) if location_uri.relative?
-
22
location_uri
-
end
-
end
-
-
1
module RequestMethods
-
1
def self.included(klass)
-
10
klass.__send__(:attr_writer, :redirect_request)
-
end
-
-
1
def redirect_request
-
54831
@redirect_request || self
-
end
-
-
1
def max_redirects
-
57
@options.max_redirects || MAX_REDIRECTS
-
end
-
end
-
end
-
1
register_plugin :follow_redirects, FollowRedirects
-
end
-
end
-
# frozen_string_literal: true
-
-
1
module HTTPX
-
1
module Plugins
-
#
-
# This plugin adds support for upgrading a plaintext HTTP/1.1 connection to HTTP/2
-
# (https://tools.ietf.org/html/rfc7540#section-3.2)
-
#
-
# https://gitlab.com/honeyryderchuck/httpx/wikis/Follow-Redirects
-
#
-
1
module H2C
-
1
def self.load_dependencies(*)
-
1
require "base64"
-
end
-
-
1
module InstanceMethods
-
1
def request(*args, **options)
-
1
h2c_options = options.merge(fallback_protocol: "h2c")
-
-
1
requests = build_requests(*args, h2c_options)
-
-
1
upgrade_request = requests.first
-
1
return super unless valid_h2c_upgrade_request?(upgrade_request)
-
-
1
upgrade_request.headers.add("connection", "upgrade")
-
1
upgrade_request.headers.add("connection", "http2-settings")
-
1
upgrade_request.headers["upgrade"] = "h2c"
-
1
upgrade_request.headers["http2-settings"] = HTTP2Next::Client.settings_header(upgrade_request.options.http2_settings)
-
2
wrap { send_requests(*upgrade_request, h2c_options).first }
-
-
1
responses = send_requests(*requests, h2c_options)
-
-
1
return responses.first if responses.size == 1
-
-
responses
-
end
-
-
1
private
-
-
1
def fetch_response(request, connections, options)
-
4
response = super
-
4
if response && valid_h2c_upgrade?(request, response, options)
-
1
log { "upgrading to h2c..." }
-
1
connection = find_connection(request, connections, options)
-
1
connections << connection unless connections.include?(connection)
-
1
connection.upgrade(request, response)
-
1
set_request_timeout(connection, request, options)
-
end
-
4
response
-
end
-
-
1
VALID_H2C_METHODS = %i[get options head].freeze
-
1
private_constant :VALID_H2C_METHODS
-
-
1
def valid_h2c_upgrade_request?(request)
-
1
VALID_H2C_METHODS.include?(request.verb) &&
-
request.scheme == "http"
-
end
-
-
1
def valid_h2c_upgrade?(request, response, options)
-
2
options.fallback_protocol == "h2c" &&
-
request.headers.get("connection").include?("upgrade") &&
-
request.headers.get("upgrade").include?("h2c") &&
-
response.status == 101
-
end
-
end
-
-
1
class H2CParser < Connection::HTTP2
-
1
def upgrade(request, response)
-
1
@connection.send_connection_preface
-
# skip checks, it is assumed that this is the first
-
# request in the connection
-
1
stream = @connection.upgrade
-
1
handle_stream(stream, request)
-
1
@streams[request] = stream
-
-
# clean up data left behind in the buffer, if the server started
-
# sending frames
-
1
data = response.to_s
-
1
@connection << data
-
end
-
end
-
-
1
module ConnectionMethods
-
1
using URIExtensions
-
-
1
def match?(uri, options)
-
2
return super unless uri.scheme == "http" && @options.fallback_protocol == "h2c"
-
-
2
super && options.fallback_protocol == "h2c"
-
end
-
-
1
def coalescable?(connection)
-
return super unless @options.fallback_protocol == "h2c" && @origin.scheme == "http"
-
-
@origin == connection.origin && connection.options.fallback_protocol == "h2c"
-
end
-
-
1
def upgrade(request, response)
-
1
@parser.reset if @parser
-
1
@parser = H2CParser.new(@write_buffer, @options)
-
1
set_parser_callbacks(@parser)
-
1
@parser.upgrade(request, response)
-
end
-
-
1
def build_parser(*)
-
1
return super unless @origin.scheme == "http"
-
-
1
super("http/1.1")
-
end
-
end
-
-
1
module FrameBuilder
-
1
include HTTP2Next
-
-
1
module_function
-
-
1
def settings_value(settings)
-
frame = Framer.new.generate(type: :settings, stream: 0, payload: settings)
-
Base64.urlsafe_encode64(frame[9..-1])
-
end
-
end
-
end
-
1
register_plugin(:h2c, H2C)
-
end
-
end
-
# frozen_string_literal: true
-
-
1
module HTTPX
-
1
module Plugins
-
#
-
# This plugin adds support for passing `http-form_data` objects (like file objects) as "multipart/form-data";
-
#
-
# HTTPX.post(URL, form: form: { image: HTTP::FormData::File.new("path/to/file")})
-
#
-
# https://gitlab.com/honeyryderchuck/httpx/wikis/Multipart-Uploads
-
#
-
1
module Multipart
-
1
module FormTranscoder
-
1
module_function
-
-
1
class Encoder
-
1
extend Forwardable
-
-
1
def_delegator :@raw, :content_type
-
-
1
def_delegator :@raw, :to_s
-
-
1
def_delegator :@raw, :read
-
-
1
def initialize(form)
-
31
@raw = HTTP::FormData.create(form)
-
end
-
-
1
def bytesize
-
125
@raw.content_length
-
end
-
-
1
def force_encoding(*args)
-
@raw.to_s.force_encoding(*args)
-
end
-
-
1
def to_str
-
@raw.to_s
-
end
-
end
-
-
1
def encode(form)
-
31
Encoder.new(form)
-
end
-
end
-
-
1
def self.load_dependencies(*)
-
16
require "http/form_data"
-
end
-
-
1
def self.configure(*)
-
16
Transcoder.register("form", FormTranscoder)
-
end
-
end
-
1
register_plugin :multipart, Multipart
-
end
-
end
-
# frozen_string_literal: true
-
-
1
module HTTPX
-
1
module Plugins
-
# This plugin implements a session that persists connections over the duration of the process.
-
#
-
# This will improve connection reuse in a long-running process.
-
#
-
# One important caveat to note is, although this session might not close connections,
-
# other sessions from the same process that don't have this plugin turned on might.
-
#
-
# This session will still be able to work with it, as if, when expecting a connection
-
# terminated by a different session, it will just retry on a new one and keep it open.
-
#
-
# This plugin is also not recommendable when connecting to >9000 (like, a lot) different origins.
-
# So when you use this, make sure that you don't fall into this trap.
-
#
-
# https://gitlab.com/honeyryderchuck/httpx/wikis/Persistent
-
#
-
1
module Persistent
-
1
def self.load_dependencies(klass)
-
1
klass.plugin(:retries, max_retries: 1, retry_change_requests: true)
-
end
-
-
1
def self.extra_options(options)
-
1
options.merge(persistent: true)
-
end
-
end
-
1
register_plugin :persistent, Persistent
-
end
-
end
-
# frozen_string_literal: true
-
-
1
require "resolv"
-
1
require "ipaddr"
-
1
require "forwardable"
-
-
1
module HTTPX
-
1
module Plugins
-
#
-
# This plugin adds support for proxies. It ships with support for:
-
#
-
# * HTTP proxies
-
# * HTTPS proxies
-
# * Socks4/4a proxies
-
# * Socks5 proxies
-
#
-
# https://gitlab.com/honeyryderchuck/httpx/wikis/Proxy
-
#
-
1
module Proxy
-
1
Error = Class.new(Error)
-
1
PROXY_ERRORS = [TimeoutError, IOError, SystemCallError, Error].freeze
-
-
1
class Parameters
-
1
attr_reader :uri, :username, :password
-
-
1
def initialize(uri:, username: nil, password: nil)
-
8
@uri = uri.is_a?(URI::Generic) ? uri : URI(uri)
-
8
@username = username || @uri.user
-
8
@password = password || @uri.password
-
end
-
-
1
def authenticated?
-
3
@username && @password
-
end
-
-
1
def token_authentication
-
Base64.strict_encode64("#{user}:#{password}")
-
end
-
-
1
def ==(other)
-
if other.is_a?(Parameters)
-
@uri == other.uri &&
-
@username == other.username &&
-
@password == other.password
-
else
-
super
-
end
-
end
-
end
-
-
1
class << self
-
1
def configure(klass)
-
8
klass.plugin(:"proxy/http")
-
8
klass.plugin(:"proxy/socks4")
-
8
klass.plugin(:"proxy/socks5")
-
end
-
-
1
def extra_options(options)
-
8
Class.new(options.class) do
-
8
def_option(:proxy) do |pr|
-
8
Hash[pr]
-
end
-
end.new(options)
-
end
-
end
-
-
1
module InstanceMethods
-
1
def with_proxy(*args)
-
8
branch(default_options.with_proxy(*args))
-
end
-
-
1
private
-
-
1
def proxy_uris(uri, options)
-
8
@_proxy_uris ||= begin
-
8
uris = options.proxy ? Array(options.proxy[:uri]) : []
-
8
if uris.empty?
-
uri = URI(uri).find_proxy
-
uris << uri if uri
-
end
-
8
uris
-
end
-
8
options.proxy.merge(uri: @_proxy_uris.first) unless @_proxy_uris.empty?
-
end
-
-
1
def find_connection(request, connections, options)
-
8
return super unless options.respond_to?(:proxy)
-
-
8
uri = URI(request.uri)
-
8
next_proxy = proxy_uris(uri, options)
-
8
raise Error, "Failed to connect to proxy" unless next_proxy
-
-
8
proxy_options = options.merge(proxy: Parameters.new(**next_proxy))
-
8
connection = pool.find_connection(uri, proxy_options) || build_connection(uri, proxy_options)
-
8
unless connections.nil? || connections.include?(connection)
-
8
connections << connection
-
8
set_connection_callbacks(connection, options)
-
end
-
8
connection
-
end
-
-
1
def build_connection(uri, options)
-
8
proxy = options.proxy
-
8
return super unless proxy
-
-
8
connection = options.connection_class.new("tcp", uri, options)
-
8
pool.init_connection(connection, options)
-
8
connection
-
end
-
-
1
def fetch_response(request, connections, options)
-
715
response = super
-
715
if response.is_a?(ErrorResponse) &&
-
# either it was a timeout error connecting, or it was a proxy error
-
PROXY_ERRORS.any? { |ex| response.error.is_a?(ex) } && !@_proxy_uris.empty?
-
@_proxy_uris.shift
-
log { "failed connecting to proxy, trying next..." }
-
request.transition(:idle)
-
connection = find_connection(request, connections, options)
-
connections << connection unless connections.include?(connection)
-
connection.send(request)
-
set_request_timeout(connection, request, options)
-
return
-
end
-
715
response
-
end
-
end
-
-
1
module ConnectionMethods
-
1
using URIExtensions
-
-
1
def initialize(*)
-
8
super
-
8
return unless @options.proxy
-
-
# redefining the connection origin as the proxy's URI,
-
# as this will be used as the tcp peer ip.
-
8
@origin = URI(@options.proxy.uri.origin)
-
end
-
-
1
def match?(uri, options)
-
return super unless @options.proxy
-
-
super && @options.proxy == options.proxy
-
end
-
-
# should not coalesce connections here, as the IP is the IP of the proxy
-
1
def coalescable?(*)
-
return super unless @options.proxy
-
-
false
-
end
-
-
1
def send(request)
-
8
return super unless @options.proxy
-
8
return super unless connecting?
-
-
8
@pending << request
-
end
-
-
1
def connecting?
-
8
return super unless @options.proxy
-
-
8
super || @state == :connecting || @state == :connected
-
end
-
-
1
def to_io
-
2812
return super unless @options.proxy
-
-
2812
case @state
-
when :idle
-
16
transition(:connecting)
-
when :connected
-
246
transition(:open)
-
end
-
2812
@io.to_io
-
end
-
-
1
def call
-
707
super
-
707
return unless @options.proxy
-
-
707
case @state
-
when :connecting
-
12
consume
-
end
-
end
-
-
1
def reset
-
return super unless @options.proxy
-
-
@state = :open
-
transition(:closing)
-
transition(:closed)
-
emit(:close)
-
end
-
end
-
end
-
1
register_plugin :proxy, Proxy
-
end
-
-
1
class ProxySSL < SSL
-
1
def initialize(tcp, request_uri, options)
-
4
@io = tcp.to_io
-
4
super(request_uri, tcp.addresses, options)
-
4
@hostname = request_uri.host
-
4
@state = :connected
-
end
-
end
-
end
-
# frozen_string_literal: true
-
-
1
require "base64"
-
-
1
module HTTPX
-
1
module Plugins
-
1
module Proxy
-
1
module HTTP
-
1
module ConnectionMethods
-
1
private
-
-
1
def transition(nextstate)
-
299
return super unless @options.proxy && @options.proxy.uri.scheme == "http"
-
-
139
case nextstate
-
when :connecting
-
4
return unless @state == :idle
-
-
4
@io.connect
-
4
return unless @io.connected?
-
-
2
@parser = ConnectProxyParser.new(@write_buffer, @options.merge(max_concurrent_requests: 1))
-
2
@parser.once(:response, &method(:__http_on_connect))
-
3
@parser.on(:close) { transition(:closing) }
-
2
__http_proxy_connect
-
2
return if @state == :connected
-
when :connected
-
2
return unless @state == :idle || @state == :connecting
-
-
2
case @state
-
when :connecting
-
1
@parser.close
-
1
@parser = nil
-
when :idle
-
1
@parser = ProxyParser.new(@write_buffer, @options)
-
1
set_parser_callbacks(@parser)
-
2
@parser.on(:close) { transition(:closing) }
-
end
-
end
-
136
super
-
end
-
-
1
def __http_proxy_connect
-
2
req, _ = @pending.first
-
# if the first request after CONNECT is to an https address, it is assumed that
-
# all requests in the queue are not only ALL HTTPS, but they also share the certificate,
-
# and therefore, will share the connection.
-
#
-
2
if req.uri.scheme == "https"
-
1
connect_request = ConnectRequest.new(req.uri, @options)
-
-
1
parser.send(connect_request)
-
else
-
1
transition(:connected)
-
end
-
end
-
-
1
def __http_on_connect(_request, response)
-
1
if response.status == 200
-
1
req, _ = @pending.first
-
1
request_uri = req.uri
-
1
@io = ProxySSL.new(@io, request_uri, @options)
-
1
transition(:connected)
-
1
throw(:called)
-
else
-
pending = @pending.map(&:first) + @parser.pending
-
while (req = pending.shift)
-
emit(:response, req, response)
-
end
-
end
-
end
-
end
-
-
1
class ProxyParser < Connection::HTTP1
-
1
def headline_uri(request)
-
1
request.uri.to_s
-
end
-
-
1
def set_request_headers(request)
-
25
super
-
25
request.headers["proxy-connection"] = request.headers["connection"]
-
25
request.headers.delete("connection")
-
end
-
end
-
-
1
class ConnectProxyParser < ProxyParser
-
1
attr_reader :pending
-
-
1
def headline_uri(request)
-
1
return super unless request.verb == :connect
-
-
1
uri = request.uri
-
1
tunnel = "#{uri.hostname}:#{uri.port}"
-
1
log { "establishing HTTP proxy tunnel to #{tunnel}" }
-
1
tunnel
-
end
-
-
1
def empty?
-
@requests.reject { |r| r.verb == :connect }.empty? ||
-
@requests.all? { |request| !request.response.nil? }
-
end
-
end
-
-
1
class ConnectRequest < Request
-
1
def initialize(uri, options)
-
1
super(:connect, uri, {})
-
1
proxy_params = options.proxy
-
1
@headers["proxy-authentication"] = "Basic #{proxy_params.token_authentication}" if proxy_params.authenticated?
-
1
@headers.delete("accept")
-
end
-
-
1
def path
-
"#{@uri.hostname}:#{@uri.port}"
-
end
-
end
-
end
-
end
-
1
register_plugin :"proxy/http", Proxy::HTTP
-
end
-
end
-
# frozen_string_literal: true
-
-
1
require "resolv"
-
1
require "ipaddr"
-
-
1
module HTTPX
-
1
module Plugins
-
1
module Proxy
-
1
module Socks4
-
1
VERSION = 4
-
1
CONNECT = 1
-
1
GRANTED = 90
-
1
PROTOCOLS = %w[socks4 socks4a].freeze
-
-
1
Error = Class.new(Error)
-
-
1
module ConnectionMethods
-
1
private
-
-
1
def transition(nextstate)
-
303
return super unless @options.proxy && PROTOCOLS.include?(@options.proxy.uri.scheme)
-
-
128
case nextstate
-
when :connecting
-
8
return unless @state == :idle
-
-
8
@io.connect
-
8
return unless @io.connected?
-
-
4
req, _ = @pending.first
-
4
return unless req
-
-
4
request_uri = req.uri
-
4
@write_buffer << Packet.connect(@options.proxy, request_uri)
-
4
__socks4_proxy_connect
-
when :connected
-
4
return unless @state == :connecting
-
-
4
@parser = nil
-
end
-
124
log(level: 1, label: "SOCKS4: ") { "#{nextstate}: #{@write_buffer.to_s.inspect}" } unless nextstate == :open
-
124
super
-
end
-
-
1
def __socks4_proxy_connect
-
4
@parser = SocksParser.new(@write_buffer, @options)
-
4
@parser.once(:packet, &method(:__socks4_on_packet))
-
end
-
-
1
def __socks4_on_packet(packet)
-
4
_version, status, _port, _ip = packet.unpack("CCnN")
-
4
if status == GRANTED
-
4
req, _ = @pending.first
-
4
request_uri = req.uri
-
4
@io = ProxySSL.new(@io, request_uri, @options) if request_uri.scheme == "https"
-
4
transition(:connected)
-
4
throw(:called)
-
else
-
on_socks4_error("socks error: #{status}")
-
end
-
end
-
-
1
def on_socks4_error(message)
-
ex = Error.new(message)
-
ex.set_backtrace(caller)
-
on_error(ex)
-
throw(:called)
-
end
-
end
-
-
1
class SocksParser
-
1
include Callbacks
-
-
1
def initialize(buffer, options)
-
4
@buffer = buffer
-
4
@options = Options.new(options)
-
end
-
-
1
def close; end
-
-
1
def consume(*); end
-
-
1
def empty?
-
true
-
end
-
-
1
def <<(packet)
-
4
emit(:packet, packet)
-
end
-
end
-
-
1
module Packet
-
1
module_function
-
-
1
def connect(parameters, uri)
-
4
packet = [VERSION, CONNECT, uri.port].pack("CCn")
-
begin
-
4
ip = IPAddr.new(uri.host)
-
raise Error, "Socks4 connection to #{ip} not supported" unless ip.ipv4?
-
-
packet << [ip.to_i].pack("N")
-
rescue IPAddr::InvalidAddressError
-
4
if parameters.uri.scheme == "socks4"
-
# resolv defaults to IPv4, and socks4 doesn't support IPv6 otherwise
-
2
ip = IPAddr.new(Resolv.getaddress(uri.host))
-
2
packet << [ip.to_i].pack("N")
-
else
-
2
packet << "\x0\x0\x0\x1" << "\x7\x0" << uri.host
-
end
-
end
-
4
packet << [parameters.username].pack("Z*")
-
4
packet
-
end
-
end
-
end
-
end
-
1
register_plugin :"proxy/socks4", Proxy::Socks4
-
end
-
end
-
# frozen_string_literal: true
-
-
1
module HTTPX
-
1
module Plugins
-
1
module Proxy
-
1
module Socks5
-
1
VERSION = 5
-
1
NOAUTH = 0
-
1
PASSWD = 2
-
1
NONE = 0xff
-
1
CONNECT = 1
-
1
IPV4 = 1
-
1
DOMAIN = 3
-
1
IPV6 = 4
-
1
SUCCESS = 0
-
-
1
Error = Class.new(Error)
-
-
1
module ConnectionMethods
-
1
def call
-
707
super
-
-
707
return unless @options.proxy && @options.proxy.uri.scheme == "socks5"
-
-
207
case @state
-
when :connecting,
-
:negotiating,
-
:authenticating
-
4
consume
-
end
-
end
-
-
1
private
-
-
1
def transition(nextstate)
-
307
return super unless @options.proxy && @options.proxy.uri.scheme == "socks5"
-
-
40
case nextstate
-
when :connecting
-
4
return unless @state == :idle
-
-
4
@io.connect
-
4
return unless @io.connected?
-
-
2
@write_buffer << Packet.negotiate(@options.proxy)
-
2
__socks5_proxy_connect
-
when :authenticating
-
return unless @state == :connecting
-
-
@write_buffer << Packet.authenticate(@options.proxy)
-
when :negotiating
-
4
return unless @state == :connecting || @state == :authenticating
-
-
2
req, _ = @pending.first
-
2
request_uri = req.uri
-
2
@write_buffer << Packet.connect(request_uri)
-
when :connected
-
2
return unless @state == :negotiating
-
-
2
@parser = nil
-
end
-
36
log(level: 1, label: "SOCKS5: ") { "#{nextstate}: #{@write_buffer.to_s.inspect}" } unless nextstate == :open
-
36
super
-
end
-
-
1
def __socks5_proxy_connect
-
2
@parser = SocksParser.new(@write_buffer, @options)
-
2
@parser.on(:packet, &method(:__socks5_on_packet))
-
2
transition(:negotiating)
-
end
-
-
1
def __socks5_on_packet(packet)
-
4
case @state
-
when :connecting
-
2
version, method = packet.unpack("CC")
-
2
__socks5_check_version(version)
-
2
case method
-
when PASSWD
-
transition(:authenticating)
-
return
-
when NONE
-
__on_socks5_error("no supported authorization methods")
-
else
-
2
transition(:negotiating)
-
end
-
when :authenticating
-
version, status = packet.unpack("CC")
-
__socks5_check_version(version)
-
return transition(:negotiating) if status == SUCCESS
-
-
__on_socks5_error("socks authentication error: #{status}")
-
when :negotiating
-
2
version, reply, = packet.unpack("CC")
-
2
__socks5_check_version(version)
-
2
__on_socks5_error("socks5 negotiation error: #{reply}") unless reply == SUCCESS
-
2
req, _ = @pending.first
-
2
request_uri = req.uri
-
2
@io = ProxySSL.new(@io, request_uri, @options) if request_uri.scheme == "https"
-
2
transition(:connected)
-
2
throw(:called)
-
end
-
end
-
-
1
def __socks5_check_version(version)
-
4
__on_socks5_error("invalid SOCKS version (#{version})") if version != 5
-
end
-
-
1
def __on_socks5_error(message)
-
ex = Error.new(message)
-
ex.set_backtrace(caller)
-
on_error(ex)
-
throw(:called)
-
end
-
end
-
-
1
class SocksParser
-
1
include Callbacks
-
-
1
def initialize(buffer, options)
-
2
@buffer = buffer
-
2
@options = Options.new(options)
-
end
-
-
1
def close; end
-
-
1
def consume(*); end
-
-
1
def empty?
-
true
-
end
-
-
1
def <<(packet)
-
4
emit(:packet, packet)
-
end
-
end
-
-
1
module Packet
-
1
module_function
-
-
1
def negotiate(parameters)
-
2
methods = [NOAUTH]
-
2
methods << PASSWD if parameters.authenticated?
-
2
methods.unshift(methods.size)
-
2
methods.unshift(VERSION)
-
2
methods.pack("C*")
-
end
-
-
1
def authenticate(parameters)
-
user = parameters.username
-
pass = parameters.password
-
[0x01, user.bytesize, user, pass.bytesize, password].pack("CCA*CA*")
-
end
-
-
1
def connect(uri)
-
2
packet = [VERSION, CONNECT, 0].pack("C*")
-
begin
-
2
ip = IPAddr.new(uri.host)
-
raise Error, "Socks4 connection to #{ip} not supported" unless ip.ipv4?
-
-
packet << [IPV4, ip.to_i].pack("CN")
-
rescue IPAddr::InvalidAddressError
-
2
packet << [DOMAIN, uri.host.bytesize, uri.host].pack("CCA*")
-
end
-
2
packet << [uri.port].pack("n")
-
2
packet
-
end
-
end
-
end
-
end
-
1
register_plugin :"proxy/socks5", Proxy::Socks5
-
end
-
end
-
# frozen_string_literal: true
-
-
1
require "httpx/plugins/proxy"
-
-
1
module HTTPX
-
1
module Plugins
-
1
module Proxy
-
1
module SSH
-
1
def self.load_dependencies(*)
-
2
require "net/ssh/gateway"
-
end
-
-
1
def self.extra_options(options)
-
2
Class.new(options.class) do
-
2
def_option(:proxy) do |pr|
-
2
Hash[pr]
-
end
-
end.new(options)
-
end
-
-
1
module InstanceMethods
-
1
def with_proxy(*args)
-
2
branch(default_options.with_proxy(*args))
-
end
-
-
1
private
-
-
1
def send_requests(*requests, options)
-
2
request_options = @options.merge(options)
-
-
2
return super unless request_options.proxy
-
-
2
ssh_options = request_options.proxy
-
2
ssh_uris = ssh_options.delete(:uri)
-
2
ssh_uri = URI.parse(ssh_uris.shift)
-
-
2
return super unless ssh_uri.scheme == "ssh"
-
-
2
ssh_username = ssh_options.delete(:username)
-
2
ssh_options[:port] ||= ssh_uri.port || 22
-
2
if request_options.debug
-
ssh_options[:verbose] = request_options.debug_level == 2 ? :debug : :info
-
end
-
2
request_uri = URI(requests.first.uri)
-
2
@_gateway = Net::SSH::Gateway.new(ssh_uri.host, ssh_username, ssh_options)
-
begin
-
2
@_gateway.open(request_uri.host, request_uri.port) do |local_port|
-
2
io = build_gateway_socket(local_port, request_uri, request_options)
-
2
super(*requests, options.merge(io: io))
-
end
-
ensure
-
2
@_gateway.shutdown!
-
end
-
end
-
-
1
def build_gateway_socket(port, request_uri, options)
-
2
case request_uri.scheme
-
when "https"
-
1
ctx = OpenSSL::SSL::SSLContext.new
-
1
ctx_options = SSL::TLS_OPTIONS.merge(options.ssl)
-
1
ctx.set_params(ctx_options) unless ctx_options.empty?
-
1
sock = TCPSocket.open("localhost", port)
-
1
io = OpenSSL::SSL::SSLSocket.new(sock, ctx)
-
1
io.hostname = request_uri.host
-
1
io.sync_close = true
-
1
io.connect
-
1
io.post_connection_check(request_uri.host) if ctx.verify_mode != OpenSSL::SSL::VERIFY_NONE
-
1
io
-
when "http"
-
1
TCPSocket.open("localhost", port)
-
else
-
raise Error, "unexpected scheme: #{request_uri.scheme}"
-
end
-
end
-
end
-
-
1
module ConnectionMethods
-
1
def match?(uri, options)
-
return super unless @options.proxy
-
-
super && @options.proxy == options.proxy
-
end
-
-
# should not coalesce connections here, as the IP is the IP of the proxy
-
1
def coalescable?(*)
-
return super unless @options.proxy
-
-
false
-
end
-
end
-
end
-
end
-
1
register_plugin :"proxy/ssh", Proxy::SSH
-
end
-
end
-
# frozen_string_literal: true
-
-
1
module HTTPX
-
1
module Plugins
-
#
-
# This plugin adds support for HTTP/2 Push responses.
-
#
-
# In order to benefit from this, requests are sent one at a time, so that
-
# no push responses are received after corresponding request has been sent.
-
#
-
# https://gitlab.com/honeyryderchuck/httpx/wikis/Server-Push
-
#
-
1
module PushPromise
-
1
def self.extra_options(options)
-
2
options.merge(http2_settings: { settings_enable_push: 1 },
-
max_concurrent_requests: 1)
-
end
-
-
1
module ResponseMethods
-
1
def pushed?
-
@__pushed
-
end
-
-
1
def mark_as_pushed!
-
1
@__pushed = true
-
end
-
end
-
-
1
module InstanceMethods
-
1
private
-
-
1
def promise_headers
-
2
@promise_headers ||= {}
-
end
-
-
1
def on_promise(parser, stream)
-
2
stream.on(:promise_headers) do |h|
-
2
__on_promise_request(parser, stream, h)
-
end
-
2
stream.on(:headers) do |h|
-
1
__on_promise_response(parser, stream, h)
-
end
-
end
-
-
1
def __on_promise_request(parser, stream, h)
-
2
log(level: 1, label: "#{stream.id}: ") do
-
h.map { |k, v| "-> PROMISE HEADER: #{k}: #{v}" }.join("\n")
-
end
-
2
headers = @options.headers_class.new(h)
-
2
path = headers[":path"]
-
2
authority = headers[":authority"]
-
-
3
request = parser.pending.find { |r| r.authority == authority && r.path == path }
-
2
if request
-
1
request.merge_headers(headers)
-
1
promise_headers[stream] = request
-
1
parser.pending.delete(request)
-
else
-
1
stream.refuse
-
end
-
end
-
-
1
def __on_promise_response(parser, stream, h)
-
1
request = promise_headers.delete(stream)
-
1
return unless request
-
-
1
parser.__send__(:on_stream_headers, stream, request, h)
-
1
request.transition(:done)
-
1
response = request.response
-
1
response.mark_as_pushed!
-
1
stream.on(:data, &parser.method(:on_stream_data).curry[stream, request])
-
1
stream.on(:close, &parser.method(:on_stream_close).curry[stream, request])
-
end
-
end
-
end
-
1
register_plugin(:push_promise, PushPromise)
-
end
-
end
-
# frozen_string_literal: true
-
-
1
module HTTPX
-
1
module Plugins
-
#
-
# This plugin adds support for retrying requests when certain errors happen.
-
#
-
# https://gitlab.com/honeyryderchuck/httpx/wikis/Retries
-
#
-
1
module Retries
-
1
MAX_RETRIES = 3
-
# TODO: pass max_retries in a configure/load block
-
-
1
IDEMPOTENT_METHODS = %i[get options head put delete].freeze
-
1
RETRYABLE_ERRORS = [IOError,
-
EOFError,
-
Errno::ECONNRESET,
-
Errno::ECONNABORTED,
-
Errno::EPIPE,
-
1
(OpenSSL::SSL::SSLError if defined?(OpenSSL)),
-
TimeoutError,
-
Parser::Error,
-
Errno::EINVAL,
-
Errno::ETIMEDOUT].freeze
-
-
1
def self.extra_options(options)
-
5
Class.new(options.class) do
-
5
def_option(:max_retries) do |num|
-
2
num = Integer(num)
-
2
raise Error, ":max_retries must be positive" unless num.positive?
-
-
2
num
-
end
-
-
5
def_option(:retry_change_requests)
-
end.new(options).merge(max_retries: MAX_RETRIES)
-
end
-
-
1
module InstanceMethods
-
1
def max_retries(n)
-
2
branch(default_options.with_max_retries(n.to_i))
-
end
-
-
1
private
-
-
1
def fetch_response(request, connections, options)
-
100245
response = super
-
100245
if response.is_a?(ErrorResponse) &&
-
request.retries.positive? &&
-
__repeatable_request?(request, options) &&
-
__retryable_error?(response.error)
-
11
request.retries -= 1
-
11
log { "failed to get response, #{request.retries} tries to go..." }
-
11
request.transition(:idle)
-
11
connection = find_connection(request, connections, options)
-
11
connection.send(request)
-
11
set_request_timeout(connection, request, options)
-
11
return
-
end
-
100234
response
-
end
-
-
1
def __repeatable_request?(request, options)
-
12
IDEMPOTENT_METHODS.include?(request.verb) || options.retry_change_requests
-
end
-
-
1
def __retryable_error?(ex)
-
98
RETRYABLE_ERRORS.any? { |klass| ex.is_a?(klass) }
-
end
-
end
-
-
1
module RequestMethods
-
1
attr_accessor :retries
-
-
1
def initialize(*args)
-
24
super
-
24
@retries = @options.max_retries
-
end
-
end
-
end
-
1
register_plugin :retries, Retries
-
end
-
end
-
# frozen_string_literal: true
-
-
1
require "forwardable"
-
1
require "timers"
-
1
require "httpx/selector"
-
1
require "httpx/connection"
-
1
require "httpx/resolver"
-
-
1
module HTTPX
-
1
class Pool
-
1
extend Forwardable
-
-
1
def_delegator :@timers, :after
-
-
1
def initialize
-
6
@resolvers = {}
-
6
@_resolver_monitors = {}
-
6
@timers = Timers::Group.new
-
6
@selector = Selector.new
-
6
@connections = []
-
6
@connected_connections = 0
-
end
-
-
1
def empty?
-
3
@connections.empty?
-
end
-
-
1
def next_tick
-
343213
catch(:jump_tick) do
-
343213
@selector.select(next_timeout || @timers.wait_interval) do |monitor|
-
894159
monitor.io.call
-
894159
monitor.interests = monitor.io.interests
-
end
-
343213
@timers.fire
-
end
-
rescue StandardError => ex
-
@connections.each do |connection|
-
connection.emit(:error, ex)
-
end
-
end
-
-
1
def close(connections = @connections)
-
169
@timers.cancel
-
169
connections = connections.reject(&:inflight?)
-
169
connections.each(&:close)
-
526
next_tick until connections.none? { |c| @connections.include?(c) }
-
2
@resolvers.each_value do |resolver|
-
resolver.close unless resolver.closed?
-
169
end if @connections.empty?
-
end
-
-
1
def init_connection(connection, _options)
-
203
resolve_connection(connection)
-
203
connection.on(:open) do
-
194
@connected_connections += 1
-
end
-
203
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+.
-
# Many hostnames are reachable through the same IP, so we try to
-
# maximize pipelining by opening as few connections as possible.
-
#
-
1
def find_connection(uri, options)
-
227
@connections.find do |connection|
-
360
connection.match?(uri, options)
-
end
-
end
-
-
1
private
-
-
1
def resolve_connection(connection)
-
203
@connections << connection unless @connections.include?(connection)
-
203
resolver = find_resolver_for(connection)
-
203
resolver << connection
-
203
return if resolver.empty?
-
-
20
@_resolver_monitors[resolver] ||= @selector.register(resolver, :w)
-
end
-
-
1
def on_resolver_connection(connection)
-
203
found_connection = @connections.find do |ch|
-
518
ch != connection && ch.mergeable?(connection)
-
end
-
203
return register_connection(connection) unless found_connection
-
-
if found_connection.state == :open
-
coalesce_connections(found_connection, connection)
-
else
-
found_connection.once(:open) do
-
coalesce_connections(found_connection, connection)
-
end
-
end
-
end
-
-
1
def on_resolver_error(ch, error)
-
ch.emit(:error, error)
-
# must remove connection by hand, hasn't been started yet
-
unregister_connection(ch)
-
end
-
-
1
def on_resolver_close(resolver)
-
40
resolver_type = resolver.class
-
40
return unless @resolvers[resolver_type] == resolver
-
-
20
@resolvers.delete(resolver_type)
-
-
20
@selector.deregister(resolver)
-
20
monitor = @_resolver_monitors.delete(resolver)
-
20
monitor.close if monitor
-
20
resolver.close unless resolver.closed?
-
end
-
-
1
def register_connection(connection)
-
203
if connection.state == :open
-
# if open, an IO was passed upstream, therefore
-
# consider it connected already.
-
4
@connected_connections += 1
-
4
@selector.register(connection, :rw)
-
else
-
199
@selector.register(connection, :w)
-
end
-
203
connection.on(:close) do
-
193
unregister_connection(connection)
-
end
-
203
return if connection.state == :open
-
end
-
-
1
def unregister_connection(connection)
-
193
@connections.delete(connection)
-
193
@selector.deregister(connection)
-
193
@connected_connections -= 1
-
end
-
-
1
def coalesce_connections(ch1, ch2)
-
if ch1.coalescable?(ch2)
-
ch1.merge(ch2)
-
@connections.delete(ch2)
-
else
-
register_connection(ch2)
-
end
-
end
-
-
1
def next_timeout
-
343213
@resolvers.values.reject(&:closed?).map(&:timeout).compact.min || @connections.map(&:timeout).compact.min
-
end
-
-
1
def find_resolver_for(connection)
-
203
connection_options = connection.options
-
203
resolver_type = connection_options.resolver_class
-
203
resolver_type = Resolver.registry(resolver_type) if resolver_type.is_a?(Symbol)
-
-
203
@resolvers[resolver_type] ||= begin
-
26
resolver = resolver_type.new(connection_options)
-
26
resolver.on(:resolve, &method(:on_resolver_connection))
-
26
resolver.on(:error, &method(:on_resolver_error))
-
66
resolver.on(:close) { on_resolver_close(resolver) }
-
26
resolver
-
end
-
end
-
end
-
end
-
# frozen_string_literal: true
-
-
1
module HTTPX
-
# Adds a general-purpose registry API to a class. It is designed to be a
-
# configuration-level API, i.e. the registry is global to the class and
-
# should be set on **boot time**.
-
#
-
# It is used internally to associate tags with handlers.
-
#
-
# ## Register/Fetch
-
#
-
# One is strongly advised to register handlers when creating the class.
-
#
-
# There is an instance-level method to retrieve from the registry based
-
# on the tag:
-
#
-
# class Server
-
# include HTTPX::Registry
-
#
-
# register "tcp", TCPHandler
-
# register "ssl", SSLHandlers
-
# ...
-
#
-
#
-
# def handle(uri)
-
# scheme = uri.scheme
-
# handler = registry(scheme) #=> TCPHandler
-
# handler.handle
-
# end
-
# end
-
#
-
1
module Registry
-
# Base Registry Error
-
1
Error = Class.new(Error)
-
-
1
def self.extended(klass)
-
4
super
-
4
klass.extend(ClassMethods)
-
end
-
-
1
def self.included(klass)
-
1
super
-
1
klass.extend(ClassMethods)
-
1
klass.__send__(:include, InstanceMethods)
-
end
-
-
# Class Methods
-
1
module ClassMethods
-
1
def inherited(klass)
-
1530
super
-
1530
klass.instance_variable_set(:@registry, @registry.dup)
-
end
-
-
# @param [Object] tag the handler identifier in the registry
-
# @return [Symbol, String, Object] the corresponding handler (if Symbol or String,
-
# will assume it referes to an autoloaded module, and will load-and-return it).
-
#
-
1
def registry(tag = nil)
-
802
@registry ||= {}
-
802
return @registry if tag.nil?
-
-
724
handler = @registry.fetch(tag)
-
724
raise(Error, "#{tag} is not registered in #{self}") unless handler
-
-
724
case handler
-
when Symbol, String
-
203
const_get(handler)
-
else
-
521
handler
-
end
-
end
-
-
# @param [Object] tag the identifier for the handler in the registry
-
# @return [Symbol, String, Object] the handler (if Symbol or String, it is
-
# assumed to be an autoloaded module, to be loaded later)
-
#
-
1
def register(tag, handler)
-
63
registry[tag] = handler
-
end
-
end
-
-
# Instance Methods
-
1
module InstanceMethods
-
# delegates to HTTPX::Registry#registry
-
1
def registry(tag)
-
197
self.class.registry(tag)
-
end
-
end
-
end
-
end
-
# frozen_string_literal: true
-
-
1
require "forwardable"
-
-
1
module HTTPX
-
1
class Request
-
1
extend Forwardable
-
1
include Callbacks
-
1
using URIExtensions
-
-
1
METHODS = [
-
# RFC 2616: Hypertext Transfer Protocol -- HTTP/1.1
-
:options, :get, :head, :post, :put, :delete, :trace, :connect,
-
-
# RFC 2518: HTTP Extensions for Distributed Authoring -- WEBDAV
-
:propfind, :proppatch, :mkcol, :copy, :move, :lock, :unlock,
-
-
# RFC 3648: WebDAV Ordered Collections Protocol
-
:orderpatch,
-
-
# RFC 3744: WebDAV Access Control Protocol
-
:acl,
-
-
# RFC 6352: vCard Extensions to WebDAV -- CardDAV
-
:report,
-
-
# RFC 5789: PATCH Method for HTTP
-
:patch,
-
-
# draft-reschke-webdav-search: WebDAV Search
-
:search
-
].freeze
-
-
1
USER_AGENT = "httpx.rb/#{VERSION}"
-
-
1
attr_reader :verb, :uri, :headers, :body, :state
-
-
1
attr_reader :options, :response
-
-
1
attr_accessor :timer
-
-
1
def_delegator :@body, :<<
-
-
1
def_delegator :@body, :empty?
-
-
1
def_delegator :@body, :chunk!
-
-
1
def initialize(verb, uri, options = {})
-
250
@verb = verb.to_s.downcase.to_sym
-
250
@uri = URI(uri.to_s)
-
250
@options = Options.new(options)
-
-
250
raise(Error, "unknown method: #{verb}") unless METHODS.include?(@verb)
-
-
250
@headers = @options.headers_class.new(@options.headers)
-
250
@headers["user-agent"] ||= USER_AGENT
-
250
@headers["accept"] ||= "*/*"
-
-
250
@body = @options.request_body_class.new(@headers, @options)
-
250
@state = :idle
-
end
-
-
1
if RUBY_VERSION < "2.2"
-
# rubocop: disable Lint/UriEscapeUnescape:
-
def initialize_with_escape(verb, uri, options = {})
-
initialize_without_escape(verb, URI.escape(uri.to_s), options)
-
end
-
alias_method :initialize_without_escape, :initialize
-
alias_method :initialize, :initialize_with_escape
-
# rubocop: enable Lint/UriEscapeUnescape:
-
end
-
-
1
def merge_headers(h)
-
1
@headers = @headers.merge(h)
-
end
-
-
1
def scheme
-
120
@uri.scheme
-
end
-
-
1
def response=(response)
-
211
return unless response
-
-
211
@timer.cancel if @timer
-
211
@response = response
-
end
-
-
1
def path
-
227
path = uri.path.dup
-
227
path << "/" if path.empty?
-
227
path << "?#{query}" unless query.empty?
-
227
path
-
end
-
-
# https://bugs.ruby-lang.org/issues/15278
-
1
def authority
-
218
@uri.authority
-
end
-
-
# https://bugs.ruby-lang.org/issues/15278
-
1
def origin
-
136
@uri.origin
-
end
-
-
1
def query
-
253
return @query if defined?(@query)
-
-
210
query = []
-
210
if (q = @options.params)
-
8
query << URI.encode_www_form(q)
-
end
-
210
query << @uri.query if @uri.query
-
210
@query = query.join("&")
-
end
-
-
1
def drain_body
-
192
return nil if @body.nil?
-
-
192
@drainer ||= @body.each
-
192
chunk = @drainer.next
-
116
chunk.dup
-
rescue StopIteration
-
76
nil
-
end
-
-
1
def inspect
-
"#<Request #{@verb.to_s.upcase} #{path} @headers=#{@headers.to_hash} @body=#{@body}>"
-
end
-
-
1
class Body
-
1
class << self
-
1
def new(*, options)
-
250
return options.body if options.body.is_a?(self)
-
-
228
super
-
end
-
end
-
-
1
def initialize(headers, options)
-
228
@headers = headers
-
228
@body = if options.body
-
44
Transcoder.registry("body").encode(options.body)
-
184
elsif options.form
-
33
Transcoder.registry("form").encode(options.form)
-
151
elsif options.json
-
9
Transcoder.registry("json").encode(options.json)
-
end
-
228
return if @body.nil?
-
-
86
@headers["content-type"] ||= @body.content_type
-
86
@headers["content-length"] = @body.bytesize unless unbounded_body?
-
end
-
-
1
def each(&block)
-
152
return enum_for(__method__) unless block_given?
-
76
return if @body.nil?
-
-
76
body = stream(@body)
-
76
if body.respond_to?(:read)
-
40
::IO.copy_stream(body, ProcIO.new(block))
-
36
elsif body.respond_to?(:each)
-
14
body.each(&block)
-
else
-
22
block[body.to_s]
-
end
-
end
-
-
1
def empty?
-
353
return true if @body.nil?
-
140
return false if chunked?
-
-
140
bytesize.zero?
-
end
-
-
1
def bytesize
-
52250
return 0 if @body.nil?
-
-
140
if @body.respond_to?(:bytesize)
-
140
@body.bytesize
-
elsif @body.respond_to?(:size)
-
@body.size
-
else
-
raise Error, "cannot determine size of body: #{@body.inspect}"
-
end
-
end
-
-
1
def stream(body)
-
76
encoded = body
-
76
encoded = Transcoder.registry("chunker").encode(body) if chunked?
-
76
encoded
-
end
-
-
1
def unbounded_body?
-
86
chunked? || @body.bytesize == Float::INFINITY
-
end
-
-
1
def chunked?
-
316
@headers["transfer-encoding"] == "chunked"
-
end
-
-
1
def chunk!
-
@headers.add("transfer-encoding", "chunked")
-
end
-
end
-
-
1
def transition(nextstate)
-
1015984
case nextstate
-
when :idle
-
13
@response = nil
-
when :headers
-
338662
return unless @state == :idle
-
when :body
-
338662
return unless @state == :headers ||
-
@state == :expect
-
-
1019
if @headers.key?("expect")
-
808
unless @response
-
800
@state = :expect
-
800
return
-
end
-
-
8
case @response.status
-
when 100
-
# deallocate
-
8
@response = nil
-
when 417
-
@response = @response
-
return
-
end
-
end
-
when :done
-
338647
return if @state == :expect
-
end
-
338298
@state = nextstate
-
nil
-
end
-
-
1
def expects?
-
207
@headers["expect"] == "100-continue" &&
-
@response && @response.status == 100
-
end
-
-
1
class ProcIO
-
1
def initialize(block)
-
40
@block = block
-
end
-
-
1
def write(data)
-
56
@block.call(data)
-
56
data.bytesize
-
end
-
end
-
end
-
end
-
# frozen_string_literal: true
-
-
1
require "resolv"
-
-
1
module HTTPX
-
1
module Resolver
-
1
autoload :ResolverMixin, "httpx/resolver/resolver_mixin"
-
1
autoload :System, "httpx/resolver/system"
-
1
autoload :Native, "httpx/resolver/native"
-
1
autoload :HTTPS, "httpx/resolver/https"
-
-
1
extend Registry
-
-
1
register :system, :System
-
1
register :native, :Native
-
1
register :https, :HTTPS
-
-
1
@lookup_mutex = Mutex.new
-
21
@lookups = Hash.new { |h, k| h[k] = [] }
-
-
1
@identifier_mutex = Mutex.new
-
1
@identifier = 1
-
-
1
module_function
-
-
1
def cached_lookup(hostname)
-
210
now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-
210
@lookup_mutex.synchronize do
-
210
lookup(hostname, now)
-
end
-
end
-
-
1
def cached_lookup_set(hostname, entries)
-
27
now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-
27
entries.each do |entry|
-
34
entry["TTL"] += now
-
end
-
27
@lookup_mutex.synchronize do
-
27
@lookups[hostname] += entries
-
27
entries.each do |entry|
-
34
@lookups[entry["name"]] << entry if entry["name"] != hostname
-
end
-
end
-
end
-
-
1
def uncache(hostname)
-
@lookup_mutex.synchronize do
-
@lookups.delete(hostname)
-
end
-
end
-
-
# do not use directly!
-
1
def lookup(hostname, ttl)
-
211
return unless @lookups.key?(hostname)
-
-
180
@lookups[hostname] = @lookups[hostname].select do |address|
-
696
address["TTL"] > ttl
-
end
-
180
ips = @lookups[hostname].flat_map do |address|
-
695
if address.key?("alias")
-
1
lookup(address["alias"], ttl)
-
else
-
694
address["data"]
-
end
-
end
-
180
ips unless ips.empty?
-
end
-
-
1
def generate_id
-
58
@identifier_mutex.synchronize { @identifier = (@identifier + 1) & 0xFFFF }
-
end
-
-
1
def encode_dns_query(hostname, type: Resolv::DNS::Resource::IN::A)
-
29
Resolv::DNS::Message.new.tap do |query|
-
29
query.id = generate_id
-
29
query.rd = 1
-
29
query.add_question(hostname, type)
-
end.encode
-
end
-
-
1
def decode_dns_answer(payload)
-
30
message = Resolv::DNS::Message.decode(payload)
-
30
addresses = []
-
30
message.each_answer do |question, _, value|
-
33
case value
-
when Resolv::DNS::Resource::IN::CNAME
-
2
addresses << {
-
"name" => question.to_s,
-
"TTL" => value.ttl,
-
"alias" => value.name.to_s,
-
}
-
when Resolv::DNS::Resource::IN::A,
-
Resolv::DNS::Resource::IN::AAAA
-
31
addresses << {
-
"name" => question.to_s,
-
"TTL" => value.ttl,
-
"data" => value.address.to_s,
-
}
-
end
-
end
-
30
addresses
-
end
-
end
-
end
-
-
1
require "httpx/resolver/options"
-
# frozen_string_literal: true
-
-
1
require "resolv"
-
1
require "uri"
-
1
require "cgi"
-
1
require "forwardable"
-
-
1
module HTTPX
-
1
class Resolver::HTTPS
-
1
extend Forwardable
-
1
include Resolver::ResolverMixin
-
-
1
NAMESERVER = "https://1.1.1.1/dns-query"
-
-
RECORD_TYPES = {
-
1
"A" => Resolv::DNS::Resource::IN::A,
-
"AAAA" => Resolv::DNS::Resource::IN::AAAA,
-
}.freeze
-
-
DEFAULTS = {
-
1
uri: NAMESERVER,
-
use_get: false,
-
}.freeze
-
-
1
def_delegator :@connections, :empty?
-
-
1
def_delegators :@resolver_connection, :to_io, :call, :interests, :close
-
-
1
def initialize(options)
-
8
@options = Options.new(options)
-
8
@resolver_options = Resolver::Options.new(DEFAULTS.merge(@options.resolver_options || {}))
-
11
@_record_types = Hash.new { |types, host| types[host] = RECORD_TYPES.keys.dup }
-
8
@queries = {}
-
8
@requests = {}
-
8
@connections = []
-
8
@uri = URI(@resolver_options.uri)
-
8
@uri_addresses = nil
-
end
-
-
1
def <<(connection)
-
5
@uri_addresses ||= Resolv.getaddresses(@uri.host)
-
5
if @uri_addresses.empty?
-
ex = ResolveError.new("Can't resolve #{connection.origin.host}")
-
ex.set_backtrace(caller)
-
emit(:error, connection, ex)
-
else
-
5
early_resolve(connection) || resolve(connection)
-
end
-
end
-
-
1
def timeout
-
@connections.map(&:timeout).min
-
end
-
-
1
def closed?
-
return true unless @resolver_connection
-
-
resolver_connection.closed?
-
end
-
-
1
private
-
-
1
def pool
-
Thread.current[:httpx_connection_pool] ||= Pool.new
-
end
-
-
1
def resolver_connection
-
5
@resolver_connection ||= pool.find_connection(@uri, @options) || begin
-
@building_connection = true
-
connection = @options.connection_class.new("ssl", @uri, @options.merge(ssl: { alpn_protocols: %w[h2] }))
-
pool.init_connection(connection, @options)
-
emit_addresses(connection, @uri_addresses)
-
@building_connection = false
-
connection
-
end
-
end
-
-
1
def resolve(connection = @connections.first, hostname = nil)
-
5
return if @building_connection
-
-
5
hostname = hostname || @queries.key(connection) || connection.origin.host
-
5
type = @_record_types[hostname].first
-
5
log(label: "resolver: ") { "query #{type} for #{hostname}" }
-
begin
-
5
request = build_request(hostname, type)
-
5
@requests[request] = connection
-
5
resolver_connection.send(request)
-
5
@queries[hostname] = connection
-
5
@connections << connection
-
rescue Resolv::DNS::EncodeError, JSON::JSONError => e
-
emit_resolve_error(connection, hostname, e)
-
end
-
end
-
-
1
def on_response(request, response)
-
response.raise_for_status
-
rescue Error => ex
-
connection = @requests[request]
-
hostname = @queries.key(connection)
-
error = ResolveError.new("Can't resolve #{hostname}: #{ex.message}")
-
error.set_backtrace(ex.backtrace)
-
emit(:error, connection, error)
-
else
-
parse(response)
-
ensure
-
@requests.delete(request)
-
end
-
-
1
def on_promise(_, stream)
-
log(level: 2, label: "#{stream.id}: ") { "refusing stream!" }
-
stream.refuse
-
end
-
-
1
def parse(response)
-
begin
-
5
answers = decode_response_body(response)
-
rescue Resolv::DNS::DecodeError, JSON::JSONError => e
-
host, connection = @queries.first
-
if @_record_types[host].empty?
-
emit_resolve_error(connection, host, e)
-
return
-
end
-
end
-
5
if answers.empty?
-
2
host, connection = @queries.first
-
2
@_record_types[host].shift
-
2
if @_record_types[host].empty?
-
1
@_record_types.delete(host)
-
1
emit_resolve_error(connection, host)
-
1
return
-
end
-
else
-
6
answers = answers.group_by { |answer| answer["name"] }
-
3
answers.each do |hostname, addresses|
-
3
addresses = addresses.flat_map do |address|
-
3
if address.key?("alias")
-
1
alias_address = answers[address["alias"]]
-
1
if alias_address.nil?
-
1
connection = @queries[hostname]
-
1
@queries.delete(address["name"])
-
1
resolve(connection, address["alias"])
-
1
return # rubocop:disable Lint/NonLocalExitFromIterator
-
else
-
alias_address
-
end
-
else
-
2
address
-
end
-
end.compact
-
2
next if addresses.empty?
-
-
2
hostname = hostname[0..-2] if hostname.end_with?(".")
-
2
connection = @queries.delete(hostname)
-
2
next unless connection # probably a retried query for which there's an answer
-
-
2
@connections.delete(connection)
-
2
Resolver.cached_lookup_set(hostname, addresses)
-
4
emit_addresses(connection, addresses.map { |addr| addr["data"] })
-
end
-
end
-
3
return if @connections.empty?
-
-
1
resolve
-
end
-
-
1
def build_request(hostname, type)
-
5
uri = @uri.dup
-
5
rklass = @options.request_class
-
5
if @resolver_options.use_get
-
params = URI.decode_www_form(uri.query.to_s)
-
params << ["type", type]
-
params << ["name", CGI.escape(hostname)]
-
uri.query = URI.encode_www_form(params)
-
request = rklass.new("GET", uri, @options)
-
else
-
5
payload = Resolver.encode_dns_query(hostname, type: RECORD_TYPES[type])
-
5
request = rklass.new("POST", uri, @options.merge(body: [payload]))
-
5
request.headers["content-type"] = "application/dns-message"
-
5
request.headers["accept"] = "application/dns-message"
-
end
-
5
request.on(:response, &method(:on_response).curry[request])
-
5
request.on(:promise, &method(:on_promise))
-
5
request
-
end
-
-
1
def decode_response_body(response)
-
5
case response.headers["content-type"]
-
when "application/dns-json",
-
"application/json",
-
%r{^application\/x\-javascript} # because google...
-
payload = JSON.parse(response.to_s)
-
payload["Answer"]
-
when "application/dns-udpwireformat",
-
"application/dns-message"
-
5
Resolver.decode_dns_answer(response.to_s)
-
else
-
raise Error, "unsupported DNS mime-type (#{response.headers["content-type"]})"
-
end
-
end
-
end
-
end
-
# frozen_string_literal: true
-
-
1
require "forwardable"
-
1
require "resolv"
-
-
1
module HTTPX
-
1
class Resolver::Native
-
1
extend Forwardable
-
1
include Resolver::ResolverMixin
-
-
1
RESOLVE_TIMEOUT = 5
-
RECORD_TYPES = {
-
1
"A" => Resolv::DNS::Resource::IN::A,
-
"AAAA" => Resolv::DNS::Resource::IN::AAAA,
-
}.freeze
-
-
1
DEFAULTS = if RUBY_VERSION < "2.2"
-
{
-
**Resolv::DNS::Config.default_config_hash,
-
packet_size: 512,
-
timeouts: RESOLVE_TIMEOUT,
-
record_types: RECORD_TYPES.keys,
-
}.freeze
-
else
-
{
-
1
nameserver: nil,
-
**Resolv::DNS::Config.default_config_hash,
-
packet_size: 512,
-
timeouts: RESOLVE_TIMEOUT,
-
record_types: RECORD_TYPES.keys,
-
}.freeze
-
end
-
-
# nameservers for ipv6 are misconfigured in certain systems;
-
# this can use an unexpected endless loop
-
# https://gitlab.com/honeyryderchuck/httpx/issues/56
-
DEFAULTS[:nameserver].select! do |nameserver|
-
begin
-
1
IPAddr.new(nameserver)
-
1
true
-
rescue IPAddr::InvalidAddressError
-
false
-
end
-
1
end if DEFAULTS[:nameserver]
-
-
1
DNS_PORT = 53
-
-
1
def_delegator :@connections, :empty?
-
-
1
def initialize(options)
-
34
@options = Options.new(options)
-
34
@ns_index = 0
-
34
@resolver_options = Resolver::Options.new(DEFAULTS.merge(@options.resolver_options || {}))
-
34
@nameserver = @resolver_options.nameserver
-
34
@_timeouts = Array(@resolver_options.timeouts)
-
54
@timeouts = Hash.new { |timeouts, host| timeouts[host] = @_timeouts.dup }
-
57
@_record_types = Hash.new { |types, host| types[host] = @resolver_options.record_types.dup }
-
34
@connections = []
-
34
@queries = {}
-
34
@read_buffer = Buffer.new(@resolver_options.packet_size)
-
34
@write_buffer = Buffer.new(@resolver_options.packet_size)
-
34
@state = :idle
-
end
-
-
1
def close
-
20
transition(:closed)
-
end
-
-
1
def closed?
-
338320
@state == :closed
-
end
-
-
1
def to_io
-
80
case @state
-
when :idle
-
20
transition(:open)
-
when :closed
-
transition(:idle)
-
transition(:open)
-
end
-
80
resolve if @queries.empty?
-
80
@io.to_io
-
end
-
-
1
def call
-
40
case @state
-
when :open
-
40
consume
-
end
-
nil
-
rescue Errno::EHOSTUNREACH,
-
NativeResolveError => e
-
@ns_index += 1
-
if @ns_index < @nameserver.size
-
log(label: "resolver: ") do
-
"failed resolving on nameserver #{@nameserver[@ns_index - 1]} (#{e.message})"
-
end
-
transition(:idle)
-
else
-
if e.respond_to?(:connection) &&
-
e.respond_to?(:host)
-
emit_resolve_error(e.connection, e.host, e)
-
else
-
@queries.each do |host, connection|
-
emit_resolve_error(connection, host, e)
-
end
-
end
-
end
-
end
-
-
1
def interests
-
40
readable = !@read_buffer.full?
-
40
writable = !@write_buffer.empty?
-
40
if readable
-
writable ? :rw : :r
-
else
-
40
writable ? :w : :r
-
end
-
end
-
-
1
def <<(connection)
-
208
return if early_resolve(connection)
-
-
22
if @nameserver.nil?
-
ex = ResolveError.new("Can't resolve #{connection.origin.host}: no nameserver")
-
ex.set_backtrace(caller)
-
emit(:error, connection, ex)
-
else
-
22
@connections << connection
-
22
resolve
-
end
-
end
-
-
1
def timeout
-
338260
@start_timeout = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-
338260
hosts = @queries.keys
-
338260
@timeouts.values_at(*hosts).reject(&:empty?).map(&:first).min
-
end
-
-
1
private
-
-
1
def consume
-
40
dread
-
40
do_retry
-
40
dwrite
-
end
-
-
1
def do_retry
-
40
return if @queries.empty?
-
-
20
loop_time = Process.clock_gettime(Process::CLOCK_MONOTONIC) - @start_timeout
-
20
connections = []
-
20
queries = {}
-
60
while (query = @queries.shift)
-
20
h, connection = query
-
20
host = connection.origin.host
-
20
timeout = (@timeouts[host][0] -= loop_time)
-
20
unless timeout.negative?
-
20
queries[h] = connection
-
20
next
-
end
-
@timeouts[host].shift
-
if @timeouts[host].empty?
-
@timeouts.delete(host)
-
raise NativeResolveError.new(connection, host)
-
else
-
connections << connection
-
log(label: "resolver: ") do
-
"timeout after #{prev_timeout}s, retry(#{timeouts.first}) #{host}..."
-
end
-
end
-
end
-
20
@queries = queries
-
20
connections.each { |ch| resolve(ch) }
-
end
-
-
1
def dread(wsize = @read_buffer.limit)
-
40
loop do
-
60
siz = @io.read(wsize, @read_buffer)
-
60
unless siz
-
20
emit(:close)
-
20
return
-
end
-
40
return if siz.zero?
-
-
20
log(label: "resolver: ") { "READ: #{siz} bytes..." }
-
20
parse(@read_buffer.to_s)
-
end
-
end
-
-
1
def dwrite
-
40
loop do
-
60
return if @write_buffer.empty?
-
-
20
siz = @io.write(@write_buffer)
-
20
unless siz
-
emit(:close)
-
return
-
end
-
20
log(label: "resolver: ") { "WRITE: #{siz} bytes..." }
-
20
return if siz.zero?
-
end
-
end
-
-
1
def parse(buffer)
-
begin
-
25
addresses = Resolver.decode_dns_answer(buffer)
-
rescue Resolv::DNS::DecodeError => e
-
hostname, connection = @queries.first
-
if @_record_types[hostname].empty?
-
ex = NativeResolveError.new(connection, hostname, e.message)
-
ex.set_backtrace(e.backtrace)
-
raise ex
-
end
-
end
-
-
25
if addresses.empty?
-
2
hostname, connection = @queries.first
-
2
@_record_types[hostname].shift
-
2
if @_record_types[hostname].empty?
-
1
@_record_types.delete(hostname)
-
1
raise NativeResolveError.new(connection, hostname)
-
end
-
else
-
23
address = addresses.first
-
23
connection = @queries.delete(address["name"])
-
23
return unless connection # probably a retried query for which there's an answer
-
-
23
if address.key?("alias") # CNAME
-
1
if early_resolve(connection, hostname: address["alias"])
-
@connections.delete(connection)
-
else
-
1
resolve(connection, address["alias"])
-
1
@queries.delete(address["name"])
-
1
return
-
end
-
else
-
22
@connections.delete(connection)
-
22
Resolver.cached_lookup_set(connection.origin.host, addresses)
-
51
emit_addresses(connection, addresses.map { |addr| addr["data"] })
-
end
-
end
-
23
return emit(:close) if @connections.empty?
-
-
1
resolve
-
end
-
-
1
def resolve(connection = @connections.first, hostname = nil)
-
26
raise Error, "no URI to resolve" unless connection
-
26
return unless @write_buffer.empty?
-
-
24
hostname = hostname || @queries.key(connection) || connection.origin.host
-
24
@queries[hostname] = connection
-
24
type = @_record_types[hostname].first
-
24
log(label: "resolver: ") { "query #{type} for #{hostname}" }
-
begin
-
24
@write_buffer << Resolver.encode_dns_query(hostname, type: RECORD_TYPES[type])
-
rescue Resolv::DNS::EncodeError => e
-
emit_resolve_error(connection, hostname, e)
-
end
-
end
-
-
1
def build_socket
-
20
return if @io
-
-
20
ip, port = @nameserver[@ns_index]
-
20
port ||= DNS_PORT
-
20
uri = URI::Generic.build(scheme: "udp", port: port)
-
20
uri.hostname = ip
-
20
type = IO.registry(uri.scheme)
-
20
log(label: "resolver: ") { "server: #{uri}..." }
-
20
@io = type.new(uri, [IPAddr.new(ip)], @options)
-
end
-
-
1
def transition(nextstate)
-
40
case nextstate
-
when :idle
-
if @io
-
@io.close
-
@io = nil
-
end
-
@timeouts.clear
-
when :open
-
20
return unless @state == :idle
-
-
20
build_socket
-
20
@io.connect
-
20
return unless @io.connected?
-
when :closed
-
20
return unless @state == :open
-
-
20
@io.close if @io
-
end
-
40
@state = nextstate
-
end
-
end
-
end
-
# frozen_string_literal: true
-
-
1
module HTTPX
-
1
class Resolver::Options
-
1
def initialize(options = {})
-
42
@options = options
-
end
-
-
1
def method_missing(m, *args, &block)
-
172
if @options.key?(m)
-
172
@options[m]
-
else
-
super
-
end
-
end
-
-
1
def respond_to_missing?(m)
-
@options.key?(m) || super
-
end
-
-
1
def to_h
-
@options
-
end
-
end
-
end
-
# frozen_string_literal: true
-
-
1
require "resolv"
-
1
require "ipaddr"
-
-
1
module HTTPX
-
1
module Resolver
-
1
module ResolverMixin
-
1
include Callbacks
-
1
include Loggable
-
-
1
CHECK_IF_IP = proc do |name|
-
begin
-
214
IPAddr.new(name)
-
6
true
-
rescue ArgumentError
-
208
false
-
end
-
end
-
-
1
def uncache(connection)
-
hostname = hostname || @queries.key(connection) || connection.origin.host
-
Resolver.uncache(hostname)
-
@_record_types[hostname].shift
-
end
-
-
1
private
-
-
1
def emit_addresses(connection, addresses)
-
217
addresses.map! do |address|
-
746
address.is_a?(IPAddr) ? address : IPAddr.new(address.to_s)
-
end
-
217
log(label: "resolver: ") { "answer #{connection.origin.host}: #{addresses.inspect}" }
-
217
connection.addresses = addresses
-
217
emit(:resolve, connection)
-
end
-
-
1
def early_resolve(connection, hostname: connection.origin.host)
-
214
addresses = connection.addresses ||
-
ip_resolve(hostname) ||
-
Resolver.cached_lookup(hostname) ||
-
system_resolve(hostname)
-
214
return unless addresses
-
-
189
emit_addresses(connection, addresses)
-
end
-
-
1
def ip_resolve(hostname)
-
214
[hostname] if CHECK_IF_IP[hostname]
-
end
-
-
1
def system_resolve(hostname)
-
32
@system_resolver ||= Resolv::Hosts.new
-
32
ips = @system_resolver.getaddresses(hostname)
-
32
return if ips.empty?
-
-
18
ips.map { |ip| IPAddr.new(ip) }
-
end
-
-
1
def emit_resolve_error(connection, hostname, ex = nil)
-
1
message = ex ? ex.message : "Can't resolve #{hostname}"
-
1
error = ResolveError.new(message)
-
1
error.set_backtrace(ex ? ex.backtrace : caller)
-
1
emit(:error, connection, error)
-
end
-
end
-
end
-
end
-
# frozen_string_literal: true
-
-
1
require "forwardable"
-
1
require "resolv"
-
-
1
module HTTPX
-
1
class Resolver::System
-
1
include Resolver::ResolverMixin
-
-
1
RESOLV_ERRORS = [Resolv::ResolvError,
-
Resolv::DNS::Requester::RequestError,
-
Resolv::DNS::EncodeError,
-
Resolv::DNS::DecodeError].freeze
-
-
1
def initialize(options)
-
7
@options = Options.new(options)
-
7
roptions = @options.resolver_options
-
7
@state = :idle
-
7
@resolver = Resolv::DNS.new(roptions.nil? ? nil : roptions)
-
7
@resolver.timeouts = roptions[:timeouts] if roptions
-
end
-
-
1
def closed?
-
true
-
end
-
-
1
def empty?
-
true
-
end
-
-
1
def <<(connection)
-
4
hostname = connection.origin.host
-
4
addresses = connection.addresses ||
-
ip_resolve(hostname) ||
-
system_resolve(hostname) ||
-
@resolver.getaddresses(hostname)
-
4
return emit_resolve_error(connection, hostname) if addresses.empty?
-
-
4
emit_addresses(connection, addresses)
-
rescue Errno::EHOSTUNREACH, *RESOLV_ERRORS => e
-
emit_resolve_error(connection, hostname, e)
-
end
-
-
1
def uncache(*); end
-
end
-
end
