mongo 0.16 → 0.17

data/README.rdoc

@@ -356,6 +356,9 @@ Les Hill, leshill on github
 Sean Cribbs, seancribbs on github
 * Modify standard_benchmark to allow profiling
 
+Sunny Hirai
+* Suggested hashcode fix for Mongo::ObjectID
+
 = License
 
  Copyright 2008-2009 10gen Inc.

data/lib/mongo.rb

@@ -18,9 +18,16 @@ require 'mongo/cursor'
 require 'mongo/collection'
 require 'mongo/admin'
 
+begin
+  require 'mongo_ext/cbson'
+    BSON_SERIALIZER = CBson
+  rescue LoadError
+    BSON_SERIALIZER = BSON
+end
+
 module Mongo
   ASCENDING = 1
   DESCENDING = -1
 
-  VERSION = "0.16"
+  VERSION = "0.17"
 end

data/lib/mongo/collection.rb

@@ -202,13 +202,7 @@ module Mongo
     def insert(doc_or_docs, options={})
       doc_or_docs = [doc_or_docs] unless doc_or_docs.is_a?(Array)
       doc_or_docs.collect! { |doc| @pk_factory.create_pk(doc) }
-      result = insert_documents(doc_or_docs)
-      if options.delete(:safe)
-        error = @db.error
-        if error
-          raise OperationFailure, error
-        end
-      end
+      result = insert_documents(doc_or_docs, @name, true, options[:safe])
       result.size > 1 ? result : result.first
     end
     alias_method :<<, :insert
@@ -227,8 +221,9 @@ module Mongo
       message.put_int(0)
       BSON.serialize_cstr(message, "#{@db.name}.#{@name}")
       message.put_int(0)
-      message.put_array(BSON.new.serialize(selector, false).to_a)
-      @db.send_message_with_operation(Mongo::Constants::OP_DELETE, message)
+      message.put_array(BSON_SERIALIZER.serialize(selector, false).unpack("C*"))
+      @db.send_message_with_operation(Mongo::Constants::OP_DELETE, message,
+        "db.#{@db.name}.remove(#{selector.inspect})")
     end
 
     # Remove all records.
@@ -240,28 +235,37 @@ module Mongo
 
     # Update a single document in this collection.
     #
-    # :spec :: a hash specifying elements which must be present for
-    #   a document to be updated
+    # :selector :: a hash specifying elements which must be present for a document to be updated. Note: 
+    # the update command currently updates only the first document matching the
+    # given selector. If you want all matching documents to be updated, be sure
+    # to specify :multi => true.
     # :document :: a hash specifying the fields to be changed in the
-    #   selected document, or (in the case of an upsert) the document to
-    #   be inserted
+    # selected document, or (in the case of an upsert) the document to
+    # be inserted
     #
     # Options:
     # :upsert :: if true, perform an upsert operation
+    # :multi :: update all documents matching the selector, as opposed to
+    # just the first matching document. Note: only works in 1.1.3 or later.
     # :safe :: if true, check that the update succeeded. OperationFailure
-    #   will be raised on an error. Checking for safety requires an extra
-    #   round-trip to the database
-    def update(spec, document, options={})
+    # will be raised on an error. Checking for safety requires an extra
+    # round-trip to the database
+    def update(selector, document, options={})
       message = ByteBuffer.new
       message.put_int(0)
       BSON.serialize_cstr(message, "#{@db.name}.#{@name}")
-      message.put_int(options[:upsert] ? 1 : 0) # 1 if a repsert operation (upsert)
-      message.put_array(BSON.new.serialize(spec, false).to_a)
-      message.put_array(BSON.new.serialize(document, false).to_a)
-      @db.send_message_with_operation(Mongo::Constants::OP_UPDATE, message)
-
-      if options[:safe] && error=@db.error
-        raise OperationFailure, error
+      update_options  = 0
+      update_options += 1 if options[:upsert]
+      update_options += 2 if options[:multi]
+      message.put_int(update_options)
+      message.put_array(BSON_SERIALIZER.serialize(selector, false).unpack("C*"))
+      message.put_array(BSON_SERIALIZER.serialize(document, false).unpack("C*"))
+      if options[:safe]
+        @db.send_message_with_safe_check(Mongo::Constants::OP_UPDATE, message,
+          "db.#{@name}.update(#{selector.inspect}, #{document.inspect})")
+      else
+        @db.send_message_with_operation(Mongo::Constants::OP_UPDATE, message, 
+          "db.#{@name}.update(#{selector.inspect}, #{document.inspect})")
       end
     end
 
@@ -383,6 +387,28 @@ EOS
       return @db.eval(Code.new(group_function, scope))["result"]
     end
 
+    # Returns a list of distinct values for +key+ across all
+    # documents in the collection. The key may use dot notation
+    # to reach into an embedded object.
+    #   @collection.save({:zip => 10010, :name => {:age => 27}})
+    #   @collection.save({:zip => 94108, :name => {:age => 24}})
+    #   @collection.save({:zip => 10010, :name => {:age => 27}})
+    #   @collection.save({:zip => 99701, :name => {:age => 24}})
+    #   @collection.save({:zip => 94108, :name => {:age => 27}})
+    #
+    #   @collection.distinct(:zip)
+    #     [10010, 94108, 99701]
+    #   @collection.distinct("name.age")
+    #     [27, 24]
+    def distinct(key)
+      raise MongoArgumentError unless [String, Symbol].include?(key.class)
+      command = OrderedHash.new
+      command[:distinct] = @name
+      command[:key]        = key.to_s
+
+      @db.db_command(command)["values"]
+    end
+
     # Rename this collection.
     #
     # If operating in auth mode, client must be authorized as an admin to
@@ -456,12 +482,18 @@ EOS
     # Sends an Mongo::Constants::OP_INSERT message to the database.
     # Takes an array of +documents+, an optional +collection_name+, and a
     # +check_keys+ setting.
-    def insert_documents(documents, collection_name=@name, check_keys=true)
+    def insert_documents(documents, collection_name=@name, check_keys=true, safe=false)
       message = ByteBuffer.new
       message.put_int(0)
       BSON.serialize_cstr(message, "#{@db.name}.#{collection_name}")
-      documents.each { |doc| message.put_array(BSON.new.serialize(doc, check_keys).to_a) }
-      @db.send_message_with_operation(Mongo::Constants::OP_INSERT, message)
+      documents.each { |doc| message.put_array(BSON_SERIALIZER.serialize(doc, check_keys).unpack("C*")) }
+      if safe
+        @db.send_message_with_safe_check(Mongo::Constants::OP_INSERT, message,
+          "db.#{collection_name}.insert(#{documents.inspect})")
+      else
+        @db.send_message_with_operation(Mongo::Constants::OP_INSERT, message,
+          "db.#{collection_name}.insert(#{documents.inspect})")
+      end
       documents.collect { |o| o[:_id] || o['_id'] }
     end
 

data/lib/mongo/connection.rb

@@ -120,9 +120,20 @@ module Mongo
       single_db_command(name, :dropDatabase => 1)
     end
 
+    # Copies the database +from+ on the local server to +to+ on the specified +host+.
+    # +host+ defaults to 'localhost' if no value is provided.
+    def copy_database(from, to, host="localhost")
+      oh = OrderedHash.new
+      oh[:copydb]   = 1
+      oh[:fromhost] = host
+      oh[:fromdb]   = from
+      oh[:todb]     = to
+      single_db_command('admin', oh)
+    end
+
     # Return the build information for the current connection.
     def server_info
-      db("admin").db_command(:buildinfo => 1)
+      db("admin").command({:buildinfo => 1}, {:admin => true, :check_response => true})
     end
 
     # Returns the build version of the current server, using

data/lib/mongo/cursor.rb

@@ -20,11 +20,8 @@ module Mongo
   # A cursor over query results. Returned objects are hashes.
   class Cursor
     include Mongo::Conversions
-
     include Enumerable
 
-    RESPONSE_HEADER_SIZE = 20
-
     attr_reader :collection, :selector, :admin, :fields, 
       :order, :hint, :snapshot, :timeout,
       :full_collection_name
@@ -199,7 +196,7 @@ module Mongo
         message.put_int(0)
         message.put_int(1)
         message.put_long(@cursor_id)
-        @db.send_message_with_operation(Mongo::Constants::OP_KILL_CURSORS, message)
+        @db.send_message_with_operation(Mongo::Constants::OP_KILL_CURSORS, message, "cursor.close()")
       end
       @cursor_id = 0
       @closed    = true
@@ -250,14 +247,14 @@ module Mongo
     # the selector will be used in a $where clause.
     # See http://www.mongodb.org/display/DOCS/Server-side+Code+Execution
     def convert_selector_for_query(selector)
-       case selector
-         when Hash
-          selector
-         when nil
-           {}
-         when String
+      case selector
+        when Hash
+         selector
+        when nil
+          {}
+        when String
           {"$where" => Code.new(selector)}
-         when Code
+        when Code
           {"$where" => selector}
       end
     end
@@ -267,47 +264,6 @@ module Mongo
       @order || @explain || @hint || @snapshot
     end
 
-    def read_all
-      read_message_header
-      read_response_header
-      read_objects_off_wire
-    end
-
-    def read_objects_off_wire
-      while doc = next_object_on_wire
-        @cache << doc
-      end
-    end
-
-    def read_message_header
-      message = ByteBuffer.new
-      message.put_array(@db.receive_full(16).unpack("C*"))
-      unless message.size == 16 #HEADER_SIZE
-        raise "Short read for DB response header: expected #{16} bytes, saw #{message.size}" 
-      end
-      message.rewind
-      size = message.get_int
-      request_id = message.get_int
-      response_to = message.get_int
-      op = message.get_int
-    end
-
-    def read_response_header
-      header_buf = ByteBuffer.new
-      header_buf.put_array(@db.receive_full(RESPONSE_HEADER_SIZE).unpack("C*"))
-      raise "Short read for DB response header; expected #{RESPONSE_HEADER_SIZE} bytes, saw #{header_buf.length}" unless header_buf.length == RESPONSE_HEADER_SIZE
-      header_buf.rewind
-      @result_flags = header_buf.get_int
-      @cursor_id = header_buf.get_long
-      @starting_from = header_buf.get_int
-      @n_remaining = header_buf.get_int
-      if @n_received
-        @n_received += @n_remaining
-      else
-        @n_received = @n_remaining
-      end
-    end
-
     def num_remaining
       refill_via_get_more if @cache.length == 0
       @cache.length
@@ -320,64 +276,42 @@ module Mongo
       num_remaining > 0
     end
 
-    def next_object_on_wire
-      # if @n_remaining is 0 but we have a non-zero cursor, there are more
-      # to fetch, so do a GetMore operation, but don't do it here - do it
-      # when someone pulls an object out of the cache and it's empty
-      return nil if @n_remaining == 0
-      object_from_stream
-    end
-
     def refill_via_get_more
       return if send_query_if_needed || @cursor_id.zero?
-      @db._synchronize {
-        message = ByteBuffer.new
-        # Reserved.
-        message.put_int(0)
+      message = ByteBuffer.new
+      # Reserved.
+      message.put_int(0)
 
-        # DB name.
-        db_name = @admin ? 'admin' : @db.name
-        BSON.serialize_cstr(message, "#{db_name}.#{@collection.name}")
+      # DB name.
+      db_name = @admin ? 'admin' : @db.name
+      BSON.serialize_cstr(message, "#{db_name}.#{@collection.name}")
 
-        # Number of results to return; db decides for now.
-        message.put_int(0)
+      # Number of results to return; db decides for now.
+      message.put_int(0)
         
-        # Cursor id.
-        message.put_long(@cursor_id)
-        @db.send_message_with_operation_without_synchronize(Mongo::Constants::OP_GET_MORE, message)
-        read_all
-      }
+      # Cursor id.
+      message.put_long(@cursor_id)
+      results, @n_received, @cursor_id = @db.receive_message_with_operation(Mongo::Constants::OP_GET_MORE, message, "cursor.get_more()")
+      @cache += results
       close_cursor_if_query_complete
     end
 
-    def object_from_stream
-      buf = ByteBuffer.new
-      buf.put_array(@db.receive_full(4).unpack("C*"))
-      buf.rewind
-      size = buf.get_int
-      buf.put_array(@db.receive_full(size - 4).unpack("C*"), 4)
-      @n_remaining -= 1
-      buf.rewind
-      BSON.new.deserialize(buf)
-    end
-
+    # Run query first time we request an object from the wire
     def send_query_if_needed
-      # Run query first time we request an object from the wire
       if @query_run
         false
       else
-        message = construct_query_message(@query)
-        @db._synchronize {
-          @db.send_message_with_operation_without_synchronize(Mongo::Constants::OP_QUERY, message)
-          @query_run = true
-          read_all
-        }
+        message = construct_query_message
+        results, @n_received, @cursor_id = @db.receive_message_with_operation(Mongo::Constants::OP_QUERY, message, 
+            (query_log_message if @db.logger))  
+        @cache += results
+        @query_run = true
         close_cursor_if_query_complete
         true
       end
     end
 
-    def construct_query_message(query)
+    def construct_query_message
       message = ByteBuffer.new
       message.put_int(query_opts)
       db_name = @admin ? 'admin' : @db.name
@@ -388,11 +322,16 @@ module Mongo
       if query_contains_special_fields?
         selector = selector_with_special_query_fields
       end
-      message.put_array(BSON.new.serialize(selector).to_a)
-      message.put_array(BSON.new.serialize(@fields).to_a) if @fields
+      message.put_array(BSON_SERIALIZER.serialize(selector, false).unpack("C*"))
+      message.put_array(BSON_SERIALIZER.serialize(@fields, false).unpack("C*")) if @fields
       message
     end
 
+    def query_log_message
+      "#{@admin ? 'admin' : @db.name}.#{@collection.name}.find(#{@selector.inspect}, #{@fields ? @fields.inspect : '{}'})" +
+      "#{@skip != 0 ? ('.skip(' + @skip.to_s + ')') : ''}#{@limit != 0 ? ('.limit(' + @limit.to_s + ')') : ''}" 
+    end
+
     def selector_with_special_query_fields
       sel = OrderedHash.new
       sel['query']     = @selector

data/lib/mongo/db.rb

@@ -26,6 +26,8 @@ module Mongo
   # A Mongo database.
   class DB
 
+    STANDARD_HEADER_SIZE = 16
+    RESPONSE_HEADER_SIZE = 20
     SYSTEM_NAMESPACE_COLLECTION = "system.namespaces"
     SYSTEM_INDEX_COLLECTION = "system.indexes"
     SYSTEM_PROFILE_COLLECTION = "system.profile"
@@ -49,6 +51,8 @@ module Mongo
     # The name of the database.
     attr_reader :name
 
+    attr_reader :connection
+
     # Host to which we are currently connected.
     attr_reader :host
     # Port to which we are currently connected.
@@ -133,6 +137,8 @@ module Mongo
         raise InvalidName, "database name cannot be the empty string"
       end
 
+      @connection = options[:connection]
+
       @name, @nodes = db_name, nodes
       @strict = options[:strict]
       @pk_factory = options[:pk]
@@ -431,54 +437,49 @@ module Mongo
       self.collection(collection_name).create_index(field_or_spec, unique)
     end
 
-    def send_to_db(message)
-      connect_to_master if !connected? && @auto_reconnect
-      begin
-        @logger.debug("  MONGODB #{message}") if @logger
-        @socket.print(message.buf.to_s)
-        @socket.flush
-      rescue => ex
-        close
-        raise ex
+    # Sends a message to MongoDB.
+    #
+    # Takes a MongoDB opcode, +operation+, a message of class ByteBuffer,
+    # +message+, and an optional formatted +log_message+.
+    # Sends the message to the databse, adding the necessary headers.
+    def send_message_with_operation(operation, message, log_message=nil)
+      message_with_headers = add_message_headers(operation, message).to_s
+      @logger.debug("  MONGODB #{log_message || message}") if @logger
+      @semaphore.synchronize do
+        send_message_on_socket(message_with_headers)
       end
     end
 
-    # Sends a message to MongoDB.
-    #
-    # Takes a MongoDB opcode, +operation+, and a message of class ByteBuffer,
-    # +message+, and sends the message to the databse, adding the necessary headers.
-    def send_message_with_operation(operation, message)
+    def send_message_with_operation_raw(operation, message, log_message=nil)
+      message_with_headers = add_message_headers_raw(operation, message)
+      @logger.debug("  MONGODB #{log_message || message}") if @logger
       @semaphore.synchronize do
-        connect_to_master if !connected? && @auto_reconnect
-        begin
-          message_with_headers = add_message_headers(operation, message)
-          @logger.debug("  MONGODB #{message}") if @logger
-          @socket.print(message_with_headers.to_s)
-          @socket.flush
-        rescue => ex
-          close
-          raise ex
-        end
+        send_message_on_socket(message_with_headers)
       end
     end
 
-    def send_message_with_operation_without_synchronize(operation, message)
-      connect_to_master if !connected? && @auto_reconnect
-      begin
-        message_with_headers = add_message_headers(operation, message)
-        @logger.debug("  MONGODB #{operation} #{message}") if @logger
-        @socket.print(message_with_headers.to_s)
-        @socket.flush
-      rescue => ex
-        close
-        raise ex
+    # Sends a message to the database, waits for a response, and raises
+    # and exception if the operation has failed.
+    def send_message_with_safe_check(operation, message, log_message=nil)
+      message_with_headers = add_message_headers(operation, message)
+      message_with_check   = last_error_message
+      @logger.debug("  MONGODB #{log_message || message}") if @logger
+      @semaphore.synchronize do
+        send_message_on_socket(message_with_headers.append!(message_with_check).to_s)
+        docs, num_received, cursor_id = receive
+        if num_received == 1 && error = docs[0]['err']
+          raise Mongo::OperationFailure, error
+        end
       end
     end
 
-    def receive_message_with_operation(operation, message)
+    # Send a message to the database and waits for the response.
+    def receive_message_with_operation(operation, message, log_message=nil)
+      message_with_headers = add_message_headers(operation, message).to_s
+      @logger.debug("  MONGODB #{log_message || message}") if @logger
       @semaphore.synchronize do 
-
-
+        send_message_on_socket(message_with_headers)
+        receive
       end
     end
 
@@ -501,9 +502,34 @@ module Mongo
       cursor = Cursor.new(Collection.new(self, SYSTEM_COMMAND_COLLECTION), :admin => use_admin_db, :limit => -1, :selector => selector)
       cursor.next_object
     end
+    
+    # Sends a command to the database.
+    #
+    # :selector (required) :: An OrderedHash, or a standard Hash with just one
+    # key, specifying the command to be performed.
+    #
+    # :admin (optional) :: If true, the command will be executed on the admin
+    # collection.
+    #
+    # :check_response (optional) :: If true, will raise an exception if the
+    # command fails.
+    #
+    # Note: DB commands must start with the "command" key. For this reason,
+    # any selector containing more than one key must be an OrderedHash.
+    def command(selector, admin=false, check_response=false)
+      raise MongoArgumentError, "command must be given a selector" unless selector.is_a?(Hash) && !selector.empty?
+      if selector.class.eql?(Hash) && selector.keys.length > 1 
+        raise MongoArgumentError, "DB#command requires an OrderedHash when hash contains multiple keys"
+      end
 
-    def _synchronize &block
-      @semaphore.synchronize &block
+      result = Cursor.new(system_command_collection, :admin => admin, 
+        :limit => -1, :selector => selector).next_object
+
+      if check_response && !ok?(result)
+        raise OperationFailure, "Database command '#{selector.keys.first}' failed."
+      else
+        result
+      end
     end
 
     def full_collection_name(collection_name)
@@ -512,6 +538,80 @@ module Mongo
 
     private
 
+    def receive
+      receive_header
+      number_received, cursor_id = receive_response_header
+      read_documents(number_received, cursor_id)
+    end
+
+    def receive_header
+      header = ByteBuffer.new
+      header.put_array(receive_data_on_socket(16).unpack("C*"))
+      unless header.size == STANDARD_HEADER_SIZE
+        raise "Short read for DB response header: " +
+          "expected #{STANDARD_HEADER_SIZE} bytes, saw #{header.size}" 
+      end
+      header.rewind
+      size        = header.get_int
+      request_id  = header.get_int
+      response_to = header.get_int
+      op          = header.get_int
+    end
+
+    def receive_response_header
+      header_buf = ByteBuffer.new
+      header_buf.put_array(receive_data_on_socket(RESPONSE_HEADER_SIZE).unpack("C*"))
+      if header_buf.length != RESPONSE_HEADER_SIZE
+        raise "Short read for DB response header; " +
+          "expected #{RESPONSE_HEADER_SIZE} bytes, saw #{header_buf.length}"
+      end
+      header_buf.rewind
+      result_flags     = header_buf.get_int
+      cursor_id        = header_buf.get_long
+      starting_from    = header_buf.get_int
+      number_remaining = header_buf.get_int
+      [number_remaining, cursor_id]
+    end
+
+    def read_documents(number_received, cursor_id)
+      docs = []
+      number_remaining = number_received
+      while number_remaining > 0 do
+        buf = ByteBuffer.new
+        buf.put_array(receive_data_on_socket(4).unpack("C*"))
+        buf.rewind
+        size = buf.get_int
+        buf.put_array(receive_data_on_socket(size - 4).unpack("C*"), 4)
+        number_remaining -= 1
+        buf.rewind
+        docs << BSON.new.deserialize(buf)
+      end
+      [docs, number_received, cursor_id]
+    end
+
+    # Sending a message on socket.
+    def send_message_on_socket(packed_message)
+      connect_to_master if !connected? && @auto_reconnect
+      begin
+        @socket.print(packed_message)
+        @socket.flush
+      rescue => ex
+        close
+        raise ex
+      end
+    end
+
+    # Receive data of specified length on socket.
+    def receive_data_on_socket(length)
+      message = ""
+      while message.length < length do
+        chunk = @socket.recv(length - message.length)
+        raise "connection closed" unless chunk.length > 0
+        message += chunk
+      end
+      message
+    end
+
     # Prepares a message for transmission to MongoDB by
     # constructing a valid message header.
     def add_message_headers(operation, message)
@@ -538,8 +638,41 @@ module Mongo
       @@current_request_id
     end
 
+    # Creates a getlasterror message.
+    def last_error_message
+      generate_last_error_message
+    end
+
+    def generate_last_error_message
+      message = ByteBuffer.new
+      message.put_int(0)
+      BSON.serialize_cstr(message, "#{@name}.$cmd")
+      message.put_int(0)
+      message.put_int(-1)
+      message.put_array(BSON_SERIALIZER.serialize({:getlasterror => 1}, false).unpack("C*"))
+      add_message_headers(Mongo::Constants::OP_QUERY, message)
+    end
+
+    def reset_error_message
+      @@reset_error_message ||= generate_reset_error_message
+    end
+
+    def generate_reset_error_message
+      message = ByteBuffer.new
+      message.put_int(0)
+      BSON.serialize_cstr(message, "#{@name}.$cmd")
+      message.put_int(0)
+      message.put_int(-1)
+      message.put_array(BSON_SERIALIZER.serialize({:reseterror => 1}, false).unpack("C*"))
+      add_message_headers(Mongo::Constants::OP_QUERY, message)
+    end
+
     def hash_password(username, plaintext)
       Digest::MD5.hexdigest("#{username}:mongo:#{plaintext}")
     end
+
+    def system_command_collection
+      Collection.new(self, SYSTEM_COMMAND_COLLECTION)
+    end
   end
 end

data/lib/mongo/errors.rb

@@ -18,14 +18,20 @@ module Mongo
   # Generic Mongo Ruby Driver exception class.
   class MongoRubyError < StandardError; end
 
+  # Raised when MongoDB itself has returned an error.
+  class MongoDBError < RuntimeError; end
+
   # Raised when configuration options cause connections, queries, etc., to fail.
   class ConfigurationError < MongoRubyError; end
 
+  # Raised when invalid arguments are sent to Mongo Ruby methods.
+  class MongoArgumentError < MongoRubyError; end
+
   # Raised when a database operation fails.
-  class OperationFailure < RuntimeError; end
+  class OperationFailure < MongoDBError; end
 
   # Raised when a client attempts to perform an invalid operation.
-  class InvalidOperation < RuntimeError; end
+  class InvalidOperation < MongoDBError; end
 
   # Raised when an invalid name is used.
   class InvalidName < RuntimeError; end

data/lib/mongo/types/objectid.rb

@@ -57,6 +57,12 @@ module Mongo
     end
     alias_method :==, :eql?
 
+    # Returns a unique hashcode for the object.
+    # This is required since we've defined an #eql? method.
+    def hash
+      @data.hash
+    end
+
     def to_a
       @data.dup
     end
@@ -120,23 +126,27 @@ module Mongo
 
     private
 
-    def generate
-      oid = ''
+    begin
+      require 'mongo_ext/cbson'
+    rescue LoadError
+      def generate
+        oid = ''
 
-      # 4 bytes current time
-      time = Time.new.to_i
-      oid += [time].pack("N")
+        # 4 bytes current time
+        time = Time.new.to_i
+        oid += [time].pack("N")
 
-      # 3 bytes machine
-      oid += Digest::MD5.digest(Socket.gethostname)[0, 3]
+        # 3 bytes machine
+        oid += Digest::MD5.digest(Socket.gethostname)[0, 3]
 
-      # 2 bytes pid
-      oid += [Process.pid % 0xFFFF].pack("n")
+        # 2 bytes pid
+        oid += [Process.pid % 0xFFFF].pack("n")
 
-      # 3 bytes inc
-      oid += [get_inc].pack("N")[1, 3]
+        # 3 bytes inc
+        oid += [get_inc].pack("N")[1, 3]
 
-      oid.unpack("C12")
+        oid.unpack("C12")
+      end
     end
 
     def get_inc

data/lib/mongo/util/bson.rb

@@ -71,6 +71,12 @@ class BSON
     @buf.to_a
   end
 
+  # Serializes an object.
+  # Implemented to ensure an API compatible with BSON extension. 
+  def self.serialize(obj, check_keys)
+    new.serialize(obj, check_keys)
+  end
+
   begin
     require 'mongo_ext/cbson'
     def serialize(obj, check_keys=false)
@@ -99,6 +105,12 @@ class BSON
     end
   end
 
+  # Returns the array stored in the buffer.
+  # Implemented to ensure an API compatible with BSON extension. 
+  def unpack(arg)
+    @buf.to_a
+  end
+
   def serialize_key_value(k, v, check_keys)
     k = k.to_s
     if check_keys

data/lib/mongo/util/byte_buffer.rb

@@ -20,9 +20,11 @@ class ByteBuffer
   attr_reader :order
 
   def initialize(initial_data=[])
-    @buf = initial_data
-    @cursor = 0
-    self.order = :little_endian
+    @buf    = initial_data
+    @cursor = @buf.length
+    @order  = :little_endian
+    @int_pack_order    = 'V'
+    @double_pack_order = 'E'
   end
 
   # +endianness+ should be :little_endian or :big_endian. Default is :little_endian
@@ -159,7 +161,9 @@ class ByteBuffer
   end
 
   def to_s
-    if @buf.respond_to? "pack"
+    if @buf.respond_to? :fast_pack
+      @buf.fast_pack
+    elsif @buf.respond_to? "pack"
       @buf.pack("C*")
     else
       @buf

data/test/test_collection.rb

@@ -59,6 +59,21 @@ class TestCollection < Test::Unit::TestCase
     assert_equal 5, @@db.collection("test.foo").find_one()["x"]
   end
 
+  if @@version > "1.1"
+    def test_distinct
+      @@test.remove
+      @@test.insert([{:a => 0, :b => {:c => "a"}},
+                     {:a => 1, :b => {:c => "b"}},
+                     {:a => 1, :b => {:c => "c"}},
+                     {:a => 2, :b => {:c => "a"}},
+                     {:a => 3},
+                     {:a => 3}])
+
+      assert_equal [0, 1, 2, 3], @@test.distinct(:a).sort
+      assert_equal ["a", "b", "c"], @@test.distinct("b.c").sort
+    end
+  end
+
   def test_safe_insert
     a = {"hello" => "world"}
     @@test.insert(a)
@@ -82,6 +97,20 @@ class TestCollection < Test::Unit::TestCase
     assert_equal 1, @@test.find_one(:_id => id2)["x"]
   end
 
+  if @@version >= "1.1.3"
+    def test_multi_update
+      @@test.save("num" => 10)
+      @@test.save("num" => 10)
+      @@test.save("num" => 10)
+      assert_equal 3, @@test.count
+
+      @@test.update({"num" => 10}, {"$set" => {"num" => 100}}, :multi => true)
+      @@test.find.each do |doc|
+        assert_equal 100, doc["num"]
+      end
+    end
+  end
+
   def test_upsert
     @@test.update({"page" => "/"}, {"$inc" => {"count" => 1}}, :upsert => true)
     @@test.update({"page" => "/"}, {"$inc" => {"count" => 1}}, :upsert => true)

data/test/test_connection.rb

@@ -21,8 +21,7 @@ class TestConnection < Test::Unit::TestCase
 
   def test_server_info
     server_info = @mongo.server_info
-    assert server_info.keys.include? "version"
-    assert server_info.keys.include? "bits"
+    assert server_info.keys.include?("version")
     assert_equal 1.0, server_info["ok"]
   end
 
@@ -54,6 +53,14 @@ class TestConnection < Test::Unit::TestCase
     @mongo.drop_database('ruby-mongo-info-test')
   end
 
+  def test_copy_database
+    @mongo.db('old').collection('copy-test').insert('a' => 1)
+    @mongo.copy_database('old', 'new')
+    old_object = @mongo.db('old').collection('copy-test').find.next_object
+    new_object = @mongo.db('new').collection('copy-test').find.next_object
+    assert_equal old_object, new_object
+  end
+
   def test_database_names
     @mongo.drop_database('ruby-mongo-info-test')
     @mongo.db('ruby-mongo-info-test').collection('info-test').insert('a' => 1)
@@ -73,7 +80,7 @@ class TestConnection < Test::Unit::TestCase
     logger.level = Logger::DEBUG
     db = Connection.new(@host, @port, :logger => logger).db('ruby-mongo-test')
 
-    assert output.string.include?("2004")
+    assert output.string.include?("$cmd.find")
   end
   
   def test_connection_logger

data/test/test_db.rb

@@ -189,6 +189,13 @@ class DBTest < Test::Unit::TestCase
     assert_nil @@db.previous_error
   end
 
+  def test_check_command_response
+    command = {:forceerror => 1}
+    assert_raise OperationFailure do 
+      @@db.command(command, false, true)
+    end
+  end
+
   def test_last_status
     @@db['test'].remove
     @@db['test'].save("i" => 1)

data/test/test_objectid.rb

@@ -7,7 +7,18 @@ class ObjectIDTest < Test::Unit::TestCase
   include Mongo
 
   def setup
-    @o = ObjectID.new()
+    @o = ObjectID.new
+  end
+
+  def test_hashcode
+    assert_equal @o.instance_variable_get(:@data).hash, @o.hash
+  end
+
+  def test_array_uniq_for_equilavent_ids
+    a = ObjectID.new('123')
+    b = ObjectID.new('123')
+    assert_equal a, b
+    assert_equal 1, [a, b].uniq.size
   end
 
   def test_create_pk_method

data/test/test_threading.rb

@@ -1,18 +1,68 @@
-$LOAD_PATH[0,0] = File.join(File.dirname(__FILE__), '..', 'lib')
-require 'mongo'
-require 'test/unit'
+require 'test/test_helper'
 
 class TestThreading < Test::Unit::TestCase
 
   include Mongo
 
-  @@host = ENV['MONGO_RUBY_DRIVER_HOST'] || 'localhost'
-  @@port = ENV['MONGO_RUBY_DRIVER_PORT'] || Connection::DEFAULT_PORT
-  @@db = Connection.new(@@host, @@port).db('ruby-mongo-test')
+  @@db = Connection.new.db('ruby-mongo-test')
   @@coll = @@db.collection('thread-test-collection')
 
+  def set_up_safe_data
+    @@db.drop_collection('duplicate')
+    @@db.drop_collection('unique')
+    @duplicate = @@db.collection('duplicate')
+    @unique    = @@db.collection('unique') 
+
+    @duplicate.insert("test" => "insert")
+    @duplicate.insert("test" => "update")
+    @unique.insert("test" => "insert")
+    @unique.insert("test" => "update")
+    @unique.create_index("test", true)
+  end
+
+  def test_safe_update
+    set_up_safe_data
+    threads = []
+    100.times do |i|
+      threads[i] = Thread.new do
+        if i % 2 == 0
+          assert_raise Mongo::OperationFailure do
+            @unique.update({"test" => "insert"}, {"$set" => {"test" => "update"}}, :safe => true)
+          end
+        else
+          @duplicate.update({"test" => "insert"}, {"$set" => {"test" => "update"}}, :safe => true)
+        end
+      end
+    end
+  
+    100.times do |i|
+      threads[i].join
+    end
+  end
+
+  def test_safe_insert
+    set_up_safe_data
+    threads = []
+    100.times do |i|
+      threads[i] = Thread.new do
+        if i % 2 == 0
+          assert_raise Mongo::OperationFailure do
+            @unique.insert({"test" => "insert"}, :safe => true)
+          end
+        else
+          @duplicate.insert({"test" => "insert"}, :safe => true)
+        end
+      end
+    end
+  
+    100.times do |i|
+      threads[i].join
+    end
+  end
+
   def test_threading
-    @@coll.remove
+    @@coll.drop
+    @@coll = @@db.collection('thread-test-collection')
 
     1000.times do |i|
       @@coll.insert("x" => i)
@@ -21,13 +71,13 @@ class TestThreading < Test::Unit::TestCase
     threads = []
 
     10.times do |i|
-      threads[i] = Thread.new{
+      threads[i] = Thread.new do
         sum = 0
-        @@coll.find().each { |document|
+        @@coll.find().each do |document|
           sum += document["x"]
-        }
+        end
         assert_equal 499500, sum
-      }
+      end
     end
 
     10.times do |i|

data/test/unit/collection_test.rb

@@ -0,0 +1,54 @@
+require 'test/test_helper'
+
+class CollectionTest < Test::Unit::TestCase
+
+  class MockDB < DB
+    def connect_to_master
+      true
+    end
+  end
+
+  context "Basic operations: " do 
+    setup do 
+      @logger = mock()
+    end
+
+    should "send update message" do 
+      @db = MockDB.new("testing", ['localhost', 27017], :logger => @logger)
+      @coll = @db.collection('books')
+      @db.expects(:send_message_with_operation).with do |op, msg, log| 
+        op == 2001 && log.include?("db.books.update")
+      end
+      @coll.update({}, {:title => 'Moby Dick'})
+    end
+
+    should "send insert message" do 
+      @db = MockDB.new("testing", ['localhost', 27017], :logger => @logger)
+      @coll = @db.collection('books')
+      @db.expects(:send_message_with_operation).with do |op, msg, log| 
+        op == 2002 && log.include?("db.books.insert")
+      end
+      @coll.insert({:title => 'Moby Dick'})
+    end
+
+    should "send safe update message" do
+      @db = MockDB.new("testing", ['localhost', 27017], :logger => @logger)
+      @coll = @db.collection('books')
+      @db.expects(:send_message_with_safe_check).with do |op, msg, log|
+        op == 2001 && log.include?("db.books.update")
+      end
+      @coll.update({}, {:title => 'Moby Dick'}, :safe => true)
+    end
+
+    should "send safe insert message" do
+      @db = MockDB.new("testing", ['localhost', 27017], :logger => @logger)
+      @coll = @db.collection('books')
+      @db.expects(:send_message_with_safe_check).with do |op, msg, log|
+        op == 2001 && log.include?("db.books.update")
+      end
+      @coll.update({}, {:title => 'Moby Dick'}, :safe => true)
+    end
+  end
+end
+
+ 

data/test/unit/db_test.rb

@@ -0,0 +1,82 @@
+require 'test/test_helper'
+
+class DBTest < Test::Unit::TestCase
+
+  class MockDB < DB
+    attr_accessor :socket
+
+    def connect_to_master
+      true
+    end
+
+    public :add_message_headers
+  end
+
+  def insert_message(db, documents)
+    documents = [documents] unless documents.is_a?(Array)
+    message = ByteBuffer.new
+    message.put_int(0)
+    BSON.serialize_cstr(message, "#{db.name}.test")
+    documents.each { |doc| message.put_array(BSON.new.serialize(doc, true).to_a) }
+    message = db.add_message_headers(Mongo::Constants::OP_INSERT, message)
+  end
+
+  context "DB commands" do 
+    setup do 
+      @db = MockDB.new("testing", ['localhost', 27017])
+      @collection = mock()
+      @db.stubs(:system_command_collection).returns(@collection)
+    end
+
+    should "raise an error if given a hash with more than one key" do
+      assert_raise MongoArgumentError do 
+        @db.command(:buildinfo => 1, :somekey => 1)
+      end
+    end
+
+    should "raise an error if the selector is omitted" do 
+      assert_raise MongoArgumentError do 
+        @db.command({}, true)
+      end
+    end
+
+    should "create the proper cursor" do 
+      @cursor = mock(:next_object => {"ok" => 1})
+      Cursor.expects(:new).with(@collection, :admin => true,
+        :limit => -1, :selector => {:buildinfo => 1}).returns(@cursor)
+      command = {:buildinfo => 1}
+      @db.command(command, true)
+    end
+
+    should "raise an error when the command fails" do 
+      @cursor = mock(:next_object => {"ok" => 0})
+      Cursor.expects(:new).with(@collection, :admin => true,
+        :limit => -1, :selector => {:buildinfo => 1}).returns(@cursor)
+      assert_raise OperationFailure do 
+        command = {:buildinfo => 1}
+        @db.command(command, true, true)
+      end
+    end
+  end
+
+  context "safe messages" do
+    setup do
+      @db = MockDB.new("testing", ['localhost', 27017])
+      @collection = mock()
+      @db.stubs(:system_command_collection).returns(@collection)
+    end
+
+    should "receive getlasterror message" do
+      @socket = mock()
+      @socket.stubs(:close)
+      @socket.expects(:flush)
+      @socket.expects(:print).with { |message| message.include?('getlasterror') }
+      @db.socket = @socket
+      @db.stubs(:receive)
+      message = insert_message(@db, {:a => 1})
+      @db.send_message_with_safe_check(Mongo::Constants::OP_QUERY, message)
+    end
+  end
+end
+
+ 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: mongo
 version: !ruby/object:Gem::Version 
-  version: "0.16"
+  version: "0.17"
 platform: ruby
 authors: 
 - Jim Menard
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-26 00:00:00 -04:00
+date: 2009-11-16 00:00:00 -05:00
 default_executable: 
 dependencies: []
 
@@ -115,4 +115,6 @@ test_files:
 - test/test_round_trip.rb
 - test/test_slave_connection.rb
 - test/test_threading.rb
+- test/unit/collection_test.rb
 - test/unit/cursor_test.rb
+- test/unit/db_test.rb