switchman 2.0.2 → 3.0.0

data/lib/switchman/default_shard.rb

@@ -4,17 +4,44 @@ require 'switchman/database_server'
 
 module Switchman
   class DefaultShard
-    def id; 'default'; end
+    def id
+      'default'
+    end
     alias cache_key id
-    def activate(*categories); yield; end
-    def activate!(*categories); end
-    def default?; true; end
-    def primary?; true; end
-    def relative_id_for(local_id, target = nil); local_id; end
-    def global_id_for(local_id); local_id; end
-    def database_server_id; nil; end
-    def database_server; DatabaseServer.find(nil); end
-    def new_record?; false; end
+    def activate(*_classes)
+      yield
+    end
+
+    def activate!(*classes); end
+
+    def default?
+      true
+    end
+
+    def primary?
+      true
+    end
+
+    def relative_id_for(local_id, _target = nil)
+      local_id
+    end
+
+    def global_id_for(local_id)
+      local_id
+    end
+
+    def database_server_id
+      nil
+    end
+
+    def database_server
+      DatabaseServer.find(nil)
+    end
+
+    def new_record?
+      false
+    end
+
     def name
       unless instance_variable_defined?(:@name)
         @name = nil # prevent taking this branch on recursion
@@ -22,18 +49,27 @@ module Switchman
       end
       @name
     end
-    def description; ::Rails.env; end
+
+    def description
+      ::Rails.env
+    end
+
     # The default's shard is always the default shard
-    def shard; self; end
-    def _dump(depth)
+    def shard
+      self
+    end
+
+    def _dump(_depth)
       ''
     end
-    def self._load(str)
+
+    def self._load(_str)
       Shard.default
     end
 
-    def ==(rhs)
-      return true if rhs.is_a?(DefaultShard) || (rhs.is_a?(Shard) && rhs[:default])
+    def ==(other)
+      return true if other.is_a?(DefaultShard) || (other.is_a?(Shard) && other[:default])
+
       super
     end
 

data/lib/switchman/engine.rb

@@ -4,24 +4,30 @@ module Switchman
   class Engine < ::Rails::Engine
     isolate_namespace Switchman
 
-    config.autoload_once_paths << File.expand_path("app/models", config.paths.path)
+    # enable Rails 6.1 style connection handling
+    config.active_record.legacy_connection_handling = false
+    config.active_record.writing_role = :primary
+
+    config.autoload_once_paths << File.expand_path('app/models', config.paths.path)
 
     def self.lookup_stores(cache_store_config)
       result = {}
       cache_store_config.each do |key, value|
         next if value.is_a?(String)
+
         result[key] = ::ActiveSupport::Cache.lookup_store(value)
       end
 
-      cache_store_config.each do |key, value|
+      cache_store_config.each do |key, value| # rubocop:disable Style/CombinableLoops
         next unless value.is_a?(String)
+
         result[key] = result[value]
       end
       result
     end
 
-    initializer 'switchman.initialize_cache', :before => 'initialize_cache' do
-      require "switchman/active_support/cache"
+    initializer 'switchman.initialize_cache', before: 'initialize_cache' do
+      require 'switchman/active_support/cache'
       ::ActiveSupport::Cache.singleton_class.prepend(ActiveSupport::Cache::ClassMethods)
 
       # if we haven't already setup our cache map out-of-band, set it up from
@@ -31,9 +37,7 @@ module Switchman
       # to fill just the Rails.env entry in the cache map.
       unless Switchman.config[:cache_map].present?
         cache_store_config = ::Rails.configuration.cache_store
-        unless cache_store_config.is_a?(Hash)
-          cache_store_config = {::Rails.env => cache_store_config}
-        end
+        cache_store_config = { ::Rails.env => cache_store_config } unless cache_store_config.is_a?(Hash)
 
         Switchman.config[:cache_map] = Engine.lookup_stores(cache_store_config)
       end
@@ -42,7 +46,7 @@ module Switchman
       # config.cache_store) didn't have an entry for Rails.env, add one using
       # lookup_store(nil); matches the behavior of Rails' default
       # initialize_cache initializer when config.cache_store is nil.
-      unless Switchman.config[:cache_map].has_key?(::Rails.env)
+      unless Switchman.config[:cache_map].key?(::Rails.env)
         value = ::ActiveSupport::Cache.lookup_store(nil)
         Switchman.config[:cache_map][::Rails.env] = value
       end
@@ -51,7 +55,7 @@ module Switchman
         store.middleware if store.respond_to?(:middleware)
       end.compact.uniq
       middlewares.each do |middleware|
-        config.middleware.insert_before("Rack::Runtime", middleware)
+        config.middleware.insert_before('Rack::Runtime', middleware)
       end
 
       # prevent :initialize_cache from trying to (or needing to) set
@@ -62,39 +66,41 @@ module Switchman
       ::Rails.cache = Switchman.config[:cache_map][::Rails.env]
     end
 
-    initializer 'switchman.extend_ar', :before => "active_record.initialize_database" do
+    initializer 'switchman.extend_ar', before: 'active_record.initialize_database' do
       ::ActiveSupport.on_load(:active_record) do
-        require "switchman/active_record/abstract_adapter"
-        require "switchman/active_record/association"
-        require "switchman/active_record/attribute_methods"
-        require "switchman/active_record/base"
-        require "switchman/active_record/batches"
-        require "switchman/active_record/calculations"
-        require "switchman/active_record/connection_handler"
-        require "switchman/active_record/connection_pool"
-        require "switchman/active_record/finder_methods"
-        require "switchman/active_record/log_subscriber"
-        require "switchman/active_record/migration"
-        require "switchman/active_record/model_schema"
-        require "switchman/active_record/persistence"
-        require "switchman/active_record/predicate_builder"
-        require "switchman/active_record/query_cache"
-        require "switchman/active_record/query_methods"
-        require "switchman/active_record/reflection"
-        require "switchman/active_record/relation"
-        require "switchman/active_record/spawn_methods"
-        require "switchman/active_record/statement_cache"
-        require "switchman/active_record/type_caster"
-        require "switchman/active_record/where_clause_factory"
-        require "switchman/arel"
-        require "switchman/call_super"
-        require "switchman/rails"
-        require "switchman/guard_rail/relation"
-        require_dependency "switchman/shard"
-        require "switchman/standard_error"
+        require 'switchman/active_record/abstract_adapter'
+        require 'switchman/active_record/association'
+        require 'switchman/active_record/attribute_methods'
+        require 'switchman/active_record/base'
+        require 'switchman/active_record/calculations'
+        require 'switchman/active_record/connection_pool'
+        require 'switchman/active_record/database_configurations'
+        require 'switchman/active_record/database_configurations/database_config'
+        require 'switchman/active_record/finder_methods'
+        require 'switchman/active_record/log_subscriber'
+        require 'switchman/active_record/migration'
+        require 'switchman/active_record/model_schema'
+        require 'switchman/active_record/persistence'
+        require 'switchman/active_record/predicate_builder'
+        require 'switchman/active_record/query_cache'
+        require 'switchman/active_record/query_methods'
+        require 'switchman/active_record/reflection'
+        require 'switchman/active_record/relation'
+        require 'switchman/active_record/spawn_methods'
+        require 'switchman/active_record/statement_cache'
+        require 'switchman/active_record/tasks/database_tasks'
+        require 'switchman/active_record/type_caster'
+        require 'switchman/arel'
+        require 'switchman/call_super'
+        require 'switchman/rails'
+        require 'switchman/guard_rail/relation'
+        require 'switchman/standard_error'
 
         ::StandardError.include(StandardError)
 
+        self.default_shard = ::Rails.env.to_sym
+        self.default_role = :primary
+
         include ActiveRecord::Base
         include ActiveRecord::AttributeMethods
         include ActiveRecord::Persistence
@@ -106,6 +112,8 @@ module Switchman
         ::ActiveRecord::StatementCache::Substitute.send(:attr_accessor, :primary, :sharded)
 
         ::ActiveRecord::Associations::CollectionAssociation.prepend(ActiveRecord::CollectionAssociation)
+        ::ActiveRecord::Associations::HasOneAssociation.prepend(ActiveRecord::ForeignAssociation)
+        ::ActiveRecord::Associations::HasManyAssociation.prepend(ActiveRecord::ForeignAssociation)
 
         ::ActiveRecord::PredicateBuilder.singleton_class.prepend(ActiveRecord::PredicateBuilder)
 
@@ -117,21 +125,22 @@ module Switchman
 
         ::ActiveRecord::Associations::Preloader::Association.prepend(ActiveRecord::Preloader::Association)
         ::ActiveRecord::ConnectionAdapters::AbstractAdapter.prepend(ActiveRecord::AbstractAdapter)
-        ::ActiveRecord::ConnectionAdapters::ConnectionHandler.prepend(ActiveRecord::ConnectionHandler)
         ::ActiveRecord::ConnectionAdapters::ConnectionPool.prepend(ActiveRecord::ConnectionPool)
         ::ActiveRecord::ConnectionAdapters::AbstractAdapter.prepend(ActiveRecord::QueryCache)
 
+        ::ActiveRecord::DatabaseConfigurations.prepend(ActiveRecord::DatabaseConfigurations)
+        ::ActiveRecord::DatabaseConfigurations::DatabaseConfig.prepend(ActiveRecord::DatabaseConfigurations::DatabaseConfig)
+
         ::ActiveRecord::LogSubscriber.prepend(ActiveRecord::LogSubscriber)
         ::ActiveRecord::Migration.prepend(ActiveRecord::Migration)
         ::ActiveRecord::Migration::Compatibility::V5_0.prepend(ActiveRecord::Migration::Compatibility::V5_0)
-        ::ActiveRecord::MigrationContext.prepend(ActiveRecord::MigrationContext) if ::Rails.version >= '5.2'
+        ::ActiveRecord::MigrationContext.prepend(ActiveRecord::MigrationContext)
         ::ActiveRecord::Migrator.prepend(ActiveRecord::Migrator)
 
         ::ActiveRecord::Reflection::AbstractReflection.include(ActiveRecord::Reflection::AbstractReflection)
         ::ActiveRecord::Reflection::AssociationReflection.prepend(ActiveRecord::Reflection::AssociationScopeCache)
         ::ActiveRecord::Reflection::ThroughReflection.prepend(ActiveRecord::Reflection::AssociationScopeCache)
         ::ActiveRecord::Reflection::AssociationReflection.prepend(ActiveRecord::Reflection::AssociationReflection)
-        ::ActiveRecord::Relation.prepend(ActiveRecord::Batches)
         ::ActiveRecord::Relation.prepend(ActiveRecord::Calculations)
         ::ActiveRecord::Relation.include(ActiveRecord::FinderMethods)
         ::ActiveRecord::Relation.include(ActiveRecord::QueryMethods)
@@ -140,8 +149,10 @@ module Switchman
         ::ActiveRecord::Relation.include(ActiveRecord::SpawnMethods)
         ::ActiveRecord::Relation.include(CallSuper)
 
-        ::ActiveRecord::Relation::WhereClauseFactory.prepend(ActiveRecord::WhereClauseFactory)
         ::ActiveRecord::PredicateBuilder::AssociationQueryValue.prepend(ActiveRecord::PredicateBuilder::AssociationQueryValue)
+
+        ::ActiveRecord::Tasks::DatabaseTasks.singleton_class.prepend(ActiveRecord::Tasks::DatabaseTasks)
+
         ::ActiveRecord::TypeCaster::Map.include(ActiveRecord::TypeCaster::Map)
         ::ActiveRecord::TypeCaster::Connection.include(ActiveRecord::TypeCaster::Connection)
 
@@ -153,12 +164,10 @@ module Switchman
     end
 
     def self.foreign_key_check(name, type, limit: nil)
-      if name.to_s =~ /_id\z/ && type.to_s == 'integer' && limit.to_i < 8
-        puts "WARNING: All foreign keys need to be 8-byte integers. #{name} looks like a foreign key. If so, please add the option: `:limit => 8`"
-      end
+      puts "WARNING: All foreign keys need to be 8-byte integers. #{name} looks like a foreign key. If so, please add the option: `:limit => 8`" if name.to_s =~ /_id\z/ && type.to_s == 'integer' && limit.to_i < 8
     end
 
-    initializer 'switchman.extend_connection_adapters', :after => "active_record.initialize_database" do
+    initializer 'switchman.extend_connection_adapters', after: 'active_record.initialize_database' do
       ::ActiveSupport.on_load(:active_record) do
         ::ActiveRecord::ConnectionAdapters::AbstractAdapter.descendants.each do |klass|
           klass.prepend(ActiveRecord::AbstractAdapter::ForeignKeyCheck)
@@ -168,15 +177,11 @@ module Switchman
         ::ActiveRecord::ConnectionAdapters::TableDefinition.prepend(ActiveRecord::TableDefinition)
 
         if defined?(::ActiveRecord::ConnectionAdapters::PostgreSQLAdapter)
-          require "switchman/active_record/postgresql_adapter"
+          require 'switchman/active_record/postgresql_adapter'
           ::ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.prepend(ActiveRecord::PostgreSQLAdapter)
         end
 
-        # If Switchman::Shard wasn't loaded as of when ActiveRecord::Base initialized
-        # establish a connection here instead
-        if !Shard.instance_variable_get(:@default)
-          ::ActiveRecord::Base.establish_connection
-        end
+        Shard.send(:initialize_sharding)
       end
     end
 
@@ -187,21 +192,20 @@ module Switchman
       end
     end
 
-    initializer 'switchman.extend_guard_rail', :before => "switchman.extend_ar" do
+    initializer 'switchman.extend_guard_rail', before: 'switchman.extend_ar' do
       ::ActiveSupport.on_load(:active_record) do
-        require "switchman/guard_rail"
+        require 'switchman/guard_rail'
 
         ::GuardRail.singleton_class.prepend(GuardRail::ClassMethods)
       end
     end
 
-    initializer 'switchman.extend_controller', :after => "guard_rail.extend_ar" do
+    initializer 'switchman.extend_controller', after: 'guard_rail.extend_ar' do
       ::ActiveSupport.on_load(:action_controller) do
-        require "switchman/action_controller/caching"
+        require 'switchman/action_controller/caching'
 
         ::ActionController::Base.include(ActionController::Caching)
       end
     end
-
   end
 end

data/lib/switchman/environment.rb

@@ -4,17 +4,13 @@ require 'etc'
 
 module Switchman
   class Environment
+    def self.cpu_count(nproc_bin = 'nproc')
+      return Etc.nprocessors if Etc.respond_to?(:nprocessors)
 
-    def self.cpu_count(nproc_bin = "nproc")
-      if Etc.respond_to?(:nprocessors)
-        return Etc.nprocessors
-      end
-
-      return `#{nproc_bin}`.to_i
+      `#{nproc_bin}`.to_i
     rescue Errno::ENOENT
       # an environment where nproc` isnt available
-      return 0
+      0
     end
-
   end
 end

data/lib/switchman/errors.rb

@@ -2,5 +2,6 @@
 
 module Switchman
   class NonExistentShardError < RuntimeError; end
+
   class ParallelShardExecError < RuntimeError; end
 end

data/lib/switchman/guard_rail.rb

@@ -3,27 +3,14 @@
 module Switchman
   module GuardRail
     module ClassMethods
-      def self.prepended(klass)
-        klass.send(:remove_method, :ensure_handler)
+      def activate(role)
+        DatabaseServer.send(:reference_role, role)
+        super
       end
 
-      # drops the save_handler and ensure_handler calls from the vanilla
-      # GuardRail' implementation.
-      def activate!(environment)
-        environment ||= :primary
-        activated_environments << environment
-        old_environment = self.environment
-        Thread.current[:guard_rail_environment] = environment
-        old_environment
-      end
-
-      # since activate! really is just a variable swap now, it's safe to use in
-      # the ensure block, simplifying the implementation
-      def activate(environment)
-        old_environment = activate!(environment)
-        yield
-      ensure
-        activate!(old_environment)
+      def activate!(role)
+        DatabaseServer.send(:reference_role, role)
+        super
       end
     end
   end

data/lib/switchman/guard_rail/relation.rb

@@ -4,19 +4,17 @@ module Switchman
   module GuardRail
     module Relation
       def exec_queries(*args)
-        if self.lock_value
-          db = Shard.current(shard_category).database_server
-          if ::GuardRail.environment != db.guard_rail_environment
-            return db.unguard { super }
-          end
+        if lock_value
+          db = Shard.current(connection_classes).database_server
+          return db.unguard { super } if ::GuardRail.environment != db.guard_rail_environment
         end
         super
       end
 
-      %w{update_all delete_all}.each do |method|
+      %w[update_all delete_all].each do |method|
         class_eval <<-RUBY, __FILE__, __LINE__ + 1
           def #{method}(*args)
-            db = Shard.current(shard_category).database_server
+            db = Shard.current(connection_classes).database_server
             if ::GuardRail.environment != db.guard_rail_environment
               db.unguard { super }
             else

data/lib/switchman/r_spec_helper.rb

@@ -1,16 +1,13 @@
 # frozen_string_literal: true
 
-require "switchman/test_helper"
+require 'switchman/test_helper'
 
 module Switchman
   # including this module in your specs will give you several shards to
   # work with during specs:
   #  * Shard.default - the test database itself
-  #  * @shard1 - a shard possibly using the same connection as Shard.default
+  #  * @shard1 - a shard using the same connection as Shard.default
   #  * @shard2 - a shard using a dedicated connection
-  #  * @shard3 - a shard using the same connection as @shard1 (this might
-  #              be Shard.default if they already share a connection, or
-  #              a separate shard)
   module RSpecHelper
     @@keep_the_shards = false
     @@shard1 = nil
@@ -31,14 +28,15 @@ module Switchman
       root_group.prepend_before(:all) do |group|
         next if @@shard1
         next if @@sharding_failed
+
         # if we aren't actually going to run a sharding group/example,
         # don't set it up after all
         groups = group.class.descendant_filtered_examples.map(&:example_group).uniq
-        next unless groups.any?{ |group| RSpecHelper.included_in?(group) }
+        next unless groups.any? { |descendant_group| RSpecHelper.included_in?(descendant_group) }
 
-        puts "Setting up sharding for all specs..."
+        puts 'Setting up sharding for all specs...'
         Shard.delete_all
-        Switchman.cache.delete("default_shard")
+        Switchman.cache.delete('default_shard')
 
         @@shard1, @@shard2 = TestHelper.recreate_persistent_test_shards
         @@default_shard = Shard.default
@@ -49,23 +47,17 @@ module Switchman
           begin
             @@shard1 = @@shard1.create_new_shard
             @@shard2 = @@shard2.create_new_shard
-            if @@shard1.database_server == Shard.default.database_server
-              @@shard3 = nil
-            else
-              @@shard3 = @@shard1.database_server.create_new_shard
-            end
           rescue => e
-            $stderr.puts "Sharding setup FAILED!:"
+            warn 'Sharding setup FAILED!:'
             while e
-              $stderr.puts "\n#{e}\n"
-              $stderr.puts e.backtrace
+              warn "\n#{e}\n"
+              warn e.backtrace
               e = e.respond_to?(:cause) ? e.cause : nil
             end
             @@sharding_failed = true
-            (@@shard1.drop_database if @@shard1) rescue nil
-            (@@shard2.drop_database if @@shard3) rescue nil
-            (@@shard3.drop_database if @@shard3) rescue nil
-            @@shard1 = @@shard2 = @@shard3 = nil
+            @@shard1&.drop_database rescue nil
+            @@shard2&.drop_database rescue nil
+            @@shard1 = @@shard2 = nil
             Shard.delete_all
             Shard.default(reload: true)
             next
@@ -74,24 +66,20 @@ module Switchman
         # we'll re-persist in the group's `before :all`; we don't want them to exist
         # in the db before then
         Shard.delete_all
-        Switchman.cache.delete("default_shard")
+        Switchman.cache.delete('default_shard')
         Shard.default(reload: true)
-        puts "Done!"
+        puts 'Done!'
 
         at_exit do
           # preserve rspec's exit status
-          status= $!.is_a?(::SystemExit) ? $!.status : nil
-          puts "Tearing down sharding for all specs"
+          status = $!.is_a?(::SystemExit) ? $!.status : nil
+          puts 'Tearing down sharding for all specs'
           @@shard1.database_server.destroy unless @@shard1.database_server == Shard.default.database_server
           unless @@keep_the_shards
             @@shard1.drop_database
             @@shard1.destroy
             @@shard2.drop_database
             @@shard2.destroy
-            if @@shard3
-              @@shard3.drop_database
-              @@shard3.destroy
-            end
           end
           @@shard2.database_server.destroy
           exit status if status
@@ -100,10 +88,11 @@ module Switchman
 
       klass.before(:all) do
         next if @@sharding_failed
+
         dup = @@default_shard.dup
         dup.id = @@default_shard.id
         dup.save!
-        Switchman.cache.delete("default_shard")
+        Switchman.cache.delete('default_shard')
         Shard.default(reload: true)
         dup = @@shard1.dup
         dup.id = @@shard1.id
@@ -111,17 +100,12 @@ module Switchman
         dup = @@shard2.dup
         dup.id = @@shard2.id
         dup.save!
-        if @@shard3
-          dup = @@shard3.dup
-          dup.id = @@shard3.id
-          dup.save!
-        end
         @shard1, @shard2 = @@shard1, @@shard2
-        @shard3 = @@shard3 ? @@shard3 : Shard.default
       end
 
       klass.before do
-        raise "Sharding did not set up correctly" if @@sharding_failed
+        raise 'Sharding did not set up correctly' if @@sharding_failed
+
         Shard.clear_cache
         if use_transactional_tests
           Shard.default(reload: true)
@@ -139,6 +123,7 @@ module Switchman
 
       klass.after do
         next if @@sharding_failed
+
         if use_transactional_tests
           shards = [@shard2]
           shards << @shard1 unless @shard1.database_server == Shard.default.database_server
@@ -148,11 +133,18 @@ module Switchman
             end
           end
         end
+        # clean up after specs
+        DatabaseServer.all.each do |ds|
+          if ds.fake? && ds != @shard2.database_server
+            ds.shards.delete_all unless use_transactional_tests
+            ds.destroy
+          end
+        end
       end
 
       klass.after(:all) do
         Shard.connection.update("TRUNCATE #{Shard.quoted_table_name} CASCADE")
-        Switchman.cache.delete("default_shard")
+        Switchman.cache.delete('default_shard')
         Shard.default(reload: true)
       end
     end