retriable 2.0.0.beta2 → 2.0.0.beta3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b252298dcbaede9a87149f78cec0c067742b1167
-  data.tar.gz: b58875b898c832a5bd8ae3fd20d2eb62f80c7f84
+  metadata.gz: e3b8d447babc7584997f6e2756375d2d48d3b4dc
+  data.tar.gz: 3c14a6becbd1708ee8dc4f2cb83c10fb74489141
 SHA512:
-  metadata.gz: e216f86b87a3526982647c8a2c6d8733eb7c9e3f4e7a262f3f38ead6d36bd4bd3c494ef22409cdf06e195de23360eb6d5f12cfa1c4c0de2492c03c49f17fe005
-  data.tar.gz: 43505f1550318db78adcb85dd1c023280ca9b7be802ec3a331e56ae094648a9fcfd2b5879bfc90ddf840e13a3ce29e96c28e7a33cb5e12abaddf89f9a32f82c7
+  metadata.gz: f04b74b90611da941a4bf425ef06383aa9140043d8b32bebec64fab29d2445db0819be5c1a40e135dee0ff0289c5c56a7061793fd46b1a307bcfc6ade287e5d7
+  data.tar.gz: 18282a856bb96a2dd2b32a564ab2093c3620c09a38f95fdc58054084e4410626ecf18daf2a8f275a81d7893d02b0cac06e0a3cba8f818d90c3388866ff62dbc6

data/CHANGELOG.md

@@ -1,12 +1,17 @@
+## 2.0.0.beta3
+* Accept `intervals` array argument to provide your own custom intervals.
+* Refactor the exponential backoff code into it's own class.
+* Add specs for exponential backoff, randomization, and config.
+
 ## 2.0.0.beta2
-* Raise not return on max elapsed time, also check for elapsed time after next interval is calculated and it goes over the max elapsed time
-* Add specs for max_elapsed_time and max_interval
+* Raise not return on max elapsed time, also check for elapsed time after next interval is calculated and it goes over the max elapsed time.
+* Add specs for `max_elapsed_time` and `max_interval`.
 
 ## 2.0.0.beta1
 * Require ruby 2.0+.
 * Default to random exponential backoff, removes the `interval` option. Exponential backoff is configurable via arguments.
 * Allow configurable defaults via `#configure`.
-* Change `Retriable.retriable` to `Retriable.retry`
+* Change `Retriable.retriable` to `Retriable.retry`.
 * Support `max_elapsed_time` termination.
 
 ## 1.4.1

data/README.md

@@ -10,6 +10,8 @@ Ruby 2.0+
 
 If you need 1.9.x support, use the [1.x branch](https://github.com/kamui/retriable/tree/1.x).
 
+WARNING: 2.x isn't API compatible with 1.x.
+
 ## Installation
 
 via command line:
@@ -80,6 +82,8 @@ randomized_interval = retry_interval * (random value in range [1 - randomization
 
 `max_elapsed_time`  (default: 900 (15 min)) - The maximum amount of total time that code is allowed to keep being retried
 
+`intervals`  (default: nil) - Skip generated intervals and provide your own array of intervals in seconds. Setting this option will ignore `max_tries`, `base_interval`, `max_interval`, `rand_factor`, and `multiplier` values.
+
 `timeout` (default: 0) - Number of seconds to allow the code block to run before raising a Timeout::Error
 
 `on` (default: [StandardError]) - An array of exceptions to rescue for each attempt, also accepts a single Exception type
@@ -131,6 +135,16 @@ Retriable.retry base_interval: (200/1000.0), timeout: (500/1000.0) do
 end
 ```
 
+### Custom Interval Array
+
+You can also bypass the built-in interval generation and provide your own array of intervals. Supplying your own intervals overrides the `max_tries`, `base_interval`, `max_interval`, `rand_factor`, and `multiplier` parameters.
+
+```ruby
+Retriable.retry intervals: [0.5, 1.0, 2.0, 2.5] do
+  # code here...
+end
+```
+
 ### Turn off Exponential Backoff
 
 Exponential backoff is enabled by default, if you want to simply execute code every second, you can do this:

data/Rakefile

@@ -1,16 +1,16 @@
 # encoding: utf-8
 
-require 'bundler'
+require "bundler"
 Bundler::GemHelper.install_tasks
 
-require 'rake/testtask'
+require "rake/testtask"
 task default: :test
 
 desc "Run tests"
 task :test do
   Rake::TestTask.new do |t|
-    t.libs << 'lib' << 'spec'
-    t.pattern = 'spec/**/*_spec.rb'
+    t.libs << "lib" << "spec"
+    t.pattern = "spec/**/*_spec.rb"
     t.verbose = true
   end
 end

data/lib/retriable.rb

@@ -1,17 +1,21 @@
-require 'timeout'
-require 'retriable/config'
-require 'retriable/version'
+require "timeout"
+require "retriable/config"
+require "retriable/exponential_backoff"
+require "retriable/version"
 
 module Retriable
   extend self
 
-  attr_accessor :config
+  attr_reader :config
 
   def self.configure
-    self.config ||= Config.new
     yield(config)
   end
 
+  def config
+    @config ||= Config.new
+  end
+
   def retry(
     max_tries:         config.max_tries,
     base_interval:     config.base_interval,
@@ -19,52 +23,39 @@ module Retriable
     rand_factor:       config.rand_factor,
     multiplier:        config.multiplier,
     max_elapsed_time:  config.max_elapsed_time,
+    intervals:         config.intervals,
     timeout:           config.timeout,
     on:                config.on,
     on_retry:          config.on_retry,
-    &block)
+    &block
+    )
 
     raise LocalJumpError unless block_given?
 
-    attempt = 0
-    interval = base_interval
     start_time = Time.now
-    elapsed_time = lambda { Time.now - start_time }
-
-    begin
-      attempt += 1
-      if timeout
-        Timeout::timeout(timeout) { return block.call(attempt) }
-      else
-        return block.call(attempt)
-      end
-    rescue *[*on] => exception
-      raise if attempt >= max_tries
-
-      interval = randomized_interval(rand_factor, interval)
-
-      on_retry.call(exception, attempt, Time.now - start_time, interval) if on_retry
-
-      raise if elapsed_time.call > max_elapsed_time || (elapsed_time.call + interval) > max_elapsed_time
-
-      sleep interval if interval > 0 && config.sleep_disabled != true
-
-      interval = if interval >= (max_interval / multiplier)
-        max_interval
-      else
-        interval * multiplier
+    elapsed_time = -> { Time.now - start_time }
+
+    max_tries = intervals.size if intervals
+    intervals ||= ExponentialBackoff.new(
+      max_tries: max_tries,
+      base_interval: base_interval,
+      multiplier: multiplier,
+      max_interval: max_interval,
+      rand_factor: rand_factor
+    ).intervals
+
+    intervals.each.with_index(1) do |interval, attempt|
+      begin
+        if timeout
+          Timeout::timeout(timeout) { return block.call(attempt) }
+        else
+          return block.call(attempt)
+        end
+      rescue *[*on] => exception
+        on_retry.call(exception, attempt, Time.now - start_time, interval) if on_retry
+        raise if attempt >= max_tries || (elapsed_time.call + interval) > max_elapsed_time
+        sleep interval if interval > 0 && config.sleep_disabled != true
       end
-
-      retry
     end
   end
-
-  private
-  def randomized_interval(rand_factor, interval)
-    return interval if rand_factor == 0
-    delta = rand_factor * interval * 1.0
-    min_interval = interval - delta
-    max_interval = interval + delta
-    rand(min_interval..max_interval)
-  end
 end

data/lib/retriable/config.rb

@@ -7,6 +7,7 @@ module Retriable
     attr_accessor :rand_factor
     attr_accessor :multiplier
     attr_accessor :max_elapsed_time
+    attr_accessor :intervals
     attr_accessor :timeout
     attr_accessor :on
     attr_accessor :on_retry
@@ -19,6 +20,7 @@ module Retriable
       @rand_factor       = 0.5
       @multiplier        = 1.5
       @max_elapsed_time  = 900 # 15 minn
+      @intervals         = nil
       @timeout           = nil
       @on                = [StandardError]
       @on_retry          = nil

data/lib/retriable/core_ext/kernel.rb

@@ -1,4 +1,4 @@
-require 'retriable'
+require "retriable"
 
 module Kernel
   def retriable(opts={}, &block)

data/lib/retriable/exponential_backoff.rb

@@ -0,0 +1,39 @@
+module Retriable
+  class ExponentialBackoff
+    attr_accessor :max_tries, :base_interval, :multiplier, :max_interval, :rand_factor
+
+    def initialize(
+      max_tries: Retriable.config.max_tries,
+      base_interval: Retriable.config.base_interval,
+      multiplier: Retriable.config.multiplier,
+      max_interval: Retriable.config.max_interval,
+      rand_factor: Retriable.config.rand_factor
+      )
+
+      @max_tries = max_tries
+      @base_interval = base_interval
+      @multiplier = multiplier
+      @max_interval = max_interval
+      @rand_factor = rand_factor
+    end
+
+    def intervals
+      intervals = Array.new(max_tries) do |iteration|
+        [base_interval * multiplier ** iteration, max_interval].min
+      end
+
+      return intervals if rand_factor == 0
+
+      intervals.map { |i| randomize(i) }
+    end
+
+    protected
+    def randomize(interval)
+      return interval if rand_factor == 0
+      delta = rand_factor * interval * 1.0
+      min_interval = interval - delta
+      max_interval = interval + delta
+      rand(min_interval..max_interval)
+    end
+  end
+end

data/lib/retriable/version.rb

@@ -1,3 +1,3 @@
 module Retriable
-  VERSION = '2.0.0.beta2'
+  VERSION = "2.0.0.beta3"
 end

data/retriable.gemspec

@@ -1,5 +1,5 @@
 # coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
+lib = File.expand_path("../lib", __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require "retriable/version"
 
@@ -22,10 +22,10 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_development_dependency 'rake'
-  s.add_development_dependency 'minitest', '>= 5.0'
-  s.add_development_dependency 'minitest-focus'
-  s.add_development_dependency 'pry'
-  s.add_development_dependency 'guard'
-  s.add_development_dependency 'guard-minitest'
+  s.add_development_dependency "rake"
+  s.add_development_dependency "minitest", ">= 5.0"
+  s.add_development_dependency "minitest-focus"
+  s.add_development_dependency "pry"
+  s.add_development_dependency "guard"
+  s.add_development_dependency "guard-minitest"
 end

data/spec/config_spec.rb

@@ -0,0 +1,47 @@
+require_relative "spec_helper"
+
+describe Retriable::Config do
+  subject do
+    Retriable::Config
+  end
+
+  it "sleep defaults to enabled" do
+    subject.new.sleep_disabled.must_equal false
+  end
+
+  it "max tries defaults to 3" do
+    subject.new.max_tries.must_equal 3
+  end
+
+  it "max interval defaults to 60" do
+    subject.new.max_interval.must_equal 60
+  end
+
+  it "randomization factor defaults to 0.5" do
+    subject.new.base_interval.must_equal 0.5
+  end
+
+  it "multiplier defaults to 1.5" do
+    subject.new.multiplier.must_equal 1.5
+  end
+
+  it "max elapsed time defaults to 900" do
+    subject.new.max_elapsed_time.must_equal 900
+  end
+
+  it "intervals defaults to nil" do
+    subject.new.intervals.must_be_nil
+  end
+
+  it "timeout defaults to nil" do
+    subject.new.timeout.must_be_nil
+  end
+
+  it "on defaults to [StandardError]" do
+    subject.new.on.must_equal [StandardError]
+  end
+
+  it "on retry handler defaults to nil" do
+    subject.new.on_retry.must_be_nil
+  end
+end

data/spec/exponential_backoff_spec.rb

@@ -0,0 +1,49 @@
+require_relative "spec_helper"
+
+describe Retriable::ExponentialBackoff do
+  subject do
+    Retriable::ExponentialBackoff
+  end
+
+  it "max tries defaults to 3" do
+    subject.new.max_tries.must_equal 3
+  end
+
+  it "max interval defaults to 60" do
+    subject.new.max_interval.must_equal 60
+  end
+
+  it "randomization factor defaults to 0.5" do
+    subject.new.base_interval.must_equal 0.5
+  end
+
+  it "multiplier defaults to 1.5" do
+    subject.new.multiplier.must_equal 1.5
+  end
+
+  it "generates randomized intervals" do
+    i = subject.new(max_tries: 9).intervals
+    i[0].between?(0.25, 0.75).must_equal true
+    i[1].between?(0.375, 1.125).must_equal true
+    i[2].between?(0.562, 1.687).must_equal true
+    i[3].between?(0.8435, 2.53).must_equal true
+    i[4].between?(1.265, 3.795).must_equal true
+    i[5].between?(1.897, 5.692).must_equal true
+    i[6].between?(2.846, 8.538).must_equal true
+    i[7].between?(4.269, 12.807).must_equal true
+    i[8].between?(6.403, 19.210).must_equal true
+  end
+
+  it "generates 5 non-randomized intervals" do
+    subject.new(
+      max_tries: 5,
+      rand_factor: 0.0
+    ).intervals.must_equal([
+      0.5,
+      0.75,
+      1.125,
+      1.6875,
+      2.53125
+    ])
+  end
+end

data/spec/retriable_spec.rb

@@ -1,4 +1,4 @@
-require_relative 'spec_helper'
+require_relative "spec_helper"
 
 class TestError < Exception; end
 
@@ -7,20 +7,29 @@ describe Retriable do
     Retriable
   end
 
-  describe 'with sleep disabled' do
+  describe "with sleep disabled" do
     before do
       Retriable.configure do |c|
         c.sleep_disabled = true
       end
     end
 
-    it 'raises a LocalJumpError if retry is not given a block' do
-      lambda do
+    it "stops at first attempt if the block does not raise an exception" do
+      attempts = 0
+      subject.retry do
+        attempts += 1
+      end
+
+      attempts.must_equal 1
+    end
+
+    it "raises a LocalJumpError if retry is not given a block" do
+      -> do
         subject.retry on: EOFError
       end.must_raise LocalJumpError
     end
 
-    describe 'retry block of code raising EOFError with no arguments' do
+    describe "retry block of code raising EOFError with no arguments" do
       before do
         @attempts = 0
 
@@ -30,20 +39,20 @@ describe Retriable do
         end
       end
 
-      it 'uses exponential backoff' do
+      it "uses exponential backoff" do
         @attempts.must_equal 3
       end
     end
 
-    it 'retry on custom exception and re-raises the exception' do
-      lambda do
+    it "retry on custom exception and re-raises the exception" do
+      -> do
         subject.retry on: TestError do
           raise TestError.new
         end
       end.must_raise TestError
     end
 
-    it 'retry with 10 max tries' do
+    it "retry with 10 max tries" do
       attempts = 0
 
       subject.retry(
@@ -56,21 +65,53 @@ describe Retriable do
       attempts.must_equal 10
     end
 
-    it 'retry will timeout after 1 second' do
-      lambda do
+    it "retry will timeout after 1 second" do
+      -> do
         subject.retry timeout: 1 do
           sleep 2
         end
       end.must_raise Timeout::Error
     end
 
-    describe 'retries with an on_retry handler, 6 max retries, and a 0.0 rand_factor' do
+    it "applies a randomized exponential backoff to each attempt" do
+      @attempts = 0
+      @time_table = {}
+
+      handler = ->(exception, attempt, elapsed_time, next_interval) do
+        exception.class.must_equal ArgumentError
+        @time_table[attempt] = next_interval
+      end
+
+      -> do
+        Retriable.retry(
+          on: [EOFError, ArgumentError],
+          on_retry: handler,
+          rand_factor: 0.0,
+          max_tries: 9
+        ) do
+          @attempts += 1
+          raise ArgumentError.new
+        end
+      end.must_raise ArgumentError
+
+      @time_table[1].between?(0.25, 0.75).must_equal true
+      @time_table[2].between?(0.375, 1.125).must_equal true
+      @time_table[3].between?(0.562, 1.687).must_equal true
+      @time_table[4].between?(0.8435, 2.53).must_equal true
+      @time_table[5].between?(1.265, 3.795).must_equal true
+      @time_table[6].between?(1.897, 5.692).must_equal true
+      @time_table[7].between?(2.846, 8.538).must_equal true
+      @time_table[8].between?(4.269, 12.807).must_equal true
+      @time_table[9].between?(6.403, 19.210).must_equal true
+    end
+
+    describe "retries with an on_retry handler, 6 max retries, and a 0.0 rand_factor" do
       before do
         max_tries = 6
         @attempts = 0
         @time_table = {}
 
-        handler = Proc.new do |exception, attempt, elapsed_time, next_interval|
+        handler = ->(exception, attempt, elapsed_time, next_interval) do
           exception.class.must_equal ArgumentError
           @time_table[attempt] = next_interval
         end
@@ -86,11 +127,11 @@ describe Retriable do
         end
       end
 
-      it 'makes 6 attempts' do
+      it "makes 6 attempts" do
         @attempts.must_equal 6
       end
 
-      it 'applies a non-randomized exponential backoff to each attempt' do
+      it "applies a non-randomized exponential backoff to each attempt" do
         @time_table.must_equal({
           1 => 0.5,
           2 => 0.75,
@@ -101,12 +142,12 @@ describe Retriable do
       end
     end
 
-    it 'retry has a max interval of 1.5 seconds' do
+    it "retry has a max interval of 1.5 seconds" do
       max_tries = 6
       attempts = 0
       time_table = {}
 
-      handler = Proc.new do |exception, attempt, elapsed_time, next_interval|
+      handler = ->(exception, attempt, elapsed_time, next_interval) do
         time_table[attempt] = next_interval
       end
 
@@ -130,14 +171,47 @@ describe Retriable do
       })
     end
 
-    it 'can call #retriable in the global' do
-      lambda do
+    it "retries with defined intervals" do
+      intervals = [
+        0.5,
+        0.75,
+        1.125,
+        1.5,
+        1.5
+      ]
+      time_table = {}
+
+      handler = ->(exception, attempt, elapsed_time, next_interval) do
+        time_table[attempt] = next_interval
+      end
+
+      -> do
+        subject.retry(
+          on: EOFError,
+          on_retry: handler,
+          intervals: intervals
+        ) do
+          raise EOFError.new
+        end
+      end.must_raise EOFError
+
+      time_table.must_equal({
+        1 => 0.5,
+        2 => 0.75,
+        3 => 1.125,
+        4 => 1.5,
+        5 => 1.5
+      })
+    end
+
+    it "can call #retriable in the global" do
+      -> do
         retriable do
-          puts 'should raise NoMethodError'
+          puts "should raise NoMethodError"
         end
       end.must_raise NoMethodError
 
-      require_relative '../lib/retriable/core_ext/kernel'
+      require_relative "../lib/retriable/core_ext/kernel"
 
       i = 0
       retriable do
@@ -148,7 +222,7 @@ describe Retriable do
     end
   end
 
-  it 'retry runs for a max elapsed time of 2 seconds' do
+  it "retry runs for a max elapsed time of 2 seconds" do
     subject.configure do |c|
       c.sleep_disabled = false
     end
@@ -158,11 +232,11 @@ describe Retriable do
     attempts = 0
     time_table = {}
 
-    handler = Proc.new do |exception, attempt, elapsed_time, next_interval|
+    handler = ->(exception, attempt, elapsed_time, next_interval) do
       time_table[attempt] = elapsed_time
     end
 
-    lambda do
+    -> do
       subject.retry(
         base_interval: 1.0,
         multiplier: 1.0,

data/spec/spec_helper.rb

@@ -1,5 +1,5 @@
-require 'minitest/autorun'
-require 'minitest/focus'
-require 'pry'
+require "minitest/autorun"
+require "minitest/focus"
+require "pry"
 
-require_relative '../lib/retriable'
+require_relative "../lib/retriable"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: retriable
 version: !ruby/object:Gem::Version
-  version: 2.0.0.beta2
+  version: 2.0.0.beta3
 platform: ruby
 authors:
 - Jack Chu
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-25 00:00:00.000000000 Z
+date: 2014-10-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -113,8 +113,11 @@ files:
 - lib/retriable.rb
 - lib/retriable/config.rb
 - lib/retriable/core_ext/kernel.rb
+- lib/retriable/exponential_backoff.rb
 - lib/retriable/version.rb
 - retriable.gemspec
+- spec/config_spec.rb
+- spec/exponential_backoff_spec.rb
 - spec/retriable_spec.rb
 - spec/spec_helper.rb
 - wercker.yml
@@ -144,5 +147,7 @@ specification_version: 4
 summary: Retriable is an simple DSL to retry failed code blocks with randomized exponential
   backoff
 test_files:
+- spec/config_spec.rb
+- spec/exponential_backoff_spec.rb
 - spec/retriable_spec.rb
 - spec/spec_helper.rb