Class: Faraday::Adapter::Excon

Inherits:
Faraday::Adapter show all
Defined in:
lib/faraday/adapter/excon.rb

Constant Summary

Constants inherited from Faraday::Adapter

CONTENT_LENGTH

Instance Attribute Summary

Attributes included from Parallelism

#supports_parallel

Instance Method Summary collapse

Methods inherited from Faraday::Adapter

#initialize, #save_response

Methods included from Parallelism

#inherited, #supports_parallel?

Methods included from Faraday::AutoloadHelper

#all_loaded_constants, #autoload_all, #load_autoloaded_constants

Methods inherited from Middleware

dependency, inherited, #initialize, loaded?, new

Methods included from MiddlewareRegistry

#fetch_middleware, #load_middleware, #lookup_middleware, #middleware_mutex, #register_middleware

Constructor Details

This class inherits a constructor from Faraday::Adapter

Instance Method Details

#call(env) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
 
# File 'lib/faraday/adapter/excon.rb', line 6

def call(env)
  super

  opts = {}
  if env[:url].scheme == 'https' && ssl = env[:ssl]
    opts[:ssl_verify_peer] = !!ssl.fetch(:verify, true)
    opts[:ssl_ca_path] = ssl[:ca_path] if ssl[:ca_path]
    opts[:ssl_ca_file] = ssl[:ca_file] if ssl[:ca_file]
    opts[:client_cert] = ssl[:client_cert] if ssl[:client_cert]
    opts[:client_key]  = ssl[:client_key]  if ssl[:client_key]
    opts[:certificate] = ssl[:certificate] if ssl[:certificate]
    opts[:private_key] = ssl[:private_key] if ssl[:private_key]

    # https://github.com/geemus/excon/issues/106
    # https://github.com/jruby/jruby-ossl/issues/19
    opts[:nonblock] = false
  end

  if ( req = env[:request] )
    if req[:timeout]
      opts[:read_timeout]      = req[:timeout]
      opts[:connect_timeout]   = req[:timeout]
      opts[:write_timeout]     = req[:timeout]
    end

    if req[:open_timeout]
      opts[:connect_timeout]   = req[:open_timeout]
      opts[:write_timeout]     = req[:open_timeout]
    end

    if req[:proxy]
      opts[:proxy] = {
        :host     => req[:proxy][:uri].host,
        :hostname => req[:proxy][:uri].hostname,
        :port     => req[:proxy][:uri].port,
        :scheme   => req[:proxy][:uri].scheme,
        :user     => req[:proxy][:user],
        :password => req[:proxy][:password]
      }
    end
  end

  conn = create_connection(env, opts)

  resp = conn.request \
    :method  => env[:method].to_s.upcase,
    :headers => env[:request_headers],
    :body    => read_body(env)

  save_response(env, resp.status.to_i, resp.body, resp.headers, resp.reason_phrase)

  @app.call env
rescue ::Excon::Errors::SocketError => err
  if err.message =~ /\btimeout\b/
    raise Error::TimeoutError, err
  elsif err.message =~ /\bcertificate\b/
    raise Faraday::SSLError, err
  else
    raise Error::ConnectionFailed, err
  end
rescue ::Excon::Errors::Timeout => err
  raise Error::TimeoutError, err
end

#create_connection(env, opts) ⇒ Object 



70
71
72
 
# File 'lib/faraday/adapter/excon.rb', line 70

def create_connection(env, opts)
  ::Excon.new(env[:url].to_s, opts.merge(@connection_options))
end

#read_body(env) ⇒ Object

TODO: support streaming requests



75
76
77
 
# File 'lib/faraday/adapter/excon.rb', line 75

def read_body(env)
  env[:body].respond_to?(:read) ? env[:body].read : env[:body]
end