switchman 1.14.10 → 2.0.0

data/db/migrate/20130328224244_create_default_shard.rb

@@ -3,7 +3,7 @@ class CreateDefaultShard < ActiveRecord::Migration[4.2]
     unless Switchman::Shard.default.is_a?(Switchman::Shard)
       Switchman::Shard.reset_column_information
       Switchman::Shard.create!(:default => true)
-      Switchman::Shard.default(true)
+      Switchman::Shard.default(reload: true)
     end
   end
 end

data/lib/switchman.rb

@@ -1,4 +1,4 @@
-require "shackles"
+require "guard_rail"
 require "switchman/open4"
 require "switchman/engine"
 

data/lib/switchman/active_record/abstract_adapter.rb

@@ -4,8 +4,8 @@ module Switchman
   module ActiveRecord
     module AbstractAdapter
       module ForeignKeyCheck
-        def add_column(table, name, type, options = {})
-          Engine.foreign_key_check(name, type, options)
+        def add_column(table, name, type, limit: nil, **)
+          Engine.foreign_key_check(name, type, limit: limit)
           super
         end
       end
@@ -27,10 +27,6 @@ module Switchman
         quote_table_name(name)
       end
 
-      def use_qualified_names?
-        false
-      end
-
       protected
 
       def log(*args, &block)

data/lib/switchman/active_record/association.rb

@@ -30,17 +30,14 @@ module Switchman
     end
 
     module CollectionAssociation
-      method = ::Rails.version < '5.1' ? :get_records : :find_target
-      module_eval <<-RUBY, __FILE__, __LINE__ + 1
-        def #{method}
-          shards = reflection.options[:multishard] && owner.respond_to?(:associated_shards) ? owner.associated_shards : [shard]
-          # activate both the owner and the target's shard category, so that Reflection#join_id_for,
-          # when called for the owner, will be returned relative to shard the query will execute on
-          Shard.with_each_shard(shards, [klass.shard_category, owner.class.shard_category].uniq) do
-            super
-          end
+      def find_target
+        shards = reflection.options[:multishard] && owner.respond_to?(:associated_shards) ? owner.associated_shards : [shard]
+        # activate both the owner and the target's shard category, so that Reflection#join_id_for,
+        # when called for the owner, will be returned relative to shard the query will execute on
+        Shard.with_each_shard(shards, [klass.shard_category, owner.class.shard_category].uniq) do
+          super
         end
-      RUBY
+      end
     end
 
     module BelongsToAssociation

data/lib/switchman/active_record/base.rb

@@ -31,20 +31,20 @@ module Switchman
           @integral_id
         end
 
-        def transaction(*args)
+        def transaction(**)
           if self != ::ActiveRecord::Base && current_scope
             current_scope.activate do
               db = Shard.current(shard_category).database_server
-              if ::Shackles.environment != db.shackles_environment
-                db.unshackle { super }
+              if ::GuardRail.environment != db.guard_rail_environment
+                db.unguard { super }
               else
                 super
               end
             end
           else
             db = Shard.current(shard_category).database_server
-            if ::Shackles.environment != db.shackles_environment
-              db.unshackle { super }
+            if ::GuardRail.environment != db.guard_rail_environment
+              db.unguard { super }
             else
               super
             end
@@ -105,12 +105,12 @@ module Switchman
         end
       end
 
-      def save(*args)
+      def save(*, **)
         @shard_set_in_stone = true
         (self.class.current_scope || self.class.default_scoped).shard(shard, :implicit).scoping { super }
       end
 
-      def save!(*args)
+      def save!(*, **)
         @shard_set_in_stone = true
         (self.class.current_scope || self.class.default_scoped).shard(shard, :implicit).scoping { super }
       end
@@ -155,6 +155,15 @@ module Switchman
         self.class.connection.quote(id)
       end
 
+      def update_columns(*)
+        db = Shard.current(self.class.shard_category).database_server
+        if ::GuardRail.environment != db.guard_rail_environment
+          return db.unguard { super }
+        else
+          super
+        end
+      end
+
       protected
 
       # see also AttributeMethods#shard_category_code_for_reflection

data/lib/switchman/active_record/connection_handler.rb

@@ -4,8 +4,6 @@ module Switchman
   module ActiveRecord
     module ConnectionHandler
       def self.make_sharing_automagic(config, shard = Shard.current)
-        key = config[:adapter] == 'postgresql' ? :schema_search_path : :database
-
         # only load the shard name from the db if we have to
         if !config[:shard_name]
           # we may not be able to connect to this shard yet, cause it might be an empty database server
@@ -15,15 +13,13 @@ module Switchman
 
           config[:shard_name] ||= shard_name
         end
-
-        if !config[key] || config[key] == shard_name
-          # this may truncate the schema_search_path if it was not specified in database.yml
-          # but that's what our old behavior was anyway, so I guess it's okay
-          config[key] = '%{shard_name}'
-        end
       end
 
       def establish_connection(spec)
+        # Just skip establishing a sharded connection if sharding isn't loaded; we'll do it again later
+        # This only can happen when loading ActiveRecord::Base; after everything is loaded Shard will
+        # be defined and this will actually establish a connection
+        return unless defined?(Shard)
         pool = super
 
         # this is the first place that the adapter would have been required; but now we
@@ -39,14 +35,12 @@ module Switchman
           # to sharding will recurse onto itself trying to access column information
           Shard.default
 
+          config = pool.spec.config
           # automatically change config to allow for sharing connections with simple config
-          config = ::Rails.version < '5.1' ? spec.config : pool.spec.config
           ConnectionHandler.make_sharing_automagic(config)
           ConnectionHandler.make_sharing_automagic(Shard.default.database_server.config)
 
-          if ::Rails.version < '5.1'
-            ::ActiveRecord::Base.configurations[::Rails.env] = spec.instance_variable_get(:@config).stringify_keys
-          elsif ::Rails.version < '6.0'
+          if ::Rails.version < '6.0'
             ::ActiveRecord::Base.configurations[::Rails.env] = config.stringify_keys
           else
             # Adopted from the deprecated code that currently lives in rails proper
@@ -61,7 +55,7 @@ module Switchman
           Shard.default.remove_instance_variable(:@name) if Shard.default.instance_variable_defined?(:@name)
         end
 
-        @shard_connection_pools ||= { [:master, Shard.default.database_server.shareable? ? ::Rails.env : Shard.default] => pool}
+        @shard_connection_pools ||= { [:primary, Shard.default.database_server.shareable? ? ::Rails.env : Shard.default] => pool}
 
         category = pool.spec.name.to_sym
         proxy = ConnectionPoolProxy.new(category,
@@ -70,13 +64,13 @@ module Switchman
         owner_to_pool[pool.spec.name] = proxy
 
         if first_time
-          if Shard.default.database_server.config[:prefer_slave]
-            Shard.default.database_server.shackle!
+          if Shard.default.database_server.config[:prefer_secondary]
+            Shard.default.database_server.guard!
           end
 
-          if Shard.default.is_a?(DefaultShard) && Shard.default.database_server.config[:slave]
-            Shard.default.database_server.shackle!
-            Shard.default(true)
+          if Shard.default.is_a?(DefaultShard) && Shard.default.database_server.config[:secondary]
+            Shard.default.database_server.guard!
+            Shard.default(reload: true)
           end
         end
 
@@ -132,8 +126,7 @@ module Switchman
             else
               ancestor_pool.spec
             end
-            spec = spec.to_hash if ::Rails.version >= '5.1'
-            pool = establish_connection spec
+            pool = establish_connection(spec.to_hash)
             pool.instance_variable_set(:@schema_cache, ancestor_pool.schema_cache) if ancestor_pool.schema_cache
             pool
           elsif spec_name != "primary"

data/lib/switchman/active_record/connection_pool.rb

@@ -84,18 +84,6 @@ module Switchman
         end
 
         spec.config[:shard_name] = self.shard.name
-        case conn.adapter_name
-          when 'MySQL', 'Mysql2'
-            conn.execute("USE #{spec.config[:database]}")
-          when 'PostgreSQL'
-            if conn.schema_search_path != spec.config[:schema_search_path]
-              conn.schema_search_path = spec.config[:schema_search_path]
-            end
-          when 'SQLite'
-            # This is an artifact of the adapter modifying the path to be an absolute path when it is instantiated; just let it slide
-          else
-            raise("Cannot switch databases on same DatabaseServer with adapter type: #{conn.adapter_name}. Limit one Shard per DatabaseServer.")
-        end
         conn.shard = shard
       end
 

data/lib/switchman/active_record/log_subscriber.rb

@@ -18,18 +18,14 @@ module Switchman
         shard = "  [#{shard[:database_server_id]}:#{shard[:id]} #{shard[:env]}]" if shard
 
         unless (payload[:binds] || []).empty?
-          if ::Rails.version < '5.0.3'
-            binds = "  " + payload[:binds].map { |attr| render_bind(attr) }.inspect
-          else
-            use_old_format = (::Rails.version < '5.1') ? (::Rails.version < '5.0.7') : (::Rails.version < '5.1.5')
-            args = use_old_format ?
-              [payload[:binds], payload[:type_casted_binds]] :
-              [payload[:type_casted_binds]]
-            casted_params = type_casted_binds(*args)
-            binds = "  " + payload[:binds].zip(casted_params).map { |attr, value|
-              render_bind(attr, value)
-            }.inspect
-          end
+          use_old_format = (::Rails.version < '5.1.5')
+          args = use_old_format ?
+            [payload[:binds], payload[:type_casted_binds]] :
+            [payload[:type_casted_binds]]
+          casted_params = type_casted_binds(*args)
+          binds = "  " + payload[:binds].zip(casted_params).map { |attr, value|
+            render_bind(attr, value)
+          }.inspect
         end
 
         name = colorize_payload_name(name, payload[:name])

data/lib/switchman/active_record/migration.rb

@@ -33,5 +33,14 @@ module Switchman
         ::ActiveRecord::Migrator::MIGRATOR_SALT * shard_name_hash
       end
     end
+
+    module MigrationContext
+      def migrations
+        return @migrations if instance_variable_defined?(:@migrations)
+        migrations_cache = Thread.current[:migrations_cache] ||= {}
+        key = Digest::MD5.hexdigest(migration_files.sort.join(','))
+        @migrations = migrations_cache[key] ||= super
+      end
+    end
   end
 end

data/lib/switchman/active_record/postgresql_adapter.rb

@@ -38,51 +38,26 @@ module Switchman
         select_values("SELECT * FROM unnest(current_schemas(false))")
       end
 
-      def use_qualified_names?
-        @config[:use_qualified_names]
-      end
-
       def tables(name = nil)
-        schema = shard.name if use_qualified_names?
-
         query(<<-SQL, 'SCHEMA').map { |row| row[0] }
           SELECT tablename
           FROM pg_tables
-          WHERE schemaname = #{schema ? "'#{schema}'" : 'ANY (current_schemas(false))'}
+          WHERE schemaname = '#{shard.name}'
         SQL
       end
 
-      if ::Rails.version >= '5.1'
-        def extract_schema_qualified_name(string)
-          name = ::ActiveRecord::ConnectionAdapters::PostgreSQL::Utils.extract_schema_qualified_name(string.to_s)
-          if string && !name.schema && use_qualified_names?
-            name.instance_variable_set(:@schema, shard.name)
-          end
-          [name.schema, name.identifier]
-        end
-      else
-        def data_source_exists?(name)
-          name = ::ActiveRecord::ConnectionAdapters::PostgreSQL::Utils.extract_schema_qualified_name(name.to_s)
-          return false unless name.identifier
-          if !name.schema && use_qualified_names?
-            name.instance_variable_set(:@schema, shard.name)
-          end
-
-          exec_query(<<-SQL, 'SCHEMA').rows.first[0].to_i > 0
-            SELECT COUNT(*)
-            FROM pg_class c
-            LEFT JOIN pg_namespace n ON n.oid = c.relnamespace
-            WHERE c.relkind IN ('r','v','m') -- (r)elation/table, (v)iew, (m)aterialized view
-            AND c.relname = '#{name.identifier}'
-            AND n.nspname = #{name.schema ? "'#{name.schema}'" : 'ANY (current_schemas(false))'}
-          SQL
+      def extract_schema_qualified_name(string)
+        name = ::ActiveRecord::ConnectionAdapters::PostgreSQL::Utils.extract_schema_qualified_name(string.to_s)
+        if string && !name.schema
+          name.instance_variable_set(:@schema, shard.name)
         end
+        [name.schema, name.identifier]
       end
 
       def view_exists?(name)
         name = ::ActiveRecord::ConnectionAdapters::PostgreSQL::Utils.extract_schema_qualified_name(name.to_s)
         return false unless name.identifier
-        if !name.schema && use_qualified_names?
+        if !name.schema
           name.instance_variable_set(:@schema, shard.name)
         end
 
@@ -92,13 +67,11 @@ module Switchman
           LEFT JOIN pg_namespace n ON n.oid = c.relnamespace
           WHERE c.relkind IN ('v','m') -- (v)iew, (m)aterialized view
           AND c.relname = '#{name.identifier}'
-          AND n.nspname = #{name.schema ? "'#{name.schema}'" : 'ANY (current_schemas(false))'}
+          AND n.nspname = '#{shard.name}'
         SQL
       end
 
       def indexes(table_name)
-        schema = shard.name if use_qualified_names?
-
         result = query(<<-SQL, 'SCHEMA')
            SELECT distinct i.relname, d.indisunique, d.indkey, pg_get_indexdef(d.indexrelid), t.oid
            FROM pg_class t
@@ -107,7 +80,7 @@ module Switchman
            WHERE i.relkind = 'i'
              AND d.indisprimary = 'f'
              AND t.relname = '#{table_name}'
-             AND i.relnamespace IN (SELECT oid FROM pg_namespace WHERE nspname = #{schema ? "'#{schema}'" : 'ANY (current_schemas(false))'} )
+             AND i.relnamespace IN (SELECT oid FROM pg_namespace WHERE nspname = '#{shard.name}' )
           ORDER BY i.relname
         SQL
 
@@ -145,8 +118,6 @@ module Switchman
       end
 
       def index_name_exists?(table_name, index_name, _default = nil)
-        schema = shard.name if use_qualified_names?
-
         exec_query(<<-SQL, 'SCHEMA').rows.first[0].to_i > 0
             SELECT COUNT(*)
             FROM pg_class t
@@ -155,7 +126,7 @@ module Switchman
             WHERE i.relkind = 'i'
               AND i.relname = '#{index_name}'
               AND t.relname = '#{table_name}'
-              AND i.relnamespace IN (SELECT oid FROM pg_namespace WHERE nspname = #{schema ? "'#{schema}'" : 'ANY (current_schemas(false))'} )
+              AND i.relnamespace IN (SELECT oid FROM pg_namespace WHERE nspname = '#{shard.name}' )
         SQL
       end
 
@@ -169,7 +140,7 @@ module Switchman
       def quote_table_name(name)
         return quote_local_table_name(name) if @use_local_table_name
         name = ::ActiveRecord::ConnectionAdapters::PostgreSQL::Utils.extract_schema_qualified_name(name.to_s)
-        if !name.schema && use_qualified_names?
+        if !name.schema
           name.instance_variable_set(:@schema, shard.name)
         end
         name.quoted
@@ -184,7 +155,6 @@ module Switchman
       end
 
       def foreign_keys(table_name)
-        schema = shard.name if use_qualified_names?
 
         # mostly copy-pasted from AR - only change is to the nspname condition for qualified names support
         fk_info = select_all <<-SQL.strip_heredoc
@@ -197,7 +167,7 @@ module Switchman
           JOIN pg_namespace t3 ON c.connamespace = t3.oid
           WHERE c.contype = 'f'
             AND t1.relname = #{quote(table_name)}
-            AND t3.nspname = #{schema ? "'#{schema}'" : 'ANY (current_schemas(false))'}
+            AND t3.nspname = '#{shard.name}'
           ORDER BY c.conname
         SQL
 
@@ -214,7 +184,7 @@ module Switchman
           # strip the schema name from to_table if it matches
           to_table = row['to_table']
           to_table_qualified_name = ::ActiveRecord::ConnectionAdapters::PostgreSQL::Utils.extract_schema_qualified_name(to_table)
-          if use_qualified_names? && to_table_qualified_name.schema == shard.name
+          if to_table_qualified_name.schema == shard.name
             to_table = to_table_qualified_name.identifier
           end
 
@@ -222,7 +192,7 @@ module Switchman
         end
       end
 
-      def add_index_options(_table_name, _column_name, _options = {})
+      def add_index_options(_table_name, _column_name, **)
         index_name, index_type, index_columns, index_options, algorithm, using = super
         algorithm = nil if DatabaseServer.creating_new_shard && algorithm == "CONCURRENTLY"
         [index_name, index_type, index_columns, index_options, algorithm, using]

data/lib/switchman/active_record/query_cache.rb

@@ -1,122 +1,32 @@
 module Switchman
   module ActiveRecord
     module QueryCache
-      if ::Rails.version < '5.0.1'
-        # thread local accessors to replace @query_cache_enabled
-        def query_cache
-          thread_cache = Thread.current[:query_cache] ||= {}
-          thread_cache[self.object_id] ||= Hash.new { |h,sql| h[sql] = {} }
-        end
-
-        def query_cache_enabled
-          Thread.current[:query_cache_enabled]
-        end
-
-        def query_cache_enabled=(value)
-          Thread.current[:query_cache_enabled] = value
-        end
-
-        # basically wholesale repeat of the methods from the original (see
-        # https://github.com/rails/rails/blob/master/activerecord/lib/active_record/connection_adapters/abstract/query_cache.rb),
-        # but with self.query_cache_enabled and self.query_cache_enabled= instead
-        # of @query_cache_enabled.
-
-        def enable_query_cache!
-          self.query_cache_enabled = true
-        end
-
-        def disable_query_cache!
-          self.query_cache_enabled = false
-        end
-
-        def cache
-          old, self.query_cache_enabled = query_cache_enabled, true
-          yield
-        ensure
-          self.query_cache_enabled = old
-          clear_query_cache unless self.query_cache_enabled
-        end
-
-        def uncached
-          old, self.query_cache_enabled = query_cache_enabled, false
-          yield
-        ensure
-          self.query_cache_enabled = old
-        end
-
-        def clear_query_cache
-          Thread.current[:query_cache]&.clear
-        end
-
-        def select_all(arel, name = nil, binds = [], preparable: nil)
-          if self.query_cache_enabled && !locked?(arel)
-            arel, binds = binds_from_relation(arel, binds)
-            sql = to_sql(arel, binds)
-            cache_sql(sql, binds) { super(sql, name, binds, preparable: preparable) }
-          else
-            super
-          end
-        end
-
-        # no reason to define these on the including class directly. the super
-        # works just as well from a method on the included module
-        [:insert, :update, :delete].each do |method_name|
-          class_eval <<-end_code, __FILE__, __LINE__ + 1
-            def #{method_name}(*args)
-              clear_query_cache if self.query_cache_enabled
-              super
-            end
-          end_code
-        end
-      end
 
       private
 
-      if ::Rails.version < '5.1'
-        def cache_sql(sql, binds)
-          # have to include the shard id in the cache key because of switching dbs on the same connection
-          sql = "#{self.shard.id}::#{sql}"
+      def cache_sql(sql, name, binds)
+        # have to include the shard id in the cache key because of switching dbs on the same connection
+        sql = "#{self.shard.id}::#{sql}"
+        @lock.synchronize do
           result =
               if query_cache[sql].key?(binds)
-                args = {:sql => sql, :binds => binds, :name => "CACHE", :connection_id => object_id}
-                args[:type_casted_binds] = -> { type_casted_binds(binds) } if ::Rails.version >= '5.0.7'
-                ::ActiveSupport::Notifications.instrument("sql.active_record", args)
+                args = {
+                  sql: sql,
+                  binds: binds,
+                  name: name,
+                  connection_id: object_id,
+                  cached: true
+                }
+                args[:type_casted_binds] = -> { type_casted_binds(binds) } if ::Rails.version >= '5.1.5'
+                ::ActiveSupport::Notifications.instrument(
+                    "sql.active_record",
+                    args
+                )
                 query_cache[sql][binds]
               else
                 query_cache[sql][binds] = yield
               end
-
-          if ::ActiveRecord::Result === result
-            result.dup
-          else
-            result.collect { |row| row.dup }
-          end
-        end
-      else
-        def cache_sql(sql, name, binds)
-          # have to include the shard id in the cache key because of switching dbs on the same connection
-          sql = "#{self.shard.id}::#{sql}"
-          @lock.synchronize do
-            result =
-                if query_cache[sql].key?(binds)
-                  args = {
-                    sql: sql,
-                    binds: binds,
-                    name: name,
-                    connection_id: object_id,
-                    cached: true
-                  }
-                  args[:type_casted_binds] = -> { type_casted_binds(binds) } if ::Rails.version >= '5.1.5'
-                  ::ActiveSupport::Notifications.instrument(
-                      "sql.active_record",
-                      args
-                  )
-                  query_cache[sql][binds]
-                else
-                  query_cache[sql][binds] = yield
-                end
-            result.dup
-          end
+          result.dup
         end
       end
     end