gracefully 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f736eec744523457533b32c6df2f79cc26c4c154
-  data.tar.gz: a02c22d1d338f3120bf7a712d6df7345552e7e88
+  metadata.gz: cf954108bc3f1509923aeb64fff8704ce06d3023
+  data.tar.gz: 157d3f6c00fdcc349a93a1fb9893e9a8dae2ed7a
 SHA512:
-  metadata.gz: 548dcba4a7645ce353bac284e57ee5b3d250f75ed40d4818bb514f71db0bd0e78af12b79979b9dfcf9bc53072f531fa8b54cd9d774cda568a5049adf35ffb291
-  data.tar.gz: b88c02168bcf7a204ae38188245cad7d655723c61a67a96e128b32815f2bb1d6dc92d95dd8d004e5a06b874153e51e630daeb6d695f4e023d236d224439dbe9e
+  metadata.gz: f461e469d24b71323e076f80e3b396c87d1cd36805a04b0668cad600af2e11da25b1e44ecb22d4ed8346e724ef88fefcc03a7390b5793b08321a9cfb859cc6e9
+  data.tar.gz: 07f36379d86f0d0ef94bd4c38abf7c1e962426b59d49646447294d765e2f46b61797d1a8f9e9494ee15f24813251476b0c07737c6eeed79a92b60dee14703152

data/.travis.yml

@@ -0,0 +1,30 @@
+bundler_args: --without development
+env:
+  global:
+    - JRUBY_OPTS="$JRUBY_OPTS --debug"
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.1.2
+  - 2.1.3
+  - jruby-19mode
+  - ruby-head
+jdk:
+  - openjdk7
+  - oraclejdk7
+matrix:
+  exclude:
+    - rvm: 1.9.3
+      jdk: openjdk7
+    - rvm: 2.1.2
+      jdk: openjdk7
+    - rvm: 2.1.3
+      jdk: openjdk7
+    - rvm: ruby-head
+      jdk: openjdk7
+  allow_failures:
+    - rvm: ruby-head
+  fast_finish: true
+sudo: false
+before_install: gem install bundler
+script: bundle exec rspec

data/Gemfile

@@ -5,4 +5,6 @@ gemspec
 
 group :test do
   gem 'rspec', '~> 3.1.0'
+  gem 'timecop', '~> 0.7.1'
+  gem 'coveralls', require: false
 end

data/README.md

@@ -1,5 +1,9 @@
 # Gracefully
 
+[![Build Status](https://travis-ci.org/crowdworks/gracefully.svg?branch=master)](https://travis-ci.org/crowdworks/gracefully)
+[![Coverage Status](https://coveralls.io/repos/crowdworks/gracefully/badge.png?branch=master)](https://coveralls.io/r/crowdworks/gracefully?branch=master)
+[![Code Climate](https://codeclimate.com/github/crowdworks/gracefully/badges/gpa.svg)](https://codeclimate.com/github/crowdworks/gracefully)
+
 ensures features gracefully degrade based on error rate or turnaround time.
 
 ## Installation
@@ -20,7 +24,36 @@ Or install it yourself as:
 
 ## Usage
 
-See `spec/gracefully_spec.rb` for basic usage.
+Set up one instance per feature which is gracefully degradable.
+
+```ruby
+the_feature = Gracefully.
+                degradable_command(retries: 0, allowed_failures: 1) do |a|
+                  if rand < 0.5
+                    'foo'
+                  else
+                    raise 'err1'
+                  end
+                end.
+                fallback_to(retries: 2) do |a|
+                  if rand < 0.5
+                    'bar'
+                  else
+                    raise 'err2'
+                  end
+                end
+
+10.times.map do
+  begin
+    the_feature.call
+  rescue => e
+    e.message
+  end
+end
+#=> ["bar", "bar", "bar", "bar", "bar", "bar", "bar", "bar", "bar", "Tried to get the value of a failure"]
+```
+
+See `spec/gracefully_spec.rb` for more usages.
 
 ## Contributing
 

data/lib/gracefully.rb

@@ -1,10 +1,28 @@
 require "gracefully/version"
-require "gracefully/feature"
-require "gracefully/feature_builder"
+require "gracefully/degradable_command"
+require "gracefully/degradable_command_builder"
 require "gracefully/try"
 
 module Gracefully
-  def self.degrade(feature_name)
-    FeatureBuilder.new(feature_name)
+  def self.degradable_command(*args, &block)
+    DegradableCommandBuilder.new.usually(*args, &block)
+  end
+
+  def self.command(*args, &block)
+    callable, options = Command.normalize_arguments(*args, &block)
+
+    options ||= {}
+
+    if options[:timeout]
+      command(TimedCommand.new(callable, options), options.dup.tap { |h| h.delete(:timeout) })
+    elsif options[:retries]
+      command(RetriedCommand.new(callable, options), options.dup.tap { |h| h.delete(:retries) })
+    elsif options[:allowed_failures]
+      command(ShortCircuitedCommand.new(callable, options), options.dup.tap { |h| h.delete(:allowed_failures) })
+    elsif options[:run_only_if]
+      TogglableCommand.new(callable, options)
+    else
+      Command.new(callable, options)
+    end
   end
 end

data/lib/gracefully/all.rb

@@ -0,0 +1,6 @@
+require 'gracefully'
+
+require_relative 'circuit_breaker'
+require_relative 'retried_command'
+require_relative 'timed_command'
+require_relative 'short_circuited_command'

data/lib/gracefully/circuit_breaker.rb

@@ -0,0 +1,88 @@
+module Gracefully
+  class CircuitBreaker
+    attr_reader :opened_date
+
+    def initialize(*args)
+      if args.size > 0
+        options = args.first
+
+        @try_close_after = options[:try_close_after]
+      end
+
+      @closed = true
+      @health = options && options[:health] || Gracefully::ConsecutiveFailuresBasedHealth.new(become_unhealthy_after_consecutive_failures: 0)
+    end
+
+    def execute(&block)
+      if open? && (@try_close_after.nil? || try_close_period_passed?.!)
+        raise CurrentlyOpenError, "Opened at #{opened_date}"
+      end
+
+      clear_opened_date!
+
+      begin
+        v = block.call
+        mark_success
+        v
+      rescue => e
+        mark_failure
+        raise e
+      end
+    end
+
+    def mark_success
+      @health.mark_success
+
+      update!
+    end
+
+    def mark_failure
+      @health.mark_failure
+
+      update!
+    end
+
+    def open?
+      closed?.!
+    end
+
+    def closed?
+      @closed
+    end
+
+    def try_close_period_passed?
+      opened_date && opened_date + @try_close_after < Time.now
+    end
+
+    def opened_date
+      @opened_date
+    end
+
+    def update!
+      if @health.healthy?
+        close!
+      else
+        open!
+      end
+    end
+
+    def close!
+      @closed = true
+    end
+
+    def open!
+      @closed = false
+      @opened_date = Time.now
+    end
+
+    private
+
+    def clear_opened_date!
+      @opened_date = nil
+    end
+
+    class CurrentlyOpenError < StandardError
+
+    end
+  end
+end

data/lib/gracefully/command.rb

@@ -0,0 +1,23 @@
+module Gracefully
+  class Command
+    def initialize(*args, &block)
+      @callable, @options = Command.normalize_arguments(*args, &block)
+    end
+
+    def self.normalize_arguments(*args, &block)
+      if args.size == 0
+        [block, {}]
+      elsif args.size == 1
+        [block, args.first]
+      elsif args.size == 2
+        args
+      else
+        raise "Invalid number of arguments: #{args.size}"
+      end
+    end
+
+    def call(*args, &block)
+      @callable.call *args, &block
+    end
+  end
+end

data/lib/gracefully/command_disabled_error.rb

@@ -0,0 +1,6 @@
+require_relative 'error'
+
+module Gracefully
+  class CommandDisabledError < ::StandardError
+  end
+end

data/lib/gracefully/consecutive_failures_based_health.rb

@@ -0,0 +1,75 @@
+require_relative 'health'
+require_relative 'counter'
+
+module Gracefully
+  class ConsecutiveFailuresBasedHealth < Health
+    # @param [Hash] args
+    def initialize(args)
+      @healthy_count = 0
+      @unhealthy_count = 0
+      conf = Configuration.new(args)
+      super(state: Healthy.new(conf))
+    end
+
+    class Configuration
+      attr_reader :become_unhealthy_after_consecutive_failures
+
+      def initialize(args)
+        @become_unhealthy_after_consecutive_failures = args[:become_unhealthy_after_consecutive_failures]
+        @counter = args[:counter] || -> { SingletonInMemoryCounter.instance }
+      end
+
+      def counter
+        @counter.call
+      end
+    end
+
+    class Health < Gracefully::Health::State
+    end
+
+    class Healthy < State
+      # @param [Configuration] conf
+      def initialize(conf)
+        @failure_counter = conf.counter
+        @configuration = conf
+      end
+
+      def mark_success
+        self
+      end
+
+      def mark_failure
+        @failure_counter.increment!
+        if @failure_counter.count <= @configuration.become_unhealthy_after_consecutive_failures
+          self
+        else
+          @failure_counter.reset!
+          Unhealthy.new @configuration
+        end
+      end
+
+      def healthy?
+        true
+      end
+    end
+
+    class Unhealthy < State
+      # @param [Configuration] conf
+      def initialize(conf)
+        @configuration = conf
+      end
+
+      def mark_success
+        Healthy.new @configuration
+      end
+
+      def mark_failure
+        self
+      end
+
+      def healthy?
+        false
+      end
+    end
+  end
+end

data/lib/gracefully/counter.rb

@@ -0,0 +1,29 @@
+module Gracefully
+  class Counter
+
+  end
+
+  class SingletonInMemoryCounter
+    def self.instance
+      @instance ||= InMemoryCounter.new
+    end
+  end
+
+  class InMemoryCounter < Counter
+    def initialize
+      @count = 0
+    end
+
+    def reset!
+      @count = 0
+    end
+
+    def increment!
+      @count += 1
+    end
+
+    def count
+      @count
+    end
+  end
+end

data/lib/gracefully/degradable.rb

@@ -0,0 +1,36 @@
+require 'gracefully'
+
+module Gracefully
+  module Degradable
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    def __call_gracefully_degradable_method__(method, *args, &block)
+      self.class.instance_variable_get(:@__gracefully_degradable_methods__)[method].call(self, *args, &block)
+    end
+
+    module ClassMethods
+      def gracefully_degrade(method, options)
+        @__gracefully_degradable_methods__ ||= {}
+
+        fallback_method, fallback_options = options[:fallback].first
+        fallback_options ||= {}
+
+        original_method = "#{method}_without_graceful_degradation"
+
+        @__gracefully_degradable_methods__[method] =
+          Gracefully.degradable_command(options) { |instance, *args, &block|
+            instance.__send__(original_method, *args, &block)
+          }.fallback_to(fallback_options) { |instance, *args, &block|
+            instance.__send__(fallback_method, *args, &block)
+          }
+
+        alias_method original_method, method
+        define_method method do |*args, &block|
+          __call_gracefully_degradable_method__(method, *args, &block)
+        end
+      end
+    end
+  end
+end

data/lib/gracefully/{feature.rb → degradable_command.rb}

@@ -1,13 +1,14 @@
 module Gracefully
-  class Feature
+  class DegradableCommand
     def initialize(args)
-      @name = args[:name]
       @usually = args[:usually]
       @fallback_to = args[:fallback_to]
     end
 
     def call(*args)
-      Try.to { @usually.call *args }.or_else(Try.to { @fallback_to.call *args }).get
+      Try.to { @usually.call *args }.
+        or_else(Try.to { @fallback_to.call *args }).
+        get
     end
   end
 end

data/lib/gracefully/degradable_command_builder.rb

@@ -0,0 +1,23 @@
+module Gracefully
+  class DegradableCommandBuilder
+    def initialize
+    end
+
+    def usually(*args, &block)
+      @usually = Gracefully.command(*args, &block)
+      self
+    end
+
+    def fallback_to(*args, &block)
+      @fallback_to = Gracefully.command(*args, &block)
+
+      build
+    end
+
+    private
+
+    def build
+      DegradableCommand.new(usually: @usually, fallback_to: @fallback_to)
+    end
+  end
+end