switchman 2.1.0 → 3.0.6

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,40 +66,43 @@ 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/active_record/test_fixtures'
+        require 'switchman/arel'
+        require 'switchman/call_super'
+        require 'switchman/rails'
+        require 'switchman/guard_rail/relation'
+        require 'switchman/standard_error'
 
         ::StandardError.include(StandardError)
 
-        include ActiveRecord::Base
+        self.default_shard = ::Rails.env.to_sym
+        self.default_role = :primary
+
+        prepend ActiveRecord::Base
         include ActiveRecord::AttributeMethods
         include ActiveRecord::Persistence
         singleton_class.prepend ActiveRecord::ModelSchema::ClassMethods
@@ -106,6 +113,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 +126,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,9 +150,13 @@ 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::PredicateBuilder::PolymorphicArrayValue.prepend(ActiveRecord::PredicateBuilder::AssociationQueryValue)
+
+        ::ActiveRecord::Tasks::DatabaseTasks.singleton_class.prepend(ActiveRecord::Tasks::DatabaseTasks)
+
+        ::ActiveRecord::TestFixtures.prepend(ActiveRecord::TestFixtures)
+
         ::ActiveRecord::TypeCaster::Map.include(ActiveRecord::TypeCaster::Map)
         ::ActiveRecord::TypeCaster::Connection.include(ActiveRecord::TypeCaster::Connection)
 
@@ -154,12 +168,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)
@@ -169,15 +181,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
 
@@ -188,21 +196,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/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/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/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,48 +100,31 @@ 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)
-          @shard1 = Shard.find(@shard1.id)
-          @shard2 = Shard.find(@shard2.id)
-          shards = [@shard2]
-          shards << @shard1 unless @shard1.database_server == Shard.default.database_server
-          shards.each do |shard|
-            shard.activate do
-              ::ActiveRecord::Base.connection.begin_transaction joinable: false
-            end
-          end
-        end
       end
 
       klass.after do
         next if @@sharding_failed
-        if use_transactional_tests
-          shards = [@shard2]
-          shards << @shard1 unless @shard1.database_server == Shard.default.database_server
-          shards.each do |shard|
-            shard.activate do
-              ::ActiveRecord::Base.connection.rollback_transaction if ::ActiveRecord::Base.connection.transaction_open?
-            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")
+        # Don't truncate because that can create some fun cross-connection lock contention
+        Shard.delete_all
+        Switchman.cache.delete('default_shard')
         Shard.default(reload: true)
       end
     end

data/lib/switchman/rails.rb

@@ -1,18 +1,20 @@
 # frozen_string_literal: true
 
-module Switchman::Rails
-  module ClassMethods
-    def self.prepended(klass)
-      # in Rails 4+, the Rails.cache= method was used during bootstrap to set
-      # Rails.cache(_without_sharding) to the value from the config file. but now
-      # that that's done (the bootstrap happened before this module is included
-      # into Rails), we want to make sure no one tries to assign to Rails.cache,
-      # because it would be wrong w.r.t. sharding.
-      klass.send(:remove_method, :cache=)
-    end
+module Switchman
+  module Rails
+    module ClassMethods
+      def self.prepended(klass)
+        # in Rails 4+, the Rails.cache= method was used during bootstrap to set
+        # Rails.cache(_without_sharding) to the value from the config file. but now
+        # that that's done (the bootstrap happened before this module is included
+        # into Rails), we want to make sure no one tries to assign to Rails.cache,
+        # because it would be wrong w.r.t. sharding.
+        klass.send(:remove_method, :cache=)
+      end
 
-    def cache
-      Switchman::Shard.current.database_server.cache_store
+      def cache
+        Switchman::Shard.current.database_server.cache_store
+      end
     end
   end
 end

data/lib/switchman/sharded_instrumenter.rb

@@ -7,7 +7,7 @@ module Switchman
       @shard_host = shard_host
     end
 
-    def instrument(name, payload={})
+    def instrument(name, payload = {})
       shard = @shard_host&.shard
       # attribute_methods_generated? will be false during a reload -
       # when we might be doing a query while defining attribute methods,

data/lib/switchman/standard_error.rb

@@ -3,12 +3,24 @@
 module Switchman
   module StandardError
     def initialize(*args)
-      @active_shards = Shard.send(:active_shards).dup
+      # Shard.current can throw this when switchman isn't working right; if we try to
+      # do our stuff here, it'll cause a SystemStackError, which is a pain to deal with
+      if is_a?(::ActiveRecord::ConnectionNotEstablished)
+        super
+        return
+      end
+
+      begin
+        @active_shards = Shard.active_shards if defined?(Shard)
+      rescue ::ActiveRecord::ConnectionNotEstablished
+        # If we hit an error really early in boot, activerecord may not be initialized yet
+      end
+
       super
     end
 
-    def current_shard(category = :primary)
-      @active_shards&.[](category) || Shard.default
+    def current_shard(klass = ::ActiveRecord::Base)
+      @active_shards&.[](klass) || Shard.default
     end
   end
 end

data/lib/switchman/test_helper.rb

@@ -11,6 +11,7 @@ module Switchman
             Shard.create!(default: true)
           rescue
             raise unless dont_create
+
             # database doesn't exist yet, presumably cause we're creating it right now
             return [nil, nil]
           end
@@ -49,8 +50,8 @@ module Switchman
             shard1.destroy
             shard2.drop_database rescue nil
             shard2.destroy
-            shard1 = server1.create_new_shard(:name => server1.config[:shard1])
-            shard2 = server2.create_new_shard(:name => server1.config[:shard2])
+            shard1 = server1.create_new_shard(name: server1.config[:shard1])
+            shard2 = server2.create_new_shard(name: server1.config[:shard2])
           end
           [shard1, shard2]
         else
@@ -59,11 +60,12 @@ module Switchman
       end
 
       private
+
       def find_existing_test_shard(server, name)
         if server == Shard.default.database_server
           server.shards.where(name: name).first
         else
-          shard = Shard.where("database_server_id IS NOT NULL AND name=?", name).first
+          shard = Shard.where('database_server_id IS NOT NULL AND name=?', name).first
           # if somehow databases got created in a different order, change the shard to match
           shard.database_server = server if shard
           shard

data/lib/switchman/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Switchman
-  VERSION = "2.1.0"
+  VERSION = '3.0.6'
 end

data/lib/switchman.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require "guard_rail"
-require "switchman/open4"
-require "switchman/engine"
+require 'guard_rail'
+require 'switchman/open4'
+require 'switchman/engine'
 
 module Switchman
   def self.config