mysql_replication_adapter 0.2.0 → 0.4.0

data/History.txt

@@ -1,3 +1,8 @@
+== 0.4.0 2007-11-02
+* 1 major enhancement
+  * Fixed a bug in the slave selection algorithm that was causing the last item in the list to always be omitted.
+* A bit of internal restructuring to make the code simpler.
+
 == 0.0.1 2007-07-23
 
 * 1 major enhancement:

data/Manifest.txt

@@ -5,6 +5,7 @@ README.txt
 Rakefile
 lib/mysql_replication_adapter.rb
 lib/mysql_replication_adapter/version.rb
+lib/mysql_replication_adapter/ar_base_ext.rb
 scripts/txt2html
 setup.rb
 test/test_helper.rb

data/lib/mysql_replication_adapter.rb

@@ -8,172 +8,22 @@ unless defined?(RAILS_CONNECTION_ADAPTERS) && RAILS_CONNECTION_ADAPTERS.include?
   RAILS_CONNECTION_ADAPTERS << "mysql_replication"
 end
 
-require 'active_record/connection_adapters/abstract_adapter'
 require 'set'
-
-module MysqlCompat #:nodoc:
-  # add all_hashes method to standard mysql-c bindings or pure ruby version
-  def self.define_all_hashes_method!
-    raise 'Mysql not loaded' unless defined?(::Mysql)
-
-    target = defined?(Mysql::Result) ? Mysql::Result : MysqlRes
-    return if target.instance_methods.include?('all_hashes')
-
-    # Ruby driver has a version string and returns null values in each_hash
-    # C driver >= 2.7 returns null values in each_hash
-    if Mysql.const_defined?(:VERSION) && (Mysql::VERSION.is_a?(String) || Mysql::VERSION >= 20700)
-      target.class_eval <<-'end_eval'
-      def all_hashes
-        rows = []
-        each_hash { |row| rows << row }
-        rows
-      end
-      end_eval
-
-    # adapters before 2.7 don't have a version constant
-    # and don't return null values in each_hash
-    else
-      target.class_eval <<-'end_eval'
-      def all_hashes
-        rows = []
-        all_fields = fetch_fields.inject({}) { |fields, f| fields[f.name] = nil; fields }
-        each_hash { |row| rows << all_fields.dup.update(row) }
-        rows
-      end
-      end_eval
-    end
-
-    unless target.instance_methods.include?('all_hashes')
-      raise "Failed to defined #{target.name}#all_hashes method. Mysql::VERSION = #{Mysql::VERSION.inspect}"
-    end
-  end
-end
+require "mysql_replication_adapter/ar_base_ext"
 
 module ActiveRecord
-  class Base
-    def self.require_mysql
-      # Include the MySQL driver if one hasn't already been loaded
-      unless defined? Mysql
-        begin
-          require_library_or_gem 'mysql'
-        rescue LoadError => cannot_require_mysql
-          # Use the bundled Ruby/MySQL driver if no driver is already in place
-          begin
-            require 'active_record/vendor/mysql'
-          rescue LoadError
-            raise cannot_require_mysql
-          end
-        end
-      end
-
-      # Define Mysql::Result.all_hashes
-      MysqlCompat.define_all_hashes_method!
-    end
-
-    # Establishes a connection to the database that's used by all Active Record objects.
-    def self.mysql_replication_connection(config) # :nodoc:
-      config = config.symbolize_keys
-      host     = config[:host]
-      port     = config[:port]
-      socket   = config[:socket]
-      username = config[:username] ? config[:username].to_s : 'root'
-      password = config[:password].to_s
-      
-      if config.has_key?(:database)
-        database = config[:database]
-      else
-        raise ArgumentError, "No database specified. Missing argument: database."
-      end
-
-      require_mysql
-      mysql = Mysql.init
-      mysql.ssl_set(config[:sslkey], config[:sslcert], config[:sslca], config[:sslcapath], config[:sslcipher]) if config[:sslkey]
-
-      ConnectionAdapters::MysqlReplicationAdapter.new(mysql, logger, [host, username, password, database, port, socket], config)
-    end
-    
-    class << self
-      alias_method :old_find_every, :find_every
-      
-      VALID_FIND_OPTIONS << :use_slave
-    
-      # Override the standard find to check for the :use_slave option. When specified, the
-      # resulting query will be sent to a slave machine.
-      def find_every(options)
-        result = if options[:use_slave] && connection.is_a?(ConnectionAdapters::MysqlReplicationAdapter)
-          connection.load_balance_query do
-            old_find_every(options)
-          end
-        else
-          old_find_every(options)
-        end
-        result
-      end
-
-      alias_method :old_find_by_sql, :find_by_sql
-      # Override find_by_sql so that you can tell it to selectively use a slave machine
-      def find_by_sql(sql, use_slave = false)
-        if use_slave && connection.is_a?(ConnectionAdapters::MysqlReplicationAdapter)
-          connection.load_balance_query {old_find_by_sql sql}
-        else
-          old_find_by_sql sql
-        end
-      end
-      
-      alias_method :old_calculate, :calculate
-      
-      def calculate(operation, column_name, options ={})
-        use_slave = options.delete(:use_slave)
-        if use_slave && connection.is_a?(ConnectionAdapters::MysqlReplicationAdapter)
-          connection.load_balance_query {old_calculate(operation, column_name, options)}
-        else
-          old_calculate(operation, column_name, options)
-        end
-      end
-    end
-    
-  end
-
   module ConnectionAdapters
     class CannotWriteToSlave < Exception
     end
     
-    #class AbstractAdapter
+    class AbstractAdapter
       # Adding this method allows non-mysql-replication adapter applications to function without changing
       # code. Useful in development and test.
-      #def load_balance_query
-      #  yield
-      #end
-    #end
-    
-    class MysqlColumn < Column #:nodoc:
-      #TYPES_ALLOWING_EMPTY_STRING_DEFAULT = Set.new([:binary, :string, :text])
-
-      def initialize(name, default, sql_type = nil, null = true)
-        @original_default = default
-        super
-        @default = nil if missing_default_forged_as_empty_string?
+      def load_balance_query
+        yield
       end
-
-      private
-        def simplified_type(field_type)
-          return :boolean if MysqlAdapter.emulate_booleans && field_type.downcase.index("tinyint(1)")
-          return :string  if field_type =~ /enum/i
-          super
-        end
-
-        # MySQL misreports NOT NULL column default when none is given.
-        # We can't detect this for columns which may have a legitimate ''
-        # default (string, text, binary) but we can for others (integer,
-        # datetime, boolean, and the rest).
-        #
-        # Test whether the column has default '', is not null, and is not
-        # a type allowing default ''.
-        def missing_default_forged_as_empty_string?
-          !null && @original_default == '' && !TYPES_ALLOWING_EMPTY_STRING_DEFAULT.include?(type)
-        end
     end
-
+    
     # The MySQL adapter will work with both Ruby/MySQL, which is a Ruby-based MySQL adapter that comes bundled with Active Record, and with
     # the faster C-based MySQL/Ruby adapter (available both as a gem and from http://www.tmtm.org/en/mysql/ruby/).
     #
@@ -196,51 +46,27 @@ module ActiveRecord
     # to your environment.rb file:
     #
     #   ActiveRecord::ConnectionAdapters::MysqlAdapter.emulate_booleans = false
-    class MysqlReplicationAdapter < AbstractAdapter
-      @@emulate_booleans = true
-      cattr_accessor :emulate_booleans
-      @@use_master_only = false
-      cattr_accessor :use_master_only
-      
-      LOST_CONNECTION_ERROR_MESSAGES = [
-        "Server shutdown in progress",
-        "Broken pipe",
-        "Lost connection to MySQL server during query",
-        "MySQL server has gone away"
-      ]
+    class MysqlReplicationAdapter < MysqlAdapter
+      # @@emulate_booleans = true
+      # cattr_accessor :emulate_booleans
+      # 
+      # LOST_CONNECTION_ERROR_MESSAGES = [
+      #   "Server shutdown in progress",
+      #   "Broken pipe",
+      #   "Lost connection to MySQL server during query",
+      #   "MySQL server has gone away"
+      # ]
 
       def initialize(connection, logger, connection_options, config)
-        super(connection, logger)
-        @connection_options, @config = connection_options, config
-
-        connect
+        @master = @clones = nil
+        @retries = config[:retries]
+        super(connection, logger, connection_options, config)
       end
 
       def adapter_name #:nodoc:
         'MySQLReplication'
       end
 
-      def supports_migrations? #:nodoc:
-        true
-      end
-
-      def native_database_types #:nodoc:
-        {
-          :primary_key => "int(11) DEFAULT NULL auto_increment PRIMARY KEY",
-          :string      => { :name => "varchar", :limit => 255 },
-          :text        => { :name => "text" },
-          :integer     => { :name => "int", :limit => 11 },
-          :float       => { :name => "float" },
-          :decimal     => { :name => "decimal" },
-          :datetime    => { :name => "datetime" },
-          :timestamp   => { :name => "datetime" },
-          :time        => { :name => "time" },
-          :date        => { :name => "date" },
-          :binary      => { :name => "blob" },
-          :boolean     => { :name => "tinyint", :limit => 1 }
-        }
-      end
-
       # the magic load_balance method
       def load_balance_query
         old_connection = @connection
@@ -253,9 +79,9 @@ module ActiveRecord
       # choose a random clone to use for the moment
       def select_clone
         # if we happen not to be connected to any clones, just use the master
-        return @master if @clones.empty?
+        return @master if @clones.nil? || @clones.empty? 
         # return a random clone
-        return @clones[rand(@clones.size - 1)]
+        return @clones[rand(@clones.size)]
       end
 
       # This method raises an exception if the current connection is a clone. It is called inside
@@ -264,65 +90,13 @@ module ActiveRecord
       def ensure_master
         raise CannotWriteToSlave, "You attempted to perform a write operation inside a slave-balanced read block." unless @connection == @master
       end
-
-      # QUOTING ==================================================
-
-      def quote(value, column = nil)
-        if value.kind_of?(String) && column && column.type == :binary && column.class.respond_to?(:string_to_binary)
-          s = column.class.string_to_binary(value).unpack("H*")[0]
-          "x'#{s}'"
-        elsif value.kind_of?(BigDecimal)
-          "'#{value.to_s("F")}'"
-        else
-          super
-        end
-      end
-
-      def quote_column_name(name) #:nodoc:
-        "`#{name}`"
-      end
-
-      def quote_string(string) #:nodoc:
-        @connection.quote(string)
-      end
-
-      def quoted_true
-        "1"
-      end
-      
-      def quoted_false
-        "0"
-      end
-
-
-      # CONNECTION MANAGEMENT ====================================
-
-      def active?
-        if @connection.respond_to?(:stat)
-          @connection.stat
-        else
-          @connection.query 'select 1'
-        end
-
-        # mysql-ruby doesn't raise an exception when stat fails.
-        if @connection.respond_to?(:errno)
-          @connection.errno.zero?
-        else
-          true
-        end
-      rescue Mysql::Error
-        false
-      end
-
-      def reconnect!
-        disconnect!
-        connect
-      end
-      
+    
       def disconnect!
-        @connection.close rescue nil
-        @clones.each do |clone|
-          clone.close rescue nil
+        @master.close rescue nil
+        if @clones
+          @clones.each do |clone|
+            clone.close rescue nil
+          end
         end
       end
 
@@ -330,9 +104,23 @@ module ActiveRecord
       # DATABASE STATEMENTS ======================================
 
       def execute(sql, name = nil) #:nodoc:
+        retries = 0
         log(sql, "#{name} against #{@connection.host_info}") do
           @connection.query(sql) 
         end
+      rescue Mysql::Error => ex
+        if ex.message =~ /MySQL server has gone away/
+          if @retries && retries < @retries
+            retries += 1
+            disconnect!
+            connect
+            retry
+          else
+            raise
+          end
+        else
+          raise
+        end
       rescue ActiveRecord::StatementInvalid => exception
         if exception.message.split(":").first =~ /Packets out of order/
           raise ActiveRecord::StatementInvalid, "'Packets out of order' error was received from the database. Please update your mysql bindings (gem install mysql) and read http://dev.mysql.com/doc/mysql/en/password-hashing.html for more information.  If you're on Windows, use the Instant Rails installer to get the updated mysql bindings."
@@ -353,179 +141,82 @@ module ActiveRecord
         @connection.affected_rows
       end
 
-      def begin_db_transaction #:nodoc:
-        execute "BEGIN"
-      rescue Exception
-        # Transactions aren't supported
-      end
-
-      def commit_db_transaction #:nodoc:
-        execute "COMMIT"
-      rescue Exception
-        # Transactions aren't supported
-      end
-
-      def rollback_db_transaction #:nodoc:
-        execute "ROLLBACK"
-      rescue Exception
-        # Transactions aren't supported
-      end
-
-
-      def add_limit_offset!(sql, options) #:nodoc:
-        if limit = options[:limit]
-          unless offset = options[:offset]
-            sql << " LIMIT #{limit}"
-          else
-            sql << " LIMIT #{offset}, #{limit}"
-          end
-        end
+      private
+      # Create the array of clone Mysql instances. Note that the instances
+      # actually don't correspond to the clone specs at this point. We're 
+      # just getting Mysql object instances we can connect with later.
+      def init_clones
+        @clones = (@config[:clones] || @config[:slaves]).map{Mysql.init}
       end
-
-
-      # SCHEMA STATEMENTS ========================================
-
-      def structure_dump #:nodoc:
-        if supports_views?
-          sql = "SHOW FULL TABLES WHERE Table_type = 'BASE TABLE'"
-        else
-          sql = "SHOW TABLES"
+    
+      # Given a Mysql object and connection options, call #real_connect
+      # on the connection. 
+      def setup_connection(conn, conn_opts)
+        # figure out if we're going to be doing any different
+        # encoding. if so, set it.
+        encoding = @config[:encoding]
+        if encoding
+          conn.options(Mysql::SET_CHARSET_NAME, encoding) rescue nil
         end
         
-        select_all(sql).inject("") do |structure, table|
-          table.delete('Table_type')
-          structure += select_one("SHOW CREATE TABLE #{table.to_a.first.last}")["Create Table"] + ";\n\n"
-        end
-      end
-
-      def recreate_database(name) #:nodoc:
-        drop_database(name)
-        create_database(name)
-      end
-
-      def create_database(name) #:nodoc:
-        execute "CREATE DATABASE `#{name}`"
-      end
-      
-      def drop_database(name) #:nodoc:
-        execute "DROP DATABASE IF EXISTS `#{name}`"
-      end
-
-      def current_database
-        select_one("SELECT DATABASE() as db")["db"]
-      end
-
-      def tables(name = nil) #:nodoc:
-        tables = []
-        execute("SHOW TABLES", name).each { |field| tables << field[0] }
-        tables
-      end
-
-      def indexes(table_name, name = nil)#:nodoc:
-        indexes = []
-        current_index = nil
-        execute("SHOW KEYS FROM #{table_name}", name).each do |row|
-          if current_index != row[2]
-            next if row[2] == "PRIMARY" # skip the primary key
-            current_index = row[2]
-            indexes << IndexDefinition.new(row[0], row[2], row[1] == "0", [])
-          end
-
-          indexes.last.columns << row[4]
-        end
-        indexes
-      end
-
-      def columns(table_name, name = nil)#:nodoc:
-        sql = "SHOW FIELDS FROM #{table_name}"
-        columns = []
-        execute(sql, name).each { |field| columns << MysqlColumn.new(field[0], field[4], field[1], field[2] == "YES") }
-        columns
-      end
-
-      def create_table(name, options = {}) #:nodoc:
-        super(name, {:options => "ENGINE=InnoDB"}.merge(options))
-      end
-      
-      def rename_table(name, new_name)
-        execute "RENAME TABLE #{name} TO #{new_name}"
-      end  
-
-      def change_column_default(table_name, column_name, default) #:nodoc:
-        current_type = select_one("SHOW COLUMNS FROM #{table_name} LIKE '#{column_name}'")["Type"]
-
-        execute("ALTER TABLE #{table_name} CHANGE #{column_name} #{column_name} #{current_type} DEFAULT #{quote(default)}")
-      end
-
-      def change_column(table_name, column_name, type, options = {}) #:nodoc:
-        unless options_include_default?(options)
-          options[:default] = select_one("SHOW COLUMNS FROM #{table_name} LIKE '#{column_name}'")["Default"]
-        end
-
-        change_column_sql = "ALTER TABLE #{table_name} CHANGE #{column_name} #{column_name} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
-        add_column_options!(change_column_sql, options)
-        execute(change_column_sql)
-      end
-
-      def rename_column(table_name, column_name, new_column_name) #:nodoc:
-        current_type = select_one("SHOW COLUMNS FROM #{table_name} LIKE '#{column_name}'")["Type"]
-        execute "ALTER TABLE #{table_name} CHANGE #{column_name} #{new_column_name} #{current_type}"
+        # set the ssl options
+        conn.ssl_set(@config[:sslkey], @config[:sslcert], @config[:sslca], @config[:sslcapath], @config[:sslcipher]) if @config[:sslkey]
+        
+        # do the actual connect
+        conn.real_connect(*conn_opts)
+        
+        # swap the current connection for the connection we just set up
+        old_conn, @connection = @connection, conn
+        
+        # set these options!
+        execute("SET NAMES '#{encoding}'") if encoding
+        # By default, MySQL 'where id is null' selects the last inserted id.
+        # Turn this off. http://dev.rubyonrails.org/ticket/6778
+        execute("SET SQL_AUTO_IS_NULL=0")
+        
+        # swap the old current connection back into place
+        @connection = old_conn
       end
-
-
-      private
-        def connect
-          encoding = @config[:encoding]
-          if encoding
-            @connection.options(Mysql::SET_CHARSET_NAME, encoding) rescue nil
-          end
-          @connection.ssl_set(@config[:sslkey], @config[:sslcert], @config[:sslca], @config[:sslcapath], @config[:sslcipher]) if @config[:sslkey]
-          @connection.real_connect(*@connection_options)
-          execute("SET NAMES '#{encoding}'") if encoding
-
-          # By default, MySQL 'where id is null' selects the last inserted id.
-          # Turn this off. http://dev.rubyonrails.org/ticket/6778
-          execute("SET SQL_AUTO_IS_NULL=0")
-          
-          # save the master in a separate instance variable so we always know what it is
-          @master = @connection
+    
+      def connect
+        # if this is our first time in this method, then master will be
+        # nil, and should get set.
+        @master = @connection unless @master
+
+        # set up the master connection
+        setup_connection(@master, @connection_options)
+                  
+        clone_config = @config[:clones] || @config[:slaves]
+
+        # if clones are specified, then set up those connections
+        if clone_config
+          # create the clone connections if they don't already exist
+          init_clones unless @clones
           
-          # connect to all the clone machines
-          @clones = []
-          clone_config = @config[:clones] || @config[:slaves]
+          # produce a pairing of connection options with an existing clone
+          clones_with_configs = @clones.zip(clone_config)
           
-          if clone_config
-            clone_config.each do |clone|
-              conn = Mysql.init
-              if encoding
-                conn.options(Mysql::SET_CHARSET_NAME, encoding) rescue nil
-              end
-              conn.ssl_set(@config[:sslkey], @config[:sslcert], @config[:sslca], @config[:sslcapath], @config[:sslcipher]) if @config[:sslkey]
+          clones_with_configs.each do |clone_and_config|
+            clone, config = clone_and_config
             
-              conn.real_connect(clone["host"], clone["username"], clone["password"], clone["database"], clone["port"], clone["socket"])
-              @clones << conn
-            end
-          else
-            # warning, no slaves specified.
-            warn "Warning: MysqlReplicationAdapter in use, but no slave database connections specified."
+            # Cause the individual clone Mysql instances to (re)connect
+            # Note - the instances aren't being replaced. This is critical,
+            # as otherwise the current connection could end up pointed at a 
+            # bad connection object in the case of a failure.
+            setup_connection(clone, 
+              [
+                config["host"], 
+                config["username"], config["password"], 
+                config["database"], config["port"], config["socket"]
+              ]
+            )
           end
+        else
+          # warning, no slaves specified.
+          warn "Warning: MysqlReplicationAdapter in use, but no slave database connections specified."
         end
-
-        def select(sql, name = nil)
-          @connection.query_with_result = true
-          result = execute(sql, name)
-          rows = result.all_hashes
-          result.free
-          rows
-        end
-
-        def supports_views?
-          version[0] >= 5
-        end
-
-        def version
-          @version ||= @connection.server_info.scan(/^(\d+)\.(\d+)\.(\d+)/).flatten.map { |v| v.to_i }
-        end
+      end
+      
     end
   end
 end

data/lib/mysql_replication_adapter/ar_base_ext.rb

@@ -0,0 +1,69 @@
+module ActiveRecord
+
+  class Base
+    class << self
+      
+      # Establishes a connection to the database that's used by all Active Record objects.
+      def mysql_replication_connection(config) # :nodoc:
+        config = config.symbolize_keys
+        host     = config[:host]
+        port     = config[:port]
+        socket   = config[:socket]
+        username = config[:username] ? config[:username].to_s : 'root'
+        password = config[:password].to_s
+
+        if config.has_key?(:database)
+          database = config[:database]
+        else
+          raise ArgumentError, "No database specified. Missing argument: database."
+        end
+
+        require_mysql
+        mysql = Mysql.init
+        mysql.ssl_set(config[:sslkey], config[:sslcert], config[:sslca], config[:sslcapath], config[:sslcipher]) if config[:sslkey]
+
+        ConnectionAdapters::MysqlReplicationAdapter.new(mysql, logger, [host, username, password, database, port, socket], config)
+      end
+      
+      alias_method :old_find_every, :find_every
+      
+      VALID_FIND_OPTIONS << :use_slave
+    
+      # Override the standard find to check for the :use_slave option. When specified, the
+      # resulting query will be sent to a slave machine.
+      def find_every(options)
+        result = if options[:use_slave] && connection.is_a?(ConnectionAdapters::MysqlReplicationAdapter)
+          connection.load_balance_query do
+            old_find_every(options)
+          end
+        else
+          old_find_every(options)
+        end
+        result
+      end
+
+      alias_method :old_find_by_sql, :find_by_sql
+      # Override find_by_sql so that you can tell it to selectively use a slave machine
+      def find_by_sql(sql, use_slave = false)
+        if use_slave && connection.is_a?(ConnectionAdapters::MysqlReplicationAdapter)
+          connection.load_balance_query {old_find_by_sql sql}
+        else
+          old_find_by_sql sql
+        end
+      end
+      
+      alias_method :old_calculate, :calculate
+      
+      def calculate(operation, column_name, options ={})
+        use_slave = options.delete(:use_slave)
+        if use_slave && connection.is_a?(ConnectionAdapters::MysqlReplicationAdapter)
+          connection.load_balance_query {old_calculate(operation, column_name, options)}
+        else
+          old_calculate(operation, column_name, options)
+        end
+      end
+      
+    end
+    
+  end
+end

data/lib/mysql_replication_adapter/version.rb

@@ -1,7 +1,7 @@
 module MysqlReplicationAdapter #:nodoc:
   module VERSION #:nodoc:
     MAJOR = 0
-    MINOR = 2
+    MINOR = 4
     TINY  = 0
 
     STRING = [MAJOR, MINOR, TINY].join('.')

data/test/test_helper.rb

@@ -1,2 +1,3 @@
 require 'test/unit'
+require "rubygems"
 require File.dirname(__FILE__) + '/../lib/mysql_replication_adapter'

data/test/test_mysql_replication_adapter.rb

@@ -1,11 +1,61 @@
 require File.dirname(__FILE__) + '/test_helper.rb'
 
+class Person < ActiveRecord::Base
+
+end
+
 class TestMysqlReplicationAdapter < Test::Unit::TestCase
 
   def setup
+    @adapter = get_adapter
+    ActiveRecord::Base.connection = @adapter
+    
+    @adapter.drop_table :people rescue nil
+    
+    @adapter.create_table :people do |t|
+      t.column :name, :string
+    end
+      
+  end
+  
+  def teardown
+    @adapter.drop_table :people
+  end
+  
+  def get_adapter
+    ActiveRecord::Base.mysql_replication_connection(
+      {"host" => "localhost", 
+        "username" => "root",
+        "password" => "",
+        "database" => "mysql_repl_test_master",
+        "retries" => 2,
+        "slaves" => [
+          {"host" => "localhost", 
+            "username" => "root",
+            "password" => "",
+            "database" => "mysql_repl_test_slave_1"
+          },
+          {"host" => "localhost", 
+            "username" => "root",
+            "password" => "",
+            "database" => "mysql_repl_test_slave_2"
+          }
+        ]
+      }
+    )
+  end
+    
+  def test_insert
+    assert_not_nil Person.create(:name => "blah")
+  end
+  
+  def test_lookup
+    Person.create(:name => "blah")
+    assert_equal Person.find(1).id, 1
   end
   
-  def test_truth
-    assert true
+  def test_slave_lookup
+    Person.create(:name => "blah")
+    assert_nil Person.find_by_id(1, :use_slave => true)
   end
 end

data/website/index.html

@@ -33,7 +33,7 @@
     <h1>mysql_replication_adapter</h1>
     <div id="version" class="clickable" onclick='document.location = "http://rubyforge.org/projects/mysql_replication_adapter"; return false'>
       <p>Get Version</p>
-      <a href="http://rubyforge.org/projects/mysql_replication_adapter" class="numbers">0.2.0</a>
+      <a href="http://rubyforge.org/projects/mysql_replication_adapter" class="numbers">0.4.0</a>
     </div>
     <h1>&#x2192; &#8216;mysql_replication_adapter&#8217;</h1>
 

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.4
 specification_version: 1
 name: mysql_replication_adapter
 version: !ruby/object:Gem::Version 
-  version: 0.2.0
-date: 2007-08-01 00:00:00 -07:00
+  version: 0.4.0
+date: 2007-11-02 00:00:00 -07:00
 summary: An ActiveRecord database adapter that allows you to specify a single write master and multiple read-only slaves.
 require_paths: 
 - lib
@@ -36,6 +36,7 @@ files:
 - Rakefile
 - lib/mysql_replication_adapter.rb
 - lib/mysql_replication_adapter/version.rb
+- lib/mysql_replication_adapter/ar_base_ext.rb
 - scripts/txt2html
 - setup.rb
 - test/test_helper.rb