Hello community, here is the log from the commit of package rubygem-faraday for openSUSE:Factory checked in at 2018-07-18 22:49:39 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/rubygem-faraday (Old) and /work/SRC/openSUSE:Factory/.rubygem-faraday.new (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "rubygem-faraday" Wed Jul 18 22:49:39 2018 rev:21 rq:621001 version:0.15.2 Changes: -------- --- /work/SRC/openSUSE:Factory/rubygem-faraday/rubygem-faraday.changes 2018-02-10 18:00:00.652127729 +0100 +++ /work/SRC/openSUSE:Factory/.rubygem-faraday.new/rubygem-faraday.changes 2018-07-18 22:49:44.679795543 +0200 @@ -1,0 +2,18 @@ +Wed May 23 16:04:31 UTC 2018 - [email protected] + +- updated to version 0.15.2 + no changelog found + +------------------------------------------------------------------- +Wed May 16 07:59:41 UTC 2018 - [email protected] + +- updated to version 0.15.1 + no changelog found + +------------------------------------------------------------------- +Fri Apr 20 08:05:59 UTC 2018 - [email protected] + +- updated to version 0.15.0 + no changelog found + +------------------------------------------------------------------- Old: ---- faraday-0.14.0.gem New: ---- faraday-0.15.2.gem ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ rubygem-faraday.spec ++++++ --- /var/tmp/diff_new_pack.9oAgiT/_old 2018-07-18 22:49:45.083794203 +0200 +++ /var/tmp/diff_new_pack.9oAgiT/_new 2018-07-18 22:49:45.087794190 +0200 @@ -24,7 +24,7 @@ # Name: rubygem-faraday -Version: 0.14.0 +Version: 0.15.2 Release: 0 %define mod_name faraday %define mod_full_name %{mod_name}-%{version} ++++++ faraday-0.14.0.gem -> faraday-0.15.2.gem ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/README.md new/README.md --- old/README.md 2018-01-19 20:19:34.000000000 +0100 +++ new/README.md 2018-05-23 17:42:34.000000000 +0200 @@ -54,7 +54,7 @@ ```ruby conn = Faraday.new(:url => 'http://sushi.com') do |faraday| faraday.request :url_encoded # form-encode POST params - faraday.response :logger # log requests to STDOUT + faraday.response :logger # log requests to $stdout faraday.adapter Faraday.default_adapter # make requests with Net::HTTP end @@ -69,7 +69,7 @@ end ``` -Once you have the connection object, use it to make HTTP requests. You can pass paramters to it in a few different ways: +Once you have the connection object, use it to make HTTP requests. You can pass parameters to it in a few different ways: ```ruby ## GET ## @@ -79,7 +79,7 @@ conn.get '/nigiri', { :name => 'Maguro' } # GET http://sushi.com/nigiri?name=Maguro -conn.get do |req| # GET http://sushi.com/search?page=2&limit=100 +conn.get do |req| # GET http://sushi.com/search?page=2&limit=100 req.url '/search', :page => 2 req.params['limit'] = 100 end @@ -118,7 +118,7 @@ req.options.context = { foo: 'foo', bar: 'bar' - } + } end ``` Binary files old/checksums.yaml.gz and new/checksums.yaml.gz differ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/faraday/adapter/excon.rb new/lib/faraday/adapter/excon.rb --- old/lib/faraday/adapter/excon.rb 2018-01-19 20:19:34.000000000 +0100 +++ new/lib/faraday/adapter/excon.rb 2018-05-23 17:42:34.000000000 +0200 @@ -15,6 +15,9 @@ 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] + opts[:ssl_version] = ssl[:version] if ssl[:version] + opts[:ssl_min_version] = ssl[:min_version] if ssl[:min_version] + opts[:ssl_max_version] = ssl[:max_version] if ssl[:max_version] # https://github.com/geemus/excon/issues/106 # https://github.com/jruby/jruby-ossl/issues/19 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/faraday/adapter/net_http.rb new/lib/faraday/adapter/net_http.rb --- old/lib/faraday/adapter/net_http.rb 2018-01-19 20:19:34.000000000 +0100 +++ new/lib/faraday/adapter/net_http.rb 2018-05-23 17:42:34.000000000 +0200 @@ -28,6 +28,11 @@ NET_HTTP_EXCEPTIONS << OpenSSL::SSL::SSLError if defined?(OpenSSL) NET_HTTP_EXCEPTIONS << Net::OpenTimeout if defined?(Net::OpenTimeout) + def initialize(app = nil, opts = {}, &block) + @cert_store = nil + super(app, opts, &block) + end + def call(env) super with_net_http_connection(env) do |http| @@ -56,6 +61,8 @@ raise Faraday::Error::TimeoutError, err end + private + def create_request(env) request = Net::HTTPGenericRequest.new \ env[:method].to_s.upcase, # request method @@ -104,21 +111,26 @@ http.ca_path = ssl[:ca_path] if ssl[:ca_path] http.verify_depth = ssl[:verify_depth] if ssl[:verify_depth] http.ssl_version = ssl[:version] if ssl[:version] + http.min_version = ssl[:min_version] if ssl[:min_version] + http.max_version = ssl[:max_version] if ssl[:max_version] end def configure_request(http, req) http.read_timeout = http.open_timeout = req[:timeout] if req[:timeout] http.open_timeout = req[:open_timeout] if req[:open_timeout] + # Only set if Net::Http supports it, since Ruby 2.5. + http.max_retries = 0 if http.respond_to?(:max_retries=) @config_block.call(http) if @config_block end def ssl_cert_store(ssl) return ssl[:cert_store] if ssl[:cert_store] + return @cert_store if @cert_store # Use the default cert store by default, i.e. system ca certs - cert_store = OpenSSL::X509::Store.new - cert_store.set_default_paths - cert_store + @cert_store = OpenSSL::X509::Store.new + @cert_store.set_default_paths + @cert_store end def ssl_verify_mode(ssl) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/faraday/adapter/net_http_persistent.rb new/lib/faraday/adapter/net_http_persistent.rb --- old/lib/faraday/adapter/net_http_persistent.rb 2018-01-19 20:19:34.000000000 +0100 +++ new/lib/faraday/adapter/net_http_persistent.rb 2018-05-23 17:42:34.000000000 +0200 @@ -1,13 +1,24 @@ -# Rely on autoloading instead of explicit require; helps avoid the "already -# initialized constant" warning on Ruby 1.8.7 when NetHttp is refereced below. -# require 'faraday/adapter/net_http' - module Faraday class Adapter class NetHttpPersistent < NetHttp dependency 'net/http/persistent' + private + def net_http_connection(env) + @cached_connection ||= + if Net::HTTP::Persistent.instance_method(:initialize).parameters.first == [:key, :name] + Net::HTTP::Persistent.new(name: 'Faraday') + else + Net::HTTP::Persistent.new('Faraday') + end + + proxy_uri = proxy_uri(env) + @cached_connection.proxy = proxy_uri if @cached_connection.proxy_uri != proxy_uri + @cached_connection + end + + def proxy_uri(env) proxy_uri = nil if (proxy = env[:request][:proxy]) proxy_uri = ::URI::HTTP === proxy[:uri] ? proxy[:uri].dup : ::URI.parse(proxy[:uri].to_s) @@ -18,12 +29,7 @@ define_method(:password) { proxy[:password] } end if proxy[:user] end - - if Net::HTTP::Persistent.instance_method(:initialize).parameters.first == [:key, :name] - Net::HTTP::Persistent.new(name: 'Faraday', proxy: proxy_uri) - else - Net::HTTP::Persistent.new('Faraday', proxy_uri) - end + proxy_uri end def perform_request(http, env) @@ -41,13 +47,19 @@ end def configure_ssl(http, ssl) - http.verify_mode = ssl_verify_mode(ssl) - http.cert_store = ssl_cert_store(ssl) + http_set(http, :verify_mode, ssl_verify_mode(ssl)) + http_set(http, :cert_store, ssl_cert_store(ssl)) - http.certificate = ssl[:client_cert] if ssl[:client_cert] - http.private_key = ssl[:client_key] if ssl[:client_key] - http.ca_file = ssl[:ca_file] if ssl[:ca_file] - http.ssl_version = ssl[:version] if ssl[:version] + http_set(http, :certificate, ssl[:client_cert]) if ssl[:client_cert] + http_set(http, :private_key, ssl[:client_key]) if ssl[:client_key] + http_set(http, :ca_file, ssl[:ca_file]) if ssl[:ca_file] + http_set(http, :ssl_version, ssl[:version]) if ssl[:version] + end + + def http_set(http, attr, value) + if http.send(attr) != value + http.send("#{attr}=", value) + end end end end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/faraday/adapter/patron.rb new/lib/faraday/adapter/patron.rb --- old/lib/faraday/adapter/patron.rb 2018-01-19 20:19:34.000000000 +0100 +++ new/lib/faraday/adapter/patron.rb 2018-05-23 17:42:34.000000000 +0200 @@ -8,7 +8,8 @@ # TODO: support streaming requests env[:body] = env[:body].read if env[:body].respond_to? :read - session = @session ||= create_session + session = ::Patron::Session.new + @config_block.call(session) if @config_block configure_ssl(session, env[:ssl]) if env[:url].scheme == 'https' and env[:ssl] if req = env[:request] @@ -65,12 +66,6 @@ end end - def create_session - session = ::Patron::Session.new - @config_block.call(session) if @config_block - session - end - def configure_ssl(session, ssl) if ssl.fetch(:verify, true) session.cacert = ssl[:ca_file] diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/faraday/adapter.rb new/lib/faraday/adapter.rb --- old/lib/faraday/adapter.rb 2018-01-19 20:19:34.000000000 +0100 +++ new/lib/faraday/adapter.rb 2018-05-23 17:42:34.000000000 +0200 @@ -40,6 +40,8 @@ env.clear_body if env.needs_body? end + private + def save_response(env, status, body, headers = nil, reason_phrase = nil) env.status = status env.body = body diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/faraday/error.rb new/lib/faraday/error.rb --- old/lib/faraday/error.rb 2018-01-19 20:19:34.000000000 +0100 +++ new/lib/faraday/error.rb 2018-05-23 17:42:34.000000000 +0200 @@ -1,6 +1,5 @@ module Faraday class Error < StandardError; end - class MissingDependency < Error; end class ClientError < Error attr_reader :response, :wrapped_exception @@ -56,8 +55,12 @@ class SSLError < ClientError end - [:MissingDependency, :ClientError, :ConnectionFailed, :ResourceNotFound, - :ParsingError, :TimeoutError, :SSLError].each do |const| + class RetriableResponse < ClientError; end + + [:ClientError, :ConnectionFailed, :ResourceNotFound, + :ParsingError, :TimeoutError, :SSLError, :RetriableResponse].each do |const| Error.const_set(const, Faraday.const_get(const)) end + + end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/faraday/options.rb new/lib/faraday/options.rb --- old/lib/faraday/options.rb 2018-01-19 20:19:34.000000000 +0100 +++ new/lib/faraday/options.rb 2018-05-23 17:42:34.000000000 +0200 @@ -214,7 +214,8 @@ end class SSLOptions < Options.new(:verify, :ca_file, :ca_path, :verify_mode, - :cert_store, :client_cert, :client_key, :certificate, :private_key, :verify_depth, :version) + :cert_store, :client_cert, :client_key, :certificate, :private_key, :verify_depth, + :version, :min_version, :max_version) def verify? verify != false diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/faraday/parameters.rb new/lib/faraday/parameters.rb --- old/lib/faraday/parameters.rb 2018-01-19 20:19:34.000000000 +0100 +++ new/lib/faraday/parameters.rb 2018-05-23 17:42:34.000000000 +0200 @@ -40,9 +40,10 @@ end return buffer.chop elsif value.is_a?(Array) + new_parent = "#{parent}%5B%5D" + return new_parent if value.empty? buffer = "" value.each_with_index do |val, i| - new_parent = "#{parent}%5B%5D" buffer << "#{to_query.call(new_parent, val)}&" end return buffer.chop diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/faraday/request/retry.rb new/lib/faraday/request/retry.rb --- old/lib/faraday/request/retry.rb 2018-01-19 20:19:34.000000000 +0100 +++ new/lib/faraday/request/retry.rb 2018-05-23 17:42:34.000000000 +0200 @@ -23,7 +23,9 @@ IDEMPOTENT_METHODS = [:delete, :get, :head, :options, :put] class Options < Faraday::Options.new(:max, :interval, :max_interval, :interval_randomness, - :backoff_factor, :exceptions, :methods, :retry_if) + :backoff_factor, :exceptions, :methods, :retry_if, :retry_block, + :retry_statuses) + DEFAULT_CHECK = lambda { |env,exception| false } def self.from(value) @@ -56,7 +58,8 @@ def exceptions Array(self[:exceptions] ||= [Errno::ETIMEDOUT, 'Timeout::Error', - Error::TimeoutError]) + Error::TimeoutError, + Faraday::Error::RetriableResponse]) end def methods @@ -67,6 +70,13 @@ self[:retry_if] ||= DEFAULT_CHECK end + def retry_block + self[:retry_block] ||= Proc.new {} + end + + def retry_statuses + Array(self[:retry_statuses] ||= []) + end end # Public: Initialize middleware @@ -83,8 +93,8 @@ # (default: 1) # exceptions - The list of exceptions to handle. Exceptions can be # given as Class, Module, or String. (default: - # [Errno::ETIMEDOUT, Timeout::Error, - # Error::TimeoutError]) + # [Errno::ETIMEDOUT, 'Timeout::Error', + # Error::TimeoutError, Faraday::Error::RetriableResponse]) # methods - A list of HTTP methods to retry without calling retry_if. Pass # an empty Array to call retry_if for all exceptions. # (defaults to the idempotent HTTP methods in IDEMPOTENT_METHODS) @@ -94,18 +104,21 @@ # if the exception produced is non-recoverable or if the # the HTTP method called is not idempotent. # (defaults to return false) + # retry_block - block that is executed after every retry. Request environment, middleware options, + # current number of retries and the exception is passed to the block as parameters. def initialize(app, options = nil) super(app) @options = Options.from(options) @errmatch = build_exception_matcher(@options.exceptions) end - def sleep_amount(retries) - retry_index = @options.max - retries - current_interval = @options.interval * (@options.backoff_factor ** retry_index) - current_interval = [current_interval, @options.max_interval].min - random_interval = rand * @options.interval_randomness.to_f * @options.interval - current_interval + random_interval + def calculate_sleep_amount(retries, env) + retry_after = calculate_retry_after(env) + retry_interval = calculate_retry_interval(retries) + + return if retry_after && retry_after > @options.max_interval + + retry_after && retry_after >= retry_interval ? retry_after : retry_interval end def call(env) @@ -113,15 +126,25 @@ request_body = env[:body] begin env[:body] = request_body # after failure env[:body] is set to the response body - @app.call(env) + @app.call(env).tap do |resp| + raise Faraday::Error::RetriableResponse.new(nil, resp) if @options.retry_statuses.include?(resp.status) + end rescue @errmatch => exception if retries > 0 && retry_request?(env, exception) retries -= 1 rewind_files(request_body) - sleep sleep_amount(retries + 1) - retry + @options.retry_block.call(env, @options, retries, exception) + if (sleep_amount = calculate_sleep_amount(retries + 1, env)) + sleep sleep_amount + retry + end + end + + if exception.is_a?(Faraday::Error::RetriableResponse) + exception.response + else + raise end - raise end end @@ -160,5 +183,29 @@ end end + # MDN spec for Retry-After header: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After + def calculate_retry_after(env) + response_headers = env[:response_headers] + return unless response_headers + + retry_after_value = env[:response_headers]["Retry-After"] + + # Try to parse date from the header value + begin + datetime = DateTime.rfc2822(retry_after_value) + datetime.to_time - Time.now.utc + rescue ArgumentError + retry_after_value.to_f + end + end + + def calculate_retry_interval(retries) + retry_index = @options.max - retries + current_interval = @options.interval * (@options.backoff_factor ** retry_index) + current_interval = [current_interval, @options.max_interval].min + random_interval = rand * @options.interval_randomness.to_f * @options.interval + + current_interval + random_interval + end end end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/faraday/response/logger.rb new/lib/faraday/response/logger.rb --- old/lib/faraday/response/logger.rb 2018-01-19 20:19:34.000000000 +0100 +++ new/lib/faraday/response/logger.rb 2018-05-23 17:42:34.000000000 +0200 @@ -10,7 +10,7 @@ super(app) @logger = logger || begin require 'logger' - ::Logger.new(STDOUT) + ::Logger.new($stdout) end @filter = [] @options = DEFAULT_OPTIONS.merge(options) @@ -20,14 +20,14 @@ def_delegators :@logger, :debug, :info, :warn, :error, :fatal def call(env) - info "#{env.method} #{apply_filters(env.url.to_s)}" + info('request') { "#{env.method.upcase} #{apply_filters(env.url.to_s)}" } debug('request') { apply_filters( dump_headers env.request_headers ) } if log_headers?(:request) debug('request') { apply_filters( dump_body(env[:body]) ) } if env[:body] && log_body?(:request) super end def on_complete(env) - info('Status') { env.status.to_s } + info('response') { "Status #{env.status.to_s}" } debug('response') { apply_filters( dump_headers env.response_headers ) } if log_headers?(:response) debug('response') { apply_filters( dump_body env[:body] ) } if env[:body] && log_body?(:response) end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/lib/faraday.rb new/lib/faraday.rb --- old/lib/faraday.rb 2018-01-19 20:19:34.000000000 +0100 +++ new/lib/faraday.rb 2018-05-23 17:42:34.000000000 +0200 @@ -14,7 +14,7 @@ # conn.get '/' # module Faraday - VERSION = "0.14.0" + VERSION = "0.15.2" class << self # Public: Gets or sets the root path that Faraday is being loaded from. diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/metadata new/metadata --- old/metadata 2018-01-19 20:19:34.000000000 +0100 +++ new/metadata 2018-05-23 17:42:34.000000000 +0200 @@ -1,14 +1,14 @@ --- !ruby/object:Gem::Specification name: faraday version: !ruby/object:Gem::Version - version: 0.14.0 + version: 0.15.2 platform: ruby authors: - Rick Olson autorequire: bindir: bin cert_chain: [] -date: 2018-01-19 00:00:00.000000000 Z +date: 2018-05-23 00:00:00.000000000 Z dependencies: - !ruby/object:Gem::Dependency name: multipart-post @@ -92,7 +92,7 @@ version: '0' requirements: [] rubyforge_project: -rubygems_version: 2.7.4 +rubygems_version: 2.7.7 signing_key: specification_version: 4 summary: HTTP/REST API client library.
