mongo 1.6.4 → 1.7.0.rc0

data/lib/mongo/cursor.rb

@@ -77,6 +77,9 @@ module Mongo
         value = collection.read_preference
       end
       @read_preference = value.is_a?(Hash) ? value.dup : value
+      @tag_sets = opts.fetch(:tag_sets, @collection.tag_sets)
+      @acceptable_latency = opts.fetch(:acceptable_latency, @collection.acceptable_latency)
+
       batch_size(opts[:batch_size] || 0)
 
       @full_collection_name = "#{@collection.db.name}.#{@collection.name}"
@@ -98,10 +101,6 @@ module Mongo
       else
         @command = false
       end
-
-      @checkin_read_pool = false
-      @checkin_connection = false
-      @read_pool = nil
     end
 
     # Guess whether the cursor is alive on the server.
@@ -199,7 +198,7 @@ module Mongo
     # This method overrides any sort order specified in the Collection#find
     # method, and only the last sort applied has an effect.
     #
-    # @param [Symbol, Array] key_or_list either 1) a key to sort by 2)
+    # @param [Symbol, Array, Hash, OrderedHash] order either 1) a key to sort by 2)
     #   an array of [key, direction] pairs to sort by or 3) a hash of
     #   field => direction pairs to sort by. Direction should be specified as 
     #   Mongo::ASCENDING (or :ascending / :asc) or Mongo::DESCENDING
@@ -339,7 +338,7 @@ module Mongo
         message.put_int(1)
         message.put_long(@cursor_id)
         log(:debug, "Cursor#close #{@cursor_id}")
-        @connection.send_message(Mongo::Constants::OP_KILL_CURSORS, message, :connection => :reader)
+        @connection.send_message(Mongo::Constants::OP_KILL_CURSORS, message, :socket => @socket)
       end
       @cursor_id = 0
       @closed    = true
@@ -462,19 +461,37 @@ module Mongo
       end
     end
 
+    # Sends initial query -- which is always a read unless it is a command
+    #
+    # Upon ConnectionFailure, tries query 3 times if socket was not provided
+    # and the query is either not a command or is a secondary_ok command.
+    # 
+    # Pins pools upon successful read and unpins pool upon ConnectionFailure
+    #
     def send_initial_query
-      message = construct_query_message
-      sock    = @socket || checkout_socket_from_connection
+      tries = 0
       instrument(:find, instrument_payload) do
         begin
-        results, @n_received, @cursor_id = @connection.receive_message(
-          Mongo::Constants::OP_QUERY, message, nil, sock, @command,
-          nil, @options & OP_QUERY_EXHAUST != 0)
-        rescue ConnectionFailure, OperationFailure, OperationTimeout => ex
-          force_checkin_socket(sock) unless @socket
+          tries += 1
+          message = construct_query_message
+          sock    = @socket || checkout_socket_from_connection
+          results, @n_received, @cursor_id = @connection.receive_message(
+            Mongo::Constants::OP_QUERY, message, nil, sock, @command,
+            nil, @options & OP_QUERY_EXHAUST != 0)
+        rescue ConnectionFailure => ex
+          if tries < 3 && !@socket && (!@command || Mongo::Support.secondary_ok?(@selector))
+            @connection.unpin_pool(sock.pool) if sock
+            @connection.refresh
+            retry
+          else
+            raise ex
+          end
+        rescue OperationFailure, OperationTimeout => ex
           raise ex
+        ensure
+          checkin_socket(sock) unless @socket
         end
-        checkin_socket(sock) unless @socket
+        @connection.pin_pool(sock.pool) if !@command && !@socket
         @returned += @n_received
         @cache += results
         @query_run = true
@@ -502,97 +519,36 @@ module Mongo
       # Cursor id.
       message.put_long(@cursor_id)
       log(:debug, "cursor.refresh() for cursor #{@cursor_id}") if @logger
-      sock = @socket || checkout_socket_for_op_get_more
+
+      sock = @socket || checkout_socket_from_connection
 
       begin
-      results, @n_received, @cursor_id = @connection.receive_message(
-        Mongo::Constants::OP_GET_MORE, message, nil, sock, @command, nil)
-      rescue ConnectionFailure, OperationFailure, OperationTimeout => ex
-        force_checkin_socket(sock)
-        raise ex
+        results, @n_received, @cursor_id = @connection.receive_message(
+          Mongo::Constants::OP_GET_MORE, message, nil, sock, @command, nil)
+      ensure
+        checkin_socket(sock) unless @socket
       end
-      checkin_socket(sock) unless @socket
+      
       @returned += @n_received
       @cache += results
       close_cursor_if_query_complete
     end
 
     def checkout_socket_from_connection
-      socket = nil
       begin
-        @checkin_connection = true
-        if @command || @read_preference == :primary
-          socket = @connection.checkout_writer
-        elsif @read_preference == :secondary_only
-          socket = @connection.checkout_secondary
+        if @command && !Mongo::Support::secondary_ok?(@selector)
+          @connection.checkout_reader(:primary)
         else
-          @read_pool = @connection.read_pool
-          socket = @connection.checkout_reader
+          @connection.checkout_reader(@read_preference, @tag_sets, @acceptable_latency)
         end
       rescue SystemStackError, NoMemoryError, SystemCallError => ex
         @connection.close
         raise ex
       end
-
-      socket
-    end
-
-    def checkout_socket_for_op_get_more
-      if @read_pool && (@read_pool != @connection.read_pool)
-        checkout_socket_from_read_pool
-      else
-        checkout_socket_from_connection
-      end
-    end
-
-    def checkout_socket_from_read_pool
-      new_pool = @connection.secondary_pools.detect do |pool|
-        pool.host == @read_pool.host && pool.port == @read_pool.port
-      end
-      if new_pool
-        sock = nil
-        begin
-          @read_pool = new_pool
-          sock = new_pool.checkout
-          @checkin_read_pool = true
-        rescue SystemStackError, NoMemoryError, SystemCallError => ex
-          @connection.close
-          raise ex
-        end
-        return sock
-      else
-        raise Mongo::OperationFailure, "Failure to continue iterating " +
-          "cursor because the the replica set member persisting this " +
-          "cursor at #{@read_pool.host_string} cannot be found."
-      end
     end
 
     def checkin_socket(sock)
-      if @checkin_read_pool
-        @read_pool.checkin(sock)
-        @checkin_read_pool = false
-      elsif @checkin_connection
-        if @command || @read_preference == :primary
-          @connection.checkin_writer(sock)
-        else
-          @connection.checkin_reader(sock)
-        end
-        @checkin_connection = false
-      end
-    end
-
-    def force_checkin_socket(sock)
-      if @checkin_read_pool
-        @read_pool.checkin(sock)
-        @checkin_read_pool = false
-      else
-        if @command || @read_preference == :primary
-          @connection.checkin_writer(sock)
-        else
-          @connection.checkin_reader(sock)
-        end
-        @checkin_connection = false
-      end
+      @connection.checkin(sock)
     end
 
     def construct_query_message

data/lib/mongo/db.rb

@@ -53,6 +53,9 @@ module Mongo
     # The length of time that Collection.ensure_index should cache index calls
     attr_accessor :cache_time
 
+    # Read Preference
+    attr_accessor :read_preference, :tag_sets, :acceptable_latency
+
     # Instances of DB are normally obtained by calling Mongo#db.
     #
     # @param [String] name the database name.
@@ -72,6 +75,7 @@ module Mongo
     #   value is provided, the default value set on this instance's Connection object will be used. This
     #   default can be overridden upon instantiation of any collection by explicity setting a :safe value
     #   on initialization
+    #
     # @option opts [Integer] :cache_time (300) Set the time that all ensure_index calls should cache the command.
     #
     # @core databases constructor_details
@@ -87,6 +91,8 @@ module Mongo
         value = @connection.read_preference
       end
       @read_preference = value.is_a?(Hash) ? value.dup : value
+      @tag_sets = opts.fetch(:tag_sets, @connection.tag_sets)
+      @acceptable_latency = opts.fetch(:acceptable_latency, @connection.acceptable_latency)
       @cache_time = opts[:cache_time] || 300 #5 minutes.
     end
 
@@ -112,8 +118,11 @@ module Mongo
         end
       end
 
-      @connection.best_available_socket do |socket|
+      begin
+        socket = @connection.checkout_reader(:primary_preferred)
         issue_authentication(username, password, save_auth, :socket => socket)
+      ensure
+        socket.pool.checkin(socket) if socket
       end
 
       @connection.authenticate_pools
@@ -628,13 +637,6 @@ module Mongo
       doc
     end
 
-    # The value of the read preference. This will be
-    # either +:primary+, +:secondary+, or an object
-    # representing the tags to be read from.
-    def read_preference
-      @read_preference
-    end
-
     private
 
     def system_command_collection

data/lib/mongo/networking.rb

@@ -23,30 +23,23 @@ module Mongo
         opts = {}
       end
 
-      connection = opts.fetch(:connection, :writer)
-
       add_message_headers(message, operation)
       packed_message = message.to_s
 
-      sock = nil
+      sock = opts.fetch(:socket, nil)
       begin
-        if connection == :writer
-          sock = checkout_writer
+        if operation == Mongo::Constants::OP_KILL_CURSORS && read_preference != :primary
+          sock ||= checkout_reader
         else
-          sock = checkout_reader
+          sock ||= checkout_writer
         end
-
         send_message_on_socket(packed_message, sock)
       rescue SystemStackError, NoMemoryError, SystemCallError => ex
         close
         raise ex
       ensure
         if sock
-          if connection == :writer
-            checkin_writer(sock)
-          else
-            checkin_reader(sock)
-          end
+          sock.pool.checkin(sock)
         end
       end
     end
@@ -77,9 +70,9 @@ module Mongo
         sock = checkout_writer
         send_message_on_socket(packed_message, sock)
         docs, num_received, cursor_id = receive(sock, last_error_id)
-        checkin_writer(sock)
+        checkin(sock)
       rescue ConnectionFailure, OperationFailure, OperationTimeout => ex
-        checkin_writer(sock)
+        checkin(sock)
         raise ex
       rescue SystemStackError, NoMemoryError, SystemCallError => ex
         close
@@ -119,24 +112,13 @@ module Mongo
       packed_message = message.to_s
 
       result = ''
-      sock   = nil
-      begin
-        if socket
-          sock = socket
-          should_checkin = false
-        else
-          if command || read == :primary
-            sock = checkout_writer
-          elsif read == :secondary
-            sock = checkout_reader
-          else
-            sock = checkout_tagged(read)
-          end
-          should_checkin = true
-        end
 
-        send_message_on_socket(packed_message, sock)
-        result = receive(sock, request_id, exhaust)
+      begin
+        send_message_on_socket(packed_message, socket)
+        result = receive(socket, request_id, exhaust)
+      rescue ConnectionFailure => ex
+        checkin(socket)
+        raise ex
       rescue SystemStackError, NoMemoryError, SystemCallError => ex
         close
         raise ex
@@ -145,16 +127,6 @@ module Mongo
           close if ex.class == IRB::Abort
         end
         raise ex
-      ensure
-        if should_checkin
-          if command || read == :primary
-            checkin_writer(sock)
-          elsif read == :secondary
-            checkin_reader(sock)
-          else
-            # TODO: sock = checkout_tagged(read)
-          end
-        end
       end
       result
     end
@@ -162,30 +134,25 @@ module Mongo
     private
 
     def receive(sock, cursor_id, exhaust=false)
-      begin
-        if exhaust
-          docs = []
-          num_received = 0
-
-          while(cursor_id != 0) do
-            receive_header(sock, cursor_id, exhaust)
-            number_received, cursor_id = receive_response_header(sock)
-            new_docs, n = read_documents(number_received, sock)
-            docs += new_docs
-            num_received += n
-          end
-
-          return [docs, num_received, cursor_id]
-        else
+      if exhaust
+        docs = []
+        num_received = 0
+
+        while(cursor_id != 0) do
           receive_header(sock, cursor_id, exhaust)
           number_received, cursor_id = receive_response_header(sock)
-          docs, num_received = read_documents(number_received, sock)
-
-          return [docs, num_received, cursor_id]
+          new_docs, n = read_documents(number_received, sock)
+          docs += new_docs
+          num_received += n
         end
-      rescue Mongo::ConnectionFailure => ex
-        close
-        raise ex
+
+        return [docs, num_received, cursor_id]
+      else
+        receive_header(sock, cursor_id, exhaust)
+        number_received, cursor_id = receive_response_header(sock)
+        docs, num_received = read_documents(number_received, sock)
+
+        return [docs, num_received, cursor_id]
       end
     end
 
@@ -194,7 +161,6 @@ module Mongo
 
       # unpacks to size, request_id, response_to
       response_to = header.unpack('VVV')[2]
-
       if !exhaust && expected_response != response_to
         raise Mongo::ConnectionFailure, "Expected response #{expected_response} but got #{response_to}"
       end
@@ -316,7 +282,6 @@ module Mongo
       end
       total_bytes_sent
       rescue => ex
-        close
         raise ConnectionFailure, "Operation failed with the following exception: #{ex}:#{ex.message}"
       end
     end
@@ -327,7 +292,7 @@ module Mongo
       begin
           message = receive_data(length, socket)
       rescue OperationTimeout, ConnectionFailure => ex
-        close
+        socket.close
 
         if ex.class == OperationTimeout
           raise OperationTimeout, "Timed out waiting on socket read."

data/lib/mongo/repl_set_connection.rb

@@ -21,11 +21,11 @@ module Mongo
   # Instantiates and manages connections to a MongoDB replica set.
   class ReplSetConnection < Connection
 
-    REPL_SET_OPTS = [:read, :refresh_mode, :refresh_interval, :require_primary,
-      :read_secondary, :rs_name, :name]
+    REPL_SET_OPTS = [:read, :refresh_mode, :refresh_interval, :read_secondary, 
+      :rs_name, :name, :tag_sets, :secondary_acceptable_latency_ms]
 
     attr_reader :replica_set_name, :seeds, :refresh_interval, :refresh_mode,
-      :refresh_version, :manager
+      :refresh_version, :manager, :tag_sets, :acceptable_latency
 
     # Create a connection to a MongoDB replica set.
     #
@@ -36,38 +36,48 @@ module Mongo
     # Connection#arbiters. This is useful if your application needs to connect manually to nodes other
     # than the primary.
     #
-    # @param [Array] seeds "host:port" strings
+    # @overload initialize(seeds=ENV["MONGODB_URI"], opts={})
+    #   @param [Array<String>, Array<Array(String, Integer)>] seeds
     #
-    # @option opts [String] :name (nil) The name of the replica set to connect to. You
-    #   can use this option to verify that you're connecting to the right replica set.
-    # @option opts [Boolean, Hash] :safe (false) Set the default safe-mode options
-    #   propogated to DB objects instantiated off of this Connection. This
-    #   default can be overridden upon instantiation of any DB by explicity setting a :safe value
-    #   on initialization.
-    # @option opts [:primary, :secondary] :read (:primary) The default read preference for Mongo::DB
-    #   objects created from this connection object. If +:secondary+ is chosen, reads will be sent
-    #   to one of the closest available secondary nodes. If a secondary node cannot be located, the
-    #   read will be sent to the primary.
-    # @option opts [Logger] :logger (nil) Logger instance to receive driver operation log.
-    # @option opts [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 opts [Float] :pool_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.
-    # @option opts [Float] :op_timeout (nil) The number of seconds to wait for a read operation to time out.
-    # @option opts [Float] :connect_timeout (30) The number of seconds to wait before timing out a
-    #   connection attempt.
-    # @option opts [Boolean] :ssl (false) If true, create the connection to the server using SSL.
-    # @option opts [Boolean] :refresh_mode (false) Set this to :sync to periodically update the
-    #   state of the connection every :refresh_interval seconds. Replica set connection failures
-    #   will always trigger a complete refresh. This option is useful when you want to add new nodes
-    #   or remove replica set nodes not currently in use by the driver.
-    # @option opts [Integer] :refresh_interval (90) If :refresh_mode is enabled, this is the number of seconds
-    #   between calls to check the replica set's state.
-    # @option opts [Boolean] :require_primary (true) If true, require a primary node for the connection
-    #   to succeed. Otherwise, connection will succeed as long as there's at least one secondary node.
-    # Note: that the number of seed nodes does not have to be equal to the number of replica set members.
-    # The purpose of seed nodes is to permit the driver to find at least one replica set member even if a member is down.
+    #   @option opts [Boolean, Hash] :safe (false) Set the default safe-mode options
+    #     propagated to DB objects instantiated off of this Connection. This
+    #     default can be overridden upon instantiation of any DB by explicitly setting a :safe value
+    #     on initialization.
+    #   @option opts [:primary, :primary_preferred, :secondary, :secondary_preferred, :nearest] :read_preference (:primary)
+    #     A "read preference" determines the candidate replica set members to which a query or command can be sent.
+    #     [:primary]
+    #       * Read from primary only.
+    #       * Cannot be combined with tags.
+    #     [:primary_preferred]
+    #       * Read from primary if available, otherwise read from a secondary.
+    #     [:secondary]
+    #       * Read from secondary if available.
+    #     [:secondary_preferred]
+    #       * Read from a secondary if available, otherwise read from the primary.
+    #     [:nearest]
+    #       * Read from any member.
+    #   @option opts [Array<Hash{ String, Symbol => Tag Value }>] :tag_sets ([])
+    #     Read from replica-set members with these tags.
+    #   @option opts [Integer] :secondary_acceptable_latency_ms (15) The acceptable
+    #     nearest available member for a member to be considered "near".
+    #   @option opts [Logger] :logger (nil) Logger instance to receive driver operation log.
+    #   @option opts [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 opts [Float] :pool_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.
+    #   @option opts [Float] :op_timeout (nil) The number of seconds to wait for a read operation to time out.
+    #   @option opts [Float] :connect_timeout (30) The number of seconds to wait before timing out a
+    #     connection attempt.
+    #   @option opts [Boolean] :ssl (false) If true, create the connection to the server using SSL.
+    #   @option opts [Boolean] :refresh_mode (false) Set this to :sync to periodically update the
+    #     state of the connection every :refresh_interval seconds. Replica set connection failures
+    #     will always trigger a complete refresh. This option is useful when you want to add new nodes
+    #     or remove replica set nodes not currently in use by the driver.
+    #   @option opts [Integer] :refresh_interval (90) If :refresh_mode is enabled, this is the number of seconds
+    #     between calls to check the replica set's state. 
+    #   @note the number of seed nodes does not have to be equal to the number of replica set members.
+    #     The purpose of seed nodes is to permit the driver to find at least one replica set member even if a member is down.
     #
     # @example Connect to a replica set and provide two seed nodes.
     #   Mongo::ReplSetConnection.new(['localhost:30000', 'localhost:30001'])
@@ -80,26 +90,20 @@ module Mongo
     #
     # @see http://api.mongodb.org/ruby/current/file.REPLICA_SETS.html Replica sets in Ruby
     #
-    # @raise [MongoArgumentError] If called with no arguments and <code>ENV["MONGODB_URI"]</code> implies a direct connection.
+    # @raise [MongoArgumentError] This is raised for usage errors.
     #
-    # @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.
+    # @raise [ConnectionFailure] This is raised for the various connection failures.
     def initialize(*args)
-      if args.last.is_a?(Hash)
-        opts = args.pop
-      else
-        opts = {}
-      end
-
+      opts = args.last.is_a?(Hash) ? args.pop : {}
       nodes = args
 
       if nodes.empty? and ENV.has_key?('MONGODB_URI')
-        parser = URIParser.new ENV['MONGODB_URI'], opts
+        parser = URIParser.new ENV['MONGODB_URI']
         if parser.direct?
           raise MongoArgumentError, "Mongo::ReplSetConnection.new called with no arguments, but ENV['MONGODB_URI'] implies a direct connection."
         end
-        opts = parser.connection_options
-        nodes = parser.nodes
+        opts = parser.connection_options.merge! opts
+        nodes = [parser.nodes]
       end
 
       unless nodes.length > 0
@@ -118,7 +122,6 @@ module Mongo
         end
       end
 
-      # TODO: add a method for replacing this list of node.
       @seeds.freeze
 
       # Refresh
@@ -160,8 +163,8 @@ module Mongo
       @connect_mutex.synchronize do
         return if @connected
 
-        discovered_seeds = @manager ? @manager.seeds : []
-        @manager = PoolManager.new(self, discovered_seeds)
+        seeds = @manager.nil? ? @seeds : @manager.seeds
+        @manager = PoolManager.new(self, seeds)
 
         Thread.current[:managers] ||= Hash.new
         Thread.current[:managers][self] = @manager
@@ -169,10 +172,7 @@ module Mongo
         @manager.connect
         @refresh_version += 1
 
-        if @require_primary && @manager.primary.nil? #TODO: in v2.0, we'll let this be optional and do a lazy connect.
-          close
-          raise ConnectionFailure, "Failed to connect to primary node."
-        elsif @manager.read_pool.nil?
+        if @manager.pools.empty?
           close
           raise ConnectionFailure, "Failed to connect to any node."
         else
@@ -213,7 +213,7 @@ module Mongo
     #   to get the refresh lock.
     def hard_refresh!
       log(:info, "Initiating hard refresh...")
-      discovered_seeds = @manager ? @manager.seeds : []
+      discovered_seeds = @manager.seeds
       new_manager = PoolManager.new(self, discovered_seeds | @seeds)
       new_manager.connect
 
@@ -228,7 +228,7 @@ module Mongo
     end
 
     def connected?
-      @connected && (@manager.primary_pool || @manager.read_pool)
+      @connected && !@manager.pools.empty?
     end
 
     # @deprecated
@@ -296,124 +296,68 @@ module Mongo
     end
 
     # Returns +true+ if it's okay to read from a secondary node.
-    # Since this is a replica set, this must always be true.
     #
     # This method exist primarily so that Cursor objects will
     # generate query messages with a slaveOkay value of +true+.
     #
     # @return [Boolean] +true+
     def slave_ok?
-      true
+      @read != :primary
     end
 
     def authenticate_pools
-      if primary_pool
-        primary_pool.authenticate_existing
-      end
-      secondary_pools.each do |pool|
-        pool.authenticate_existing
-      end
+      pools.each { |pool| pool.authenticate_existing }
     end
 
     def logout_pools(db)
-      if primary_pool
-        primary_pool.logout_existing(db)
-      end
-      secondary_pools.each do |pool|
-        pool.logout_existing(db)
-      end
+      pools.each { |pool| pool.logout_existing(db) }
     end
 
     # Generic socket checkout
     # Takes a block that returns a socket from pool
-    def checkout(&block)
-      if connected?
-        sync_refresh
-      else
-        connect
-      end
-      
+    def checkout
+      ensure_manager
+
+      connected? ? sync_refresh : connect
+
       begin
-        socket = block.call
+        socket = yield
       rescue => ex
         checkin(socket) if socket
         raise ex
       end
-      
+
       if socket
         socket
       else
         @connected = false
         raise ConnectionFailure.new("Could not checkout a socket.")
       end
-    end
-
-    # Checkout best available socket by trying primary
-    # pool first and then falling back to secondary.
-    def checkout_best
-      checkout do
-        socket = get_socket_from_pool(:primary)
-        if !socket
-          connect
-          socket = get_socket_from_pool(:secondary)
-        end
-        socket
-      end
+      socket
     end
     
-    # Checkout a socket for reading (i.e., a secondary node).
-    # Note that @read_pool might point to the primary pool
-    # if no read pool has been defined.
-    def checkout_reader
-      checkout do
-        socket = get_socket_from_pool(:read)
-        if !socket
-          connect
-          socket = get_socket_from_pool(:primary)
-        end
-        socket
-      end
-    end
-
-    # Checkout a socket from a secondary
-    # For :read_preference => :secondary_only
-    def checkout_secondary
+    def checkout_reader(mode=@read, tag_sets=@tag_sets, acceptable_latency=@acceptable_latency)
       checkout do
-        get_socket_from_pool(:secondary)
+        pool = read_pool(mode, tag_sets, acceptable_latency)
+        get_socket_from_pool(pool)
       end
     end
 
     # Checkout a socket for writing (i.e., a primary node).
     def checkout_writer
       checkout do
-        get_socket_from_pool(:primary)
+        get_socket_from_pool(primary_pool)
       end
     end
 
     # Checkin a socket used for reading.
-    def checkin_reader(socket)
-      if socket
-        socket.pool.checkin(socket)
-      end
-      sync_refresh
-    end
-
-    # Checkin a socket used for writing.
-    def checkin_writer(socket)
-      if socket
+    def checkin(socket)
+      if socket && socket.pool
         socket.pool.checkin(socket)
       end
       sync_refresh
     end
 
-    def close_socket(socket)
-      begin
-        socket.close if socket
-      rescue IOError
-        log(:info, "Tried to close socket #{socket} but already closed.")
-      end
-    end
-
     def ensure_manager
       Thread.current[:managers] ||= Hash.new
 
@@ -422,25 +366,19 @@ module Mongo
       end
     end
 
-    def get_socket_from_pool(pool_type)
-      ensure_manager
+    def pin_pool(pool)
+      @manager.pinned_pools[Thread.current] = pool if @manager
+    end
 
-      pool = case pool_type
-        when :primary
-          primary_pool
-        when :secondary
-          secondary_pool
-        when :read
-          read_pool
-      end
+    def unpin_pool(pool)
+      @manager.pinned_pools[Thread.current] = nil if @manager
+    end
 
+    def get_socket_from_pool(pool)
       begin
-        if pool
-          pool.checkout
-        end
-      rescue ConnectionFailure => ex
-        log(:info, "Failed to checkout from #{pool} with #{ex.class}; #{ex.message}")
-        return nil
+        pool.checkout if pool
+      rescue ConnectionFailure
+        nil
       end
     end
 
@@ -469,8 +407,8 @@ module Mongo
       local_manager ? local_manager.primary_pool : nil
     end
 
-    def read_pool
-      local_manager ? local_manager.read_pool : nil
+    def read_pool(mode=@read, tags=@tag_sets, acceptable_latency=@acceptable_latency)
+      local_manager ? local_manager.read_pool(mode, tags, acceptable_latency) : nil
     end
 
     def secondary_pool
@@ -497,9 +435,6 @@ module Mongo
 
     # Parse option hash
     def setup(opts)
-      # Require a primary node to connect?
-      @require_primary = opts.fetch(:require_primary, true)
-
       # Refresh
       @refresh_mode = opts.fetch(:refresh_mode, false)
       @refresh_interval = opts.fetch(:refresh_interval, 90)
@@ -516,17 +451,20 @@ module Mongo
           "Refresh mode must be either :sync or false."
       end
 
-      # Are we allowing reads from secondaries?
+      # Determine read preference
       if opts[:read_secondary]
         warn ":read_secondary options has now been deprecated and will " +
           "be removed in driver v2.0. Use the :read option instead."
         @read_secondary = opts.fetch(:read_secondary, false)
-        @read = :secondary
+        @read = :secondary_preferred
       else
         @read = opts.fetch(:read, :primary)
         Mongo::Support.validate_read_preference(@read)
       end
 
+      @tag_sets = opts.fetch(:tag_sets, [])
+      @acceptable_latency = opts.fetch(:secondary_acceptable_latency_ms, 15)
+
       # Replica set name
       if opts[:rs_name]
         warn ":rs_name option has been deprecated and will be removed in v2.0. " +
@@ -540,24 +478,6 @@ module Mongo
 
       super opts
     end
-
-    # Checkout a socket connected to a node with one of
-    # the provided tags. If no such node exists, raise
-    # an exception.
-    #
-    # NOTE: will be available in driver release v2.0.
-    def checkout_tagged(tags)
-      tags.each do |k, v|
-        pool = self.tag_map[{k.to_s => v}]
-        if pool
-          socket = pool.checkout
-          return socket
-        end
-      end
-
-      raise NodeWithTagsNotFound,
-        "Could not find a connection tagged with #{tags}."
-    end
     
     def prune_managers
       @old_managers.each do |manager|
@@ -574,8 +494,9 @@ module Mongo
     def sync_refresh
       if @refresh_mode == :sync &&
         ((Time.now - @last_refresh) > @refresh_interval)
+
         @last_refresh = Time.now
-        
+
         if @refresh_mutex.try_lock
           begin
             refresh