makara 0.3.8 → 0.5.0

data/spec/pool_spec.rb

@@ -5,6 +5,7 @@ describe Makara::Pool do
   let(:proxy){ FakeProxy.new({:makara => pool_config.merge(:connections => [])}) }
   let(:pool){ Makara::Pool.new('test', proxy) }
   let(:pool_config){ {:blacklist_duration => 5} }
+  let(:master_pool){ Makara::Pool.new('master', proxy) }
 
   it 'should wrap connections with a ConnectionWrapper as theyre added to the pool' do
     expect(pool.connections).to be_empty
@@ -157,4 +158,27 @@ describe Makara::Pool do
 
   end
 
+  it 'should error out while blacklisted in transaction' do
+    wrapper_a = master_pool.add(pool_config){ FakeConnection.new(open_transactions: 1) }
+    master_pool.add(pool_config){ FakeConnection.new }
+    expect {
+      master_pool.provide do |connection|
+        if connection == wrapper_a
+          raise Makara::Errors::BlacklistConnection.new(wrapper_a, StandardError.new('failure'))
+        end
+      end
+    }.to raise_error(Makara::Errors::BlacklistedWhileInTransaction)
+  end
+
+  it 'skips blacklisted connections in master pool when not in transaction' do
+    wrapper_a = master_pool.add(pool_config){ FakeConnection.new(open_transactions: 0) }
+    master_pool.add(pool_config){ FakeConnection.new }
+    master_pool.provide do |connection|
+      if connection == wrapper_a
+        raise Makara::Errors::BlacklistConnection.new(wrapper_a, StandardError.new('failure'))
+      end
+    end
+    10.times{ master_pool.provide{|connection| expect(connection).not_to eq(wrapper_a) } }
+  end
+
 end

data/spec/proxy_spec.rb

@@ -41,20 +41,57 @@ describe Makara::Proxy do
     expect(proxy.irespondtothis).to eq('hello!')
   end
 
-  it 'should use master if manually forced' do
-    proxy = klass.new(config(1, 2))
+  describe '#stick_to_master' do
+    let(:proxy) { klass.new(config(1, 2)) }
 
-    expect(proxy.master_for?('select * from users')).to eq(false)
+    it 'should use master if manually forced' do
+      expect(proxy.master_for?('select * from users')).to eq(false)
 
-    proxy.stick_to_master!
+      proxy.stick_to_master!
 
-    expect(proxy.master_for?('select * from users')).to eq(true)
-  end
+      expect(proxy.master_for?('select * from users')).to eq(true)
+    end
+
+    it 'should persist stickiness by default' do
+      now = Time.now
+      proxy.stick_to_master!
+
+      next_context = Makara::Context.next
+      expect(next_context[proxy.id]).to be >= (now + 5).to_f
+
+      proxy = klass.new(config(1, 2))
+      expect(proxy.master_for?('select * from users')).to eq(true)
+    end
 
+    it 'optionally skips stickiness persistence, so it applies only to the current request' do
+      now = Time.now
+      proxy.stick_to_master!(false)
+
+      expect(proxy.master_for?('select * from users')).to eq(true)
+      next_context = Makara::Context.next
+      expect(next_context).to be_nil # Nothing to persist, so context is empty
+
+      proxy = klass.new(config(1, 2))
+      expect(proxy.master_for?('select * from users')).to eq(false)
+    end
+
+    it 'supports a float master_ttl for stickiness duration' do
+      now = Time.now
+      config = config(1, 2).dup
+      config[:makara][:master_ttl] = 0.5
+      proxy = klass.new(config)
+
+      proxy.stick_to_master!
+
+      next_context = Makara::Context.next
+      expect(next_context[proxy.id]).to be >= (now + 0.5).to_f
+      expect(next_context[proxy.id]).to be < (now + 1).to_f
+    end
+  end
 
-  context '#appropriate_pool' do
 
-    let(:proxy){ klass.new(config(1,1)) }
+  describe '#appropriate_pool' do
+    let(:proxy) { klass.new(config(1,1)) }
 
     it 'should be sticky by default' do
       expect(proxy.sticky).to eq(true)
@@ -104,41 +141,23 @@ describe Makara::Proxy do
       expect(proxy.master_for?('select * from users')).to eq(false)
     end
 
-    # if the context changes we should still use master until the previous context is no longer relevant
-    it 'should release master if the context changes and enough time passes' do
+    it "should not release master if it was stuck in the same request (no context changes yet)" do
       expect(proxy.master_for?('insert into users values (a,b,c)')).to eq(true)
       expect(proxy.master_for?('select * from users')).to eq(true)
 
-      change_context
-
       Timecop.travel Time.now + 10 do
-        expect(proxy.master_for?('select * from users')).to eq(false)
+        # master_ttl has passed but we are still in the same request, so current context
+        # is still relevant
+        expect(proxy.master_for?('select * from users')).to eq(true)
       end
     end
 
-    it 'should not release master if the previous context is still relevant' do
+    it 'should release master if all stuck connections are released' do
       expect(proxy.master_for?('insert into users values (a,b,c)')).to eq(true)
       expect(proxy.master_for?('select * from users')).to eq(true)
 
-      roll_context
-
-      proxy.master_for?('select * from users')
-      expect(proxy.master_for?('select * from users')).to eq(true)
-
-      Timecop.travel Time.now + 10 do
-        # cache is expired but context has not changed
-        expect(proxy.master_for?('select * from users')).to eq(true)
-
-        roll_context
+      Makara::Context.release_all
 
-        expect(proxy.master_for?('select * from users')).to eq(false)
-      end
-    end
-
-    it 'should release master if context changes enough' do
-      expect(proxy.master_for?('insert into users values (a,b,c)')).to eq(true)
-      roll_context
-      roll_context
       expect(proxy.master_for?('select * from users')).to eq(false)
     end
 
@@ -188,9 +207,5 @@ describe Makara::Proxy do
       proxy.slave_pool.connections.each{|con| expect(con._makara_blacklisted?).to eq(false) }
       proxy.master_pool.connections.each{|con| expect(con._makara_blacklisted?).to eq(false) }
     end
-
   end
-
-
-
 end

data/spec/spec_helper.rb

@@ -1,7 +1,9 @@
+require 'uri'
 require 'active_record'
 require 'makara'
 require 'timecop'
 require 'yaml'
+require 'rack'
 
 begin
   require 'byebug'
@@ -24,23 +26,17 @@ RSpec.configure do |config|
   require "#{File.dirname(__FILE__)}/support/pool_extensions"
   require "#{File.dirname(__FILE__)}/support/mock_objects"
   require "#{File.dirname(__FILE__)}/support/deep_dup"
+  require "#{File.dirname(__FILE__)}/support/user"
 
   config.include SpecHelpers
 
   config.before :each do
-    Makara::Cache.store = :memory
     change_context
     allow_any_instance_of(Makara::Strategies::RoundRobin).to receive(:should_shuffle?){ false }
+    RSpec::Mocks.space.proxy_for(ActiveRecord::Base).reset # make sure not stubbed in some way
   end
 
   def change_context
-    Makara::Context.set_previous nil
-    Makara::Context.set_current nil
+    Makara::Context.set_current({})
   end
-
-  def roll_context
-    Makara::Context.set_previous Makara::Context.get_current
-    Makara::Context.set_current Makara::Context.generate
-  end
-
 end

data/spec/strategies/shard_aware_spec.rb

@@ -0,0 +1,219 @@
+require 'spec_helper'
+
+describe Makara::Strategies::ShardAware do
+
+  def with_shard(shard_id)
+    begin
+      Thread.current['makara_shard_id'] = shard_id
+      yield
+    ensure
+      Thread.current['makara_shard_id'] = nil
+    end
+  end
+
+  describe "failover strategy with shard awareness," 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',
+        master_shard_aware: true,
+        master_default_shard: 'shard2'
+      } }
+    let(:strategy) { pool.strategy }
+
+    it 'should use the strategy' do
+      expect(pool.strategy).to be_instance_of(Makara::Strategies::ShardAware)
+    end
+
+    it 'should take the top weight for a given shard' do
+      wrapper_a = pool.add(pool_config.merge(shard_id: 'shard1')){ FakeConnection.new(something: 'a') }
+      wrapper_b = pool.add(pool_config.merge(shard_id: 'shard1', weight: 2)){ FakeConnection.new(something: 'b') }
+      wrapper_c = pool.add(pool_config.merge(weight: 2, shard_id: 'shard2')){ FakeConnection.new(something: 'c') }
+
+      # default shard
+      expect(strategy.current.something).to eql('c')
+      expect(strategy.next.something).to eql('c')
+      expect(strategy.next.something).to eql('c')
+
+      # shard1
+      with_shard('shard1') do
+        expect(strategy.current.something).to eql('b')
+        expect(strategy.next.something).to eql('b')
+        expect(strategy.next.something).to eql('b')
+      end
+
+      # shard2
+      with_shard('shard2') do
+        expect(strategy.current.something).to eql('c')
+        expect(strategy.next.something).to eql('c')
+        expect(strategy.next.something).to eql('c')
+      end
+    end
+
+    it 'should take given order within shard if no weights' do
+      wrapper_a = pool.add(pool_config.merge(shard_id: 'shard1')){ FakeConnection.new(something: 'a') }
+      wrapper_b = pool.add(pool_config.merge(shard_id: 'shard1')){ FakeConnection.new(something: 'b') }
+      wrapper_c = pool.add(pool_config.merge(shard_id: 'shard2')){ FakeConnection.new(something: 'c') }
+
+      # default shard
+      expect(strategy.current.something).to eql('c')
+      expect(strategy.next.something).to eql('c')
+      expect(strategy.next.something).to eql('c')
+
+      # shard1
+      with_shard('shard1') do
+        expect(strategy.current.something).to eql('a')
+        expect(strategy.next.something).to eql('a')
+      end
+
+      # shard2
+      with_shard('shard2') do
+        expect(strategy.current.something).to eql('c')
+        expect(strategy.next.something).to eql('c')
+      end
+    end
+
+    it 'should handle failover to next one within shard' do
+      wrapper_a = pool.add(pool_config.merge(shard_id: 'shard1')){ FakeConnection.new(something: 'a') }
+      wrapper_b = pool.add(pool_config.merge(shard_id: 'shard1')){ FakeConnection.new(something: 'b') }
+      wrapper_c = pool.add(pool_config.merge(shard_id: 'shard2')){ FakeConnection.new(something: 'c') }
+
+      # default shard
+      expect(strategy.current.something).to eql('c')
+      expect(strategy.next.something).to eql('c')
+      expect(strategy.next.something).to eql('c')
+
+      # skips a for shard1
+      with_shard('shard1') do
+        pool.provide do |connection|
+          if connection == wrapper_a
+            raise Makara::Errors::BlacklistConnection.new(wrapper_a, StandardError.new('failure'))
+          end
+        end
+        expect(strategy.current.something).to eql('b')
+        expect(strategy.next.something).to eql('b')
+      end
+
+      # shard2
+      with_shard('shard2') do
+        expect(strategy.current.something).to eql('c')
+        expect(strategy.next.something).to eql('c')
+      end
+    end
+    it 'raises error for invalid shard' do
+      with_shard('shard3') do
+        expect{strategy.current.something }.to raise_error(Makara::Errors::InvalidShard)
+      end
+    end
+  end
+
+  describe "round_robin strategy with shard awareness," 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: 'round_robin',
+        master_shard_aware: true,
+        master_default_shard: 'shard2'
+      } }
+    let(:strategy) { pool.strategy }
+
+    it 'should use the strategy' do
+      expect(pool.strategy).to be_instance_of(Makara::Strategies::ShardAware)
+    end
+
+    it 'should loop through with weights within shard' do
+      wrapper_a = pool.add(pool_config.merge(shard_id: 'shard1')){ FakeConnection.new(something: 'a') }
+      wrapper_b = pool.add(pool_config.merge(shard_id: 'shard1', weight: 2)){ FakeConnection.new(something: 'b') }
+      wrapper_c = pool.add(pool_config.merge(weight: 2, shard_id: 'shard2')){ FakeConnection.new(something: 'c') }
+
+      # default shard
+      expect(strategy.current.something).to eql('c')
+      expect(strategy.next.something).to eql('c')
+      expect(strategy.next.something).to eql('c')
+
+      # shard1
+      with_shard('shard1') do
+        expect(strategy.current.something).to eql('a')
+        expect(strategy.next.something).to eql('b')
+        expect(strategy.next.something).to eql('b')
+        expect(strategy.next.something).to eql('a')
+      end
+
+      # shard2
+      with_shard('shard2') do
+        expect(strategy.current.something).to eql('c')
+        expect(strategy.next.something).to eql('c')
+        expect(strategy.next.something).to eql('c')
+      end
+    end
+
+    it 'should handle failover to next one within shard' do
+      wrapper_a = pool.add(pool_config.merge(shard_id: 'shard1')){ FakeConnection.new(something: 'a') }
+      wrapper_b = pool.add(pool_config.merge(shard_id: 'shard1')){ FakeConnection.new(something: 'b') }
+      wrapper_c = pool.add(pool_config.merge(shard_id: 'shard2')){ FakeConnection.new(something: 'c') }
+
+      # default shard
+      expect(strategy.current.something).to eql('c')
+      expect(strategy.next.something).to eql('c')
+      expect(strategy.next.something).to eql('c')
+
+      # skips a for shard1
+      with_shard('shard1') do
+        pool.provide do |connection|
+          if connection == wrapper_a
+            raise Makara::Errors::BlacklistConnection.new(wrapper_a, StandardError.new('failure'))
+          end
+        end
+        expect(strategy.current.something).to eql('b')
+        expect(strategy.next.something).to eql('b')
+        expect(strategy.next.something).to eql('b')
+      end
+
+      # shard2
+      with_shard('shard2') do
+        expect(strategy.current.something).to eql('c')
+        expect(strategy.next.something).to eql('c')
+        expect(strategy.next.something).to eql('c')
+      end
+    end
+    it 'raises error for invalid shard' do
+      with_shard('shard3') do
+        expect{strategy.current.something }.to raise_error(Makara::Errors::InvalidShard)
+      end
+    end
+  end
+
+  describe "uses the configured failover strategy when shard_aware set to false," 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',
+        master_shard_aware: false,
+        master_default_shard: 'shard2'
+      } }
+    let(:strategy) { pool.strategy }
+
+    it 'should use the failover strategy' do
+      expect(pool.strategy).to be_instance_of(Makara::Strategies::PriorityFailover)
+    end
+  end
+
+  describe "uses the configured roundrobin strategy when shard_aware set to false," 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: 'round_robin',
+        master_shard_aware: false,
+        master_default_shard: 'shard2'
+      } }
+    let(:strategy) { pool.strategy }
+
+    it 'should use the failover strategy' do
+      expect(pool.strategy).to be_instance_of(Makara::Strategies::RoundRobin)
+    end
+  end
+end

data/spec/support/helpers.rb

@@ -15,9 +15,13 @@ module SpecHelpers
     slaves.times{ connections << {:role => 'slave'} }
     {
       :makara => {
-        :blacklist_duration => 30,
+        # Defaults:
+        # :master_ttl => 5,
+        # :blacklist_duration => 30,
+        # :sticky => true
+        :id => 'mock_mysql',
         :connections => connections
       }
     }
   end
-end
+end

data/spec/support/mock_objects.rb

@@ -11,13 +11,17 @@ class FakeConnection < Struct.new(:config)
   end
 
   def query(content)
-    []
+    config[:name]
   end
 
   def active?
     true
   end
 
+  def open_transactions
+    (config || {}).fetch(:open_transactions, 0)
+  end
+
   def disconnect!
     true
   end