stoplight 0.1.0

data/lib/stoplight/data_store/redis.rb

@@ -0,0 +1,72 @@
+# coding: utf-8
+
+begin
+  require 'redis'
+  REDIS_LOADED = true
+rescue LoadError
+  REDIS_LOADED = false
+end
+
+module Stoplight
+  module DataStore
+    class Redis < Base
+      def initialize(*args)
+        fail Error::NoRedis unless REDIS_LOADED
+
+        @redis = ::Redis.new(*args)
+      end
+
+      def names
+        @redis.scan_each(match: "#{DataStore::KEY_PREFIX}:*:*").map do |key|
+          key[/^#{DataStore::KEY_PREFIX}:(.+):[^:]+$/o, 1]
+        end.uniq
+      end
+
+      def record_failure(name, error)
+        failure = Failure.new(error)
+        @redis.rpush(failure_key(name), failure.to_json)
+        # TODO: Trim failures (think ring buffer). Probably in a multi block.
+      end
+
+      def clear_failures(name)
+        @redis.del(failure_key(name))
+      end
+
+      def failures(name)
+        @redis.lrange(failure_key(name), 0, -1)
+      end
+
+      def threshold(name)
+        value = @redis.hget(settings_key(name), 'threshold')
+        Integer(value) if value
+      end
+
+      def set_threshold(name, threshold)
+        @redis.hset(settings_key(name), 'threshold', threshold)
+        threshold
+      end
+
+      def record_attempt(name)
+        @redis.incr(attempt_key(name))
+      end
+
+      def clear_attempts(name)
+        @redis.del(attempt_key(name))
+      end
+
+      def attempts(name)
+        @redis.get(attempt_key(name)).to_i
+      end
+
+      def state(name)
+        @redis.hget(settings_key(name), 'state') || DataStore::STATE_UNLOCKED
+      end
+
+      def set_state(name, state)
+        validate_state!(state)
+        @redis.hset(settings_key(name), 'state', state)
+        state
+      end
+    end
+  end
+end

data/lib/stoplight/error.rb

@@ -0,0 +1,12 @@
+# coding: utf-8
+
+module Stoplight
+  module Error
+    # @return [Class]
+    Base = Class.new(StandardError)
+    # @return [Class]
+    NoFallback = Class.new(Base)
+    # @return [Class]
+    NoRedis = Class.new(Base)
+  end
+end

data/lib/stoplight/failure.rb

@@ -0,0 +1,24 @@
+# coding: utf-8
+
+require 'json'
+
+module Stoplight
+  class Failure
+    # @param error [Exception]
+    def initialize(error)
+      @error = error
+      @time = Time.now
+    end
+
+    # @return [String]
+    def to_json
+      JSON.dump(to_h)
+    end
+
+    private
+
+    def to_h
+      { error: @error.inspect, time: @time }
+    end
+  end
+end

data/lib/stoplight/light.rb

@@ -0,0 +1,115 @@
+# coding: utf-8
+
+module Stoplight
+  class Light
+    # @return [Integer]
+    DEFAULT_THRESHOLD = 3
+
+    # @return [Array<Exception>]
+    attr_reader :allowed_errors
+
+    # @return [Proc]
+    attr_reader :code
+
+    # @return [String]
+    attr_reader :name
+
+    # @param name [String]
+    # @yield []
+    def initialize(name, &code)
+      @allowed_errors = []
+      @code = code.to_proc
+      @name = name.to_s
+    end
+
+    # @return [Object]
+    # @raise [Error::NoFallback]
+    # @see #fallback
+    # @see #green?
+    def run
+      sync_settings
+
+      if green?
+        run_code
+      else
+        run_fallback
+      end
+    end
+
+    # Fluent builders
+
+    # @param allowed_errors [Array<Exception>]
+    # @return [self]
+    def with_allowed_errors(allowed_errors)
+      @allowed_errors = allowed_errors.to_a
+      self
+    end
+
+    # @yield []
+    # @return [self]
+    def with_fallback(&fallback)
+      @fallback = fallback.to_proc
+      self
+    end
+
+    # @param threshold [Integer]
+    # @return [self]
+    def with_threshold(threshold)
+      Stoplight.data_store.set_threshold(name, threshold.to_i)
+      self
+    end
+
+    # Attribute readers
+
+    # @return [Object]
+    # @raise [Error::NoFallback]
+    def fallback
+      return @fallback if defined?(@fallback)
+      fail Error::NoFallback
+    end
+
+    # @return (see Stoplight.green?)
+    def green?
+      Stoplight.green?(name)
+    end
+
+    # @return (see Stoplight.red?)
+    def red?
+      !green?
+    end
+
+    # @return (see Stoplight.threshold)
+    def threshold
+      Stoplight.threshold(name)
+    end
+
+    private
+
+    def error_allowed?(error)
+      allowed_errors.any? { |klass| error.is_a?(klass) }
+    end
+
+    def run_code
+      result = code.call
+      Stoplight.data_store.clear_failures(name)
+      result
+    rescue => error
+      if error_allowed?(error)
+        Stoplight.data_store.clear_failures(name)
+      else
+        Stoplight.data_store.record_failure(name, error)
+      end
+
+      raise
+    end
+
+    def run_fallback
+      Stoplight.data_store.record_attempt(name)
+      fallback.call
+    end
+
+    def sync_settings
+      Stoplight.data_store.set_threshold(name, threshold)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+# coding: utf-8
+
+require 'coveralls'
+Coveralls.wear!
+
+require 'stoplight'

data/spec/stoplight/data_store/base_spec.rb

@@ -0,0 +1,31 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+describe Stoplight::DataStore::Base do
+  subject(:data_store) { described_class.new }
+
+  %w(
+    attempts
+    clear_attempts
+    clear_failures
+    failures
+    names
+    record_attempt
+    record_failure
+    set_state
+    set_threshold
+    state
+    threshold
+  ).each do |method|
+    it "responds to #{method}" do
+      expect(data_store).to respond_to(method)
+    end
+
+    it "does not implement #{method}" do
+      args = [nil] * data_store.method(method).arity
+      expect { data_store.public_send(method, *args) }.to raise_error(
+        NotImplementedError)
+    end
+  end
+end

data/spec/stoplight/data_store/memory_spec.rb

@@ -0,0 +1,189 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+describe Stoplight::DataStore::Memory do
+  let(:error) { error_klass.new }
+  let(:error_klass) { Class.new(StandardError) }
+  let(:name) { SecureRandom.hex }
+  let(:state) { Stoplight::DataStore::STATE_LOCKED_GREEN }
+  let(:threshold) { rand(10) }
+
+  subject(:data_store) { described_class.new }
+
+  describe '#attempts' do
+    subject(:result) { data_store.attempts(name) }
+
+    it 'is zero' do
+      expect(result).to eql(0)
+    end
+
+    context 'with an attempt' do
+      before { data_store.record_attempt(name) }
+
+      it 'is one' do
+        expect(result).to eql(1)
+      end
+    end
+  end
+
+  describe '#clear_attempts' do
+    subject(:result) { data_store.clear_attempts(name) }
+
+    it 'returns nil' do
+      expect(result).to be_nil
+    end
+
+    context 'with an attempt' do
+      before { data_store.record_attempt(name) }
+
+      it 'returns one' do
+        expect(result).to eql(1)
+      end
+
+      it 'clears attempts' do
+        result
+        expect(data_store.attempts(name)).to eql(0)
+      end
+    end
+  end
+
+  describe '#clear_failures' do
+    subject(:result) { data_store.clear_failures(name) }
+
+    it 'returns nil' do
+      expect(result).to be nil
+    end
+
+    context 'with a failure' do
+      before { data_store.record_failure(name, error) }
+
+      it 'returns the failures' do
+        failures = data_store.failures(name)
+        expect(result).to eql(failures)
+      end
+
+      it 'clears the failures' do
+        result
+        expect(data_store.failures(name)).to be_empty
+      end
+    end
+  end
+
+  describe '#threshold' do
+    subject(:result) { data_store.threshold(name) }
+
+    it 'is nil' do
+      expect(result).to be nil
+    end
+
+    context 'with a threshold' do
+      before { data_store.set_threshold(name, threshold) }
+
+      it 'returns the threshold' do
+        expect(result).to eql(threshold)
+      end
+    end
+  end
+
+  describe '#failures' do
+    subject(:result) { data_store.failures(name) }
+
+    it 'is an array' do
+      expect(result).to be_an(Array)
+    end
+
+    it 'is empty' do
+      expect(result).to be_empty
+    end
+
+    context 'with a failure' do
+      before { data_store.record_failure(name, error) }
+
+      it 'returns the failures' do
+        expect(result.size).to eql(1)
+      end
+    end
+  end
+
+  describe '#names' do
+    subject(:result) { data_store.names }
+
+    it 'is an array' do
+      expect(result).to be_an(Array)
+    end
+
+    it 'is empty' do
+      expect(result).to be_empty
+    end
+
+    context 'with a name' do
+      before { data_store.settings(name) }
+
+      it 'includes the name' do
+        expect(result).to include(name)
+      end
+    end
+  end
+
+  describe '#record_attempt' do
+    subject(:result) { data_store.record_attempt(name) }
+
+    it 'records the attempt' do
+      result
+      expect(data_store.attempts(name)).to eql(1)
+    end
+  end
+
+  describe '#record_failure' do
+    subject(:result) { data_store.record_failure(name, error) }
+
+    it 'returns the failures' do
+      expect(result).to eql(data_store.failures(name))
+    end
+
+    it 'logs the failure' do
+      expect(result.size).to eql(1)
+    end
+  end
+
+  describe '#set_threshold' do
+    subject(:result) { data_store.set_threshold(name, threshold) }
+
+    it 'returns the threshold' do
+      expect(result).to eql(threshold)
+    end
+  end
+
+  describe '#set_state' do
+    subject(:result) { data_store.set_state(name, state) }
+
+    it 'returns the state' do
+      expect(result).to eql(state)
+    end
+
+    context 'with an invalid state' do
+      let(:state) { SecureRandom.hex }
+
+      it 'raises an error' do
+        expect { result }.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  describe '#state' do
+    subject(:result) { data_store.state(name) }
+
+    it 'returns the default state' do
+      expect(result).to eql(Stoplight::DataStore::STATE_UNLOCKED)
+    end
+
+    context 'with a custom state' do
+      before { data_store.set_state(name, state) }
+
+      it 'returns the state' do
+        expect(result).to eql(state)
+      end
+    end
+  end
+end