makara 0.3.5

data/lib/makara/pool.rb

@@ -0,0 +1,188 @@
+require 'active_support/core_ext/hash/keys'
+
+# Wraps a collection of similar connections and chooses which one to use
+# Uses the Makara::Context to determine if the connection needs rotation.
+# Provides convenience methods for accessing underlying connections
+
+module Makara
+  class Pool
+
+    # there are cases when we understand the pool is busted and we essentially want to skip
+    # all execution
+    attr_accessor :disabled
+    attr_reader :blacklist_errors
+    attr_reader :role
+    attr_reader :connections
+
+    def initialize(role, proxy)
+      @role             = role
+      @proxy            = proxy
+      @context          = Makara::Context.get_current
+      @connections      = []
+      @blacklist_errors = []
+      @current_idx      = 0
+      @disabled         = false
+    end
+
+
+    def completely_blacklisted?
+      @connections.each do |connection|
+        return false unless connection._makara_blacklisted?
+      end
+      true
+    end
+
+
+    # Add a connection to this pool, wrapping the connection with a Makara::ConnectionWrapper
+    def add(config)
+      config[:name] ||= "#{@role}/#{@connections.length + 1}"
+
+      connection = yield
+
+      # already wrapped because of initial error
+      if connection.is_a?(Makara::ConnectionWrapper)
+        connection.config = config # to add :name
+        wrapper = connection
+      else
+        wrapper = Makara::ConnectionWrapper.new(@proxy, connection, config)
+      end
+
+
+      # the weight results in N references to the connection, not N connections
+      wrapper._makara_weight.times{ @connections << wrapper }
+
+      if should_shuffle?
+        # randomize the connections so we don't get peaks and valleys of load
+        @connections.shuffle!
+
+        # then start at a random spot in the list
+        @current_idx = rand(@connections.length)
+      end
+
+      wrapper
+    end
+
+    # send this method to all available nodes
+    def send_to_all(method, *args)
+      ret = nil
+      provide_each do |con|
+        ret = con.send(method, *args)
+      end
+      ret
+    end
+
+    # provide all available nodes to the given block
+    def provide_each
+      idx = @current_idx
+      last_idx = nil
+      begin
+        provide(false) do |con|
+          yield con
+        end
+        return if @current_idx == last_idx
+        last_idx = @current_idx
+      end while @current_idx != idx
+    end
+
+    # Provide a connection that is not blacklisted and connected. Handle any errors
+    # that may occur within the block.
+    def provide(allow_stickiness = true)
+      provided_connection = self.next(allow_stickiness)
+
+      # nil implies that it's blacklisted
+      if provided_connection
+
+        value = @proxy.error_handler.handle(provided_connection) do
+          yield provided_connection
+        end
+
+        @blacklist_errors = []
+
+        value
+
+      # if we've made any connections within this pool, we should report the blackout.
+      elsif connection_made?
+        err = Makara::Errors::AllConnectionsBlacklisted.new(self, @blacklist_errors)
+        @blacklist_errors = []
+        raise err
+      else
+        raise Makara::Errors::NoConnectionsAvailable.new(@role) unless @disabled
+      end
+
+    # when a connection causes a blacklist error within the provided block, we blacklist it then retry
+    rescue Makara::Errors::BlacklistConnection => e
+      @blacklist_errors.insert(0, e)
+      provided_connection._makara_blacklist!
+      retry
+    end
+
+
+
+    protected
+
+
+    # have we connected to any of the underlying connections.
+    def connection_made?
+      @connections.any?(&:_makara_connected?)
+    end
+
+
+    # Get the next non-blacklisted connection. If the proxy is setup
+    # to be sticky, provide back the current connection assuming it is
+    # not blacklisted.
+    def next(allow_stickiness = true)
+
+      if allow_stickiness && @proxy.sticky && Makara::Context.get_current == @context
+        con = safe_value(@current_idx)
+        return con if con
+      end
+
+      idx = @current_idx
+      begin
+
+        idx = next_index(idx)
+
+        # if we've looped all the way around, return our safe value
+        return safe_value(idx, true) if idx == @current_idx
+
+      # while our current safe value is dangerous
+      end while safe_value(idx).nil?
+
+      # store our current spot and return our safe value
+      safe_value(idx, true)
+    end
+
+
+    # next index within the bounds of the connections array
+    # loop around when the end is hit
+    def next_index(idx)
+      idx = idx + 1
+      idx = 0 if idx >= @connections.length
+      idx
+    end
+
+
+    # return the connection if it's not blacklisted
+    # otherwise return nil
+    # optionally, store the position and context we're returning
+    def safe_value(idx, stick = false)
+      con = @connections[idx]
+      return nil unless con
+      return nil if con._makara_blacklisted?
+
+      if stick
+        @current_idx = idx
+        @context = Makara::Context.get_current
+      end
+
+      con
+    end
+
+
+    # stub in test mode to ensure consistency
+    def should_shuffle?
+      true
+    end
+
+  end
+end

data/lib/makara/proxy.rb

@@ -0,0 +1,277 @@
+require 'delegate'
+require 'active_support/core_ext/class/attribute'
+require 'active_support/core_ext/hash/keys'
+
+# The entry point of Makara. It contains a master and slave pool which are chosen based on the invocation
+# being proxied. Makara::Proxy implementations should declare which methods they are hijacking via the
+# `hijack_method` class method.
+# While debugging this class use prepend debug calls with Kernel. (Kernel.byebug for example)
+# to avoid getting into method_missing stuff.
+
+module Makara
+  class Proxy < ::SimpleDelegator
+
+    METHOD_MISSING_SKIP = [ :byebug ]
+
+    class_attribute :hijack_methods
+    self.hijack_methods = []
+
+    class << self
+      def hijack_method(*method_names)
+        self.hijack_methods = self.hijack_methods || []
+        self.hijack_methods |= method_names
+
+        method_names.each do |method_name|
+          define_method method_name do |*args, &block|
+            appropriate_connection(method_name, args) do |con|
+              con.send(method_name, *args, &block)
+            end
+          end
+        end
+      end
+
+      def send_to_all(*method_names)
+        method_names.each do |method_name|
+          define_method method_name do |*args|
+            send_to_all method_name, *args
+          end
+        end
+      end
+    end
+
+
+    attr_reader :error_handler
+    attr_reader :sticky
+
+    def initialize(config)
+      @config         = config.symbolize_keys
+      @config_parser  = Makara::ConfigParser.new(@config)
+      @id             = @config_parser.id
+      @ttl            = @config_parser.makara_config[:master_ttl]
+      @sticky         = @config_parser.makara_config[:sticky]
+      @hijacked       = false
+      @error_handler  ||= ::Makara::ErrorHandler.new
+      @skip_sticking  = false
+      instantiate_connections
+      super(config)
+    end
+
+    def without_sticking
+      @skip_sticking = true
+      yield
+    ensure
+      @skip_sticking = false
+    end
+
+    def hijacked?
+      @hijacked
+    end
+
+    def stick_to_master!(write_to_cache = true)
+      @master_context = Makara::Context.get_current
+      Makara::Cache.write("makara::#{@master_context}-#{@id}", '1', @ttl) if write_to_cache
+    end
+
+    def method_missing(m, *args, &block)
+      if METHOD_MISSING_SKIP.include?(m)
+        return super(m, *args, &block)
+      end
+
+      any_connection do |con|
+        if con.respond_to?(m)
+          con.public_send(m, *args, &block)
+        elsif con.respond_to?(m, true)
+          con.__send__(m, *args, &block)
+        else
+          super(m, *args, &block)
+        end
+      end
+    end
+
+    class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
+      def respond_to#{RUBY_VERSION.to_s =~ /^1.8/ ? nil : '_missing'}?(m, include_private = false)
+        any_connection do |con|
+          con._makara_connection.respond_to?(m, true)
+        end
+      end
+    RUBY_EVAL
+
+    def graceful_connection_for(config)
+      fake_wrapper = Makara::ConnectionWrapper.new(self, nil, config)
+
+      @error_handler.handle(fake_wrapper) do
+        connection_for(config)
+      end
+    rescue Makara::Errors::BlacklistConnection => e
+      fake_wrapper.initial_error = e.original_error
+      fake_wrapper
+    end
+
+    def disconnect!
+      send_to_all(:disconnect!)
+    rescue ::Makara::Errors::AllConnectionsBlacklisted, ::Makara::Errors::NoConnectionsAvailable
+      # all connections are already down, nothing to do here
+    end
+
+    protected
+
+
+    def send_to_all(method_name, *args)
+      # slave pool must run first to allow for slave-->master failover without running operations on master twice.
+      handling_an_all_execution(method_name) do
+        @slave_pool.send_to_all method_name, *args
+        @master_pool.send_to_all method_name, *args
+      end
+    end
+
+    def any_connection
+      @master_pool.provide(true) do |con|
+        yield con
+      end
+    rescue ::Makara::Errors::AllConnectionsBlacklisted, ::Makara::Errors::NoConnectionsAvailable => e
+      begin
+        @master_pool.disabled = true
+        @slave_pool.provide(true) do |con|
+          yield con
+        end
+      ensure
+        @master_pool.disabled = false
+      end
+    end
+
+    # based on the method_name and args, provide the appropriate connection
+    # mark this proxy as hijacked so the underlying connection does not attempt to check
+    # with back with this proxy.
+    def appropriate_connection(method_name, args)
+      appropriate_pool(method_name, args) do |pool|
+        pool.provide do |connection|
+          hijacked do
+            yield connection
+          end
+        end
+      end
+    end
+
+
+    # master or slave
+    def appropriate_pool(method_name, args)
+
+      # for testing purposes
+      pool = _appropriate_pool(method_name, args)
+
+      yield pool
+
+    rescue ::Makara::Errors::AllConnectionsBlacklisted, ::Makara::Errors::NoConnectionsAvailable => e
+      if pool == @master_pool
+        @master_pool.connections.each(&:_makara_whitelist!)
+        @slave_pool.connections.each(&:_makara_whitelist!)
+        Kernel.raise e
+      else
+        @master_pool.blacklist_errors << e
+        retry
+      end
+    end
+
+    def _appropriate_pool(method_name, args)
+      # the args provided absolutely need master
+      if needs_master?(method_name, args)
+        stick_to_master(method_name, args)
+        @master_pool
+
+      # in this context, we've already stuck to master
+      elsif Makara::Context.get_current == @master_context
+        @master_pool
+
+      # the previous context stuck us to master
+      elsif previously_stuck_to_master?
+
+        # we're only on master because of the previous context so
+        # behave like we're sticking to master but store the current context
+        stick_to_master(method_name, args, false)
+        @master_pool
+
+      # all slaves are down (or empty)
+      elsif @slave_pool.completely_blacklisted?
+        stick_to_master(method_name, args)
+        @master_pool
+
+      # yay! use a slave
+      else
+        @slave_pool
+      end
+    end
+
+    # do these args require a master connection
+    def needs_master?(method_name, args)
+      true
+    end
+
+
+    def hijacked
+      @hijacked = true
+      yield
+    ensure
+      @hijacked = false
+    end
+
+
+    def previously_stuck_to_master?
+      return false unless @sticky
+      !!Makara::Cache.read("makara::#{Makara::Context.get_previous}-#{@id}")
+    end
+
+
+    def stick_to_master(method_name, args, write_to_cache = true)
+      # if we're already stuck to master, don't bother doing it again
+      return if @master_context == Makara::Context.get_current
+
+      # check to see if we're configured, bypassed, or some custom implementation has input
+      return unless should_stick?(method_name, args)
+
+      # do the sticking
+      stick_to_master!(write_to_cache)
+    end
+
+
+    # if we are configured to be sticky and we aren't bypassing stickiness
+    def should_stick?(method_name, args)
+      @sticky && !@skip_sticking
+    end
+
+
+    # use the config parser to generate a master and slave pool
+    def instantiate_connections
+      @master_pool = Makara::Pool.new('master', self)
+      @config_parser.master_configs.each do |master_config|
+        @master_pool.add master_config.merge(@config_parser.makara_config) do
+          graceful_connection_for(master_config)
+        end
+      end
+
+      @slave_pool = Makara::Pool.new('slave', self)
+      @config_parser.slave_configs.each do |slave_config|
+        @slave_pool.add slave_config.merge(@config_parser.makara_config) do
+          graceful_connection_for(slave_config)
+        end
+      end
+    end
+
+    def handling_an_all_execution(method_name)
+      yield
+    rescue ::Makara::Errors::NoConnectionsAvailable => e
+      if e.role == 'master'
+        Kernel.raise ::Makara::Errors::NoConnectionsAvailable.new('master and slave')
+      end
+      @slave_pool.disabled = true
+      yield
+    ensure
+      @slave_pool.disabled = false
+    end
+
+
+    def connection_for(config)
+      Kernel.raise NotImplementedError
+    end
+
+  end
+end