stoplight 0.4.1 → 0.5.0

data/lib/stoplight/data_store/base.rb

@@ -3,158 +3,35 @@
 module Stoplight
   module DataStore
     class Base
-      # @return [Array<String>]
       def names
         fail NotImplementedError
       end
 
-      def clear_stale
+      def get_all(_light)
         fail NotImplementedError
       end
 
-      # @param _name [String]
-      def clear(_name)
+      def get_failures(_light)
         fail NotImplementedError
       end
 
-      # @param _name [String]
-      def sync(_name)
+      def record_failure(_light, _failure)
         fail NotImplementedError
       end
 
-      # @param _name [String]
-      def greenify(_name)
+      def clear_failures(_light)
         fail NotImplementedError
       end
 
-      # @group Colors
-
-      # @param name [String]
-      # @return [Boolean]
-      def green?(name)
-        color = get_color(name)
-        DataStore.validate_color!(color)
-        color == COLOR_GREEN
-      end
-
-      # @param name [String]
-      # @return [Boolean]
-      def yellow?(name)
-        color = get_color(name)
-        DataStore.validate_color!(color)
-        color == COLOR_YELLOW
-      end
-
-      # @param name [String]
-      # @return [Boolean]
-      def red?(name)
-        color = get_color(name)
-        DataStore.validate_color!(color)
-        color == COLOR_RED
-      end
-
-      # @param _name [String]
-      # @return [String]
-      def get_color(_name)
-        fail NotImplementedError
-      end
-
-      # @group Attempts
-
-      # @param _name [String]
-      # @return [Integer]
-      def get_attempts(_name)
-        fail NotImplementedError
-      end
-
-      # @param _name [String]
-      # @return [Integer]
-      def record_attempt(_name)
-        fail NotImplementedError
-      end
-
-      # @param _name [String]
-      def clear_attempts(_name)
-        fail NotImplementedError
-      end
-
-      # @group Failures
-
-      # @param _name [String]
-      # @return [Array<Failure>]
-      def get_failures(_name)
-        fail NotImplementedError
-      end
-
-      # @param _name [String]
-      # @param _failure [Failure]
-      # @return [Failure]
-      def record_failure(_name, _failure)
-        fail NotImplementedError
-      end
-
-      # @param _name [String]
-      def clear_failures(_name)
-        fail NotImplementedError
-      end
-
-      # @group States
-
-      # @param _name [String]
-      # @return [String]
-      def get_state(_name)
-        fail NotImplementedError
-      end
-
-      # @param _name [String]
-      # @param _state [String]
-      # @return [String]
-      def set_state(_name, _state)
-        fail NotImplementedError
-      end
-
-      # @param _name [String]
-      def clear_state(_name)
-        fail NotImplementedError
-      end
-
-      # @group Thresholds
-
-      # @param _name [String]
-      # @return [Integer]
-      def get_threshold(_name)
-        fail NotImplementedError
-      end
-
-      # @param _name [String]
-      # @param _threshold [Integer]
-      # @return [Integer]
-      def set_threshold(_name, _threshold)
-        fail NotImplementedError
-      end
-
-      # @param _name [String]
-      def clear_threshold(_name)
-        fail NotImplementedError
-      end
-
-      # @group Timeouts
-
-      # @param _name [String]
-      # @return [Integer]
-      def get_timeout(_name)
+      def get_state(_light)
         fail NotImplementedError
       end
 
-      # @param _name [String]
-      # @param _timeout [Integer]
-      # @return [Integer]
-      def set_timeout(_name, _timeout)
+      def set_state(_light, _state)
         fail NotImplementedError
       end
 
-      # @param _name [String]
-      def clear_timeout(_name)
+      def clear_state(_light)
         fail NotImplementedError
       end
     end

data/lib/stoplight/data_store/memory.rb

@@ -8,126 +8,51 @@ module Stoplight
       end
 
       def names
-        thresholds.keys
+        (all_failures.keys + all_states.keys).uniq
       end
 
-      def clear_stale
-        names
-          .select { |name| get_failures(name).empty? }
-          .each { |name| clear(name) }
+      def get_all(light)
+        [get_failures(light), get_state(light)]
       end
 
-      def clear(name)
-        clear_attempts(name)
-        clear_failures(name)
-        clear_state(name)
-        clear_threshold(name)
-        clear_timeout(name)
+      def get_failures(light)
+        all_failures[light.name] || []
       end
 
-      def sync(name)
-        set_threshold(name, get_threshold(name))
+      def record_failure(light, failure)
+        failures = get_failures(light).unshift(failure).first(light.threshold)
+        all_failures[light.name] = failures
+        failures.size
       end
 
-      def greenify(name)
-        clear_attempts(name)
-        clear_failures(name)
+      def clear_failures(light)
+        failures = get_failures(light)
+        all_failures.delete(light.name)
+        failures
       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)
+      def get_state(light)
+        all_states[light.name] || State::UNLOCKED
       end
 
-      def get_attempts(name)
-        attempts[name]
+      def set_state(light, state)
+        all_states[light.name] = state
       end
 
-      def record_attempt(name)
-        attempts[name] += 1
-      end
-
-      def clear_attempts(name)
-        attempts.delete(name)
-      end
-
-      def get_failures(name)
-        @data.fetch(DataStore.failures_key(name), DEFAULT_FAILURES)
-      end
-
-      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(DataStore.failures_key(name))
-      end
-
-      def get_state(name)
-        states[name]
-      end
-
-      def set_state(name, state)
-        DataStore.validate_state!(state)
-        states[name] = state
-      end
-
-      def clear_state(name)
-        states.delete(name)
-      end
-
-      def get_threshold(name)
-        thresholds[name]
-      end
-
-      def set_threshold(name, threshold)
-        DataStore.validate_threshold!(threshold)
-        thresholds[name] = threshold
-      end
-
-      def clear_threshold(name)
-        thresholds.delete(name)
-      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)
+      def clear_state(light)
+        state = get_state(light)
+        all_states.delete(light.name)
+        state
       end
 
       private
 
-      # @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
-
-      # @return [Hash{String => Integer}]
-      def thresholds
-        @data[DataStore.thresholds_key] ||= Hash.new(DEFAULT_THRESHOLD)
+      def all_failures
+        @data['failures'] ||= {}
       end
 
-      # @return [Hash{String => Integer}]
-      def timeouts
-        @data[DataStore.timeouts_key] ||= Hash.new(DEFAULT_TIMEOUT)
+      def all_states
+        @data['states'] ||= {}
       end
     end
   end

data/lib/stoplight/data_store/redis.rb

@@ -1,171 +1,113 @@
 # coding: utf-8
-# rubocop:disable Metrics/ClassLength
-
-require 'json'
 
 module Stoplight
   module DataStore
     class Redis < Base
+      KEY_PREFIX = 'stoplight'.freeze
+      KEY_SEPARATOR = ':'.freeze
+
       def initialize(redis)
         @redis = redis
       end
 
       def names
-        @redis.hkeys(DataStore.thresholds_key)
-      end
-
-      def clear_stale
-        names
-          .select { |name| get_failures(name).empty? }
-          .each { |name| clear(name) }
-      end
+        state_names = @redis.hkeys(states_key)
 
-      def clear(name)
-        @redis.pipelined do
-          clear_attempts(name)
-          clear_failures(name)
-          clear_state(name)
-          clear_threshold(name)
-          clear_timeout(name)
+        pattern = key('failures', '*')
+        failure_names = @redis.scan_each(match: pattern).to_a.map do |key|
+          key.split(KEY_SEPARATOR).last
         end
-      end
 
-      def sync(name)
-        threshold = @redis.hget(DataStore.thresholds_key, name)
-        threshold = normalize_threshold(threshold)
-        @redis.hset(DataStore.thresholds_key, name, threshold)
-      rescue ::Redis::BaseError => error
-        raise Error::BadDataStore, error
+        (state_names + failure_names).uniq
       end
 
-      def greenify(name)
-        @redis.pipelined do
-          clear_attempts(name)
-          clear_failures(name)
+      def get_all(light)
+        failures, state = @redis.multi do
+          query_failures(light)
+          @redis.hget('stoplight:states', light.name)
         end
-      end
-
-      def get_color(name)
-        DataStore.colorize(*colorize_args(name))
-      end
 
-      def get_attempts(name)
-        normalize_attempts(@redis.hget(DataStore.attempts_key, name))
+        [
+          normalize_failures(failures, light.error_notifier),
+          normalize_state(state)
+        ]
       end
 
-      def record_attempt(name)
-        @redis.hincrby(DataStore.attempts_key, name, 1)
+      def get_failures(light)
+        normalize_failures(query_failures(light), light.error_notifier)
       end
 
-      def clear_attempts(name)
-        @redis.hdel(DataStore.attempts_key, name)
-      end
+      def record_failure(light, failure)
+        size, _ = @redis.multi do
+          @redis.lpush(failures_key(light), failure.to_json)
+          @redis.ltrim(failures_key(light), 0, light.threshold - 1)
+        end
 
-      def get_failures(name)
-        normalize_failures(@redis.lrange(DataStore.failures_key(name), 0, -1))
+        size
       end
 
-      def record_failure(name, failure)
-        DataStore.validate_failure!(failure)
-        @redis.rpush(DataStore.failures_key(name), failure.to_json)
-        failure
-      end
+      def clear_failures(light)
+        failures, _ = @redis.multi do
+          query_failures(light)
+          @redis.del(failures_key(light))
+        end
 
-      def clear_failures(name)
-        @redis.del(DataStore.failures_key(name))
+        normalize_failures(failures, light.error_notifier)
       end
 
-      def get_state(name)
-        normalize_state(@redis.hget(DataStore.states_key, name))
+      def get_state(light)
+        query_state(light) || State::UNLOCKED
       end
 
-      def set_state(name, state)
-        DataStore.validate_state!(state)
-        @redis.hset(DataStore.states_key, name, state)
+      def set_state(light, state)
+        @redis.hset(states_key, light.name, state)
         state
       end
 
-      def clear_state(name)
-        @redis.hdel(DataStore.states_key, name)
-      end
-
-      def get_threshold(name)
-        normalize_threshold(@redis.hget(DataStore.thresholds_key, name))
-      end
-
-      def set_threshold(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)
-      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_state(light)
+        state, _ = @redis.multi do
+          query_state(light)
+          @redis.hdel(states_key, light.name)
+        end
 
-      def clear_timeout(name)
-        @redis.hdel(DataStore.timeouts_key, name)
+        normalize_state(state)
       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)
+      def query_failures(light)
+        @redis.lrange(failures_key(light), 0, -1)
       end
 
-      def normalize_colorize_args(state, threshold, failures, timeout)
-        [
-          normalize_state(state),
-          normalize_threshold(threshold),
-          normalize_failures(failures),
-          normalize_timeout(timeout)
-        ]
+      def normalize_failures(failures, error_notifier)
+        failures.map do |json|
+          begin
+            Failure.from_json(json)
+          rescue => error
+            error_notifier.call(error)
+            Failure.from_error(error)
+          end
+        end
       end
 
-      # @param attempts [String, nil]
-      # @return [Integer]
-      def normalize_attempts(attempts)
-        attempts ? attempts.to_i : DEFAULT_ATTEMPTS
+      def query_state(light)
+        @redis.hget(states_key, light.name)
       end
 
-      # @param failures [Array<String>]
-      # @return [Array<Failure>]
-      def normalize_failures(failures)
-        failures.map { |json| Failure.from_json(json) }
+      def normalize_state(state)
+        state || State::UNLOCKED
       end
 
-      # @param state [String, nil]
-      # @return [String]
-      def normalize_state(state)
-        state || DEFAULT_STATE
+      def failures_key(light)
+        key('failures', light.name)
       end
 
-      # @param threshold [String, nil]
-      # @return [Integer]
-      def normalize_threshold(threshold)
-        threshold ? threshold.to_i : DEFAULT_THRESHOLD
+      def states_key
+        key('states')
       end
 
-      # @param timeout [String, nil]
-      # @return [Integer]
-      def normalize_timeout(timeout)
-        timeout ? timeout.to_i : DEFAULT_TIMEOUT
+      def key(*pieces)
+        ([KEY_PREFIX] + pieces).join(KEY_SEPARATOR)
       end
     end
   end