stoplight 0.4.1 → 0.5.0

data/lib/stoplight/default.rb

@@ -0,0 +1,34 @@
+# coding: utf-8
+
+module Stoplight
+  module Default
+    ALLOWED_ERRORS = [
+      NoMemoryError,
+      ScriptError,
+      SecurityError,
+      SignalException,
+      SystemExit,
+      SystemStackError
+    ].freeze
+
+    DATA_STORE = DataStore::Memory.new
+
+    ERROR_NOTIFIER = -> error { warn error }
+
+    FALLBACK = nil
+
+    FORMATTER = lambda do |light, from_color, to_color, error|
+      words = ['Switching', light.name, 'from', from_color, 'to', to_color]
+      words += ['because', error.class, error.message] if error
+      words.join(' ')
+    end
+
+    NOTIFIERS = [
+      Notifier::IO.new($stderr)
+    ].freeze
+
+    THRESHOLD = 3
+
+    TIMEOUT = 60.0
+  end
+end

data/lib/stoplight/error.rb

@@ -2,49 +2,7 @@
 
 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)
-
-    # @return [Class]
-    class BadDataStore < Base
-      # @return [Exception]
-      attr_reader :cause
-
-      # @param cause [Exception]
-      def initialize(cause)
-        super(cause.message)
-        @cause = cause
-      end
-    end
-
-    # @return [Class]
-    class BadNotifier < Base
-      # @return [Exception]
-      attr_reader :cause
-
-      # @param cause [Exception]
-      def initialize(cause)
-        super(cause.message)
-        @cause = cause
-      end
-    end
   end
 end

data/lib/stoplight/failure.rb

@@ -5,48 +5,44 @@ require 'time'
 
 module Stoplight
   class Failure
-    # @return [String]
     attr_reader :error_class
-
-    # @return [String]
     attr_reader :error_message
-
-    # @return [Time]
     attr_reader :time
 
-    # @param error [Exception]
-    def self.create(error)
-      new(error.class.name, error.message)
+    def self.from_error(error)
+      new(error.class.name, error.message, Time.new)
     end
 
-    # @param json [String]
     def self.from_json(json)
-      h = JSON.parse(json)
-      new(
-        h['error']['class'],
-        h['error']['message'],
-        Time.parse(h['time']))
-    rescue => error
-      new(Error::InvalidFailure.name, error.message)
+      object = JSON.parse(json)
+
+      error_class = object['error']['class']
+      error_message = object['error']['message']
+      time = Time.parse(object['time'])
+
+      new(error_class, error_message, time)
     end
 
-    # @param error_class [String]
-    # @param error_message [String]
-    # @param time [Time, nil]
-    def initialize(error_class, error_message, time = nil)
+    def initialize(error_class, error_message, time)
       @error_class = error_class
       @error_message = error_message
-      @time = time || Time.now
+      @time = time
+    end
+
+    def ==(other)
+      error_class == other.error_class &&
+        error_message == other.error_message &&
+        time == other.time
     end
 
-    def to_json(*args)
-      {
+    def to_json
+      JSON.generate(
         error: {
           class: error_class,
           message: error_message
         },
-        time: time.iso8601
-      }.to_json(*args)
+        time: time.strftime('%Y-%m-%dT%H:%M:%S.%N%:z')
+      )
     end
   end
 end

data/lib/stoplight/light.rb

@@ -2,159 +2,74 @@
 
 module Stoplight
   class Light
-    # @return [Array<Exception>]
-    attr_reader :allowed_errors
+    include Runnable
 
-    # @return [Proc]
+    attr_reader :allowed_errors
     attr_reader :code
-
-    # @return [String]
+    attr_reader :data_store
+    attr_reader :error_notifier
+    attr_reader :fallback
     attr_reader :name
+    attr_reader :notifiers
+    attr_reader :threshold
+    attr_reader :timeout
 
-    # @param name [String]
-    # @yield []
-    def initialize(name, &code)
-      @allowed_errors = []
-      @code = code.to_proc
-      @name = name.to_s
+    class << self
+      attr_accessor :default_data_store
+      attr_accessor :default_error_notifier
+      attr_accessor :default_notifiers
     end
 
-    # @return [Object]
-    # @raise [Error::RedLight]
-    # @see #fallback
-    # @see #green?
-    def run
-      sync
+    @default_data_store = Default::DATA_STORE
+    @default_error_notifier = Default::ERROR_NOTIFIER
+    @default_notifiers = Default::NOTIFIERS
 
-      case color
-      when DataStore::COLOR_GREEN
-        run_green
-      when DataStore::COLOR_YELLOW
-        run_yellow
-      when DataStore::COLOR_RED
-        run_red
-      end
-    end
+    def initialize(name, &code)
+      @name = name
+      @code = code
 
-    # Fluent builders
+      @allowed_errors = Default::ALLOWED_ERRORS
+      @data_store = self.class.default_data_store
+      @error_notifier = self.class.default_error_notifier
+      @fallback = Default::FALLBACK
+      @notifiers = self.class.default_notifiers
+      @threshold = Default::THRESHOLD
+      @timeout = Default::TIMEOUT
+    end
 
-    # @param allowed_errors [Array<Exception>]
-    # @return [self]
     def with_allowed_errors(allowed_errors)
-      @allowed_errors = allowed_errors.to_a
+      @allowed_errors = Default::ALLOWED_ERRORS + allowed_errors
       self
     end
 
-    # @yield []
-    # @return [self]
-    def with_fallback(&fallback)
-      @fallback = fallback.to_proc
+    def with_data_store(data_store)
+      @data_store = data_store
       self
     end
 
-    # @param threshold [Integer]
-    # @return [self]
-    def with_threshold(threshold)
-      Stoplight.data_store.set_threshold(name, threshold)
+    def with_error_notifier(&error_notifier)
+      @error_notifier = error_notifier
       self
     end
 
-    # @param timeout [Integer]
-    # @return [self]
-    def with_timeout(timeout)
-      Stoplight.data_store.set_timeout(name, timeout)
+    def with_fallback(&fallback)
+      @fallback = fallback
       self
     end
 
-    # Attribute readers
-
-    # @return [Object]
-    # @raise [Error::RedLight]
-    def fallback
-      return @fallback if defined?(@fallback)
-      fail Error::RedLight, name
-    end
-
-    # @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.data_store.green?(name)
-    end
-
-    # @return (see Stoplight::DataStore::Base#yellow?)
-    def yellow?
-      Stoplight.data_store.yellow?(name)
-    end
-
-    # @return (see Stoplight::DataStore::Base#red?)
-    def red?
-      Stoplight.data_store.red?(name)
-    end
-
-    private
-
-    def run_green
-      code.call.tap { Stoplight.data_store.greenify(name) }
-    rescue => error
-      handle_error(error)
-      raise
-    end
-
-    def run_yellow
-      run_green.tap { notify(DataStore::COLOR_RED, DataStore::COLOR_GREEN) }
-    end
-
-    def run_red
-      if Stoplight.data_store.record_attempt(name) == 1
-        notify(DataStore::COLOR_GREEN, DataStore::COLOR_RED)
-      end
-      fallback.call
-    end
-
-    def handle_error(error)
-      if error_allowed?(error)
-        Stoplight.data_store.greenify(name)
-      else
-        Stoplight.data_store.record_failure(name, Failure.create(error))
-      end
-    end
-
-    def error_allowed?(error)
-      allowed_errors.any? { |klass| error.is_a?(klass) }
+    def with_notifiers(notifiers)
+      @notifiers = notifiers
+      self
     end
 
-    def notify(from_color, to_color)
-      Stoplight.notifiers.each do |notifier|
-        begin
-          notifier.notify(self, from_color, to_color)
-        rescue Error::BadNotifier => error
-          warn(error.cause)
-        end
-      end
+    def with_threshold(threshold)
+      @threshold = threshold
+      self
     end
 
-    def sync
-      Stoplight.data_store.sync(name)
-    rescue Error::BadDataStore => error
-      warn(error.cause)
-      Stoplight.data_store = Stoplight::DataStore::Memory.new
-      retry
+    def with_timeout(timeout)
+      @timeout = timeout
+      self
     end
   end
 end

data/lib/stoplight/light/runnable.rb

@@ -0,0 +1,97 @@
+# coding: utf-8
+
+module Stoplight
+  class Light
+    module Runnable
+      def color
+        failures, state = failures_and_state
+        now = Time.new
+
+        case
+        when state == State::LOCKED_GREEN then Color::GREEN
+        when state == State::LOCKED_RED then Color::RED
+        when failures.size < threshold then Color::GREEN
+        when failures.any? { |f| now - f.time >= timeout } then Color::YELLOW
+        else Color::RED
+        end
+      end
+
+      def run
+        case color
+        when Color::GREEN then run_green
+        when Color::YELLOW then run_yellow
+        else run_red
+        end
+      end
+
+      private
+
+      def run_green
+        on_failure = lambda do |size, error|
+          notify(Color::GREEN, Color::RED, error) if size == threshold
+        end
+        run_code(nil, on_failure)
+      end
+
+      def run_yellow
+        on_success = lambda do |failures|
+          notify(Color::RED, Color::GREEN) unless failures.empty?
+        end
+        run_code(on_success, nil)
+      end
+
+      def run_red
+        fail Error::RedLight, name unless fallback
+        fallback.call(nil)
+      end
+
+      def run_code(on_success, on_failure)
+        result = code.call
+        failures = clear_failures
+        on_success.call(failures) if on_success
+        result
+      rescue => error
+        handle_error(error, on_failure)
+      end
+
+      def handle_error(error, on_failure)
+        fail error if allowed_errors.any? { |klass| error.is_a?(klass) }
+        size = record_failure(error)
+        on_failure.call(size, error) if on_failure
+        fail error unless fallback
+        fallback.call(error)
+      end
+
+      def clear_failures
+        safely([]) { data_store.clear_failures(self) }
+      end
+
+      def failures_and_state
+        safely([[], State::UNLOCKED]) { data_store.get_all(self) }
+      end
+
+      def notify(from_color, to_color, error = nil)
+        notifiers.each do |notifier|
+          safely { notifier.notify(self, from_color, to_color, error) }
+        end
+      end
+
+      def record_failure(error)
+        failure = Failure.from_error(error)
+        safely(0) { data_store.record_failure(self, failure) }
+      end
+
+      def safely(default = nil, &code)
+        return code.call if data_store == Default::DATA_STORE
+
+        self.class.new("#{name}-safely", &code)
+          .with_data_store(Default::DATA_STORE)
+          .with_fallback do |error|
+            error_notifier.call(error) if error
+            default
+          end
+          .run
+      end
+    end
+  end
+end