retriable 1.2.0

data/.gitignore

@@ -0,0 +1,6 @@
+.DS_Store
+.rvmrc
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/CHANGELOG

@@ -0,0 +1 @@
+v1.2.0. Fork the retryable-rb repo. Extend the Kernel module with the retriable method so you can use it anywhere without having to include it in every class. Update gemspec, Gemfile, and Raketask. Remove echoe dependency.

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2011 Robert Sosinski (http://www.robertsosinski.com)
+
+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,84 @@
+Introduction
+============
+
+Retriable is an easy to use DSL to retry code if an exception is raised.  This is especially useful when interacting with unreliable services that fail randomly.
+
+Installation
+------------
+
+    gem install retriable
+
+    # In your ruby application
+    require 'retriable'
+
+    # In your Gemfile
+    gem 'retriable'
+
+Using Retriable
+---------------
+
+Code wrapped in a retriable block will be retried if a failure occurs.  As such, code attempted once, will be retried again for another attempt if it fails to run.
+
+    require 'retriable'
+
+    class Api
+      # Use it in methods that interact with unreliable services
+      def get
+        retriable do
+          # code here...
+        end
+      end
+    end
+
+By default, Retriable will rescue any exception inherited from `Exception`, retry once (for a total of two attempts) and sleep for a random amount time (between 0 to 100 milliseconds, in 10 millisecond increments).  You can choose additional options by passing them via an options `Hash`.
+
+    retriable :on => Timeout::Error, :times => 3, :sleep => 1 do
+      # code here...
+    end
+
+This example will only retry on a `Timeout::Error`, retry 3 times (for a total of 4 attempts) and sleep for a full second before each retry.  You can also specify multiple errors to retry on by passing an array.
+
+    retriable :on => [Timeout::Error, Errno::ECONNRESET] do
+      # code here...
+    end
+
+You can also have Ruby retry immediately after a failure by passing `false` as the sleep option.
+
+    retriable :sleep => false do
+      # code here...
+    end
+
+Retriable also allows for callbacks to be defined, which is useful to log failures for analytics purposes or cleanup after repeated failures.  Retriable has three types of callbacks: `then`, `finally`, and `always`.
+
+`then`: Run every time a failure occurs.
+
+`finally`: Run when the number of retries runs out.
+
+`always`: Run when the code wrapped in a retriable block passes or when the number of retries runs out.
+
+The `then` and `finally` callbacks pass the exception raised, which can be used for logging or error control.  All three callbacks also have a `handler`, which provides an interface to pass data between the code wrapped in the retriable block and the callbacks defined.
+
+Furthermore, each callback provides the number of `attempts`, `retries` and `times` that the wrapped code should be retried.  As these are specified in a `Proc`, unnecessary variables can be left out of the parameter list.
+
+    then_cb = Proc.new do |exception, handler, attempts, retries, times|
+      log "#{exception.class}: '#{exception.message}' - #{attempts} attempts, #{retries} out of #{times} retries left."}
+    end
+
+    finally_cb = Proc.new do |exception, handler|
+      log "#{exception.class} raised too many times. First attempt at #{handler[:start]} and final attempt at #{Time.now}"
+    end
+
+    always_cb = Proc.new do |handler, attempts|
+      log "total time for #{attempts} attempts: #{Time.now - handler[:start]}"
+    end
+
+    retriable :then => then_cb do, :finally => finally_cb, :always => always_cb |handler|
+      handler[:start] ||= Time.now
+
+      # code here...
+    end
+
+Credits
+-------
+
+Retriable was originally forked from the retryable-rb gem by [Robert Sosinski](https://github.com/robertsosinski), which in turn originally inspired by code written by [Michael Celona](http://github.com/mcelona) and later assisted by [David Malin](http://github.com/dmalin).

data/Rakefile

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

data/lib/retriable.rb

@@ -0,0 +1,33 @@
+require 'retriable/version'
+
+module Kernel
+  def retriable(options = {})
+    opts    = {:on => Exception, :times => 1}.merge(options)
+    handler = {}
+
+    retry_exception = opts[:on].is_a?(Array) ? opts[:on] : [opts[:on]]
+    times = retries = opts[:times]
+    attempts        = 0
+
+    begin
+      attempts += 1
+
+      return yield(handler)
+    rescue *retry_exception => exception
+      opts[:then].call(exception, handler, attempts, retries, times) if opts[:then]
+
+      if attempts <= times
+        sleep(opts[:sleep] || (rand(11) / 100.0)) unless opts[:sleep] == false
+        retries -= 1
+        retry
+      else
+        opts[:finally].call(exception, handler, attempts, retries, times) if opts[:finally]
+        raise exception
+      end
+    ensure
+      opts[:always].call(handler, attempts, retries, times) if opts[:always]
+    end
+
+    yield(handler)
+  end
+end

data/lib/retriable/version.rb

@@ -0,0 +1,5 @@
+# encoding: utf-8
+
+module Retriable
+  VERSION = '1.2.0'
+end

data/retriable.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "retriable/version"
+
+Gem::Specification.new do |s|
+  s.name        = "retriable"
+  s.version     = Retriable::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Jack Chu"]
+  s.email       = ["jack@jackchu.com"]
+  s.homepage    = %q{http://github.com/kamui/retriable}
+  s.summary     = %q{Easy to use DSL to retry code if an exception is raised.}
+  s.description = %q{Easy to use DSL to retry code if an exception is raised.}
+
+  s.rubyforge_project = "retriable"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/test/retriable_test.rb

@@ -0,0 +1,72 @@
+$:.unshift(File.dirname(__FILE__) + "../lib")
+
+require 'test/unit'
+require 'retriable'
+
+class RetriableTest < Test::Unit::TestCase
+  def test_without_arguments
+    i = 0
+
+    retriable do
+      i += 1
+
+      raise Exception.new
+    end
+  rescue Exception
+    assert_equal i, 2
+  end
+
+  def test_with_one_exception_and_two_times
+    i = 0
+
+    retriable :on => EOFError, :times => 2 do
+      i += 1
+
+      raise EOFError.new
+    end
+
+  rescue EOFError
+    assert_equal i, 3
+  end
+
+  def test_with_arguments_and_handler
+      i = 0
+
+      then_cb    = Proc.new do |e, h, a, r, t|
+        assert_equal e.class, ArgumentError
+        assert h[:value]
+
+        assert_equal a, i
+        assert_equal r, 6 - a
+        assert_equal t, 5
+      end
+
+      finally_cb = Proc.new do |e, h, a, r, t|
+        assert_equal e.class, ArgumentError
+        assert h[:value]
+
+        assert_equal a, 6
+        assert_equal r, 0
+        assert_equal t, 5
+      end
+
+      always_cb  = Proc.new do |h, a, r, t|
+        assert h[:value]
+
+        assert_equal a, 6
+        assert_equal r, 0
+        assert_equal t, 5
+      end
+
+      retriable :on => [EOFError, ArgumentError], :then => then_cb, :finally => finally_cb, :always => always_cb, :times => 5, :sleep => 0.2 do |h|
+        i += 1
+
+        h[:value] = true
+
+        raise ArgumentError.new
+      end
+
+    rescue ArgumentError
+      assert_equal i, 6
+    end
+end

metadata

@@ -0,0 +1,56 @@
+--- !ruby/object:Gem::Specification
+name: retriable
+version: !ruby/object:Gem::Version
+  version: 1.2.0
+  prerelease: 
+platform: ruby
+authors:
+- Jack Chu
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-02-10 00:00:00.000000000 Z
+dependencies: []
+description: Easy to use DSL to retry code if an exception is raised.
+email:
+- jack@jackchu.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- CHANGELOG
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/retriable.rb
+- lib/retriable/version.rb
+- retriable.gemspec
+- test/retriable_test.rb
+homepage: http://github.com/kamui/retriable
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: retriable
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: Easy to use DSL to retry code if an exception is raised.
+test_files:
+- test/retriable_test.rb