faraday 0.17.3 → 1.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (133) hide show
  1. checksums.yaml +4 -4
  2. data/CHANGELOG.md +52 -8
  3. data/LICENSE.md +1 -1
  4. data/README.md +18 -358
  5. data/Rakefile +1 -7
  6. data/examples/client_spec.rb +65 -0
  7. data/examples/client_test.rb +79 -0
  8. data/lib/faraday.rb +94 -175
  9. data/lib/faraday/adapter.rb +82 -22
  10. data/lib/faraday/adapter/em_http.rb +142 -99
  11. data/lib/faraday/adapter/em_http_ssl_patch.rb +24 -18
  12. data/lib/faraday/adapter/em_synchrony.rb +104 -60
  13. data/lib/faraday/adapter/em_synchrony/parallel_manager.rb +18 -15
  14. data/lib/faraday/adapter/excon.rb +98 -56
  15. data/lib/faraday/adapter/httpclient.rb +83 -59
  16. data/lib/faraday/adapter/net_http.rb +130 -63
  17. data/lib/faraday/adapter/net_http_persistent.rb +50 -27
  18. data/lib/faraday/adapter/patron.rb +80 -43
  19. data/lib/faraday/adapter/rack.rb +30 -13
  20. data/lib/faraday/adapter/test.rb +86 -53
  21. data/lib/faraday/adapter/typhoeus.rb +4 -1
  22. data/lib/faraday/adapter_registry.rb +30 -0
  23. data/lib/faraday/autoload.rb +47 -36
  24. data/lib/faraday/connection.rb +312 -182
  25. data/lib/faraday/dependency_loader.rb +37 -0
  26. data/lib/faraday/encoders/flat_params_encoder.rb +98 -0
  27. data/lib/faraday/encoders/nested_params_encoder.rb +171 -0
  28. data/lib/faraday/error.rb +9 -35
  29. data/lib/faraday/file_part.rb +128 -0
  30. data/lib/faraday/logging/formatter.rb +105 -0
  31. data/lib/faraday/middleware.rb +12 -28
  32. data/lib/faraday/middleware_registry.rb +129 -0
  33. data/lib/faraday/options.rb +32 -183
  34. data/lib/faraday/options/connection_options.rb +22 -0
  35. data/lib/faraday/options/env.rb +181 -0
  36. data/lib/faraday/options/proxy_options.rb +28 -0
  37. data/lib/faraday/options/request_options.rb +22 -0
  38. data/lib/faraday/options/ssl_options.rb +59 -0
  39. data/lib/faraday/param_part.rb +53 -0
  40. data/lib/faraday/parameters.rb +4 -197
  41. data/lib/faraday/rack_builder.rb +66 -55
  42. data/lib/faraday/request.rb +68 -36
  43. data/lib/faraday/request/authorization.rb +44 -30
  44. data/lib/faraday/request/basic_authentication.rb +14 -7
  45. data/lib/faraday/request/instrumentation.rb +45 -27
  46. data/lib/faraday/request/multipart.rb +79 -48
  47. data/lib/faraday/request/retry.rb +197 -171
  48. data/lib/faraday/request/token_authentication.rb +15 -10
  49. data/lib/faraday/request/url_encoded.rb +43 -23
  50. data/lib/faraday/response.rb +24 -14
  51. data/lib/faraday/response/logger.rb +22 -69
  52. data/lib/faraday/response/raise_error.rb +38 -18
  53. data/lib/faraday/utils.rb +36 -245
  54. data/lib/faraday/utils/headers.rb +139 -0
  55. data/lib/faraday/utils/params_hash.rb +61 -0
  56. data/spec/external_adapters/faraday_specs_setup.rb +14 -0
  57. data/spec/faraday/adapter/em_http_spec.rb +47 -0
  58. data/spec/faraday/adapter/em_synchrony_spec.rb +16 -0
  59. data/spec/faraday/adapter/excon_spec.rb +49 -0
  60. data/spec/faraday/adapter/httpclient_spec.rb +73 -0
  61. data/spec/faraday/adapter/net_http_persistent_spec.rb +57 -0
  62. data/spec/faraday/adapter/net_http_spec.rb +64 -0
  63. data/spec/faraday/adapter/patron_spec.rb +18 -0
  64. data/spec/faraday/adapter/rack_spec.rb +8 -0
  65. data/spec/faraday/adapter/typhoeus_spec.rb +7 -0
  66. data/spec/faraday/adapter_registry_spec.rb +28 -0
  67. data/spec/faraday/adapter_spec.rb +55 -0
  68. data/spec/faraday/composite_read_io_spec.rb +80 -0
  69. data/spec/faraday/connection_spec.rb +691 -0
  70. data/spec/faraday/error_spec.rb +0 -57
  71. data/spec/faraday/middleware_spec.rb +26 -0
  72. data/spec/faraday/options/env_spec.rb +70 -0
  73. data/spec/faraday/options/options_spec.rb +297 -0
  74. data/spec/faraday/options/proxy_options_spec.rb +37 -0
  75. data/spec/faraday/options/request_options_spec.rb +19 -0
  76. data/spec/faraday/params_encoders/flat_spec.rb +34 -0
  77. data/spec/faraday/params_encoders/nested_spec.rb +134 -0
  78. data/spec/faraday/rack_builder_spec.rb +196 -0
  79. data/spec/faraday/request/authorization_spec.rb +88 -0
  80. data/spec/faraday/request/instrumentation_spec.rb +76 -0
  81. data/spec/faraday/request/multipart_spec.rb +274 -0
  82. data/spec/faraday/request/retry_spec.rb +242 -0
  83. data/spec/faraday/request/url_encoded_spec.rb +83 -0
  84. data/spec/faraday/request_spec.rb +109 -0
  85. data/spec/faraday/response/logger_spec.rb +220 -0
  86. data/spec/faraday/response/middleware_spec.rb +68 -0
  87. data/spec/faraday/response/raise_error_spec.rb +15 -15
  88. data/spec/faraday/response_spec.rb +75 -0
  89. data/spec/faraday/utils/headers_spec.rb +82 -0
  90. data/spec/faraday/utils_spec.rb +56 -0
  91. data/spec/faraday_spec.rb +37 -0
  92. data/spec/spec_helper.rb +63 -36
  93. data/spec/support/disabling_stub.rb +14 -0
  94. data/spec/support/fake_safe_buffer.rb +15 -0
  95. data/spec/support/helper_methods.rb +133 -0
  96. data/spec/support/shared_examples/adapter.rb +104 -0
  97. data/spec/support/shared_examples/params_encoder.rb +18 -0
  98. data/spec/support/shared_examples/request_method.rb +234 -0
  99. data/spec/support/streaming_response_checker.rb +35 -0
  100. data/spec/support/webmock_rack_app.rb +68 -0
  101. metadata +66 -38
  102. data/lib/faraday/deprecate.rb +0 -107
  103. data/lib/faraday/upload_io.rb +0 -67
  104. data/spec/faraday/deprecate_spec.rb +0 -69
  105. data/test/adapters/default_test.rb +0 -14
  106. data/test/adapters/em_http_test.rb +0 -30
  107. data/test/adapters/em_synchrony_test.rb +0 -32
  108. data/test/adapters/excon_test.rb +0 -30
  109. data/test/adapters/httpclient_test.rb +0 -34
  110. data/test/adapters/integration.rb +0 -263
  111. data/test/adapters/logger_test.rb +0 -136
  112. data/test/adapters/net_http_persistent_test.rb +0 -114
  113. data/test/adapters/net_http_test.rb +0 -79
  114. data/test/adapters/patron_test.rb +0 -40
  115. data/test/adapters/rack_test.rb +0 -38
  116. data/test/adapters/test_middleware_test.rb +0 -157
  117. data/test/adapters/typhoeus_test.rb +0 -38
  118. data/test/authentication_middleware_test.rb +0 -65
  119. data/test/composite_read_io_test.rb +0 -109
  120. data/test/connection_test.rb +0 -738
  121. data/test/env_test.rb +0 -268
  122. data/test/helper.rb +0 -75
  123. data/test/live_server.rb +0 -67
  124. data/test/middleware/instrumentation_test.rb +0 -88
  125. data/test/middleware/retry_test.rb +0 -282
  126. data/test/middleware_stack_test.rb +0 -260
  127. data/test/multibyte.txt +0 -1
  128. data/test/options_test.rb +0 -333
  129. data/test/parameters_test.rb +0 -157
  130. data/test/request_middleware_test.rb +0 -126
  131. data/test/response_middleware_test.rb +0 -72
  132. data/test/strawberry.rb +0 -2
  133. data/test/utils_test.rb +0 -98
@@ -1,13 +1,20 @@
1
+ # frozen_string_literal: true
2
+
1
3
  require 'base64'
2
4
 
3
5
  module Faraday
4
- class Request::BasicAuthentication < Request.load_middleware(:authorization)
5
- # Public
6
- def self.header(login, pass)
7
- value = Base64.encode64([login, pass].join(':'))
8
- value.gsub!("\n", '')
9
- super(:Basic, value)
6
+ class Request
7
+ # Authorization middleware for Basic Authentication.
8
+ class BasicAuthentication < load_middleware(:authorization)
9
+ # @param login [String]
10
+ # @param pass [String]
11
+ #
12
+ # @return [String] a Basic Authentication header line
13
+ def self.header(login, pass)
14
+ value = Base64.encode64([login, pass].join(':'))
15
+ value.delete!("\n")
16
+ super(:Basic, value)
17
+ end
10
18
  end
11
19
  end
12
20
  end
13
-
@@ -1,35 +1,53 @@
1
+ # frozen_string_literal: true
2
+
1
3
  module Faraday
2
- class Request::Instrumentation < Faraday::Middleware
3
- class Options < Faraday::Options.new(:name, :instrumenter)
4
- def name
5
- self[:name] ||= 'request.faraday'
6
- end
4
+ class Request
5
+ # Middleware for instrumenting Requests.
6
+ class Instrumentation < Faraday::Middleware
7
+ # Options class used in Request::Instrumentation class.
8
+ class Options < Faraday::Options.new(:name, :instrumenter)
9
+ # @return [String]
10
+ def name
11
+ self[:name] ||= 'request.faraday'
12
+ end
7
13
 
8
- def instrumenter
9
- self[:instrumenter] ||= ActiveSupport::Notifications
14
+ # @return [Class]
15
+ def instrumenter
16
+ self[:instrumenter] ||= ActiveSupport::Notifications
17
+ end
10
18
  end
11
- end
12
19
 
13
- # Public: Instruments requests using Active Support.
14
- #
15
- # Measures time spent only for synchronous requests.
16
- #
17
- # Examples
18
- #
19
- # ActiveSupport::Notifications.subscribe('request.faraday') do |name, starts, ends, _, env|
20
- # url = env[:url]
21
- # http_method = env[:method].to_s.upcase
22
- # duration = ends - starts
23
- # $stderr.puts '[%s] %s %s (%.3f s)' % [url.host, http_method, url.request_uri, duration]
24
- # end
25
- def initialize(app, options = nil)
26
- super(app)
27
- @name, @instrumenter = Options.from(options).values_at(:name, :instrumenter)
28
- end
20
+ # Instruments requests using Active Support.
21
+ #
22
+ # Measures time spent only for synchronous requests.
23
+ #
24
+ # @example Using ActiveSupport::Notifications to measure time spent
25
+ # for Faraday requests.
26
+ # ActiveSupport::Notifications
27
+ # .subscribe('request.faraday') do |name, starts, ends, _, env|
28
+ # url = env[:url]
29
+ # http_method = env[:method].to_s.upcase
30
+ # duration = ends - starts
31
+ # $stderr.puts '[%s] %s %s (%.3f s)' %
32
+ # [url.host, http_method, url.request_uri, duration]
33
+ # end
34
+ # @param app [#call]
35
+ # @param options [nil, Hash] Options hash
36
+ # @option options [String] :name ('request.faraday')
37
+ # Name of the instrumenter
38
+ # @option options [Class] :instrumenter (ActiveSupport::Notifications)
39
+ # Active Support instrumenter class.
40
+ def initialize(app, options = nil)
41
+ super(app)
42
+ @name, @instrumenter = Options.from(options)
43
+ .values_at(:name, :instrumenter)
44
+ end
29
45
 
30
- def call(env)
31
- @instrumenter.instrument(@name, env) do
32
- @app.call(env)
46
+ # @param env [Faraday::Env]
47
+ def call(env)
48
+ @instrumenter.instrument(@name, env) do
49
+ @app.call(env)
50
+ end
33
51
  end
34
52
  end
35
53
  end
@@ -1,66 +1,97 @@
1
- require File.expand_path("../url_encoded", __FILE__)
1
+ # frozen_string_literal: true
2
+
3
+ require File.expand_path('url_encoded', __dir__)
2
4
  require 'securerandom'
3
5
 
4
6
  module Faraday
5
- class Request::Multipart < Request::UrlEncoded
6
- self.mime_type = 'multipart/form-data'.freeze
7
- DEFAULT_BOUNDARY_PREFIX = "-----------RubyMultipartPost".freeze unless defined? DEFAULT_BOUNDARY_PREFIX
7
+ class Request
8
+ # Middleware for supporting multi-part requests.
9
+ class Multipart < UrlEncoded
10
+ self.mime_type = 'multipart/form-data'
11
+ unless defined?(::Faraday::Request::Multipart::DEFAULT_BOUNDARY_PREFIX)
12
+ DEFAULT_BOUNDARY_PREFIX = '-----------RubyMultipartPost'
13
+ end
8
14
 
9
- def call(env)
10
- match_content_type(env) do |params|
11
- env.request.boundary ||= unique_boundary
12
- env.request_headers[CONTENT_TYPE] += "; boundary=#{env.request.boundary}"
13
- env.body = create_multipart(env, params)
15
+ # Checks for files in the payload, otherwise leaves everything untouched.
16
+ #
17
+ # @param env [Faraday::Env]
18
+ def call(env)
19
+ match_content_type(env) do |params|
20
+ env.request.boundary ||= unique_boundary
21
+ env.request_headers[CONTENT_TYPE] +=
22
+ "; boundary=#{env.request.boundary}"
23
+ env.body = create_multipart(env, params)
24
+ end
25
+ @app.call env
14
26
  end
15
- @app.call env
16
- end
17
27
 
18
- def process_request?(env)
19
- type = request_type(env)
20
- env.body.respond_to?(:each_key) and !env.body.empty? and (
21
- (type.empty? and has_multipart?(env.body)) or
22
- type == self.class.mime_type
23
- )
24
- end
28
+ # @param env [Faraday::Env]
29
+ def process_request?(env)
30
+ type = request_type(env)
31
+ env.body.respond_to?(:each_key) && !env.body.empty? && (
32
+ (type.empty? && has_multipart?(env.body)) ||
33
+ (type == self.class.mime_type)
34
+ )
35
+ end
25
36
 
26
- def has_multipart?(obj)
27
- # string is an enum in 1.8, returning list of itself
28
- if obj.respond_to?(:each) && !obj.is_a?(String)
29
- (obj.respond_to?(:values) ? obj.values : obj).each do |val|
30
- return true if (val.respond_to?(:content_type) || has_multipart?(val))
37
+ # Returns true if obj is an enumerable with values that are multipart.
38
+ #
39
+ # @param obj [Object]
40
+ # @return [Boolean]
41
+ def has_multipart?(obj) # rubocop:disable Naming/PredicateName
42
+ if obj.respond_to?(:each)
43
+ (obj.respond_to?(:values) ? obj.values : obj).each do |val|
44
+ return true if val.respond_to?(:content_type) || has_multipart?(val)
45
+ end
31
46
  end
47
+ false
32
48
  end
33
- false
34
- end
35
49
 
36
- def create_multipart(env, params)
37
- boundary = env.request.boundary
38
- parts = process_params(params) do |key, value|
39
- Faraday::Parts::Part.new(boundary, key, value)
50
+ # @param env [Faraday::Env]
51
+ # @param params [Hash]
52
+ def create_multipart(env, params)
53
+ boundary = env.request.boundary
54
+ parts = process_params(params) do |key, value|
55
+ part(boundary, key, value)
56
+ end
57
+ parts << Faraday::Parts::EpiloguePart.new(boundary)
58
+
59
+ body = Faraday::CompositeReadIO.new(parts)
60
+ env.request_headers[Faraday::Env::ContentLength] = body.length.to_s
61
+ body
40
62
  end
41
- parts << Faraday::Parts::EpiloguePart.new(boundary)
42
63
 
43
- body = Faraday::CompositeReadIO.new(parts)
44
- env.request_headers[Faraday::Env::ContentLength] = body.length.to_s
45
- return body
46
- end
64
+ def part(boundary, key, value)
65
+ if value.respond_to?(:to_part)
66
+ value.to_part(boundary, key)
67
+ else
68
+ Faraday::Parts::Part.new(boundary, key, value)
69
+ end
70
+ end
47
71
 
48
- def unique_boundary
49
- "#{DEFAULT_BOUNDARY_PREFIX}-#{SecureRandom.hex}"
50
- end
72
+ # @return [String]
73
+ def unique_boundary
74
+ "#{DEFAULT_BOUNDARY_PREFIX}-#{SecureRandom.hex}"
75
+ end
51
76
 
52
- def process_params(params, prefix = nil, pieces = nil, &block)
53
- params.inject(pieces || []) do |all, (key, value)|
54
- key = "#{prefix}[#{key}]" if prefix
77
+ # @param params [Hash]
78
+ # @param prefix [String]
79
+ # @param pieces [Array]
80
+ def process_params(params, prefix = nil, pieces = nil, &block)
81
+ params.inject(pieces || []) do |all, (key, value)|
82
+ key = "#{prefix}[#{key}]" if prefix
55
83
 
56
- case value
57
- when Array
58
- values = value.inject([]) { |a,v| a << [nil, v] }
59
- process_params(values, key, all, &block)
60
- when Hash
61
- process_params(value, key, all, &block)
62
- else
63
- all << block.call(key, value)
84
+ case value
85
+ when Array
86
+ values = value.inject([]) { |a, v| a << [nil, v] }
87
+ process_params(values, key, all, &block)
88
+ when Hash
89
+ process_params(value, key, all, &block)
90
+ else
91
+ # rubocop:disable Performance/RedundantBlockCall
92
+ all << block.call(key, value)
93
+ # rubocop:enable Performance/RedundantBlockCall
94
+ end
64
95
  end
65
96
  end
66
97
  end
@@ -1,213 +1,239 @@
1
- require 'date'
1
+ # frozen_string_literal: true
2
2
 
3
3
  module Faraday
4
- # Catches exceptions and retries each request a limited number of times.
5
- #
6
- # By default, it retries 2 times and handles only timeout exceptions. It can
7
- # be configured with an arbitrary number of retries, a list of exceptions to
8
- # handle, a retry interval, a percentage of randomness to add to the retry
9
- # interval, and a backoff factor.
10
- #
11
- # Examples
12
- #
13
- # Faraday.new do |conn|
14
- # conn.request :retry, max: 2, interval: 0.05,
15
- # interval_randomness: 0.5, backoff_factor: 2,
16
- # exceptions: [CustomException, 'Timeout::Error']
17
- # conn.adapter ...
18
- # end
19
- #
20
- # This example will result in a first interval that is random between 0.05 and 0.075 and a second
21
- # interval that is random between 0.1 and 0.15
22
- #
23
- class Request::Retry < Faraday::Middleware
24
- DEFAULT_EXCEPTIONS = [Errno::ETIMEDOUT, 'Timeout::Error',
25
- Faraday::TimeoutError, Faraday::RetriableResponse
26
- ].freeze
27
- IDEMPOTENT_METHODS = [:delete, :get, :head, :options, :put]
28
-
29
- class Options < Faraday::Options.new(:max, :interval, :max_interval, :interval_randomness,
30
- :backoff_factor, :exceptions, :methods, :retry_if, :retry_block,
31
- :retry_statuses)
32
-
33
- DEFAULT_CHECK = lambda { |env,exception| false }
34
-
35
- def self.from(value)
36
- if Integer === value
37
- new(value)
38
- else
39
- super(value)
4
+ class Request
5
+ # Catches exceptions and retries each request a limited number of times.
6
+ #
7
+ # By default, it retries 2 times and handles only timeout exceptions. It can
8
+ # be configured with an arbitrary number of retries, a list of exceptions to
9
+ # handle, a retry interval, a percentage of randomness to add to the retry
10
+ # interval, and a backoff factor.
11
+ #
12
+ # @example Configure Retry middleware using intervals
13
+ # Faraday.new do |conn|
14
+ # conn.request(:retry, max: 2,
15
+ # interval: 0.05,
16
+ # interval_randomness: 0.5,
17
+ # backoff_factor: 2,
18
+ # exceptions: [CustomException, 'Timeout::Error'])
19
+ #
20
+ # conn.adapter(:net_http) # NB: Last middleware must be the adapter
21
+ # end
22
+ #
23
+ # This example will result in a first interval that is random between 0.05
24
+ # and 0.075 and a second interval that is random between 0.1 and 0.15.
25
+ class Retry < Faraday::Middleware
26
+ DEFAULT_EXCEPTIONS = [
27
+ Errno::ETIMEDOUT, 'Timeout::Error',
28
+ Faraday::TimeoutError, Faraday::RetriableResponse
29
+ ].freeze
30
+ IDEMPOTENT_METHODS = %i[delete get head options put].freeze
31
+
32
+ # Options contains the configurable parameters for the Retry middleware.
33
+ class Options < Faraday::Options.new(:max, :interval, :max_interval,
34
+ :interval_randomness,
35
+ :backoff_factor, :exceptions,
36
+ :methods, :retry_if, :retry_block,
37
+ :retry_statuses)
38
+
39
+ DEFAULT_CHECK = ->(_env, _exception) { false }
40
+
41
+ def self.from(value)
42
+ if value.is_a?(Integer)
43
+ new(value)
44
+ else
45
+ super(value)
46
+ end
40
47
  end
41
- end
42
48
 
43
- def max
44
- (self[:max] ||= 2).to_i
45
- end
49
+ def max
50
+ (self[:max] ||= 2).to_i
51
+ end
46
52
 
47
- def interval
48
- (self[:interval] ||= 0).to_f
49
- end
53
+ def interval
54
+ (self[:interval] ||= 0).to_f
55
+ end
50
56
 
51
- def max_interval
52
- (self[:max_interval] ||= Float::MAX).to_f
53
- end
57
+ def max_interval
58
+ (self[:max_interval] ||= Float::MAX).to_f
59
+ end
54
60
 
55
- def interval_randomness
56
- (self[:interval_randomness] ||= 0).to_f
57
- end
61
+ def interval_randomness
62
+ (self[:interval_randomness] ||= 0).to_f
63
+ end
58
64
 
59
- def backoff_factor
60
- (self[:backoff_factor] ||= 1).to_f
61
- end
65
+ def backoff_factor
66
+ (self[:backoff_factor] ||= 1).to_f
67
+ end
62
68
 
63
- def exceptions
64
- Array(self[:exceptions] ||= DEFAULT_EXCEPTIONS)
65
- end
69
+ def exceptions
70
+ Array(self[:exceptions] ||= DEFAULT_EXCEPTIONS)
71
+ end
66
72
 
67
- def methods
68
- Array(self[:methods] ||= IDEMPOTENT_METHODS)
69
- end
73
+ def methods
74
+ Array(self[:methods] ||= IDEMPOTENT_METHODS)
75
+ end
70
76
 
71
- def retry_if
72
- self[:retry_if] ||= DEFAULT_CHECK
73
- end
77
+ def retry_if
78
+ self[:retry_if] ||= DEFAULT_CHECK
79
+ end
74
80
 
75
- def retry_block
76
- self[:retry_block] ||= Proc.new {}
77
- end
81
+ def retry_block
82
+ self[:retry_block] ||= proc {}
83
+ end
78
84
 
79
- def retry_statuses
80
- Array(self[:retry_statuses] ||= [])
85
+ def retry_statuses
86
+ Array(self[:retry_statuses] ||= [])
87
+ end
81
88
  end
82
- end
83
89
 
84
- # Public: Initialize middleware
85
- #
86
- # Options:
87
- # max - Maximum number of retries (default: 2)
88
- # interval - Pause in seconds between retries (default: 0)
89
- # interval_randomness - The maximum random interval amount expressed
90
- # as a float between 0 and 1 to use in addition to the
91
- # interval. (default: 0)
92
- # max_interval - An upper limit for the interval (default: Float::MAX)
93
- # backoff_factor - The amount to multiple each successive retry's
94
- # interval amount by in order to provide backoff
95
- # (default: 1)
96
- # exceptions - The list of exceptions to handle. Exceptions can be
97
- # given as Class, Module, or String. (default:
98
- # [Errno::ETIMEDOUT, 'Timeout::Error',
99
- # Faraday::TimeoutError, Faraday::RetriableResponse])
100
- # methods - A list of HTTP methods to retry without calling retry_if. Pass
101
- # an empty Array to call retry_if for all exceptions.
102
- # (defaults to the idempotent HTTP methods in IDEMPOTENT_METHODS)
103
- # retry_if - block that will receive the env object and the exception raised
104
- # and should decide if the code should retry still the action or
105
- # not independent of the retry count. This would be useful
106
- # if the exception produced is non-recoverable or if the
107
- # the HTTP method called is not idempotent.
108
- # (defaults to return false)
109
- # retry_block - block that is executed after every retry. Request environment, middleware options,
110
- # current number of retries and the exception is passed to the block as parameters.
111
- def initialize(app, options = nil)
112
- super(app)
113
- @options = Options.from(options)
114
- @errmatch = build_exception_matcher(@options.exceptions)
115
- end
90
+ # @param app [#call]
91
+ # @param options [Hash]
92
+ # @option options [Integer] :max (2) Maximum number of retries
93
+ # @option options [Integer] :interval (0) Pause in seconds between retries
94
+ # @option options [Integer] :interval_randomness (0) The maximum random
95
+ # interval amount expressed as a float between
96
+ # 0 and 1 to use in addition to the interval.
97
+ # @option options [Integer] :max_interval (Float::MAX) An upper limit
98
+ # for the interval
99
+ # @option options [Integer] :backoff_factor (1) The amount to multiply
100
+ # each successive retry's interval amount by in order to provide backoff
101
+ # @option options [Array] :exceptions ([ Errno::ETIMEDOUT,
102
+ # 'Timeout::Error', Faraday::TimeoutError, Faraday::RetriableResponse])
103
+ # The list of exceptions to handle. Exceptions can be given as
104
+ # Class, Module, or String.
105
+ # @option options [Array] :methods (the idempotent HTTP methods
106
+ # in IDEMPOTENT_METHODS) A list of HTTP methods to retry without
107
+ # calling retry_if. Pass an empty Array to call retry_if
108
+ # for all exceptions.
109
+ # @option options [Block] :retry_if (false) block that will receive
110
+ # the env object and the exception raised
111
+ # and should decide if the code should retry still the action or
112
+ # not independent of the retry count. This would be useful
113
+ # if the exception produced is non-recoverable or if the
114
+ # the HTTP method called is not idempotent.
115
+ # @option options [Block] :retry_block block that is executed after
116
+ # every retry. Request environment, middleware options, current number
117
+ # of retries and the exception is passed to the block as parameters.
118
+ # @option options [Array] :retry_statuses Array of Integer HTTP status
119
+ # codes or a single Integer value that determines whether to raise
120
+ # a Faraday::RetriableResponse exception based on the HTTP status code
121
+ # of an HTTP response.
122
+ def initialize(app, options = nil)
123
+ super(app)
124
+ @options = Options.from(options)
125
+ @errmatch = build_exception_matcher(@options.exceptions)
126
+ end
116
127
 
117
- def calculate_sleep_amount(retries, env)
118
- retry_after = calculate_retry_after(env)
119
- retry_interval = calculate_retry_interval(retries)
128
+ def calculate_sleep_amount(retries, env)
129
+ retry_after = calculate_retry_after(env)
130
+ retry_interval = calculate_retry_interval(retries)
120
131
 
121
- return if retry_after && retry_after > @options.max_interval
132
+ return if retry_after && retry_after > @options.max_interval
122
133
 
123
- retry_after && retry_after >= retry_interval ? retry_after : retry_interval
124
- end
134
+ if retry_after && retry_after >= retry_interval
135
+ retry_after
136
+ else
137
+ retry_interval
138
+ end
139
+ end
125
140
 
126
- def call(env)
127
- retries = @options.max
128
- request_body = env[:body]
129
- begin
130
- env[:body] = request_body # after failure env[:body] is set to the response body
131
- @app.call(env).tap do |resp|
132
- raise Faraday::RetriableResponse.new(nil, resp) if @options.retry_statuses.include?(resp.status)
133
- end
134
- rescue @errmatch => exception
135
- if retries > 0 && retry_request?(env, exception)
136
- retries -= 1
137
- rewind_files(request_body)
138
- @options.retry_block.call(env, @options, retries, exception)
139
- if (sleep_amount = calculate_sleep_amount(retries + 1, env))
140
- sleep sleep_amount
141
- retry
141
+ # @param env [Faraday::Env]
142
+ def call(env)
143
+ retries = @options.max
144
+ request_body = env[:body]
145
+ begin
146
+ # after failure env[:body] is set to the response body
147
+ env[:body] = request_body
148
+ @app.call(env).tap do |resp|
149
+ if @options.retry_statuses.include?(resp.status)
150
+ raise Faraday::RetriableResponse.new(nil, resp)
151
+ end
152
+ end
153
+ rescue @errmatch => e
154
+ if retries.positive? && retry_request?(env, e)
155
+ retries -= 1
156
+ rewind_files(request_body)
157
+ @options.retry_block.call(env, @options, retries, e)
158
+ if (sleep_amount = calculate_sleep_amount(retries + 1, env))
159
+ sleep sleep_amount
160
+ retry
161
+ end
142
162
  end
143
- end
144
163
 
145
- if exception.is_a?(Faraday::RetriableResponse)
146
- exception.response
147
- else
148
- raise
164
+ raise unless e.is_a?(Faraday::RetriableResponse)
165
+
166
+ e.response
149
167
  end
150
168
  end
151
- end
152
169
 
153
- # Private: construct an exception matcher object.
154
- #
155
- # An exception matcher for the rescue clause can usually be any object that
156
- # responds to `===`, but for Ruby 1.8 it has to be a Class or Module.
157
- def build_exception_matcher(exceptions)
158
- matcher = Module.new
159
- (class << matcher; self; end).class_eval do
160
- define_method(:===) do |error|
161
- exceptions.any? do |ex|
162
- if ex.is_a? Module
163
- error.is_a? ex
164
- else
165
- error.class.to_s == ex.to_s
170
+ # An exception matcher for the rescue clause can usually be any object
171
+ # that responds to `===`, but for Ruby 1.8 it has to be a Class or Module.
172
+ #
173
+ # @param exceptions [Array]
174
+ # @api private
175
+ # @return [Module] an exception matcher
176
+ def build_exception_matcher(exceptions)
177
+ matcher = Module.new
178
+ (
179
+ class << matcher
180
+ self
181
+ end).class_eval do
182
+ define_method(:===) do |error|
183
+ exceptions.any? do |ex|
184
+ if ex.is_a? Module
185
+ error.is_a? ex
186
+ else
187
+ error.class.to_s == ex.to_s
188
+ end
166
189
  end
167
190
  end
168
191
  end
192
+ matcher
169
193
  end
170
- matcher
171
- end
172
194
 
173
- private
195
+ private
174
196
 
175
- def retry_request?(env, exception)
176
- @options.methods.include?(env[:method]) || @options.retry_if.call(env, exception)
177
- end
197
+ def retry_request?(env, exception)
198
+ @options.methods.include?(env[:method]) ||
199
+ @options.retry_if.call(env, exception)
200
+ end
201
+
202
+ def rewind_files(body)
203
+ return unless body.is_a?(Hash)
178
204
 
179
- def rewind_files(body)
180
- return unless body.is_a?(Hash)
181
- body.each do |_, value|
182
- if value.is_a? UploadIO
183
- value.rewind
205
+ body.each do |_, value|
206
+ value.rewind if value.is_a?(UploadIO)
184
207
  end
185
208
  end
186
- end
187
209
 
188
- # MDN spec for Retry-After header: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After
189
- def calculate_retry_after(env)
190
- response_headers = env[:response_headers]
191
- return unless response_headers
210
+ # MDN spec for Retry-After header:
211
+ # https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After
212
+ def calculate_retry_after(env)
213
+ response_headers = env[:response_headers]
214
+ return unless response_headers
192
215
 
193
- retry_after_value = env[:response_headers]["Retry-After"]
216
+ retry_after_value = env[:response_headers]['Retry-After']
194
217
 
195
- # Try to parse date from the header value
196
- begin
197
- datetime = DateTime.rfc2822(retry_after_value)
198
- datetime.to_time - Time.now.utc
199
- rescue ArgumentError
200
- retry_after_value.to_f
218
+ # Try to parse date from the header value
219
+ begin
220
+ datetime = DateTime.rfc2822(retry_after_value)
221
+ datetime.to_time - Time.now.utc
222
+ rescue ArgumentError
223
+ retry_after_value.to_f
224
+ end
201
225
  end
202
- end
203
226
 
204
- def calculate_retry_interval(retries)
205
- retry_index = @options.max - retries
206
- current_interval = @options.interval * (@options.backoff_factor ** retry_index)
207
- current_interval = [current_interval, @options.max_interval].min
208
- random_interval = rand * @options.interval_randomness.to_f * @options.interval
227
+ def calculate_retry_interval(retries)
228
+ retry_index = @options.max - retries
229
+ current_interval = @options.interval *
230
+ (@options.backoff_factor**retry_index)
231
+ current_interval = [current_interval, @options.max_interval].min
232
+ random_interval = rand * @options.interval_randomness.to_f *
233
+ @options.interval
209
234
 
210
- current_interval + random_interval
235
+ current_interval + random_interval
236
+ end
211
237
  end
212
238
  end
213
239
  end