rhod 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: deae1b7b10203a606f6ba69985c0b0520e3ed666
+  data.tar.gz: e7485d2cb082e4697c55ac0af77ad59a94f5e9d2
+SHA512:
+  metadata.gz: fbb5a386678bbdb265d75323df5cbb8c8f77100a4224d814dbe7d3391367f7cbfeaee3b9e203de061a3d2a50eacbd0ce35d49c0d3ae4472c1427b113ea340c37
+  data.tar.gz: 69cab5ac043ac3806c37f47e55f39b5a42b91cc01b9015ddebda5ce91d7258dfe97a999a260225597405aef2ce082d99a4d671e6fd0daac79b7319d420d75580

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.pryrc

@@ -0,0 +1 @@
+require './lib/rhod'

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in rhod.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Paul Bergeron
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,164 @@
+# Rhod
+
+A Lightweight High Avalibility framework for Ruby, inspired by [Hystrix](https://github.com/Netflix/Hystrix)
+
+> Korben Dallas: You guard this with your life, or you're gonna look like this guy here! You green?
+>
+> DJ Ruby Rhod: G-green.
+>
+> Korben Dallas: Super green?
+>
+> DJ Ruby Rhod: Super green.
+
+Rhod helps you handle failures gracefully, even during a firefight. When your code has to interact with other services, it also means writing code to keep it running in the event of failure. Failures can include exceptions, timeouts, downed hosts, and any number of issues that are caused by events outside of your application.
+
+Rhod allows you to fully customize how your application reacts when it can't reach a service it needs. but by default it is configured for a 'fail fast' scenario. With some configuration, Rhod can support the following failure scenarios and variations on them:
+
+  - Fail Fast
+  - Retry N times before Fail
+  - Retry N times with progressive backoffs before Fail
+  - Fail Silent
+  - Fail w/ Fallback
+  - Primary / Secondary ("hot spare") switch over
+
+## Installation
+
+Rhod requires Ruby 1.9.2 or greater.
+
+Add this line to your application's Gemfile:
+
+    gem 'rhod'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rhod
+
+## Usage
+
+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
+
+This implements the "Fail Fast" scenario by default.
+
+Example, open a remote reasource, fail immediately if it fails:
+
+    require 'open-uri'
+    require 'rhod'
+
+    Rhod.execute { open("http://google.com").read }
+
+### Retries with and without backoffs
+
+#### Idempotence Caution
+
+Code within a `Rhod::Command` block with reties in use must be _idempotent_, i.e., safe to run multiple times.
+
+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]
+
+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'
+
+    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'
+
+    Rhod.execute(:retries => 10, :backoffs => Rhod::Backoffs.constant_backoff(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'
+
+    Rhod.execute(:retries => 10, :backoffs => Rhod::Backoffs.expoential_backoffs) do
+      open("http://google.com").read
+    end
+
+Example, open a remote reasource, fail once it has failed 10 times, with waiting between attempts:
+
+    require 'open-uri'
+    require 'rhod'
+
+    Rhod.execute(:retries => 10, :backoffs => Rhod::Backoffs.constant_backoff(0)) do
+      open("http://google.com").read
+    end
+
+### Fail Silent
+
+In the event of a failure, Rhod falls back to a `fallback`. The most basic case is to fall back to a constant value.
+
+Example, open a remote reasource, if it fails return them empty string.
+
+    require 'open-uri'
+    require 'rhod'
+
+    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'
+
+    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
+
+### 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'
+
+    class SearchEngineHTML
+      attr_accessor :secondary
+
+      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
+    end
+
+    search_engine_html = SearchEngineHTML.new
+
+    search_engine_html.fetch
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b feature/my-new-feature`)
+3. Make your changes and add tests, verify they pass with (`bundle exec rake test`)
+4. Commit your changes (`git commit -am 'Add some feature'`)
+5. Push to the branch (`git push origin feature/my-new-feature`)
+6. Create new Pull Request

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'test'
+  test.test_files = Dir['test/**/test_*.rb']
+  test.verbose = true
+end

data/lib/rhod.rb

@@ -0,0 +1,9 @@
+require_relative "rhod/version"
+require_relative "rhod/backoffs"
+require_relative "rhod/command"
+
+module Rhod
+  def self.execute(*args, &block)
+    Rhod::Command.execute(*args, &block)
+  end
+end

data/lib/rhod/backoffs.rb

@@ -0,0 +1,36 @@
+module Rhod::Backoffs
+
+  extend self
+  # Returns a generator of a expoentially increasing series starting at 1
+  def expoential_backoffs
+    Enumerator.new do |yielder|
+      x = 0
+      loop do
+        x += 1
+        yielder << (1.0/2.0*(2.0**x - 1.0)).ceil
+      end
+    end
+  end
+
+  # Returns a generator of a logarithmicly increasing series starting at 0.3
+  def logarithmic_backoffs
+    Enumerator.new do |yielder|
+      x = 0.3
+      loop do
+        x += 1
+        yielder << Math.log2(x**2)
+      end
+    end
+  end
+
+  # Always the same backoff
+  def constant_backoff(i)
+    Enumerator.new do |yielder|
+      loop do
+        yielder << i
+      end
+    end
+  end
+
+  alias default logarithmic_backoffs
+end

data/lib/rhod/command.rb

@@ -0,0 +1,46 @@
+class Rhod::Command
+
+  EXCEPTIONS = [Exception, StandardError]
+
+  def initialize(*args, &block)
+    opts = args[-1].kind_of?(Hash) ? args.pop : {}
+    @args = args
+    @args ||= []
+
+    @request = block
+
+    @retries = opts[:retries]
+    @retries ||= 0
+    @attempts = 0
+
+    @backoffs = opts[:backoffs]
+    @backoffs ||= Rhod::Backoffs.default
+
+    @fallback = opts[:fallback]
+  end
+
+  ### Class methods
+
+  def self.execute(*args, &block)
+    this = self.new(*args, &block)
+    this.execute
+  end
+
+  ### Instance methods
+
+  def execute
+    begin
+      @request.call(*@args)
+    rescue *EXCEPTIONS
+      @attempts += 1
+      if @attempts <= @retries
+        sleep(@backoffs.next)
+        retry
+      else
+        return @fallback.call(*@args) if @fallback
+        raise
+      end
+    end
+  end
+
+end

data/lib/rhod/version.rb

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

data/rhod.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rhod/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rhod"
+  spec.version       = Rhod::VERSION
+  spec.authors       = ["Paul Bergeron"]
+  spec.email         = ["paul.d.bergeron@gmail.com"]
+  spec.summary       = %q{A High Avalibility framework for Ruby}
+  spec.homepage      = "https://github.com/dinedal/rhod"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "minitest"
+  spec.add_development_dependency "turn"
+end

data/test/helper.rb

@@ -0,0 +1,17 @@
+require 'rhod'
+require 'turn'
+
+Turn.config do |c|
+  # use one of output formats:
+  # :outline  - turn's original case/test outline mode [default]
+  # :progress - indicates progress with progress bar
+  # :dotted   - test/unit's traditional dot-progress mode
+  # :pretty   - new pretty reporter
+  # :marshal  - dump output as YAML (normal run mode only)
+  # :cue      - interactive testing
+  c.format  = :pretty
+  # turn on invoke/execute tracing, enable full backtrace
+  c.trace   = 100
+  # use humanized test names (works only with :outline format)
+  c.natural = true
+end

data/test/test_command.rb

@@ -0,0 +1,54 @@
+require 'minitest/autorun'
+require File.expand_path(File.dirname(__FILE__) + '/helper')
+
+describe Rhod::Command do
+  describe "self.execute" do
+    it "runs immediately and returns inner value" do
+      Rhod::Command.execute { 1 }.must_equal 1
+    end
+  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
+
+      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
+
+        val.must_equal 2
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,129 @@
+--- !ruby/object:Gem::Specification
+name: rhod
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Paul Bergeron
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: turn
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- paul.d.bergeron@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .pryrc
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/rhod.rb
+- lib/rhod/backoffs.rb
+- lib/rhod/command.rb
+- lib/rhod/version.rb
+- rhod.gemspec
+- test/helper.rb
+- test/test_command.rb
+homepage: https://github.com/dinedal/rhod
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: A High Avalibility framework for Ruby
+test_files:
+- test/helper.rb
+- test/test_command.rb