stoplight 0.1.0 → 0.2.0

data/lib/stoplight/data_store/redis.rb

@@ -1,72 +1,82 @@
 # 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)
+      def initialize(redis)
+        @redis = redis
       end
 
       def names
-        @redis.scan_each(match: "#{DataStore::KEY_PREFIX}:*:*").map do |key|
-          key[/^#{DataStore::KEY_PREFIX}:(.+):[^:]+$/o, 1]
-        end.uniq
+        @redis.hkeys(thresholds_key)
       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.
+      def purge
+        names
+          .select { |l| failures(l).empty? }
+          .each   { |l| delete(l) }
       end
 
-      def clear_failures(name)
-        @redis.del(failure_key(name))
+      def delete(name)
+        @redis.pipelined do
+          clear_attempts(name)
+          clear_failures(name)
+          @redis.hdel(states_key, name)
+          @redis.hdel(thresholds_key, name)
+        end
       end
 
-      def failures(name)
-        @redis.lrange(failure_key(name), 0, -1)
+      # @group Attempts
+
+      def attempts(name)
+        @redis.hget(attempts_key, name).to_i
       end
 
-      def threshold(name)
-        value = @redis.hget(settings_key(name), 'threshold')
-        Integer(value) if value
+      def record_attempt(name)
+        @redis.hincrby(attempts_key, name, 1)
       end
 
-      def set_threshold(name, threshold)
-        @redis.hset(settings_key(name), 'threshold', threshold)
-        threshold
+      def clear_attempts(name)
+        @redis.hdel(attempts_key, name)
       end
 
-      def record_attempt(name)
-        @redis.incr(attempt_key(name))
+      # @group Failures
+
+      def failures(name)
+        @redis.lrange(failures_key(name), 0, -1)
       end
 
-      def clear_attempts(name)
-        @redis.del(attempt_key(name))
+      def record_failure(name, error)
+        @redis.rpush(failures_key(name), Failure.new(error).to_json)
       end
 
-      def attempts(name)
-        @redis.get(attempt_key(name)).to_i
+      def clear_failures(name)
+        @redis.del(failures_key(name))
       end
 
+      # @group State
+
       def state(name)
-        @redis.hget(settings_key(name), 'state') || DataStore::STATE_UNLOCKED
+        @redis.hget(states_key, name) || STATE_UNLOCKED
       end
 
       def set_state(name, state)
         validate_state!(state)
-        @redis.hset(settings_key(name), 'state', state)
+        @redis.hset(states_key, name, state)
         state
       end
+
+      # @group Threshold
+
+      def threshold(name)
+        value = @redis.hget(thresholds_key, name)
+        Integer(value) if value
+      end
+
+      def set_threshold(name, threshold)
+        @redis.hset(thresholds_key, name, threshold)
+        threshold
+      end
     end
   end
 end

data/lib/stoplight/error.rb

@@ -5,8 +5,6 @@ module Stoplight
     # @return [Class]
     Base = Class.new(StandardError)
     # @return [Class]
-    NoFallback = Class.new(Base)
-    # @return [Class]
-    NoRedis = Class.new(Base)
+    RedLight = Class.new(Base)
   end
 end

data/lib/stoplight/light.rb

@@ -2,9 +2,6 @@
 
 module Stoplight
   class Light
-    # @return [Integer]
-    DEFAULT_THRESHOLD = 3
-
     # @return [Array<Exception>]
     attr_reader :allowed_errors
 
@@ -23,7 +20,7 @@ module Stoplight
     end
 
     # @return [Object]
-    # @raise [Error::NoFallback]
+    # @raise [Error::RedLight]
     # @see #fallback
     # @see #green?
     def run
@@ -32,6 +29,11 @@ module Stoplight
       if green?
         run_code
       else
+        if Stoplight.attempts(name).zero?
+          message = "Switching #{name} stoplight from green to red."
+          Stoplight.notifiers.each { |notifier| notifier.notify(message) }
+        end
+
         run_fallback
       end
     end
@@ -55,17 +57,17 @@ module Stoplight
     # @param threshold [Integer]
     # @return [self]
     def with_threshold(threshold)
-      Stoplight.data_store.set_threshold(name, threshold.to_i)
+      Stoplight.set_threshold(name, threshold.to_i)
       self
     end
 
     # Attribute readers
 
     # @return [Object]
-    # @raise [Error::NoFallback]
+    # @raise [Error::RedLight]
     def fallback
       return @fallback if defined?(@fallback)
-      fail Error::NoFallback
+      fail Error::RedLight
     end
 
     # @return (see Stoplight.green?)
@@ -91,25 +93,25 @@ module Stoplight
 
     def run_code
       result = code.call
-      Stoplight.data_store.clear_failures(name)
+      Stoplight.clear_failures(name)
       result
     rescue => error
       if error_allowed?(error)
-        Stoplight.data_store.clear_failures(name)
+        Stoplight.clear_failures(name)
       else
-        Stoplight.data_store.record_failure(name, error)
+        Stoplight.record_failure(name, error)
       end
 
       raise
     end
 
     def run_fallback
-      Stoplight.data_store.record_attempt(name)
+      Stoplight.record_attempt(name)
       fallback.call
     end
 
     def sync_settings
-      Stoplight.data_store.set_threshold(name, threshold)
+      Stoplight.set_threshold(name, threshold)
     end
   end
 end

data/lib/stoplight/mixin.rb

@@ -0,0 +1,9 @@
+# coding: utf-8
+
+module Stoplight
+  module Mixin
+    def stoplight(name, &block)
+      Stoplight::Light.new(name, &block).run
+    end
+  end
+end

data/lib/stoplight/notifier.rb

@@ -0,0 +1,6 @@
+# coding: utf-8
+
+module Stoplight
+  module Notifier
+  end
+end

data/lib/stoplight/notifier/base.rb

@@ -0,0 +1,11 @@
+# coding: utf-8
+
+module Stoplight
+  module Notifier
+    class Base
+      def notify(_message)
+        fail NotImplementedError
+      end
+    end
+  end
+end

data/lib/stoplight/notifier/hip_chat.rb

@@ -0,0 +1,27 @@
+# coding: utf-8
+
+module Stoplight
+  module Notifier
+    # @note hipchat ~> 1.3.0
+    class HipChat < Base
+      # @param client [HipChat::Client]
+      # @param room [String]
+      # @param options [Hash]
+      def initialize(client, room, options = {})
+        @client = client
+        @room = room
+        @options = default_options.merge(options)
+      end
+
+      def notify(message)
+        @client[@room].send('Stoplight', "@all #{message}", @options)
+      end
+
+      private
+
+      def default_options
+        { color: 'red', notify: true }
+      end
+    end
+  end
+end

data/lib/stoplight/notifier/standard_error.rb

@@ -0,0 +1,11 @@
+# coding: utf-8
+
+module Stoplight
+  module Notifier
+    class StandardError < Base
+      def notify(message)
+        warn(message)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -4,3 +4,7 @@ require 'coveralls'
 Coveralls.wear!
 
 require 'stoplight'
+
+Dir.glob(File.join('.', 'spec', 'support', '**', '*.rb')).each do |filename|
+  require filename
+end

data/spec/stoplight/data_store/base_spec.rb

@@ -9,8 +9,10 @@ describe Stoplight::DataStore::Base do
     attempts
     clear_attempts
     clear_failures
+    delete
     failures
     names
+    purge
     record_attempt
     record_failure
     set_state

data/spec/stoplight/data_store/memory_spec.rb

@@ -3,187 +3,7 @@
 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
+  it_behaves_like 'a data store'
 end