mongo 1.4.0 → 1.5.0.rc0

data/lib/mongo/util/core_ext.rb

@@ -58,3 +58,48 @@ class String
   end
 
 end
+
+#:nodoc:
+class Class
+  def mongo_thread_local_accessor name, options = {}
+    m = Module.new
+    m.module_eval do
+      class_variable_set :"@@#{name}", Hash.new {|h,k| h[k] = options[:default] }
+    end
+    m.module_eval %{
+
+      def #{name}
+        @@#{name}[Thread.current.object_id]
+      end
+
+      def #{name}=(val)
+        @@#{name}[Thread.current.object_id] = val
+      end
+    }
+
+    class_eval do
+      include m
+      extend m
+    end
+  end
+end
+
+# Fix a bug in the interaction of
+# mutexes and timeouts in Ruby 1.9.
+# See https://jira.mongodb.org/browse/RUBY-364 for details.
+if RUBY_VERSION > '1.9'
+  class Mutex
+    def lock_with_hack
+      lock_without_hack
+      rescue ThreadError => e
+      if e.message != "deadlock; recursive locking"
+        raise
+      else
+        unlock
+        lock_without_hack
+      end
+    end
+      alias_method :lock_without_hack, :lock
+      alias_method :lock, :lock_with_hack
+  end
+end

data/lib/mongo/util/logging.rb

@@ -1,6 +1,11 @@
 module Mongo
   module Logging
 
+    def write_logging_startup_message
+      log(:warn, "Please note that logging negatively impacts client-side performance. " +
+      "You should set your logging level no lower than :info in production.")
+    end
+
     # Log a message with the given level.
     def log(level, msg)
       return unless @logger

data/lib/mongo/util/node.rb

@@ -1,7 +1,8 @@
 module Mongo
   class Node
 
-    attr_accessor :host, :port, :address, :config, :connection, :socket
+    attr_accessor :host, :port, :address, :config, :connection, :socket,
+      :last_state
 
     def initialize(connection, data)
       @connection = connection
@@ -13,6 +14,7 @@ module Mongo
       end
       @address = "#{host}:#{port}"
       @config = nil
+      @socket = nil
     end
 
     def eql?(other)
@@ -57,11 +59,11 @@ module Mongo
     end
 
     def close
-      if @socket
+      if @socket && !@socket.closed?
         @socket.close
-        @socket = nil
-        @config = nil
       end
+      @socket = nil
+      @config = nil
     end
 
     def connected?

data/lib/mongo/util/pool.rb

@@ -17,12 +17,13 @@
 
 module Mongo
   class Pool
-    PING_ATTEMPTS = 6
+    PING_ATTEMPTS  = 6
+    MAX_PING_TIME  = 1_000_000
 
-    attr_accessor :host, :port, :size, :timeout, :safe, :checked_out, :connection
+    attr_accessor :host, :port, :address,
+      :size, :timeout, :safe, :checked_out, :connection
 
     # Create a new pool of connections.
-    #
     def initialize(connection, host, port, opts={})
       @connection  = connection
 
@@ -31,8 +32,11 @@ module Mongo
       # A Mongo::Node object.
       @node = opts[:node]
 
+      # The string address
+      @address = "#{@host}:#{@port}"
+
       # Pool size and timeout.
-      @size      = opts[:size] || 1
+      @size      = opts[:size] || 10000
       @timeout   = opts[:timeout]   || 5.0
 
       # Mutex for synchronizing pool access
@@ -47,26 +51,42 @@ module Mongo
       @sockets      = []
       @pids         = {}
       @checked_out  = []
+      @threads      = {}
       @ping_time    = nil
       @last_ping    = nil
+      @closed       = false
+      @last_pruning = Time.now
     end
 
-    def close
+    # Close this pool.
+    #
+    # @option opts [Boolean] :soft (false) If true,
+    #   close only those sockets that are not checked out.
+    def close(opts={})
       @connection_mutex.synchronize do
-        @sockets.each do |sock|
+        if opts[:soft]
+          sockets_to_close = @sockets - @checked_out
+        else
+          sockets_to_close = @sockets
+        end
+        sockets_to_close.each do |sock|
           begin
-            sock.close
+            sock.close unless sock.closed?
           rescue IOError => ex
             warn "IOError when attempting to close socket connected to #{@host}:#{@port}: #{ex.inspect}"
           end
         end
-        @host = @port = nil
         @sockets.clear
         @pids.clear
         @checked_out.clear
+        @closed = true
       end
     end
 
+    def closed?
+      @closed
+    end
+
     def inspect
       "#<Mongo::Pool:0x#{self.object_id.to_s(16)} @host=#{@host} @port=#{port} " +
         "@ping_time=#{@ping_time} #{@checked_out.size}/#{@size} sockets available.>"
@@ -98,14 +118,12 @@ module Mongo
     # to do a round-trip against this node.
     def refresh_ping_time
       trials = []
-      begin
-         PING_ATTEMPTS.times do
-           t1 = Time.now
-           self.connection['admin'].command({:ping => 1}, :socket => @node.socket)
-           trials << (Time.now - t1) * 1000
-         end
-       rescue OperationFailure, SocketError, SystemCallError, IOError => ex
-         return nil
+      PING_ATTEMPTS.times do
+        t1 = Time.now
+        if !self.ping
+          return MAX_PING_TIME
+        end
+        trials << (Time.now - t1) * 1000
       end
 
       trials.sort!
@@ -120,11 +138,22 @@ module Mongo
       (total / trials.length).ceil
     end
 
+    def ping
+      begin
+        return self.connection['admin'].command({:ping => 1}, :socket => @node.socket)
+      rescue OperationFailure, SocketError, SystemCallError, IOError => ex
+        return false
+      end
+    end
+
     # Return a socket to the pool.
     def checkin(socket)
       @connection_mutex.synchronize do
-        @checked_out.delete(socket)
-        @queue.signal
+        if @checked_out.delete(socket)
+          @queue.signal
+        else
+          return false
+        end
       end
       true
     end
@@ -150,6 +179,7 @@ module Mongo
       @sockets << socket
       @pids[socket] = Process.pid
       @checked_out << socket
+      @threads[socket] = Thread.current.object_id
       socket
     end
 
@@ -195,10 +225,26 @@ module Mongo
          checkout_new_socket
       else
         @checked_out << socket
+        @threads[socket] = Thread.current.object_id
         socket
       end
     end
 
+    # If we have more sockets than the soft limit specified
+    # by the max pool size, then we should prune those
+    # extraneous sockets.
+    #
+    # Note: this must be called from within a mutex.
+    def prune
+      surplus = @size - @sockets.size
+      return if surplus <= 0
+      idle_sockets = @sockets - @checked_out
+      [surplus, idle_sockets.length].min.times do |n|
+        idle_sockets[n].close
+        @sockets.delete(idle_sockets[n])
+      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.
@@ -213,20 +259,21 @@ module Mongo
         end
 
         @connection_mutex.synchronize do
+          #prune
+
           socket = if @checked_out.size < @sockets.size
                      checkout_existing_socket
-                   elsif @sockets.size < @size
+                   else
                      checkout_new_socket
                    end
 
           if socket
-
-          # This calls all procs, in order, scoped to existing sockets.
-          # At the moment, we use this to lazily authenticate and
-          # logout existing socket connections.
-          @socket_ops[socket].reject! do |op|
-            op.call
-          end
+            # This calls all procs, in order, scoped to existing sockets.
+            # At the moment, we use this to lazily authenticate and
+            # logout existing socket connections.
+            @socket_ops[socket].reject! do |op|
+              op.call
+            end
 
             return socket
           else

data/lib/mongo/util/pool_manager.rb

@@ -3,13 +3,13 @@ module Mongo
 
     attr_reader :connection, :seeds, :arbiters, :primary, :secondaries,
       :primary_pool, :read_pool, :secondary_pools, :hosts, :nodes, :max_bson_size,
-      :tags_to_pools, :members
+      :tags_to_pools, :tag_map, :members
 
     def initialize(connection, seeds)
       @connection = connection
       @seeds = seeds
-      @refresh_node = nil
       @previously_connected = false
+      @refresh_required = false
     end
 
     def inspect
@@ -25,28 +25,69 @@ module Mongo
       members = connect_to_members
       initialize_pools(members)
       update_seed_list(members)
+      set_read_pool
+      set_tag_mappings
 
       @members = members
       @previously_connected = true
     end
 
-    def healthy?
-      if !@refresh_node || !refresh_node.set_config
-        return false
+    # We're healthy if all members are pingable and if the view
+    # of the replica set returned by isMaster is equivalent
+    # to our view. If any of these isn't the case,
+    # set @refresh_require to true, and return.
+    def check_connection_health
+      begin
+        seed = get_valid_seed_node
+      rescue ConnectionFailure
+        @refresh_required = true
+        return
+      end
+
+      config = seed.set_config
+      if !config
+        @refresh_required = true
+        seed.close
+        return
+      end
+
+      if config['hosts'].length != @members.length
+        @refresh_required = true
+        seed.close
+        return
       end
 
-      #if refresh_node.node_list
+      config['hosts'].each do |host|
+        member = @members.detect do |m|
+          m.address == host
+        end
+
+        if member && validate_existing_member(member)
+          next
+        else
+          @refresh_required = true
+          seed.close
+          return false
+        end
+      end
+
+      seed.close
+    end
+
+    # The replica set connection should initiate a full refresh.
+    def refresh_required?
+      @refresh_required
     end
 
-    def close
+    def close(opts={})
       begin
         if @primary_pool
-          @primary_pool.close
+          @primary_pool.close(opts)
         end
 
         if @secondary_pools
           @secondary_pools.each do |pool|
-            pool.close
+            pool.close(opts)
           end
         end
 
@@ -62,6 +103,26 @@ module Mongo
 
     private
 
+    def validate_existing_member(member)
+      config = member.set_config
+      if !config
+        return false
+      else
+        if member.primary?
+          if member.last_state == :primary
+            return true
+          else # This node is now primary, but didn't used to be.
+            return false
+          end
+        elsif member.last_state == :secondary &&
+          member.secondary?
+          return true
+        else # This node isn't what it used to be.
+          return false
+        end
+      end
+    end
+
     def initialize_data
       @primary = nil
       @primary_pool = nil
@@ -72,6 +133,7 @@ module Mongo
       @hosts = Set.new
       @members = Set.new
       @tags_to_pools = {}
+      @tag_map = {}
     end
 
     # Connect to each member of the replica set
@@ -110,40 +172,46 @@ module Mongo
         @hosts << member.host_string
 
         if member.primary?
-          @primary = member.host_port
-          @primary_pool = Pool.new(self.connection, member.host, member.port,
-                                  :size => self.connection.pool_size,
-                                  :timeout => self.connection.connect_timeout,
-                                  :node => member)
-          associate_tags_with_pool(member.tags, @primary_pool)
+          assign_primary(member)
         elsif member.secondary? && !@secondaries.include?(member.host_port)
-          @secondaries << member.host_port
-          pool = Pool.new(self.connection, member.host, member.port,
-                                       :size => self.connection.pool_size,
-                                       :timeout => self.connection.connect_timeout,
-                                       :node => member)
-          @secondary_pools << pool
-          associate_tags_with_pool(member.tags, pool)
+          assign_secondary(member)
         end
       end
 
-
       @max_bson_size = members.first.config['maxBsonObjectSize'] ||
         Mongo::DEFAULT_MAX_BSON_SIZE
       @arbiters = members.first.arbiters
+    end
 
-      set_read_pool
-      set_primary_tag_pools
+    def assign_primary(member)
+      member.last_state = :primary
+      @primary = member.host_port
+      @primary_pool = Pool.new(self.connection, member.host, member.port,
+                              :size => self.connection.pool_size,
+                              :timeout => self.connection.pool_timeout,
+                              :node => member)
+      associate_tags_with_pool(member.tags, @primary_pool)
+    end
+
+    def assign_secondary(member)
+      member.last_state = :secondary
+      @secondaries << member.host_port
+      pool = Pool.new(self.connection, member.host, member.port,
+                                   :size => self.connection.pool_size,
+                                   :timeout => self.connection.pool_timeout,
+                                   :node => member)
+      @secondary_pools << pool
+      associate_tags_with_pool(member.tags, pool)
     end
 
     # If there's more than one pool associated with
     # a given tag, choose a close one using the bucket method.
-    def set_primary_tag_pools
-      @tags_to_pools.each do |k, pool_list|
+    def set_tag_mappings
+      @tags_to_pools.each do |key, pool_list|
         if pool_list.length == 1
-          @tags_to_pools[k] = pool_list.first
+          @tag_map[key] = pool_list.first
         else
-          @tags_to_pools[k] = nearby_pool_from_set(pool_list)
+          @tag_map[key] = nearby_pool_from_set(pool_list)
         end
       end
     end
@@ -189,7 +257,9 @@ module Mongo
     def get_valid_seed_node
       @seeds.each do |seed|
         node = Mongo::Node.new(self.connection, seed)
-        if node.connect && node.set_config
+        if !node.connect
+          next
+        elsif node.set_config
           return node
         else
           node.close