makara 0.3.9 → 0.5.1

data/spec/connection_wrapper_spec.rb

@@ -1,8 +1,7 @@
 require 'spec_helper'
 
 describe Makara::ConnectionWrapper do
-
-  let(:proxy){ FakeProxy.new({:makara => {:blacklist_duration => 5, :connections => [{:role => 'master'}, {:role => 'slave'}, {:role => 'slave'}]}}) }
+  let(:proxy){ FakeProxy.new({makara: {blacklist_duration: 5, connections: [{role: 'master'}, {role: 'slave'}, {role: 'slave'}]}}) }
   let(:connection){ subject._makara_connection }
 
   subject{ proxy.master_pool.connections.first }
@@ -14,8 +13,11 @@ describe Makara::ConnectionWrapper do
   end
 
   it 'should invoke hijacked methods on the proxy when invoked directly' do
-    expect(proxy).to receive(:execute).with('test').once
-    connection.execute("test")
+    expect(proxy).to receive(:execute).with('test').once do |&block|
+      expect(block.call).to eq('Hello')
+    end
+
+    connection.execute('test') { 'Hello' }
   end
 
   it 'should have a default weight of 1' do

data/spec/context_spec.rb

@@ -1,146 +1,209 @@
 require 'spec_helper'
+require 'rack'
+require 'time'
 
 describe Makara::Context do
+  let(:now) { Time.parse('2018-02-11 11:10:40 +0000') }
+  let(:context_data) { { "mysql" => now.to_f + 5, "redis" => now.to_f + 5 } }
 
-  describe 'get_current' do
-    it 'does not share context acorss threads' do
-      uniq_curret_contexts = []
-      threads = []
-
-      1.upto(3).map do |i|
-        threads << Thread.new do
-          current = Makara::Context.get_current
-          expect(current).to_not be_nil
-          expect(uniq_curret_contexts).to_not include(current)
-          uniq_curret_contexts << current
-
-          sleep(0.2)
-        end
-        sleep(0.1)
-      end
+  before do
+    Timecop.freeze(now)
+  end
+
+  after do
+    Timecop.return
+  end
+
+  it 'does not share stickiness state across threads' do
+    contexts = {}
+    threads = []
+
+    [1, -1].each_with_index do |f, i|
+      threads << Thread.new do
+        context_data = { "mysql" => now.to_f + f*5 }
+        Makara::Context.set_current(context_data)
 
-      threads.map(&:join)
-      expect(uniq_curret_contexts.uniq.count).to eq(3)
+        contexts["context_#{i}"] = Makara::Context.stuck?('mysql')
+
+        sleep(0.2)
+      end
+      sleep(0.1)
     end
+
+    threads.map(&:join)
+    expect(contexts).to eq({ 'context_0' => true, 'context_1' => false })
   end
 
   describe 'set_current' do
+    it 'sets stickiness information from given hash' do
+      Makara::Context.set_current(context_data)
+
+      expect(Makara::Context.stuck?('mysql')).to be_truthy
+      expect(Makara::Context.stuck?('redis')).to be_truthy
+      expect(Makara::Context.stuck?('mariadb')).to be_falsey
+    end
+  end
 
-    it 'does not share context acorss threads' do
-      uniq_curret_contexts = []
-      threads = []
+  describe 'stick' do
+    before do
+      Makara::Context.set_current(context_data)
+    end
+
+    it 'sticks a proxy to master for the current request' do
+      expect(Makara::Context.stuck?('mariadb')).to be_falsey
 
-      1.upto(3).map do |i|
-        threads << Thread.new do
+      Makara::Context.stick('mariadb', 10)
 
-          current = Makara::Context.set_current("val#{i}")
-          expect(current).to_not be_nil
-          expect(current).to eq("val#{i}")
+      expect(Makara::Context.stuck?('mariadb')).to be_truthy
+      Timecop.travel(Time.now + 20)
+      # The ttl kicks off when the context is committed
+      next_context = Makara::Context.next
+      expect(next_context['mariadb']).to be >= now.to_f + 30 # 10 ttl + 20 seconds that have passed
 
-          sleep(0.2)
+      # It expires after going to the next request
+      Timecop.travel(Time.now + 20)
+      Makara::Context.next
+      expect(Makara::Context.stuck?('mariadb')).to be_falsey
+    end
 
-          current = Makara::Context.get_current
-          expect(current).to_not be_nil
-          expect(current).to eq("val#{i}")
+    it "doesn't overwrite previously stuck proxies with current-request-only stickiness" do
+      expect(Makara::Context.stuck?('mysql')).to be_truthy
 
-          uniq_curret_contexts << current
-        end
-        sleep(0.1)
-      end
+      # ttl=0 to avoid persisting mysql for the next request
+      Makara::Context.stick('mysql', 0)
 
-      threads.map(&:join)
-      expect(uniq_curret_contexts.uniq.count).to eq(3)
+      Makara::Context.next
+      # mysql proxy is still stuck in the next context
+      expect(Makara::Context.stuck?('mysql')).to be_truthy
     end
-  end
 
-  describe 'get_previous' do
-    it 'does not share context acorss threads' do
-      uniq_curret_contexts = []
-      threads = []
-
-      1.upto(3).map do |i|
-        threads << Thread.new do
-          current = Makara::Context.get_previous
-          expect(current).to_not be_nil
-          expect(uniq_curret_contexts).to_not include(current)
-          uniq_curret_contexts << current
-
-          sleep(0.2)
-        end
-        sleep(0.1)
-      end
+    it 'uses always the max ttl given' do
+      expect(Makara::Context.stuck?('mariadb')).to be_falsey
+
+      Makara::Context.stick('mariadb', 10)
+      expect(Makara::Context.stuck?('mariadb')).to be_truthy
+
+      Makara::Context.stick('mariadb', 5)
+
+      next_context = Makara::Context.next
+      expect(next_context['mariadb']).to eq((now + 10).to_f)
+    end
+
+    it 'supports floats as ttl' do
+      expect(Makara::Context.stuck?('mariadb')).to be_falsey
 
-      threads.map(&:join)
-      expect(uniq_curret_contexts.uniq.count).to eq(3)
+      Makara::Context.stick('mariadb', 0.5)
+
+      next_context = Makara::Context.next
+      expect(next_context['mariadb']).to eq((now + 0.5).to_f)
     end
   end
 
-  describe 'set_previous' do
-    it 'does not share context acorss threads' do
-      uniq_curret_contexts = []
-      threads = []
+  describe 'next' do
+    before do
+      Makara::Context.set_current(context_data)
+    end
 
-      1.upto(3).map do |i|
-        threads << Thread.new do
+    it 'returns nil if there is nothing new to stick' do
+      expect(Makara::Context.next).to be_nil
+    end
 
-          current = Makara::Context.set_previous("val#{i}")
-          expect(current).to_not be_nil
-          expect(current).to eq("val#{i}")
+    it "doesn't store staged proxies with 0 stickiness duration" do
+      Makara::Context.stick('mariadb', 0)
 
-          sleep(0.2)
+      expect(Makara::Context.next).to be_nil
+    end
 
-          current = Makara::Context.get_previous
-          expect(current).to_not be_nil
-          expect(current).to eq("val#{i}")
+    it 'returns hash with updated stickiness' do
+      Makara::Context.stick('mariadb', 10)
 
-          uniq_curret_contexts << current
-        end
-        sleep(0.1)
-      end
+      next_context = Makara::Context.next
+      expect(next_context['mysql']).to eq((now + 5).to_f)
+      expect(next_context['redis']).to eq((now + 5).to_f)
+      expect(next_context['mariadb']).to eq((now + 10).to_f)
+    end
+
+    it "doesn't update previously stored proxies if the update will cause a sooner expiration" do
+      Makara::Context.stick('mariadb', 10)
+      Makara::Context.stick('mysql', 2.5)
+
+      next_context = Makara::Context.next
+      expect(next_context['mysql']).to eq((now + 5).to_f)
+      expect(next_context['mariadb']).to eq((now + 10).to_f)
+
+      Makara::Context.set_current(context_data)
+      Makara::Context.stick('mysql', 2.5)
+
+      expect(Makara::Context.next).to be_nil
+    end
+
+    it 'clears expired entries for proxies that are no longer stuck' do
+      Timecop.travel(now + 10)
 
-      threads.map(&:join)
-      expect(uniq_curret_contexts.uniq.count).to eq(3)
+      expect(Makara::Context.next).to eq({})
     end
 
-    it 'clears config sticky cache' do
-      Makara::Cache.store = :memory
+    it 'sets expiration time with ttl based on the invokation time' do
+      Makara::Context.stick('mariadb', 10)
+      request_ends_at = Time.now + 20
+      Timecop.travel(request_ends_at)
 
-      Makara::Context.set_previous('a')
-      Makara::Context.stick('a', 1, 10)
-      expect(Makara::Context.previously_stuck?(1)).to be_truthy
+      next_context = Makara::Context.next
 
-      Makara::Context.set_previous('b')
-      expect(Makara::Context.previously_stuck?(1)).to be_falsey
+      # The previous stuck proxies would have expired
+      expect(next_context['mysql']).to be_nil
+      expect(next_context['redis']).to be_nil
+      # But the proxy stuck in that request would expire in ttl seconds from now
+      expect(next_context['mariadb']).to be >= (request_ends_at + 10).to_f
     end
   end
 
-  describe 'stick' do
-    it 'sticks a config to master for subsequent requests' do
-      Makara::Cache.store = :memory
+  describe 'release' do
+    before do
+      Makara::Context.set_current(context_data)
+    end
+
+    it 'clears stickiness for the given proxy' do
+      expect(Makara::Context.stuck?('mysql')).to be_truthy
+
+      Makara::Context.release('mysql')
+
+      expect(Makara::Context.stuck?('mysql')).to be_falsey
+
+      next_context = Makara::Context.next
+      expect(next_context.key?('mysql')).to be_falsey
+      expect(next_context['redis']).to eq((now + 5).to_f)
+    end
+
+    it 'does nothing if the proxy given was not stuck' do
+      expect(Makara::Context.stuck?('mariadb')).to be_falsey
 
-      expect(Makara::Context.stuck?('context', 1)).to be_falsey
+      Makara::Context.release('mariadb')
 
-      Makara::Context.stick('context', 1, 10)
-      expect(Makara::Context.stuck?('context', 1)).to be_truthy
-      expect(Makara::Context.stuck?('context', 2)).to be_falsey
+      expect(Makara::Context.stuck?('mariadb')).to be_falsey
+      expect(Makara::Context.next).to be_nil
     end
   end
 
-  describe 'previously_stuck?' do
-    it 'checks whether a config was stuck to master in the previous context' do
-      Makara::Cache.store = :memory
-      Makara::Context.set_previous 'previous'
+  describe 'release_all' do
+    it 'clears stickiness for all stuck proxies' do
+      Makara::Context.set_current(context_data)
+      expect(Makara::Context.stuck?('mysql')).to be_truthy
+      expect(Makara::Context.stuck?('redis')).to be_truthy
+
+      Makara::Context.release_all
 
-      # Emulate sticking the previous web request to master.
-      Makara::Context.stick 'previous', 1, 10
+      expect(Makara::Context.stuck?('mysql')).to be_falsey
+      expect(Makara::Context.stuck?('redis')).to be_falsey
+      expect(Makara::Context.next).to eq({})
+    end
+
+    it 'does nothing if there were no stuck proxies' do
+      Makara::Context.set_current({})
 
-      # Emulate handling the subsequent web request with a previous context
-      # cookie that is stuck to master.
-      expect(Makara::Context.previously_stuck?(1)).to be_truthy
+      Makara::Context.release_all
 
-      # Other configs should not be stuck to master, though.
-      expect(Makara::Context.previously_stuck?(2)).to be_falsey
+      expect(Makara::Context.next).to be_nil
     end
   end
 end
-

data/spec/cookie_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+require 'rack'
+require 'time'
+
+describe Makara::Cookie do
+  let(:now) { Time.parse('2018-02-11 11:10:40 +0000') }
+  let(:cookie_key) { Makara::Cookie::IDENTIFIER }
+
+  before do
+    Timecop.freeze(now)
+  end
+
+  after do
+    Timecop.return
+  end
+
+  describe 'fetch' do
+    let(:cookie_string) { "mysql:#{now.to_f + 5}|redis:#{now.to_f + 5}" }
+    let(:request) { Rack::Request.new('HTTP_COOKIE' => "#{cookie_key}=#{cookie_string}") }
+
+    it 'parses stickiness context from cookie string' do
+      context_data = Makara::Cookie.fetch(request)
+
+      expect(context_data['mysql']).to eq(now.to_f + 5)
+      expect(context_data['redis']).to eq(now.to_f + 5)
+      expect(context_data.key?('mariadb')).to be_falsey
+    end
+
+    it 'returns empty context data when there is no cookie' do
+      context_data = Makara::Cookie.fetch(Rack::Request.new('HTTP_COOKIE' => "another_cookie=1"))
+
+      expect(context_data).to eq({})
+    end
+
+    it 'returns empty context data when the cookie contents are invalid' do
+      context_data = Makara::Cookie.fetch(Rack::Request.new('HTTP_COOKIE' => "#{cookie_key}=1"))
+
+      expect(context_data).to eq({})
+    end
+  end
+
+  describe 'store' do
+    let(:headers) { {} }
+    let(:context_data) { { "mysql" => now.to_f + 5, "redis" => now.to_f + 5 } }
+
+    it 'does not set a cookie if there is no next context' do
+      Makara::Cookie.store(nil, headers)
+
+      expect(headers).to eq({})
+    end
+
+    it 'sets the context cookie with updated stickiness and enough expiration time' do
+      Makara::Cookie.store(context_data, headers)
+
+      expect(headers['Set-Cookie']).to include("#{cookie_key}=mysql%3A#{(now + 5).to_f}%7Credis%3A#{(now + 5).to_f};")
+      expect(headers['Set-Cookie']).to include("path=/; max-age=10; expires=#{(Time.now + 10).httpdate}; HttpOnly")
+    end
+
+    it 'expires the cookie if the next context is empty' do
+      Makara::Cookie.store({}, headers)
+
+      expect(headers['Set-Cookie']).to eq("#{cookie_key}=; path=/; max-age=0; expires=#{Time.now.httpdate}; HttpOnly")
+    end
+
+    it 'allows custom cookie options to be provided' do
+      Makara::Cookie.store(context_data, headers, { secure: true })
+
+      expect(headers['Set-Cookie']).to include("#{cookie_key}=mysql%3A#{(now + 5).to_f}%7Credis%3A#{(now + 5).to_f};")
+      expect(headers['Set-Cookie']).to include("path=/; max-age=10; expires=#{(Time.now + 10).httpdate}; secure; HttpOnly")
+    end
+  end
+end

data/spec/middleware_spec.rb

@@ -1,84 +1,55 @@
 require 'spec_helper'
+require 'time'
 
 describe Makara::Middleware do
-
+  let(:now) { Time.parse('2018-02-11 11:10:40 +0000') }
   let(:app){
     lambda{|env|
-      proxy.query(env[:query] || 'select * from users')
-      [200, {}, ["#{Makara::Context.get_current}-#{Makara::Context.get_previous}"]]
+      response = proxy.query(env[:query] || 'select * from users')
+      [200, {}, response]
     }
   }
 
   let(:env){ {} }
   let(:proxy){ FakeProxy.new(config(1,2)) }
-  let(:middleware){ described_class.new(app, :secure => true) }
-
-  let(:key){ Makara::Middleware::IDENTIFIER }
-
-  it 'should set the context before the request' do
-    Makara::Context.set_previous 'old'
-    Makara::Context.set_current 'old'
+  let(:middleware){ described_class.new(app, secure: true) }
 
-    response = middleware.call(env)
-    current, prev = context_from(response)
+  let(:key){ Makara::Cookie::IDENTIFIER }
 
-    expect(current).not_to eq('old')
-    expect(prev).not_to eq('old')
-
-    expect(current).to eq(Makara::Context.get_current)
-    expect(prev).to eq(Makara::Context.get_previous)
+  before do
+    @hijacked_methods = FakeProxy.hijack_methods
+    FakeProxy.hijack_method :query
+    Timecop.freeze(now)
   end
 
-  it 'should use the cookie-provided context if present' do
-    env['HTTP_COOKIE'] = "#{key}=abcdefg--200; path=/; max-age=5"
+  after do
+    Timecop.return
+    FakeProxy.hijack_methods = []
+    FakeProxy.hijack_method(*@hijacked_methods)
+  end
 
-    response = middleware.call(env)
-    current, prev = context_from(response)
+  it 'should init the context and not be stuck by default' do
+    _, headers, body = middleware.call(env)
 
-    expect(prev).to eq('abcdefg')
-    expect(current).to eq(Makara::Context.get_current)
-    expect(current).not_to eq('abcdefg')
+    expect(headers).to eq({})
+    expect(body).to eq('slave/1')
   end
 
-  it 'should use the param-provided context if present' do
-    env['QUERY_STRING'] = "dog=true&#{key}=abcdefg&cat=false"
+  it 'should use the cookie-provided context if present' do
+    env['HTTP_COOKIE'] = "#{key}=mock_mysql%3A#{(now + 3).to_f}; path=/; max-age=5"
 
-    response = middleware.call(env)
-    current, prev = context_from(response)
+    _, headers, body = middleware.call(env)
 
-    expect(prev).to eq('abcdefg')
-    expect(current).to eq(Makara::Context.get_current)
-    expect(current).not_to eq('abcdefg')
+    expect(headers).to eq({})
+    expect(body).to eq('master/1')
   end
 
   it 'should set the cookie if master is used' do
     env[:query] = 'update users set name = "phil"'
 
-    status, headers, body = middleware.call(env)
+    _, headers, body = middleware.call(env)
 
-    expect(headers['Set-Cookie']).to eq("#{key}=#{Makara::Context.get_current}--200; path=/; max-age=5; 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
-
-  it 'should preserve the same context if the previous request was a redirect' do
-    env['HTTP_COOKIE'] = "#{key}=abcdefg--301; path=/; max-age=5"
-
-    response    = middleware.call(env)
-    curr, prev  = context_from(response)
-
-    expect(curr).to eq('abcdefg')
-    expect(prev).to eq('abcdefg')
-
-    env['HTTP_COOKIE'] = response[1]['Set-Cookie']
-
-    response      = middleware.call(env)
-    curr2, prev2  = context_from(response)
-
-    expect(prev2).to eq('abcdefg')
-    expect(curr2).to eq(Makara::Context.get_current)
-  end
-
-  def context_from(response)
-    response[2][0].split('-')
-  end
-
 end