gracefully 0.0.1 → 0.1.0

data/lib/gracefully/error.rb

@@ -0,0 +1,37 @@
+module Gracefully
+  # Thanks to [nested](https://github.com/skorks/nesty) for the original code
+  module NestedError
+    def initialize(message, args)
+      @nested = args[:nested]
+      super(message)
+    end
+
+    def set_backtrace(backtrace)
+      @raw_backtrace = backtrace
+      if nested
+        backtrace = include_nested_raw_backtrace_in backtrace
+      end
+      super(backtrace)
+    end
+
+    private
+
+    def include_nested_raw_backtrace_in(backtrace)
+      backtrace = backtrace - nested_raw_backtrace
+      backtrace += ["#{nested.backtrace.first}: #{nested.message} (#{nested.class.name})"]
+      backtrace + nested.backtrace[1..-1] || []
+    end
+
+    def nested_raw_backtrace
+      nested.respond_to?(:raw_backtrace) ? nested.raw_backtrace : nested.backtrace
+    end
+
+    def nested
+      @nested
+    end
+  end
+
+  class Error < StandardError
+    include NestedError
+  end
+end

data/lib/gracefully/health.rb

@@ -0,0 +1,29 @@
+module Gracefully
+  class Health
+    def initialize(args)
+      @state = args[:state]
+    end
+
+    def mark_success
+      @state = @state.mark_success
+    end
+
+    def mark_failure
+      @state = @state.mark_failure
+    end
+
+    def healthy?
+      @state.healthy?
+    end
+
+    def unhealthy?
+      @state.unhealthy?
+    end
+
+    class State
+      def unhealthy?
+        !healthy?
+      end
+    end
+  end
+end

data/lib/gracefully/mutex_based_synchronized_counter.rb

@@ -0,0 +1,30 @@
+require_relative 'counter'
+
+require 'thread'
+
+module Gracefully
+  # The counter equipped with the possibly easiest kind of synchronization.
+  class MutexBasedSynchronizedCounter < Counter
+    # @param [Counter] counter
+    def initialize(counter)
+      @counter = counter
+      @mutex = Mutex.new
+    end
+
+    def reset!
+      @mutex.synchronize do
+        @counter.reset!
+      end
+    end
+
+    def increment!
+      @mutex.synchronize do
+        @counter.increment!
+      end
+    end
+
+    def count
+      @counter.count
+    end
+  end
+end

data/lib/gracefully/retried_command.rb

@@ -0,0 +1,25 @@
+require_relative 'command'
+
+module Gracefully
+  class RetriedCommand < Command
+    def initialize(*args, &block)
+      super
+
+      @retries = @options[:retries]
+    end
+
+    def call(*args, &block)
+      num_tried = 0
+      begin
+        @callable.call *args, &block
+      rescue => e
+        num_tried += 1
+        if num_tried <= @retries
+          retry
+        else
+          raise Gracefully::Error.new(e.message, nested: e)
+        end
+      end
+    end
+  end
+end

data/lib/gracefully/short_circuited_command.rb

@@ -0,0 +1,23 @@
+require_relative 'command'
+require_relative 'circuit_breaker'
+require_relative 'consecutive_failures_based_health'
+
+module Gracefully
+  class ShortCircuitedCommand < Command
+    def initialize(*args, &block)
+      super
+
+      @circuit_breaker = Gracefully::CircuitBreaker.new(
+        try_close_after: @options[:try_close_after],
+        health: Gracefully::ConsecutiveFailuresBasedHealth.new(
+          become_unhealthy_after_consecutive_failures: @options[:allowed_failures],
+          counter: @options[:counter]
+        )
+      )
+    end
+
+    def call(*args, &block)
+      @circuit_breaker.execute { super }
+    end
+  end
+end

data/lib/gracefully/timed_command.rb

@@ -0,0 +1,19 @@
+require 'timeout'
+
+require_relative 'command'
+
+module Gracefully
+  class TimedCommand < Command
+    def initialize(*args, &block)
+      super
+
+      @timeout = @options[:timeout]
+    end
+
+    def call(*args, &block)
+      Timeout.timeout(@timeout) do
+        @callable.call *args, &block
+      end
+    end
+  end
+end

data/lib/gracefully/togglable_command.rb

@@ -0,0 +1,20 @@
+require_relative 'command'
+require_relative 'command_disabled_error'
+
+module Gracefully
+  class TogglableCommand < Command
+    def initialize(*args, &block)
+      super
+
+      @run_only_if = @options[:run_only_if]
+    end
+
+    def call(*args, &block)
+      if @run_only_if.call
+        @callable.call *args, &block
+      else
+        raise Gracefully::CommandDisabledError
+      end
+    end
+  end
+end

data/lib/gracefully/try.rb

@@ -1,3 +1,5 @@
+require_relative 'error'
+
 module Gracefully
   class Try
     def self.to(&block)
@@ -14,7 +16,9 @@ module Gracefully
       @resolved = begin
         Success.with @block.call
       rescue => e
-        Failure.with Error.new('Nested error', nested: e)
+        # Back-traces, which are required by Gracefully::Error, of errors are usually set by `raise`.
+        # We need to set them manually because we aren't relying on `raise`.
+        Failure.with Error.new('Nested error', nested: e).tap { |e| e.set_backtrace caller(0) }
       end
     end
 
@@ -59,39 +63,7 @@ module Gracefully
     end
 
     def get
-      raise @error
-    end
-  end
-
-  # Thanks to [nested](https://github.com/skorks/nesty) for the original code
-  module NestedError
-    def initialize(message, args)
-      @nested = args[:nested]
-      super(message)
-    end
-
-    def set_backtrace(backtrace)
-      @raw_backtrace = backtrace
-      if nested
-        backtrace = backtrace - nested_raw_backtrace
-        backtrace += ["#{nested.backtrace.first}: #{nested.message} (#{nested.class.name})"]
-        backtrace += nested.backtrace[1..-1] || []
-      end
-      super(backtrace)
+      raise Error.new('Tried to get the value of a failure', nested: @error)
     end
-
-    private
-
-    def nested_raw_backtrace
-      nested.respond_to?(:raw_backtrace) ? nested.raw_backtrace : nested.backtrace
-    end
-
-    def nested
-      @nested
-    end
-  end
-
-  class Error < StandardError
-    include NestedError
   end
 end

data/lib/gracefully/version.rb

@@ -1,3 +1,3 @@
 module Gracefully
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/spec/circuit_breaker_spec.rb

@@ -0,0 +1,142 @@
+require 'timecop_helper'
+
+require 'gracefully'
+require 'gracefully/circuit_breaker'
+
+RSpec.shared_examples 'a open circuit breaker' do
+  specify { expect(subject.open?).to be_truthy }
+  specify { expect(subject.closed?).to be_falsey }
+end
+
+RSpec.shared_examples 'a closed circuit breaker' do
+  specify { expect(subject.open?).to be_falsey }
+  specify { expect(subject.closed?).to be_truthy }
+end
+
+RSpec.shared_examples 'a circuit breaker' do
+  context 'when failed' do
+    before do
+      subject.mark_success
+      subject.mark_failure
+    end
+
+    it_behaves_like 'a open circuit breaker'
+  end
+
+  context 'when succeeded' do
+    before do
+      subject.mark_failure
+      subject.mark_success
+    end
+
+    it_behaves_like 'a closed circuit breaker'
+  end
+
+  context 'when opened' do
+    before do
+      subject.open!
+    end
+
+    it_behaves_like 'a open circuit breaker'
+  end
+
+  context 'when closed' do
+    before do
+      subject.close!
+    end
+
+    it_behaves_like 'a closed circuit breaker'
+  end
+end
+
+RSpec.describe Gracefully::CircuitBreaker do
+  context 'without try_close_period' do
+    subject {
+      described_class.new
+    }
+
+    it_behaves_like 'a circuit breaker'
+  end
+
+  context 'with try_close_period' do
+    subject {
+      described_class.new(try_close_after: try_close_period)
+    }
+
+    let(:try_close_period) {
+      10
+    }
+
+    it_behaves_like 'a circuit breaker'
+
+    it 'passes the integration test' do
+      initial_failure_time = Time.now
+
+      Timecop.freeze(initial_failure_time) do
+        expect {
+          subject.execute do
+            raise 'foo'
+          end
+        }.to raise_error('foo')
+
+        expect(subject.open?).to be_truthy
+        expect(subject.closed?).to be_falsey
+        expect(subject.opened_date).not_to be_nil
+      end
+
+      Timecop.freeze(initial_failure_time + 10) do
+        expect {
+          subject.execute do
+          end
+        }.to raise_error(Gracefully::CircuitBreaker::CurrentlyOpenError)
+
+        expect(subject.open?).to be_truthy
+        expect(subject.closed?).to be_falsey
+        expect(subject.opened_date).not_to be_nil
+      end
+
+      Timecop.freeze(initial_failure_time + 11) do
+        expect(
+          subject.execute do
+            'baz'
+          end
+        ).to eq('baz')
+
+        expect(subject.open?).to be_falsey
+        expect(subject.closed?).to be_truthy
+        expect(subject.try_close_period_passed?).to be_falsey
+        expect(subject.opened_date).to be_nil
+      end
+    end
+
+    context 'when try-close period passed after its opened' do
+      before do
+        Timecop.freeze(failed_date) do
+          subject.mark_failure
+        end
+      end
+
+      let(:failed_date) {
+        Time.now
+      }
+
+      let(:after_date) {
+        failed_date + 11
+      }
+
+      specify { expect(subject.open?).to be_truthy }
+      specify { expect(subject.closed?).to be_falsey }
+      specify { expect(subject.opened_date).to eq(failed_date) }
+      specify {
+        Timecop.freeze(after_date) do
+          expect(subject.try_close_period_passed?).to be_truthy
+        end
+      }
+      specify {
+        Timecop.freeze(failed_date) do
+          expect(subject.try_close_period_passed?).to be_falsey
+        end
+      }
+    end
+  end
+end

data/spec/command_spec.rb

@@ -0,0 +1,34 @@
+require 'gracefully'
+require 'gracefully/command'
+
+RSpec.shared_examples 'a command' do
+  let(:input1) {
+    'input1'
+  }
+
+  context 'when the block given to the command succeeds without any error' do
+    let(:usually) {
+      -> arg1 { 'usually:arg1:' + arg1 }
+    }
+
+    it { is_expected.to eq('usually:arg1:input1') }
+  end
+
+  context 'when the usually block fails with an error' do
+    let(:usually) {
+      -> arg1 { raise 'simulated error' }
+    }
+
+    specify { expect { subject }.to raise_error('simulated error') }
+  end
+end
+
+RSpec.describe Gracefully::Command do
+  describe "feature call result" do
+    subject {
+      described_class.new(&usually).call input1
+    }
+
+    it_behaves_like 'a command'
+  end
+end

data/spec/consecutive_failures_based_health_spec.rb

@@ -0,0 +1,78 @@
+require 'gracefully/consecutive_failures_based_health'
+
+RSpec.shared_examples 'healthy' do
+  it { is_expected.to be_healthy }
+  it { is_expected.not_to be_unhealthy }
+end
+
+RSpec.shared_examples 'unhealthy' do
+  it { is_expected.to be_unhealthy }
+  it { is_expected.not_to be_healthy }
+end
+
+RSpec.describe Gracefully::ConsecutiveFailuresBasedHealth do
+  subject {
+    described_class.new(
+      become_unhealthy_after_consecutive_failures: threshold,
+      counter: -> { Gracefully::InMemoryCounter.new }
+    )
+  }
+
+  let(:threshold) {
+    1
+  }
+
+  def less_than_or_equal_to(t)
+    t
+  end
+
+  def more_than(t)
+    t + 1
+  end
+
+  context 'initially' do
+    it_behaves_like 'healthy'
+  end
+
+  context 'after failures less than or equal to the threshold' do
+    before do
+      less_than_or_equal_to(threshold).times { subject.mark_failure }
+    end
+
+    it_behaves_like 'healthy'
+  end
+
+  context 'after failures more than the threshold' do
+    before do
+      more_than(threshold).times { subject.mark_failure }
+    end
+
+    it_behaves_like 'unhealthy'
+  end
+
+  context 'after failures more than threshold and a success' do
+    before do
+      more_than(threshold).times { subject.mark_failure }
+      subject.mark_success
+    end
+
+    it_behaves_like 'healthy'
+  end
+
+  context 'after failurse more than thoreshold + 1 and a success' do
+    before do
+      more_than(threshold + 1).times { subject.mark_failure }
+      subject.mark_success
+    end
+
+    it_behaves_like 'healthy'
+  end
+
+  context 'after consecutive successes' do
+    before do
+      2.times { subject.mark_success }
+    end
+
+    it_behaves_like 'healthy'
+  end
+end