mongo 1.6.1 → 1.6.2

data/lib/mongo.rb

@@ -78,6 +78,3 @@ if RUBY_PLATFORM =~ /java/
   require 'mongo/gridfs/grid_io_fix'
 end
 require 'mongo/gridfs/grid_file_system'
-
-require 'timeout'
-Mongo::TimeoutHandler = Timeout

data/lib/mongo/collection.rb

@@ -961,7 +961,7 @@ module Mongo
             begin
               message.put_binary(BSON::BSON_CODER.serialize(doc, check_keys, true, @connection.max_bson_size).to_s)
               true
-            rescue StandardError => e  # StandardError will be replaced with BSONError
+            rescue StandardError # StandardError will be replaced with BSONError
               doc.delete(:_id)
               error_docs << doc
               false

data/lib/mongo/connection.rb

@@ -26,7 +26,7 @@ module Mongo
     include Mongo::Logging
     include Mongo::Networking
 
-    TCPSocket = ::TCPSocket
+    TCPSocket = Mongo::TCPSocket
     Mutex = ::Mutex
     ConditionVariable = ::ConditionVariable
 
@@ -67,7 +67,7 @@ module Mongo
     #   logging negatively impacts performance; therefore, it should not be used for high-performance apps.
     # @option opts [Integer] :pool_size (1) The maximum number of socket self.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 self.connections a pool are checked out,
+    # @option opts [Float] :timeout (5.0) When all of the self.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).
     # @option opts [Float] :op_timeout (nil) The number of seconds to wait for a read operation to time out.
@@ -480,6 +480,12 @@ module Mongo
       @max_bson_size
     end
 
+    # Prefer primary pool but fall back to secondary
+    def checkout_best
+      connect unless connected?
+      @primary_pool.checkout
+    end
+
     # Checkout a socket for reading (i.e., a secondary node).
     # Note: this is overridden in ReplSetConnection.
     def checkout_reader
@@ -513,6 +519,19 @@ module Mongo
       end
     end
 
+    # Excecutes block with the best available socket
+    def best_available_socket
+      socket = nil
+      begin
+        socket = checkout_best
+        yield socket
+      ensure
+        if socket
+          socket.pool.checkin(socket)
+        end
+      end
+    end
+
     protected
 
     def valid_opts
@@ -603,27 +622,16 @@ module Mongo
         socket = nil
         config = nil
 
-        if @connect_timeout
-          Mongo::TimeoutHandler.timeout(@connect_timeout, OperationTimeout) do
-            socket = @socket_class.new(host, port)
-            socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
-          end
-        else
-          socket = @socket_class.new(host, port)
-          socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
-        end
+        socket = @socket_class.new(host, port, @op_timeout, @connect_timeout)
+        socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
 
-        if @connect_timeout
-          Mongo::TimeoutHandler.timeout(@connect_timeout, OperationTimeout) do
-            config = self['admin'].command({:ismaster => 1}, :socket => socket)
-          end
-        else
-          config = self['admin'].command({:ismaster => 1}, :socket => socket)
-        end
-      rescue OperationFailure, SocketError, SystemCallError, IOError => ex
+        config = self['admin'].command({:ismaster => 1}, :socket => socket)
+      rescue OperationFailure, SocketError, SystemCallError, IOError
         close
       ensure
-        socket.close if socket
+        if socket
+          socket.close unless socket.closed?
+        end
       end
 
       config

data/lib/mongo/db.rb

@@ -17,7 +17,6 @@
 # ++
 
 require 'socket'
-require 'timeout'
 require 'thread'
 
 module Mongo
@@ -111,10 +110,13 @@ module Mongo
         if !save_auth
           raise MongoArgumentError, "If using connection pooling, :save_auth must be set to true."
         end
-        @connection.authenticate_pools
       end
 
-      issue_authentication(username, password, save_auth)
+      @connection.best_available_socket do |socket|
+        issue_authentication(username, password, save_auth, :socket => socket)
+      end
+
+      @connection.authenticate_pools
     end
 
     def issue_authentication(username, password, save_auth=true, opts={})

data/lib/mongo/exceptions.rb

@@ -71,7 +71,7 @@ module Mongo
   class OperationFailure < MongoDBError; end
 
   # Raised when a socket read operation times out.
-  class OperationTimeout < ::Timeout::Error; end
+  class OperationTimeout < SocketError; end
 
   # Raised when a client attempts to perform an invalid operation.
   class InvalidOperation < MongoDBError; end

data/lib/mongo/gridfs/grid_file_system.rb

@@ -115,7 +115,7 @@ module Mongo
         id = file.close
         if versions
           self.delete do
-            @files.find({'filename' => filename, '_id' => {'$ne' => id}}, :fields => ['_id'], :sort => ['uploadDate', -1], :skip => (versions -1))
+            @files.find({'filename' => filename, '_id' => {'$ne' => id}}, :fields => ['_id'], :sort => ['uploadDate', -1], :skip => (versions - 1))
           end
         end
       end

data/lib/mongo/networking.rb

@@ -186,7 +186,10 @@ module Mongo
 
     def receive_header(sock, expected_response, exhaust=false)
       header = receive_message_on_socket(16, sock)
-      size, request_id, response_to = header.unpack('VVV')
+
+      # 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
@@ -204,7 +207,10 @@ module Mongo
         raise "Short read for DB response header; " +
           "expected #{RESPONSE_HEADER_SIZE} bytes, saw #{header_buf.length}"
       end
-      flags, cursor_id_a, cursor_id_b, starting_from, number_remaining = header_buf.unpack('VVVVV')
+
+      # unpacks to flags, cursor_id_a, cursor_id_b, starting_from, number_remaining
+      flags, cursor_id_a, cursor_id_b, _, number_remaining = header_buf.unpack('VVVVV')
+      
       check_response_flags(flags)
       cursor_id = (cursor_id_b << 32) + cursor_id_a
       [number_remaining, cursor_id]
@@ -294,11 +300,11 @@ module Mongo
     # @return [Integer] number of bytes sent
     def send_message_on_socket(packed_message, socket)
       begin
-      total_bytes_sent = socket.send(packed_message, 0)
+      total_bytes_sent = socket.send(packed_message)
       if total_bytes_sent != packed_message.size
         packed_message.slice!(0, total_bytes_sent)
         while packed_message.size > 0
-          byte_sent = socket.send(packed_message, 0)
+          byte_sent = socket.send(packed_message)
           total_bytes_sent += byte_sent
           packed_message.slice!(0, byte_sent)
         end
@@ -314,22 +320,15 @@ module Mongo
     # Requires length and an available socket.
     def receive_message_on_socket(length, socket)
       begin
-        if @op_timeout
-          message = nil
-          Mongo::TimeoutHandler.timeout(@op_timeout, OperationTimeout) do
-            message = receive_data(length, socket)
-          end
-        else
           message = receive_data(length, socket)
-        end
-        rescue => ex
-          close
+      rescue OperationTimeout, ConnectionFailure => ex
+        close
 
-          if ex.class == OperationTimeout
-            raise OperationTimeout, "Timed out waiting on socket read."
-          else
-            raise ConnectionFailure, "Operation failed with the following exception: #{ex}"
-          end
+        if ex.class == OperationTimeout
+          raise OperationTimeout, "Timed out waiting on socket read."
+        else
+          raise ConnectionFailure, "Operation failed with the following exception: #{ex}"
+        end
       end
       message
     end
@@ -337,6 +336,7 @@ module Mongo
     def receive_data(length, socket)
       message = new_binary_string
       socket.read(length, message)
+ 
       raise ConnectionFailure, "connection closed" unless message && message.length > 0
       if message.length < length
         chunk = new_binary_string

data/lib/mongo/repl_set_connection.rb

@@ -287,14 +287,18 @@ module Mongo
     end
 
     def authenticate_pools
-      primary_pool.authenticate_existing
+      if primary_pool
+        primary_pool.authenticate_existing
+      end
       secondary_pools.each do |pool|
         pool.authenticate_existing
       end
     end
 
     def logout_pools(db)
-      primary_pool.logout_existing(db)
+      if primary_pool
+        primary_pool.logout_existing(db)
+      end
       secondary_pools.each do |pool|
         pool.logout_existing(db)
       end
@@ -323,6 +327,19 @@ module Mongo
         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
+    end
     
     # Checkout a socket for reading (i.e., a secondary node).
     # Note that @read_pool might point to the primary pool
@@ -459,7 +476,11 @@ module Mongo
 
       # Refresh
       @refresh_mode = opts.fetch(:refresh_mode, false)
-      @refresh_interval = opts[:refresh_interval] || 90
+      @refresh_interval = opts.fetch(:refresh_interval, 90)
+
+      if @refresh_mode && @refresh_interval < 60
+        @refresh_interval = 60 unless ENV['TEST_MODE'] = 'TRUE'
+      end
 
       if @refresh_mode == :async
         warn ":async refresh mode has been deprecated. Refresh

data/lib/mongo/util/node.rb

@@ -36,20 +36,16 @@ module Mongo
     def connect
       begin
         socket = nil
-        if @connection.connect_timeout
-          Mongo::TimeoutHandler.timeout(@connection.connect_timeout, OperationTimeout) do
-            socket = @connection.socket_class.new(@host, @port)
-          end
-        else
-          socket = @connection.socket_class.new(@host, @port)
-        end
+        socket = @connection.socket_class.new(@host, @port, 
+          @connection.op_timeout, @connection.connect_timeout
+        )
 
         if socket.nil?
           return nil
         else
           socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
         end
-      rescue OperationTimeout, OperationFailure, SocketError, SystemCallError, IOError => ex
+      rescue OperationTimeout, ConnectionFailure, OperationFailure, SocketError, SystemCallError, IOError => ex
         @connection.log(:debug, "Failed connection to #{host_string} with #{ex.class}, #{ex.message}.")
         socket.close if socket
         return nil
@@ -74,7 +70,7 @@ module Mongo
       begin
         result = @connection['admin'].command({:ping => 1}, :socket => @socket)
         return result['ok'] == 1
-      rescue OperationFailure, SocketError, SystemCallError, IOError => ex
+      rescue OperationFailure, SocketError, SystemCallError, IOError
         return nil
       end
     end
@@ -84,13 +80,7 @@ module Mongo
     # matches with the name provided.
     def set_config
       begin
-        if @connection.connect_timeout
-          Mongo::TimeoutHandler.timeout(@connection.connect_timeout, OperationTimeout) do
-            @config = @connection['admin'].command({:ismaster => 1}, :socket => @socket)
-          end
-        else
-          @config = @connection['admin'].command({:ismaster => 1}, :socket => @socket)
-        end
+        @config = @connection['admin'].command({:ismaster => 1}, :socket => @socket)
 
         if @config['msg'] && @logger
           @connection.log(:warn, "#{config['msg']}")

data/lib/mongo/util/pool.rb

@@ -133,7 +133,7 @@ module Mongo
     def ping
       begin
         return self.connection['admin'].command({:ping => 1}, :socket => @node.socket)
-      rescue OperationFailure, SocketError, SystemCallError, IOError => ex
+      rescue OperationFailure, SocketError, SystemCallError, IOError
         return false
       end
     end
@@ -156,7 +156,7 @@ module Mongo
     # therefore, it runs within a mutex.
     def checkout_new_socket
       begin
-        socket = self.connection.socket_class.new(@host, @port)
+        socket = @connection.socket_class.new(@host, @port, @connection.op_timeout)
         socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
         socket.pool = self
       rescue => ex
@@ -217,7 +217,9 @@ module Mongo
       if @pids[socket] != Process.pid
         @pids[socket] = nil
         @sockets.delete(socket)
-        socket.close if socket
+        if socket
+          socket.close unless socket.closed?
+        end
         checkout_new_socket
       else
         @checked_out << socket
@@ -227,15 +229,10 @@ module Mongo
     end
 
     def prune_thread_socket_hash
-      map = {}
-      Thread.list.each do |t|
-        map[t] = 1
-      end
+      current_threads = Set[*Thread.list]
 
-      @threads_to_sockets.keys.each do |key|
-        if !map[key]
-          @threads_to_sockets.delete(key)
-        end
+      @threads_to_sockets.delete_if do |thread, socket|
+        !current_threads.include?(thread)
       end
     end
 

data/lib/mongo/util/ssl_socket.rb

@@ -1,4 +1,6 @@
+require 'socket'
 require 'openssl'
+require 'timeout'
 
 module Mongo
 
@@ -9,31 +11,51 @@ module Mongo
 
     attr_accessor :pool
 
-    def initialize(host, port)
-      @socket = ::TCPSocket.new(host, port)
+    def initialize(host, port, op_timeout=nil, connect_timeout=nil)
+      @op_timeout = op_timeout
+      @connect_timeout = connect_timeout
+
+      @socket = ::TCPSocket.new(host, port) 
       @ssl = OpenSSL::SSL::SSLSocket.new(@socket)
       @ssl.sync_close = true
-      @ssl.connect
+      
+      connect
     end
 
-    def setsockopt(key, value, n)
-      @socket.setsockopt(key, value, n)
+    def connect
+      if @connect_timeout
+        Timeout::timeout(@connect_timeout, ConnectionTimeoutError) do
+          @ssl.connect
+        end
+      else
+        @ssl.connect
+      end
     end
 
-    # Write to the SSL socket.
-    #
-    # @param buffer a buffer to send.
-    # @param flags socket flags. Because Ruby's SSL
-    def send(buffer, flags=0)
-      @ssl.syswrite(buffer)
+    def send(data)
+      @ssl.syswrite(data)
     end
 
     def read(length, buffer)
-      @ssl.sysread(length, buffer)
+      if @op_timeout
+        Timeout::timeout(@op_timeout, OperationTimeout) do
+          @ssl.sysread(length, buffer)
+        end
+      else
+        @ssl.sysread(length, buffer)
+      end 
+    end
+
+    def setsockopt(key, value, n)
+      @ssl.setsockopt(key, value, n)
     end
 
     def close
       @ssl.close
     end
+
+    def closed?
+      @ssl.closed?
+    end
   end
 end

data/lib/mongo/util/tcp_socket.rb

@@ -1,6 +1,95 @@
+require 'socket'
+
 module Mongo
- class TCPSocket < ::TCPSocket
-   attr_accessor :pool
+  # Wrapper class for Socket
+  #
+  # Emulates TCPSocket with operation and connection timeout
+  # sans Timeout::timeout
+  #
+  class TCPSocket
+    attr_accessor :pool
+
+    def initialize(host, port, op_timeout=nil, connect_timeout=nil)
+      @op_timeout = op_timeout 
+      @connect_timeout = connect_timeout
+
+      # TODO: Prefer ipv6 if server is ipv6 enabled
+      @host = Socket.getaddrinfo(host, nil, Socket::AF_INET).first[3]
+      @port = port
+      @socket_address = Socket.pack_sockaddr_in(@port, @host)
+      @socket = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
+
+      connect
+    end
+
+    def connect
+      # Connect nonblock is broken in current versions of JRuby
+      if RUBY_PLATFORM == 'java'
+        require 'timeout'
+        if @connect_timeout
+          Timeout::timeout(@connect_timeout, OperationTimeout) do
+            @socket.connect(@socket_address)
+          end
+        else
+          @socket.connect(@socket_address)
+        end
+      else
+        # Try to connect for @connect_timeout seconds
+        begin
+          @socket.connect_nonblock(@socket_address)
+        rescue Errno::EINPROGRESS
+          # Block until there is a response or error
+          resp = IO.select([@socket], [@socket], [@socket], @connect_timeout)
+          if resp.nil?
+            raise ConnectionTimeoutError
+          end
+        end
+
+        # If there was a failure this will raise an Error
+        begin
+          @socket.connect_nonblock(@socket_address)
+        rescue Errno::EISCONN
+          # Successfully connected
+        end
+      end
+    end
+
+    def send(data)
+      @socket.write(data)
+    end
+
+    def read(maxlen, buffer)
+      # Block on data to read for @op_timeout seconds
+      begin
+        ready = IO.select([@socket], nil, [@socket], @op_timeout)
+      rescue IOError
+        raise OperationFailure
+      end
+      if ready
+        begin
+          @socket.readpartial(maxlen, buffer)
+        rescue EOFError
+          return ConnectionError
+        rescue Errno::ENOTCONN, Errno::EBADF, Errno::ECONNRESET, Errno::EPIPE
+          raise ConnectionFailure
+        rescue Errno::EINTR, Errno::EIO, IOError 
+          raise OperationFailure 
+        end
+      else
+        raise OperationTimeout
+      end
+    end
+
+    def setsockopt(key, value, n)
+      @socket.setsockopt(key, value, n)
+    end
+
+    def close
+      @socket.close
+    end
 
- end
+    def closed?
+      @socket.closed?
+    end
+  end
 end