switchman 1.15.0 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6521b8f2a993bab5cb400bdc0fa741fd6e2391e7efb9801f058f21fe3c75169f
-  data.tar.gz: e96468030c6d98b3c93730877ba6943d5c925255f59ed4a09c3ddfa0bce7388a
+  metadata.gz: 0d6fc62ea8d63155621448b9dc70e5aab0bfa3e15b766ad6bc8b7282e124933b
+  data.tar.gz: 210c939e4c6a5c1c4b340e81c91fa68c0e019adeabf7dd0500f42eaa3605ad1e
 SHA512:
-  metadata.gz: 32b791ddb7c5198a5fcd96448ee0abe59d011f0c422ba9115df5b44e50a53c8a6f4ac1bea35e2a98db52cbfb5f46cb501dbf30dde123125bfef599f67c1ccd86
-  data.tar.gz: ca11fa309c8f3c5bd7f9a9466327e95fddcff2342dc15d7732adaecab09911a2f9bfc0b2ed0d90cdd8899bf470d3a776945b86a470b8c84f5845878f9b46df0c
+  metadata.gz: 780cc1c19606c00ecfb8df648a3f2d1e9744f375ff0a1e7793482108f81221f313254e16873db977af14e19adb0cb3d1bd9af3318c15c92ba3e54e01a91eb072
+  data.tar.gz: fe688c62be4f0b5e36279b93925377d3165d238a19c37124d90d464b9eac08691f2b8f0f550e56ccf5dd092cd872a3bf1ec23780fc719b8b2cf3a62539a06113

data/app/models/switchman/shard.rb

@@ -38,7 +38,10 @@ module Switchman
       end
 
       def default(reload_deprecated = false, reload: false, with_fallback: false)
-        reload = reload_deprecated if reload_deprecated
+        if reload_deprecated
+          reload = reload_deprecated
+          ::ActiveSupport::Deprecation.warn("positional reload parameter to Switchman::Shard.default is deprecated; use `reload: true`")
+        end
         if !@default || reload
           # Have to create a dummy object so that several key methods still work
           # (it's easier to do this in one place here, and just assume that sharding
@@ -351,8 +354,8 @@ module Switchman
           # prune the prior connection unless it happened to be the same
           if previous_shard && shard != previous_shard && !previous_shard.database_server.shareable?
             previous_shard.activate do
-              ::Shackles.activated_environments.each do |env|
-                ::Shackles.activate(env) do
+              ::GuardRail.activated_environments.each do |env|
+                ::GuardRail.activate(env) do
                   if ::ActiveRecord::Base.connected? && ::ActiveRecord::Base.connection.open_transactions == 0
                     ::ActiveRecord::Base.connection_pool.current_pool.disconnect!
                   end
@@ -425,6 +428,19 @@ module Switchman
         end
       end
 
+      # it's tedious to hold onto this same
+      # kind of sign state and transform the
+      # result in multiple places, so
+      # here we can operate on the absolute value
+      # in a provided block and trust the sign will
+      # stay as provided.  This assumes no consumer
+      # will return a nil value from the block.
+      def signed_id_operation(input_id)
+        sign = input_id < 0 ? -1 : 1
+        output = yield input_id.abs
+        output * sign
+      end
+
       # converts an AR object, integral id, string id, or string short-global-id to a
       # integral id. nil if it can't be interpreted
       def integral_id_for(any_id)
@@ -437,12 +453,13 @@ module Switchman
         case any_id
         when ::ActiveRecord::Base
           any_id.id
-        when /^(\d+)~(\d+)$/
+        when /^(\d+)~(-?\d+)$/
           local_id = $2.to_i
-          # doesn't make sense to have a double-global id
-          return nil if local_id > IDS_PER_SHARD
-          $1.to_i * IDS_PER_SHARD + local_id
-        when Integer, /^\d+$/
+          signed_id_operation(local_id) do |id|
+            return nil if id > IDS_PER_SHARD
+            $1.to_i * IDS_PER_SHARD + id
+          end
+        when Integer, /^-?\d+$/
           any_id.to_i
         else
           nil
@@ -457,13 +474,17 @@ module Switchman
       def local_id_for(any_id)
         id = integral_id_for(any_id)
         return NIL_NIL_ID unless id
-        if id < IDS_PER_SHARD
-          [id, nil]
-        elsif shard = lookup(id / IDS_PER_SHARD)
-          [id % IDS_PER_SHARD, shard]
-        else
-          NIL_NIL_ID
+        return_shard = nil
+        local_id = signed_id_operation(id) do |abs_id|
+          if abs_id < IDS_PER_SHARD
+            abs_id
+          elsif return_shard = lookup(abs_id / IDS_PER_SHARD)
+            abs_id % IDS_PER_SHARD
+          else
+            return NIL_NIL_ID
+          end
         end
+        [local_id, return_shard]
       end
 
       # takes an id-ish, and returns an integral id relative to
@@ -494,11 +515,13 @@ module Switchman
       def global_id_for(any_id, source_shard = nil)
         id = integral_id_for(any_id)
         return any_id unless id
-        if id >= IDS_PER_SHARD
-          id
-        else
-          source_shard ||= Shard.current
-          source_shard.global_id_for(id)
+        signed_id_operation(id) do |abs_id|
+          if abs_id >= IDS_PER_SHARD
+            abs_id
+          else
+            source_shard ||= Shard.current
+            source_shard.global_id_for(abs_id)
+          end
         end
       end
 
@@ -639,7 +662,7 @@ module Switchman
         case adapter
           when 'mysql', 'mysql2'
             self.activate do
-              ::Shackles.activate(:deploy) do
+              ::GuardRail.activate(:deploy) do
                 drop_statement ||= "DROP DATABASE #{self.name}"
                 Array(drop_statement).each do |stmt|
                   ::ActiveRecord::Base.connection.execute(stmt)
@@ -648,7 +671,7 @@ module Switchman
             end
           when 'postgresql'
             self.activate do
-              ::Shackles.activate(:deploy) do
+              ::GuardRail.activate(:deploy) do
                 # Shut up, Postgres!
                 conn = ::ActiveRecord::Base.connection
                 old_proc = conn.raw_connection.set_notice_processor {}
@@ -671,7 +694,9 @@ module Switchman
     # takes an id local to this shard, and returns a global id
     def global_id_for(local_id)
       return nil unless local_id
-      local_id + self.id * IDS_PER_SHARD
+      self.class.signed_id_operation(local_id) do |abs_id|
+        abs_id + self.id * IDS_PER_SHARD
+      end
     end
 
     # skip global_id.hash

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/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
@@ -128,9 +128,9 @@ module Switchman
         result
       end
 
-      def transaction(options={}, &block)
+      def transaction(**kwargs, &block)
         shard.activate(self.class.shard_category) do
-          self.class.transaction(options, &block)
+          self.class.transaction(**kwargs, &block)
         end
       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,12 +13,6 @@ 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)
@@ -63,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,
@@ -72,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
 

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/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/persistence.rb

@@ -2,7 +2,7 @@ module Switchman
   module ActiveRecord
     module Persistence
       # touch reads the id attribute directly, so it's not relative to the current shard
-      def touch(*)
+      def touch(*, **)
         shard.activate(self.class.shard_category) { super }
       end
 

data/lib/switchman/active_record/postgresql_adapter.rb

@@ -38,23 +38,17 @@ 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
 
       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?
+        if string && !name.schema
           name.instance_variable_set(:@schema, shard.name)
         end
         [name.schema, name.identifier]
@@ -63,7 +57,7 @@ module Switchman
       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
 
@@ -73,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
@@ -88,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
 
@@ -126,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
@@ -136,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
 
@@ -150,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
@@ -165,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
@@ -178,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
 
@@ -195,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
 
@@ -203,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/relation.rb

@@ -5,7 +5,7 @@ module Switchman
         klass::SINGLE_VALUE_METHODS.concat [ :shard, :shard_source ]
       end
 
-      def initialize(*args)
+      def initialize(*, **)
         super
         self.shard_value = Shard.current(klass ? klass.shard_category : :primary) unless shard_value
         self.shard_source_value = :implicit unless shard_source_value
@@ -17,7 +17,7 @@ module Switchman
         result
       end
 
-      def merge(*args)
+      def merge(*)
         relation = super
         if relation.shard_value != self.shard_value && relation.shard_source_value == :implicit
           relation.shard_value = self.shard_value
@@ -26,15 +26,15 @@ module Switchman
         relation
       end
 
-      def new(*args, &block)
+      def new(*, &block)
         primary_shard.activate(klass.shard_category) { super }
       end
 
-      def create(*args, &block)
+      def create(*, &block)
         primary_shard.activate(klass.shard_category) { super }
       end
 
-      def create!(*args, &block)
+      def create!(*, &block)
         primary_shard.activate(klass.shard_category) { super }
       end
 

data/lib/switchman/active_record/statement_cache.rb

@@ -2,7 +2,7 @@ module Switchman
   module ActiveRecord
     module StatementCache
       module ClassMethods
-        def create(connection, block = Proc.new)
+        def create(connection, &block)
           relation = block.call ::ActiveRecord::StatementCache::Params.new
 
           if ::Rails.version >= "5.2"
@@ -46,29 +46,16 @@ module Switchman
         bind_values = bind_map.bind(params, current_shard, target_shard)
 
         target_shard.activate(klass.shard_category) do
-          if connection.use_qualified_names?
-            sql = qualified_query_builder(target_shard, klass).sql_for(bind_values, connection)
-            klass.find_by_sql(sql, bind_values)
-          else
-            sql = generic_query_builder(connection).sql_for(bind_values, connection)
-            klass.find_by_sql(sql, bind_values)
-          end
+          sql = qualified_query_builder(target_shard, klass).sql_for(bind_values, connection)
+          klass.find_by_sql(sql, bind_values)
         end
       end
 
       if ::Rails.version < '5.2'
-        def generic_query_builder(connection)
-          @query_builder ||= connection.cacheable_query(self.class, @arel)
-        end
-
         def qualified_query_builder(shard, klass)
           @qualified_query_builders[shard.id] ||= klass.connection.cacheable_query(self.class, @arel)
         end
       else
-        def generic_query_builder(connection)
-          @query_builder ||= connection.cacheable_query(self.class, @arel).first
-        end
-
         def qualified_query_builder(shard, klass)
           @qualified_query_builders[shard.id] ||= klass.connection.cacheable_query(self.class, @arel).first
         end

data/lib/switchman/active_record/table_definition.rb

@@ -1,8 +1,8 @@
 module Switchman
   module ActiveRecord
     module TableDefinition
-      def column(name, type, options = {})
-        Engine.foreign_key_check(name, type, options)
+      def column(name, type, limit: nil, **)
+        Engine.foreign_key_check(name, type, limit: limit)
         super
       end
     end

data/lib/switchman/active_support/cache.rb

@@ -15,12 +15,12 @@ module Switchman
       end
 
       module RedisCacheStore
-        def clear(options = {})
+        def clear(namespace: nil, **)
           # RedisCacheStore tries to be smart and only clear the cache under your namespace, if you have one set
           # unfortunately, it uses the keys command, which is extraordinarily inefficient in a large redis instance
           # fortunately, we can assume we control the entire instance, because we set up the namespacing, so just
           # always unset it temporarily for clear calls
-          options[:namespace] = nil
+          namespace = nil
           super
         end
       end

data/lib/switchman/connection_pool_proxy.rb

@@ -37,13 +37,13 @@ module Switchman
       Shard.current(@category)
     end
 
-    def active_shackles_environment
-      ::Rails.env.test? ? :master : active_shard.database_server.shackles_environment
+    def active_guard_rail_environment
+      ::Rails.env.test? ? :primary : active_shard.database_server.guard_rail_environment
     end
 
     def current_pool
       current_active_shard = active_shard
-      pool = self.default_pool if current_active_shard.database_server == Shard.default.database_server && active_shackles_environment == :master && (current_active_shard.default? || current_active_shard.database_server.shareable?)
+      pool = self.default_pool if current_active_shard.database_server == Shard.default.database_server && active_guard_rail_environment == :primary && (current_active_shard.default? || current_active_shard.database_server.shareable?)
       pool = @connection_pools[pool_key] ||= create_pool unless pool
       pool.shard = current_active_shard
       pool
@@ -60,8 +60,8 @@ module Switchman
         connection.instance_variable_set(:@schema_cache, @schema_cache) unless ::Rails.version >= '6'
         connection
       rescue ConnectionError
-        raise if active_shard.database_server == Shard.default.database_server && active_shackles_environment == :master
-        configs = active_shard.database_server.config(active_shackles_environment)
+        raise if active_shard.database_server == Shard.default.database_server && active_guard_rail_environment == :primary
+        configs = active_shard.database_server.config(active_guard_rail_environment)
         raise unless configs.is_a?(Array)
         configs.each_with_index do |config, idx|
           pool = create_pool(config.dup)
@@ -120,7 +120,7 @@ module Switchman
     end
 
     def pool_key
-      [active_shackles_environment,
+      [active_guard_rail_environment,
         active_shard.database_server.shareable? ? active_shard.database_server.pool_key : active_shard]
     end
 
@@ -128,7 +128,7 @@ module Switchman
       shard = active_shard
       unless config
         if shard != Shard.default
-          config = shard.database_server.config(active_shackles_environment)
+          config = shard.database_server.config(active_guard_rail_environment)
           config = config.first if config.is_a?(Array)
           config = config.dup
         else
@@ -138,10 +138,10 @@ module Switchman
           # different models could be using different configs on the default
           # shard, and database server wouldn't know about that
           config = default_pool.spec.instance_variable_get(:@config)
-          if config[active_shackles_environment].is_a?(Hash)
-            config = config.merge(config[active_shackles_environment])
-          elsif config[active_shackles_environment].is_a?(Array)
-            config = config.merge(config[active_shackles_environment].first)
+          if config[active_guard_rail_environment].is_a?(Hash)
+            config = config.merge(config[active_guard_rail_environment])
+          elsif config[active_guard_rail_environment].is_a?(Array)
+            config = config.merge(config[active_guard_rail_environment].first)
           else
             config = config.dup
           end

data/lib/switchman/database_server.rb

@@ -69,12 +69,12 @@ module Switchman
       @fake
     end
 
-    def config(environment = :master)
+    def config(environment = :primary)
       @configs[environment] ||= begin
         if @config[environment].is_a?(Array)
           @config[environment].map do |config|
             config = @config.merge((config || {}).symbolize_keys)
-            # make sure Shackles doesn't get any brilliant ideas about choosing the first possible server
+            # make sure GuardRail doesn't get any brilliant ideas about choosing the first possible server
             config.delete(environment)
             config
           end
@@ -86,33 +86,33 @@ module Switchman
       end
     end
 
-    def shackles_environment
-      @shackles_environment || ::Shackles.environment
+    def guard_rail_environment
+      @guard_rail_environment || ::GuardRail.environment
     end
 
     # locks this db to a specific environment, except for
     # when doing writes (then it falls back to the current
-    # value of Shackles.environment)
-    def shackle!(environment = :slave)
-      @shackles_environment = environment
+    # value of GuardRail.environment)
+    def guard!(environment = :secondary)
+      @guard_rail_environment = environment
     end
 
-    def unshackle!
-      @shackles_environment = nil
+    def unguard!
+      @guard_rail_environment = nil
     end
 
-    def unshackle
-      old_env = @shackles_environment
-      unshackle!
+    def unguard
+      old_env = @guard_rail_environment
+      unguard!
       yield
     ensure
-      shackle!(old_env)
+      guard!(old_env)
     end
 
     def shareable?
       @shareable_environment_key ||= []
-      environment = shackles_environment
-      explicit_user = ::Shackles.global_config[:username]
+      environment = guard_rail_environment
+      explicit_user = ::GuardRail.global_config[:username]
       return @shareable if @shareable_environment_key == [environment, explicit_user]
       @shareable_environment_key = [environment, explicit_user]
       if explicit_user
@@ -190,7 +190,7 @@ module Switchman
         begin
           self.class.creating_new_shard = true
           shard.activate(*Shard.categories) do
-            ::Shackles.activate(:deploy) do
+            ::GuardRail.activate(:deploy) do
               begin
                 if create_statement
                   if (::ActiveRecord::Base.connection.select_value("SELECT 1 FROM pg_namespace WHERE nspname=#{::ActiveRecord::Base.connection.quote(name)}"))

data/lib/switchman/engine.rb

@@ -87,7 +87,7 @@ module Switchman
         require "switchman/arel"
         require "switchman/call_super"
         require "switchman/rails"
-        require "switchman/shackles/relation"
+        require "switchman/guard_rail/relation"
         require_dependency "switchman/shard"
         require "switchman/standard_error"
 
@@ -122,6 +122,7 @@ module Switchman
         ::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::Migrator.prepend(ActiveRecord::Migrator)
 
         ::ActiveRecord::Reflection::AbstractReflection.include(ActiveRecord::Reflection::AbstractReflection)
@@ -132,7 +133,7 @@ module Switchman
         ::ActiveRecord::Relation.prepend(ActiveRecord::Calculations)
         ::ActiveRecord::Relation.include(ActiveRecord::FinderMethods)
         ::ActiveRecord::Relation.include(ActiveRecord::QueryMethods)
-        ::ActiveRecord::Relation.prepend(Shackles::Relation)
+        ::ActiveRecord::Relation.prepend(GuardRail::Relation)
         ::ActiveRecord::Relation.prepend(ActiveRecord::Relation)
         ::ActiveRecord::Relation.include(ActiveRecord::SpawnMethods)
         ::ActiveRecord::Relation.include(CallSuper)
@@ -149,8 +150,8 @@ module Switchman
       end
     end
 
-    def self.foreign_key_check(name, type, options)
-      if name.to_s =~ /_id\z/ && type.to_s == 'integer' && options[:limit].to_i < 8
+    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
     end
@@ -184,15 +185,15 @@ module Switchman
       end
     end
 
-    initializer 'switchman.extend_shackles', :before => "switchman.extend_ar" do
+    initializer 'switchman.extend_guard_rail', :before => "switchman.extend_ar" do
       ::ActiveSupport.on_load(:active_record) do
-        require "switchman/shackles"
+        require "switchman/guard_rail"
 
-        ::Shackles.singleton_class.prepend(Shackles::ClassMethods)
+        ::GuardRail.singleton_class.prepend(GuardRail::ClassMethods)
       end
     end
 
-    initializer 'switchman.extend_controller', :after => "shackles.extend_ar" do
+    initializer 'switchman.extend_controller', :after => "guard_rail.extend_ar" do
       ::ActiveSupport.on_load(:action_controller) do
         require "switchman/action_controller/caching"
 

data/lib/switchman/{shackles.rb → guard_rail.rb}

@@ -1,17 +1,17 @@
 module Switchman
-  module Shackles
+  module GuardRail
     module ClassMethods
       def self.prepended(klass)
         klass.send(:remove_method, :ensure_handler)
       end
 
       # drops the save_handler and ensure_handler calls from the vanilla
-      # Shackles' implementation.
+      # GuardRail' implementation.
       def activate!(environment)
-        environment ||= :master
+        environment ||= :primary
         activated_environments << environment
         old_environment = self.environment
-        Thread.current[:shackles_environment] = environment
+        Thread.current[:guard_rail_environment] = environment
         old_environment
       end
 

data/lib/switchman/{shackles → guard_rail}/relation.rb

@@ -1,11 +1,11 @@
 module Switchman
-  module Shackles
+  module GuardRail
     module Relation
       def exec_queries(*args)
         if self.lock_value
           db = Shard.current(shard_category).database_server
-          if ::Shackles.environment != db.shackles_environment
-            return db.unshackle { super }
+          if ::GuardRail.environment != db.guard_rail_environment
+            return db.unguard { super }
           end
         end
         super
@@ -15,8 +15,8 @@ module Switchman
         class_eval <<-RUBY, __FILE__, __LINE__ + 1
           def #{method}(*args)
             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

data/lib/switchman/r_spec_helper.rb

@@ -65,7 +65,7 @@ module Switchman
             (@@shard3.drop_database if @@shard3) rescue nil
             @@shard1 = @@shard2 = @@shard3 = nil
             Shard.delete_all
-            Shard.default(true)
+            Shard.default(reload: true)
             next
           end
         end
@@ -73,7 +73,7 @@ module Switchman
         # in the db before then
         Shard.delete_all
         Switchman.cache.delete("default_shard")
-        Shard.default(true)
+        Shard.default(reload: true)
         puts "Done!"
 
         at_exit do
@@ -102,7 +102,7 @@ module Switchman
         dup.id = @@default_shard.id
         dup.save!
         Switchman.cache.delete("default_shard")
-        Shard.default(true)
+        Shard.default(reload: true)
         dup = @@shard1.dup
         dup.id = @@shard1.id
         dup.save!
@@ -122,7 +122,7 @@ module Switchman
         raise "Sharding did not set up correctly" if @@sharding_failed
         Shard.clear_cache
         if use_transactional_tests
-          Shard.default(true)
+          Shard.default(reload: true)
           @shard1 = Shard.find(@shard1.id)
           @shard2 = Shard.find(@shard2.id)
           shards = [@shard2]
@@ -151,7 +151,7 @@ module Switchman
       klass.after(:all) do
         Shard.connection.update("TRUNCATE #{Shard.quoted_table_name} CASCADE")
         Switchman.cache.delete("default_shard")
-        Shard.default(true)
+        Shard.default(reload: true)
       end
     end
   end

data/lib/switchman/sharded_instrumenter.rb

@@ -14,7 +14,7 @@ module Switchman
         payload[:shard] = {
           database_server_id: shard.database_server.id,
           id: shard.id,
-          env: shard.database_server.shackles_environment
+          env: shard.database_server.guard_rail_environment
         }
       end
       super name, payload

data/lib/switchman/test_helper.rb

@@ -3,8 +3,8 @@ module Switchman
     class << self
       def recreate_persistent_test_shards(dont_create: false)
         # recreate the default shard (it got buhleted)
-        ::Shackles.activate(:deploy) { Switchman.cache.clear }
-        if Shard.default(true).is_a?(DefaultShard)
+        ::GuardRail.activate(:deploy) { Switchman.cache.clear }
+        if Shard.default(reload: true).is_a?(DefaultShard)
           begin
             Shard.create!(default: true)
           rescue
@@ -12,7 +12,7 @@ module Switchman
             # database doesn't exist yet, presumably cause we're creating it right now
             return [nil, nil]
           end
-          Shard.default(true)
+          Shard.default(reload: true)
         end
 
         # can't auto-create a new shard on the default shard's db server if the

data/lib/switchman/version.rb

@@ -1,3 +1,3 @@
 module Switchman
-  VERSION = "1.15.0"
+  VERSION = "2.0.1"
 end

data/lib/tasks/switchman.rake

@@ -64,8 +64,8 @@ module Switchman
           TestHelper.recreate_persistent_test_shards(dont_create: true)
         end
 
-        ::Shackles.activate(:deploy) do
-          Shard.default.database_server.unshackle do
+        ::GuardRail.activate(:deploy) do
+          Shard.default.database_server.unguard do
             begin
               categories = categories.call if categories.respond_to?(:call)
               Shard.with_each_shard(scope, categories, options) do
@@ -83,7 +83,7 @@ module Switchman
       
                   ::ActiveRecord::Base.configurations = new_configs
                 end
-                shard.database_server.unshackle do
+                shard.database_server.unguard do
                   old_actions.each { |action| action.call(*task_args) }
                 end
                 nil
@@ -218,16 +218,9 @@ module Switchman
         args = ['-s', '-x', '-O', '-f', filename]
         args.concat(Array(extra_flags)) if extra_flags
         search_path = configuration['schema_search_path']
-        if configuration['use_qualified_names']
-          shard = Shard.current.name
-          serialized_search_path = shard
-          args << "--schema=#{Shellwords.escape(shard)}"
-        elsif !search_path.blank?
-          args << search_path.split(',').map do |part|
-            "--schema=#{part.strip}"
-          end.join(' ')
-          serialized_search_path = connection.schema_search_path
-        end
+        shard = Shard.current.name
+        serialized_search_path = shard
+        args << "--schema=#{Shellwords.escape(shard)}"
 
         args << configuration['database']
         run_cmd('pg_dump', args, 'dumping')

metadata

@@ -1,16 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: switchman
 version: !ruby/object:Gem::Version
-  version: 1.15.0
+  version: 2.0.1
 platform: ruby
 authors:
 - Cody Cutrer
 - James Williams
 - Jacob Fugal
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-05-18 00:00:00.000000000 Z
+date: 2020-10-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: railties
@@ -53,19 +53,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '6.1'
 - !ruby/object:Gem::Dependency
-  name: shackles
+  name: guardrail
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.4.2
+        version: 2.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.4.2
+        version: 2.0.0
 - !ruby/object:Gem::Dependency
   name: open4
   requirement: !ruby/object:Gem::Requirement
@@ -108,6 +108,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: pg
   requirement: !ruby/object:Gem::Requirement
@@ -214,12 +228,12 @@ files:
 - lib/switchman/engine.rb
 - lib/switchman/environment.rb
 - lib/switchman/errors.rb
+- lib/switchman/guard_rail.rb
+- lib/switchman/guard_rail/relation.rb
 - lib/switchman/open4.rb
 - lib/switchman/r_spec_helper.rb
 - lib/switchman/rails.rb
 - lib/switchman/schema_cache.rb
-- lib/switchman/shackles.rb
-- lib/switchman/shackles/relation.rb
 - lib/switchman/sharded_instrumenter.rb
 - lib/switchman/standard_error.rb
 - lib/switchman/test_helper.rb
@@ -229,7 +243,7 @@ homepage: http://www.instructure.com/
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -237,15 +251,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.4'
+      version: '2.5'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.1.2
+signing_key:
 specification_version: 4
-summary: Rails 4 sharding magic
+summary: Rails sharding magic
 test_files: []