switchman 1.0.0 → 1.2.0

data/lib/switchman/active_record/query_methods.rb

@@ -12,36 +12,59 @@ module Switchman
       #                  for foreign key transposition
       #   :to_a        - a special value that Relation#to_a uses when querying multiple shards to
       #                  remove primary keys from conditions that aren't applicable to the current shard
-      attr_accessor :shard_value, :shard_source_value
+      if ::Rails.version < '4'
+        attr_accessor :shard_value, :shard_source_value
+      else
+        def shard_value
+          @values[:shard]
+        end
+        def shard_source_value
+          @values[:shard_source]
+        end
+        def shard_value=(value)
+          raise ImmutableRelation if @loaded
+          @values[:shard] = value
+        end
+        def shard_source_value=(value)
+          raise ImmutableRelation if @loaded
+          @values[:shard_source] = value
+        end
+      end
 
       def shard(value, source = :explicit)
-        relation = clone
-        relation.shard_value = value
-        relation.shard_source_value = source
-        if (primary_shard != relation.primary_shard || source == :to_a)
-          relation.where_values = relation.transpose_predicates(relation.where_values, primary_shard, relation.primary_shard, source == :to_a) if !relation.where_values.empty?
-          relation.having_values = relation.transpose_predicates(relation.having_values, primary_shard, relation.primary_shard, source == :to_a) if !relation.having_values.empty?
+        (::Rails.version < '4' ? clone : spawn).shard!(value, source)
+      end
+
+      def shard!(value, source = :explicit)
+        primary_shard = self.primary_shard
+        self.shard_value = value
+        self.shard_source_value = source
+        if (primary_shard != self.primary_shard || source == :to_a)
+          self.where_values = transpose_predicates(where_values, primary_shard, self.primary_shard, source == :to_a) if !where_values.empty?
+          self.having_values = transpose_predicates(having_values, primary_shard, self.primary_shard, source == :to_a) if !having_values.empty?
         end
-        relation
+        self
       end
 
-      # replace these with versions that call build_where on the
-      # result relation, not the source relation (so build_where
-      # is able to implicitly change the shard_value)
-      def where(opts, *rest)
-        return self if opts.blank?
+      if ::Rails.version < '4'
+        # replace these with versions that call build_where on the
+        # result relation, not the source relation (so build_where
+        # is able to implicitly change the shard_value)
+        def where(opts, *rest)
+          return self if opts.blank?
 
-        relation = clone
-        relation.where_values += relation.build_where(opts, rest)
-        relation
-      end
+          relation = clone
+          relation.where_values += relation.build_where(opts, rest)
+          relation
+        end
 
-      def having(opts, *rest)
-        return self if opts.blank?
+        def having(opts, *rest)
+          return self if opts.blank?
 
-        relation = clone
-        relation.having_values += relation.build_where(opts, rest)
-        relation
+          relation = clone
+          relation.having_values += relation.build_where(opts, rest)
+          relation
+        end
       end
 
       def build_where(opts, other = [])
@@ -147,6 +170,7 @@ module Switchman
       end
 
       def sharded_primary_key?(relation, column)
+        return column == 'id' if relation.engine == ::ActiveRecord::Base
         relation.engine.primary_key == column
       end
 
@@ -165,6 +189,7 @@ module Switchman
         attribute = attribute.relation if attribute.relation.is_a?(Arel::Nodes::TableAlias)
         [attribute.relation, column]
       end
+
       # semi-private
       public
       def transpose_predicates(predicates, source_shard, target_shard, remove_nonlocal_primary_keys = false)
@@ -194,11 +219,11 @@ module Switchman
             local_ids
           when Arel::Nodes::BindParam
             # look for a bind param with a matching column name
-            if @bind_params && idx = @bind_params.find_index{|b| b.is_a?(Array) && b.first.try(:name) == predicate.left}
-              column, value = @bind_params[idx]
+            if bind_values && idx = bind_values.find_index{|b| b.is_a?(Array) && b.first.try(:name) == predicate.left.name}
+              column, value = bind_values[idx]
               local_id = Shard.relative_id_for(value, current_source_shard, target_shard)
               local_id = [] if remove && local_id > Shard::IDS_PER_SHARD
-              @bind_params[idx] = [column, local_id]
+              bind_values[idx] = [column, local_id]
             end
             predicate.right
           else

data/lib/switchman/active_record/relation.rb

@@ -13,10 +13,10 @@ module Switchman
         end
       end
 
-      def initialize_with_sharding(klass, table)
-        initialize_without_sharding(klass, table)
-        self.shard_value = Shard.current(klass.shard_category)
-        self.shard_source_value = :implicit
+      def initialize_with_sharding(*args)
+        initialize_without_sharding(*args)
+        self.shard_value = Shard.current(klass.try(:shard_category) || :default) unless shard_value
+        self.shard_source_value = :implicit unless shard_source_value
       end
 
       def merge(*args)
@@ -62,7 +62,7 @@ module Switchman
       end
 
       %w{update_all delete_all}.each do |method|
-        class_eval <<-RUBY
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
           def #{method}_with_deshackles(*args)
             db = Shard.current(shard_category).database_server
             if ::Shackles.environment != db.shackles_environment

data/lib/switchman/active_record/spawn_methods.rb

@@ -1,17 +1,13 @@
 module Switchman
   module ActiveRecord
     module SpawnMethods
-      def merge(r)
-        return self unless r
-        return to_a & r if r.is_a?(Array)
-
-        # have to figure out shard stuff *before* conditions are merged
+      def shard_values_for_merge(r)
         if shard_value != r.shard_value
-          if (r.shard_source_value == :implicit)
+          if r.shard_source_value == :implicit
             final_shard_value = shard_value
             final_primary_shard = primary_shard
             final_shard_source_value = shard_source_value
-          elsif (shard_source_value == :implicit)
+          elsif shard_source_value == :implicit
             final_shard_value = r.shard_value
             final_primary_shard = r.primary_shard
             final_shard_source_value = r.shard_source_value
@@ -30,7 +26,6 @@ module Switchman
               final_primary_shard = Shard.default
             else
               final_shard_value = lhs_shard_value.to_a & rhs_shard_value.to_a
-              return none if final_shard_value.length == 0
               final_primary_shard = final_shard_value.first
               final_shard_value = final_shard_value.first if final_shard_value.length == 1
             end
@@ -40,34 +35,86 @@ module Switchman
             shard_source_value == source_value || r.shard_source_value == source_value
           end
           raise "unknown shard_source_value" unless final_shard_source_value
-
-          result = super
-          result.shard_source_value = final_shard_source_value
-          return result
         else
           # nothing fancy
-          return super
         end
 
-        # change the primary shard if necessary before merging
-        result = if primary_shard != final_primary_shard && r.primary_shard != final_primary_shard
-          lhs = shard(final_primary_shard)
-          r = r.shard(final_primary_shard)
-          lhs.merge(r)
-        elsif primary_shard != final_primary_shard
-          lhs = shard(final_primary_shard)
-          lhs.merge(r)
-        elsif r.primary_shard != final_primary_shard
-          r = r.shard(final_primary_shard)
-          super(r)
-        else
-          super
+        [final_shard_value, final_primary_shard, final_shard_source_value]
+      end
+
+      if ::Rails.version < '4'
+        def merge(r)
+          return self unless r
+          return super unless r.is_a?(Relation)
+
+          # have to figure out shard stuff *before* conditions are merged
+          final_shard_value, final_primary_shard, final_shard_source_value = shard_values_for_merge(r)
+
+          return super unless final_shard_source_value
+
+          if !final_shard_value
+            result = super
+            result.shard_source_value = final_shard_source_value
+            return result
+          end
+
+          return none if final_shard_value == []
+
+          # change the primary shard if necessary before merging
+          result = if primary_shard != final_primary_shard && r.primary_shard != final_primary_shard
+                     lhs = shard(final_primary_shard)
+                     r = r.shard(final_primary_shard)
+                     lhs.merge(r)
+                   elsif primary_shard != final_primary_shard
+                     lhs = shard(final_primary_shard)
+                     lhs.merge(r)
+                   elsif r.primary_shard != final_primary_shard
+                     r = r.shard(final_primary_shard)
+                     super(r)
+                   else
+                     super
+                   end
+
+          result.shard_value = final_shard_value
+          result.shard_source_value = final_shard_source_value
+
+          result
         end
+      else
+        def merge!(r)
+          # have to figure out shard stuff *before* conditions are merged
+          final_shard_value, final_primary_shard, final_shard_source_value = shard_values_for_merge(r)
+
+          return super unless final_shard_source_value
+
+          if !final_shard_value
+            super
+            self.shard_source_value = final_shard_source_value
+            return self
+          end
 
-        result.shard_value = final_shard_value
-        result.shard_source_value = final_shard_source_value
+          return none! if final_shard_value == []
 
-        result
+          # change the primary shard if necessary before merging
+          if primary_shard != final_primary_shard && r.primary_shard != final_primary_shard
+            shard!(final_primary_shard)
+            r = r.shard(final_primary_shard)
+            super(r)
+          elsif primary_shard != final_primary_shard
+            shard!(final_primary_shard)
+            super(r)
+          elsif r.primary_shard != final_primary_shard
+            r = r.shard(final_primary_shard)
+            super(r)
+          else
+            super
+          end
+
+          self.shard_value = final_shard_value
+          self.shard_source_value = final_shard_source_value
+
+          self
+        end
       end
     end
   end

data/lib/switchman/connection_pool_proxy.rb

@@ -2,6 +2,7 @@ module Switchman
   module ConnectionError
     def self.===(other)
       return true if defined?(PG::Error) && PG::Error === other
+      return true if defined?(Mysql2::Error) && Mysql2::Error === other
       false
     end
   end
@@ -90,7 +91,8 @@ module Switchman
           end
         end
       end
-      spec = ::ActiveRecord::Base::ConnectionSpecification.new(config, "#{config[:adapter]}_connection")
+      klass = ::Rails.version < '4' ? ::ActiveRecord::Base : ::ActiveRecord::ConnectionAdapters
+      spec = klass::ConnectionSpecification.new(config, "#{config[:adapter]}_connection")
       # unfortunately the AR code that does this require logic can't really be
       # called in isolation
       require "active_record/connection_adapters/#{config[:adapter]}_adapter"

data/lib/switchman/database_server.rb

@@ -125,7 +125,7 @@ module Switchman
     end
 
     def create_new_shard(options = {})
-      raise MethodNotImplemented unless Shard.default.is_a?(Shard)
+      raise NotImplementedError.new("Cannot create new shards when sharding isn't initialized") unless Shard.default.is_a?(Shard)
 
       db_name = options[:db_name]
       create_schema = options[:schema]
@@ -193,13 +193,15 @@ module Switchman
                     ::ActiveRecord::Base.connection.execute(stmt)
                   end
                   # have to disconnect and reconnect to the correct db
+                  shard.name = db_name
                   if self.shareable? && other_shard
                     other_shard.activate { ::ActiveRecord::Base.connection }
                   else
                     ::ActiveRecord::Base.connection_pool.current_pool.disconnect!
                   end
+                else
+                  shard.name = db_name
                 end
-                shard.name = db_name
                 old_proc = ::ActiveRecord::Base.connection.raw_connection.set_notice_processor {} if config[:adapter] == 'postgresql'
                 old_verbose = ::ActiveRecord::Migration.verbose
                 ::ActiveRecord::Migration.verbose = false

data/lib/switchman/engine.rb

@@ -3,6 +3,9 @@ module Switchman
     isolate_namespace Switchman
 
     initializer 'switchman.initialize_cache', :before => 'initialize_cache' do
+      require "switchman/active_support/cache"
+      ::ActiveSupport::Cache::Store.send(:include, ActiveSupport::Cache::Store)
+
       # if we haven't already setup our cache map out-of-band, set it up from
       # config.cache_store now. behaves similarly to Rails' default
       # initialize_cache initializer, but for each value in the map, rather
@@ -46,11 +49,13 @@ module Switchman
       else
         ::Rails.cache = Switchman.config[:cache_map][::Rails.env]
       end
+
+      require "switchman/rails"
+      ::Rails.send(:include, Rails)
     end
 
     initializer 'switchman.extend_ar', :before => "active_record.initialize_database" do
       ::ActiveSupport.on_load(:active_record) do
-        require "switchman/active_support/cache"
         require "switchman/active_record/abstract_adapter"
         require "switchman/active_record/association"
         require "switchman/active_record/attribute_methods"
@@ -64,15 +69,13 @@ module Switchman
         require "switchman/active_record/query_methods"
         require "switchman/active_record/relation"
         require "switchman/active_record/spawn_methods"
-        require "switchman/rails"
 
-        ::ActiveSupport::Cache::Store.send(:include, ActiveSupport::Cache::Store)
         include ActiveRecord::Base
         include ActiveRecord::AttributeMethods
         ::ActiveRecord::Associations::Association.send(:include, ActiveRecord::Association)
         ::ActiveRecord::Associations::BelongsToAssociation.send(:include, ActiveRecord::BelongsToAssociation)
         ::ActiveRecord::Associations::CollectionProxy.send(:include, ActiveRecord::CollectionProxy)
-        ::ActiveRecord::Associations::Builder::Association.send(:include, ActiveRecord::Builder::Association)
+        ::ActiveRecord::Associations::Builder::CollectionAssociation.send(:include, ActiveRecord::Builder::CollectionAssociation)
 
         ::ActiveRecord::Associations::Preloader::Association.send(:include, ActiveRecord::Preloader::Association)
         ::ActiveRecord::ConnectionAdapters::AbstractAdapter.send(:include, ActiveRecord::AbstractAdapter)
@@ -91,7 +94,6 @@ module Switchman
         ::ActiveRecord::Relation.send(:include, ActiveRecord::QueryMethods)
         ::ActiveRecord::Relation.send(:include, ActiveRecord::Relation)
         ::ActiveRecord::Relation.send(:include, ActiveRecord::SpawnMethods)
-        ::Rails.send(:include, Rails)
       end
     end
 
@@ -104,6 +106,7 @@ module Switchman
     initializer 'switchman.extend_connection_adapters', :after => "active_record.initialize_database" do
       ::ActiveSupport.on_load(:active_record) do
         ::ActiveRecord::ConnectionAdapters::AbstractAdapter.descendants.each do |klass|
+          next if klass.instance_methods.include?(:add_column_with_foreign_key_check)
           klass.class_eval do
             def add_column_with_foreign_key_check(table, name, type, options = {})
               Switchman::Engine.foreign_key_check(name, type, options)

data/lib/switchman/r_spec_helper.rb

@@ -96,9 +96,13 @@ module Switchman
           shards.each do |shard|
             shard.activate do
               # this is how AR does it in fixtures.rb
-              ::ActiveRecord::Base.connection.increment_open_transactions
-              ::ActiveRecord::Base.connection.transaction_joinable = false
-              ::ActiveRecord::Base.connection.begin_db_transaction
+              if ::Rails.version < '4'
+                ::ActiveRecord::Base.connection.increment_open_transactions
+                ::ActiveRecord::Base.connection.transaction_joinable = false
+                ::ActiveRecord::Base.connection.begin_db_transaction
+              else
+                ::ActiveRecord::Base.connection.begin_transaction joinable: false
+              end
             end
           end
         end
@@ -110,9 +114,13 @@ module Switchman
           shards << @shard1 unless @shard1.database_server == Shard.default.database_server
           shards.each do |shard|
             shard.activate do
-              if ::ActiveRecord::Base.connection.open_transactions != 0
-                ::ActiveRecord::Base.connection.rollback_db_transaction
-                ::ActiveRecord::Base.connection.decrement_open_transactions
+              if ::Rails.version < '4'
+                if ::ActiveRecord::Base.connection.open_transactions != 0
+                  ::ActiveRecord::Base.connection.rollback_db_transaction
+                  ::ActiveRecord::Base.connection.decrement_open_transactions
+                end
+              else
+                ::ActiveRecord::Base.connection.rollback_transaction if ::ActiveRecord::Base.connection.transaction_open?
               end
             end
           end

data/lib/switchman/rails.rb

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

data/lib/switchman/test_helper.rb

@@ -5,9 +5,9 @@ module Switchman
         # recreate the default shard (it got buhleted)
         if Shard.default(true).is_a?(DefaultShard)
           begin
-            Shard.create!(:default => true)
+            Shard.create!(default: true)
           rescue
-            # database doesn't exist yet, presumably
+            # database doesn't exist yet, presumably cause we're creating it right now
             [nil, nil]
           end
           Shard.default(true)
@@ -15,7 +15,8 @@ module Switchman
 
         # 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_pools.length > 1
+        if (::Rails.version < '4' ? ::ActiveRecord::Base.connection_handler.connection_pools.length :
+            ::ActiveRecord::Base.connection_handler.connection_pool_list.length) > 1
           server1 = DatabaseServer.create(:config => Shard.default.database_server.config)
         else
           server1 = Shard.default.database_server

data/lib/switchman/version.rb

@@ -1,3 +1,3 @@
 module Switchman
-  VERSION = "1.0.0"
+  VERSION = "1.2.0"
 end

data/spec/dummy/app/models/appendage.rb

@@ -1,13 +1,11 @@
 class Appendage < ActiveRecord::Base
-  attr_accessible :user, :user_id, :value
-
   belongs_to :user
   has_many :digits
 
   has_many :features, :as => :owner
 
-  scope :has_no_value, where(:value => nil)
-  scope :has_value, where("appendages.value IS NOT NULL")
+  scope :has_no_value, -> { where(:value => nil) }
+  scope :has_value, -> { where("appendages.value IS NOT NULL") }
 
   attr_writer :associated_shards
   class << self

data/spec/dummy/app/models/digit.rb

@@ -1,9 +1,7 @@
 class Digit < ActiveRecord::Base
-  attr_accessible :appendage, :appendage_id, :value
-
   belongs_to :appendage
   has_one :user, :through => :appendage
 
-  scope :has_no_value, where(:value => nil)
-  scope :has_value, where("digits.value IS NOT NULL")
+  scope :has_no_value, -> { where(:value => nil) }
+  scope :has_value, -> { where("digits.value IS NOT NULL") }
 end

data/spec/dummy/app/models/feature.rb

@@ -1,5 +1,3 @@
 class Feature < ActiveRecord::Base
   belongs_to :owner, :polymorphic => true
-
-  attr_accessible :owner, :value
 end

data/spec/dummy/app/models/user.rb

@@ -1,6 +1,4 @@
 class User < ActiveRecord::Base
-  attr_accessible :name
-
   has_many :appendages, :multishard => true
   has_many :digits, :through => :appendages, :multishard => true
 

data/spec/dummy/config/application.rb

@@ -43,12 +43,6 @@ module Dummy
     # like if you have constraints or database-specific column types
     # config.active_record.schema_format = :sql
 
-    # Enforce whitelist mode for mass assignment.
-    # This will create an empty whitelist of attributes available for mass-assignment for all models
-    # in your app. As such, your models will need to explicitly whitelist or blacklist accessible
-    # parameters by using an attr_accessible or attr_protected declaration.
-    config.active_record.whitelist_attributes = true
-
     # Enable the asset pipeline
     config.assets.enabled = true
 

data/spec/dummy/config/database.yml

@@ -15,3 +15,13 @@ test:
   adapter: postgresql
   database: switchman_test
   port: 15432
+
+testm:
+  adapter: mysql2
+  database: switchman_test
+  socket: /opt/boxen/data/mysql/socket
+  username: root
+
+tests:
+  adapter: sqlite3
+  database: db/switchman_test.sqlite3

data/spec/dummy/config/environments/development.rb

@@ -6,25 +6,16 @@ Dummy::Application.configure do
   # since you don't have to restart the web server when you make code changes.
   config.cache_classes = false
 
-  # Log error messages when you accidentally call methods on nil.
-  config.whiny_nils = true
-
   # Show full error reports and disable caching
   config.consider_all_requests_local       = true
   config.action_controller.perform_caching = false
 
-  # Don't care if the mailer can't send
-  config.action_mailer.raise_delivery_errors = false
-
   # Print deprecation notices to the Rails logger
   config.active_support.deprecation = :log
 
   # Only use best-standards-support built into browsers
   config.action_dispatch.best_standards_support = :builtin
 
-  # Raise exception on mass assignment protection for Active Record models
-  config.active_record.mass_assignment_sanitizer = :strict
-
   # Log the query plan for queries taking more than this (works
   # with SQLite, MySQL, and PostgreSQL)
   config.active_record.auto_explain_threshold_in_seconds = 0.5
@@ -34,4 +25,6 @@ Dummy::Application.configure do
 
   # Expands the lines which load the assets
   config.assets.debug = true
+
+  config.eager_load = false
 end

data/spec/dummy/config/environments/production.rb

@@ -48,9 +48,6 @@ Dummy::Application.configure do
   # Precompile additional assets (application.js, application.css, and all non-JS/CSS are already added)
   # config.assets.precompile += %w( search.js )
 
-  # Disable delivery errors, bad email addresses will be ignored
-  # config.action_mailer.raise_delivery_errors = false
-
   # Enable threaded mode
   # config.threadsafe!
 
@@ -64,4 +61,6 @@ Dummy::Application.configure do
   # Log the query plan for queries taking more than this (works
   # with SQLite, MySQL, and PostgreSQL)
   # config.active_record.auto_explain_threshold_in_seconds = 0.5
+
+  config.eager_load = true
 end

data/spec/dummy/config/environments/test.rb

@@ -11,9 +11,6 @@ Dummy::Application.configure do
   config.serve_static_assets = true
   config.static_cache_control = "public, max-age=3600"
 
-  # Log error messages when you accidentally call methods on nil
-  config.whiny_nils = true
-
   # Show full error reports and disable caching
   config.consider_all_requests_local       = true
   config.action_controller.perform_caching = false
@@ -24,14 +21,8 @@ Dummy::Application.configure do
   # Disable request forgery protection in test environment
   config.action_controller.allow_forgery_protection    = false
 
-  # Tell Action Mailer not to deliver emails to the real world.
-  # The :test delivery method accumulates sent emails in the
-  # ActionMailer::Base.deliveries array.
-  config.action_mailer.delivery_method = :test
-
-  # Raise exception on mass assignment protection for Active Record models
-  config.active_record.mass_assignment_sanitizer = :strict
-
   # Print deprecation notices to the stderr
   config.active_support.deprecation = :stderr
+
+  config.eager_load = false
 end

data/spec/dummy/config/routes.rb

@@ -3,6 +3,6 @@ Dummy::Application.routes.draw do
     resources :appendages
   end
 
-  match 'users/:id' => 'users#test1', :as => :user_test1
-  match 'users/:user_id/test2' => 'users#test2', :as => :user_test2
+  get 'users/:id' => 'users#test1', :as => :user_test1
+  get 'users/:user_id/test2' => 'users#test2', :as => :user_test2
 end