makara 0.4.1 → 0.5.1

data/spec/strategies/round_robin_spec.rb

@@ -1,9 +1,9 @@
 require 'spec_helper'
 
 describe Makara::Strategies::RoundRobin do
-  let(:proxy){ FakeProxy.new({:makara => pool_config.merge(makara_config).merge(:connections => [])}) }
+  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(:pool_config){ {blacklist_duration: 5} }
   let(:makara_config) { {} }
   let(:strategy) { pool.strategy }
 
@@ -14,7 +14,7 @@ describe Makara::Strategies::RoundRobin do
   end
 
   context 'bad config' do
-    let(:makara_config) { { :test_strategy => 'SomethingElse::Here' } }
+    let(:makara_config) { { test_strategy: 'SomethingElse::Here' } }
     it 'should raise name error' do
       expect {
         pool
@@ -23,13 +23,12 @@ describe Makara::Strategies::RoundRobin do
   end
 
   context 'given in config' do
-    let(:makara_config) { { :test_strategy => 'round_robin' } }
+    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') }
@@ -61,7 +60,4 @@ describe Makara::Strategies::RoundRobin do
     expect(strategy.next.something).to eql('c')
     expect(strategy.next.something).to eql('b')
   end
-
-
-
 end

data/spec/strategies/shard_aware_spec.rb

@@ -0,0 +1,218 @@
+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/deep_dup.rb

@@ -9,4 +9,4 @@ unless Hash.respond_to?(:deep_dup)
       duplicate
     end
   end
-end
+end

data/spec/support/helpers.rb

@@ -11,16 +11,16 @@ module SpecHelpers
 
   def config(masters = 1, slaves = 2)
     connections = []
-    masters.times{ connections << {:role => 'master'} }
-    slaves.times{ connections << {:role => 'slave'} }
+    masters.times{ connections << {role: 'master'} }
+    slaves.times{ connections << {role: 'slave'} }
     {
-      :makara => {
+      makara: {
         # Defaults:
         # :master_ttl => 5,
         # :blacklist_duration => 30,
         # :sticky => true
-        :id => 'mock_mysql',
-        :connections => connections
+        id: 'mock_mysql',
+        connections: connections
       }
     }
   end

data/spec/support/mock_objects.rb

@@ -1,7 +1,6 @@
 require 'active_record/connection_adapters/makara_abstract_adapter'
 
 class FakeConnection < Struct.new(:config)
-
   def ping
     'ping!'
   end
@@ -18,6 +17,10 @@ class FakeConnection < Struct.new(:config)
     true
   end
 
+  def open_transactions
+    (config || {}).fetch(:open_transactions, 0)
+  end
+
   def disconnect!
     true
   end
@@ -28,7 +31,6 @@ class FakeConnection < Struct.new(:config)
 end
 
 class FakeDatabaseAdapter < Struct.new(:config)
-
   def execute(sql, name = nil)
     []
   end
@@ -44,11 +46,9 @@ class FakeDatabaseAdapter < Struct.new(:config)
   def active?
     true
   end
-
 end
 
 class FakeProxy < Makara::Proxy
-
   send_to_all :ping
   hijack_method :execute
 
@@ -58,6 +58,7 @@ class FakeProxy < Makara::Proxy
 
   def needs_master?(method_name, args)
     return false if args.first =~ /^select/
+
     true
   end
 end

data/spec/support/mysql2_database.yml

@@ -1,9 +1,9 @@
 test:
   adapter: 'mysql2_makara'
   database: 'makara_test'
-  username: 'root'
+  host: <%= ENV["MYSQL_HOST"] %>
+  username: root
   password: ''
-
   timeout: 5000
   connect_timeout: 1
   read_timeout: 1

data/spec/support/mysql2_database_with_custom_errors.yml

@@ -1,9 +1,9 @@
 test:
   adapter: 'mysql2_makara'
   database: 'makara_test'
-  username: 'root'
+  host: <%= ENV["MYSQL_HOST"] %>
+  username: root
   password: ''
-
   timeout: 5000
   connect_timeout: 1
   read_timeout: 1

data/spec/support/pool_extensions.rb

@@ -1,5 +1,4 @@
 module PoolExtensions
-
   def connections
     @connections
   end
@@ -7,8 +6,6 @@ module PoolExtensions
   def connection_count
     @connections.length
   end
-
 end
 
-
 Makara::Pool.send(:include, PoolExtensions)

data/spec/support/postgis_schema.rb

@@ -5,7 +5,7 @@ conn.execute "create extension if not exists postgis"
 if conn.table_exists? "towns"
   conn.execute("TRUNCATE TABLE towns")
 else
-  conn.create_table "towns", :force => true do |t|
+  conn.create_table "towns", force: true do |t|
     t.st_point "location"
   end
 end

data/spec/support/postgresql_database.yml

@@ -1,8 +1,6 @@
 test:
   adapter: 'postgresql_makara'
   database: 'makara_test'
-  username: 'root'
-  password: ''
 
   timeout: 5000
 

data/spec/support/proxy_extensions.rb

@@ -1,7 +1,6 @@
 module ProxyExtensions
-
   attr_reader :master_pool, :slave_pool, :id
-  
+
   def master_for?(sql)
     pool_for(sql) == master_pool
   end
@@ -27,7 +26,6 @@ module ProxyExtensions
   def sticky=(s)
     @sticky = s
   end
-
 end
 
 Makara::Proxy.send(:include, ProxyExtensions)

data/spec/support/schema.rb

@@ -4,6 +4,6 @@ if conn.table_exists? "users"
   conn.execute("TRUNCATE TABLE users")
 else
   conn.create_table "users" do |t|
-    t.string   "name"
+    t.string "name"
   end
 end

data/spec/support/user.rb

@@ -1,5 +1,4 @@
 module Test
   class User < ::ActiveRecord::Base
-
   end
-end
+end