mongo 1.8.0 → 1.8.2

data/lib/mongo/util/pool.rb

@@ -1,5 +1,3 @@
-# encoding: UTF-8
-
 # --
 # Copyright (C) 2008-2012 10gen Inc.
 #
@@ -19,7 +17,7 @@ module Mongo
   class Pool
     PING_ATTEMPTS  = 6
     MAX_PING_TIME  = 1_000_000
-    PRUNE_INTERVAL = 10_000
+    include ThreadLocalVariableManager
 
     attr_accessor :host,
                   :port,
@@ -58,12 +56,10 @@ module Mongo
       @socket_ops = Hash.new { |h, k| h[k] = [] }
 
       @sockets            = []
-      @pids               = {}
       @checked_out        = []
       @ping_time          = nil
       @last_ping          = nil
       @closed             = false
-      @threads_to_sockets = {}
       @checkout_counter   = 0
     end
 
@@ -205,9 +201,9 @@ module Mongo
       @client.apply_saved_authentication(:socket => socket)
 
       @sockets << socket
-      @pids[socket] = Process.pid
       @checked_out << socket
-      @threads_to_sockets[Thread.current] = socket
+
+      thread_local[:sockets][self.object_id] = socket
       socket
     end
 
@@ -249,8 +245,7 @@ module Mongo
         socket = (@sockets - @checked_out).first
       end
 
-      if @pids[socket] != Process.pid
-        @pids[socket] = nil
+      if socket.pid != Process.pid
         @sockets.delete(socket)
         if socket
           socket.close unless socket.closed?
@@ -258,19 +253,11 @@ module Mongo
         checkout_new_socket
       else
         @checked_out << socket
-        @threads_to_sockets[Thread.current] = socket
+        thread_local[:sockets][self.object_id] = socket
         socket
       end
     end
 
-    def prune_thread_socket_hash
-      current_threads = Set[*Thread.list]
-
-      @threads_to_sockets.delete_if do |thread, socket|
-        !current_threads.include?(thread)
-      end
-    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.
@@ -278,32 +265,16 @@ module Mongo
       @client.connect if !@client.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
-          if @checkout_counter > PRUNE_INTERVAL
-            @checkout_counter = 0
-            prune_thread_socket_hash
-          else
-            @checkout_counter += 1
-          end
-
-          if socket_for_thread = @threads_to_sockets[Thread.current]
+          if socket_for_thread = thread_local[:sockets][self.object_id]
             if !@checked_out.include?(socket_for_thread)
               socket = checkout_existing_socket(socket_for_thread)
             end
-          else # First checkout for this thread
-            thread_length = @threads_to_sockets.keys.length
-            if (thread_length <= @sockets.size) && (@sockets.size < @size)
+          else
+            if @sockets.size < @size
               socket = checkout_new_socket
             elsif @checked_out.size < @sockets.size
               socket = checkout_existing_socket
-            elsif @sockets.size < @size
-              socket = checkout_new_socket
             end
           end
 
@@ -318,12 +289,7 @@ module Mongo
             if socket.closed?
               @checked_out.delete(socket)
               @sockets.delete(socket)
-              @threads_to_sockets.each do |k,v|
-                if v == socket
-                  @threads_to_sockets.delete(k)
-                end
-              end
-
+              thread_local[:sockets].delete self.object_id
               socket = checkout_new_socket
             end
 
@@ -333,6 +299,12 @@ module Mongo
             @queue.wait(@connection_mutex)
           end
         end
+
+        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
       end
     end
 

data/lib/mongo/util/pool_manager.rb

@@ -1,12 +1,12 @@
 module Mongo
   class PoolManager
+    include Mongo::ReadPreference
+    include ThreadLocalVariableManager
 
     attr_reader :client, :arbiters, :primary, :secondaries, :primary_pool,
       :secondary_pool, :secondary_pools, :hosts, :nodes, :members, :seeds,
       :max_bson_size
 
-    attr_accessor :pinned_pools
-
     # Create a new set of connection pools.
     #
     # The pool manager will by default use the original seed list passed
@@ -15,7 +15,6 @@ module Mongo
     # time. The union of these lists will be used when attempting to connect,
     # with the newly-discovered nodes being used first.
     def initialize(client, seeds=[])
-      @pinned_pools         = {}
       @client               = client
       @seeds                = seeds
       @previously_connected = false
@@ -49,8 +48,8 @@ module Mongo
         return
       end
 
-      config = seed.set_config
-      if !config
+      config = seed.config
+      if config
         @refresh_required = true
         seed.close
         return
@@ -99,30 +98,16 @@ module Mongo
       read_pool.host_port
     end
 
-    def read_pool(mode=@client.read_preference,
+    def read_pool(mode=@client.read,
                   tags=@client.tag_sets,
                   acceptable_latency=@client.acceptable_latency)
 
-      if mode == :primary && !tags.empty?
-        raise MongoArgumentError, "Read preferecy :primary cannot be combined with tags"
-      end
+      pinned = thread_local[:pinned_pools][self.object_id]
 
-      pinned = @pinned_pools[Thread.current]
       if pinned && pinned.matches_mode(mode) && pinned.matches_tag_sets(tags) && pinned.up?
         pool = pinned
       else
-        pool = case mode
-        when :primary
-          @primary_pool
-        when :primary_preferred
-          @primary_pool || select_pool(@secondary_pools, tags, acceptable_latency)
-        when :secondary
-          select_pool(@secondary_pools, tags, acceptable_latency)
-        when :secondary_preferred
-          select_pool(@secondary_pools, tags, acceptable_latency) || @primary_pool
-        when :nearest
-          select_pool(pools, tags, acceptable_latency)
-        end
+        pool = select_pool(mode, tags, acceptable_latency)
       end
 
       unless pool
@@ -140,8 +125,8 @@ module Mongo
     private
 
     def validate_existing_member(member)
-      config = member.set_config
-      if !config
+      config = member.config
+      if config
         return false
       else
         if member.primary?
@@ -165,13 +150,12 @@ module Mongo
       @read             = nil
       @read_pool        = nil
       @arbiters         = []
-      @secondaries      = []
+      @secondaries      = Set.new
       @secondary_pool   = nil
       @secondary_pools  = []
       @hosts            = Set.new
       @members          = Set.new
       @refresh_required = false
-      @pinned_pools     = {}
     end
 
     # Connect to each member of the replica set
@@ -184,9 +168,8 @@ module Mongo
 
       seed.node_list.each do |host|
         node = Mongo::Node.new(self.client, host)
-        if node.connect && node.set_config && node.healthy?
-          members << node
-        end
+        node.connect
+        members << node if node.healthy?
       end
       seed.close
 
@@ -201,10 +184,10 @@ module Mongo
     def initialize_pools(members)
       members.each do |member|
         @hosts << member.host_string
-
         if member.primary?
           assign_primary(member)
-        elsif member.secondary? && !@secondaries.include?(member.host_port)
+        elsif member.secondary?
+          # member could be not primary but secondary still is false
           assign_secondary(member)
         end
       end
@@ -235,33 +218,6 @@ module Mongo
       @secondary_pools << pool
     end
 
-    def select_pool(candidates, tag_sets, acceptable_latency)
-      tag_sets = [tag_sets] unless tag_sets.is_a?(Array)
-
-      if !tag_sets.empty?
-        matches = []
-        tag_sets.detect do |tag_set|
-          matches = candidates.select do |candidate|
-            tag_set.none? { |k,v| candidate.tags[k.to_s] != v } &&
-            candidate.ping_time
-          end
-          !matches.empty?
-        end
-      else
-        matches = candidates
-      end
-
-      matches.empty? ? nil : near_pool(matches, acceptable_latency)
-    end
-
-    def near_pool(pool_set, acceptable_latency)
-      nearest_pool = pool_set.min_by { |pool| pool.ping_time }
-      near_pools = pool_set.select do |pool|
-        (pool.ping_time - nearest_pool.ping_time) <= acceptable_latency
-      end
-      near_pools[ rand(near_pools.length) ]
-    end
-
     # Iterate through the list of provided seed
     # nodes until we've gotten a response from the
     # replica set we're trying to connect to.
@@ -270,13 +226,8 @@ module Mongo
     def get_valid_seed_node
       @seeds.each do |seed|
         node = Mongo::Node.new(self.client, seed)
-        if !node.connect
-          next
-        elsif node.set_config && node.healthy?
-          return node
-        else
-          node.close
-        end
+        node.connect
+        return node if node.healthy?
       end
 
       raise ConnectionFailure, "Cannot connect to a replica set using seeds " +

data/lib/mongo/util/read_preference.rb

@@ -0,0 +1,82 @@
+module Mongo
+  module ReadPreference
+    READ_PREFERENCES = [
+      :primary,
+      :primary_preferred,
+      :secondary,
+      :secondary_preferred,
+      :nearest
+    ]
+
+    MONGOS_MODES = {
+      :primary              => :primary,
+      :primary_preferred    => :primaryPreferred,
+      :secondary            => :secondary,
+      :secondary_preferred  => :secondaryPreferred,
+      :nearest              => :nearest
+    }
+
+    def self.mongos(mode, tag_sets)
+      if mode != :secondary_preferred || !tag_sets.empty?
+        mongos_read_preference = BSON::OrderedHash[:mode => MONGOS_MODES[mode]]
+        mongos_read_preference[:tags] = tag_sets if !tag_sets.empty?
+      end
+      mongos_read_preference
+    end
+
+    def self.validate(value)
+      if READ_PREFERENCES.include?(value)
+        return true
+      else
+        raise MongoArgumentError, "#{value} is not a valid read preference. " +
+          "Please specify one of the following read preferences as a symbol: #{READ_PREFERENCES}"
+      end
+    end
+
+    def select_pool(mode, tags, latency)
+      if mode == :primary && !tags.empty?
+        raise MongoArgumentError, "Read preferecy :primary cannot be combined with tags"
+      end
+
+      case mode
+        when :primary
+          primary_pool
+        when :primary_preferred
+          primary_pool || select_secondary_pool(secondary_pools, tags, latency)
+        when :secondary
+          select_secondary_pool(secondary_pools, tags, latency)
+        when :secondary_preferred
+          select_secondary_pool(secondary_pools, tags, latency) || primary_pool
+        when :nearest
+          select_secondary_pool(pools, tags, latency)
+      end
+    end
+
+    def select_secondary_pool(candidates, tag_sets, latency)
+      tag_sets = [tag_sets] unless tag_sets.is_a?(Array)
+
+      if !tag_sets.empty?
+        matches = []
+        tag_sets.detect do |tag_set|
+          matches = candidates.select do |candidate|
+            tag_set.none? { |k,v| candidate.tags[k.to_s] != v } &&
+            candidate.ping_time
+          end
+          !matches.empty?
+        end
+      else
+        matches = candidates
+      end
+
+      matches.empty? ? nil : select_near_pool(matches, latency)
+    end
+
+    def select_near_pool(candidates, latency)
+      nearest_pool = candidates.min_by { |candidate| candidate.ping_time }
+      near_pools = candidates.select do |candidate|
+        (candidate.ping_time - nearest_pool.ping_time) <= latency
+      end
+      near_pools[ rand(near_pools.length) ]
+    end
+  end
+end

data/lib/mongo/util/sharding_pool_manager.rb

@@ -1,42 +1,5 @@
 
 module Mongo
-  module ShardingNode
-    def set_config
-      begin
-        @config = @client['admin'].command({:ismaster => 1}, :socket => @socket)
-
-        # warning: instance variable @logger not initialized
-        #if @config['msg'] && @logger
-        #  @client.log(:warn, "#{config['msg']}")
-        #end
-
-      rescue ConnectionFailure, OperationFailure, OperationTimeout, SocketError, SystemCallError, IOError => ex
-        @client.log(:warn, "Attempted connection to node #{host_string} raised " +
-            "#{ex.class}: #{ex.message}")
-
-        # Socket may already be nil from issuing command
-        if @socket && !@socket.closed?
-          @socket.close
-        end
-
-        return nil
-      end
-
-      @config
-    end
-
-    # Return a list of sharded cluster nodes from the config - currently just the current node.
-    def node_list
-      connect unless connected?
-      set_config unless @config
-
-      return [] unless config
-
-      ["#{@host}:#{@port}"]
-    end
-
-  end
-
   class ShardingPoolManager < PoolManager
 
     attr_reader :client, :primary, :primary_pool, :hosts, :nodes,
@@ -90,54 +53,5 @@ module Mongo
         @refresh_required = true
       end
     end
-
-    private
-
-    # Connect to each member of the sharded cluster
-    # as reported by the given seed node, and return
-    # as a list of Mongo::Node objects.
-    def connect_to_members
-      members = []
-
-      seed = get_valid_seed_node
-
-      seed.node_list.each do |host|
-        node = Mongo::Node.new(self.client, host)
-        node.extend ShardingNode
-        if node.connect && node.set_config
-          members << node
-        end
-      end
-      seed.close
-
-      if members.empty?
-        raise ConnectionFailure, "Failed to connect to any given member."
-      end
-
-      members
-    end
-
-    # Iterate through the list of provided seed
-    # nodes until we've gotten a response from the
-    # sharded cluster we're trying to connect to.
-    #
-    # If we don't get a response, raise an exception.
-    def get_valid_seed_node
-      @seeds.each do |seed|
-        node = Mongo::Node.new(self.client, seed)
-        node.extend ShardingNode
-        if !node.connect
-          next
-        elsif node.set_config && node.healthy?
-          return node
-        else
-          node.close
-        end
-      end
-
-      raise ConnectionFailure, "Cannot connect to a sharded cluster using seeds " +
-          "#{@seeds.map {|s| "#{s[0]}:#{s[1]}" }.join(', ')}"
-    end
-
   end
 end