disyuntor 0.1.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7ab5e6badbc47e7babf6bd794c93b14c826458bd
-  data.tar.gz: a8b0a6b6fc72713b987ae48fb091364471568d08
+  metadata.gz: 601f1ae1935ac87a0fffe20e3f3181dd4cafc5c6
+  data.tar.gz: 7a6815a58f579049f49c018796cfe45a51763239
 SHA512:
-  metadata.gz: 3bd3266ebe4e42789dbeac531495e08544a2959ed4b62b39e900a312f6cb1084bbab73f8f02d21aac1df44303d614f077ddb8324642187f9f866e84a31ef2264
-  data.tar.gz: 5d2350086bb03289c4510998d7fa806fd3e7c443c7b2615f77750432a8e2304c37dda443f6d8454a8470d2942981d8ddecfce77131e0dfa5c5f809d083137046
+  metadata.gz: dbd2b6f2d21f9091320eeb45b1c7e02d0dab9c576dac0575acfee8abeb8519d1af7cec61170a0055272d387044c1764863387e88803413b1b7452f6accb1c19f
+  data.tar.gz: 3d1d685bac30efb63cb3f6208ff46a02a5c2667b356d293b9a871a6f17dd5532bdc6358220b7c40c8154a7f7497de45ebc2ac5365fe4e6daa76f00fb05a4b3ac

data/.travis.yml

@@ -0,0 +1,9 @@
+language: ruby
+
+install: gem install minitest:5.8.4
+
+rvm:
+  - "2.1"
+  - "2.2"
+
+script: ruby test/disyuntor_test.rb -v

data/README.md

@@ -1,6 +1,6 @@
 # Simple Circuit Breaker Pattern in Ruby
 
-[![Join the chat at https://gitter.im/inkel/disyuntor](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/inkel/disyuntor?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+[![Join the chat at https://gitter.im/inkel/disyuntor](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/inkel/disyuntor?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge) ![build status on master](https://travis-ci.org/inkel/disyuntor.svg?branch=master)
 
 This gem implements a very simple class to deal with the Circuit Breaker Pattern as described by [Michael T. Nygard](http://www.michaelnygard.com/) in his amazing and highly recommended [Release It! - Design and Deploy Production-Ready Software](http://www.amazon.com/Release-It-Production-Ready-Pragmatic-Programmers/dp/0978739213).
 
@@ -9,41 +9,33 @@ This gem implements a very simple class to deal with the Circuit Breaker Pattern
 ```ruby
 require "disyuntor"
 
-options = {
-  # Trip circuit after 10 errors
-  threshold: 10,
-  # Wait 5 seconds before trying again
-  timeout: 5
-}
+# Trip circuit after 10 errors
+# Wait 5 seconds before trying again
+disyuntor = Disyuntor.new(threshold: 10, timeout: 5)
 
-circuit_breaker = Disyuntor.new(options)
-
-res = circuit_breaker.try do
+res = disyuntor.try do
   # …your potentially failing operation…
 end
 ```
 
-By default, when the circuit is open, `Disyuntor#try` will fail with a `Disyuntor::CircuitOpenError`. This behavior can be changed by passing a `Proc` in the `on_circuit_open` option or method.
-
-If you want to use it as a [`Rack`](https://github.com/rack/rack) middleware, add the following in your `config.ru`:
-
-```ruby
-require "rack/disyuntor"
+A _Disyuntor_, or circuit breaker, has two (and a half) possible states:
 
-use Rack::Disyuntor, threshold: 10, timeout: 5
-```
+* `#closed?` for when the protection hasn't detected any issues and your code is allowed to run;
+* `#open?` for when the protection has reached a `threshold` of issues and your code won't be allowed to run.
 
-This will start responding with `[503, { "Content-Type" => "text/plain", ["Service Unavailable"]]` when the circuit is open.
+The third, or rather second and a half state, is for when the circuit was open and `timeout` seconds passed. In this state your code is allowed to run **just once**. If it works without raising any new failure, then the circuit will automatically close itself until, otherwise it will remain in an open state for a new `timeout` interval in seconds.
 
 ## Custom actions when circuit is open
 
+By default, when the circuit is open, `Disyuntor#try` will fail with a `Disyuntor::CircuitOpenError`. This behavior can be changed by passing a `Proc` in the `on_circuit_open` option or method.
+
 Every time the circuit is open, the `#on_circuit_open` method is called, passing the circuit as its argument. This allows customizing the failure mode of your circuit:
 
 ```ruby
-circuit_breaker = Disyuntor.new(threshold: 3, timeout: 5)
+disyuntor = Disyuntor.new(threshold: 3, timeout: 5)
 
-circuit_breaker.on_circuit_open do |c|
-  "Circuit was open at #{c.opened_at}"
+disyuntor.on_circuit_open do |c|
+  puts "Ooops, can't execute circuit"
 end
 ```
 

data/disyuntor.gemspec

@@ -16,5 +16,5 @@ Gem::Specification.new do |s|
 
   s.files = `git ls-files`.split("\n")
 
-  s.add_dependency "micromachine", "1.2.0"
+  s.add_development_dependency "minitest", ">= 5.8.4"
 end

data/lib/disyuntor.rb

@@ -1,92 +1,76 @@
-require "micromachine"
-
 class Disyuntor
   CircuitOpenError = Class.new(RuntimeError)
 
-  attr_reader :failures, :opened_at, :threshold, :timeout
+  attr_reader :failures, :threshold, :timeout
 
-  def initialize(threshold: 5, timeout: 10, &block)
+  def initialize(threshold:, timeout:)
     @threshold = threshold
     @timeout   = timeout
 
-    @on_circuit_open = if block_given?
-                         block
-                       else
-                         Proc.new{ fail CircuitOpenError }
-                       end
+    on_circuit_open { fail CircuitOpenError }
 
     close!
   end
 
-  def states
-    @states ||= MicroMachine.new(:closed).tap do |fsm|
-      fsm.when(:trip,  :half_open => :open,   :closed => :open)
-      fsm.when(:reset, :half_open => :closed, :closed => :closed)
-      fsm.when(:try,   :open      => :half_open)
+  def try(&block)
+    if closed? or timed_out?
+      circuit_closed(&block)
+    else
+      circuit_open
+    end
+  end
 
-      fsm.on(:open) do
-        @opened_at = Time.now.to_i
-      end
+  def on_circuit_open(&block)
+    raise ArgumentError, "Must pass a block" unless block_given?
+    @on_circuit_open = block
+  end
 
-      fsm.on(:closed) do
-        @opened_at = nil
-        @failures  = 0
-      end
-    end
+  def closed?
+    state == :closed
   end
 
-  def close!     () states.trigger!(:reset) end
-  def open!      () states.trigger!(:trip)  end
-  def half_open! () states.trigger!(:try)   end
+  def open?
+    not (closed? or timed_out?)
+  end
 
-  def state      () states.state        end
+  private
 
-  def closed?    () state == :closed    end
-  def open?      () state == :open      end
-  def half_open? () state == :half_open end
+  attr_reader :opened_at, :state
 
-  def timed_out?
-    open? && Time.now.to_i > (@opened_at + @timeout)
+  def close!
+    @opened_at = nil
+    @failures  = 0
+    @state     = :closed
   end
 
-  def try(&block)
-    half_open! if timed_out?
+  def open!
+    @opened_at = Time.now.to_i
+    @state     = :open
+  end
 
-    case
-    when closed?    then on_circuit_closed(&block)
-    when half_open? then on_circuit_half_open(&block)
-    when open?      then on_circuit_open
-    else
-      fail RuntimeError, "Invalid state! #{state}"
-    end
+  def timed_out?
+    Time.now.to_i > next_timeout_at
   end
 
-  def on_circuit_closed(&block)
-    ret = block.call
-  rescue
+  def next_timeout_at
+    opened_at + timeout
+  end
+
+  def increment_failures!
     @failures += 1
-    open! if @failures > @threshold
-    raise
-  else
-    close!
-    ret
   end
 
-  def on_circuit_half_open(&block)
+  def circuit_closed(&block)
     ret = block.call
   rescue
-    open!
+    open! if increment_failures! >= threshold
     raise
   else
     close!
     ret
   end
 
-  def on_circuit_open(&block)
-    if block_given?
-      @on_circuit_open = block
-    else
-      @on_circuit_open.(self)
-    end
+  def circuit_open
+    @on_circuit_open.call(self)
   end
 end

data/lib/disyuntor/version.rb

@@ -1,3 +1,3 @@
 class Disyuntor
-  VERSION = "0.1.0"
+  VERSION = "0.9.0"
 end

data/test/disyuntor_test.rb

@@ -0,0 +1,186 @@
+if ENV["COVERAGE"]
+  require "simplecov"
+  SimpleCov.start do
+    add_filter "/test/"
+    add_filter "/spec/"
+    add_filter "/.gs/"
+  end
+end
+
+require "minitest/autorun"
+require_relative "../lib/disyuntor"
+
+class DisyuntorTest < Minitest::Test
+  CustomRuntimeError = Class.new(RuntimeError)
+
+  def test_initialize_without_defaults
+    assert_raises(ArgumentError) { Disyuntor.new }
+  end
+
+  def test_initialize_requires_timeout
+    assert_raises(ArgumentError) do
+      Disyuntor.new(threshold: 1)
+    end
+  end
+
+  def test_initialize_requires_threshold
+    assert_raises(ArgumentError) do
+      Disyuntor.new(timeout: 1)
+    end
+  end
+
+  def setup
+    @threshold = 3
+    @timeout   = 5
+    @disyuntor = Disyuntor.new(threshold: @threshold, timeout: @timeout)
+  end
+
+  def test_initialize_closed
+    assert @disyuntor.closed?
+  end
+
+  def test_initialize_without_failures
+    assert_equal 0, @disyuntor.failures
+  end
+
+  def test_closed_circuit_returns_block_value
+    assert_equal 42, @disyuntor.try { 42 }
+  end
+
+  def test_closed_circuit_do_not_count_failures_on_success
+    @disyuntor.try { true }
+    assert_equal 0, @disyuntor.failures
+  end
+
+  def test_reset_failures_counter_on_closed_circuit_success
+    begin
+      @disyuntor.try { fail CustomRuntimeError }
+    rescue CustomRuntimeError
+    end
+
+    assert_equal 1, @disyuntor.failures
+
+    @disyuntor.try { true }
+
+    assert_equal 0, @disyuntor.failures
+  end
+
+  def make_open(breaker)
+    breaker.threshold.times do
+      begin
+        breaker.try { fail CustomRuntimeError }
+      rescue CustomRuntimeError
+      end
+    end
+  end
+
+  def after_timeout(breaker, &block)
+    Time.stub(:now, Time.at(Time.now.to_i + breaker.timeout + 1), &block)
+  end
+
+  def test_open_circuit_after_threshold_failures
+    @disyuntor.threshold.times do
+      begin
+        @disyuntor.try { fail CustomRuntimeError }
+      rescue CustomRuntimeError
+      end
+    end
+
+    refute @disyuntor.closed?
+  end
+
+  def test_open_circuit_raises_default_error
+    make_open(@disyuntor)
+
+    assert_raises(Disyuntor::CircuitOpenError) do
+      @disyuntor.try { fail CustomRuntimeError }
+    end
+  end
+
+  def test_override_on_circuit_open
+    @disyuntor.on_circuit_open { 42 }
+
+    make_open(@disyuntor)
+
+    assert_equal 42, @disyuntor.try { fail CustomRuntimeError }
+  end
+
+  def test_count_failures
+    assert_equal 0, @disyuntor.failures
+
+    make_open(@disyuntor)
+
+    assert_equal @threshold, @disyuntor.failures
+  end
+
+  def test_do_not_count_failures_when_open
+    make_open(@disyuntor)
+
+    begin
+      @disyuntor.try { fail CustomRuntimeError }
+    rescue Disyuntor::CircuitOpenError
+    end
+
+    assert_equal @threshold, @disyuntor.failures
+  end
+
+  def test_close_after_timeout_if_success
+    make_open(@disyuntor)
+
+    refute @disyuntor.closed?
+
+    after_timeout(@disyuntor) do
+      assert_equal 42, @disyuntor.try { 42 }
+    end
+
+    assert @disyuntor.closed?
+  end
+
+  def test_reopen_after_timeout_if_fails
+    make_open(@disyuntor)
+
+    refute @disyuntor.closed?
+
+    after_timeout(@disyuntor) do
+      assert_raises(CustomRuntimeError) do
+        @disyuntor.try { fail CustomRuntimeError }
+      end
+    end
+
+    refute @disyuntor.closed?
+  end
+
+  def test_count_failure_after_timeout_if_fails
+    make_open(@disyuntor)
+
+    refute @disyuntor.closed?
+
+    after_timeout(@disyuntor) do
+      assert_raises(CustomRuntimeError) do
+        @disyuntor.try { fail CustomRuntimeError }
+      end
+    end
+
+    assert_equal @threshold.next, @disyuntor.failures
+  end
+
+  def test_close_after_timeout_if_succeeds
+    make_open(@disyuntor)
+
+    refute @disyuntor.closed?
+
+    after_timeout(@disyuntor) do
+      assert_equal 42, @disyuntor.try { 42 }
+    end
+
+    assert @disyuntor.closed?
+  end
+
+  def test_do_not_report_open_when_timed_out
+    make_open(@disyuntor)
+
+    after_timeout(@disyuntor) do
+      refute @disyuntor.open?
+    end
+  end
+end

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: disyuntor
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.9.0
 platform: ruby
 authors:
 - Leandro López
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-22 00:00:00.000000000 Z
+date: 2016-06-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: micromachine
+  name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 1.2.0
-  type: :runtime
+        version: 5.8.4
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 1.2.0
+        version: 5.8.4
 description: Simple implementation of Michael T. Nygard's Circuit Breaker Pattern
 email:
 - inkel.ar@gmail.com
@@ -31,12 +31,13 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".travis.yml"
 - LICENSE
 - README.md
 - disyuntor.gemspec
 - lib/disyuntor.rb
 - lib/disyuntor/version.rb
-- lib/rack/disyuntor.rb
+- test/disyuntor_test.rb
 homepage: http://github.com/inkel/disyuntor
 licenses:
 - MIT
@@ -57,7 +58,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: Circuit Breaker Pattern in Ruby

data/lib/rack/disyuntor.rb

@@ -1,20 +0,0 @@
-require "rack"
-require_relative "../disyuntor"
-
-class Rack::Disyuntor
-  def initialize(app, options={})
-    @app = app
-
-    options[:on_circuit_open] ||= -> { circuit_open_response }
-
-    @circuit_breaker = Disyuntor.new(options)
-  end
-
-  def call(env)
-    @circuit_breaker.try { @app.call(env) }
-  end
-
-  def circuit_open_response
-    [503, { "Content-Type" => "text/plain" }, ["Service Unavailable"]]
-  end
-end