ar-octopus 0.8.2 → 0.8.3

data/lib/octopus/abstract_adapter.rb

@@ -2,7 +2,6 @@
 module Octopus
   module AbstractAdapter
     module OctopusShard
-
       parent = Octopus.rails3? ? ActiveSupport::BasicObject : ActiveSupport::ProxyObject
 
       class InstrumenterDecorator < parent
@@ -33,7 +32,6 @@ module Octopus
         initialize_without_octopus_shard(*args)
         @instrumenter = InstrumenterDecorator.new(self, @instrumenter)
       end
-
     end
   end
 end

data/lib/octopus/association.rb

@@ -1,10 +1,12 @@
-module Octopus::Association
-  def self.included(base)
-    base.send(:include, Octopus::ShardTracking::Dynamic)
-  end
+module Octopus
+  module Association
+    def self.included(base)
+      base.send(:include, Octopus::ShardTracking::Dynamic)
+    end
 
-  def current_shard
-    owner.current_shard
+    def current_shard
+      owner.current_shard
+    end
   end
 end
 

data/lib/octopus/association_shard_tracking.rb

@@ -1,104 +1,103 @@
-module Octopus::AssociationShardTracking
-  def self.extended(base)
-    base.send(:include, InstanceMethods)
-  end
-
-  module QueryOnCurrentShard
+module Octopus
+  module AssociationShardTracking
+    def self.extended(base)
+      base.send(:include, InstanceMethods)
+    end
 
-    METHODS= %w[
-      all
-      average
-      count
-      empty?
-      exists?
-      find
-      find_by_sql
-      first
-      last
-      maximum
-      minimum
-      pluck
-      scoping
-      size
-      sum
-      to_a
-    ]
+    module QueryOnCurrentShard
+      METHODS = %w(
+        all
+        average
+        count
+        empty?
+        exists?
+        find
+        find_by_sql
+        first
+        last
+        maximum
+        minimum
+        pluck
+        scoping
+        size
+        sum
+        to_a
+      )
 
-    METHODS.each do |m|
-      define_method m.to_sym do |*args,&block|
-        if self.respond_to?(:proxy_association) and self.proxy_association
-          self.proxy_association.owner.run_on_shard { super(*args, &block) }
-        else
-          super(*args, &block)
+      METHODS.each do |m|
+        define_method m.to_sym do |*args, &block|
+          if self.respond_to?(:proxy_association) && proxy_association
+            proxy_association.owner.run_on_shard { super(*args, &block) }
+          else
+            super(*args, &block)
+          end
         end
       end
     end
 
-  end
+    module InstanceMethods
+      def connection_on_association=(record)
+        return unless ::Octopus.enabled?
+        return if !self.class.connection.respond_to?(:current_shard) || !self.respond_to?(:current_shard)
+        if !record.current_shard.nil? && !current_shard.nil? && record.current_shard != current_shard
+          fail 'Association Error: Records are from different shards'
+        end
 
-  module InstanceMethods
-    def set_connection_on_association(record)
-      return unless ::Octopus.enabled?
-      return if !self.class.connection.respond_to?(:current_shard) || !self.respond_to?(:current_shard)
-      if !record.current_shard.nil? && !self.current_shard.nil? && record.current_shard != self.current_shard
-        raise "Association Error: Records are from different shards"
+        record.current_shard = self.class.connection.current_shard = current_shard if should_set_current_shard?
       end
-
-      record.current_shard = self.class.connection.current_shard = self.current_shard if should_set_current_shard?
     end
-  end
 
-  if Octopus.rails4?
-    def has_many(association_id, scope=nil, options={}, &extension)
-      if options == {} && scope.is_a?(Hash)
-        default_octopus_opts(scope)
-      else
+    if Octopus.rails4?
+      def has_many(association_id, scope = nil, options = {}, &extension)
+        if options == {} && scope.is_a?(Hash)
+          default_octopus_opts(scope)
+        else
+          default_octopus_opts(options)
+        end
+        super
+      end
+    else
+      def has_many(association_id, options = {}, &extension)
         default_octopus_opts(options)
+        super
       end
-      super
-    end
-  else
-    def has_many(association_id, options={}, &extension)
-      default_octopus_opts(options)
-      super
     end
-  end
-
 
-  if Octopus.rails4?
-    def has_and_belongs_to_many(association_id, scope=nil, options={}, &extension)
-      if options == {} && scope.is_a?(Hash)
-        default_octopus_opts(scope)
-      else
+    if Octopus.rails4?
+      def has_and_belongs_to_many(association_id, scope = nil, options = {}, &extension)
+        if options == {} && scope.is_a?(Hash)
+          default_octopus_opts(scope)
+        else
+          default_octopus_opts(options)
+        end
+        super
+      end
+    else
+      def has_and_belongs_to_many(association_id, options = {}, &extension)
         default_octopus_opts(options)
+        super
       end
-      super
-    end
-  else
-    def has_and_belongs_to_many(association_id, options={}, &extension)
-      default_octopus_opts(options)
-      super
     end
-  end
 
-  def default_octopus_opts(options)
-    if options[:before_add].is_a?(Array)
-      options[:before_add] << :set_connection_on_association
-    elsif options[:before_add].is_a?(Symbol)
-      options[:before_add] = [:set_connection_on_association, options[:before_add]]
-    else
-      options[:before_add] = :set_connection_on_association
-    end
+    def default_octopus_opts(options)
+      if options[:before_add].is_a?(Array)
+        options[:before_add] << :connection_on_association=
+      elsif options[:before_add].is_a?(Symbol)
+        options[:before_add] = [:connection_on_association=, options[:before_add]]
+      else
+        options[:before_add] = :connection_on_association=
+      end
 
-    if options[:before_remove].is_a?(Array)
-      options[:before_remove] << :set_connection_on_association
-    elsif options[:before_remove].is_a?(Symbol)
-      options[:before_remove] = [:set_connection_on_association, options[:before_remove]]
-    else
-      options[:before_remove] = :set_connection_on_association
-    end
+      if options[:before_remove].is_a?(Array)
+        options[:before_remove] << :connection_on_association=
+      elsif options[:before_remove].is_a?(Symbol)
+        options[:before_remove] = [:connection_on_association=, options[:before_remove]]
+      else
+        options[:before_remove] = :connection_on_association=
+      end
 
-    options[:extend] = [ Octopus::AssociationShardTracking::QueryOnCurrentShard, options[:extend] ].flatten.compact
+      options[:extend] = [Octopus::AssociationShardTracking::QueryOnCurrentShard, options[:extend]].flatten.compact
+    end
   end
 end
 

data/lib/octopus/collection_association.rb

@@ -1,8 +1,10 @@
-module Octopus::CollectionAssociation
-  def self.included(base)
-    base.sharded_methods :reader, :writer, :ids_reader, :ids_writer, :create, :create!,
-                         :build, :any?, :count, :empty?, :first, :include?, :last, :length,
-                         :load_target, :many?, :reload, :size, :select, :uniq
+module Octopus
+  module CollectionAssociation
+    def self.included(base)
+      base.sharded_methods :reader, :writer, :ids_reader, :ids_writer, :create, :create!,
+                           :build, :any?, :count, :empty?, :first, :include?, :last, :length,
+                           :load_target, :many?, :reload, :size, :select, :uniq
+    end
   end
 end
 

data/lib/octopus/collection_proxy.rb

@@ -1,13 +1,15 @@
-module Octopus::CollectionProxy
-  def self.included(base)
-    base.send(:include, Octopus::ShardTracking::Dynamic)
-    base.sharded_methods :any?, :build, :count, :create, :create!, :concat, :delete, :delete_all,
-                         :destroy, :destroy_all, :empty?, :find, :first, :include?, :last, :length,
-                         :many?, :pluck, :replace, :select, :size, :sum, :to_a, :uniq
-  end
+module Octopus
+  module CollectionProxy
+    def self.included(base)
+      base.send(:include, Octopus::ShardTracking::Dynamic)
+      base.sharded_methods :any?, :build, :count, :create, :create!, :concat, :delete, :delete_all,
+                           :destroy, :destroy_all, :empty?, :find, :first, :include?, :last, :length,
+                           :many?, :pluck, :replace, :select, :size, :sum, :to_a, :uniq
+    end
 
-  def current_shard
-    @association.owner.current_shard
+    def current_shard
+      @association.owner.current_shard
+    end
   end
 end
 

data/lib/octopus/has_and_belongs_to_many_association.rb

@@ -1,6 +1,8 @@
-module Octopus::HasAndBelongsToManyAssociation
-  def self.included(base)
-    base.sharded_methods :insert_record
+module Octopus
+  module HasAndBelongsToManyAssociation
+    def self.included(base)
+      base.sharded_methods :insert_record
+    end
   end
 end
 

data/lib/octopus/load_balancing.rb

@@ -1,3 +1,4 @@
-module Octopus::LoadBalancing
-
+module Octopus
+  module LoadBalancing
+  end
 end

data/lib/octopus/load_balancing/round_robin.rb

@@ -2,14 +2,18 @@ require 'octopus/load_balancing'
 
 # The round-robin load balancing of slaves belonging to the same shard.
 # It is a pool that contains slaves which queries are distributed to.
-class Octopus::LoadBalancing::RoundRobin
-  def initialize(slaves_list)
-    @slaves_list = slaves_list
-    @slave_index = 0
-  end
+module Octopus
+  module LoadBalancing
+    class RoundRobin
+      def initialize(slaves_list)
+        @slaves_list = slaves_list
+        @slave_index = 0
+      end
 
-  # Returns the next available slave in the pool
-  def next
-    @slaves_list[@slave_index = (@slave_index + 1) % @slaves_list.length]
+      # Returns the next available slave in the pool
+      def next
+        @slaves_list[@slave_index = (@slave_index + 1) % @slaves_list.length]
+      end
+    end
   end
 end

data/lib/octopus/migration.rb

@@ -1,155 +1,164 @@
-require "set"
-require "active_support/core_ext/module/aliasing"
-require "active_support/core_ext/array/wrap"
-
-module Octopus::Migration
-  module InstanceOrClassMethods
-    def announce_with_octopus(message)
-      announce_without_octopus("#{message} - #{get_current_shard}")
-    end
+require 'set'
+require 'active_support/core_ext/module/aliasing'
+require 'active_support/core_ext/array/wrap'
+
+module Octopus
+  module Migration
+    module InstanceOrClassMethods
+      def announce_with_octopus(message)
+        announce_without_octopus("#{message} - #{current_shard}")
+      end
 
-    def get_current_shard
-      "Shard: #{connection.current_shard}" if connection.respond_to?(:current_shard)
+      def current_shard
+        "Shard: #{connection.current_shard}" if connection.respond_to?(:current_shard)
+      end
     end
-  end
 
-  include InstanceOrClassMethods
+    include InstanceOrClassMethods
 
-  def self.included(base)
-    base.extend(ClassMethods)
+    def self.included(base)
+      base.extend(ClassMethods)
 
-    base.alias_method_chain :announce, :octopus
-    base.class_attribute :current_shard, :current_group, :current_group_specified, :instance_reader => false, :instance_writer => false
-  end
+      base.alias_method_chain :announce, :octopus
+      base.class_attribute :current_shard, :current_group, :current_group_specified, :instance_reader => false, :instance_writer => false
+    end
 
-  module ClassMethods
-    def using(*args)
-      return self unless connection.is_a?(Octopus::Proxy)
+    module ClassMethods
+      def using(*args)
+        return self unless connection.is_a?(Octopus::Proxy)
 
-      self.current_shard = args
-      self
-    end
+        self.current_shard = args
+        self
+      end
 
-    def using_group(*groups)
-      return self unless connection.is_a?(Octopus::Proxy)
+      def using_group(*groups)
+        return self unless connection.is_a?(Octopus::Proxy)
 
-      self.current_group = groups
-      self.current_group_specified = true
-      self
-    end
+        self.current_group = groups
+        self.current_group_specified = true
+        self
+      end
 
-    def shards
-      shards = Set.new
+      def shards
+        shards = Set.new
 
-      if groups = (current_group_specified ? current_group : Octopus.config[:default_migration_group])
-        Array.wrap(groups).each do |group|
-          group_shards = connection.shards_for_group(group)
-          shards.merge(group_shards) if group_shards
+        if (groups = (current_group_specified ? current_group : Octopus.config[:default_migration_group]))
+          Array.wrap(groups).each do |group|
+            group_shards = connection.shards_for_group(group)
+            shards.merge(group_shards) if group_shards
+          end
+        elsif (shard = current_shard)
+          shards.merge(Array.wrap(shard))
         end
-      elsif shard = current_shard
-        shards.merge(Array.wrap(shard))
-      end
 
-      shards.to_a.presence || [:master]
+        shards.to_a.presence || [:master]
+      end
     end
   end
 end
 
-module Octopus::Migrator
-  def self.included(base)
-    base.extend(ClassMethods)
-
-    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
+module Octopus
+  module Migrator
+    def self.included(base)
+      base.extend(ClassMethods)
+
+      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
+        end
       end
-    end
 
-    base.alias_method_chain :run, :octopus
-    base.alias_method_chain :migrate, :octopus
-    base.alias_method_chain :migrations, :octopus
-  end
+      base.alias_method_chain :run, :octopus
+      base.alias_method_chain :migrate, :octopus
+      base.alias_method_chain :migrations, :octopus
+    end
 
-  def run_with_octopus(&block)
-    run_without_octopus(&block)
-  rescue ActiveRecord::UnknownMigrationVersionError => e
-    raise unless migrations(true).find {|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)
-    migrate_without_octopus(&block)
-  rescue ActiveRecord::UnknownMigrationVersionError => e
-    raise unless migrations(true).find {|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 = false)
-    connection = ActiveRecord::Base.connection
-    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
+      migrations.select { |m| m.shards.include?(connection.current_shard.to_sym) }
+    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)
+    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
-        migrate_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 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 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
 
-      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
+          up_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 == :master
+      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
 
-      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
+          down_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 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)
+        connection.send_queries_to_multiple_shards(connection.shard_names) do
+          run_without_octopus(direction, migrations_paths, target_version)
+        end
       end
-    end
 
-    private
-    def connection
-      ActiveRecord::Base.connection
+      private
+
+      def connection
+        ActiveRecord::Base.connection
+      end
     end
   end
 end
 
-module Octopus::MigrationProxy
-  def shards
-    migration.class.shards
+module Octopus
+  module MigrationProxy
+    def shards
+      migration.class.shards
+    end
   end
 end
 
-module Octopus::UnknownMigrationVersionError
-  def self.included(base)
-    base.alias_method_chain :initialize, :octopus
-    base.send(:attr_accessor, :version)
-  end
+module Octopus
+  module UnknownMigrationVersionError
+    def self.included(base)
+      base.alias_method_chain :initialize, :octopus
+      base.send(:attr_accessor, :version)
+    end
 
-  def initialize_with_octopus(version)
-    @version = version
-    initialize_without_octopus(version)
+    def initialize_with_octopus(version)
+      @version = version
+      initialize_without_octopus(version)
+    end
   end
 end