semian_extension 0.11.4.1

data/lib/semian/net_http.rb

@@ -0,0 +1,117 @@
+require 'semian/adapter'
+require 'net/http'
+
+module Net
+  ProtocolError.include(::Semian::AdapterError)
+
+  class SemianError < ::Net::ProtocolError
+    def initialize(semian_identifier, *args)
+      super(*args)
+      @semian_identifier = semian_identifier
+    end
+  end
+
+  ResourceBusyError = Class.new(SemianError)
+  CircuitOpenError = Class.new(SemianError)
+end
+
+module Semian
+  module NetHTTP
+    include Semian::Adapter
+
+    ResourceBusyError = ::Net::ResourceBusyError
+    CircuitOpenError = ::Net::CircuitOpenError
+
+    class SemianConfigurationChangedError < RuntimeError
+      def initialize(msg = "Cannot re-initialize semian_configuration")
+        super
+      end
+    end
+
+    def semian_identifier
+      "nethttp_#{raw_semian_options[:name]}"
+    end
+
+    DEFAULT_ERRORS = [
+      ::Timeout::Error, # includes ::Net::ReadTimeout and ::Net::OpenTimeout
+      ::SocketError,
+      ::Net::HTTPBadResponse,
+      ::Net::HTTPHeaderSyntaxError,
+      ::Net::ProtocolError,
+      ::EOFError,
+      ::IOError,
+      ::SystemCallError, # includes ::Errno::EINVAL, ::Errno::ECONNRESET, ::Errno::ECONNREFUSED, ::Errno::ETIMEDOUT, and more
+    ].freeze # Net::HTTP can throw many different errors, this tries to capture most of them
+
+    class << self
+      attr_accessor :exceptions
+      attr_reader :semian_configuration
+
+      def semian_configuration=(configuration)
+        raise Semian::NetHTTP::SemianConfigurationChangedError unless @semian_configuration.nil?
+        @semian_configuration = configuration
+      end
+
+      def retrieve_semian_configuration(host, port)
+        @semian_configuration.call(host, port) if @semian_configuration.respond_to?(:call)
+      end
+
+      def reset_exceptions
+        self.exceptions = Semian::NetHTTP::DEFAULT_ERRORS.dup
+      end
+    end
+
+    Semian::NetHTTP.reset_exceptions
+
+    def raw_semian_options
+      @raw_semian_options ||= begin
+        @raw_semian_options = Semian::NetHTTP.retrieve_semian_configuration(address, port)
+        @raw_semian_options = @raw_semian_options.dup unless @raw_semian_options.nil?
+      end
+    end
+
+    def resource_exceptions
+      Semian::NetHTTP.exceptions
+    end
+
+    def disabled?
+      raw_semian_options.nil?
+    end
+
+    def connect
+      return super if disabled?
+      acquire_semian_resource(adapter: :http, scope: :connection) { super }
+    end
+
+    def transport_request(*)
+      return super if disabled?
+      acquire_semian_resource(adapter: :http, scope: :query) do
+        handle_error_responses(super)
+      end
+    end
+
+    def with_resource_timeout(timeout)
+      prev_read_timeout = read_timeout
+      prev_open_timeout = open_timeout
+      begin
+        self.read_timeout = timeout
+        self.open_timeout = timeout
+        yield
+      ensure
+        self.read_timeout = prev_read_timeout
+        self.open_timeout = prev_open_timeout
+      end
+    end
+
+    private
+
+    def handle_error_responses(result)
+      if raw_semian_options.fetch(:open_circuit_server_errors, false)
+        semian_resource.mark_failed(result) if result.is_a?(::Net::HTTPServerError)
+      end
+      result
+    end
+  end
+end
+
+Net::HTTP.prepend(Semian::NetHTTP)

data/lib/semian/platform.rb

@@ -0,0 +1,16 @@
+module Semian
+  extend self
+
+  # Determines if Semian supported on the current platform.
+  def sysv_semaphores_supported?
+    /linux/.match(RUBY_PLATFORM)
+  end
+
+  def semaphores_enabled?
+    !disabled? && sysv_semaphores_supported?
+  end
+
+  def disabled?
+    ENV['SEMIAN_SEMAPHORES_DISABLED'] || ENV['SEMIAN_DISABLED']
+  end
+end

data/lib/semian/protected_resource.rb

@@ -0,0 +1,65 @@
+module Semian
+  class ProtectedResource
+    extend Forwardable
+
+    def_delegators :@bulkhead, :destroy, :count, :semid, :tickets, :registered_workers
+    def_delegators :@circuit_breaker, :reset, :mark_failed, :mark_success, :request_allowed?,
+                   :open?, :closed?, :half_open?
+
+    attr_reader :bulkhead, :circuit_breaker, :name
+    attr_accessor :updated_at
+
+    def initialize(name, bulkhead, circuit_breaker)
+      @name = name
+      @bulkhead = bulkhead
+      @circuit_breaker = circuit_breaker
+      @updated_at = Time.now
+    end
+
+    def destroy
+      @bulkhead.destroy unless @bulkhead.nil?
+      @circuit_breaker.destroy unless @circuit_breaker.nil?
+    end
+
+    def acquire(timeout: nil, scope: nil, adapter: nil, resource: nil)
+      acquire_circuit_breaker(scope, adapter, resource) do
+        acquire_bulkhead(timeout, scope, adapter) do |_, wait_time|
+          Semian.notify(:success, self, scope, adapter, wait_time)
+          yield self
+        end
+      end
+    end
+
+    def in_use?
+      circuit_breaker&.in_use? || bulkhead&.in_use?
+    end
+
+    private
+
+    def acquire_circuit_breaker(scope, adapter, resource)
+      if @circuit_breaker.nil?
+        yield self
+      else
+        @circuit_breaker.acquire(resource) 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, 0
+      else
+        @bulkhead.acquire(timeout: timeout) do |wait_time|
+          yield self, wait_time
+        end
+      end
+    rescue ::Semian::TimeoutError
+      Semian.notify(:busy, self, scope, adapter)
+      raise
+    end
+  end
+end

data/lib/semian/rails.rb

@@ -0,0 +1,7 @@
+require 'active_record/connection_adapters/abstract_adapter'
+
+class ActiveRecord::ConnectionAdapters::AbstractAdapter
+  def semian_resource
+    @connection.semian_resource
+  end
+end

data/lib/semian/redis.rb

@@ -0,0 +1,143 @@
+require 'semian/adapter'
+require 'redis'
+
+class Redis
+  Redis::BaseConnectionError.include(::Semian::AdapterError)
+  ::Errno::EINVAL.include(::Semian::AdapterError)
+
+  class SemianError < Redis::BaseConnectionError
+    def initialize(semian_identifier, *args)
+      super(*args)
+      @semian_identifier = semian_identifier
+    end
+  end
+
+  class OutOfMemoryError < Redis::CommandError
+    include ::Semian::AdapterError
+  end
+
+  ResourceBusyError = Class.new(SemianError)
+  CircuitOpenError = Class.new(SemianError)
+  ResolveError = Class.new(SemianError)
+
+  alias_method :_original_initialize, :initialize
+
+  def initialize(*args, &block)
+    _original_initialize(*args, &block)
+
+    # 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
+    semian_resource.name
+  end
+
+  # Compatibility with old versions of the Redis gem
+  unless instance_methods.include?(:_client)
+    def _client
+      @client
+    end
+  end
+end
+
+module Semian
+  module Redis
+    include Semian::Adapter
+
+    ResourceBusyError = ::Redis::ResourceBusyError
+    CircuitOpenError = ::Redis::CircuitOpenError
+    ResolveError = ::Redis::ResolveError
+
+    # The naked methods are exposed as `raw_query` and `raw_connect` for instrumentation purpose
+    def self.included(base)
+      base.send(:alias_method, :raw_io, :io)
+      base.send(:remove_method, :io)
+
+      base.send(:alias_method, :raw_connect, :connect)
+      base.send(:remove_method, :connect)
+    end
+
+    def semian_identifier
+      @semian_identifier ||= begin
+        name = semian_options && semian_options[:name]
+        name ||= "#{location}/#{db}"
+        :"redis_#{name}"
+      end
+    end
+
+    def io(&block)
+      acquire_semian_resource(adapter: :redis, scope: :query) do
+        reply = raw_io(&block)
+        raise_if_out_of_memory(reply)
+        reply
+      end
+    end
+
+    def connect
+      acquire_semian_resource(adapter: :redis, scope: :connection) do
+        begin
+          raw_connect
+        rescue SocketError, RuntimeError => e
+          raise ResolveError.new(semian_identifier) if dns_resolve_failure?(e.cause || e)
+          raise
+        end
+      end
+    end
+
+    def with_resource_timeout(temp_timeout)
+      timeout = options[:timeout]
+      connect_timeout = options[:connect_timeout]
+      read_timeout = options[:read_timeout]
+      write_timeout = options[:write_timeout]
+
+      begin
+        connection.timeout = temp_timeout if connected?
+        options[:timeout] = Float(temp_timeout),
+        options[:connect_timeout] = Float(temp_timeout)
+        options[:read_timeout] = Float(temp_timeout)
+        options[:write_timeout] = Float(temp_timeout)
+        yield
+      ensure
+        options[:timeout] = timeout
+        options[:connect_timeout] = connect_timeout
+        options[:read_timeout] = read_timeout
+        options[:write_timeout] = write_timeout
+        connection.timeout = self.timeout if connected?
+      end
+    end
+
+    private
+
+    def resource_exceptions
+      [
+        ::Redis::BaseConnectionError,
+        ::Errno::EINVAL, # Hiredis bug: https://github.com/redis/hiredis-rb/issues/21
+        ::Redis::OutOfMemoryError,
+      ]
+    end
+
+    def raw_semian_options
+      return options[:semian] if options.key?(:semian)
+      return options['semian'.freeze] if options.key?('semian'.freeze)
+    end
+
+    def raise_if_out_of_memory(reply)
+      return unless reply.is_a?(::Redis::CommandError)
+      return unless reply.message =~ /OOM command not allowed when used memory > 'maxmemory'\.\s*\z/
+      raise ::Redis::OutOfMemoryError.new(reply.message)
+    end
+
+    def dns_resolve_failure?(e)
+      e.to_s.match?(/(can't resolve)|(name or service not known)|(nodename nor servname provided, or not known)|(failure in name resolution)/i)
+    end
+  end
+end
+
+::Redis::Client.include(Semian::Redis)

data/lib/semian/resource.rb

@@ -0,0 +1,65 @@
+module Semian
+  class Resource #:nodoc:
+    attr_reader :tickets, :name
+
+    class << Semian::Resource
+      # Ensure that there can only be one resource of a given type
+      def instance(name, **kwargs)
+        Semian.resources[name] ||= ProtectedResource.new(name, new(name, **kwargs), nil)
+      end
+    end
+
+    def initialize(name, tickets: nil, quota: nil, permissions: Semian.default_permissions, timeout: 0)
+      unless name.is_a?(String) || name.is_a?(Symbol)
+        raise TypeError, "name must be a string or symbol, got: #{name.class}"
+      end
+
+      if Semian.semaphores_enabled?
+        if respond_to?(:initialize_semaphore)
+          initialize_semaphore("#{Semian.namespace}#{name}", tickets, quota, permissions, timeout)
+        end
+      else
+        Semian.issue_disabled_semaphores_warning
+      end
+      @name = name
+    end
+
+    def reset_registered_workers!
+    end
+
+    def destroy
+    end
+
+    def unregister_worker
+    end
+
+    def acquire(*)
+      wait_time = 0
+      yield wait_time
+    end
+
+    def count
+      0
+    end
+
+    def tickets
+      0
+    end
+
+    def registered_workers
+      0
+    end
+
+    def semid
+      0
+    end
+
+    def key
+      '0x00000000'
+    end
+
+    def in_use?
+      false
+    end
+  end
+end

data/lib/semian/simple_integer.rb

@@ -0,0 +1,38 @@
+require 'thread'
+
+module Semian
+  module Simple
+    class Integer #:nodoc:
+      attr_accessor :value
+
+      def initialize
+        reset
+      end
+
+      def increment(val = 1)
+        @value += val
+      end
+
+      def reset
+        @value = 0
+      end
+
+      def destroy
+        reset
+      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

@@ -0,0 +1,68 @@
+require 'thread'
+
+module Semian
+  module Simple
+    class SlidingWindow #:nodoc:
+      extend Forwardable
+
+      def_delegators :@window, :size, :last
+      attr_reader :max_size
+
+      # A sliding window is a structure that stores the most @max_size recent timestamps
+      # like this: if @max_size = 4, current time is 10, @window =[5,7,9,10].
+      # Another push of (11) at 11 sec would make @window [7,9,10,11], shifting off 5.
+
+      def initialize(max_size:)
+        @max_size = max_size
+        @window = []
+      end
+
+      def reject!(&block)
+        @window.reject!(&block)
+      end
+
+      def push(value)
+        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 push(*)
+        @lock.synchronize { super }
+      end
+    end
+  end
+end

data/lib/semian/simple_state.rb

@@ -0,0 +1,50 @@
+module Semian
+  module Simple
+    class State #:nodoc:
+      def initialize
+        reset
+      end
+
+      attr_reader :value
+
+      def open?
+        value == :open
+      end
+
+      def closed?
+        value == :closed
+      end
+
+      def half_open?
+        value == :half_open
+      end
+
+      def open!
+        @value = :open
+      end
+
+      def close!
+        @value = :closed
+      end
+
+      def half_open!
+        @value = :half_open
+      end
+
+      def reset
+        close!
+      end
+
+      def destroy
+        reset
+      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/typhoeus.rb

@@ -0,0 +1,103 @@
+require 'semian/adapter'
+require 'typhoeus'
+require 'uri'
+
+module Typhoeus
+  Errors::TyphoeusError.include(::Semian::AdapterError)
+
+  class SemianError < ::Typhoeus::Errors::TyphoeusError
+    def initialize(semian_identifier, *args)
+      super(*args)
+      @semian_identifier = semian_identifier
+    end
+  end
+
+  ResourceBusyError = Class.new(SemianError)
+  CircuitOpenError = Class.new(SemianError)
+end
+
+module Semian
+  module Typhoeus
+    include Semian::Adapter
+
+    ResourceBusyError = ::Typhoeus::ResourceBusyError
+    CircuitOpenError = ::Typhoeus::CircuitOpenError
+
+    class SemianConfigurationChangedError < RuntimeError
+      def initialize(msg = "Cannot re-initialize semian_configuration")
+        super
+      end
+    end
+
+    def semian_identifier
+      "typhoeus_#{raw_semian_options[:name]}"
+    end
+
+    DEFAULT_ERRORS = [
+      ::Timeout::Error,
+      ::SocketError,
+      ::Typhoeus::Errors::NoStub,
+      ::Typhoeus::Errors::TyphoeusError,
+      ::EOFError,
+      ::IOError,
+      ::SystemCallError, # includes ::Errno::EINVAL, ::Errno::ECONNRESET, ::Errno::ECONNREFUSED, ::Errno::ETIMEDOUT, and more
+    ].freeze # Typhoeus can throw many different errors, this tries to capture most of them
+
+    class << self
+      attr_accessor :exceptions
+      attr_reader :semian_configuration
+
+      def semian_configuration=(configuration)
+        raise Semian::Typhoeus::SemianConfigurationChangedError unless @semian_configuration.nil?
+        @semian_configuration = configuration
+      end
+
+      def retrieve_semian_configuration(host, port)
+        @semian_configuration.call(host, port) if @semian_configuration.respond_to?(:call)
+      end
+
+      def reset_exceptions
+        self.exceptions = Semian::Typhoeus::DEFAULT_ERRORS.dup
+      end
+    end
+
+    Semian::Typhoeus.reset_exceptions
+
+    def raw_semian_options
+      @raw_semian_options ||= begin
+        uri = URI.parse(url)
+        @raw_semian_options = Semian::Typhoeus.retrieve_semian_configuration(uri.host, uri.port)
+        @raw_semian_options = @raw_semian_options.dup unless @raw_semian_options.nil?
+      end
+    end
+
+    def resource_exceptions
+      Semian::Typhoeus.exceptions
+    end
+
+    def disabled?
+      raw_semian_options.nil?
+    end
+
+    def run
+      return super if disabled?
+
+      acquire_semian_resource(adapter: :typhoeus, scope: :query) { handle_error_responses(super) }
+    end
+
+    private
+
+    def handle_error_responses(result)
+      semian_resource.mark_failed(TyphoeusError.new(result.return_message)) if !result.success?
+      result
+    end
+  end
+end
+
+class TyphoeusError < StandardError
+  def initialize(msg)
+    super(msg)
+  end
+end
+
+Typhoeus::Request.prepend(Semian::Typhoeus)