mongo 1.1.2 → 1.1.3

data/lib/mongo/collection.rb

@@ -74,6 +74,8 @@ module Mongo
       @db, @name  = db, name
       @connection = @db.connection
       @logger     = @connection.logger
+      @cache_time = @db.cache_time
+      @cache = Hash.new(0)
       unless pk_factory
         @safe       = options.has_key?(:safe) ? options[:safe] : @db.safe
       end
@@ -243,10 +245,10 @@ module Mongo
     def save(doc, opts={})
       if doc.has_key?(:_id) || doc.has_key?('_id')
         id = doc[:_id] || doc['_id']
-        update({:_id => id}, doc, :upsert => true, :safe => opts[:safe])
+        update({:_id => id}, doc, :upsert => true, :safe => opts.fetch(:safe, @safe))
         id
       else
-        insert(doc, :safe => opts[:safe])
+        insert(doc, :safe => opts.fetch(:safe, @safe))
       end
     end
 
@@ -256,8 +258,7 @@ module Mongo
     #   a document (as a hash) or array of documents to be inserted.
     #
     # @return [ObjectId, Array]
-    #   the _id of the inserted document or a list of _ids of all inserted documents.
-    #   Note: the object may have been modified by the database's PK factory, if it has one.
+    #   The _id of the inserted document or a list of _ids of all inserted documents.
     #
     # @option opts [Boolean, Hash] :safe (+false+)
     #   run the operation in safe mode, which run a getlasterror command on the
@@ -298,7 +299,8 @@ module Mongo
     # @example remove only documents that have expired:
     #   users.remove({:expire => {"$lte" => Time.now}})
     #
-    # @return [True]
+    # @return [Hash, true] Returns a Hash containing the last error object if running in safe mode.
+    #   Otherwise, returns true.
     #
     # @raise [Mongo::OperationFailure] an exception will be raised iff safe mode is enabled
     #   and the operation fails.
@@ -317,15 +319,12 @@ module Mongo
       @logger.debug("MONGODB #{@db.name}['#{@name}'].remove(#{selector.inspect})") if @logger
       if safe
         @connection.send_message_with_safe_check(Mongo::Constants::OP_DELETE, message, @db.name, nil, safe)
-        # the return value of send_message_with_safe_check isn't actually meaningful --
-        # only the fact that it didn't raise an error is -- so just return true
-        true
       else
         @connection.send_message(Mongo::Constants::OP_DELETE, message)
       end
     end
 
-    # Update a single document in this collection.
+    # Update one or more documents in this collection.
     #
     # @param [Hash] selector
     #   a hash specifying elements which must be present for a document to be updated. Note:
@@ -346,6 +345,9 @@ module Mongo
     #   options set on this collection, its database object, or the current collection.
     #   See the options for DB#get_last_error for details.
     #
+    # @return [Hash, true] Returns a Hash containing the last error object if running in safe mode.
+    #   Otherwise, returns true.
+    #
     # @core update update-instance_method
     def update(selector, document, options={})
       # Initial byte is 0.
@@ -380,6 +382,9 @@ module Mongo
     #   Also note that it is permissible to create compound indexes that include a geospatial index as
     #   long as the geospatial index comes first.
     #
+    #   If your code calls create_index frequently, you can use Collection#ensure_index to cache these calls
+    #   and thereby prevent excessive round trips to the database.
+    #
     # @option opts [Boolean] :unique (false) if true, this index will enforce a uniqueness constraint.
     # @option opts [Boolean] :background (false) indicate that the index should be built in the background. This
     #   feature is only available in MongoDB >= 1.3.2.
@@ -407,43 +412,45 @@ module Mongo
     # @core indexes create_index-instance_method
     def create_index(spec, opts={})
       opts[:dropDups] = opts.delete(:drop_dups) if opts[:drop_dups]
-      field_spec = BSON::OrderedHash.new
-      if spec.is_a?(String) || spec.is_a?(Symbol)
-        field_spec[spec.to_s] = 1
-      elsif spec.is_a?(Array) && spec.all? {|field| field.is_a?(Array) }
-        spec.each do |f|
-          if [Mongo::ASCENDING, Mongo::DESCENDING, Mongo::GEO2D].include?(f[1])
-            field_spec[f[0].to_s] = f[1]
-          else
-            raise MongoArgumentError, "Invalid index field #{f[1].inspect}; " + 
-              "should be one of Mongo::ASCENDING (1), Mongo::DESCENDING (-1) or Mongo::GEO2D ('2d')."
-          end
-        end
-      else
-        raise MongoArgumentError, "Invalid index specification #{spec.inspect}; " + 
-          "should be either a string, symbol, or an array of arrays."
-      end
-
+      field_spec = parse_index_spec(spec)
       name = opts.delete(:name) || generate_index_name(field_spec)
 
-      selector = {
-        :name   => name,
-        :ns     => "#{@db.name}.#{@name}",
-        :key    => field_spec
-      }
-      selector.merge!(opts)
-
-      insert_documents([selector], Mongo::DB::SYSTEM_INDEX_COLLECTION, false, false)
-      response = @db.get_last_error
+      generate_indexes(field_spec, name, opts)
+      name
+    end
 
-      if response['err']
-        if response['code'] == 11000 && selector[:dropDups]
-          # NOP. If the user is intentionally dropping dups, we can ignore duplicate key errors.
-        else
-          raise Mongo::OperationFailure, "Failed to create index #{selector.inspect} with the following error: " +
-           "#{response['err']}"
-        end
+    # Calls create_index and sets a flag to not do so again for another X minutes.
+    # this time can be specified as an option when initializing a Mongo::DB object as options[:cache_time]
+    # Any changes to an index will be propogated through regardless of cache time (e.g., a change of index direction)
+    #
+    # The parameters and options for this methods are the same as those for Collection#create_index.
+    #
+    # @example Call sequence:
+    #   Time t: @posts.ensure_index([['subject', Mongo::ASCENDING])  -- calls create_index and
+    #     sets the 5 minute cache
+    #   Time t+2min : @posts.ensure_index([['subject', Mongo::ASCENDING])  -- doesn't do anything
+    #   Time t+3min : @posts.ensure_index([['something_else', Mongo::ASCENDING])  -- calls create_index
+    #     and sets 5 minute cache
+    #   Time t+10min : @posts.ensure_index([['subject', Mongo::ASCENDING])  -- calls create_index and
+    #     resets the 5 minute counter
+    #
+    # @return [String] the name of the index.
+    def ensure_index(spec, opts={})
+      valid = BSON::OrderedHash.new
+      now = Time.now.utc.to_i
+      field_spec = parse_index_spec(spec)
+
+      field_spec.each do |key, value|
+        cache_key = generate_index_name({key => value})
+        timeout = @cache[cache_key] || 0
+        valid[key] = value if timeout <= now
       end
+
+      name = opts.delete(:name) || generate_index_name(valid)
+      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}
       name
     end
 
@@ -453,6 +460,7 @@ module Mongo
     #
     # @core indexes
     def drop_index(name)
+      @cache[name] = nil
       @db.drop_index(@name, name)
     end
 
@@ -460,6 +468,7 @@ module Mongo
     #
     # @core indexes
     def drop_indexes
+      @cache = {}
 
       # Note: calling drop_indexes with no args will drop them all.
       @db.drop_index(@name, '*')
@@ -470,7 +479,6 @@ module Mongo
       @db.drop_collection(@name)
     end
 
-
     # Atomically update and return a document using MongoDB's findAndModify command. (MongoDB > 1.3.0)
     #
     # @option opts [Hash] :query ({}) a query selector document for matching the desired document.
@@ -630,10 +638,12 @@ module Mongo
     # Rename this collection.
     #
     # Note: If operating in auth mode, the client must be authorized as an admin to
-    # perform this operation. 
+    # perform this operation.
     #
     # @param [String] new_name the new name for this collection
     #
+    # @return [String] the name of the new collection.
+    #
     # @raise [Mongo::InvalidNSName] if +new_name+ is an invalid collection name.
     def rename(new_name)
       case new_name
@@ -655,6 +665,7 @@ module Mongo
       end
 
       @db.rename_collection(@name, new_name)
+      @name = new_name
     end
 
     # Get information on the indexes for this collection.
@@ -709,6 +720,49 @@ module Mongo
 
     private
 
+    def parse_index_spec(spec)
+      field_spec = BSON::OrderedHash.new
+      if spec.is_a?(String) || spec.is_a?(Symbol)
+        field_spec[spec.to_s] = 1
+      elsif spec.is_a?(Array) && spec.all? {|field| field.is_a?(Array) }
+        spec.each do |f|
+          if [Mongo::ASCENDING, Mongo::DESCENDING, Mongo::GEO2D].include?(f[1])
+            field_spec[f[0].to_s] = f[1]
+          else
+            raise MongoArgumentError, "Invalid index field #{f[1].inspect}; " + 
+              "should be one of Mongo::ASCENDING (1), Mongo::DESCENDING (-1) or Mongo::GEO2D ('2d')."
+          end
+        end
+      else
+        raise MongoArgumentError, "Invalid index specification #{spec.inspect}; " + 
+          "should be either a string, symbol, or an array of arrays."
+      end
+      field_spec
+    end
+
+    def generate_indexes(field_spec, name, opts)
+      selector = {
+        :name   => name,
+        :ns     => "#{@db.name}.#{@name}",
+        :key    => field_spec
+      }
+      selector.merge!(opts)
+
+      begin
+      insert_documents([selector], Mongo::DB::SYSTEM_INDEX_COLLECTION, false, true)
+
+      rescue Mongo::OperationFailure => e
+        if selector[:dropDups] && e.message =~ /^11000/
+          # NOP. If the user is intentionally dropping dups, we can ignore duplicate key errors.
+        else
+          raise Mongo::OperationFailure, "Failed to create index #{selector.inspect} with the following error: " +
+           "#{e.message}"
+        end
+      end
+
+      nil
+    end
+
     # Sends a Mongo::Constants::OP_INSERT message to the database.
     # Takes an array of +documents+, an optional +collection_name+, and a
     # +check_keys+ setting.

data/lib/mongo/connection.rb

@@ -38,21 +38,19 @@ module Mongo
     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, :host, :port, :nodes, :auths, :sockets, :checked_out, :primary, :secondaries, :arbiters,
-      :safe
+    attr_reader :logger, :size, :nodes, :auths, :primary, :secondaries, :arbiters,
+      :safe, :primary_pool, :read_pool, :secondary_pools
 
     # Counter for generating unique request ids.
     @@current_request_id = 0
 
-    # Create a connection to MongoDB.
+    # Create a connection to single MongoDB instance.
     #
-    # If connecting to just one server, you may specify whether connection to slave is permitted.
+    # 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
-    # or replica pair, use Connection.multi. If you're only specifying one node in the
-    # replica set, you can use Connection.new, as any other host known to the set will be
-    # cached.
+    # To specify more than one host pair to be used as seeds in a replica set,
+    # use Connection.multi.
     #
     # 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
@@ -69,12 +67,11 @@ module Mongo
     # @option options [Boolean] :slave_ok (false) Must be set to +true+ when connecting
     #   to a single, slave node.
     # @option options [Logger, #debug] :logger (nil) Logger instance to receive driver operation log.
-    # @option options [String] :name (nil) The name of the replica set to connect to. An exception will be
-    #   raised if unable to connect to a replica set with this name.
-    # @option options [Integer] :pool_size (1) The maximum number of socket connections that can be
-    #   opened to the database.
-    # @option options [Float] :timeout (5.0) When all of the connections to the pool are checked out,
+    # @option options [Integer] :pool_size (1) The maximum number of socket connections allowed per
+    #   connection pool. Note: this setting is relevant only for multi-threaded applications.
+    # @option options [Float] :timeout (5.0) When all of the connections a pool are checked out,
     #   this is the number of seconds to wait for a new connection to be released before throwing an exception.
+    #   Note: this setting is relevant only for multi-threaded applications (which in Ruby are rare).
     #
     # @example localhost, 27017
     #   Connection.new
@@ -88,7 +85,7 @@ module Mongo
     # @example localhost, 3000, where this node may be a slave
     #   Connection.new("localhost", 3000, :slave_ok => true)
     #
-    # @see http://www.mongodb.org/display/DOCS/Replica+Pairs+in+Ruby Replica pairs in Ruby
+    # @see http://api.mongodb.org/ruby/current/file.REPLICA_SETS.html Replica sets in Ruby
     #
     # @raise [ReplicaSetConnectionError] This is raised if a replica set name is specified and the
     #   driver fails to connect to a replica set with that name.
@@ -107,13 +104,13 @@ module Mongo
       @host = @port = nil
 
       # Replica set name
-      @replica_set_name = options[:name]
+      @replica_set_name = options[:rs_name]
 
       # Lock for request ids.
       @id_lock = Mutex.new
 
       # Pool size and timeout.
-      @size      = options[:pool_size] || 1
+      @pool_size = options[:pool_size] || 1
       @timeout   = options[:timeout]   || 5.0
 
       # Mutex for synchronizing pool access
@@ -129,15 +126,8 @@ module Mongo
       # Condition variable for signal and wait
       @queue = ConditionVariable.new
 
-      @sockets      = []
-      @checked_out  = []
-
       # slave_ok can be true only if one node is specified
-      if @nodes.length > 1 && options[:slave_ok]
-        raise MongoArgumentError, "Can't specify more than one node when :slave_ok is true."
-      else
-        @slave_ok = options[:slave_ok]
-      end
+      @slave_ok = options[:slave_ok]
 
       # Cache the various node types
       # when connecting to a replica set.
@@ -145,8 +135,14 @@ module Mongo
       @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
-      @options  = options
 
       should_connect = options.fetch(:connect, true)
       connect if should_connect
@@ -154,30 +150,37 @@ module Mongo
 
     # Initialize a connection to a MongoDB replica set using an array of seed nodes.
     #
-    # Note that, even when connecting to a replica set, you can use Connection.new specifying
-    # just a single node. If the replica set is up, the remaining nodes in the set will be cached
-    # for failover.
+    # The seed nodes specified will be used on the initial connection to the replica set, but note
+    # that this list of nodes will be replced by the list of canonical nodes returned by running the
+    # is_master command on the replica set.
     #
     # @param nodes [Array] An array of arrays, each of which specifies a host and port.
-    # @param opts Takes the same options as Connection.new
+    # @param opts [Hash] Any of the available options that can be passed to Connection.new.
     #
-    # @example
-    #   Connection.multi([["db1.example.com", 27017],
-    #                   ["db2.example.com", 27017]])
+    # @option options [String] :rs_name (nil) The name of the replica set to connect to. An exception will be
+    #   raised if unable to connect to a replica set with this name.
+    # @option options [Boolean] :read_secondary (false) When true, this connection object will pick a random slave
+    #   to send reads to.
     #
     # @example
+    #   Connection.multi([["db1.example.com", 27017], ["db2.example.com", 27017]])
+    #
+    # @example This connection will read from a random secondary node.
     #   Connection.multi([["db1.example.com", 27017], ["db2.example.com", 27017], ["db3.example.com", 27017]],
-    #                   :pool_size => 20, :timeout => 5)
+    #                   :read_secondary => true)
     #
     # @return [Mongo::Connection]
     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
+
       # 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
@@ -389,12 +392,9 @@ module Mongo
     #
     # @return [Boolean]
     def slave_ok?
-      @slave_ok
+      @read_secondary || @slave_ok
     end
 
-
-    ## Connections and pooling ##
-
     # Send a message to MongoDB, adding the necessary headers.
     #
     # @param [Integer] operation a MongoDB opcode.
@@ -404,10 +404,10 @@ module Mongo
     def send_message(operation, message, log_message=nil)
       begin
         packed_message = add_message_headers(operation, message).to_s
-        socket = checkout
+        socket = checkout_writer
         send_message_on_socket(packed_message, socket)
       ensure
-        checkin(socket)
+        checkin_writer(socket)
       end
     end
 
@@ -422,14 +422,12 @@ module Mongo
     #
     # @see DB#get_last_error for valid last error params.
     #
-    # @return [Array]
-    #   An array whose indexes include [0] documents returned, [1] number of document received,
-    #   and [3] a cursor_id.
+    # @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)
       begin
-        sock = checkout
+        sock = checkout_writer
         packed_message = message_with_headers.append!(message_with_check).to_s
         docs = num_received = cursor_id = ''
         @safe_mutexes[sock].synchronize do
@@ -437,13 +435,15 @@ module Mongo
           docs, num_received, cursor_id = receive(sock)
         end
       ensure
-        checkin(sock)
+        checkin_writer(sock)
       end
+
       if num_received == 1 && (error = docs[0]['err'] || docs[0]['errmsg'])
         close if error == "not master"
-        raise Mongo::OperationFailure, error
+        raise Mongo::OperationFailure, docs[0]['code'].to_s + ': ' + error
       end
-      [docs, num_received, cursor_id]
+
+      docs[0]
     end
 
     # Sends a message to the database and waits for the response.
@@ -455,10 +455,10 @@ module Mongo
     # @return [Array]
     #   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)
+    def receive_message(operation, message, log_message=nil, socket=nil, command=false)
       packed_message = add_message_headers(operation, message).to_s
       begin
-        sock = socket || checkout
+        sock = socket || (command ? checkout_writer : checkout_reader)
 
         result = ''
         @safe_mutexes[sock].synchronize do
@@ -466,7 +466,7 @@ module Mongo
           result = receive(sock)
         end
       ensure
-        checkin(sock)
+        command ? checkin_writer(sock) : checkin_reader(sock)
       end
       result
     end
@@ -480,33 +480,43 @@ module Mongo
     # @raise [ConnectionFailure] if unable to connect to any host or port.
     def connect
       reset_connection
+      @nodes_to_try = @nodes.clone
 
-      while !connected? && !(nodes_to_try = @nodes - @nodes_tried).empty?
-        nodes_to_try.each do |node|
-          config = check_is_master(node)
-          if is_primary?(config)
-            set_primary(node)
-          else
-            set_auxillary(node, config)
-          end
+      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
       end
 
+      pick_secondary_for_read
+
       raise ConnectionFailure, "failed to connect to any given host:port" unless connected?
     end
 
+    def connecting?
+      !(connected? && @nodes_to_try.empty?)
+    end
+
+    # It's possible that we defined connected as all nodes being connected???
+    # NOTE: Do check if this needs to be more stringent.
+    # Probably not since if any node raises a connection failure, all nodes will be closed.
     def connected?
-      @host && @port
+      @primary_pool && @primary_pool.host && @primary_pool.port
     end
 
     # Close the connection to the database.
     def close
-      @sockets.each do |sock|
-        sock.close
+      @primary_pool.close if @primary_pool
+      @primary_pool = nil
+      @read_pool    = nil
+      @secondary_pools.each do |pool|
+        pool.close
       end
-      @host = @port = nil
-      @sockets.clear
-      @checked_out.clear
     end
 
     ## Configuration helper methods
@@ -583,18 +593,59 @@ module Mongo
       nodes
     end
 
+    # Checkout a socket for reading (i.e., a secondary node).
+    def checkout_reader
+      connect unless connected?
+
+      if @read_pool
+        @read_pool.checkout
+      else
+        checkout_writer
+      end
+    end
+
+    # Checkout a socket for writing (i.e., a primary node).
+    def checkout_writer
+      connect unless connected?
+
+      @primary_pool.checkout
+    end
+
+    # Checkin a socket used for reading.
+    def checkin_reader(socket)
+      if @read_pool
+        @read_pool.checkin(socket)
+      else
+        checkin_writer(socket)
+      end
+    end
+
+    # Checkin a socket used for writing.
+    def checkin_writer(socket)
+      if @primary_pool
+        @primary_pool.checkin(socket)
+      end
+    end
+
     private
 
+    # 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)]
+      end
+    end
+
     # If a ConnectionFailure is raised, this method will be called
     # to close the connection and reset connection values.
     def reset_connection
       close
-      @host = nil
-      @port = nil
       @primary = nil
-      @secondaries = []
-      @arbiters    = []
-      @nodes_tried = []
+      @secondaries     = []
+      @secondary_pools = []
+      @arbiters        = []
+      @nodes_tried     = []
+      @nodes_to_try    = []
     end
 
     # Primary is defined as either a master node or a slave if
@@ -603,7 +654,7 @@ module Mongo
     # If a primary node is discovered, we set the the @host and @port and
     # apply any saved authentication.
     def is_primary?(config)
-      config && (config['ismaster'] == 1 || config['ismaster'] == true) || @slave_ok
+      config && (config['ismaster'] == 1 || config['ismaster'] == true) || !@replica_set && @slave_ok
     end
 
     def check_is_master(node)
@@ -621,8 +672,9 @@ module Mongo
         @nodes_tried << node
         if config
           update_node_list(config['hosts']) if config['hosts']
-          if @logger
-            @logger.warn("MONGODB #{config['msg']}") if config['msg']
+
+          if config['msg'] && @logger
+            @logger.warn("MONGODB #{config['msg']}")
           end
         end
 
@@ -650,8 +702,9 @@ module Mongo
     # Set the specified node as primary, and
     # apply any saved authentication credentials.
     def set_primary(node)
-      @host, @port = *node
-      @primary = [@host, @port]
+      host, port = *node
+      @primary = [host, port]
+      @primary_pool = Pool.new(self, host, port, :size => @pool_size, :timeout => @timeout)
       apply_saved_authentication
     end
 
@@ -660,7 +713,11 @@ module Mongo
     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
@@ -686,73 +743,10 @@ module Mongo
         [host, port.to_i]
       end
 
-      @nodes |= new_nodes
-    end
+      # Replace the list of seed nodes with the canonical list.
+      @nodes = new_nodes.clone
 
-    # Return a socket to the pool.
-    def checkin(socket)
-      @connection_mutex.synchronize do
-        @checked_out.delete(socket)
-        @queue.signal
-      end
-      true
-    end
-
-    # Adds a new socket to the pool and checks it out.
-    #
-    # This method is called exclusively from #checkout;
-    # therefore, it runs within a mutex.
-    def checkout_new_socket
-      begin
-      socket = TCPSocket.new(@host, @port)
-      socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
-      rescue => ex
-        raise ConnectionFailure, "Failed to connect socket: #{ex}"
-      end
-      @sockets << socket
-      @checked_out << socket
-      socket
-    end
-
-    # Checks out the first available socket from the pool.
-    #
-    # This method is called exclusively from #checkout;
-    # therefore, it runs within a mutex.
-    def checkout_existing_socket
-      socket = (@sockets - @checked_out).first
-      @checked_out << socket
-      socket
-    end
-
-    # Check out an existing socket or create a new socket if the maximum
-    # pool size has not been exceeded. Otherwise, wait for the next
-    # available socket.
-    def checkout
-      connect if !connected?
-      start_time = Time.now
-      loop do
-        if (Time.now - start_time) > @timeout
-            raise ConnectionTimeoutError, "could not obtain connection within " +
-              "#{@timeout} seconds. The max pool size is currently #{@size}; " +
-              "consider increasing the pool size or timeout."
-        end
-
-        @connection_mutex.synchronize do
-          socket = if @checked_out.size < @sockets.size
-                     checkout_existing_socket
-                   elsif @sockets.size < @size
-                     checkout_new_socket
-                   end
-
-          return socket if socket
-
-          # Otherwise, wait
-          if @logger
-            @logger.warn "MONGODB Waiting for available connection; #{@checked_out.size} of #{@size} connections checked out."
-          end
-          @queue.wait(@connection_mutex)
-        end
-      end
+      @nodes_to_try = new_nodes - @nodes_tried
     end
 
     def receive(sock)
@@ -842,17 +836,17 @@ module Mongo
       headers = [
         # Message size.
         16 + message.size,
-        
+
         # Unique request id.
         get_request_id,
-        
+
         # Response id.
         0,
-        
+
         # Opcode.
         operation
       ].pack('VVVV')
-      
+
       message.prepend!(headers)
     end
 
@@ -898,7 +892,7 @@ module Mongo
       end
       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.
@@ -921,10 +915,10 @@ module Mongo
       end
       bytes_read
     end
-    
+
     if defined?(Encoding)
       BINARY_ENCODING = Encoding.find("binary")
-      
+
       def new_binary_string
         "".force_encoding(BINARY_ENCODING)
       end