rhod 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: deae1b7b10203a606f6ba69985c0b0520e3ed666
-  data.tar.gz: e7485d2cb082e4697c55ac0af77ad59a94f5e9d2
+  metadata.gz: 48eaf0e214a15e8bbedf592f83cdac4f5ad24af8
+  data.tar.gz: c58dedc35eb28bd9247516b64dee33d8083e69ae
 SHA512:
-  metadata.gz: fbb5a386678bbdb265d75323df5cbb8c8f77100a4224d814dbe7d3391367f7cbfeaee3b9e203de061a3d2a50eacbd0ce35d49c0d3ae4472c1427b113ea340c37
-  data.tar.gz: 69cab5ac043ac3806c37f47e55f39b5a42b91cc01b9015ddebda5ce91d7258dfe97a999a260225597405aef2ce082d99a4d671e6fd0daac79b7319d420d75580
+  metadata.gz: 67aca7d1a71afb19bc469c07ad193054c7df1ab1aa0e31dae5ed522bd9b04eb91cec3fea0f6d259c8f3c3ef0673e46ee8f82468ae50ecbb64029c269ee9a1f3f
+  data.tar.gz: 8cb15b2867eb6b00c1574841508e31317b8791b0f16e545b4a7df6da7ed5759c2a56b4a24ae0b2d088e795d3bde087c02960bd2e29f68b54369098aa7bc1547a

data/README.md

@@ -27,7 +27,9 @@ Rhod requires Ruby 1.9.2 or greater.
 
 Add this line to your application's Gemfile:
 
-    gem 'rhod'
+```ruby
+gem 'rhod'
+```
 
 And then execute:
 
@@ -41,18 +43,22 @@ Or install it yourself as:
 
 Rhod has a very simple API. Design your application as you would normally, then enclose network accessing portions of your code with:
 
-    Rhod.execute do
-      ...
-    end
+```ruby
+Rhod.execute do
+  ...
+end
+```
 
 This implements the "Fail Fast" scenario by default.
 
 Example, open a remote reasource, fail immediately if it fails:
 
-    require 'open-uri'
-    require 'rhod'
+```ruby
+require 'open-uri'
+require 'rhod'
 
-    Rhod.execute { open("http://google.com").read }
+Rhod.execute { open("http://google.com").read }
+```
 
 ### Retries with and without backoffs
 
@@ -62,44 +68,54 @@ Code within a `Rhod::Command` block with reties in use must be _idempotent_, i.e
 
 Rhod supports retying up to N times. By default it uses a logarithmic backoff:
 
-    Rhod::Backoffs.default.take(5)
-    # [0.7570232465074598, 2.403267722339301, 3.444932048942182, 4.208673319629471, 4.811984719351674]
+```ruby
+Rhod::Backoffs.default.take(5)
+# [0.7570232465074598, 2.403267722339301, 3.444932048942182, 4.208673319629471, 4.811984719351674]
+```
 
 Rhod also comes with exponential and constant (always the same value) backoffs. You can also supply any Enumerator that produces a series of numbers. See `lib/rhod/backoffs.rb` for examples.
 
 Example, open a remote reasource, fail once it has failed 10 times, with the default (logarithmic) backoff:
 
-    require 'open-uri'
-    require 'rhod'
+```ruby
+require 'open-uri'
+require 'rhod'
 
-    Rhod::Command.execute(:retries => 10) { open("http://google.com").read }
+Rhod::Command.execute(:retries => 10) { open("http://google.com").read }
+```
 
 Example, open a remote reasource, fail once it has failed 10 times, waiting 0.2 seconds between attempts:
 
-    require 'open-uri'
-    require 'rhod'
+```ruby
+require 'open-uri'
+require 'rhod'
 
-    Rhod.execute(:retries => 10, :backoffs => Rhod::Backoffs.constant_backoff(0.2)) do
+    Rhod.execute(:retries => 10, :backoffs => 0.2) do
       open("http://google.com").read
     end
+```
 
 Example, open a remote reasource, fail once it has failed 10 times, with an exponetially growing wait time between attempts:
 
-    require 'open-uri'
-    require 'rhod'
+```ruby
+require 'open-uri'
+require 'rhod'
 
-    Rhod.execute(:retries => 10, :backoffs => Rhod::Backoffs.expoential_backoffs) do
-      open("http://google.com").read
-    end
+Rhod.execute(:retries => 10, :backoffs => :^) do
+  open("http://google.com").read
+end
+```
 
-Example, open a remote reasource, fail once it has failed 10 times, with waiting between attempts:
+Example, open a remote reasource, fail once it has failed 10 times, with no waiting between attempts:
 
-    require 'open-uri'
-    require 'rhod'
+```ruby
+require 'open-uri'
+require 'rhod'
 
-    Rhod.execute(:retries => 10, :backoffs => Rhod::Backoffs.constant_backoff(0)) do
-      open("http://google.com").read
-    end
+Rhod.execute(:retries => 10, :backoffs => 0) do
+  open("http://google.com").read
+end
+```
 
 ### Fail Silent
 
@@ -107,52 +123,58 @@ In the event of a failure, Rhod falls back to a `fallback`. The most basic case
 
 Example, open a remote reasource, if it fails return them empty string.
 
-    require 'open-uri'
-    require 'rhod'
+```ruby
+require 'open-uri'
+require 'rhod'
 
-    Rhod.execute(:fallback => -> {""}) do
-      open("http://google.com").read
-    end
+Rhod.execute(:fallback => -> {""}) do
+  open("http://google.com").read
+end
+```
 
 ### Fail w/ Fallback
 
 If there is another network call that can be used to fetch the reasource, it's possible to use another `Rhod::Command` once a failure has occurred.
 
-    require 'open-uri'
-    require 'rhod'
+```ruby
+require 'open-uri'
+require 'rhod'
 
-    search_engine_fallback = Rhod::Command.new(
-      :fallback => -> {""} # couldn't get anything
-    ) do
-      open("https://yahoo.com").read
-    end
+search_engine_fallback = Rhod::Command.new(
+  :fallback => -> {""} # couldn't get anything
+) do
+  open("https://yahoo.com").read
+end
 
-    Rhod.execute(:fallback => -> { search_engine_fallback.execute }) do
-      open("http://google.com").read
-    end
+Rhod.execute(:fallback => -> { search_engine_fallback.execute }) do
+  open("http://google.com").read
+end
+```
 
 ### Primary / Secondary ("Hot Spare") switch over
 
 Sometimes the fallback is just a part of normal operation. Just code in the state of which back end to access.
 
-    require 'open-uri'
-    require 'rhod'
+```ruby
+require 'open-uri'
+require 'rhod'
 
-    class SearchEngineHTML
-      attr_accessor :secondary
+class SearchEngineHTML
+  attr_accessor :secondary
 
-      def fetch
-        url = !@secondary ? "http://google.com" : "https://yahoo.com"
+  def fetch
+    url = !@secondary ? "http://google.com" : "https://yahoo.com"
 
-        Rhod.execute(url, :fallback => Proc.new { @secondary = !@secondary; fetch }) do |url|
-          open(url).read
-        end
-      end
+    Rhod.execute(url, :fallback => Proc.new { @secondary = !@secondary; fetch }) do |url|
+      open(url).read
     end
+  end
+end
 
-    search_engine_html = SearchEngineHTML.new
+search_engine_html = SearchEngineHTML.new
 
-    search_engine_html.fetch
+search_engine_html.fetch
+```
 
 ## Contributing
 

data/lib/rhod/backoffs.rb

@@ -1,21 +1,45 @@
 module Rhod::Backoffs
 
   extend self
-  # Returns a generator of a expoentially increasing series starting at 1
-  def expoential_backoffs
+
+  def backoff_sugar_to_enumerator(backoff)
+    if backoff.is_a?(Enumerator)
+      backoff
+    elsif backoff.is_a?(Numeric)
+      constant_backoff(backoff)
+    elsif backoff.is_a?(String)
+      n = (backoff[1..-1].to_i)
+      case backoff[0]
+      when "^"
+        expoential_backoffs(n)
+      when "l"
+        logarithmic_backoffs(n)
+      end
+    elsif backoff.is_a?(Symbol)
+      case backoff
+      when :^
+        expoential_backoffs
+      when :l
+        logarithmic_backoffs
+      end
+    end
+  end
+
+  # Returns a generator of a expoentially increasing series starting at n
+  def expoential_backoffs(n=1)
     Enumerator.new do |yielder|
-      x = 0
+      x = (n - 1)
       loop do
         x += 1
-        yielder << (1.0/2.0*(2.0**x - 1.0)).ceil
+        yielder << 2.0**x
       end
     end
   end
 
-  # Returns a generator of a logarithmicly increasing series starting at 0.3
-  def logarithmic_backoffs
+  # Returns a generator of a logarithmicly increasing series starting at n
+  def logarithmic_backoffs(n=0.3)
     Enumerator.new do |yielder|
-      x = 0.3
+      x = n
       loop do
         x += 1
         yielder << Math.log2(x**2)
@@ -24,10 +48,10 @@ module Rhod::Backoffs
   end
 
   # Always the same backoff
-  def constant_backoff(i)
+  def constant_backoff(n)
     Enumerator.new do |yielder|
       loop do
-        yielder << i
+        yielder << n
       end
     end
   end

data/lib/rhod/command.rb

@@ -13,7 +13,7 @@ class Rhod::Command
     @retries ||= 0
     @attempts = 0
 
-    @backoffs = opts[:backoffs]
+    @backoffs = Rhod::Backoffs.backoff_sugar_to_enumerator(opts[:backoffs])
     @backoffs ||= Rhod::Backoffs.default
 
     @fallback = opts[:fallback]

data/lib/rhod/version.rb

@@ -1,3 +1,3 @@
 module Rhod
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/test/test_backoffs.rb

@@ -0,0 +1,34 @@
+require 'minitest/autorun'
+require File.expand_path(File.dirname(__FILE__) + '/helper')
+
+describe Rhod::Backoffs do
+  describe "backoff_sugar_to_enumerator" do
+    it "returns enumerators as is" do
+      e = Rhod::Backoffs.constant_backoff(0)
+      Rhod::Backoffs.backoff_sugar_to_enumerator(e).must_equal e
+    end
+
+    it "generates constant backoffs from a Numeric" do
+      Rhod::Backoffs.backoff_sugar_to_enumerator(2.0).next.must_equal 2.0
+      Rhod::Backoffs.backoff_sugar_to_enumerator(5).next.must_equal 5
+    end
+
+    it "generates expoential backoffs with '^' syntax" do
+      Rhod::Backoffs.backoff_sugar_to_enumerator("^2.0").take(3).must_equal [4.0, 8.0, 16.0]
+    end
+
+    it "generates logarithmic backoffs with 'l' syntax" do
+      Rhod::Backoffs.backoff_sugar_to_enumerator("l2.0").
+        take(3).must_equal [3.169925001442312, 4.0, 4.643856189774724]
+    end
+
+    it "generates expoential backoffs with :^ syntax" do
+      Rhod::Backoffs.backoff_sugar_to_enumerator(:^).take(3).must_equal [2.0, 4.0, 8.0]
+    end
+
+    it "generates logarithmic backoffs with :l syntax" do
+      Rhod::Backoffs.backoff_sugar_to_enumerator(:l).
+        take(3).must_equal [0.7570232465074598, 2.403267722339301, 3.444932048942182]
+    end
+  end
+end

data/test/test_command.rb

@@ -9,45 +9,67 @@ describe Rhod::Command do
   end
 
   describe "execute" do
-    it "retries requests" do
-      val = 0
-
-      begin
-        Rhod::Command.new(:retries => 1, :backoffs => Rhod::Backoffs.constant_backoff(0)) do
-          val += 1
-          raise StandardError
-        end.execute
-      rescue
-      end
-
-      val.must_equal 2
-    end
-
     it "takes args" do
       Rhod::Command.new(1) {|a| 1 + a}.execute.must_equal 2
     end
 
-    describe "fallbacks" do
-      it "triggers fallback on failure" do
-        Rhod::Command.new(:fallback => -> { 1 }) {raise StandardError}.execute.must_equal 1
-      end
+    describe "with failures" do
+
+      describe "retrying" do
+        it "retries" do
+          val = 0
+
+          begin
+            Rhod::Command.new(:retries => 1, :backoffs => 0) do
+              val += 1
+              raise StandardError
+            end.execute
+          rescue
+          end
+
+          val.must_equal 2
+        end
+
+        it "uses backoffs" do
+          backoff = MiniTest::Mock.new
+          backoff.expect(:next, 0)
+
+          Rhod::Backoffs.stub(:constant_backoff, backoff) do
+            begin
+              Rhod::Command.new(:retries => 1, :backoffs => 0) do
+                val += 1
+                raise StandardError
+              end.execute
+            rescue
+            end
+          end
+          backoff.verify
+        end
 
-      it "passes args to fallbacks" do
-        Rhod::Command.new(1, :fallback => ->(a) { 1 + a }) {raise StandardError}.execute.must_equal 2
       end
 
-      it "only uses fallback after all retries" do
-        val = 0
+      describe "it uses fallbacks" do
+        it "triggers fallback on failure" do
+          Rhod::Command.new(:fallback => -> { 1 }) {raise StandardError}.execute.must_equal 1
+        end
+
+        it "passes args to fallbacks" do
+          Rhod::Command.new(1, :fallback => ->(a) { 1 + a }) {raise StandardError}.execute.must_equal 2
+        end
+
+        it "only uses fallback after all retries" do
+          val = 0
 
-        Rhod::Command.new(
-          :retries => 1,
-          :backoffs => Rhod::Backoffs.constant_backoff(0),
-          :fallback => -> { 1 }) do
-          val += 1
-          raise StandardError
-        end.execute
+          Rhod::Command.new(
+            :retries => 1,
+            :backoffs => 0,
+            :fallback => -> { 1 }) do
+            val += 1
+            raise StandardError
+          end.execute
 
-        val.must_equal 2
+          val.must_equal 2
+        end
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rhod
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Paul Bergeron
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-05 00:00:00.000000000 Z
+date: 2013-04-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -99,6 +99,7 @@ files:
 - lib/rhod/version.rb
 - rhod.gemspec
 - test/helper.rb
+- test/test_backoffs.rb
 - test/test_command.rb
 homepage: https://github.com/dinedal/rhod
 licenses:
@@ -126,4 +127,5 @@ specification_version: 4
 summary: A High Avalibility framework for Ruby
 test_files:
 - test/helper.rb
+- test/test_backoffs.rb
 - test/test_command.rb