semian 0.6.2 → 0.7.0

data/lib/semian/circuit_breaker.rb

@@ -4,6 +4,8 @@ module Semian
 
     def_delegators :@state, :closed?, :open?, :half_open?
 
+    attr_reader :name
+
     def initialize(name, exceptions:, success_threshold:, error_threshold:, error_timeout:, implementation:)
       @name = name.to_sym
       @success_count_threshold = success_threshold
@@ -41,7 +43,7 @@ module Semian
     end
 
     def mark_failed(_error)
-      push_time(@errors, duration: @error_timeout)
+      push_time(@errors)
       if closed?
         open if error_threshold_reached?
       elsif half_open?
@@ -95,14 +97,14 @@ module Semian
     end
 
     def error_timeout_expired?
-      time_ms = @errors.last
-      time_ms && (Time.at(time_ms / 1000) + @error_timeout < Time.now)
+      last_error_time = @errors.last
+      return false unless last_error_time
+      Time.at(last_error_time) + @error_timeout < Time.now
     end
 
-    def push_time(window, duration:, time: Time.now)
-      # The sliding window stores the integer amount of milliseconds since epoch as a timestamp
-      window.shift while window.first && window.first / 1000 + duration < time.to_i
-      window << (time.to_f * 1000).to_i
+    def push_time(window, time: Time.now)
+      window.reject! { |err_time| err_time + @error_timeout < time.to_i }
+      window << time.to_i
     end
 
     def log_state_transition(new_state)

data/lib/semian/mysql2.rb

@@ -24,6 +24,8 @@ module Semian
       /Lost connection to MySQL server/i,
       /MySQL server has gone away/i,
       /Too many connections/i,
+      /closed MySQL connection/i,
+      /MySQL client is not connected/i,
     )
 
     ResourceBusyError = ::Mysql2::ResourceBusyError

data/lib/semian/protected_resource.rb

@@ -2,35 +2,58 @@ module Semian
   class ProtectedResource
     extend Forwardable
 
-    def_delegators :@resource, :destroy, :count, :semid, :tickets, :name
+    def_delegators :@bulkhead, :destroy, :count, :semid, :tickets, :registered_workers
     def_delegators :@circuit_breaker, :reset, :mark_failed, :mark_success, :request_allowed?,
                    :open?, :closed?, :half_open?
 
-    def initialize(resource, circuit_breaker)
-      @resource = resource
+    attr_reader :bulkhead, :circuit_breaker, :name
+
+    def initialize(name, bulkhead, circuit_breaker)
+      @name = name
+      @bulkhead = bulkhead
       @circuit_breaker = circuit_breaker
     end
 
     def destroy
-      @resource.destroy
-      @circuit_breaker.destroy
+      @bulkhead.destroy unless @bulkhead.nil?
+      @circuit_breaker.destroy unless @circuit_breaker.nil?
     end
 
     def acquire(timeout: nil, scope: nil, adapter: nil)
-      @circuit_breaker.acquire do
-        begin
-          @resource.acquire(timeout: timeout) do
-            Semian.notify(:success, self, scope, adapter)
-            yield self
-          end
-        rescue ::Semian::TimeoutError
-          Semian.notify(:busy, self, scope, adapter)
-          raise
+      acquire_circuit_breaker(scope, adapter) do
+        acquire_bulkhead(timeout, scope, adapter) do
+          yield self
+        end
+      end
+    end
+
+    private
+
+    def acquire_circuit_breaker(scope, adapter)
+      if @circuit_breaker.nil?
+        yield self
+      else
+        @circuit_breaker.acquire do
+          yield self
         end
       end
     rescue ::Semian::OpenCircuitError
       Semian.notify(:circuit_open, self, scope, adapter)
       raise
     end
+
+    def acquire_bulkhead(timeout, scope, adapter)
+      if @bulkhead.nil?
+        yield self
+      else
+        @bulkhead.acquire(timeout: timeout) do
+          Semian.notify(:success, self, scope, adapter)
+          yield self
+        end
+      end
+    rescue ::Semian::TimeoutError
+      Semian.notify(:busy, self, scope, adapter)
+      raise
+    end
   end
 end

data/lib/semian/redis.rb

@@ -15,17 +15,19 @@ class Redis
   ResourceBusyError = Class.new(SemianError)
   CircuitOpenError = Class.new(SemianError)
 
-  attr_reader :semian_resource
-
   alias_method :_original_initialize, :initialize
 
   def initialize(*args, &block)
     _original_initialize(*args, &block)
 
-    # This alias is necessary because during a `pipelined` block
-    # the client is replaced by an instance of `Redis::Pipeline` and there is
-    # no way to access the original client.
-    @semian_resource = client.semian_resource
+    # This reference is necessary because during a `pipelined` block the client
+    # is replaced by an instance of `Redis::Pipeline` and there is no way to
+    # access the original client which references the Semian resource.
+    @original_client = client
+  end
+
+  def semian_resource
+    @original_client.semian_resource
   end
 
   def semian_identifier

data/lib/semian/resource.rb

@@ -2,19 +2,31 @@ module Semian
   class Resource #:nodoc:
     attr_reader :tickets, :name
 
-    def initialize(name, tickets:, permissions: 0660, timeout: 0)
+    class << Semian::Resource
+      # Ensure that there can only be one resource of a given type
+      def instance(*args)
+        Semian.resources[args.first] ||= new(*args)
+      end
+    end
+
+    def initialize(name, tickets: nil, quota: nil, permissions: 0660, timeout: 0)
       if Semian.semaphores_enabled?
-        initialize_semaphore(name, tickets, permissions, timeout) if respond_to?(:initialize_semaphore)
+        initialize_semaphore(name, tickets, quota, permissions, timeout) if respond_to?(:initialize_semaphore)
       else
         Semian.issue_disabled_semaphores_warning
       end
       @name = name
-      @tickets = tickets
+    end
+
+    def reset_registered_workers!
     end
 
     def destroy
     end
 
+    def unregister_worker
+    end
+
     def acquire(*)
       yield self
     end
@@ -23,8 +35,20 @@ module Semian
       0
     end
 
+    def tickets
+      0
+    end
+
+    def registered_workers
+      0
+    end
+
     def semid
       0
     end
+
+    def key
+      '0x00000000'
+    end
   end
 end

data/lib/semian/simple_integer.rb

@@ -1,3 +1,5 @@
+require 'thread'
+
 module Semian
   module Simple
     class Integer #:nodoc:
@@ -20,4 +22,17 @@ module Semian
       end
     end
   end
+
+  module ThreadSafe
+    class Integer < Simple::Integer
+      def initialize(*)
+        super
+        @lock = Mutex.new
+      end
+
+      def increment(*)
+        @lock.synchronize { super }
+      end
+    end
+  end
 end

data/lib/semian/simple_sliding_window.rb

@@ -1,9 +1,11 @@
+require 'thread'
+
 module Semian
   module Simple
     class SlidingWindow #:nodoc:
       extend Forwardable
 
-      def_delegators :@window, :size, :pop, :shift, :first, :last
+      def_delegators :@window, :size, :last
       attr_reader :max_size
 
       # A sliding window is a structure that stores the most @max_size recent timestamps
@@ -15,28 +17,51 @@ module Semian
         @window = []
       end
 
-      def resize_to(size)
-        raise ArgumentError.new('size must be larger than 0') if size < 1
-        @max_size = size
-        @window.shift while @window.size > @max_size
-        self
+      def reject!(&block)
+        @window.reject!(&block)
       end
 
       def push(value)
-        @window.shift while @window.size >= @max_size
+        resize_to(@max_size - 1) # make room
         @window << value
         self
       end
-
       alias_method :<<, :push
 
       def clear
         @window.clear
         self
       end
+      alias_method :destroy, :clear
+
+      private
+
+      def resize_to(size)
+        @window = @window.last(size) if @window.size >= size
+      end
+    end
+  end
+
+  module ThreadSafe
+    class SlidingWindow < Simple::SlidingWindow
+      def initialize(*)
+        super
+        @lock = Mutex.new
+      end
+
+      # #size, #last, and #clear are not wrapped in a mutex. For the first two,
+      # the worst-case is a thread-switch at a timing where they'd receive an
+      # out-of-date value--which could happen with a mutex as well.
+      #
+      # As for clear, it's an all or nothing operation. Doesn't matter if we
+      # have the lock or not.
+
+      def reject!(*)
+        @lock.synchronize { super }
+      end
 
-      def destroy
-        clear
+      def push(*)
+        @lock.synchronize { super }
       end
     end
   end

data/lib/semian/simple_state.rb

@@ -40,4 +40,11 @@ module Semian
       end
     end
   end
+
+  module ThreadSafe
+    class State < Simple::State
+      # These operations are already safe for a threaded environment since it's
+      # a simple assignment.
+    end
+  end
 end

data/lib/semian/unprotected_resource.rb

@@ -8,6 +8,10 @@ module Semian
       @name = name
     end
 
+    def registered_workers
+      0
+    end
+
     def tickets
       -1
     end
@@ -51,5 +55,13 @@ module Semian
 
     def mark_success
     end
+
+    def bulkhead
+      nil
+    end
+
+    def circuit_breaker
+      nil
+    end
   end
 end

data/lib/semian/version.rb

@@ -1,3 +1,3 @@
 module Semian
-  VERSION = '0.6.2'
+  VERSION = '0.7.0'
 end

metadata

@@ -1,15 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: semian
 version: !ruby/object:Gem::Version
-  version: 0.6.2
+  version: 0.7.0
 platform: ruby
 authors:
 - Scott Francis
 - Simon Eskildsen
+- Dale Hamel
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-02-16 00:00:00.000000000 Z
+date: 2017-06-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler