schoefmax-multi_db 0.1.1

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT license:
+Copyright (c) 2008 Maximilian Schöfmann
+ 
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+ 
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+ 
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,104 @@
+= multi_db
+
+=====-- This Plugin was inspired by Rick Olson's "masochism"-Plugin
+
+multi_db uses a connection proxy, which sends read queries to slave databases,
+and all write queries to the master database (Read/Write Split).
+Within transactions, while executing ActiveRecord Observers and
+within "with_master" blocks (see below), even read queries are sent to the 
+master database.
+
+=== Caveats
+
+* works with activerecord 2.1 - 2.2
+
+=== Install
+
+  gem install schoefmax-multi_db --source http://gems.github.com
+
+In Rails 2.1, add this to your environment.rb:
+
+  config.gem 'schoefmax-multi_db', :lib => 'multi_db', :source => 'http://gems.github.com'
+
+=== Setup
+
+In your database.yml, add sections for the slaves, e.g.:
+
+  production: # that would be the master
+    adapter: mysql
+    database: myapp_production
+    username: root
+    password: 
+    host: localhost
+
+  production_slave_database: # that would be a slave 
+    adapter: mysql
+    database: myapp_production
+    username: root
+    password: 
+    host: 10.0.0.2
+
+  production_slave_database2: # another slave
+    ...
+  production_slave_database_some_server: # yet another one
+    ...
+
+*NOTE*: multi_db identifies slave databases by looking for "slave_database" 
+somewhere in the database name!
+
+To enable the proxy globally, add this to your environment.rb, or some file in
+config/initializers:
+
+  MultiDb::ConnectionProxy.setup!
+
+If you only want to enable it for specific environments, add this to 
+the corresponding file in config/environments:
+
+  config.after_initialize do
+    MultiDb::ConnectionProxy.setup!
+  end
+
+In the development and test environments, you can use the same configuration
+for your master and slave databases.
+
+=== Differences to "masochism":
+
+* Support for multiple slave connections (round robin)
+* It sends anything except "select ..." queries to the master, instead of 
+  sending only specific things to the master and anything "else" to the slave, 
+  which is a lot more dangerous (e.g. "execute" wasn't sent to the master in 
+  earlier versions of masochism)
+* It sends everything coming from AR-Observers to the master, to avoid race 
+  conditions (idea from one of the commenters on a blog entry about masochism)
+* It uses its own query cache (with masochism, the slave's cache isn't emptied 
+  when there are changes on the master)
+* It supports immediate failover for slave connections
+* It will wait some time before trying to query a failed slave database again
+* It supports nested "with_master"-blocks (in masochism, nesting such blocks 
+  would unexpectedly switch you to the slave again)
+* It schedules a reconnect on the master connection to avoid problems
+  with virtual, migrating IPs for the master (e.g. multi-master HA setups)
+* It's possible to specify slave_database instead of master_database which
+  makes migration between with and without multi_db less dangerous
+* It allows environment specific settings for different slave setups
+* It doesn't come with set_to_master! and set_to_slave!, as these are 
+  considered dangerous (and make no sense) in a multi-slave setup. Instead of 
+  set_to_master!, use with_master { code }
+
+
+=== Contributors
+
+ * Matt Conway http://github.com/wr0ngway
+ * Matthias Marshall http://github.com/webops
+
+=== Running specs
+
+If you haven't already, install the rspec gem, then create an empty database
+called "multi_db_test" (you might want to tweak the spec/config/database.yml).
+From the plugin directory, run:
+
+  spec spec
+
+
+Copyright (c) 2008, Max Schoefmann <max (a) pragmatic-it de>
+Released under the MIT license

data/lib/multi_db.rb

@@ -0,0 +1,5 @@
+require 'multi_db/scheduler'
+require 'multi_db/active_record_extensions'
+require 'multi_db/observer_extensions'
+require 'multi_db/query_cache_compat'
+require 'multi_db/connection_proxy'

data/lib/multi_db/active_record_extensions.rb

@@ -0,0 +1,23 @@
+module MultiDb
+  module ActiveRecordExtensions
+    def self.included(base)
+      base.alias_method_chain :reload, :master
+
+      class << base
+        def connection_proxy=(proxy)
+          @@connection_proxy = proxy
+        end
+        
+        # hijack the original method
+        def connection
+          @@connection_proxy
+        end
+      end
+      
+    end
+    
+    def reload_with_master(*args, &block)
+      connection.with_master { reload_without_master }
+    end
+  end
+end

data/lib/multi_db/connection_proxy.rb

@@ -0,0 +1,178 @@
+module MultiDb
+  class ConnectionProxy
+    include MultiDb::QueryCacheCompat
+    include ActiveRecord::ConnectionAdapters::QueryCache
+    
+    # Safe methods are those that should either go to the slave ONLY or go
+    # to the current active connection.
+    SAFE_METHODS = [ :select_all, :select_one, :select_value, :select_values, 
+      :select_rows, :select, :verify!, :raw_connection, :active?, :reconnect!,
+      :disconnect!, :reset_runtime, :log, :log_info ]
+
+    attr_accessor :master
+    attr_accessor :current
+    
+    class << self
+      
+      # Example:
+      #  MultiDb::ConnectionProxy.configuration = {
+      #    :production_master_database => {
+      #      :adapter => 
+      #    }
+      #  }
+      # defaults to the content of Rails.root/config/database.yml if not set and used with Rails
+      attr_accessor :configuration
+      # defaults to RAILS_ENV if multi_db is used with Rails
+      attr_accessor :environment
+      
+      def setup!
+        # if no configuration was set, we assume that rails is used and load the database.yml
+        unless self.configuration
+          raise "RAILS_ROOT not set. Set MultiDb::ConnectionProxy.configuration manually if you use multi_db outside rails" unless defined?(RAILS_ROOT)
+          self.configuration = YAML.load(ERB.new(File.read(File.join(RAILS_ROOT, 'config', 'database.yml'))).result)
+        end
+        unless self.environment
+          raise "RAILS_ENV not set. Set MultiDb::ConnectionProxy.environment manually if you use multi_db outside rails" unless defined?(RAILS_ENV)
+          self.environment = RAILS_ENV
+        end
+        master = ActiveRecord::Base
+        master.send :include, MultiDb::ActiveRecordExtensions
+        slaves = init_slaves
+        raise "No slaves defined in database configuration" if slaves.empty?
+        slaves.each {|slave| slave.send :include, MultiDb::ActiveRecordExtensions}
+        ActiveRecord::Observer.send :include, MultiDb::ObserverExtensions
+        master.connection_proxy = new(master, slaves)
+        master.logger.info("** multi_db with master and #{slaves.length} slave#{"s" if slaves.length > 1} loaded.")
+      end
+
+      # Slave entries in the database.yml must be named like this
+      #   development_slave_database:
+      # or
+      #   development_slave_database1:
+      # or
+      #   production_slave_database_someserver:
+      # These would be available later as MultiDb::SlaveDatabaseSomeserver
+      def init_slaves
+        returning([]) do |slaves|
+          self.configuration.keys.each do |name|
+            if name.to_s =~ /#{self.environment}_(slave_database.*)/
+              MultiDb.module_eval %Q{
+                class #{$1.camelize} < ActiveRecord::Base
+                  self.abstract_class = true
+                  establish_connection :#{name}
+                end
+              }, __FILE__, __LINE__
+              slaves << "MultiDb::#{$1.camelize}".constantize
+            end
+          end
+        end
+      end
+      
+    end
+
+    def initialize(master, slaves)
+      @slaves      = Scheduler.new(slaves)
+      @master      = master
+      @current     = @slaves.current
+      @reconnect   = false
+      @with_master = 0
+    end
+    
+    def slave
+      @slaves.current
+    end
+
+    def with_master
+      @current = @master
+      @with_master += 1
+      yield
+    ensure
+      @with_master -= 1
+      @current = @slaves.current if @with_master == 0
+    end
+    
+    def transaction(start_db_transaction = true, &block)
+      with_master { get_connection(@current).transaction(start_db_transaction, &block) }
+    end
+
+    # Calls the method on master/slave and dynamically creates a new
+    # method on success to speed up subsequent calls
+    def method_missing(method, *args, &block)
+      returning(send(target_method(method), method, *args, &block)) do 
+        create_delegation_method!(method)
+      end
+    end
+        
+    protected
+
+    def get_connection(db_class)
+      db_class.retrieve_connection
+    end
+
+    def create_delegation_method!(method)
+      self.instance_eval %Q{
+        def #{method}(*args, &block)
+          #{'next_reader!' unless unsafe?(method)}
+          #{target_method(method)}(:#{method}, *args, &block)
+        end
+      }
+    end
+    
+    def target_method(method)
+      unsafe?(method) ? :send_to_master : :send_to_current
+    end
+    
+    def send_to_master(method, *args, &block)
+      reconnect_master! if @reconnect
+      get_connection(@master).send(method, *args, &block)
+    rescue => e
+      raise_master_error(e)
+    end
+    
+    def send_to_current(method, *args, &block)
+      reconnect_master! if @reconnect && master?
+      get_connection(@current).send(method, *args, &block)
+    rescue NotImplementedError, NoMethodError
+      raise
+    rescue => e # TODO don't rescue everything
+      raise_master_error(e) if master?
+      logger.warn "[MULTIDB] Error reading from slave database"
+      logger.error %(#{e.message}\n#{e.backtrace.join("\n")})
+      @slaves.blacklist!(@current)
+      next_reader!
+      retry
+    end
+    
+    def next_reader!
+      return if @with_master > 0 # don't if in with_master block
+      @current = @slaves.next
+    rescue Scheduler::NoMoreItems
+      logger.warn "[MULTIDB] All slaves are blacklisted. Reading from master"
+      @current = @master
+    end
+    
+    def reconnect_master!
+      get_connection(@master).reconnect!
+      @reconnect = false
+    end
+    
+    def raise_master_error(error)
+      logger.fatal "[MULTIDB] Error accessing master database. Scheduling reconnect"
+      @reconnect = true
+      raise error
+    end
+    
+    def unsafe?(method)
+      !SAFE_METHODS.include?(method)
+    end
+    
+    def master?
+      @current == @master
+    end
+        
+    def logger
+      ActiveRecord::Base.logger
+    end
+    
+  end
+end

data/lib/multi_db/observer_extensions.rb

@@ -0,0 +1,18 @@
+module MultiDb
+  module ObserverExtensions
+    def self.included(base)
+      base.alias_method_chain :update, :masterdb
+    end
+    
+    # Send observed_method(object) if the method exists.
+    def update_with_masterdb(observed_method, object) #:nodoc:
+      if object.class.connection.respond_to?(:with_master)
+        object.class.connection.with_master do
+          update_without_masterdb(observed_method, object)
+        end
+      else
+        update_without_masterdb(observed_method, object)
+      end
+    end
+  end
+end

data/lib/multi_db/query_cache_compat.rb

@@ -0,0 +1,21 @@
+module MultiDb
+  # Implements the methods expected by the QueryCache module
+  module QueryCacheCompat
+    def select_all(*a, &b)
+      next_reader!
+      send_to_current(:select_all, *a, &b)
+    end
+    def columns(*a, &b)
+      send_to_current(:columns, *a, &b)
+    end
+    def insert(*a, &b)
+      send_to_master(:insert, *a, &b)
+    end
+    def update(*a, &b)
+      send_to_master(:update, *a, &b)
+    end
+    def delete(*a, &b)
+      send_to_master(:delete, *a, &b)
+    end
+  end
+end

data/lib/multi_db/scheduler.rb

@@ -0,0 +1,39 @@
+module MultiDb
+  class Scheduler
+    class NoMoreItems < Exception; end
+    
+    attr :items
+    delegate :[], :[]=, :to => :items
+    
+    def initialize(items, blacklist_timeout = 1.minute)
+      @n = items.length
+      @items     = items
+      @blacklist = Array.new(@n, Time.at(0))
+      @current   = 0
+      @blacklist_timeout = blacklist_timeout
+    end
+    
+    def blacklist!(item)
+      @blacklist[@items.index(item)] = Time.now
+    end
+    
+    def current
+      @items[@current]
+    end
+    
+    def next
+      previous = @current
+      until(@blacklist[next_index!] < Time.now - @blacklist_timeout) do
+        raise NoMoreItems, 'All items are blacklisted' if @current == previous
+      end
+      @items[@current]
+    end
+    
+    protected
+    
+    def next_index!
+      @current = (@current + 1) % @n
+    end
+    
+  end
+end

data/multi_db.gemspec

@@ -0,0 +1,33 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{multi_db}
+  s.version = "0.1.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Maximilian Sch\303\266fmann"]
+  s.date = %q{2009-01-29}
+  s.description = "Connection proxy for ActiveRecord for single master / multiple slave database deployments"
+  s.email = "max@pragmatic-it.de"
+  s.extra_rdoc_files = ["lib/multi_db/active_record_extensions.rb", "lib/multi_db/connection_proxy.rb", "lib/multi_db/observer_extensions.rb", "lib/multi_db/query_cache_compat.rb", "lib/multi_db/scheduler.rb", "LICENSE", "README.rdoc"]
+  s.files = ["lib/multi_db.rb", "lib/multi_db/active_record_extensions.rb", "lib/multi_db/connection_proxy.rb", "lib/multi_db/observer_extensions.rb", "lib/multi_db/query_cache_compat.rb", "lib/multi_db/scheduler.rb", "LICENSE", "README.rdoc", "spec/config/database.yml", "spec/connection_proxy_spec.rb", "spec/scheduler_spec.rb", "spec/spec_helper.rb", "multi_db.gemspec"]
+  s.has_rdoc = true
+  s.homepage = "http://github.com/schoefmax/multi_db"
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "multi_db", "--main", "README.rdoc"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = "multi_db"
+  s.rubygems_version = %q{1.3.1}
+  s.summary = "Connection proxy for ActiveRecord for single master / multiple slave database deployments"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency('activerecord', [">= 2.1.0"])
+    else
+      s.add_dependency('activerecord', [">= 2.1.0"])
+    end
+  else
+    s.add_dependency('activerecord', [">= 2.1.0"])
+  end
+end

data/spec/config/database.yml

@@ -0,0 +1,20 @@
+test:
+  adapter: mysql
+  database: multi_db_test
+  username: root
+  password:
+  host: 127.0.0.1
+
+test_slave_database_1:
+  adapter: mysql
+  database: multi_db_test
+  username: root
+  password:
+  host: 127.0.0.1
+
+test_slave_database_2:
+  adapter: mysql
+  database: multi_db_test
+  username: root
+  password:
+  host: 127.0.0.1

data/spec/connection_proxy_spec.rb

@@ -0,0 +1,119 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require MULTI_DB_SPEC_DIR + '/../lib/multi_db/query_cache_compat'
+require MULTI_DB_SPEC_DIR + '/../lib/multi_db/active_record_extensions'
+require MULTI_DB_SPEC_DIR + '/../lib/multi_db/observer_extensions'
+require MULTI_DB_SPEC_DIR + '/../lib/multi_db/scheduler'
+require MULTI_DB_SPEC_DIR + '/../lib/multi_db/connection_proxy'
+
+RAILS_ROOT = MULTI_DB_SPEC_DIR
+
+describe MultiDb::ConnectionProxy do
+  
+  before(:all) do
+    ActiveRecord::Base.establish_connection(MULTI_DB_SPEC_CONFIG['test'])
+    MultiDb::ConnectionProxy.setup!
+    @proxy = ActiveRecord::Base.connection
+    @sql = 'SELECT 1 + 1 FROM DUAL'
+  end
+
+  it "should generate classes for each entry in the database.yml" do
+    defined?(MultiDb::SlaveDatabase1).should_not be_nil
+    defined?(MultiDb::SlaveDatabase2).should_not be_nil
+  end
+  
+  it 'should handle nested with_master-blocks correctly' do
+    @proxy.current.should_not == @proxy.master
+    @proxy.with_master do
+      @proxy.current.should == @proxy.master
+      @proxy.with_master do
+        @proxy.current.should == @proxy.master
+        @proxy.with_master do
+          @proxy.current.should == @proxy.master
+        end
+        @proxy.current.should == @proxy.master
+      end
+      @proxy.current.should == @proxy.master
+    end
+    @proxy.current.should_not == @proxy.master
+  end
+  
+  it 'should perform transactions on the master' do
+    @proxy.master.retrieve_connection.should_receive(:select_all).exactly(1) # makes sure the first one goes to a slave
+    @proxy.select_all(@sql)
+    ActiveRecord::Base.transaction do
+      @proxy.select_all(@sql)
+    end
+  end
+  
+  it 'should switch to the next reader on selects' do
+    MultiDb::SlaveDatabase1.retrieve_connection.should_receive(:select_one).twice
+    MultiDb::SlaveDatabase2.retrieve_connection.should_receive(:select_one).twice
+    4.times { @proxy.select_one(@sql) }
+  end
+  
+  it 'should not switch to the next reader when whithin a with_master-block' do
+    @proxy.master.retrieve_connection.should_receive(:select_one).twice
+    MultiDb::SlaveDatabase1.retrieve_connection.should_not_receive(:select_one)
+    MultiDb::SlaveDatabase2.retrieve_connection.should_not_receive(:select_one)
+    @proxy.with_master do
+      2.times { @proxy.select_one(@sql) }
+    end
+  end
+  
+  it 'should send dangerous methods to the master' do
+    meths = [:insert, :update, :delete, :execute]
+    meths.each do |meth|
+      MultiDb::SlaveDatabase1.retrieve_connection.stub!(meth).and_raise(RuntimeError)
+      @proxy.master.retrieve_connection.should_receive(meth).and_return(true)
+      @proxy.send(meth, @sql)
+    end
+  end
+  
+  it 'should dynamically generate safe methods' do
+    @proxy.should_not respond_to(:select_value)
+    @proxy.select_value(@sql)
+    @proxy.should respond_to(:select_value)
+  end
+  
+  it 'should cache queries using select_all' do
+    ActiveRecord::Base.cache do
+      # next_reader will be called and switch to the SlaveDatabase2
+      MultiDb::SlaveDatabase2.retrieve_connection.should_receive(:select_all).exactly(1)
+      MultiDb::SlaveDatabase1.retrieve_connection.should_not_receive(:select_all)
+      @proxy.master.retrieve_connection.should_not_receive(:select_all)
+      3.times { @proxy.select_all(@sql) }
+    end
+  end
+  
+  it 'should invalidate the cache on insert, delete and update' do
+    ActiveRecord::Base.cache do
+      meths = [:insert, :update, :delete]
+      meths.each do |meth|
+        @proxy.master.retrieve_connection.should_receive(meth).and_return(true)
+      end
+      MultiDb::SlaveDatabase2.retrieve_connection.should_receive(:select_all).twice
+      MultiDb::SlaveDatabase1.retrieve_connection.should_receive(:select_all).once
+      3.times do |i|
+        @proxy.select_all(@sql)
+        @proxy.send(meths[i])
+      end
+    end
+  end
+  
+  it 'should retry the next slave when one fails and finally fall back to the master' do
+    MultiDb::SlaveDatabase1.retrieve_connection.should_receive(:select_all).once.and_raise(RuntimeError)
+    MultiDb::SlaveDatabase2.retrieve_connection.should_receive(:select_all).once.and_raise(RuntimeError)
+    @proxy.master.retrieve_connection.should_receive(:select_all).and_return(true)
+    @proxy.select_all(@sql)
+  end
+  
+  it 'should try to reconnect the master connection after the master has failed' do
+    @proxy.master.retrieve_connection.should_receive(:update).and_raise(RuntimeError)
+    lambda { @proxy.update(@sql) }.should raise_error
+    @proxy.master.retrieve_connection.should_receive(:reconnect!).and_return(true)
+    @proxy.master.retrieve_connection.should_receive(:insert).and_return(1)
+    @proxy.insert(@sql)
+  end
+  
+end
+

data/spec/scheduler_spec.rb

@@ -0,0 +1,44 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+require MULTI_DB_SPEC_DIR + '/../lib/multi_db/scheduler'
+
+describe MultiDb::Scheduler do
+  
+  before do
+    @items = [5, 2, 4, 8]
+    @scheduler = MultiDb::Scheduler.new(@items.clone)
+  end
+  
+  it "should return items in a round robin fashion" do
+    first = @items.shift
+    @scheduler.current.should == first
+    @items.each do |item|
+      @scheduler.next.should == item
+    end
+    @scheduler.next.should == first
+  end
+  
+  it 'should not return blacklisted items' do
+    @scheduler.blacklist!(4)
+    @items.size.times do
+      @scheduler.next.should_not == 4
+    end
+  end
+  
+  it 'should raise NoMoreItems if all are blacklisted' do
+    @items.each do |item|
+      @scheduler.blacklist!(item)
+    end
+    lambda {
+      @scheduler.next
+    }.should raise_error(MultiDb::Scheduler::NoMoreItems)
+  end
+  
+  it 'should unblacklist items automatically' do
+    @scheduler = MultiDb::Scheduler.new(@items.clone, 1.second)
+    @scheduler.blacklist!(2)
+    sleep(1)
+    @scheduler.next.should == 2 
+  end
+  
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+%w[rubygems active_record yaml erb spec].each {|lib| require lib}
+
+RAILS_ENV = ENV['RAILS_ENV'] = 'test'
+
+MULTI_DB_SPEC_DIR = File.dirname(__FILE__)
+MULTI_DB_SPEC_CONFIG = YAML::load(File.open(MULTI_DB_SPEC_DIR + '/config/database.yml'))
+
+ActiveRecord::Base.logger = Logger.new(MULTI_DB_SPEC_DIR + "/debug.log")
+ActiveRecord::Base.configurations = MULTI_DB_SPEC_CONFIG

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification 
+name: schoefmax-multi_db
+version: !ruby/object:Gem::Version 
+  version: 0.1.1
+platform: ruby
+authors: 
+- "Maximilian Sch\xC3\xB6fmann"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-01-29 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.1.0
+    version: 
+description: Connection proxy for ActiveRecord for single master / multiple slave database deployments
+email: max@pragmatic-it.de
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- lib/multi_db/active_record_extensions.rb
+- lib/multi_db/connection_proxy.rb
+- lib/multi_db/observer_extensions.rb
+- lib/multi_db/query_cache_compat.rb
+- lib/multi_db/scheduler.rb
+- LICENSE
+- README.rdoc
+files: 
+- lib/multi_db.rb
+- lib/multi_db/active_record_extensions.rb
+- lib/multi_db/connection_proxy.rb
+- lib/multi_db/observer_extensions.rb
+- lib/multi_db/query_cache_compat.rb
+- lib/multi_db/scheduler.rb
+- LICENSE
+- README.rdoc
+- spec/config/database.yml
+- spec/connection_proxy_spec.rb
+- spec/scheduler_spec.rb
+- spec/spec_helper.rb
+- multi_db.gemspec
+has_rdoc: true
+homepage: http://github.com/schoefmax/multi_db
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --title
+- multi_db
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "1.2"
+  version: 
+requirements: []
+
+rubyforge_project: multi_db
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Connection proxy for ActiveRecord for single master / multiple slave database deployments
+test_files: []
+