makara 0.5.1 → 0.6.0.pre

data/lib/makara/connection_wrapper.rb

@@ -181,7 +181,7 @@ module Makara
       end
 
       # extend the instance
-      con.instance_eval(extension, __FILE__, __LINE__ + 1)
+      con.instance_eval(extension)
       # set the makara context
       con._makara = @proxy
 

data/lib/makara/context.rb

@@ -99,7 +99,7 @@ module Makara
         set(:makara_current_context, new(context_data))
       end
 
-      # Called by `Proxy#stick_to_master!` to use master in subsequent requests
+      # Called by `Proxy#stick_to_primary!` to use primary in subsequent requests
       def stick(proxy_id, ttl)
         current.stage(proxy_id, ttl)
       end

data/lib/makara/logging/subscriber.rb

@@ -18,7 +18,7 @@ module Makara
       # uses the adapter's connection proxy to modify the name of the event
       # the name of the used connection will be prepended to the sql log
       ###
-      ### [Master|Slave] User Load (1.3ms) SELECT * FROM `users`;
+      ### [Primary|Replica] User Load (1.3ms) SELECT * FROM `users`;
       ###
       def current_wrapper_name(event)
         connection_object_id = event.payload[:connection_id]

data/lib/makara/middleware.rb

@@ -1,6 +1,6 @@
 require 'rack'
 
-# Persists the Makara::Context across requests ensuring the same master pool is used on subsequent requests.
+# Persists the Makara::Context across requests ensuring the same primary pool is used on subsequent requests.
 module Makara
   class Middleware
     def initialize(app, cookie_options = {})

data/lib/makara/pool.rb

@@ -17,7 +17,7 @@ module Makara
     attr_reader :default_shard
 
     def initialize(role, proxy)
-      @role             = role
+      @role             = role == "master" ? "primary" : role
       @proxy            = proxy
       @connections      = []
       @blacklist_errors = []
@@ -125,7 +125,7 @@ module Makara
       # when a connection causes a blacklist error within the provided block, we blacklist it then retry
       rescue Makara::Errors::BlacklistConnection => e
         @blacklist_errors.insert(0, e)
-        in_transaction = self.role == "master" && provided_connection._makara_in_transaction?
+        in_transaction = self.role == "primary" && provided_connection._makara_in_transaction?
         provided_connection._makara_blacklist!
         raise Makara::Errors::BlacklistedWhileInTransaction.new(@role) if in_transaction
 

data/lib/makara/proxy.rb

@@ -3,7 +3,7 @@ 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
+# The entry point of Makara. It contains a primary and replica pool which are chosen based on the invocation
 # being proxied. Makara::Proxy implementations should declare which methods they are hijacking via the
 # `hijack_method` class method.
 # While debugging this class use prepend debug calls with Kernel. (Kernel.byebug for example)
@@ -66,7 +66,7 @@ module Makara
       @config         = config.symbolize_keys
       @config_parser  = Makara::ConfigParser.new(@config)
       @id             = @config_parser.id
-      @ttl            = @config_parser.makara_config[:master_ttl]
+      @ttl            = @config_parser.makara_config[:primary_ttl]
       @sticky         = @config_parser.makara_config[:sticky]
       @hijacked       = false
       @error_handler  ||= ::Makara::ErrorHandler.new
@@ -86,13 +86,18 @@ module Makara
       @hijacked
     end
 
-    # If persist is true, we stick the proxy to master for subsequent requests
-    # up to master_ttl duration. Otherwise we just stick it for the current request
-    def stick_to_master!(persist = true)
+    # If persist is true, we stick the proxy to primary for subsequent requests
+    # up to primary_ttl duration. Otherwise we just stick it for the current request
+    def stick_to_primary!(persist = true)
       stickiness_duration = persist ? @ttl : 0
       Makara::Context.stick(@id, stickiness_duration)
     end
 
+    def stick_to_master!(persist = true)
+      warn "#{self.class}.stick_to_master! is deprecated. Switch to #stick_to_primary!"
+      stick_to_primary!(persist)
+    end
+
     def strategy_for(role)
       strategy_class_for(strategy_name_for(role)).new(self)
     end
@@ -162,33 +167,33 @@ module Makara
     protected
 
     def send_to_all(method_name, *args)
-      # slave pool must run first to allow for slave-->master failover without running operations on master twice.
+      # replica pool must run first to allow for replica --> primary failover without running operations on the primary twice.
       handling_an_all_execution(method_name) do
-        @slave_pool.send_to_all(method_name, *args)
-        @master_pool.send_to_all(method_name, *args)
+        @replica_pool.send_to_all(method_name, *args)
+        @primary_pool.send_to_all(method_name, *args)
       end
     end
 
     ruby2_keywords :send_to_all if Module.private_method_defined?(:ruby2_keywords)
 
     def any_connection
-      if @master_pool.disabled
-        @slave_pool.provide do |con|
+      if @primary_pool.disabled
+        @replica_pool.provide do |con|
           yield con
         end
       else
-        @master_pool.provide do |con|
+        @primary_pool.provide do |con|
           yield con
         end
       end
     rescue ::Makara::Errors::AllConnectionsBlacklisted, ::Makara::Errors::NoConnectionsAvailable
       begin
-        @master_pool.disabled = true
-        @slave_pool.provide do |con|
+        @primary_pool.disabled = true
+        @replica_pool.provide do |con|
           yield con
         end
       ensure
-        @master_pool.disabled = false
+        @primary_pool.disabled = false
       end
     end
 
@@ -205,52 +210,57 @@ module Makara
       end
     end
 
-    # master or slave
+    # primary or replica
     def appropriate_pool(method_name, args)
       # for testing purposes
       pool = _appropriate_pool(method_name, args)
       yield pool
     rescue ::Makara::Errors::AllConnectionsBlacklisted, ::Makara::Errors::NoConnectionsAvailable => e
-      if pool == @master_pool
-        @master_pool.connections.each(&:_makara_whitelist!)
-        @slave_pool.connections.each(&:_makara_whitelist!)
+      if pool == @primary_pool
+        @primary_pool.connections.each(&:_makara_whitelist!)
+        @replica_pool.connections.each(&:_makara_whitelist!)
         Kernel.raise e
       else
-        @master_pool.blacklist_errors << e
+        @primary_pool.blacklist_errors << e
         retry
       end
     end
 
     def _appropriate_pool(method_name, args)
-      # the args provided absolutely need master
-      if needs_master?(method_name, args)
-        stick_to_master(method_name, args)
-        @master_pool
+      # the args provided absolutely need primary
+      if needs_primary?(method_name, args)
+        stick_to_primary(method_name, args)
+        @primary_pool
 
-      elsif stuck_to_master?
+      elsif stuck_to_primary?
 
-        # we're on master because we already stuck this proxy in this
+        # we're on primary because we already stuck this proxy in this
         # request or because we got stuck in previous requests and the
         # stickiness is still valid
-        @master_pool
+        @primary_pool
 
-      # all slaves are down (or empty)
-      elsif @slave_pool.completely_blacklisted?
-        stick_to_master(method_name, args)
-        @master_pool
+      # all replicas are down (or empty)
+      elsif @replica_pool.completely_blacklisted?
+        stick_to_primary(method_name, args)
+        @primary_pool
 
       elsif in_transaction?
-        @master_pool
+        @primary_pool
 
-      # yay! use a slave
+      # yay! use a replica
       else
-        @slave_pool
+        @replica_pool
       end
     end
 
-    # do these args require a master connection
-    def needs_master?(method_name, args)
-      true
+    # Do these args require a primary connection
+    def needs_primary?(method_name, args)
+      if respond_to?(:needs_master?)
+        warn "#{self.class}#needs_master? is deprecated. Switch to #needs_primary?"
+        needs_master?(method_name, args)
+      else
+        true
+      end
     end
 
     def in_transaction?
@@ -268,16 +278,21 @@ module Makara
       @hijacked = false
     end
 
-    def stuck_to_master?
+    def stuck_to_primary?
       sticky? && Makara::Context.stuck?(@id)
     end
 
-    def stick_to_master(method_name, args)
+    def stick_to_primary(method_name, args)
       # check to see if we're configured, bypassed, or some custom implementation has input
       return unless should_stick?(method_name, args)
 
       # do the sticking
-      stick_to_master!
+      stick_to_primary!
+    end
+
+    def stick_to_master(method_names, args)
+      warn "#{self.class}#stick_to_master is deprecated. Switch to #stick_to_primary"
+      stick_to_primary(method_names, args)
     end
 
     # For the generic proxy implementation, we stick if we are sticky,
@@ -291,19 +306,19 @@ module Makara
       @sticky && !@skip_sticking
     end
 
-    # use the config parser to generate a master and slave pool
+    # use the config parser to generate a primary and replica pool
     def instantiate_connections
-      @master_pool = Makara::Pool.new('master', self)
-      @config_parser.master_configs.each do |master_config|
-        @master_pool.add master_config do
-          graceful_connection_for(master_config)
+      @primary_pool = Makara::Pool.new('primary', self)
+      @config_parser.primary_configs.each do |primary_config|
+        @primary_pool.add primary_config do
+          graceful_connection_for(primary_config)
         end
       end
 
-      @slave_pool = Makara::Pool.new('slave', self)
-      @config_parser.slave_configs.each do |slave_config|
-        @slave_pool.add slave_config do
-          graceful_connection_for(slave_config)
+      @replica_pool = Makara::Pool.new('replica', self)
+      @config_parser.replica_configs.each do |replica_config|
+        @replica_pool.add replica_config do
+          graceful_connection_for(replica_config)
         end
       end
     end
@@ -311,15 +326,15 @@ module Makara
     def handling_an_all_execution(method_name)
       yield
     rescue ::Makara::Errors::NoConnectionsAvailable => e
-      if e.role == 'master'
-        # this means slave connections are good.
+      if e.role == 'primary'
+        # this means replica connections are good.
         return
       end
 
-      @slave_pool.disabled = true
+      @replica_pool.disabled = true
       yield
     ensure
-      @slave_pool.disabled = false
+      @replica_pool.disabled = false
     end
 
     def connection_for(config)

data/lib/makara/version.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 module Makara
   module VERSION
     MAJOR = 0
-    MINOR = 5
-    PATCH = 1
-    PRE = nil
+    MINOR = 6
+    PATCH = 0
+    PRE = "pre"
 
     def self.to_s
       [MAJOR, MINOR, PATCH, PRE].compact.join('.')

data/spec/active_record/connection_adapters/makara_abstract_adapter_error_handling_spec.rb

@@ -4,7 +4,7 @@ require 'active_record/connection_adapters/makara_abstract_adapter'
 describe ActiveRecord::ConnectionAdapters::MakaraAbstractAdapter::ErrorHandler do
   let(:handler){ described_class.new }
   let(:proxy) { FakeAdapter.new(config(1,1)) }
-  let(:connection){ proxy.master_pool.connections.first }
+  let(:connection){ proxy.primary_pool.connections.first }
 
   [
     %|Mysql::Error: : INSERT INTO `watchers` (`user_id`, `watchable_id`, `watchable_type`) VALUES|,
@@ -63,7 +63,7 @@ describe ActiveRecord::ConnectionAdapters::MakaraAbstractAdapter::ErrorHandler d
     let(:config) { YAML.load(ERB.new(File.read(config_path)).result)['test'] }
     let(:handler){ described_class.new }
     let(:proxy) { FakeAdapter.new(config) }
-    let(:connection){ proxy.master_pool.connections.first }
+    let(:connection){ proxy.primary_pool.connections.first }
     let(:msg1) { "ActiveRecord::StatementInvalid: Mysql2::Error: Unknown command1: SELECT `users`.* FROM `users` WHERE `users`.`id` = 53469 LIMIT 1" }
     let(:msg2) { "activeRecord::statementInvalid: mysql2::error: unknown command2: SELECT `users`.* FROM `users` WHERE `users`.`id` = 53469 LIMIT 1" }
     let(:msg3) { "ActiveRecord::StatementInvalid: Mysql2::Error: Unknown command3: SELECT `users`.* FROM `users` WHERE `users`.`id` = 53469 LIMIT 1" }

data/spec/active_record/connection_adapters/makara_abstract_adapter_spec.rb

@@ -36,10 +36,10 @@ describe ActiveRecord::ConnectionAdapters::MakaraAbstractAdapter do
     'select release_lock(\'foo\')' => true,
     'select pg_advisory_lock(12345)' => true,
     'select pg_advisory_unlock(12345)' => true
-  }.each do |sql, should_go_to_master|
-    it "determines that \"#{sql}\" #{should_go_to_master ? 'requires' : 'does not require'} master" do
+  }.each do |sql, should_go_to_primary|
+    it "determines that \"#{sql}\" #{should_go_to_primary ? 'requires' : 'does not require'} primary" do
       proxy = klass.new(config(1,1))
-      expect(proxy.master_for?(sql)).to eq(should_go_to_master)
+      expect(proxy.primary_for?(sql)).to eq(should_go_to_primary)
     end
   end
 
@@ -59,8 +59,8 @@ describe ActiveRecord::ConnectionAdapters::MakaraAbstractAdapter do
   }.each do |sql, should_send_to_all_connections|
     it "determines that \"#{sql}\" #{should_send_to_all_connections ? 'should' : 'should not'} be sent to all underlying connections" do
       proxy = klass.new(config(1,1))
-      proxy.master_pool.connections.each{|con| expect(con).to receive(:execute).with(sql).once}
-      proxy.slave_pool.connections.each do |con|
+      proxy.primary_pool.connections.each{|con| expect(con).to receive(:execute).with(sql).once}
+      proxy.replica_pool.connections.each do |con|
         if should_send_to_all_connections
           expect(con).to receive(:execute).with(sql).once
         else
@@ -102,7 +102,7 @@ describe ActiveRecord::ConnectionAdapters::MakaraAbstractAdapter do
         max_treats IS NULL
     } => true
   }.each do |sql,should_stick|
-    it "should #{should_stick ? 'stick' : 'not stick'} to master if handling sql like \"#{sql}\"" do
+    it "should #{should_stick ? 'stick' : 'not stick'} to primary if handling sql like \"#{sql}\"" do
       proxy = klass.new(config(0,0))
       expect(proxy.would_stick?(sql)).to eq(should_stick)
     end

data/spec/active_record/connection_adapters/makara_mysql2_adapter_spec.rb

@@ -21,17 +21,17 @@ describe 'MakaraMysql2Adapter' do
       expect(ActiveRecord::Base.connection).to be_instance_of(ActiveRecord::ConnectionAdapters::MakaraMysql2Adapter)
     end
 
-    it 'should execute a send_to_all against master even if no slaves are connected' do
+    it 'should execute a send_to_all against primary even if no replicas are connected' do
       establish_connection(config)
       connection = ActiveRecord::Base.connection
 
-      connection.slave_pool.connections.each do |c|
+      connection.replica_pool.connections.each do |c|
         allow(c).to receive(:_makara_blacklisted?){ true }
         allow(c).to receive(:_makara_connected?){ false }
         expect(c).to receive(:execute).with('SET @t1 = 1').never
       end
 
-      connection.master_pool.connections.each do |c|
+      connection.primary_pool.connections.each do |c|
         expect(c).to receive(:execute).with('SET @t1 = 1')
       end
 
@@ -44,7 +44,7 @@ describe 'MakaraMysql2Adapter' do
       establish_connection(config)
       connection = ActiveRecord::Base.connection
 
-      (connection.slave_pool.connections | connection.master_pool.connections).each do |c|
+      (connection.replica_pool.connections | connection.primary_pool.connections).each do |c|
         allow(c).to receive(:_makara_blacklisted?){ true }
         allow(c).to receive(:_makara_connected?){ false }
         expect(c).to receive(:execute).with('SET @t1 = 1').never
@@ -62,7 +62,7 @@ describe 'MakaraMysql2Adapter' do
 
       it 'should not blow up if a connection fails' do
         wrong_config = config.deep_dup
-        wrong_config['makara']['connections'].select{|h| h['role'] == 'slave' }.each{|h| h['username'] = 'other'}
+        wrong_config['makara']['connections'].select{|h| h['role'] == 'replica' }.each{|h| h['username'] = 'other'}
 
         original_method = ActiveRecord::Base.method(:mysql2_connection)
 
@@ -84,8 +84,8 @@ describe 'MakaraMysql2Adapter' do
           original_method.call(config)
         end
 
-        ActiveRecord::Base.connection.slave_pool.connections.each(&:_makara_whitelist!)
-        ActiveRecord::Base.connection.slave_pool.provide do |con|
+        ActiveRecord::Base.connection.replica_pool.connections.each(&:_makara_whitelist!)
+        ActiveRecord::Base.connection.replica_pool.provide do |con|
           res = con.execute('SELECT count(*) FROM users')
           if defined?(JRUBY_VERSION)
             expect(res[0]).to eq('count(*)' => 0)
@@ -106,16 +106,16 @@ describe 'MakaraMysql2Adapter' do
       change_context
     end
 
-    it 'should have one master and two slaves' do
-      expect(connection.master_pool.connection_count).to eq(1)
-      expect(connection.slave_pool.connection_count).to eq(2)
+    it 'should have one primary and two replicas' do
+      expect(connection.primary_pool.connection_count).to eq(1)
+      expect(connection.replica_pool.connection_count).to eq(2)
     end
 
     it 'should allow real queries to work' do
       connection.execute("INSERT INTO users (name) VALUES ('John')")
 
-      connection.master_pool.connections.each do |master|
-        expect(master).to receive(:execute).never
+      connection.primary_pool.connections.each do |primary|
+        expect(primary).to receive(:execute).never
       end
 
       change_context
@@ -130,40 +130,42 @@ describe 'MakaraMysql2Adapter' do
     end
 
     it 'should send SET operations to each connection' do
-      connection.master_pool.connections.each do |con|
+      connection.primary_pool.connections.each do |con|
         expect(con).to receive(:execute).with('SET @t1 = 1').once
       end
 
-      connection.slave_pool.connections.each do |con|
+      connection.replica_pool.connections.each do |con|
         expect(con).to receive(:execute).with('SET @t1 = 1').once
       end
       connection.execute("SET @t1 = 1")
     end
 
-    it 'should send reads to the slave' do
+    it 'should send reads to the replica' do
       # ensure the next connection will be the first one
       allow_any_instance_of(Makara::Strategies::RoundRobin).to receive(:single_one?){ true }
 
-      con = connection.slave_pool.connections.first
+      con = connection.replica_pool.connections.first
       expect(con).to receive(:execute).with('SELECT * FROM users').once
 
       connection.execute('SELECT * FROM users')
     end
 
-    it 'should send exists? to slave' do
+    it 'should send exists? to replica' do
       allow_any_instance_of(Makara::Strategies::RoundRobin).to receive(:single_one?){ true }
       Test::User.exists? # flush other (schema) things that need to happen
 
-      con = connection.slave_pool.connections.first
+      con = connection.replica_pool.connections.first
       expect(con).to receive(:exec_query) do |query|
         expect(query).to match(/SELECT\s+1\s*(AS one)?\s+FROM .?users.?\s+LIMIT\s+.?1/)
-      end.once.and_call_original
+      end.once.
+        # and_call_original # Switch back to this once https://github.com/rspec/rspec-mocks/pull/1385 is released
+        and_wrap_original { |m, *args| m.call(*args.first(3)) }
 
       Test::User.exists?
     end
 
-    it 'should send writes to master' do
-      con = connection.master_pool.connections.first
+    it 'should send writes to primary' do
+      con = connection.primary_pool.connections.first
       expect(con).to receive(:execute).with('UPDATE users SET name = "bob" WHERE id = 1')
       connection.execute('UPDATE users SET name = "bob" WHERE id = 1')
     end
@@ -174,7 +176,7 @@ describe 'MakaraMysql2Adapter' do
     end
 
     it 'should allow reconnecting when one of the nodes is blacklisted' do
-      con = connection.slave_pool.connections.first
+      con = connection.replica_pool.connections.first
       allow(con).to receive(:_makara_blacklisted?){ true }
       connection.reconnect!
     end
@@ -196,11 +198,11 @@ describe 'MakaraMysql2Adapter' do
         load(File.dirname(__FILE__) + '/../../support/schema.rb')
         change_context
 
-        connection.slave_pool.connections.each do |slave|
+        connection.replica_pool.connections.each do |replica|
           # Using method missing to help with back trace, literally
-          # no query should be executed on slave once a transaction is opened
-          expect(slave).to receive(:method_missing).never
-          expect(slave).to receive(:execute).never
+          # no query should be executed on replica once a transaction is opened
+          expect(replica).to receive(:method_missing).never
+          expect(replica).to receive(:execute).never
         end
       end