makara 0.3.5 → 0.3.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 43573a40ca103839cfe03e0194c500ab656e03a6
-  data.tar.gz: e2baf81e7328bfba4d363992aee0e3308df53705
+  metadata.gz: 854be0f8b5615812158cd37511db68cc47310f75
+  data.tar.gz: 8cc3d705dd2d83415a8d4348d9ce2b949d0eb954
 SHA512:
-  metadata.gz: 27dabc4695a384d29c6c41d410e1604020d8c157cd32341a329bbe9a2208efeb5e4b30708398b97cea37df9d990b602da103f5931e22d34aa73c0922f6a9961e
-  data.tar.gz: d8f28626cc7d690d160a86dbc9846a99f6112fa0dba32114e1020103ed0dd1c1276fff2d900c7ca57a0c1b278feac6bed02a604addb83e3e41a70d66800a809d
+  metadata.gz: 8669c261ead2cce40c1ffa8f319f975d162623071f54290fbed54e1a65159b2698c9eab709159cb6f71858b2d32b20ad9996b8472502c91a8086fdb89c08d31a
+  data.tar.gz: 2089f3e36f9add64c5ecdef2634665fde5aa3a2cc94ab4230f9f8099d9c438f7da057b73406b8c8f9abab8c596424ad4cd0deef627fff7831f0c0ca9f9004233

data/CHANGELOG.md

@@ -1,27 +1,95 @@
 # Change Log
 All notable changes to this project will be documented in this file.
 
-## 0.3.0rc2 - 2014-08-05
-### Added
-- allow bypassing of stickiness
+## v0.3.5 - 2016-01-08
 
-## 0.3.0rc2 - 2014-08-05
-### Added
-- add postgres specific tests.
+[Full Changelog](https://github.com/taskrabbit/makara/compare/v0.3.4.rc1...v0.3.5)
 
-### Changed
-- change using methods for matchers to be able to monkey patch them
-- follow AR naming conventions for adapter naming
+Changed
 
-## 0.3.0rc1 - 2014-08-05
-### Removed
-- removed initial connection logic. If a connection can't be made on startup, an error will be thrown rather than the node getting blacklisted.
+- Raise `Makara::Errors::AllConnectionsBlacklisted` on timeout. [#104](https://github.com/taskrabbit/makara/pull/104) Brian Leonard
+
+## v0.3.4.rc1 - 2016-01-06
+
+[Full Changelog](https://github.com/taskrabbit/makara/compare/v0.3.3...v0.3.4.rc1)
+
+Added
+
+- Add `url` to database connections configurations. [#93](https://github.com/taskrabbit/makara/pull/93) Benjamin Fleischer
+
+Changed
+
+- Improve Postgresql compatibility and failover support, also fix [#78](https://github.com/taskrabbit/makara/issues/78), [#79](https://github.com/taskrabbit/makara/issues/79). [#87](https://github.com/taskrabbit/makara/pull/87) Vlad
+- Update README: Specify newrelic_rpm gem versions that will have the performance issue. [#95](https://github.com/taskrabbit/makara/pull/95) Benjamin Fleischer
+
+## v0.3.3 - 2015-05-20
+
+[Full Changelog](https://github.com/taskrabbit/makara/compare/v0.3.2...v0.3.3)
+
+Changed
+
+- A context is local to the curent thread of execution. This will allow you to stick to master safely in a single thread in systems such as sidekiq, for instance. Fix [#83](https://github.com/taskrabbit/makara/issues/83). [#84](https://github.com/taskrabbit/makara/pull/84) Matt Camuto
+
+## v0.3.2 - 2015-05-16
+
+[Full Changelog](https://github.com/taskrabbit/makara/compare/v0.3.1...v0.3.2)
+
+Fixed
+
+- Fix a `ArgumentError: not delegated` error for rails 3. [#82](https://github.com/taskrabbit/makara/pull/82) Eric Saxby
+
+Changed
+
+- Switch log format from `:info` to `:error`. Mike Nelson
+
+## v0.3.1 - 2015-05-08
+
+[Full Changelog](https://github.com/taskrabbit/makara/compare/v0.3.0...v0.3.1)
+
+Changed
+
+- Globally move to multiline matchers. Mike Nelson
+
+Changed
+
+## v0.3.0 - 2015-04-27
+
+[Full Changelog](https://github.com/taskrabbit/makara/compare/v0.3.0.rc3...v0.3.0)
+
+Changed
+
+- Reduce logging noise by using [the same rules as ActiveRecord uses](https://github.com/rails/rails/blob/b06f64c3480cd389d14618540d62da4978918af0/activerecord/lib/active_record/log_subscriber.rb#L33). [#76](https://github.com/taskrabbit/makara/pull/76) Andrew Kane
+
+Fixed
+
+- Fix an issue for postgres that would route all queries to master. [#72](https://github.com/taskrabbit/makara/pull/72) Kali Donovan
+- Fix an edge case which would cause SET operations to send to all connections([#70](https://github.com/taskrabbit/makara/issues/70)). [#80](https://github.com/taskrabbit/makara/pull/80) Michael Amor Righi
+- Fix performance regression with certain verions of [newrelic/rpm](https://github.com/newrelic/rpm)([#59](https://github.com/taskrabbit/makara/issues/59)). [#75](https://github.com/taskrabbit/makara/pull/75) Mike Nelson
+
+## 0.3.0.rc3 - 2014-09-02[YANKED]
+
+[Full Changelog](https://github.com/taskrabbit/makara/compare/v0.3.0.rc2...v0.3.0.rc3)
+
+Added
+- Allow bypassing of stickiness
+
+## 0.3.0.rc2 - 2014-08-05
+Added
+- Add postgres specific tests.
+
+Changed
+- Change using methods for matchers to be able to monkey patch them.
+- Follow AR naming conventions for adapter naming.
+
+## 0.3.0.rc1 - 2014-08-05
+Removed
+- Remove initial connection logic. If a connection can't be made on startup, an error will be thrown rather than the node getting blacklisted.
 
 
 ## 0.2.2 - 2014-04-03
-### Added
-- add logging of makara operations via the Makara::Logger
+Added
+- Add logging of makara operations via the Makara::Logger.
 
-### Changed
-- begin tracing the series of errors associated with blacklisting rather than just the last. This becomes apparent in error messages.
-- fix Rails.cache usage when full environment is not loaded.
+Changed
+- Begin tracing the series of errors associated with blacklisting rather than just the last. This becomes apparent in error messages.
+- Fix Rails.cache usage when full environment is not loaded.

data/README.md

@@ -140,6 +140,7 @@ production:
     # the following are default values
     blacklist_duration: 5
     master_ttl: 5
+    master_strategy: round_robin
     sticky: true
 
     # list your connections with the override values (they're merged into the top-level config)
@@ -161,6 +162,7 @@ The makara subconfig sets up the proxy with a few of its own options, then provi
 * blacklist_duration - the number of seconds a node is blacklisted when a connection failure occurs
 * sticky - if a node should be stuck to once it's used during a specific context
 * master_ttl - how long the master context is persisted. generally, this needs to be longer than any replication lag
+* master_strategy - use a different strategy for picking the "current" node: `failover` will try to keep the same one until it is blacklisted. The default is `round_robin` which will cycle through available ones.
 * connection_error_matchers - array of custom error matchers you want to be handled gracefully by Makara (as in, errors matching these regexes will result in blacklisting the connection as opposed to raising directly).
 
 Connection definitions contain any extra node-specific configurations. If the node should behave as a master you must provide `role: master`. Any previous configurations can be overridden within a specific node's config. Nodes can also contain weights if you'd like to balance usage based on hardware specifications. Optionally, you can provide a name attribute which will be used in sql logging.

data/lib/active_record/connection_adapters/makara_abstract_adapter.rb

@@ -143,21 +143,14 @@ module ActiveRecord
       protected
 
 
-      def appropriate_connection(method_name, args)
+      def appropriate_connection(method_name, args, &block)
         if needed_by_all?(method_name, args)
 
           handling_an_all_execution(method_name) do
-            # slave pool must run first.
-            @slave_pool.provide_each do |con|
-              hijacked do
-                yield con
-              end
-            end
-
-            @master_pool.provide_each do |con|
-              hijacked do
-                yield con
-              end
+            hijacked do
+              # slave pool must run first.
+              @slave_pool.send_to_all(nil, &block)  # just yields to each con
+              @master_pool.send_to_all(nil, &block) # just yields to each con
             end
           end
 

data/lib/makara.rb

@@ -22,4 +22,10 @@ module Makara
     autoload :Subscriber, 'makara/logging/subscriber'
   end
 
+  module Strategies
+    autoload :Abstract,         'makara/strategies/abstract'
+    autoload :RoundRobin,       'makara/strategies/round_robin'
+    autoload :PriorityFailover, 'makara/strategies/priority_failover'
+  end
+
 end

data/lib/makara/error_handler.rb

@@ -31,7 +31,7 @@ module Makara
 
 
     def harshly(e)
-      ::Makara::Logging::Logger.log("[Makara] Harshly handling: #{e}")
+      ::Makara::Logging::Logger.log("[Makara] Harshly handling: #{e}\n#{e.backtrace.join("\n\t")}")
       raise e
     end
 

data/lib/makara/pool.rb

@@ -13,6 +13,7 @@ module Makara
     attr_reader :blacklist_errors
     attr_reader :role
     attr_reader :connections
+    attr_reader :strategy
 
     def initialize(role, proxy)
       @role             = role
@@ -20,8 +21,8 @@ module Makara
       @context          = Makara::Context.get_current
       @connections      = []
       @blacklist_errors = []
-      @current_idx      = 0
       @disabled         = false
+      @strategy         = proxy.strategy_for(role)
     end
 
 
@@ -47,47 +48,55 @@ module Makara
         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
+      @connections << wrapper
+      @strategy.connection_added(wrapper)
 
       wrapper
     end
 
     # send this method to all available nodes
-    def send_to_all(method, *args)
+    # send nil to just yield with each con if there is block
+    def send_to_all(method, *args, &block)
       ret = nil
-      provide_each do |con|
-        ret = con.send(method, *args)
+      one_worked = false # actually found one that worked
+      errors = []
+
+      @connections.each do |con|
+        next if con._makara_blacklisted?
+        begin
+          if block
+            value = @proxy.error_handler.handle(con) do
+              yield con
+            end
+          end
+
+          if method
+            ret = con.send(method, *args)
+          else
+            ret = value
+          end
+          one_worked = true
+        rescue Makara::Errors::BlacklistConnection => e
+          errors.insert(0, e)
+          con._makara_blacklist!
+        end
       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
+      if !one_worked
+        if connection_made?
+          raise Makara::Errors::AllConnectionsBlacklisted.new(self, errors)
+        else
+          raise Makara::Errors::NoConnectionsAvailable.new(@role) unless @disabled
         end
-        return if @current_idx == last_idx
-        last_idx = @current_idx
-      end while @current_idx != idx
+      end
+
+      ret
     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)
+    def provide
+      provided_connection = self.next
 
       # nil implies that it's blacklisted
       if provided_connection
@@ -130,59 +139,17 @@ module Makara
     # 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)
+    def next
+      if @proxy.sticky && Makara::Context.get_current == @context
+        con = @strategy.current
         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
+      con = @strategy.next
+      if con
         @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

@@ -1,6 +1,7 @@
 require 'delegate'
 require 'active_support/core_ext/class/attribute'
 require 'active_support/core_ext/hash/keys'
+require 'active_support/core_ext/string/inflections'
 
 # 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
@@ -11,7 +12,7 @@ require 'active_support/core_ext/hash/keys'
 module Makara
   class Proxy < ::SimpleDelegator
 
-    METHOD_MISSING_SKIP = [ :byebug ]
+    METHOD_MISSING_SKIP = [ :byebug, :puts ]
 
     class_attribute :hijack_methods
     self.hijack_methods = []
@@ -42,6 +43,7 @@ module Makara
 
     attr_reader :error_handler
     attr_reader :sticky
+    attr_reader :config_parser
 
     def initialize(config)
       @config         = config.symbolize_keys
@@ -72,6 +74,17 @@ module Makara
       Makara::Cache.write("makara::#{@master_context}-#{@id}", '1', @ttl) if write_to_cache
     end
 
+    def strategy_for(role)
+      strategy_name = @config_parser.makara_config["#{role}_strategy".to_sym]
+      case strategy_name
+      when 'round_robin', 'roundrobin', nil, ''
+        strategy_name = "::Makara::Strategies::RoundRobin"
+      when 'failover'
+        strategy_name = "::Makara::Strategies::PriorityFailover"
+      end
+      strategy_name.constantize.new(self)
+    end
+
     def method_missing(m, *args, &block)
       if METHOD_MISSING_SKIP.include?(m)
         return super(m, *args, &block)
@@ -125,13 +138,13 @@ module Makara
     end
 
     def any_connection
-      @master_pool.provide(true) do |con|
+      @master_pool.provide do |con|
         yield con
       end
     rescue ::Makara::Errors::AllConnectionsBlacklisted, ::Makara::Errors::NoConnectionsAvailable => e
       begin
         @master_pool.disabled = true
-        @slave_pool.provide(true) do |con|
+        @slave_pool.provide do |con|
           yield con
         end
       ensure

data/lib/makara/strategies/abstract.rb

@@ -0,0 +1,29 @@
+module Makara
+  module Strategies
+    class Abstract
+      attr_reader :pool
+      def initialize(pool)
+        @pool = pool
+        init
+      end
+
+      def init
+        # explicit constructor
+      end
+
+      def connection_added(wrapper)
+        # doesn't have to be implemented
+      end
+
+      def current
+        # it's sticky - give the "curent" one
+        Kernel.raise NotImplementedError
+      end
+
+      def next
+        # rotate to the "next" one if you feel like it
+        Kernel.raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/makara/strategies/priority_failover.rb

@@ -0,0 +1,48 @@
+module Makara
+  module Strategies
+    class PriorityFailover < ::Makara::Strategies::Abstract
+      def init
+        @current_idx = 0
+        @weighted_connections = []
+      end
+
+      def connection_added(wrapper)
+        # insert in weighted order
+        @weighted_connections.each_with_index do |con, index|
+          if wrapper._makara_weight > con._makara_weight
+            @weighted_connections.insert(index, wrapper)
+            return
+          end
+        end
+
+        # else at end
+        @weighted_connections << wrapper
+      end
+
+      def current
+        safe_value(@current_idx)
+      end
+
+      def next
+        @weighted_connections.each_with_index do |con, index|
+          check = safe_value(index)
+          next unless check
+          @current_idx = index
+          return check
+        end
+
+        nil
+      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)
+        con = @weighted_connections[idx]
+        return nil unless con
+        return nil if con._makara_blacklisted?
+        con
+      end
+    end
+  end
+end

data/lib/makara/strategies/round_robin.rb

@@ -0,0 +1,72 @@
+module Makara
+  module Strategies
+    class RoundRobin < ::Makara::Strategies::Abstract
+      def init
+        @current_idx = 0
+        @weighted_connections = []
+      end
+
+      def connection_added(wrapper)
+        # the weight results in N references to the connection, not N connections
+        wrapper._makara_weight.times{ @weighted_connections << wrapper }
+
+        if should_shuffle?
+          # randomize the connections so we don't get peaks and valleys of load
+          @weighted_connections.shuffle!
+          # then start at a random spot in the list
+          @current_idx = rand(@weighted_connections.length)
+        end
+      end
+
+      def current
+        safe_value(@current_idx)
+      end
+
+      def next
+        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 >= @weighted_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 = @weighted_connections[idx]
+        return nil unless con
+        return nil if con._makara_blacklisted?
+
+        if stick
+          @current_idx = idx
+        end
+
+        con
+      end
+
+
+      # stub in test mode to ensure consistency
+      def should_shuffle?
+        true
+      end
+    end
+  end
+end

data/lib/makara/version.rb

@@ -3,7 +3,7 @@ module Makara
 
     MAJOR = 0
     MINOR = 3
-    PATCH = 5
+    PATCH = 6
     PRE = nil
 
     def self.to_s

data/spec/active_record/connection_adapters/makara_mysql2_adapter_spec.rb

@@ -144,7 +144,7 @@ describe 'MakaraMysql2Adapter' do
 
     it 'should send reads to the slave' do
       # ensure the next connection will be the first one
-      connection.slave_pool.instance_variable_set('@current_idx', connection.slave_pool.connections.length)
+      connection.slave_pool.strategy.instance_variable_set('@current_idx', connection.slave_pool.connections.length)
 
       con = connection.slave_pool.connections.first
       expect(con).to receive(:execute).with('SELECT * FROM users').once

data/spec/active_record/connection_adapters/makara_postgresql_adapter_spec.rb

@@ -64,7 +64,7 @@ describe 'MakaraPostgreSQLAdapter' do
 
     it 'should send reads to the slave' do
       # ensure the next connection will be the first one
-      connection.slave_pool.instance_variable_set('@current_idx', connection.slave_pool.connections.length)
+      connection.slave_pool.strategy.instance_variable_set('@current_idx', connection.slave_pool.connections.length)
 
       con = connection.slave_pool.connections.first
       expect(con).to receive(:execute).with('SELECT * FROM users').once

data/spec/pool_spec.rb

@@ -9,18 +9,20 @@ describe Makara::Pool do
   it 'should wrap connections with a ConnectionWrapper as theyre added to the pool' do
     expect(pool.connections).to be_empty
 
-    connection_a = FakeConnection.new
-    connection_a.something = 'a'
+    connection_a = FakeConnection.new(something: 'a')
 
     wrapper_a = pool.add(pool_config){ connection_a }
     wrapper_b = pool.add(pool_config.merge(:weight => 2)){ FakeConnection.new }
 
-    expect(pool.connections.length).to eq(3)
+    connections = pool.connections
+    weighted_connections = pool.strategy.instance_variable_get("@weighted_connections")
+    expect(connections.length).to eq(2)
+    expect(weighted_connections.length).to eq(3)
 
     expect(wrapper_a).to be_a(Makara::ConnectionWrapper)
     expect(wrapper_a.irespondtothis).to eq('hey!')
 
-    as, bs = pool.connections.partition{|c| c.something == 'a'}
+    as, bs = weighted_connections.partition{|c| c.something == 'a'}
     expect(as.length).to eq(1)
     expect(bs.length).to eq(2)
   end
@@ -74,8 +76,8 @@ describe Makara::Pool do
 
   it 'provides the next connection and blacklists' do
 
-    connection_a = FakeConnection.new
-    connection_b = FakeConnection.new
+    connection_a = FakeConnection.new(something: 'a')
+    connection_b = FakeConnection.new(something: 'b')
 
     wrapper_a = pool.add(pool_config){ connection_a }
     wrapper_b = pool.add(pool_config){ connection_b }

data/spec/spec_helper.rb

@@ -30,7 +30,7 @@ RSpec.configure do |config|
   config.before :each do
     Makara::Cache.store = :memory
     change_context
-    allow_any_instance_of(Makara::Pool).to receive(:should_shuffle?){ false }
+    allow_any_instance_of(Makara::Strategies::RoundRobin).to receive(:should_shuffle?){ false }
   end
 
   def change_context

data/spec/strategies/priority_failover_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe Makara::Strategies::PriorityFailover do
+  let(:proxy){ FakeProxy.new({:makara => pool_config.merge(makara_config).merge(:connections => [])}) }
+  let(:pool){ Makara::Pool.new('master', proxy) }
+  let(:pool_config){ {:blacklist_duration => 5} }
+  let(:makara_config) { { :master_strategy => 'failover' } }
+  let(:strategy) { pool.strategy }
+
+  it 'should use the strategy' do
+    expect(pool.strategy).to be_instance_of(Makara::Strategies::PriorityFailover)
+  end
+
+  it 'should take the top weight' do
+    wrapper_a = pool.add(pool_config){ FakeConnection.new(something: 'a') }
+    wrapper_b = pool.add(pool_config){ FakeConnection.new(something: 'b') }
+    wrapper_c = pool.add(pool_config.merge(weight: 2)){ FakeConnection.new(something: 'c') }
+
+    expect(strategy.current.something).to eql('c')
+    expect(strategy.next.something).to eql('c')
+    expect(strategy.next.something).to eql('c')
+  end
+
+  it 'should take given order if no weights' do
+    wrapper_a = pool.add(pool_config){ FakeConnection.new(something: 'a') }
+    wrapper_b = pool.add(pool_config){ FakeConnection.new(something: 'b') }
+    wrapper_c = pool.add(pool_config){ FakeConnection.new(something: 'c') }
+
+    expect(strategy.current.something).to eql('a')
+    expect(strategy.next.something).to eql('a')
+  end
+
+  it 'should handle failover to next one' do
+    wrapper_a = pool.add(pool_config){ FakeConnection.new(something: 'a') }
+    wrapper_b = pool.add(pool_config){ FakeConnection.new(something: 'b') }
+    wrapper_c = pool.add(pool_config){ FakeConnection.new(something: 'c') }
+
+    pool.provide do |connection|
+      if connection == wrapper_a
+        raise Makara::Errors::BlacklistConnection.new(wrapper_a, StandardError.new('failure'))
+      end
+    end
+
+    # skips a
+    expect(strategy.current.something).to eql('b')
+    expect(strategy.next.something).to eql('b')
+  end
+
+end

data/spec/strategies/round_robin_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+describe Makara::Strategies::RoundRobin do
+  let(:proxy){ FakeProxy.new({:makara => pool_config.merge(makara_config).merge(:connections => [])}) }
+  let(:pool){ Makara::Pool.new('test', proxy) }
+  let(:pool_config){ {:blacklist_duration => 5} }
+  let(:makara_config) { {} }
+  let(:strategy) { pool.strategy }
+
+  context 'default config' do
+    it 'should default to the strategy' do
+      expect(pool.strategy).to be_instance_of(Makara::Strategies::RoundRobin)
+    end
+  end
+
+  context 'bad config' do
+    let(:makara_config) { { :test_strategy => 'SomethingElse::Here' } }
+    it 'should raise name error' do
+      expect {
+        pool
+      }.to raise_error(NameError)
+    end
+  end
+
+  context 'given in config' do
+    let(:makara_config) { { :test_strategy => 'round_robin' } }
+    it 'should use the strategy' do
+      expect(pool.strategy).to be_instance_of(Makara::Strategies::RoundRobin)
+    end
+  end
+
+
+  it 'should loop through with weights' do
+    wrapper_a = pool.add(pool_config){ FakeConnection.new(something: 'a') }
+    wrapper_b = pool.add(pool_config){ FakeConnection.new(something: 'b') }
+    wrapper_c = pool.add(pool_config.merge(weight: 2)){ FakeConnection.new(something: 'c') }
+
+    expect(strategy.current.something).to eql('a')
+    expect(strategy.next.something).to eql('b')
+    expect(strategy.current.something).to eql('b')
+    expect(strategy.current.something).to eql('b')
+    expect(strategy.next.something).to eql('c')
+    expect(strategy.next.something).to eql('c')
+    expect(strategy.next.something).to eql('a')
+  end
+
+  it 'should handle failover to next one' do
+    wrapper_a = pool.add(pool_config){ FakeConnection.new(something: 'a') }
+    wrapper_b = pool.add(pool_config){ FakeConnection.new(something: 'b') }
+    wrapper_c = pool.add(pool_config.merge(weight: 2)){ FakeConnection.new(something: 'c') }
+
+    pool.provide do |connection|
+      if connection == wrapper_a
+        raise Makara::Errors::BlacklistConnection.new(wrapper_a, StandardError.new('failure'))
+      end
+    end
+
+    # skips a
+    expect(strategy.current.something).to eql('b')
+    expect(strategy.next.something).to eql('c')
+    expect(strategy.next.something).to eql('c')
+    expect(strategy.next.something).to eql('b')
+  end
+
+
+
+end

data/spec/support/mock_objects.rb

@@ -2,8 +2,6 @@ require 'active_record/connection_adapters/makara_abstract_adapter'
 
 class FakeConnection < Struct.new(:config)
 
-  attr_accessor :something
-
   def ping
     'ping!'
   end
@@ -23,6 +21,10 @@ class FakeConnection < Struct.new(:config)
   def disconnect!
     true
   end
+
+  def something
+    (config || {})[:something]
+  end
 end
 
 class FakeDatabaseAdapter < Struct.new(:config)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: makara
 version: !ruby/object:Gem::Version
-  version: 0.3.5
+  version: 0.3.6
 platform: ruby
 authors:
 - Mike Nelson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-03 00:00:00.000000000 Z
+date: 2016-04-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -73,6 +73,9 @@ files:
 - lib/makara/pool.rb
 - lib/makara/proxy.rb
 - lib/makara/railtie.rb
+- lib/makara/strategies/abstract.rb
+- lib/makara/strategies/priority_failover.rb
+- lib/makara/strategies/round_robin.rb
 - lib/makara/version.rb
 - makara.gemspec
 - spec/active_record/connection_adapters/makara_abstract_adapter_error_handling_spec.rb
@@ -87,6 +90,8 @@ files:
 - spec/pool_spec.rb
 - spec/proxy_spec.rb
 - spec/spec_helper.rb
+- spec/strategies/priority_failover_spec.rb
+- spec/strategies/round_robin_spec.rb
 - spec/support/configurator.rb
 - spec/support/deep_dup.rb
 - spec/support/mock_objects.rb
@@ -132,6 +137,8 @@ test_files:
 - spec/pool_spec.rb
 - spec/proxy_spec.rb
 - spec/spec_helper.rb
+- spec/strategies/priority_failover_spec.rb
+- spec/strategies/round_robin_spec.rb
 - spec/support/configurator.rb
 - spec/support/deep_dup.rb
 - spec/support/mock_objects.rb