mongo 1.6.2 → 1.6.4

data/lib/mongo/gridfs/grid_ext.rb

@@ -33,19 +33,19 @@ module Mongo
       # @example
       #
       #   # Check for the existence of a given filename
-      #   @grid = GridFileSystem.new(@db)
+      #   @grid = Mongo::GridFileSystem.new(@db)
       #   @grid.exist?(:filename => 'foo.txt')
       #
       #   # Check for existence filename and content type
-      #   @grid = GridFileSystem.new(@db)
+      #   @grid = Mongo::GridFileSystem.new(@db)
       #   @grid.exist?(:filename => 'foo.txt', :content_type => 'image/jpg')
       #
       #   # Check for existence by _id
-      #   @grid = Grid.new(@db)
+      #   @grid = Mongo::Grid.new(@db)
       #   @grid.exist?(:_id => BSON::ObjectId.from_string('4bddcd24beffd95a7db9b8c8'))
       #
       #   # Check for existence by an arbitrary attribute.
-      #   @grid = Grid.new(@db)
+      #   @grid = Mongo::Grid.new(@db)
       #   @grid.exist?(:tags => {'$in' => ['nature', 'zen', 'photography']})
       #
       # @return [nil, Hash] either nil for the file's metadata as a hash.

data/lib/mongo/gridfs/grid_file_system.rb

@@ -78,20 +78,20 @@ module Mongo
     # @example
     #
     #  # Store the text "Hello, world!" in the grid file system.
-    #  @grid = GridFileSystem.new(@db)
+    #  @grid = Mongo::GridFileSystem.new(@db)
     #  @grid.open('filename', 'w') do |f|
     #    f.write "Hello, world!"
     #  end
     #
     #  # Output "Hello, world!"
-    #  @grid = GridFileSystem.new(@db)
+    #  @grid = Mongo::GridFileSystem.new(@db)
     #  @grid.open('filename', 'r') do |f|
     #    puts f.read
     #  end
     #
     #  # Write a file on disk to the GridFileSystem
     #  @file = File.open('image.jpg')
-    #  @grid = GridFileSystem.new(@db)
+    #  @grid = Mongo::GridFileSystem.new(@db)
     #  @grid.open('image.jpg, 'w') do |f|
     #    f.write @file
     #  end

data/lib/mongo/gridfs/grid_io.rb

@@ -275,7 +275,7 @@ module Mongo
     end
 
     def save_chunk(chunk)
-      @chunks.insert(chunk)
+      @chunks.save(chunk)
     end
 
     def get_chunk(n)

data/lib/mongo/networking.rb

@@ -140,6 +140,11 @@ module Mongo
       rescue SystemStackError, NoMemoryError, SystemCallError => ex
         close
         raise ex
+      rescue Exception => ex
+        if defined?(IRB)
+          close if ex.class == IRB::Abort
+        end
+        raise ex
       ensure
         if should_checkin
           if command || read == :primary

data/lib/mongo/repl_set_connection.rb

@@ -25,10 +25,12 @@ module Mongo
       :read_secondary, :rs_name, :name]
 
     attr_reader :replica_set_name, :seeds, :refresh_interval, :refresh_mode,
-      :refresh_version
+      :refresh_version, :manager
 
     # Create a connection to a MongoDB replica set.
     #
+    # If no args are provided, it will check <code>ENV["MONGODB_URI"]</code>.
+    #
     # 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
     # Connection#arbiters. This is useful if your application needs to connect manually to nodes other
@@ -68,16 +70,18 @@ module Mongo
     # 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.
-    #   ReplSetConnection.new(['localhost:30000', 'localhost:30001'])
+    #   Mongo::ReplSetConnection.new(['localhost:30000', 'localhost:30001'])
     #
     # @example Connect to a replica set providing two seed nodes and ensuring a connection to the replica set named 'prod':
-    #   ReplSetConnection.new(['localhost:30000', 'localhost:30001'], :name => 'prod')
+    #   Mongo::ReplSetConnection.new(['localhost:30000', 'localhost:30001'], :name => 'prod')
     #
     # @example Connect to a replica set providing two seed nodes and allowing reads from a secondary node:
-    #   ReplSetConnection.new(['localhost:30000', 'localhost:30001'], :read => :secondary)
+    #   Mongo::ReplSetConnection.new(['localhost:30000', 'localhost:30001'], :read => :secondary)
     #
     # @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 [ReplicaSetConnectionError] This is raised if a replica set name is specified and the
     #   driver fails to connect to a replica set with that name.
     def initialize(*args)
@@ -87,21 +91,30 @@ module Mongo
         opts = {}
       end
 
-      unless args.length > 0
+      nodes = args
+
+      if nodes.empty? and ENV.has_key?('MONGODB_URI')
+        parser = URIParser.new ENV['MONGODB_URI'], opts
+        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
+      end
+
+      unless nodes.length > 0
         raise MongoArgumentError, "A ReplSetConnection requires at least one seed node."
       end
 
       # This is temporary until support for the old format is dropped
-      @seeds = []
-      if args.first.last.is_a?(Integer)
+      if nodes.first.last.is_a?(Integer)
         warn "Initiating a ReplSetConnection with seeds passed as individual [host, port] array arguments is deprecated."
         warn "Please specify hosts as an array of 'host:port' strings; the old format will be removed in v2.0"
-        @seeds = args
+        @seeds = nodes
       else
-        args.first.map do |host_port|
-          seed = host_port.split(":")
-          seed[1] = seed[1].to_i
-          seeds << seed
+        @seeds = nodes.first.map do |host_port|
+          host, port = host_port.split(":")
+          [ host, port.to_i ]
         end
       end
 
@@ -149,8 +162,9 @@ module Mongo
 
         discovered_seeds = @manager ? @manager.seeds : []
         @manager = PoolManager.new(self, discovered_seeds)
-        
-        Thread.current[:manager] = @manager
+
+        Thread.current[:managers] ||= Hash.new
+        Thread.current[:managers][self] = @manager
 
         @manager.connect
         @refresh_version += 1
@@ -203,7 +217,7 @@ module Mongo
       new_manager = PoolManager.new(self, discovered_seeds | @seeds)
       new_manager.connect
 
-      Thread.current[:manager] = new_manager
+      Thread.current[:managers][self] = new_manager
 
       # TODO: make sure that connect has succeeded
       @old_managers << @manager
@@ -263,6 +277,12 @@ module Mongo
       else
         @manager.close if @manager
       end
+
+      # Clear the reference to this object.
+      if Thread.current[:managers]
+        Thread.current[:managers].delete(self)
+      end
+
       @connected = false
     end
 
@@ -394,11 +414,17 @@ module Mongo
       end
     end
 
-    def get_socket_from_pool(pool_type)
-      if Thread.current[:manager] != @manager
-        Thread.current[:manager] = @manager
+    def ensure_manager
+      Thread.current[:managers] ||= Hash.new
+
+      if Thread.current[:managers][self] != @manager
+        Thread.current[:managers][self] = @manager
       end
-      
+    end
+
+    def get_socket_from_pool(pool_type)
+      ensure_manager
+
       pool = case pool_type
         when :primary
           primary_pool
@@ -417,9 +443,9 @@ module Mongo
         return nil
       end
     end
-    
+
     def local_manager
-      Thread.current[:manager]
+      Thread.current[:managers][self] if Thread.current[:managers]
     end
 
     def arbiters

data/lib/mongo/util/conversions.rb

@@ -24,6 +24,29 @@ module Mongo #:nodoc:
     ASCENDING_CONVERSION  = ["ascending", "asc", "1"]
     DESCENDING_CONVERSION = ["descending", "desc", "-1"]
 
+    # Allows sort parameters to be defined as a Hash.
+    # Does not allow usage of un-ordered hashes, therefore
+    # Ruby 1.8.x users must use BSON::OrderedHash.
+    #
+    # Example:
+    #
+    # <tt>hash_as_sort_parameters({:field1 => :asc, "field2" => :desc})</tt> =>
+    # <tt>{ "field1" => 1, "field2" => -1}</tt>
+    def hash_as_sort_parameters(value)
+      if RUBY_VERSION < '1.9' && !value.is_a?(BSON::OrderedHash)
+        raise InvalidSortValueError.new(
+          "Hashes used to supply sort order must maintain ordering." +
+          "Use BSON::OrderedHash."
+        )
+      else
+        order_by = value.inject({}) do |memo, (key, direction)|
+          memo[key.to_s] = sort_value(direction.to_s.downcase)
+          memo
+        end
+      end
+      order_by
+    end
+
     # Converts the supplied +Array+ to a +Hash+ to pass to mongo as
     # sorting parameters. The returned +Hash+ will vary depending 
     # on whether the passed +Array+ is one or two dimensional.

data/lib/mongo/util/logging.rb

@@ -1,14 +1,10 @@
 module Mongo
   module Logging
 
-    DEBUG_LEVEL = defined?(Logger) ? Logger::DEBUG : 0
-
     def write_logging_startup_message
-      if @logger && (@logger.level == DEBUG_LEVEL)
-        log(:debug, "Logging level is currently :debug which could negatively impact " +
+      log(:debug, "Logging level is currently :debug which could negatively impact " +
           "client-side performance. You should set your logging level no lower than " +
           ":info in production.")
-      end
     end
 
     # Log a message with the given level.
@@ -31,27 +27,26 @@ module Mongo
     end
 
     # Execute the block and log the operation described by name and payload.
-    def instrument(name, payload = {}, &blk)
+    def instrument(name, payload = {})
       start_time = Time.now
       res = yield
-      if @logger && (@logger.level == DEBUG_LEVEL)
-        log_operation(name, payload, start_time)
-      end
+      log_operation(name, payload, start_time)
       res
     end
 
     protected
 
     def log_operation(name, payload, start_time)
-      msg = "MONGODB "
-      msg << "(#{((Time.now - start_time) * 1000).to_i}ms) "
-      msg << "#{payload[:database]}['#{payload[:collection]}'].#{name}("
-      msg << payload.values_at(:selector, :document, :documents, :fields ).compact.map(&:inspect).join(', ') + ")"
-      msg << ".skip(#{payload[:skip]})"   if payload[:skip]
-      msg << ".limit(#{payload[:limit]})" if payload[:limit]
-      msg << ".sort(#{payload[:order]})"  if payload[:order]
-
-      @logger.debug(msg)
+      @logger && @logger.debug do
+        msg = "MONGODB "
+        msg << "(#{((Time.now - start_time) * 1000).to_i}ms) "
+        msg << "#{payload[:database]}['#{payload[:collection]}'].#{name}("
+        msg << payload.values_at(:selector, :document, :documents, :fields ).compact.map(&:inspect).join(', ') + ")"
+        msg << ".skip(#{payload[:skip]})"   if payload[:skip]
+        msg << ".limit(#{payload[:limit]})" if payload[:limit]
+        msg << ".sort(#{payload[:order]})"  if payload[:order]
+        msg
+      end
     end
 
   end

data/lib/mongo/util/node.rb

@@ -40,11 +40,7 @@ module Mongo
           @connection.op_timeout, @connection.connect_timeout
         )
 
-        if socket.nil?
-          return nil
-        else
-          socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
-        end
+        return nil if socket.nil?
       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

data/lib/mongo/util/pool.rb

@@ -157,7 +157,6 @@ module Mongo
     def checkout_new_socket
       begin
         socket = @connection.socket_class.new(@host, @port, @connection.op_timeout)
-        socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
         socket.pool = self
       rescue => ex
         socket.close if socket

data/lib/mongo/util/ssl_socket.rb

@@ -15,7 +15,9 @@ module Mongo
       @op_timeout = op_timeout
       @connect_timeout = connect_timeout
 
-      @socket = ::TCPSocket.new(host, port) 
+      @socket = ::TCPSocket.new(host, port)
+      @socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
+
       @ssl = OpenSSL::SSL::SSLSocket.new(@socket)
       @ssl.sync_close = true
       

data/lib/mongo/util/support.rb

@@ -69,6 +69,7 @@ module Mongo
 
     def format_order_clause(order)
       case order
+        when Hash, BSON::OrderedHash then hash_as_sort_parameters(order)
         when String, Symbol then string_as_sort_parameters(order)
         when Array then array_as_sort_parameters(order)
         else

data/lib/mongo/util/tcp_socket.rb

@@ -1,4 +1,5 @@
 require 'socket'
+require 'timeout'
 
 module Mongo
   # Wrapper class for Socket
@@ -16,41 +17,21 @@ module Mongo
       # 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)
+      @socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
 
       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
+      if @connect_timeout
+        Timeout::timeout(@connect_timeout, OperationTimeout) do
           @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
+        @socket.connect(@socket_address)
       end
     end
 
@@ -67,13 +48,15 @@ module Mongo
       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 
+          @socket.sysread(maxlen, buffer)
+        rescue SystemCallError => ex
+          # Needed because sometimes JRUBY doesn't throw Errno::ECONNRESET as it should
+          # http://jira.codehaus.org/browse/JRUBY-6180
+          raise ConnectionFailure, ex
+        rescue Errno::ENOTCONN, Errno::EBADF, Errno::ECONNRESET, Errno::EPIPE, Errno::ETIMEDOUT, EOFError => ex
+          raise ConnectionFailure, ex
+        rescue Errno::EINTR, Errno::EIO, IOError => ex
+          raise OperationFailure, ex
         end
       else
         raise OperationTimeout

data/lib/mongo/util/uri_parser.rb

@@ -16,11 +16,11 @@
 # limitations under the License.
 # ++
 
+require 'cgi'
+
 module Mongo
   class URIParser
 
-    DEFAULT_PORT = 27017
-
     USER_REGEX = /([-.\w:]+)/
     PASS_REGEX = /([^@,]+)/
     AUTH_REGEX = /(#{USER_REGEX}:#{PASS_REGEX}@)?/
@@ -37,7 +37,7 @@ module Mongo
     SPEC_ATTRS = [:nodes, :auths]
     OPT_ATTRS  = [:connect, :replicaset, :slaveok, :safe, :w, :wtimeout, :fsync, :journal, :connecttimeoutms, :sockettimeoutms, :wtimeoutms]
 
-    OPT_VALID  = {:connect          => lambda {|arg| ['direct', 'replicaset'].include?(arg)},
+    OPT_VALID  = {:connect          => lambda {|arg| ['direct', 'replicaset', 'true', 'false', true, false].include?(arg)},
                   :replicaset       => lambda {|arg| arg.length > 0},
                   :slaveok          => lambda {|arg| ['true', 'false'].include?(arg)},
                   :safe             => lambda {|arg| ['true', 'false'].include?(arg)},
@@ -50,7 +50,7 @@ module Mongo
                   :wtimeoutms       => lambda {|arg| arg =~ /^\d+$/ }
                  }
 
-    OPT_ERR    = {:connect          => "must be 'direct' or 'replicaset'",
+    OPT_ERR    = {:connect          => "must be 'direct', 'replicaset', 'true', or 'false'",
                   :replicaset       => "must be a string containing the name of the replica set to connect to",
                   :slaveok          => "must be 'true' or 'false'",
                   :safe             => "must be 'true' or 'false'",
@@ -63,7 +63,7 @@ module Mongo
                   :wtimeoutms       => "must be an integer specifying milliseconds"
                  }
 
-    OPT_CONV   = {:connect          => lambda {|arg| arg},
+    OPT_CONV   = {:connect          => lambda {|arg| arg == 'false' ? false : arg}, # be sure to convert 'false' to FalseClass
                   :replicaset       => lambda {|arg| arg},
                   :slaveok          => lambda {|arg| arg == 'true' ? true : false},
                   :safe             => lambda {|arg| arg == 'true' ? true : false},
@@ -81,22 +81,73 @@ module Mongo
     # Parse a MongoDB URI. This method is used by Connection.from_uri.
     # Returns an array of nodes and an array of db authorizations, if applicable.
     #
-    # Note: passwords can contain any character except for a ','.
+    # @note Passwords can contain any character except for ','
+    #
+    # @param [String] uri The MongoDB URI string.
+    # @param [Hash,nil] extra_opts Extra options. Will override anything already specified in the URI.
     #
     # @core connections
-    def initialize(string)
-      if string =~ /^mongodb:\/\//
-        string = string[10..-1]
+    def initialize(uri, extra_opts={})
+      if uri.start_with?('mongodb://')
+        uri = uri[10..-1]
       else
         raise MongoArgumentError, "MongoDB URI must match this spec: #{MONGODB_URI_SPEC}"
       end
 
-      hosts, opts = string.split('?')
+      hosts, opts = uri.split('?')
       parse_hosts(hosts)
-      parse_options(opts)
-      configure_connect
+      parse_options(opts, extra_opts)
+      validate_connect
+    end
+
+    # Create a Mongo::Connection or a Mongo::ReplSetConnection based on the URI.
+    #
+    # @note Don't confuse this with attribute getter method #connect.
+    #
+    # @return [Connection,ReplSetConnection]
+    def connection
+      if replicaset?
+        ReplSetConnection.new(*(nodes+[connection_options]))
+      else
+        Connection.new(host, port, connection_options)
+      end
+    end
+
+    # Whether this represents a replica set.
+    # @return [true,false]
+    def replicaset?
+      replicaset.is_a?(String) || nodes.length > 1
+    end
+
+    # Whether to immediately connect to the MongoDB node[s]. Defaults to true.
+    # @return [true, false]
+    def connect?
+      connect != false
+    end
+
+    # Whether this represents a direct connection.
+    #
+    # @note Specifying :connect => 'direct' has no effect... other than to raise an exception if other variables suggest a replicaset.
+    #
+    # @return [true,false]
+    def direct?
+      !replicaset?
+    end
+
+    # For direct connections, the host of the (only) node.
+    # @return [String]
+    def host
+      nodes[0][0]
     end
 
+    # For direct connections, the port of the (only) node.
+    # @return [Integer]
+    def port
+      nodes[0][1].to_i
+    end
+
+    # Options that can be passed to Mongo::Connection.new or Mongo::ReplSetConnection.new
+    # @return [Hash]
     def connection_options
       opts = {}
 
@@ -136,14 +187,22 @@ module Mongo
       end
 
       if @slaveok
-        if @connect == 'direct'
+        if direct?
           opts[:slave_ok] = true
         else
           opts[:read] = :secondary
         end
       end
 
-      opts[:name] = @replicaset if @replicaset
+      if direct?
+        opts[:auths] = auths
+      end
+
+      if replicaset.is_a?(String)
+        opts[:name] = replicaset
+      end
+
+      opts[:connect] = connect?
 
       opts
     end
@@ -167,7 +226,7 @@ module Mongo
 
       hosturis.each do |hosturi|
         # If port is present, use it, otherwise use default port
-        host, port = hosturi.split(':') + [DEFAULT_PORT]
+        host, port = hosturi.split(':') + [Connection::DEFAULT_PORT]
 
         if !(port.to_s =~ /^\d+$/)
           raise MongoArgumentError, "Invalid port #{port}; port must be specified as digits."
@@ -178,6 +237,10 @@ module Mongo
         @nodes << [host, port]
       end
 
+      if @nodes.empty?
+        raise MongoArgumentError, "No nodes specified. Please ensure that you've provided at least one node."
+      end
+
       if uname && pwd && db
         auths << {'db_name' => db, 'username' => uname, 'password' => pwd}
       elsif uname || pwd
@@ -191,40 +254,42 @@ module Mongo
 
     # This method uses the lambdas defined in OPT_VALID and OPT_CONV to validate
     # and convert the given options.
-    def parse_options(opts)
+    def parse_options(string_opts, extra_opts={})
       # initialize instance variables for available options
       OPT_VALID.keys.each { |k| instance_variable_set("@#{k}", nil) }
 
-      return unless opts
+      string_opts ||= ''
 
-      separator = opts.include?('&') ? '&' : ';'
-      opts.split(separator).each do |attr|
-        key, value = attr.split('=')
-        key = key.downcase.to_sym
-        value = value.strip.downcase
+      return if string_opts.empty? && extra_opts.empty?
+
+      if string_opts.include?(';') and string_opts.include?('&')
+        raise MongoArgumentError, "must not mix URL separators ; and &"
+      end
+
+      opts = CGI.parse(string_opts).inject({}) do |memo, (key, value)|
+        value = value.first
+        memo[key.downcase.to_sym] = value.strip.downcase
+        memo
+      end
+
+      opts.merge! extra_opts
+
+      opts.each do |key, value|
         if !OPT_ATTRS.include?(key)
           raise MongoArgumentError, "Invalid Mongo URI option #{key}"
         end
-
         if OPT_VALID[key].call(value)
           instance_variable_set("@#{key}", OPT_CONV[key].call(value))
         else
-          raise MongoArgumentError, "Invalid value for #{key}: #{OPT_ERR[key]}"
+          raise MongoArgumentError, "Invalid value #{value.inspect} for #{key}: #{OPT_ERR[key]}"
         end
       end
     end
 
-    def configure_connect
-      if !@connect
-        if @nodes.length > 1
-          @connect = 'replicaset'
-        else
-          @connect = 'direct'
-        end
-      end
-
-      if @connect == 'direct' && @replicaset
-        raise MongoArgumentError, "If specifying a replica set name, please also specify that connect=replicaset"
+    def validate_connect
+      if replicaset? and @connect == 'direct'
+        # Make sure the user doesn't specify something contradictory
+        raise MongoArgumentError, "connect=direct conflicts with setting a replicaset name"
       end
     end
   end