makara 0.4.1 → 0.5.0

data/spec/middleware_spec.rb

@@ -49,7 +49,7 @@ describe Makara::Middleware do
 
     _, headers, body = middleware.call(env)
 
-    expect(headers['Set-Cookie']).to eq("#{key}=mock_mysql%3A#{(now + 5).to_f}; path=/; max-age=10; expires=#{(Time.now + 10).gmtime.rfc2822}; secure; HttpOnly")
+    expect(headers['Set-Cookie']).to eq("#{key}=mock_mysql%3A#{(now + 5).to_f}; path=/; max-age=10; expires=#{(Time.now + 10).httpdate}; secure; HttpOnly")
     expect(body).to eq('master/1')
   end
 end

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/spec_helper.rb

@@ -1,3 +1,4 @@
+require 'uri'
 require 'active_record'
 require 'makara'
 require 'timecop'

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/mock_objects.rb

@@ -18,6 +18,10 @@ class FakeConnection < Struct.new(:config)
     true
   end
 
+  def open_transactions
+    (config || {}).fetch(:open_transactions, 0)
+  end
+
   def disconnect!
     true
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: makara
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.5.0
 platform: ruby
 authors:
 - Mike Nelson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-03-25 00:00:00.000000000 Z
+date: 2021-01-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -31,6 +31,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/gem-publish-public.yml"
 - ".gitignore"
 - ".rspec"
 - ".ruby-gemset"
@@ -49,6 +50,8 @@ files:
 - gemfiles/ar42.gemfile
 - gemfiles/ar50.gemfile
 - gemfiles/ar51.gemfile
+- gemfiles/ar52.gemfile
+- gemfiles/ar60.gemfile
 - lib/active_record/connection_adapters/jdbcmysql_makara_adapter.rb
 - lib/active_record/connection_adapters/jdbcpostgresql_makara_adapter.rb
 - lib/active_record/connection_adapters/makara_abstract_adapter.rb
@@ -68,6 +71,8 @@ files:
 - lib/makara/error_handler.rb
 - lib/makara/errors/all_connections_blacklisted.rb
 - lib/makara/errors/blacklist_connection.rb
+- lib/makara/errors/blacklisted_while_in_transaction.rb
+- lib/makara/errors/invalid_shard.rb
 - lib/makara/errors/makara_error.rb
 - lib/makara/errors/no_connections_available.rb
 - lib/makara/logging/logger.rb
@@ -79,6 +84,7 @@ files:
 - lib/makara/strategies/abstract.rb
 - lib/makara/strategies/priority_failover.rb
 - lib/makara/strategies/round_robin.rb
+- lib/makara/strategies/shard_aware.rb
 - lib/makara/version.rb
 - makara.gemspec
 - spec/active_record/connection_adapters/makara_abstract_adapter_error_handling_spec.rb
@@ -97,6 +103,7 @@ files:
 - spec/spec_helper.rb
 - spec/strategies/priority_failover_spec.rb
 - spec/strategies/round_robin_spec.rb
+- spec/strategies/shard_aware_spec.rb
 - spec/support/deep_dup.rb
 - spec/support/helpers.rb
 - spec/support/mock_objects.rb
@@ -109,9 +116,11 @@ files:
 - spec/support/proxy_extensions.rb
 - spec/support/schema.rb
 - spec/support/user.rb
-homepage: ''
-licenses: []
-metadata: {}
+homepage: https://github.com/taskrabbit/makara
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/taskrabbit/makara
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -127,8 +136,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.2
+rubygems_version: 3.1.4
 signing_key: 
 specification_version: 4
 summary: Read-write split your DB yo
@@ -149,6 +157,7 @@ test_files:
 - spec/spec_helper.rb
 - spec/strategies/priority_failover_spec.rb
 - spec/strategies/round_robin_spec.rb
+- spec/strategies/shard_aware_spec.rb
 - spec/support/deep_dup.rb
 - spec/support/helpers.rb
 - spec/support/mock_objects.rb