switchman 1.1.0 → 1.2.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    NTc5NGVlNTU2ODI2YTQ3NjY4OTBhOGZiNTZjN2MyMWNjYjY5YmNhZg==
+    YzRjZGFmYzVmY2EwYjYyNGQ3Nzc0NzYxNjdhOTQ2M2U5ZDU1YmE0Zg==
   data.tar.gz: !binary |-
-    ZGNkZjQ3YWQ0Njg5ZTJhMDQ5ZTVmMWIyZGVhZDJhMTQ5MzE4ZDNlZg==
+    ZTY2ZDgwNDU2YjFmOWYwMDMyYzgyYzJmOGU5MWIzZTJlNGIzNDVhNg==
 SHA512:
   metadata.gz: !binary |-
-    ODY5NDM1MTFiYTFkMWM5MWYzMDJiZjFkNjY1YWNjZDg3MjFmZjM4YTM3ZjEx
-    MzA4MDJjMjJkMjViOTQ5ZWZlMGYyOWUwMmRmYjI2MzNhYjE3ZmJhODk4ZGJh
-    ODhlYzllMmQxYzVhYjc2NTE4MjYxNmIzZGM2N2M0YWU2NmZkMzg=
+    NTVmOWYyY2Y2YWUzMmQ4MWY3NjUzZTFiYThmMmM0OGM3ZDA1YTczNDdmZjFl
+    MjEzYmJhNzBjODc4OGZmYzgwZmEwNDI3NWQ2YWU3Yzg3ODBkNTBmNTYyNThh
+    YTJlOGRjMDI5NzhjYmNhZmQyYTMwNWQ4MGIwOWQ2MDM4ODYwZDU=
   data.tar.gz: !binary |-
-    YzlkM2FlYmY5MTNlMzUzMDBhYjRkZGU5MGY5NWZjMzRiMGYyYzhlNDAyMmM0
-    MWE1M2RkZmUyNWRjNDdlN2U5YTY3NTgxNWY4YWI4Y2M3NGZjMmUxMGNjODFh
-    NTA1MGIwNTdlZTBhY2U1MzM1ZmU5ZDBiYjc1ZmM2MTE2MDdjZmY=
+    MzY2ODJiM2E3YWZkNjJhYjllODIyNDBkMzQ5NTkyNzhjNjY4Yzc5MDdiY2Iy
+    OGE3ZTA2N2U4YTdlZWFmMWJhZjQzNTU5NzNmYWYyMGIxZTNmOWVhZTc3Mzgw
+    MWE3YjYwNTlkODIzZThkNTlmMDI2NTVhNWNlNTA4Nzc5MTdlNjI=

data/app/models/switchman/shard.rb

@@ -16,8 +16,6 @@ module Switchman
     private_constant :CATEGORIES
     @shard_category = :unsharded
 
-    attr_accessible :name, :database_server, :default
-
     # only allow one default
     validates_uniqueness_of :default, :if => lambda { |s| s.default? }
 
@@ -87,7 +85,11 @@ module Switchman
             nil
           else
             shard = Shard.new
-            shard.assign_attributes(attributes, :without_protection => true)
+            if ::Rails.version < '4'
+              shard.assign_attributes(attributes, :without_protection => true)
+            else
+              shard.assign_attributes(attributes)
+            end
             shard.instance_variable_set(:@new_record, false)
             # connection info doesn't exist in database.yml;
             # pretend the shard doesn't exist either
@@ -520,6 +522,11 @@ module Switchman
       super
     end
 
+    # skip global_id.hash
+    def hash
+      id.hash
+    end
+
     private
 
     def clear_cache

data/lib/switchman/active_record/association.rb

@@ -2,7 +2,8 @@ module Switchman
   module ActiveRecord
     module Association
       def self.included(klass)
-        %w{build_record creation_attributes load_target scoped}.each do |method|
+        %w{build_record creation_attributes load_target scope}.each do |method|
+          method = 'scoped' if method == 'scope' && ::Rails.version < '4'
           klass.alias_method_chain(method, :sharding)
         end
       end
@@ -24,10 +25,14 @@ module Switchman
         self.shard.activate { load_target_without_sharding }
       end
 
-      def scoped_with_sharding
-        shard_value = @reflection.options[:multishard] ? @owner : self.shard
-        @owner.shard.activate { scoped_without_sharding.shard(shard_value, :association) }
-      end
+      # scoped is renamed to scope in Rails 4
+      method = ::Rails.version < '4' ? 'scoped' : 'scope'
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{method}_with_sharding
+          shard_value = @reflection.options[:multishard] ? @owner : self.shard
+          @owner.shard.activate { #{method}_without_sharding.shard(shard_value, :association) }
+        end
+      RUBY
 
       def creation_attributes_with_sharding
         attributes = creation_attributes_without_sharding
@@ -65,9 +70,17 @@ module Switchman
     end
 
     module Builder
-      module Association
+      module CollectionAssociation
         def self.included(klass)
-          klass.descendants.each{|d| d.valid_options += [:multishard]}
+          if ::Rails.version < '4'
+            [klass] + klass.descendants.each do |k|
+              k.valid_options << :multishard
+            end
+          end
+        end
+
+        def valid_options
+          super + [:multishard]
         end
       end
     end
@@ -77,7 +90,11 @@ module Switchman
         def self.included(klass)
           klass.send(:remove_method, :associated_records_by_owner)
           klass.send(:remove_method, :owners_by_key)
-          klass.send(:remove_method, :scoped)
+          if ::Rails.version < '4'
+            klass.send(:remove_method, :scoped)
+          else
+            klass.send(:remove_method, :scope)
+          end
         end
 
         def associated_records_by_owner
@@ -126,15 +143,24 @@ module Switchman
           end
         end
 
-        def scoped
+        def scope
           build_scope
         end
+        # renamed to just scope in Rails 4
+        if ::Rails.version < '4'
+          alias_method :scoped, :scope
+          remove_method(:scope)
+        end
       end
     end
 
     module CollectionProxy
       def shard(*args)
-        scoped.shard(*args)
+        if ::Rails.version < '4'
+          scoped.shard(*args)
+        else
+          scope.shard(*args)
+        end
       end
     end
   end

data/lib/switchman/active_record/base.rb

@@ -2,7 +2,11 @@ module Switchman
   module ActiveRecord
     module Base
       module ClassMethods
-        delegate :shard, :to => :scoped
+        if ::Rails.version < '4'
+          delegate :shard, to: :scoped
+        else
+          delegate :shard, to: :all
+        end
 
         def shard_category
           @shard_category || :default
@@ -29,7 +33,7 @@ module Switchman
         end
 
         def transaction(*args)
-          if current_scope
+          if self != ::ActiveRecord::Base && current_scope
             current_scope.activate do
               db = Shard.current(shard_category).database_server
               if ::Shackles.environment != db.shackles_environment
@@ -78,16 +82,16 @@ module Switchman
 
       def save(*args)
         @shard_set_in_stone = true
-        self.class.with_scope(self.class.shard(shard), :overwrite) { super }
+        self.class.shard(shard).scoping { super }
       end
 
       def save!(*args)
         @shard_set_in_stone = true
-        self.class.with_scope(self.class.shard(shard), :overwrite) { super }
+        self.class.shard(shard).scoping { super }
       end
 
       def destroy
-        self.class.with_scope(self.class.shard(shard), :overwrite) { super }
+        self.class.shard(shard).scoping { super }
       end
 
       def clone

data/lib/switchman/active_record/calculations.rb

@@ -45,15 +45,15 @@ module Switchman
         relation.select_values = [operation_over_aggregate_column(column, "average", distinct).as("average"),
                                   operation_over_aggregate_column(column, "count", distinct).as("count")]
 
-        initial_results = relation.activate{ |rel| @klass.connection.select_all(rel) }
+        initial_results = relation.activate{ |rel| klass.connection.select_all(rel) }
         if initial_results.is_a?(Array)
           initial_results.each do |r|
-            r["average"] = type_cast_calculated_value(r["average"], nil, "average")
-            r["count"] = type_cast_calculated_value(r["count"], nil, "count")
+            r["average"] = type_cast_calculated_value(r["average"], column_for(column_name), "average")
+            r["count"] = type_cast_calculated_value(r["count"], column_for(column_name), "count")
           end
           result = initial_results.map{|r| r["average"] * r["count"]}.sum / initial_results.map{|r| r["count"]}.sum
         else
-          result = type_cast_calculated_value(initial_results["average"], nil, "average")
+          result = type_cast_calculated_value(initial_results.first["average"], column_for(column_name), "average")
         end
         result
       end
@@ -66,7 +66,7 @@ module Switchman
         target_shard = Shard.current(:default)
 
         rows = relation.activate do |rel, shard|
-          calculated_data = @klass.connection.select_all(rel)
+          calculated_data = klass.connection.select_all(rel)
 
           if opts[:association]
             key_ids     = calculated_data.collect { |row| row[opts[:group_aliases].first] }
@@ -98,9 +98,9 @@ module Switchman
         opts = {:operation => operation, :column_name => column_name, :distinct => distinct}
 
         opts[:aggregate_alias] = aggregate_alias_for(operation, column_name)
-        group_attrs = @group_values
+        group_attrs = group_values
         if group_attrs.first.respond_to?(:to_sym)
-          association  = @klass.reflect_on_association(group_attrs.first.to_sym)
+          association  = klass.reflect_on_association(group_attrs.first.to_sym)
           associated   = group_attrs.size == 1 && association && association.macro == :belongs_to # only count belongs_to associations
           group_fields = Array(associated ? association.foreign_key : group_attrs)
         else
@@ -125,12 +125,12 @@ module Switchman
         elsif operation == 'average'
           'average'
         else
-          column_alias_for(operation, column_name)
+          column_alias_for("#{operation} #{column_name}")
         end
       end
 
       def build_grouped_calculation_relation(opts)
-        group = @klass.connection.adapter_name == 'FrontBase' ? opts[:group_aliases] : opts[:group_fields]
+        group = opts[:group_fields]
 
         select_values = [
             operation_over_aggregate_column(
@@ -146,7 +146,7 @@ module Switchman
               'count', opts[:distinct]).as('count')
         end
 
-        select_values += @select_values unless @having_values.empty?
+        select_values += select_values unless having_values.empty?
         select_values.concat opts[:group_fields].zip(opts[:group_aliases]).map { |field,aliaz|
           if field.respond_to?(:as)
             field.as(aliaz)
@@ -155,7 +155,8 @@ module Switchman
           end
         }
 
-        relation = except(:group).group(group)
+        relation = except(:group)
+        relation.group_values = group
         relation.select_values = select_values
         relation
       end

data/lib/switchman/active_record/connection_handler.rb

@@ -22,10 +22,11 @@ module Switchman
       def self.included(klass)
         klass.alias_method_chain(:establish_connection, :sharding)
         klass.alias_method_chain(:remove_connection, :sharding)
+        klass.send(:remove_method, :retrieve_connection_pool) if ::Rails.version >= '4'
       end
 
-      def establish_connection_with_sharding(name, spec)
-        establish_connection_without_sharding(name, spec)
+      def establish_connection_with_sharding(owner, spec)
+        establish_connection_without_sharding(owner, spec)
 
         # this is the first place that the adapter would have been required; but now we
         # need this addition ASAP since it will be called when loading the default shard below
@@ -34,8 +35,16 @@ module Switchman
           ::ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.send(:include, ActiveRecord::PostgreSQLAdapter)
         end
 
-        model = name.constantize
-        pool = connection_pools[spec]
+        # AR3 uses the name, AR4 uses the model
+        model = case owner
+                when String
+                  owner.constantize
+                when Class
+                  owner
+                else
+                  raise "unknown owner #{owner}"
+                end
+        pool = ::Rails.version < '4' ? connection_pools[spec] : owner_to_pool[owner.name]
 
         first_time = !Shard.instance_variable_get(:@default)
         if first_time
@@ -52,7 +61,12 @@ module Switchman
         proxy = ConnectionPoolProxy.new(model.shard_category,
                                         pool,
                                         @shard_connection_pools)
-        connection_pools[spec] = proxy
+        if ::Rails.version < '4'
+          connection_pools[spec] = proxy
+        else
+          owner_to_pool[owner.name] = proxy
+          class_to_pool.clear
+        end
 
         if first_time
           if Shard.default.database_server.config[:prefer_slave]
@@ -65,8 +79,10 @@ module Switchman
           end
         end
 
-        initialize_categories(model)
-        @class_to_pool[name] = proxy
+        if ::Rails.version < '4'
+          initialize_categories(model)
+          class_to_pool[model.name] = proxy
+        end
 
         # reload the default shard if we just got a new connection
         # to where the Shards table is
@@ -96,61 +112,100 @@ module Switchman
       end
 
       def remove_connection_with_sharding(model)
-        uninitialize_ar(model) if @class_to_pool[model.name].is_a?(ConnectionPoolProxy)
-        remove_connection_without_sharding(model)
+        uninitialize_ar(model) if (::Rails.version < '4' ? class_to_pool : owner_to_pool)[model.name].is_a?(ConnectionPoolProxy)
+        result = remove_connection_without_sharding(model)
+        initialize_categories if ::Rails.version >= '4'
+        result
+      end
+
+      if ::Rails.version >= '4'
+        def retrieve_connection_pool(klass)
+          class_to_pool[klass.name] ||= begin
+            original_klass = klass
+            until pool = pool_for(klass)
+              klass = klass.superclass
+              break unless klass <= Base
+            end
+
+            if pool.is_a?(ConnectionPoolProxy) && pool.category != original_klass.shard_category
+              default_pool = pool.default_pool
+              pool = nil
+              class_to_pool.each_value { |p| pool = p if p.is_a?(ConnectionPoolProxy) &&
+                  p.category == original_klass.shard_category &&
+                  p.default_pool == default_pool }
+              pool ||= ConnectionPoolProxy.new(original_klass.shard_category, default_pool, @shard_connection_pools)
+            end
+
+            class_to_pool[original_klass.name] = pool
+          end
+        end
       end
 
       private
 
+      # AR3 only; AR4 defines it, and hides this version,
+      # and it's a slightly different data structure
+      def class_to_pool
+        @class_to_pool
+      end
+
       def uninitialize_ar(model = ::ActiveRecord::Base)
         # take the proxies out
-        @class_to_pool.each_key do |model_name|
-          pool_model = model_name.constantize
-          # only de-proxify models that inherit from what we're uninitializing
-          next unless pool_model == model || pool_model < model
-          proxy = @class_to_pool[model_name]
-          next unless proxy.is_a?(ConnectionPoolProxy)
-
-          # make sure we're switched back to the default shard for the
-          # connection that will remain
-          if proxy.connected?
-            Shard.default.activate { proxy.connection }
+        if ::Rails.version >= '4'
+          owner_to_pool[model.name] = owner_to_pool[model.name].default_pool
+        else
+          class_to_pool.each_key do |model_name|
+            pool_model = model_name.constantize
+            # only de-proxify models that inherit from what we're uninitializing
+            next unless pool_model == model || pool_model < model
+            proxy = class_to_pool[model_name]
+            next unless proxy.is_a?(ConnectionPoolProxy)
+
+            # make sure we're switched back to the default shard for the
+            # connection that will remain
+            if proxy.connected?
+              Shard.default.activate(proxy.category) { proxy.connection }
+            end
+            connection_pools[proxy.spec] = proxy.default_pool
+            class_to_pool[model_name] = proxy.default_pool
           end
-          connection_pools[proxy.spec] = proxy.default_pool
-          @class_to_pool[model_name] = proxy.default_pool
-        end
 
-        # prune dups that were created for implementing shard categories
-        @class_to_pool.each_key do |model_name|
-          next if model_name == ::ActiveRecord::Base.name
-          pool_model = model_name.constantize
-          @class_to_pool.delete(model_name) if retrieve_connection_pool(pool_model.superclass) == @class_to_pool[model_name]
+          # prune dups that were created for implementing shard categories
+          class_to_pool.each_key do |model_name|
+            next if model_name == ::ActiveRecord::Base.name
+            pool_model = model_name.constantize
+            class_to_pool.delete(model_name) if retrieve_connection_pool(pool_model.superclass) == class_to_pool[model_name]
+          end
         end
       end
 
       # semi-private
       public
       def initialize_categories(model = ::ActiveRecord::Base)
-        # now set up pools for models that inherit from this model, but with a different
-        # sharding category
-        Shard.const_get(:CATEGORIES).each do |category, models|
-          next if category == :default
-          next if category == model.shard_category
-
-          this_proxy = nil
-          Array(models).each do |category_model|
-            category_model = category_model.constantize if category_model.is_a? String
-            next unless category_model < model
-
-            # don't replace existing connections
-            next if @class_to_pool[category_model.name]
-
-            default_pool = retrieve_connection_pool(model)
-            default_pool = default_pool.default_pool if default_pool.is_a?(ConnectionPoolProxy)
-            # look for an existing compatible proxy for this category
-            this_proxy ||= ConnectionPoolProxy.new(category_model.shard_category, default_pool, @shard_connection_pools)
-            @class_to_pool[category_model.name] = this_proxy
+        if ::Rails.version < '4'
+          # now set up pools for models that inherit from this model, but with a different
+          # sharding category
+          Shard.const_get(:CATEGORIES).each do |category, models|
+            next if category == :default
+            next if category == model.shard_category
+
+            this_proxy = nil
+            Array(models).each do |category_model|
+              category_model = category_model.constantize if category_model.is_a? String
+              next unless category_model < model
+
+              # don't replace existing connections
+              next if class_to_pool[category_model.name]
+
+              default_pool = retrieve_connection_pool(model)
+              default_pool = default_pool.default_pool if default_pool.is_a?(ConnectionPoolProxy)
+              # look for an existing compatible proxy for this category
+              this_proxy ||= ConnectionPoolProxy.new(category_model.shard_category, default_pool, @shard_connection_pools)
+              class_to_pool[category_model.name] = this_proxy
+            end
           end
+        else
+          class_to_pool.clear
         end
       end
     end