ar-octopus 0.8.1 → 0.8.2

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    MTRmYWZkMTg0YzU4MTM4YmNjYTM3MDE3MDVjZjQ1MjdiYmE2NDkwMg==
+    YzBiMGIyMGY1ZGEyOWRlMGY0MjAyNjljYWQ4ZTI2NmFhZmE0NzIzZg==
   data.tar.gz: !binary |-
-    ODhhZTJjNDQzZDVhMWZhYzc1NzRjYWNjOTdlYTQ5MTNlYzk5YWJkMA==
+    MDM0Yzg3ODhlMjNjODEzYjcyYTFmOTFmYmFhNmNjOTk2NmI0Y2YwZg==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    Y2JiNmI0MjEzYWRjYTFhYjMwN2IyYWQwMTQyMDI1M2UyYTdiNzU3NGY4ZDlm
-    MGYwNDQ2NGViMjhjOGRjMTZiNjdjN2VhODZiOGQ3ZWQ2Njg5OTFjZWE1ZDQ5
-    ZThjNjUxOTNhYzYyNTMwMjk3MjkwYmYzNmU3YjA0Y2MzMjMyZmE=
+    ZjFlODczZWIwYTM3MWNiZWE3ZjYwMTRiZTRhOTlhODMwZmVkZmU5ZWM1MTMy
+    ODRlNzllMjgwY2Q4NzY3NjhiMzBhNTk4ZGRhNDNiYWRmZWE0NDBlM2UxZDE3
+    ZTYyNjYyZmM1MTIwNTdmODkwNzM1MmMwYzU2NTY0MDI2Mzg5NzU=
   data.tar.gz: !binary |-
-    MjU1YzZlNzczNGM2OGQ2YzMxYmZhMWE4M2QzYTQ5ZjM1NjEwYTQ4MDJiMDY5
-    YzM0Mjg4OTc4MmI4ZGYxMTlhNDJmYWMxMzA3MjU5ZDdmNjIwNmNmNmNlMmY3
-    OWZjY2RkNTViY2MzOTdjMjU5NTg2NjFkNDcyZmRiMWU5NDA2MWM=
+    MmM5NGFiZWE5MGE3ZWM2N2M0OGFkOGNjOWJiZmZlOWVhOTA5YjYzNmQ1Yzlh
+    ZDlkMWNiNDMwYjQ3ZWEzYzY5MDFkOTAxOTNhZTk0NTk0YTkyYjc4NGQzYTM4
+    ZjE2Yjg5ZmEzYmMxOTRjODgxMDc4YjA3Y2VjNDE1NjZhNTEwODE=

data/README.mkdn

@@ -21,13 +21,17 @@ When using replication, all writes queries will be sent to master, and read quer
  When using sharding, you need to specify which shard to send the query. Octopus supports selecting the shard inside a controller, or manually in each object. More could be found at <a href="http://wiki.github.com/tchandy/octopus/sharding"> Wiki</a>
 
 ### Replication + Sharding
- Replication + Sharding isn't supported yet. This is on our TODO list and will be done ASAP. If you need, feel free to fork and implement it.
+ When using replication and sharding concurrently, you must specify a shard, and can optionally specify a <a href="https://github.com/tchandy/octopus/wiki/Slave-Groups">slave group</a>.
+ All write queries will be sent to each shard's master. If the slave group is specified read queries will be sent to slaves in it, or else to shard's master.
+ More info could be found at <a href="https://github.com/tchandy/octopus/wiki/Slave-Groups"> Wiki</a>
 
 ## Install
 
 Add this line to Gemfile:
 
-    gem 'ar-octopus'
+```
+gem 'ar-octopus'
+```
 
 Currently, Octopus doesn't support Rails 2. If you need support for rails 2, please use the version 0.5.0.
 
@@ -42,7 +46,9 @@ information for each shard is stored within that shard's database.
 If you are upgrading from < 0.5.0 run the `copy_schema_versions` rake task to copy the schema version information in the
 master database to each of the shards:
 
-    rake octopus:copy_schema_versions
+```bash
+rake octopus:copy_schema_versions
+```
 
 Once the task completes migrations will operate normally and schema information will be stored in each shard database
 going forward.
@@ -55,62 +61,73 @@ First, you need to create a config file, shards.yml, inside your config/ directo
 
 Octopus adds a method to each AR Class and object: the using method is used to select the shard like this:
 
-    User.where(:name => "Thiago").limit(3).using(:slave_one)
+```ruby
+User.where(:name => "Thiago").limit(3).using(:slave_one)
+```
 
 Octopus also supports queries within a block. When you pass a block to the using method, all queries inside the block will be sent to the specified shard.
 
-    Octopus.using(:slave_two) do
-      User.create(:name => "Mike")
-    end
+```ruby
+Octopus.using(:slave_two) do
+  User.create(:name => "Mike")
+end
+```
 
 Each model instance knows which shard it came from so this will work automatically:
 
-    # This will find the user in the shard1
-    @user = User.using(:shard1).find_by_name("Joao")
+```ruby
+# This will find the user in the shard1
+@user = User.using(:shard1).find_by_name("Joao")
 
-    # This will find the user in the master database
-    @user2 = User.find_by_name("Jose")
+# This will find the user in the master database
+@user2 = User.find_by_name("Jose")
 
-    #Sets the name
-    @user.name = "Mike"
+#Sets the name
+@user.name = "Mike"
 
-    # Save the user in the correct shard, shard1.
-    @user.save
+# Save the user in the correct shard, shard1.
+@user.save
+```
 
 ### Migrations
 
 In migrations, you also have access to the using method. The syntax is basically the same. This migration will run in the brazil and canada shards.
 
-    class CreateUsersOnBothShards < ActiveRecord::Migration
-      using(:brazil, :canada)
+```ruby
+class CreateUsersOnBothShards < ActiveRecord::Migration
+  using(:brazil, :canada)
 
-      def self.up
-        User.create!(:name => "Both")
-      end
+  def self.up
+    User.create!(:name => "Both")
+  end
 
-      def self.down
-        User.delete_all
-      end
-    end
+  def self.down
+    User.delete_all
+  end
+end
+```
 
 You also could send a migration to a group of shards.  This migration will be sent to all shards that belongs to history_shards group, specified in shards.yml:
 
-    class CreateUsersOnMultiplesGroups < ActiveRecord::Migration
-      using_group(:history_shards)
+```ruby
+class CreateUsersOnMultiplesGroups < ActiveRecord::Migration
+  using_group(:history_shards)
 
-      def self.up
-        User.create!(:name => "MultipleGroup")
-      end
+  def self.up
+    User.create!(:name => "MultipleGroup")
+  end
 
-      def self.down
-        User.delete_all
-      end
-    end
+  def self.down
+    User.delete_all
+  end
+end
+```
 
 You can specify a `default_migration_group` for migrations, so that modifications to each individual migration file are not needed:
-
-    octopus:
-      default_migration_group: europe_databases
+```yaml
+octopus:
+  default_migration_group: europe_databases
+```
 
 There is no need for a corresponding `default_migration_shard` - simply define that database to be your master. You might want this setting if all of your databases have identical schemas, but are not replicated.
 
@@ -118,13 +135,15 @@ There is no need for a corresponding `default_migration_shard` - simply define t
 
 If you want to send a specified action, or all actions from a controller, to a specific shard,  use this syntax:
 
-    class ApplicationController < ActionController::Base
-      around_filter :select_shard
+```ruby
+class ApplicationController < ActionController::Base
+  around_filter :select_shard
 
-      def select_shard(&block)
-        Octopus.using(:brazil, &block)
-      end
-    end
+  def select_shard(&block)
+    Octopus.using(:brazil, &block)
+  end
+end
+```
 
  To see the complete list of features and syntax, please check out our <a href="http://wiki.github.com/tchandy/octopus/"> Wiki</a>
 Want to see sample rails applications using octopus features? please check it out: <a href="http://github.com/tchandy/octopus_sharding_example">Sharding Example</a> and <a href="http://github.com/tchandy/octopus_replication_example">Replication Example</a>. Also, we have an example that shows how to use Octopus without Rails: <a href="http://github.com/tchandy/octopus_sinatra"> Octopus + Sinatra Example</a>.
@@ -132,27 +151,33 @@ Want to see sample rails applications using octopus features? please check it ou
 ## Mixing Octopus with the Rails multiple database model
 If you want to set a custom connection to a specific model, use the syntax `octopus_establish_connection` syntax:
 
-    #This class sets its own connection
-    class CustomConnection < ActiveRecord::Base
-      octopus_establish_connection(:adapter => "mysql", :database => "octopus_shard2")
-    end
+```ruby
+#This class sets its own connection
+class CustomConnection < ActiveRecord::Base
+  octopus_establish_connection(:adapter => "mysql", :database => "octopus_shard2")
+end
+```
 
 ## Contributing with Octopus
 Contributors are welcome! To run the test suite, you need mysql, postgresql and sqlite3 installed. This is what you need to setup your Octopus development environment:
 
-    git clone http://github.com/tchandy/octopus.git
-    cd octopus
-    bundle install
-    bundle exec rake db:prepare
-    bundle exec rake appraisal:install
-    bundle exec rake spec
+```bash
+git clone http://github.com/tchandy/octopus.git
+cd octopus
+bundle install
+bundle exec rake db:prepare
+bundle exec rake appraisal:install
+bundle exec rake spec
+```
 
 This command will run the spec suite for all rails versions supported.
 To run our integrations tests inside sample_app, you need to following commands:
 
-    cd sample_app
-    bundle install
-    cucumber
+```bash
+cd sample_app
+bundle install
+cucumber
+```
 
 If you are having issues running the octopus spec suite, verify your database users and passwords match those inside the config files and your permissions are correct.
 

data/lib/octopus.rb

@@ -90,18 +90,30 @@ module Octopus
       yield
     end
   end
+
+  def self.fully_replicated(&block)
+    old_fully_replicated = Thread.current["octopus.fully_replicated"]
+    Thread.current["octopus.fully_replicated"] = true
+    yield
+  ensure
+    Thread.current["octopus.fully_replicated"] = old_fully_replicated
+  end
 end
 
+require "octopus/shard_tracking"
+require "octopus/shard_tracking/attribute"
+require "octopus/shard_tracking/dynamic"
 
 require "octopus/model"
 require "octopus/migration"
-require "octopus/association_collection"
-require "octopus/has_and_belongs_to_many_association"
 require "octopus/association"
-require "octopus/rails3/persistence"
-require "octopus/rails3/log_subscriber"
-require "octopus/rails3/abstract_adapter"
-require "octopus/rails3/singular_association"
+require "octopus/collection_association"
+require "octopus/has_and_belongs_to_many_association"
+require "octopus/association_shard_tracking"
+require "octopus/persistence"
+require "octopus/log_subscriber"
+require "octopus/abstract_adapter"
+require "octopus/singular_association"
 
 if defined?(::Rails)
   require "octopus/railtie"
@@ -109,4 +121,6 @@ end
 
 
 require "octopus/proxy"
+require "octopus/collection_proxy"
+require "octopus/relation_proxy"
 require "octopus/scope_proxy"

data/lib/octopus/{rails3/abstract_adapter.rb → abstract_adapter.rb}

@@ -3,10 +3,7 @@ module Octopus
   module AbstractAdapter
     module OctopusShard
 
-      parent = ActiveSupport::BasicObject
-      if Octopus.rails4?
-        parent = ActiveSupport::ProxyObject
-      end
+      parent = Octopus.rails3? ? ActiveSupport::BasicObject : ActiveSupport::ProxyObject
 
       class InstrumenterDecorator < parent
         def initialize(adapter, instrumenter)

data/lib/octopus/association.rb

@@ -1,105 +1,11 @@
 module Octopus::Association
-  def self.extended(base)
-    base.send(:include, InstanceMethods)
+  def self.included(base)
+    base.send(:include, Octopus::ShardTracking::Dynamic)
   end
 
-  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)
-        end
-      end
-    end
-
-  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"
-      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
-        default_octopus_opts(options)
-      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
-        default_octopus_opts(options)
-      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
-
-    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
-
-    options[:extend] = [ Octopus::Association::QueryOnCurrentShard, options[:extend] ].flatten.compact
+  def current_shard
+    owner.current_shard
   end
 end
 
-ActiveRecord::Base.extend(Octopus::Association)
+ActiveRecord::Associations::Association.send(:include, Octopus::Association)

data/lib/octopus/association_shard_tracking.rb

@@ -0,0 +1,105 @@
+module Octopus::AssociationShardTracking
+  def self.extended(base)
+    base.send(:include, InstanceMethods)
+  end
+
+  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)
+        end
+      end
+    end
+
+  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"
+      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
+        default_octopus_opts(options)
+      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
+        default_octopus_opts(options)
+      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
+
+    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
+
+    options[:extend] = [ Octopus::AssociationShardTracking::QueryOnCurrentShard, options[:extend] ].flatten.compact
+  end
+end
+
+ActiveRecord::Base.extend(Octopus::AssociationShardTracking)