ar-octopus 0.8.5 → 0.10.2

data/lib/octopus/migration.rb

@@ -19,7 +19,9 @@ module Octopus
     def self.included(base)
       base.extend(ClassMethods)
 
-      base.alias_method_chain :announce, :octopus
+      base.send :alias_method, :announce_without_octopus, :announce
+      base.send :alias_method, :announce, :announce_with_octopus
+
       base.class_attribute :current_shard, :current_group, :current_group_specified, :instance_reader => false, :instance_writer => false
     end
 
@@ -51,7 +53,7 @@ module Octopus
           shards.merge(Array.wrap(shard))
         end
 
-        shards.to_a.presence || [:master]
+        shards.to_a.presence || [Octopus.master_shard]
       end
     end
   end
@@ -60,81 +62,145 @@ end
 module Octopus
   module Migrator
     def self.included(base)
-      base.extend(ClassMethods)
+      unless Octopus.atleast_rails52?
+        base.extend(ClassMethods)
+
+        base.class_eval do
+          class << self
+              alias_method :migrate_without_octopus, :migrate
+              alias_method :migrate, :migrate_with_octopus
+              
+              alias_method :up_without_octopus, :up
+              alias_method :up, :up_with_octopus
 
-      base.class_eval do
-        class << self
-          alias_method_chain :migrate, :octopus
-          alias_method_chain :up, :octopus
-          alias_method_chain :down, :octopus
-          alias_method_chain :run, :octopus
+              alias_method :down_without_octopus, :down
+              alias_method :down, :down_with_octopus
+
+              alias_method :run_without_octopus, :run
+              alias_method :run, :run_with_octopus
+
+              alias_method :rollback_without_octopus, :rollback
+              alias_method :rollback, :rollback_with_octopus
+          end
         end
       end
 
-      base.alias_method_chain :run, :octopus
-      base.alias_method_chain :migrate, :octopus
-      base.alias_method_chain :migrations, :octopus
-    end
+      base.send :alias_method, :run_without_octopus, :run
+      base.send :alias_method, :run, :run_with_octopus
 
-    def run_with_octopus(&block)
-      run_without_octopus(&block)
-    rescue ActiveRecord::UnknownMigrationVersionError => e
-      raise unless migrations(true).detect { |m| m.version == e.version }
-    end
+      base.send :alias_method, :migrate_without_octopus, :migrate
+      base.send :alias_method, :migrate, :migrate_with_octopus
 
-    def migrate_with_octopus(&block)
-      migrate_without_octopus(&block)
-    rescue ActiveRecord::UnknownMigrationVersionError => e
-      raise unless migrations(true).detect { |m| m.version == e.version }
+      base.send :alias_method, :migrations_without_octopus, :migrations
+      base.send :alias_method, :migrations, :migrations_with_octopus
     end
+    if Octopus.atleast_rails52?
+      ### Post RAILS 5.2 Migration methods
+      
+      def run_with_octopus(&block)
+        return run_without_octopus(&block) unless connection.is_a?(Octopus::Proxy)
+        shards = migrations.map(&:shards).flatten.map(&:to_s)
+        connection.send_queries_to_multiple_shards(shards) do
+          run_without_octopus(&block)
+        end
+        rescue ActiveRecord::UnknownMigrationVersionError => e
+          raise unless migrations(true).detect { |m| m.version == e.version }
+      end
 
-    def migrations_with_octopus(shard_agnostic = false)
-      connection = ActiveRecord::Base.connection
-      migrations = migrations_without_octopus
-      return migrations if !connection.is_a?(Octopus::Proxy) || shard_agnostic
+      def migrate_with_octopus(&block)
+        return migrate_without_octopus(&block) unless connection.is_a?(Octopus::Proxy)
+        shards = migrations.map(&:shards).flatten.map(&:to_s)
+        connection.send_queries_to_multiple_shards(shards) do
+          migrate_without_octopus(&block)
+        end
+        rescue ActiveRecord::UnknownMigrationVersionError => e
+          raise unless migrations(true).detect { |m| m.version == e.version }
+      end
 
-      migrations.select { |m| m.shards.include?(connection.current_shard.to_sym) }
-    end
+      def migrations_with_octopus(shard_agnostic = true)
+        migrations = migrations_without_octopus
+        return migrations if !connection.is_a?(Octopus::Proxy) || shard_agnostic
 
-    module ClassMethods
-      def migrate_with_octopus(migrations_paths, target_version = nil, &block)
-        return migrate_without_octopus(migrations_paths, target_version, &block) unless connection.is_a?(Octopus::Proxy)
+        migrations.select { |m| m.shards.include?(connection.current_shard.to_sym) }
+      end
+      
+      private 
+      
+      def connection
+        ActiveRecord::Base.connection
+      end
+      
+    else 
+      ### Pre RAILS 5.2 Migration methods
+      
+      def run_with_octopus(&block)
+        run_without_octopus(&block)
+      rescue ActiveRecord::UnknownMigrationVersionError => e
+        raise unless migrations(true).detect { |m| m.version == e.version }
+      end
 
-        connection.send_queries_to_multiple_shards(connection.shard_names) do
-          migrate_without_octopus(migrations_paths, target_version, &block)
-        end
+      def migrate_with_octopus(&block)
+        migrate_without_octopus(&block)
+      rescue ActiveRecord::UnknownMigrationVersionError => e
+        raise unless migrations(true).detect { |m| m.version == e.version }
       end
 
-      def up_with_octopus(migrations_paths, target_version = nil, &block)
-        return up_without_octopus(migrations_paths, target_version, &block) unless connection.is_a?(Octopus::Proxy)
-        return up_without_octopus(migrations_paths, target_version, &block) unless connection.current_shard == :master
+      def migrations_with_octopus(shard_agnostic = false)
+        connection = ActiveRecord::Base.connection
+        migrations = migrations_without_octopus
+        return migrations if !connection.is_a?(Octopus::Proxy) || shard_agnostic
 
-        connection.send_queries_to_multiple_shards(connection.shard_names) do
-          up_without_octopus(migrations_paths, target_version, &block)
-        end
+        migrations.select { |m| m.shards.include?(connection.current_shard.to_sym) }
       end
 
-      def down_with_octopus(migrations_paths, target_version = nil, &block)
-        return down_without_octopus(migrations_paths, target_version, &block) unless connection.is_a?(Octopus::Proxy)
-        return down_without_octopus(migrations_paths, target_version, &block) unless connection.current_shard == :master
+      module ClassMethods
+        def migrate_with_octopus(migrations_paths, target_version = nil, &block)
+          return migrate_without_octopus(migrations_paths, target_version, &block) unless connection.is_a?(Octopus::Proxy)
 
-        connection.send_queries_to_multiple_shards(connection.shard_names) do
-          down_without_octopus(migrations_paths, target_version, &block)
+          connection.send_queries_to_multiple_shards(connection.shard_names) do
+            migrate_without_octopus(migrations_paths, target_version, &block)
+          end
         end
-      end
 
-      def run_with_octopus(direction, migrations_paths, target_version)
-        return run_without_octopus(direction, migrations_paths, target_version) unless connection.is_a?(Octopus::Proxy)
+        def up_with_octopus(migrations_paths, target_version = nil, &block)
+          return up_without_octopus(migrations_paths, target_version, &block) unless connection.is_a?(Octopus::Proxy)
+          return up_without_octopus(migrations_paths, target_version, &block) unless connection.current_shard.to_s == Octopus.master_shard.to_s
 
-        connection.send_queries_to_multiple_shards(connection.shard_names) do
-          run_without_octopus(direction, migrations_paths, target_version)
+          connection.send_queries_to_multiple_shards(connection.shard_names) do
+            up_without_octopus(migrations_paths, target_version, &block)
+          end
         end
-      end
 
-      private
+        def down_with_octopus(migrations_paths, target_version = nil, &block)
+          return down_without_octopus(migrations_paths, target_version, &block) unless connection.is_a?(Octopus::Proxy)
+          return down_without_octopus(migrations_paths, target_version, &block) unless connection.current_shard.to_s == Octopus.master_shard.to_s
 
-      def connection
-        ActiveRecord::Base.connection
+          connection.send_queries_to_multiple_shards(connection.shard_names) do
+            down_without_octopus(migrations_paths, target_version, &block)
+          end
+        end
+
+        def run_with_octopus(direction, migrations_paths, target_version)
+          return run_without_octopus(direction, migrations_paths, target_version) unless connection.is_a?(Octopus::Proxy)
+
+          connection.send_queries_to_multiple_shards(connection.shard_names) do
+            run_without_octopus(direction, migrations_paths, target_version)
+          end
+        end
+
+        def rollback_with_octopus(migrations_paths, steps = 1)
+          return rollback_without_octopus(migrations_paths, steps) unless connection.is_a?(Octopus::Proxy)
+
+          connection.send_queries_to_multiple_shards(connection.shard_names) do
+            rollback_without_octopus(migrations_paths, steps)
+          end
+        end
+
+        private
+
+        def connection
+          ActiveRecord::Base.connection
+        end
       end
     end
   end
@@ -151,7 +217,9 @@ end
 module Octopus
   module UnknownMigrationVersionError
     def self.included(base)
-      base.alias_method_chain :initialize, :octopus
+      base.send :alias_method, :initialize_without_octopus, :initialize
+      base.send :alias_method, :initialize, :initialize_with_octopus
+
       base.send(:attr_accessor, :version)
     end
 

data/lib/octopus/model.rb

@@ -9,20 +9,16 @@ module Octopus
     end
 
     module SharedMethods
-      def clean_table_name
-        return unless connection_proxy.should_clean_table_name?
+      def using(shard)
+        if block_given?
+          raise Octopus::Exception, <<-EOF
+#{name}.using is not allowed to receive a block, it works just like a regular scope.
 
-        if self != ActiveRecord::Base && self.respond_to?(:reset_table_name) && !custom_octopus_table_name
-          reset_table_name
+If you are trying to scope everything to a specific shard, use Octopus.using instead.
+          EOF
         end
 
-        reset_column_information
-        instance_variable_set(:@quoted_table_name, nil)
-      end
-
-      def using(shard)
         if Octopus.enabled?
-          clean_table_name
           Octopus::ScopeProxy.new(shard, self)
         else
           self
@@ -37,19 +33,29 @@ module Octopus
         base.send(:alias_method, :equality_without_octopus, :==)
         base.send(:alias_method, :==, :equality_with_octopus)
         base.send(:alias_method, :eql?, :==)
-        base.send(:alias_method_chain, :perform_validations, :octopus)
+        base.send(:alias_method, :perform_validations_without_octopus, :perform_validations)
+        base.send(:alias_method, :perform_validations, :perform_validations_with_octopus)
       end
 
       def set_current_shard
         return unless Octopus.enabled?
+        shard = self.class.connection_proxy.current_shard
+        self.current_shard = shard if self.class.allowed_shard?(shard)
+      end
 
-        if new_record? || self.class.connection_proxy.block
-          shard = self.class.connection_proxy.current_shard
-        else
-          shard = self.class.connection_proxy.last_current_shard || self.class.connection_proxy.current_shard
-        end
+      def init_with(coder)
+        obj = super
 
-        self.current_shard = shard if self.class.allowed_shard?(shard)
+        return obj unless Octopus.enabled?
+        return obj if obj.class.connection_proxy.current_model_replicated?
+
+        current_shard_value = coder['attributes']['current_shard'].value if coder['attributes']['current_shard'].present? && coder['attributes']['current_shard'].value.present?
+
+        coder['attributes'].send(:attributes).send(:values).delete('current_shard')
+        coder['attributes'].send(:attributes).send(:delegate_hash).delete('current_shard')
+
+        obj.current_shard = current_shard_value if current_shard_value.present?
+        obj
       end
 
       def should_set_current_shard?
@@ -57,7 +63,7 @@ module Octopus
       end
 
       def equality_with_octopus(comparison_object)
-        equality_without_octopus(comparison_object) && comparison_object.current_shard == current_shard
+        equality_without_octopus(comparison_object) && comparison_object.current_shard.to_s == current_shard.to_s
       end
 
       def perform_validations_with_octopus(*args)
@@ -95,20 +101,29 @@ module Octopus
       end
 
       def hijack_methods
-        around_save :run_on_shard, :unless => -> { self.class.custom_octopus_connection }
         after_initialize :set_current_shard
 
+        around_save :run_on_shard, :unless => lambda { self.class.custom_octopus_connection }
+
+        class_attribute :custom_octopus_connection
+
         class << self
-          attr_accessor :custom_octopus_connection
           attr_accessor :custom_octopus_table_name
 
-          alias_method_chain :connection, :octopus
-          alias_method_chain :connection_pool, :octopus
-          alias_method_chain :clear_all_connections!, :octopus
-          alias_method_chain :clear_active_connections!, :octopus
-          alias_method_chain :connected?, :octopus
+          alias_method :connection_without_octopus, :connection
+          alias_method :connection, :connection_with_octopus
+
+          alias_method :connection_pool_without_octopus, :connection_pool
+          alias_method :connection_pool, :connection_pool_with_octopus
+
+          alias_method :clear_all_connections_without_octopus!, :clear_all_connections!
+          alias_method :clear_all_connections!, :clear_all_connections_with_octopus!
+
+          alias_method :clear_active_connections_without_octopus!, :clear_active_connections!
+          alias_method :clear_active_connections!, :clear_active_connections_with_octopus!
 
-          alias_method_chain(:set_table_name, :octopus) if Octopus.rails3?
+          alias_method :connected_without_octopus?, :connected?
+          alias_method :connected?, :connected_with_octopus?
 
           def table_name=(value = nil)
             self.custom_octopus_table_name = true
@@ -133,7 +148,7 @@ module Octopus
 
       def allowed_shard?(shard)
         if custom_octopus_connection
-          allowed_shards && shard && allowed_shards.include?(shard)
+          allowed_shards && shard && (allowed_shards.include?(shard.to_s) || allowed_shards.include?(shard.to_sym))
         else
           true
         end

data/lib/octopus/persistence.rb

@@ -1,39 +1,45 @@
 module Octopus
-  module Rails3
-    module Persistence
-      def update_attribute(*args)
-        run_on_shard { super }
-      end
+  module Persistence
+    def update_attribute(*args)
+      run_on_shard { super }
+    end
 
-      def update_attributes(*args)
-        run_on_shard { super }
-      end
+    def update_attributes(*args)
+      run_on_shard { super }
+    end
 
-      def update_attributes!(*args)
-        run_on_shard { super }
-      end
+    def update_attributes!(*args)
+      run_on_shard { super }
+    end
 
-      def reload(*args)
-        run_on_shard { super }
-      end
+    def reload(*args)
+      run_on_shard { super }
+    end
 
-      def delete
-        run_on_shard { super }
-      end
+    def delete
+      run_on_shard { super }
+    end
 
-      def destroy
-        run_on_shard { super }
-      end
+    def destroy
+      run_on_shard { super }
+    end
 
-      def touch(*args)
-        run_on_shard { super }
-      end
+    def touch(*args)
+      run_on_shard { super }
+    end
+
+    def update_column(*args)
+      run_on_shard { super }
+    end
+
+    def increment!(*args)
+      run_on_shard { super }
+    end
 
-      def update_column(*args)
-        run_on_shard { super }
-      end
+    def decrement!(*args)
+      run_on_shard { super }
     end
   end
 end
 
-ActiveRecord::Base.send(:include, Octopus::Rails3::Persistence)
+ActiveRecord::Base.send(:include, Octopus::Persistence)