stoplight 0.2.1 → 0.3.0

data/lib/stoplight/data_store/memory.rb

@@ -8,84 +8,128 @@ module Stoplight
       end
 
       def names
-        all_thresholds.keys
+        thresholds.keys
       end
 
-      def purge
+      def clear_stale
         names
-          .select { |l| failures(l).empty? }
-          .each   { |l| delete(l) }
+          .select { |name| get_failures(name).empty? }
+          .each { |name| clear(name) }
+        nil
       end
 
-      def delete(name)
+      def clear(name)
         clear_attempts(name)
         clear_failures(name)
-        all_states.delete(name)
-        all_thresholds.delete(name)
+        clear_state(name)
+        clear_threshold(name)
+        clear_timeout(name)
       end
 
-      # @group Attempts
+      def sync(name)
+        set_threshold(name, get_threshold(name))
+        nil
+      end
+
+      def get_color(name)
+        state = get_state(name)
+        threshold = get_threshold(name)
+        failures = get_failures(name)
+        timeout = get_timeout(name)
+        DataStore.colorize(state, threshold, failures, timeout)
+      end
 
-      def attempts(name)
-        all_attempts[name] || 0
+      def get_attempts(name)
+        attempts[name]
       end
 
       def record_attempt(name)
-        all_attempts[name] ||= 0
-        all_attempts[name] += 1
+        attempts[name] += 1
       end
 
       def clear_attempts(name)
-        all_attempts.delete(name)
+        attempts.delete(name)
+        nil
       end
 
-      # @group Failures
-
-      def failures(name)
-        @data[failures_key(name)] || []
+      def get_failures(name)
+        @data.fetch(DataStore.failures_key(name), DEFAULT_FAILURES)
       end
 
-      def record_failure(name, error)
-        (@data[failures_key(name)] ||= []).push(Failure.new(error))
+      def record_failure(name, failure)
+        DataStore.validate_failure!(failure)
+        @data[DataStore.failures_key(name)] ||= DEFAULT_FAILURES.dup
+        @data[DataStore.failures_key(name)].push(failure)
+        failure
       end
 
       def clear_failures(name)
-        @data.delete(failures_key(name))
+        @data.delete(DataStore.failures_key(name))
+        nil
       end
 
-      # @group State
-
-      def state(name)
-        all_states[name] || STATE_UNLOCKED
+      def get_state(name)
+        states[name]
       end
 
       def set_state(name, state)
-        validate_state!(state)
-        all_states[name] = state
+        DataStore.validate_state!(state)
+        states[name] = state
       end
 
-      # @group Threshold
+      def clear_state(name)
+        states.delete(name)
+        nil
+      end
 
-      def threshold(name)
-        all_thresholds[name]
+      def get_threshold(name)
+        thresholds[name]
       end
 
       def set_threshold(name, threshold)
-        all_thresholds[name] = threshold
+        DataStore.validate_threshold!(threshold)
+        thresholds[name] = threshold
+      end
+
+      def clear_threshold(name)
+        thresholds.delete(name)
+        nil
+      end
+
+      def get_timeout(name)
+        timeouts[name]
+      end
+
+      def set_timeout(name, timeout)
+        DataStore.validate_timeout!(timeout)
+        timeouts[name] = timeout
+      end
+
+      def clear_timeout(name)
+        timeouts.delete(name)
+        nil
       end
 
       private
 
-      def all_attempts
-        @data[attempts_key] ||= {}
+      # @return [Hash{String => Integer}]
+      def attempts
+        @data[DataStore.attempts_key] ||= Hash.new(DEFAULT_ATTEMPTS)
+      end
+
+      # @return [Hash{String => String}]
+      def states
+        @data[DataStore.states_key] ||= Hash.new(DEFAULT_STATE)
       end
 
-      def all_states
-        @data[states_key] ||= {}
+      # @return [Hash{String => Integer}]
+      def thresholds
+        @data[DataStore.thresholds_key] ||= Hash.new(DEFAULT_THRESHOLD)
       end
 
-      def all_thresholds
-        @data[thresholds_key] ||= {}
+      # @return [Hash{String => Integer}]
+      def timeouts
+        @data[DataStore.timeouts_key] ||= Hash.new(DEFAULT_TIMEOUT)
       end
     end
   end

data/lib/stoplight/data_store/redis.rb

@@ -1,4 +1,7 @@
 # coding: utf-8
+# rubocop:disable Metrics/ClassLength
+
+require 'json'
 
 module Stoplight
   module DataStore
@@ -8,75 +11,162 @@ module Stoplight
       end
 
       def names
-        @redis.hkeys(thresholds_key)
+        @redis.hkeys(DataStore.thresholds_key)
       end
 
-      def purge
+      def clear_stale
         names
-          .select { |l| failures(l).empty? }
-          .each   { |l| delete(l) }
+          .select { |name| get_failures(name).empty? }
+          .each { |name| clear(name) }
+        nil
       end
 
-      def delete(name)
+      def clear(name)
         @redis.pipelined do
           clear_attempts(name)
           clear_failures(name)
-          @redis.hdel(states_key, name)
-          @redis.hdel(thresholds_key, name)
+          clear_state(name)
+          clear_threshold(name)
+          clear_timeout(name)
         end
+
+        nil
+      end
+
+      def sync(name)
+        threshold = @redis.hget(DataStore.thresholds_key, name)
+        threshold = normalize_threshold(threshold)
+        @redis.hset(DataStore.thresholds_key, name, threshold)
+        nil
       end
 
-      # @group Attempts
+      def get_color(name)
+        DataStore.colorize(*colorize_args(name))
+      end
 
-      def attempts(name)
-        @redis.hget(attempts_key, name).to_i
+      def get_attempts(name)
+        normalize_attempts(@redis.hget(DataStore.attempts_key, name))
       end
 
       def record_attempt(name)
-        @redis.hincrby(attempts_key, name, 1)
+        @redis.hincrby(DataStore.attempts_key, name, 1)
       end
 
       def clear_attempts(name)
-        @redis.hdel(attempts_key, name)
+        @redis.hdel(DataStore.attempts_key, name)
+        nil
       end
 
-      # @group Failures
-
-      def failures(name)
-        @redis.lrange(failures_key(name), 0, -1)
+      def get_failures(name)
+        normalize_failures(@redis.lrange(DataStore.failures_key(name), 0, -1))
       end
 
-      def record_failure(name, error)
-        @redis.rpush(failures_key(name), Failure.new(error).to_json)
+      def record_failure(name, failure)
+        DataStore.validate_failure!(failure)
+        @redis.rpush(DataStore.failures_key(name), failure.to_json)
+        failure
       end
 
       def clear_failures(name)
-        @redis.del(failures_key(name))
+        @redis.del(DataStore.failures_key(name))
+        nil
       end
 
-      # @group State
-
-      def state(name)
-        @redis.hget(states_key, name) || STATE_UNLOCKED
+      def get_state(name)
+        normalize_state(@redis.hget(DataStore.states_key, name))
       end
 
       def set_state(name, state)
-        validate_state!(state)
-        @redis.hset(states_key, name, state)
+        DataStore.validate_state!(state)
+        @redis.hset(DataStore.states_key, name, state)
         state
       end
 
-      # @group Threshold
+      def clear_state(name)
+        @redis.hdel(DataStore.states_key, name)
+        nil
+      end
 
-      def threshold(name)
-        value = @redis.hget(thresholds_key, name)
-        Integer(value) if value
+      def get_threshold(name)
+        normalize_threshold(@redis.hget(DataStore.thresholds_key, name))
       end
 
       def set_threshold(name, threshold)
-        @redis.hset(thresholds_key, name, threshold)
+        DataStore.validate_threshold!(threshold)
+        @redis.hset(DataStore.thresholds_key, name, threshold)
         threshold
       end
+
+      def clear_threshold(name)
+        @redis.hdel(DataStore.thresholds_key, name)
+        nil
+      end
+
+      def get_timeout(name)
+        normalize_timeout(@redis.hget(DataStore.timeouts_key, name))
+      end
+
+      def set_timeout(name, timeout)
+        DataStore.validate_timeout!(timeout)
+        @redis.hset(DataStore.timeouts_key, name, timeout)
+        timeout
+      end
+
+      def clear_timeout(name)
+        @redis.hdel(DataStore.timeouts_key, name)
+        nil
+      end
+
+      private
+
+      def colorize_args(name)
+        state, threshold, failures, timeout = @redis.pipelined do
+          @redis.hget(DataStore.states_key, name)
+          @redis.hget(DataStore.thresholds_key, name)
+          @redis.lrange(DataStore.failures_key(name), 0, -1)
+          @redis.hget(DataStore.timeouts_key, name)
+        end
+        normalize_colorize_args(state, threshold, failures, timeout)
+      end
+
+      def normalize_colorize_args(state, threshold, failures, timeout)
+        [
+          normalize_state(state),
+          normalize_threshold(threshold),
+          normalize_failures(failures),
+          normalize_timeout(timeout)
+        ]
+      end
+
+      # @param attempts [String, nil]
+      # @return [Integer]
+      def normalize_attempts(attempts)
+        attempts ? attempts.to_i : DEFAULT_ATTEMPTS
+      end
+
+      # @param failures [Array<String>]
+      # @return [Array<Failure>]
+      def normalize_failures(failures)
+        failures.map { |json| Failure.from_json(json) }
+      end
+
+      # @param state [String, nil]
+      # @return [String]
+      def normalize_state(state)
+        state || DEFAULT_STATE
+      end
+
+      # @param threshold [String, nil]
+      # @return [Integer]
+      def normalize_threshold(threshold)
+        threshold ? threshold.to_i : DEFAULT_THRESHOLD
+      end
+
+      # @param timeout [String, nil]
+      # @return [Integer]
+      def normalize_timeout(timeout)
+        timeout ? timeout.to_i : DEFAULT_TIMEOUT
+      end
     end
   end
 end

data/lib/stoplight/error.rb

@@ -4,7 +4,23 @@ module Stoplight
   module Error
     # @return [Class]
     Base = Class.new(StandardError)
+
     # @return [Class]
     RedLight = Class.new(Base)
+
+    # @return [Class]
+    InvalidColor = Class.new(Base)
+
+    # @return [Class]
+    InvalidFailure = Class.new(Base)
+
+    # @return [Class]
+    InvalidState = Class.new(Base)
+
+    # @return [Class]
+    InvalidThreshold = Class.new(Base)
+
+    # @return [Class]
+    InvalidTimeout = Class.new(Base)
   end
 end

data/lib/stoplight/failure.rb

@@ -4,21 +4,34 @@ require 'json'
 
 module Stoplight
   class Failure
-    # @param error [Exception]
-    def initialize(error)
-      @error = error
-      @time = Time.now
-    end
+    # @return [Exception]
+    attr_reader :error
+
+    # @return [Time]
+    attr_reader :time
+
+    def self.from_json(json)
+      h = JSON.parse(json)
 
-    # @return [String]
-    def to_json
-      JSON.dump(to_h)
+      match = /#<(.+): (.+)>/.match(h['error'])
+      error = Object.const_get(match[1]).new(match[2]) if match
+
+      time = Time.parse(h['time'])
+
+      new(error, time)
     end
 
-    private
+    # @param error [Exception]
+    def initialize(error, time = nil)
+      @error = error
+      @time = time || Time.now
+    end
 
-    def to_h
-      { error: @error.inspect, time: @time.inspect }
+    def to_json(*args)
+      {
+        error: @error.inspect,
+        time: time.inspect
+      }.to_json(*args)
     end
   end
 end

data/lib/stoplight/light.rb

@@ -24,17 +24,15 @@ module Stoplight
     # @see #fallback
     # @see #green?
     def run
-      sync_settings
-
-      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
+      Stoplight.data_store.sync(name)
+
+      case color
+      when DataStore::COLOR_GREEN
+        run_green
+      when DataStore::COLOR_YELLOW
+        run_yellow
+      when DataStore::COLOR_RED
+        run_red
       end
     end
 
@@ -57,7 +55,14 @@ module Stoplight
     # @param threshold [Integer]
     # @return [self]
     def with_threshold(threshold)
-      Stoplight.set_threshold(name, threshold.to_i)
+      Stoplight.data_store.set_threshold(name, threshold)
+      self
+    end
+
+    # @param timeout [Integer]
+    # @return [self]
+    def with_timeout(timeout)
+      Stoplight.data_store.set_timeout(name, timeout)
       self
     end
 
@@ -67,51 +72,75 @@ module Stoplight
     # @raise [Error::RedLight]
     def fallback
       return @fallback if defined?(@fallback)
-      fail Error::RedLight
+      fail Error::RedLight, name
     end
 
-    # @return (see Stoplight.green?)
+    # @return (see Stoplight::DataStore::Base#threshold)
+    def threshold
+      Stoplight.data_store.get_threshold(name)
+    end
+
+    # @return (see Stoplight::DataStore::Base#timeout)
+    def timeout
+      Stoplight.data_store.get_timeout(name)
+    end
+
+    # Colors
+
+    # @return (see Stoplight::DataStore::Base#get_color)
+    def color
+      Stoplight.data_store.get_color(name)
+    end
+
+    # @return (see Stoplight::DataStore::Base#green?)
     def green?
-      Stoplight.green?(name)
+      Stoplight.data_store.green?(name)
     end
 
-    # @return (see Stoplight.red?)
-    def red?
-      !green?
+    # @return (see Stoplight::DataStore::Base#yellow?)
+    def yellow?
+      Stoplight.data_store.yellow?(name)
     end
 
-    # @return (see Stoplight.threshold)
-    def threshold
-      Stoplight.threshold(name)
+    # @return (see Stoplight::DataStore::Base#red?)
+    def red?
+      Stoplight.data_store.red?(name)
     end
 
     private
 
-    def error_allowed?(error)
-      allowed_errors.any? { |klass| error.is_a?(klass) }
+    def run_green
+      code.call.tap { Stoplight.data_store.clear_failures(name) }
+    rescue => error
+      handle_error(error)
+      raise
     end
 
-    def run_code
-      result = code.call
-      Stoplight.clear_failures(name)
-      result
-    rescue => error
+    def run_yellow
+      run_green.tap { notify("Switching #{name} from red to green.") }
+    end
+
+    def run_red
+      if Stoplight.data_store.record_attempt(name) == 1
+        notify("Switching #{name} from green to red.")
+      end
+      fallback.call
+    end
+
+    def handle_error(error)
       if error_allowed?(error)
-        Stoplight.clear_failures(name)
+        Stoplight.data_store.clear_failures(name)
       else
-        Stoplight.record_failure(name, error)
+        Stoplight.data_store.record_failure(name, Failure.new(error))
       end
-
-      raise
     end
 
-    def run_fallback
-      Stoplight.record_attempt(name)
-      fallback.call
+    def error_allowed?(error)
+      allowed_errors.any? { |klass| error.is_a?(klass) }
     end
 
-    def sync_settings
-      Stoplight.set_threshold(name, threshold)
+    def notify(message)
+      Stoplight.notifiers.each { |notifier| notifier.notify(message) }
     end
   end
 end