ar-octopus 0.9.2 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5bacaaae3374f747c5158b3cf929bc53bb6b37c0
-  data.tar.gz: acef7102fc1a7639b43e3425325a357a682b553d
+  metadata.gz: 962dc9c9117e08008c637c759626480b47566338
+  data.tar.gz: 8661fb69b2f9fd24df265827eabbc5ee4aa623ce
 SHA512:
-  metadata.gz: d574b68144683c9ab61ee42e390c579ce41ff4997584eb081277b43df22a2b8ae0c996de227a04cb8832fb2435309b7429d3b630225306a4ff9939f55b5074d5
-  data.tar.gz: a24042265c44af4c6fe61c0681eac8f4848d565bd2b7a454942a4ed62497249abc0fd79c2d949ea28ea8daa01c5b534996e50a051b009246a8f95e0a91a0d315
+  metadata.gz: f6091ea4584d2c031076b6ea0f4fc06abd9a10c2ed4d88762711d4854c8524c5172bab6081e50bc2a73c8ccf67dc68aeba8d91cdf179cfdc9aa7b77dbff37924
+  data.tar.gz: 96109ec7506bed3e1cd898e2efb1174006d18ca35ee538dbf5e1912fc3d4465188dd7110884ffaff17c2c9fefe126c726e415201e8423e2e957e1dbbaf7bd378

data/.travis.yml

@@ -8,18 +8,11 @@ rvm:
   - 2.3.4
   - 2.4.1
 gemfile:
-  - gemfiles/rails4.gemfile
-  - gemfiles/rails41.gemfile
   - gemfiles/rails42.gemfile
   - gemfiles/rails5.gemfile
   - gemfiles/rails51.gemfile
+  - gemfiles/rails52.gemfile
 notifications:
   recipients:
     - gabriel.sobrinho@gmail.com
     - thiago.pradi@gmail.com
-matrix:
-  exclude:
-    - rvm: 2.4.1
-      gemfile: gemfiles/rails4.gemfile
-    - rvm: 2.4.1
-      gemfile: gemfiles/rails41.gemfile

data/Appraisals

@@ -1,11 +1,3 @@
-appraise "rails4" do
-  gem "activerecord", "~> 4.0.0"
-end
-
-appraise "rails41" do
-  gem "activerecord", "~> 4.1.0"
-end
-
 appraise "rails42" do
   gem "activerecord", "~> 4.2.0"
 end
@@ -17,4 +9,8 @@ end
 appraise "rails51" do
   gem "activerecord", "~> 5.1.0"
 end
+
+appraise "rails52" do
+  gem "activerecord", "~> 5.2.0"
+end
 # vim: ft=ruby

data/README.mkdn

@@ -1,6 +1,11 @@
+# Important Notice:
+
+Octopus will enter into maintainance mode once Rails 6 is released - since Rails 6 will include all the features for Database Sharding / Replication into Rails Core (PR: https://github.com/rails/rails/pull/34052).
+Once the first version of Rails 6 beta is released, there will be a migration guide to help users migrate from Octopus to Rails 6.
+
 # Octopus  - Easy Database Sharding for ActiveRecord
 
-<a href='http://www.pledgie.com/campaigns/20950'><img alt='Click here to lend your support to: Octopus and make a donation at www.pledgie.com !' src='http://www.pledgie.com/campaigns/20950.png?skin_name=chrome' border='0' /></a> [![Build Status](https://travis-ci.org/thiagopradi/octopus.svg)](https://travis-ci.org/thiagopradi/octopus) [![Code Climate](https://codeclimate.com/badge.png)](https://codeclimate.com/github/thiagopradi/octopus)
+[![Build Status](https://travis-ci.org/thiagopradi/octopus.svg)](https://travis-ci.org/thiagopradi/octopus) [![Code Climate](https://codeclimate.com/badge.png)](https://codeclimate.com/github/thiagopradi/octopus)
 
 Octopus is a better way to do Database Sharding in ActiveRecord. Sharding allows multiple databases in the same rails application. While there are several projects that implement Sharding (e.g. DbCharmer, DataFabric, MultiDb), each project has its own limitations. The main goal of octopus project is to provide a better way of doing Database Sharding.
 

data/Rakefile

@@ -65,6 +65,7 @@ namespace :db do
       class BlankModel < ActiveRecord::Base; end
 
       BlankModel.using(shard_symbol).connection.initialize_schema_migrations_table
+      BlankModel.using(shard_symbol).connection.initialize_metadata_table if Octopus.atleast_rails50? 
 
       BlankModel.using(shard_symbol).connection.create_table(:users) do |u|
         u.string :name

data/ar-octopus.gemspec

@@ -21,13 +21,13 @@ Gem::Specification.new do |s|
                            'Octopus now stores schema version information in each shard and migrations will not ' \
                            'work properly unless this task is invoked.'
 
-  s.required_ruby_version = '>= 2.1.0'
+  s.required_ruby_version = '>= 2.2.0'
 
-  s.add_dependency 'activerecord', '>= 4.0.0'
-  s.add_dependency 'activesupport', '>= 4.0.0'
+  s.add_dependency 'activerecord', '>= 4.2.0'
+  s.add_dependency 'activesupport', '>= 4.2.0'
 
   s.add_development_dependency 'appraisal', '>= 0.3.8'
-  s.add_development_dependency 'mysql2', '~> 0.3.18'
+  s.add_development_dependency 'mysql2', '>= 0.3.18', "< 0.5"
   s.add_development_dependency 'pg', '~> 0.18'
   s.add_development_dependency 'rake'
   s.add_development_dependency 'rspec', '>= 3'

data/gemfiles/rails42.gemfile

@@ -3,5 +3,5 @@
 source "https://rubygems.org"
 
 gem "activerecord", "~> 4.2.0"
-
-gemspec :path => "../"
+gem "mysql2", "0.4.10"
+gemspec path: "../"

data/gemfiles/rails5.gemfile

@@ -4,4 +4,4 @@ source "https://rubygems.org"
 
 gem "activerecord", "~> 5.0.0"
 
-gemspec :path => "../"
+gemspec path: "../"

data/gemfiles/rails51.gemfile

@@ -4,4 +4,4 @@ source "https://rubygems.org"
 
 gem "activerecord", "~> 5.1.0"
 
-gemspec :path => "../"
+gemspec path: "../"

data/gemfiles/{rails4.gemfile → rails52.gemfile}

@@ -2,6 +2,6 @@
 
 source "https://rubygems.org"
 
-gem "activerecord", "~> 4.0.0"
+gem "activerecord", "~> 5.2.0"
 
-gemspec :path => "../"
+gemspec path: "../"

data/lib/octopus.rb

@@ -94,18 +94,6 @@ module Octopus
     ActiveRecord::VERSION::MAJOR == 4
   end
 
-  def self.rails40?
-    rails4? && ActiveRecord::VERSION::MINOR == 0
-  end
-
-  def self.rails41_only?
-    rails4? && ActiveRecord::VERSION::MINOR == 1
-  end
-
-  def self.rails41?
-    rails4? && ActiveRecord::VERSION::MINOR >= 1
-  end
-
   def self.rails42?
     rails4? && ActiveRecord::VERSION::MINOR == 2
   end
@@ -113,15 +101,27 @@ module Octopus
   def self.rails50?
     ActiveRecord::VERSION::MAJOR == 5 && ActiveRecord::VERSION::MINOR == 0
   end
+  
+  def self.atleast_rails50?
+    ActiveRecord::VERSION::MAJOR >= 5
+  end
 
   def self.rails51?
     ActiveRecord::VERSION::MAJOR == 5 && ActiveRecord::VERSION::MINOR == 1
   end
 
+  def self.rails52?
+    ActiveRecord::VERSION::MAJOR == 5 && ActiveRecord::VERSION::MINOR == 2
+  end
+
   def self.atleast_rails51?
     ActiveRecord::VERSION::MAJOR > 5 || (ActiveRecord::VERSION::MAJOR == 5 && ActiveRecord::VERSION::MINOR >= 1)
   end
 
+  def self.atleast_rails52?
+    ActiveRecord::VERSION::MAJOR > 5 || (ActiveRecord::VERSION::MAJOR == 5 && ActiveRecord::VERSION::MINOR > 1)
+  end
+
   attr_writer :logger
 
   def self.logger
@@ -187,13 +187,13 @@ require 'octopus/result_patch'
 require 'octopus/migration'
 require 'octopus/association'
 require 'octopus/collection_association'
-require 'octopus/has_and_belongs_to_many_association' unless Octopus.rails41? || Octopus.rails50? || Octopus.rails51?
 require 'octopus/association_shard_tracking'
 require 'octopus/persistence'
 require 'octopus/log_subscriber'
 require 'octopus/abstract_adapter'
 require 'octopus/singular_association'
 require 'octopus/finder_methods'
+require 'octopus/query_cache_for_shards' unless Octopus.rails4?
 
 require 'octopus/railtie' if defined?(::Rails::Railtie)
 

data/lib/octopus/association_shard_tracking.rb

@@ -35,7 +35,7 @@ module Octopus
       end
     end
 
-    def has_many(association_id, scope = nil, options = {}, &extension)
+    def has_many(name, scope = nil, **options, &extension)
       if options == {} && scope.is_a?(Hash)
         default_octopus_opts(scope)
       else

data/lib/octopus/collection_association.rb

@@ -1,7 +1,7 @@
 module Octopus
   module CollectionAssociation
     def self.included(base)
-      if Octopus.rails51?
+      if Octopus.rails51? || Octopus.rails52?
         base.sharded_methods :reader, :writer, :ids_reader, :ids_writer, :create, :create!,
                              :build, :include?,
                              :load_target, :reload, :size, :select

data/lib/octopus/migration.rb

@@ -62,24 +62,26 @@ end
 module Octopus
   module Migrator
     def self.included(base)
-      base.extend(ClassMethods)
-
-      base.class_eval do
-        class << self
-          alias_method :migrate_without_octopus, :migrate
-          alias_method :migrate, :migrate_with_octopus
+      unless Octopus.atleast_rails52?
+        base.extend(ClassMethods)
 
-          alias_method :up_without_octopus, :up
-          alias_method :up, :up_with_octopus
+        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
 
-          alias_method :down_without_octopus, :down
-          alias_method :down, :down_with_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 :run_without_octopus, :run
+              alias_method :run, :run_with_octopus
 
-          alias_method :rollback_without_octopus, :rollback
-          alias_method :rollback, :rollback_with_octopus
+              alias_method :rollback_without_octopus, :rollback
+              alias_method :rollback, :rollback_with_octopus
+          end
         end
       end
 
@@ -92,74 +94,113 @@ module Octopus
       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 run_with_octopus(&block)
-      run_without_octopus(&block)
-    rescue ActiveRecord::UnknownMigrationVersionError => e
-      raise unless migrations(true).detect { |m| m.version == e.version }
-    end
+      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
 
-    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 migrations_with_octopus(shard_agnostic = true)
+        migrations = migrations_without_octopus
+        return migrations if !connection.is_a?(Octopus::Proxy) || shard_agnostic
 
-    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
+        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
 
-      migrations.select { |m| m.shards.include?(connection.current_shard.to_sym) }
-    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
 
-    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)
+      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
-          migrate_without_octopus(migrations_paths, target_version, &block)
-        end
+        migrations.select { |m| m.shards.include?(connection.current_shard.to_sym) }
       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.to_s == Octopus.master_shard.to_s
+      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
-          up_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 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 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
-          down_without_octopus(migrations_paths, target_version, &block)
+          connection.send_queries_to_multiple_shards(connection.shard_names) do
+            up_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 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
 
-        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
+            down_without_octopus(migrations_paths, target_version, &block)
+          end
         end
-      end
 
-      def rollback_with_octopus(migrations_paths, steps = 1)
-        return rollback_without_octopus(migrations_paths, steps) unless connection.is_a?(Octopus::Proxy)
+        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
 
-        connection.send_queries_to_multiple_shards(connection.shard_names) do
-          rollback_without_octopus(migrations_paths, steps)
+        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
-      end
 
-      private
+        private
 
-      def connection
-        ActiveRecord::Base.connection
+        def connection
+          ActiveRecord::Base.connection
+        end
       end
     end
   end

data/lib/octopus/model.rb

@@ -44,20 +44,16 @@ If you are trying to scope everything to a specific shard, use Octopus.using ins
       end
 
       def init_with(coder)
-        current_shard_value = if Octopus.rails40? || Octopus.rails41_only?
-          coder['attributes']['current_shard'] if coder['attributes']['current_shard'].present?
-        else
-          coder['attributes']['current_shard'].value if coder['attributes']['current_shard'].present? && coder['attributes']['current_shard'].value.present?
-        end
+        obj = super
 
-        if Octopus.rails40? || Octopus.rails41_only?
-          coder['attributes'].delete('current_shard')
-        else
-          coder['attributes'].send(:attributes).send(:values).delete('current_shard')
-          coder['attributes'].send(:attributes).send(:delegate_hash).delete('current_shard')
-        end
+        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 = super
         obj.current_shard = current_shard_value if current_shard_value.present?
         obj
       end

data/lib/octopus/proxy.rb

@@ -26,7 +26,7 @@ module Octopus
       :type_cast, :to_sql, :quote, :quote_column_name, :quote_table_name,
       :quote_table_name_for_assignment, :supports_migrations?, :table_alias_for,
       :table_exists?, :in_clause_length, :supports_ddl_transactions?,
-      :sanitize_limit, :prefetch_primary_key?, :current_database, :initialize_schema_migrations_table,
+      :sanitize_limit, :prefetch_primary_key?, :current_database,
       :combine_bind_parameters, :empty_insert_statement_value, :assume_migrated_upto_version,
       :schema_cache, :substitute_at, :internal_string_options_for_primary_key, :lookup_cast_type_from_column,
       :supports_advisory_locks?, :get_advisory_lock, :initialize_internal_metadata_table,
@@ -139,13 +139,15 @@ module Octopus
       shards[current_shard]
     end
 
-    def enable_query_cache!
-      clear_query_cache
-      with_each_healthy_shard { |v| v.connected? && safe_connection(v).enable_query_cache! }
-    end
+    if Octopus.rails4?
+      def enable_query_cache!
+        clear_query_cache
+        with_each_healthy_shard { |v| v.connected? && safe_connection(v).enable_query_cache! }
+      end
 
-    def disable_query_cache!
-      with_each_healthy_shard { |v| v.connected? && safe_connection(v).disable_query_cache! }
+      def disable_query_cache!
+        with_each_healthy_shard { |v| v.connected? && safe_connection(v).disable_query_cache! }
+      end
     end
 
     def clear_query_cache
@@ -158,6 +160,13 @@ module Octopus
 
     def clear_all_connections!
       with_each_healthy_shard(&:disconnect!)
+
+      if Octopus.atleast_rails52?
+        # On Rails 5.2 it is no longer safe to re-use connection pools after they have been discarded
+        # This happens on webservers with forking, for example Phusion Passenger.
+        # Therefor after we clear all connections we reinitialize the shards to get fresh and not discarded ConnectionPool objects
+        proxy_config.reinitialize_shards
+      end
     end
 
     def connected?
@@ -180,6 +189,22 @@ module Octopus
       send_queries_to_balancer(slave_groups[current_slave_group], method, *args, &block)
     end
 
+    def current_model_replicated?
+      replicated && (current_model.try(:replicated) || fully_replicated?)
+    end
+    
+    def initialize_schema_migrations_table
+      if Octopus.atleast_rails52?
+        select_connection.transaction { ActiveRecord::SchemaMigration.create_table }
+      else 
+        select_connection.initialize_schema_migrations_table
+      end
+    end
+    
+    def initialize_metadata_table
+      select_connection.transaction { ActiveRecord::InternalMetadata.create_table }
+    end
+
     protected
 
     # @thiagopradi - This legacy method missing logic will be keep for a while for compatibility
@@ -247,10 +272,6 @@ module Octopus
       replicated && method.to_s =~ /select/ && !block && !slaves_grouped?
     end
 
-    def current_model_replicated?
-      replicated && (current_model.try(:replicated) || fully_replicated?)
-    end
-
     def send_queries_to_selected_slave(method, *args, &block)
       if current_model.replicated || fully_replicated?
         selected_slave = slaves_load_balancer.next current_load_balance_options