switchman 2.0.13 → 2.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: de9d4ea9f0368bf1bfe15fdb8dd6bef040a8ec107aed386eaa81f8fa444513df
-  data.tar.gz: 71b7905b40d59a4767576552c8f5d16a2b3bdaec6d910f81f18d803a9c916256
+  metadata.gz: 62fa2df72b999208e937ba7df468f122159e573d3e838cf86df601592e64fb0c
+  data.tar.gz: 20e83c56b8043a8d5e9fbc433db4b1a26a6ec7291389c59463a47ea2ed0b0b87
 SHA512:
-  metadata.gz: bac07aa4f15521f123a1d95f676448d649c71eddd86fdfbbb57504f59d0c71f9ce69618aa7d1e25e93fdc278708cb2a7385d111417f23a8fc0eb1e9b6f6eefb3
-  data.tar.gz: 1c091615da88fe2f54de51de1e740336007fd13d66d0cac0b977d0e2770a6dfacd6a85bd12b689a0c610b1de5daeab4512743f0c50199e0f610806cc2f4dd629
+  metadata.gz: 7c2cdc6f074ddb755b8a80dad67a2828a8f52d2c034f9ec7bdf473d2e2241cf21b80969cc3f6d0dcc33b6713f299ea976370800640a54839d0895cd41c29f01a
+  data.tar.gz: 68651c29f71fad57c1e6bbc02b35c6e607a98bc708045841b547c07de4f0ce63048d4a22b22c561d4692a728adc8740fd139ef4d88e5e777cf593e1de679ca9b

data/app/models/switchman/shard.rb

@@ -18,7 +18,7 @@ module Switchman
           :unsharded => [Shard]
       }
     private_constant :CATEGORIES
-    @connection_specification_name = @shard_category = :unsharded
+    @connection_specification_name = 'unsharded'
 
     if defined?(::ProtectedAttributes)
       attr_accessible :default, :name, :database_server
@@ -283,17 +283,28 @@ module Switchman
 
                   with_each_shard(subscope, categories, options) { yield }
                   exception_pipe.last.close
-                rescue => e
+                rescue Exception => e
                   begin
                     dumped = Marshal.dump(e)
+                    dumped = nil if dumped.length > 64 * 1024
                   rescue
+                    dumped = nil
+                  end
+
+                  if dumped.nil?
                     # couldn't dump the exception; create a copy with just
                     # the message and the backtrace
                     e2 = e.class.new(e.message)
-                    e2.set_backtrace(e.backtrace)
+                    backtrace = e.backtrace
+                    # truncate excessively long backtraces
+                    if backtrace.length > 50
+                      backtrace = backtrace[0...25] + ['...'] + backtrace[-25..-1]
+                    end
+                    e2.set_backtrace(backtrace)
                     e2.instance_variable_set(:@active_shards, e.instance_variable_get(:@active_shards))
                     dumped = Marshal.dump(e2)
                   end
+
                   exception_pipe.last.set_encoding(dumped.encoding)
                   exception_pipe.last.write(dumped)
                   exception_pipe.last.flush

data/lib/switchman/active_record/attribute_methods.rb

@@ -38,11 +38,15 @@ module Switchman
         def define_method_global_attribute(attr_name)
           if sharded_column?(attr_name)
             generated_attribute_methods.module_eval <<-RUBY, __FILE__, __LINE__ + 1
-              def __temp__
+              def __temp_global_attribute__
+                raw_value = original_#{attr_name}
+                return nil if raw_value.nil?
+                return raw_value if raw_value > Shard::IDS_PER_SHARD
+
                 Shard.global_id_for(original_#{attr_name}, shard)
               end
-              alias_method 'global_#{attr_name}', :__temp__
-              undef_method :__temp__
+              alias_method 'global_#{attr_name}', :__temp_global_attribute__
+              undef_method :__temp_global_attribute__
             RUBY
           else
             define_method_unsharded_column(attr_name, 'global')
@@ -52,11 +56,13 @@ module Switchman
         def define_method_local_attribute(attr_name)
           if sharded_column?(attr_name)
             generated_attribute_methods.module_eval <<-RUBY, __FILE__, __LINE__ + 1
-              def __temp__
-                Shard.local_id_for(original_#{attr_name}).first
+              def __temp_local_attribute__
+                raw_value = original_#{attr_name}
+                return nil if raw_value.nil?
+                return raw_value % Shard::IDS_PER_SHARD
               end
-              alias_method 'local_#{attr_name}', :__temp__
-              undef_method :__temp__
+              alias_method 'local_#{attr_name}', :__temp_local_attribute__
+              undef_method :__temp_local_attribute__
             RUBY
           else
             define_method_unsharded_column(attr_name, 'local')
@@ -94,18 +100,33 @@ module Switchman
               # rename the original method to original_
               alias_method 'original_#{attr_name}', '#{attr_name}'
               # and replace with one that transposes the id
-              def __temp__
-                Shard.relative_id_for(original_#{attr_name}, shard, Shard.current(#{shard_category_code_for_reflection(reflection)}))
+              def __temp_relative_attribute__
+                raw_value = original_#{attr_name}
+                return nil if raw_value.nil?
+
+                abs_raw_value = raw_value.abs
+                current_shard = Shard.current(#{shard_category_code_for_reflection(reflection)})
+                same_shard = shard == current_shard
+                return raw_value if same_shard && abs_raw_value < Shard::IDS_PER_SHARD
+
+                value_shard_id = abs_raw_value / Shard::IDS_PER_SHARD
+                # this is a stupid case when someone stuffed a global id for the current shard in instead
+                # of a local id
+                return raw_value % Shard::IDS_PER_SHARD if value_shard_id == current_shard.id
+                return raw_value if !same_shard && abs_raw_value > Shard::IDS_PER_SHARD
+                return shard.global_id_for(raw_value) if !same_shard && abs_raw_value < Shard::IDS_PER_SHARD
+
+                Shard.relative_id_for(raw_value, shard, current_shard)
               end
-              alias_method '#{attr_name}', :__temp__
-              undef_method :__temp__
+              alias_method '#{attr_name}', :__temp_relative_attribute__
+              undef_method :__temp_relative_attribute__
 
               alias_method 'original_#{attr_name}=', '#{attr_name}='
-              def __temp__(new_value)
+              def __temp_relative_attribute_assignment__(new_value)
                 self.original_#{attr_name} = Shard.relative_id_for(new_value, Shard.current(#{shard_category_code_for_reflection(reflection)}), shard)
               end
-              alias_method '#{attr_name}=', :__temp__
-              undef_method :__temp__
+              alias_method '#{attr_name}=', :__temp_relative_attribute_assignment__
+              undef_method :__temp_relative_attribute_assignment__
             RUBY
           else
             define_method_unsharded_column(attr_name, 'global')
@@ -115,11 +136,11 @@ module Switchman
         def define_method_unsharded_column(attr_name, prefix)
           return if columns_hash["#{prefix}_#{attr_name}"]
           generated_attribute_methods.module_eval <<-RUBY, __FILE__, __LINE__ + 1
-              def __temp__
+              def __temp_unsharded_attribute__
                 raise NoMethodError, "undefined method `#{prefix}_#{attr_name}'; are you missing an association?"
               end
-              alias_method '#{prefix}_#{attr_name}', :__temp__
-              undef_method :__temp__
+              alias_method '#{prefix}_#{attr_name}', :__temp_unsharded_attribute__
+              undef_method :__temp_unsharded_attribute__
           RUBY
         end
       end

data/lib/switchman/active_record/connection_handler.rb

@@ -112,8 +112,20 @@ module Switchman
       end
 
       def remove_connection(spec_name)
+        # also remove pools based on the same spec name that are for shard category purposes
+        # can't just use delete_if, because it's a Concurrent::Map, not a Hash
+        owner_to_pool.keys.each do |k|
+          next if k == spec_name
+
+          v = owner_to_pool[k]
+          owner_to_pool.delete(k) if v.is_a?(ConnectionPoolProxy) && v.default_pool.spec.name == spec_name
+        end
+
+        # unwrap the pool from inside a ConnectionPoolProxy
         pool = owner_to_pool[spec_name]
         owner_to_pool[spec_name] = pool.default_pool if pool.is_a?(ConnectionPoolProxy)
+
+        # now let Rails do its thing with the data type it expects
         super
       end
 
@@ -128,15 +140,21 @@ module Switchman
             else
               ancestor_pool.spec
             end
-            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"
+            # avoid copying "duplicate" pools that implement shard categories.
+            # they'll have a spec.name of primary, but a spec_name of something else, like unsharded
+            if spec.name == spec_name
+              pool = establish_connection(spec.to_hash)
+              pool.instance_variable_set(:@schema_cache, ancestor_pool.schema_cache) if ancestor_pool.schema_cache
+              next pool
+            end
+          end
+
+          if spec_name != "primary"
             primary_pool = retrieve_connection_pool("primary")
             if primary_pool.is_a?(ConnectionPoolProxy)
               pool = ConnectionPoolProxy.new(spec_name.to_sym, primary_pool.default_pool, @shard_connection_pools)
               pool.schema_cache.copy_references(primary_pool.schema_cache)
-              pool
+              owner_to_pool[spec_name] = pool
             else
               primary_pool
             end

data/lib/switchman/active_record/reflection.rb

@@ -28,15 +28,26 @@ module Switchman
         # this technically belongs on AssociationReflection, but we put it on
         # ThroughReflection as well, instead of delegating to its internal
         # HasManyAssociation, losing its proper `klass`
-        def association_scope_cache(conn, owner, &block)
-          key = conn.prepared_statements
-          if polymorphic?
-            key = [key, owner._read_attribute(@foreign_type)]
+        if ::Rails.version < '6.0.4'
+          def association_scope_cache(conn, owner, &block)
+            key = conn.prepared_statements
+            if polymorphic?
+              key = [key, owner._read_attribute(@foreign_type)]
+            end
+            key = [key, shard(owner).id].flatten
+            @association_scope_cache[key] ||= @scope_lock.synchronize {
+              @association_scope_cache[key] ||= (::Rails.version >= "5.2" ? ::ActiveRecord::StatementCache.create(conn, &block) : block.call)
+            }
+          end
+        else
+          def association_scope_cache(klass, owner, &block)
+            key = self
+            if polymorphic?
+              key = [key, owner._read_attribute(@foreign_type)]
+            end
+            key = [key, shard(owner).id].flatten
+            klass.cached_find_by_statement(key, &block)
           end
-          key = [key, shard(owner).id].flatten
-          @association_scope_cache[key] ||= @scope_lock.synchronize {
-            @association_scope_cache[key] ||= (::Rails.version >= "5.2" ? ::ActiveRecord::StatementCache.create(conn, &block) : block.call)
-          }
         end
       end
 

data/lib/switchman/connection_pool_proxy.rb

@@ -154,7 +154,7 @@ module Switchman
         end
       end
       spec = ::ActiveRecord::ConnectionAdapters::ConnectionSpecification.new(
-        category,
+        default_pool.spec.name,
         config,
         "#{config[:adapter]}_connection"
       )

data/lib/switchman/test_helper.rb

@@ -17,13 +17,7 @@ module Switchman
           Shard.default(reload: true)
         end
 
-        # can't auto-create a new shard on the default shard's db server if the
-        # default shard is split across multiple db servers
-        if ::ActiveRecord::Base.connection_handler.connection_pool_list.length > 1
-          server1 = DatabaseServer.create(Shard.default.database_server.config)
-        else
-          server1 = Shard.default.database_server
-        end
+        server1 = Shard.default.database_server
         server2 = DatabaseServer.create(Shard.default.database_server.config.merge(server2: true))
 
         if server1 == Shard.default.database_server && server1.config[:shard1] && server1.config[:shard2]

data/lib/switchman/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Switchman
-  VERSION = "2.0.13"
+  VERSION = "2.1.3"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: switchman
 version: !ruby/object:Gem::Version
-  version: 2.0.13
+  version: 2.1.3
 platform: ruby
 authors:
 - Cody Cutrer
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-06-11 00:00:00.000000000 Z
+date: 2021-07-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: railties
@@ -272,7 +272,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.15
+rubygems_version: 3.2.24
 signing_key:
 specification_version: 4
 summary: Rails sharding magic