slave_pools 0.1.2 → 1.0.0.rc1

data/spec/slave_pools_spec.rb

@@ -2,67 +2,29 @@ require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
 describe SlavePools do
 
-  before(:all) do
-    ActiveRecord::Base.configurations = SLAVE_POOLS_SPEC_CONFIG
-    ActiveRecord::Base.establish_connection :test
-    @sql = 'SELECT NOW()'
+  before(:each) do
+    SlavePools.pools.each{|_, pool| pool.reset }
+    @proxy = SlavePools.proxy
   end
-  
-  context "with no setup" do
-    it "should not error out if next slave is called and SlavePools is not set up" do
-      SlavePools.should_receive(:active?).and_return(false)
-      SlavePools.next_slave!.should be_nil
-    end
-    
-    it "should not error out if current is called and SlavePools is not set up" do
-      SlavePools.should_receive(:active?).and_return(false)
-      SlavePools.current.should be_nil
-    end
-    
-    it "should yield on a with_pool call if slave_pools is not active" do
-      SlavePools.should_receive(:active?).and_return(false)
-      ActiveRecord::Base.connection.should_receive(:execute)
-      SlavePools.with_pool('admin') {ActiveRecord::Base.connection.execute(@sql)}
-    end
 
-    it "should yield on a with_master call if slave_pools is not active" do
-      SlavePools.should_receive(:active?).and_return(false)
-      ActiveRecord::Base.connection.should_receive(:execute)
-      SlavePools.with_master {ActiveRecord::Base.connection.execute(@sql)}
-    end
+  it 'should delegate next_slave! call to connection proxy' do
+    @proxy.should_receive(:next_slave!).exactly(1)
+    SlavePools.next_slave!
   end
-  
-  describe "Slave Pool Wrapper calls" do
-    before(:each) do
-      SlavePools.setup!
-      @proxy = ActiveRecord::Base.connection_proxy
-    end
-    
-    it 'should send next_slave! call to connection proxy' do
-      ActiveRecord::Base.should_receive(:respond_to?).exactly(1)
-      SlavePools.active?
-    end
-  
-    it 'should send next_slave! call to connection proxy' do
-      @proxy.should_receive(:next_slave!).exactly(1)
-      SlavePools.next_slave!
-    end
-    
-    it 'should send with_pool call to connection proxy' do
-      @proxy.should_receive(:with_pool).exactly(1)
-      SlavePools.with_pool('test')
-    end
-    
-    it 'should send with_master call to connection proxy' do
-      @proxy.should_receive(:with_master).exactly(1)
-      SlavePools.with_master
-    end
 
-    it 'should send current call to connection proxy' do
-      @proxy.should_receive(:current).exactly(1)
-      SlavePools.current
-    end
+  it 'should delegate with_pool call to connection proxy' do
+    @proxy.should_receive(:with_pool).exactly(1)
+    SlavePools.with_pool('test')
+  end
+
+  it 'should delegate with_master call to connection proxy' do
+    @proxy.should_receive(:with_master).exactly(1)
+    SlavePools.with_master
+  end
 
+  it 'should delegate current call to connection proxy' do
+    @proxy.should_receive(:current).exactly(1)
+    SlavePools.current
   end
 
 end

data/spec/spec_helper.rb

@@ -2,16 +2,44 @@ require 'rubygems'
 require 'bundler/setup'
 require 'logger'
 
-require 'slave_pools'
-
 module Rails
   def self.env
     ActiveSupport::StringInquirer.new("test")
   end
 end
 
-SLAVE_POOLS_SPEC_DIR = File.dirname(__FILE__)
-SLAVE_POOLS_SPEC_CONFIG = YAML::load(File.open(SLAVE_POOLS_SPEC_DIR + '/config/database.yml'))
+require 'active_record'
+spec_dir = File.dirname(__FILE__)
+ActiveRecord::Base.logger = Logger.new(spec_dir + "/debug.log")
+ActiveRecord::Base.configurations = YAML::load(File.open(spec_dir + '/config/database.yml'))
+
+ActiveRecord::Base.establish_connection :test
+ActiveRecord::Migration.verbose = false
+ActiveRecord::Migration.create_table(:test_models, :force => true) {}
+ActiveRecord::Migration.create_table(:test_subs, :force => true) {|t| t.integer :test_model_id}
 
-ActiveRecord::Base.logger = Logger.new(SLAVE_POOLS_SPEC_DIR + "/debug.log")
-ActiveRecord::Base.configurations = SLAVE_POOLS_SPEC_CONFIG
+require 'slave_pools'
+SlavePools::Engine.initializers.each(&:run)
+ActiveSupport.run_load_hooks(:after_initialize, SlavePools::Engine)
+
+module SlavePools::Testing
+  # Creates aliases for the slave connections in each pool
+  # for easy reference in tests.
+  def create_slave_aliases(proxy)
+    proxy.slave_pools.each do |name, pool|
+      pool.slaves.each.with_index do |slave, i|
+        instance_variable_set("@#{name}_slave#{i + 1}", slave.retrieve_connection)
+      end
+    end
+  end
+
+  def reset_proxy(proxy)
+    proxy.slave_pools.each{|_, pool| pool.reset }
+    proxy.current_pool = proxy.slave_pools[:default]
+    proxy.current      = proxy.current_slave
+  end
+end
+
+RSpec.configure do |c|
+  c.include SlavePools::Testing
+end

metadata

@@ -1,144 +1,141 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: slave_pools
-version: !ruby/object:Gem::Version 
-  hash: 31
-  prerelease: 
-  segments: 
-  - 0
-  - 1
-  - 2
-  version: 0.1.2
+version: !ruby/object:Gem::Version
+  version: 1.0.0.rc1
 platform: ruby
-authors: 
+authors:
 - Dan Drabik
+- Lance Ivy
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2013-07-11 00:00:00 Z
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2013-12-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: activerecord
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 23
-        segments: 
-        - 3
-        - 2
-        - 12
+      - !ruby/object:Gem::Version
         version: 3.2.12
   type: :runtime
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: mysql2
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.12
+- !ruby/object:Gem::Dependency
+  name: mysql2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 5
-        segments: 
-        - 0
-        - 3
-        - 11
+      - !ruby/object:Gem::Version
         version: 0.3.11
   type: :development
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
-  name: rspec
   prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.3.11
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id003
-- !ruby/object:Gem::Dependency 
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
   name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
   prerelease: false
-  requirement: &id004 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id004
-description: Connection proxy for ActiveRecord for single master / multiple slave database groups
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Connection proxy for ActiveRecord for master / replica setups.
 email: dan@kickstarter.com
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
-- LICENSE
-- README.rdoc
-files: 
-- lib/slave_pools.rb
+extra_rdoc_files: []
+files:
 - lib/slave_pools/active_record_extensions.rb
+- lib/slave_pools/config.rb
 - lib/slave_pools/connection_proxy.rb
+- lib/slave_pools/engine.rb
+- lib/slave_pools/hijack.rb
 - lib/slave_pools/observer_extensions.rb
-- lib/slave_pools/query_cache_compat.rb
-- lib/slave_pools/slave_pool.rb
+- lib/slave_pools/pool.rb
+- lib/slave_pools/pools.rb
+- lib/slave_pools/query_cache.rb
+- lib/slave_pools/version.rb
+- lib/slave_pools.rb
 - LICENSE
-- README.rdoc
-- spec/config/database.yml
+- README.md
+- spec/config/test_model.rb
 - spec/connection_proxy_spec.rb
-- spec/slave_pool_spec.rb
+- spec/observer_extensions_spec.rb
+- spec/pool_spec.rb
+- spec/query_cache_spec.rb
 - spec/slave_pools_spec.rb
 - spec/spec_helper.rb
-- slave_pools.gemspec
 homepage: https://github.com/kickstarter/slave_pools
-licenses: 
+licenses:
 - MIT
+metadata: {}
 post_install_message: 
-rdoc_options: 
-- --line-numbers
-- --inline-source
-- --title
-- slave_pools
-- --main
-- README.rdoc
-require_paths: 
+rdoc_options: []
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 11
-      segments: 
-      - 1
-      - 2
-      version: "1.2"
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '1.2'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.8.10
+rubygems_version: 2.1.11
 signing_key: 
-specification_version: 3
-summary: Connection proxy for ActiveRecord for single master / multiple slave database groups
-test_files: []
-
+specification_version: 4
+summary: Connection proxy for ActiveRecord for master / replica setups.
+test_files:
+- spec/config/test_model.rb
+- spec/connection_proxy_spec.rb
+- spec/observer_extensions_spec.rb
+- spec/pool_spec.rb
+- spec/query_cache_spec.rb
+- spec/slave_pools_spec.rb
+- spec/spec_helper.rb

data/README.rdoc

@@ -1,259 +0,0 @@
-= SlavePools
-
-== Easy Single Master/ Multiple Slave Setup for use in Ruby/Rails projects
-
-SlavePools builds a base layer of master/slave query splitting, by overwriting ActiveRecord's connection (with connection_proxy). With this in place, you can easily add a second layer of traffic splitting, by wrapping requests in the provided helper methods (examples below), and have a manageable master/slave solution for a standard rails application
-
-Overview
-* Sends only whitelisted SELECT-type queries to the Slaves
-* Sends all other queries to the Master
-* Works with query caching and transactions
-* Easy to separate types of read traffic into different collections of slaves (e.g. separating admin and user traffic)
-* Minimalist approach
-  * doesn't include sharding
-  * doesn't create a new ActiveRecord adapter
-  * doesn't weight slave db's
-  * Builds onto a standard database.yml file (gem doesn't initialize if no slaves are specified)
-  * doesn't switch slaves on its own (the user specifies when to switch in their code)
-
-The SlavePools GEM started as a fork of Maximilian Sch\303\266fmann's https://github.com/schoefmax/multi_db
-The MultiDB gem was inspired by Rick Olson's "masochism"-Plugin
-
-== Usage
-
-Toggle to next slave:
-  SlavePools.next_slave!
-
-Specify a different slave pool than the default:
-  SlavePools.with_pool('other_pool') { #do stuff }
-
-Specifically use the master for a call:
-  SlavePools.with_master { #do stuff }
-
-Determine if there are slaves:
-  SlavePools.active?
-
-The gem, by default, sends writes and reads to the master and slave databases, respectfully. But in your app, if you write to the master during a request, you will probably want to read from the master in that request as well, in case there is replication. You will also probably want to read from the master on the next request (after a write to the master) to cover redirects.
-
-Using a standard rails application setup, you can achieve this by adding these example methods to your application controller (some of these may be folded in the gem, but leaving out for now):
-
-  class ApplicationController < ActionController::Base
-
-    around_filter   :stick_to_master_for_updates
-    around_filter   :use_master_for_redirect #goes with above
-    after_filter    :switch_to_next_slave
-
-    def switch_to_next_slave
-      SlavePools.next_slave! if slaves?
-    end
-
-    def use_admin_slave_pool
-      SlavePools.with_pool('admin') { yield } if slaves?
-    end
-
-    def stick_to_master_for_updates
-      if slaves? && (request.post? || request.put? || request.delete?)
-        SlavePools.with_master { yield }
-        session[:stick_to_master] = 1
-      else
-        yield
-      end
-    end
-
-    def use_master_for_redirect
-      if slaves? && session[:stick_to_master]
-        session[:stick_to_master] = nil
-        SlavePools.with_master { yield }
-      else
-        yield
-      end
-    end
-
-    def use_master
-      if slaves?
-        SlavePools.with_master { yield }
-        session[:stick_to_master] = 1
-      else
-        yield
-      end
-    end
-
-    def slaves?
-      SlavePools.active?
-    end
-  end
-
-For other cases where you use the master for writes, you should wrap the request in a 'use_master' block
-
-  class PostsController < ApplicationController
-    around_filter :use_master, :only=>:index
-
-    def index
-      Activity.create()
-      # index is a GET call, but we've decided to record something, so we want to wrap it in a use_master block
-    end
-  end
-
-* works with activerecord 3.2.12 (not tested with Rails 2)
-
-=== Install
-
-Add to your Gemfile
-
-  gem 'slave_pools'
-
-=== Setup
-
-slave_pools identifies slave databases by looking for entries of the form
-"<tt><environment>_pool_<pool_name>_name_<db_name></tt>".
-
-In your database.yml, add sections for the slaves, e.g.:
-
-  development: # that would be the master
-    adapter: mysql
-    database: myapp_production
-    username: root
-    password:
-    host: localhost
-
-  development_pool_default_name_slave1: # that would be a slave named 'slave1' in the 'default' pool
-    adapter: mysql
-    database: slave_db1
-    username: root
-    password:
-    host: 10.0.0.2
-
-  development_pool_default_name_slave2: # that would be a slave named 'slave2' in the 'default' pool
-    ...
-  development_pool_admin_name_slave1: # that would be a slave named 'slave1' in the 'admin' pool (db names can be reused across pools)
-    ...
-  development_pool_admin_name_another_slave: # that would be a slave named 'another_slave' in the 'admin' pool
-
-This also creates an abstract classes named <tt>SlavePools::DefaultDb1</tt> for each db of the form <tt>SlavePools::<PoolName><DbName></tt>etc. If no slaves are specified, the SlavePools setup does not run, and the development DB would be used as normal.
-
-For development testing, I recommend creating a read-only mysql user and just point all of your slave DB's to the your development DB using the read-only user.
-
-The Default SlavePool will be used for all requests, so you should name on of the pools 'default' (if there isn't a 'default' slave_pool, the first slave_pool specified becomes the default)
-
-To enable the proxy globally, add this to a config/initializers:
-
-  SlavePools.setup!
-
-If you only want to enable it for specific environments, add this to
-the corresponding file in config/environments:
-
-  config.after_initialize do
-    SlavePools.setup!
-  end
-
-
-=== Using with Phusion Passenger
-
-(this is a note from MultiDB gem and has not been verified)
-
-With Passengers smart spawning method, child processes forked by the ApplicationSpawner
-won't have the connection proxy set up properly (this is a note from ).
-
-To make it work, add this to your <tt>environment.rb</tt> or an initializer script
-(e.g. <tt>config/initializers/connection_proxy.rb</tt>):
-
-  if defined?(PhusionPassenger)
-    PhusionPassenger.on_event(:starting_worker_process) do |forked|
-      if forked
-        # ... set configuration options, if any ...
-        SlavePools::ConnectionProxy.setup!
-      end
-    end
-  else # not using passenger (e.g. development/testing)
-    # ... set configuration options, if any ...
-    SlavePools::ConnectionProxy.setup!
-  end
-
-=== Using with ThinkingSphinx
-
-ThinkingSphinx looks for an adapter type and
-  SlavePools::ConnectionProxy.setup!
-
-  if ActiveRecord::Base.respond_to?('connection_proxy')
-    ThinkingSphinx::AbstractAdapter.class_eval do
-      def self.standard_adapter_for_model(model)
-        :mysql
-      end
-    end
-  end
-
-=== Forcing the master for certain actions
-
-Just add this to your controller:
-
-  around_filter(:only => :foo_action) { |c,a| ActiveRecord::Base.connection_proxy.with_master { a.call } }
-
-=== Forcing the master for certain models
-
-In your environment.rb or an initializer, add this *before* the call to <tt>setup!</tt>:
-
-  SlavePoolsModule::ConnectionProxy.master_models = ['CGI::Session::ActiveRecordStore::Session', 'PaymentTransaction', ...]
-  SlavePoolsModule::ConnectionProxy.setup!
-
-*NOTE*: You cannot safely add more master_models after calling <tt>setup!</tt>.
-=== Features
-* Minimalist implementation - does include sharding, doesn't creation a new adapter (so if you don't specify slaves for
-  an environment, the connection is not overwritten, and the DB works as normal), doesn't blacklist/remove slaves,
-* It sends everything except "select ..." queries to the master, instead of
-  sending only specific things to the master and anything "else" to the slave.
-  This avoids accidental writes to the master when there are API changes in
-  ActiveRecord which haven't been picked up by multi_db yet.
-  Note that this behavior will also always send helper methods like "+quote+" or
-  "<tt>add_limit!</tt>" to the master connection object, which doesn't add any
-  more load on the master, as these methods don't communicate with the db server
-  itself.
-
-
-=== Differences to "multi_db":
-
-* Supports multiple separate pools of slave databases
-* query caching is fixed
-* tries a slave once and immediately reverts to the master afterwards (does not cycle through slaves)
-* stays with the same slave DB until explicitly told to change. In practical usage, it didn't make sense to us
-  to have it cycle through slaves in the same web request, so I made the 'sticky slave' feature permanent
-* removed weighted slave rotation for now (didn't need it)
-* Currently not using Threaded variables (left this commented out in the code for now, may revisit)
-* Added with_pool method
-* does not blacklist slaves for timing out (we want other more robust monitoring software to take care of this)
-* better default case handling - if no slave DB's are specified, the regular Environment database is used, and the gem is
-  not initialized
-* added a wrapper class for shorter calls
-
-=== See also
-
-===== Masochism
-
-The original master/slave plugin:
-
-* http://github.com/technoweenie/masochism
-
-===== MultiDb
-
-The project is based on:
-
-* https://github.com/schoefmax/multi_db
-
-=== Running specs
-
-If you haven't already, install the rspec gem, then set up your database
-with a test database and a read_only user.
-
-To match spec/config/database.yml, you can:
-
-  mysql>
-    create database test_db;
-    create user 'read_only'@'localhost' identified by 'readme';
-    grant select on db_test.* to 'read_only'@'localhost';
-
-From the plugin directory, run:
-
-  rspec spec
-
-Author: Dan Drabik
-Copyright (c) 2012, Kickstarter
-Released under the MIT license

data/lib/slave_pools/query_cache_compat.rb

@@ -1,45 +0,0 @@
-module SlavePoolsModule
-  # Implements the methods expected by the QueryCache module
-  module QueryCacheCompat
-
-    def select_all(*a, &b)
-      arel, name, binds = a
-      if query_cache_enabled && !locked?(arel)
-        # FIXME this still hits the +select_all+ method in AR connection's
-        # query_cache.rb. It'd be nice if we could avoid it somehow so
-        # +select_all+ and then +to_sql+ aren't called redundantly.
-        sql = to_sql(arel, binds)
-        @master.connection.send(:cache_sql, sql, binds) {send_to_current(:select_all, *[sql, name, binds], &b)}
-      else
-        send_to_current(:select_all, *a, &b)
-      end
-    end
-
-    def insert(*a, &b)
-      @master.connection.clear_query_cache if query_cache_enabled
-      send_to_master(:insert, *a, &b)
-    end
-
-    def update(*a, &b)
-      @master.connection.clear_query_cache if query_cache_enabled
-      send_to_master(:update, *a, &b)
-    end
-
-    def delete(*a, &b)
-      @master.connection.clear_query_cache if query_cache_enabled
-      send_to_master(:delete, *a, &b)
-    end
-
-    # Rails 3.2 changed query cacheing a little and affected slave_pools like this:
-    #
-    #   * ActiveRecord::Base.cache sets @query_cache_enabled for current connection
-    #   * ActiveRecord::QueryCache middleware (in call()) that Rails uses sets
-    #     @query_cache_enabled directly on ActiveRecord::Base.connection
-    #     (which could be master at that point)
-    #
-    # :`( So, let's just use the master connection for all query cacheing.
-    def query_cache_enabled
-      @master.connection.query_cache_enabled
-    end
-  end
-end