ar-octopus 0.9.0 → 0.9.1

data/lib/octopus/proxy_config.rb

@@ -0,0 +1,252 @@
+module Octopus
+  class ProxyConfig
+    CURRENT_MODEL_KEY = 'octopus.current_model'.freeze
+    CURRENT_SHARD_KEY = 'octopus.current_shard'.freeze
+    CURRENT_GROUP_KEY = 'octopus.current_group'.freeze
+    CURRENT_SLAVE_GROUP_KEY = 'octopus.current_slave_group'.freeze
+    CURRENT_LOAD_BALANCE_OPTIONS_KEY = 'octopus.current_load_balance_options'.freeze
+    BLOCK_KEY = 'octopus.block'.freeze
+    FULLY_REPLICATED_KEY = 'octopus.fully_replicated'.freeze
+
+    attr_accessor :config, :sharded, :shards, :shards_slave_groups, :slave_groups,
+                  :adapters, :replicated, :slaves_load_balancer, :slaves_list, :shards_slave_groups,
+                  :slave_groups, :groups, :entire_sharded, :shards_config
+
+    def initialize(config)
+      initialize_shards(config)
+      initialize_replication(config) if !config.nil? && config['replicated']
+    end
+
+    def current_model
+      Thread.current[CURRENT_MODEL_KEY]
+    end
+
+    def current_model=(model)
+      Thread.current[CURRENT_MODEL_KEY] = model.is_a?(ActiveRecord::Base) ? model.class : model
+    end
+
+    def current_shard
+      Thread.current[CURRENT_SHARD_KEY] ||= Octopus.master_shard
+    end
+
+    def current_shard=(shard_symbol)
+      if shard_symbol.is_a?(Array)
+        self.current_slave_group = nil
+        shard_symbol.each { |symbol| fail "Nonexistent Shard Name: #{symbol}" if shards[symbol].nil? }
+      elsif shard_symbol.is_a?(Hash)
+        hash = shard_symbol
+        shard_symbol = hash[:shard]
+        slave_group_symbol = hash[:slave_group]
+        load_balance_options = hash[:load_balance_options]
+
+        if shard_symbol.nil? && slave_group_symbol.nil?
+          fail 'Neither shard or slave group must be specified'
+        end
+
+        if shard_symbol.present?
+          fail "Nonexistent Shard Name: #{shard_symbol}" if shards[shard_symbol].nil?
+        end
+
+        if slave_group_symbol.present?
+          if (shards_slave_groups.try(:[], shard_symbol).present? && shards_slave_groups[shard_symbol][slave_group_symbol].nil?) ||
+              (shards_slave_groups.try(:[], shard_symbol).nil? && @slave_groups[slave_group_symbol].nil?)
+            fail "Nonexistent Slave Group Name: #{slave_group_symbol} in shards config: #{shards_config.inspect}"
+          end
+        end
+        self.current_slave_group = slave_group_symbol
+        self.current_load_balance_options = load_balance_options
+      else
+        fail "Nonexistent Shard Name: #{shard_symbol}" if shards[shard_symbol].nil?
+      end
+
+      Thread.current[CURRENT_SHARD_KEY] = shard_symbol
+    end
+
+    def current_group
+      Thread.current[CURRENT_GROUP_KEY]
+    end
+
+    def current_group=(group_symbol)
+      # TODO: Error message should include all groups if given more than one bad name.
+      [group_symbol].flatten.compact.each do |group|
+        fail "Nonexistent Group Name: #{group}" unless has_group?(group)
+      end
+
+      Thread.current[CURRENT_GROUP_KEY] = group_symbol
+    end
+
+    def current_slave_group
+      Thread.current[CURRENT_SLAVE_GROUP_KEY]
+    end
+
+    def current_slave_group=(slave_group_symbol)
+      Thread.current[CURRENT_SLAVE_GROUP_KEY] = slave_group_symbol
+      Thread.current[CURRENT_LOAD_BALANCE_OPTIONS_KEY] = nil if slave_group_symbol.nil?
+    end
+
+    def current_load_balance_options
+      Thread.current[CURRENT_LOAD_BALANCE_OPTIONS_KEY]
+    end
+
+    def current_load_balance_options=(options)
+      Thread.current[CURRENT_LOAD_BALANCE_OPTIONS_KEY] = options
+    end
+
+    def block
+      Thread.current[BLOCK_KEY]
+    end
+
+    def block=(block)
+      Thread.current[BLOCK_KEY] = block
+    end
+
+    def fully_replicated?
+      @fully_replicated || Thread.current[FULLY_REPLICATED_KEY]
+    end
+
+    # Public: Whether or not a group exists with the given name converted to a
+    # string.
+    #
+    # Returns a boolean.
+    def has_group?(group)
+      @groups.key?(group.to_s)
+    end
+
+    # Public: Retrieves names of all loaded shards.
+    #
+    # Returns an array of shard names as symbols
+    def shard_names
+      shards.keys
+    end
+
+    def shard_name
+      current_shard.is_a?(Array) ? current_shard.first : current_shard
+    end
+
+    # Public: Retrieves the defined shards for a given group.
+    #
+    # Returns an array of shard names as symbols or nil if the group is not
+    # defined.
+    def shards_for_group(group)
+      @groups.fetch(group.to_s, nil)
+    end
+
+    def initialize_shards(config)
+      self.config = config
+
+      self.shards = HashWithIndifferentAccess.new
+      self.shards_slave_groups = HashWithIndifferentAccess.new
+      self.slave_groups = HashWithIndifferentAccess.new
+      self.groups = {}
+      self.config = ActiveRecord::Base.connection_pool_without_octopus.spec.config
+
+      unless config.nil?
+        self.entire_sharded = config['entire_sharded']
+        self.shards_config = config[Octopus.rails_env]
+      end
+
+      self.shards_config ||= []
+
+      shards_config.each do |key, value|
+        if value.is_a?(String)
+          value = resolve_string_connection(value).merge(:octopus_shard => key)
+          initialize_adapter(value['adapter'])
+          shards[key.to_sym] = connection_pool_for(value, "#{value['adapter']}_connection")
+        elsif value.is_a?(Hash) && value.key?('adapter')
+          value.merge!(:octopus_shard => key)
+          initialize_adapter(value['adapter'])
+          shards[key.to_sym] = connection_pool_for(value, "#{value['adapter']}_connection")
+
+          slave_group_configs = value.select do |_k, v|
+            structurally_slave_group? v
+          end
+
+          if slave_group_configs.present?
+            slave_groups = HashWithIndifferentAccess.new
+            slave_group_configs.each do |slave_group_name, slave_configs|
+              slaves = HashWithIndifferentAccess.new
+              slave_configs.each do |slave_name, slave_config|
+                shards[slave_name.to_sym] = connection_pool_for(slave_config, "#{value['adapter']}_connection")
+                slaves[slave_name.to_sym] = slave_name.to_sym
+              end
+              slave_groups[slave_group_name.to_sym] = Octopus::SlaveGroup.new(slaves)
+            end
+            @shards_slave_groups[key.to_sym] = slave_groups
+            @sharded = true
+          end
+        elsif value.is_a?(Hash)
+          @groups[key.to_s] = []
+
+          value.each do |k, v|
+            fail 'You have duplicated shard names!' if shards.key?(k.to_sym)
+
+            initialize_adapter(v['adapter'])
+            config_with_octopus_shard = v.merge(:octopus_shard => k)
+
+            shards[k.to_sym] = connection_pool_for(config_with_octopus_shard, "#{v['adapter']}_connection")
+            @groups[key.to_s] << k.to_sym
+          end
+
+          if structurally_slave_group? value
+            slaves = Hash[@groups[key.to_s].map { |v| [v, v] }]
+            @slave_groups[key.to_sym] = Octopus::SlaveGroup.new(slaves)
+          end
+        end
+      end
+
+      shards[:master] ||= ActiveRecord::Base.connection_pool_without_octopus if Octopus.master_shard == :master
+    end
+
+    def initialize_replication(config)
+      @replicated = true
+      if config.key?('fully_replicated')
+        @fully_replicated = config['fully_replicated']
+      else
+        @fully_replicated = true
+      end
+
+      @slaves_list = shards.keys.map(&:to_s).sort
+      @slaves_list.delete('master')
+      @slaves_load_balancer = Octopus.load_balancer.new(@slaves_list)
+    end
+
+    private
+
+    def connection_pool_for(adapter, config)
+      if Octopus.rails4?
+        arg = ActiveRecord::ConnectionAdapters::ConnectionSpecification.new(adapter.dup, config)
+      else
+        name = adapter["octopus_shard"]
+        arg = ActiveRecord::ConnectionAdapters::ConnectionSpecification.new(name, adapter.dup, config)
+      end
+
+      ActiveRecord::ConnectionAdapters::ConnectionPool.new(arg)
+    end
+
+    def resolve_string_connection(spec)
+      if Octopus.rails41? || Octopus.rails50? || Octopus.rails51?
+        resolver = ActiveRecord::ConnectionAdapters::ConnectionSpecification::Resolver.new({})
+        HashWithIndifferentAccess.new(resolver.spec(spec).config)
+      else
+        resolver = ActiveRecord::ConnectionAdapters::ConnectionSpecification::Resolver.new(spec, {})
+        HashWithIndifferentAccess.new(resolver.spec.config)
+      end
+    end
+
+    def structurally_slave?(config)
+      config.is_a?(Hash) && config.key?('adapter')
+    end
+
+    def structurally_slave_group?(config)
+      config.is_a?(Hash) && config.values.any? { |v| structurally_slave? v }
+    end
+
+    def initialize_adapter(adapter)
+      begin
+        require "active_record/connection_adapters/#{adapter}_adapter"
+      rescue LoadError
+        raise "Please install the #{adapter} adapter: `gem install activerecord-#{adapter}-adapter` (#{$ERROR_INFO})"
+      end
+    end
+  end
+end

data/lib/octopus/relation_proxy.rb

@@ -24,7 +24,13 @@ module Octopus
       if block
         @ar_relation.public_send(method, *args, &block)
       else
-        run_on_shard { @ar_relation.public_send(method, *args) }
+        run_on_shard do
+          if method == :load_records
+            @ar_relation.send(method, *args)
+          else
+            @ar_relation.public_send(method, *args)
+          end
+        end
       end
     end
 

data/lib/octopus/scope_proxy.rb

@@ -21,7 +21,7 @@ module Octopus
     end
 
     def using(shard)
-      fail "Nonexistent Shard Name: #{shard}" if @klass.connection.instance_variable_get(:@shards)[shard].nil?
+      fail "Nonexistent Shard Name: #{shard}" if @klass.connection.shards[shard].nil?
       @current_shard = shard
       self
     end

data/lib/octopus/shard_tracking.rb

@@ -20,7 +20,8 @@ module Octopus
         define_method with do |*args, &block|
           run_on_shard { send(without, *args, &block) }
         end
-        alias_method_chain name.to_sym, :octopus
+        alias_method without.to_sym, name.to_sym
+        alias_method name.to_sym, with.to_sym
       end
     end
 

data/lib/octopus/version.rb

@@ -1,3 +1,3 @@
 module Octopus
-  VERSION = '0.9.0'
+  VERSION = '0.9.1'
 end

data/spec/migrations/10_create_users_using_replication.rb

@@ -1,4 +1,4 @@
-class CreateUsersUsingReplication < ActiveRecord::Migration
+class CreateUsersUsingReplication < BaseOctopusMigrationClass
   def self.up
     Cat.create!(:name => 'Replication')
   end

data/spec/migrations/11_add_field_in_all_slaves.rb

@@ -1,4 +1,4 @@
-class AddFieldInAllSlaves < ActiveRecord::Migration
+class AddFieldInAllSlaves < BaseOctopusMigrationClass
   using(:slave1, :slave2, :slave3, :slave4)
 
   def self.up

data/spec/migrations/12_create_users_using_block.rb

@@ -1,4 +1,4 @@
-class CreateUsersUsingBlock < ActiveRecord::Migration
+class CreateUsersUsingBlock < BaseOctopusMigrationClass
   def self.up
     Octopus.using(:brazil) do
       User.create!(:name => 'UsingBlock1')

data/spec/migrations/13_create_users_using_block_and_using.rb

@@ -1,4 +1,4 @@
-class CreateUsersUsingBlockAndUsing < ActiveRecord::Migration
+class CreateUsersUsingBlockAndUsing < BaseOctopusMigrationClass
   using(:brazil)
 
   def self.up

data/spec/migrations/14_create_users_on_shards_of_a_group_with_versions.rb

@@ -1,4 +1,4 @@
-class CreateUsersOnShardsOfAGroupWithVersions < ActiveRecord::Migration
+class CreateUsersOnShardsOfAGroupWithVersions < BaseOctopusMigrationClass
   using_group(:country_shards)
 
   def self.up

data/spec/migrations/15_create_user_on_shards_of_default_group_with_versions.rb

@@ -1,4 +1,4 @@
-class CreateUserOnShardsOfDefaultGroupWithVersions < ActiveRecord::Migration
+class CreateUserOnShardsOfDefaultGroupWithVersions < BaseOctopusMigrationClass
   def self.up
     User.create!(:name => 'Default Group')
   end

data/spec/migrations/1_create_users_on_master.rb

@@ -1,4 +1,4 @@
-class CreateUsersOnMaster < ActiveRecord::Migration
+class CreateUsersOnMaster < BaseOctopusMigrationClass
   def self.up
     User.create!(:name => 'Master')
   end

data/spec/migrations/2_create_users_on_canada.rb

@@ -1,4 +1,4 @@
-class CreateUsersOnCanada < ActiveRecord::Migration
+class CreateUsersOnCanada < BaseOctopusMigrationClass
   using(:canada)
 
   def self.up

data/spec/migrations/3_create_users_on_both_shards.rb

@@ -1,4 +1,4 @@
-class CreateUsersOnBothShards < ActiveRecord::Migration
+class CreateUsersOnBothShards < BaseOctopusMigrationClass
   using(:brazil, :canada)
 
   def self.up

data/spec/migrations/4_create_users_on_shards_of_a_group.rb

@@ -1,4 +1,4 @@
-class CreateUsersOnShardsOfAGroup < ActiveRecord::Migration
+class CreateUsersOnShardsOfAGroup < BaseOctopusMigrationClass
   using_group(:country_shards)
 
   def self.up

data/spec/migrations/5_create_users_on_multiples_groups.rb

@@ -1,4 +1,4 @@
-class CreateUsersOnMultiplesGroups < ActiveRecord::Migration
+class CreateUsersOnMultiplesGroups < BaseOctopusMigrationClass
   using_group('country_shards', 'history_shards')
 
   def self.up

data/spec/migrations/6_raise_exception_with_invalid_shard_name.rb

@@ -1,4 +1,4 @@
-class RaiseExceptionWithInvalidShardName < ActiveRecord::Migration
+class RaiseExceptionWithInvalidShardName < BaseOctopusMigrationClass
   using(:amazing_shard)
 
   def self.up

data/spec/migrations/7_raise_exception_with_invalid_multiple_shard_names.rb

@@ -1,4 +1,4 @@
-class RaiseExceptionWithInvalidMultipleShardNames < ActiveRecord::Migration
+class RaiseExceptionWithInvalidMultipleShardNames < BaseOctopusMigrationClass
   using(:brazil, :invalid_shard)
 
   def self.up

data/spec/migrations/8_raise_exception_with_invalid_group_name.rb

@@ -1,4 +1,4 @@
-class RaiseExceptionWithInvalidGroupName < ActiveRecord::Migration
+class RaiseExceptionWithInvalidGroupName < BaseOctopusMigrationClass
   using_group(:invalid_group)
 
   def self.up

data/spec/migrations/9_raise_exception_with_multiple_invalid_group_names.rb

@@ -1,4 +1,4 @@
-class RaiseExceptionWithMultipleInvalidGroupNames < ActiveRecord::Migration
+class RaiseExceptionWithMultipleInvalidGroupNames < BaseOctopusMigrationClass
   using_group(:country_shards, :invalid_group)
 
   def self.up

data/spec/octopus/association_shard_tracking_spec.rb

@@ -96,7 +96,7 @@ describe Octopus::AssociationShardTracking, :shards => [:brazil, :master, :canad
       expect(@permission_brazil.roles).to eq([new_brazil_role])
     end
 
-    it 'should works for build method' do
+    it 'should work for build method' do
       new_brazil_role = Role.using(:brazil).create!(:name => 'Brazil Role')
       c = new_brazil_role.permissions.create(:name => 'new Permission')
       c.save
@@ -105,7 +105,7 @@ describe Octopus::AssociationShardTracking, :shards => [:brazil, :master, :canad
       expect(new_brazil_role.permissions).to eq([c])
     end
 
-    describe 'it should works when using' do
+    describe 'it should work when using' do
       before(:each) do
         @permission_brazil_2 = Permission.using(:brazil).create!(:name => 'Brazil Item 2')
         @role = Role.using(:brazil).create!(:name => 'testes')
@@ -198,9 +198,9 @@ describe Octopus::AssociationShardTracking, :shards => [:brazil, :master, :canad
 
       it 'exists?' do
         role = @permission_brazil_2.roles.create(:name => 'Builded Role')
-        expect(@permission_brazil_2.roles.exists?(role)).to be true
+        expect(@permission_brazil_2.roles.exists?(role.id)).to be true
         @permission_brazil_2.roles.destroy_all
-        expect(@permission_brazil_2.roles.exists?(role)).to be false
+        expect(@permission_brazil_2.roles.exists?(role.id)).to be false
       end
 
       it 'clear' do
@@ -250,7 +250,7 @@ describe Octopus::AssociationShardTracking, :shards => [:brazil, :master, :canad
       expect(@project.programmers).to eq([new_brazil_programmer])
     end
 
-    it 'should works for create method' do
+    it 'should work for create method' do
       new_brazil_programmer = Programmer.using(:brazil).create!(:name => 'Joao')
       c = new_brazil_programmer.projects.create(:name => 'new Project')
       c.save
@@ -259,7 +259,7 @@ describe Octopus::AssociationShardTracking, :shards => [:brazil, :master, :canad
       expect(new_brazil_programmer.projects).to eq([c])
     end
 
-    describe 'it should works when using' do
+    describe 'it should work when using' do
       before(:each) do
         @new_brazil_programmer = Programmer.using(:brazil).create!(:name => 'Jose')
         @project = Project.using(:brazil).create!(:name => 'VB Application :-(')
@@ -352,9 +352,9 @@ describe Octopus::AssociationShardTracking, :shards => [:brazil, :master, :canad
 
       it 'exists?' do
         role = @new_brazil_programmer.projects.create(:name => 'New VB App :-/')
-        expect(@new_brazil_programmer.projects.exists?(role)).to be true
+        expect(@new_brazil_programmer.projects.exists?(role.id)).to be true
         @new_brazil_programmer.projects.destroy_all
-        expect(@new_brazil_programmer.projects.exists?(role)).to be false
+        expect(@new_brazil_programmer.projects.exists?(role.id)).to be false
       end
 
       it 'clear' do
@@ -414,7 +414,7 @@ describe Octopus::AssociationShardTracking, :shards => [:brazil, :master, :canad
       expect(@item_brazil.client).to eq(new_brazil_client)
     end
 
-    it 'should works for build method' do
+    it 'should work for build method' do
       item2 = Item.using(:brazil).create!(:name => 'Brazil Item')
       c = item2.create_client(:name => 'new Client')
       c.save
@@ -442,7 +442,7 @@ describe Octopus::AssociationShardTracking, :shards => [:brazil, :master, :canad
       end
     end
 
-    describe 'it should works when using' do
+    describe 'it should work when using' do
       before(:each) do
         @item_brazil_2 = Item.using(:brazil).create!(:name => 'Brazil Item 2')
         expect(@brazil_client.items.to_set).to eq([@item_brazil].to_set)
@@ -540,9 +540,9 @@ describe Octopus::AssociationShardTracking, :shards => [:brazil, :master, :canad
       end
 
       it 'exists?' do
-        expect(@brazil_client.items.exists?(@item_brazil)).to be true
+        expect(@brazil_client.items.exists?(@item_brazil.id)).to be true
         @brazil_client.items.destroy_all
-        expect(@brazil_client.items.exists?(@item_brazil)).to be false
+        expect(@brazil_client.items.exists?(@item_brazil.id)).to be false
       end
 
       it 'uniq' do
@@ -586,7 +586,7 @@ describe Octopus::AssociationShardTracking, :shards => [:brazil, :master, :canad
       expect(@comment_brazil.commentable).to eq(new_brazil_client)
     end
 
-    describe 'it should works when using' do
+    describe 'it should work when using' do
       before(:each) do
         @comment_brazil_2 = Comment.using(:brazil).create!(:name => 'Brazil Comment 2')
         expect(@brazil_client.comments.to_set).to eq([@comment_brazil].to_set)
@@ -690,9 +690,9 @@ describe Octopus::AssociationShardTracking, :shards => [:brazil, :master, :canad
       end
 
       it 'exists?' do
-        expect(@brazil_client.comments.exists?(@comment_brazil)).to be true
+        expect(@brazil_client.comments.exists?(@comment_brazil.id)).to be true
         @brazil_client.comments.destroy_all
-        expect(@brazil_client.comments.exists?(@comment_brazil)).to be false
+        expect(@brazil_client.comments.exists?(@comment_brazil.id)).to be false
       end
 
       it 'uniq' do