mongo 1.1.4 → 1.1.5

data/Rakefile

@@ -38,32 +38,45 @@ end
 
 desc "Test the MongoDB Ruby driver."
 task :test do
-  puts "\nThis option has changed."
-  puts "\nTo test the driver with the c-extensions:\nrake test:c\n"
-  puts "To test the pure ruby driver: \nrake test:ruby"
+  puts "\nTo test the driver with the C-extensions:\nrake test:c\n\n"
+  puts "To test the pure ruby driver: \nrake test:ruby\n\n"
 end
 
 namespace :test do
 
-  desc "Test the driver with the c extension enabled."
+  desc "Test the driver with the C extension enabled."
   task :c do
     ENV['C_EXT'] = 'TRUE'
-    Rake::Task['test:unit'].invoke
-    Rake::Task['test:functional'].invoke
-    Rake::Task['test:bson'].invoke
-    Rake::Task['test:pooled_threading'].invoke
-    Rake::Task['test:drop_databases'].invoke
+    if ENV['TEST']
+      Rake::Task['test:functional'].invoke
+    else
+      Rake::Task['test:unit'].invoke
+      Rake::Task['test:functional'].invoke
+      Rake::Task['test:bson'].invoke
+      Rake::Task['test:pooled_threading'].invoke
+      Rake::Task['test:drop_databases'].invoke
+    end
     ENV['C_EXT'] = nil
   end
 
-  desc "Test the driver using pure ruby (no c extension)"
+  desc "Test the driver using pure ruby (no C extension)"
   task :ruby do
     ENV['C_EXT'] = nil
-    Rake::Task['test:unit'].invoke
-    Rake::Task['test:functional'].invoke
-    Rake::Task['test:bson'].invoke
-    Rake::Task['test:pooled_threading'].invoke
-    Rake::Task['test:drop_databases'].invoke
+    if ENV['TEST']
+      Rake::Task['test:functional'].invoke
+    else
+      Rake::Task['test:unit'].invoke
+      Rake::Task['test:functional'].invoke
+      Rake::Task['test:bson'].invoke
+      Rake::Task['test:pooled_threading'].invoke
+      Rake::Task['test:drop_databases'].invoke
+    end
+  end
+
+  desc "Run the replica set test suite"
+  Rake::TestTask.new(:rs) do |t|
+    t.test_files = FileList['test/replica_sets/*_test.rb']
+    t.verbose    = true
   end
 
   Rake::TestTask.new(:unit) do |t|
@@ -77,52 +90,7 @@ namespace :test do
   end
 
   Rake::TestTask.new(:pooled_threading) do |t|
-    t.test_files = FileList['test/threading/*.rb']
-    t.verbose    = true
-  end
-
-  Rake::TestTask.new(:replica_pair_count) do |t|
-    t.test_files = FileList['test/replica_pairs/count_test.rb']
-    t.verbose    = true
-  end
-
-  Rake::TestTask.new(:replica_pair_insert) do |t|
-    t.test_files = FileList['test/replica_pairs/insert_test.rb']
-    t.verbose    = true
-  end
-
-  Rake::TestTask.new(:pooled_replica_pair_insert) do |t|
-    t.test_files = FileList['test/replica_pairs/pooled_insert_test.rb']
-    t.verbose    = true
-  end
-
-  Rake::TestTask.new(:replica_pair_query) do |t|
-    t.test_files = FileList['test/replica_pairs/query_test.rb']
-    t.verbose    = true
-  end
-
-  Rake::TestTask.new(:replica_set_count) do |t|
-    t.test_files = FileList['test/replica_sets/count_test.rb']
-    t.verbose    = true
-  end
-
-  Rake::TestTask.new(:replica_set_insert) do |t|
-    t.test_files = FileList['test/replica_sets/insert_test.rb']
-    t.verbose    = true
-  end
-
-  Rake::TestTask.new(:pooled_replica_set_insert) do |t|
-    t.test_files = FileList['test/replica_sets/pooled_insert_test.rb']
-    t.verbose    = true
-  end
-
-  Rake::TestTask.new(:replica_set_query) do |t|
-    t.test_files = FileList['test/replica_sets/query_test.rb']
-    t.verbose    = true
-  end
-
-  Rake::TestTask.new(:replica_set_ack) do |t|
-    t.test_files = FileList['test/replica_sets/replication_ack_test.rb']
+    t.test_files = FileList['test/threading/*_test.rb']
     t.verbose    = true
   end
 
@@ -147,16 +115,17 @@ namespace :test do
   end
 
   task :drop_databases do |t|
-    puts "Dropping test database..."
-    require File.join(File.dirname(__FILE__), 'test', 'test_helper')
-    include Mongo
-    con = Connection.new(ENV['MONGO_RUBY_DRIVER_HOST'] || 'localhost',
-      ENV['MONGO_RUBY_DRIVER_PORT'] || Connection::DEFAULT_PORT)
-    con.drop_database(MONGO_TEST_DB)
+    puts "Dropping test databases..."
+    require './lib/mongo'
+    con = Mongo::Connection.new(ENV['MONGO_RUBY_DRIVER_HOST'] || 'localhost',
+      ENV['MONGO_RUBY_DRIVER_PORT'] || Mongo::Connection::DEFAULT_PORT)
+    con.database_names.each do |name|
+      con.drop_database(name) if name =~ /^ruby-test/
+    end
   end
 end
 
-desc "Generate documentation"
+desc "Generate RDOC documentation"
 task :rdoc do
   version = eval(File.read("mongo.gemspec")).version
   out = File.join('html', version.to_s)
@@ -172,6 +141,19 @@ task :ydoc do
   system "yardoc lib/**/*.rb lib/mongo/**/*.rb lib/bson/**/*.rb -e yard/yard_ext.rb -p yard/templates -o #{out} --title MongoRuby-#{Mongo::VERSION} --files docs/TUTORIAL.md,docs/GridFS.md,docs/FAQ.md,docs/REPLICA_SETS.md,docs/WRITE_CONCERN.md,docs/HISTORY.md,docs/CREDITS.md,docs/1.0_UPGRADE.md"
 end
 
+namespace :bamboo do
+  namespace :test do
+    task :ruby do
+      Rake::Task['test:ruby'].invoke
+    end
+
+    task :c do
+      Rake::Task['gem:install_extensions'].invoke
+      Rake::Task['test:c'].invoke
+    end
+  end
+end
+
 namespace :gem do
 
   desc "Install the gem locally"
@@ -188,7 +170,6 @@ namespace :gem do
 
   desc "Install the optional c extensions"
   task :install_extensions do
-    sh "gem uninstall -x -a -I bson_ext"
     sh "gem build bson_ext.gemspec"
     sh "gem install --no-rdoc --no-ri bson_ext-*.gem"
     sh "rm bson_ext-*.gem"

data/docs/CREDITS.md

@@ -117,3 +117,7 @@ Hongli Lai (Phusion)
 Mislav Marohnić
 
 * Replaced returning with each_with_object
+
+Alex Stupka
+
+* Replica set port bug

data/docs/HISTORY.md

@@ -1,5 +1,14 @@
 # MongoDB Ruby Driver History
 
+### 1.1.5
+2010-12-15
+
+* ReplSetConnection class. This must be used for replica set connections from
+  now on. You can still use Connection.multi, but that method has been deprecated.
+* Automated replica set tests. rake test:rs
+* Check that request and response ids match.
+* Several bug fixes. See the commit history for details.
+
 ### 1.1.4
 2010-11-30
 

data/docs/REPLICA_SETS.md

@@ -6,17 +6,17 @@ Here follow a few considerations for those using the MongoDB Ruby driver with [r
 
 First, make sure that you've configured and initialized a replica set.
 
-Use `Connection.multi` to connect to a replica set:
+Use `ReplSetConnection.new` to connect to a replica set:
 
-    @connection = Connection.multi([['n1.mydb.net', 27017], ['n2.mydb.net', 27017], ['n3.mydb.net', 27017]])
+    @connection = ReplSetConnection.new(['n1.mydb.net', 27017], ['n2.mydb.net', 27017], ['n3.mydb.net', 27017])
 
 The driver will attempt to connect to a master node and, when found, will replace all seed nodes with known members of the replica set.
 
 ### Read slaves
 
-If you want to read from a seconday node, you can pass :read_secondary => true to Connection#multi.
+If you want to read from a seconday node, you can pass :read_secondary => true to ReplSetConnection#new.
 
-    @connection = Connection.multi([['n1.mydb.net', 27017], ['n2.mydb.net', 27017], ['n3.mydb.net', 27017]],
+    @connection = ReplSetConnection.new(['n1.mydb.net', 27017], ['n2.mydb.net', 27017], ['n3.mydb.net', 27017],
                   :read_secondary => true)
 
 A random secondary will be chosen to be read from. In a typical multi-process Ruby application, you'll have a good distribution of reads across secondary nodes.
@@ -62,14 +62,12 @@ Of course, the proper way to handle connection failures will always depend on th
 
 ### Testing
 
-The Ruby driver (>= 1.0.6) includes some unit tests for verifying replica set behavior. They reside in *tests/replica_sets*. You can run them individually with the following rake tasks:
+The Ruby driver (>= 1.1.5) includes unit tests for verifying replica set behavior. They reside in *tests/replica_sets*. You can run them as a group with the following rake task:
 
-    rake test:replica_set_count
-    rake test:replica_set_insert
-    rake test:pooled_replica_set_insert
-    rake test:replica_set_query
+    rake test:rs
 
-Make sure you have a replica set running on localhost before trying to run these tests.
+The suite will set up a five-node replica set by itself and ensure that driver behaves correctly even in the face
+of individual node failures. Node that the `mongod` executable must be in the search path for this to work.
 
 ### Further Reading
 

data/lib/mongo.rb

@@ -3,7 +3,7 @@
 $:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 
 module Mongo
-  VERSION = "1.1.4"
+  VERSION = "1.1.5"
 end
 
 module Mongo
@@ -42,9 +42,11 @@ require 'mongo/util/support'
 require 'mongo/util/core_ext'
 require 'mongo/util/pool'
 require 'mongo/util/server_version'
+require 'mongo/util/uri_parser'
 
 require 'mongo/collection'
 require 'mongo/connection'
+require 'mongo/repl_set_connection'
 require 'mongo/cursor'
 require 'mongo/db'
 require 'mongo/exceptions'

data/lib/mongo/collection.rb

@@ -321,6 +321,7 @@ module Mongo
         @connection.send_message_with_safe_check(Mongo::Constants::OP_DELETE, message, @db.name, nil, safe)
       else
         @connection.send_message(Mongo::Constants::OP_DELETE, message)
+        true
       end
     end
 
@@ -450,7 +451,7 @@ module Mongo
       generate_indexes(valid, name, opts) if valid.any?
 
       # Reset the cache here in case there are any errors inserting. Best to be safe.
-      name.each {|n| @cache[n] = now + @cache_time}
+      @cache[name] = now + @cache_time
       name
     end
 

data/lib/mongo/connection.rb

@@ -35,11 +35,7 @@ module Mongo
     STANDARD_HEADER_SIZE = 16
     RESPONSE_HEADER_SIZE = 20
 
-    MONGODB_URI_MATCHER = /(([-_.\w\d]+):([-_\w\d]+)@)?([-.\w\d]+)(:([\w\d]+))?(\/([-\d\w]+))?/
-    MONGODB_URI_SPEC = "mongodb://[username:password@]host1[:port1][,host2[:port2],...[,hostN[:portN]]][/database]"
-
-    attr_reader :logger, :size, :nodes, :auths, :primary, :secondaries, :arbiters,
-      :safe, :primary_pool, :read_pool, :secondary_pools
+    attr_reader :logger, :size, :auths, :primary, :safe, :primary_pool, :host_to_try
 
     # Counter for generating unique request ids.
     @@current_request_id = 0
@@ -49,8 +45,7 @@ module Mongo
     # You may specify whether connection to slave is permitted.
     # In all cases, the default host is "localhost" and the default port is 27017.
     #
-    # To specify more than one host pair to be used as seeds in a replica set,
-    # use Connection.multi.
+    # If you're connecting to a replica set, you'll need to use ReplSetConnection.new instead.
     #
     # Once connected to a replica set, you can find out which nodes are primary, secondary, and
     # arbiters with the corresponding accessors: Connection#primary, Connection#secondaries, and
@@ -92,62 +87,19 @@ module Mongo
     #
     # @core connections
     def initialize(host=nil, port=nil, options={})
-      @auths        = []
-
-      if block_given?
-        @nodes = yield self
-      else
-        @nodes = format_pair(host, port)
-      end
+      @host_to_try = format_pair(host, port)
 
       # Host and port of current master.
       @host = @port = nil
 
-      # Replica set name
-      @replica_set_name = options[:rs_name]
-
-      # Lock for request ids.
-      @id_lock = Mutex.new
-
-      # Pool size and timeout.
-      @pool_size = options[:pool_size] || 1
-      @timeout   = options[:timeout]   || 5.0
-
-      # Mutex for synchronizing pool access
-      @connection_mutex = Mutex.new
-
-      # Global safe option. This is false by default.
-      @safe = options[:safe] || false
-
-      # Create a mutex when a new key, in this case a socket,
-      # is added to the hash.
-      @safe_mutexes = Hash.new { |h, k| h[k] = Mutex.new }
-
-      # Condition variable for signal and wait
-      @queue = ConditionVariable.new
-
       # slave_ok can be true only if one node is specified
       @slave_ok = options[:slave_ok]
 
-      # Cache the various node types
-      # when connecting to a replica set.
-      @primary     = nil
-      @secondaries = []
-      @arbiters    = []
-
-      # Connection pool for primay node
-      @primary_pool    = nil
-
-      # Connection pools for each secondary node
-      @secondary_pools = []
-      @read_pool = nil
-
-      @logger   = options[:logger] || nil
-
-      should_connect = options.fetch(:connect, true)
-      connect if should_connect
+      setup(options)
     end
 
+    # DEPRECATED
+    #
     # Initialize a connection to a MongoDB replica set using an array of seed nodes.
     #
     # The seed nodes specified will be used on the initial connection to the replica set, but note
@@ -170,20 +122,13 @@ module Mongo
     #                   :read_secondary => true)
     #
     # @return [Mongo::Connection]
+    #
+    # @deprecated
     def self.multi(nodes, opts={})
-      unless nodes.length > 0 && nodes.all? {|n| n.is_a? Array}
-        raise MongoArgumentError, "Connection.multi requires at least one node to be specified."
-      end
+      warn "Connection.multi is now deprecated. Please use ReplSetConnection.new instead."
 
-      # Block returns an array, the first element being an array of nodes and the second an array
-      # of authorizations for the database.
-      new(nil, nil, opts) do |con|
-        nodes.map do |node|
-          con.instance_variable_set(:@replica_set, true)
-          con.instance_variable_set(:@read_secondary, true) if opts[:read_secondary]
-          con.pair_val_to_connection(node)
-        end
-      end
+      nodes << opts
+      ReplSetConnection.new(*nodes)
     end
 
     # Initialize a connection to MongoDB using the MongoDB URI spec:
@@ -195,8 +140,15 @@ module Mongo
     #
     # @return [Mongo::Connection]
     def self.from_uri(uri, opts={})
-      new(nil, nil, opts) do |con|
-        con.parse_uri(uri)
+      nodes, auths = Mongo::URIParser.parse(uri)
+      opts.merge!({:auths => auths})
+      if nodes.length == 1
+        Connection.new(nodes[0][0], nodes[0][1], opts)
+      elsif nodes.length > 1
+        nodes << opts
+        ReplSetConnection.new(*nodes)
+      else
+        raise MongoArgumentError, "No nodes specified. Please ensure that you've provided at least one node."
       end
     end
 
@@ -362,18 +314,7 @@ module Mongo
       self["admin"].command(oh)
     end
 
-    # Increment and return the next available request id.
-    #
-    # return [Integer]
-    def get_request_id
-      request_id = ''
-      @id_lock.synchronize do
-        request_id = @@current_request_id += 1
-      end
-      request_id
-    end
-
-    # Get the build information for the current connection.
+        # Get the build information for the current connection.
     #
     # @return [Hash]
     def server_info
@@ -392,7 +333,7 @@ module Mongo
     #
     # @return [Boolean]
     def slave_ok?
-      @read_secondary || @slave_ok
+      @slave_ok
     end
 
     # Send a message to MongoDB, adding the necessary headers.
@@ -403,7 +344,8 @@ module Mongo
     # @return [Integer] number of bytes sent
     def send_message(operation, message, log_message=nil)
       begin
-        packed_message = add_message_headers(operation, message).to_s
+        add_message_headers(message, operation)
+        packed_message = message.to_s
         socket = checkout_writer
         send_message_on_socket(packed_message, socket)
       ensure
@@ -424,15 +366,19 @@ module Mongo
     #
     # @return [Hash] The document returned by the call to getlasterror.
     def send_message_with_safe_check(operation, message, db_name, log_message=nil, last_error_params=false)
-      message_with_headers = add_message_headers(operation, message)
-      message_with_check   = last_error_message(db_name, last_error_params)
+      docs = num_received = cursor_id = ''
+      add_message_headers(message, operation)
+
+      last_error_message = BSON::ByteBuffer.new
+      build_last_error_message(last_error_message, db_name, last_error_params)
+      last_error_id = add_message_headers(last_error_message, Mongo::Constants::OP_QUERY)
+
+      packed_message = message.append!(last_error_message).to_s
       begin
         sock = checkout_writer
-        packed_message = message_with_headers.append!(message_with_check).to_s
-        docs = num_received = cursor_id = ''
         @safe_mutexes[sock].synchronize do
           send_message_on_socket(packed_message, sock)
-          docs, num_received, cursor_id = receive(sock)
+          docs, num_received, cursor_id = receive(sock, last_error_id)
         end
       ensure
         checkin_writer(sock)
@@ -440,6 +386,7 @@ module Mongo
 
       if num_received == 1 && (error = docs[0]['err'] || docs[0]['errmsg'])
         close if error == "not master"
+        error = "wtimeout" if error == "timeout"
         raise Mongo::OperationFailure, docs[0]['code'].to_s + ': ' + error
       end
 
@@ -456,14 +403,15 @@ module Mongo
     #   An array whose indexes include [0] documents returned, [1] number of document received,
     #   and [3] a cursor_id.
     def receive_message(operation, message, log_message=nil, socket=nil, command=false)
-      packed_message = add_message_headers(operation, message).to_s
+      request_id = add_message_headers(message, operation)
+      packed_message = message.to_s
       begin
         sock = socket || (command ? checkout_writer : checkout_reader)
 
         result = ''
         @safe_mutexes[sock].synchronize do
           send_message_on_socket(packed_message, sock)
-          result = receive(sock)
+          result = receive(sock, request_id)
         end
       ensure
         command ? checkin_writer(sock) : checkin_reader(sock)
@@ -480,22 +428,15 @@ module Mongo
     # @raise [ConnectionFailure] if unable to connect to any host or port.
     def connect
       reset_connection
-      @nodes_to_try = @nodes.clone
-
-      while connecting?
-        node   = @nodes_to_try.shift
-        config = check_is_master(node)
 
-        if is_primary?(config)
-          set_primary(node)
-        else
-          set_auxillary(node, config)
-        end
+      config = check_is_master(@host_to_try)
+      if is_primary?(config)
+        set_primary(@host_to_try)
       end
 
-      pick_secondary_for_read if @read_secondary
-
-      raise ConnectionFailure, "failed to connect to any given host:port" unless connected?
+      if !connected?
+        raise ConnectionFailure, "Failed to connect to a master node at #{@host_to_try[0]}:#{@host_to_try[1]}"
+      end
     end
 
     def connecting?
@@ -513,139 +454,102 @@ module Mongo
     def close
       @primary_pool.close if @primary_pool
       @primary_pool = nil
-      @read_pool    = nil
-      @secondary_pools.each do |pool|
-        pool.close
-      end
-    end
-
-    ## Configuration helper methods
-
-    # Returns an array of host-port pairs.
-    #
-    # @private
-    def format_pair(pair_or_host, port)
-      case pair_or_host
-        when String
-          [[pair_or_host, port ? port.to_i : DEFAULT_PORT]]
-        when nil
-          [['localhost', DEFAULT_PORT]]
-      end
-    end
-
-    # Convert an argument containing a host name string and a
-    # port number integer into a [host, port] pair array.
-    #
-    # @private
-    def pair_val_to_connection(a)
-      case a
-      when nil
-        ['localhost', DEFAULT_PORT]
-      when String
-        [a, DEFAULT_PORT]
-      when Integer
-        ['localhost', a]
-      when Array
-        a
-      end
-    end
-
-    # Parse a MongoDB URI. This method is used by Connection.from_uri.
-    # Returns an array of nodes and an array of db authorizations, if applicable.
-    #
-    # @private
-    def parse_uri(string)
-      if string =~ /^mongodb:\/\//
-        string = string[10..-1]
-      else
-        raise MongoArgumentError, "MongoDB URI must match this spec: #{MONGODB_URI_SPEC}"
-      end
-
-      nodes = []
-      auths = []
-      specs = string.split(',')
-      specs.each do |spec|
-        matches  = MONGODB_URI_MATCHER.match(spec)
-        if !matches
-          raise MongoArgumentError, "MongoDB URI must match this spec: #{MONGODB_URI_SPEC}"
-        end
-
-        uname = matches[2]
-        pwd   = matches[3]
-        host  = matches[4]
-        port  = matches[6] || DEFAULT_PORT
-        if !(port.to_s =~ /^\d+$/)
-          raise MongoArgumentError, "Invalid port #{port}; port must be specified as digits."
-        end
-        port  = port.to_i
-        db    = matches[8]
-
-        if uname && pwd && db
-          add_auth(db, uname, pwd)
-        elsif uname || pwd || db
-          raise MongoArgumentError, "MongoDB URI must include all three of username, password, " +
-            "and db if any one of these is specified."
-        end
-
-        nodes << [host, port]
-      end
-
-      nodes
     end
 
     # Checkout a socket for reading (i.e., a secondary node).
+    # Note: this is overridden in ReplSetConnection.
     def checkout_reader
       connect unless connected?
-
-      if @read_pool
-        @read_pool.checkout
-      else
-        checkout_writer
-      end
+      @primary_pool.checkout
     end
 
     # Checkout a socket for writing (i.e., a primary node).
+    # Note: this is overridden in ReplSetConnection.
     def checkout_writer
       connect unless connected?
-
       @primary_pool.checkout
     end
 
     # Checkin a socket used for reading.
+    # Note: this is overridden in ReplSetConnection.
     def checkin_reader(socket)
-      if @read_pool
-        @read_pool.checkin(socket)
-      else
-        checkin_writer(socket)
+      if @primary_pool
+        @primary_pool.checkin(socket)
       end
     end
 
     # Checkin a socket used for writing.
+    # Note: this is overridden in ReplSetConnection.
     def checkin_writer(socket)
       if @primary_pool
         @primary_pool.checkin(socket)
       end
     end
 
-    private
+    protected
 
-    # Pick a node randomly from the set of possibly secondaries.
-    def pick_secondary_for_read
-      if (size = @secondary_pools.size) > 1
-        @read_pool = @secondary_pools[rand(size)]
+    # Generic initialization code.
+    # @protected
+    def setup(options)
+      # Authentication objects
+      @auths = options.fetch(:auths, [])
+
+      # Lock for request ids.
+      @id_lock = Mutex.new
+
+      # Pool size and timeout.
+      @pool_size = options[:pool_size] || 1
+      @timeout   = options[:timeout]   || 5.0
+
+      # Mutex for synchronizing pool access
+      @connection_mutex = Mutex.new
+
+      # Global safe option. This is false by default.
+      @safe = options[:safe] || false
+
+      # Create a mutex when a new key, in this case a socket,
+      # is added to the hash.
+      @safe_mutexes = Hash.new { |h, k| h[k] = Mutex.new }
+
+      # Condition variable for signal and wait
+      @queue = ConditionVariable.new
+
+      # Connection pool for primay node
+      @primary      = nil
+      @primary_pool = nil
+
+      @logger   = options[:logger] || nil
+
+      should_connect = options.fetch(:connect, true)
+      connect if should_connect
+    end
+
+    ## Configuration helper methods
+
+    # Returns a host-port pair.
+    #
+    # @return [Array]
+    #
+    # @private
+    def format_pair(host, port)
+      case host
+        when String
+          [host, port ? port.to_i : DEFAULT_PORT]
+        when nil
+          ['localhost', DEFAULT_PORT]
       end
     end
 
+    private
+
+    ## Methods for establishing a connection:
+
     # If a ConnectionFailure is raised, this method will be called
     # to close the connection and reset connection values.
+    # TODO: evaluate whether this method is actually necessary
     def reset_connection
       close
       @primary = nil
-      @secondaries     = []
-      @secondary_pools = []
-      @arbiters        = []
-      @nodes_tried     = []
-      @nodes_to_try    = []
     end
 
     # Primary is defined as either a master node or a slave if
@@ -653,8 +557,9 @@ module Mongo
     #
     # If a primary node is discovered, we set the the @host and @port and
     # apply any saved authentication.
+    # TODO: simplify
     def is_primary?(config)
-      config && (config['ismaster'] == 1 || config['ismaster'] == true) || !@replica_set && @slave_ok
+      config && (config['ismaster'] == 1 || config['ismaster'] == true) || @slave_ok
     end
 
     def check_is_master(node)
@@ -664,41 +569,15 @@ module Mongo
         socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
 
         config = self['admin'].command({:ismaster => 1}, :sock => socket)
-
-        check_set_name(config, socket)
       rescue OperationFailure, SocketError, SystemCallError, IOError => ex
-        close unless connected?
+        close
       ensure
-        @nodes_tried << node
-        if config
-          update_node_list(config['hosts']) if config['hosts']
-
-          if config['msg'] && @logger
-            @logger.warn("MONGODB #{config['msg']}")
-          end
-        end
-
         socket.close if socket
       end
 
       config
     end
 
-    # Make sure that we're connected to the expected replica set.
-    def check_set_name(config, socket)
-      if @replica_set_name
-        config = self['admin'].command({:replSetGetStatus => 1},
-                   :sock => socket, :check_response => false)
-
-        if !Mongo::Support.ok?(config)
-          raise ReplicaSetConnectionError, config['errmsg']
-        elsif config['set'] != @replica_set_name
-          raise ReplicaSetConnectionError,
-            "Attempting to connect to replica set '#{config['set']}' but expected '#{@replica_set_name}'"
-        end
-      end
-    end
-
     # Set the specified node as primary, and
     # apply any saved authentication credentials.
     def set_primary(node)
@@ -708,72 +587,30 @@ module Mongo
       apply_saved_authentication
     end
 
-    # Determines what kind of node we have and caches its host
-    # and port so that users can easily connect manually.
-    def set_auxillary(node, config)
-      if config
-        if config['secondary']
-          host, port = *node
-          @secondaries << node unless @secondaries.include?(node)
-          if @read_secondary
-            @secondary_pools << Pool.new(self, host, port, :size => @pool_size, :timeout => @timeout)
-          end
-        elsif config['arbiterOnly']
-          @arbiters << node unless @arbiters.include?(node)
-        end
-      end
-    end
-
-    # Update the list of known nodes. Only applies to replica sets,
-    # where the response to the ismaster command will return a list
-    # of known hosts.
-    #
-    # @param hosts [Array] a list of hosts, specified as string-encoded
-    #   host-port values. Example: ["myserver-1.org:27017", "myserver-1.org:27017"]
-    #
-    # @return [Array] the updated list of nodes
-    def update_node_list(hosts)
-      new_nodes = hosts.map do |host|
-        if !host.respond_to?(:split)
-          warn "Could not parse host #{host.inspect}."
-          next
-        end
-
-        host, port = host.split(':')
-        [host, port.to_i]
-      end
-
-      # Replace the list of seed nodes with the canonical list.
-      @nodes = new_nodes.clone
 
-      @nodes_to_try = new_nodes - @nodes_tried
-    end
+    ## Low-level connection methods.
 
-    def receive(sock)
-      receive_and_discard_header(sock)
+    def receive(sock, expected_response)
+      begin
+      receive_header(sock, expected_response)
       number_received, cursor_id = receive_response_header(sock)
       read_documents(number_received, cursor_id, sock)
+      rescue Mongo::ConnectionFailure => ex
+        close
+        raise ex
+      end
     end
 
-    def receive_header(sock)
-      header = BSON::ByteBuffer.new
-      header.put_binary(receive_message_on_socket(16, sock))
-      unless header.size == STANDARD_HEADER_SIZE
-        raise "Short read for DB response header: " +
-          "expected #{STANDARD_HEADER_SIZE} bytes, saw #{header.size}"
+    def receive_header(sock, expected_response)
+      header = receive_message_on_socket(16, sock)
+      size, request_id, response_to = header.unpack('VVV')
+      if expected_response != response_to
+        raise Mongo::ConnectionFailure, "Expected response #{expected_response} but got #{response_to}"
       end
-      header.rewind
-      size        = header.get_int
-      request_id  = header.get_int
-      response_to = header.get_int
-      op          = header.get_int
-    end
 
-    def receive_and_discard_header(sock)
-      bytes_read = receive_and_discard_message_on_socket(16, sock)
-      unless bytes_read == STANDARD_HEADER_SIZE
+      unless header.size == STANDARD_HEADER_SIZE
         raise "Short read for DB response header: " +
-          "expected #{STANDARD_HEADER_SIZE} bytes, saw #{bytes_read}"
+          "expected #{STANDARD_HEADER_SIZE} bytes, saw #{header.size}"
       end
       nil
     end
@@ -814,8 +651,9 @@ module Mongo
 
     # Constructs a getlasterror message. This method is used exclusively by
     # Connection#send_message_with_safe_check.
-    def last_error_message(db_name, opts)
-      message = BSON::ByteBuffer.new
+    #
+    # Because it modifies message by reference, we don't need to return it.
+    def build_last_error_message(message, db_name, opts)
       message.put_int(0)
       BSON::BSON_RUBY.serialize_cstr(message, "#{db_name}.$cmd")
       message.put_int(0)
@@ -827,18 +665,22 @@ module Mongo
         cmd.merge!(opts)
       end
       message.put_binary(BSON::BSON_CODER.serialize(cmd, false).to_s)
-      add_message_headers(Mongo::Constants::OP_QUERY, message)
+      nil
     end
 
     # Prepares a message for transmission to MongoDB by
     # constructing a valid message header.
-    def add_message_headers(operation, message)
+    #
+    # Note: this method modifies message by reference.
+    #
+    # @returns [Integer] the request id used in the header
+    def add_message_headers(message, operation)
       headers = [
         # Message size.
         16 + message.size,
 
         # Unique request id.
-        get_request_id,
+        request_id = get_request_id,
 
         # Response id.
         0,
@@ -848,6 +690,19 @@ module Mongo
       ].pack('VVVV')
 
       message.prepend!(headers)
+
+      request_id
+    end
+
+    # Increment and return the next available request id.
+    #
+    # return [Integer]
+    def get_request_id
+      request_id = ''
+      @id_lock.synchronize do
+        request_id = @@current_request_id += 1
+      end
+      request_id
     end
 
     # Low-level method for sending a message on a socket.
@@ -893,29 +748,6 @@ module Mongo
       message
     end
 
-    # Low-level data for receiving data from socket.
-    # Unlike #receive_message_on_socket, this method immediately discards the data
-    # and only returns the number of bytes read.
-    def receive_and_discard_message_on_socket(length, socket)
-      bytes_read = 0
-      begin
-        chunk = socket.read(length)
-        bytes_read = chunk.length
-        raise ConnectionFailure, "connection closed" unless bytes_read > 0
-        if bytes_read < length
-          while bytes_read < length
-            socket.read(length - bytes_read, chunk)
-            raise ConnectionFailure, "connection closed" unless chunk.length > 0
-            bytes_read += chunk.length
-          end
-        end
-        rescue => ex
-          close
-          raise ConnectionFailure, "Operation failed with the following exception: #{ex}"
-      end
-      bytes_read
-    end
-
     if defined?(Encoding)
       BINARY_ENCODING = Encoding.find("binary")